@mediabunny/server 1.45.0

package/src/index.ts

@@ -0,0 +1,104 @@
+/*!
+ * 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 { AudioSample, registerDecoder, registerEncoder, registerVideoSampleTransformer, VideoSample } from 'mediabunny';
+import * as NodeAv from 'node-av';
+import { NodeAvVideoDecoder } from './video-decoder';
+import { NodeAvVideoEncoder } from './video-encoder';
+import { NodeAvAudioDecoder } from './audio-decoder';
+import { NodeAvAudioEncoder } from './audio-encoder';
+import { copyVideoSampleToAvFrame, AvFrameVideoSampleResource, transformVideoSample } from './video-sample';
+import { copyAudioSampleToAvFrame, AvFrameAudioSampleResource } from './audio-sample';
+
+const SERVER_LOADED_SYMBOL = Symbol.for('@mediabunny/server loaded');
+if ((globalThis as Record<symbol, unknown>)[SERVER_LOADED_SYMBOL]) {
+	console.error(
+		'[WARNING]\n@mediabunny/server was loaded twice.'
+		+ ' This will likely cause the package not to work correctly.'
+		+ ' Check if multiple dependencies are importing different versions of @mediabunny/server,'
+		+ ' or if something is being bundled incorrectly.',
+	);
+}
+(globalThis as Record<symbol, unknown>)[SERVER_LOADED_SYMBOL] = true;
+
+let registered = false;
+
+/**
+ * Registers video and audio decoders and encoders for all codecs, using FFmpeg's libavcodec under the hood.
+ * Additionally, a custom `VideoSample` transformer based on libavfilter is registered to enable resizing, rotation and
+ * cropping of video frames.
+ *
+ * Make sure to call this function before interacting with Mediabunny.
+ *
+ * The decoders and encoders will automatically detect hardware acceleration support for each codec and platform and
+ * make use of it if applicable.
+ *
+ * @group \@mediabunny/server
+ * @public
+ */
+export const registerMediabunnyServer = () => {
+	if (registered) {
+		return;
+	}
+	registered = true;
+
+	NodeAv.Log.setLevel(NodeAv.AV_LOG_ERROR);
+
+	// Video
+	registerDecoder(NodeAvVideoDecoder);
+	registerEncoder(NodeAvVideoEncoder);
+
+	// Audio
+	registerDecoder(NodeAvAudioDecoder);
+	registerEncoder(NodeAvAudioEncoder);
+
+	registerVideoSampleTransformer(transformVideoSample);
+};
+
+export { AvFrameVideoSampleResource } from './video-sample';
+export { AvFrameAudioSampleResource } from './audio-sample';
+
+/**
+ * Copies a `VideoSample` or `AudioSample` into the given NodeAV
+ * [`Frame`](https://seydx.github.io/node-av/api/lib/classes/Frame.html), setting up the frame's format, media type,
+ * timing and data. When the sample is already backed by an `AVFrame` (via `AvFrameVideoSampleResource` or
+ * `AvFrameAudioSampleResource`), the frame is ref'd instead of copied for zero-copy reuse.
+ *
+ * For video samples, the frame's time base is always set to 1/1000000 (microsecond accuracy). For audio samples, the
+ * frame's time base is always set to 1/sampleRate.
+ *
+ * @group \@mediabunny/server
+ * @public
+ */
+export const toAvFrame = async (sample: VideoSample | AudioSample, frame: NodeAv.Frame) => {
+	if (sample instanceof VideoSample) {
+		if (sample._data instanceof AvFrameVideoSampleResource) {
+			frame.ref(sample._data.frame);
+		} else {
+			if (sample.format === null) {
+				throw new Error('Cannot convert foreign VideoSample with unknown (null) format.');
+			}
+
+			await copyVideoSampleToAvFrame(sample, frame, null);
+		}
+
+		frame.pts = BigInt(sample.microsecondTimestamp);
+		frame.duration = BigInt(sample.microsecondDuration);
+		frame.timeBase = new NodeAv.Rational(1, 1e6);
+	} else {
+		if (sample._data instanceof AvFrameAudioSampleResource) {
+			frame.ref(sample._data.frame);
+		} else {
+			copyAudioSampleToAvFrame(sample, frame);
+		}
+
+		frame.timeBase = new NodeAv.Rational(1, sample.sampleRate);
+		frame.pts = BigInt(Math.round(sample.timestamp * sample.sampleRate));
+		frame.duration = BigInt(sample.numberOfFrames);
+	}
+};

