@bubo-squared/gyroview 0.2.0 → 0.3.1

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

@@ -0,0 +1,41 @@
+import { seconds } from "../../shared/units/time.js";
+//#region ../../packages/core/src/domain/download/DownloadPolicy.ts
+var MEBIBYTE = 1048576;
+/**
+* What the policy reads ahead and keeps behind, as time and at most as bytes: the byte limits
+* bind first on the X5's 210 Mbit/s, the times on slower recordings. A split recording shares
+* the byte limits among its files.
+*/
+var AHEAD_SECONDS = 10;
+var MOST_AHEAD_MEBIBYTES = 128;
+var KEEP_BEHIND_SECONDS = 2;
+var MOST_KEPT_BEHIND_MEBIBYTES = 32;
+var REQUEST_MEBIBYTES = 8;
+var REQUESTS_IN_FLIGHT = 2;
+var BRIDGED_GAP_MEBIBYTES = 1;
+var REFILL_FRACTION = .25;
+/**
+* Long enough that a link slower than the recording plays in stretches rather than frame by
+* frame, short enough that the wait does not feel like a stop.
+*/
+var RESUME_SECONDS = 4;
+/**
+* The policy for one file of a recording of `fileCount` files, by its bit rate.
+*/
+function downloadPolicyFor(file, fileCount) {
+	const bytesPerSecond = file.size / file.duration;
+	const aheadBytes = Math.min(Math.round(AHEAD_SECONDS * bytesPerSecond), MOST_AHEAD_MEBIBYTES * MEBIBYTE / fileCount);
+	return {
+		aheadSeconds: seconds(AHEAD_SECONDS),
+		aheadBytes,
+		keepBehindBytes: Math.min(Math.round(KEEP_BEHIND_SECONDS * bytesPerSecond), MOST_KEPT_BEHIND_MEBIBYTES * MEBIBYTE / fileCount),
+		keepBehindSeconds: seconds(KEEP_BEHIND_SECONDS),
+		requestSize: REQUEST_MEBIBYTES * MEBIBYTE,
+		requestsInFlight: REQUESTS_IN_FLIGHT,
+		bridgedGap: BRIDGED_GAP_MEBIBYTES * MEBIBYTE,
+		refillBytes: Math.round(aheadBytes * REFILL_FRACTION),
+		resumeSeconds: seconds(RESUME_SECONDS)
+	};
+}
+//#endregion
+export { downloadPolicyFor };

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

@@ -0,0 +1,27 @@
+import { seconds } from "../../shared/units/time.js";
+import { ByteRangeSet } from "../../shared/binary/ByteRangeSet.js";
+import { needsOf, withinBytes } from "./trackNeeds.js";
+//#region ../../packages/core/src/domain/download/isReadyToResume.ts
+/**
+* What playback that starved at `time` waits for before it plays again (ADR 0011, ADR 0029):
+* every picture reader's frames up to the policy's resume seconds past it, or as many of them as
+* the budget holds less a request (a refill's worth, where that is less), so the download that
+* keeps it held still tops up in large ranges. Sound needs nothing of its own.
+*/
+function resumeThresholdOf(need) {
+	const { policy } = need;
+	const until = seconds(need.time + policy.resumeSeconds);
+	const pictures = need.cursors.filter((cursor) => cursor.track.kind === "video");
+	const needs = ByteRangeSet.of(pictures.flatMap((cursor) => needsOf(cursor, until)));
+	const margin = Math.min(policy.requestSize, policy.refillBytes);
+	return withinBytes(needs, policy.aheadBytes - margin);
+}
+/**
+* Whether the threshold is held: the download keeps it held once playing, so a download that
+* reads ahead is ready as soon as its bytes have come.
+*/
+function isReadyToResume(state) {
+	return resumeThresholdOf(state).subtract(state.held).isEmpty;
+}
+//#endregion
+export { isReadyToResume, resumeThresholdOf };

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

