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

package/dist/color/sps.js

@@ -0,0 +1,275 @@
+import { u16 } from "./config.js";
+const H264_HIGH_PROFILES = new Set([100, 110, 122, 244, 44, 83, 86, 118, 128, 138, 139, 134, 135, 144]);
+const PIXEL_ASPECT = [0, 1, 1, 1, 12, 11, 10, 11, 16, 11, 40, 33, 24, 11, 20, 11, 32, 11, 80, 33, 18, 11, 15, 11, 64, 33, 160, 99, 4, 3, 3, 2, 2, 1];
+const EXTENDED_SAR = 255;
+const GIVE_UP = new RangeError();
+const HEVC_SPS_NAL = 33;
+export function unescapeRbsp(nal) {
+    const out = new Uint8Array(nal.length);
+    let n = 0;
+    let zeros = 0;
+    for (const byte of nal) {
+        if (zeros >= 2 && byte === 3) {
+            zeros = 0;
+            continue;
+        }
+        out[n++] = byte;
+        zeros = byte === 0 ? zeros + 1 : 0;
+    }
+    return out.subarray(0, n);
+}
+export function bitReader(b, start = 0) {
+    let pos = start * 8;
+    const end = b.length * 8;
+    const bit = () => {
+        check(pos < end);
+        const v = (b[pos >> 3] >> (7 - (pos & 7))) & 1;
+        pos++;
+        return v;
+    };
+    const bits = (n) => {
+        let v = 0;
+        for (let i = 0; i < n; i++)
+            v = v * 2 + bit();
+        return v;
+    };
+    const skip = (n) => {
+        check(pos + n <= end);
+        pos += n;
+    };
+    const ue = (max = 0xfffffffe) => {
+        let zeros = 0;
+        while (bit() === 0)
+            check(++zeros < 32);
+        const v = 2 ** zeros - 1 + bits(zeros);
+        check(v <= max);
+        return v;
+    };
+    const se = () => {
+        const k = ue();
+        return k & 1 ? (k + 1) / 2 : k ? -k / 2 : 0;
+    };
+    return { bit, bits, skip, ue, se };
+}
+function check(ok) {
+    if (!ok)
+        throw GIVE_UP;
+}
+function readVui(r) {
+    const { bit, bits, skip } = r;
+    const vui = { sar: null, fullRange: null, colour: null };
+    if (bit()) {
+        const idc = bits(8);
+        const sar = idc === EXTENDED_SAR ? [bits(16), bits(16)] : [PIXEL_ASPECT[idc * 2] ?? 0, PIXEL_ASPECT[idc * 2 + 1] ?? 0];
+        vui.sar = sar[0] > 0 && sar[1] > 0 ? [sar[0], sar[1]] : null;
+    }
+    if (bit())
+        skip(1);
+    if (bit()) {
+        skip(3);
+        vui.fullRange = bit() === 1;
+        if (bit())
+            vui.colour = [bits(8), bits(8), bits(8)];
+    }
+    return vui;
+}
+function skipH264ScalingList(r, size) {
+    const { se } = r;
+    let last = 8;
+    let next = 8;
+    for (let j = 0; j < size; j++) {
+        if (next !== 0)
+            next = (last + se() + 256) % 256;
+        last = next === 0 ? last : next;
+    }
+}
+export function parseH264Sps(nal) {
+    try {
+        const r = bitReader(unescapeRbsp(nal), 1);
+        const { bit, bits, skip, ue, se } = r;
+        const profile = bits(8);
+        skip(16);
+        ue(31);
+        let bitDepth = 8;
+        if (H264_HIGH_PROFILES.has(profile)) {
+            const chroma = ue(3);
+            if (chroma === 3)
+                skip(1);
+            bitDepth = ue(6) + 8;
+            check(ue(6) + 8 === bitDepth);
+            skip(1);
+            if (bit())
+                for (let i = 0; i < (chroma === 3 ? 12 : 8); i++)
+                    if (bit())
+                        skipH264ScalingList(r, i < 6 ? 16 : 64);
+        }
+        ue(12);
+        const poc = ue(2);
+        if (poc === 0)
+            ue(12);
+        else if (poc === 1) {
+            skip(1);
+            se();
+            se();
+            const cycle = ue(255);
+            for (let i = 0; i < cycle; i++)
+                se();
+        }
+        ue(16);
+        skip(1);
+        ue();
+        ue();
+        if (!bit())
+            skip(1);
+        skip(1);
+        if (bit())
+            for (let i = 0; i < 4; i++)
+                ue();
+        return { bitDepth, vui: bit() ? readVui(r) : null };
+    }
+    catch (e) {
+        if (e === GIVE_UP)
+            return null;
+        throw e;
+    }
+}
+function skipProfileTierLevel(r, maxSubLayersMinus1) {
+    const { bit, skip } = r;
+    skip(88);
+    skip(8);
+    const present = [];
+    for (let i = 0; i < maxSubLayersMinus1; i++)
+        present.push([bit(), bit()]);
+    if (maxSubLayersMinus1 > 0)
+        skip(2 * (8 - maxSubLayersMinus1));
+    for (const [profile, level] of present) {
+        if (profile)
+            skip(88);
+        if (level)
+            skip(8);
+    }
+}
+function skipHevcScalingListData(r) {
+    const { bit, ue, se } = r;
+    for (let size = 0; size < 4; size++) {
+        for (let matrix = 0; matrix < 6; matrix += size === 3 ? 3 : 1) {
+            if (!bit()) {
+                const delta = ue();
+                check(matrix - delta * (size === 3 ? 3 : 1) >= 0);
+            }
+            else {
+                const coefs = Math.min(64, 1 << (4 + (size << 1)));
+                if (size > 1) {
+                    const dc = se();
+                    check(dc >= -7 && dc <= 247);
+                }
+                for (let i = 0; i < coefs; i++)
+                    se();
+            }
+        }
+    }
+}
+const HEVC_MAX_REFS = 16;
+const HEVC_MAX_DELTA_POCS = 32;
+function skipShortTermRefPicSets(r, count) {
+    const { bit, skip, ue } = r;
+    const deltaPocs = [];
+    for (let idx = 0; idx < count; idx++) {
+        if (idx > 0 && bit()) {
+            skip(1);
+            ue(32767);
+            let k = 0;
+            for (let j = 0; j <= deltaPocs[idx - 1]; j++) {
+                const used = bit();
+                if (used || bit())
+                    k++;
+            }
+            check(k < HEVC_MAX_DELTA_POCS);
+            deltaPocs.push(k);
+        }
+        else {
+            const negative = ue(HEVC_MAX_REFS - 1);
+            const positive = ue(HEVC_MAX_REFS - 1);
+            for (let i = 0; i < negative + positive; i++) {
+                ue(32767);
+                skip(1);
+            }
+            deltaPocs.push(negative + positive);
+        }
+    }
+}
+export function parseHevcSps(nal) {
+    try {
+        const r = bitReader(unescapeRbsp(nal), 2);
+        const { bit, bits, skip, ue } = r;
+        skip(4);
+        const maxSubLayersMinus1 = bits(3);
+        check(maxSubLayersMinus1 < 7);
+        skip(1);
+        skipProfileTierLevel(r, maxSubLayersMinus1);
+        ue(15);
+        const chroma = ue(3);
+        if (chroma === 3)
+            skip(1);
+        ue();
+        ue();
+        if (bit())
+            for (let i = 0; i < 4; i++)
+                ue();
+        const bitDepth = ue(8) + 8;
+        const chromaDepth = ue(8) + 8;
+        check(chroma === 0 || chromaDepth === bitDepth);
+        const pocLsbBits = ue(12) + 4;
+        const ordering = bit();
+        for (let i = ordering ? 0 : maxSubLayersMinus1; i <= maxSubLayersMinus1; i++) {
+            ue();
+            ue();
+            ue();
+        }
+        for (let i = 0; i < 6; i++)
+            ue();
+        if (bit() && bit())
+            skipHevcScalingListData(r);
+        skip(2);
+        if (bit()) {
+            skip(8);
+            ue();
+            ue();
+            skip(1);
+        }
+        skipShortTermRefPicSets(r, ue(64));
+        if (bit()) {
+            const longTerm = ue(32);
+            for (let i = 0; i < longTerm; i++)
+                skip(pocLsbBits + 1);
+        }
+        skip(2);
+        return { bitDepth, vui: bit() ? readVui(r) : null };
+    }
+    catch (e) {
+        if (e === GIVE_UP)
+            return null;
+        throw e;
+    }
+}
+export function avcConfigSps(b, s) {
+    const len = s.end - s.start >= 8 && b[s.start + 5] & 31 ? u16(b, s.start + 6) : -1;
+    return len >= 0 && s.start + 8 + len <= s.end ? parseH264Sps(b.subarray(s.start + 8, s.start + 8 + len)) : null;
+}
+export function hevcConfigSps(b, s) {
+    let q = s.start + 23;
+    for (let a = 0, arrays = s.end - s.start >= 23 ? b[s.start + 22] : 0; a < arrays && q + 3 <= s.end; a++) {
+        const type = b[q] & 63;
+        const count = u16(b, q + 1);
+        q += 3;
+        for (let i = 0; i < count && q + 2 <= s.end; i++) {
+            const len = u16(b, q);
+            if (q + 2 + len > s.end)
+                return null;
+            if (type === HEVC_SPS_NAL)
+                return parseHevcSps(b.subarray(q + 2, q + 2 + len));
+            q += 2 + len;
+        }
+    }
+    return null;
+}