package/src/misc.ts

@@ -0,0 +1,242 @@
+/*!
+ * 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 { VideoSamplePixelFormat, MediaCodec } from 'mediabunny';
+import * as NodeAv from 'node-av';
+
+export const CODEC_TO_CODEC_ID: Partial<Record<MediaCodec, NodeAv.AVCodecID>> = {
+	avc: NodeAv.AV_CODEC_ID_H264,
+	hevc: NodeAv.AV_CODEC_ID_HEVC,
+	vp8: NodeAv.AV_CODEC_ID_VP8,
+	vp9: NodeAv.AV_CODEC_ID_VP9,
+	av1: NodeAv.AV_CODEC_ID_AV1,
+
+	aac: NodeAv.AV_CODEC_ID_AAC,
+	opus: NodeAv.AV_CODEC_ID_OPUS,
+	mp3: NodeAv.AV_CODEC_ID_MP3,
+	vorbis: NodeAv.AV_CODEC_ID_VORBIS,
+	flac: NodeAv.AV_CODEC_ID_FLAC,
+	ac3: NodeAv.AV_CODEC_ID_AC3,
+	eac3: NodeAv.AV_CODEC_ID_EAC3,
+};
+
+let cachedHardwareContext: NodeAv.HardwareContext | null | undefined = undefined;
+export const getHardwareContext = (): NodeAv.HardwareContext | null => {
+	if (cachedHardwareContext === undefined) {
+		cachedHardwareContext = NodeAv.HardwareContext.auto();
+	}
+	return cachedHardwareContext;
+};
+
+const hardwareDecoderCodecCache = new Map<NodeAv.AVCodecID, NodeAv.Codec | null>();
+export const getHardwareDecoderCodec = (codecId: NodeAv.AVCodecID): NodeAv.Codec | null => {
+	if (!hardwareDecoderCodecCache.has(codecId)) {
+		const hw = getHardwareContext();
+		hardwareDecoderCodecCache.set(codecId, hw?.getDecoderCodec(codecId) ?? null);
+	}
+	return hardwareDecoderCodecCache.get(codecId)!;
+};
+
+const hardwareEncoderCodecCache = new Map<NodeAv.AVCodecID, NodeAv.Codec | null>();
+export const getHardwareEncoderCodec = (codecId: NodeAv.AVCodecID): NodeAv.Codec | null => {
+	if (!hardwareEncoderCodecCache.has(codecId)) {
+		const hw = getHardwareContext();
+		hardwareEncoderCodecCache.set(codecId, hw?.getEncoderCodec(codecId) ?? null);
+	}
+	return hardwareEncoderCodecCache.get(codecId)!;
+};
+
+export const mapColorPrimaries = (primaries: string) => {
+	switch (primaries) {
+		case 'bt709': return NodeAv.AVCOL_PRI_BT709;
+		case 'bt470bg': return NodeAv.AVCOL_PRI_BT470BG;
+		case 'smpte170m': return NodeAv.AVCOL_PRI_SMPTE170M;
+		case 'bt2020': return NodeAv.AVCOL_PRI_BT2020;
+		case 'smpte432': return NodeAv.AVCOL_PRI_SMPTE432;
+	}
+
+	return null;
+};
+
+export const unmapColorPrimaries = (primaries: number) => {
+	switch (primaries) {
+		case NodeAv.AVCOL_PRI_BT709: return 'bt709';
+		case NodeAv.AVCOL_PRI_BT470BG: return 'bt470bg';
+		case NodeAv.AVCOL_PRI_SMPTE170M: return 'smpte170m';
+		case NodeAv.AVCOL_PRI_BT2020: return 'bt2020';
+		case NodeAv.AVCOL_PRI_SMPTE432: return 'smpte432';
+	}
+
+	return null;
+};
+
+export const mapTransferCharacteristics = (transfer: string) => {
+	switch (transfer) {
+		case 'bt709': return NodeAv.AVCOL_TRC_BT709;
+		case 'smpte170m': return NodeAv.AVCOL_TRC_SMPTE170M;
+		case 'iec61966-2-1': return NodeAv.AVCOL_TRC_IEC61966_2_1;
+		case 'linear': return NodeAv.AVCOL_TRC_LINEAR;
+		case 'pq': return NodeAv.AVCOL_TRC_SMPTE2084;
+		case 'hlg': return NodeAv.AVCOL_TRC_ARIB_STD_B67;
+	}
+
+	return null;
+};
+
+export const unmapTransferCharacteristics = (transfer: number) => {
+	switch (transfer) {
+		case NodeAv.AVCOL_TRC_BT709: return 'bt709';
+		case NodeAv.AVCOL_TRC_SMPTE170M: return 'smpte170m';
+		case NodeAv.AVCOL_TRC_IEC61966_2_1: return 'iec61966-2-1';
+		case NodeAv.AVCOL_TRC_LINEAR: return 'linear';
+		case NodeAv.AVCOL_TRC_SMPTE2084: return 'pq';
+		case NodeAv.AVCOL_TRC_ARIB_STD_B67: return 'hlg';
+	}
+
+	return null;
+};
+
+export const mapMatrixCoefficients = (matrix: string) => {
+	switch (matrix) {
+		case 'rgb': return NodeAv.AVCOL_SPC_RGB;
+		case 'bt709': return NodeAv.AVCOL_SPC_BT709;
+		case 'bt470bg': return NodeAv.AVCOL_SPC_BT470BG;
+		case 'smpte170m': return NodeAv.AVCOL_SPC_SMPTE170M;
+		case 'bt2020-ncl': return NodeAv.AVCOL_SPC_BT2020_NCL;
+	}
+
+	return null;
+};
+
+export const unmapMatrixCoefficients = (matrix: number) => {
+	switch (matrix) {
+		case NodeAv.AVCOL_SPC_RGB: return 'rgb';
+		case NodeAv.AVCOL_SPC_BT709: return 'bt709';
+		case NodeAv.AVCOL_SPC_BT470BG: return 'bt470bg';
+		case NodeAv.AVCOL_SPC_SMPTE170M: return 'smpte170m';
+		case NodeAv.AVCOL_SPC_BT2020_NCL: return 'bt2020-ncl';
+	}
+
+	return null;
+};
+
+export const toPixelFormat = (ffmpegPixelFormat: NodeAv.AVPixelFormat): VideoSamplePixelFormat | null => {
+	switch (ffmpegPixelFormat) {
+		case NodeAv.AV_PIX_FMT_YUV420P: return 'I420';
+		// "deprecated in favor of AV_PIX_FMT_YUV420P and setting color_range"
+		case NodeAv.AV_PIX_FMT_YUVJ420P: return 'I420';
+		case NodeAv.AV_PIX_FMT_YUV420P10LE: return 'I420P10';
+		case NodeAv.AV_PIX_FMT_YUV420P12LE: return 'I420P12';
+		case NodeAv.AV_PIX_FMT_YUVA420P: return 'I420A';
+		case NodeAv.AV_PIX_FMT_YUVA420P10LE: return 'I420AP10';
+
+		case NodeAv.AV_PIX_FMT_YUV422P: return 'I422';
+		// "deprecated in favor of AV_PIX_FMT_YUV422P and setting color_range"
+		case NodeAv.AV_PIX_FMT_YUVJ422P: return 'I422';
+		case NodeAv.AV_PIX_FMT_YUV422P10LE: return 'I422P10';
+		case NodeAv.AV_PIX_FMT_YUV422P12LE: return 'I422P12';
+		case NodeAv.AV_PIX_FMT_YUVA422P: return 'I422A';
+		case NodeAv.AV_PIX_FMT_YUVA422P10LE: return 'I422AP10';
+		case NodeAv.AV_PIX_FMT_YUVA422P12LE: return 'I422AP12';
+
+		case NodeAv.AV_PIX_FMT_YUV444P: return 'I444';
+		// "deprecated in favor of AV_PIX_FMT_YUV444P and setting color_range"
+		case NodeAv.AV_PIX_FMT_YUVJ444P: return 'I444';
+		case NodeAv.AV_PIX_FMT_YUV444P10LE: return 'I444P10';
+		case NodeAv.AV_PIX_FMT_YUV444P12LE: return 'I444P12';
+		case NodeAv.AV_PIX_FMT_YUVA444P: return 'I444A';
+		case NodeAv.AV_PIX_FMT_YUVA444P10LE: return 'I444AP10';
+		case NodeAv.AV_PIX_FMT_YUVA444P12LE: return 'I444AP12';
+
+		case NodeAv.AV_PIX_FMT_NV12: return 'NV12';
+
+		case NodeAv.AV_PIX_FMT_RGBA: return 'RGBA';
+		case NodeAv.AV_PIX_FMT_RGB0: return 'RGBX';
+		case NodeAv.AV_PIX_FMT_BGRA: return 'BGRA';
+		case NodeAv.AV_PIX_FMT_BGR0: return 'BGRX';
+
+		default: return null;
+	}
+};
+
+export const fromPixelFormat = (pixelFormat: VideoSamplePixelFormat) => {
+	switch (pixelFormat) {
+		case 'I420': return NodeAv.AV_PIX_FMT_YUV420P;
+		case 'I420P10': return NodeAv.AV_PIX_FMT_YUV420P10LE;
+		case 'I420P12': return NodeAv.AV_PIX_FMT_YUV420P12LE;
+		case 'I420A': return NodeAv.AV_PIX_FMT_YUVA420P;
+		case 'I420AP10': return NodeAv.AV_PIX_FMT_YUVA420P10LE;
+
+		case 'I422': return NodeAv.AV_PIX_FMT_YUV422P;
+		case 'I422P10': return NodeAv.AV_PIX_FMT_YUV422P10LE;
+		case 'I422P12': return NodeAv.AV_PIX_FMT_YUV422P12LE;
+		case 'I422A': return NodeAv.AV_PIX_FMT_YUVA422P;
+		case 'I422AP10': return NodeAv.AV_PIX_FMT_YUVA422P10LE;
+		case 'I422AP12': return NodeAv.AV_PIX_FMT_YUVA422P12LE;
+
+		case 'I444': return NodeAv.AV_PIX_FMT_YUV444P;
+		case 'I444P10': return NodeAv.AV_PIX_FMT_YUV444P10LE;
+		case 'I444P12': return NodeAv.AV_PIX_FMT_YUV444P12LE;
+		case 'I444A': return NodeAv.AV_PIX_FMT_YUVA444P;
+		case 'I444AP10': return NodeAv.AV_PIX_FMT_YUVA444P10LE;
+		case 'I444AP12': return NodeAv.AV_PIX_FMT_YUVA444P12LE;
+
+		case 'NV12': return NodeAv.AV_PIX_FMT_NV12;
+
+		case 'RGBA': return NodeAv.AV_PIX_FMT_RGBA;
+		case 'RGBX': return NodeAv.AV_PIX_FMT_RGB0;
+		case 'BGRA': return NodeAv.AV_PIX_FMT_BGRA;
+		case 'BGRX': return NodeAv.AV_PIX_FMT_BGR0;
+
+		default: return NodeAv.AV_PIX_FMT_NONE;
+	}
+};
+
+export const toAudioSampleFormat = (ffmpegSampleFormat: NodeAv.AVSampleFormat): AudioSampleFormat | null => {
+	switch (ffmpegSampleFormat) {
+		case NodeAv.AV_SAMPLE_FMT_U8: return 'u8';
+		case NodeAv.AV_SAMPLE_FMT_S16: return 's16';
+		case NodeAv.AV_SAMPLE_FMT_S32: return 's32';
+		case NodeAv.AV_SAMPLE_FMT_FLT: return 'f32';
+		case NodeAv.AV_SAMPLE_FMT_U8P: return 'u8-planar';
+		case NodeAv.AV_SAMPLE_FMT_S16P: return 's16-planar';
+		case NodeAv.AV_SAMPLE_FMT_S32P: return 's32-planar';
+		case NodeAv.AV_SAMPLE_FMT_FLTP: return 'f32-planar';
+
+		default: return null;
+	}
+};
+
+export const fromAudioSampleFormat = (sampleFormat: AudioSampleFormat): NodeAv.AVSampleFormat => {
+	switch (sampleFormat) {
+		case 'u8': return NodeAv.AV_SAMPLE_FMT_U8;
+		case 's16': return NodeAv.AV_SAMPLE_FMT_S16;
+		case 's32': return NodeAv.AV_SAMPLE_FMT_S32;
+		case 'f32': return NodeAv.AV_SAMPLE_FMT_FLT;
+		case 'u8-planar': return NodeAv.AV_SAMPLE_FMT_U8P;
+		case 's16-planar': return NodeAv.AV_SAMPLE_FMT_S16P;
+		case 's32-planar': return NodeAv.AV_SAMPLE_FMT_S32P;
+		case 'f32-planar': return NodeAv.AV_SAMPLE_FMT_FLTP;
+
+		default: return NodeAv.AV_SAMPLE_FMT_NONE;
+	}
+};
+
+export const getChannelLayout = (numChannels: number): NodeAv.ChannelLayout => {
+	switch (numChannels) {
+		case 1: return NodeAv.AV_CHANNEL_LAYOUT_MONO;
+		case 2: return NodeAv.AV_CHANNEL_LAYOUT_STEREO;
+		case 4: return NodeAv.AV_CHANNEL_LAYOUT_QUAD;
+		case 6: return NodeAv.AV_CHANNEL_LAYOUT_5POINT1_BACK;
+		case 8: return NodeAv.AV_CHANNEL_LAYOUT_7POINT1;
+		default: return { nbChannels: numChannels, order: NodeAv.AV_CHANNEL_ORDER_UNSPEC, mask: 0n };
+	}
+};
+
+// The value is incorrect in the node-av source code, so we do:
+export const LIBVPX_VP9 = 'libvpx-vp9' as (NodeAv.FFEncoderCodec & NodeAv.FFDecoderCodec);

package/src/video-decoder.ts

@@ -0,0 +1,224 @@
+/*!
+ * 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 { CustomVideoDecoder, VideoCodec, EncodedPacket, VideoSample, type MaybePromise, Rational } from 'mediabunny';
+import * as NodeAv from 'node-av';
+import { CODEC_TO_CODEC_ID, getHardwareDecoderCodec, LIBVPX_VP9 } from './misc';
+import { assert, binarySearchLessOrEqual, simplifyRational, toUint8Array } from '../../../src/misc';
+import { AvFrameVideoSampleResource } from './video-sample';
+
+export class NodeAvVideoDecoder extends CustomVideoDecoder {
+	frame!: NodeAv.Frame;
+	packet!: NodeAv.Packet;
+	codecContext: NodeAv.CodecContext | null = null;
+	pixelAspectRatio!: Rational;
+
+	// Bookkeeping to restore the original timing information
+	preciseTimings: {
+		microsecondTimestamp: number;
+		timestamp: number;
+		duration: number;
+		timestampIsValid: boolean;
+		durationIsValid: boolean;
+	}[] = [];
+
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	static override supports(codec: VideoCodec, config: VideoDecoderConfig): boolean {
+		return codec === 'avc' || codec === 'hevc' || codec === 'vp8' || codec === 'vp9' || codec === 'av1';
+	}
+
+	async init() {
+		this.frame = new NodeAv.Frame();
+		this.frame.alloc();
+		this.packet = new NodeAv.Packet();
+		this.packet.alloc();
+	}
+
+	async initCodecContext(packet: EncodedPacket) {
+		assert(this.codecContext === null);
+
+		const codecId = CODEC_TO_CODEC_ID[this.codec];
+		assert(codecId !== undefined);
+
+		let codec: NodeAv.Codec | null;
+		if (this.codec === 'vp9' && packet.sideData.alpha) {
+			codec = NodeAv.Codec.findDecoderByName(LIBVPX_VP9) ?? NodeAv.Codec.findDecoder(codecId);
+		} else if (
+			// This check used to be "is not prefer-hardware", meaning it would default to using software decode. I
+			// didn't leave a comment for that back then so I actually don't know what it was for. I'm sure it was to
+			// work around an issue but, I don't know. Not using hardware decode at all by defaults feels wrong to me,
+			// so I changed it to what it is right now. If an issue is encountered, I can always change it.
+			this.config.hardwareAcceleration === 'prefer-software'
+			|| this.codec === 'av1' // https://github.com/opencv/opencv/issues/24430
+		) {
+			codec = NodeAv.Codec.findDecoder(codecId);
+		} else {
+			codec = getHardwareDecoderCodec(codecId) ?? NodeAv.Codec.findDecoder(codecId);
+		}
+
+		if (!codec) {
+			throw new Error(`Unable to obtain libav codec for '${this.codec}'.`);
+		}
+
+		const codecContext = new NodeAv.CodecContext();
+		codecContext.allocContext3(codec);
+
+		this.pixelAspectRatio = simplifyRational({
+			num: (this.config.displayAspectWidth ?? this.config.codedWidth ?? 0) * (this.config.codedHeight ?? 0),
+			den: (this.config.displayAspectHeight ?? this.config.codedHeight ?? 0) * (this.config.codedWidth ?? 0) || 1,
+		});
+
+		codecContext.width = this.config.codedWidth ?? 0; // Fucky that the dimensions can be optional, but oh well
+		codecContext.height = this.config.codedHeight ?? 0;
+		codecContext.codecType = NodeAv.AVMEDIA_TYPE_VIDEO;
+		codecContext.codecId = codecId;
+		codecContext.extraData = this.config.description
+			? Buffer.from(toUint8Array(this.config.description))
+			: null;
+		codecContext.sampleAspectRatio = new NodeAv.Rational(this.pixelAspectRatio.num, this.pixelAspectRatio.den);
+
+		const ret = await codecContext.open2();
+		NodeAv.FFmpegError.throwIfError(ret, 'Open codec context');
+
+		this.codecContext = codecContext;
+	}
+
+	async decode(packet: EncodedPacket) {
+		if (this.codecContext === null) {
+			await this.initCodecContext(packet);
+			assert(this.codecContext);
+		}
+
+		this.packet.isKeyframe = packet.type === 'key';
+		this.packet.data = Buffer.from(packet.data);
+		this.packet.timeBase = { num: 1, den: 1e6 };
+		this.packet.pts = BigInt(packet.microsecondTimestamp);
+		this.packet.dts = NodeAv.AV_NOPTS_VALUE;
+		this.packet.duration = BigInt(packet.microsecondDuration);
+
+		if (packet.sideData.alpha) {
+			const matroskaBlockAdditional = Buffer.alloc(8 + packet.sideData.alpha.byteLength);
+			matroskaBlockAdditional[7] = 1; // BlockAddId
+			matroskaBlockAdditional.set(packet.sideData.alpha, 8);
+
+			this.packet.addSideData(NodeAv.AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL, matroskaBlockAdditional);
+		}
+
+		const preciseTimingIndex = binarySearchLessOrEqual(
+			this.preciseTimings,
+			packet.microsecondTimestamp,
+			x => x.microsecondTimestamp,
+		);
+		const existingEntry = preciseTimingIndex !== -1
+			? this.preciseTimings[preciseTimingIndex]
+			: null;
+		if (existingEntry && existingEntry.microsecondTimestamp === packet.microsecondTimestamp) {
+			if (existingEntry.timestamp !== packet.timestamp) {
+				// Mapping isn't unique, can't use the timestamp
+				existingEntry.timestampIsValid = false;
+			}
+			if (existingEntry.duration !== packet.duration) {
+				// Mapping isn't unique, can't use the duration
+				existingEntry.durationIsValid = false;
+			}
+		} else {
+			this.preciseTimings.splice(preciseTimingIndex + 1, 0, {
+				microsecondTimestamp: packet.microsecondTimestamp,
+				timestamp: packet.timestamp,
+				duration: packet.duration,
+				timestampIsValid: true,
+				durationIsValid: true,
+			});
+
+			// Make sure it doesn't grow indefinitely
+			if (this.preciseTimings.length > 128) {
+				this.preciseTimings.shift();
+			}
+		}
+
+		const ret = await this.codecContext.sendPacket(this.packet);
+		NodeAv.FFmpegError.throwIfError(ret, 'Send packet');
+
+		while (true) {
+			const receiveRet = await this.codecContext.receiveFrame(this.frame);
+			if (receiveRet === NodeAv.AVERROR_EAGAIN || receiveRet === NodeAv.AVERROR_EOF) {
+				break;
+			}
+
+			this.receiveFrame(receiveRet);
+		}
+	}
+
+	receiveFrame(ret: number) {
+		NodeAv.FFmpegError.throwIfError(ret, 'Receive frame');
+
+		this.frame.sampleAspectRatio = new NodeAv.Rational(this.pixelAspectRatio.num, this.pixelAspectRatio.den);
+
+		let timestamp = Number(this.frame.pts) / 1e6;
+		let duration = Number(this.frame.duration) / 1e6;
+
+		const preciseTimingIndex = binarySearchLessOrEqual(
+			this.preciseTimings,
+			Number(this.frame.pts),
+			x => x.microsecondTimestamp,
+		);
+		const entry = preciseTimingIndex !== -1
+			? this.preciseTimings[preciseTimingIndex]
+			: null;
+
+		// If there's a relevant timing entry, refine the frame's timing data to get better accuracy than
+		// microseconds
+		if (entry && entry.microsecondTimestamp === Number(this.frame.pts)) {
+			if (entry.timestampIsValid) {
+				timestamp = entry.timestamp;
+			}
+			if (entry.durationIsValid) {
+				duration = entry.duration;
+			}
+		}
+
+		const clone = this.frame.clone();
+		if (!clone) {
+			throw new Error('Frame clone allocation failed.');
+		}
+
+		this.onSample(new VideoSample(new AvFrameVideoSampleResource(clone), {
+			timestamp,
+			duration,
+		}));
+	}
+
+	async flush() {
+		if (!this.codecContext) {
+			return;
+		}
+
+		// Send null packet to signal flush
+		const ret = await this.codecContext.sendPacket(null);
+		NodeAv.FFmpegError.throwIfError(ret, 'Flush decoder');
+
+		// Keep receiving frames until no more are available
+		while (true) {
+			const receiveRet = await this.codecContext.receiveFrame(this.frame);
+			if (receiveRet === NodeAv.AVERROR_EAGAIN || receiveRet === NodeAv.AVERROR_EOF) {
+				// No more frames available
+				break;
+			}
+
+			this.receiveFrame(receiveRet);
+		}
+
+		this.codecContext.flushBuffers();
+	}
+
+	close(): MaybePromise<void> {
+		this.codecContext?.freeContext();
+		this.frame.free();
+		this.packet.free();
+	}
+}