@@ -0,0 +1,175 @@
+import { seconds } from "../../shared/units/time.js";
+import { ByteRange } from "../../shared/binary/ByteRange.js";
+import { ByteRangeSet } from "../../shared/binary/ByteRangeSet.js";
+import { needsOf, withinBytes } from "./trackNeeds.js";
+import { resumeThresholdOf } from "./isReadyToResume.js";
+//#region ../../packages/core/src/domain/download/planDownloads.ts
+/**
+* The download's plan, from where its readers stand (ADR 0029). The window starts at the
+* slowest picture reader, where the picture last stood once its readers closed (so the sound
+* after the last frame still comes), or at the sound where no picture was ever read; once
+* playing it reaches as far ahead as the policy's seconds and bytes allow, before that only to
+* what the readers wait for. Every picture reader's next frame is read, however far from the
+* others, so none waits for ever; a reader a seek left behind wants nothing until it follows.
+* What is wanted is asked for lowest first and in large ranges: at once when playback needs it
+* now, otherwise once a refill's worth is missing.
+*/
+function planDownloads(state) {
+	const pictures = state.cursors.filter((cursor) => isPicture(cursor));
+	const anchor = pictures.length > 0 ? anchorOf(pictures) : state.anchor;
+	const windowStart = anchor ?? soundLeadOf(state);
+	if (!windowStart) return nothingToRead(state);
+	const ahead = state.isReadingAhead ? state.policy.aheadSeconds : 0;
+	const windowEnd = seconds(windowStart.time + ahead);
+	const wanted = wantedBytes({
+		state,
+		windowStart,
+		windowEnd
+	}).bridgingGapsBelow(state.policy.bridgedGap);
+	const kept = state.transfers.filter((transfer) => transfer.remaining.length === 0 || wanted.overlaps(transfer.remaining));
+	const coming = ByteRangeSet.of(kept.map((transfer) => transfer.remaining));
+	const missing = wanted.subtract(state.held).subtract(coming).subtract(state.unreadable);
+	const room = state.policy.requestsInFlight - kept.length;
+	return {
+		start: isTopUpDue({
+			state,
+			windowStart,
+			windowEnd,
+			missing,
+			threshold: thresholdOf(state, windowStart)
+		}) ? requestsFor(missing, state.policy, room) : [],
+		cancel: state.transfers.filter((transfer) => !kept.includes(transfer)).map((transfer) => transfer.id),
+		release: state.held.subtract(wanted.union(keptBehind(windowStart, state.policy))),
+		anchor
+	};
+}
+/**
+* Where the window starts once playing where no picture was ever read: at the sound, which then
+* has no picture to follow, and follows it as it moves on.
+*/
+function soundLeadOf(state) {
+	return state.isReadingAhead && state.cursors.length > 0 ? anchorOf(state.cursors) : void 0;
+}
+function nothingToRead(state) {
+	return {
+		start: [],
+		cancel: state.transfers.map((transfer) => transfer.id),
+		release: ByteRangeSet.empty,
+		anchor: void 0
+	};
+}
+function anchorOf(cursors) {
+	return {
+		time: seconds(Math.min(...cursors.map((cursor) => timeOf(cursor)))),
+		offset: Math.min(...cursors.map((cursor) => offsetOf(cursor))),
+		keyframeOffset: Math.min(...cursors.map((cursor) => keyframeOffsetOf(cursor)))
+	};
+}
+/**
+* Every sample the readers following the picture will hand out within the window, clipped to
+* the bytes the policy allows ahead, nearest first; and the next sample of every picture reader
+* and of every reader waiting within the window, whatever the budget and wherever the file
+* puts it, so no reader waits for ever.
+*/
+function wantedBytes(window) {
+	const { state, windowEnd } = window;
+	const following = state.cursors.filter((cursor) => isFollowing(cursor, window));
+	const needs = following.flatMap((cursor) => needsOf(cursor, laterOf(windowEnd, cursor.target)));
+	const next = following.filter((cursor) => isNextSampleOwed(cursor, windowEnd));
+	const nextSamples = ByteRangeSet.of(next.map((cursor) => cursor.track.rangeOf(cursor.sample)));
+	return withinBytes(ByteRangeSet.of(needs), state.policy.aheadBytes).union(nextSamples);
+}
+/**
+* A reader no further behind the picture than the policy allows: the sound lags the picture
+* by the decoders' lead, and until it follows a seek it stands far behind.
+*/
+function isFollowing(cursor, window) {
+	return timeOf(cursor) >= window.windowStart.time - window.state.policy.keepBehindSeconds;
+}
+function isNextSampleOwed(cursor, windowEnd) {
+	const isWaitingWithin = cursor.isWaiting && timeOf(cursor) <= windowEnd;
+	return !isAtItsEnd(cursor) && (isPicture(cursor) || isWaitingWithin);
+}
+function laterOf(time, other) {
+	return other !== void 0 && other > time ? other : time;
+}
+function isPicture(cursor) {
+	return cursor.track.kind === "video";
+}
+/**
+* Once playing, what playback that starved would wait for, which the download keeps held; none
+* before.
+*/
+function thresholdOf(state, windowStart) {
+	const need = {
+		cursors: state.cursors,
+		time: windowStart.time,
+		policy: state.policy
+	};
+	return state.isReadingAhead ? resumeThresholdOf(need) : ByteRangeSet.empty;
+}
+/**
+* Whether to ask for what is missing now: a reader needs it at once, the resume threshold is
+* not all held, or a refill's worth is missing. The last seconds of the tracks come as the
+* threshold reaches them, however few their bytes.
+*/
+function isTopUpDue(topUp) {
+	const { state, missing, threshold } = topUp;
+	if (missing.ranges.some((range) => threshold.overlaps(range))) return true;
+	return state.cursors.some((cursor) => isNeededAtOnce(cursor, topUp) && missing.overlaps(cursor.track.rangeOf(cursor.sample))) || missing.totalLength >= state.policy.refillBytes;
+}
+/**
+* A reader waiting on a sample playback needs now: a picture's, or one due within the resume
+* seconds. Sound that buffers far ahead waits where the downloaded bytes end, and would
+* otherwise ask for a small range every time the picture moved.
+*/
+function isNeededAtOnce(cursor, topUp) {
+	if (!cursor.isWaiting || isAtItsEnd(cursor)) return false;
+	const { windowStart, state } = topUp;
+	const horizon = windowStart.time + (state.isReadingAhead ? state.policy.resumeSeconds : 0);
+	return isPicture(cursor) || timeOf(cursor) <= horizon;
+}
+/**
+* The missing ranges in order, cut to the request size, as many as there is room for.
+*/
+function requestsFor(missing, policy, room) {
+	const requests = [];
+	for (const range of missing.ranges) for (let offset = range.offset; offset < range.end && requests.length < room; offset += policy.requestSize) requests.push(ByteRange.of(offset, Math.min(policy.requestSize, range.end - offset)));
+	return requests;
+}
+/**
+* The stretch behind the picture that is kept for short seeks back: its group of pictures from
+* the key frame, or the policy's distance, whichever reaches further back.
+*/
+function keptBehind(anchor, policy) {
+	const start = keptBehindStart(anchor, policy);
+	return ByteRangeSet.of([ByteRange.of(start, anchor.offset - start)]);
+}
+function keptBehindStart(anchor, policy) {
+	return Math.max(0, Math.min(anchor.keyframeOffset, anchor.offset - policy.keepBehindBytes));
+}
+function isAtItsEnd(cursor) {
+	return cursor.sample >= cursor.track.sampleCount;
+}
+/**
+* When a picture reader stands: at its next frame, or at its track's end once it read them all.
+*/
+function timeOf(cursor) {
+	return isAtItsEnd(cursor) ? cursor.track.end : cursor.track.timestampOf(cursor.sample);
+}
+/**
+* Where the key frame before a reader's next sample lies; a sound sample is its own.
+*/
+function keyframeOffsetOf(cursor) {
+	const { track } = cursor;
+	const last = Math.min(cursor.sample, track.sampleCount - 1);
+	const keyframe = track.syncSampleAtOrBefore(last);
+	return keyframe === void 0 ? offsetOf(cursor) : track.rangeOf(keyframe).offset;
+}
+function offsetOf(cursor) {
+	const { track } = cursor;
+	if (!isAtItsEnd(cursor)) return track.rangeOf(cursor.sample).offset;
+	return track.sampleCount > 0 ? track.rangeOf(track.sampleCount - 1).end : 0;
+}
+//#endregion
+export { planDownloads };

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 };