video-fps-probe 0.2.0 → 0.4.0-beta.1

package/dist/client/probe.js

@@ -2,10 +2,11 @@ import { ProbeError } from "../api/errors.js";
 import { WorkerPool, workerFailed } from "./pool.js";
 const notRegistered = (id, message = `engine ${id} is not registered`) => new ProbeError('engine-not-registered', message, { engine: id });
 export const nameOf = (file) => (typeof File !== 'undefined' && file instanceof File ? file.name : '');
-const loadOwnInThread = async () => (await import("../worker/runtime.js")).ownEngine;
+const loadOwnInThread = () => import("../worker/runtime.js").then((m) => m.ownEngine);
 export function createProbeCore(options) {
-    const { worker, engines: descriptors = [], engine: defaultEngine = 'own', fallback: defaultFallback = [], workers, idleTimeoutMs, timeoutMs: defaultTimeout, defaults } = options;
+    const { worker, engines: descriptors = [], engine: defaultEngine = 'own', fallback: defaultFallback = [], workers, idleTimeoutMs, timeoutMs: defaultTimeout, defaults, split } = options;
     const custom = typeof worker === 'object' ? worker : null;
+    const byContainer = custom?.byContainer;
     const inline = worker === 'inline' || typeof Worker === 'undefined';
     const pools = new Map();
     const byId = new Map();
@@ -21,27 +22,29 @@ export function createProbeCore(options) {
             stop();
         chunk.then(resolve, (e) => reject(workerFailed(String(e), 'load', engine, e))).finally(() => life.signal.removeEventListener('abort', stop));
     });
-    const poolOf = (kind, create) => ({
-        kind,
-        pool: () => {
-            let pool = pools.get(kind);
-            if (!pool)
-                pools.set(kind, (pool = new WorkerPool({ create, size: workers, idleTimeoutMs })));
-            return pool;
-        },
-    });
+    const poolFor = (key, create) => {
+        let pool = pools.get(key);
+        if (!pool)
+            pools.set(key, (pool = new WorkerPool({ create, size: workers, idleTimeoutMs })));
+        return pool;
+    };
+    const poolOf = (kind, create) => ({ kind, pool: () => poolFor(kind, create) });
     const servedBy = (d, key) => {
         const load = d?.[key];
         if (!d || !load)
             return null;
-        return !inline && d.thread === 'worker' && d.createWorker ? poolOf(d.id, d.createWorker) : { load };
+        if (inline || d.thread !== 'worker')
+            return { load };
+        if (d.createWorker)
+            return poolOf(d.id, d.createWorker);
+        return (d.createWorkers && split?.(d.id, d.createWorkers, poolFor, lazy, life.signal)) || { load };
     };
     const routeOf = (id) => {
         const listed = !custom?.engines.includes(id)
             ? null
             : inline
                 ? { error: new ProbeError('unsupported-environment', `engine ${id} runs in a worker and Worker is not available`, { engine: id }) }
-                : poolOf('custom', custom.create);
+                : (id === 'own' && byContainer && split?.('custom', byContainer, poolFor, lazy, life.signal, custom.create)) || poolOf('custom', custom.create);
         if (listed && 'pool' in listed)
             return listed;
         const route = id === 'own'
@@ -106,13 +109,14 @@ export function createProbeCore(options) {
                     continue;
                 if ('load' in route)
                     jobs.push(lazy(route.load(), id).then((m) => m.warm?.(containers)));
-                else {
-                    const pool = route.pool();
-                    warm.set(pool, [...(warm.get(pool) ?? []), id]);
-                }
+                else
+                    for (const [pool, families] of route.warmPools ? route.warmPools(containers) : [[route.pool(), containers]]) {
+                        const [engines, union] = warm.get(pool) ?? [[], []];
+                        warm.set(pool, [[...engines, id], [...new Set([...union, ...families])]]);
+                    }
             }
-            for (const [pool, engines] of warm)
-                jobs.push(pool.run({ type: 'warm', engines, containers }, { timeoutMs: defaultTimeout }));
+            for (const [pool, [engines, union]] of warm)
+                jobs.push(pool.run({ type: 'warm', engines, containers: union }, { timeoutMs: defaultTimeout }));
             await Promise.allSettled(jobs);
         },
         dispose() {
@@ -126,6 +130,3 @@ export function createProbeCore(options) {
         },
     };
 }
-export function createProbeClient(options) {
-    return createProbeCore(options);
-}

package/dist/client/route.js

