@osmo.inc/cli 0.1.18 → 0.1.19

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

@@ -1,2519 +0,0 @@
-/*!
- * 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 { TrackType } from '../output';
-import { SAMPLES_PER_AAC_FRAME } from '../adts/adts-demuxer';
-import { MAX_ADTS_FRAME_HEADER_SIZE, readAdtsFrameHeader } from '../adts/adts-reader';
-import { aacChannelMap, aacFrequencyTable } from '../../shared/aac-misc';
-import {
-	AacCodecInfo,
-	AudioCodec,
-	extractAudioCodecString,
-	extractVideoCodecString,
-	MediaCodec,
-	VideoCodec,
-} from '../codec';
-import {
-	AC3_ACMOD_CHANNEL_COUNTS,
-	AC3_SAMPLES_PER_FRAME,
-	AvcDecoderConfigurationRecord,
-	AvcNalUnitType,
-	determineVideoPacketType,
-	extractAvcDecoderConfigurationRecord,
-	extractHevcDecoderConfigurationRecord,
-	EAC3_NUMBLKS_TABLE,
-	getEac3ChannelCount,
-	getEac3SampleRate,
-	HevcDecoderConfigurationRecord,
-	HevcNalUnitType,
-	parseAc3SyncFrame,
-	parseAvcSps,
-	parseEac3SyncFrame,
-	parseHevcSps,
-	AC3_FRAME_SIZES,
-	extractNalUnitTypeForAvc,
-	extractNalUnitTypeForHevc,
-} from '../codec-data';
-import { Demuxer } from '../demuxer';
-import { Input } from '../input';
-import { Logging } from '../logging';
-import {
-	InputAudioTrackBacking,
-	InputTrackBacking,
-	InputVideoTrackBacking,
-} from '../input-track';
-import { PacketRetrievalOptions } from '../media-sink';
-import { DEFAULT_TRACK_DISPOSITION, MetadataTags, TrackDisposition } from '../metadata';
-import {
-	assert,
-	binarySearchExact,
-	binarySearchLessOrEqual,
-	COLOR_PRIMARIES_MAP_INVERSE,
-	findLastIndex,
-	floorToMultiple,
-	last,
-	MATRIX_COEFFICIENTS_MAP_INVERSE,
-	readExpGolomb,
-	Rotation,
-	roundIfAlmostInteger,
-	toDataView,
-	TRANSFER_CHARACTERISTICS_MAP_INVERSE,
-	UNDETERMINED_LANGUAGE,
-} from '../misc';
-import {
-	MP3_FRAME_HEADER_SIZE,
-	getMp3ChannelCount,
-	readMp3FrameHeader,
-} from '../../shared/mp3-misc';
-import { EncodedPacket, PacketType, PLACEHOLDER_DATA } from '../packet';
-import { FileSlice, readBytes, Reader, readU16Be, readU32Be, readU8 } from '../reader';
-import { buildMpegTsMimeType, MpegTsStreamType, TIMESCALE, TS_PACKET_SIZE } from './mpeg-ts-misc';
-import { AC3_SAMPLE_RATES } from '../../shared/ac3-misc';
-import { Bitstream } from '../../shared/bitstream';
-
-// Resources:
-// ISO/IEC 13818-1
-
-const MISSING_PTS_ERROR_MESSAGE = 'PES packet is missing PTS where it was expected. PES packets without PTS are not'
-	+ ' currently supported. If you think this file should be supported, please report it.';
-
-type ElementaryStream = {
-	demuxer: MpegTsDemuxer;
-	pid: number;
-	streamType: number;
-	initialized: boolean;
-	firstSection: Section | null;
-	/**
-	 * Some muxers suck ass and don't correctly label key frames, meaning we'll need to use our skill to
-	 * compensate for another programmer's skill issue.
-	 */
-	canBeTrustedWithKeyPackets: boolean;
-	info: {
-		type: 'video';
-		codec: VideoCodec;
-		decoderConfig: VideoDecoderConfig | null;
-		avcCodecInfo: AvcDecoderConfigurationRecord | null;
-		hevcCodecInfo: HevcDecoderConfigurationRecord | null;
-		colorSpace: VideoColorSpaceInit;
-		width: number;
-		height: number;
-		squarePixelWidth: number;
-		squarePixelHeight: number;
-		reorderSize: number;
-	} | {
-		type: 'audio';
-		codec: AudioCodec;
-		decoderConfig: AudioDecoderConfig | null;
-		aacCodecInfo: AacCodecInfo | null;
-		numberOfChannels: number;
-		sampleRate: number;
-	};
-	/**
-	 * Reference PES packets, spread throughout the file, to be used to speed up repeated random access. Sorted by both
-	 * byte offset and PTS.
-	 */
-	referencePesPackets: TimestampedPesPacketHeader[];
-};
-
-type ElementaryVideoStream = ElementaryStream & { info: { type: 'video' } };
-type ElementaryAudioStream = ElementaryStream & { info: { type: 'audio' } };
-
-type TsPacketHeader = {
-	payloadUnitStartIndicator: number;
-	pid: number;
-	adaptationFieldControl: number;
-};
-
-type TsPacket = TsPacketHeader & {
-	body: Uint8Array<ArrayBufferLike>;
-};
-
-type Section = {
-	startPos: number;
-	endPos: number | null; // null if the section was not read fully
-	pid: number;
-	payload: Uint8Array<ArrayBufferLike>;
-	randomAccessIndicator: number;
-};
-
-// Remember them so the warning doesn't get spammed
-const ignoredStreamTypes = new Set<number>();
-
-export class MpegTsDemuxer extends Demuxer {
-	reader: Reader;
-
-	metadataPromise: Promise<void> | null = null;
-	elementaryStreams: ElementaryStream[] = [];
-	trackBackingEntries: InputTrackBacking[] = [];
-	packetOffset = 0;
-	packetStride = -1;
-	sectionEndPositions: number[] = [];
-	seekChunkSize = 5 * 1024 * 1024; // 5 MiB, picked because most HLS segments are below this size
-	minReferencePointByteDistance = -1;
-
-	constructor(input: Input) {
-		super(input);
-
-		this.reader = input._reader;
-	}
-
-	async readMetadata() {
-		return this.metadataPromise ??= (async () => {
-			const lengthToCheck = TS_PACKET_SIZE + 16 + 1;
-			let startingSlice = this.reader.requestSlice(0, lengthToCheck);
-			if (startingSlice instanceof Promise) startingSlice = await startingSlice;
-			assert(startingSlice);
-
-			const startingBytes = readBytes(startingSlice, lengthToCheck);
-
-			if (startingBytes[0] === 0x47 && startingBytes[TS_PACKET_SIZE] === 0x47) {
-				// Regular MPEG-TS
-				this.packetOffset = 0;
-				this.packetStride = TS_PACKET_SIZE;
-			} else if (startingBytes[0] === 0x47 && startingBytes[TS_PACKET_SIZE + 16] === 0x47) {
-				// MPEG-TS with Forward Error Correction
-				this.packetOffset = 0;
-				this.packetStride = TS_PACKET_SIZE + 16;
-			} else if (startingBytes[4] === 0x47 && startingBytes[4 + TS_PACKET_SIZE + 4] === 0x47) {
-				// MPEG-2-TS (DVHS)
-				this.packetOffset = 4;
-				this.packetStride = TS_PACKET_SIZE + 4;
-			} else {
-				throw new Error('Unreachable.');
-			}
-
-			const MIN_REFERENCE_POINT_PACKET_DISTANCE = 256;
-			this.minReferencePointByteDistance = MIN_REFERENCE_POINT_PACKET_DISTANCE * this.packetStride;
-
-			let currentPos = this.packetOffset;
-			let programMapPid: number | null = null;
-			// Some files contain these multiple times, but we only care about their first appearance
-			let hasProgramAssociationTable = false;
-			let hasProgramMap = false;
-
-			while (true) {
-				const packetHeader = await this.readPacketHeader(currentPos);
-				if (!packetHeader) {
-					break;
-				}
-
-				if (packetHeader.payloadUnitStartIndicator === 0) {
-					// Not the start of a section
-					currentPos += this.packetStride;
-					continue;
-				}
-
-				if (hasProgramMap && !this.elementaryStreams.some(x => x.pid === packetHeader.pid)) {
-					// Don't care about this PID
-					currentPos += this.packetStride;
-					continue;
-				}
-
-				const section = await this.readSection(
-					currentPos,
-					true,
-					!hasProgramMap, // Expect contiguous sections as long as we don't have the PMT
-				);
-				if (!section) {
-					break;
-				}
-
-				const BYTES_BEFORE_SECTION_LENGTH = 3;
-				const BITS_IN_CRC_32 = 32; // Duh
-
-				// Some streams don't contain a PAT for some reason, so we must do some guesswork to figure out where
-				// the PMT is.
-				let isProbablyProgramMap = false;
-				if (!hasProgramMap && section.pid !== 0) {
-					const isPesPacket
-						= section.payload[0] === 0x00 && section.payload[1] === 0x00 && section.payload[2] === 0x01;
-
-					if (!isPesPacket) {
-						// Assume it's a PSI
-
-						const bitstream = new Bitstream(section.payload);
-						const pointerField = bitstream.readAlignedByte();
-
-						bitstream.skipBits(8 * pointerField);
-
-						const tableId = bitstream.readBits(8);
-						isProbablyProgramMap = tableId === 0x02; // 0x02 == TS_program_map_section
-					}
-				}
-
-				if (section.pid === 0 && !hasProgramAssociationTable) {
-					const bitstream = new Bitstream(section.payload);
-					const pointerField = bitstream.readAlignedByte();
-
-					bitstream.skipBits(8 * pointerField);
-
-					bitstream.skipBits(14);
-					const sectionLength = bitstream.readBits(10);
-
-					bitstream.skipBits(40);
-
-					while (8 * (sectionLength + BYTES_BEFORE_SECTION_LENGTH) - bitstream.pos > BITS_IN_CRC_32) {
-						const programNumber = bitstream.readBits(16);
-						bitstream.skipBits(3); // Reserved
-						const id = bitstream.readBits(13);
-
-						if (programNumber !== 0) {
-							if (programMapPid !== null) {
-								throw new Error('Only files with a single program are supported.');
-							} else {
-								programMapPid = id;
-							}
-						}
-					}
-
-					if (programMapPid === null) {
-						throw new Error('Program Association Table must link to a Program Map Table.');
-					}
-
-					hasProgramAssociationTable = true;
-				} else if ((section.pid === programMapPid || isProbablyProgramMap) && !hasProgramMap) {
-					const bitstream = new Bitstream(section.payload);
-					const pointerField = bitstream.readAlignedByte();
-
-					bitstream.skipBits(8 * pointerField);
-
-					bitstream.skipBits(12);
-					const sectionLength = bitstream.readBits(12);
-
-					bitstream.skipBits(43);
-					// eslint-disable-next-line @typescript-eslint/no-unused-vars
-					const pcrPid = bitstream.readBits(13);
-
-					bitstream.skipBits(6);
-
-					// "The remaining 10 bits specify the number of bytes of the descriptors immediately following the
-					// program_info_length field"
-					const programInfoLength = bitstream.readBits(10);
-					bitstream.skipBits(8 * programInfoLength);
-
-					while (8 * (sectionLength + BYTES_BEFORE_SECTION_LENGTH) - bitstream.pos > BITS_IN_CRC_32) {
-						const streamType = bitstream.readBits(8);
-						bitstream.skipBits(3);
-						const elementaryPid = bitstream.readBits(13);
-
-						bitstream.skipBits(6);
-						const esInfoLength = bitstream.readBits(10);
-
-						// Check ES descriptors to detect AC-3/E-AC-3 in System B
-						const esInfoEndPos = bitstream.pos + 8 * esInfoLength;
-						let hasAc3Descriptor = false;
-						let hasEac3Descriptor = false;
-						while (bitstream.pos < esInfoEndPos) {
-							const descriptorTag = bitstream.readBits(8);
-							const descriptorLength = bitstream.readBits(8);
-							if (descriptorTag === 0x6a) {
-								hasAc3Descriptor = true;
-							} else if (descriptorTag === 0x7a || descriptorTag === 0xcc) {
-								hasEac3Descriptor = true;
-							}
-							bitstream.skipBits(8 * descriptorLength);
-						}
-
-						let info: ElementaryStream['info'] | null = null;
-
-						switch (streamType) {
-							case MpegTsStreamType.AVC:
-							case MpegTsStreamType.HEVC: {
-								const codec = streamType === MpegTsStreamType.AVC ? 'avc' : 'hevc';
-
-								info = {
-									type: 'video',
-									codec,
-									decoderConfig: null,
-									avcCodecInfo: null,
-									hevcCodecInfo: null,
-									colorSpace: {
-										primaries: null,
-										transfer: null,
-										matrix: null,
-										fullRange: null,
-									},
-									width: -1,
-									height: -1,
-									squarePixelWidth: -1,
-									squarePixelHeight: -1,
-									reorderSize: -1,
-								};
-							}; break;
-
-							case MpegTsStreamType.MP3_MPEG1:
-							case MpegTsStreamType.MP3_MPEG2:
-							case MpegTsStreamType.AAC:
-							case MpegTsStreamType.AC3_SYSTEM_A:
-							case MpegTsStreamType.EAC3_SYSTEM_A: {
-								let codec: AudioCodec;
-								if (
-									streamType === MpegTsStreamType.MP3_MPEG1
-									|| streamType === MpegTsStreamType.MP3_MPEG2
-								) {
-									codec = 'mp3';
-								} else if (streamType === MpegTsStreamType.AAC) {
-									codec = 'aac';
-								} else if (streamType === MpegTsStreamType.AC3_SYSTEM_A) {
-									codec = 'ac3';
-								} else if (streamType === MpegTsStreamType.EAC3_SYSTEM_A) {
-									codec = 'eac3';
-								} else {
-									throw new Error('Unreachable.');
-								}
-
-								info = {
-									type: 'audio',
-									codec,
-									decoderConfig: null,
-									aacCodecInfo: null,
-									numberOfChannels: -1,
-									sampleRate: -1,
-								};
-							}; break;
-
-							case MpegTsStreamType.PRIVATE_DATA: {
-								if (hasEac3Descriptor) {
-									info = {
-										type: 'audio',
-										codec: 'eac3',
-										decoderConfig: null,
-										aacCodecInfo: null,
-										numberOfChannels: -1,
-										sampleRate: -1,
-									};
-								} else if (hasAc3Descriptor) {
-									info = {
-										type: 'audio',
-										codec: 'ac3',
-										decoderConfig: null,
-										aacCodecInfo: null,
-										numberOfChannels: -1,
-										sampleRate: -1,
-									};
-								}
-							}; break;
-
-							default: {
-								// If we don't recognize the codec, we don't surface the track at all. This is because
-								// we can't determine its metadata and also have no idea how to packetize its data.
-
-								if (!ignoredStreamTypes.has(streamType)) {
-									Logging._warn(
-										`Note: MPEG-TS streams with stream_type 0x${streamType.toString(16)} are not`
-										+ ` currently supported.`,
-									);
-									ignoredStreamTypes.add(streamType);
-								}
-							}
-						}
-
-						if (info) {
-							this.elementaryStreams.push({
-								demuxer: this,
-								pid: elementaryPid,
-								streamType,
-								initialized: false,
-								firstSection: null,
-								canBeTrustedWithKeyPackets: false,
-								info,
-								referencePesPackets: [],
-							});
-						}
-					}
-
-					hasProgramMap = true;
-				} else {
-					const elementaryStream = this.elementaryStreams.find(x => x.pid === section.pid);
-					outer:
-					if (elementaryStream && !elementaryStream.initialized) {
-						const pesPacket = readPesPacket(section, true);
-						if (!pesPacket) {
-							throw new Error(
-								`Couldn't read first PES packet for Elementary Stream with PID ${elementaryStream.pid}`,
-							);
-						}
-
-						elementaryStream.firstSection = section;
-						elementaryStream.canBeTrustedWithKeyPackets = section.randomAccessIndicator === 1;
-
-						if (this.input._initInput) {
-							const initDemuxer = (await this.input._initInput._getDemuxer()) as MpegTsDemuxer;
-							const matchingStream = initDemuxer.elementaryStreams.find(x => (
-								x.pid === section.pid && x.info.codec === elementaryStream.info.codec
-							));
-
-							if (matchingStream) {
-								elementaryStream.info = matchingStream.info;
-								elementaryStream.initialized = true;
-
-								break outer; // We have the stream info, we're done
-							}
-						}
-
-						const context = new PacketReadingContext(elementaryStream, pesPacket);
-
-						if (elementaryStream.info.type === 'video') {
-							// We loop because in some files, the video parameters are not in the first packet
-							while (true) {
-								const contextAlias = context; // TyyyyypeScript 😩
-								contextAlias.suppliedPacket = null;
-								await context.markNextPacket();
-
-								if (elementaryStream.info.codec === 'avc') {
-									if (!context.suppliedPacket) {
-										throw new Error(
-											'Invalid AVC video stream; could not extract AVCDecoderConfigurationRecord'
-											+ ' from any packet.',
-										);
-									}
-
-									elementaryStream.info.avcCodecInfo
-										= extractAvcDecoderConfigurationRecord(context.suppliedPacket.data);
-
-									if (!elementaryStream.info.avcCodecInfo) {
-										continue; // Search the next packet for it
-									}
-
-									const spsUnit = elementaryStream.info.avcCodecInfo.sequenceParameterSets[0];
-									assert(spsUnit);
-									const spsInfo = parseAvcSps(spsUnit)!;
-
-									elementaryStream.info.width = spsInfo.displayWidth;
-									elementaryStream.info.height = spsInfo.displayHeight;
-
-									const num = spsInfo.pixelAspectRatio.num;
-									const den = spsInfo.pixelAspectRatio.den;
-
-									if (num > 0 && den > 0) {
-										if (num > den) {
-											elementaryStream.info.squarePixelWidth = Math.round(
-												elementaryStream.info.width * num / den,
-											);
-											elementaryStream.info.squarePixelHeight = elementaryStream.info.height;
-										} else {
-											elementaryStream.info.squarePixelWidth = elementaryStream.info.width;
-											elementaryStream.info.squarePixelHeight = Math.round(
-												elementaryStream.info.height * den / num,
-											);
-										}
-									}
-
-									elementaryStream.info.colorSpace = {
-										primaries:
-											COLOR_PRIMARIES_MAP_INVERSE[spsInfo.colourPrimaries] as
-											VideoColorPrimaries | undefined,
-										transfer:
-											TRANSFER_CHARACTERISTICS_MAP_INVERSE[spsInfo.transferCharacteristics] as
-											VideoTransferCharacteristics | undefined,
-										matrix:
-											MATRIX_COEFFICIENTS_MAP_INVERSE[spsInfo.matrixCoefficients] as
-											VideoMatrixCoefficients | undefined,
-										fullRange: !!spsInfo.fullRangeFlag,
-									};
-									elementaryStream.info.reorderSize = spsInfo.maxDecFrameBuffering;
-
-									break;
-								} else if (elementaryStream.info.codec === 'hevc') {
-									if (!context.suppliedPacket) {
-										throw new Error(
-											'Invalid HEVC video stream; could not extract HVCDecoderConfigurationRecord'
-											+ ' from first packet.',
-										);
-									}
-
-									elementaryStream.info.hevcCodecInfo
-										= extractHevcDecoderConfigurationRecord(context.suppliedPacket.data);
-
-									if (!elementaryStream.info.hevcCodecInfo) {
-										continue; // Search the next packet for it
-									}
-
-									const spsArray = elementaryStream.info.hevcCodecInfo.arrays.find(
-										a => a.nalUnitType === HevcNalUnitType.SPS_NUT,
-									)!;
-									const spsUnit = spsArray.nalUnits[0];
-									assert(spsUnit);
-									const spsInfo = parseHevcSps(spsUnit)!;
-
-									elementaryStream.info.width = spsInfo.displayWidth;
-									elementaryStream.info.height = spsInfo.displayHeight;
-									if (spsInfo.pixelAspectRatio.num > spsInfo.pixelAspectRatio.den) {
-										elementaryStream.info.squarePixelWidth = Math.round(
-											elementaryStream.info.width
-											* spsInfo.pixelAspectRatio.num / spsInfo.pixelAspectRatio.den,
-										);
-										elementaryStream.info.squarePixelHeight = elementaryStream.info.height;
-									} else {
-										elementaryStream.info.squarePixelWidth = elementaryStream.info.width;
-										elementaryStream.info.squarePixelHeight = Math.round(
-											elementaryStream.info.height
-											* spsInfo.pixelAspectRatio.den / spsInfo.pixelAspectRatio.num,
-										);
-									}
-
-									elementaryStream.info.colorSpace = {
-										primaries:
-											COLOR_PRIMARIES_MAP_INVERSE[spsInfo.colourPrimaries] as
-											VideoColorPrimaries | undefined,
-										transfer:
-											TRANSFER_CHARACTERISTICS_MAP_INVERSE[spsInfo.transferCharacteristics] as
-											VideoTransferCharacteristics | undefined,
-										matrix:
-											MATRIX_COEFFICIENTS_MAP_INVERSE[spsInfo.matrixCoefficients] as
-											VideoMatrixCoefficients | undefined,
-										fullRange: !!spsInfo.fullRangeFlag,
-									};
-									elementaryStream.info.reorderSize = spsInfo.maxDecFrameBuffering;
-
-									break;
-								} else {
-									throw new Error('Unhandled.');
-								}
-							}
-
-							elementaryStream.info.decoderConfig = {
-								codec: extractVideoCodecString({
-									width: elementaryStream.info.width,
-									height: elementaryStream.info.height,
-									codec: elementaryStream.info.codec,
-									codecDescription: null,
-									colorSpace: elementaryStream.info.colorSpace,
-									avcType: 1,
-									avcCodecInfo: elementaryStream.info.avcCodecInfo,
-									hevcCodecInfo: elementaryStream.info.hevcCodecInfo,
-									vp9CodecInfo: null,
-									av1CodecInfo: null,
-									proresFormat: null,
-								}),
-								codedWidth: elementaryStream.info.width,
-								codedHeight: elementaryStream.info.height,
-								colorSpace: elementaryStream.info.colorSpace,
-							};
-
-							if (
-								elementaryStream.info.width !== elementaryStream.info.squarePixelWidth
-								|| elementaryStream.info.height !== elementaryStream.info.squarePixelHeight
-							) {
-								elementaryStream.info.decoderConfig.displayAspectWidth
-									= elementaryStream.info.squarePixelWidth;
-								elementaryStream.info.decoderConfig.displayAspectHeight
-									= elementaryStream.info.squarePixelHeight;
-							}
-
-							elementaryStream.initialized = true;
-						} else {
-							await context.markNextPacket();
-							if (!context.suppliedPacket) {
-								throw new Error(
-									`Couldn't parse first media packet for Elementary Stream with`
-									+ ` PID ${elementaryStream.pid}`,
-								);
-							}
-
-							if (elementaryStream.info.codec === 'aac') {
-								const slice = FileSlice.tempFromBytes(context.suppliedPacket.data);
-								const header = readAdtsFrameHeader(slice);
-								if (!header) {
-									throw new Error(
-										'Invalid AAC audio stream; could not read ADTS frame header from first packet.',
-									);
-								}
-
-								elementaryStream.info.aacCodecInfo = {
-									isMpeg2: false,
-									objectType: header.objectType,
-								};
-								elementaryStream.info.numberOfChannels
-									= aacChannelMap[header.channelConfiguration]!;
-								elementaryStream.info.sampleRate
-									= aacFrequencyTable[header.samplingFrequencyIndex]!;
-							} else if (elementaryStream.info.codec === 'mp3') {
-								const word = readU32Be(FileSlice.tempFromBytes(context.suppliedPacket.data));
-								const result = readMp3FrameHeader(word, context.suppliedPacket.data.byteLength);
-								if (!result.header) {
-									throw new Error(
-										'Invalid MP3 audio stream; could not read frame header from first packet.',
-									);
-								}
-
-								elementaryStream.info.numberOfChannels = getMp3ChannelCount(result.header.channel);
-								elementaryStream.info.sampleRate = result.header.sampleRate;
-							} else if (elementaryStream.info.codec === 'ac3') {
-								const frameInfo = parseAc3SyncFrame(context.suppliedPacket.data);
-								if (!frameInfo) {
-									throw new Error(
-										'Invalid AC-3 audio stream; could not read sync frame from first packet.',
-									);
-								}
-
-								if (frameInfo.fscod === 3) {
-									throw new Error(
-										'Invalid AC-3 audio stream; reserved sample rate code found in first packet.',
-									);
-								}
-
-								elementaryStream.info.numberOfChannels
-									= AC3_ACMOD_CHANNEL_COUNTS[frameInfo.acmod]! + frameInfo.lfeon;
-								elementaryStream.info.sampleRate = AC3_SAMPLE_RATES[frameInfo.fscod]!;
-							} else if (elementaryStream.info.codec === 'eac3') {
-								const frameInfo = parseEac3SyncFrame(context.suppliedPacket.data);
-								if (!frameInfo) {
-									throw new Error(
-										'Invalid E-AC-3 audio stream; could not read sync frame from first packet.',
-									);
-								}
-
-								const sampleRate = getEac3SampleRate(frameInfo);
-								if (sampleRate === null) {
-									throw new Error(
-										'Invalid E-AC-3 audio stream; reserved sample rate code found in first packet.',
-									);
-								}
-
-								elementaryStream.info.numberOfChannels = getEac3ChannelCount(frameInfo);
-								elementaryStream.info.sampleRate = sampleRate;
-							} else {
-								throw new Error('Unhandled.');
-							}
-
-							elementaryStream.info.decoderConfig = {
-								codec: extractAudioCodecString({
-									codec: elementaryStream.info.codec,
-									codecDescription: null,
-									aacCodecInfo: elementaryStream.info.aacCodecInfo,
-								}),
-								numberOfChannels: elementaryStream.info.numberOfChannels,
-								sampleRate: elementaryStream.info.sampleRate,
-							};
-							elementaryStream.initialized = true;
-						}
-					}
-				}
-
-				const isDone = hasProgramMap && this.elementaryStreams.every(x => x.initialized);
-				if (isDone) {
-					break;
-				}
-
-				currentPos += this.packetStride;
-			}
-
-			if (!hasProgramMap) {
-				if (!hasProgramAssociationTable) {
-					throw new Error('No Program Association Table found in the file.');
-				}
-
-				throw new Error('No Program Map Table found in the file.');
-			}
-
-			for (const stream of this.elementaryStreams) {
-				if (stream.info.type === 'video') {
-					this.trackBackingEntries.push(
-						new MpegTsVideoTrackBacking(stream as ElementaryVideoStream),
-					);
-				} else {
-					this.trackBackingEntries.push(
-						new MpegTsAudioTrackBacking(stream as ElementaryAudioStream),
-					);
-				}
-			}
-		})();
-	}
-
-	async getTrackBackings() {
-		await this.readMetadata();
-		return this.trackBackingEntries;
-	}
-
-	async getMetadataTags(): Promise<MetadataTags> {
-		return {}; // Nothing for now
-	}
-
-	async getMimeType(): Promise<string> {
-		await this.readMetadata();
-
-		const codecStrings = await Promise.all(this.trackBackingEntries.map(
-			x => x.getDecoderConfig().then(c => c?.codec ?? null),
-		));
-
-		return buildMpegTsMimeType(codecStrings);
-	}
-
-	async readSection(startPos: number, full: boolean, contiguous = false): Promise<Section | null> {
-		let endPos = startPos;
-		let currentPos = startPos;
-		const chunks: Uint8Array[] = [];
-		let chunksByteLength = 0;
-		let firstPacket: TsPacket | null = null;
-		let mustAddSectionEnd = true;
-		let randomAccessIndicator = 0;
-
-		while (true) {
-			const packet = await this.readPacket(currentPos);
-			currentPos += this.packetStride;
-
-			if (!packet) {
-				break;
-			}
-
-			if (!firstPacket) {
-				if (packet.payloadUnitStartIndicator === 0) {
-					break;
-				}
-
-				firstPacket = packet;
-			} else {
-				if (packet.pid !== firstPacket.pid) {
-					if (contiguous) {
-						break; // End of section
-					} else {
-						continue; // Ignore this packet
-					}
-				}
-
-				if (packet.payloadUnitStartIndicator === 1) {
-					break;
-				}
-			}
-
-			const hasAdaptationField = !!(packet.adaptationFieldControl & 0b10);
-			const hasPayload = !!(packet.adaptationFieldControl & 0b01);
-
-			let adaptationFieldLength = 0;
-			if (hasAdaptationField) {
-				adaptationFieldLength = 1 + packet.body[0]!;
-
-				// Extract random_access_indicator from first packet's adaptation field
-				if (packet === firstPacket && adaptationFieldLength > 1) {
-					randomAccessIndicator = (packet.body[1]! >> 6) & 1;
-				}
-			}
-
-			if (hasPayload) {
-				if (adaptationFieldLength === 0) {
-					chunks.push(packet.body);
-					chunksByteLength += packet.body.byteLength;
-				} else {
-					chunks.push(packet.body.subarray(adaptationFieldLength));
-					chunksByteLength += packet.body.byteLength - adaptationFieldLength;
-				}
-			}
-
-			endPos = currentPos;
-
-			// 64 is just "a bit of data", enough for the PES packet header
-			if (!full && chunksByteLength >= 64) {
-				mustAddSectionEnd = false; // Not the actual section end
-				break;
-			}
-
-			// Check if we already know this is a section end
-			const isKnownSectionEnd = binarySearchExact(this.sectionEndPositions, endPos, x => x) !== -1;
-			if (isKnownSectionEnd) {
-				mustAddSectionEnd = false;
-				break;
-			}
-		}
-
-		if (mustAddSectionEnd) {
-			const index = binarySearchLessOrEqual(this.sectionEndPositions, endPos, x => x);
-			this.sectionEndPositions.splice(index + 1, 0, endPos);
-		}
-
-		if (!firstPacket) {
-			return null;
-		}
-
-		let merged: Uint8Array;
-		if (chunks.length === 1) {
-			merged = chunks[0]!;
-		} else {
-			const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-			merged = new Uint8Array(totalLength);
-			let offset = 0;
-			for (const chunk of chunks) {
-				merged.set(chunk, offset);
-				offset += chunk.length;
-			}
-		}
-
-		return {
-			startPos,
-			endPos: full ? endPos : null,
-			pid: firstPacket.pid,
-			payload: merged,
-			randomAccessIndicator,
-		};
-	}
-
-	async readPacketHeader(pos: number): Promise<TsPacketHeader | null> {
-		let slice = this.reader.requestSlice(pos, 4);
-		if (slice instanceof Promise) slice = await slice;
-
-		if (!slice) {
-			return null;
-		}
-
-		const syncByte = readU8(slice);
-		if (syncByte !== 0x47) {
-			throw new Error('Invalid TS packet sync byte. Likely an internal bug, please report this file.');
-		}
-
-		const nextTwoBytes = readU16Be(slice);
-		// eslint-disable-next-line @typescript-eslint/no-unused-vars
-		const transportErrorIndicator = nextTwoBytes >> 15;
-		const payloadUnitStartIndicator = (nextTwoBytes >> 14) & 0x1;
-		// eslint-disable-next-line @typescript-eslint/no-unused-vars
-		const transportPriority = (nextTwoBytes >> 13) & 0x1;
-		const pid = nextTwoBytes & 0x1FFF;
-
-		const nextByte = readU8(slice);
-		// eslint-disable-next-line @typescript-eslint/no-unused-vars
-		const transportScramblingControl = nextByte >> 6;
-		const adaptationFieldControl = (nextByte >> 4) & 0x3;
-		// eslint-disable-next-line @typescript-eslint/no-unused-vars
-		const continuityCounter = nextByte & 0xF;
-
-		return {
-			payloadUnitStartIndicator,
-			pid,
-			adaptationFieldControl,
-		};
-	}
-
-	async readPacket(pos: number): Promise<TsPacket | null> {
-		// Code in here is duplicated from readPacketHeader for performance reasons
-		let slice = this.reader.requestSlice(pos, TS_PACKET_SIZE);
-		if (slice instanceof Promise) slice = await slice;
-
-		if (!slice) {
-			return null;
-		}
-
-		const bytes = readBytes(slice, TS_PACKET_SIZE);
-
-		const syncByte = bytes[0]!;
-		if (syncByte !== 0x47) {
-			throw new Error('Invalid TS packet sync byte. Likely an internal bug, please report this file.');
-		}
-
-		const nextTwoBytes = (bytes[1]! << 8) + bytes[2]!;
-		// eslint-disable-next-line @typescript-eslint/no-unused-vars
-		const transportErrorIndicator = nextTwoBytes >> 15;
-		const payloadUnitStartIndicator = (nextTwoBytes >> 14) & 0x1;
-		// eslint-disable-next-line @typescript-eslint/no-unused-vars
-		const transportPriority = (nextTwoBytes >> 13) & 0x1;
-		const pid = nextTwoBytes & 0x1FFF;
-
-		const nextByte = bytes[3]!;
-		// eslint-disable-next-line @typescript-eslint/no-unused-vars
-		const transportScramblingControl = nextByte >> 6;
-		const adaptationFieldControl = (nextByte >> 4) & 0x3;
-		// eslint-disable-next-line @typescript-eslint/no-unused-vars
-		const continuityCounter = nextByte & 0xF;
-
-		return {
-			payloadUnitStartIndicator,
-			pid,
-			adaptationFieldControl,
-			body: bytes.subarray(4),
-		};
-	}
-}
-
-type PesPacketHeader = {
-	sectionStartPos: number;
-	sectionEndPos: number | null; // null if the section wasn't read fully
-	pts: number | null;
-	randomAccessIndicator: number;
-};
-
-type TimestampedPesPacketHeader = PesPacketHeader & {
-	pts: number;
-};
-
-type PesPacket = PesPacketHeader & {
-	data: Uint8Array<ArrayBufferLike>;
-};
-
-type TimestampedPesPacket = PesPacket & {
-	pts: number;
-};
-
-const readPesPacketHeader = <T extends boolean>(
-	section: Section,
-	expectPts: T,
-): (T extends true ? TimestampedPesPacketHeader : PesPacketHeader) | null => {
-	if (section.payload.byteLength < 3) {
-		return null;
-	}
-
-	const bitstream = new Bitstream(section.payload);
-
-	const startCodePrefix = bitstream.readBits(24);
-	if (startCodePrefix !== 0x000001) {
-		return null;
-	}
-
-	const streamId = bitstream.readBits(8);
-	bitstream.skipBits(16);
-
-	if (
-		streamId === 0b10111100 // program_stream_map
-		|| streamId === 0b10111110 // padding_stream
-		|| streamId === 0b10111111 // private_stream_2
-		|| streamId === 0b11110000 // ECM
-		|| streamId === 0b11110001 // EMM
-		|| streamId === 0b11111111 // program_stream_directory
-		|| streamId === 0b11110010 // DSMCC_stream
-		|| streamId === 0b11111000 // ITU-T Rec. H.222.1 type E stream
-	) {
-		return null;
-	}
-
-	bitstream.skipBits(8);
-
-	const ptsDtsFlags = bitstream.readBits(2);
-
-	bitstream.skipBits(14);
-
-	let pts: number | null = null;
-	if (ptsDtsFlags === 0b10 || ptsDtsFlags === 0b11) {
-		pts = 0;
-
-		bitstream.skipBits(4);
-		pts += bitstream.readBits(3) * (1 << 30);
-		bitstream.skipBits(1);
-		pts += bitstream.readBits(15) * (1 << 15);
-		bitstream.skipBits(1);
-		pts += bitstream.readBits(15);
-	} else {
-		if (expectPts) {
-			throw new Error(MISSING_PTS_ERROR_MESSAGE);
-		}
-	}
-
-	return {
-		sectionStartPos: section.startPos,
-		sectionEndPos: section.endPos,
-		pts,
-		randomAccessIndicator: section.randomAccessIndicator,
-	} as T extends true ? TimestampedPesPacketHeader : PesPacketHeader;
-};
-
-const readPesPacket = <T extends boolean>(
-	section: Section,
-	expectPts: T,
-): (T extends true ? TimestampedPesPacket : PesPacket) | null => {
-	assert(section.endPos !== null); // Can only read full PES packets from fully read sections
-
-	const header = readPesPacketHeader(section, expectPts);
-	if (!header) {
-		return null;
-	}
-
-	const bitstream = new Bitstream(section.payload);
-	bitstream.skipBits(32);
-	const pesPacketLength = bitstream.readBits(16);
-	const BYTES_UNTIL_END_OF_PES_PACKET_LENGTH = 6;
-
-	bitstream.skipBits(16);
-	const pesHeaderDataLength = bitstream.readBits(8);
-	const pesHeaderEndPos = bitstream.pos + 8 * pesHeaderDataLength;
-
-	bitstream.pos = pesHeaderEndPos;
-
-	const bytePos = pesHeaderEndPos / 8;
-	assert(Number.isInteger(bytePos));
-
-	const data = section.payload.subarray(
-		bytePos,
-		// "A value of 0 indicates that the PES packet length is neither specified nor bounded and is allowed only in
-		// PES packets whose payload consists of bytes from a video elementary stream contained in
-		// transport stream packets."
-		pesPacketLength > 0
-			? BYTES_UNTIL_END_OF_PES_PACKET_LENGTH + pesPacketLength
-			: section.payload.byteLength,
-	);
-
-	return {
-		...header,
-		data,
-	} as T extends true ? TimestampedPesPacket : PesPacket;
-};
-
-abstract class MpegTsTrackBacking implements InputTrackBacking {
-	packetBuffers = new WeakMap<EncodedPacket, PacketBuffer>();
-	/** Used for recreating PacketBuffers if necessary. */
-	packetSectionStarts = new WeakMap<EncodedPacket, number>();
-
-	constructor(public elementaryStream: ElementaryStream) {}
-
-	abstract getType(): TrackType;
-	abstract getDecoderConfig(): Promise<VideoDecoderConfig | AudioDecoderConfig | null>;
-
-	getId() {
-		return this.elementaryStream.pid;
-	}
-
-	getNumber() {
-		const demuxer = this.elementaryStream.demuxer;
-		const trackType = this.elementaryStream.info.type;
-
-		let number = 0;
-		for (const backing of demuxer.trackBackingEntries) {
-			if (backing.getType() === trackType) {
-				number++;
-			}
-
-			assert(backing instanceof MpegTsTrackBacking);
-			if (backing.elementaryStream === this.elementaryStream) {
-				break;
-			}
-		}
-
-		return number;
-	}
-
-	getCodec(): MediaCodec | null {
-		throw new Error('Not implemented on base class.');
-	}
-
-	getInternalCodecId() {
-		return this.elementaryStream.streamType;
-	}
-
-	getName() {
-		return null;
-	}
-
-	getLanguageCode() {
-		return UNDETERMINED_LANGUAGE;
-	}
-
-	getDisposition(): TrackDisposition {
-		return {
-			...DEFAULT_TRACK_DISPOSITION,
-			primary: false,
-		};
-	}
-
-	getTimeResolution() {
-		return TIMESCALE;
-	}
-
-	isRelativeToUnixEpoch() {
-		return false;
-	}
-
-	getUnixTimeForTimestamp() {
-		return null;
-	}
-
-	getPairingMask() {
-		return 1n;
-	}
-
-	getBitrate() {
-		return null;
-	}
-
-	getAverageBitrate() {
-		return null;
-	}
-
-	async getDurationFromMetadata() {
-		return null;
-	}
-
-	async getLiveRefreshInterval() {
-		return null;
-	}
-
-	abstract allPacketsAreKeyPackets(): boolean;
-	abstract getReorderSize(): number;
-
-	createEncodedPacket(
-		suppliedPacket: SuppliedPacket,
-		duration: number,
-		options: PacketRetrievalOptions,
-	) {
-		let packetType: PacketType;
-
-		if (this.allPacketsAreKeyPackets()) {
-			packetType = 'key';
-		} else {
-			packetType = suppliedPacket.randomAccessIndicator === 1
-				? 'key'
-				: 'delta';
-		}
-
-		return new EncodedPacket(
-			options.metadataOnly ? PLACEHOLDER_DATA : suppliedPacket.data,
-			packetType,
-			suppliedPacket.pts / TIMESCALE,
-			Math.max(duration / TIMESCALE, 0),
-			suppliedPacket.sequenceNumber,
-			suppliedPacket.data.byteLength,
-		);
-	}
-
-	async getFirstPacket(options: PacketRetrievalOptions): Promise<EncodedPacket | null> {
-		const section = this.elementaryStream.firstSection;
-		assert(section);
-
-		const pesPacket = readPesPacket(section, true);
-		assert(pesPacket);
-
-		const context = new PacketReadingContext(this.elementaryStream, pesPacket);
-		const buffer = new PacketBuffer(this, context);
-
-		const result = await buffer.readNext();
-		if (!result) {
-			return null;
-		}
-
-		const packet = this.createEncodedPacket(result.packet, result.duration, options);
-		this.packetBuffers.set(packet, buffer);
-		this.packetSectionStarts.set(packet, result.packet.sectionStartPos);
-
-		return packet;
-	}
-
-	async getNextPacket(packet: EncodedPacket, options: PacketRetrievalOptions): Promise<EncodedPacket | null> {
-		let buffer = this.packetBuffers.get(packet);
-
-		if (buffer) {
-			// Fast path
-			const result = await buffer.readNext();
-			if (!result) {
-				return null;
-			}
-
-			// Remove PacketBuffer access from the old packet, it belongs to the next packet now
-			this.packetBuffers.delete(packet);
-
-			const newPacket = this.createEncodedPacket(result.packet, result.duration, options);
-			this.packetBuffers.set(newPacket, buffer);
-			this.packetSectionStarts.set(newPacket, result.packet.sectionStartPos);
-
-			return newPacket;
-		}
-
-		// No buffer, we gotta do some rereading
-		const sectionStartPos = this.packetSectionStarts.get(packet);
-		if (sectionStartPos === undefined) {
-			throw new Error('Packet was not created from this track.');
-		}
-
-		const demuxer = this.elementaryStream.demuxer;
-		const section = await demuxer.readSection(sectionStartPos, true);
-		assert(section);
-
-		const pesPacket = readPesPacket(section, true);
-		assert(pesPacket);
-
-		const context = new PacketReadingContext(this.elementaryStream, pesPacket);
-		buffer = new PacketBuffer(this, context);
-
-		// Advance until we pass the current packet's sequence number
-		const targetSequenceNumber = packet.sequenceNumber;
-		while (true) {
-			const result = await buffer.readNext();
-			if (!result) {
-				return null;
-			}
-
-			if (result.packet.sequenceNumber > targetSequenceNumber) {
-				// We found the next packet!
-				const newPacket = this.createEncodedPacket(result.packet, result.duration, options);
-				this.packetBuffers.set(newPacket, buffer);
-				this.packetSectionStarts.set(newPacket, result.packet.sectionStartPos);
-				return newPacket;
-			}
-		}
-	}
-
-	async getNextKeyPacket(packet: EncodedPacket, options: PacketRetrievalOptions): Promise<EncodedPacket | null> {
-		let currentPacket: EncodedPacket | null = packet;
-
-		// Just loop until we hit one
-		while (true) {
-			currentPacket = await this.getNextPacket(currentPacket, options);
-
-			if (!currentPacket) {
-				return null;
-			}
-
-			if (currentPacket.type === 'key') {
-				return currentPacket;
-			}
-		}
-	}
-
-	getPacket(timestamp: number, options: PacketRetrievalOptions): Promise<EncodedPacket | null> {
-		return this.doPacketLookup(timestamp, false, options);
-	}
-
-	getKeyPacket(timestamp: number, options: PacketRetrievalOptions): Promise<EncodedPacket | null> {
-		return this.doPacketLookup(timestamp, true, options);
-	}
-
-	/**
-	 * Searches for the packet with the largest timestamp not larger than `timestamp` in the file, using a combination
-	 * of chunk-based binary search and linear refinement. The reason the coarse search is done in large chunks is to
-	 * make it more performant for small files and over high-latency readers such as the network.
-	 */
-	async doPacketLookup(
-		timestamp: number,
-		keyframesOnly: boolean,
-		options: PacketRetrievalOptions,
-	): Promise<EncodedPacket | null> {
-		const searchPts = roundIfAlmostInteger(timestamp * TIMESCALE);
-
-		const demuxer = this.elementaryStream.demuxer;
-		const { reader, seekChunkSize } = demuxer;
-		const pid = this.elementaryStream.pid;
-
-		const findFirstPesPacketHeaderInChunk = async (
-			startPos: number,
-			endPos: number,
-			readSectionInFull: boolean,
-		) => {
-			let currentPos = startPos;
-
-			while (currentPos < endPos) {
-				const packetHeader = await demuxer.readPacketHeader(currentPos);
-				if (!packetHeader) {
-					return null;
-				}
-
-				if (packetHeader.pid === pid && packetHeader.payloadUnitStartIndicator === 1) {
-					const section = await demuxer.readSection(currentPos, readSectionInFull);
-					if (!section) {
-						return null;
-					}
-
-					const pesPacketHeader = readPesPacketHeader(section, false);
-					if (pesPacketHeader && pesPacketHeader.pts !== null) {
-						return {
-							pesPacketHeader: pesPacketHeader as TimestampedPesPacketHeader,
-							section,
-						};
-					}
-				}
-
-				currentPos += demuxer.packetStride;
-			}
-
-			return null;
-		};
-
-		// Get the first PES packet of the track
-		const firstSection = this.elementaryStream.firstSection;
-		assert(firstSection);
-		const firstPesPacketHeader = readPesPacketHeader(firstSection, true);
-		assert(firstPesPacketHeader);
-
-		if (searchPts < firstPesPacketHeader.pts) {
-			// We're before the first packet, definitely nothing here
-			return null;
-		}
-
-		let scanStartPos: number;
-
-		const referencePesPackets = this.elementaryStream.referencePesPackets;
-		const referencePointIndex = binarySearchLessOrEqual(referencePesPackets, searchPts, x => x.pts);
-		const referencePoint = referencePointIndex !== -1 ? referencePesPackets[referencePointIndex]! : null;
-		if (referencePoint && searchPts - referencePoint.pts < TIMESCALE / 2) {
-			// Reference point ain't too far away, prefer it over the chunk search
-			scanStartPos = referencePoint.sectionStartPos;
-		} else {
-			let startChunkIndex = 0;
-
-			if (reader.fileSize !== null) {
-				const numChunks = Math.ceil(reader.fileSize / seekChunkSize);
-
-				if (numChunks > 1) {
-					// Binary search to find the chunk with highest index whose first PES has pts <= searchPts
-					let low = 0;
-					let high = numChunks - 1;
-					startChunkIndex = low;
-
-					while (low <= high) {
-						const mid = Math.floor((low + high) / 2);
-						const chunkStartPos = floorToMultiple(mid * seekChunkSize, demuxer.packetStride)
-							+ firstPesPacketHeader.sectionStartPos;
-						const chunkEndPos = chunkStartPos + seekChunkSize;
-
-						const result = await findFirstPesPacketHeaderInChunk(chunkStartPos, chunkEndPos, false);
-
-						if (!result) {
-							// No PES packet found in this chunk, search left
-							high = mid - 1;
-							continue;
-						}
-
-						if (result.pesPacketHeader.pts <= searchPts) {
-							// This chunk's first PES is <= searchPts, it's a candidate
-							startChunkIndex = mid;
-							low = mid + 1; // Search right
-						} else {
-							// Search left
-							high = mid - 1;
-						}
-					}
-				}
-			}
-
-			scanStartPos = floorToMultiple(
-				startChunkIndex * seekChunkSize,
-				demuxer.packetStride,
-			) + firstPesPacketHeader.sectionStartPos;
-		}
-
-		// Find the first PES packet at or after scanStartPos
-		const result = await findFirstPesPacketHeaderInChunk(
-			scanStartPos,
-			reader.fileSize ?? Infinity,
-			false,
-		);
-
-		let currentPesHeader = result?.pesPacketHeader ?? null;
-		if (!currentPesHeader) {
-			// Fall back to first packet
-			currentPesHeader = firstPesPacketHeader;
-		}
-
-		const reorderSize = this.getReorderSize();
-
-		const retrieveEncodedPacket = async (
-			sectionStartPos: number,
-			predicate: (packet: SuppliedPacket) => boolean,
-		) => {
-			// Load the relevant section in full
-			const section = await demuxer.readSection(sectionStartPos, true);
-			assert(section);
-
-			const pesPacket = readPesPacket(section, true);
-			assert(pesPacket);
-
-			const context = new PacketReadingContext(this.elementaryStream, pesPacket);
-			const buffer = new PacketBuffer(this, context);
-
-			// Advance until the top-most presentation timestamp crosses or equals searchPts
-			while (true) {
-				const topPts = last(buffer.presentationOrderPackets)?.pts ?? -Infinity;
-				if (topPts >= searchPts) {
-					break;
-				}
-
-				const didRead = await buffer.readNextPacket();
-				if (!didRead) {
-					break;
-				}
-			}
-
-			const targetIndex = findLastIndex(buffer.presentationOrderPackets, predicate);
-			if (targetIndex === -1) {
-				return null;
-			}
-
-			const targetPacket = buffer.presentationOrderPackets[targetIndex]!;
-			const lastDuration = targetIndex === 0
-				? 0
-				: targetPacket.pts - buffer.presentationOrderPackets[targetIndex - 1]!.pts;
-
-			// Pop packets in decode order until we hit the target packet
-			while (buffer.decodeOrderPackets[0] !== targetPacket) {
-				buffer.decodeOrderPackets.shift();
-			}
-			buffer.lastDuration = lastDuration; // Kinda ugly but necessary fix
-
-			const result = await buffer.readNext();
-			assert(result);
-
-			const packet = this.createEncodedPacket(result.packet, result.duration, options);
-			this.packetBuffers.set(packet, buffer);
-			this.packetSectionStarts.set(packet, result.packet.sectionStartPos);
-
-			return packet;
-		};
-
-		if (!keyframesOnly || this.allPacketsAreKeyPackets()) {
-			// Normat packet lookup case. Slightly easier since we just need to search (mostly) forward to find the
-			// packet.
-
-			// Linear scan to find the PES packet with largest pts <= searchPts. This will be used as the "midpoint"
-			// of the next refinement step (which is needed because of B-frames).
-			outer:
-			while (true) {
-				let currentPos = currentPesHeader.sectionStartPos + demuxer.packetStride;
-
-				while (true) {
-					const packetHeader = await demuxer.readPacketHeader(currentPos);
-					if (!packetHeader) {
-						break outer; // End of file
-					}
-
-					if (packetHeader.pid === pid && packetHeader.payloadUnitStartIndicator === 1) {
-						const section = await demuxer.readSection(currentPos, false);
-						if (section) {
-							const nextPesHeader = readPesPacketHeader(section, false);
-							if (nextPesHeader && nextPesHeader.pts !== null) {
-								if (nextPesHeader.pts > searchPts) {
-									break outer;
-								}
-
-								currentPesHeader = nextPesHeader as TimestampedPesPacketHeader;
-								maybeInsertReferencePacket(this.elementaryStream, currentPesHeader);
-
-								break;
-							}
-						}
-					}
-
-					currentPos += demuxer.packetStride;
-				}
-			}
-
-			// Rewind by reorderSize + 1 PES packets (even for audio! To ensure proper durations)
-			outer:
-			for (let i = 0; i < reorderSize + 1; i++) {
-				let pos = currentPesHeader.sectionStartPos - demuxer.packetStride;
-
-				while (pos >= demuxer.packetOffset) {
-					const packetHeader = await demuxer.readPacketHeader(pos);
-					if (!packetHeader) {
-						break outer;
-					}
-
-					if (packetHeader.pid === pid && packetHeader.payloadUnitStartIndicator === 1) {
-						const section = await demuxer.readSection(pos, false);
-						if (section) {
-							const header = readPesPacketHeader(section, false);
-							if (header && header.pts !== null) {
-								currentPesHeader = header as TimestampedPesPacketHeader;
-								break;
-							}
-						}
-					}
-
-					pos -= demuxer.packetStride;
-				}
-			}
-
-			return retrieveEncodedPacket(currentPesHeader.sectionStartPos, p => p.pts <= searchPts);
-		} else {
-			// Key packet lookup case. Slightly harder since the starting chunk may not have a key packet at all, which
-			// means we might need to search the previous chunks until we find something.
-
-			let currentChunkStartPos = scanStartPos;
-			let nextChunkStartPos: number | null = null; // "next" as in later in the file, even tho we scan backwards
-
-			const readSectionsInFull = !this.elementaryStream.canBeTrustedWithKeyPackets;
-
-			while (true) {
-				let bestKeyPesHeader: TimestampedPesPacketHeader | null = null;
-
-				const isFirstChunk = currentChunkStartPos <= firstPesPacketHeader.sectionStartPos;
-
-				let pesHeader: TimestampedPesPacketHeader | null;
-				let pesHeaderSection: Section | null = null;
-
-				if (isFirstChunk) {
-					pesHeader = firstPesPacketHeader;
-					pesHeaderSection = firstSection;
-				} else {
-					const result = await findFirstPesPacketHeaderInChunk(
-						currentChunkStartPos,
-						reader.fileSize ?? Infinity,
-						readSectionsInFull,
-					);
-
-					pesHeader = result?.pesPacketHeader ?? null;
-					pesHeaderSection = result?.section ?? null;
-				}
-
-				let passedSearchPts = false;
-				let lookaheadCount = 0;
-
-				outer:
-				while (pesHeader) {
-					if (nextChunkStartPos !== null && pesHeader.sectionStartPos >= nextChunkStartPos) {
-						// Stop at the next chunk boundary
-						break;
-					}
-
-					if (pesHeader.pts <= searchPts) {
-						let isKeyPacket: boolean;
-						if (this.elementaryStream.canBeTrustedWithKeyPackets) {
-							isKeyPacket = pesHeader.randomAccessIndicator === 1;
-						} else {
-							assert(pesHeaderSection);
-							const pesPacket = readPesPacket(pesHeaderSection, true);
-							assert(pesPacket);
-
-							const context = new PacketReadingContext(this.elementaryStream, pesPacket);
-							await context.markNextPacket();
-
-							isKeyPacket = context.suppliedPacket?.randomAccessIndicator === 1;
-						}
-
-						if (isKeyPacket) {
-							bestKeyPesHeader = pesHeader;
-						}
-					}
-
-					if (pesHeader.pts > searchPts) {
-						passedSearchPts = true;
-					}
-
-					// If we've passed searchPts, do lookahead for reorderSize more packets just to be sure
-					if (passedSearchPts) {
-						lookaheadCount++;
-
-						if (lookaheadCount > reorderSize) {
-							break;
-						}
-					}
-
-					// Find next PES packet
-					let currentPos = pesHeader.sectionStartPos + demuxer.packetStride;
-
-					while (true) {
-						const packetHeader = await demuxer.readPacketHeader(currentPos);
-						if (!packetHeader) {
-							break outer; // End of file
-						}
-
-						if (packetHeader.pid === pid && packetHeader.payloadUnitStartIndicator === 1) {
-							const section = await demuxer.readSection(currentPos, readSectionsInFull);
-							if (section) {
-								const nextPesHeader = readPesPacketHeader(section, false);
-
-								if (nextPesHeader && nextPesHeader.pts !== null) {
-									pesHeader = nextPesHeader as TimestampedPesPacketHeader;
-									pesHeaderSection = section;
-									maybeInsertReferencePacket(this.elementaryStream, pesHeader);
-
-									break;
-								}
-							}
-						}
-
-						currentPos += demuxer.packetStride;
-					}
-				}
-
-				if (bestKeyPesHeader) {
-					let startPesHeader = bestKeyPesHeader;
-
-					if (lookaheadCount === 0) {
-						// Packet is at the end of stream, let's rewind a little to obtain the correct packet duration
-						outer:
-						for (let i = 0; i < reorderSize; i++) {
-							let pos = startPesHeader.sectionStartPos - demuxer.packetStride;
-
-							while (pos >= demuxer.packetOffset) {
-								const packetHeader = await demuxer.readPacketHeader(pos);
-								if (!packetHeader) {
-									break outer;
-								}
-
-								if (packetHeader.pid === pid && packetHeader.payloadUnitStartIndicator === 1) {
-									const section = await demuxer.readSection(pos, readSectionsInFull);
-									if (section) {
-										const header = readPesPacketHeader(section, false);
-										if (header && header.pts !== null) {
-											startPesHeader = header as TimestampedPesPacketHeader;
-											break;
-										}
-									}
-								}
-
-								pos -= demuxer.packetStride;
-							}
-						}
-					}
-
-					const encodedPacket = await retrieveEncodedPacket(
-						startPesHeader.sectionStartPos,
-						p => p.pts <= searchPts && p.randomAccessIndicator === 1,
-					);
-					assert(encodedPacket); // There must be one
-
-					return encodedPacket;
-				}
-
-				if (isFirstChunk) {
-					return null;
-				}
-
-				// No key frame found in this chunk, move one chunk to the left
-				nextChunkStartPos = currentChunkStartPos;
-				currentChunkStartPos = Math.max(
-					floorToMultiple(
-						currentChunkStartPos - firstPesPacketHeader.sectionStartPos - seekChunkSize,
-						demuxer.packetStride,
-					) + firstPesPacketHeader.sectionStartPos,
-					firstPesPacketHeader.sectionStartPos,
-				);
-			}
-		}
-	}
-}
-
-class MpegTsVideoTrackBacking extends MpegTsTrackBacking implements InputVideoTrackBacking {
-	override elementaryStream!: ElementaryVideoStream;
-
-	getType() {
-		return 'video' as const;
-	}
-
-	override getCodec(): VideoCodec {
-		return this.elementaryStream.info.codec;
-	}
-
-	getCodedWidth() {
-		return this.elementaryStream.info.width;
-	}
-
-	getCodedHeight() {
-		return this.elementaryStream.info.height;
-	}
-
-	getSquarePixelWidth() {
-		return this.elementaryStream.info.squarePixelWidth;
-	}
-
-	getSquarePixelHeight() {
-		return this.elementaryStream.info.squarePixelHeight;
-	}
-
-	getRotation(): Rotation {
-		return 0;
-	}
-
-	async getColorSpace(): Promise<VideoColorSpaceInit> {
-		return this.elementaryStream.info.colorSpace;
-	}
-
-	async canBeTransparent() {
-		return false;
-	}
-
-	async getDecoderConfig(): Promise<VideoDecoderConfig> {
-		assert(this.elementaryStream.info.decoderConfig);
-		return this.elementaryStream.info.decoderConfig;
-	}
-
-	override allPacketsAreKeyPackets(): boolean {
-		return false;
-	}
-
-	override getReorderSize(): number {
-		return this.elementaryStream.info.reorderSize;
-	}
-}
-
-class MpegTsAudioTrackBacking extends MpegTsTrackBacking implements InputAudioTrackBacking {
-	override elementaryStream!: ElementaryAudioStream;
-
-	getType() {
-		return 'audio' as const;
-	}
-
-	override getCodec(): AudioCodec {
-		return this.elementaryStream.info.codec;
-	}
-
-	getNumberOfChannels() {
-		return this.elementaryStream.info.numberOfChannels;
-	}
-
-	getSampleRate() {
-		return this.elementaryStream.info.sampleRate;
-	}
-
-	async getDecoderConfig(): Promise<AudioDecoderConfig> {
-		assert(this.elementaryStream.info.decoderConfig);
-		return this.elementaryStream.info.decoderConfig;
-	}
-
-	override allPacketsAreKeyPackets(): boolean {
-		return true;
-	}
-
-	override getReorderSize(): number {
-		return 0; // No reordering, since no B-frames because goated
-	}
-}
-
-const maybeInsertReferencePacket = (
-	elementaryStream: ElementaryStream,
-	pesPacketHeader: TimestampedPesPacketHeader,
-) => {
-	const referencePesPackets = elementaryStream.referencePesPackets;
-
-	const index = binarySearchLessOrEqual(
-		referencePesPackets,
-		pesPacketHeader.sectionStartPos,
-		x => x.sectionStartPos,
-	);
-	if (index >= 0) {
-		// Since pts and file position don't necessarily have a monotonic relationship (since pts can go crazy),
-		// let's see if inserting at the given index would violate the pts order. If so, return.
-		const entry = referencePesPackets[index]!;
-		if (pesPacketHeader.pts <= entry.pts) {
-			return false;
-		}
-
-		const minByteDistance = elementaryStream.demuxer.minReferencePointByteDistance;
-
-		if (pesPacketHeader.sectionStartPos - entry.sectionStartPos < minByteDistance) {
-			// Too close
-			return false;
-		}
-
-		if (index < referencePesPackets.length - 1) {
-			const nextEntry = referencePesPackets[index + 1]!;
-			if (nextEntry.pts < pesPacketHeader.pts) {
-				// Out of order
-				return false;
-			}
-
-			if (nextEntry.sectionStartPos - pesPacketHeader.sectionStartPos < minByteDistance) {
-				// Too close
-				return false;
-			}
-		}
-	}
-
-	referencePesPackets.splice(index + 1, 0, pesPacketHeader);
-	return true;
-};
-
-type SuppliedPacket = {
-	pts: number;
-	data: Uint8Array;
-	sequenceNumber: number;
-	sectionStartPos: number;
-	randomAccessIndicator: number;
-};
-
-/** Stateful context used to extract exact encoded packets from the underlying data stream. */
-class PacketReadingContext {
-	elementaryStream: ElementaryStream;
-	pid: number;
-	demuxer: MpegTsDemuxer;
-	startingPesPacket: TimestampedPesPacket;
-
-	currentPos = 0; // Relative to the data in startingPesPacket
-	pesPackets: PesPacket[] = [];
-	currentPesPacketIndex = 0;
-	currentPesPacketPos = 0;
-	endPos = 0;
-	lastSuppliedPesPacket: PesPacket | null = null;
-	nextPts: number | null = null;
-
-	suppliedPacket: SuppliedPacket | null = null;
-
-	constructor(elementaryStream: ElementaryStream, startingPesPacket: TimestampedPesPacket) {
-		this.elementaryStream = elementaryStream;
-		this.pid = elementaryStream.pid;
-		this.demuxer = elementaryStream.demuxer;
-		this.startingPesPacket = startingPesPacket;
-	}
-
-	ensureBuffered(length: number) {
-		const remaining = this.endPos - this.currentPos;
-		if (remaining >= length) {
-			return length;
-		}
-
-		return this.bufferData(length - remaining)
-			.then(() => Math.min(this.endPos - this.currentPos, length));
-	}
-
-	getCurrentPesPacket() {
-		const packet = this.pesPackets[this.currentPesPacketIndex];
-		assert(packet);
-
-		return packet;
-	}
-
-	async bufferData(length: number): Promise<void> {
-		const targetEndPos = this.endPos + length;
-
-		while (this.endPos < targetEndPos) {
-			let pesPacket: PesPacket;
-			if (this.pesPackets.length === 0) {
-				pesPacket = this.startingPesPacket;
-			} else {
-				// Find the next PES packet
-				let currentPos = last(this.pesPackets)!.sectionEndPos;
-				assert(currentPos !== null);
-
-				while (true) {
-					const packetHeader = await this.demuxer.readPacketHeader(currentPos);
-					if (!packetHeader) {
-						return;
-					}
-
-					if (packetHeader.pid === this.pid) {
-						const nextSection = await this.demuxer.readSection(currentPos, true);
-						if (!nextSection) {
-							return;
-						}
-
-						const nextPesPacket = readPesPacket(nextSection, false);
-						if (nextPesPacket) {
-							pesPacket = nextPesPacket;
-							break;
-						}
-					}
-
-					currentPos += this.demuxer.packetStride;
-				}
-			}
-
-			this.pesPackets.push(pesPacket);
-			this.endPos += pesPacket.data.byteLength;
-		}
-	}
-
-	readBytes(length: number) {
-		const currentPesPacket = this.getCurrentPesPacket();
-
-		const relativeStartOffset = this.currentPos - this.currentPesPacketPos;
-		const relativeEndOffset = relativeStartOffset + length;
-
-		this.currentPos += length;
-
-		if (relativeEndOffset <= currentPesPacket.data.byteLength) {
-			// Request can be satisfied with one PES packet
-			return currentPesPacket.data.subarray(relativeStartOffset, relativeEndOffset);
-		}
-
-		// Data spans multiple PES packets, we must do some merging
-		const result = new Uint8Array(length);
-		result.set(currentPesPacket.data.subarray(relativeStartOffset));
-		let offset = currentPesPacket.data.byteLength - relativeStartOffset;
-
-		while (true) {
-			this.advanceCurrentPacket();
-			const currentPesPacket = this.getCurrentPesPacket();
-			const relativeEndOffset = length - offset;
-
-			if (relativeEndOffset <= currentPesPacket.data.byteLength) {
-				result.set(currentPesPacket.data.subarray(0, relativeEndOffset), offset);
-				break;
-			}
-
-			result.set(currentPesPacket.data, offset);
-			offset += currentPesPacket.data.byteLength;
-		}
-
-		return result;
-	}
-
-	readU8() {
-		let currentPesPacket = this.getCurrentPesPacket();
-
-		const relativeOffset = this.currentPos - this.currentPesPacketPos;
-		this.currentPos++;
-
-		if (relativeOffset < currentPesPacket.data.byteLength) {
-			return currentPesPacket.data[relativeOffset]!;
-		}
-
-		this.advanceCurrentPacket();
-
-		currentPesPacket = this.getCurrentPesPacket();
-		return currentPesPacket.data[0]!;
-	}
-
-	seekTo(pos: number) {
-		if (pos === this.currentPos) {
-			return;
-		}
-
-		if (pos < this.currentPos) {
-			while (pos < this.currentPesPacketPos) {
-				// Move to the previous PES packet
-				this.currentPesPacketIndex--;
-				const currentPacket = this.getCurrentPesPacket();
-				this.currentPesPacketPos -= currentPacket.data.byteLength;
-			}
-		} else {
-			while (true) {
-				// Move to the next PES packet
-				const currentPesPacket = this.getCurrentPesPacket();
-				const currentEndPos = this.currentPesPacketPos + currentPesPacket.data.byteLength;
-
-				if (pos < currentEndPos) {
-					break;
-				}
-
-				this.currentPesPacketPos += currentPesPacket.data.byteLength;
-				this.currentPesPacketIndex++;
-			}
-		}
-
-		this.currentPos = pos;
-	}
-
-	skip(n: number) {
-		this.seekTo(this.currentPos + n);
-	}
-
-	advanceCurrentPacket() {
-		this.currentPesPacketPos += this.getCurrentPesPacket().data.byteLength;
-		this.currentPesPacketIndex++;
-	}
-
-	async markNextPacket() {
-		assert(!this.suppliedPacket);
-
-		const elementaryStream = this.elementaryStream;
-
-		if (elementaryStream.info.type === 'video') {
-			// Our job here is to separate the video stream into access units. Sometimes this is easy (like when AUDs
-			// are present), sometimes it's a little harder.
-
-			const codec = elementaryStream.info.codec;
-			const CHUNK_SIZE = 1024;
-
-			if (codec !== 'avc' && codec !== 'hevc') {
-				throw new Error('Unhandled.');
-			}
-
-			const nalHeaderSize = codec === 'avc' ? 1 : 2;
-			let packetStartPos: number | null = null;
-			let frameStartFound = false;
-			let lastFirstMacroblockInSlice = 0;
-
-			while (true) {
-				let remaining = this.ensureBuffered(CHUNK_SIZE);
-				if (remaining instanceof Promise) remaining = await remaining;
-
-				if (remaining === 0) {
-					break;
-				}
-
-				const chunkStartPos = this.currentPos;
-				const chunk = this.readBytes(remaining);
-				const length = chunk.byteLength;
-
-				let i = 0;
-				while (i < length) {
-					const zeroIndex = chunk.indexOf(0, i);
-					if (zeroIndex === -1 || zeroIndex >= length) {
-						break;
-					}
-					i = zeroIndex;
-
-					const posBeforeZero = chunkStartPos + i;
-
-					// Need 3 more bytes after the 0x00 to recognize a start code prefix
-					if (i + 3 >= length) {
-						// Not enough data in current chunk, seek back and let the next iteration handle it
-						this.seekTo(posBeforeZero);
-						break;
-					}
-
-					const b1 = chunk[i + 1]!;
-					const b2 = chunk[i + 2]!;
-					const b3 = chunk[i + 3]!;
-
-					let startCodeLength = 0;
-
-					// Check for 4-byte start code (0x00000001)
-					if (b1 === 0x00 && b2 === 0x00 && b3 === 0x01) {
-						startCodeLength = 4;
-					} else if (b1 === 0x00 && b2 === 0x01) {
-						// 3-byte start code (0x000001)
-						startCodeLength = 3;
-					}
-
-					if (startCodeLength === 0) {
-						// Not a start code, continue
-						i++;
-						continue;
-					}
-
-					const startCodePos = posBeforeZero;
-
-					// The packet only really begins at the first NAL unit; anything before it isn't usable
-					packetStartPos ??= startCodePos;
-
-					const nalHeaderStart = i + startCodeLength;
-					const payloadStart = nalHeaderStart + nalHeaderSize;
-
-					// Bytes peeked from the start of a slice header to decode first_mb_in_slice. Six bytes (48 bits)
-					// comfortably covers the exp-Golomb code for any realistic macroblock count
-					const AVC_SLICE_HEADER_PEEK_SIZE = 6;
-
-					// We read the NAL header plus, for slices, the start of the slice header to decode the
-					// first_mb_in_slice / first_slice_segment_in_pic_flag. Make sure all of it is buffered.
-					const bytesNeeded = payloadStart + (codec === 'avc' ? AVC_SLICE_HEADER_PEEK_SIZE : 1);
-					if (bytesNeeded > length) {
-						this.seekTo(posBeforeZero);
-						break;
-					}
-
-					const headerByte0 = chunk[nalHeaderStart]!;
-
-					let nalUnitType: number;
-					let isSlice: boolean;
-					let isAccessUnitStart: boolean;
-
-					if (codec === 'avc') {
-						nalUnitType = extractNalUnitTypeForAvc(headerByte0);
-						isSlice = nalUnitType === AvcNalUnitType.NON_IDR_SLICE
-							|| nalUnitType === AvcNalUnitType.SLICE_DPA
-							|| nalUnitType === AvcNalUnitType.IDR;
-						isAccessUnitStart = nalUnitType === AvcNalUnitType.SEI
-							|| nalUnitType === AvcNalUnitType.SPS
-							|| nalUnitType === AvcNalUnitType.PPS
-							|| nalUnitType === AvcNalUnitType.AUD;
-					} else {
-						nalUnitType = extractNalUnitTypeForHevc(headerByte0);
-						const layerId = ((headerByte0 & 1) << 5) | (chunk[nalHeaderStart + 1]! >> 3);
-						if (layerId > 0) {
-							// Higher layers don't delimit the base-layer frames we care about
-							i += startCodeLength;
-							continue;
-						}
-
-						// VCL slices: 0..RASL_R, plus the IRAP range BLA_W_LP..CRA_NUT
-						isSlice = nalUnitType <= HevcNalUnitType.RASL_R
-							|| (nalUnitType >= HevcNalUnitType.BLA_W_LP && nalUnitType <= 21);
-						// VPS..FD, prefix SEI, and the reserved/unspecified non-VCL ranges
-						isAccessUnitStart = (nalUnitType >= HevcNalUnitType.VPS_NUT && nalUnitType <= 37)
-							|| nalUnitType === HevcNalUnitType.PREFIX_SEI_NUT
-							|| (nalUnitType >= 41 && nalUnitType <= 44)
-							|| (nalUnitType >= 48 && nalUnitType <= 55);
-					}
-
-					let isFrameBoundary = false;
-
-					if (isSlice) {
-						let startsNewPicture: boolean;
-
-						if (codec === 'avc') {
-							const headerBytes = chunk.subarray(payloadStart, payloadStart + AVC_SLICE_HEADER_PEEK_SIZE);
-							const firstMacroblockInSlice = readExpGolomb(new Bitstream(headerBytes));
-							startsNewPicture = !frameStartFound || firstMacroblockInSlice <= lastFirstMacroblockInSlice;
-							lastFirstMacroblockInSlice = firstMacroblockInSlice;
-						} else {
-							startsNewPicture = (chunk[payloadStart]! >> 7) === 1;
-						}
-
-						if (startsNewPicture) {
-							if (frameStartFound) {
-								isFrameBoundary = true;
-							} else {
-								frameStartFound = true;
-							}
-						}
-					} else if (isAccessUnitStart && frameStartFound) {
-						isFrameBoundary = true;
-					}
-
-					if (isFrameBoundary) {
-						// End the packet at this start code (the next frame begins here)
-						const packetLength = startCodePos - packetStartPos;
-						this.seekTo(packetStartPos);
-						return this.supplyPacket(packetLength, 0);
-					}
-
-					i += startCodeLength;
-				}
-
-				if (remaining < CHUNK_SIZE) {
-					// End of stream
-					break;
-				}
-			}
-
-			// End of stream - emit whatever's left as the final packet
-			if (packetStartPos !== null && this.endPos > packetStartPos) {
-				const packetLength = this.endPos - packetStartPos;
-				this.seekTo(packetStartPos);
-				return this.supplyPacket(packetLength, 0);
-			}
-		} else {
-			const codec = elementaryStream.info.codec;
-			const CHUNK_SIZE = 128;
-
-			while (true) {
-				let remaining = this.ensureBuffered(CHUNK_SIZE);
-				if (remaining instanceof Promise) remaining = await remaining;
-
-				const startPos = this.currentPos;
-
-				while (this.currentPos - startPos < remaining) {
-					const byte = this.readU8();
-
-					if (codec === 'aac') {
-						if (byte !== 0xff) {
-							continue;
-						}
-
-						this.skip(-1);
-						const possibleHeaderStartPos = this.currentPos;
-
-						let remaining = this.ensureBuffered(MAX_ADTS_FRAME_HEADER_SIZE);
-						if (remaining instanceof Promise) remaining = await remaining;
-
-						if (remaining < MAX_ADTS_FRAME_HEADER_SIZE) {
-							return;
-						}
-
-						const headerBytes = this.readBytes(MAX_ADTS_FRAME_HEADER_SIZE);
-						const header = readAdtsFrameHeader(FileSlice.tempFromBytes(headerBytes));
-
-						if (header) {
-							this.seekTo(possibleHeaderStartPos);
-
-							let remaining = this.ensureBuffered(header.frameLength);
-							if (remaining instanceof Promise) remaining = await remaining;
-
-							return this.supplyPacket(
-								remaining,
-								Math.round(SAMPLES_PER_AAC_FRAME * TIMESCALE / elementaryStream.info.sampleRate),
-							);
-						} else {
-							this.seekTo(possibleHeaderStartPos + 1);
-						}
-					} else if (codec === 'mp3') {
-						if (byte !== 0xff) {
-							continue;
-						}
-
-						this.skip(-1);
-						const possibleHeaderStartPos = this.currentPos;
-
-						let remaining = this.ensureBuffered(MP3_FRAME_HEADER_SIZE);
-						if (remaining instanceof Promise) remaining = await remaining;
-
-						if (remaining < MP3_FRAME_HEADER_SIZE) {
-							return;
-						}
-
-						const headerBytes = this.readBytes(MP3_FRAME_HEADER_SIZE);
-						const word = toDataView(headerBytes).getUint32(0);
-						const result = readMp3FrameHeader(word, null);
-
-						if (result.header) {
-							this.seekTo(possibleHeaderStartPos);
-
-							let remaining = this.ensureBuffered(result.header.totalSize);
-							if (remaining instanceof Promise) remaining = await remaining;
-
-							const duration = result.header.audioSamplesInFrame * TIMESCALE
-								/ elementaryStream.info.sampleRate;
-							return this.supplyPacket(remaining, Math.round(duration));
-						} else {
-							this.seekTo(possibleHeaderStartPos + 1);
-						}
-					} else if (codec === 'ac3') {
-						if (byte !== 0x0b) {
-							continue;
-						}
-
-						this.skip(-1);
-						const possibleSyncPos = this.currentPos;
-
-						// Need at least 5 bytes for sync word + CRC + fscod/frmsizecod
-						let remaining = this.ensureBuffered(5);
-						if (remaining instanceof Promise) remaining = await remaining;
-
-						if (remaining < 5) {
-							return;
-						}
-
-						const headerBytes = this.readBytes(5);
-
-						// Verify sync word (0x0B77)
-						if (headerBytes[0] !== 0x0b || headerBytes[1] !== 0x77) {
-							this.seekTo(possibleSyncPos + 1);
-							continue;
-						}
-
-						const fscod = headerBytes[4]! >> 6;
-						const frmsizecod = headerBytes[4]! & 0x3f;
-
-						if (fscod === 3 || frmsizecod > 37) {
-							// Invalid
-							this.seekTo(possibleSyncPos + 1);
-							continue;
-						}
-
-						const frameSize = AC3_FRAME_SIZES[3 * frmsizecod + fscod];
-						assert(frameSize !== undefined);
-
-						this.seekTo(possibleSyncPos);
-
-						remaining = this.ensureBuffered(frameSize);
-						if (remaining instanceof Promise) remaining = await remaining;
-
-						const duration = Math.round(
-							AC3_SAMPLES_PER_FRAME * TIMESCALE / elementaryStream.info.sampleRate,
-						);
-						return this.supplyPacket(remaining, duration);
-					} else if (codec === 'eac3') {
-						if (byte !== 0x0b) {
-							continue;
-						}
-
-						this.skip(-1);
-						const possibleSyncPos = this.currentPos;
-
-						// Need at least 5 bytes for E-AC-3 header parsing (sync word + frmsiz + fscod/numblkscod)
-						let remaining = this.ensureBuffered(5);
-						if (remaining instanceof Promise) remaining = await remaining;
-
-						if (remaining < 5) {
-							return;
-						}
-
-						const headerBytes = this.readBytes(5);
-
-						if (headerBytes[0] !== 0x0b || headerBytes[1] !== 0x77) {
-							this.seekTo(possibleSyncPos + 1);
-							continue;
-						}
-
-						const frmsiz = ((headerBytes[2]! & 0x07) << 8) | headerBytes[3]!;
-						const frameSize = (frmsiz + 1) * 2;
-						const fscod = headerBytes[4]! >> 6;
-						const numblkscod = fscod === 3 ? 3 : (headerBytes[4]! >> 4) & 0x03;
-						const numblks = EAC3_NUMBLKS_TABLE[numblkscod]!;
-
-						this.seekTo(possibleSyncPos);
-
-						remaining = this.ensureBuffered(frameSize);
-						if (remaining instanceof Promise) remaining = await remaining;
-
-						// Duration = numblks * 256 samples per block
-						const samplesPerFrame = numblks * 256;
-						const duration = Math.round(
-							samplesPerFrame * TIMESCALE / elementaryStream.info.sampleRate,
-						);
-						return this.supplyPacket(remaining, duration);
-					} else {
-						throw new Error('Unhandled.');
-					}
-				}
-
-				if (remaining < CHUNK_SIZE) {
-					break;
-				}
-			}
-		}
-	}
-
-	/** Supplies the context with a new encoded packet, beginning at the current position. */
-	supplyPacket(packetLength: number, intrinsicDuration: number) {
-		const currentPesPacket = this.getCurrentPesPacket();
-
-		let pts: number;
-		if (this.lastSuppliedPesPacket === currentPesPacket) {
-			assert(this.nextPts !== null);
-			pts = this.nextPts;
-		} else {
-			if (currentPesPacket.pts === null) {
-				throw new Error(MISSING_PTS_ERROR_MESSAGE);
-			}
-
-			pts = currentPesPacket.pts;
-
-			maybeInsertReferencePacket(this.elementaryStream, currentPesPacket as TimestampedPesPacket);
-		}
-
-		this.lastSuppliedPesPacket = currentPesPacket;
-		this.nextPts = pts + intrinsicDuration;
-
-		const sectionStartPos = currentPesPacket.sectionStartPos;
-		// The sequence number is the starting position of the section the PES packet is in, PLUS the offset within the
-		// PES packet where the packet starts.
-		const sequenceNumber = sectionStartPos + (this.currentPos - this.currentPesPacketPos);
-		const data = this.readBytes(packetLength);
-
-		let randomAccessIndicator = currentPesPacket.randomAccessIndicator;
-
-		if (randomAccessIndicator === 0 && !this.elementaryStream.canBeTrustedWithKeyPackets) {
-			if (this.elementaryStream.info.type === 'audio') {
-				randomAccessIndicator = 1;
-			} else {
-				if (this.elementaryStream.info.decoderConfig) {
-					const isKey = determineVideoPacketType(
-						this.elementaryStream.info.codec,
-						this.elementaryStream.info.decoderConfig,
-						data,
-					) === 'key';
-
-					randomAccessIndicator = Number(isKey);
-				} else {
-					// We're reading packets before the decoder config is determined
-				}
-			}
-		}
-
-		this.suppliedPacket = {
-			pts,
-			data,
-			sequenceNumber,
-			sectionStartPos,
-			randomAccessIndicator,
-		};
-
-		this.pesPackets.splice(0, this.currentPesPacketIndex);
-		this.currentPesPacketIndex = 0;
-	}
-}
-
-/**
- * A buffer that simulates decoder frame reordering to compute packet durations. Packets arrive in decode order but
- * durations are based on presentation order.
- */
-class PacketBuffer {
-	backing: MpegTsTrackBacking;
-	context: PacketReadingContext;
-
-	decodeOrderPackets: SuppliedPacket[] = [];
-	reorderSize: number;
-	reorderBuffer: SuppliedPacket[] = [];
-	presentationOrderPackets: SuppliedPacket[] = [];
-	reachedEnd = false;
-	lastDuration = 0;
-
-	constructor(backing: MpegTsTrackBacking, context: PacketReadingContext) {
-		this.backing = backing;
-		this.context = context;
-		this.reorderSize = backing.getReorderSize();
-		assert(this.reorderSize >= 0);
-	}
-
-	async readNext(): Promise<{ packet: SuppliedPacket; duration: number } | null> {
-		if (this.decodeOrderPackets.length === 0) {
-			// We need the next packet
-			const didRead = await this.readNextPacket();
-			if (!didRead) {
-				return null;
-			}
-		}
-
-		// Ensure we know the next packet in presentation order so we can compute the current packet's duration
-		await this.ensureCurrentPacketHasNext();
-
-		const packet = this.decodeOrderPackets[0]!;
-
-		// Let's compute the duration
-		const presentationIndex = this.presentationOrderPackets.indexOf(packet);
-		assert(presentationIndex !== -1);
-
-		let duration: number;
-		if (presentationIndex === this.presentationOrderPackets.length - 1) {
-			duration = this.lastDuration; // Reasonable heuristic
-		} else {
-			const nextPacket = this.presentationOrderPackets[presentationIndex + 1]!;
-			duration = nextPacket.pts - packet.pts;
-			this.lastDuration = duration;
-		}
-
-		this.decodeOrderPackets.shift();
-
-		// Shrink the presentation array as much as possible
-		while (this.presentationOrderPackets.length > 0) {
-			const first = this.presentationOrderPackets[0]!;
-			if (this.decodeOrderPackets.includes(first)) {
-				break;
-			}
-
-			this.presentationOrderPackets.shift();
-		}
-
-		return { packet, duration };
-	}
-
-	async readNextPacket() {
-		if (this.reachedEnd) {
-			return false;
-		}
-
-		let suppliedPacket: SuppliedPacket | null;
-		if (this.context.suppliedPacket) {
-			// Small optimization: there was already a supplied packet in the context, so let's first use that one
-			suppliedPacket = this.context.suppliedPacket;
-		} else {
-			await this.context.markNextPacket();
-			suppliedPacket = this.context.suppliedPacket;
-		}
-		this.context.suppliedPacket = null;
-
-		if (!suppliedPacket) {
-			this.reachedEnd = true;
-			this.flushReorderBuffer();
-
-			return false;
-		}
-
-		this.decodeOrderPackets.push(suppliedPacket);
-		this.processPacketThroughReorderBuffer(suppliedPacket);
-
-		return true;
-	}
-
-	async ensureCurrentPacketHasNext() {
-		const current = this.decodeOrderPackets[0];
-		assert(current);
-
-		while (true) {
-			const presentationIndex = this.presentationOrderPackets.indexOf(current);
-
-			// Check if current packet has a next packet
-			if (presentationIndex !== -1 && presentationIndex <= this.presentationOrderPackets.length - 2) {
-				break;
-			}
-
-			const didRead = await this.readNextPacket();
-			if (!didRead) {
-				break;
-			}
-		}
-	}
-
-	processPacketThroughReorderBuffer(packet: SuppliedPacket) {
-		this.reorderBuffer.push(packet);
-
-		// If buffer is now overfull, output the packet with smallest PTS
-		if (this.reorderBuffer.length > this.reorderSize) {
-			let minIndex = 0;
-			for (let i = 1; i < this.reorderBuffer.length; i++) {
-				if (this.reorderBuffer[i]!.pts < this.reorderBuffer[minIndex]!.pts) {
-					minIndex = i;
-				}
-			}
-
-			const packet = this.reorderBuffer[minIndex]!;
-			this.presentationOrderPackets.push(packet);
-			this.reorderBuffer.splice(minIndex, 1);
-		}
-	}
-
-	flushReorderBuffer() {
-		this.reorderBuffer.sort((a, b) => a.pts - b.pts);
-		this.presentationOrderPackets.push(...this.reorderBuffer);
-		this.reorderBuffer.length = 0;
-	}
-}