node-av 6.2.0-beta.3 → 6.2.0-beta.31

package/dist/api/rtp-stream.js

@@ -1,11 +1,11 @@
 import { isRtcp, RtpPacket } from 'werift';
-import { AV_HWDEVICE_TYPE_NONE, AV_PICTURE_TYPE_I, AV_SAMPLE_FMT_FLTP } from '../constants/constants.js';
+import { AV_CODEC_ID_HEVC, AV_HWDEVICE_TYPE_NONE, AV_PICTURE_TYPE_I, AV_PIX_FMT_YUV420P, 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 { avChannelLayoutDefault, avGetPixFmtName } from '../lib/utilities.js';
+import { BitStreamFilterAPI } from './bitstream-filter.js';
 import { MAX_PACKET_SIZE } from './constants.js';
-import { pickSupportedLayout, pickSupportedRate, pickSupportedSampleFormat } from './utilities/codec-format.js';
 import { Decoder } from './decoder.js';
 import { Demuxer } from './demuxer.js';
 import { Encoder } from './encoder.js';
@@ -13,7 +13,8 @@ import { FilterPreset } from './filter-presets.js';
 import { FilterAPI } from './filter.js';
 import { HardwareContext } from './hardware.js';
 import { Muxer } from './muxer.js';
-import { pipeline } from './pipeline.js';
+import { interruptibleFrameSource, pipeline } from './pipeline.js';
+import { pickSupportedLayout, pickSupportedPixelFormat, pickSupportedRate, pickSupportedSampleFormat } from './utilities/codec-format.js';
 /**
  * Check whether a streaming-class input is a frame source (not a URL or Demuxer).
  *
@@ -100,6 +101,7 @@ export class RTPStream {
     videoDecoder;
     videoFilter;
     videoEncoder;
+    videoBitstreamFilter;
     audioDecoder;
     audioFilter;
     audioEncoder;
@@ -109,6 +111,11 @@ export class RTPStream {
     supportedVideoCodecs;
     supportedAudioCodecs;
     videoKeyframeRequested = false;
+    abortHandler;
+    stopRequested = false;
+    stopPromise;
+    startAbort;
+    stopSignal = Promise.withResolvers();
     /**
      * @param input - Media input URL or pre-opened Demuxer
      *
@@ -161,9 +168,11 @@ export class RTPStream {
                 ssrc: options.video?.ssrc,
                 payloadType: options.video?.payloadType,
                 mtu: options.video?.mtu ?? MAX_PACKET_SIZE,
-                fps: options.video?.fps ?? 20,
+                fps: options.video?.fps,
                 width: options.video?.width,
                 height: options.video?.height,
+                bitrate: options.video?.bitrate,
+                dumpExtra: options.video?.dumpExtra,
                 encoderOptions: options.video?.encoderOptions ?? {},
             },
             audio: {
@@ -223,10 +232,14 @@ export class RTPStream {
     /**
      * 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 && !this.pipeline.isStopped();
+        return this.pipeline !== undefined;
     }
     /**
      * Get the demuxer instance.
@@ -282,7 +295,9 @@ export class RTPStream {
      * @internal
      */
     async *wrapVideoSource(src) {
-        for await (const frame of src) {
+        // Pull through the interruptible wrapper: a frame source has no demuxer for
+        // stop() to interrupt, so without it a silent source blocks teardown.
+        for await (const frame of interruptibleFrameSource(src, this.stopSignal.promise)) {
             if (frame && this.videoKeyframeRequested) {
                 this.videoKeyframeRequested = false;
                 frame.pictType = AV_PICTURE_TYPE_I;
@@ -332,11 +347,30 @@ export class RTPStream {
      * @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();
-        this.signal?.addEventListener('abort', () => this.stop(), { once: true });
+        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();
@@ -346,10 +380,13 @@ export class RTPStream {
             if (!this.inputUrl) {
                 throw new Error('No input URL or Demuxer provided');
             }
-            this.input = await Demuxer.open(this.inputUrl, this.inputOptions);
+            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.isVideoCodecSupported(videoStream.codecpar.codecId)) {
             // Check if we need hardware acceleration
@@ -370,6 +407,21 @@ export class RTPStream {
             const needsScale = (this.options.video.width !== undefined && this.options.video.width !== currentWidth) ||
                 (this.options.video.height !== undefined && this.options.video.height !== currentHeight);
             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');
+            }
+            let encoderCodec = null;
+            if (typeof targetCodecId === 'string') {
+                encoderCodec = Codec.findEncoderByName(targetCodecId);
+            }
+            else {
+                encoderCodec = this.hardwareContext?.getEncoderCodec(targetCodecId) ?? Codec.findEncoder(targetCodecId);
+            }
+            if (!encoderCodec) {
+                throw new Error(`No encoder found for codec ID ${targetCodecId}`);
+            }
             // Create filter chain only if needed
             if (needsScale || needsFps) {
                 const filterChain = FilterPreset.chain(this.hardwareContext);
@@ -383,25 +435,26 @@ export class RTPStream {
                 if (needsFps) {
                     filterChain.filter('fps', { fps: this.options.video.fps });
                 }
+                // Software scaling leaves the graph output format unconstrained, so swscale keeps the
+                // source format on both sides of the scale. Packed formats like yuyv422 can't be scaled
+                // in place (yuyv422 -> yuyv422 fails with ENOSYS), and the encoder wouldn't accept them
+                // anyway. Pin the output to yuv420p so the graph negotiates a real conversion: it is the
+                // one format every browser/player can decode over WebRTC (unlike e.g. the 4:2:2 High
+                // profile that a least-loss pick would choose for a yuyv422 source). Fall back to a
+                // codec-supported format only if the encoder genuinely can't take yuv420p. Hardware chains
+                // negotiate their format through the frames context instead.
+                if (needsScale && !this.hardwareContext) {
+                    const formats = encoderCodec.pixelFormats;
+                    const targetFmt = !formats || formats.includes(AV_PIX_FMT_YUV420P) ? AV_PIX_FMT_YUV420P : pickSupportedPixelFormat(videoStream.codecpar.format, formats);
+                    const targetFmtName = avGetPixFmtName(targetFmt);
+                    if (targetFmtName) {
+                        filterChain.filter('format', { pix_fmts: targetFmtName });
+                    }
+                }
                 this.videoFilter = FilterAPI.create(filterChain.build(), {
                     hardware: this.hardwareContext,
                 });
             }
-            // Get first supported codec
-            const targetCodecId = this.options.supportedVideoCodecs[0];
-            if (!targetCodecId) {
-                throw new Error('No supported video codec specified for transcoding');
-            }
-            let encoderCodec = null;
-            if (typeof targetCodecId === 'string') {
-                encoderCodec = Codec.findEncoderByName(targetCodecId);
-            }
-            else {
-                encoderCodec = this.hardwareContext?.getEncoderCodec(targetCodecId) ?? Codec.findEncoder(targetCodecId);
-            }
-            if (!encoderCodec) {
-                throw new Error(`No encoder found for codec ID ${targetCodecId}`);
-            }
             let encoderOptions = {};
             if (encoderCodec.name === FF_ENCODER_LIBX264 || encoderCodec.name === FF_ENCODER_LIBX265) {
                 encoderOptions.preset = 'ultrafast';
@@ -411,20 +464,25 @@ export class RTPStream {
                 ...encoderOptions,
                 ...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) => {
+                    this.applyBitrate(ctx, bitrate);
+                },
             });
+            this.throwIfStopRequested();
+            videoOutputIsHevc = encoderCodec.id === AV_CODEC_ID_HEVC;
         }
-        // Calculate video timestamp increment from the input stream fps (or option override)
-        const videoStreamFps = videoStream ? videoStream.avgFrameRate.num / videoStream.avgFrameRate.den : 20;
-        let fps = this.options.video.fps ?? videoStreamFps;
-        if (!isFinite(fps) || fps <= 0 || isNaN(fps)) {
-            fps = 20; // Default to 20 FPS if invalid
+        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(fps);
+        this.videoOutput = await this.createVideoOutput();
+        this.throwIfStopRequested();
         // Setup audio if available and needs transcoding
         if (audioStream && !this.isAudioCodecSupported(audioStream.codecpar.codecId)) {
             this.audioDecoder = await Decoder.create(audioStream, {
@@ -470,37 +528,139 @@ export class RTPStream {
                 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');
+        }
+    }
+    /**
+     * Cap the video bitrate on the encoder context.
+     *
+     * Sets the target bitrate together with a VBV cap (maxrate + a 1s buffer).
+     * Encoder.create() always seeds a default target bitrate (1 Mbps for video),
+     * so the target MUST be lowered along with the cap.
+     *
+     * @param ctx - Encoder codec context
+     *
+     * @param bitrate - Maximum bitrate in bits per second, or undefined
+     *
+     * @internal
+     */
+    applyBitrate(ctx, bitrate) {
+        if (!bitrate || bitrate <= 0) {
+            return;
+        }
+        const rate = Math.round(bitrate);
+        ctx.bitRate = BigInt(rate);
+        ctx.rcMaxRate = BigInt(rate);
+        ctx.rcBufferSize = rate;
+    }
     /**
      * Wire the pipeline completion to the onClose/error callbacks.
      *
      * On success invokes `onClose()`; on error stops the stream and invokes
-     * `onClose(error)`. Runs in the background (not awaited).
+     * `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.options.onClose?.();
+            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);
         })
-            .catch(async (error) => {
-            console.error('[RTPStream] Pipeline error:', error);
-            await this.stop();
-            this.options.onClose?.(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
@@ -557,15 +717,18 @@ export class RTPStream {
             // 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));
+                    this.applyBitrate(ctx, bitrate);
                 },
             });
-            this.videoOutput = await this.createVideoOutput(fps);
+            this.videoOutput = await this.createVideoOutput();
+            this.throwIfStopRequested();
             controls.push(pipeline(this.wrapVideoSource(source.video), this.videoEncoder, this.videoOutput, opts));
         }
         // Audio
@@ -599,9 +762,12 @@ export class RTPStream {
             this.audioEncoder = await Encoder.create(encoderCodec, {
                 filter: this.audioFilter,
                 options: encoderOptions,
+                audioFrameBuffer: { maxGapFill: 0 },
             });
             this.audioOutput = await this.createAudioOutput();
-            controls.push(pipeline(source.audio, this.audioFilter, this.audioEncoder, this.audioOutput, opts));
+            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);
@@ -609,21 +775,19 @@ export class RTPStream {
     /**
      * Create the RTP video output muxer.
      *
-     * Rewrites RTP sequence numbers (continuous) and timestamps (90 kHz, advanced
-     * per frame at `fps`) 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.
-     *
-     * @param fps - Frame rate used for the RTP timestamp increment
+     * 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(fps) {
+    async createVideoOutput() {
         let videoSequenceNumber = Math.floor(Math.random() * 0xffff);
-        let videoTimestamp = Math.floor(Math.random() * 0xffffffff) >>> 0; // unsigned 32-bit
-        const videoTimestampIncrement = 90000 / fps;
+        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;
@@ -641,12 +805,14 @@ export class RTPStream {
                 // Fix sequence number - ensure continuous sequence
                 rtpPacket.header.sequenceNumber = videoSequenceNumber;
                 videoSequenceNumber = (videoSequenceNumber + 1) & 0xffff; // Wrap at 16-bit
-                // Fix timestamp - calculate based on FPS. All packets in the same frame
-                // share a timestamp (marker=false); advance only when the frame ends.
-                rtpPacket.header.timestamp = videoTimestamp;
-                if (rtpPacket.header.marker) {
-                    videoTimestamp = (videoTimestamp + videoTimestampIncrement) >>> 0; // Unsigned 32-bit wrap
-                }
+                // 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;
             },
@@ -713,7 +879,7 @@ export class RTPStream {
         const opts = this.signal ? { signal: this.signal } : undefined;
         if (hasAudio && hasVideo) {
             this.pipeline = pipeline(this.input, {
-                video: [this.videoDecoder, this.videoFilter, this.videoEncoder],
+                video: [this.videoDecoder, this.videoFilter, this.videoEncoder, this.videoBitstreamFilter],
                 audio: [this.audioDecoder, this.audioFilter, this.audioEncoder],
             }, {
                 video: this.videoOutput,
@@ -722,7 +888,7 @@ export class RTPStream {
         }
         else if (hasVideo) {
             this.pipeline = pipeline(this.input, {
-                video: [this.videoDecoder, this.videoFilter, this.videoEncoder],
+                video: [this.videoDecoder, this.videoFilter, this.videoEncoder, this.videoBitstreamFilter],
             }, this.videoOutput, opts);
         }
         else if (hasAudio) {
@@ -741,7 +907,8 @@ export class RTPStream {
      *
      * 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.
+     * to restart the stream. Resolves even if the pipeline had failed; that
+     * error is reported through `onClose(error)`.
      *
      * @example
      * ```typescript
@@ -755,43 +922,104 @@ export class RTPStream {
      * ```
      */
     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;
-        // 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.
-        if (this.pipeline && !this.pipeline.isStopped()) {
-            this.pipeline.stop();
+        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.pipeline.completion;
+                await this.videoOutput?.close();
             }
             catch {
-                // Pipeline errored - proceed with teardown regardless.
-            }
-            this.pipeline = undefined;
-        }
-        // Close all resources
-        await this.videoOutput?.close();
-        this.videoOutput = undefined;
-        await this.audioOutput?.close();
-        this.audioOutput = undefined;
-        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;
-        await this.input?.close();
-        this.input = undefined;
+                // Surfaced through the pipeline completion.
+            }
+            this.videoOutput = undefined;
+            try {
+                await this.audioOutput?.close();
+            }
+            catch {
+                // Surfaced through the pipeline completion.
+            }
+            this.audioOutput = undefined;
+            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;
+            await this.input?.close();
+            this.input = undefined;
+        }
+        finally {
+            this.stopRequested = false;
+        }
     }
     /**
      * Check if the given audio codec is supported.