@@ -0,0 +1,20 @@
+import { splitBy } from "./split.js";
+export const EBML = [0x1a, 0x45, 0xdf, 0xa3];
+export const familyOf = (file, signal) => new Promise((resolve) => {
+    const iso = () => resolve('isobmff');
+    if (signal?.aborted)
+        return iso();
+    signal?.addEventListener('abort', iso);
+    Promise.resolve()
+        .then(() => file.slice(0, 4).arrayBuffer())
+        .then((b) => {
+        const head = new Uint8Array(b);
+        return EBML.every((x, i) => head[i] === x) ? 'matroska' : 'isobmff';
+    })
+        .then(resolve, iso)
+        .finally(() => signal?.removeEventListener('abort', iso));
+});
+export const runByHead = (pool, lazy, life) => ({
+    run: (request, options) => lazy(familyOf(request.file, options.signal), request.engine).then((family) => (life.aborted ? lazy(Promise.reject(), request.engine) : pool(family).run(request, options))),
+});
+export const splitRoute = splitBy(runByHead);

package/dist/client/split.js

@@ -0,0 +1,9 @@
+const FAMILIES = ['isobmff', 'matroska'];
+export const splitBy = (runner) => (kind, byFamily, pools, lazy, life, create) => {
+    const pool = (family) => {
+        const own = byFamily[family];
+        return own ? pools(`${kind}-${family}`, own) : pools(kind, create);
+    };
+    const run = runner(pool, lazy, life);
+    return { kind, pool: () => run, warmPools: (containers) => FAMILIES.filter((f) => containers.includes(f)).map((f) => [pool(f), [f]]) };
+};

package/dist/client/stub.js

@@ -1,5 +1,5 @@
 import { ProbeError } from "../api/errors.js";