package/dist/core/dispatch.js

@@ -1,6 +1,6 @@
 import { throwIfAborted } from "./abort.js";
 import { resolveOptions } from "./options.js";
-import { BlobReader } from "./reader.js";
+import { BlobReader, whichErrorCode, withErrorCode } from "./reader.js";
 import { emptyAnalysis } from "./result.js";
 import { sniff } from "./sniff.js";
 const SNIFF_BYTES = 1024;
@@ -18,17 +18,6 @@ export function errorMessage(e) {
         return e.message || e.name;
     return String(e);
 }
-function applyAnalysis(target, a) {
-    target.container = a.container;
-    target.brand = a.brand;
-    target.formatDurationSec = a.formatDurationSec;
-    target.scan = a.scan;
-    target.videoTracks = a.videoTracks;
-    target.audioTrackCount = a.audioTrackCount;
-    target.primaryTrackId = a.primaryTrackId;
-    target.error = a.error;
-    target.warnings = a.warnings;
-}
 export async function analyzeWith(blob, name, opts, analyzerOf) {
     const t0 = performance.now();
     const resolved = resolveOptions(opts);
@@ -37,35 +26,35 @@ export async function analyzeWith(blob, name, opts, analyzerOf) {
         name,
         size: blob.size,
         ...emptyAnalysis('unknown'),
+        errorCode: null,
+        layout: null,
         io: { reads: 0, bytesRead: 0, ms: 0 },
         engine: 'own',
     };
     let reader = null;
     let loadMs = 0;
+    let loading = false;
     try {
         reader = new BlobReader(blob, { headWindow: resolved.readAhead.head, signal: resolved.signal });
-        if (reader.size === 0) {
-            result.error = 'not a recognised container: empty file';
-        }
-        else {
-            const head = await reader.bytes(0, Math.min(SNIFF_BYTES, reader.size), firstReadAhead(reader.size, resolved));
-            const sniffed = sniff(head);
-            if (sniffed.kind === 'unknown') {
-                result.error = `not a recognised container: ${sniffed.reason}`;
-            }
-            else {
-                result.container = sniffed.kind === 'isobmff' ? 'mp4' : 'matroska';
-                const l0 = performance.now();
-                const analyzer = await analyzerOf(sniffed.kind);
-                loadMs = performance.now() - l0;
-                applyAnalysis(result, await analyzer(reader, resolved));
-            }
-        }
+        if (reader.size === 0)
+            throw withErrorCode('empty-file', 'not a recognised container: empty file');
+        const head = await reader.bytes(0, Math.min(SNIFF_BYTES, reader.size), firstReadAhead(reader.size, resolved));
+        const sniffed = sniff(head);
+        if (sniffed.kind === 'unknown')
+            throw withErrorCode('unrecognised', `not a recognised container: ${sniffed.reason}`);
+        result.container = sniffed.kind === 'isobmff' ? 'mp4' : 'matroska';
+        const l0 = performance.now();
+        loading = true;
+        const analyzer = await analyzerOf(sniffed.kind);
+        loading = false;
+        loadMs = performance.now() - l0;
+        Object.assign(result, await analyzer(reader, resolved));
     }
     catch (e) {
         if (resolved.signal?.aborted || isAbortError(e))
             throw e;
         result.error = errorMessage(e);
+        result.errorCode = whichErrorCode(e, loading ? 'load-failed' : 'internal');
     }
     if (reader) {
         result.io.reads = reader.reads;

package/dist/core/isobmff/boxes.js

@@ -1,8 +1,9 @@
 import { fourcc } from "../reader.js";
 export class IsoBmffError extends Error {
-    constructor(message) {
+    constructor(code, message) {
         super(message);
         this.name = 'IsoBmffError';
+        this.errorCode = code;
     }
 }
 export const MAX_BOX_HEADER = 32;
@@ -19,7 +20,7 @@ export function readBoxHeader(dv, p, parentEnd, base = 0) {
             return null;
         const big = dv.getBigUint64(p + 8);
         if (big > BigInt(Number.MAX_SAFE_INTEGER))
-            throw new IsoBmffError(`corrupt file: box '${type}' at ${base + p} has a size above 2^53-1`);
+            throw new IsoBmffError('corrupt', `corrupt file: box '${type}' at ${base + p} has a size above 2^53-1`);
         size = Number(big);
         headerSize = 16;
     }
@@ -29,7 +30,7 @@ export function readBoxHeader(dv, p, parentEnd, base = 0) {
     if (type === 'uuid')
         headerSize += 16;
     if (size < headerSize)
-        throw new IsoBmffError(`corrupt file: box '${type}' at ${base + p} is smaller than its header`);
+        throw new IsoBmffError('corrupt', `corrupt file: box '${type}' at ${base + p} is smaller than its header`);
     const end = p + size;
     return { type, start: p, size, headerSize, end: Math.min(end, parentEnd), truncated: end > parentEnd };
 }
@@ -53,13 +54,13 @@ export function* childBoxes(dv, start, end, warnings) {
 export function boxU64(dv, p, box, at) {
     const v = dv.getBigUint64(p);
     if (v > BigInt(Number.MAX_SAFE_INTEGER))
-        throw new IsoBmffError(`unsupported: box '${box}' at ${at} holds a value above 2^53-1`);
+        throw new IsoBmffError('unsupported', `unsupported: box '${box}' at ${at} holds a value above 2^53-1`);
     return Number(v);
 }
 export function boxI64(dv, p, box, at) {
     const v = dv.getBigInt64(p);
     if (v > BigInt(Number.MAX_SAFE_INTEGER) || v < -BigInt(Number.MAX_SAFE_INTEGER)) {
-        throw new IsoBmffError(`unsupported: box '${box}' at ${at} holds a value beyond 2^53-1`);
+        throw new IsoBmffError('unsupported', `unsupported: box '${box}' at ${at} holds a value beyond 2^53-1`);
     }
     return Number(v);
 }