video-fps-probe 0.3.0 → 0.4.0-beta.2

package/dist/core/isobmff/header.js

@@ -0,0 +1,677 @@
+import { MAX_EXPANDED_SAMPLES } from "../options.js";
+import { emptyAnalysis } from "../result.js";
+import { fourcc, whichErrorCode } from "../reader.js";
+import { childBoxes, IsoBmffError, readBoxHeader } from "./boxes.js";
+import { buildVideoTrack, containerOf, formatDuration, isAbort, isVideoTrack, layoutOf, MOOV_HARD_CAP, MOOV_SUSPECT_CAP, pickPrimary, readMoov, reportedIds } from "./build.js";
+import { newMovie } from "./model.js";
+import { parseMoof, parseSidx } from "./moof.js";
+import { parseTfraOffsets } from "./prefetch.js";
+import { editInfo, rescaleRound, sampleTotals, trackTiming } from "./track.js";
+const HEADER_PEEK = 16;
+const MFRA_TAIL = 64 * 1024;
+const MFRA_CAP = 16 * 1024 * 1024;
+const MOOF_HARD_CAP = 64 * 1024 * 1024;
+const RUN_TYPES = new Set(['sidx', 'styp', 'prft', 'emsg']);
+const RUN_WINDOW = 4096;
+const SIDX = 0x73696478;
+function count(w) {
+    if (++w.boxes > w.plan.maxTopLevelBoxes)
+        throw new IsoBmffError('structure-limit', `limit reached: maxTopLevelBoxes ${w.plan.maxTopLevelBoxes}`);
+}
+function visit(w) {
+    w.budget.checkTime();
+    count(w);
+}
+function ahead(w, pos, wanted) {
+    return Math.max(0, Math.min(wanted, w.budget.bytesLeft, w.reader.size - pos));
+}
+async function peekAt(w, pos, wanted) {
+    const need = Math.min(HEADER_PEEK, w.reader.size - pos);
+    return w.reader.peek(pos, need) ?? w.reader.view(pos, need, ahead(w, pos, wanted));
+}
+export function countTracks(dv, max) {
+    let moov;
+    try {
+        moov = readBoxHeader(dv, 0, dv.byteLength);
+    }
+    catch {
+        return;
+    }
+    if (!moov)
+        return;
+    let n = 0;
+    for (let p = moov.start + moov.headerSize; p + 8 <= moov.end;) {
+        let c;
+        try {
+            c = readBoxHeader(dv, p, moov.end);
+        }
+        catch {
+            return;
+        }
+        if (!c)
+            return;
+        if (c.type === 'trak' && ++n > max)
+            throw new IsoBmffError('structure-limit', `limit reached: maxTracks ${max}`);
+        p = c.start + c.size;
+    }
+}
+export function mehdDuration(dv) {
+    let moov;
+    try {
+        moov = readBoxHeader(dv, 0, dv.byteLength);
+    }
+    catch {
+        return null;
+    }
+    if (!moov)
+        return null;
+    for (const c of childBoxes(dv, moov.start + moov.headerSize, moov.end)) {
+        if (c.type !== 'mvex')
+            continue;
+        for (const m of childBoxes(dv, c.start + c.headerSize, c.end)) {
+            const p = m.start + m.headerSize;
+            if (m.type !== 'mehd' || p + 8 > m.end)
+                continue;
+            if (dv.getUint8(p) === 1) {
+                if (p + 12 > m.end)
+                    return null;
+                const d = dv.getBigUint64(p + 4);
+                return d === 0n || d > BigInt(Number.MAX_SAFE_INTEGER) ? null : Number(d);
+            }
+            const d = dv.getUint32(p + 4);
+            return d === 0 || d === 0xffffffff ? null : d;
+        }
+    }
+    return null;
+}
+async function readHeaderMoov(w, h) {
+    const size = w.reader.size;
+    const beyond = h.start + h.size > size;
+    w.movie.moov = [h.start, h.size];
+    if (!beyond && h.size > MOOV_HARD_CAP)
+        throw new IsoBmffError('too-large', 'unsupported: moov larger than 256 MiB');
+    const dv = await w.reader.view(h.start, beyond ? Math.min(size - h.start, MOOV_SUSPECT_CAP) : h.size, beyond ? 0 : ahead(w, h.start, h.size + 2 * HEADER_PEEK));
+    countTracks(dv, w.plan.maxTracks);
+    await readMoov(w.reader, h, w.movie);
+    return dv;
+}
+async function walkTop(w) {
+    const { reader, movie } = w;
+    const size = reader.size;
+    let pos = 0;
+    let moov = null;
+    let afterMdat = false;
+    let runFrom = 0;
+    let peeked = false;
+    const walked = (firstMoof, limit = null) => ({ moov, fragments: movie.hasMvex && (firstMoof !== null || limit !== null), firstMoof, run: firstMoof ? firstMoof.start - runFrom : 0, limit });
+    try {
+        while (pos + 8 <= size) {
+            const cached = moov !== null && !movie.hasMvex;
+            let hv;
+            if (cached) {
+                hv = reader.peek(pos, Math.min(HEADER_PEEK, size - pos));
+                if (!hv) {
+                    if (peeked)
+                        break;
+                    peeked = true;
+                    try {
+                        hv = await peekAt(w, pos, w.plan.head);
+                    }
+                    catch (e) {
+                        if (isAbort(e, reader))
+                            throw e;
+                        const limit = w.budget.take();
+                        if (limit)
+                            throw limit;
+                        movie.warnings.push(`fragments ignored: read at ${pos} after a moov without an mvex failed: ${e.message}`);
+                        break;
+                    }
+                }
+                if (++w.boxes > w.plan.maxTopLevelBoxes) {
+                    movie.warnings.push('too many top-level boxes');
+                    break;
+                }
+            }
+            else {
+                visit(w);
+                hv = await peekAt(w, pos, afterMdat && !moov ? w.plan.tail : w.plan.head);
+            }
+            let rel;
+            try {
+                rel = readBoxHeader(hv, 0, size - pos, pos);
+            }
+            catch (e) {
+                if (!moov)
+                    throw e;
+                movie.warnings.push(`ignored trailing data at ${pos}: ${e.message}`);
+                break;
+            }
+            if (!rel)
+                break;
+            const h = { ...rel, start: pos, end: Math.min(pos + rel.size, size) };
+            const trailer = rel.truncated && moov !== null && h.type !== 'mdat' && h.type !== 'moof';
+            if (rel.truncated) {
+                movie.truncated = true;
+                movie.warnings.push(trailer ? `ignored trailing data at ${pos}: not a box` : `'${h.type}' at ${pos} is truncated`);
+            }
+            const top = { type: h.type, start: pos, end: h.end, sidx: null };
+            movie.topLevel.push(top);
+            if (cached && h.type === 'moof')
+                movie.warnings.push(`fragments ignored: moof at ${pos} after a moov without an mvex`);
+            if (trailer || (cached && h.type === 'moof') || (moov && h.type === 'mfra'))
+                break;
+            if (moov && h.type === 'moof')
+                return walked(h);
+            if (h.type === 'ftyp' && !cached) {
+                const fv = await reader.view(pos, Math.min(h.size, 1024), ahead(w, pos, w.plan.head));
+                const p = h.headerSize;
+                if (p + 4 <= fv.byteLength) {
+                    movie.hasFtyp = true;
+                    movie.brand = fourcc(fv, p);
+                    for (let q = p + 8; q + 4 <= fv.byteLength; q += 4)
+                        movie.compatibleBrands.push(fourcc(fv, q));
+                }
+            }
+            else if (h.type === 'moov') {
+                if (moov)
+                    movie.warnings.push(`ignored a second moov at ${pos}`);
+                else
+                    moov = await readHeaderMoov(w, h);
+            }
+            else if (h.type === 'moof') {
+                throw new IsoBmffError('corrupt', 'corrupt file: movie fragment (moof) before moov');
+            }
+            else if (h.type === 'sidx' && !rel.truncated) {
+                const dv = cached ? reader.peek(pos, h.size) : await reader.view(pos, h.size, ahead(w, pos, w.plan.head));
+                const sh = dv && readBoxHeader(dv, 0, dv.byteLength);
+                if (sh)
+                    top.sidx = parseSidx(dv, sh, pos);
+            }
+            if (!RUN_TYPES.has(h.type))
+                runFrom = pos + rel.size;
+            afterMdat = h.type === 'mdat';
+            pos += rel.size;
+        }
+    }
+    catch (e) {
+        if (!moov || isAbort(e, reader))
+            throw e;
+        const limit = w.budget.take() ?? (isLimit(e) ? e : null);
+        if (!limit)
+            throw e;
+        return walked(null, limit);
+    }
+    if (!moov)
+        throw new IsoBmffError('no-header', 'incomplete file: no moov');
+    return walked(null);
+}
+async function readTailIndex(w) {
+    const { reader } = w;
+    const size = reader.size;
+    const tailLen = Math.min(size, MFRA_TAIL);
+    if (tailLen < 16)
+        return null;
+    const tail = reader.peek(size - tailLen, tailLen) ?? (await reader.view(size - tailLen, tailLen, 0));
+    if (fourcc(tail, tailLen - 12) !== 'mfro')
+        return null;
+    const mfraSize = tail.getUint32(tailLen - 4);
+    if (mfraSize < 24 || mfraSize > Math.min(size, MFRA_CAP))
+        return null;
+    const dv = mfraSize <= tailLen ? new DataView(tail.buffer, tail.byteOffset + tailLen - mfraSize, mfraSize) : await reader.view(size - mfraSize, mfraSize, 0);
+    let h;
+    try {
+        h = readBoxHeader(dv, 0, mfraSize);
+    }
+    catch {
+        return null;
+    }
+    if (!h || h.type !== 'mfra')
+        return null;
+    const offsets = new Map();
+    for (const t of childBoxes(dv, h.headerSize, h.end)) {
+        const p = t.start + t.headerSize;
+        if (t.type !== 'tfra' || p + 8 > t.end)
+            continue;
+        const id = dv.getUint32(p + 4);
+        const set = offsets.get(id) ?? new Set();
+        parseTfraOffsets(dv, t.start, t.end, set, size - mfraSize);
+        if (set.size > 0)
+            offsets.set(id, set);
+    }
+    return { mfraSize, offsets };
+}
+function parseFragment(w, dv, pos, parsed) {
+    const mh = readBoxHeader(dv, 0, dv.byteLength);
+    if (mh)
+        parseMoof(dv, mh, pos, w.movie.moofCount, w.movie, MAX_EXPANDED_SAMPLES);
+    w.movie.moofCount++;
+    parsed.add(pos);
+}
+async function walkFragments(w, from, end, parsed) {
+    let pos = from;
+    while (pos + 8 <= end) {
+        visit(w);
+        const hv = await peekAt(w, pos, w.plan.head);
+        let h;
+        try {
+            h = readBoxHeader(hv, 0, end - pos, pos);
+        }
+        catch {
+            return false;
+        }
+        if (!h || h.truncated)
+            return false;
+        if (h.type === 'mfra')
+            return true;
+        if (h.type === 'moof' && !parsed.has(pos)) {
+            if (h.size > MOOF_HARD_CAP)
+                throw new IsoBmffError('too-large', `corrupt file: moof larger than 64 MiB at ${pos}`);
+            parseFragment(w, await w.reader.view(pos, h.size, ahead(w, pos, w.plan.head)), pos, parsed);
+        }
+        else if (h.type === 'sidx') {
+            w.movie.topLevel.push({ type: 'sidx', start: pos, end: pos + h.size, sidx: parseSidx(await w.reader.view(pos, h.size, ahead(w, pos, w.plan.head)), h, pos) });
+        }
+        pos += h.size;
+    }
+    return true;
+}
+function runTo(dv, q, at) {
+    const found = [];
+    try {
+        for (let p = q; p < dv.byteLength;) {
+            const h = readBoxHeader(dv, p, dv.byteLength);
+            if (!h || h.truncated || !RUN_TYPES.has(h.type))
+                return null;
+            found.push({ type: h.type, start: at + p, end: at + h.end, sidx: h.type === 'sidx' ? parseSidx(dv, h, at + p) : null });
+            p = h.end;
+        }
+    }
+    catch {
+        return null;
+    }
+    return found;
+}
+async function preRun(w, from, run, after) {
+    const at = Math.max(after, from - Math.max(run, RUN_WINDOW));
+    if (from - at < 8)
+        return from;
+    const dv = await w.reader.view(at, from - at, ahead(w, at, w.plan.head));
+    for (let q = 0; q + 8 <= dv.byteLength; q++) {
+        const found = dv.getUint32(q + 4) === SIDX ? runTo(dv, q, at) : null;
+        if (!found)
+            continue;
+        for (const b of found) {
+            count(w);
+            w.movie.topLevel.push(b);
+        }
+        return at + q;
+    }
+    return from;
+}
+function lastSidx(movie, tr, ends) {
+    let last = null;
+    for (const b of movie.topLevel) {
+        const x = b.sidx;
+        if (x && (!last || b.start > last.start) && !x.hierarchical && x.referenceId === tr.id && x.timescale === tr.timescale && (!ends || ends.includes(x.coverageEnd)))
+            last = b;
+    }
+    return last;
+}
+function timingOf(tr, movie, fragments) {
+    const t = { ...tr, fragments };
+    const totals = sampleTotals(t);
+    return trackTiming(t, movie, totals, editInfo(t, movie.timescale, totals));
+}
+function hasFragmentData(tr, movie, index) {
+    return movie.trex.has(tr.id) || (index?.offsets.has(tr.id) ?? false) || movie.topLevel.some((b) => b.sidx?.referenceId === tr.id);
+}
+function stillFragmented(tr, movie, index, parsed, resolved) {
+    if (!resolved)
+        return false;
+    let samples = sampleTotals({ ...tr, fragments: [] }).moovSamples;
+    for (const f of tr.fragments)
+        samples += f.count;
+    if (samples > 1)
+        return false;
+    for (const o of index?.offsets.get(tr.id) ?? [])
+        if (!parsed.has(o))
+            return false;
+    for (const b of movie.topLevel)
+        if (b.sidx?.referenceId === tr.id && b.sidx.subsegments.some(([o]) => !parsed.has(o)))
+            return false;
+    const first = tr.fragments[0];
+    const interval = movie.trex.get(tr.id)?.duration || (first ? (first.durations?.[0] ?? first.defaultDuration) : 0);
+    if (!(interval > 0))
+        return false;
+    return resolved.ticks * tr.timescale <= interval * resolved.timescale;
+}
+function fragmentedPrimary(built) {
+    let best = null;
+    const rank = (b) => (b.auxiliary ? 0.5 : b.enabled ? 2 : 1);
+    const area = (b) => b.result.width * b.result.height;
+    for (const b of built) {
+        if (!best)
+            best = b;
+        else if (rank(b) !== rank(best))
+            best = rank(b) > rank(best) ? b : best;
+        else if (b.result.isStill !== best.result.isStill)
+            best = best.result.isStill ? b : best;
+        else if (area(b) !== area(best))
+            best = area(b) > area(best) ? b : best;
+        else if (b.result.trackId < best.result.trackId)
+            best = b;
+    }
+    return best ? best.result.trackId : null;
+}
+function headerTrack(t) {
+    t.presentedFrames = null;
+    delete t.provenance.presentedFrames;
+}
+function isLimit(e) {
+    const code = e?.errorCode;
+    return typeof code === 'string' && code.endsWith('-limit');
+}
+function cachedBox(reader, pos) {
+    const size = reader.size;
+    const hv = pos + 8 <= size ? reader.peek(pos, Math.min(HEADER_PEEK, size - pos)) : null;
+    try {
+        const h = hv && readBoxHeader(hv, 0, size - pos, pos);
+        return h && !h.truncated ? h : null;
+    }
+    catch {
+        return null;
+    }
+}
+function onlyFragment(reader, first) {
+    const after = first.start + first.size;
+    const data = cachedBox(reader, after);
+    if (after === reader.size)
+        return true;
+    if (data?.type !== 'mdat')
+        return false;
+    const end = after + data.size;
+    const next = cachedBox(reader, end);
+    return end === reader.size || (next?.type === 'mfra' && end + next.size === reader.size);
+}
+function lastOffset(set) {
+    let last = null;
+    for (const o of set ?? [])
+        if (last === null || o > last)
+            last = o;
+    return last;
+}
+async function resolveFragmented(w, walked, videos, built, analysis) {
+    const { reader, plan, movie } = w;
+    const size = reader.size;
+    const isMain = (t) => videos.includes(t) || t.handler === 'soun';
+    const tracks = movie.tracks.filter((t) => isMain(t) || t.hasMdhd);
+    const resolved = new Map();
+    const early = new Map();
+    const uncovered = new Set();
+    const parsed = new Set();
+    const firstCount = new Map();
+    const first = walked.firstMoof;
+    let index = null;
+    let limit = walked.limit;
+    let whole = false;
+    let low = size;
+    const open = () => tracks.filter((t) => !resolved.has(t) && (videos.includes(t) || hasFragmentData(t, movie, index)));
+    const settle = (tr, ends, fragments, into = resolved) => {
+        const x = lastSidx(movie, tr, ends)?.sidx;
+        const end = x ? x.earliestPts + x.durationSum : 0;
+        const ticks = timingOf(tr, movie, fragments).durationTs;
+        if (ends ? !x : !whole && x && x.start < low && x.coverageEnd <= low && end < ticks)
+            return;
+        into.set(tr, { ticks: Math.max(ticks, end), timescale: tr.timescale, provenance: 'header' });
+    };
+    const bySidx = (ends) => {
+        const list = open();
+        const own = list.filter((tr) => lastSidx(movie, tr, ends) !== null);
+        uncovered.clear();
+        for (const tr of list) {
+            if (own.includes(tr))
+                settle(tr, ends, tr.fragments, own.length === list.length ? resolved : early);
+            else
+                uncovered.add(tr);
+        }
+    };
+    try {
+        const cut = first ? reader.peek(first.start, first.size) === null : false;
+        if (first && !limit && (plan.index || !cut || open().some((tr) => lastSidx(movie, tr, [size]) !== null))) {
+            if (first.size > MOOF_HARD_CAP)
+                throw new IsoBmffError('too-large', `corrupt file: moof larger than 64 MiB at ${first.start}`);
+            parseFragment(w, reader.peek(first.start, first.size) ?? (await reader.view(first.start, first.size, ahead(w, first.start, plan.head))), first.start, parsed);
+            whole = onlyFragment(reader, first);
+            if (whole)
+                for (const tr of open())
+                    settle(tr, null, tr.fragments);
+            else
+                bySidx([size]);
+        }
+        for (const tr of tracks)
+            firstCount.set(tr, tr.fragments.length);
+        if (plan.index && !limit && open().length > 0) {
+            index = await readTailIndex(w);
+            if (index) {
+                const stop = size - index.mfraSize;
+                bySidx([size, stop]);
+                low = stop;
+                let reached = true;
+                for (const main of [true, false]) {
+                    let from = null;
+                    for (const tr of open()) {
+                        const last = isMain(tr) === main ? lastOffset(index.offsets.get(tr.id)) : null;
+                        if (last !== null && last < low && (from === null || last < from))
+                            from = last;
+                    }
+                    if (from === null)
+                        continue;
+                    const before = tracks.map((t) => t.fragments.length);
+                    const seen = main && first ? await preRun(w, from, walked.run, first.start + first.size) : from;
+                    reached = (await walkFragments(w, from, low, parsed)) && reached;
+                    tracks.forEach((t, i) => {
+                        const f = t.fragments;
+                        const a = firstCount.get(t) ?? 0;
+                        t.fragments = [...f.slice(0, a), ...f.slice(before[i]), ...f.slice(a, before[i])];
+                    });
+                    low = seen;
+                    whole = reached && first !== null && from <= first.start;
+                    for (const tr of open()) {
+                        const tail = tr.fragments.slice(firstCount.get(tr));
+                        if (whole || (tail.length > 0 && tail[0].baseDts !== null))
+                            settle(tr, null, tr.fragments);
+                    }
+                }
+            }
+        }
+    }
+    catch (e) {
+        if (isAbort(e, reader))
+            throw e;
+        limit = w.budget.take() ?? (isLimit(e) ? e : null);
+        if (!limit)
+            throw e;
+        for (const tr of tracks)
+            tr.fragments.length = firstCount.get(tr) ?? 0;
+    }
+    const mehd = walked.moov ? mehdDuration(walked.moov) : null;
+    const unread = open().length > 0 ? limit : null;
+    const kept = [...early.keys()].filter((tr) => !resolved.has(tr));
+    for (const tr of kept)
+        resolved.set(tr, early.get(tr));
+    for (const tr of open())
+        if (mehd !== null)
+            resolved.set(tr, { ticks: mehd, timescale: movie.timescale, provenance: 'estimated' });
+    for (const tr of tracks) {
+        if (!resolved.has(tr) && !videos.includes(tr) && !hasFragmentData(tr, movie, index))
+            resolved.set(tr, { ticks: timingOf(tr, movie, []).durationTs, timescale: tr.timescale, provenance: 'header' });
+    }
+    videos.forEach((tr, i) => {
+        const t = built[i].result;
+        const r = resolved.get(tr) ?? null;
+        const p = t.provenance;
+        t.frames = null;
+        t.avgFps = null;
+        t.avgFpsFfprobe = null;
+        t.startSec = null;
+        t.durationSec = r ? r.ticks / r.timescale : null;
+        t.isStill = stillFragmented(tr, movie, index, parsed, r);
+        delete p.frames;
+        delete p.avgFps;
+        delete p.startSec;
+        if (r)
+            p.durationSec = r.provenance;
+        else
+            delete p.durationSec;
+    });
+    const unresolved = open();
+    const failed = videos.length > 0 ? !videos.some((tr) => resolved.has(tr)) : ![...resolved.keys()].some(isMain) && unresolved.some(isMain);
+    if (unread && !failed)
+        analysis.warnings.push(`fragment index not read: ${unread.message}`);
+    const estimate = [...resolved].some(([tr, r]) => isMain(tr) && tr.hasMdhd && r.provenance === 'estimated');
+    const loose = (tr) => !estimate && !isMain(tr) && tracks.some((t) => isMain(t) && t.hasMdhd);
+    const dropped = unresolved.filter(loose);
+    const missing = unresolved.filter((tr) => !loose(tr));
+    const unstarted = [];
+    const NONE = Number.MAX_SAFE_INTEGER;
+    const av = { start: NONE, end: -NONE, dur: -NONE };
+    const text = { ...av };
+    let span = true;
+    let counted = 0;
+    for (const [tr, r] of resolved) {
+        if (!tr.hasMdhd)
+            continue;
+        const s = timingOf(tr, movie, whole ? tr.fragments : tr.fragments.slice(0, firstCount.get(tr) ?? 0)).startPts;
+        const exact = r.provenance !== 'estimated';
+        const started = s !== null || whole || !hasFragmentData(tr, movie, index);
+        if (loose(tr) && !(exact && started)) {
+            dropped.push(tr);
+            continue;
+        }
+        counted++;
+        const m = isMain(tr) ? av : text;
+        const d = rescaleRound(r.ticks, 1e6, r.timescale);
+        m.dur = Math.max(m.dur, d);
+        if (!exact)
+            span = false;
+        else if (s !== null) {
+            const at = rescaleRound(s, 1e6, tr.timescale);
+            m.start = Math.min(m.start, at);
+            m.end = Math.max(m.end, at + d);
+        }
+        else if (!started)
+            unstarted.push(tr);
+    }
+    if (av.start === NONE || (av.start > text.start && av.start - text.start < 1e6))
+        av.start = text.start;
+    if (av.end === -NONE || (av.end < text.end && text.end - av.end < 1e6))
+        av.end = text.end;
+    let dur = av.dur === -NONE || (av.dur < text.dur && text.dur - av.dur < 1e6) ? text.dur : av.dur;
+    if (span && av.start !== NONE && av.end !== -NONE && av.end >= av.start)
+        dur = Math.max(dur, av.end - av.start);
+    if (!span || counted < 2)
+        unstarted.length = 0;
+    const unsure = kept.length > 0 ? [...uncovered].filter((tr) => resolved.get(tr)?.provenance !== 'header') : [];
+    if (kept.length > 0 && unsure.length === 0)
+        unsure.push(...kept);
+    const flagged = new Set([...missing, ...unstarted, ...dropped, ...unsure]);
+    if (!failed)
+        for (const tr of tracks)
+            if (flagged.has(tr))
+                analysis.warnings.push(`format duration unresolved: track ${tr.id}`);
+    analysis.formatDurationSec = missing.length + unstarted.length + unsure.length === 0 && dur > 0 ? dur / 1e6 : null;
+    analysis.primaryTrackId = fragmentedPrimary(built);
+    if (failed) {
+        const err = limit ?? new IsoBmffError('no-duration', 'incomplete header: fragmented file without a sidx, mfra or mehd duration');
+        analysis.error = err.message;
+        analysis.errorCode = whichErrorCode(err);
+    }
+}
+function collapse(list) {
+    const seen = new Map();
+    for (const s of list)
+        seen.set(s, (seen.get(s) ?? 0) + 1);
+    if (seen.size === list.length)
+        return;
+    list.length = 0;
+    for (const [s, n] of seen)
+        list.push(n > 1 ? `${s} (${n} times)` : s);
+}
+let capture;
+let captureLoad;
+function loadCapture() {
+    captureLoad ??= import("./config.js").then((m) => (capture = m), (e) => {
+        captureLoad = undefined;
+        throw e;
+    });
+    return captureLoad;
+}
+export async function analyzeIsoBmffHeader(reader, budget, plan) {
+    const movie = newMovie(reader.size);
+    const w = { reader, budget, plan, movie, boxes: 0 };
+    const analysis = emptyAnalysis('mp4');
+    analysis.scan = 'header';
+    analysis.warnings = movie.warnings;
+    analysis.errorCode = null;
+    try {
+        const walked = await walkTop(w);
+        analysis.container = containerOf(movie);
+        analysis.brand = movie.brand;
+        const reject = movie.ffprobeReject;
+        const ffprobeFails = reject !== null && reject.moof < movie.ffprobeMoofLimit;
+        if (ffprobeFails)
+            movie.warnings.push(`ffprobe 8.1.1 ${reject.reason}`);
+        const ids = reportedIds(movie.tracks);
+        if ([...ids].some(([t, id]) => t.id !== id))
+            movie.warnings.push('duplicate track_ID values');
+        const videos = movie.tracks.filter((t) => isVideoTrack(t, movie));
+        const built = videos.map((t) => buildVideoTrack(t, movie, { maxExpandedSamples: 0 }, { reportedId: ids.get(t) ?? t.id, ffprobeFails }));
+        for (const b of built)
+            headerTrack(b.result);
+        let loadError = null;
+        if (plan.codecConfig) {
+            try {
+                const { isoCodecConfig } = capture ?? (await budget.race(loadCapture()));
+                videos.forEach((t, i) => (built[i].result.codecConfig = isoCodecConfig(movie, t)));
+            }
+            catch (e) {
+                if (isAbort(e, reader))
+                    throw e;
+                loadError = e;
+            }
+        }
+        analysis.videoTracks = built.map((b) => b.result);
+        analysis.audioTrackCount = movie.tracks.filter((t) => t.handler === 'soun').length;
+        if (walked.fragments)
+            await resolveFragmented(w, walked, videos, built, analysis);
+        else {
+            analysis.primaryTrackId = pickPrimary(built);
+            analysis.formatDurationSec = formatDuration(movie, new Set(videos));
+            if (walked.limit) {
+                analysis.error = walked.limit.message;
+                analysis.errorCode = whichErrorCode(walked.limit);
+            }
+        }
+        if (loadError !== null)
+            analysis.warnings.push(`codec configuration unavailable: ${loadError instanceof Error ? loadError.message : String(loadError)}`);
+    }
+    catch (e) {
+        if (isAbort(e, reader))
+            throw e;
+        const limit = budget.take();
+        const message = limit ? limit.message : e instanceof Error ? e.message : String(e);
+        analysis.container = containerOf(movie);
+        analysis.brand = movie.brand;
+        analysis.error = limit || e?.errorCode ? message : `corrupt file: ${message}`;
+        analysis.errorCode = whichErrorCode(limit ?? e);
+        analysis.videoTracks = [];
+        analysis.audioTrackCount = 0;
+        analysis.primaryTrackId = null;
+        analysis.formatDurationSec = null;
+    }
+    analysis.layout = layoutOf(movie);
+    collapse(analysis.warnings);
+    for (const t of analysis.videoTracks)
+        collapse(t.warnings);
+    return analysis;
+}