-export const knownEngines = (worker, descriptors = []) => [...new Set(['own', ...(typeof worker === 'object' ? worker.engines : []), ...descriptors.map((d) => d.id)])];
+export const knownEngines = (worker, descriptors = []) => [...new Set(['own', ...(worker?.engines ?? []), ...descriptors.map((d) => d.id)])];
 export function lazyStub(factory, known) {
     let probe = null;
     let loading = null;
@@ -11,7 +11,7 @@ export function lazyStub(factory, known) {
         return (probe = p);
     }, (e) => {
         loading = null;
-        throw e instanceof ProbeError ? e : Object.assign(new ProbeError('worker-failed', String(e), { cause: e }), { reason: 'load' });
+        throw e?.name === 'ProbeError' && typeof e.code === 'string' ? e : Object.assign(new ProbeError('worker-failed', String(e), { cause: e }), { reason: 'load' });
     }));
     const loadUnlessDestroyed = () => new Promise((resolve, reject) => {
         const stop = () => reject(aborted());

package/dist/client/types.d.ts

@@ -20,6 +20,7 @@ export interface ProbeOptions<E extends readonly EngineDescriptor[] = []> extend
 export interface CustomWorker<W extends WorkerEngineId> {
     create: () => Worker;
     engines: readonly W[];
+    byContainer?: Readonly<Partial<Record<ContainerFamily, () => Worker>>>;
 }
 export interface ClientOptions<E extends readonly EngineDescriptor[] = [], W extends WorkerEngineId = never> extends BaseOptions<NoInfer<W | IdOf<E[number]> | 'own'>> {
     worker: CustomWorker<W> | 'inline';

package/dist/core/analyze.js

@@ -1,8 +1,5 @@
-import { throwIfAborted } from "./abort.js";
-import { resolveOptions } from "./options.js";
-import { BlobReader } from "./reader.js";
-import { emptyAnalysis } from "./result.js";
-import { sniff } from "./sniff.js";
+import { analyzeWith } from "./dispatch.js";
+export { errorMessage, firstReadAhead, isAbortError, SINGLE_READ_MAX_BYTES } from "./dispatch.js";
 export const DEFAULT_LOADERS = {
     isobmff: async () => (await Promise.all([import("./isobmff/index.js"), import("./stats.js")]))[0].analyzeIsoBmff,
     matroska: async () => (await Promise.all([import("./matroska/index.js"), import("./stats.js")]))[0].analyzeMatroska,
@@ -11,77 +8,6 @@ export const DEFAULT_ANALYZERS = {
     isobmff: async (reader, opts) => (await DEFAULT_LOADERS.isobmff())(reader, opts),
     matroska: async (reader, opts) => (await DEFAULT_LOADERS.matroska())(reader, opts),
 };
-const SNIFF_BYTES = 1024;
-export const SINGLE_READ_MAX_BYTES = 1024 * 1024;
-export function firstReadAhead(size, opts) {
-    const { perReadMs, bytesPerMs } = opts.costModel;
-    const head = opts.readAhead.head;
-    return size < Math.max(head, Math.min(head + perReadMs * bytesPerMs, SINGLE_READ_MAX_BYTES)) ? size : head;
-}
-export function isAbortError(e) {
-    return typeof e === 'object' && e !== null && 'name' in e && e.name === 'AbortError';
-}
-export function errorMessage(e) {
-    if (e instanceof Error)
-        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 analyze(blob, name, opts = {}, analyzers = DEFAULT_ANALYZERS, loaders = analyzers === DEFAULT_ANALYZERS ? DEFAULT_LOADERS : null) {
-    const t0 = performance.now();
-    const resolved = resolveOptions(opts);
-    throwIfAborted(resolved.signal);
-    const result = {
-        name,
-        size: blob.size,
-        ...emptyAnalysis('unknown'),
-        io: { reads: 0, bytesRead: 0, ms: 0 },
-        engine: 'own',
-    };
-    let reader = null;
-    let loadMs = 0;
-    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';
-                let analyzer = analyzers[sniffed.kind];
-                if (loaders) {
-                    const l0 = performance.now();
-                    analyzer = await loaders[sniffed.kind]();
-                    loadMs = performance.now() - l0;
-                }
-                applyAnalysis(result, await analyzer(reader, resolved));
-            }
-        }
-    }
-    catch (e) {
-        if (resolved.signal?.aborted || isAbortError(e))
-            throw e;
-        result.error = errorMessage(e);
-    }
-    if (reader) {
-        result.io.reads = reader.reads;
-        result.io.bytesRead = reader.bytesFetched;
-    }
-    result.io.ms = performance.now() - t0 - loadMs;
-    return result;
+export function analyze(blob, name, opts = {}, analyzers = DEFAULT_ANALYZERS, loaders = analyzers === DEFAULT_ANALYZERS ? DEFAULT_LOADERS : null) {
+    return analyzeWith(blob, name, opts, loaders ? (kind) => loaders[kind]() : (kind) => analyzers[kind]);
 }

package/dist/core/dispatch.js

@@ -0,0 +1,65 @@
+import { throwIfAborted } from "./abort.js";
+import { resolveOptions } from "./options.js";
+import { BlobReader, whichErrorCode, withErrorCode } from "./reader.js";
+import { emptyAnalysis } from "./result.js";
+import { sniff } from "./sniff.js";
+const SNIFF_BYTES = 1024;
+export const SINGLE_READ_MAX_BYTES = 1024 * 1024;
+export function firstReadAhead(size, opts) {
+    const { perReadMs, bytesPerMs } = opts.costModel;
+    const head = opts.readAhead.head;
+    return size < Math.max(head, Math.min(head + perReadMs * bytesPerMs, SINGLE_READ_MAX_BYTES)) ? size : head;
+}
+export function isAbortError(e) {
+    return e?.name === 'AbortError';
+}
+export function errorMessage(e) {
+    if (e instanceof Error)
+        return e.message || e.name;
+    return String(e);
+}
+export async function analyzeWith(blob, name, opts, analyzerOf) {
+    const t0 = performance.now();
+    const resolved = resolveOptions(opts);
+    throwIfAborted(resolved.signal);
+    const result = {
+        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)
+            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;
+        result.io.bytesRead = reader.bytesFetched;
+    }
+    result.io.ms = performance.now() - t0 - loadMs;
+    return result;
+}

package/dist/core/isobmff/boxes.js

@@ -1,13 +1,11 @@
 import { fourcc } from "../reader.js";
 export class IsoBmffError extends Error {
-    constructor(message) {
+    constructor(code, message) {
         super(message);
         this.name = 'IsoBmffError';
+        this.errorCode = code;
     }
 }
-function printable(type) {
-    return type.replace(/[^\x20-\x7e]/g, '?');
-}
 export const MAX_BOX_HEADER = 32;
 export function readBoxHeader(dv, p, parentEnd, base = 0) {
     const avail = Math.min(dv.byteLength, parentEnd);
@@ -22,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 '${printable(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;
     }
@@ -32,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 '${printable(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 };
 }
@@ -56,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 '${printable(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 '${printable(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);
 }