From e83356662e932a02e4e9707557eef061e8edb22c Mon Sep 17 00:00:00 2001
From: Vanilagy <1696106+Vanilagy@users.noreply.github.com>
Date: Sat, 4 Jan 2025 00:14:34 +0100
Subject: [PATCH] Add own encoded sample classes and port the code to them

---
 dev/demux.html                 |  65 +++-
 dev/index.html                 |   2 +
 dev/player.html                |   2 +
 src/codec.ts                   |  46 ++-
 src/index.ts                   |  14 +-
 src/input-track.ts             |  23 +-
 src/isobmff/isobmff-demuxer.ts | 183 +++++----
 src/media-drain.ts             | 687 ++++++++++++++++++---------------
 src/reader.ts                  |  22 +-
 src/sample.ts                  |  84 ++++
 10 files changed, 694 insertions(+), 434 deletions(-)
 create mode 100644 src/sample.ts
diff --git a/dev/demux.html b/dev/demux.html
index 3dbf8a4..3924f4d 100644
--- a/dev/demux.html
+++ b/dev/demux.html
@@ -1,3 +1,5 @@
+<!DOCTYPE html>
+
 <script src="../dist/metamuxer.js"></script>
 
 <script type="module">
@@ -30,19 +32,72 @@
 
 	fileInput.addEventListener('change', async () => {
 		const file = fileInput.files[0];
-		const source = new Metamuxer.BlobSource(file);
+		const source = new Metamuxer.BufferSource(await file.arrayBuffer()) ?? new Metamuxer.BlobSource(file);
+
+		const start = performance.now();	
 		const input = new Metamuxer.Input({
 			formats: Metamuxer.ALL_FORMATS,
 			source
 		});
 
-		const audioTrack = await input.getPrimaryAudioTrack();
-		const drain = new Metamuxer.EncodedAudioChunkDrain(audioTrack);
+		const videoTrack = await input.getPrimaryVideoTrack();
+		const drain = new Metamuxer.EncodedVideoSampleDrain(videoTrack);
+
+		for await (const sample of drain.samples()) {
+			//console.log(chunk);
+		}
+
+		document.body.textContent = performance.now() - start;
+
+		/*
+		const videoTrack = await input.getPrimaryVideoTrack();
+		const drain = new Metamuxer.VideoFrameDrain(videoTrack);
+
+		async function* timestamps() {
+			const fromTime = 0;
+			const toTime = await videoTrack.computeDuration();
+			const extractDuration = toTime - fromTime;
+			const drain = new Metamuxer.EncodedVideoSampleDrain(videoTrack);
+			const thumbnailsNeeded = 16;
+
+			  for (let i = 0; i < thumbnailsNeeded; i++) {
+				const startTime = (extractDuration * i) / thumbnailsNeeded + fromTime;
+				const endTime = Math.min(
+				  (extractDuration * (i + 1)) / thumbnailsNeeded + fromTime,
+				  toTime + 1,
+				);
+
+				const sample = await drain.getSample(startTime, { onlyMetadata: true });
+
+				let bestTimestamp = sample.timestamp;
+				if (sample.type !== 'key') {
+					const nextKeySample = await drain.getNextKeySample(sample, { onlyMetadata: true });
+					if (nextKeySample.timestamp < endTime) {
+						bestTimestamp = nextKeySample.timestamp;
+					}
+				}
+
+				yield bestTimestamp;
+			  }
+		}
+
+		for await (const { frame, timestamp } of drain.framesAtTimestamps(timestamps())) {
+			console.log(frame.timestamp, timestamp)
+			frame.close();
+		}
+		console.log("done")
+		*/
+
+		/*
+		const audioTrack = await input.getPrimaryVideoTrack();
+		const drain = new Metamuxer.EncodedVideoChunkDrain(audioTrack);
 
 		for await (const chunk of drain.chunks()) {
-			console.log(chunk);
+			//console.log(chunk);
 		}
-		console.log("Done??")
+
+		document.body.textContent = performance.now() - start;
+		*/
 
 
 		/*
diff --git a/dev/index.html b/dev/index.html
index dde4b8c..6994c3a 100644
--- a/dev/index.html
+++ b/dev/index.html
@@ -1,3 +1,5 @@
+<!DOCTYPE html>
+
 <script src="../dist/metamuxer.js"></script>
 
 <script type="module">
diff --git a/dev/player.html b/dev/player.html
index bc930c2..7222e10 100644
--- a/dev/player.html
+++ b/dev/player.html
@@ -1,3 +1,5 @@
+<!DOCTYPE html>
+
 <input type="file" accept="video/mp4,video/quicktime,audio/x-m4a,video/x-m4v">
 
 <div id="player"
diff --git a/src/codec.ts b/src/codec.ts
index 33e5fdf..2fef35f 100644
--- a/src/codec.ts
+++ b/src/codec.ts
@@ -842,7 +842,7 @@ export const canEncode = (codec: MediaCodec) => {
 		return canEncodeSubtitles(codec as SubtitleCodec);
 	}
 
-	throw new Error('Unhandled codec.');
+	throw new TypeError(`Unknown codec '${codec}'.`);
 };
 
 /** @public */
@@ -851,6 +851,19 @@ export const canEncodeVideo = async (codec: VideoCodec, { width = 1280, height =
 	height?: number;
 	bitrate?: 1e6;
 } = {}) => {
+	if (!VIDEO_CODECS.includes(codec)) {
+		return false;
+	}
+	if (!Number.isInteger(width) || width <= 0) {
+		throw new TypeError('width must be a positive integer.');
+	}
+	if (!Number.isInteger(height) || height <= 0) {
+		throw new TypeError('height must be a positive integer.');
+	}
+	if (!Number.isInteger(bitrate) || bitrate <= 0) {
+		throw new TypeError('bitrate must be a positive integer.');
+	}
+
 	if (typeof VideoEncoder === 'undefined') {
 		return false;
 	}
@@ -872,14 +885,27 @@ export const canEncodeAudio = async (codec: AudioCodec, { numberOfChannels = 2,
 	sampleRate?: number;
 	bitrate?: number;
 } = {}) => {
-	if (typeof AudioEncoder === 'undefined') {
+	if (!AUDIO_CODECS.includes(codec)) {
 		return false;
 	}
+	if (!Number.isInteger(numberOfChannels) || numberOfChannels <= 0) {
+		throw new TypeError('numberOfChannels must be a positive integer.');
+	}
+	if (!Number.isInteger(sampleRate) || sampleRate <= 0) {
+		throw new TypeError('sampleRate must be a positive integer.');
+	}
+	if (!Number.isInteger(bitrate) || bitrate <= 0) {
+		throw new TypeError('bitrate must be a positive integer.');
+	}
 
 	if ((PCM_CODECS as readonly string[]).includes(codec)) {
 		return false; // TODO write encoder
 	}
 
+	if (typeof AudioEncoder === 'undefined') {
+		return false;
+	}
+
 	const support = await AudioEncoder.isConfigSupported({
 		codec: buildAudioCodecString(codec, numberOfChannels, sampleRate),
 		numberOfChannels,
@@ -891,6 +917,16 @@ export const canEncodeAudio = async (codec: AudioCodec, { numberOfChannels = 2,
 	return support.supported === true;
 };
 
+/** @public */
+
+export const canEncodeSubtitles = async (codec: SubtitleCodec) => {
+	if (!SUBTITLE_CODECS.includes(codec)) {
+		return false;
+	}
+
+	return true;
+};
+
 /** @public */
 export const getEncodableCodecs = async (): Promise<MediaCodec[]> => {
 	const [videoCodecs, audioCodecs, subtitleCodecs] = await Promise.all([
@@ -902,12 +938,6 @@ export const getEncodableCodecs = async (): Promise<MediaCodec[]> => {
 	return [...videoCodecs, ...audioCodecs, ...subtitleCodecs];
 };
 
-/** @public */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export const canEncodeSubtitles = async (codec: SubtitleCodec) => {
-	return true;
-};
-
 /** @public */
 export const getEncodableVideoCodecs = async (): Promise<VideoCodec[]> => {
 	const bools = await Promise.all(VIDEO_CODECS.map(canEncode));
diff --git a/src/index.ts b/src/index.ts
index 0405644..a8e998d 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -60,12 +60,18 @@ export {
 export { Input, InputOptions } from './input';
 export { InputTrack, InputVideoTrack, InputAudioTrack } from './input-track';
 export {
-	ChunkRetrievalOptions,
-	BaseChunkDrain,
+	EncodedVideoSample,
+	EncodedAudioSample,
+	SampleType,
+} from './sample';
+export {
+	SampleRetrievalOptions,
+	BaseSampleDrain,
+	WrappedMediaFrame,
 	BaseMediaFrameDrain,
-	EncodedVideoChunkDrain,
+	EncodedVideoSampleDrain,
 	VideoFrameDrain,
-	EncodedAudioChunkDrain,
+	EncodedAudioSampleDrain,
 	CanvasDrain,
 	WrappedCanvas,
 	AudioDataDrain,
diff --git a/src/input-track.ts b/src/input-track.ts
index 6fb7e90..198e02c 100644
--- a/src/input-track.ts
+++ b/src/input-track.ts
@@ -1,6 +1,7 @@
 import { AudioCodec, MediaCodec, VideoCodec } from './codec';
-import { ChunkRetrievalOptions } from './media-drain';
+import { SampleRetrievalOptions } from './media-drain';
 import { Rotation } from './misc';
+import { EncodedAudioSample, EncodedVideoSample } from './sample';
 
 export interface InputTrackBacking {
 	getCodec(): Promise<MediaCodec | null>;
@@ -40,11 +41,11 @@ export interface InputVideoTrackBacking extends InputTrackBacking {
 	getCodedHeight(): Promise<number>;
 	getRotation(): Promise<Rotation>;
 	getDecoderConfig(): Promise<VideoDecoderConfig | null>;
-	getFirstChunk(options: ChunkRetrievalOptions): Promise<EncodedVideoChunk | null>;
-	getChunk(timestamp: number, options: ChunkRetrievalOptions): Promise<EncodedVideoChunk | null>;
-	getNextChunk(chunk: EncodedVideoChunk, options: ChunkRetrievalOptions): Promise<EncodedVideoChunk | null>;
-	getKeyChunk(timestamp: number, options: ChunkRetrievalOptions): Promise<EncodedVideoChunk | null>;
-	getNextKeyChunk(chunk: EncodedVideoChunk, options: ChunkRetrievalOptions): Promise<EncodedVideoChunk | null>;
+	getFirstSample(options: SampleRetrievalOptions): Promise<EncodedVideoSample | null>;
+	getSample(timestamp: number, options: SampleRetrievalOptions): Promise<EncodedVideoSample | null>;
+	getNextSample(sample: EncodedVideoSample, options: SampleRetrievalOptions): Promise<EncodedVideoSample | null>;
+	getKeySample(timestamp: number, options: SampleRetrievalOptions): Promise<EncodedVideoSample | null>;
+	getNextKeySample(sample: EncodedVideoSample, options: SampleRetrievalOptions): Promise<EncodedVideoSample | null>;
 }
 
 /** @public */
@@ -115,11 +116,11 @@ export interface InputAudioTrackBacking extends InputTrackBacking {
 	getNumberOfChannels(): Promise<number>;
 	getSampleRate(): Promise<number>;
 	getDecoderConfig(): Promise<AudioDecoderConfig | null>;
-	getFirstChunk(options: ChunkRetrievalOptions): Promise<EncodedAudioChunk | null>;
-	getChunk(timestamp: number, options: ChunkRetrievalOptions): Promise<EncodedAudioChunk | null>;
-	getNextChunk(chunk: EncodedAudioChunk, options: ChunkRetrievalOptions): Promise<EncodedAudioChunk | null>;
-	getKeyChunk(timestamp: number, options: ChunkRetrievalOptions): Promise<EncodedAudioChunk | null>;
-	getNextKeyChunk(chunk: EncodedAudioChunk, options: ChunkRetrievalOptions): Promise<EncodedAudioChunk | null>;
+	getFirstSample(options: SampleRetrievalOptions): Promise<EncodedAudioSample | null>;
+	getSample(timestamp: number, options: SampleRetrievalOptions): Promise<EncodedAudioSample | null>;
+	getNextSample(sample: EncodedAudioSample, options: SampleRetrievalOptions): Promise<EncodedAudioSample | null>;
+	getKeySample(timestamp: number, options: SampleRetrievalOptions): Promise<EncodedAudioSample | null>;
+	getNextKeySample(sample: EncodedAudioSample, options: SampleRetrievalOptions): Promise<EncodedAudioSample | null>;
 }
 
 /** @public */
diff --git a/src/isobmff/isobmff-demuxer.ts b/src/isobmff/isobmff-demuxer.ts
index 0c49ba4..ecc41dc 100644
--- a/src/isobmff/isobmff-demuxer.ts
+++ b/src/isobmff/isobmff-demuxer.ts
@@ -19,7 +19,7 @@ import {
 	InputVideoTrack,
 	InputVideoTrackBacking,
 } from '../input-track';
-import { ChunkRetrievalOptions } from '../media-drain';
+import { SampleRetrievalOptions } from '../media-drain';
 import {
 	assert,
 	COLOR_PRIMARIES_MAP_INVERSE,
@@ -34,6 +34,7 @@ import {
 	findLastIndex,
 } from '../misc';
 import { Reader } from '../reader';
+import { EncodedAudioSample, EncodedVideoSample, PLACEHOLDER_DATA, SampleType } from '../sample';
 import { IsobmffReader } from './isobmff-reader';
 
 type InternalTrack = {
@@ -1637,9 +1638,11 @@ export class IsobmffDemuxer extends Demuxer {
 	}
 }
 
-abstract class IsobmffTrackBacking<Chunk extends EncodedVideoChunk | EncodedAudioChunk> implements InputTrackBacking {
-	chunkToSampleIndex = new WeakMap<Chunk, number>();
-	chunkToFragmentLocation = new WeakMap<Chunk, {
+abstract class IsobmffTrackBacking<
+	Sample extends EncodedVideoSample | EncodedAudioSample,
+> implements InputTrackBacking {
+	sampleToSampleIndex = new WeakMap<Sample, number>();
+	sampleToFragmentLocation = new WeakMap<Sample, {
 		fragment: Fragment;
 		sampleIndex: number;
 	}>();
@@ -1651,18 +1654,19 @@ abstract class IsobmffTrackBacking<Chunk extends EncodedVideoChunk | EncodedAudi
 	}
 
 	async computeDuration() {
-		const lastChunk = await this.getChunk(Infinity, { metadataOnly: true });
-		return ((lastChunk?.timestamp ?? 0) + (lastChunk?.duration ?? 0)) / 1e6;
+		const lastSample = await this.getSample(Infinity, { metadataOnly: true });
+		return (lastSample?.timestamp ?? 0) + (lastSample?.duration ?? 0);
 	}
 
-	abstract createChunk(
+	abstract createSample(
 		data: Uint8Array,
+		byteLength: number,
+		type: SampleType,
 		timestamp: number,
 		duration: number,
-		isKeyFrame: boolean,
-	): Chunk;
+	): Sample;
 
-	async getFirstChunk(options: ChunkRetrievalOptions) {
+	async getFirstSample(options: SampleRetrievalOptions) {
 		if (this.internalTrack.demuxer.isFragmented) {
 			return this.performFragmentedLookup(
 				() => {
@@ -1679,24 +1683,24 @@ abstract class IsobmffTrackBacking<Chunk extends EncodedVideoChunk | EncodedAudi
 			);
 		}
 
-		return this.fetchChunkForSampleIndex(0, options);
+		return this.fetchSampleForSampleIndex(0, options);
 	}
 
-	private roundToMicrosecond(timestamp: number) {
-		// We transform the timestamp so that chunk retrieval behaves expectedly: All chunks returned have a timestamp
-		// that's floored to the microseconds, and that timestamp may be before the actual timestamp. But since the
-		// actual timestamp is never communicated to the outside, chunk retrieval should work like the timestamp is
-		// exactly equal to its floored version. This means, when we retrieve the chunk for timestamp 0.333333, but the
-		// chunk's true, unrounded timestamp is 1/3, then we would not retrieve that chunk, despite the chunk having a
-		// floored timestamp of 0.333333. That's why we transform the search timestamp by first flooring it to the
-		// microsecond, and then adding "1-eps" to it to make sure get all chunks whose timestamps will round down to
-		// a value included by the search timestamp.
-		return (Math.floor(timestamp * 1e6) + 0.99999999) / 1e6;
+	private intoTimescale(timestamp: number) {
+		const result = timestamp * this.internalTrack.timescale;
+		const rounded = Math.round(result);
+
+		if (Math.abs(1 - (result / rounded)) < 10 * Number.EPSILON) {
+			// The result is very close to an integer, meaning the number likely originated by an integer being divided
+			// by the timescale. For stability, it's best to return the integer in this case.
+			return rounded;
+		}
+
+		return result;
 	}
 
-	async getChunk(timestamp: number, options: ChunkRetrievalOptions) {
-		timestamp = this.roundToMicrosecond(timestamp);
-		const timestampInTimescale = timestamp * this.internalTrack.timescale;
+	async getSample(timestamp: number, options: SampleRetrievalOptions) {
+		const timestampInTimescale = this.intoTimescale(timestamp);
 
 		if (this.internalTrack.demuxer.isFragmented) {
 			return this.performFragmentedLookup(
@@ -1708,19 +1712,19 @@ abstract class IsobmffTrackBacking<Chunk extends EncodedVideoChunk | EncodedAudi
 		} else {
 			const sampleTable = this.internalTrack.demuxer.getSampleTableForTrack(this.internalTrack);
 			const sampleIndex = getSampleIndexForTimestamp(sampleTable, timestampInTimescale);
-			return this.fetchChunkForSampleIndex(sampleIndex, options);
+			return this.fetchSampleForSampleIndex(sampleIndex, options);
 		}
 	}
 
-	async getNextChunk(chunk: Chunk, options: ChunkRetrievalOptions) {
+	async getNextSample(sample: Sample, options: SampleRetrievalOptions) {
 		if (this.internalTrack.demuxer.isFragmented) {
-			const locationInFragment = this.chunkToFragmentLocation.get(chunk);
+			const locationInFragment = this.sampleToFragmentLocation.get(sample);
 			if (locationInFragment === undefined) {
-				throw new Error('Chunk was not created from this track.');
+				throw new Error('Sample was not created from this track.');
 			}
 
 			const trackData = locationInFragment.fragment.trackData.get(this.internalTrack.id)!;
-			const sample = trackData.samples[locationInFragment.sampleIndex]!;
+			const fragmentSample = trackData.samples[locationInFragment.sampleIndex]!;
 
 			const fragmentIndex = binarySearchExact(
 				this.internalTrack.fragments,
@@ -1767,22 +1771,21 @@ abstract class IsobmffTrackBacking<Chunk extends EncodedVideoChunk | EncodedAudi
 						};
 					}
 				},
-				sample.presentationTimestamp,
+				fragmentSample.presentationTimestamp,
 				Infinity,
 				options,
 			);
 		}
 
-		const sampleIndex = this.chunkToSampleIndex.get(chunk);
+		const sampleIndex = this.sampleToSampleIndex.get(sample);
 		if (sampleIndex === undefined) {
-			throw new Error('Chunk was not created from this track.');
+			throw new Error('Sample was not created from this track.');
 		}
-		return this.fetchChunkForSampleIndex(sampleIndex + 1, options);
+		return this.fetchSampleForSampleIndex(sampleIndex + 1, options);
 	}
 
-	async getKeyChunk(timestamp: number, options: ChunkRetrievalOptions) {
-		timestamp = this.roundToMicrosecond(timestamp);
-		const timestampInTimescale = timestamp * this.internalTrack.timescale;
+	async getKeySample(timestamp: number, options: SampleRetrievalOptions) {
+		const timestampInTimescale = this.intoTimescale(timestamp);
 
 		if (this.internalTrack.demuxer.isFragmented) {
 			return this.performFragmentedLookup(
@@ -1798,18 +1801,18 @@ abstract class IsobmffTrackBacking<Chunk extends EncodedVideoChunk | EncodedAudi
 		const keyFrameSampleIndex = sampleIndex === -1
 			? -1
 			: getRelevantKeyframeIndexForSample(sampleTable, sampleIndex);
-		return this.fetchChunkForSampleIndex(keyFrameSampleIndex, options);
+		return this.fetchSampleForSampleIndex(keyFrameSampleIndex, options);
 	}
 
-	async getNextKeyChunk(chunk: Chunk, options: ChunkRetrievalOptions) {
+	async getNextKeySample(sample: Sample, options: SampleRetrievalOptions) {
 		if (this.internalTrack.demuxer.isFragmented) {
-			const locationInFragment = this.chunkToFragmentLocation.get(chunk);
+			const locationInFragment = this.sampleToFragmentLocation.get(sample);
 			if (locationInFragment === undefined) {
-				throw new Error('Chunk was not created from this track.');
+				throw new Error('Sample was not created from this track.');
 			}
 
 			const trackData = locationInFragment.fragment.trackData.get(this.internalTrack.id)!;
-			const sample = trackData.samples[locationInFragment.sampleIndex]!;
+			const fragmentSample = trackData.samples[locationInFragment.sampleIndex]!;
 
 			const fragmentIndex = binarySearchExact(
 				this.internalTrack.fragments,
@@ -1866,22 +1869,22 @@ abstract class IsobmffTrackBacking<Chunk extends EncodedVideoChunk | EncodedAudi
 						};
 					}
 				},
-				sample.presentationTimestamp,
+				fragmentSample.presentationTimestamp,
 				Infinity,
 				options,
 			);
 		}
 
-		const sampleIndex = this.chunkToSampleIndex.get(chunk);
+		const sampleIndex = this.sampleToSampleIndex.get(sample);
 		if (sampleIndex === undefined) {
-			throw new Error('Chunk was not created from this track.');
+			throw new Error('Sample was not created from this track.');
 		}
 		const sampleTable = this.internalTrack.demuxer.getSampleTableForTrack(this.internalTrack);
 		const nextKeyFrameSampleIndex = getNextKeyframeIndexForSample(sampleTable, sampleIndex);
-		return this.fetchChunkForSampleIndex(nextKeyFrameSampleIndex, options);
+		return this.fetchSampleForSampleIndex(nextKeyFrameSampleIndex, options);
 	}
 
-	private async fetchChunkForSampleIndex(sampleIndex: number, options: ChunkRetrievalOptions) {
+	private async fetchSampleForSampleIndex(sampleIndex: number, options: SampleRetrievalOptions) {
 		if (sampleIndex === -1) {
 			return null;
 		}
@@ -1894,7 +1897,7 @@ abstract class IsobmffTrackBacking<Chunk extends EncodedVideoChunk | EncodedAudi
 
 		let data: Uint8Array;
 		if (options.metadataOnly) {
-			data = new Uint8Array(0); // Placeholder buffer
+			data = PLACEHOLDER_DATA;
 		} else {
 			// Load the entire chunk
 			await this.internalTrack.demuxer.chunkReader.reader.loadRange(
@@ -1906,42 +1909,54 @@ abstract class IsobmffTrackBacking<Chunk extends EncodedVideoChunk | EncodedAudi
 			data = this.internalTrack.demuxer.chunkReader.readBytes(sampleInfo.sampleSize);
 		}
 
-		const timestamp = 1e6 * sampleInfo.presentationTimestamp / this.internalTrack.timescale;
-		const duration = 1e6 * sampleInfo.duration / this.internalTrack.timescale;
-		const chunk = this.createChunk(data, timestamp, duration, sampleInfo.isKeyFrame);
+		const timestamp = sampleInfo.presentationTimestamp / this.internalTrack.timescale;
+		const duration = sampleInfo.duration / this.internalTrack.timescale;
+		const sample = this.createSample(
+			data,
+			sampleInfo.sampleSize,
+			sampleInfo.isKeyFrame ? 'key' : 'delta',
+			timestamp,
+			duration,
+		);
 
-		this.chunkToSampleIndex.set(chunk, sampleIndex);
+		this.sampleToSampleIndex.set(sample, sampleIndex);
 
-		return chunk;
+		return sample;
 	}
 
-	private async fetchChunkInFragment(fragment: Fragment, sampleIndex: number, options: ChunkRetrievalOptions) {
+	private async fetchSampleInFragment(fragment: Fragment, sampleIndex: number, options: SampleRetrievalOptions) {
 		if (sampleIndex === -1) {
 			return null;
 		}
 
 		const trackData = fragment.trackData.get(this.internalTrack.id)!;
-		const sample = trackData.samples[sampleIndex];
-		assert(sample);
+		const fragmentSample = trackData.samples[sampleIndex];
+		assert(fragmentSample);
 
 		let data: Uint8Array;
 		if (options.metadataOnly) {
-			data = new Uint8Array(0); // Placeholder buffer
+			data = PLACEHOLDER_DATA;
 		} else {
 			// Load the entire fragment
 			await this.internalTrack.demuxer.chunkReader.reader.loadRange(fragment.dataStart, fragment.dataEnd);
 
-			this.internalTrack.demuxer.chunkReader.pos = sample.byteOffset;
-			data = this.internalTrack.demuxer.chunkReader.readBytes(sample.byteSize);
+			this.internalTrack.demuxer.chunkReader.pos = fragmentSample.byteOffset;
+			data = this.internalTrack.demuxer.chunkReader.readBytes(fragmentSample.byteSize);
 		}
 
-		const timestamp = 1e6 * sample.presentationTimestamp / this.internalTrack.timescale;
-		const duration = 1e6 * sample.duration / this.internalTrack.timescale;
-		const chunk = this.createChunk(data, timestamp, duration, sample.isKeyFrame);
+		const timestamp = fragmentSample.presentationTimestamp / this.internalTrack.timescale;
+		const duration = fragmentSample.duration / this.internalTrack.timescale;
+		const sample = this.createSample(
+			data,
+			fragmentSample.byteSize,
+			fragmentSample.isKeyFrame ? 'key' : 'delta',
+			timestamp,
+			duration,
+		);
 
-		this.chunkToFragmentLocation.set(chunk, { fragment, sampleIndex });
+		this.sampleToFragmentLocation.set(sample, { fragment, sampleIndex });
 
-		return chunk;
+		return sample;
 	}
 
 	private findSampleInFragmentsForTimestamp(timestampInTimescale: number) {
@@ -2009,7 +2024,7 @@ abstract class IsobmffTrackBacking<Chunk extends EncodedVideoChunk | EncodedAudi
 		searchTimestamp: number,
 		// The timestamp for which we know the correct sample will not come after it
 		latestTimestamp: number,
-		options: ChunkRetrievalOptions,
+		options: SampleRetrievalOptions,
 	) {
 		const demuxer = this.internalTrack.demuxer;
 		const release = await demuxer.fragmentLookupMutex.acquire(); // The algorithm requires exclusivity
@@ -2019,7 +2034,7 @@ abstract class IsobmffTrackBacking<Chunk extends EncodedVideoChunk | EncodedAudi
 			if (correctSampleFound) {
 				// The correct sample already exists, easy path.
 				const fragment = this.internalTrack.fragments[fragmentIndex]!;
-				return this.fetchChunkInFragment(fragment, sampleIndex, options);
+				return this.fetchSampleInFragment(fragment, sampleIndex, options);
 			}
 
 			const isobmffReader = demuxer.isobmffReader;
@@ -2101,7 +2116,7 @@ abstract class IsobmffTrackBacking<Chunk extends EncodedVideoChunk | EncodedAudi
 					const { fragmentIndex, sampleIndex, correctSampleFound } = getBestMatch();
 					if (correctSampleFound) {
 						const fragment = this.internalTrack.fragments[fragmentIndex]!;
-						return this.fetchChunkInFragment(fragment, sampleIndex, options);
+						return this.fetchSampleInFragment(fragment, sampleIndex, options);
 					}
 					if (fragmentIndex !== -1) {
 						bestFragmentIndex = fragmentIndex;
@@ -2115,7 +2130,7 @@ abstract class IsobmffTrackBacking<Chunk extends EncodedVideoChunk | EncodedAudi
 			if (bestFragmentIndex !== -1) {
 				// If we finished looping but didn't find a perfect match, still return the best match we found
 				const fragment = this.internalTrack.fragments[bestFragmentIndex]!;
-				return this.fetchChunkInFragment(fragment, bestSampleIndex, options);
+				return this.fetchSampleInFragment(fragment, bestSampleIndex, options);
 			}
 
 			return null;
@@ -2125,7 +2140,7 @@ abstract class IsobmffTrackBacking<Chunk extends EncodedVideoChunk | EncodedAudi
 	}
 }
 
-class IsobmffVideoTrackBacking extends IsobmffTrackBacking<EncodedVideoChunk> implements InputVideoTrackBacking {
+class IsobmffVideoTrackBacking extends IsobmffTrackBacking<EncodedVideoSample> implements InputVideoTrackBacking {
 	override internalTrack: InternalVideoTrack;
 
 	constructor(internalTrack: InternalVideoTrack) {
@@ -2163,17 +2178,18 @@ class IsobmffVideoTrackBacking extends IsobmffTrackBacking<EncodedVideoChunk> im
 		};
 	}
 
-	createChunk(data: Uint8Array, timestamp: number, duration: number, isKeyFrame: boolean) {
-		return new EncodedVideoChunk({
-			data,
-			timestamp,
-			duration,
-			type: isKeyFrame ? 'key' : 'delta',
-		});
+	createSample(
+		data: Uint8Array,
+		byteLength: number,
+		type: SampleType,
+		timestamp: number,
+		duration: number,
+	) {
+		return new EncodedVideoSample(data, type, timestamp, duration, byteLength);
 	}
 }
 
-class IsobmffAudioTrackBacking extends IsobmffTrackBacking<EncodedAudioChunk> implements InputAudioTrackBacking {
+class IsobmffAudioTrackBacking extends IsobmffTrackBacking<EncodedAudioSample> implements InputAudioTrackBacking {
 	override internalTrack: InternalAudioTrack;
 
 	constructor(internalTrack: InternalAudioTrack) {
@@ -2206,13 +2222,14 @@ class IsobmffAudioTrackBacking extends IsobmffTrackBacking<EncodedAudioChunk> im
 		};
 	}
 
-	createChunk(data: Uint8Array, timestamp: number, duration: number, isKeyFrame: boolean) {
-		return new EncodedAudioChunk({
-			data,
-			timestamp,
-			duration,
-			type: isKeyFrame ? 'key' : 'delta',
-		});
+	createSample(
+		data: Uint8Array,
+		byteLength: number,
+		type: SampleType,
+		timestamp: number,
+		duration: number,
+	) {
+		return new EncodedAudioSample(data, type, timestamp, duration, byteLength);
 	}
 }
 
diff --git a/src/media-drain.ts b/src/media-drain.ts
index a043869..a4d4290 100644
--- a/src/media-drain.ts
+++ b/src/media-drain.ts
@@ -3,6 +3,7 @@ import { InputAudioTrack, InputVideoTrack } from './input-track';
 import {
 	AnyIterable,
 	assert,
+	binarySearchLessOrEqual,
 	getInt24,
 	getUint24,
 	mapAsyncGenerator,
@@ -10,13 +11,14 @@ import {
 	toAsyncIterator,
 	validateAnyIterable,
 } from './misc';
+import { EncodedAudioSample, EncodedVideoSample } from './sample';
 
 /** @public */
-export type ChunkRetrievalOptions = {
+export type SampleRetrievalOptions = {
 	metadataOnly?: boolean;
 };
 
-const validateChunkRetrievalOptions = (options: ChunkRetrievalOptions) => {
+const validateSampleRetrievalOptions = (options: SampleRetrievalOptions) => {
 	if (!options || typeof options !== 'object') {
 		throw new TypeError('options must be an object.');
 	}
@@ -32,15 +34,15 @@ const validateTimestamp = (timestamp: number) => {
 };
 
 /** @public */
-export abstract class BaseChunkDrain<Chunk extends EncodedVideoChunk | EncodedAudioChunk> {
-	abstract getFirstChunk(options?: ChunkRetrievalOptions): Promise<Chunk | null>;
-	abstract getChunk(timestamp: number, options?: ChunkRetrievalOptions): Promise<Chunk | null>;
-	abstract getNextChunk(chunk: Chunk, options?: ChunkRetrievalOptions): Promise<Chunk | null>;
-	abstract getKeyChunk(timestamp: number, options?: ChunkRetrievalOptions): Promise<Chunk | null>;
-	abstract getNextKeyChunk(chunk: Chunk, options?: ChunkRetrievalOptions): Promise<Chunk | null>;
+export abstract class BaseSampleDrain<Sample extends EncodedVideoSample | EncodedAudioSample> {
+	abstract getFirstSample(options?: SampleRetrievalOptions): Promise<Sample | null>;
+	abstract getSample(timestamp: number, options?: SampleRetrievalOptions): Promise<Sample | null>;
+	abstract getNextSample(sample: Sample, options?: SampleRetrievalOptions): Promise<Sample | null>;
+	abstract getKeySample(timestamp: number, options?: SampleRetrievalOptions): Promise<Sample | null>;
+	abstract getNextKeySample(sample: Sample, options?: SampleRetrievalOptions): Promise<Sample | null>;
 
-	chunks(startChunk?: Chunk, endTimestamp = Infinity): AsyncGenerator<Chunk, void, unknown> {
-		const chunkQueue: Chunk[] = [];
+	samples(startSample?: Sample, endTimestamp = Infinity): AsyncGenerator<Sample, void, unknown> {
+		const sampleQueue: Sample[] = [];
 
 		let { promise: queueNotEmpty, resolve: onQueueNotEmpty } = promiseWithResolvers();
 		let { promise: queueDequeue, resolve: onQueueDequeue } = promiseWithResolvers();
@@ -53,30 +55,30 @@ export abstract class BaseChunkDrain<Chunk extends EncodedVideoChunk | EncodedAu
 		let outOfBandError = null as Error | null;
 
 		const timestamps: number[] = [];
-		// The queue should always be big enough to hold 1 second worth of chunks
+		// The queue should always be big enough to hold 1 second worth of samples
 		const maxQueueSize = () => Math.max(2, timestamps.length);
 
-		// The following is the "pump" process that keeps pumping chunks into the queue
+		// The following is the "pump" process that keeps pumping samples into the queue
 		(async () => {
-			let chunk = startChunk ?? await this.getFirstChunk();
+			let sample = startSample ?? await this.getFirstSample();
 
-			while (chunk && !terminated) {
-				if (chunk.timestamp / 1e6 >= endTimestamp) {
+			while (sample && !terminated) {
+				if (sample.timestamp >= endTimestamp) {
 					break;
 				}
 
-				if (chunkQueue.length > maxQueueSize()) {
+				if (sampleQueue.length > maxQueueSize()) {
 					({ promise: queueDequeue, resolve: onQueueDequeue } = promiseWithResolvers());
 					await queueDequeue;
 					continue;
 				}
 
-				chunkQueue.push(chunk);
+				sampleQueue.push(sample);
 
 				onQueueNotEmpty();
 				({ promise: queueNotEmpty, resolve: onQueueNotEmpty } = promiseWithResolvers());
 
-				chunk = await this.getNextChunk(chunk);
+				sample = await this.getNextSample(sample);
 			}
 
 			ended = true;
@@ -95,8 +97,8 @@ export abstract class BaseChunkDrain<Chunk extends EncodedVideoChunk | EncodedAu
 						return { value: undefined, done: true };
 					} else if (outOfBandError) {
 						throw outOfBandError;
-					} else if (chunkQueue.length > 0) {
-						const value = chunkQueue.shift()!;
+					} else if (sampleQueue.length > 0) {
+						const value = sampleQueue.shift()!;
 						const now = performance.now();
 						timestamps.push(now);
 
@@ -131,220 +133,59 @@ export abstract class BaseChunkDrain<Chunk extends EncodedVideoChunk | EncodedAu
 	}
 }
 
+/** @public */
+export type WrappedMediaFrame<T extends VideoFrame | AudioData> = {
+	frame: T;
+	timestamp: number;
+	duration: number;
+};
+
 abstract class DecoderWrapper<
-	Chunk extends EncodedVideoChunk | EncodedAudioChunk,
+	Sample extends EncodedVideoSample | EncodedAudioSample,
 	MediaFrame extends VideoFrame | AudioData,
+	WrappedFrame extends WrappedMediaFrame<MediaFrame> = WrappedMediaFrame<MediaFrame>,
 > {
 	constructor(
-		public onMedia: (media: MediaFrame) => unknown,
+		public onFrame: (frame: WrappedFrame) => unknown,
 		public onError: (error: DOMException) => unknown,
 	) {}
 
 	abstract getDecodeQueueSize(): number;
-	abstract decode(chunk: Chunk): void;
+	abstract decode(sample: Sample): void;
 	abstract flush(): Promise<void>;
 	abstract close(): void;
 }
 
 /** @public */
 export abstract class BaseMediaFrameDrain<
-	Chunk extends EncodedVideoChunk | EncodedAudioChunk,
+	Sample extends EncodedVideoSample | EncodedAudioSample,
 	MediaFrame extends VideoFrame | AudioData,
+	WrappedFrame extends WrappedMediaFrame<MediaFrame> = WrappedMediaFrame<MediaFrame>,
 > {
 	/** @internal */
 	abstract _createDecoder(
-		onMedia: (media: MediaFrame) => unknown,
+		onFrame: (frame: WrappedFrame) => unknown,
 		onError: (error: DOMException) => unknown
-	): Promise<DecoderWrapper<Chunk, MediaFrame>>;
+	): Promise<DecoderWrapper<Sample, MediaFrame>>;
 	/** @internal */
-	abstract _createChunkDrain(): BaseChunkDrain<Chunk>;
+	abstract _createSampleDrain(): BaseSampleDrain<Sample>;
 
 	/** @internal */
-	private _duplicateFrame(frame: MediaFrame) {
+	private _duplicateFrame(frame: WrappedFrame) {
 		return structuredClone(frame);
 	}
 
-	protected mediaFramesAtTimestamps(
-		timestamps: AnyIterable<number>,
-	): AsyncGenerator<MediaFrame | null, void, unknown> {
-		validateAnyIterable(timestamps);
-		const timestampIterator = toAsyncIterator(timestamps);
-		const timestampsOfInterest: number[] = [];
-
-		const MAX_QUEUE_SIZE = 8;
-		const frameQueue: (MediaFrame | null)[] = [];
-		let { promise: queueNotEmpty, resolve: onQueueNotEmpty } = promiseWithResolvers();
-		let { promise: queueDequeue, resolve: onQueueDequeue } = promiseWithResolvers();
-		let decoderIsFlushed = false;
-		let terminated = false;
-
-		// This stores errors that are "out of band" in the sense that they didn't occur in the normal flow of this
-		// method but instead in a different context. This error should not go unnoticed and must be bubbled up to
-		// the consumer.
-		let outOfBandError = null as Error | null;
-
-		let lastUsedFrame = null as MediaFrame | null;
-		const pushToQueue = (frame: MediaFrame | null) => {
-			frameQueue.push(frame);
-			onQueueNotEmpty();
-			({ promise: queueNotEmpty, resolve: onQueueNotEmpty } = promiseWithResolvers());
-		};
-
-		// The following is the "pump" process that keeps pumping chunks into the decoder
-		(async () => {
-			const decoderError = new Error();
-			const decoder = await this._createDecoder((frame) => {
-				onQueueDequeue();
-
-				if (terminated) {
-					frame.close();
-					return;
-				}
-
-				let frameUsed = false;
-				while (timestampsOfInterest.length > 0 && timestampsOfInterest[0] === frame.timestamp) {
-					pushToQueue(this._duplicateFrame(frame));
-					timestampsOfInterest.shift();
-					frameUsed = true;
-				}
-
-				if (frameUsed) {
-					lastUsedFrame?.close();
-					lastUsedFrame = frame;
-				} else {
-					frame.close();
-				}
-			}, (error) => {
-				if (!outOfBandError) {
-					error.stack = decoderError.stack; // Provide a more useful stack trace
-					outOfBandError = error;
-					onQueueNotEmpty();
-				}
-			});
-
-			const chunkDrain = this._createChunkDrain();
-			let lastKeyChunk: Chunk | null = null;
-			let lastChunk: Chunk | null = null;
-
-			for await (const timestamp of timestampIterator) {
-				validateTimestamp(timestamp);
-
-				while (frameQueue.length + decoder.getDecodeQueueSize() > MAX_QUEUE_SIZE && !terminated) {
-					({ promise: queueDequeue, resolve: onQueueDequeue } = promiseWithResolvers());
-					await queueDequeue;
-				}
-
-				if (terminated) {
-					break;
-				}
-
-				const targetChunk = await chunkDrain.getChunk(timestamp);
-				if (!targetChunk) {
-					pushToQueue(null);
-					continue;
-				}
-
-				const keyChunk = await chunkDrain.getKeyChunk(timestamp);
-				if (!keyChunk) {
-					pushToQueue(null);
-					continue;
-				}
-
-				timestampsOfInterest.push(targetChunk.timestamp);
-
-				if (
-					lastKeyChunk
-					&& keyChunk.timestamp === lastKeyChunk.timestamp
-					&& targetChunk.timestamp >= lastChunk!.timestamp
-				) {
-					assert(lastChunk);
-
-					if (targetChunk.timestamp === lastChunk.timestamp && timestampsOfInterest.length === 1) {
-						// Special case: We have a repeat chunk, but the frame for that chunk has already been decoded.
-						// Therefore, we need to push the frame here instead of in the decoder callback.
-						if (lastUsedFrame) {
-							pushToQueue(this._duplicateFrame(lastUsedFrame));
-						}
-						timestampsOfInterest.shift();
-					}
-				} else {
-					lastKeyChunk = keyChunk;
-					lastChunk = keyChunk;
-					decoder.decode(keyChunk);
-				}
-
-				while (lastChunk.timestamp !== targetChunk.timestamp) {
-					const nextChunk = await chunkDrain.getNextChunk(lastChunk);
-					assert(nextChunk);
-
-					lastChunk = nextChunk;
-					decoder.decode(nextChunk);
-				}
-			}
-
-			if (!terminated) await decoder.flush();
-			decoder.close();
-
-			decoderIsFlushed = true;
-			onQueueNotEmpty(); // To unstuck the generator
-		})().catch((error: Error) => {
-			if (!outOfBandError) {
-				outOfBandError = error;
-				onQueueNotEmpty();
-			}
-		});
-
-		return {
-			async next() {
-				while (true) {
-					if (terminated) {
-						return { value: undefined, done: true };
-					} else if (outOfBandError) {
-						throw outOfBandError;
-					} else if (frameQueue.length > 0) {
-						const value = frameQueue.shift();
-						assert(value !== undefined);
-						onQueueDequeue();
-						return { value, done: false };
-					} else if (!decoderIsFlushed) {
-						await queueNotEmpty;
-					} else {
-						return { value: undefined, done: true };
-					}
-				}
-			},
-			async return() {
-				terminated = true;
-				onQueueDequeue();
-				onQueueNotEmpty();
-
-				for (const frame of frameQueue) {
-					frame?.close();
-				}
-				lastUsedFrame?.close();
-
-				return { value: undefined, done: true };
-			},
-			async throw(error) {
-				throw error;
-			},
-			[Symbol.asyncIterator]() {
-				return this;
-			},
-		};
-	}
-
 	protected mediaFramesInRange(
 		startTimestamp = 0,
 		endTimestamp = Infinity,
-	): AsyncGenerator<MediaFrame, void, unknown> {
+	): AsyncGenerator<WrappedFrame, void, unknown> {
 		validateTimestamp(startTimestamp);
 		validateTimestamp(endTimestamp);
 
 		const MAX_QUEUE_SIZE = 8;
-		const frameQueue: MediaFrame[] = [];
+		const frameQueue: WrappedFrame[] = [];
 		let firstFrameQueued = false;
-		let lastFrame: MediaFrame | null = null;
+		let lastFrame: WrappedFrame | null = null;
 		let { promise: queueNotEmpty, resolve: onQueueNotEmpty } = promiseWithResolvers();
 		let { promise: queueDequeue, resolve: onQueueDequeue } = promiseWithResolvers();
 		let decoderIsFlushed = false;
@@ -356,24 +197,22 @@ export abstract class BaseMediaFrameDrain<
 		// the consumer.
 		let outOfBandError = null as Error | null;
 
-		// The following is the "pump" process that keeps pumping chunks into the decoder
+		// The following is the "pump" process that keeps pumping samples into the decoder
 		(async () => {
 			const decoderError = new Error();
-			const decoder = await this._createDecoder((frame) => {
+			const decoder = await this._createDecoder((wrappedFrame) => {
 				onQueueDequeue();
-				const frameTimestamp = frame.timestamp / 1e6;
-
-				if (frameTimestamp >= endTimestamp) {
+				if (wrappedFrame.timestamp >= endTimestamp) {
 					ended = true;
 				}
 
 				if (ended) {
-					frame.close();
+					wrappedFrame.frame.close();
 					return;
 				}
 
 				if (lastFrame) {
-					if (frameTimestamp > startTimestamp) {
+					if (wrappedFrame.timestamp > startTimestamp) {
 						// We don't know ahead of time what the first first is. This is because the first first is the
 						// last first whose timestamp is less than or equal to the start timestamp. Therefore we need to
 						// wait for the first first after the start timestamp, and then we'll know that the previous
@@ -381,16 +220,16 @@ export abstract class BaseMediaFrameDrain<
 						frameQueue.push(lastFrame);
 						firstFrameQueued = true;
 					} else {
-						lastFrame.close();
+						lastFrame.frame.close();
 					}
 				}
 
-				if (frameTimestamp >= startTimestamp) {
-					frameQueue.push(frame);
+				if (wrappedFrame.timestamp >= startTimestamp) {
+					frameQueue.push(wrappedFrame);
 					firstFrameQueued = true;
 				}
 
-				lastFrame = firstFrameQueued ? null : frame;
+				lastFrame = firstFrameQueued ? null : wrappedFrame;
 
 				if (frameQueue.length > 0) {
 					onQueueNotEmpty();
@@ -404,53 +243,53 @@ export abstract class BaseMediaFrameDrain<
 				}
 			});
 
-			const chunkDrain = this._createChunkDrain();
-			const keyChunk = await chunkDrain.getKeyChunk(startTimestamp) ?? await chunkDrain.getFirstChunk();
-			if (!keyChunk) {
+			const sampleDrain = this._createSampleDrain();
+			const keySample = await sampleDrain.getKeySample(startTimestamp) ?? await sampleDrain.getFirstSample();
+			if (!keySample) {
 				return;
 			}
 
-			let currentChunk: Chunk | null = keyChunk;
+			let currentSample: Sample | null = keySample;
 
-			let chunksEndTimestamp = Infinity;
+			let samplesEndTimestamp = Infinity;
 			if (endTimestamp < Infinity) {
-				// When an end timestamp is set, we cannot simply use that for the chunk iterator due to out-of-order
-				// frames (B-frames). Instead, we'll need to keep decoding chunks until we get a frame that exceeds
+				// When an end timestamp is set, we cannot simply use that for the sample iterator due to out-of-order
+				// frames (B-frames). Instead, we'll need to keep decoding samples until we get a frame that exceeds
 				// this end time. However, we can still put a bound on it: Since key frames are by definition never
 				// out of order, we can stop at the first key frame after the end timestamp.
-				const endFrame = await chunkDrain.getChunk(endTimestamp);
-				const endKeyFrame = !endFrame
+				const endSample = await sampleDrain.getSample(endTimestamp);
+				const endKeySample = !endSample
 					? null
-					: endFrame.type === 'key' && endFrame.timestamp / 1e6 === endTimestamp
-						? endFrame
-						: await chunkDrain.getNextKeyChunk(endFrame);
+					: endSample.type === 'key' && endSample.timestamp === endTimestamp
+						? endSample
+						: await sampleDrain.getNextKeySample(endSample);
 
-				if (endKeyFrame) {
-					chunksEndTimestamp = endKeyFrame.timestamp / 1e6;
+				if (endKeySample) {
+					samplesEndTimestamp = endKeySample.timestamp;
 				}
 			}
 
-			const chunks = chunkDrain.chunks(keyChunk, chunksEndTimestamp);
-			await chunks.next(); // Skip the start chunk as we already have it
+			const samples = sampleDrain.samples(keySample, samplesEndTimestamp);
+			await samples.next(); // Skip the start sample as we already have it
 
-			while (currentChunk && !ended) {
+			while (currentSample && !ended) {
 				if (frameQueue.length + decoder.getDecodeQueueSize() > MAX_QUEUE_SIZE) {
 					({ promise: queueDequeue, resolve: onQueueDequeue } = promiseWithResolvers());
 					await queueDequeue;
 					continue;
 				}
 
-				decoder.decode(currentChunk);
+				decoder.decode(currentSample);
 
-				const chunkResult = await chunks.next();
-				if (chunkResult.done) {
+				const sampleResult = await samples.next();
+				if (sampleResult.done) {
 					break;
 				}
 
-				currentChunk = chunkResult.value;
+				currentSample = sampleResult.value;
 			}
 
-			await chunks.return();
+			await samples.return();
 
 			if (!terminated) await decoder.flush();
 			decoder.close();
@@ -493,7 +332,7 @@ export abstract class BaseMediaFrameDrain<
 				onQueueNotEmpty();
 
 				for (const frame of frameQueue) {
-					frame.close();
+					frame.frame.close();
 				}
 
 				return { value: undefined, done: true };
@@ -506,10 +345,180 @@ export abstract class BaseMediaFrameDrain<
 			},
 		};
 	}
+
+	protected mediaFramesAtTimestamps(
+		timestamps: AnyIterable<number>,
+	): AsyncGenerator<WrappedFrame | null, void, unknown> {
+		validateAnyIterable(timestamps);
+		const timestampIterator = toAsyncIterator(timestamps);
+		const timestampsOfInterest: number[] = [];
+
+		const MAX_QUEUE_SIZE = 8;
+		const frameQueue: (WrappedFrame | null)[] = [];
+		let { promise: queueNotEmpty, resolve: onQueueNotEmpty } = promiseWithResolvers();
+		let { promise: queueDequeue, resolve: onQueueDequeue } = promiseWithResolvers();
+		let decoderIsFlushed = false;
+		let terminated = false;
+
+		// This stores errors that are "out of band" in the sense that they didn't occur in the normal flow of this
+		// method but instead in a different context. This error should not go unnoticed and must be bubbled up to
+		// the consumer.
+		let outOfBandError = null as Error | null;
+
+		let lastUsedFrame = null as WrappedFrame | null;
+		const pushToQueue = (frame: WrappedFrame | null) => {
+			frameQueue.push(frame);
+			onQueueNotEmpty();
+			({ promise: queueNotEmpty, resolve: onQueueNotEmpty } = promiseWithResolvers());
+		};
+
+		// The following is the "pump" process that keeps pumping samples into the decoder
+		(async () => {
+			const decoderError = new Error();
+			const decoder = await this._createDecoder((wrappedFrame) => {
+				onQueueDequeue();
+
+				if (terminated) {
+					wrappedFrame.frame.close();
+					return;
+				}
+
+				let frameUsed = false;
+				while (timestampsOfInterest.length > 0 && timestampsOfInterest[0] === wrappedFrame.timestamp) {
+					pushToQueue(this._duplicateFrame(wrappedFrame));
+					timestampsOfInterest.shift();
+					frameUsed = true;
+				}
+
+				if (frameUsed) {
+					lastUsedFrame?.frame.close();
+					lastUsedFrame = wrappedFrame;
+				} else {
+					wrappedFrame.frame.close();
+				}
+			}, (error) => {
+				if (!outOfBandError) {
+					error.stack = decoderError.stack; // Provide a more useful stack trace
+					outOfBandError = error;
+					onQueueNotEmpty();
+				}
+			});
+
+			const sampleDrain = this._createSampleDrain();
+			let lastKeySample: Sample | null = null;
+			let lastSample: Sample | null = null;
+
+			for await (const timestamp of timestampIterator) {
+				validateTimestamp(timestamp);
+
+				while (frameQueue.length + decoder.getDecodeQueueSize() > MAX_QUEUE_SIZE && !terminated) {
+					({ promise: queueDequeue, resolve: onQueueDequeue } = promiseWithResolvers());
+					await queueDequeue;
+				}
+
+				if (terminated) {
+					break;
+				}
+
+				const targetSample = await sampleDrain.getSample(timestamp);
+				if (!targetSample) {
+					pushToQueue(null);
+					continue;
+				}
+
+				const keySample = await sampleDrain.getKeySample(timestamp);
+				if (!keySample) {
+					pushToQueue(null);
+					continue;
+				}
+
+				timestampsOfInterest.push(targetSample.timestamp);
+
+				if (
+					lastKeySample
+					&& keySample.timestamp === lastKeySample.timestamp
+					&& targetSample.timestamp >= lastSample!.timestamp
+				) {
+					assert(lastSample);
+
+					if (targetSample.timestamp === lastSample.timestamp && timestampsOfInterest.length === 1) {
+						// Special case: We have a repeat sample, but the frame for that sample has already been
+						// decoded. Therefore, we need to push the frame here instead of in the decoder callback.
+						if (lastUsedFrame) {
+							pushToQueue(this._duplicateFrame(lastUsedFrame));
+						}
+						timestampsOfInterest.shift();
+					}
+				} else {
+					lastKeySample = keySample;
+					lastSample = keySample;
+					decoder.decode(keySample);
+				}
+
+				while (lastSample.timestamp !== targetSample.timestamp) {
+					const nextSample = await sampleDrain.getNextSample(lastSample);
+					assert(nextSample);
+
+					lastSample = nextSample;
+					decoder.decode(nextSample);
+				}
+			}
+
+			if (!terminated) await decoder.flush();
+			decoder.close();
+
+			decoderIsFlushed = true;
+			onQueueNotEmpty(); // To unstuck the generator
+		})().catch((error: Error) => {
+			if (!outOfBandError) {
+				outOfBandError = error;
+				onQueueNotEmpty();
+			}
+		});
+
+		return {
+			async next() {
+				while (true) {
+					if (terminated) {
+						return { value: undefined, done: true };
+					} else if (outOfBandError) {
+						throw outOfBandError;
+					} else if (frameQueue.length > 0) {
+						const value = frameQueue.shift();
+						assert(value !== undefined);
+						onQueueDequeue();
+						return { value, done: false };
+					} else if (!decoderIsFlushed) {
+						await queueNotEmpty;
+					} else {
+						return { value: undefined, done: true };
+					}
+				}
+			},
+			async return() {
+				terminated = true;
+				onQueueDequeue();
+				onQueueNotEmpty();
+
+				for (const frame of frameQueue) {
+					frame?.frame.close();
+				}
+				lastUsedFrame?.frame.close();
+
+				return { value: undefined, done: true };
+			},
+			async throw(error) {
+				throw error;
+			},
+			[Symbol.asyncIterator]() {
+				return this;
+			},
+		};
+	}
 }
 
 /** @public */
-export class EncodedVideoChunkDrain extends BaseChunkDrain<EncodedVideoChunk> {
+export class EncodedVideoSampleDrain extends BaseSampleDrain<EncodedVideoSample> {
 	/** @internal */
 	_videoTrack: InputVideoTrack;
 
@@ -523,51 +532,64 @@ export class EncodedVideoChunkDrain extends BaseChunkDrain<EncodedVideoChunk> {
 		this._videoTrack = videoTrack;
 	}
 
-	getFirstChunk(options: ChunkRetrievalOptions = {}) {
-		validateChunkRetrievalOptions(options);
-		return this._videoTrack._backing.getFirstChunk(options);
+	getFirstSample(options: SampleRetrievalOptions = {}) {
+		validateSampleRetrievalOptions(options);
+		return this._videoTrack._backing.getFirstSample(options);
 	}
 
-	getChunk(timestamp: number, options: ChunkRetrievalOptions = {}) {
+	getSample(timestamp: number, options: SampleRetrievalOptions = {}) {
 		validateTimestamp(timestamp);
-		validateChunkRetrievalOptions(options);
-		return this._videoTrack._backing.getChunk(timestamp, options);
+		validateSampleRetrievalOptions(options);
+		return this._videoTrack._backing.getSample(timestamp, options);
 	}
 
-	getNextChunk(chunk: EncodedVideoChunk, options: ChunkRetrievalOptions = {}) {
-		if (!(chunk instanceof EncodedVideoChunk)) {
-			throw new TypeError('chunk must be an EncodedVideoChunk.');
+	getNextSample(sample: EncodedVideoSample, options: SampleRetrievalOptions = {}) {
+		if (!(sample instanceof EncodedVideoSample)) {
+			throw new TypeError('sample must be an EncodedVideoSample.');
 		}
-		validateChunkRetrievalOptions(options);
-		return this._videoTrack._backing.getNextChunk(chunk, options);
+		validateSampleRetrievalOptions(options);
+		return this._videoTrack._backing.getNextSample(sample, options);
 	}
 
-	getKeyChunk(timestamp: number, options: ChunkRetrievalOptions = {}) {
+	getKeySample(timestamp: number, options: SampleRetrievalOptions = {}) {
 		validateTimestamp(timestamp);
-		validateChunkRetrievalOptions(options);
-		return this._videoTrack._backing.getKeyChunk(timestamp, options);
+		validateSampleRetrievalOptions(options);
+		return this._videoTrack._backing.getKeySample(timestamp, options);
 	}
 
-	getNextKeyChunk(chunk: EncodedVideoChunk, options: ChunkRetrievalOptions = {}) {
-		if (!(chunk instanceof EncodedVideoChunk)) {
-			throw new TypeError('chunk must be an EncodedVideoChunk.');
+	getNextKeySample(sample: EncodedVideoSample, options: SampleRetrievalOptions = {}) {
+		if (!(sample instanceof EncodedVideoSample)) {
+			throw new TypeError('sample must be an EncodedVideoSample.');
 		}
-		validateChunkRetrievalOptions(options);
-		return this._videoTrack._backing.getNextKeyChunk(chunk, options);
+		validateSampleRetrievalOptions(options);
+		return this._videoTrack._backing.getNextKeySample(sample, options);
 	}
 }
 
-class VideoDecoderWrapper extends DecoderWrapper<EncodedVideoChunk, VideoFrame> {
+class VideoDecoderWrapper extends DecoderWrapper<EncodedVideoSample, VideoFrame> {
 	decoder: VideoDecoder;
+	pendingSamples: EncodedVideoSample[] = [];
 
 	constructor(
-		onFrame: (frame: VideoFrame) => unknown,
+		onFrame: (frame: WrappedMediaFrame<VideoFrame>) => unknown,
 		onError: (error: DOMException) => unknown,
 		decoderConfig: VideoDecoderConfig,
 	) {
 		super(onFrame, onError);
 
-		this.decoder = new VideoDecoder({ output: onFrame, error: onError });
+		this.decoder = new VideoDecoder({
+			output: (frame) => {
+				const sample = this.pendingSamples.shift();
+				assert(sample);
+
+				onFrame({
+					frame,
+					timestamp: sample.timestamp,
+					duration: sample.duration,
+				});
+			},
+			error: onError,
+		});
 		this.decoder.configure(decoderConfig);
 	}
 
@@ -575,8 +597,12 @@ class VideoDecoderWrapper extends DecoderWrapper<EncodedVideoChunk, VideoFrame>
 		return this.decoder.decodeQueueSize;
 	}
 
-	decode(chunk: EncodedVideoChunk) {
-		this.decoder.decode(chunk);
+	decode(sample: EncodedVideoSample) {
+		// We know the decoder spits out frames in sorted order, so we need to insert the sample in the right place
+		const insertionIndex = binarySearchLessOrEqual(this.pendingSamples, sample.timestamp, x => x.timestamp);
+		this.pendingSamples.splice(insertionIndex + 1, 0, sample);
+
+		this.decoder.decode(sample.toEncodedVideoChunk());
 	}
 
 	flush() {
@@ -589,7 +615,7 @@ class VideoDecoderWrapper extends DecoderWrapper<EncodedVideoChunk, VideoFrame>
 }
 
 /** @public */
-export class VideoFrameDrain extends BaseMediaFrameDrain<EncodedVideoChunk, VideoFrame> {
+export class VideoFrameDrain extends BaseMediaFrameDrain<EncodedVideoSample, VideoFrame> {
 	/** @internal */
 	_videoTrack: InputVideoTrack;
 
@@ -604,7 +630,10 @@ export class VideoFrameDrain extends BaseMediaFrameDrain<EncodedVideoChunk, Vide
 	}
 
 	/** @internal */
-	async _createDecoder(onFrame: (frame: VideoFrame) => unknown, onError: (error: DOMException) => unknown) {
+	async _createDecoder(
+		onFrame: (frame: WrappedMediaFrame<VideoFrame>) => unknown,
+		onError: (error: DOMException) => unknown,
+	) {
 		if (!(await this._videoTrack.canDecode())) {
 			throw new Error(
 				'This video track cannot be decoded by this browser. Make sure to check decodability before using'
@@ -619,8 +648,8 @@ export class VideoFrameDrain extends BaseMediaFrameDrain<EncodedVideoChunk, Vide
 	}
 
 	/** @internal */
-	_createChunkDrain() {
-		return new EncodedVideoChunkDrain(this._videoTrack);
+	_createSampleDrain() {
+		return new EncodedVideoSampleDrain(this._videoTrack);
 	}
 
 	async getFrame(timestamp: number) {
@@ -677,7 +706,9 @@ export class CanvasDrain {
 	}
 
 	/** @internal */
-	async _videoFrameToWrappedCanvas(frame: VideoFrame): Promise<WrappedCanvas> {
+	async _videoFrameToWrappedCanvas(
+		frame: WrappedMediaFrame<VideoFrame>,
+	): Promise<WrappedCanvas> {
 		const width = this._dimensions?.width ?? await this._videoTrack.getDisplayWidth();
 		const height = this._dimensions?.height ?? await this._videoTrack.getDisplayHeight();
 		const rotation = await this._videoTrack.getRotation();
@@ -695,15 +726,15 @@ export class CanvasDrain {
 
 		const [imageWidth, imageHeight] = rotation % 180 === 0 ? [width, height] : [height, width];
 
-		context.drawImage(frame, (width - imageWidth) / 2, (height - imageHeight) / 2, imageWidth, imageHeight);
+		context.drawImage(frame.frame, (width - imageWidth) / 2, (height - imageHeight) / 2, imageWidth, imageHeight);
 
 		const result = {
 			canvas,
-			timestamp: frame.timestamp / 1e6,
-			duration: (frame.duration ?? 0) / 1e6,
+			timestamp: frame.timestamp,
+			duration: frame.duration,
 		};
 
-		frame.close();
+		frame.frame.close();
 		return result;
 	}
 
@@ -730,7 +761,7 @@ export class CanvasDrain {
 }
 
 /** @public */
-export class EncodedAudioChunkDrain extends BaseChunkDrain<EncodedAudioChunk> {
+export class EncodedAudioSampleDrain extends BaseSampleDrain<EncodedAudioSample> {
 	/** @internal */
 	_audioTrack: InputAudioTrack;
 
@@ -744,51 +775,61 @@ export class EncodedAudioChunkDrain extends BaseChunkDrain<EncodedAudioChunk> {
 		this._audioTrack = audioTrack;
 	}
 
-	getFirstChunk(options: ChunkRetrievalOptions = {}) {
-		validateChunkRetrievalOptions(options);
-		return this._audioTrack._backing.getFirstChunk(options);
+	getFirstSample(options: SampleRetrievalOptions = {}) {
+		validateSampleRetrievalOptions(options);
+		return this._audioTrack._backing.getFirstSample(options);
 	}
 
-	getChunk(timestamp: number, options: ChunkRetrievalOptions = {}) {
+	getSample(timestamp: number, options: SampleRetrievalOptions = {}) {
 		validateTimestamp(timestamp);
-		validateChunkRetrievalOptions(options);
-		return this._audioTrack._backing.getChunk(timestamp, options);
+		validateSampleRetrievalOptions(options);
+		return this._audioTrack._backing.getSample(timestamp, options);
 	}
 
-	getNextChunk(chunk: EncodedAudioChunk, options: ChunkRetrievalOptions = {}) {
-		if (!(chunk instanceof EncodedAudioChunk)) {
-			throw new TypeError('chunk must be an EncodedAudioChunk.');
+	getNextSample(sample: EncodedAudioSample, options: SampleRetrievalOptions = {}) {
+		if (!(sample instanceof EncodedAudioSample)) {
+			throw new TypeError('sample must be an EncodedAudioSample.');
 		}
-		validateChunkRetrievalOptions(options);
-		return this._audioTrack._backing.getNextChunk(chunk, options);
+		validateSampleRetrievalOptions(options);
+		return this._audioTrack._backing.getNextSample(sample, options);
 	}
 
-	getKeyChunk(timestamp: number, options: ChunkRetrievalOptions = {}) {
+	getKeySample(timestamp: number, options: SampleRetrievalOptions = {}) {
 		validateTimestamp(timestamp);
-		validateChunkRetrievalOptions(options);
-		return this._audioTrack._backing.getKeyChunk(timestamp, options);
+		validateSampleRetrievalOptions(options);
+		return this._audioTrack._backing.getKeySample(timestamp, options);
 	}
 
-	getNextKeyChunk(chunk: EncodedAudioChunk, options: ChunkRetrievalOptions = {}) {
-		if (!(chunk instanceof EncodedAudioChunk)) {
-			throw new TypeError('chunk must be an EncodedAudioChunk.');
+	getNextKeySample(sample: EncodedAudioSample, options: SampleRetrievalOptions = {}) {
+		if (!(sample instanceof EncodedAudioSample)) {
+			throw new TypeError('sample must be an EncodedAudioSample.');
 		}
-		validateChunkRetrievalOptions(options);
-		return this._audioTrack._backing.getNextKeyChunk(chunk, options);
+		validateSampleRetrievalOptions(options);
+		return this._audioTrack._backing.getNextKeySample(sample, options);
 	}
 }
 
-class AudioDecoderWrapper extends DecoderWrapper<EncodedAudioChunk, AudioData> {
+class AudioDecoderWrapper extends DecoderWrapper<EncodedAudioSample, AudioData> {
 	decoder: AudioDecoder;
+	pendingSamples: EncodedAudioSample[] = [];
 
 	constructor(
-		onData: (data: AudioData) => unknown,
+		onData: (data: WrappedMediaFrame<AudioData>) => unknown,
 		onError: (error: DOMException) => unknown,
 		decoderConfig: AudioDecoderConfig,
 	) {
 		super(onData, onError);
 
-		this.decoder = new AudioDecoder({ output: onData, error: onError });
+		this.decoder = new AudioDecoder({ output: (data) => {
+			const sample = this.pendingSamples.shift();
+			assert(sample);
+
+			onData({
+				frame: data,
+				timestamp: sample.timestamp,
+				duration: sample.duration,
+			});
+		}, error: onError });
 		this.decoder.configure(decoderConfig);
 	}
 
@@ -796,8 +837,12 @@ class AudioDecoderWrapper extends DecoderWrapper<EncodedAudioChunk, AudioData> {
 		return this.decoder.decodeQueueSize;
 	}
 
-	decode(chunk: EncodedAudioChunk) {
-		this.decoder.decode(chunk);
+	decode(sample: EncodedAudioSample) {
+		// We know the decoder spits out data in sorted order, so we need to insert the sample in the right place
+		const insertionIndex = binarySearchLessOrEqual(this.pendingSamples, sample.timestamp, x => x.timestamp);
+		this.pendingSamples.splice(insertionIndex + 1, 0, sample);
+
+		this.decoder.decode(sample.toEncodedAudioChunk());
 	}
 
 	flush() {
@@ -813,7 +858,7 @@ const PCM_CODEC_REGEX = /^pcm-([usf])(\d+)+(be)?$/;
 
 // There are a lot of PCM variants not natively supported by the browser and by AudioData. Therefore we need a simple
 // decoder that maps any input PCM format into a PCM format supported by the browser.
-class PcmAudioDecoderWrapper extends DecoderWrapper<EncodedAudioChunk, AudioData> {
+class PcmAudioDecoderWrapper extends DecoderWrapper<EncodedAudioSample, AudioData> {
 	codec: PcmAudioCodec;
 
 	inputSampleSize: 1 | 2 | 3 | 4;
@@ -824,7 +869,7 @@ class PcmAudioDecoderWrapper extends DecoderWrapper<EncodedAudioChunk, AudioData
 	writeOutputValue: (view: DataView, byteOffset: number, value: number) => void;
 
 	constructor(
-		onData: (data: AudioData) => unknown,
+		onData: (data: WrappedMediaFrame<AudioData>) => unknown,
 		onError: (error: DOMException) => unknown,
 		public decoderConfig: AudioDecoderConfig,
 	) {
@@ -918,12 +963,10 @@ class PcmAudioDecoderWrapper extends DecoderWrapper<EncodedAudioChunk, AudioData
 		return 0;
 	}
 
-	decode(chunk: EncodedAudioChunk) {
-		const inputBuffer = new ArrayBuffer(chunk.byteLength);
-		const inputView = new DataView(inputBuffer);
-		chunk.copyTo(inputBuffer);
+	decode(sample: EncodedAudioSample) {
+		const inputView = new DataView(sample.data.buffer, sample.data.byteOffset, sample.byteLength);
 
-		const numberOfFrames = chunk.byteLength / this.decoderConfig.numberOfChannels / this.inputSampleSize;
+		const numberOfFrames = sample.byteLength / this.decoderConfig.numberOfChannels / this.inputSampleSize;
 
 		const outputBufferSize = numberOfFrames * this.decoderConfig.numberOfChannels * this.outputSampleSize;
 		const outputBuffer = new ArrayBuffer(outputBufferSize);
@@ -943,11 +986,15 @@ class PcmAudioDecoderWrapper extends DecoderWrapper<EncodedAudioChunk, AudioData
 			numberOfChannels: this.decoderConfig.numberOfChannels,
 			sampleRate: this.decoderConfig.sampleRate,
 			numberOfFrames,
-			timestamp: chunk.timestamp,
+			timestamp: sample.timestamp,
 		});
 
 		// Since all other decoders are async, we'll make this one behave async as well
-		queueMicrotask(() => this.onMedia(audioData));
+		queueMicrotask(() => this.onFrame({
+			frame: audioData,
+			timestamp: sample.timestamp,
+			duration: sample.duration,
+		}));
 	}
 
 	async flush() {
@@ -960,7 +1007,7 @@ class PcmAudioDecoderWrapper extends DecoderWrapper<EncodedAudioChunk, AudioData
 }
 
 /** @public */
-export class AudioDataDrain extends BaseMediaFrameDrain<EncodedAudioChunk, AudioData> {
+export class AudioDataDrain extends BaseMediaFrameDrain<EncodedAudioSample, AudioData> {
 	/** @internal */
 	_audioTrack: InputAudioTrack;
 
@@ -975,7 +1022,10 @@ export class AudioDataDrain extends BaseMediaFrameDrain<EncodedAudioChunk, Audio
 	}
 
 	/** @internal */
-	async _createDecoder(onData: (data: AudioData) => unknown, onError: (error: DOMException) => unknown) {
+	async _createDecoder(
+		onData: (data: WrappedMediaFrame<AudioData>) => unknown,
+		onError: (error: DOMException) => unknown,
+	) {
 		if (!(await this._audioTrack.canDecode())) {
 			throw new Error(
 				'This audio track cannot be decoded by this browser. Make sure to check decodability before using'
@@ -994,8 +1044,8 @@ export class AudioDataDrain extends BaseMediaFrameDrain<EncodedAudioChunk, Audio
 	}
 
 	/** @internal */
-	_createChunkDrain() {
-		return new EncodedAudioChunkDrain(this._audioTrack);
+	_createSampleDrain() {
+		return new EncodedAudioSampleDrain(this._audioTrack);
 	}
 
 	async getData(timestamp: number) {
@@ -1020,6 +1070,7 @@ export class AudioDataDrain extends BaseMediaFrameDrain<EncodedAudioChunk, Audio
 export type WrappedAudioBuffer = {
 	buffer: AudioBuffer;
 	timestamp: number;
+	duration: number;
 };
 
 /** @public */
@@ -1036,30 +1087,28 @@ export class AudioBufferDrain {
 	}
 
 	/** @internal */
-	_audioDataToWrappedArrayBuffer(data: AudioData): WrappedAudioBuffer {
+	_audioDataToWrappedArrayBuffer(data: WrappedMediaFrame<AudioData>): WrappedAudioBuffer {
 		const audioBuffer = new AudioBuffer({
-			numberOfChannels: data.numberOfChannels,
-			length: data.numberOfFrames,
-			sampleRate: data.sampleRate,
+			numberOfChannels: data.frame.numberOfChannels,
+			length: data.frame.numberOfFrames,
+			sampleRate: data.frame.sampleRate,
 		});
 
 		// All user agents are required to support conversion to f32-planar
-		const dataBytes = new Float32Array(data.allocationSize({ planeIndex: 0, format: 'f32-planar' }) / 4);
+		const dataBytes = new Float32Array(data.frame.allocationSize({ planeIndex: 0, format: 'f32-planar' }) / 4);
 
-		for (let i = 0; i < data.numberOfChannels; i++) {
-			data.copyTo(dataBytes, { planeIndex: i, format: 'f32-planar' });
+		for (let i = 0; i < data.frame.numberOfChannels; i++) {
+			data.frame.copyTo(dataBytes, { planeIndex: i, format: 'f32-planar' });
 			audioBuffer.copyToChannel(dataBytes, i);
 		}
 
-		const sampleDuration = 1 / data.sampleRate;
-
 		const result = {
 			buffer: audioBuffer,
-			// Rounding the timestamp based on the sample duration removes audio playback artifacts
-			timestamp: Math.round(data.timestamp / 1e6 / sampleDuration) * sampleDuration,
+			timestamp: data.timestamp,
+			duration: data.duration,
 		};
 
-		data.close();
+		data.frame.close();
 		return result;
 	}
 
diff --git a/src/reader.ts b/src/reader.ts
index b0b32a7..0f859f7 100644
--- a/src/reader.ts
+++ b/src/reader.ts
@@ -34,10 +34,24 @@ export class Reader {
 			return;
 		}
 
-		const encasingSegmentExists = this.loadedSegments.some(x => x.start <= start && x.end >= end);
-		if (encasingSegmentExists) {
-			// Nothing to load
-			return;
+		const index = binarySearchLessOrEqual(
+			this.loadedSegments,
+			start,
+			x => x.start,
+		);
+		if (index !== -1) {
+			for (let i = index; i < this.loadedSegments.length; i++) {
+				const segment = this.loadedSegments[i]!;
+				if (segment.start > start) {
+					break;
+				}
+
+				const segmentEncasesRequestedRange = segment.end >= end;
+				if (segmentEncasesRequestedRange) {
+					// Nothing to load
+					return;
+				}
+			}
 		}
 
 		const bytesPromise = this.source._read(start, end);
diff --git a/src/sample.ts b/src/sample.ts
new file mode 100644
index 0000000..2e6aa3f
--- /dev/null
+++ b/src/sample.ts
@@ -0,0 +1,84 @@
+export const PLACEHOLDER_DATA = new Uint8Array(0);
+
+/** @public */
+export type SampleType = 'key' | 'delta';
+
+/** @public */
+export class EncodedVideoSample {
+	constructor(
+		public readonly data: Uint8Array,
+		public readonly type: SampleType,
+		public readonly timestamp: number,
+		public readonly duration: number,
+		public readonly byteLength = data.byteLength,
+	) {}
+
+	get isMetadataOnly() {
+		return this.data === PLACEHOLDER_DATA;
+	}
+
+	get microsecondTimestamp() {
+		return Math.floor(1e6 * this.timestamp);
+	}
+
+	get microsecondDuration() {
+		return Math.floor(1e6 * this.duration);
+	}
+
+	toEncodedVideoChunk() {
+		if (this.isMetadataOnly) {
+			throw new TypeError('Metadata-only samples cannot be converted to a chunk.');
+		}
+
+		if (typeof EncodedVideoChunk === 'undefined') {
+			throw new Error('Your browser does not support EncodedVideoChunk.');
+		}
+
+		return new EncodedVideoChunk({
+			data: this.data,
+			type: this.type,
+			timestamp: this.microsecondTimestamp,
+			duration: this.microsecondDuration,
+		});
+	}
+}
+
+/** @public */
+export class EncodedAudioSample {
+	constructor(
+		public readonly data: Uint8Array,
+		public readonly type: SampleType,
+		public readonly timestamp: number,
+		public readonly duration: number,
+		public readonly byteLength = data.byteLength,
+	) {}
+
+	get isMetadataOnly() {
+		return this.data === PLACEHOLDER_DATA;
+	}
+
+	get microsecondTimestamp() {
+		return Math.floor(1e6 * this.timestamp);
+	}
+
+	get microsecondDuration() {
+		return Math.floor(1e6 * this.duration);
+	}
+
+	toEncodedAudioChunk() {
+		if (this.isMetadataOnly) {
+			throw new TypeError('Metadata-only samples cannot be converted to a chunk.');
+		}
+
+		if (typeof EncodedAudioChunk === 'undefined') {
+			throw new Error('Your browser does not support EncodedAudioChunk.');
+		}
+
+		return new EncodedAudioChunk({
+			data: this.data,
+			type: this.type,
+			timestamp: this.microsecondTimestamp,
+			duration: this.microsecondDuration,
+		});
+	}
+}
