node-av-lgpl 0.0.0 → 7.1.0-beta.2

package/dist/api/rtp-stream.js

@@ -0,0 +1,1131 @@
+import { isRtcp, RtpPacket } from 'werift';
+import { AV_CODEC_ID_HEVC, AV_HWDEVICE_TYPE_NONE, AV_SAMPLE_FMT_FLTP } from '../constants/constants.js';
+import { FF_ENCODER_LIBOPUS, FF_ENCODER_LIBX264, FF_ENCODER_LIBX265 } from '../constants/encoders.js';
+import { Codec } from '../lib/codec.js';
+import { Rational } from '../lib/rational.js';
+import { avChannelLayoutDefault } from '../lib/utilities.js';
+import { BitStreamFilterAPI } from './bitstream-filter.js';
+import { MAX_PACKET_SIZE } from './constants.js';
+import { Demuxer } from './demuxer.js';
+import { Encoder } from './encoder.js';
+import { FilterPreset } from './filter-presets.js';
+import { FilterAPI } from './filter.js';
+import { HardwareContext } from './hardware.js';
+import { Muxer } from './muxer.js';
+import { interruptibleFrameSource, pipeline } from './pipeline.js';
+import { openAudioDecoder } from './utilities/audio-transcode.js';
+import { pickSupportedLayout, pickSupportedRate, pickSupportedSampleFormat } from './utilities/codec-format.js';
+import { configureLiveDecoderThreading } from './utilities/live-decoding.js';
+import { transcodeScale } from './utilities/scale-size.js';
+import { applyVideoBitrate, createVideoTranscodeFilter, findSoftwareEncoder, findUsableHardwareEncoder, openTranscodeDecoder } from './utilities/video-transcode.js';
+/**
+ * Check whether a streaming-class input is a frame source (not a URL or Demuxer).
+ *
+ * @param input - The input passed to `create()`
+ *
+ * @returns True if `input` is a {@link MediaFrameSource}
+ *
+ * @internal
+ */
+export function isMediaFrameSource(input) {
+    return typeof input !== 'string' && !(input instanceof Demuxer);
+}
+/**
+ * Combine one or two pipeline controls behind a single {@link PipelineControl}.
+ *
+ * The frame-source path runs separate video/audio pipelines; this presents them
+ * as one control so `stop()`/`completion` work uniformly.
+ *
+ * @internal
+ */
+class CombinedPipelineControl {
+    controls;
+    constructor(controls) {
+        this.controls = controls;
+    }
+    stop() {
+        for (const control of this.controls) {
+            control.stop();
+        }
+    }
+    isStopped() {
+        return this.controls.every((control) => control.isStopped());
+    }
+    get completion() {
+        return Promise.all(this.controls.map((control) => control.completion)).then(() => undefined);
+    }
+    get progress() {
+        // Delegate to the first control (video when present) - a merged view is not
+        // meaningful across independently-clocked streams.
+        return this.controls[0]?.progress ?? { frames: 0, bytes: 0, time: 0, fps: 0, bitrate: 0, speed: 0, elapsed: 0 };
+    }
+}
+/**
+ * Generic RTP streaming with automatic codec detection and transcoding.
+ *
+ * Provides library-agnostic RTP streaming for various applications.
+ * Automatically detects input codecs and transcodes non-compatible formats.
+ * Supports hardware acceleration for video transcoding.
+ * Essential component for building RTP streaming servers.
+ *
+ * @example
+ * ```typescript
+ * import { RTPStream } from 'node-av/api';
+ *
+ * // Create stream with RTP packet callbacks
+ * const stream = RTPStream.create('rtsp://camera.local/stream', {
+ *   mtu: 1200,
+ *   hardware: 'auto',
+ *   onVideoPacket: (rtp) => {
+ *     // Send RTP packet
+ *     sendRtpPacket(rtp);
+ *   },
+ *   onAudioPacket: (rtp) => {
+ *     sendRtpPacket(rtp);
+ *   }
+ * });
+ *
+ * // Start streaming
+ * await stream.start();
+ * ```
+ *
+ * @see {@link Demuxer} For input media handling
+ * @see {@link HardwareContext} For GPU acceleration
+ */
+export class RTPStream {
+    options;
+    inputUrl;
+    inputOptions;
+    input;
+    source;
+    videoOutput;
+    audioOutput;
+    hardwareContext;
+    videoDecoder;
+    videoFilter;
+    videoEncoder;
+    videoBitstreamFilter;
+    audioDecoder;
+    audioFilter;
+    audioEncoder;
+    pipeline;
+    startPromise;
+    signal;
+    supportedVideoCodecs;
+    supportedAudioCodecs;
+    abortHandler;
+    stopRequested = false;
+    stopPromise;
+    startAbort;
+    stopSignal = Promise.withResolvers();
+    /**
+     * @param input - Media input URL or pre-opened Demuxer
+     *
+     * @param options - Stream configuration options
+     *
+     * Use {@link create} factory method
+     *
+     * @internal
+     */
+    constructor(input, options) {
+        if (typeof input === 'string') {
+            this.inputUrl = input;
+        }
+        else if (input instanceof Demuxer) {
+            this.inputUrl = null;
+            this.input = input;
+        }
+        else {
+            this.inputUrl = null;
+            this.source = input;
+        }
+        const inputUrl = this.inputUrl ?? '';
+        this.inputOptions = {
+            ...options.inputOptions,
+            options: {
+                flags: 'low_delay',
+                // fflags: 'nobuffer',
+                analyzeduration: 0,
+                probesize: 32,
+                timeout: 10000000,
+                rtsp_transport: inputUrl.toLowerCase().startsWith('rtsp') ? 'tcp' : undefined,
+                ...options.inputOptions?.options,
+            },
+        };
+        this.signal = options.signal;
+        // If no supported codecs specified, empty set means ALL codecs are supported (passthrough only)
+        this.supportedVideoCodecs = new Set(options.supportedVideoCodecs?.filter(Boolean));
+        this.supportedAudioCodecs = new Set(options.supportedAudioCodecs?.filter(Boolean));
+        this.options = {
+            onVideoPacket: options.onVideoPacket ?? (() => { }),
+            onAudioPacket: options.onAudioPacket ?? (() => { }),
+            onClose: options.onClose ?? (() => { }),
+            supportedVideoCodecs: Array.from(this.supportedVideoCodecs),
+            supportedAudioCodecs: Array.from(this.supportedAudioCodecs),
+            hardware: options.hardware ?? { deviceType: AV_HWDEVICE_TYPE_NONE },
+            inputOptions: options.inputOptions,
+            video: {
+                ssrc: options.video?.ssrc,
+                payloadType: options.video?.payloadType,
+                mtu: options.video?.mtu ?? MAX_PACKET_SIZE,
+                fps: options.video?.fps,
+                width: options.video?.width,
+                height: options.video?.height,
+                bitrate: options.video?.bitrate,
+                dumpExtra: options.video?.dumpExtra,
+                transcode: options.video?.transcode,
+                encoderOptions: options.video?.encoderOptions ?? {},
+            },
+            audio: {
+                ssrc: options.audio?.ssrc,
+                payloadType: options.audio?.payloadType,
+                mtu: options.audio?.mtu ?? MAX_PACKET_SIZE,
+                sampleRate: options.audio?.sampleRate,
+                channels: options.audio?.channels,
+                transcode: options.audio?.transcode,
+                encoderOptions: options.audio?.encoderOptions,
+                sampleFormat: options.audio?.sampleFormat,
+            },
+        };
+    }
+    /**
+     * Create an RTP stream from a media source.
+     *
+     * Configures the stream with input URL and options. The input is not opened
+     * until start() is called, allowing the stream to be reused after stop().
+     *
+     * @param input - Media source URL (RTSP, file path, HTTP, etc.) or a pre-opened {@link Demuxer}
+     *
+     * @param options - Stream configuration options
+     *
+     * @returns Configured RTP stream instance
+     *
+     * @example
+     * ```typescript
+     * // Stream from RTSP camera
+     * const stream = RTPStream.create('rtsp://camera.local/stream', {
+     *   mtu: 1200,
+     *   onVideoPacket: (rtp) => sendPacket(rtp),
+     *   onAudioPacket: (rtp) => sendPacket(rtp)
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Stream file with auto hardware acceleration
+     * const stream = RTPStream.create('video.mp4', {
+     *   hardware: 'auto'
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Stream from a pre-opened Demuxer (e.g. Device.openScreen())
+     * const demuxer = await Device.openScreen({ frameRate: 30 });
+     * const stream = RTPStream.create(demuxer, {
+     *   hardware: 'auto',
+     *   onVideoPacket: (rtp) => sendPacket(rtp)
+     * });
+     * ```
+     */
+    static create(input, options = {}) {
+        return new RTPStream(input, options);
+    }
+    /**
+     * Check if the stream is active.
+     *
+     * Stays true while a requested stop is still unwinding: the pipeline reports
+     * itself stopped as soon as stop() is called, but its packets keep flowing
+     * and its native resources stay open until completion settles.
+     *
+     * @returns True if the stream is active, false otherwise
+     */
+    get isStreamActive() {
+        return this.pipeline !== undefined;
+    }
+    /**
+     * Get the demuxer instance.
+     *
+     * Used for accessing the underlying demuxer.
+     * Only available after start() is called.
+     *
+     * @returns Demuxer instance or undefined if not started
+     *
+     * @example
+     * ```typescript
+     * const stream = RTPStream.create('input.mp4', {
+     *   onVideoPacket: (rtp) => sendRtp(rtp)
+     * });
+     * await stream.start();
+     * const input = stream.getInput();
+     * console.log('Bitrate:', input?.bitRate);
+     * ```
+     */
+    getInput() {
+        return this.input;
+    }
+    /**
+     * Request that the next encoded video frame is a keyframe.
+     *
+     * Used to answer receiver feedback (e.g. a WebRTC PLI) so a receiver that
+     * missed the stream start or lost packets can resync without waiting for the
+     * next scheduled GOP keyframe. Effective whenever the video is encoded, from
+     * frame sources and from a transcoded URL or {@link Demuxer} input; a stream
+     * passed through keeps the source's keyframes.
+     *
+     * @example
+     * ```typescript
+     * transceiver.sender.onPictureLossIndication.subscribe(() => {
+     *   stream.requestVideoKeyframe();
+     * });
+     * ```
+     */
+    requestVideoKeyframe() {
+        this.videoEncoder?.requestKeyframe();
+    }
+    /**
+     * 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.
+     * This method returns immediately after starting the pipeline.
+     *
+     * @returns Promise that resolves when pipeline is started
+     *
+     * @throws {Error} If no video stream found in input
+     *
+     * @throws {FFmpegError} If setup fails
+     *
+     * @example
+     * ```typescript
+     * const stream = RTPStream.create('rtsp://camera.local/stream', {
+     *   onVideoPacket: (rtp) => sendRtp(rtp)
+     * });
+     *
+     * // Start streaming (returns immediately)
+     * await stream.start();
+     *
+     * // Later: stop streaming
+     * await stream.stop();
+     * ```
+     */
+    async start() {
+        // Idempotent: concurrent and repeated calls share a single startup (e.g.
+        // an explicit start() racing WebRTCStream.setOffer()'s automatic one).
+        this.startPromise ??= this.doStart().catch((error) => {
+            this.startPromise = undefined;
+            throw error;
+        });
+        await this.startPromise;
+    }
+    /**
+     * Perform the actual startup (see {@link start}).
+     *
+     * @internal
+     */
+    async doStart() {
+        // A start racing an in-flight stop() waits for the teardown to finish,
+        // otherwise it would build the pipeline on top of freed resources.
+        if (this.stopPromise) {
+            await this.stopPromise;
+        }
+        if (this.pipeline) {
+            return;
+        }
+        this.signal?.throwIfAborted();
+        if (this.signal && !this.abortHandler) {
+            // Stop on abort. Keep a reference so stop() can detach the listener again,
+            // otherwise restarts would stack one listener per start(). Errors from the
+            // async stop() are swallowed here; they already surface via onClose(error).
+            this.abortHandler = () => {
+                this.abortHandler = undefined;
+                this.stop().catch(() => { });
+            };
+            this.signal.addEventListener('abort', this.abortHandler, { once: true });
+        }
+        // Re-armed per start so a restart is not torn down by the previous run.
+        this.stopSignal = Promise.withResolvers();
+        // Lets stop() interrupt a startup that is blocked in the input open
+        // (an RTSP connect can take seconds).
+        this.startAbort = new AbortController();
+        // Frame-source path: encode pre-composited frames directly (no demuxer/decoder).
+        if (this.source) {
+            await this.startFromFrames();
+            return;
+        }
+        if (!this.input) {
+            if (!this.inputUrl) {
+                throw new Error('No input URL or Demuxer provided');
+            }
+            const openSignal = this.signal ? AbortSignal.any([this.signal, this.startAbort.signal]) : this.startAbort.signal;
+            this.input = await Demuxer.open(this.inputUrl, { ...this.inputOptions, signal: openSignal });
+        }
+        this.throwIfStopRequested();
+        const videoStream = this.input.video();
+        const audioStream = this.input.audio();
+        let videoOutputIsHevc = videoStream?.codecpar.codecId === AV_CODEC_ID_HEVC;
+        // Setup video transcoding if needed
+        if (videoStream && (this.options.video.transcode || !this.isVideoCodecSupported(videoStream.codecpar.codecId))) {
+            // 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);
+            }
+            const currentFps = videoStream.avgFrameRate.num / videoStream.avgFrameRate.den;
+            const needsFps = this.options.video.fps !== undefined && isFinite(currentFps) && this.options.video.fps !== currentFps;
+            // Get first supported codec
+            const targetCodecId = this.options.supportedVideoCodecs[0];
+            if (!targetCodecId) {
+                throw new Error('No supported video codec specified for transcoding');
+            }
+            const { codecpar } = videoStream;
+            const scale = transcodeScale(codecpar.width, codecpar.height, this.options.video.width, this.options.video.height);
+            // a GPU encodes up to a size of its own, test it with the size it will get
+            const encoderCodec = await this.findVideoEncoder(targetCodecId, scale.output);
+            if (!encoderCodec) {
+                throw new Error(`No encoder found for codec ID ${targetCodecId}`);
+            }
+            this.throwIfStopRequested();
+            this.videoDecoder = await openTranscodeDecoder(videoStream, this.hardwareContext, {
+                exitOnError: false,
+                // Frame threading holds back one frame per thread before the first output
+                configure: configureLiveDecoderThreading,
+            });
+            // The graph follows the frames: whether they come from the device and in
+            // which format shows only once they are decoded
+            this.videoFilter = createVideoTranscodeFilter({
+                ...scale.target,
+                fps: needsFps ? this.options.video.fps : undefined,
+                encoder: encoderCodec,
+                hardware: this.hardwareContext,
+            });
+            const encoderOptions = liveVideoEncoderOptions(encoderCodec.name, this.options.video.encoderOptions);
+            const bitrate = this.options.video.bitrate;
+            this.videoEncoder = await Encoder.create(encoderCodec, {
+                decoder: this.videoDecoder,
+                filter: this.videoFilter,
+                maxBFrames: 0,
+                options: encoderOptions,
+                configure: (ctx) => {
+                    // encoder defaults are 120 (VAAPI) or 250 frames (libx264, NVENC), a receiver that lost a packet waits that long;
+                    // after the short probe the input rate is often unknown, the context has it from the frames
+                    const fps = ctx.framerate.num > 0 ? ctx.framerate.num / ctx.framerate.den : 30;
+                    ctx.gopSize = Math.max(1, Math.round(fps * 2));
+                    applyVideoBitrate(ctx, bitrate);
+                },
+            });
+            this.throwIfStopRequested();
+            videoOutputIsHevc = encoderCodec.id === AV_CODEC_ID_HEVC;
+        }
+        if (videoStream && videoOutputIsHevc && this.options.video?.dumpExtra) {
+            this.videoBitstreamFilter = BitStreamFilterAPI.create('dump_extra', this.videoEncoder ?? videoStream, { options: { freq: 'k' } });
+        }
+        // Setup video output
+        this.videoOutput = await this.createVideoOutput();
+        this.throwIfStopRequested();
+        // Setup audio if available and needs transcoding
+        if (audioStream && (this.options.audio.transcode || !this.isAudioCodecSupported(audioStream.codecpar.codecId))) {
+            this.audioDecoder = await openAudioDecoder(audioStream, {
+                exitOnError: false,
+            });
+            // Get first supported audio codec
+            const targetCodecId = this.options.supportedAudioCodecs[0];
+            if (!targetCodecId) {
+                throw new Error('No supported audio codec specified for transcoding');
+            }
+            let encoderCodec = null;
+            if (typeof targetCodecId === 'string') {
+                encoderCodec = Codec.findEncoderByName(targetCodecId);
+            }
+            else {
+                encoderCodec = Codec.findEncoder(targetCodecId);
+            }
+            if (!encoderCodec) {
+                throw new Error(`No encoder found for codec ID ${targetCodecId}`);
+            }
+            // Determine target audio parameters from options
+            const desiredSampleFormat = this.options.audio?.sampleFormat ?? audioStream.codecpar.format;
+            const desiredSampleRate = this.options.audio?.sampleRate ?? (audioStream.codecpar.sampleRate > 0 ? audioStream.codecpar.sampleRate : 48000);
+            const desiredChannels = this.options.audio?.channels ?? (audioStream.codecpar.channels > 0 ? audioStream.codecpar.channels : 2);
+            // Select best supported parameters from codec
+            const targetSampleFormat = this.selectSampleFormat(encoderCodec, desiredSampleFormat);
+            const targetSampleRate = this.selectSampleRate(encoderCodec, desiredSampleRate);
+            const channelLayoutStr = this.selectChannelLayout(encoderCodec, desiredChannels);
+            // Create audio filter for resampling
+            const filterChain = FilterPreset.chain().aformat(targetSampleFormat, targetSampleRate, channelLayoutStr).build();
+            // FilterAPI now auto-calculates timeBase from first frame (FFmpeg behavior)
+            this.audioFilter = FilterAPI.create(filterChain);
+            let encoderOptions = {};
+            if (encoderCodec.name === FF_ENCODER_LIBOPUS) {
+                encoderOptions.application = 'lowdelay';
+                encoderOptions.frame_duration = 20;
+            }
+            encoderOptions = {
+                ...encoderOptions,
+                ...this.options.audio.encoderOptions,
+            };
+            this.audioEncoder = await Encoder.create(encoderCodec, {
+                decoder: this.audioDecoder,
+                filter: this.audioFilter,
+                options: encoderOptions,
+                // Silence for an input gap would only go out once the input resumes, as a burst of
+                // late packets; receivers conceal a timestamp gap like packet loss instead
+                audioFrameBuffer: { maxGapFill: 0 },
+            });
+            this.throwIfStopRequested();
+        }
+        // Setup audio output if available
+        if (audioStream) {
+            this.audioOutput = await this.createAudioOutput();
+            this.throwIfStopRequested();
+        }
+        // Start pipeline in background (don't await)
+        this.attachCompletion(this.runPipeline());
+    }
+    /**
+     * Abort an in-flight startup once stop() was requested.
+     *
+     * Checked after every await in the startup path: the resources created so
+     * far are all assigned to instance fields, so the stop() that is waiting on
+     * this startup tears them down the moment it unwinds.
+     *
+     * @throws {Error} If stop() was called while starting
+     *
+     * @internal
+     */
+    throwIfStopRequested() {
+        if (this.stopRequested) {
+            throw new Error('RTPStream stopped during start');
+        }
+    }
+    /**
+     * Wire the pipeline completion to the onClose/error callbacks.
+     *
+     * On success invokes `onClose()`; on error stops the stream and invokes
+     * `onClose(error)`. Either way `onClose` runs exactly once and the detached
+     * chain never rejects. Runs in the background (not awaited).
+     *
+     * @param completion - The pipeline completion promise
+     *
+     * @internal
+     */
+    attachCompletion(completion) {
+        // Captured so a restart that installed a newer pipeline keeps it.
+        const control = this.pipeline;
+        // One then() with both handlers: a throwing onClose() in the success path
+        // must not fall through into the error path and fire onClose a second time.
+        completion
+            .then(() => {
+            // Pipeline completed successfully
+            this.emitClose();
+        }, async (reason) => {
+            const error = reason instanceof Error ? reason : new Error(String(reason));
+            // A stop() in flight or an aborted signal means the owner is tearing
+            // the stream down - the pipeline unwinding with an AbortError (or an
+            // interrupted FFmpeg call) is the expected shutdown path, not a failure.
+            // Decided before the stop() below, which would make every failure look deliberate.
+            const deliberate = this.isDeliberateStop(reason);
+            if (!deliberate) {
+                console.error('[RTPStream] Pipeline error:', error);
+            }
+            // A teardown failure must not swallow the onClose call: without it
+            // the owner never learns the stream is gone.
+            try {
+                await this.stop();
+            }
+            catch {
+                // doStop() already released whatever it could.
+            }
+            this.emitClose(deliberate ? undefined : error);
+        })
+            .finally(() => {
+            // Drop the finished pipeline so isStreamActive reports inactive. The
+            // demuxer path already clears it in runPipeline(); a frame source has
+            // no such step, so without this it would look active forever.
+            if (this.pipeline === control) {
+                this.pipeline = undefined;
+            }
+        });
+    }
+    /**
+     * Invoke the owner's onClose callback.
+     *
+     * The completion chain runs detached, so an exception from the callback
+     * could only surface as an unhandled rejection - it is logged instead.
+     *
+     * @param error - Pipeline error, or undefined for a clean end
+     *
+     * @internal
+     */
+    emitClose(error) {
+        try {
+            this.options.onClose(error);
+        }
+        catch (callbackError) {
+            // The stream is already closed; logged so a broken restart path in the
+            // owner does not vanish silently.
+            console.error('[RTPStream] onClose callback threw:', callbackError);
+        }
+    }
+    /**
+     * Whether a pipeline rejection was caused by an intentional shutdown.
+     *
+     * @param error - The pipeline rejection reason
+     *
+     * @returns True when stop() is in flight or the owner's signal aborted
+     *
+     * @internal
+     */
+    isDeliberateStop(error) {
+        return this.stopRequested || this.stopPromise !== undefined || this.signal?.aborted === true || (error instanceof Error && error.name === 'AbortError');
+    }
+    /**
+     * Set up encoders and RTP outputs for a pre-composited frame source and start
+     * encoding. No demuxer or decoder is involved - the provided frames are encoded
+     * straight to RTP. Video and audio (whichever are present) run as separate
+     * pipelines combined behind a single control.
+     *
+     * @throws {Error} If the source has neither video nor audio frames
+     *
+     * @internal
+     */
+    async startFromFrames() {
+        const source = this.source;
+        if (!source.video && !source.audio) {
+            throw new Error('Frame source must provide video and/or audio frames');
+        }
+        const controls = [];
+        const opts = this.signal ? { signal: this.signal } : undefined;
+        // Video
+        if (source.video) {
+            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);
+            }
+            const targetCodecId = this.options.supportedVideoCodecs[0] ?? FF_ENCODER_LIBX264;
+            const encoderCodec = await this.findVideoEncoder(targetCodecId);
+            if (!encoderCodec) {
+                throw new Error(`No encoder found for video codec ${String(targetCodecId)}`);
+            }
+            this.throwIfStopRequested();
+            const encoderOptions = liveVideoEncoderOptions(encoderCodec.name, this.options.video.encoderOptions);
+            let fps = this.options.video.fps ?? 20;
+            if (!isFinite(fps) || fps <= 0 || isNaN(fps)) {
+                fps = 20;
+            }
+            // No decoder/filter: the encoder adopts width/height/pixelFormat/timeBase
+            // from the first composited frame. Set the framerate explicitly, otherwise
+            // the encoder infers it from the frame timebase (often a fine-grained tick
+            // like 1/12800), which makes x264 pick an absurd level (huge MB rate) that
+            // browsers can't decode over WebRTC. Bound the GOP to ~2s: live receivers
+            // that join (or lose) mid-stream must get a keyframe quickly - the x264
+            // default of 250 frames leaves them waiting for many seconds.
+            const bitrate = this.options.video.bitrate;
+            this.videoEncoder = await Encoder.create(encoderCodec, {
+                maxBFrames: 0,
+                options: encoderOptions,
+                configure: (ctx) => {
+                    ctx.framerate = new Rational(Math.round(fps), 1);
+                    ctx.gopSize = Math.max(1, Math.round(fps * 2));
+                    applyVideoBitrate(ctx, bitrate);
+                },
+            });
+            // Source frames may sit on another device or in a format the encoder rejects
+            this.videoFilter = createVideoTranscodeFilter({ width: -1, height: -1, encoder: encoderCodec, hardware: this.hardwareContext });
+            this.videoOutput = await this.createVideoOutput();
+            this.throwIfStopRequested();
+            // a frame source has no demuxer for stop() to interrupt, a silent one would block teardown
+            const video = interruptibleFrameSource(source.video, this.stopSignal.promise);
+            controls.push(pipeline(video, this.videoFilter, this.videoEncoder, this.videoOutput, opts));
+        }
+        // Audio
+        if (source.audio) {
+            const targetCodecId = this.options.supportedAudioCodecs[0] ?? FF_ENCODER_LIBOPUS;
+            let encoderCodec = null;
+            if (typeof targetCodecId === 'string') {
+                encoderCodec = Codec.findEncoderByName(targetCodecId);
+            }
+            else {
+                encoderCodec = Codec.findEncoder(targetCodecId);
+            }
+            if (!encoderCodec) {
+                throw new Error(`No encoder found for audio codec ${String(targetCodecId)}`);
+            }
+            // There is no input stream to derive formats from - resample to the desired
+            // (or codec-preferred) sample format/rate/layout via an aformat filter.
+            const desiredSampleFormat = this.options.audio?.sampleFormat ?? AV_SAMPLE_FMT_FLTP;
+            const desiredSampleRate = this.options.audio?.sampleRate ?? 48000;
+            const desiredChannels = this.options.audio?.channels ?? 2;
+            const targetSampleFormat = this.selectSampleFormat(encoderCodec, desiredSampleFormat);
+            const targetSampleRate = this.selectSampleRate(encoderCodec, desiredSampleRate);
+            const channelLayoutStr = this.selectChannelLayout(encoderCodec, desiredChannels);
+            this.audioFilter = FilterAPI.create(FilterPreset.chain().aformat(targetSampleFormat, targetSampleRate, channelLayoutStr).build());
+            let encoderOptions = {};
+            if (encoderCodec.name === FF_ENCODER_LIBOPUS) {
+                encoderOptions.application = 'lowdelay';
+                encoderOptions.frame_duration = 20;
+            }
+            encoderOptions = { ...encoderOptions, ...this.options.audio.encoderOptions };
+            this.audioEncoder = await Encoder.create(encoderCodec, {
+                filter: this.audioFilter,
+                options: encoderOptions,
+                audioFrameBuffer: { maxGapFill: 0 },
+            });
+            this.audioOutput = await this.createAudioOutput();
+            this.throwIfStopRequested();
+            const audio = interruptibleFrameSource(source.audio, this.stopSignal.promise);
+            controls.push(pipeline(audio, this.audioFilter, this.audioEncoder, this.audioOutput, opts));
+        }
+        this.pipeline = new CombinedPipelineControl(controls);
+        this.attachCompletion(this.pipeline.completion);
+    }
+    /**
+     * Create the RTP video output muxer.
+     *
+     * Rewrites RTP sequence numbers (continuous) and rebases the PTS-derived
+     * timestamps (90 kHz) onto a random initial value in the write callback, then
+     * forwards each packet to `onVideoPacket`. Uses `this.input` when present
+     * (demuxer path) and no input for the frame-source path.
+     *
+     * @returns The configured video muxer
+     *
+     * @internal
+     */
+    async createVideoOutput() {
+        let videoSequenceNumber = Math.floor(Math.random() * 0xffff);
+        const videoTimestampBase = Math.floor(Math.random() * 0xffffffff) >>> 0; // unsigned 32-bit
+        let videoTimestampOffset;
+        const videoMuxerOptions = {};
+        if (this.options.video.ssrc !== undefined) {
+            videoMuxerOptions.ssrc = this.options.video.ssrc;
+        }
+        if (this.options.video.payloadType !== undefined) {
+            videoMuxerOptions.payload_type = this.options.video.payloadType;
+        }
+        return await Muxer.open({
+            write: (buffer) => {
+                if (isRtcp(buffer)) {
+                    // Ignore RTCP packets
+                    return buffer.length;
+                }
+                const rtpPacket = RtpPacket.deSerialize(buffer);
+                // Fix sequence number - ensure continuous sequence
+                rtpPacket.header.sequenceNumber = videoSequenceNumber;
+                videoSequenceNumber = (videoSequenceNumber + 1) & 0xffff; // Wrap at 16-bit
+                // Rebase the timestamp onto our own random initial value. FFmpeg's RTP
+                // muxer derives it from the packet PTS in the 90 kHz clock (plus its own
+                // random base), so the deltas carry the real presentation times -
+                // including B-frame reordering and VFR cadence. Only the base is swapped;
+                // modular uint32 arithmetic keeps wrap-around intact, and packets of the
+                // same frame keep sharing a timestamp.
+                videoTimestampOffset ??= (videoTimestampBase - rtpPacket.header.timestamp) >>> 0;
+                rtpPacket.header.timestamp = (rtpPacket.header.timestamp + videoTimestampOffset) >>> 0;
+                this.options.onVideoPacket(rtpPacket);
+                return buffer.length;
+            },
+        }, {
+            input: this.input,
+            copyInitialNonkeyframes: true,
+            format: 'rtp',
+            maxPacketSize: this.options.video.mtu,
+            options: videoMuxerOptions,
+        });
+    }
+    /**
+     * Create the RTP audio output muxer.
+     *
+     * Rewrites RTP sequence numbers (continuous) in the write callback and forwards
+     * each packet to `onAudioPacket`. Uses `this.input` when present (demuxer path)
+     * and no input for the frame-source path.
+     *
+     * @returns The configured audio muxer
+     *
+     * @internal
+     */
+    async createAudioOutput() {
+        let audioSequenceNumber = Math.floor(Math.random() * 0xffff);
+        const audioMuxerOptions = {};
+        if (this.options.audio.ssrc !== undefined) {
+            audioMuxerOptions.ssrc = this.options.audio.ssrc;
+        }
+        if (this.options.audio.payloadType !== undefined) {
+            audioMuxerOptions.payload_type = this.options.audio.payloadType;
+        }
+        return await Muxer.open({
+            write: (buffer) => {
+                if (isRtcp(buffer)) {
+                    // Ignore RTCP packets
+                    return buffer.length;
+                }
+                const rtpPacket = RtpPacket.deSerialize(buffer);
+                // Fix sequence number - ensure continuous sequence
+                rtpPacket.header.sequenceNumber = audioSequenceNumber;
+                audioSequenceNumber = (audioSequenceNumber + 1) & 0xffff; // Wrap at 16-bit
+                this.options.onAudioPacket(rtpPacket);
+                return buffer.length;
+            },
+        }, {
+            input: this.input,
+            copyInitialNonkeyframes: true,
+            format: 'rtp',
+            maxPacketSize: this.options.audio.mtu,
+            options: audioMuxerOptions,
+        });
+    }
+    /**
+     * Run the streaming pipeline until completion or stopped.
+     *
+     * @internal
+     */
+    async runPipeline() {
+        if (!this.input) {
+            return;
+        }
+        const hasVideo = this.input.video() !== undefined && this.videoOutput !== undefined;
+        const hasAudio = this.input.audio() !== undefined && this.audioOutput !== undefined;
+        const opts = this.signal ? { signal: this.signal } : undefined;
+        if (hasAudio && hasVideo) {
+            this.pipeline = pipeline(this.input, {
+                video: [this.videoDecoder, this.videoFilter, this.videoEncoder, this.videoBitstreamFilter],
+                audio: [this.audioDecoder, this.audioFilter, this.audioEncoder],
+            }, {
+                video: this.videoOutput,
+                audio: this.audioOutput,
+            }, opts);
+        }
+        else if (hasVideo) {
+            this.pipeline = pipeline(this.input, {
+                video: [this.videoDecoder, this.videoFilter, this.videoEncoder, this.videoBitstreamFilter],
+            }, this.videoOutput, opts);
+        }
+        else if (hasAudio) {
+            this.pipeline = pipeline(this.input, {
+                audio: [this.audioDecoder, this.audioFilter, this.audioEncoder],
+            }, this.audioOutput, opts);
+        }
+        else {
+            throw new Error('No audio or video streams found in input');
+        }
+        await this.pipeline.completion;
+        this.pipeline = undefined;
+    }
+    /**
+     * Stop streaming gracefully and clean up all resources.
+     *
+     * Stops the pipeline, closes output, and releases all FFmpeg resources.
+     * Safe to call multiple times. After stopping, you can call start() again
+     * to restart the stream. Resolves even if the pipeline had failed; that
+     * error is reported through `onClose(error)`.
+     *
+     * @example
+     * ```typescript
+     * const stream = RTPStream.create('input.mp4', {
+     *   onVideoPacket: (rtp) => sendRtp(rtp)
+     * });
+     * await stream.start();
+     *
+     * // Stop after 10 seconds
+     * setTimeout(async () => await stream.stop(), 10000);
+     * ```
+     */
+    async stop() {
+        // Memoized: concurrent stop() calls share one teardown instead of
+        // double-closing native resources.
+        this.stopPromise ??= this.doStop().finally(() => {
+            this.stopPromise = undefined;
+        });
+        await this.stopPromise;
+    }
+    /**
+     * Perform the actual teardown (see {@link stop}).
+     *
+     * @internal
+     */
+    async doStop() {
+        // An in-flight start() must unwind before teardown - otherwise it would
+        // keep building the pipeline on top of freed resources and leave an
+        // orphaned transcode running forever. The flag makes doStart() bail at its
+        // next checkpoint, the abort unblocks a startup stuck in the input open.
+        this.stopRequested = true;
+        this.startAbort?.abort();
+        this.startAbort = undefined;
+        // Unblocks a frame source that went silent, so the completion barrier below
+        // cannot wait on a pull that will never settle.
+        this.stopSignal.resolve();
+        const inflightStart = this.startPromise;
+        // Allow a fresh start() after stopping.
+        this.startPromise = undefined;
+        if (inflightStart) {
+            try {
+                await inflightStart;
+            }
+            catch {
+                // Aborted or failed startup - resources are torn down below either way.
+            }
+        }
+        try {
+            // Detach the abort listener so it cannot fire for a torn-down session and
+            // does not accumulate across start()/stop() cycles.
+            if (this.abortHandler) {
+                this.signal?.removeEventListener('abort', this.abortHandler);
+                this.abortHandler = undefined;
+            }
+            // Stop pipeline if running and wait for completion. pipeline.stop() interrupts
+            // the source demuxer's read (frame-source pipelines unwind via iterator.return
+            // instead). Swallow a rejected completion here - the error is already surfaced
+            // to the caller via the onClose(error) path; we just need cleanup to proceed.
+            const pipeline = this.pipeline;
+            if (pipeline) {
+                if (!pipeline.isStopped()) {
+                    pipeline.stop();
+                }
+                try {
+                    await pipeline.completion;
+                }
+                catch {
+                    // Pipeline errored - proceed with teardown regardless.
+                }
+                if (this.pipeline === pipeline) {
+                    this.pipeline = undefined;
+                }
+            }
+            // Close all resources. close() rethrows a failed background write after it
+            // freed the muxer. That error already ended the pipeline and reaches the
+            // owner through onClose(error), so it must not abort the teardown here and
+            // leak the other output, the codecs and the input (an RTSP connection).
+            try {
+                await this.videoOutput?.close();
+            }
+            catch {
+                // Surfaced through the pipeline completion.
+            }
+            this.videoOutput = undefined;
+            try {
+                await this.audioOutput?.close();
+            }
+            catch {
+                // Surfaced through the pipeline completion.
+            }
+            this.audioOutput = undefined;
+            // A codec that refuses to close (still busy) must not leave the input,
+            // an RTSP connection, open.
+            try {
+                this.videoEncoder?.close();
+                this.videoEncoder = undefined;
+                this.videoFilter?.close();
+                this.videoFilter = undefined;
+                this.videoDecoder?.close();
+                this.videoDecoder = undefined;
+                this.audioEncoder?.close();
+                this.audioEncoder = undefined;
+                this.audioFilter?.close();
+                this.audioFilter = undefined;
+                this.audioDecoder?.close();
+                this.audioDecoder = undefined;
+                this.hardwareContext?.dispose();
+                this.hardwareContext = undefined;
+            }
+            finally {
+                await this.input?.close();
+                this.input = undefined;
+            }
+        }
+        finally {
+            this.stopRequested = false;
+        }
+    }
+    /**
+     * Check if the given audio codec is supported.
+     *
+     * @param codecId - The AVCodecID to check
+     *
+     * @returns True if the codec is supported, false otherwise
+     *
+     * @internal
+     */
+    isAudioCodecSupported(codecId) {
+        // Empty set means all codecs are supported (passthrough only)
+        if (this.supportedAudioCodecs.size === 0) {
+            return true;
+        }
+        const isSupported = this.supportedAudioCodecs.has(codecId);
+        if (!isSupported) {
+            try {
+                const ffEncoderCodecs = Array.from(this.supportedAudioCodecs).filter((c) => typeof c === 'string');
+                for (const encoderName of ffEncoderCodecs) {
+                    const encoderCodec = Codec.findEncoderByName(encoderName);
+                    if (encoderCodec?.id === codecId) {
+                        return true;
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        return isSupported;
+    }
+    /**
+     * Find the encoder for a target video codec, on the device when it works there.
+     *
+     * @param target - Codec ID, or the name of a specific encoder to use as it is
+     *
+     * @param size - The output size, when known before the first frame
+     *
+     * @param size.width - Width
+     *
+     * @param size.height - Height
+     *
+     * @returns The encoder, or null if none exists
+     *
+     * @internal
+     */
+    async findVideoEncoder(target, size) {
+        if (typeof target === 'string') {
+            return Codec.findEncoderByName(target);
+        }
+        return (await findUsableHardwareEncoder(this.hardwareContext, target, this.options.video.encoderOptions, size)) ?? findSoftwareEncoder(target);
+    }
+    /**
+     * Check if the given video codec is supported.
+     *
+     * @param codecId - The AVCodecID to check
+     *
+     * @returns True if the codec is supported, false otherwise
+     *
+     * @internal
+     */
+    isVideoCodecSupported(codecId) {
+        // Empty set means all codecs are supported (passthrough only)
+        if (this.supportedVideoCodecs.size === 0) {
+            return true;
+        }
+        const isSupported = this.supportedVideoCodecs.has(codecId);
+        if (!isSupported) {
+            try {
+                const ffEncoderCodecs = Array.from(this.supportedVideoCodecs).filter((c) => typeof c === 'string');
+                for (const encoderName of ffEncoderCodecs) {
+                    const encoderCodec = Codec.findEncoderByName(encoderName);
+                    if (encoderCodec?.id === codecId) {
+                        return true;
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        return isSupported;
+    }
+    /**
+     * Select a codec-supported sample format for the desired one.
+     *
+     * Delegates to the shared {@link pickSupportedSampleFormat} so the RTP path and
+     * the encoder negotiate formats identically.
+     *
+     * @param codec - Audio encoder codec
+     *
+     * @param desiredFormat - Desired sample format
+     *
+     * @returns A sample format the codec accepts
+     *
+     * @internal
+     */
+    selectSampleFormat(codec, desiredFormat) {
+        return pickSupportedSampleFormat(desiredFormat, codec.sampleFormats);
+    }
+    /**
+     * Select a codec-supported sample rate for the desired one.
+     *
+     * Delegates to the shared {@link pickSupportedRate} (keeps the desired rate when
+     * accepted, otherwise the nearest supported one).
+     *
+     * @param codec - Audio encoder codec
+     *
+     * @param desiredRate - Desired sample rate
+     *
+     * @returns A sample rate the codec accepts
+     *
+     * @internal
+     */
+    selectSampleRate(codec, desiredRate) {
+        return pickSupportedRate(desiredRate, codec.supportedSamplerates);
+    }
+    /**
+     * Select a codec-supported channel layout for the desired channel count, as an
+     * SDP layout string.
+     *
+     * Delegates the choice to the shared {@link pickSupportedLayout} (nearest channel
+     * count when the exact count is unsupported), then renders it as `'mono'`,
+     * `'stereo'`, or the layout mask.
+     *
+     * @param codec - Audio encoder codec
+     *
+     * @param desiredChannels - Desired number of channels
+     *
+     * @returns Channel layout string the codec accepts
+     *
+     * @internal
+     */
+    selectChannelLayout(codec, desiredChannels) {
+        const supportedLayouts = codec.channelLayouts;
+        if (!supportedLayouts || supportedLayouts.length === 0) {
+            return desiredChannels === 1 ? 'mono' : 'stereo'; // should normally not happen
+        }
+        const picked = pickSupportedLayout(avChannelLayoutDefault(desiredChannels), supportedLayouts);
+        if (picked.nbChannels === 1)
+            return 'mono';
+        if (picked.nbChannels === 2)
+            return 'stereo';
+        return picked.mask.toString();
+    }
+}
+/**
+ * Encoder options for live video: low-latency presets for x264/x265 and an IDR
+ * for every requested keyframe, so a receiver that lost packets can resync.
+ *
+ * @param name - The encoder's name
+ *
+ * @param overrides - Caller options, applied last
+ *
+ * @returns The encoder options
+ *
+ * @internal
+ */
+function liveVideoEncoderOptions(name, overrides) {
+    const options = {};
+    if (name === FF_ENCODER_LIBX264 || name === FF_ENCODER_LIBX265) {
+        options.preset = 'ultrafast';
+        options.tune = 'zerolatency';
+    }
+    // VAAPI, D3D12 and VideoToolbox make a forced I frame an IDR without an option
+    const forcedIdr = forcedIdrOption(name);
+    if (forcedIdr) {
+        options[forcedIdr] = true;
+    }
+    return { ...options, ...overrides };
+}
+/**
+ * The option that makes an encoder emit a forced I frame (frame.pictType = I) as IDR.
+ *
+ * @param name - The encoder's name
+ *
+ * @returns The option, or null when the encoder needs none or has none
+ *
+ * @internal
+ */
+function forcedIdrOption(name) {
+    if (name === FF_ENCODER_LIBX264 || name === FF_ENCODER_LIBX265 || name?.endsWith('_nvenc')) {
+        return 'forced-idr';
+    }
+    if (name?.endsWith('_qsv') || name?.endsWith('_amf')) {
+        return 'forced_idr';
+    }
+    return null;
+}
+//# sourceMappingURL=rtp-stream.js.map