@bubo-squared/gyroview 0.2.0 → 0.3.0

package/dist/packages/core/src/domain/download/trackNeeds.js

@@ -0,0 +1,32 @@
+import { ByteRange } from "../../shared/binary/ByteRange.js";
+import { ByteRangeSet } from "../../shared/binary/ByteRangeSet.js";
+//#region ../../packages/core/src/domain/download/trackNeeds.ts
+/**
+* The ranges of the samples a cursor will hand out, in decode order, up to the first that shows
+* after `until`: with B-frames the window ends up to a reordering group early, which the plans
+* after read.
+*/
+function needsOf(cursor, until) {
+	const { track } = cursor;
+	const needs = [];
+	for (let sample = cursor.sample; sample < track.sampleCount; sample += 1) {
+		if (track.timestampOf(sample) > until) break;
+		needs.push(track.rangeOf(sample));
+	}
+	return needs;
+}
+/**
+* The first `budget` bytes of `wanted`, lowest first; the gaps between its ranges cost nothing.
+*/
+function withinBytes(wanted, budget) {
+	const kept = [];
+	let left = budget;
+	for (const range of wanted.ranges) {
+		if (left <= 0) break;
+		kept.push(ByteRange.of(range.offset, Math.min(range.length, left)));
+		left -= range.length;
+	}
+	return ByteRangeSet.of(kept);
+}
+//#endregion
+export { needsOf, withinBytes };

package/dist/packages/core/src/domain/format/boxes/boxHeader.js

@@ -0,0 +1,44 @@
+import { hasErrorCode } from "../../../shared/errors/GyroViewError.js";
+import { isPlausibleBoxType } from "./boxConstants.js";
+//#region ../../packages/core/src/domain/format/boxes/boxHeader.ts
+/**
+* The header of the box whose first bytes `header` holds, in a space of `room` bytes from the
+* box's start (to the end of the file, or of the box around it), which a size of zero fills.
+* Undefined when those bytes form no box that fits there: the file's boxes have ended and a
+* bare trailer begins, or a box inside another is malformed.
+*/
+function boxHeaderOf(header, room) {
+	if (header.length < 8) return void 0;
+	const type = header.asciiAt(4, 4);
+	if (!isPlausibleBoxType(type)) return void 0;
+	const extent = extentOf(header, room);
+	return extent !== void 0 && extent.size >= extent.headerSize && extent.size <= room ? {
+		type,
+		...extent
+	} : void 0;
+}
+/**
+* Undefined when the header declares a large size that is not a safe integer: real boxes never
+* do, so those bytes are not a box.
+*/
+function extentOf(header, room) {
+	const declared = header.uint32BeAt(0);
+	if (declared === 1 && header.length >= 16) return largeExtent(header);
+	return {
+		size: declared === 0 ? room : declared,
+		headerSize: 8
+	};
+}
+function largeExtent(header) {
+	try {
+		return {
+			size: header.uint64BeAt(8),
+			headerSize: 16
+		};
+	} catch (error) {
+		if (hasErrorCode(error, "binary-unsafe-integer")) return void 0;
+		throw error;
+	}
+}
+//#endregion
+export { boxHeaderOf };

package/dist/packages/core/src/domain/format/boxes/scanBoxes.js

@@ -1,7 +1,6 @@
-import { hasErrorCode } from "../../../shared/errors/GyroViewError.js";
 import { ByteReader } from "../../../shared/binary/ByteReader.js";
 import { ByteRange } from "../../../shared/binary/ByteRange.js";
