@osmo.inc/cli 0.1.15

package/third-party/npm/mediabunny@1.52.2/source/src/media-source.ts

@@ -0,0 +1,3041 @@
+/*!
+ * Copyright (c) 2026-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+import { buildAacAudioSpecificConfig, parseAacAudioSpecificConfig } from '../shared/aac-misc';
+import {
+	AUDIO_CODECS,
+	AudioCodec,
+	MediaCodec,
+	parsePcmCodec,
+	PCM_AUDIO_CODECS,
+	PcmAudioCodec,
+	SUBTITLE_CODECS,
+	SubtitleCodec,
+	VIDEO_CODECS,
+	VideoCodec,
+} from './codec';
+import { OutputAudioTrack, OutputSubtitleTrack, OutputTrack, OutputVideoTrack } from './output';
+import {
+	assert,
+	assertNever,
+	binarySearchLessOrEqual,
+	CallSerializer,
+	clamp,
+	clearIntervalUnthrottled,
+	floorToDivisor,
+	last,
+	promiseWithResolvers,
+	roundToDivisor,
+	setInt24,
+	setIntervalUnthrottled,
+	setUint24,
+	toUint8Array,
+	UnthrottledTimerHandle,
+	wait,
+} from './misc';
+import { Muxer } from './muxer';
+import { SubtitleParser } from './subtitles';
+import { toAlaw, toUlaw } from './pcm';
+import {
+	CustomVideoEncoder,
+	CustomAudioEncoder,
+	customVideoEncoders,
+	customAudioEncoders,
+} from './custom-coder';
+import { EncodedPacket, EncodedPacketSideData, PacketType } from './packet';
+import {
+	AudioSample,
+	audioSampleToInterleavedFormat,
+	toInterleavedAudioFormat,
+	VideoSample,
+	VideoSamplePixelFormat,
+} from './sample';
+import {
+	AudioEncodingConfig,
+	buildAudioEncoderConfig,
+	buildQuantizerEncodeOptions,
+	buildVideoEncoderConfigs,
+	resolveQuality,
+	validateAudioEncodingConfig,
+	validateVideoEncodingConfig,
+	VideoEncoderConfigCandidate,
+	VideoEncodingConfig,
+} from './encode';
+import { AudioResampler } from './resample';
+import { determineVideoPacketType } from './codec-data';
+import { Logging } from './logging';
+
+/**
+ * Base class for media sources. Media sources are used to add media samples to an output file.
+ * @group Media sources
+ * @public
+ */
+export abstract class MediaSource {
+	/** @internal */
+	abstract readonly _codec: MediaCodec;
+	/** @internal */
+	_connectedTrack: OutputTrack | null = null;
+	/** @internal */
+	_closingPromise: Promise<void> | null = null;
+	/** @internal */
+	_closed = false;
+
+	/** @internal */
+	_ensureValidAdd() {
+		if (!this._connectedTrack) {
+			throw new Error('Source is not connected to an output track.');
+		}
+
+		if (this._connectedTrack.output.state === 'canceled') {
+			throw new Error('Output has been canceled.');
+		}
+
+		if (this._connectedTrack.output.state === 'finalizing' || this._connectedTrack.output.state === 'finalized') {
+			throw new Error('Output has been finalized.');
+		}
+
+		if (this._connectedTrack.output.state === 'pending') {
+			throw new Error('Output has not started.');
+		}
+
+		if (this._closed) {
+			throw new Error('Source is closed.');
+		}
+	}
+
+	/** @internal */
+	async _start() {}
+	/** @internal */
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	async _flushAndClose(forceClose: boolean) {}
+
+	/**
+	 * Closes this source. This prevents future samples from being added and signals to the output file that no further
+	 * samples will come in for this track. Calling `.close()` is optional but recommended after adding the
+	 * last sample - for improved performance and reduced memory usage.
+	 */
+	close() {
+		if (this._closingPromise) {
+			return;
+		}
+
+		const connectedTrack = this._connectedTrack;
+
+		if (!connectedTrack) {
+			throw new Error('Cannot call close without connecting the source to an output track.');
+		}
+
+		if (connectedTrack.output.state === 'pending') {
+			throw new Error('Cannot call close before output has been started.');
+		}
+
+		this._closingPromise = (async () => {
+			await this._flushAndClose(false);
+
+			this._closed = true;
+
+			if (connectedTrack.output.state === 'finalizing' || connectedTrack.output.state === 'finalized') {
+				return;
+			}
+
+			connectedTrack.output._muxer.onTrackClose(connectedTrack);
+		})();
+	}
+
+	/** @internal */
+	async _flushOrWaitForOngoingClose(forceClose: boolean) {
+		return this._closingPromise ??= (async () => {
+			await this._flushAndClose(forceClose);
+			this._closed = true;
+		})();
+	}
+}
+
+/**
+ * Base class for video sources - sources for video tracks.
+ * @group Media sources
+ * @public
+ */
+export abstract class VideoSource extends MediaSource {
+	/** @internal */
+	override _connectedTrack: OutputVideoTrack | null = null;
+	/** @internal */
+	override readonly _codec: VideoCodec;
+
+	/** Internal constructor. */
+	constructor(codec: VideoCodec) {
+		super();
+
+		if (!VIDEO_CODECS.includes(codec)) {
+			throw new TypeError(`Invalid video codec '${codec}'. Must be one of: ${VIDEO_CODECS.join(', ')}.`);
+		}
+
+		this._codec = codec;
+	}
+}
+
+const maybeEnsureIsKeyPacket = (track: OutputVideoTrack, packet: EncodedPacket) => {
+	if (track.metadata.hasOnlyKeyPackets && packet.type !== 'key') {
+		throw new Error('Cannot add non-key packets to a hasOnlyKeyPackets video track.');
+	}
+};
+
+/**
+ * The most basic video source; can be used to directly pipe encoded packets into the output file.
+ * @group Media sources
+ * @public
+ */
+export class EncodedVideoPacketSource extends VideoSource {
+	/** Creates a new {@link EncodedVideoPacketSource} whose packets are encoded using `codec`. */
+	constructor(codec: VideoCodec) {
+		super(codec);
+	}
+
+	/**
+	 * Adds an encoded packet to the output video track. Packets must be added in *decode order*, while a packet's
+	 * timestamp must be its *presentation timestamp*. B-frames are handled automatically.
+	 *
+	 * @param meta - Additional metadata from the encoder. You should pass this for the first call, including a valid
+	 * decoder config.
+	 *
+	 * @returns A Promise that resolves once the output is ready to receive more samples. You should await this Promise
+	 * to respect writer and encoder backpressure.
+	 */
+	add(packet: EncodedPacket, meta?: EncodedVideoChunkMetadata) {
+		if (!(packet instanceof EncodedPacket)) {
+			throw new TypeError('packet must be an EncodedPacket.');
+		}
+		if (packet.isMetadataOnly) {
+			throw new TypeError('Metadata-only packets cannot be added.');
+		}
+		if (meta !== undefined && (!meta || typeof meta !== 'object')) {
+			throw new TypeError('meta, when provided, must be an object.');
+		}
+
+		this._ensureValidAdd();
+
+		maybeEnsureIsKeyPacket(this._connectedTrack!, packet);
+		return this._connectedTrack!.output._muxer.addEncodedVideoPacket(this._connectedTrack!, packet, meta);
+	}
+}
+
+class VideoEncoderWrapper {
+	private ensureEncoderPromise: Promise<void> | null = null;
+	private encoderInitialized = false;
+	private encoder: VideoEncoder | null = null;
+	private muxer: Muxer | null = null;
+	private lastMultipleOfKeyFrameInterval = -1;
+	private emittedEncoderPackets = 0;
+
+	// Tracks the input dimensions of the first frame
+	private codedWidth: number | null = null;
+	private codedHeight: number | null = null;
+	// Tracks the output dimensions of the first frame (used to lock dimensions for fill/contain/cover)
+	private outputWidth: number | null = null;
+	private outputHeight: number | null = null;
+
+	// Frame rate normalization state
+	private frameRateLastSample: VideoSample | null = null;
+	private frameRateLastTimestamp: number | null = null;
+	private frameRateLastEndTimestamp: number | null = null;
+
+	// VideoEncoder converts everything to microseconds, so we need to do some bookkeeping to restore the original
+	// timing information
+	private preciseTimings: {
+		microsecondTimestamp: number;
+		timestamp: number;
+		duration: number;
+		timestampIsValid: boolean;
+		durationIsValid: boolean;
+	}[] = [];
+
+	private customEncoder: CustomVideoEncoder | null = null;
+	private customEncoderCallSerializer = new CallSerializer();
+	private customEncoderQueueSize = 0;
+
+	// Set when the encoder uses quantizer-based rate control; carries the quantizer value applied to each frame
+	private defaultEncodeOptions: VideoEncoderEncodeOptions = {};
+
+	// Alpha stuff
+	private alphaEncoder: VideoEncoder | null = null;
+	private splitter: ColorAlphaSplitter | null = null;
+	private splitterCreationFailed = false;
+	private alphaFrameQueue: (VideoFrame | null)[] = [];
+
+	/**
+	 * Encoders typically throw their errors "out of band", meaning asynchronously in some other execution context.
+	 * However, we want to surface these errors to the user within the normal control flow, so they don't go uncaught.
+	 * So, we keep track of the encoder error and throw it as soon as we get the chance.
+	 */
+	private error: unknown = null;
+	private errorSet = false;
+
+	private setError(error: unknown) {
+		if (!this.errorSet) {
+			this.error = error;
+			this.errorSet = true;
+		}
+	}
+
+	private lastMuxerPromise: Promise<void> = Promise.resolve();
+	private closed = false;
+
+	constructor(private source: VideoSource, private encodingConfig: VideoEncodingConfig) {}
+
+	async add(videoSample: VideoSample, shouldClose: boolean, encodeOptions?: VideoEncoderEncodeOptions) {
+		const originalSample = videoSample;
+
+		try {
+			this.checkForEncoderError();
+			this.source._ensureValidAdd();
+
+			const config = this.encodingConfig;
+			const sizeChangeBehavior = config.sizeChangeBehavior ?? 'deny';
+			let isSizeChange = false;
+
+			// Ensure video sample size remains constant or handle the change
+			if (this.codedWidth !== null && this.codedHeight !== null) {
+				if (videoSample.codedWidth !== this.codedWidth || videoSample.codedHeight !== this.codedHeight) {
+					isSizeChange = true;
+					if (sizeChangeBehavior === 'deny') {
+						throw new Error(
+							`Video sample size must remain constant. Expected ${this.codedWidth}x${this.codedHeight},`
+							+ ` got ${videoSample.codedWidth}x${videoSample.codedHeight}. To allow the sample size to`
+							+ ` change over time, set \`sizeChangeBehavior\` to a value other than 'deny' in the`
+							+ ` encoding options.`,
+						);
+					}
+				}
+			} else {
+				this.codedWidth = videoSample.codedWidth;
+				this.codedHeight = videoSample.codedHeight;
+			}
+
+			// Determine if we need to apply transformations via canvas
+			const hasTransformConfig = config.transform?.width !== undefined
+				|| config.transform?.height !== undefined
+				|| config.transform?.rotate !== undefined
+				|| config.transform?.crop !== undefined
+				|| config.transform?.force === true;
+			const needsTransform = hasTransformConfig || (isSizeChange && sizeChangeBehavior !== 'passThrough');
+
+			if (needsTransform) {
+				let targetWidth = config.transform?.width;
+				let targetHeight = config.transform?.height;
+				let appliedFit: 'fill' | 'contain' | 'cover' = config.transform?.fit ?? 'fill';
+
+				// If the size changed and behavior is fill/contain/cover, lock to the original output dimensions
+				if (isSizeChange && sizeChangeBehavior !== 'passThrough') {
+					assert(this.outputWidth);
+					assert(this.outputHeight);
+					assert(sizeChangeBehavior !== 'deny');
+
+					targetWidth = this.outputWidth!;
+					targetHeight = this.outputHeight!;
+					appliedFit = sizeChangeBehavior;
+				}
+
+				const transformed = await videoSample.transform({
+					width: targetWidth,
+					height: targetHeight,
+					roundDimensionsTo: 2,
+					crop: config.transform?.crop,
+					rotate: config.transform?.rotate,
+					fit: appliedFit,
+					alpha: config.alpha,
+				});
+
+				// Save the output dimensions of the first frame
+				if (this.outputWidth === null || this.outputHeight === null) {
+					this.outputWidth = transformed.displayWidth;
+					this.outputHeight = transformed.displayHeight;
+				}
+
+				if (shouldClose) {
+					videoSample.close();
+				}
+
+				videoSample = transformed;
+				shouldClose = true;
+			} else {
+				// If no canvas is needed, we still need to record the output dimensions for the first frame
+				if (this.outputWidth === null || this.outputHeight === null) {
+					this.outputWidth = videoSample.codedWidth;
+					this.outputHeight = videoSample.codedHeight;
+				}
+			}
+
+			const frameRate = config.transform?.frameRate;
+			if (frameRate !== undefined) {
+				// Apply frame rate normalization
+				const originalEndTimestamp = videoSample.timestamp + videoSample.duration;
+				const alignedTimestamp = floorToDivisor(videoSample.timestamp, frameRate);
+
+				if (this.frameRateLastSample !== null) {
+					if (alignedTimestamp <= this.frameRateLastTimestamp!) {
+						// Same frame rate slot, replace stored sample with the newer one
+						this.frameRateLastSample.close();
+						this.frameRateLastSample = videoSample.clone();
+						this.frameRateLastEndTimestamp = originalEndTimestamp;
+						return;
+					} else {
+						// Pad the gap by repeating the previous frame
+						await this.padFrameRate(alignedTimestamp, encodeOptions);
+					}
+				}
+
+				// Clone if the sample is still the user's, to avoid mutating externally-owned data
+				if (videoSample === originalSample) {
+					videoSample = videoSample.clone();
+					shouldClose = true;
+				}
+
+				videoSample.setTimestamp(alignedTimestamp);
+				videoSample.setDuration(1 / frameRate);
+
+				this.frameRateLastSample?.close();
+				this.frameRateLastSample = videoSample.clone();
+				this.frameRateLastTimestamp = alignedTimestamp;
+				this.frameRateLastEndTimestamp = originalEndTimestamp;
+			}
+
+			await this.processAndEncode(videoSample, encodeOptions);
+		} finally {
+			if (shouldClose) {
+				videoSample.close();
+			}
+		}
+	}
+
+	/**
+	 * Runs the process function (if any) and encodes the resulting samples.
+	 */
+	private async processAndEncode(
+		videoSample: VideoSample,
+		encodeOptions?: VideoEncoderEncodeOptions,
+	) {
+		const config = this.encodingConfig;
+		let samplesToEncode: VideoSample[];
+
+		// Apply the user-defined process function, if any
+		if (config.transform?.process) {
+			let processed = config.transform.process(videoSample);
+			if (processed instanceof Promise) {
+				processed = await processed;
+			}
+
+			if (processed === null) {
+				return;
+			}
+
+			if (!Array.isArray(processed)) {
+				processed = [processed];
+			}
+
+			const mappedSamples: VideoSample[] = [];
+
+			try {
+				for (const x of processed) {
+					if (x instanceof VideoSample) {
+						mappedSamples.push(x);
+					} else if (typeof VideoFrame !== 'undefined' && x instanceof VideoFrame) {
+						mappedSamples.push(new VideoSample(x));
+					} else {
+						// Calling the VideoSample constructor here will automatically handle input validation for us
+						// (it throws for any non-legal argument).
+						mappedSamples.push(new VideoSample(x as CanvasImageSource, {
+							timestamp: videoSample.timestamp,
+							duration: videoSample.duration,
+						}));
+					}
+				}
+			} catch (error) {
+				// One of the returned elements was invalid; close everything closable so no resource is leaked
+				for (const sample of mappedSamples) {
+					if (sample !== videoSample) {
+						sample.close();
+					}
+				}
+				for (const x of processed) {
+					if (x instanceof VideoSample && x !== videoSample) {
+						x.close();
+					} else if (typeof VideoFrame !== 'undefined' && x instanceof VideoFrame) {
+						x.close();
+					}
+				}
+
+				throw error;
+			}
+
+			samplesToEncode = mappedSamples;
+		} else {
+			samplesToEncode = [videoSample];
+		}
+
+		try {
+			for (const sampleToEncode of samplesToEncode) {
+				if (!this.encoderInitialized) {
+					if (!this.ensureEncoderPromise) {
+						this.ensureEncoder(sampleToEncode);
+					}
+
+					// No, this "if" statement is not useless. Sometimes, the above call to
+					// `ensureEncoder` might have synchronously completed and the encoder is
+					// already initialized. In this case, we don't need to await the promise
+					// anymore. This also fixes nasty async race condition bugs when multiple
+					// code paths are calling this method: It's important that the call that
+					// initialized the encoder go through this code first.
+					if (!this.encoderInitialized) {
+						await this.ensureEncoderPromise;
+					}
+				}
+				assert(this.encoderInitialized);
+
+				if (this.closed) {
+					break;
+				}
+
+				const keyFrameInterval = this.encodingConfig.keyFrameInterval ?? 2;
+				const multipleOfKeyFrameInterval = Math.floor(sampleToEncode.timestamp / keyFrameInterval);
+
+				const mergedEncodeOptions = {
+					...this.defaultEncodeOptions,
+					...sampleToEncode.encodeOptions,
+					...encodeOptions,
+				};
+
+				const finalEncodeOptions = {
+					...mergedEncodeOptions,
+					keyFrame: mergedEncodeOptions.keyFrame !== undefined
+						? mergedEncodeOptions.keyFrame
+						// Ensure a key frame every keyFrameInterval seconds. It is important that all video tracks
+						// follow the same "key frame" rhythm, because aligned key frames are required to start new
+						// fragments in ISOBMFF or clusters in Matroska (or at least desirable).
+						: keyFrameInterval === 0
+							|| multipleOfKeyFrameInterval !== this.lastMultipleOfKeyFrameInterval,
+				};
+				this.lastMultipleOfKeyFrameInterval = multipleOfKeyFrameInterval;
+
+				this.encodingConfig.onEncodedSample?.(sampleToEncode);
+
+				if (this.customEncoder) {
+					this.customEncoderQueueSize++;
+
+					// We clone the sample so it cannot be closed on us from the outside before it reaches the encoder
+					const clonedSample = sampleToEncode.clone();
+
+					const promise = this.customEncoderCallSerializer
+						.call(() => this.customEncoder!.encode(clonedSample, finalEncodeOptions))
+						.catch((error: unknown) => this.setError(error))
+						.finally(() => {
+							this.customEncoderQueueSize--;
+							clonedSample.close();
+						});
+
+					if (this.customEncoderQueueSize >= 4) {
+						await promise;
+					}
+				} else {
+					assert(this.encoder);
+
+					const videoFrame = sampleToEncode.toVideoFrame();
+
+					const preciseTimingIndex = binarySearchLessOrEqual(
+						this.preciseTimings,
+						videoFrame.timestamp,
+						x => x.microsecondTimestamp,
+					);
+					const existingEntry = preciseTimingIndex !== -1
+						? this.preciseTimings[preciseTimingIndex]
+						: null;
+					if (existingEntry && existingEntry.microsecondTimestamp === videoFrame.timestamp) {
+						if (existingEntry.timestamp !== sampleToEncode.timestamp) {
+							// Mapping isn't unique, can't use the timestamp
+							existingEntry.timestampIsValid = false;
+						}
+						if (existingEntry.duration !== sampleToEncode.duration) {
+							// Mapping isn't unique, can't use the duration
+							existingEntry.durationIsValid = false;
+						}
+					} else {
+						this.preciseTimings.splice(preciseTimingIndex + 1, 0, {
+							microsecondTimestamp: videoFrame.timestamp,
+							timestamp: sampleToEncode.timestamp,
+							duration: sampleToEncode.duration,
+							timestampIsValid: true,
+							durationIsValid: true,
+						});
+
+						// Make sure it doesn't grow indefinitely
+						if (this.preciseTimings.length > 128) {
+							this.preciseTimings.shift();
+						}
+					}
+
+					if (!this.alphaEncoder) {
+						// No alpha encoder, simple case
+						try {
+							this.encoder.encode(videoFrame, finalEncodeOptions);
+						} finally {
+							videoFrame.close();
+						}
+					} else {
+						// We're expected to encode alpha as well
+						const frameDefinitelyHasNoAlpha = !!videoFrame.format && !videoFrame.format.includes('A');
+
+						if (frameDefinitelyHasNoAlpha || this.splitterCreationFailed) {
+							this.alphaFrameQueue.push(null);
+							try {
+								this.encoder.encode(videoFrame, finalEncodeOptions);
+							} finally {
+								videoFrame.close();
+							}
+						} else {
+							if (!this.splitter) {
+								this.splitter = new ColorAlphaSplitter();
+							}
+
+							// The splitter takes ownership, so no need to close the frames ourselves
+							const { colorFrame, alphaFrame } = await this.splitter.split(videoFrame);
+
+							this.alphaFrameQueue.push(alphaFrame);
+							try {
+								this.encoder.encode(colorFrame, finalEncodeOptions);
+							} finally {
+								colorFrame.close();
+							}
+						}
+					}
+
+					// We need to do this after sending the frame to the encoder as the frame otherwise might be closed
+					if (this.encoder.encodeQueueSize >= 4) {
+						await new Promise(resolve =>
+							this.encoder!.addEventListener('dequeue', resolve, { once: true }),
+						);
+					}
+				}
+
+				await this.lastMuxerPromise; // Allow the writer to apply backpressure
+			}
+		} finally {
+			for (const sample of samplesToEncode) {
+				if (sample !== videoSample) {
+					sample.close();
+				}
+			}
+		}
+	}
+
+	/** Repeats the last frame rate sample to fill the gap up to the given timestamp. */
+	private async padFrameRate(until: number, encodeOptions?: VideoEncoderEncodeOptions) {
+		const frameRate = this.encodingConfig.transform!.frameRate!;
+		assert(this.frameRateLastSample);
+
+		const frameDifference = Math.round((until - this.frameRateLastTimestamp!) * frameRate);
+
+		for (let i = 1; i < frameDifference; i++) {
+			using sample = this.frameRateLastSample.clone();
+			sample.setTimestamp(this.frameRateLastTimestamp! + i / frameRate);
+			sample.setDuration(1 / frameRate);
+			await this.processAndEncode(sample, encodeOptions);
+		}
+	}
+
+	private ensureEncoder(videoSample: VideoSample) {
+		this.ensureEncoderPromise = (async () => {
+			// eslint-disable-next-line @typescript-eslint/no-deprecated
+			const quality = resolveQuality(this.encodingConfig.quality, this.encodingConfig.bitrate);
+			assert(quality !== undefined);
+
+			const candidates = buildVideoEncoderConfigs({
+				...this.encodingConfig,
+				quality,
+				width: videoSample.codedWidth,
+				height: videoSample.codedHeight,
+				squarePixelWidth: videoSample.squarePixelWidth,
+				squarePixelHeight: videoSample.squarePixelHeight,
+				framerate: this.source._connectedTrack?.metadata.frameRate,
+			});
+
+			// Try the candidate configs in order of preference until we find one that is supported
+			let selected: VideoEncoderConfigCandidate | null = null;
+			let MatchingCustomEncoder: (typeof customVideoEncoders)[number] | undefined;
+
+			for (const candidate of candidates) {
+				const candidateConfig = candidate.config;
+				this.encodingConfig.onEncoderConfig?.(candidateConfig);
+
+				MatchingCustomEncoder = customVideoEncoders.find(x => x.supports(
+					this.encodingConfig.codec,
+					candidateConfig,
+				));
+				if (MatchingCustomEncoder) {
+					selected = candidate;
+					break;
+				}
+
+				if (typeof VideoEncoder === 'undefined') {
+					continue;
+				}
+
+				candidateConfig.alpha = 'discard'; // Since we handle alpha ourselves
+
+				if (this.encodingConfig.alpha === 'keep') {
+					// Encoding alpha requires using two parallel encoders, so we need to make sure they stay in sync
+					// and that neither of them drops frames. Setting latencyMode to 'quality' achieves this, because
+					// "User Agents MUST not drop frames to achieve the target bitrate and/or framerate."
+					candidateConfig.latencyMode = 'quality';
+				}
+
+				const hasOddDimension = candidateConfig.width % 2 === 1 || candidateConfig.height % 2 === 1;
+				if (
+					hasOddDimension
+					&& (this.encodingConfig.codec === 'avc' || this.encodingConfig.codec === 'hevc')
+				) {
+					// Throw a special error for this case as it gets hit often
+					throw new Error(
+						`The dimensions ${candidateConfig.width}x${candidateConfig.height} are not supported for codec`
+						+ ` '${this.encodingConfig.codec}'; both width and height must be even numbers. Make sure to`
+						+ ` round your dimensions to the nearest even number.`,
+					);
+				}
+
+				const support = await VideoEncoder.isConfigSupported(candidateConfig);
+				if (support.supported) {
+					selected = candidate;
+					break;
+				}
+			}
+
+			if (!selected) {
+				if (typeof VideoEncoder === 'undefined') {
+					throw new Error('VideoEncoder is not supported by this browser.');
+				}
+
+				// The candidates only differ in their rate control, so we describe them as one config with a
+				// slash-separated list of the attempted rate control methods
+				const firstConfig = candidates[0]!.config;
+				const rateControls = candidates.map(({ config, quantizer }) =>
+					quantizer !== null ? `quantizer ${quantizer}` : `${config.bitrate} bps`,
+				);
+
+				throw new Error(
+					`This specific encoder configuration (${firstConfig.codec}, ${rateControls.join(' / ')},`
+					+ ` ${firstConfig.width}x${firstConfig.height}, hardware acceleration:`
+					+ ` ${firstConfig.hardwareAcceleration ?? 'no-preference'}) is not supported by this browser.`
+					+ ` Consider using another codec or changing your video parameters.`,
+				);
+			}
+
+			const encoderConfig = selected.config;
+			if (selected.quantizer !== null) {
+				// The chosen config uses quantizer-based rate control, so each frame must carry the quantizer value
+				this.defaultEncodeOptions = buildQuantizerEncodeOptions(
+					this.encodingConfig.codec,
+					selected.quantizer,
+				);
+			}
+
+			if (MatchingCustomEncoder) {
+				// @ts-expect-error "Can't create instance of abstract class 🤓"
+				this.customEncoder = new MatchingCustomEncoder() as CustomVideoEncoder;
+				// @ts-expect-error It's technically readonly
+				this.customEncoder.codec = this.encodingConfig.codec;
+				// @ts-expect-error It's technically readonly
+				this.customEncoder.config = encoderConfig;
+				// @ts-expect-error It's technically readonly
+				this.customEncoder.onPacket = (packet, meta) => {
+					if (!(packet instanceof EncodedPacket)) {
+						throw new TypeError('The first argument passed to onPacket must be an EncodedPacket.');
+					}
+					if (meta !== undefined && (!meta || typeof meta !== 'object')) {
+						throw new TypeError('The second argument passed to onPacket must be an object or undefined.');
+					}
+
+					maybeEnsureIsKeyPacket(this.source._connectedTrack!, packet);
+
+					this.encodingConfig.onEncodedPacket?.(packet, meta);
+					this.lastMuxerPromise
+						= this.muxer!.addEncodedVideoPacket(this.source._connectedTrack!, packet, meta)
+							.catch((error) => {
+								this.setError(error);
+							});
+				};
+				// @ts-expect-error It's technically readonly
+				this.customEncoder.onError = (error) => {
+					this.setError(error);
+				};
+
+				await this.customEncoder.init();
+			} else {
+				/** Queue of color chunks waiting for their alpha counterpart. */
+				const colorChunkQueue: {
+					chunk: EncodedVideoChunk;
+					meta: EncodedVideoChunkMetadata | undefined;
+				}[] = [];
+				/** Each value is the number of encoded alpha chunks at which a null alpha chunk should be added. */
+				const nullAlphaChunkQueue: number[] = [];
+				let encodedAlphaChunkCount = 0;
+				let alphaEncoderQueue = 0;
+
+				const addPacket = (
+					colorChunk: EncodedVideoChunk,
+					alphaChunk: EncodedVideoChunk | null,
+					meta: EncodedVideoChunkMetadata | undefined,
+				) => {
+					const sideData: EncodedPacketSideData = {};
+
+					if (alphaChunk) {
+						const alphaData = new Uint8Array(alphaChunk.byteLength);
+						alphaChunk.copyTo(alphaData);
+
+						sideData.alpha = alphaData;
+					}
+
+					let packet = EncodedPacket.fromEncodedChunk(colorChunk, sideData);
+
+					// See if there's a relevant timing entry to refine the packet's timing data
+					const preciseTimingIndex = binarySearchLessOrEqual(
+						this.preciseTimings,
+						colorChunk.timestamp,
+						x => x.microsecondTimestamp,
+					);
+					const entry = preciseTimingIndex !== -1
+						? this.preciseTimings[preciseTimingIndex]
+						: null;
+
+					let actualType: PacketType | null = null;
+					if (this.emittedEncoderPackets === 0 && packet.type === 'delta' && meta?.decoderConfig) {
+						// https://github.com/Vanilagy/mediabunny/issues/365
+						// We expect the first packet to be a key packet. If it's not, let's actually verify that it's
+						// not by getting the actual type.
+						actualType = determineVideoPacketType(
+							this.encodingConfig.codec,
+							meta.decoderConfig,
+							packet.data,
+						);
+					}
+
+					// Define the packet
+					if ((entry && entry.microsecondTimestamp === colorChunk.timestamp) || actualType !== null) {
+						packet = packet.clone({
+							timestamp: entry?.timestampIsValid ? entry.timestamp : undefined,
+							duration: entry?.durationIsValid ? entry.duration : undefined,
+							type: actualType ?? undefined,
+						});
+					}
+
+					maybeEnsureIsKeyPacket(this.source._connectedTrack!, packet);
+
+					this.encodingConfig.onEncodedPacket?.(packet, meta);
+					this.lastMuxerPromise
+						= this.muxer!.addEncodedVideoPacket(this.source._connectedTrack!, packet, meta)
+							.catch((error) => {
+								this.setError(error);
+							});
+
+					this.emittedEncoderPackets++;
+				};
+
+				const stack = new Error('Encoding error').stack;
+
+				this.encoder = new VideoEncoder({
+					output: (chunk, meta) => {
+						if (!this.alphaEncoder) {
+							// We're done
+							addPacket(chunk, null, meta);
+							return;
+						}
+
+						const alphaFrame = this.alphaFrameQueue.shift();
+						assert(alphaFrame !== undefined);
+
+						if (alphaFrame) {
+							this.alphaEncoder.encode(alphaFrame, {
+								...this.defaultEncodeOptions,
+								// Crucial: The alpha frame is forced to be a key frame whenever the color frame
+								// also is. Without this, playback can glitch and even crash in some browsers.
+								// This is the reason why the two encoders are wired in series and not in parallel.
+								keyFrame: chunk.type === 'key',
+							});
+							alphaEncoderQueue++;
+							alphaFrame.close();
+							colorChunkQueue.push({ chunk, meta });
+						} else {
+							// There was no alpha component for this frame
+							if (alphaEncoderQueue === 0) {
+								// No pending alpha encodes either, so we're done
+								addPacket(chunk, null, meta);
+							} else {
+								// There are still alpha encodes pending, so we can't add the packet immediately since
+								// we'd end up with out-of-order packets. Instead, let's queue a null alpha chunk to be
+								// added in the future, after the current encoder workload has completed:
+								nullAlphaChunkQueue.push(encodedAlphaChunkCount + alphaEncoderQueue);
+								colorChunkQueue.push({ chunk, meta });
+							}
+						}
+					},
+					error: (error) => {
+						error.stack = stack; // Provide a more useful stack trace, the default one sucks
+						this.setError(error);
+					},
+				});
+				this.encoder.configure(encoderConfig);
+
+				if (this.encodingConfig.alpha === 'keep') {
+					const stack = new Error('Encoding error').stack;
+
+					// We need to encode alpha as well, which we do with a separate encoder
+					this.alphaEncoder = new VideoEncoder({
+						// We ignore the alpha chunk's metadata
+						// eslint-disable-next-line @typescript-eslint/no-unused-vars
+						output: (chunk, meta) => {
+							alphaEncoderQueue--;
+
+							// There has to be a color chunk because the encoders are wired in series
+							const colorChunk = colorChunkQueue.shift();
+							assert(colorChunk !== undefined);
+
+							addPacket(colorChunk.chunk, chunk, colorChunk.meta);
+
+							// See if there are any null alpha chunks queued up
+							encodedAlphaChunkCount++;
+							while (
+								nullAlphaChunkQueue.length > 0
+								&& nullAlphaChunkQueue[0] === encodedAlphaChunkCount
+							) {
+								nullAlphaChunkQueue.shift();
+								const colorChunk = colorChunkQueue.shift();
+								assert(colorChunk !== undefined);
+
+								addPacket(colorChunk.chunk, null, colorChunk.meta);
+							}
+						},
+						error: (error) => {
+							error.stack = stack; // Provide a more useful stack trace
+							this.setError(error);
+						},
+					});
+					this.alphaEncoder.configure(encoderConfig);
+				}
+			}
+
+			assert(this.source._connectedTrack);
+			this.muxer = this.source._connectedTrack.output._muxer;
+
+			this.encoderInitialized = true;
+		})();
+	}
+
+	async flushAndClose(forceClose: boolean) {
+		try {
+			if (!forceClose) {
+				this.checkForEncoderError();
+
+				// Final frame rate padding: fill remaining frames up to the last sample's original end timestamp
+				if (this.frameRateLastSample) {
+					const frameRate = this.encodingConfig.transform!.frameRate!;
+					const alignedEnd = floorToDivisor(this.frameRateLastEndTimestamp!, frameRate);
+					await this.padFrameRate(alignedEnd);
+				}
+			}
+
+			this.closed = true;
+
+			if (!forceClose) {
+				if (this.customEncoder) {
+					void this.customEncoderCallSerializer.call(() => this.customEncoder!.flush());
+				} else if (this.encoder) {
+					// These are wired in series, therefore they must also be flushed in series
+					await this.encoder.flush();
+					await this.alphaEncoder?.flush();
+
+					// Workaround for https://issues.chromium.org/issues/529852980 to give it time for errors to
+					// surface
+					await wait(25);
+				}
+			}
+		} finally {
+			// This cleanup must also run when padding or flushing threw (e.g. due to an encoder error), otherwise
+			// samples, frames and encoders would be left dangling
+			this.closed = true;
+
+			this.frameRateLastSample?.close();
+			this.frameRateLastSample = null;
+
+			if (this.customEncoder) {
+				await this.customEncoderCallSerializer.call(() => this.customEncoder!.close())
+					.catch((error: unknown) => this.setError(error));
+			} else if (this.encoder) {
+				if (this.encoder.state !== 'closed') {
+					this.encoder.close();
+				}
+				if (this.alphaEncoder && this.alphaEncoder.state !== 'closed') {
+					this.alphaEncoder.close();
+				}
+
+				this.alphaFrameQueue.forEach(x => x?.close());
+				this.alphaFrameQueue.length = 0;
+
+				this.splitter?.close();
+			}
+		}
+
+		if (!forceClose) {
+			this.checkForEncoderError();
+		}
+	}
+
+	getQueueSize() {
+		if (this.customEncoder) {
+			return this.customEncoderQueueSize;
+		} else {
+			// Because the color and alpha encoders are wired in series, there's no need to also include the alpha
+			// encoder's queue size here
+			return this.encoder?.encodeQueueSize ?? 0;
+		}
+	}
+
+	checkForEncoderError() {
+		if (this.errorSet) {
+			throw this.error;
+		}
+	}
+}
+
+let splitterWorkerUrl: string | null = null;
+
+/** Utility class for splitting a composite frame into separate color and alpha parts on the CPU in a worker. */
+export class ColorAlphaSplitter {
+	private worker: Worker | null = null;
+	private pendingRequests = new Map<
+		number,
+		ReturnType<typeof promiseWithResolvers<{ colorFrame: VideoFrame; alphaFrame: VideoFrame }>>
+	>();
+
+	private nextRequestId = 0;
+
+	split(sourceFrame: VideoFrame): Promise<{ colorFrame: VideoFrame; alphaFrame: VideoFrame }> {
+		if (!this.worker) {
+			if (!splitterWorkerUrl) {
+				const blob = new Blob(
+					[`(${colorAlphaSplitterWorkerCode.toString()})()`],
+					{ type: 'application/javascript' },
+				);
+				splitterWorkerUrl = URL.createObjectURL(blob);
+			}
+
+			this.worker = new Worker(splitterWorkerUrl);
+
+			this.worker.addEventListener('message', (event: MessageEvent<ColorAlphaSplitterWorkerResponse>) => {
+				const data = event.data;
+				const pending = this.pendingRequests.get(data.id);
+				if (!pending) {
+					return;
+				}
+				this.pendingRequests.delete(data.id);
+
+				if ('error' in data) {
+					pending.reject(new Error(data.error));
+				} else {
+					pending.resolve({ colorFrame: data.colorFrame, alphaFrame: data.alphaFrame });
+				}
+			});
+
+			this.worker.addEventListener('error', (event) => {
+				const error = new Error(event.message || 'Color/alpha splitter worker error.');
+				for (const pending of this.pendingRequests.values()) {
+					pending.reject(error);
+				}
+				this.pendingRequests.clear();
+			});
+		}
+
+		const id = this.nextRequestId++;
+		const pending = promiseWithResolvers<{ colorFrame: VideoFrame; alphaFrame: VideoFrame }>();
+		this.pendingRequests.set(id, pending);
+		this.worker.postMessage({ id, sourceFrame }, { transfer: [sourceFrame] });
+
+		return pending.promise;
+	}
+
+	close() {
+		this.worker?.terminate();
+		this.worker = null;
+
+		const error = new Error('Color/alpha splitter closed.');
+		for (const pending of this.pendingRequests.values()) {
+			pending.reject(error);
+		}
+		this.pendingRequests.clear();
+	}
+}
+
+type ColorAlphaSplitterWorkerRequest = {
+	id: number;
+	sourceFrame: VideoFrame;
+};
+
+type ColorAlphaSplitterWorkerResponse =
+	| { id: number; colorFrame: VideoFrame; alphaFrame: VideoFrame }
+	| { id: number; error: string };
+
+const colorAlphaSplitterWorkerCode = () => {
+	// Reused across frames as long as the size matches, since consecutive frames usually share dimensions.
+	let cpuSourceBuffer: Uint8Array | null = null;
+
+	// Serialize execution internally so concurrent requests don't race on the shared cpuSourceBuffer.
+	let chain: Promise<void> = Promise.resolve();
+	self.addEventListener('message', (event: MessageEvent<ColorAlphaSplitterWorkerRequest>) => {
+		const { id, sourceFrame } = event.data;
+		chain = chain.then(async () => {
+			try {
+				const { colorFrame, alphaFrame } = await split(sourceFrame);
+				self.postMessage({ id, colorFrame, alphaFrame }, { transfer: [colorFrame, alphaFrame] });
+			} catch (error) {
+				self.postMessage({ id, error: (error as Error).message });
+			} finally {
+				sourceFrame.close();
+			}
+		});
+	});
+
+	const split = async (sourceFrame: VideoFrame) => {
+		const format = sourceFrame.format as VideoSamplePixelFormat | null;
+		if (!format) {
+			throw new Error('CPU color/alpha splitting requires a known VideoFrame format.');
+		}
+
+		const sourceSize = sourceFrame.allocationSize();
+
+		if (!cpuSourceBuffer || cpuSourceBuffer.byteLength !== sourceSize) {
+			cpuSourceBuffer = new Uint8Array(sourceSize);
+		}
+		await sourceFrame.copyTo(cpuSourceBuffer);
+
+		if (format === 'RGBA' || format === 'BGRA') {
+			return splitInterleavedRgba(cpuSourceBuffer, format, sourceFrame);
+		} else if (
+			format === 'I420A' || format === 'I420AP10' || format === 'I420AP12'
+			|| format === 'I422A' || format === 'I422AP10' || format === 'I422AP12'
+			|| format === 'I444A' || format === 'I444AP10' || format === 'I444AP12'
+		) {
+			return splitPlanarYuvA(cpuSourceBuffer, format, sourceFrame);
+		}
+
+		throw new Error(`CPU color/alpha splitting does not support format '${format}'.`);
+	};
+
+	const splitInterleavedRgba = (
+		source: Uint8Array,
+		format: 'RGBA' | 'BGRA',
+		sourceFrame: VideoFrame,
+	) => {
+		const width = sourceFrame.visibleRect?.width ?? sourceFrame.codedWidth;
+		const height = sourceFrame.visibleRect?.height ?? sourceFrame.codedHeight;
+
+		const pixelCount = width * height;
+		const chromaW = Math.ceil(width / 2);
+		const chromaH = Math.ceil(height / 2);
+		const alphaSize = pixelCount + chromaW * chromaH * 2;
+
+		// Encode alpha as I420: Y = source A bytes, UV = 128
+		const alphaBuffer = new Uint8Array(alphaSize);
+		for (let i = 0, j = 3; i < pixelCount; i++, j += 4) {
+			alphaBuffer[i] = source[j]!;
+		}
+		alphaBuffer.fill(128, pixelCount);
+
+		// Hand the source buffer straight to VideoFrame as RGBX/BGRX so the A bytes are ignored
+		const colorFrame = new VideoFrame(source, {
+			format: format === 'RGBA' ? 'RGBX' : 'BGRX',
+			codedWidth: width,
+			codedHeight: height,
+			timestamp: sourceFrame.timestamp,
+			duration: sourceFrame.duration ?? undefined,
+			// No transfer!
+		});
+		const alphaInit = {
+			format: 'I420' as const,
+			codedWidth: width,
+			codedHeight: height,
+			timestamp: sourceFrame.timestamp,
+			duration: sourceFrame.duration ?? undefined,
+			transfer: [alphaBuffer.buffer],
+		};
+		const alphaFrame = new VideoFrame(alphaBuffer, alphaInit);
+		return { colorFrame, alphaFrame };
+	};
+
+	const splitPlanarYuvA = (
+		source: Uint8Array,
+		format:
+			| 'I420A' | 'I420AP10' | 'I420AP12'
+			| 'I422A' | 'I422AP10' | 'I422AP12'
+			| 'I444A' | 'I444AP10' | 'I444AP12',
+		sourceFrame: VideoFrame,
+	) => {
+		const width = sourceFrame.visibleRect?.width ?? sourceFrame.codedWidth;
+		const height = sourceFrame.visibleRect?.height ?? sourceFrame.codedHeight;
+
+		const is10 = format.includes('P10');
+		const is12 = format.includes('P12');
+		const bytesPerSample = (is10 || is12) ? 2 : 1;
+
+		let chromaW: number;
+		let chromaH: number;
+		if (format.startsWith('I420')) {
+			chromaW = Math.ceil(width / 2);
+			chromaH = Math.ceil(height / 2);
+		} else if (format.startsWith('I422')) {
+			chromaW = Math.ceil(width / 2);
+			chromaH = height;
+		} else {
+			chromaW = width;
+			chromaH = height;
+		}
+
+		const ySamples = width * height;
+		const uvSamples = chromaW * chromaH;
+		const yBytes = ySamples * bytesPerSample;
+		const uvBytes = uvSamples * bytesPerSample;
+		const aBytes = ySamples * bytesPerSample;
+
+		const colorBytes = yBytes + uvBytes * 2;
+		const colorFormat = format.replace('A', '') as VideoPixelFormat;
+
+		const alphaChromaW = Math.ceil(width / 2);
+		const alphaChromaH = Math.ceil(height / 2);
+		const alphaUvSamples = alphaChromaW * alphaChromaH;
+		const alphaUvBytes = alphaUvSamples * bytesPerSample;
+		const alphaSize = aBytes + 2 * alphaUvBytes;
+		const alphaBuffer = new Uint8Array(alphaSize);
+
+		const aPlaneStart = colorBytes;
+		alphaBuffer.set(source.subarray(aPlaneStart, aPlaneStart + aBytes), 0);
+
+		// Fill UV planes with the neutral chroma value
+		const uvOffset = aBytes;
+		const neutralChroma = is10 ? 512 : (is12 ? 2048 : 128);
+
+		if (bytesPerSample === 1) {
+			alphaBuffer.fill(neutralChroma, uvOffset);
+		} else {
+			const uvView = new Uint16Array(alphaBuffer.buffer, uvOffset, 2 * alphaUvSamples);
+			uvView.fill(neutralChroma);
+		}
+
+		const alphaFormat = (is10 ? 'I420P10' : (is12 ? 'I420P12' : 'I420')) as VideoPixelFormat;
+
+		// Color frame is simply a prefix of the combined bytes
+		const colorFrame = new VideoFrame(source.subarray(0, colorBytes), {
+			format: colorFormat,
+			codedWidth: width,
+			codedHeight: height,
+			timestamp: sourceFrame.timestamp,
+			duration: sourceFrame.duration ?? undefined,
+		});
+		const alphaInit = {
+			format: alphaFormat,
+			codedWidth: width,
+			codedHeight: height,
+			timestamp: sourceFrame.timestamp,
+			duration: sourceFrame.duration ?? undefined,
+			transfer: [alphaBuffer.buffer],
+		};
+		const alphaFrame = new VideoFrame(alphaBuffer, alphaInit);
+		return { colorFrame, alphaFrame };
+	};
+};
+
+/**
+ * This source can be used to add raw, unencoded video samples (frames) to an output video track. These frames will
+ * automatically be encoded and then piped into the output.
+ * @group Media sources
+ * @public
+ */
+export class VideoSampleSource extends VideoSource {
+	/** @internal */
+	private _encoder: VideoEncoderWrapper;
+
+	/**
+	 * Creates a new {@link VideoSampleSource} whose samples are encoded according to the specified
+	 * {@link VideoEncodingConfig}.
+	 */
+	constructor(encodingConfig: VideoEncodingConfig) {
+		validateVideoEncodingConfig(encodingConfig);
+
+		super(encodingConfig.codec);
+		this._encoder = new VideoEncoderWrapper(this, encodingConfig);
+	}
+
+	/**
+	 * Encodes a video sample (frame) and then adds it to the output.
+	 *
+	 * @returns A Promise that resolves once the output is ready to receive more samples. You should await this Promise
+	 * to respect writer and encoder backpressure.
+	 */
+	add(videoSample: VideoSample, encodeOptions?: VideoEncoderEncodeOptions) {
+		if (!(videoSample instanceof VideoSample)) {
+			throw new TypeError('videoSample must be a VideoSample.');
+		}
+
+		return this._encoder.add(videoSample, false, encodeOptions);
+	}
+
+	/** @internal */
+	override _flushAndClose(forceClose: boolean) {
+		return this._encoder.flushAndClose(forceClose);
+	}
+}
+
+/**
+ * This source can be used to add video frames to the output track from a fixed canvas element. Since canvases are often
+ * used for rendering, this source provides a convenient wrapper around {@link VideoSampleSource}.
+ * @group Media sources
+ * @public
+ */
+export class CanvasSource extends VideoSource {
+	/** @internal */
+	private _encoder: VideoEncoderWrapper;
+	/** @internal */
+	private _canvas: HTMLCanvasElement | OffscreenCanvas;
+
+	/**
+	 * Creates a new {@link CanvasSource} from a canvas element or `OffscreenCanvas` whose samples are encoded
+	 * according to the specified {@link VideoEncodingConfig}.
+	 */
+	constructor(canvas: HTMLCanvasElement | OffscreenCanvas, encodingConfig: VideoEncodingConfig) {
+		if (
+			!(typeof HTMLCanvasElement !== 'undefined' && canvas instanceof HTMLCanvasElement)
+			&& !(typeof OffscreenCanvas !== 'undefined' && canvas instanceof OffscreenCanvas)
+		) {
+			throw new TypeError('canvas must be an HTMLCanvasElement or OffscreenCanvas.');
+		}
+		validateVideoEncodingConfig(encodingConfig);
+
+		super(encodingConfig.codec);
+		this._encoder = new VideoEncoderWrapper(this, encodingConfig);
+		this._canvas = canvas;
+	}
+
+	/**
+	 * Captures the current canvas state as a video sample (frame), encodes it and adds it to the output.
+	 *
+	 * @param timestamp - The timestamp of the sample, in seconds.
+	 * @param duration - The duration of the sample, in seconds.
+	 *
+	 * @returns A Promise that resolves once the output is ready to receive more samples. You should await this Promise
+	 * to respect writer and encoder backpressure.
+	 */
+	add(timestamp: number, duration = 0, encodeOptions?: VideoEncoderEncodeOptions) {
+		if (!Number.isFinite(timestamp) || timestamp < 0) {
+			throw new TypeError('timestamp must be a non-negative number.');
+		}
+		if (!Number.isFinite(duration) || duration < 0) {
+			throw new TypeError('duration must be a non-negative number.');
+		}
+
+		const sample = new VideoSample(this._canvas, { timestamp, duration });
+		return this._encoder.add(sample, true, encodeOptions);
+	}
+
+	/** @internal */
+	override _flushAndClose(forceClose: boolean) {
+		return this._encoder.flushAndClose(forceClose);
+	}
+}
+
+/**
+ * Options for {@link MediaStreamVideoTrackSource}.
+ * @group Media sources
+ * @public
+ */
+export type MediaStreamVideoTrackSourceOptions = {
+	/**
+	 * The frame rate at which the underlying video track is sampled. Defaults to the frame rate specified in the
+	 * track's [`MediaTrackSettings`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackSettings). Set to
+	 * `null` to only add a frame whenever the underlying track pushes one - this minimizes frame count but can
+	 * lead to wildly irregular FPS.
+	 */
+	frameRate?: number | null;
+	/**
+	 * Controls the basis (zero point) for video frame timestamps.
+	 *
+	 * When set to `'synced-zero'`, timestamps will be relative to the first chunk of media from a `MediaStreamTrack`
+	 * added to the {@link Output}.
+	 *
+	 * When set to `'zero'`, timestamps will be relative to the first video frame emitted by this source.
+	 *
+	 * When set to `'unix'`, timestamps will be relative to the Unix epoch, so clearly associated with a distinct point
+	 * in time. Here, pausing via {@link MediaStreamVideoTrackSource.pause} will also create gaps in timestamps. Be sure
+	 * to pair this mode with {@link BaseTrackMetadata.isRelativeToUnixEpoch}.
+	 *
+	 * Defaults to `'synced-zero'`.
+	 */
+	timestampBase?: 'synced-zero' | 'zero' | 'unix';
+};
+
+/**
+ * Video source that encodes the frames of a
+ * [`MediaStreamVideoTrack`](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack) and pipes them into the
+ * output. This is useful for capturing live or real-time data such as webcams or screen captures. Frames will
+ * automatically start being captured once the connected {@link Output} is started, and will keep being captured until
+ * the {@link Output} is finalized or this source is closed.
+ * @group Media sources
+ * @public
+ */
+export class MediaStreamVideoTrackSource extends VideoSource {
+	/** @internal */
+	private _options: MediaStreamVideoTrackSourceOptions;
+	/** @internal */
+	private _encoder: VideoEncoderWrapper;
+	/** @internal */
+	private _abortController: AbortController | null = null;
+	/** @internal */
+	private _track: MediaStreamVideoTrack;
+	/** @internal */
+	private _workerTrackId: number | null = null;
+	/** @internal */
+	private _workerListener: ((event: MessageEvent) => void) | null = null;
+	/** @internal */
+	private _promiseWithResolvers = promiseWithResolvers();
+	/** @internal */
+	private _errorPromiseAccessed = false;
+	/** @internal */
+	private _paused = false;
+	/** @internal */
+	private _lastVideoFrame: VideoFrame | null = null;
+	/** @internal */
+	private _timerHandle: UnthrottledTimerHandle | null = null;
+	/** @internal */
+	private _videoElement: HTMLVideoElement | null = null;
+
+	/** A promise that rejects upon any error within this source. This promise never resolves. */
+	get errorPromise() {
+		this._errorPromiseAccessed = true;
+		return this._promiseWithResolvers.promise;
+	}
+
+	/** Whether this source is currently paused as a result of calling `.pause()`. */
+	get paused() {
+		return this._paused;
+	}
+
+	/**
+	 * Creates a new {@link MediaStreamVideoTrackSource} from a
+	 * [`MediaStreamVideoTrack`](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack), which will pull
+	 * video samples from the stream in real time and encode them according to {@link VideoEncodingConfig}.
+	 */
+	constructor(
+		track: MediaStreamVideoTrack,
+		encodingConfig: VideoEncodingConfig,
+		options: MediaStreamVideoTrackSourceOptions = {},
+	) {
+		if (!(track instanceof MediaStreamTrack) || track.kind !== 'video') {
+			throw new TypeError('track must be a video MediaStreamTrack.');
+		}
+		validateVideoEncodingConfig(encodingConfig);
+		if (typeof options !== 'object' || !options) {
+			throw new TypeError('options must be an object.');
+		}
+		if (options.frameRate != null && (typeof options.frameRate !== 'number' || options.frameRate <= 0)) {
+			throw new TypeError('options.frameRate, when provided, must be either a positive number or null.');
+		}
+		if (
+			options.timestampBase !== undefined
+			&& options.timestampBase !== 'synced-zero'
+			&& options.timestampBase !== 'zero'
+			&& options.timestampBase !== 'unix'
+		) {
+			throw new TypeError(
+				'options.timestampBase, when provided, must be one of \'synced-zero\', \'zero\', or \'unix\'.',
+			);
+		}
+
+		encodingConfig = {
+			...encodingConfig,
+			latencyMode: 'realtime',
+		};
+
+		super(encodingConfig.codec);
+
+		this._options = options;
+		this._encoder = new VideoEncoderWrapper(this, encodingConfig);
+		this._track = track;
+	}
+
+	/** @internal */
+	override async _start() {
+		if (!this._errorPromiseAccessed) {
+			Logging._warn(
+				'Make sure not to ignore the `errorPromise` field on MediaStreamVideoTrackSource, so that any internal'
+				+ ' errors get bubbled up properly.',
+			);
+		}
+
+		const frameRate = this._options.frameRate !== undefined
+			? this._options.frameRate
+			: (this._track.getSettings().frameRate ?? null);
+
+		this._abortController = new AbortController();
+
+		let firstVideoFrameTimestamp: number | null = null;
+		let lastFrameTime: number | null = null;
+		let frameCount = 0;
+		let errored = false;
+		let lastSampleTimestamp: number | null = null;
+		let timestampOffset = 0;
+
+		const tick = () => {
+			assert(frameRate !== null);
+
+			if (!this._lastVideoFrame) {
+				return;
+			}
+
+			assert(lastFrameTime !== null);
+			assert(firstVideoFrameTimestamp !== null);
+
+			const now = performance.now();
+
+			// Add as many frames as warranted by the elapsed time.
+			// > instead of >= intentionally because tick() is called before the _lastVideoFrame is changed
+			while (now - lastFrameTime > 1000 / frameRate) {
+				lastFrameTime += 1000 / frameRate;
+				const timestamp = firstVideoFrameTimestamp + frameCount / frameRate;
+
+				const frame = new VideoFrame(this._videoElement ?? this._lastVideoFrame, {
+					timestamp: 1e6 * timestamp,
+					duration: 1e6 / frameRate,
+				});
+
+				addVideoFrame(frame, now);
+			}
+		};
+
+		if (frameRate !== null) {
+			this._timerHandle = setIntervalUnthrottled(tick, 4); // Run it at 250 Hz
+		}
+
+		const onVideoFrame = (videoFrame: VideoFrame) => {
+			if (frameRate === null) {
+				addVideoFrame(videoFrame);
+			} else {
+				const now = performance.now();
+
+				if (!this._lastVideoFrame) {
+					addVideoFrame(videoFrame.clone(), now);
+					lastFrameTime = now;
+					this._lastVideoFrame = videoFrame;
+				} else {
+					tick();
+					this._lastVideoFrame?.close();
+					this._lastVideoFrame = videoFrame;
+				}
+			}
+		};
+
+		const addVideoFrame = (videoFrame: VideoFrame, now = performance.now()) => {
+			if (errored) {
+				videoFrame.close();
+				return;
+			}
+
+			frameCount++;
+			const currentTimestamp = videoFrame.timestamp / 1e6;
+
+			if (this._paused) {
+				const frameSeen = firstVideoFrameTimestamp !== null;
+				if (frameSeen) {
+					if (lastSampleTimestamp !== null && this._options.timestampBase !== 'unix') {
+						// In addition to dropping this frame, let's also keep track of the time we have lost due to the
+						// pause. Doing it like this instead of simply keeping track of the paused time is better since
+						// it retains the frame rate of the underlying source.
+						const timeDelta = currentTimestamp - lastSampleTimestamp;
+						timestampOffset -= timeDelta;
+					}
+					lastSampleTimestamp = currentTimestamp;
+				}
+
+				videoFrame.close();
+				return;
+			}
+
+			if (firstVideoFrameTimestamp === null) {
+				firstVideoFrameTimestamp = currentTimestamp;
+
+				let target: number;
+				const timestampBase = this._options.timestampBase ?? 'synced-zero';
+				if (timestampBase === 'unix') {
+					target = Date.now() / 1000;
+				} else if (timestampBase === 'zero') {
+					target = 0;
+				} else {
+					const output = this._connectedTrack!.output;
+					if (output._firstMediaStreamTimestamp === null) {
+						output._firstMediaStreamTimestamp = now / 1000;
+						target = 0;
+					} else {
+						target = now / 1000 - output._firstMediaStreamTimestamp;
+					}
+				}
+
+				timestampOffset = target - firstVideoFrameTimestamp;
+			}
+
+			lastSampleTimestamp = currentTimestamp;
+
+			if (this._encoder.getQueueSize() >= 8) {
+				// Drop frames if the encoder is overloaded
+				videoFrame.close();
+				return;
+			}
+
+			const sample = new VideoSample(videoFrame, {
+				timestamp: currentTimestamp + timestampOffset,
+			});
+
+			void this._encoder.add(sample, true)
+				.catch((error) => {
+					errored = true;
+
+					this._abortController?.abort();
+					this._promiseWithResolvers.reject(error);
+
+					if (this._workerTrackId !== null) {
+						// Tell the worker to stop the track
+						sendMessageToMediaStreamTrackProcessorWorker({
+							type: 'stopTrack',
+							trackId: this._workerTrackId,
+						});
+					}
+				});
+		};
+
+		if (typeof MediaStreamTrackProcessor !== 'undefined') {
+			// We can do it here directly, perfect
+			const processor = new MediaStreamTrackProcessor({ track: this._track });
+			const consumer = new WritableStream<VideoFrame>({ write: onVideoFrame });
+
+			processor.readable.pipeTo(consumer, {
+				signal: this._abortController.signal,
+			}).catch((error) => {
+				// Handle AbortError silently
+				if (error instanceof DOMException && error.name === 'AbortError') return;
+
+				this._promiseWithResolvers.reject(error);
+			});
+		} else {
+			// It might still be supported in a worker, so let's check that
+			const supportedInWorker = await mediaStreamTrackProcessorIsSupportedInWorker();
+
+			if (supportedInWorker) {
+				this._workerTrackId = nextMediaStreamTrackProcessorWorkerId++;
+
+				sendMessageToMediaStreamTrackProcessorWorker({
+					type: 'videoTrack',
+					trackId: this._workerTrackId,
+					track: this._track,
+				});
+
+				this._workerListener = (event: MessageEvent) => {
+					const message = event.data as MediaStreamTrackProcessorWorkerMessage;
+
+					if (message.type === 'videoFrame' && message.trackId === this._workerTrackId) {
+						onVideoFrame(message.videoFrame);
+					} else if (message.type === 'error' && message.trackId === this._workerTrackId) {
+						this._promiseWithResolvers.reject(message.error);
+					}
+				};
+
+				mediaStreamTrackProcessorWorker!.addEventListener('message', this._workerListener);
+			} else if (frameRate !== null) {
+				// No MediaStreamTrackProcessor support at all (e.g. Firefox), but we have a frame rate, so we can
+				// manually sample from a hidden <video> element instead.
+				const video = document.createElement('video');
+				video.style.position = 'fixed';
+				video.style.left = '-10000px';
+				video.style.top = '-10000px';
+				video.style.width = '1px';
+				video.style.height = '1px';
+				video.style.opacity = '0';
+				video.style.pointerEvents = 'none';
+				video.muted = true;
+				video.srcObject = new MediaStream([this._track]);
+				document.body.appendChild(video);
+				this._videoElement = video;
+
+				video.addEventListener('loadeddata', () => {
+					if (errored || !this._videoElement) {
+						return;
+					}
+
+					// This will be the first frame
+					const frame = new VideoFrame(video, {
+						timestamp: 1000 * performance.now(),
+					});
+					onVideoFrame(frame);
+					frame.close();
+				}, { once: true });
+
+				void video.play().catch((error) => {
+					errored = true;
+					this._promiseWithResolvers.reject(error);
+				});
+			} else {
+				throw new Error(
+					'When no explicit frame rate is set, MediaStreamTrackProcessor is required; but it\'s not supported'
+					+ ' by this browser.',
+				);
+			}
+		}
+	}
+
+	/**
+	 * Pauses the capture of video frames - any video frames emitted by the underlying media stream will be ignored
+	 * while paused. This does *not* close the underlying `MediaStreamVideoTrack`, it just ignores its output.
+	 */
+	pause() {
+		this._paused = true;
+	}
+
+	/** Resumes the capture of video frames after being paused. */
+	resume() {
+		this._paused = false;
+	}
+
+	/** @internal */
+	override async _flushAndClose(forceClose: boolean) {
+		if (this._abortController) {
+			this._abortController.abort();
+			this._abortController = null;
+		}
+
+		if (this._timerHandle) {
+			clearIntervalUnthrottled(this._timerHandle);
+		}
+		this._lastVideoFrame?.close();
+
+		if (this._videoElement) {
+			this._videoElement.srcObject = null;
+			this._videoElement.remove();
+			this._videoElement = null;
+		}
+
+		if (this._workerTrackId !== null) {
+			assert(this._workerListener);
+
+			sendMessageToMediaStreamTrackProcessorWorker({
+				type: 'stopTrack',
+				trackId: this._workerTrackId,
+			});
+
+			// Wait for the worker to stop the track
+			await new Promise<void>((resolve) => {
+				const listener = (event: MessageEvent) => {
+					const message = event.data as MediaStreamTrackProcessorWorkerMessage;
+
+					if (message.type === 'trackStopped' && message.trackId === this._workerTrackId) {
+						assert(this._workerListener);
+						mediaStreamTrackProcessorWorker!.removeEventListener('message', this._workerListener);
+						mediaStreamTrackProcessorWorker!.removeEventListener('message', listener);
+
+						resolve();
+					}
+				};
+
+				mediaStreamTrackProcessorWorker!.addEventListener('message', listener);
+			});
+		}
+
+		await this._encoder.flushAndClose(forceClose);
+	}
+}
+
+/**
+ * Base class for audio sources - sources for audio tracks.
+ * @group Media sources
+ * @public
+ */
+export abstract class AudioSource extends MediaSource {
+	/** @internal */
+	override _connectedTrack: OutputAudioTrack | null = null;
+	/** @internal */
+	override readonly _codec: AudioCodec;
+
+	/** Internal constructor. */
+	constructor(codec: AudioCodec) {
+		super();
+
+		if (!AUDIO_CODECS.includes(codec)) {
+			throw new TypeError(`Invalid audio codec '${codec}'. Must be one of: ${AUDIO_CODECS.join(', ')}.`);
+		}
+
+		this._codec = codec;
+	}
+}
+
+/**
+ * The most basic audio source; can be used to directly pipe encoded packets into the output file.
+ * @group Media sources
+ * @public
+ */
+export class EncodedAudioPacketSource extends AudioSource {
+	/** Creates a new {@link EncodedAudioPacketSource} whose packets are encoded using `codec`. */
+	constructor(codec: AudioCodec) {
+		super(codec);
+	}
+
+	/**
+	 * Adds an encoded packet to the output audio track. Packets must be added in *decode order*.
+	 *
+	 * @param meta - Additional metadata from the encoder. You should pass this for the first call, including a valid
+	 * decoder config.
+	 *
+	 * @returns A Promise that resolves once the output is ready to receive more samples. You should await this Promise
+	 * to respect writer and encoder backpressure.
+	 */
+	add(packet: EncodedPacket, meta?: EncodedAudioChunkMetadata) {
+		if (!(packet instanceof EncodedPacket)) {
+			throw new TypeError('packet must be an EncodedPacket.');
+		}
+		if (packet.isMetadataOnly) {
+			throw new TypeError('Metadata-only packets cannot be added.');
+		}
+		if (meta !== undefined && (!meta || typeof meta !== 'object')) {
+			throw new TypeError('meta, when provided, must be an object.');
+		}
+
+		this._ensureValidAdd();
+		return this._connectedTrack!.output._muxer.addEncodedAudioPacket(this._connectedTrack!, packet, meta);
+	}
+}
+
+class AudioEncoderWrapper {
+	private ensureEncoderPromise: Promise<void> | null = null;
+	private encoderInitialized = false;
+	private encoder: AudioEncoder | null = null;
+	private muxer: Muxer | null = null;
+	private lastNumberOfChannels: number | null = null;
+	private lastSampleRate: number | null = null;
+
+	private isPcmEncoder = false;
+	private outputSampleSize: number | null = null;
+	private writeOutputValue: ((view: DataView, byteOffset: number, value: number) => void) | null = null;
+
+	private customEncoder: CustomAudioEncoder | null = null;
+	private customEncoderCallSerializer = new CallSerializer();
+	private customEncoderQueueSize = 0;
+
+	private lastEndSampleIndex: number | null = null;
+
+	private resampler: AudioResampler | null = null;
+
+	/**
+	 * Encoders typically throw their errors "out of band", meaning asynchronously in some other execution context.
+	 * However, we want to surface these errors to the user within the normal control flow, so they don't go uncaught.
+	 * So, we keep track of the encoder error and throw it as soon as we get the chance.
+	 */
+	private error: unknown = null;
+	private errorSet = false;
+
+	private setError(error: unknown) {
+		if (!this.errorSet) {
+			this.error = error;
+			this.errorSet = true;
+		}
+	}
+
+	private lastMuxerPromise: Promise<void> = Promise.resolve();
+	private closed = false;
+
+	constructor(private source: AudioSource, private encodingConfig: AudioEncodingConfig) {}
+
+	async add(audioSample: AudioSample, shouldClose: boolean) {
+		try {
+			this.checkForEncoderError();
+			this.source._ensureValidAdd();
+
+			// Ensure audio parameters remain constant
+			if (this.lastNumberOfChannels !== null && this.lastSampleRate !== null) {
+				if (
+					audioSample.numberOfChannels !== this.lastNumberOfChannels
+					|| audioSample.sampleRate !== this.lastSampleRate
+				) {
+					throw new Error(
+						`Audio parameters must remain constant. Expected ${this.lastNumberOfChannels} channels at`
+						+ ` ${this.lastSampleRate} Hz, got ${audioSample.numberOfChannels} channels at`
+						+ ` ${audioSample.sampleRate} Hz.`,
+					);
+				}
+			} else {
+				this.lastNumberOfChannels = audioSample.numberOfChannels;
+				this.lastSampleRate = audioSample.sampleRate;
+			}
+
+			const config = this.encodingConfig;
+			const needsResample = config.transform?.numberOfChannels !== undefined
+				|| config.transform?.sampleRate !== undefined;
+
+			if (needsResample) {
+				if (!this.resampler) {
+					// Initialize the resampler on first sample
+					this.resampler = new AudioResampler({
+						targetNumberOfChannels: config.transform!.numberOfChannels
+							?? audioSample.numberOfChannels,
+						targetSampleRate: config.transform!.sampleRate
+							?? audioSample.sampleRate,
+						onSample: async (sample) => {
+							await this.processAndEncode(sample, true);
+						},
+					});
+				}
+
+				await this.resampler.add(audioSample);
+			} else {
+				await this.processAndEncode(audioSample, shouldClose);
+			}
+		} finally {
+			if (shouldClose) {
+				audioSample.close();
+			}
+		}
+	}
+
+	/**
+	 * Runs the process function (if any) and encodes the resulting samples.
+	 */
+	private async processAndEncode(audioSample: AudioSample, shouldClose: boolean) {
+		const config = this.encodingConfig;
+
+		if (
+			config.transform?.sampleFormat !== undefined
+			&& toInterleavedAudioFormat(audioSample.format) !== config.transform.sampleFormat
+		) {
+			// Do a sample format conversion
+			const newSample = audioSampleToInterleavedFormat(audioSample, config.transform.sampleFormat);
+
+			if (shouldClose) {
+				audioSample.close();
+			}
+
+			audioSample = newSample;
+			shouldClose = true;
+		}
+
+		if (config.transform?.process) {
+			try {
+				let processed = config.transform.process(audioSample);
+				if (processed instanceof Promise) {
+					processed = await processed;
+				}
+
+				if (processed === null) {
+					return;
+				}
+
+				if (!Array.isArray(processed)) {
+					processed = [processed];
+				}
+
+				try {
+					for (const sample of processed) {
+						if (!(sample instanceof AudioSample)) {
+							throw new TypeError(
+								'The audio process function must return an AudioSample, null, or an array of'
+								+ ' AudioSamples.',
+							);
+						}
+					}
+
+					for (const sample of processed) {
+						await this.encodeSample(sample, true);
+					}
+				} finally {
+					// encodeSample closes the samples it was passed; this additionally covers the samples never
+					// reached because an earlier one threw (closing is idempotent)
+					for (const sample of processed) {
+						if (sample instanceof AudioSample) {
+							sample.close();
+						}
+					}
+				}
+			} finally {
+				if (shouldClose) {
+					audioSample.close();
+				}
+			}
+		} else {
+			await this.encodeSample(audioSample, shouldClose);
+		}
+	}
+
+	/**
+	 * Encodes a single audio sample, handling encoder init, gap padding, and backpressure.
+	 */
+	private async encodeSample(audioSample: AudioSample, shouldClose: boolean) {
+		try {
+			if (!this.encoderInitialized) {
+				if (!this.ensureEncoderPromise) {
+					this.ensureEncoder(audioSample);
+				}
+
+				// No, this "if" statement is not useless. Sometimes, the above call to `ensureEncoder` might have
+				// synchronously completed and the encoder is already initialized. In this case, we don't need to await
+				// the promise anymore. This also fixes nasty async race condition bugs when multiple code paths are
+				// calling this method: It's important that the call that initialized the encoder go through this
+				// code first.
+				if (!this.encoderInitialized) {
+					await this.ensureEncoderPromise;
+				}
+			}
+			assert(this.encoderInitialized);
+
+			if (this.closed) {
+				return;
+			}
+
+			// Handle padding of gaps with silence to avoid audio drift over time, like in
+			// https://github.com/Vanilagy/mediabunny/issues/176
+			// TODO An open question is how encoders deal with the first AudioData having a non-zero timestamp, and with
+			// AudioDatas that have an overlapping timestamp range.
+			{
+				const startSampleIndex = Math.round(
+					audioSample.timestamp * audioSample.sampleRate,
+				);
+				const endSampleIndex = Math.round(
+					(audioSample.timestamp + audioSample.duration) * audioSample.sampleRate,
+				);
+
+				if (this.lastEndSampleIndex === null) {
+					this.lastEndSampleIndex = endSampleIndex;
+				} else {
+					const sampleDiff = startSampleIndex - this.lastEndSampleIndex;
+
+					if (sampleDiff >= 64) {
+						// The gap is big enough, let's add a correction sample
+						const fillSample = new AudioSample({
+							data: new Float32Array(sampleDiff * audioSample.numberOfChannels),
+							format: 'f32-planar',
+							sampleRate: audioSample.sampleRate,
+							numberOfChannels: audioSample.numberOfChannels,
+							numberOfFrames: sampleDiff,
+							timestamp: this.lastEndSampleIndex / audioSample.sampleRate,
+						});
+
+						await this.encodeSample(fillSample, true); // Recursive call
+					}
+
+					this.lastEndSampleIndex += audioSample.numberOfFrames;
+				}
+			}
+
+			this.encodingConfig.onEncodedSample?.(audioSample);
+
+			if (this.customEncoder) {
+				this.customEncoderQueueSize++;
+
+				// We clone the sample so it cannot be closed on us from the outside before it reaches the encoder
+				const clonedSample = audioSample.clone();
+
+				const promise = this.customEncoderCallSerializer
+					.call(() => this.customEncoder!.encode(clonedSample))
+					.catch((error: unknown) => this.setError(error))
+					.finally(() => {
+						this.customEncoderQueueSize--;
+						clonedSample.close();
+					});
+
+				if (this.customEncoderQueueSize >= 4) {
+					await promise;
+				}
+
+				await this.lastMuxerPromise; // Allow the writer to apply backpressure
+			} else if (this.isPcmEncoder) {
+				await this.doPcmEncoding(audioSample, shouldClose);
+			} else {
+				assert(this.encoder);
+				const audioData = audioSample.toAudioData();
+				this.encoder.encode(audioData);
+				audioData.close();
+
+				if (shouldClose) {
+					audioSample.close();
+				}
+
+				if (this.encoder.encodeQueueSize >= 4) {
+					await new Promise(resolve => this.encoder!.addEventListener('dequeue', resolve, { once: true }));
+				}
+
+				await this.lastMuxerPromise; // Allow the writer to apply backpressure
+			}
+		} finally {
+			if (shouldClose) {
+				audioSample.close();
+			}
+		}
+	}
+
+	private async doPcmEncoding(audioSample: AudioSample, shouldClose: boolean) {
+		assert(this.outputSampleSize);
+		assert(this.writeOutputValue);
+
+		// Need to extract data from the audio data before we close it
+		const { numberOfChannels, numberOfFrames, sampleRate, timestamp } = audioSample;
+
+		const CHUNK_SIZE = 2048;
+		const outputs: {
+			frameCount: number;
+			view: DataView;
+		}[] = [];
+
+		// Prepare all of the output buffers, each being bounded by CHUNK_SIZE so we don't generate huge packets
+		for (let frame = 0; frame < numberOfFrames; frame += CHUNK_SIZE) {
+			const frameCount = Math.min(CHUNK_SIZE, audioSample.numberOfFrames - frame);
+			const outputSize = frameCount * numberOfChannels * this.outputSampleSize;
+			const outputBuffer = new ArrayBuffer(outputSize);
+			const outputView = new DataView(outputBuffer);
+
+			outputs.push({ frameCount, view: outputView });
+		}
+
+		const allocationSize = audioSample.allocationSize(({ planeIndex: 0, format: 'f32-planar' }));
+		const floats = new Float32Array(allocationSize / Float32Array.BYTES_PER_ELEMENT);
+
+		for (let i = 0; i < numberOfChannels; i++) {
+			audioSample.copyTo(floats, { planeIndex: i, format: 'f32-planar' });
+
+			for (let j = 0; j < outputs.length; j++) {
+				const { frameCount, view } = outputs[j]!;
+
+				for (let k = 0; k < frameCount; k++) {
+					this.writeOutputValue(
+						view,
+						(k * numberOfChannels + i) * this.outputSampleSize,
+						floats[j * CHUNK_SIZE + k]!,
+					);
+				}
+			}
+		}
+
+		if (shouldClose) {
+			audioSample.close();
+		}
+
+		const meta: EncodedAudioChunkMetadata = {
+			decoderConfig: {
+				codec: this.encodingConfig.codec,
+				numberOfChannels,
+				sampleRate,
+			},
+		};
+
+		for (let i = 0; i < outputs.length; i++) {
+			const { frameCount, view } = outputs[i]!;
+			const outputBuffer = view.buffer;
+			const startFrame = i * CHUNK_SIZE;
+
+			const packet = new EncodedPacket(
+				new Uint8Array(outputBuffer),
+				'key',
+				timestamp + startFrame / sampleRate,
+				frameCount / sampleRate,
+			);
+
+			this.encodingConfig.onEncodedPacket?.(packet, meta);
+			await this.muxer!.addEncodedAudioPacket(this.source._connectedTrack!, packet, meta); // With backpressure
+		}
+	}
+
+	private ensureEncoder(audioSample: AudioSample) {
+		this.ensureEncoderPromise = (async () => {
+			const { numberOfChannels, sampleRate } = audioSample;
+
+			// eslint-disable-next-line @typescript-eslint/no-deprecated
+			const quality = resolveQuality(this.encodingConfig.quality, this.encodingConfig.bitrate);
+
+			const encoderConfig = buildAudioEncoderConfig({
+				numberOfChannels,
+				sampleRate,
+				...this.encodingConfig,
+				quality,
+			});
+			this.encodingConfig.onEncoderConfig?.(encoderConfig);
+
+			const MatchingCustomEncoder = customAudioEncoders.find(x => x.supports(
+				this.encodingConfig.codec,
+				encoderConfig,
+			));
+
+			if (MatchingCustomEncoder) {
+				// @ts-expect-error "Can't create instance of abstract class 🤓"
+				this.customEncoder = new MatchingCustomEncoder() as CustomAudioEncoder;
+				// @ts-expect-error It's technically readonly
+				this.customEncoder.codec = this.encodingConfig.codec;
+				// @ts-expect-error It's technically readonly
+				this.customEncoder.config = encoderConfig;
+				// @ts-expect-error It's technically readonly
+				this.customEncoder.onPacket = (packet, meta) => {
+					if (!(packet instanceof EncodedPacket)) {
+						throw new TypeError('The first argument passed to onPacket must be an EncodedPacket.');
+					}
+					if (meta !== undefined && (!meta || typeof meta !== 'object')) {
+						throw new TypeError('The second argument passed to onPacket must be an object or undefined.');
+					}
+
+					this.encodingConfig.onEncodedPacket?.(packet, meta);
+					this.lastMuxerPromise
+						= this.muxer!.addEncodedAudioPacket(this.source._connectedTrack!, packet, meta)
+							.catch((error) => {
+								this.setError(error);
+							});
+				};
+				// @ts-expect-error It's technically readonly
+				this.customEncoder.onError = (error) => {
+					this.setError(error);
+				};
+
+				await this.customEncoder.init();
+			} else if ((PCM_AUDIO_CODECS as readonly string[]).includes(this.encodingConfig.codec)) {
+				this.initPcmEncoder();
+			} else {
+				if (typeof AudioEncoder === 'undefined') {
+					throw new Error('AudioEncoder is not supported by this browser.');
+				}
+
+				const support = await AudioEncoder.isConfigSupported(encoderConfig);
+				if (!support.supported) {
+					throw new Error(
+						`This specific encoder configuration (${encoderConfig.codec}, ${encoderConfig.bitrate} bps,`
+						+ ` ${encoderConfig.numberOfChannels} channels, ${encoderConfig.sampleRate} Hz) is not`
+						+ ` supported by this browser. Consider using another codec or changing your audio parameters.`,
+					);
+				}
+
+				const stack = new Error('Encoding error').stack;
+
+				this.encoder = new AudioEncoder({
+					output: (chunk, meta) => {
+						// WebKit emits an invalid description for AAC (https://bugs.webkit.org/show_bug.cgi?id=302253),
+						// which we try to detect here. If detected, we'll provide our own description instead, derived
+						// from the codec string and audio parameters.
+						if (this.encodingConfig.codec === 'aac' && meta?.decoderConfig) {
+							let needsDescriptionOverwrite = false;
+							if (!meta.decoderConfig.description || meta.decoderConfig.description.byteLength < 2) {
+								needsDescriptionOverwrite = true;
+							} else {
+								const audioSpecificConfig = parseAacAudioSpecificConfig(
+									toUint8Array(meta.decoderConfig.description),
+								);
+
+								needsDescriptionOverwrite = audioSpecificConfig.objectType === 0;
+							}
+
+							if (needsDescriptionOverwrite) {
+								const objectType = Number(last(encoderConfig.codec.split('.')));
+
+								meta.decoderConfig.description = buildAacAudioSpecificConfig({
+									objectType,
+									numberOfChannels: meta.decoderConfig.numberOfChannels,
+									sampleRate: meta.decoderConfig.sampleRate,
+								});
+							}
+						}
+
+						let packet = EncodedPacket.fromEncodedChunk(chunk);
+
+						// Snap the timing information to the sample rate to recover information lost in microsecond
+						// conversion
+						packet = packet.clone({
+							timestamp: roundToDivisor(packet.timestamp, encoderConfig.sampleRate),
+							duration: chunk.duration != null
+								? roundToDivisor(packet.duration, encoderConfig.sampleRate)
+								: undefined,
+						});
+
+						this.encodingConfig.onEncodedPacket?.(packet, meta);
+						this.lastMuxerPromise
+							= this.muxer!.addEncodedAudioPacket(this.source._connectedTrack!, packet, meta)
+								.catch((error) => {
+									this.setError(error);
+								});
+					},
+					error: (error) => {
+						error.stack = stack; // Provide a more useful stack trace
+						this.setError(error);
+					},
+				});
+				this.encoder.configure(encoderConfig);
+			}
+
+			assert(this.source._connectedTrack);
+			this.muxer = this.source._connectedTrack.output._muxer;
+
+			this.encoderInitialized = true;
+		})();
+	}
+
+	private initPcmEncoder() {
+		this.isPcmEncoder = true;
+
+		const codec = this.encodingConfig.codec as PcmAudioCodec;
+		const { dataType, sampleSize, littleEndian } = parsePcmCodec(codec);
+
+		this.outputSampleSize = sampleSize;
+
+		// All these functions receive a float sample as input and map it into the desired format
+
+		switch (sampleSize) {
+			case 1: {
+				if (dataType === 'unsigned') {
+					this.writeOutputValue = (view, byteOffset, value) =>
+						view.setUint8(byteOffset, clamp((value + 1) * 127.5, 0, 255));
+				} else if (dataType === 'signed') {
+					this.writeOutputValue = (view, byteOffset, value) => {
+						view.setInt8(byteOffset, clamp(Math.round(value * 128), -128, 127));
+					};
+				} else if (dataType === 'ulaw') {
+					this.writeOutputValue = (view, byteOffset, value) => {
+						const int16 = clamp(Math.floor(value * 32767), -32768, 32767);
+						view.setUint8(byteOffset, toUlaw(int16));
+					};
+				} else if (dataType === 'alaw') {
+					this.writeOutputValue = (view, byteOffset, value) => {
+						const int16 = clamp(Math.floor(value * 32767), -32768, 32767);
+						view.setUint8(byteOffset, toAlaw(int16));
+					};
+				} else {
+					assert(false);
+				}
+			}; break;
+			case 2: {
+				if (dataType === 'unsigned') {
+					this.writeOutputValue = (view, byteOffset, value) =>
+						view.setUint16(byteOffset, clamp((value + 1) * 32767.5, 0, 65535), littleEndian);
+				} else if (dataType === 'signed') {
+					this.writeOutputValue = (view, byteOffset, value) =>
+						view.setInt16(byteOffset, clamp(Math.round(value * 32767), -32768, 32767), littleEndian);
+				} else {
+					assert(false);
+				}
+			}; break;
+			case 3: {
+				if (dataType === 'unsigned') {
+					this.writeOutputValue = (view, byteOffset, value) =>
+						setUint24(view, byteOffset, clamp((value + 1) * 8388607.5, 0, 16777215), littleEndian);
+				} else if (dataType === 'signed') {
+					this.writeOutputValue = (view, byteOffset, value) =>
+						setInt24(
+							view,
+							byteOffset,
+							clamp(Math.round(value * 8388607), -8388608, 8388607),
+							littleEndian,
+						);
+				} else {
+					assert(false);
+				}
+			}; break;
+			case 4: {
+				if (dataType === 'unsigned') {
+					this.writeOutputValue = (view, byteOffset, value) =>
+						view.setUint32(byteOffset, clamp((value + 1) * 2147483647.5, 0, 4294967295), littleEndian);
+				} else if (dataType === 'signed') {
+					this.writeOutputValue = (view, byteOffset, value) =>
+						view.setInt32(
+							byteOffset,
+							clamp(Math.round(value * 2147483647), -2147483648, 2147483647),
+							littleEndian,
+						);
+				} else if (dataType === 'float') {
+					this.writeOutputValue = (view, byteOffset, value) =>
+						view.setFloat32(byteOffset, value, littleEndian);
+				} else {
+					assert(false);
+				}
+			}; break;
+			case 8: {
+				if (dataType === 'float') {
+					this.writeOutputValue = (view, byteOffset, value) =>
+						view.setFloat64(byteOffset, value, littleEndian);
+				} else {
+					assert(false);
+				}
+			}; break;
+			default: {
+				assertNever(sampleSize);
+				assert(false);
+			};
+		}
+	}
+
+	async flushAndClose(forceClose: boolean) {
+		try {
+			if (!forceClose) {
+				this.checkForEncoderError();
+
+				// Finalize the resampler to flush any buffered audio
+				if (this.resampler) {
+					await this.resampler.finalize();
+				}
+			}
+
+			this.closed = true;
+
+			if (!forceClose) {
+				if (this.customEncoder) {
+					void this.customEncoderCallSerializer.call(() => this.customEncoder!.flush());
+				} else if (this.encoder) {
+					await this.encoder.flush();
+				}
+			}
+		} finally {
+			// This cleanup must also run when flushing threw (e.g. due to an encoder error), otherwise the encoder
+			// would be left dangling
+			this.closed = true;
+			this.resampler = null;
+
+			if (this.customEncoder) {
+				await this.customEncoderCallSerializer.call(() => this.customEncoder!.close())
+					.catch((error: unknown) => this.setError(error));
+			} else if (this.encoder && this.encoder.state !== 'closed') {
+				this.encoder.close();
+			}
+		}
+
+		if (!forceClose) {
+			this.checkForEncoderError();
+		}
+	}
+
+	getQueueSize() {
+		if (this.customEncoder) {
+			return this.customEncoderQueueSize;
+		} else if (this.isPcmEncoder) {
+			return 0;
+		} else {
+			return this.encoder?.encodeQueueSize ?? 0;
+		}
+	}
+
+	checkForEncoderError() {
+		if (this.errorSet) {
+			throw this.error;
+		}
+	}
+}
+
+/**
+ * This source can be used to add raw, unencoded audio samples to an output audio track. These samples will
+ * automatically be encoded and then piped into the output.
+ * @group Media sources
+ * @public
+ */
+export class AudioSampleSource extends AudioSource {
+	/** @internal */
+	private _encoder: AudioEncoderWrapper;
+
+	/**
+	 * Creates a new {@link AudioSampleSource} whose samples are encoded according to the specified
+	 * {@link AudioEncodingConfig}.
+	 */
+	constructor(encodingConfig: AudioEncodingConfig) {
+		validateAudioEncodingConfig(encodingConfig);
+
+		super(encodingConfig.codec);
+		this._encoder = new AudioEncoderWrapper(this, encodingConfig);
+	}
+
+	/**
+	 * Encodes an audio sample and then adds it to the output.
+	 *
+	 * @returns A Promise that resolves once the output is ready to receive more samples. You should await this Promise
+	 * to respect writer and encoder backpressure.
+	 */
+	add(audioSample: AudioSample) {
+		if (!(audioSample instanceof AudioSample)) {
+			throw new TypeError('audioSample must be an AudioSample.');
+		}
+
+		return this._encoder.add(audioSample, false);
+	}
+
+	/** @internal */
+	override _flushAndClose(forceClose: boolean) {
+		return this._encoder.flushAndClose(forceClose);
+	}
+}
+
+/**
+ * This source can be used to add audio data from an AudioBuffer to the output track. This is useful when working with
+ * the Web Audio API.
+ * @group Media sources
+ * @public
+ */
+export class AudioBufferSource extends AudioSource {
+	/** @internal */
+	private _encoder: AudioEncoderWrapper;
+	/** @internal */
+	private _accumulatedTime = 0;
+
+	/**
+	 * Creates a new {@link AudioBufferSource} whose `AudioBuffer` instances are encoded according to the specified
+	 * {@link AudioEncodingConfig}.
+	 */
+	constructor(encodingConfig: AudioEncodingConfig) {
+		validateAudioEncodingConfig(encodingConfig);
+
+		super(encodingConfig.codec);
+		this._encoder = new AudioEncoderWrapper(this, encodingConfig);
+	}
+
+	/**
+	 * Converts an AudioBuffer to audio samples, encodes them and adds them to the output. The first AudioBuffer will
+	 * be played at timestamp 0, and any subsequent AudioBuffer will have a timestamp equal to the total duration of
+	 * all previous AudioBuffers.
+	 *
+	 * @returns A Promise that resolves once the output is ready to receive more samples. You should await this Promise
+	 * to respect writer and encoder backpressure.
+	 */
+	async add(audioBuffer: AudioBuffer) {
+		if (!(audioBuffer instanceof AudioBuffer)) {
+			throw new TypeError('audioBuffer must be an AudioBuffer.');
+		}
+
+		const iterator = AudioSample._fromAudioBuffer(audioBuffer, this._accumulatedTime);
+		this._accumulatedTime += audioBuffer.duration;
+
+		for (const audioSample of iterator) {
+			await this._encoder.add(audioSample, true);
+		}
+	}
+
+	/** @internal */
+	override _flushAndClose(forceClose: boolean) {
+		return this._encoder.flushAndClose(forceClose);
+	}
+}
+
+/**
+ * Options for {@link MediaStreamAudioTrackSource}.
+ * @group Media sources
+ * @public
+ */
+export type MediaStreamAudioTrackSourceOptions = {
+	/**
+	 * Controls the basis (zero point) for audio sample timestamps.
+	 *
+	 * When set to `'synced-zero'`, timestamps will be relative to the first chunk of media from a `MediaStreamTrack`
+	 * added to the {@link Output}.
+	 *
+	 * When set to `'zero'`, timestamps will be relative to the first audio sample emitted by this source.
+	 *
+	 * When set to `'unix'`, timestamps will be relative to the Unix epoch, so clearly associated with a distinct point
+	 * in time. Here, pausing via {@link MediaStreamAudioTrackSource.pause} will also create gaps in timestamps. Be sure
+	 * to pair this mode with {@link BaseTrackMetadata.isRelativeToUnixEpoch}.
+	 *
+	 * Defaults to `'synced-zero'`.
+	 */
+	timestampBase?: 'synced-zero' | 'zero' | 'unix';
+};
+
+/**
+ * Audio source that encodes the data of a
+ * [`MediaStreamAudioTrack`](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack) and pipes it into the
+ * output. This is useful for capturing live or real-time audio such as microphones or audio from other media elements.
+ * Audio will automatically start being captured once the connected {@link Output} is started, and will keep being
+ * captured until the {@link Output} is finalized or this source is closed.
+ * @group Media sources
+ * @public
+ */
+export class MediaStreamAudioTrackSource extends AudioSource {
+	/** @internal */
+	private _options: MediaStreamAudioTrackSourceOptions;
+	/** @internal */
+	private _encoder: AudioEncoderWrapper;
+	/** @internal */
+	private _abortController: AbortController | null = null;
+	/** @internal */
+	private _track: MediaStreamAudioTrack;
+	/** @internal */
+	private _audioContext: AudioContext | null = null;
+	/** @internal */
+	// eslint-disable-next-line @typescript-eslint/no-deprecated
+	private _scriptProcessorNode: ScriptProcessorNode | null = null; // Deprecated but goated
+	/** @internal */
+	private _promiseWithResolvers = promiseWithResolvers();
+	/** @internal */
+	private _errorPromiseAccessed = false;
+	/** @internal */
+	private _paused = false;
+
+	/** A promise that rejects upon any error within this source. This promise never resolves. */
+	get errorPromise() {
+		this._errorPromiseAccessed = true;
+		return this._promiseWithResolvers.promise;
+	}
+
+	/** Whether this source is currently paused as a result of calling `.pause()`. */
+	get paused() {
+		return this._paused;
+	}
+
+	/**
+	 * Creates a new {@link MediaStreamAudioTrackSource} from a `MediaStreamAudioTrack`, which will pull audio samples
+	 * from the stream in real time and encode them according to {@link AudioEncodingConfig}.
+	 */
+	constructor(
+		track: MediaStreamAudioTrack,
+		encodingConfig: AudioEncodingConfig,
+		options: MediaStreamAudioTrackSourceOptions = {},
+	) {
+		if (!(track instanceof MediaStreamTrack) || track.kind !== 'audio') {
+			throw new TypeError('track must be an audio MediaStreamTrack.');
+		}
+		validateAudioEncodingConfig(encodingConfig);
+		if (typeof options !== 'object' || !options) {
+			throw new TypeError('options must be an object.');
+		}
+		if (
+			options.timestampBase !== undefined
+			&& options.timestampBase !== 'synced-zero'
+			&& options.timestampBase !== 'zero'
+			&& options.timestampBase !== 'unix'
+		) {
+			throw new TypeError(
+				'options.timestampBase, when provided, must be one of \'synced-zero\', \'zero\', or \'unix\'.',
+			);
+		}
+
+		super(encodingConfig.codec);
+		this._options = options;
+		this._encoder = new AudioEncoderWrapper(this, encodingConfig);
+		this._track = track;
+	}
+
+	/** @internal */
+	override async _start() {
+		if (!this._errorPromiseAccessed) {
+			Logging._warn(
+				'Make sure not to ignore the `errorPromise` field on MediaStreamAudioTrackSource, so that any internal'
+				+ ' errors get bubbled up properly.',
+			);
+		}
+
+		this._abortController = new AbortController();
+
+		let firstAudioDataTimestamp: number | null = null;
+		let errored = false;
+		let lastSampleTimestamp: number | null = null;
+		let timestampOffset = 0;
+
+		const onAudioSample = (audioSample: AudioSample) => {
+			if (errored) {
+				audioSample.close();
+				return;
+			}
+
+			const currentTimestamp = audioSample.timestamp;
+
+			if (this._paused) {
+				const dataSeen = firstAudioDataTimestamp !== null;
+				if (dataSeen) {
+					if (lastSampleTimestamp !== null && this._options.timestampBase !== 'unix') {
+						// In addition to dropping this sample, let's also keep track of the time we have lost due to
+						// the pause. Doing it like this instead of simply keeping track of the paused time is better
+						// since it retains the sample rate of the underlying source.
+						const timeDelta = currentTimestamp - lastSampleTimestamp;
+						timestampOffset -= timeDelta;
+					}
+					lastSampleTimestamp = currentTimestamp;
+				}
+
+				audioSample.close();
+				return;
+			}
+
+			if (firstAudioDataTimestamp === null) {
+				firstAudioDataTimestamp = audioSample.timestamp;
+
+				let target: number;
+				const timestampBase = this._options.timestampBase ?? 'synced-zero';
+				if (timestampBase === 'unix') {
+					target = Date.now() / 1000;
+				} else if (timestampBase === 'zero') {
+					target = 0;
+				} else {
+					const output = this._connectedTrack!.output;
+					if (output._firstMediaStreamTimestamp === null) {
+						output._firstMediaStreamTimestamp = performance.now() / 1000;
+						target = 0;
+					} else {
+						target = performance.now() / 1000 - output._firstMediaStreamTimestamp;
+					}
+				}
+
+				timestampOffset = target - firstAudioDataTimestamp;
+			}
+
+			lastSampleTimestamp = currentTimestamp;
+
+			if (this._encoder.getQueueSize() >= 8) {
+				// Drop data if the encoder is overloaded
+				audioSample.close();
+				return;
+			}
+
+			audioSample.setTimestamp(currentTimestamp + timestampOffset);
+
+			void this._encoder.add(audioSample, true)
+				.catch((error) => {
+					errored = true;
+
+					this._abortController?.abort();
+					this._promiseWithResolvers.reject(error);
+					void this._audioContext?.suspend();
+				});
+		};
+
+		if (typeof MediaStreamTrackProcessor !== 'undefined') {
+			// Great, MediaStreamTrackProcessor is supported, this is the preferred way of doing things
+			const processor = new MediaStreamTrackProcessor({ track: this._track });
+			const consumer = new WritableStream<AudioData>({
+				write: audioData => onAudioSample(new AudioSample(audioData)),
+			});
+
+			processor.readable.pipeTo(consumer, {
+				signal: this._abortController.signal,
+			}).catch((error) => {
+				// Handle AbortError silently
+				if (error instanceof DOMException && error.name === 'AbortError') return;
+
+				this._promiseWithResolvers.reject(error);
+			});
+		} else {
+			// Let's fall back to an AudioContext approach
+
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+			const AudioContext = window.AudioContext || (window as any).webkitAudioContext;
+
+			this._audioContext = new AudioContext({ sampleRate: this._track.getSettings().sampleRate });
+			const sourceNode = this._audioContext.createMediaStreamSource(new MediaStream([this._track]));
+			// eslint-disable-next-line @typescript-eslint/no-deprecated
+			this._scriptProcessorNode = this._audioContext.createScriptProcessor(4096);
+
+			if (this._audioContext.state === 'suspended') {
+				await this._audioContext.resume();
+			}
+
+			sourceNode.connect(this._scriptProcessorNode);
+			this._scriptProcessorNode.connect(this._audioContext.destination);
+
+			let totalDuration = 0;
+
+			// eslint-disable-next-line @typescript-eslint/no-deprecated
+			this._scriptProcessorNode.onaudioprocess = (event) => {
+				// eslint-disable-next-line @typescript-eslint/no-deprecated
+				const iterator = AudioSample._fromAudioBuffer(event.inputBuffer, totalDuration);
+				// eslint-disable-next-line @typescript-eslint/no-deprecated
+				totalDuration += event.inputBuffer.duration;
+
+				for (const audioSample of iterator) {
+					onAudioSample(audioSample);
+				}
+			};
+		}
+	}
+
+	/**
+	 * Pauses the capture of audio data - any audio data emitted by the underlying media stream will be ignored
+	 * while paused. This does *not* close the underlying `MediaStreamAudioTrack`, it just ignores its output.
+	 */
+	pause() {
+		this._paused = true;
+	}
+
+	/** Resumes the capture of audio data after being paused. */
+	resume() {
+		this._paused = false;
+	}
+
+	/** @internal */
+	override async _flushAndClose(forceClose: boolean) {
+		if (this._abortController) {
+			this._abortController.abort();
+			this._abortController = null;
+		}
+
+		if (this._audioContext) {
+			assert(this._scriptProcessorNode);
+
+			this._scriptProcessorNode.disconnect();
+			await this._audioContext.suspend();
+		}
+
+		await this._encoder.flushAndClose(forceClose);
+	}
+}
+
+// === MEDIA STREAM TRACK PROCESSOR WORKER ===
+
+type MediaStreamTrackProcessorWorkerMessage = {
+	type: 'support';
+	supported: boolean;
+} | {
+	type: 'videoFrame';
+	trackId: number;
+	videoFrame: VideoFrame;
+} | {
+	type: 'trackStopped';
+	trackId: number;
+} | {
+	type: 'error';
+	trackId: number;
+	error: unknown;
+};
+
+type MediaStreamTrackProcessorControllerMessage = {
+	type: 'videoTrack';
+	trackId: number;
+	track: MediaStreamVideoTrack;
+} | {
+	type: 'stopTrack';
+	trackId: number;
+};
+
+const mediaStreamTrackProcessorWorkerCode = () => {
+	const sendMessage = (message: MediaStreamTrackProcessorWorkerMessage, transfer?: Transferable[]) => {
+		if (transfer) {
+			self.postMessage(message, { transfer });
+		} else {
+			self.postMessage(message);
+		}
+	};
+
+	// Immediately send a message to the main thread, letting them know of the support
+	sendMessage({
+		type: 'support',
+		supported: typeof MediaStreamTrackProcessor !== 'undefined',
+	});
+
+	const abortControllers = new Map<number, AbortController>();
+	const activeTracks = new Map<number, MediaStreamVideoTrack>();
+
+	self.addEventListener('message', (event) => {
+		const message = event.data as MediaStreamTrackProcessorControllerMessage;
+
+		switch (message.type) {
+			case 'videoTrack': {
+				activeTracks.set(message.trackId, message.track);
+
+				const processor = new MediaStreamTrackProcessor({ track: message.track });
+				const consumer = new WritableStream<VideoFrame>({
+					write: (videoFrame) => {
+						if (!activeTracks.has(message.trackId)) {
+							videoFrame.close();
+							return;
+						}
+
+						// Send it to the main thread
+						sendMessage({
+							type: 'videoFrame',
+							trackId: message.trackId,
+							videoFrame,
+						}, [videoFrame]);
+					},
+				});
+
+				const abortController = new AbortController();
+				abortControllers.set(message.trackId, abortController);
+
+				processor.readable.pipeTo(consumer, {
+					signal: abortController.signal,
+				}).catch((error: unknown) => {
+					// Handle AbortError silently
+					if (error instanceof DOMException && error.name === 'AbortError') return;
+
+					sendMessage({
+						type: 'error',
+						trackId: message.trackId,
+						error,
+					});
+				});
+			}; break;
+
+			case 'stopTrack': {
+				const abortController = abortControllers.get(message.trackId);
+				if (abortController) {
+					abortController.abort();
+					abortControllers.delete(message.trackId);
+				}
+
+				const track = activeTracks.get(message.trackId);
+				track?.stop();
+				activeTracks.delete(message.trackId);
+
+				sendMessage({
+					type: 'trackStopped',
+					trackId: message.trackId,
+				});
+			}; break;
+
+			default: assertNever(message);
+		}
+	});
+};
+
+let nextMediaStreamTrackProcessorWorkerId = 0;
+let mediaStreamTrackProcessorWorker: Worker | null = null;
+
+const initMediaStreamTrackProcessorWorker = () => {
+	const blob = new Blob(
+		[`(${mediaStreamTrackProcessorWorkerCode.toString()})()`],
+		{ type: 'application/javascript' },
+	);
+	const url = URL.createObjectURL(blob);
+
+	mediaStreamTrackProcessorWorker = new Worker(url);
+};
+
+let mediaStreamTrackProcessorIsSupportedInWorkerCache: boolean | null = null;
+const mediaStreamTrackProcessorIsSupportedInWorker = async () => {
+	if (mediaStreamTrackProcessorIsSupportedInWorkerCache !== null) {
+		return mediaStreamTrackProcessorIsSupportedInWorkerCache;
+	}
+
+	if (!mediaStreamTrackProcessorWorker) {
+		initMediaStreamTrackProcessorWorker();
+	}
+
+	return new Promise<boolean>((resolve) => {
+		assert(mediaStreamTrackProcessorWorker);
+
+		const listener = (event: MessageEvent) => {
+			const message = event.data as MediaStreamTrackProcessorWorkerMessage;
+
+			if (message.type === 'support') {
+				mediaStreamTrackProcessorIsSupportedInWorkerCache = message.supported;
+				mediaStreamTrackProcessorWorker!.removeEventListener('message', listener);
+
+				resolve(message.supported);
+			}
+		};
+
+		mediaStreamTrackProcessorWorker.addEventListener('message', listener);
+	});
+};
+
+const sendMessageToMediaStreamTrackProcessorWorker = (
+	message: MediaStreamTrackProcessorControllerMessage,
+	transfer?: Transferable[],
+) => {
+	assert(mediaStreamTrackProcessorWorker);
+
+	if (transfer) {
+		mediaStreamTrackProcessorWorker.postMessage(message, transfer);
+	} else {
+		mediaStreamTrackProcessorWorker.postMessage(message);
+	}
+};
+
+/**
+ * Base class for subtitle sources - sources for subtitle tracks.
+ * @group Media sources
+ * @public
+ */
+export abstract class SubtitleSource extends MediaSource {
+	/** @internal */
+	override _connectedTrack: OutputSubtitleTrack | null = null;
+	/** @internal */
+	override readonly _codec: SubtitleCodec;
+
+	/** Internal constructor. */
+	constructor(codec: SubtitleCodec) {
+		super();
+
+		if (!SUBTITLE_CODECS.includes(codec)) {
+			throw new TypeError(`Invalid subtitle codec '${codec}'. Must be one of: ${SUBTITLE_CODECS.join(', ')}.`);
+		}
+
+		this._codec = codec;
+	}
+}
+
+/**
+ * This source can be used to add subtitles from a subtitle text file.
+ * @group Media sources
+ * @public
+ */
+export class TextSubtitleSource extends SubtitleSource {
+	/** @internal */
+	private _parser: SubtitleParser;
+	/** @internal */
+	private _error: unknown = null;
+	/** @internal */
+	private _errorSet = false;
+	/** @internal */
+	private _lastMuxerPromise: Promise<void> = Promise.resolve();
+
+	/** Creates a new {@link TextSubtitleSource} where added text chunks are in the specified `codec`. */
+	constructor(codec: SubtitleCodec) {
+		super(codec);
+
+		this._parser = new SubtitleParser({
+			codec,
+			output: (cue, metadata) => {
+				this._lastMuxerPromise
+					= this._connectedTrack!.output._muxer.addSubtitleCue(this._connectedTrack!, cue, metadata)
+						.catch((error) => {
+							this._setError(error);
+						});
+			},
+		});
+	}
+
+	/**
+	 * Parses the subtitle text according to the specified codec and adds it to the output track. You don't have to
+	 * add the entire subtitle file at once here; you can provide it in chunks.
+	 *
+	 * @returns A Promise that resolves once the output is ready to receive more samples. You should await this Promise
+	 * to respect writer and encoder backpressure.
+	 */
+	add(text: string) {
+		if (typeof text !== 'string') {
+			throw new TypeError('text must be a string.');
+		}
+
+		this._checkForError();
+
+		this._ensureValidAdd();
+		this._parser.parse(text);
+
+		return this._lastMuxerPromise; // Allow the writer to apply backpressure
+	}
+
+	/** @internal */
+	private _setError(error: unknown) {
+		if (!this._errorSet) {
+			this._error = error;
+			this._errorSet = true;
+		}
+	}
+
+	/** @internal */
+	_checkForError() {
+		if (this._errorSet) {
+			throw this._error;
+		}
+	}
+
+	/** @internal */
+	override async _flushAndClose(forceClose: boolean) {
+		if (!forceClose) {
+			this._checkForError();
+		}
+	}
+}