-import { isPlausibleBoxType } from "./boxConstants.js";
+import { boxHeaderOf } from "./boxHeader.js";
 //#region ../../packages/core/src/domain/format/boxes/scanBoxes.ts
 /**
 * Walks the top-level boxes of a file with one small read per box, and stops at the first bytes
@@ -20,40 +19,14 @@ async function scanBoxes(source, fileSize) {
 	return boxes;
 }
 async function readBoxAt(source, offset, fileSize) {
-	const headerLength = Math.min(16, fileSize - offset);
+	const room = fileSize - offset;
+	const headerLength = Math.min(16, room);
 	const header = new ByteReader(await source.read(ByteRange.of(offset, headerLength)));
-	const type = header.asciiAt(4, 4);
-	if (!isPlausibleBoxType(type)) return void 0;
-	const resolved = resolveSize(header, offset, fileSize);
-	if (!resolved) return void 0;
-	const { size, headerSize } = resolved;
-	return size >= headerSize && offset + size <= fileSize ? {
-		type,
-		range: ByteRange.of(offset, size)
-	} : void 0;
-}
-/**
-* Undefined when the header declares a large size that is not a safe integer: real boxes never
-* do, so those bytes are trailer data, not a box.
-*/
-function resolveSize(header, offset, fileSize) {
-	const declared = header.uint32BeAt(0);
-	if (declared === 1 && header.length >= 16) return largeSize(header);
-	return {
-		size: declared === 0 ? fileSize - offset : declared,
-		headerSize: 8
+	const box = boxHeaderOf(header, room);
+	return box && {
+		type: box.type,
+		range: ByteRange.of(offset, box.size)
 	};
 }
-function largeSize(header) {
-	try {
-		return {
-			size: header.uint64BeAt(8),
-			headerSize: 16
-		};
-	} catch (error) {
-		if (hasErrorCode(error, "binary-unsafe-integer")) return void 0;
-		throw error;
-	}
-}
 //#endregion
 export { scanBoxes };

package/dist/packages/core/src/domain/format/mp4/keyframeRules.js

@@ -0,0 +1,81 @@
+import { AVC_SAMPLE_ENTRIES, HEVC_SAMPLE_ENTRIES } from "./mp4BoxTypes.js";
+import { EVERY_SAMPLE_IS_A_KEYFRAME } from "../../container/KeyframeRule.js";
+//#region ../../packages/core/src/domain/format/mp4/keyframeRules.ts
+/**
+* ITU-T H.264 Table 7-1: nal_unit_type is the low five bits of the header byte; types 1 to 4 are
+* slices of a picture that is not an IDR picture, type 5 a slice of one.
+*/
+var AVC_TYPE_MASK = 31;
+var AVC_FIRST_NON_IDR_SLICE = 1;
+var AVC_LAST_SLICE_PARTITION = 4;
+var AVC_IDR_SLICE = 5;
+/**
+* ITU-T H.265 Table 7-1: nal_unit_type is six bits after the header's first bit; types 0 to 15
+* are pictures that are no intra random access point, 16 (BLA_W_LP) to 23 (RSV_IRAP_VCL23) ones
+* that are, and the rest (reserved, parameter sets, SEI) say nothing of the picture.
+*/
+var HEVC_TYPE_SHIFT = 1;
+var HEVC_TYPE_MASK = 63;
+var HEVC_FIRST_IRAP = 16;
+var HEVC_LAST_IRAP = 23;
+/**
+* Only an IDR slice starts decoding. mediabunny also takes a recovery-point SEI outside
+* Chromium, where decoding from it may show broken frames first; the player never starts there.
+*/
+var AVC = {
+	typeOf: (header) => header & AVC_TYPE_MASK,
+	verdictOn: (type) => {
+		if (type === AVC_IDR_SLICE) return "keyframe";
+		return type >= AVC_FIRST_NON_IDR_SLICE && type <= AVC_LAST_SLICE_PARTITION ? "not-a-keyframe" : "read-on";
+	}
+};
+var HEVC = {
+	typeOf: (header) => header >> HEVC_TYPE_SHIFT & HEVC_TYPE_MASK,
+	verdictOn: (type) => {
+		if (type < HEVC_FIRST_IRAP) return "not-a-keyframe";
+		return type <= HEVC_LAST_IRAP ? "keyframe" : "read-on";
+	}
+};
+var BITS_PER_BYTE = 8;
+/**
+* Reads a sample's NAL units one after another, each after its length, until one tells whether
+* the picture is a keyframe; a sample that never tells, or whose units run past its end, is not
+* one.
+*/
+var NalKeyframeRule = class {
+	family;
+	lengthSize;
+	constructor(family, lengthSize) {
+		this.family = family;
+		this.lengthSize = lengthSize;
+	}
+	isKeyframe(sample) {
+		let offset = 0;
+		while (offset + this.lengthSize < sample.length) {
+			const unitStart = offset + this.lengthSize;
+			const unitEnd = unitStart + lengthAt(sample, offset, this.lengthSize);
+			if (unitEnd > sample.length) return false;
+			const verdict = this.family.verdictOn(this.family.typeOf(sample[unitStart] ?? 0));
+			if (verdict !== "read-on") return verdict === "keyframe";
+			offset = unitEnd;
+		}
+		return false;
+	}
+};
+function lengthAt(sample, offset, size) {
+	let length = 0;
+	for (let index = 0; index < size; index += 1) length = length * 2 ** BITS_PER_BYTE + (sample[offset + index] ?? 0);
+	return length;
+}
+var FAMILIES_BY_SAMPLE_ENTRY = [[AVC_SAMPLE_ENTRIES, AVC], [HEVC_SAMPLE_ENTRIES, HEVC]];
+/**
+* The rule for a track's codec, by its sample entry. A codec without NAL units, or whose length
+* size is unknown, keeps its sample table's word.
+*/
+function keyframeRuleFor(entry) {
+	const { sampleEntryType, nalLengthSize } = entry;
+	const [, family] = FAMILIES_BY_SAMPLE_ENTRY.find(([entries]) => entries.includes(sampleEntryType)) ?? [];
+	return family && nalLengthSize !== void 0 ? new NalKeyframeRule(family, nalLengthSize) : EVERY_SAMPLE_IS_A_KEYFRAME;
+}
+//#endregion
+export { keyframeRuleFor };

package/dist/packages/core/src/domain/format/mp4/movieBoxes.js

@@ -0,0 +1,52 @@
+import { GyroViewError } from "../../../shared/errors/GyroViewError.js";
+import { ByteReader } from "../../../shared/binary/ByteReader.js";
+import { boxHeaderOf } from "../boxes/boxHeader.js";
+//#region ../../packages/core/src/domain/format/mp4/movieBoxes.ts
+/**
+* The boxes `bytes` holds one after another: the children of a container box. Fewer bytes than
+* a header at the end are padding, which some muxers leave; any other bytes that form no box are
+* a movie box the player cannot read.
+*/
+function boxesIn(bytes) {
+	const boxes = [];
+	let offset = 0;
+	while (bytes.byteLength - offset >= 8) {
+		const room = bytes.byteLength - offset;
+		const headerBytes = bytes.subarray(offset, offset + 16);
+		const header = boxHeaderOf(new ByteReader(headerBytes), room);
+		if (!header) throw unreadableMovie(`holds no box at byte ${offset} of ${bytes.byteLength}`);
+		const body = bytes.subarray(offset + header.headerSize, offset + header.size);
+		boxes.push({
+			type: header.type,
+			body
+		});
+		offset += header.size;
+	}
+	return boxes;
+}
+/**
+* The first box of a type the movie box cannot do without.
+*/
+function requiredBox(boxes, type) {
+	const box = optionalBox(boxes, type);
+	if (!box) throw unreadableMovie(`has no ${type} box where one belongs`);
+	return box;
+}
+function optionalBox(boxes, type) {
+	return boxes.find((box) => box.type === type);
+}
+function fullBoxOf(box) {
+	if (box.body.byteLength < 4) throw unreadableMovie(`has a ${box.type} box too short for its version and flags`);
+	return {
+		version: box.body[0] ?? 0,
+		content: new ByteReader(box.body.subarray(4))
+	};
+}
+/**
+* A movie box whose bytes do not describe the samples as ISO/IEC 14496-12 lays them out.
+*/
+function unreadableMovie(what) {
+	return new GyroViewError("unsupported-container", `the movie box ${what}`);
+}
+//#endregion
+export { boxesIn, fullBoxOf, optionalBox, requiredBox, unreadableMovie };

package/dist/packages/core/src/domain/format/mp4/mp4BoxTypes.js

@@ -0,0 +1,46 @@
+//#region ../../packages/core/src/domain/format/mp4/mp4BoxTypes.ts
+/**
+* The MP4 boxes the player reads or refuses, by the names ISO/IEC 14496-12 gives them.
+*/
+var Mp4BoxType = {
+	FileType: "ftyp",
+	MediaData: "mdat",
+	Movie: "moov",
+	MovieHeader: "mvhd",
+	MovieExtends: "mvex",
+	Track: "trak",
+	TrackHeader: "tkhd",
+	Edit: "edts",
+	EditList: "elst",
+	Media: "mdia",
+	MediaHeader: "mdhd",
+	Handler: "hdlr",
+	MediaInformation: "minf",
+	SampleTable: "stbl",
+	SampleDescription: "stsd",
+	TimeToSample: "stts",
+	CompositionOffset: "ctts",
+	SyncSample: "stss",
+	SampleToChunk: "stsc",
+	SampleSize: "stsz",
+	ChunkOffset: "stco",
+	ChunkLargeOffset: "co64",
+	AvcConfiguration: "avcC",
+	HevcConfiguration: "hvcC"
+};
+/**
+* A track's handler type (ISO/IEC 14496-12 §8.4.3): what its samples are. Tracks of any other
+* handler (timed metadata, hints) are not played.
+*/
+var HandlerType = {
+	Video: "vide",
+	Sound: "soun"
+};
+/**
+* The sample entries of the codecs the cameras record, by family: the parameter sets travel in
+* the sample entry (`avc1`, `hvc1`) or in the stream as well (`avc3`, `hev1`); ISO/IEC 14496-15.
+*/
+var AVC_SAMPLE_ENTRIES = ["avc1", "avc3"];
+var HEVC_SAMPLE_ENTRIES = ["hvc1", "hev1"];
+//#endregion
+export { AVC_SAMPLE_ENTRIES, HEVC_SAMPLE_ENTRIES, HandlerType, Mp4BoxType };

package/dist/packages/core/src/domain/format/mp4/mp4Layouts.js

@@ -0,0 +1,183 @@
+//#region ../../packages/core/src/domain/format/mp4/mp4Layouts.ts
+/**
+* MovieHeaderBox, `mvhd` (§8.2.2): creation and modification times, the movie timescale (in which
+* edit lists count), the duration, then fields the player does not read.
+*/
+var MOVIE_HEADER = {
+	0: {
+		timescale: 8,
+		duration: {
+			offset: 12,
+			kind: "uint32"
+		},
+		size: 96
+	},
+	1: {
+		timescale: 16,
+		duration: {
+			offset: 20,
+			kind: "uint64"
+		},
+		size: 108
+	}
+};
+/**
+* TrackHeaderBox, `tkhd` (§8.3.2): the track's id sits after the creation and modification times.
+*/
+var TRACK_HEADER_ID = {
+	0: 8,
+	1: 16
+};
+/**
+* MediaHeaderBox, `mdhd` (§8.4.2): the timescale the track's sample tables count in.
+*/
+var MEDIA_HEADER = {
+	0: {
+		timescale: 8,
+		duration: {
+			offset: 12,
+			kind: "uint32"
+		},
+		size: 20
+	},
+	1: {
+		timescale: 16,
+		duration: {
+			offset: 20,
+			kind: "uint64"
+		},
+		size: 32
+	}
+};
+/**
+* TimeToSampleBox, `stts` (§8.6.1.2): runs of samples with the same decode duration.
+*/
+var TIME_TO_SAMPLE = {
+	entrySize: 8,
+	fields: {
+		sampleCount: {
+			offset: 0,
+			kind: "uint32"
+		},
+		sampleDelta: {
+			offset: 4,
+			kind: "uint32"
+		}
+	}
+};
+/**
+* CompositionOffsetBox, `ctts` (§8.6.1.3): runs of samples presented the same time after (and in
+* version 1, possibly before) they are decoded. Version 0 is unsigned by the standard, but
+* writers put negative offsets there too, so both versions are read signed, as mediabunny and
+* FFmpeg read them.
+*/
+var COMPOSITION_OFFSET = {
+	entrySize: 8,
+	fields: {
+		sampleCount: {
+			offset: 0,
+			kind: "uint32"
+		},
+		sampleOffset: {
+			offset: 4,
+			kind: "int32"
+		}
+	}
+};
+/**
+* SyncSampleBox, `stss` (§8.6.2): the 1-based numbers of the samples decoding may start at. A
+* track without one starts anywhere.
+*/
+var SYNC_SAMPLE = {
+	entrySize: 4,
+	fields: { sampleNumber: {
+		offset: 0,
+		kind: "uint32"
+	} }
+};
+/**
+* EditListBox, `elst` (§8.6.6): segments of the movie timeline, each showing the media from
+* `mediaTime` (media timescale) for `segmentDuration` (movie timescale), or nothing where
+* `mediaTime` is -1.
+*/
+var EDIT_LIST = {
+	0: {
+		entrySize: 12,
+		fields: {
+			segmentDuration: {
+				offset: 0,
+				kind: "uint32"
+			},
+			mediaTime: {
+				offset: 4,
+				kind: "int32"
+			},
+			mediaRate: {
+				offset: 8,
+				kind: "uint32"
+			}
+		}
+	},
+	1: {
+		entrySize: 20,
+		fields: {
+			segmentDuration: {
+				offset: 0,
+				kind: "uint64"
+			},
+			mediaTime: {
+				offset: 8,
+				kind: "int64"
+			},
+			mediaRate: {
+				offset: 16,
+				kind: "uint32"
+			}
+		}
+	}
+};
+/**
+* An edit's media rate is 16.16 fixed point; 1 plays the media at its own pace.
+*/
+var UNIT_MEDIA_RATE = 65536;
+/**
+* SampleToChunkBox, `stsc` (§8.7.4): from each 1-based first chunk on, how many samples a chunk
+* holds, until the next entry's first chunk.
+*/
+var SAMPLE_TO_CHUNK = {
+	entrySize: 12,
+	fields: {
+		firstChunk: {
+			offset: 0,
+			kind: "uint32"
+		},
+		samplesPerChunk: {
+			offset: 4,
+			kind: "uint32"
+		},
+		sampleDescriptionIndex: {
+			offset: 8,
+			kind: "uint32"
+		}
+	}
+};
+/**
+* ChunkOffsetBox, `stco`, and ChunkLargeOffsetBox, `co64` (§8.7.5): where each chunk starts in the
+* file, in 32 or 64 bits.
+*/
+var CHUNK_OFFSET = {
+	entrySize: 4,
+	fields: { chunkOffset: {
+		offset: 0,
+		kind: "uint32"
+	} }
+};
+var CHUNK_LARGE_OFFSET = {
+	entrySize: 8,
+	fields: { chunkOffset: {
+		offset: 0,
+		kind: "uint64"
+	} }
+};
+//#endregion
+export { CHUNK_LARGE_OFFSET, CHUNK_OFFSET, COMPOSITION_OFFSET, EDIT_LIST, MEDIA_HEADER, MOVIE_HEADER, SAMPLE_TO_CHUNK, SYNC_SAMPLE, TIME_TO_SAMPLE, TRACK_HEADER_ID, UNIT_MEDIA_RATE };

package/dist/packages/core/src/domain/format/mp4/parseMovie.js

@@ -0,0 +1,67 @@
+import { HandlerType, Mp4BoxType } from "./mp4BoxTypes.js";
+import { keyframeRuleFor } from "./keyframeRules.js";
+import { boxesIn, fullBoxOf, optionalBox, unreadableMovie } from "./movieBoxes.js";
+import { SYNC_SAMPLE } from "./mp4Layouts.js";
+import { readTableColumns } from "./readTable.js";
+import { sampleLocationsOf } from "./sampleLocations.js";
+import { movieTimescaleOf, trackBoxesOf, trackHeadersOf } from "./trackHeaders.js";
+import { sampleTimingOf } from "./sampleTiming.js";
+import { SampleTable } from "../../container/SampleTable.js";
+import { TrackSampleTable } from "../../container/TrackSampleTable.js";
+//#region ../../packages/core/src/domain/format/mp4/parseMovie.ts
+/**
+* The tracks the player plays, by handler; the others (time codes, metadata) are left out.
+*/
+var KIND_OF_HANDLER = {
+	[HandlerType.Video]: "video",
+	[HandlerType.Sound]: "audio"
+};
+/**
+* Sample numbers in the sync sample table count from one.
+*/
+var FIRST_SAMPLE_NUMBER = 1;
+/**
+* The sample table of a whole movie box (`moov`, header included): every sample of every track
+* of picture or sound. A fragmented movie, whose samples are described in movie fragments after
+* it, is refused: the cameras write none.
+*/
+function parseMovie(movieBox) {
+	const [movie] = boxesIn(movieBox);
+	if (movie?.type !== Mp4BoxType.Movie) throw unreadableMovie("is not where the file says it is");
+	const children = boxesIn(movie.body);
+	if (optionalBox(children, Mp4BoxType.MovieExtends)) throw unreadableMovie("is fragmented: its samples are described in movie fragments after it");
+	const movieTimescale = movieTimescaleOf(children);
+	const tracks = children.filter((box) => box.type === Mp4BoxType.Track).flatMap((box) => playedTrackOf(trackBoxesOf(box), movieTimescale));
+	return new SampleTable(tracks);
+}
+function playedTrackOf(boxes, movieTimescale) {
+	const headers = trackHeadersOf(boxes);
+	const kind = KIND_OF_HANDLER[headers.handlerType];
+	if (!kind) return [];
+	const locations = sampleLocationsOf(boxes.sampleTable);
+	const timing = sampleTimingOf(boxes, {
+		media: headers.mediaTimescale,
+		movie: movieTimescale,
+		sampleCount: locations.sizes.length
+	});
+	return [new TrackSampleTable({
+		trackId: headers.trackId,
+		kind,
+		...locations,
+		...timing,
+		syncSamples: syncSamplesOf(boxes.sampleTable),
+		keyframeRule: keyframeRuleFor(headers)
+	})];
+}
+/**
+* The samples decoding may start at, counted from zero; undefined for a track without a sync
+* sample table, whose every sample is one.
+*/
+function syncSamplesOf(sampleTable) {
+	const box = optionalBox(sampleTable, Mp4BoxType.SyncSample);
+	if (!box) return void 0;
+	const { sampleNumber } = readTableColumns(fullBoxOf(box).content, SYNC_SAMPLE);
+	return sampleNumber.map((number) => number - FIRST_SAMPLE_NUMBER);
+}
+//#endregion
+export { parseMovie };

package/dist/packages/core/src/domain/format/mp4/readTable.js

@@ -0,0 +1,31 @@
+import { unreadableMovie } from "./movieBoxes.js";
+//#region ../../packages/core/src/domain/format/mp4/readTable.ts
+/**
+* How each kind of integer in a box layout is read, big-endian.
+*/
+var READERS = {
+	uint32: (reader, offset) => reader.uint32BeAt(offset),
+	uint64: (reader, offset) => reader.uint64BeAt(offset),
+	int32: (reader, offset) => reader.int32BeAt(offset),
+	int64: (reader, offset) => reader.int64BeAt(offset)
+};
+/**
+* The integer a layout puts at `field`, counted from `base`.
+*/
+function readInteger(reader, field, base = 0) {
+	return READERS[field.kind](reader, base + field.offset);
+}
+/**
+* A table box's entries, one column per field, read from its content after the version and
+* flags.
+*/
+function readTableColumns(content, layout) {
+	const count = content.uint32BeAt(0);
+	if (4 + count * layout.entrySize > content.length) throw unreadableMovie(`has a table of ${count} entries that do not fit in its box`);
+	const fields = Object.keys(layout.fields);
+	const columns = {};
+	for (const field of fields) columns[field] = Array.from({ length: count }, (_, index) => readInteger(content, layout.fields[field], 4 + index * layout.entrySize));
+	return columns;
+}
+//#endregion
+export { readTableColumns };

package/dist/packages/core/src/domain/format/mp4/sampleLocations.js

@@ -0,0 +1,69 @@
+import { Mp4BoxType } from "./mp4BoxTypes.js";
+import { fullBoxOf, optionalBox, requiredBox, unreadableMovie } from "./movieBoxes.js";
+import { CHUNK_LARGE_OFFSET, CHUNK_OFFSET, SAMPLE_TO_CHUNK } from "./mp4Layouts.js";
+import { readTableColumns } from "./readTable.js";
+//#region ../../packages/core/src/domain/format/mp4/sampleLocations.ts
+/**
+* Chunk numbers in the sample-to-chunk table count from one.
+*/
+var FIRST_CHUNK_NUMBER = 1;
+/**
+* The sample locations a sample table's boxes describe: the sizes of `stsz`, laid out one after
+* another in the chunks `stsc` fills, which start where `stco` or `co64` says.
+*/
+function sampleLocationsOf(sampleTable) {
+	const sizes = sampleSizesOf(requiredBox(sampleTable, Mp4BoxType.SampleSize));
+	const chunkOffsets = chunkOffsetsOf(sampleTable);
+	const sampleToChunk = fullBoxOf(requiredBox(sampleTable, Mp4BoxType.SampleToChunk)).content;
+	return {
+		offsets: offsetsOf({
+			sizes,
+			chunkOffsets,
+			perChunk: samplesPerChunkOf(readTableColumns(sampleToChunk, SAMPLE_TO_CHUNK), chunkOffsets.length)
+		}),
+		sizes
+	};
+}
+function sampleSizesOf(box) {
+	const { content } = fullBoxOf(box);
+	const shared = content.uint32BeAt(0);
+	const count = content.uint32BeAt(4);
+	if (shared !== 0) return new Float64Array(count).fill(shared);
+	if (8 + count * 4 > content.length) throw unreadableMovie(`lists ${count} sample sizes that do not fit in its box`);
+	return Float64Array.from({ length: count }, (_, index) => content.uint32BeAt(8 + index * 4));
+}
+function chunkOffsetsOf(sampleTable) {
+	const large = optionalBox(sampleTable, Mp4BoxType.ChunkLargeOffset);
+	const box = large ?? optionalBox(sampleTable, Mp4BoxType.ChunkOffset);
+	if (!box) throw unreadableMovie("has a sample table without chunk offsets");
+	const layout = large ? CHUNK_LARGE_OFFSET : CHUNK_OFFSET;
+	return readTableColumns(fullBoxOf(box).content, layout).chunkOffset;
+}
+/**
+* How many samples each chunk holds: every entry holds from its first chunk to the next entry's.
+*/
+function samplesPerChunkOf(table, chunkCount) {
+	const perChunk = Array.from({ length: chunkCount }, () => 0);
+	for (const [entry, firstChunk] of table.firstChunk.entries()) {
+		const nextFirst = table.firstChunk[entry + 1] ?? chunkCount + FIRST_CHUNK_NUMBER;
+		const count = table.samplesPerChunk[entry] ?? 0;
+		perChunk.fill(count, firstChunk - FIRST_CHUNK_NUMBER, nextFirst - FIRST_CHUNK_NUMBER);
+	}
+	return perChunk;
+}
+function offsetsOf(layout) {
+	const offsets = new Float64Array(layout.sizes.length);
+	let sample = 0;
+	for (const [chunk, chunkOffset] of layout.chunkOffsets.entries()) {
+		let offset = chunkOffset;
+		const last = Math.min(sample + (layout.perChunk[chunk] ?? 0), offsets.length);
+		for (; sample < last; sample += 1) {
+			offsets[sample] = offset;
+			offset += layout.sizes[sample] ?? 0;
+		}
+	}
+	if (sample < offsets.length) throw unreadableMovie(`has chunks for ${sample} of its ${offsets.length} samples`);
+	return offsets;
+}
+//#endregion
+export { sampleLocationsOf };