9b5854aa4c
Each family whose corpus lacked them gets the three signatures a verifier that checks only the equation accepts and WAI's rule refuses (wai_sig::forgeries): the identity as the key with (R, S) = (B, 1), the identity spelled y = p + 1, and R of small order under the base point. Every case is new; no existing vector's expectation changes. - jwp: group_signer_key_identity_forged, group_signer_key_identity_y_not_reduced (step 1, bad_signer_key), group_signature_r_small_order (step 2). - signer: anchor_root_identity_forged, anchor_root_identity_y_not_reduced, anchor_root_signature_r_small_order (not anchored, key_log_signature_invalid). - pack: mutations receipt-key-identity, receipt-key-identity-y-not-reduced, receipt-r-small-order (receipt-signature); receipts/ v1-key-identity, v1-key-identity-y-not-reduced, v1-r-small-order, marked "signature": "refused", which wai-pack and pack_verify.py now read. - quantum-ops: cal_q3_ and job_bell_ key_identity, key_identity_y_not_reduced and r_small_order, "verifies": false, which wai_quantum_ops_vectors checks are refused and hash as pinned. claim (signer_key_identity, signer_key_identity_y_not_reduced, signature_r_small_order and others) and http (sig-key-identity, -long, sig-r-small-order) had them already. OER/2 keeps its own rule. PackageReceipt::signing_payload (v1) and the calibration and job receipts' signing_payload are public, so a corpus generator can sign over them; wai-quantum re-exports wai_sig beside ed25519_dalek. Co-Authored-By: Claude Opus 5.5 <[email protected]>
3104 lines
136 KiB
Python
3104 lines
136 KiB
Python
#!/usr/bin/env python3
|
||
"""Independent verifier of the packaging corpus (extensions/packaging.md).
|
||
|
||
Written from the extension text. It shares no code with wai-pack, which generates the
|
||
corpus. It takes BLAKE3 from ../claim-conformance/_blake3.py and the WIV1 parser and
|
||
keyframe-0 decoder from ../int-payload-conformance/int_payload_verify.py, both written
|
||
from their specifications, reads the capability registry from its published export
|
||
(../registry/capabilities.json), reads TOML with the standard library's tomllib (TOML
|
||
1.0), checks Ed25519 signatures with ../claim-conformance/_ed25519.py, WAI's strict rule
|
||
(SPEC §7 *Signatures*) written from RFC 8032, signs its own re-derivations with the
|
||
`cryptography` package, imported only where it signs, and implements the rest:
|
||
|
||
- the policy (§3): the value-kind walk, the schema with every default, the constraints
|
||
and their refusal names, the effective policy as JSON, RFC 8785 canonical JSON and the
|
||
digest; every case of policy/ is recomputed, every equal pair compared, and every
|
||
policy of refusals/policy/ refused with its reason, the capability rules of §3.6
|
||
included;
|
||
- the sources (§4.7): a Y4M reader with BT.709 limited-range conversion to RGB8, and a
|
||
WAV reader; every source of refusals/source/ refused with its reason, and every frame
|
||
of conversions/ converted to the SHA-256 the corpus states;
|
||
- the unit conversions (§4.4, §4.5);
|
||
- the fixtures, regenerated from their definition and checked against their pinned
|
||
SHA-256, and wai.pack.scenecut/1 (§4.3) with its lookahead clauses, written in the
|
||
on-demand form (every frame known), against the streaming segmenter's vectors; and the
|
||
classification (§4.6) of every piece;
|
||
- the encode vectors: which frames each one codes (every piece of every fixture, cut by
|
||
the segmenter above), each payload's BLAKE3, its header's parameters, every decoded
|
||
frame's SHA-256, and the SSE of the decode against the regenerated source; and the
|
||
encoder's choices (§5.5) recomputed from the decode: every motion vector by the
|
||
search, its order and its tie-break, on the source and the previous decoded frame;
|
||
every coded residual (the stream's symbols) equal to quantize(source − prediction);
|
||
and the residual table and its offset equal to the fit of those residuals;
|
||
- the choice of step (§5.6): every candidate's SSE from an encoder of its own (search,
|
||
quantization, reconstruction, closed loop), and the step the rule chooses;
|
||
- the stage index (§6.2–§6.4): the WSIX reader and its refusals, the rules in their
|
||
order, each tier from the registry's replicate class, the index digest and the stage
|
||
root (a jwp-receipts §2.2 Merkle root); and the object rules of §6.3 over WAI1 and WAI2
|
||
envelopes. Every case of mutations/ (an index; an index and its objects; a receipt and
|
||
its indexes) gets its reason, and every file of mutations/ is used by a case;
|
||
- the package receipt (§9.1): its JSON reader, its signing payload with the energy class
|
||
of energy-measurement §2.7–§2.8, its receipt hash, and its verification against its
|
||
indexes; and version 1 (§9.3), every receipt of receipts/: its payload, receipt hash,
|
||
segment map root, counts and signature;
|
||
- the package (packs/, §11.3, in its order, without the source): the LISTING, the
|
||
receipt, policy.json and policy.toml, the indexes, every object, each prefix digest by
|
||
decoding its WIV1 base, the plan file, the floor objects, the CMAF files rebuilt byte
|
||
for byte from their temporal units (an AV1 OBU reader and sequence header parser, §7.6's
|
||
boxes), every catalog rendered byte for byte (§8.3–§8.8), §9.4's claim rule, and no
|
||
unlisted or unexpected file; then what only the source decides: the fixture
|
||
regenerated and cut, each piece's start, duration, flags and kind, its rules, moments
|
||
and class plan (§8.1), each base's sse (§6.6) and step (§5.6) and its decode equal to the
|
||
encoder's reconstruction, and the supplied floor (§7.3): its listing, a temporal unit
|
||
per frame, shown key frames exactly at the piece starts, and each floor object holding
|
||
its piece's units of the stream;
|
||
- the package mutations (package-mutations/): each case the golden altered (re-sealed
|
||
with its key where the receipt or LISTING alone would catch it), written out and
|
||
verified as above without its inputs, and refused with the reason the corpus gives it
|
||
(the first check that fails), or accepted where the corpus says `ok`.
|
||
|
||
python3 pack_verify.py <pack-conformance dir>
|
||
|
||
Exit status 0 only if every vector verifies. Python 3.11 or later (tomllib).
|
||
"""
|
||
import hashlib
|
||
import json
|
||
import os
|
||
import re
|
||
import shutil
|
||
import sys
|
||
import tempfile
|
||
import tomllib
|
||
|
||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||
sys.path.insert(0, os.path.join(HERE, "..", "claim-conformance"))
|
||
sys.path.insert(0, os.path.join(HERE, "..", "int-payload-conformance"))
|
||
from _blake3 import blake3 # noqa: E402
|
||
import _ed25519 as ED # noqa: E402
|
||
import int_payload_verify as IPV # noqa: E402
|
||
|
||
MAX_INTEGER = (1 << 53) - 1
|
||
U32 = (1 << 32) - 1
|
||
# The frames of each piece an encode vector codes: the first ENCODE_FRAMES.
|
||
ENCODE_FRAMES = 12
|
||
|
||
# ---------------------------------------------------------------- canonical JSON (RFC 8785)
|
||
|
||
|
||
def jcs(v):
|
||
if v is None:
|
||
return "null"
|
||
if v is True:
|
||
return "true"
|
||
if v is False:
|
||
return "false"
|
||
if isinstance(v, int):
|
||
if not 0 <= v <= MAX_INTEGER:
|
||
raise ValueError("an integer outside the canonical subset")
|
||
return str(v)
|
||
if isinstance(v, str):
|
||
return json.dumps(v, ensure_ascii=False)
|
||
if isinstance(v, list):
|
||
return "[" + ",".join(jcs(x) for x in v) + "]"
|
||
if isinstance(v, dict):
|
||
keys = sorted(v, key=lambda k: k.encode("utf-16-be"))
|
||
return "{" + ",".join(json.dumps(k, ensure_ascii=False) + ":" + jcs(v[k]) for k in keys) + "}"
|
||
raise ValueError("a value outside the canonical subset")
|
||
|
||
|
||
# ---------------------------------------------------------------- policy (§3)
|
||
|
||
|
||
class Refused(Exception):
|
||
def __init__(self, code, at=""):
|
||
super().__init__(code)
|
||
self.code = code
|
||
self.at = at
|
||
|
||
|
||
def is_int(v):
|
||
return isinstance(v, int) and not isinstance(v, bool)
|
||
|
||
|
||
def kinds(v, at):
|
||
"""Stage 1: the value kinds canonical JSON cannot carry, members in key order."""
|
||
import datetime
|
||
|
||
if isinstance(v, float):
|
||
raise Refused("policy-float", at)
|
||
if isinstance(v, (datetime.datetime, datetime.date, datetime.time)):
|
||
raise Refused("policy-datetime", at)
|
||
if is_int(v) and v < 0:
|
||
raise Refused("policy-negative", at)
|
||
if is_int(v) and v > MAX_INTEGER:
|
||
raise Refused("policy-integer-range", at)
|
||
if isinstance(v, list):
|
||
for i, x in enumerate(v):
|
||
kinds(x, f"{at}[{i}]")
|
||
if isinstance(v, dict):
|
||
for k in sorted(v):
|
||
kinds(v[k], f"{at}.{k}" if at else k)
|
||
|
||
|
||
class Tab:
|
||
def __init__(self, t, at):
|
||
self.t, self.at = t, at
|
||
|
||
def err(self, code, k):
|
||
return Refused(code, f"{self.at}.{k}" if self.at else k)
|
||
|
||
def keys(self, allowed):
|
||
for k in sorted(self.t):
|
||
if k not in allowed:
|
||
raise self.err("policy-unknown-key", k)
|
||
|
||
def string(self, k):
|
||
if k not in self.t:
|
||
return None
|
||
if not isinstance(self.t[k], str):
|
||
raise self.err("policy-type", k)
|
||
return self.t[k]
|
||
|
||
def string_req(self, k):
|
||
s = self.string(k)
|
||
if s is None:
|
||
raise self.err("policy-missing-key", k)
|
||
return s
|
||
|
||
def ident(self, k):
|
||
s = self.string_req(k)
|
||
if not s or len(s.encode()) > 255:
|
||
raise self.err("policy-value", k)
|
||
return s
|
||
|
||
def uint(self, k):
|
||
if k not in self.t:
|
||
return None
|
||
if not is_int(self.t[k]):
|
||
raise self.err("policy-type", k)
|
||
return self.t[k]
|
||
|
||
def uint_in(self, k, lo, hi, default):
|
||
v = self.uint(k)
|
||
if v is None:
|
||
if default is None:
|
||
raise self.err("policy-missing-key", k)
|
||
return default
|
||
if v < lo or v > hi:
|
||
raise self.err("policy-value", k)
|
||
return v
|
||
|
||
def uint_opt_in(self, k, lo, hi):
|
||
v = self.uint(k)
|
||
if v is not None and (v < lo or v > hi):
|
||
raise self.err("policy-value", k)
|
||
return v
|
||
|
||
def boolean(self, k, default):
|
||
if k not in self.t:
|
||
return default
|
||
if not isinstance(self.t[k], bool):
|
||
raise self.err("policy-type", k)
|
||
return self.t[k]
|
||
|
||
def table(self, k):
|
||
if k not in self.t:
|
||
return Tab({}, f"{self.at}.{k}" if self.at else k)
|
||
if not isinstance(self.t[k], dict):
|
||
raise self.err("policy-type", k)
|
||
return Tab(self.t[k], f"{self.at}.{k}" if self.at else k)
|
||
|
||
def table_req(self, k):
|
||
if k not in self.t:
|
||
raise self.err("policy-missing-key", k)
|
||
return self.table(k)
|
||
|
||
def tables(self, k):
|
||
if k not in self.t:
|
||
return []
|
||
v = self.t[k]
|
||
if not isinstance(v, list) or not all(isinstance(x, dict) for x in v):
|
||
raise self.err("policy-type", k)
|
||
return [Tab(x, f"{k}[{i}]") for i, x in enumerate(v)]
|
||
|
||
def strings(self, k):
|
||
if k not in self.t:
|
||
return None
|
||
v = self.t[k]
|
||
if not isinstance(v, list) or not all(isinstance(x, str) for x in v):
|
||
raise self.err("policy-type", k)
|
||
return list(v)
|
||
|
||
def uints(self, k):
|
||
if k not in self.t:
|
||
return None
|
||
v = self.t[k]
|
||
if not isinstance(v, list) or not all(is_int(x) for x in v):
|
||
raise self.err("policy-type", k)
|
||
return list(v)
|
||
|
||
|
||
# §3.3: the parameters each capability's rung takes; another capability takes none.
|
||
PARAMS = {
|
||
"wai.video.int_motion": [
|
||
("block", ("one_of", [4, 8, 16, 32], 16)),
|
||
("search", ("int", 0, 32, 7)),
|
||
("mv_precision", ("one_of", [1, 2], 2)),
|
||
("q_candidates", ("ints", 1, 255, [8])),
|
||
("max_sse_px_milli", ("int", 0, MAX_INTEGER, 0)),
|
||
],
|
||
"wai.video.int_refine": [("q", ("int", 1, 255, None))],
|
||
"wai.video.av1": [("source", ("word", ["supplied", "encode"], "supplied"))],
|
||
"wai.video.av1.lossless": [("source", ("word", ["supplied", "encode"], "supplied"))],
|
||
"wai.audio.int_refine": [("to_rate", ("int", 1, 384000, None)), ("q", ("int", 1, 65535, None))],
|
||
"wai.audio.flac": [("source", ("word", ["encode", "supplied"], "encode"))],
|
||
}
|
||
|
||
MEDIA = ["video", "image", "audio", "world", "feed", "avatar", "film"]
|
||
KINDS = ["natural", "static", "synthetic", "motion_high"]
|
||
|
||
|
||
def read_params(rung, cap):
|
||
p = rung.table("params")
|
||
schema = PARAMS.get(cap, [])
|
||
p.keys([k for k, _ in schema])
|
||
out = {}
|
||
for k, kind in schema:
|
||
if kind[0] == "int":
|
||
out[k] = p.uint_in(k, kind[1], kind[2], kind[3])
|
||
elif kind[0] == "one_of":
|
||
v = p.uint_in(k, 0, MAX_INTEGER, kind[2])
|
||
if v not in kind[1]:
|
||
raise p.err("policy-value", k)
|
||
out[k] = v
|
||
elif kind[0] == "ints":
|
||
v = p.uints(k)
|
||
v = list(kind[3]) if v is None else v
|
||
if not v or any(x < kind[1] or x > kind[2] for x in v):
|
||
raise p.err("policy-value", k)
|
||
out[k] = v
|
||
else:
|
||
v = p.string(k)
|
||
v = kind[2] if v is None else v
|
||
if v not in kind[1]:
|
||
raise p.err("policy-value", k)
|
||
out[k] = v
|
||
return out
|
||
|
||
|
||
def is_hex64(s):
|
||
return len(s) == 64 and all(c in "0123456789abcdef" for c in s)
|
||
|
||
|
||
def read_policy(doc):
|
||
"""Stage 2. Returns the policy as a dict of its JSON members (layer_lag_ms unchecked)."""
|
||
top = Tab(doc, "")
|
||
top.keys(["schema", "asset_id", "royalty_free_only", "lead", "component", "segmentation", "ladder", "floor",
|
||
"live", "class", "moment", "rule", "defaults", "classify"])
|
||
if top.string_req("schema") != "wai.pack.policy/1":
|
||
raise top.err("policy-schema", "schema")
|
||
P = {"schema": "wai.pack.policy/1", "asset_id": top.ident("asset_id"),
|
||
"royalty_free_only": top.boolean("royalty_free_only", False), "lead": top.ident("lead")}
|
||
if "component" not in doc:
|
||
raise top.err("policy-missing-key", "component")
|
||
comps = []
|
||
for c in top.tables("component"):
|
||
c.keys(["id", "media", "source", "timebase"])
|
||
m = {"id": c.ident("id")}
|
||
media = c.string_req("media")
|
||
if media not in MEDIA:
|
||
raise c.err("policy-value", "media")
|
||
m["media"] = media
|
||
s = c.string("source")
|
||
if s is not None:
|
||
m["source"] = s
|
||
tb = c.table_req("timebase")
|
||
tb.keys(["num", "den"])
|
||
m["timebase"] = {"num": tb.uint_in("num", 1, U32, None), "den": tb.uint_in("den", 1, U32, None)}
|
||
comps.append(m)
|
||
P["component"] = comps
|
||
s = top.table("segmentation")
|
||
s.keys(["target_ms", "min_ms", "max_ms", "scene_cut", "cut_abs_permille", "cut_rel_permille", "cut_window",
|
||
"lookahead_frames", "closed"])
|
||
seg = {"target_ms": s.uint_in("target_ms", 0, MAX_INTEGER, 2000),
|
||
"min_ms": s.uint_in("min_ms", 0, MAX_INTEGER, 1000),
|
||
"max_ms": s.uint_in("max_ms", 0, MAX_INTEGER, 4000)}
|
||
sc = s.string("scene_cut")
|
||
sc = "wai.pack.scenecut/1" if sc is None else sc
|
||
if sc != "wai.pack.scenecut/1":
|
||
raise s.err("policy-value", "scene_cut")
|
||
seg["scene_cut"] = sc
|
||
seg["cut_abs_permille"] = s.uint_in("cut_abs_permille", 1, 1000, 300)
|
||
seg["cut_rel_permille"] = s.uint_in("cut_rel_permille", 0, 1000000, 3000)
|
||
seg["cut_window"] = s.uint_in("cut_window", 3, 64, 8)
|
||
seg["lookahead_frames"] = s.uint_in("lookahead_frames", 0, 64, 6)
|
||
seg["closed"] = s.boolean("closed", True)
|
||
P["segmentation"] = seg
|
||
ladder = []
|
||
for r in top.tables("ladder"):
|
||
r.keys(["id", "component", "capability", "role", "refines", "params"])
|
||
m = {"id": r.ident("id"), "component": r.ident("component"), "capability": r.string_req("capability")}
|
||
role = r.string_req("role")
|
||
if role not in ("base", "refinement", "floor"):
|
||
raise r.err("policy-value", "role")
|
||
m["role"] = role
|
||
t = r.string("refines")
|
||
if t is not None:
|
||
m["refines"] = t
|
||
m["params"] = read_params(r, m["capability"])
|
||
ladder.append(m)
|
||
P["ladder"] = ladder
|
||
f = top.table("floor")
|
||
f.keys(["supplied_listing", "extra_keyframes"])
|
||
fl = {}
|
||
sl = f.string("supplied_listing")
|
||
if sl is not None:
|
||
if not is_hex64(sl):
|
||
raise f.err("policy-value", "supplied_listing")
|
||
fl["supplied_listing"] = sl
|
||
fl["extra_keyframes"] = f.boolean("extra_keyframes", False)
|
||
P["floor"] = fl
|
||
lv = top.table("live")
|
||
lv.keys(["layer_lag_ms"])
|
||
lag = lv.uints("layer_lag_ms")
|
||
classes = []
|
||
for c in top.tables("class"):
|
||
c.keys(["id", "max_layer", "max_kbps", "floor_only"])
|
||
m = {"id": c.ident("id"), "max_layer": c.uint_in("max_layer", 0, 255, 0)}
|
||
k = c.uint_opt_in("max_kbps", 1, U32)
|
||
if k is not None:
|
||
m["max_kbps"] = k
|
||
m["floor_only"] = c.boolean("floor_only", False)
|
||
classes.append(m)
|
||
P["class"] = classes
|
||
moments = []
|
||
for m in top.tables("moment"):
|
||
m.keys(["id", "from_ms", "to_ms", "tags"])
|
||
x = {"id": m.ident("id"), "from_ms": m.uint_in("from_ms", 0, MAX_INTEGER, None),
|
||
"to_ms": m.uint_in("to_ms", 0, MAX_INTEGER, None)}
|
||
if x["to_ms"] <= x["from_ms"]:
|
||
raise m.err("policy-value", "to_ms")
|
||
x["tags"] = m.strings("tags") or []
|
||
moments.append(x)
|
||
P["moment"] = moments
|
||
rules = []
|
||
for r in top.tables("rule"):
|
||
r.keys(["id", "when", "then"])
|
||
x = {"id": r.ident("id")}
|
||
w = r.table("when")
|
||
w.keys(["piece_kind", "moment_tag"])
|
||
when = {}
|
||
pk = w.strings("piece_kind")
|
||
if pk is not None:
|
||
if any(k not in KINDS for k in pk):
|
||
raise w.err("policy-value", "piece_kind")
|
||
when["piece_kind"] = pk
|
||
mt = w.strings("moment_tag")
|
||
if mt is not None:
|
||
when["moment_tag"] = mt
|
||
t = r.table("then")
|
||
t.keys(["ladder", "max_layer", "deadline_ms"])
|
||
then = {}
|
||
ld = t.strings("ladder")
|
||
if ld is not None:
|
||
then["ladder"] = ld
|
||
ml = t.uint_opt_in("max_layer", 0, 255)
|
||
if ml is not None:
|
||
then["max_layer"] = ml
|
||
dl = t.uint_opt_in("deadline_ms", 1, U32)
|
||
if dl is not None:
|
||
then["deadline_ms"] = dl
|
||
x["when"], x["then"] = when, then
|
||
rules.append(x)
|
||
P["rule"] = rules
|
||
d = top.table("defaults")
|
||
d.keys(["deadline_ms"])
|
||
P["defaults"] = {"deadline_ms": d.uint_in("deadline_ms", 1, U32, 1500)}
|
||
c = top.table("classify")
|
||
c.keys(["static_permille", "static_mad_milli", "synthetic_bins", "motion_high_milli"])
|
||
P["classify"] = {"static_permille": c.uint_in("static_permille", 0, 1000, 5),
|
||
"static_mad_milli": c.uint_in("static_mad_milli", 0, MAX_INTEGER, 300),
|
||
"synthetic_bins": c.uint_in("synthetic_bins", 0, 64, 12),
|
||
"motion_high_milli": c.uint_in("motion_high_milli", 0, MAX_INTEGER, 9000)}
|
||
return P, lag
|
||
|
||
|
||
def first_dup(ids):
|
||
seen = set()
|
||
for i in ids:
|
||
if i in seen:
|
||
return i
|
||
seen.add(i)
|
||
return None
|
||
|
||
|
||
def layers(P):
|
||
by = {r["id"]: r for r in P["ladder"]}
|
||
out = {}
|
||
for r in P["ladder"]:
|
||
k, cur = 0, r
|
||
while "refines" in cur and cur["refines"] in by:
|
||
k, cur = k + 1, by[cur["refines"]]
|
||
out[r["id"]] = k
|
||
return out
|
||
|
||
|
||
def constrain(P, lag):
|
||
"""Stage 3, in the order of the extension's list."""
|
||
def no(code):
|
||
raise Refused(code)
|
||
if not P["component"] or len(P["component"]) > 8:
|
||
no("policy-too-many-components")
|
||
if len(P["ladder"]) > 64:
|
||
no("policy-too-many-rungs")
|
||
if len(P["class"]) > 32:
|
||
no("policy-too-many-classes")
|
||
if len(P["rule"]) > 32:
|
||
no("policy-too-many-rules")
|
||
if len(P["moment"]) > 32:
|
||
no("policy-too-many-moments")
|
||
# One namespace for every id, so no reference names two things.
|
||
if first_dup(x["id"] for k in ("component", "ladder", "class", "moment", "rule") for x in P[k]) is not None:
|
||
no("policy-duplicate-id")
|
||
if P["lead"] not in [c["id"] for c in P["component"]]:
|
||
no("policy-lead")
|
||
s = P["segmentation"]
|
||
if not s["closed"]:
|
||
no("policy-open-gop")
|
||
if not (1 <= s["min_ms"] <= s["target_ms"] <= s["max_ms"]):
|
||
no("policy-piece-bounds")
|
||
comps = {c["id"] for c in P["component"]}
|
||
if any(r["component"] not in comps for r in P["ladder"]):
|
||
no("policy-ladder-component")
|
||
if any((r["role"] == "refinement") != ("refines" in r) for r in P["ladder"]):
|
||
no("policy-refines-role")
|
||
by = {r["id"]: r for r in P["ladder"]}
|
||
if any("refines" in r and r["refines"] not in by for r in P["ladder"]):
|
||
no("policy-dangling-refines")
|
||
for r in P["ladder"]:
|
||
seen, cur = {r["id"]}, r
|
||
while "refines" in cur:
|
||
if cur["refines"] in seen:
|
||
no("policy-refines-cycle")
|
||
seen.add(cur["refines"])
|
||
cur = by[cur["refines"]]
|
||
for r in P["ladder"]:
|
||
if r["role"] != "refinement":
|
||
continue
|
||
cur = r
|
||
while "refines" in cur:
|
||
cur = by[cur["refines"]]
|
||
if cur["component"] != r["component"]:
|
||
no("policy-refines-base")
|
||
if cur["role"] != "base":
|
||
no("policy-refines-base")
|
||
if first_dup(r["refines"] for r in P["ladder"] if "refines" in r) is not None:
|
||
no("policy-refines-branch")
|
||
for c in P["component"]:
|
||
if not any(r["component"] == c["id"] and r["role"] == "base" for r in P["ladder"]):
|
||
no("policy-no-base")
|
||
n = max(layers(P).values(), default=0) + 1
|
||
if any(c["max_layer"] > n - 1 for c in P["class"]):
|
||
no("policy-class-layer")
|
||
if any(r["then"].get("max_layer", 0) > n - 1 for r in P["rule"]):
|
||
no("policy-class-layer")
|
||
for r in P["rule"]:
|
||
if "ladder" in r["then"]:
|
||
rs = [by.get(i) for i in r["then"]["ladder"]]
|
||
ok = rs and all(rs) and all(x["component"] == rs[0]["component"] for x in rs) \
|
||
and any(x["role"] == "base" for x in rs)
|
||
if not ok:
|
||
no("policy-rule-ladder")
|
||
lag = [0] * n if lag is None else lag
|
||
if len(lag) != n or lag[0] != 0 or any(b < a for a, b in zip(lag, lag[1:])):
|
||
no("policy-layer-lag")
|
||
P["live"] = {"layer_lag_ms": lag}
|
||
deadlines = {r["then"]["deadline_ms"] for r in P["rule"] if "deadline_ms" in r["then"]}
|
||
deadlines.add(P["defaults"]["deadline_ms"])
|
||
if len(deadlines) > 4:
|
||
no("policy-too-many-deadlines")
|
||
for d in deadlines:
|
||
if any(d < x + 1 for x in lag[1:]):
|
||
no("policy-deadline-unreachable")
|
||
return P
|
||
|
||
|
||
MAX_DEPTH = 32
|
||
I64 = (-(1 << 63), (1 << 63) - 1)
|
||
|
||
|
||
def shallow(v, depth):
|
||
"""Every container in v, itself at depth `depth`, at most MAX_DEPTH deep (§3.2). The
|
||
recursion stops at the first container past it."""
|
||
if isinstance(v, list):
|
||
return depth <= MAX_DEPTH and all(shallow(x, depth + 1) for x in v)
|
||
if isinstance(v, dict):
|
||
return depth <= MAX_DEPTH and all(shallow(x, depth + 1) for x in v.values())
|
||
return True
|
||
|
||
|
||
def in_i64(v):
|
||
"""TOML's integers are 64-bit (TOML 1.0); tomllib reads any size."""
|
||
if is_int(v):
|
||
return I64[0] <= v <= I64[1]
|
||
if isinstance(v, list):
|
||
return all(in_i64(x) for x in v)
|
||
if isinstance(v, dict):
|
||
return all(in_i64(x) for x in v.values())
|
||
return True
|
||
|
||
|
||
def parse_policy(text):
|
||
"""§3.2: not TOML 1.0, a byte-order mark, an integer outside 64 bits, or nesting past
|
||
MAX_DEPTH are `policy-toml`, before any value kind; then the three stages."""
|
||
if text.startswith("\ufeff"):
|
||
raise Refused("policy-toml")
|
||
try:
|
||
doc = tomllib.loads(text)
|
||
except (tomllib.TOMLDecodeError, RecursionError):
|
||
raise Refused("policy-toml")
|
||
if not all(shallow(v, 2) for v in doc.values()) or not in_i64(doc):
|
||
raise Refused("policy-toml")
|
||
for k in sorted(doc):
|
||
kinds(doc[k], k)
|
||
P, lag = read_policy(doc)
|
||
return constrain(P, lag)
|
||
|
||
|
||
def parse_policy_bytes(b):
|
||
"""A policy's bytes: UTF-8 with no byte-order mark (§3.2)."""
|
||
if b.startswith(b"\xef\xbb\xbf"):
|
||
raise Refused("policy-toml")
|
||
try:
|
||
text = b.decode("utf-8")
|
||
except UnicodeDecodeError:
|
||
raise Refused("policy-toml")
|
||
return parse_policy(text)
|
||
|
||
|
||
def digest(P):
|
||
return blake3(b"wai:pack-policy\x01" + jcs(P).encode()).hex()
|
||
|
||
|
||
# ---------------------------------------------------------------- what a packager may emit (§3.6)
|
||
|
||
with open(os.path.join(HERE, "..", "registry", "capabilities.json"), "rb") as _f:
|
||
REGISTRY = {c["capability"]: c for c in json.loads(_f.read())["capabilities"]}
|
||
|
||
|
||
def rung_refusal(cap, role, royalty_free_only):
|
||
r = REGISTRY.get(cap)
|
||
if r is None:
|
||
return f"capability-unknown:{cap}"
|
||
if r["kind"] in ("record", "derivation"):
|
||
return f"capability-not-payload:{cap}"
|
||
if r["status"] == "candidate":
|
||
return f"capability-candidate:{cap}"
|
||
if r["role"] != ("refinement" if role == "refinement" else "standalone"):
|
||
return f"capability-role:{cap}"
|
||
if royalty_free_only:
|
||
if r["licence"] is None:
|
||
return f"license-unclassified:{cap}"
|
||
if r["licence"] != "royalty-free":
|
||
return f"license-refused:{cap}:{r['licence']}"
|
||
return None
|
||
|
||
|
||
def admit(b):
|
||
"""A packager's verdict on a policy's bytes: the policy's refusal, or the first rung's."""
|
||
P = parse_policy_bytes(b)
|
||
for r in P["ladder"]:
|
||
code = rung_refusal(r["capability"], r["role"], P["royalty_free_only"])
|
||
if code:
|
||
raise Refused(code)
|
||
return P
|
||
|
||
|
||
# ---------------------------------------------------------------- sources (§4.7)
|
||
|
||
|
||
def clip(v):
|
||
return 0 if v < 0 else 255 if v > 255 else v
|
||
|
||
|
||
def bt709(y, cb, cr):
|
||
y, cb, cr = y - 16, cb - 128, cr - 128
|
||
return (clip((298 * y + 459 * cr + 128) >> 8), clip((298 * y - 55 * cb - 136 * cr + 128) >> 8),
|
||
clip((298 * y + 541 * cb + 128) >> 8))
|
||
|
||
|
||
def line(b, pos, at_end):
|
||
"""A line of at most 1024 bytes and its newline; None at the end of the bytes."""
|
||
if pos >= len(b):
|
||
return None, pos
|
||
nl = b.find(b"\n", pos, pos + 1025)
|
||
if nl < 0:
|
||
raise Refused(at_end)
|
||
return b[pos:nl], nl + 1
|
||
|
||
|
||
def u32_digits(s):
|
||
if not s or len(s) > 10 or not s.isdigit():
|
||
return None
|
||
v = int(s)
|
||
return v if v <= U32 else None
|
||
|
||
|
||
def read_y4m(b):
|
||
"""(w, h, rate, chroma, frames as RGB8 bytes)."""
|
||
l, pos = line(b, 0, "y4m-header")
|
||
if l is None:
|
||
raise Refused("y4m-header")
|
||
parts = l.split(b" ")
|
||
if parts[0] != b"YUV4MPEG2":
|
||
raise Refused("y4m-header")
|
||
w = h = rate = None
|
||
chroma = "420"
|
||
for p in parts[1:]:
|
||
if not p:
|
||
continue
|
||
tag, v = p[:1], p[1:]
|
||
if tag == b"W" or tag == b"H":
|
||
x = u32_digits(v)
|
||
if x is None:
|
||
raise Refused("y4m-header")
|
||
if tag == b"W":
|
||
w = x
|
||
else:
|
||
h = x
|
||
elif tag == b"F":
|
||
nd = v.split(b":")
|
||
n = u32_digits(nd[0]) if len(nd) == 2 else None
|
||
d = u32_digits(nd[1]) if len(nd) == 2 else None
|
||
if not n or not d:
|
||
raise Refused("y4m-header")
|
||
rate = (n, d)
|
||
elif tag == b"I" and v != b"p":
|
||
raise Refused("y4m-interlaced")
|
||
elif tag == b"C":
|
||
if v in (b"420jpeg", b"420paldv", b"420mpeg2", b"420"):
|
||
chroma = "420"
|
||
elif v == b"444":
|
||
chroma = "444"
|
||
else:
|
||
raise Refused("y4m-colorspace")
|
||
if not w or not h or w * h > (1 << 26) // 3:
|
||
raise Refused("y4m-header")
|
||
cw, ch = (w, h) if chroma == "444" else ((w + 1) // 2, (h + 1) // 2)
|
||
size = w * h + 2 * cw * ch
|
||
frames = []
|
||
while True:
|
||
l, pos = line(b, pos, "y4m-truncated")
|
||
if l is None:
|
||
break
|
||
parts = l.split(b" ")
|
||
if parts[0] != b"FRAME":
|
||
raise Refused("y4m-truncated")
|
||
for p in parts[1:]:
|
||
if p[:1] in (b"W", b"H", b"C"):
|
||
raise Refused("y4m-size-change")
|
||
if p[:1] == b"I" and p[1:] != b"p":
|
||
raise Refused("y4m-interlaced")
|
||
if pos + size > len(b):
|
||
raise Refused("y4m-truncated")
|
||
yp, up, vp = b[pos:pos + w * h], b[pos + w * h:pos + w * h + cw * ch], b[pos + w * h + cw * ch:pos + size]
|
||
pos += size
|
||
rgb = bytearray()
|
||
for y in range(h):
|
||
for x in range(w):
|
||
ci = y * w + x if chroma == "444" else (y >> 1) * cw + (x >> 1)
|
||
rgb.extend(bt709(yp[y * w + x], up[ci], vp[ci]))
|
||
frames.append(bytes(rgb))
|
||
return w, h, rate, chroma, frames
|
||
|
||
|
||
def read_wav(b):
|
||
if len(b) < 12 or b[0:4] != b"RIFF" or b[8:12] != b"WAVE":
|
||
raise Refused("wav-format")
|
||
pos, fmt = 12, None
|
||
while True:
|
||
if pos + 8 > len(b):
|
||
raise Refused("wav-truncated")
|
||
cid, ln = b[pos:pos + 4], int.from_bytes(b[pos + 4:pos + 8], "little")
|
||
pos += 8
|
||
if cid == b"fmt ":
|
||
if not 16 <= ln <= 40:
|
||
raise Refused("wav-format")
|
||
if pos + ln > len(b):
|
||
raise Refused("wav-truncated")
|
||
f = b[pos:pos + ln]
|
||
tag, ch, rate = int.from_bytes(f[0:2], "little"), int.from_bytes(f[2:4], "little"), int.from_bytes(f[4:8], "little")
|
||
align, bits = int.from_bytes(f[12:14], "little"), int.from_bytes(f[14:16], "little")
|
||
if tag != 1 or bits != 16 or ch == 0 or rate == 0 or align != 2 * ch:
|
||
raise Refused("wav-format")
|
||
fmt = (ch, rate)
|
||
pos += ln + (ln & 1)
|
||
elif cid == b"data":
|
||
if fmt is None or ln % (2 * fmt[0]):
|
||
raise Refused("wav-format")
|
||
if pos + ln > len(b):
|
||
raise Refused("wav-truncated")
|
||
return fmt, b[pos:pos + ln]
|
||
else:
|
||
pos += ln + (ln & 1)
|
||
if pos > len(b):
|
||
raise Refused("wav-truncated")
|
||
|
||
|
||
def source_verdict(name, b):
|
||
try:
|
||
read_y4m(b) if name.endswith(".y4m") else read_wav(b)
|
||
return "ok"
|
||
except Refused as r:
|
||
return r.code
|
||
|
||
|
||
# ---------------------------------------------------------------- unit conversions (§4.4, §4.5)
|
||
|
||
|
||
U64 = (1 << 64) - 1
|
||
|
||
|
||
def units_from_ms(ms, num, den):
|
||
return min(max(ms * num // (1000 * den), 1), U64)
|
||
|
||
|
||
def align(start, lead, comp):
|
||
return min(start * comp[0] * lead[1] // (comp[1] * lead[0]), U64)
|
||
|
||
|
||
# ---------------------------------------------------------------- fixtures
|
||
|
||
|
||
M32 = 0xFFFFFFFF
|
||
|
||
|
||
def mix(v):
|
||
v ^= v >> 16
|
||
v = (v * 0x7FEB352D) & M32
|
||
v ^= v >> 15
|
||
v = (v * 0x846CA68B) & M32
|
||
v ^= v >> 16
|
||
return v
|
||
|
||
|
||
def noise(seed, x, y, t):
|
||
return mix(seed ^ mix(x ^ mix(y ^ mix(t))))
|
||
|
||
|
||
def ramp(lo, hi, dx, dy, speed, jitter, seed, cb, cr):
|
||
def y_of(x, y, t):
|
||
v = (x * dx + y * dy + t * speed) % 32
|
||
base = lo + v * (hi - lo) // 31
|
||
if jitter:
|
||
return min(max(max(base + noise(seed, x, y, t) % 3 - 1, 0), 16), 235)
|
||
return base
|
||
return y_of, (cb, cr)
|
||
|
||
|
||
def blocks(levels, bw, bh, speed, cb, cr):
|
||
return (lambda x, y, t: levels[((x + t * speed) // bw + y // bh) % 3]), (cb, cr)
|
||
|
||
|
||
def noise_shot(lo, hi, seed, cb, cr):
|
||
return (lambda x, y, t: lo + noise(seed, x, y, t) % (hi - lo + 1)), (cb, cr)
|
||
|
||
|
||
# A span's optional fourth member: LOCAL reads `t` as the frame's index within the span
|
||
# (0..n-1) instead of the global frame index, so two LOCAL spans of one shot are equal
|
||
# frame for frame.
|
||
LOCAL = "local"
|
||
|
||
|
||
def fixture_spans(name):
|
||
"""(w, h, spans): each span (frames, shot, blend target or None[, LOCAL])."""
|
||
if name == "video-base-01":
|
||
shot = blocks([40, 120, 200], 8, 6, 1, 100, 160)
|
||
return 64, 36, [(60, ramp(20, 200, 1, 1, 1, True, 11, 110, 140), None),
|
||
(25, shot, None, LOCAL),
|
||
(50, ramp(30, 220, 2, 1, 1, True, 12, 150, 120), None),
|
||
(25, shot, None, LOCAL),
|
||
(40, ramp(16, 160, 1, 2, 1, True, 13, 128, 128), None)]
|
||
if name == "cuts-01":
|
||
a = ramp(20, 100, 1, 1, 1, True, 1, 110, 140)
|
||
b = ramp(120, 220, 2, 1, 1, True, 2, 150, 120)
|
||
flash = noise_shot(228, 235, 3, 128, 128)
|
||
c = ramp(30, 90, 1, 2, 1, True, 4, 120, 120)
|
||
d = ramp(150, 230, 1, 0, 2, True, 5, 136, 136)
|
||
e = ramp(40, 120, 0, 1, 1, True, 6, 100, 150)
|
||
f = ramp(140, 200, 1, 0, 1, True, 7, 160, 110)
|
||
return 32, 18, [(60, a, None), (30, b, None), (6, flash, None), (44, b, None), (20, c, None), (40, c, d),
|
||
(30, d, None), (30, e, None), (30, f, None), (30, e, None), (30, f, None)]
|
||
if name == "kinds-01":
|
||
return 32, 18, [(40, ramp(20, 200, 1, 1, 0, False, 0, 128, 128), None),
|
||
(40, blocks([40, 120, 200], 8, 6, 1, 128, 128), None),
|
||
(40, noise_shot(16, 235, 7, 128, 128), None),
|
||
(40, ramp(16, 80, 1, 1, 1, True, 8, 128, 128), None),
|
||
(130, ramp(60, 180, 2, 1, 0, False, 0, 140, 116), None)]
|
||
return None
|
||
|
||
|
||
def fixture(name):
|
||
w, h, spans = fixture_spans(name)
|
||
cw, ch = (w + 1) // 2, (h + 1) // 2
|
||
out = bytearray(f"YUV4MPEG2 W{w} H{h} F25:1 Ip A1:1 C420jpeg\n".encode())
|
||
t = 0
|
||
for span in spans:
|
||
n, (y_of, chroma), to = span[:3]
|
||
local = span[3:] == (LOCAL,)
|
||
for i in range(n):
|
||
out += b"FRAME\n"
|
||
def blend(a, b):
|
||
return (a * (n - i - 1) + b * (i + 1)) // n
|
||
tt = i if local else t
|
||
for y in range(h):
|
||
for x in range(w):
|
||
v = y_of(x, y, tt)
|
||
out.append(blend(v, to[0](x, y, tt)) if to else v)
|
||
cb, cr = chroma
|
||
if to:
|
||
cb, cr = blend(cb, to[1][0]), blend(cr, to[1][1])
|
||
out += bytes([cb]) * (cw * ch) + bytes([cr]) * (cw * ch)
|
||
t += 1
|
||
return bytes(out)
|
||
|
||
|
||
# ---------------------------------------------------------------- scene cut (§4.3) and kinds (§4.6)
|
||
|
||
|
||
def luma(r, g, b):
|
||
return (77 * r + 150 * g + 29 * b + 128) >> 8
|
||
|
||
|
||
def distance(a, b, wh):
|
||
return sum(abs(x - y) for x, y in zip(a, b)) * 1000 // (2 * wh)
|
||
|
||
|
||
def segment(frames, w, h, p):
|
||
"""The on-demand form: every frame known, `last` the final index."""
|
||
wh = w * h
|
||
ys = [[luma(f[i], f[i + 1], f[i + 2]) for i in range(0, len(f), 3)] for f in frames]
|
||
hists = []
|
||
for y in ys:
|
||
hh = [0] * 64
|
||
for v in y:
|
||
hh[v >> 2] += 1
|
||
hists.append(hh)
|
||
n = len(frames)
|
||
last = n - 1
|
||
scores = [0] + [distance(hists[f], hists[f - 1], wh) for f in range(1, n)]
|
||
L = p["lookahead"]
|
||
|
||
def rejected(f):
|
||
if any(distance(hists[f + k], hists[f - 1], wh) < p["cut_abs"] for k in range(1, min(L, last - f) + 1)):
|
||
return True
|
||
return any(distance(hists[f], hists[f - 1 - j], wh) < p["cut_abs"] for j in range(1, min(L, f - 1) + 1))
|
||
|
||
starts, flags, window, start = [0], [0], [], 0
|
||
for f in range(1, n):
|
||
ln, s = f - start, scores[f]
|
||
med = sorted(window)[(len(window) - 1) // 2] if window else 0
|
||
hard = ln >= p["min"] and s >= p["cut_abs"] and (len(window) < 3 or s * 1000 >= p["cut_rel"] * med)
|
||
soft = ln >= p["target"] and 2 * s >= p["cut_abs"]
|
||
if (hard or soft) and not rejected(f):
|
||
flag = 1
|
||
elif ln >= p["max"]:
|
||
flag = 2
|
||
else:
|
||
flag = 0
|
||
if flag:
|
||
starts.append(f)
|
||
flags.append(flag)
|
||
start, window = f, []
|
||
else:
|
||
window = (window + [s])[-p["window"]:]
|
||
pieces = []
|
||
for i, st in enumerate(starts):
|
||
end = starts[i + 1] if i + 1 < len(starts) else n
|
||
abs_diff = changed = 0
|
||
for f in range(st + 1, end):
|
||
for a, b in zip(ys[f], ys[f - 1]):
|
||
abs_diff += abs(a - b)
|
||
changed += a != b
|
||
compared = wh * (end - st - 1)
|
||
pieces.append({"start": st, "len": end - st, "flags": flags[i], "abs_diff": abs_diff, "changed": changed,
|
||
"compared": compared, "occupancy": sum(1 for c in hists[st] if c)})
|
||
return pieces, scores
|
||
|
||
|
||
def classify(pc, c):
|
||
mad = pc["abs_diff"] * 1000 // pc["compared"] if pc["compared"] else 0
|
||
chg = pc["changed"] * 1000 // pc["compared"] if pc["compared"] else 0
|
||
if mad <= c["static_mad_milli"] and chg <= c["static_permille"]:
|
||
kind = "static"
|
||
elif pc["occupancy"] <= c["synthetic_bins"]:
|
||
kind = "synthetic"
|
||
elif mad >= c["motion_high_milli"]:
|
||
kind = "motion_high"
|
||
else:
|
||
kind = "natural"
|
||
return kind, mad, chg
|
||
|
||
|
||
def plan_digest(starts):
|
||
b = b"wai:pack-plan\x01" + len(starts).to_bytes(8, "little")
|
||
for s in starts:
|
||
b += s.to_bytes(8, "little")
|
||
return blake3(b).hex()
|
||
|
||
|
||
# ---------------------------------------------------------------- the encoder's choices (§5.5, §5.6)
|
||
|
||
|
||
def quantize(r, q):
|
||
"""r / q rounded to the nearest integer, halves away from zero."""
|
||
m = (2 * abs(r) + q) // (2 * q)
|
||
return -m if r < 0 else m
|
||
|
||
|
||
def hist_to_cdf(hist, precision=16):
|
||
"""§5.5's table: every symbol frequency 1 + floor(R·h/H), the remainder one each to the
|
||
largest R·h mod H (the lower symbol first), the escape 1."""
|
||
total, n = 1 << precision, len(hist)
|
||
r = total - n - 1
|
||
weight = [1] * n if all(h == 0 for h in hist) else list(hist)
|
||
big_h = sum(weight)
|
||
freq = [1 + r * x // big_h for x in weight]
|
||
given = sum(f - 1 for f in freq)
|
||
order = sorted(range(n), key=lambda i: -(r * weight[i] % big_h))
|
||
for i in order[:r - given]:
|
||
freq[i] += 1
|
||
freq.append(1)
|
||
cdf, acc = [0], 0
|
||
for f in freq:
|
||
acc += f
|
||
cdf.append(acc)
|
||
return cdf
|
||
|
||
|
||
def residual_table(residuals):
|
||
"""The table and offset of §5.5 from a clip's residuals."""
|
||
lo, hi = min(residuals), max(residuals)
|
||
width = min(hi - lo + 1, 4095)
|
||
hist = [0] * width
|
||
for r in residuals:
|
||
if lo <= r < lo + width:
|
||
hist[r - lo] += 1
|
||
return hist_to_cdf(hist), lo
|
||
|
||
|
||
def clampi(v, lo, hi):
|
||
return lo if v < lo else hi if v > hi else v
|
||
|
||
|
||
def block_rows(ref, h, w, y0, y1, x0, x1, dy, dx, prec):
|
||
"""The decoder's prediction (integer-payloads §3) of the rows y0..y1, columns x0..x1
|
||
of a block from the reference frame `ref` (h·w·3 bytes) with vector (dy, dx): one
|
||
tuple of R, G, B samples per row."""
|
||
def cols(xs):
|
||
return [clampi(x, 0, w - 1) * 3 + c for x in xs for c in range(3)]
|
||
|
||
def rowsl(y):
|
||
k = clampi(y, 0, h - 1) * w * 3
|
||
return ref[k:k + w * 3]
|
||
out = []
|
||
if prec == 1:
|
||
get = cols(range(x0 + dx, x1 + dx))
|
||
for y in range(y0, y1):
|
||
row = rowsl(y + dy)
|
||
out.append([row[i] for i in get])
|
||
return out
|
||
fy, fx = dy & 1, dx & 1
|
||
ga = cols(range(x0 + (dx >> 1), x1 + (dx >> 1)))
|
||
gb = cols(range(x0 + (dx >> 1) + 1, x1 + (dx >> 1) + 1))
|
||
for y in range(y0, y1):
|
||
iy = y + (dy >> 1)
|
||
r0 = rowsl(iy)
|
||
a = [r0[i] for i in ga]
|
||
if not fy and not fx:
|
||
out.append(a)
|
||
continue
|
||
if not fy:
|
||
b = [r0[i] for i in gb]
|
||
out.append([(p + q + 1) >> 1 for p, q in zip(a, b)])
|
||
continue
|
||
r1 = rowsl(iy + 1)
|
||
c = [r1[i] for i in ga]
|
||
if not fx:
|
||
out.append([(p + q + 1) >> 1 for p, q in zip(a, c)])
|
||
continue
|
||
b = [r0[i] for i in gb]
|
||
d = [r1[i] for i in gb]
|
||
out.append([(p + q + s + t + 2) >> 2 for p, q, s, t in zip(a, b, c, d)])
|
||
return out
|
||
|
||
|
||
def search_block(src, ref, h, w, y0, x0, block, rng, prec):
|
||
"""§5.5's motion search for one block: dy outer, dx inner, each ascending over
|
||
-rng..=rng; the least SAD wins, a tie to the smaller |dy| + |dx|, then the earlier."""
|
||
y1, x1 = min(y0 + block, h), min(x0 + block, w)
|
||
srows = [src[(y * w + x0) * 3:(y * w + x1) * 3] for y in range(y0, y1)]
|
||
best = None # (cost, l1, dy, dx)
|
||
for dy in range(-rng, rng + 1):
|
||
for dx in range(-rng, rng + 1):
|
||
cost = 0
|
||
for s, p in zip(srows, block_rows(ref, h, w, y0, y1, x0, x1, dy, dx, prec)):
|
||
cost += sum(abs(a - b) for a, b in zip(s, p))
|
||
if best is not None and cost > best[0]:
|
||
break
|
||
l1 = abs(dy) + abs(dx)
|
||
if best is None or cost < best[0] or (cost == best[0] and l1 < best[1]):
|
||
best = (cost, l1, dy, dx)
|
||
return best[2], best[3]
|
||
|
||
|
||
def frame_pred(ref, h, w, block, mvs, prec):
|
||
"""A whole frame's prediction from `ref` with its blocks' vectors (raster order)."""
|
||
pred = [0] * (h * w * 3)
|
||
nbx = -(-w // block)
|
||
for by in range(-(-h // block)):
|
||
for bx in range(nbx):
|
||
y0, x0 = by * block, bx * block
|
||
y1, x1 = min(y0 + block, h), min(x0 + block, w)
|
||
dy, dx = mvs[by * nbx + bx]
|
||
for y, row in zip(range(y0, y1), block_rows(ref, h, w, y0, y1, x0, x1, dy, dx, prec)):
|
||
pred[(y * w + x0) * 3:(y * w + x1) * 3] = row
|
||
return pred
|
||
|
||
|
||
def frame_vectors(src, ref, h, w, block, rng, prec):
|
||
nbx, nby = -(-w // block), -(-h // block)
|
||
return [search_block(src, ref, h, w, by * block, bx * block, block, rng, prec) for by in range(nby) for bx in range(nbx)]
|
||
|
||
|
||
def closed_loop(frames, h, w, block, search, prec, q):
|
||
"""The encoder's reconstruction and its SSE (§5.5), without the entropy coder: each
|
||
frame's vectors searched against the previous frame as reconstructed."""
|
||
if len(frames) == 1:
|
||
block, prec = 1, 1
|
||
rng = search * prec if len(frames) > 1 else 0
|
||
recon, sse = [], 0
|
||
for f, src in enumerate(frames):
|
||
if f == 0:
|
||
pred = [128] * len(src)
|
||
else:
|
||
mvs = frame_vectors(src, recon[f - 1], h, w, block, rng, prec)
|
||
pred = frame_pred(recon[f - 1], h, w, block, mvs, prec)
|
||
cur = []
|
||
for t, p in zip(src, pred):
|
||
v = clampi(p + quantize(t - p, q) * q, 0, 255)
|
||
sse += (t - v) * (t - v)
|
||
cur.append(v)
|
||
recon.append(cur)
|
||
return recon, sse
|
||
|
||
|
||
def encoder_choices(v, params, src, decoded):
|
||
"""Item by item, what §5.5 makes of the source against the payload: every motion
|
||
vector, every coded residual, and the table and its offset. Returns the failures."""
|
||
h, w, n, q, prec, block = v["h"], v["w"], v["n_frames"], v["q"], v["mv_precision"], v["block"]
|
||
bad = []
|
||
rng = params["search"] * prec if n > 1 else 0
|
||
nb = -(-h // block) * -(-w // block)
|
||
d = IPV.Rans(v["rans"])
|
||
residuals = []
|
||
for f in range(n):
|
||
if f == 0:
|
||
pred = [128] * (h * w * 3)
|
||
else:
|
||
mvs = frame_vectors(src[f], decoded[f - 1], h, w, block, rng, prec)
|
||
if mvs != [tuple(m) for m in v["mvs"][(f - 1) * nb:f * nb]]:
|
||
bad.append(f"frame {f}: a motion vector is not the search's")
|
||
pred = frame_pred(decoded[f - 1], h, w, block, [tuple(m) for m in v["mvs"][(f - 1) * nb:f * nb]], prec)
|
||
for t, p in zip(src[f], pred):
|
||
r = quantize(t - p, q)
|
||
residuals.append(r)
|
||
if d.decode(v["cdf"], v["offset"]) != r:
|
||
bad.append(f"frame {f}: a coded residual is not quantize(source - prediction)")
|
||
return bad
|
||
cdf, offset = residual_table(residuals)
|
||
if (cdf, offset) != (list(v["cdf"]), v["offset"]):
|
||
bad.append("the residual table or its offset is not the fit of the residuals")
|
||
return bad
|
||
|
||
|
||
def sse_px_milli(sse, h, w, n):
|
||
return sse * 1000 // (3 * h * w * n)
|
||
|
||
|
||
def choose_q(metric_of, candidates, bound):
|
||
"""§5.6: the largest candidate meeting the bound, else the smallest."""
|
||
qs = sorted(set(candidates), reverse=True)
|
||
for q in qs:
|
||
if metric_of(q) <= bound:
|
||
return q
|
||
return qs[-1]
|
||
|
||
|
||
# ---------------------------------------------------------------- the stage index (§6.2–§6.4)
|
||
|
||
|
||
MEDIA_CLASSES = ["video", "image", "audio", "world", "feed", "avatar", "film"]
|
||
ROLES = ["base", "refinement", "floor", "snapshot", "ops", "receipt", "asset"]
|
||
BASE, REFINEMENT, FLOOR = 0, 1, 2
|
||
NO_REFINES = 0xFFFFFFFF
|
||
PIECE_KINDS = KINDS + ["world", "audio"]
|
||
ENTRY_DUP, ENTRY_DERIVED = 2, 4
|
||
TIER_NAMES = [None, "entropy-consistency", "decode-equivalence"]
|
||
|
||
|
||
def le(b, at, n):
|
||
return int.from_bytes(b[at:at + n], "little")
|
||
|
||
|
||
def pad8(n):
|
||
return (n + 7) // 8 * 8
|
||
|
||
|
||
def parse_index(b):
|
||
"""§6.2: a WSIX file read into its header, records, class plan and strings, or the
|
||
reader's refusal, the first that applies."""
|
||
if b[:4] != b"WSIX":
|
||
raise Refused("index-magic")
|
||
if len(b) < 6:
|
||
raise Refused("index-truncated")
|
||
if le(b, 4, 2) != 1:
|
||
raise Refused("index-version")
|
||
if len(b) < 160:
|
||
raise Refused("index-truncated")
|
||
n_p, n_e, n_s, n_c = le(b, 16, 4), le(b, 20, 4), le(b, 24, 4), le(b, 28, 4)
|
||
# Every table's size from its count, before anything is read from it.
|
||
at_e = 160 + 32 * n_p
|
||
at_c = at_e + 128 * n_e
|
||
at_plan = at_c + 16 * n_c
|
||
at_s = at_plan + pad8(n_c * n_p)
|
||
if at_s > len(b):
|
||
raise Refused("index-truncated")
|
||
raw, pos = [], at_s
|
||
for _ in range(n_s):
|
||
if pos + 2 > len(b) or pos + 2 + le(b, pos, 2) > len(b):
|
||
raise Refused("index-truncated")
|
||
raw.append(b[pos + 2:pos + 2 + le(b, pos, 2)])
|
||
pos += 2 + le(b, pos, 2)
|
||
end = at_s + pad8(pos - at_s)
|
||
if end > len(b):
|
||
raise Refused("index-truncated")
|
||
P = [b[160 + 32 * i:192 + 32 * i] for i in range(n_p)]
|
||
E = [b[at_e + 128 * i:at_e + 128 * (i + 1)] for i in range(n_e)]
|
||
C = [b[at_c + 16 * i:at_c + 16 * (i + 1)] for i in range(n_c)]
|
||
reserved = [b[146:160], b[at_plan + n_c * n_p:at_s], b[pos:end]]
|
||
reserved += [p[28:32] for p in P] + [e[58:60] + e[108:112] + e[120:128] for e in E] + [c[8:16] for c in C]
|
||
if any(any(r) for r in reserved):
|
||
raise Refused("index-reserved")
|
||
if le(b, 6, 2) >= len(MEDIA_CLASSES):
|
||
raise Refused("index-media-class")
|
||
for e in E:
|
||
if e[54] >= len(ROLES):
|
||
raise Refused("index-role")
|
||
if e[56] >= len(TIER_NAMES):
|
||
raise Refused("index-tier")
|
||
strings = []
|
||
for s in raw:
|
||
try:
|
||
strings.append(s.decode("utf-8"))
|
||
except UnicodeDecodeError:
|
||
raise Refused("index-string")
|
||
if not all(strings) or any(i >= n_s for i in [le(b, 144, 2)] + [le(e, 52, 2) for e in E] + [le(c, 0, 2) for c in C]):
|
||
raise Refused("index-string")
|
||
if end != len(b):
|
||
raise Refused("index-trailing")
|
||
return {
|
||
"raw": b, "media_class": le(b, 6, 2), "tb": (le(b, 8, 4), le(b, 12, 4)), "policy_digest": b[32:64],
|
||
"prev": b[64:96], "first_piece": le(b, 96, 8), "first_entry": le(b, 104, 8), "plan_digest": b[112:144],
|
||
"component": strings[le(b, 144, 2)], "strings": strings,
|
||
"pieces": [{"start": le(p, 0, 8), "duration": le(p, 8, 4), "first_entry": le(p, 12, 4),
|
||
"n_entries": le(p, 16, 2), "kind": p[18], "flags": p[19], "rules": le(p, 20, 4),
|
||
"moments": le(p, 24, 4)} for p in P],
|
||
"entries": [{"record": e, "hash": e[0:32], "byte_len": le(e, 32, 8), "piece": le(e, 40, 8),
|
||
"refines": le(e, 48, 4), "cap": strings[le(e, 52, 2)], "role": e[54], "layer": e[55],
|
||
"tier": e[56], "flags": e[57], "deadline": le(e, 60, 4), "prefix": e[64:96],
|
||
"sse": le(e, 96, 8), "man_len": le(e, 104, 4), "payload_len": le(e, 112, 8)} for e in E],
|
||
"classes": [{"name": strings[le(c, 0, 2)], "max_layer": c[2], "flags": c[3], "max_kbps": le(c, 4, 4)}
|
||
for c in C],
|
||
"plan": [list(b[at_plan + k * n_p:at_plan + (k + 1) * n_p]) for k in range(n_c)],
|
||
}
|
||
|
||
|
||
def cap_tier(cap):
|
||
"""§6.4: decode-equivalence (2) for a registry class that reconstructs exactly,
|
||
entropy-consistency (1) for neural-entropy-exact, none (0) otherwise."""
|
||
rep = (REGISTRY.get(cap) or {}).get("replicate")
|
||
return 2 if rep in ("standard-defined", "neural-int-exact") else 1 if rep == "neural-entropy-exact" else 0
|
||
|
||
|
||
def due_tier(E, i):
|
||
"""The tier §6.4 gives entry i: a refinement holds decode-equivalence only over a prefix
|
||
that does; a floor states none; any other entry its capability's."""
|
||
e = E[i]
|
||
if e["role"] == REFINEMENT:
|
||
return 2 if E[e["refines"]]["tier"] == 2 and cap_tier(e["cap"]) == 2 else 0
|
||
return 0 if e["role"] == FLOOR else cap_tier(e["cap"])
|
||
|
||
|
||
def owners(ix):
|
||
"""The window-relative piece of each entry, by the pieces' entry ranges."""
|
||
return [k for k, pc in enumerate(ix["pieces"]) for _ in range(pc["n_entries"])]
|
||
|
||
|
||
def highest_layer(ix, k):
|
||
pc = ix["pieces"][k]
|
||
es = ix["entries"][pc["first_entry"]:pc["first_entry"] + pc["n_entries"]]
|
||
return max((e["layer"] for e in es if e["role"] in (BASE, REFINEMENT)), default=0)
|
||
|
||
|
||
def index_rules(ix):
|
||
"""§6.3's rules in their order, with §6.4's tiers; the first broken is the refusal."""
|
||
if 0 in ix["tb"]:
|
||
raise Refused("index-timebase")
|
||
# An index with no previous window starts the timeline and the chain (§4.5).
|
||
if not any(ix["prev"]) and (ix["first_piece"] or ix["first_entry"] or (ix["pieces"] and ix["pieces"][0]["start"])):
|
||
raise Refused("window-start")
|
||
pieces, E, before = ix["pieces"], ix["entries"], 0
|
||
for k, pc in enumerate(pieces):
|
||
if pc["duration"] == 0 or (k and pc["start"] != pieces[k - 1]["start"] + pieces[k - 1]["duration"]):
|
||
raise Refused("piece-order")
|
||
if pc["first_entry"] != before or pc["n_entries"] == 0:
|
||
raise Refused("piece-entries")
|
||
if pc["kind"] >= len(PIECE_KINDS) or pc["flags"] > 0x0F:
|
||
raise Refused("piece-kind")
|
||
before += pc["n_entries"]
|
||
if before != len(E):
|
||
raise Refused("piece-entries")
|
||
rank = {BASE: 0, REFINEMENT: 1, FLOOR: 2}
|
||
own = owners(ix)
|
||
for i, e in enumerate(E):
|
||
pc = pieces[own[i]]
|
||
if e["piece"] != ix["first_piece"] + own[i]:
|
||
raise Refused("piece-entries")
|
||
if e["flags"] > 0x07:
|
||
raise Refused("entry-flags")
|
||
if i > pc["first_entry"]:
|
||
p = E[i - 1]
|
||
if rank.get(e["role"], 3) < rank.get(p["role"], 3) or \
|
||
(e["role"] == p["role"] == REFINEMENT and e["layer"] < p["layer"]):
|
||
raise Refused("entry-order")
|
||
refinement = e["role"] == REFINEMENT
|
||
if (e["role"] in (BASE, FLOOR) and e["layer"] > 0) or (refinement and e["layer"] == 0) \
|
||
or refinement != (e["refines"] != NO_REFINES):
|
||
raise Refused("layer-role")
|
||
if refinement:
|
||
if e["refines"] >= len(E):
|
||
raise Refused("refines-outside-window")
|
||
if not pc["first_entry"] <= e["refines"] < i:
|
||
raise Refused("refines-mismatch")
|
||
if E[e["refines"]]["layer"] != e["layer"] - 1:
|
||
raise Refused("layer-gap")
|
||
due = due_tier(E, i)
|
||
if e["layer"] > 0 and e["tier"] == 1:
|
||
raise Refused("tier-entropy-passthrough")
|
||
if e["layer"] > 0 and e["tier"] == 2 and due != 2:
|
||
raise Refused("tier-weakest")
|
||
if e["tier"] != due:
|
||
raise Refused("tier-mismatch")
|
||
if any(e["prefix"]) and e["tier"] != 2:
|
||
raise Refused("digest-without-tier")
|
||
if e["deadline"] and not refinement:
|
||
raise Refused("deadline-role")
|
||
if e["role"] == FLOOR and not e["flags"] & ENTRY_DERIVED:
|
||
raise Refused("floor-derived-from")
|
||
earlier = [x for x in E[:i] if x["hash"] == e["hash"]]
|
||
if any(x["byte_len"] != e["byte_len"] for x in earlier):
|
||
raise Refused("dup-length")
|
||
if bool(e["flags"] & ENTRY_DUP) != bool(earlier):
|
||
raise Refused("dup-flag")
|
||
if len(ix["plan"]) != len(ix["classes"]):
|
||
raise Refused("class-plan")
|
||
for cl, row in zip(ix["classes"], ix["plan"]):
|
||
if cl["flags"] > 0x01:
|
||
raise Refused("class-flags")
|
||
if len(row) != len(pieces):
|
||
raise Refused("class-plan")
|
||
for k, v in enumerate(row):
|
||
if cl["flags"] & 1:
|
||
ok = v == 0xFF
|
||
else:
|
||
ok = v == 0xFF or (v <= cl["max_layer"] and v <= highest_layer(ix, k))
|
||
if not ok:
|
||
raise Refused("class-plan")
|
||
|
||
|
||
def merkle_root(items):
|
||
"""jwp-receipts §2.2: each item under the leaf domain, pairs under the node domain, an
|
||
odd level's last node duplicated; no items, 32 zero bytes."""
|
||
if not items:
|
||
return bytes(32)
|
||
level = [blake3(b"moq-jwp:merkle-leaf\x01" + x) for x in items]
|
||
while len(level) > 1:
|
||
if len(level) % 2:
|
||
level.append(level[-1])
|
||
level = [blake3(b"moq-jwp:merkle-node\x01" + level[i] + level[i + 1]) for i in range(0, len(level), 2)]
|
||
return level[0]
|
||
|
||
|
||
def index_digest(b):
|
||
return blake3(b"wai:pack-stage-index\x01" + b)
|
||
|
||
|
||
def stage_root(ix):
|
||
"""§6.2: the Merkle root over BLAKE3("wai:pack-stage\\x01" ‖ entry record)."""
|
||
return merkle_root([blake3(b"wai:pack-stage\x01" + e["record"]) for e in ix["entries"]])
|
||
|
||
|
||
# ---------------------------------------------------------------- objects (§5, §6.3)
|
||
|
||
|
||
def content_hash(b):
|
||
"""jwp-receipts §2.1."""
|
||
return blake3(b"moq-jwp:object\x01" + b)
|
||
|
||
|
||
def read_json(b, minus_zero=False):
|
||
"""JSON in UTF-8 whose objects name no member twice (SPEC §2), or None. With
|
||
`minus_zero`, the number -0 is read as the float -0.0, as RFC 8259 readers that keep
|
||
its sign do, so no rule that requires an integer accepts it."""
|
||
def members(pairs):
|
||
d = {}
|
||
for k, v in pairs:
|
||
if k in d:
|
||
raise ValueError("a member named twice")
|
||
d[k] = v
|
||
return d
|
||
|
||
def no_constant(s):
|
||
raise ValueError(s)
|
||
|
||
def finite(t):
|
||
# RFC 8259 readers that hold numbers as binary64 refuse one past its range.
|
||
v = float(t)
|
||
if v in (float("inf"), float("-inf")):
|
||
raise ValueError(t)
|
||
return v
|
||
try:
|
||
hook = (lambda t: float(t) if t == "-0" else int(t)) if minus_zero else int
|
||
return json.loads(b.decode("utf-8"), object_pairs_hook=members, parse_constant=no_constant, parse_int=hook,
|
||
parse_float=finite)
|
||
except (UnicodeDecodeError, ValueError, RecursionError):
|
||
return None
|
||
|
||
|
||
def opt_str(o, k):
|
||
"""An OPTIONAL string member: absent, null, or a string."""
|
||
return k not in o or o[k] is None or isinstance(o[k], str)
|
||
|
||
|
||
def prior_ok(p):
|
||
"""SPEC §3.1: a pin is null, or an object whose id, sha256 and determinism are strings,
|
||
form and tier OPTIONAL strings, supersedes null or an object of a string sha256 and an
|
||
OPTIONAL string form."""
|
||
if p is None:
|
||
return True
|
||
if not isinstance(p, dict) or not all(isinstance(p.get(k), str) for k in ("id", "sha256", "determinism")):
|
||
return False
|
||
sup = p.get("supersedes")
|
||
return opt_str(p, "form") and opt_str(p, "tier") and \
|
||
(sup is None or (isinstance(sup, dict) and isinstance(sup.get("sha256"), str) and opt_str(sup, "form")))
|
||
|
||
|
||
def is_number(v):
|
||
return isinstance(v, (int, float)) and not isinstance(v, bool)
|
||
|
||
|
||
def manifest_typed(m, v2):
|
||
"""SPEC §3 and §7.1: a manifest that parses with its members' types. wai, media and
|
||
intent are strings. A WAI1's model_requirement is an object whose capability is a
|
||
string, fallback and sim_metric OPTIONAL strings, min_sim null or a number; its
|
||
conditioning an object whose kind is a string and prior a pin; security null or an
|
||
object of an OPTIONAL string encryption and an OPTIONAL u64 kid. A WAI2's renditions are
|
||
objects whose capability and kind are strings, id, sha256, role, companion_of and
|
||
companion_of_id OPTIONAL strings, prior a pin. Members this revision does not define
|
||
may have any value; refines, derived_from, envelope_manifest and target any JSON."""
|
||
if not isinstance(m, dict) or not all(isinstance(m.get(k), str) for k in ("wai", "media", "intent")):
|
||
return False
|
||
if v2:
|
||
rs = m.get("renditions")
|
||
return isinstance(rs, list) and all(
|
||
isinstance(r, dict) and isinstance(r.get("capability"), str) and isinstance(r.get("kind"), str)
|
||
and all(opt_str(r, k) for k in ("id", "sha256", "role", "companion_of", "companion_of_id")) and prior_ok(r.get("prior"))
|
||
for r in rs)
|
||
mr, c, sec = m.get("model_requirement"), m.get("conditioning"), m.get("security")
|
||
if not isinstance(mr, dict) or not isinstance(mr.get("capability"), str) or not opt_str(mr, "fallback") \
|
||
or not opt_str(mr, "sim_metric") or not (mr.get("min_sim") is None or is_number(mr["min_sim"])):
|
||
return False
|
||
if not isinstance(c, dict) or not isinstance(c.get("kind"), str) or not prior_ok(c.get("prior")):
|
||
return False
|
||
return sec is None or (isinstance(sec, dict) and opt_str(sec, "encryption")
|
||
and (sec.get("kid") is None or (is_int(sec["kid"]) and 0 <= sec["kid"] < 1 << 64)))
|
||
|
||
|
||
def read_envelope(b):
|
||
"""Exactly one WAI1 or WAI2 envelope and nothing after it (http-delivery §5.1), its
|
||
manifest JSON that parses (SPEC §2, §7.1): (man_len, payload_len, the member that
|
||
names the capability, the capability, each payload with the capabilities that decode
|
||
it), or None. The member is the WAI1 manifest, or the WAI2's first rendition entry; a
|
||
WAI2's payload length is every component's; a WAI1's payload is decoded by its
|
||
capability and its fallback (SPEC §4)."""
|
||
if len(b) < 8 or b[:4] not in (b"WAI1", b"WAI2"):
|
||
return None
|
||
ml = le(b, 4, 4)
|
||
if 8 + ml > len(b):
|
||
return None
|
||
man = read_json(b[8:8 + ml])
|
||
# §6.3: "does not parse" is the typed parse with SPEC §3's members.
|
||
if not manifest_typed(man, b[:4] == b"WAI2"):
|
||
return None
|
||
if b[:4] == b"WAI1":
|
||
if 12 + ml > len(b) or len(b) != 12 + ml + le(b, 8 + ml, 4):
|
||
return None
|
||
mr = man.get("model_requirement") if isinstance(man.get("model_requirement"), dict) else {}
|
||
caps = [c for c in (mr.get("capability"), mr.get("fallback")) if isinstance(c, str)]
|
||
return ml, le(b, 8 + ml, 4), man, mr.get("capability"), [(caps, b[12 + ml:])]
|
||
rs = man.get("renditions")
|
||
at = 8 + ml
|
||
if not isinstance(rs, list) or not rs or not all(isinstance(r, dict) for r in rs) or at + 2 > len(b):
|
||
return None
|
||
n = le(b, at, 2)
|
||
head = at + 2 + 8 * n
|
||
if n != len(rs) or head > len(b):
|
||
return None
|
||
total, parts = 0, []
|
||
for i in range(n):
|
||
if le(b, at + 2 + 8 * i, 4) != total:
|
||
return None
|
||
parts.append(([rs[i].get("capability")], b[head + total:head + total + le(b, at + 6 + 8 * i, 4)]))
|
||
total += le(b, at + 6 + 8 * i, 4)
|
||
return (ml, total, rs[0], rs[0].get("capability"), parts) if len(b) == head + total else None
|
||
|
||
|
||
WIR1_KIND = {"wai.image.int_refine": "rgb8", "wai.video.int_refine": "rgb8", "wai.audio.int_refine": "pcm",
|
||
"wai.splat.int_refine": "tensor"}
|
||
|
||
|
||
def wir1_parses(cap, p):
|
||
"""staged-delivery A.1–A.3: a WIR1 payload's parse, for the capability's unit kind."""
|
||
if p[:4] != b"WIR1" or len(p) < 44 or p[4] != 1 or le(p, 42, 2):
|
||
return False
|
||
elem, pred, mode, n, d0, d1, d2 = p[5], p[6], p[7], le(p, 8, 4), le(p, 12, 4), le(p, 16, 4), le(p, 20, 4)
|
||
rn, rd, q, cdf_len = le(p, 24, 4), le(p, 28, 4), le(p, 32, 4), le(p, 40, 2)
|
||
if elem not in (1, 2) or pred not in (0, 1, 2) or mode not in (0, 1) or 0 in (n, d0, d1, d2):
|
||
return False
|
||
if not ((rn >= 1 and rd >= 1) if pred == 2 else rn == rd == 0):
|
||
return False
|
||
if not 1 <= q <= 65535 or not 3 <= cdf_len <= 4097:
|
||
return False
|
||
kind = WIR1_KIND[cap]
|
||
if kind == "rgb8" and (elem != 1 or pred not in (0, 1) or d2 != 3):
|
||
return False
|
||
if kind == "pcm" and (elem != 2 or pred not in (0, 2) or d1 != 1):
|
||
return False
|
||
if kind == "tensor" and (elem != 1 or pred != 0):
|
||
return False
|
||
if d0 * d1 * d2 > 1 << 26 or n > 1 << 20 or n * d0 * d1 * d2 > 1 << 30:
|
||
return False
|
||
at = 44
|
||
for _ in range(n if mode else 1):
|
||
if at + 4 * cdf_len > len(p):
|
||
return False
|
||
try:
|
||
IPV.check_cdf([le(p, at + 4 * k, 4) for k in range(cdf_len)])
|
||
except IPV.Refused:
|
||
return False
|
||
at += 4 * cdf_len
|
||
if at + 4 * n > len(p):
|
||
return False
|
||
lens = [le(p, at + 4 * k, 4) for k in range(n)]
|
||
if any(x % 4 or x < 8 for x in lens):
|
||
return False
|
||
return at + 4 * n + sum(lens) == len(p)
|
||
|
||
|
||
def payload_parses(cap, p):
|
||
"""§6.2 with staged-measurement §3.2 and its Appendix A: a payload of a capability WAI
|
||
pins to a binary format parses as that format, by the parse a sink runs; a capability
|
||
with no pinned format asks nothing of it."""
|
||
if cap in IPV.CAP_MAGIC:
|
||
try:
|
||
IPV.parse(cap, p)
|
||
return True
|
||
except IPV.Refused:
|
||
return False
|
||
return wir1_parses(cap, p) if cap in WIR1_KIND else True
|
||
|
||
|
||
def derived_from_ok(df):
|
||
"""SPEC §7.1, *Derived renditions*: the member's four values in their forms."""
|
||
return isinstance(df, dict) and all(isinstance(df.get(k), str) and df[k] for k in
|
||
("motif", "motif_capability", "renderer", "settings")) \
|
||
and is_hex64(df["motif"]) and is_hex64(df["settings"])
|
||
|
||
|
||
def refines_ok(ix, i, rf):
|
||
"""§5.4: `base` the content hash of its piece's base, `layer` its layer, and as
|
||
producers in `prev` only objects of the layers below it, the entry it refines among them."""
|
||
E, pc = ix["entries"], ix["pieces"][owners(ix)[i]]
|
||
e, mine = E[i], E[pc["first_entry"]:pc["first_entry"] + pc["n_entries"]]
|
||
base = next((x for x in mine if x["role"] == BASE), None)
|
||
if not isinstance(rf, dict) or base is None or rf.get("base") != base["hash"].hex():
|
||
return False
|
||
if not is_int(rf.get("layer")) or rf["layer"] != e["layer"]:
|
||
return False
|
||
prev = rf.get("prev")
|
||
if isinstance(prev, str):
|
||
producers = [prev]
|
||
elif isinstance(prev, list) and prev and all(isinstance(r, dict) for r in prev):
|
||
producers = [r.get("producer") for r in prev]
|
||
else:
|
||
return False
|
||
below = {x["hash"].hex() for x in mine if x["role"] in (BASE, REFINEMENT) and x["layer"] < e["layer"]}
|
||
return all(p in below for p in producers) and E[e["refines"]]["hash"].hex() in producers
|
||
|
||
|
||
def object_rules(ix, i, data):
|
||
"""§6.3, with the objects in hand: entry i's object, the first rule broken is the refusal."""
|
||
e = ix["entries"][i]
|
||
if len(data) != e["byte_len"]:
|
||
raise Refused("object-length")
|
||
if content_hash(data) != e["hash"]:
|
||
raise Refused("object-hash")
|
||
env = read_envelope(data)
|
||
if env is None:
|
||
raise Refused("non-envelope-entry")
|
||
ml, pl, m, cap, parts = env
|
||
if ml != e["man_len"] or pl != e["payload_len"]:
|
||
raise Refused("object-lengths")
|
||
if cap != e["cap"]:
|
||
raise Refused("object-capability")
|
||
wai2 = data[:4] == b"WAI2"
|
||
# A refinement's object is a WAI1 that carries refines (§5.4).
|
||
if e["role"] == REFINEMENT and (wai2 or not refines_ok(ix, i, m.get("refines"))):
|
||
raise Refused("object-refines")
|
||
# derived_from: a WAI1's manifest member; a WAI2's entries', present when any entry
|
||
# carries it and well formed only when every one that does is. null is absent.
|
||
if wai2:
|
||
dfs = [r.get("derived_from") for r in read_json(data[8:8 + ml])["renditions"] if r.get("derived_from") is not None]
|
||
has, good = bool(dfs), all(derived_from_ok(x) for x in dfs)
|
||
else:
|
||
has = m.get("derived_from") is not None
|
||
good = not has or derived_from_ok(m["derived_from"])
|
||
if has != bool(e["flags"] & ENTRY_DERIVED) or not good:
|
||
raise Refused("object-derived-from")
|
||
# §6.2, after the other object rules: where WAI checks a payload's format, the lengths
|
||
# are its counted bytes (staged-measurement §3), so every such payload parses as its
|
||
# format.
|
||
if not all(payload_parses(c, p) for caps, p in parts for c in caps):
|
||
raise Refused("object-lengths")
|
||
return m
|
||
|
||
|
||
# ---------------------------------------------------------------- package receipts (§9)
|
||
|
||
|
||
PARENT_KINDS = ["none", "live-window", "re-pack"]
|
||
# energy-measurement §2.7: a class's tag, and the evidence members each class carries.
|
||
CLASS_TAGS = {"HwShunt": 1, "ModelBased": 2, "Estimator": 3, "OnChipCounter": 4, "CalibratedInstrument": 5}
|
||
FILTERING = {"Unknown": 0, "Off": 1, "On": 2}
|
||
EVIDENCE = {"OnChipCounter": {"energy_uncertainty", "energy_counter_filtering"},
|
||
"CalibratedInstrument": {"energy_uncertainty", "energy_calibration_ref"}}
|
||
EVIDENCE_MEMBERS = {"energy_uncertainty", "energy_counter_filtering", "energy_calibration_ref"}
|
||
V2_MEMBERS = {"asset_id", "components", "grant", "joules_micro", "kind", "packager", "parent_kind",
|
||
"parent_receipt_hash", "policy_digest", "receipt_hash", "sig", "signer_id", "signer_pubkey",
|
||
"stored_bytes", "total_bytes", "total_entries", "unique_objects", "version", "work_units"}
|
||
V1_MEMBERS = {"asset_id", "grant", "joules_micro", "kind", "parent_receipt_hash",
|
||
"receipt_hash", "segment_map_root", "segments", "sig", "signer_id", "signer_pubkey", "stored_bytes",
|
||
"total_bytes", "total_segments", "unique_segments", "work_segment_ops"}
|
||
RECEIPT_ID = b"wai:video-package-receipt-id\x01"
|
||
|
||
|
||
def be(v, n):
|
||
return v.to_bytes(n, "big")
|
||
|
||
|
||
def lp(s):
|
||
s = s.encode()
|
||
return be(len(s), 4) + s
|
||
|
||
|
||
def is_hex(s, n):
|
||
return isinstance(s, str) and len(s) == n and all(c in "0123456789abcdef" for c in s)
|
||
|
||
|
||
def is_u53(v):
|
||
return is_int(v) and 0 <= v <= MAX_INTEGER
|
||
|
||
|
||
def need(ok):
|
||
if not ok:
|
||
raise Refused("receipt-json")
|
||
|
||
|
||
def energy_label(j, strict):
|
||
"""energy-measurement §2.7: the class's signed encoding from its JSON members, or None
|
||
for no class. Evidence without its class, a class without its evidence, and evidence a
|
||
class does not carry are refused. Version 2 (`strict`, §9.1) writes the evidence exactly
|
||
as its class carries it, with no null in its place; version 1 (§9.3) reads a null
|
||
evidence member as absent, and an on-chip counter's filtering, absent, as Unknown."""
|
||
cls = j.get("energy_provenance")
|
||
if strict:
|
||
need(not any(k in j and j[k] is None for k in EVIDENCE_MEMBERS))
|
||
present = EVIDENCE_MEMBERS & set(j)
|
||
else:
|
||
present = {k for k in EVIDENCE_MEMBERS if j.get(k) is not None}
|
||
if cls is None:
|
||
need(not present)
|
||
return None
|
||
allowed = EVIDENCE.get(cls, set())
|
||
lenient = set() if strict else {"energy_counter_filtering"}
|
||
need(isinstance(cls, str) and cls in CLASS_TAGS and present <= allowed and (allowed - present) <= lenient)
|
||
out = bytes([CLASS_TAGS[cls]])
|
||
if cls in EVIDENCE:
|
||
u = j["energy_uncertainty"]
|
||
need(isinstance(u, dict) and set(u) == {"relative_ppm", "window_us"} and is_u53(u["relative_ppm"])
|
||
and u["relative_ppm"] <= U32 and is_u53(u["window_us"]))
|
||
out += be(u["relative_ppm"], 4) + be(u["window_us"], 8)
|
||
if cls == "OnChipCounter":
|
||
f = j.get("energy_counter_filtering") or "Unknown"
|
||
need(isinstance(f, str) and f in FILTERING)
|
||
out += bytes([FILTERING[f]])
|
||
else:
|
||
ref = j["energy_calibration_ref"]
|
||
need(isinstance(ref, str) and ref != "")
|
||
out += lp(ref)
|
||
return out
|
||
|
||
|
||
def grant_bytes(g):
|
||
"""The grant as §9.1 (and version 1) sign it: grant_hash ‖ u32 len ‖ capability ‖ u64
|
||
joule_ceiling_micro (null: 2^64 − 1) ‖ u8 0, or u8 1 ‖ u64 funds_ceiling."""
|
||
need(isinstance(g, dict) and set(g) == {"capability", "funds_ceiling", "grant_hash", "joule_ceiling_micro"})
|
||
need(isinstance(g["capability"], str) and is_hex(g["grant_hash"], 64))
|
||
need(g["joule_ceiling_micro"] is None or is_u53(g["joule_ceiling_micro"]))
|
||
need(g["funds_ceiling"] is None or is_u53(g["funds_ceiling"]))
|
||
out = bytes.fromhex(g["grant_hash"]) + lp(g["capability"])
|
||
out += be(U64 if g["joule_ceiling_micro"] is None else g["joule_ceiling_micro"], 8)
|
||
return out + (b"\x00" if g["funds_ceiling"] is None else b"\x01" + be(g["funds_ceiling"], 8))
|
||
|
||
|
||
def v1_leaf(s):
|
||
return blake3(b"wai:video-package-seg\x01" + be(s["index"], 8) + bytes.fromhex(s["content_hash"])
|
||
+ be(s["duration_ms"], 8) + be(s["byte_len"], 8))
|
||
|
||
|
||
def read_receipt(b):
|
||
"""§9.1 and §9.3: a receipt's JSON read as version 1 or 2, every member in its form,
|
||
its signing payload rebuilt and its receipt_hash checked; refuses receipt-version and
|
||
receipt-json. Returns the version, the JSON, the payload and the class encoding."""
|
||
# RFC 8259 with no member named twice; -0 is read as a number that is not an integer,
|
||
# so it is refused where an integer is required; a string that cannot be written in
|
||
# UTF-8 (a lone surrogate escape) has no form (receipt-json).
|
||
j = read_json(b, minus_zero=True)
|
||
need(isinstance(j, dict))
|
||
try:
|
||
r = receipt_payload(j)
|
||
need(blake3(RECEIPT_ID + r["payload"] + bytes.fromhex(j["sig"])).hex() == j["receipt_hash"])
|
||
except (UnicodeEncodeError, OverflowError, ValueError):
|
||
raise Refused("receipt-json")
|
||
return r
|
||
|
||
|
||
def receipt_payload(j):
|
||
"""A receipt's members read in their forms and its signing payload: version 2's
|
||
(§9.1), or version 1's (§9.3), the version a receipt without `version` has."""
|
||
v = j.get("version", 1)
|
||
if not is_int(v) or v not in (1, 2):
|
||
raise Refused("receipt-version")
|
||
need(isinstance(j.get("asset_id"), str) and j.get("kind") == "package")
|
||
# Version 2 writes every member, null where there is none (energy_provenance among
|
||
# them, §9.1); version 1 may leave energy_provenance out (§9.3).
|
||
if v == 2:
|
||
need(V2_MEMBERS | {"energy_provenance"} <= set(j) and set(j) <= V2_MEMBERS | {"energy_provenance"} | EVIDENCE_MEMBERS)
|
||
else:
|
||
need(V1_MEMBERS <= set(j) and set(j) <= V1_MEMBERS | {"version", "energy_provenance"} | EVIDENCE_MEMBERS)
|
||
label = energy_label(j, v == 2)
|
||
counts = ("total_entries", "unique_objects", "total_bytes", "stored_bytes", "work_units") if v == 2 else \
|
||
("total_segments", "unique_segments", "total_bytes", "stored_bytes", "work_segment_ops")
|
||
need(all(is_u53(j[k]) for k in counts + ("joules_micro",)))
|
||
need(is_hex(j["receipt_hash"], 64) and is_hex(j["sig"], 128) and is_hex(j["signer_pubkey"], 64))
|
||
need(isinstance(j["signer_id"], str))
|
||
grant = grant_bytes(j["grant"])
|
||
signer = bytes.fromhex(j["signer_pubkey"]) + lp(j["signer_id"])
|
||
figure = be(j["joules_micro"], 8)
|
||
if v == 2:
|
||
need(j["parent_kind"] in PARENT_KINDS if isinstance(j["parent_kind"], str) else False)
|
||
none = j["parent_kind"] == "none"
|
||
need(j["parent_receipt_hash"] is None if none else is_hex(j["parent_receipt_hash"], 64))
|
||
need(is_hex(j["policy_digest"], 64) and isinstance(j["packager"], str))
|
||
cs = j["components"]
|
||
need(isinstance(cs, list))
|
||
for c in cs:
|
||
need(isinstance(c, dict) and set(c) == {"id", "index", "index_digest", "media_class", "stage_root"})
|
||
need(isinstance(c["id"], str) and c["id"] != "" and c["index"] == f"index-{c['id']}.wsix")
|
||
need(is_hex(c["index_digest"], 64) and is_hex(c["stage_root"], 64))
|
||
need(isinstance(c["media_class"], str) and c["media_class"] in MEDIA_CLASSES)
|
||
payload = b"wai:pack-receipt" + (b"\x01" if label is None else b"\x02")
|
||
payload += lp(j["asset_id"]) + bytes.fromhex(j["policy_digest"])
|
||
payload += bytes([PARENT_KINDS.index(j["parent_kind"])])
|
||
payload += b"" if none else bytes.fromhex(j["parent_receipt_hash"])
|
||
payload += be(len(cs), 4)
|
||
for c in cs:
|
||
payload += lp(c["id"]) + bytes([MEDIA_CLASSES.index(c["media_class"])])
|
||
payload += bytes.fromhex(c["index_digest"]) + bytes.fromhex(c["stage_root"])
|
||
payload += b"".join(be(j[k], 8) for k in counts) + lp(j["packager"])
|
||
payload += figure + (label or b"") + grant + signer
|
||
else:
|
||
need(j["parent_receipt_hash"] is None or is_hex(j["parent_receipt_hash"], 64))
|
||
need(is_hex(j["segment_map_root"], 64) and isinstance(j["segments"], list))
|
||
for s in j["segments"]:
|
||
need(isinstance(s, dict) and set(s) == {"byte_len", "content_hash", "duration_ms", "index"})
|
||
need(is_u53(s["byte_len"]) and is_u53(s["duration_ms"]) and is_u53(s["index"]))
|
||
need(is_hex(s["content_hash"], 64))
|
||
payload = b"wai:video-package-receipt\x01" + lp(j["asset_id"]) + bytes.fromhex(j["segment_map_root"])
|
||
payload += b"".join(be(j[k], 8) for k in counts) + figure + (label or b"\x00") + grant
|
||
payload += b"\x00" if j["parent_receipt_hash"] is None else b"\x01" + bytes.fromhex(j["parent_receipt_hash"])
|
||
payload += be(len(j["segments"]), 8) + b"".join(v1_leaf(s) for s in j["segments"]) + signer
|
||
return {"version": v, "json": j, "payload": payload, "label": label}
|
||
|
||
|
||
def ed25519_verifies(pk, sig, msg):
|
||
"""WAI's strict rule (SPEC §7 *Signatures*): a canonical key of large order, S < L, R
|
||
not of small order, and the cofactorless equation with R compared byte for byte. The
|
||
`cryptography` package alone accepts a key of small order, a second spelling of a key,
|
||
and an R of small order."""
|
||
return ED.verifies(pk, msg, sig)
|
||
|
||
|
||
def ed25519_from_seed(seed, msg):
|
||
"""The public key of a 32-byte seed and its signature over msg (RFC 8032; deterministic)."""
|
||
from cryptography.hazmat.primitives import serialization
|
||
from cryptography.hazmat.primitives.asymmetric import ed25519
|
||
sk = ed25519.Ed25519PrivateKey.from_private_bytes(seed)
|
||
pk = sk.public_key().public_bytes(serialization.Encoding.Raw, serialization.PublicFormat.Raw)
|
||
return pk, sk.sign(msg)
|
||
|
||
|
||
def package_counts(ixs):
|
||
"""§9.1: entries, distinct content hashes, referenced and stored bytes, work units; None
|
||
when a content hash comes at two lengths."""
|
||
E = [e for ix in ixs for e in ix["entries"]]
|
||
first = {}
|
||
for e in E:
|
||
if first.setdefault(e["hash"], e["byte_len"]) != e["byte_len"]:
|
||
return None
|
||
return {"total_entries": len(E), "unique_objects": len(first), "total_bytes": sum(e["byte_len"] for e in E),
|
||
"stored_bytes": sum(first.values()), "work_units": len(E)}
|
||
|
||
|
||
def verify_receipt_v2(r, index_files):
|
||
"""§9.1's verification of a version-2 receipt against its indexes, in its components'
|
||
order: the first refusal that applies. Returns the parsed indexes."""
|
||
j = r["json"]
|
||
if r["version"] != 2:
|
||
raise Refused("receipt-version")
|
||
if not j["components"] or len(index_files) != len(j["components"]):
|
||
raise Refused("receipt-index-count")
|
||
ixs = []
|
||
for c, b in zip(j["components"], index_files):
|
||
ix = parse_index(b)
|
||
index_rules(ix)
|
||
if index_digest(b).hex() != c["index_digest"]:
|
||
raise Refused("receipt-index-digest")
|
||
if stage_root(ix).hex() != c["stage_root"]:
|
||
raise Refused("receipt-stage-root")
|
||
if ix["component"] != c["id"] or MEDIA_CLASSES[ix["media_class"]] != c["media_class"]:
|
||
raise Refused("receipt-component")
|
||
if ix["policy_digest"].hex() != j["policy_digest"]:
|
||
raise Refused("receipt-policy-digest")
|
||
ixs.append(ix)
|
||
if len({c["id"] for c in j["components"]}) != len(j["components"]):
|
||
raise Refused("receipt-component")
|
||
counts = package_counts(ixs)
|
||
if counts is None or any(counts[k] != j[k] for k in counts):
|
||
raise Refused("receipt-counts")
|
||
live = [any(ix["prev"]) for ix in ixs]
|
||
if not (all(live) if j["parent_kind"] == "live-window" else not any(live)):
|
||
raise Refused("receipt-parent-kind")
|
||
lab = r["label"]
|
||
if (lab is None) != (j["joules_micro"] == 0) or (lab is not None and lab[0] == CLASS_TAGS["HwShunt"]):
|
||
raise Refused("receipt-energy")
|
||
if not ed25519_verifies(bytes.fromhex(j["signer_pubkey"]), bytes.fromhex(j["sig"]), r["payload"]):
|
||
raise Refused("receipt-signature")
|
||
return ixs
|
||
|
||
|
||
# ---------------------------------------------------------------- the AV1 floor (§7)
|
||
|
||
|
||
class Malformed(Exception):
|
||
pass
|
||
|
||
|
||
def obus(b):
|
||
"""The low-overhead OBU format (AV1 §5.3): every OBU with its size field, read into
|
||
(type, the OBU's bytes, its payload)."""
|
||
out, p = [], 0
|
||
while p < len(b):
|
||
hdr = b[p]
|
||
if hdr & 0x80 or not hdr & 0x02:
|
||
raise Malformed("the forbidden bit, or an OBU without its size field")
|
||
q, size, shift = p + 1 + (hdr >> 2 & 1), 0, 0
|
||
for k in range(8):
|
||
if q >= len(b):
|
||
raise Malformed("a size field past the end")
|
||
size |= (b[q] & 0x7F) << shift
|
||
shift, q = shift + 7, q + 1
|
||
if not b[q - 1] & 0x80:
|
||
break
|
||
else:
|
||
raise Malformed("a size field over 8 bytes")
|
||
if q + size > len(b):
|
||
raise Malformed("an OBU past the end")
|
||
out.append((hdr >> 3 & 0x0F, b[p:q + size], b[q:q + size]))
|
||
p = q + size
|
||
return out
|
||
|
||
|
||
OBU_SEQ, OBU_TD, OBU_FRAME_HEADER, OBU_FRAME = 1, 2, 3, 6
|
||
|
||
|
||
def temporal_units(b):
|
||
"""A stream split at each temporal delimiter: (the unit's bytes, its OBUs)."""
|
||
units = []
|
||
for t, whole, payload in obus(b):
|
||
if t == OBU_TD:
|
||
units.append([b"", []])
|
||
elif not units:
|
||
raise Malformed("an OBU before the first temporal delimiter")
|
||
units[-1][0] += whole
|
||
units[-1][1].append((t, whole, payload))
|
||
return [(u, o) for u, o in units]
|
||
|
||
|
||
class Bits:
|
||
def __init__(self, b):
|
||
self.b, self.p = b, 0
|
||
|
||
def f(self, n):
|
||
v = 0
|
||
for _ in range(n):
|
||
if self.p >= 8 * len(self.b):
|
||
raise Malformed("a sequence header past its end")
|
||
v = v << 1 | (self.b[self.p >> 3] >> (7 - (self.p & 7)) & 1)
|
||
self.p += 1
|
||
return v
|
||
|
||
def uvlc(self):
|
||
zeros = 0
|
||
while not self.f(1):
|
||
zeros += 1
|
||
return (1 << 32) - 1 if zeros >= 32 else self.f(zeros) + (1 << zeros) - 1
|
||
|
||
|
||
def sequence_header(payload):
|
||
"""sequence_header_obu (AV1 §5.5): profile, operating point 0's level and tier, the
|
||
frame size, and color_config's bit depth, monochrome and chroma fields."""
|
||
r = Bits(payload)
|
||
s = {"profile": r.f(3), "still": r.f(1), "reduced": r.f(1)}
|
||
if s["reduced"]:
|
||
s["level"], s["tier"] = r.f(5), 0
|
||
else:
|
||
decoder_model = 0
|
||
if r.f(1): # timing_info_present_flag
|
||
r.f(32), r.f(32)
|
||
if r.f(1): # equal_picture_interval
|
||
r.uvlc()
|
||
decoder_model = r.f(1)
|
||
if decoder_model:
|
||
delay_bits = r.f(5) + 1
|
||
r.f(32), r.f(5), r.f(5)
|
||
initial_delay = r.f(1)
|
||
for i in range(r.f(5) + 1):
|
||
r.f(12)
|
||
level = r.f(5)
|
||
tier = r.f(1) if level > 7 else 0
|
||
if i == 0:
|
||
s["level"], s["tier"] = level, tier
|
||
if decoder_model and r.f(1):
|
||
r.f(delay_bits), r.f(delay_bits), r.f(1)
|
||
if initial_delay and r.f(1):
|
||
r.f(4)
|
||
wb, hb = r.f(4) + 1, r.f(4) + 1
|
||
s["max_w"], s["max_h"] = r.f(wb) + 1, r.f(hb) + 1
|
||
if not s["reduced"] and r.f(1): # frame_id_numbers_present_flag
|
||
r.f(4), r.f(3)
|
||
r.f(1), r.f(1), r.f(1) # 128x128 superblock, filter intra, intra edge filter
|
||
if not s["reduced"]:
|
||
r.f(1), r.f(1), r.f(1), r.f(1) # interintra, masked compound, warped motion, dual filter
|
||
order_hint = r.f(1)
|
||
if order_hint:
|
||
r.f(1), r.f(1) # jnt_comp, ref_frame_mvs
|
||
screen = 2 if r.f(1) else r.f(1) # seq_choose_screen_content_tools, else its value
|
||
if screen > 0 and not r.f(1): # seq_choose_integer_mv
|
||
r.f(1)
|
||
if order_hint:
|
||
r.f(3)
|
||
r.f(1), r.f(1), r.f(1) # superres, cdef, restoration
|
||
hbd = r.f(1)
|
||
s["high_bitdepth"], s["twelve_bit"] = hbd, 0
|
||
if s["profile"] == 2 and hbd:
|
||
s["twelve_bit"] = r.f(1)
|
||
s["bit_depth"] = 12 if s["twelve_bit"] else 10
|
||
else:
|
||
s["bit_depth"] = 10 if hbd else 8
|
||
s["mono"] = 0 if s["profile"] == 1 else r.f(1)
|
||
cp = tc = mc = 2
|
||
if r.f(1): # color_description_present_flag
|
||
cp, tc, mc = r.f(8), r.f(8), r.f(8)
|
||
s["csp"] = 0
|
||
if s["mono"]:
|
||
r.f(1)
|
||
s["ssx"] = s["ssy"] = 1
|
||
elif cp == 1 and tc == 13 and mc == 0:
|
||
s["ssx"] = s["ssy"] = 0
|
||
else:
|
||
r.f(1)
|
||
if s["profile"] == 0:
|
||
s["ssx"] = s["ssy"] = 1
|
||
elif s["profile"] == 1:
|
||
s["ssx"] = s["ssy"] = 0
|
||
elif s["bit_depth"] == 12:
|
||
s["ssx"] = r.f(1)
|
||
s["ssy"] = r.f(1) if s["ssx"] else 0
|
||
else:
|
||
s["ssx"], s["ssy"] = 1, 0
|
||
if s["ssx"] and s["ssy"]:
|
||
s["csp"] = r.f(2)
|
||
return s
|
||
|
||
|
||
def unit_frame(obu_list):
|
||
"""The first frame header or frame OBU of a unit, or None."""
|
||
return next((p for t, _, p in obu_list if t in (OBU_FRAME_HEADER, OBU_FRAME)), None)
|
||
|
||
|
||
def shown_key(obu_list, seq):
|
||
"""§7.3: a unit starts at a shown key frame when its first frame header has
|
||
show_existing_frame 0, frame_type KEY_FRAME and show_frame 1 (AV1 §5.9.2), or the
|
||
sequence uses the reduced still-picture header."""
|
||
p = unit_frame(obu_list)
|
||
if p is None:
|
||
return False
|
||
if seq["reduced"]:
|
||
return True
|
||
return len(p) > 0 and p[0] >> 7 == 0 and p[0] >> 5 & 3 == 0 and p[0] >> 4 & 1 == 1
|
||
|
||
|
||
def key_frame(obu_list, seq):
|
||
"""A unit whose first frame header is a key frame, shown or not."""
|
||
p = unit_frame(obu_list)
|
||
return p is not None and (seq["reduced"] or (len(p) > 0 and p[0] >> 7 == 0 and p[0] >> 5 & 3 == 0))
|
||
|
||
|
||
def av1c(seq, seq_obu):
|
||
"""§7.6: the AV1 binding's configuration record: marker and version 1, the profile,
|
||
level, tier, bit depth, monochrome and chroma fields, no initial presentation delay,
|
||
then the sequence header OBU."""
|
||
return bytes([0x81, seq["profile"] << 5 | seq["level"],
|
||
seq["tier"] << 7 | seq["high_bitdepth"] << 6 | seq["twelve_bit"] << 5 | seq["mono"] << 4
|
||
| seq["ssx"] << 3 | seq["ssy"] << 2 | seq["csp"], 0]) + seq_obu
|
||
|
||
|
||
def av1_codecs(seq):
|
||
"""§7.6: av01.<profile>.<level, two digits><M or H>.<bit depth, two digits>."""
|
||
return f"av01.{seq['profile']}.{seq['level']:02d}{'H' if seq['tier'] else 'M'}.{seq['bit_depth']:02d}"
|
||
|
||
|
||
def floor_payload(p):
|
||
"""§7.2: n, h, w, fps_num, fps_den as u32 LE, then n units, each a u32 LE length and its
|
||
bytes; None when it is not that."""
|
||
if len(p) < 20:
|
||
return None
|
||
n, h, w, fn, fd = (le(p, 4 * i, 4) for i in range(5))
|
||
units, at = [], 20
|
||
for _ in range(n):
|
||
if at + 4 > len(p) or at + 4 + le(p, at, 4) > len(p):
|
||
return None
|
||
units.append(p[at + 4:at + 4 + le(p, at, 4)])
|
||
at += 4 + le(p, at, 4)
|
||
return (n, h, w, fn, fd, units) if at == len(p) else None
|
||
|
||
|
||
# ---------------------------------------------------------------- CMAF (§7.6)
|
||
|
||
|
||
def u16(v):
|
||
return be(v, 2)
|
||
|
||
|
||
def u32(v):
|
||
return be(v, 4)
|
||
|
||
|
||
def box(kind, *parts):
|
||
body = b"".join(parts)
|
||
return u32(8 + len(body)) + kind + body
|
||
|
||
|
||
def full_box(kind, version, flags, *parts):
|
||
return box(kind, bytes([version]) + be(flags, 3), *parts)
|
||
|
||
|
||
UNITY = b"".join(u32(x) for x in (0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000))
|
||
|
||
|
||
def language(code):
|
||
"""ISO/IEC 14496-12 mdhd: three letters, each minus 0x60 in five bits."""
|
||
return (ord(code[0]) - 0x60) << 10 | (ord(code[1]) - 0x60) << 5 | (ord(code[2]) - 0x60)
|
||
|
||
|
||
def init_mp4(tb_num, w, h, config):
|
||
"""§7.6's init.mp4: ftyp, then moov (mvhd, trak, mvex), every time 0."""
|
||
ftyp = box(b"ftyp", b"cmfc", u32(0), b"cmfc", b"iso6", b"av01")
|
||
mvhd = full_box(b"mvhd", 0, 0, u32(0), u32(0), u32(tb_num), u32(0), u32(0x00010000), u16(0x0100),
|
||
bytes(10), UNITY, bytes(24), u32(2))
|
||
tkhd = full_box(b"tkhd", 0, 3, u32(0), u32(0), u32(1), u32(0), u32(0), bytes(8), u16(0), u16(0), u16(0),
|
||
u16(0), UNITY, u32(w << 16), u32(h << 16))
|
||
mdhd = full_box(b"mdhd", 0, 0, u32(0), u32(0), u32(tb_num), u32(0), u16(language("und")), u16(0))
|
||
hdlr = full_box(b"hdlr", 0, 0, u32(0), b"vide", bytes(12), b"video\x00")
|
||
vmhd = full_box(b"vmhd", 0, 1, u16(0), bytes(6))
|
||
dinf = box(b"dinf", full_box(b"dref", 0, 0, u32(1), full_box(b"url ", 0, 1)))
|
||
av01 = box(b"av01", bytes(6), u16(1), u16(0), u16(0), bytes(12), u16(w), u16(h), u32(0x00480000),
|
||
u32(0x00480000), u32(0), u16(1), bytes(32), u16(24), u16(0xFFFF), box(b"av1C", config))
|
||
stbl = box(b"stbl", full_box(b"stsd", 0, 0, u32(1), av01), full_box(b"stts", 0, 0, u32(0)),
|
||
full_box(b"stsc", 0, 0, u32(0)), full_box(b"stsz", 0, 0, u32(0), u32(0)),
|
||
full_box(b"stco", 0, 0, u32(0)))
|
||
trak = box(b"trak", tkhd, box(b"mdia", mdhd, hdlr, box(b"minf", vmhd, dinf, stbl)))
|
||
mvex = box(b"mvex", full_box(b"trex", 0, 0, u32(1), u32(1), u32(0), u32(0), u32(0)))
|
||
return ftyp + box(b"moov", mvhd, trak, mvex)
|
||
|
||
|
||
def fragment(piece, start, tb_den, samples):
|
||
"""§7.6's fragment: moof (mfhd, traf: tfhd, tfdt, trun with the offset of the mdat
|
||
payload), then mdat. samples: (bytes, at a shown key frame)."""
|
||
def moof(offset):
|
||
trun = full_box(b"trun", 0, 0x000701, u32(len(samples)), u32(offset),
|
||
*(u32(tb_den) + u32(len(s)) + u32(0x02000000 if key else 0x01010000) for s, key in samples))
|
||
traf = box(b"traf", full_box(b"tfhd", 0, 0x020000, u32(1)), full_box(b"tfdt", 1, 0, be(start * tb_den, 8)),
|
||
trun)
|
||
return box(b"moof", full_box(b"mfhd", 0, 0, u32(piece + 1)), traf)
|
||
m = moof(0)
|
||
return moof(len(m) + 8) + box(b"mdat", *(s for s, _ in samples))
|
||
|
||
|
||
def without_delimiters(obu_list):
|
||
return b"".join(whole for t, whole, _ in obu_list if t != OBU_TD)
|
||
|
||
|
||
# ---------------------------------------------------------------- classes and catalogs (§8)
|
||
|
||
|
||
def ms_text(units, num, den):
|
||
"""§8.3: floor(d · den · 1000 / num) milliseconds as S.mmm."""
|
||
ms = units * den * 1000 // num
|
||
return f"{ms // 1000}.{ms % 1000:03d}"
|
||
|
||
|
||
def bps(nbytes, units, num, den):
|
||
return -(-8 * nbytes * num // (units * den))
|
||
|
||
|
||
def listed_bytes(ix, k, top):
|
||
"""The bytes of piece k's bases and refinements up to layer `top`."""
|
||
pc = ix["pieces"][k]
|
||
return sum(e["byte_len"] for e in ix["entries"][pc["first_entry"]:pc["first_entry"] + pc["n_entries"]]
|
||
if e["role"] in (BASE, REFINEMENT) and e["layer"] <= top)
|
||
|
||
|
||
def class_plan(P, ix):
|
||
"""§8.1: each piece's moments and matching rules as bits, and per class the highest
|
||
layer it lists for each piece, 0xFF for the floor only."""
|
||
num, den = ix["tb"]
|
||
bits, rows = [], [[] for _ in P["class"]]
|
||
for k, pc in enumerate(ix["pieces"]):
|
||
s_ms, e_ms = pc["start"] * den * 1000 // num, (pc["start"] + pc["duration"]) * den * 1000 // num
|
||
moments = [i for i, m in enumerate(P["moment"]) if s_ms < m["to_ms"] and e_ms > m["from_ms"]]
|
||
tags = {t for i in moments for t in P["moment"][i]["tags"]}
|
||
rules, then = [], {}
|
||
for i, r in enumerate(P["rule"]):
|
||
w = r["when"]
|
||
if "piece_kind" in w and PIECE_KINDS[pc["kind"]] not in w["piece_kind"]:
|
||
continue
|
||
if "moment_tag" in w and not tags & set(w["moment_tag"]):
|
||
continue
|
||
rules.append(i)
|
||
then.update(r["then"])
|
||
bits.append((sum(1 << i for i in rules), sum(1 << i for i in moments)))
|
||
for row, cl in zip(rows, P["class"]):
|
||
if cl["floor_only"]:
|
||
row.append(0xFF)
|
||
continue
|
||
top = min(cl["max_layer"], then.get("max_layer", 255), highest_layer(ix, k))
|
||
if "max_kbps" in cl:
|
||
while top >= 0 and -(-8 * listed_bytes(ix, k, top) * num // (1000 * pc["duration"] * den)) \
|
||
> cl["max_kbps"]:
|
||
top -= 1
|
||
row.append(0xFF if top < 0 else top)
|
||
return bits, rows
|
||
|
||
|
||
def listed(ix, k, top):
|
||
"""The bases and refinements piece k lists up to layer `top`, in entry order."""
|
||
pc = ix["pieces"][k]
|
||
if top == 0xFF:
|
||
return []
|
||
return [e for e in ix["entries"][pc["first_entry"]:pc["first_entry"] + pc["n_entries"]]
|
||
if e["role"] in (BASE, REFINEMENT) and e["layer"] <= top]
|
||
|
||
|
||
def codecs_value(objects):
|
||
"""http-delivery §4.2 over a sequence of WAI1 objects (entries): the union, an alt per
|
||
distinct capability of the objects that are not layers, a layer's capability after `+`
|
||
in its base's alt; and the floor, the alts every such object has."""
|
||
alts, joined = [], {}
|
||
for e in objects:
|
||
if e["role"] != REFINEMENT and e["cap"] not in alts:
|
||
alts.append(e["cap"])
|
||
bases = [e for e in objects if e["role"] != REFINEMENT]
|
||
for e in objects:
|
||
if e["role"] == REFINEMENT:
|
||
base_cap = e.get("base_cap")
|
||
joined.setdefault(base_cap, [])
|
||
if e["cap"] not in joined[base_cap]:
|
||
joined[base_cap].append(e["cap"])
|
||
|
||
def alt(c):
|
||
return "+".join(x[len("wai."):] for x in [c] + joined.get(c, []))
|
||
union = "wai1." + "|".join(alt(c) for c in alts)
|
||
floor = "wai1." + "|".join(alt(c) for c in alts if all(b["cap"] == c for b in bases))
|
||
return union, floor
|
||
|
||
|
||
def render_catalogs(P, ix, c, floor, size, policy_hex):
|
||
"""§8.3–§8.8 for one component c: every catalog file as the index, the objects and the
|
||
floor give it. floor: (codecs, width, height, [(fragment name, bytes)]); size: (W, H)."""
|
||
num, den = ix["tb"]
|
||
pieces, plan = ix["pieces"], ix["plan"]
|
||
F, FW, FH, frags = floor
|
||
W, H = size
|
||
first_piece, first_start = ix["first_piece"], pieces[0]["start"]
|
||
total = sum(pc["duration"] for pc in pieces)
|
||
tgt = max(-(-pc["duration"] * den // num) for pc in pieces)
|
||
out = {}
|
||
|
||
def text(lines):
|
||
return "".join(x + "\n" for x in lines).encode()
|
||
|
||
def rates(per):
|
||
"""(BANDWIDTH, AVERAGE-BANDWIDTH) over (bytes, units) pairs."""
|
||
return (max(bps(n, d, num, den) for n, d in per),
|
||
bps(sum(n for n, _ in per), sum(d for _, d in per), num, den))
|
||
fb, fa = rates([(len(fr), pc["duration"]) for (_, fr), pc in zip(frags, pieces)])
|
||
head = ["#EXTM3U", "#EXT-X-VERSION:7", "#EXT-X-INDEPENDENT-SEGMENTS"]
|
||
inf = f'#EXT-X-STREAM-INF:BANDWIDTH={fb},AVERAGE-BANDWIDTH={fa},CODECS="{F}",RESOLUTION={FW}x{FH}'
|
||
# The floor variant's URI resolves from hls/classic/ and from every class's directory
|
||
# alike, so a class's master is the classical one with at most one line added.
|
||
out["hls/classic/master.m3u8"] = text(head + [inf, f"../classic/floor-{c}.m3u8"])
|
||
media = ["#EXTM3U", "#EXT-X-VERSION:7", f"#EXT-X-TARGETDURATION:{tgt}", "#EXT-X-MEDIA-SEQUENCE:0",
|
||
"#EXT-X-PLAYLIST-TYPE:VOD", "#EXT-X-INDEPENDENT-SEGMENTS"]
|
||
lines = media + [f'#EXT-X-MAP:URI="../../floor/{c}/init.mp4"']
|
||
for (name, _), pc in zip(frags, pieces):
|
||
lines += [f"#EXTINF:{ms_text(pc['duration'], num, den)},", f"../../floor/{c}/{name}"]
|
||
out[f"hls/classic/floor-{c}.m3u8"] = text(lines + ["#EXT-X-ENDLIST"])
|
||
mpd_head = ['<?xml version="1.0" encoding="UTF-8"?>',
|
||
'<MPD xmlns="urn:mpeg:dash:schema:mpd:2011" profiles="urn:mpeg:dash:profile:full:2011" '
|
||
f'type="static" mediaPresentationDuration="PT{ms_text(total, num, den)}S" minBufferTime="PT{tgt}S">',
|
||
' <Period id="p0" start="PT0S">']
|
||
mpd_tail = [" </AdaptationSet>", " </Period>", "</MPD>"]
|
||
|
||
def timeline(ks):
|
||
return [" <SegmentTimeline>"] + \
|
||
[f' <S t="{(pieces[k]["start"] - first_start) * den}" d="{pieces[k]["duration"] * den}"/>'
|
||
for k in ks] + [" </SegmentTimeline>"]
|
||
lines = mpd_head + [
|
||
f' <AdaptationSet id="1" contentType="video" mimeType="video/mp4" codecs="{F}" width="{FW}" '
|
||
f'height="{FH}" segmentAlignment="true" startWithSAP="1">',
|
||
f' <Representation id="{c}-floor" bandwidth="{fb}">', f' <SegmentList timescale="{num}">',
|
||
f' <Initialization sourceURL="../floor/{c}/init.mp4"/>'] + timeline(range(len(pieces)))
|
||
lines += [f' <SegmentURL media="../floor/{c}/{name}"/>' for name, _ in frags]
|
||
out["dash/classic.mpd"] = text(lines + [" </SegmentList>", " </Representation>"] + mpd_tail)
|
||
E = ix["entries"]
|
||
by_hash = {}
|
||
for e in E:
|
||
by_hash.setdefault(e["hash"], e)
|
||
for ci, cl in enumerate(P["class"]):
|
||
name, row = cl["id"], plan[ci]
|
||
lists = [listed(ix, k, row[k]) for k in range(len(pieces))]
|
||
wai = any(lists)
|
||
lines = head[:]
|
||
if wai:
|
||
lines.append('#EXT-X-SESSION-DATA:DATA-ID="science.transaction.wai.multivariant",VALUE="wai.m3u8"')
|
||
out[f"hls/{name}/master.m3u8"] = text(lines + [inf, f"../classic/floor-{c}.m3u8"])
|
||
views = []
|
||
for k, pc in enumerate(pieces):
|
||
v = {"dur": pc["duration"], "p": first_piece + k, "start": pc["start"], "stages": []}
|
||
if row[k] == 0xFF:
|
||
v["floor_only"] = True
|
||
for e in lists[k]:
|
||
s = {"bytes": e["byte_len"], "h": e["hash"].hex(), "layer": e["layer"]}
|
||
if e["role"] == REFINEMENT:
|
||
s["refines"] = E[e["refines"]]["hash"].hex()
|
||
s["deadline_ms"] = e["deadline"]
|
||
v["stages"].append(s)
|
||
views.append(v)
|
||
comp = {"pieces": views}
|
||
if any(lists[k] for k in range(len(pieces))):
|
||
comp["media_playlist"] = f"../hls/{name}/wai-{c}.m3u8"
|
||
view = {"class": name, "components": {c: comp}, "policy_digest": policy_hex}
|
||
out[f"stages/{name}.json"] = (jcs(view) + "\n").encode()
|
||
if not wai:
|
||
continue
|
||
objs = []
|
||
for k in range(len(pieces)):
|
||
base = next((e for e in lists[k] if e["role"] == BASE), None)
|
||
for e in lists[k]:
|
||
objs.append(dict(e, base_cap=base and base["cap"]))
|
||
union, fl = codecs_value(objs)
|
||
wb, wa = rates([(sum(e["byte_len"] for e in lists[k]), pieces[k]["duration"])
|
||
for k in range(len(pieces)) if lists[k]])
|
||
out[f"hls/{name}/wai.m3u8"] = text(head + [
|
||
f'#EXT-X-SESSION-DATA:DATA-ID="science.transaction.wai.class",VALUE="{name}"',
|
||
f'#EXT-X-SESSION-DATA:DATA-ID="science.transaction.wai.stages",URI="../../stages/{name}.json"',
|
||
f'#EXT-X-STREAM-INF:BANDWIDTH={wb},AVERAGE-BANDWIDTH={wa},CODECS="{union}",X-WAI-FLOOR="{fl}",'
|
||
f'RESOLUTION={W}x{H}', f"wai-{c}.m3u8"])
|
||
lines = media[:]
|
||
for k, pc in enumerate(pieces):
|
||
p0 = pc["first_entry"]
|
||
base = next(e for e in E[p0:p0 + pc["n_entries"]] if e["role"] == BASE)
|
||
if row[k] == 0xFF:
|
||
lines.append("#EXT-X-GAP")
|
||
# A layer line follows its segment's EXTINF, before the segment's URI
|
||
# (http-delivery §10.4).
|
||
lines.append(f"#EXTINF:{ms_text(pc['duration'], num, den)},")
|
||
lines += [f'#WAI-LAYER:N={e["layer"]},URI="../../objects/{e["hash"].hex()}.wai#n={e["byte_len"]}"'
|
||
for e in lists[k] if e["role"] == REFINEMENT]
|
||
lines.append(f"../../objects/{base['hash'].hex()}.wai#n={base['byte_len']}")
|
||
out[f"hls/{name}/wai-{c}.m3u8"] = text(lines + ["#EXT-X-ENDLIST"])
|
||
lines = mpd_head + [
|
||
f' <AdaptationSet id="1" contentType="video" mimeType="application/wai" codecs="{union}" '
|
||
f'width="{W}" height="{H}">',
|
||
' <EssentialProperty schemeIdUri="tag:transaction.science,2026:wai/http-delivery"/>',
|
||
f' <SupplementalProperty schemeIdUri="tag:transaction.science,2026:wai/floor" value="{fl}"/>',
|
||
f' <SupplementalProperty schemeIdUri="tag:transaction.science,2026:wai/class" value="{name}"/>',
|
||
' <SupplementalProperty schemeIdUri="tag:transaction.science,2026:wai/stages" '
|
||
f'value="../stages/{name}.json"/>']
|
||
for layer in range(max(v for v in row if v != 0xFF) + 1):
|
||
ks = [k for k in range(len(pieces)) if any(e["layer"] == layer for e in lists[k])]
|
||
mine = [[e for e in lists[k] if e["layer"] == layer] for k in ks]
|
||
peak = max((bps(sum(e["byte_len"] for e in m), pieces[k]["duration"], num, den)
|
||
for k, m in zip(ks, mine)), default=0)
|
||
dep = f' dependencyId="{c}-l{layer - 1}"' if layer else ""
|
||
lines += [f' <Representation id="{c}-l{layer}"{dep} bandwidth="{peak}">',
|
||
f' <SegmentList timescale="{num}">'] + timeline(ks)
|
||
lines += [f' <SegmentURL media="../objects/{e["hash"].hex()}.wai"/>' for m in mine for e in m]
|
||
lines += [" </SegmentList>", " </Representation>"]
|
||
out[f"dash/{name}.mpd"] = text(lines + mpd_tail)
|
||
has_floor = any(e["role"] == FLOOR for e in E)
|
||
out["moq/catalog.json"] = render_moq(c, E, P["live"]["layer_lag_ms"], P["defaults"]["deadline_ms"],
|
||
(F, FW, FH) if has_floor else None)
|
||
return out
|
||
|
||
|
||
def render_moq(c, E, lag, default_deadline, floor):
|
||
"""§8.4: moq/catalog.json. One track per (layer, deadline), by layer, then by deadline
|
||
ascending; a refinement track depends on every track that carries an entry its entries
|
||
refine, in track order, so it never names a track the catalog does not hold. floor:
|
||
(codecs, width, height) or None."""
|
||
keys = sorted({(e["layer"], e["deadline"]) for e in E if e["role"] in (BASE, REFINEMENT)})
|
||
|
||
def name(key):
|
||
layer, deadline = key
|
||
return f"{c}/l{layer}" + (f"@{deadline}" if layer and deadline != default_deadline else "")
|
||
tracks = []
|
||
for ti, (layer, deadline) in enumerate(keys):
|
||
es = [e for e in E if e["role"] in (BASE, REFINEMENT) and (e["layer"], e["deadline"]) == (layer, deadline)]
|
||
caps = []
|
||
for e in es:
|
||
if e["cap"] not in caps:
|
||
caps.append(e["cap"])
|
||
t = {"name": name((layer, deadline)), "packaging": "wai", "renderGroup": 1,
|
||
"priority": 64 + 32 * layer, "wai_capabilities": caps, "wai_layer": layer, "wai_receipts": False}
|
||
if min(e["tier"] for e in es):
|
||
t["wai_determinism"] = TIER_NAMES[min(e["tier"] for e in es)]
|
||
if layer == 0 and floor is not None:
|
||
t["altGroup"] = 1
|
||
if layer:
|
||
deps = set()
|
||
for e in es:
|
||
below = E[e["refines"]]
|
||
dt = keys.index((below["layer"], below["deadline"]))
|
||
if dt >= ti:
|
||
raise ValueError("a refinement refines an entry on no earlier track")
|
||
deps.add(dt)
|
||
t["depends"] = [name(keys[x]) for x in sorted(deps)]
|
||
t["wai_delivery_timeout_ms"] = max(0, deadline - (lag[layer] if layer < len(lag) else 0))
|
||
tracks.append(t)
|
||
if floor is not None:
|
||
tracks.append({"altGroup": 1, "codec": floor[0], "height": floor[2], "name": f"{c}/floor", "packaging": "cmaf",
|
||
"renderGroup": 1, "width": floor[1]})
|
||
return (jcs({"tracks": tracks, "version": 1}) + "\n").encode()
|
||
|
||
|
||
# ---------------------------------------------------------------- the corpus
|
||
|
||
|
||
class Report:
|
||
def __init__(self):
|
||
self.failures = 0
|
||
self.checked = 0
|
||
|
||
def check(self, ok, what):
|
||
self.checked += 1
|
||
if not ok:
|
||
self.failures += 1
|
||
print(f"FAIL {what}")
|
||
|
||
|
||
def load(path):
|
||
with open(path, "rb") as f:
|
||
return f.read()
|
||
|
||
|
||
def tree(root):
|
||
"""Every file below root, as paths, in byte order, read strictly (§11.3 step 1): every
|
||
name, one beginning with `.` and a `*.sha256` file included; None when an entry is a
|
||
symbolic link or neither a file nor a directory, when a directory cannot be read, or
|
||
when a directory below root holds nothing (§11.1: no other file or directory)."""
|
||
def unreadable(e):
|
||
raise e
|
||
out = []
|
||
try:
|
||
for at, dirs, files in os.walk(root, onerror=unreadable):
|
||
if at != root and not dirs and not files:
|
||
return None
|
||
for n in dirs + files:
|
||
full = os.path.join(at, n)
|
||
if os.path.islink(full) or not (os.path.isdir(full) or os.path.isfile(full)):
|
||
return None
|
||
out += [os.path.relpath(os.path.join(at, f), root).replace(os.sep, "/") for f in files]
|
||
except OSError:
|
||
return None
|
||
return sorted(out, key=lambda p: p.encode())
|
||
|
||
|
||
SEGMENT_FIRST = set("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-")
|
||
|
||
|
||
def segment_ok(s):
|
||
"""SPEC §3.1: a path segment."""
|
||
return s != "" and s[0] in SEGMENT_FIRST and all(c in SEGMENT_FIRST | {"."} for c in s) and not s.endswith(".")
|
||
|
||
|
||
def listing(root, paths):
|
||
"""SPEC §3.1: a line per file, its SHA-256, two spaces, its path and a line feed."""
|
||
return "".join(hashlib.sha256(load(os.path.join(root, p))).hexdigest() + " " + p + "\n" for p in paths).encode()
|
||
|
||
|
||
def seg_params(P, tb):
|
||
s = P["segmentation"]
|
||
return {"min": units_from_ms(s["min_ms"], *tb), "target": units_from_ms(s["target_ms"], *tb),
|
||
"max": units_from_ms(s["max_ms"], *tb), "cut_abs": s["cut_abs_permille"], "cut_rel": s["cut_rel_permille"],
|
||
"window": s["cut_window"], "lookahead": s["lookahead_frames"]}
|
||
|
||
|
||
def clip_digest(frames):
|
||
"""SPEC §7, *Digests*: the SHA-256 of the frames' SHA-256 digests concatenated."""
|
||
return hashlib.sha256(b"".join(hashlib.sha256(f).digest() for f in frames)).digest()
|
||
|
||
|
||
def verify_pack(rep, d, name, pkg=None, inputs=True):
|
||
"""packs/<name>/: package/ (or `pkg`) verified in §11.3's order, without the source;
|
||
then, with `inputs`, the package's inputs: policy.toml as given, and what only the
|
||
source decides (the plan, each base's sse and step) and the supplied floor."""
|
||
root = os.path.join(d, "packs", name)
|
||
pkg = pkg or os.path.join(root, "package")
|
||
tag = f"packs/{name}"
|
||
files = tree(pkg)
|
||
if files is None:
|
||
rep.check(False, f"{tag}: a symbolic link or an entry that is neither file nor directory (unexpected-file)")
|
||
return
|
||
paths_ok = all(all(segment_ok(s) for s in p.split("/")) for p in files) and len({p.lower() for p in files}) == len(files)
|
||
rep.check(paths_ok, f"{tag}: every file, read strictly, has a listing path (SPEC §3.1) (unexpected-file)")
|
||
if not paths_ok:
|
||
return
|
||
if "LISTING" not in files:
|
||
rep.check(False, f"{tag}: no LISTING (listing-missing)")
|
||
return
|
||
others = [p for p in files if p != "LISTING"]
|
||
ok = load(os.path.join(pkg, "LISTING")) == listing(pkg, others)
|
||
rep.check(ok, f"{tag}: LISTING is the listing of the other files (listing-mismatch)")
|
||
if not ok:
|
||
return
|
||
def get(p):
|
||
return load(os.path.join(pkg, p)) if p in files else b""
|
||
raw = get("package.receipt.json")
|
||
try:
|
||
r = read_receipt(raw)
|
||
if r["version"] != 2:
|
||
raise Refused("receipt-version")
|
||
except Refused as e:
|
||
rep.check(False, f"{tag}: package.receipt.json does not read as version 2 ({e.code})")
|
||
return
|
||
j = r["json"]
|
||
ok = raw == jcs(j).encode()
|
||
rep.check(ok, f"{tag}: package.receipt.json is RFC 8785 canonical JSON, its receipt's own form (receipt-json)")
|
||
if not ok:
|
||
return
|
||
|
||
# The policy: as given, its effective canonical JSON, its digest (§3.2, §11.1).
|
||
toml_b, pj = get("policy.toml"), get("policy.json")
|
||
if inputs:
|
||
rep.check(toml_b == load(os.path.join(root, "policy.toml")), f"{tag}: policy.toml is the policy as given")
|
||
rep.check(blake3(b"wai:pack-policy\x01" + pj).hex() == j["policy_digest"],
|
||
f"{tag}: policy.json hashes to the receipt's policy digest (policy-digest-mismatch)")
|
||
# policy.toml parsed (§3.2–§3.4); the override applied, policy.json's
|
||
# royalty_free_only, which only ever forces it on (§3.2); then §3.6 under that
|
||
# effective policy, below.
|
||
try:
|
||
P = parse_policy_bytes(toml_b)
|
||
except Refused as e:
|
||
rep.check(False, f"{tag}: policy.toml refused ({e.code})")
|
||
return
|
||
given = read_json(pj)
|
||
if isinstance(given, dict) and given.get("royalty_free_only") is True:
|
||
P["royalty_free_only"] = True
|
||
ok = jcs(P).encode() == pj
|
||
rep.check(ok, f"{tag}: policy.json is policy.toml's effective canonical JSON (policy-json-mismatch)")
|
||
if not ok:
|
||
return
|
||
ids = [c["id"] for c in P["component"]] + [c["id"] for c in P["class"]]
|
||
cls = [c["id"].lower() for c in P["class"]]
|
||
ok = all(segment_ok(i) for i in ids) and len(set(cls)) == len(cls) and "classic" not in cls
|
||
rep.check(ok, f"{tag}: component and class ids are path segments, class ids distinct in any case, none `classic` (pack-id)")
|
||
if not ok:
|
||
return
|
||
# §3.6 under the effective policy: royalty_free_only as policy.json states it.
|
||
refused = next((code for code in (rung_refusal(x["capability"], x["role"], P["royalty_free_only"]) for x in P["ladder"]) if code), None)
|
||
rep.check(refused is None, f"{tag}: the effective policy asks for nothing a packager may not emit ({refused})")
|
||
if refused:
|
||
return
|
||
# The receipt's components are the policy's, by id, order and media (§11.3).
|
||
ok = [(c["id"], c["media_class"]) for c in j["components"]] == [(x["id"], x["media"]) for x in P["component"]]
|
||
rep.check(ok, f"{tag}: the receipt's components are the policy's, by id, order and media (policy-component-mismatch)")
|
||
if not ok:
|
||
return
|
||
|
||
# The indexes and the receipt's own refusals (§9.1).
|
||
index_files = []
|
||
for c in j["components"]:
|
||
present = c["index"] in files
|
||
rep.check(present, f"{tag}: {c['index']} present (index-missing)")
|
||
if not present:
|
||
return
|
||
index_files.append(load(os.path.join(pkg, c["index"])))
|
||
try:
|
||
ixs = verify_receipt_v2(r, index_files)
|
||
rep.check(True, f"{tag}: the receipt verifies against its indexes (§9.1)")
|
||
except Refused as e:
|
||
rep.check(False, f"{tag}: the receipt against its indexes ({e.code})")
|
||
return
|
||
seed = bytes.fromhex(load(os.path.join(root, "key.hex")).decode().strip())
|
||
pk, sig = ed25519_from_seed(seed, r["payload"])
|
||
rep.check(pk.hex() == j["signer_pubkey"], f"{tag}: the receipt's signer is the package key")
|
||
rep.check(sig.hex() == j["sig"], f"{tag}: the signature is the package key's over the payload (§11.2)")
|
||
|
||
named = {"LISTING", "policy.toml", "policy.json", "package.receipt.json"} | {c["index"] for c in j["components"]}
|
||
for c, ix in zip(j["components"], ixs):
|
||
try:
|
||
named |= verify_component(rep, tag, root, pkg, files, P, j, c, ix, inputs)
|
||
except (Refused, Malformed, ValueError, OverflowError, UnicodeError, KeyError, IndexError) as x:
|
||
# A package this verifier cannot read further is refused, never a crash.
|
||
rep.check(False, f"{tag} {c['id']}: refused ({type(x).__name__}: {x})")
|
||
return
|
||
|
||
# §9.4: a metered package publishes its measurement claim; an unmetered one, none.
|
||
claim = f"claims/{j['receipt_hash']}.measurement.json"
|
||
if j["joules_micro"]:
|
||
rep.check(claim in files, f"{tag}: a metered package's measurement claim (measurement-claim-missing)")
|
||
rep.check(False, f"{tag}: this verifier does not check a measurement claim (measurement-claim-invalid)")
|
||
named.add(claim)
|
||
else:
|
||
rep.check(not any(p.startswith("claims/") for p in others),
|
||
f"{tag}: an unmetered package publishes no measurement claim (§9.4)")
|
||
unlisted = [p for p in others if p.startswith("objects/") and p not in named]
|
||
rep.check(not unlisted, f"{tag}: object files no entry names: {unlisted} (object-unlisted)")
|
||
catalogs = ("hls/", "dash/", "moq/", "stages/")
|
||
extra = [p for p in others if p.startswith(catalogs) and p not in named]
|
||
rep.check(not extra, f"{tag}: catalogs past the ones the index gives: {extra} (catalog-unexpected)")
|
||
other = [p for p in others if p not in named and not p.startswith(("objects/",) + catalogs)]
|
||
rep.check(not other, f"{tag}: other files: {other} (unexpected-file)")
|
||
|
||
|
||
class Capture(Report):
|
||
"""A report that keeps what fails, in order, and prints nothing."""
|
||
def __init__(self):
|
||
super().__init__()
|
||
self.failed = []
|
||
|
||
def check(self, ok, what):
|
||
self.checked += 1
|
||
if not ok:
|
||
self.failures += 1
|
||
self.failed.append(what)
|
||
|
||
|
||
REASON_AT_END = re.compile(r"\(([a-z0-9][a-z0-9.:-]*)\)$")
|
||
|
||
|
||
def package_verdict(d, name, pkg):
|
||
"""The reason §11.3 gives the package in `pkg` (the first check that fails, by the
|
||
reason it names), or `ok`; the inputs of packs/<name>/ are not consulted."""
|
||
cap = Capture()
|
||
verify_pack(cap, d, name, pkg=pkg, inputs=False)
|
||
if not cap.failed:
|
||
return "ok"
|
||
m = REASON_AT_END.search(cap.failed[0])
|
||
return m.group(1) if m else f"no reason named: {cap.failed[0]}"
|
||
|
||
|
||
def verify_package_mutations(rep, d):
|
||
"""package-mutations/: each case the golden less the files it removes (and the
|
||
directories that leaves with nothing in them), with its overlay and the directories
|
||
it adds that hold nothing (`empty_dirs`) or cannot be read (`unreadable_dirs`, mode 0
|
||
where the platform has modes), written out and verified as a package (§11.3); refused
|
||
with the corpus's reason, or accepted where it says `ok`."""
|
||
m = os.path.join(d, "package-mutations")
|
||
held = tree(m)
|
||
if held is None:
|
||
rep.check(False, "package-mutations/: a symbolic link or an entry that is neither file nor directory")
|
||
return
|
||
pm = json.loads(load(os.path.join(m, "expected.json")))
|
||
golden = os.path.join(d, "packs", pm["pack"], "package")
|
||
used = {"expected.json"}
|
||
with tempfile.TemporaryDirectory() as tmp:
|
||
for c in pm["cases"]:
|
||
pkg = os.path.join(tmp, c["name"])
|
||
shutil.copytree(golden, pkg)
|
||
for p in c["remove"]:
|
||
os.remove(os.path.join(pkg, p))
|
||
for at, dirs, files in os.walk(pkg, topdown=False):
|
||
if at != pkg and not os.listdir(at):
|
||
os.rmdir(at)
|
||
for p in held:
|
||
if p.startswith(c["name"] + "/"):
|
||
used.add(p)
|
||
dst = os.path.join(pkg, p[len(c["name"]) + 1:])
|
||
os.makedirs(os.path.dirname(dst), exist_ok=True)
|
||
shutil.copyfile(os.path.join(m, p), dst)
|
||
for p in c.get("empty_dirs", []) + c.get("unreadable_dirs", []):
|
||
os.makedirs(os.path.join(pkg, p))
|
||
for p in c.get("unreadable_dirs", []):
|
||
os.chmod(os.path.join(pkg, p), 0)
|
||
got = package_verdict(d, pm["pack"], pkg)
|
||
for p in c.get("unreadable_dirs", []):
|
||
os.chmod(os.path.join(pkg, p), 0o755)
|
||
rep.check(got == c["reason"], f"package-mutations {c['name']}: {got}, the corpus says {c['reason']}")
|
||
rest = [p for p in held if p not in used]
|
||
rep.check(not rest, f"package-mutations/: files no case uses: {rest}")
|
||
|
||
|
||
def unreached(files, c):
|
||
"""The floor and catalog files of a component whose verification stopped at an earlier
|
||
refusal: named, so that refusal is not reported again as unexpected files."""
|
||
return {p for p in files if p.startswith((f"floor/{c}/", "hls/", "dash/", "moq/", "stages/"))}
|
||
|
||
|
||
def index_against_policy(P, comp, c, ix):
|
||
"""§11.3 step 6, the index against its component's policy, in its order: its timebase
|
||
and media; its string table (the component's id, the class ids, each capability at its
|
||
first use); its class records (the policy's classes); each entry's role, capability
|
||
and layer a rung's of the component; each piece's kind one a video piece has, and its
|
||
rules, moments and class plan §8.1's. None when it holds, else what fails."""
|
||
if ix["tb"] != (comp["timebase"]["num"], comp["timebase"]["den"]) or MEDIA_CLASSES[ix["media_class"]] != comp["media"]:
|
||
return "the timebase or media class"
|
||
caps = []
|
||
for e in ix["entries"]:
|
||
if e["cap"] not in caps:
|
||
caps.append(e["cap"])
|
||
if ix["strings"] != [c["id"]] + [x["id"] for x in P["class"]] + caps or ix["strings"][0] != ix["component"]:
|
||
return "the string table"
|
||
want = [(x["id"], min(x["max_layer"], 255), int(x["floor_only"]), min(x.get("max_kbps", 0), U32)) for x in P["class"]]
|
||
if [(x["name"], x["max_layer"], x["flags"], x["max_kbps"]) for x in ix["classes"]] != want:
|
||
return "the class records"
|
||
lay = layers(P)
|
||
for i, e in enumerate(ix["entries"]):
|
||
role = ROLES[e["role"]]
|
||
if not any(r["component"] == c["id"] and r["role"] == role and r["capability"] == e["cap"] and lay[r["id"]] == e["layer"]
|
||
for r in P["ladder"]):
|
||
return f"entry {i}: no rung of the component"
|
||
if any(pc["kind"] >= len(KINDS) for pc in ix["pieces"]):
|
||
return "a piece kind a video piece does not have"
|
||
bits, rows = class_plan(P, ix)
|
||
if bits != [(pc["rules"], pc["moments"]) for pc in ix["pieces"]]:
|
||
return "the rules and moments"
|
||
if rows != ix["plan"]:
|
||
return "the class plan"
|
||
return None
|
||
|
||
|
||
def verify_component(rep, tag, root, pkg, files, P, j, c, ix, inputs=True):
|
||
"""§11.3 per component, then (with `inputs`) the source's side. Returns the files it
|
||
names."""
|
||
t = f"{tag} {c['id']}"
|
||
comp = next((x for x in P["component"] if x["id"] == c["id"]), None)
|
||
if comp is None:
|
||
rep.check(False, f"{t}: the receipt's component is not the policy's")
|
||
return set()
|
||
tb = (comp["timebase"]["num"], comp["timebase"]["den"])
|
||
num, den = tb
|
||
pieces, E = ix["pieces"], ix["entries"]
|
||
why = index_against_policy(P, comp, c, ix)
|
||
rep.check(why is None, f"{t}: the index against the policy: {why} (index-policy-mismatch)")
|
||
if why is not None:
|
||
return set(unreached(files, c["id"])) | {f"plan-{c['id']}.txt"} | {f"objects/{e['hash'].hex()}.wai" for e in E}
|
||
starts = [pc["start"] for pc in pieces]
|
||
plan_file = f"plan-{c['id']}.txt"
|
||
rep.check(plan_file in files and load(os.path.join(pkg, plan_file)) == "".join(f"{s}\n" for s in starts).encode(),
|
||
f"{t}: {plan_file} is the index's plan (plan-mismatch)")
|
||
rep.check(ix["plan_digest"].hex() == plan_digest(starts), f"{t}: the index's plan_digest is its starts' (§4.2)")
|
||
if inputs:
|
||
# Of the golden, not a rule a package is held to: a live window is a package too
|
||
# (§6.1, §9.2).
|
||
rep.check(ix["first_piece"] == 0 and ix["first_entry"] == 0 and not any(ix["prev"]),
|
||
f"{t}: the golden is on-demand content, one window (§6.1)")
|
||
named = {plan_file}
|
||
|
||
# Every entry's object (§6.3), the decode-equivalent prefixes (§6.5).
|
||
objs, mans, decoded = {}, {}, {}
|
||
for i, e in enumerate(E):
|
||
path = f"objects/{e['hash'].hex()}.wai"
|
||
named.add(path)
|
||
if path not in files:
|
||
rep.check(False, f"{t}: entry {i}: {path} (object-missing)")
|
||
continue
|
||
objs[i] = load(os.path.join(pkg, path))
|
||
try:
|
||
mans[i] = object_rules(ix, i, objs[i])
|
||
rep.check(True, f"{t}: entry {i}: the object rules (§6.3)")
|
||
except Refused as x:
|
||
rep.check(False, f"{t}: entry {i}: the object rules (§6.3) ({x.code})")
|
||
if len(mans) != len(E):
|
||
return named | unreached(files, c['id'])
|
||
size = None
|
||
for i, e in enumerate(E):
|
||
if e["role"] != BASE:
|
||
continue
|
||
ml = e["man_len"]
|
||
try:
|
||
w = IPV.parse_wiv1(objs[i][12 + ml:], 0)
|
||
if e["hash"] not in decoded:
|
||
decoded[e["hash"]] = (w, IPV.decode_wiv1_k0(w))
|
||
except IPV.Refused as x:
|
||
rep.check(False, f"{t}: entry {i}: the WIV1 payload is refused ({x})")
|
||
return named | unreached(files, c['id'])
|
||
size = size or (w["w"], w["h"])
|
||
# §5.2: the reference packager's base manifest, as SPEC §3 orders it.
|
||
want = {"wai": "1.0", "media": comp["media"], "intent": "replicate",
|
||
"model_requirement": {"capability": e["cap"]}, "conditioning": {"kind": e["cap"].split(".")[-1]},
|
||
"target": {"frames": pieces[owners(ix)[i]]["duration"], "h": w["h"], "w": w["w"]}}
|
||
rep.check(objs[i][8:8 + ml] == json.dumps(want, separators=(",", ":")).encode(),
|
||
f"{t}: entry {i}: the base's manifest is §5.2's")
|
||
for i, e in enumerate(E):
|
||
if e["tier"] != 2:
|
||
continue
|
||
if e["role"] != BASE:
|
||
rep.check(False, f"{t}: entry {i}: a refinement's prefix, which this verifier does not decode")
|
||
continue
|
||
rep.check(clip_digest(decoded[e["hash"]][1]) == e["prefix"],
|
||
f"{t}: entry {i}: the prefix decodes to its prefix_digest (prefix-digest)")
|
||
|
||
# The floor objects (§7.2) and the CMAF files their temporal units give (§7.6).
|
||
rung = next((r for r in P["ladder"] if r["component"] == c["id"] and r["role"] == "floor"), None)
|
||
sup = P["floor"].get("supplied_listing")
|
||
settings = blake3(b"wai:render-settings\x01" + jcs({"source": "supplied", "supplied_listing": sup}).encode()).hex() \
|
||
if sup else None
|
||
seq = seq_obu = None
|
||
units_of, frags = [], []
|
||
own = owners(ix)
|
||
for k, pc in enumerate(pieces):
|
||
mine = [i for i in range(len(E)) if own[i] == k]
|
||
bases = [i for i in mine if E[i]["role"] == BASE]
|
||
fl = [i for i in mine if E[i]["role"] == FLOOR]
|
||
rep.check(len(bases) == 1 and rung is not None and len(fl) == 1 and E[fl[0]]["cap"] == rung["capability"],
|
||
f"{t}: piece {k}: one base, and one floor object of the floor rung's capability (§5, §7.2) (floor-object-mismatch)")
|
||
if len(bases) != 1 or len(fl) != 1:
|
||
return named | unreached(files, c['id'])
|
||
base, i = bases[0], fl[0]
|
||
df = mans[i]["derived_from"]
|
||
rep.check(df["motif"] == E[base]["hash"].hex() and df["motif_capability"] == E[base]["cap"],
|
||
f"{t}: piece {k}: the floor presents its piece's base (floor-motif-mismatch)")
|
||
rep.check(sup is not None and df["renderer"] == f"supplied@{sup}" and df["settings"] == settings,
|
||
f"{t}: piece {k}: a supplied floor's renderer and settings (§7.2) (floor-object-mismatch)")
|
||
fp = floor_payload(objs[i][12 + E[i]["man_len"]:])
|
||
if fp is None:
|
||
rep.check(False, f"{t}: piece {k}: the floor payload is not §7.2's framing (floor-object-mismatch)")
|
||
return named | unreached(files, c['id'])
|
||
rep.check(len(fp[5]) == pc["duration"], f"{t}: piece {k}: one temporal unit per frame (floor-object-mismatch)")
|
||
try:
|
||
units = [obus(u) for u in fp[5]]
|
||
if any(not o or o[0][0] != OBU_TD or sum(x[0] == OBU_TD for x in o) != 1 or unit_frame(o) is None for o in units):
|
||
raise Malformed("a unit that is not one temporal unit holding a frame")
|
||
if seq is None:
|
||
seq_obu = next((whole for typ, whole, _ in units[0] if typ == OBU_SEQ), None) if units else None
|
||
if seq_obu is None:
|
||
raise Malformed("the first unit holds no sequence header")
|
||
seq = sequence_header(obus(seq_obu)[0][2])
|
||
# §7.3 against the package: every sequence header the first's bytes, a shown key
|
||
# frame with one.
|
||
for o in units:
|
||
if any(typ == OBU_SEQ and whole != seq_obu for typ, whole, _ in o):
|
||
raise Malformed("a sequence header other than the first")
|
||
if shown_key(o, seq) and not any(typ == OBU_SEQ for typ, _, _ in o):
|
||
raise Malformed("a shown key frame without a sequence header")
|
||
except Malformed as x:
|
||
rep.check(False, f"{t}: piece {k}: the floor payload ({x}) (floor-av1-malformed)")
|
||
return named | unreached(files, c['id'])
|
||
rep.check(fp[:5] == (pc["duration"], seq["max_h"], seq["max_w"], num, den),
|
||
f"{t}: piece {k}: the floor payload's n, h, w, fps_num and fps_den (§7.2) (floor-object-mismatch)")
|
||
rep.check(mans[i].get("target") == {"frames": pc["duration"], "h": seq["max_h"], "w": seq["max_w"]},
|
||
f"{t}: piece {k}: the floor's target is its piece's frames and its size (§5.2, §7.2) (floor-object-mismatch)")
|
||
keys = [shown_key(o, seq) for o in units]
|
||
ok = bool(keys) and keys[0] and (P["floor"]["extra_keyframes"] or not any(keys[1:]))
|
||
rep.check(ok, f"{t}: piece {k}: it opens on a shown key frame, with no other unless the policy allows (floor-keyframe-mismatch)")
|
||
if not ok:
|
||
return named | unreached(files, c['id'])
|
||
units_of.append(fp[5])
|
||
frag = fragment(ix["first_piece"] + k, pc["start"], den, [(without_delimiters(o), shown_key(o, seq)) for o in units])
|
||
frags.append((hashlib.sha256(frag).hexdigest() + ".m4s", frag))
|
||
init = init_mp4(num, seq["max_w"], seq["max_h"], av1c(seq, seq_obu))
|
||
for p, want in [("init.mp4", init)] + frags:
|
||
path = f"floor/{c['id']}/{p}"
|
||
named.add(path)
|
||
rep.check(path in files and load(os.path.join(pkg, path)) == want,
|
||
f"{t}: {path} is the one the floor's temporal units give (floor-cmaf-mismatch)")
|
||
|
||
# The catalogs (§8.3–§8.8).
|
||
try:
|
||
cats = render_catalogs(P, ix, c["id"], (av1_codecs(seq), seq["max_w"], seq["max_h"], frags), size,
|
||
j["policy_digest"])
|
||
except (ValueError, OverflowError) as x:
|
||
# A time or count past the canonical range (a start past 2^53 − 1): no catalog can
|
||
# be written for this index (§11.3).
|
||
rep.check(False, f"{t}: no catalog can be written for the index ({x}) (catalog-mismatch)")
|
||
return named | unreached(files, c['id'])
|
||
for path in sorted(cats):
|
||
named.add(path)
|
||
rep.check(path in files and load(os.path.join(pkg, path)) == cats[path],
|
||
f"{t}: {path} is the one the index, the objects and the floor give (catalog-mismatch)")
|
||
if inputs:
|
||
verify_sources(rep, t, root, P, comp, ix, decoded, units_of)
|
||
return named
|
||
|
||
|
||
def verify_sources(rep, t, root, P, comp, ix, decoded, units_of):
|
||
"""What only the source decides: the pieces (§4.3, §4.6) and their rules, moments and
|
||
class plan (§8.1), each base's sse (§6.6) and step (§5.6), and the supplied floor (§7.3)."""
|
||
num, den = comp["timebase"]["num"], comp["timebase"]["den"]
|
||
source = comp.get("source", "")
|
||
name = source[:-len(".y4m")]
|
||
if not source.endswith(".y4m") or fixture_spans(name) is None:
|
||
rep.check(False, f"{t}: the source {source!r} is no fixture this verifier generates (pack-source-missing)")
|
||
return
|
||
w, h, rate, _, frames = read_y4m(fixture(name))
|
||
rep.check(rate == (num, den), f"{t}: the source's frame rate is its timebase (pack-source-rate)")
|
||
pieces, _ = segment(frames, w, h, seg_params(P, (num, den)))
|
||
got = [(pc["start"], pc["len"], pc["flags"], KINDS.index(classify(pc, P["classify"])[0])) for pc in pieces]
|
||
rep.check(got == [(pc["start"], pc["duration"], pc["flags"], pc["kind"]) for pc in ix["pieces"]],
|
||
f"{t}: every piece's start, duration, flags and kind are the segmenter's (§4.3, §4.6)")
|
||
bits, rows = class_plan(P, ix)
|
||
rep.check(bits == [(pc["rules"], pc["moments"]) for pc in ix["pieces"]],
|
||
f"{t}: every piece's rules and moments (§8.1)")
|
||
rep.check(rows == ix["plan"], f"{t}: the class plan is §8.1's")
|
||
rung = next(r for r in P["ladder"] if r["component"] == comp["id"] and r["role"] == "base")
|
||
p = rung["params"]
|
||
own, cache, chosen = owners(ix), {}, set()
|
||
for i, e in enumerate(ix["entries"]):
|
||
if e["role"] != BASE:
|
||
continue
|
||
pc = ix["pieces"][own[i]]
|
||
src = frames[pc["start"]:pc["start"] + pc["duration"]]
|
||
wv, dec = decoded[e["hash"]]
|
||
sse = sum((a - b) ** 2 for s, f in zip(src, dec) for a, b in zip(s, f))
|
||
rep.check(len(dec) == len(src) and sse == e["sse"], f"{t}: entry {i}: sse against the source (§6.6)")
|
||
n = len(src)
|
||
rep.check((wv["block"], wv["mv_precision"]) == ((p["block"], p["mv_precision"]) if n > 1 else (1, 1)),
|
||
f"{t}: entry {i}: the payload's block and precision are the rung's (§5.5)")
|
||
key = hashlib.sha256(b"".join(src)).digest()
|
||
|
||
def sse_of(q, key=key, src=src):
|
||
if (key, q) not in cache:
|
||
cache[key, q] = closed_loop(src, h, w, p["block"], p["search"], p["mv_precision"], q)
|
||
return sse_px_milli(cache[key, q][1], h, w, len(src))
|
||
q = choose_q(sse_of, p["q_candidates"], p["max_sse_px_milli"])
|
||
rep.check(wv["q"] == q, f"{t}: entry {i}: the step is §5.6's choice ({wv['q']}, the rule {q})")
|
||
rep.check([bytes(f) for f in cache[key, q][0]] == dec,
|
||
f"{t}: entry {i}: the payload decodes to the encoder's reconstruction at that step (§5.5)")
|
||
if (e["hash"], key) not in chosen:
|
||
chosen.add((e["hash"], key))
|
||
bad = encoder_choices(wv, p, src, dec)
|
||
rep.check(not bad, f"{t}: entry {i}: every vector, coded residual and the table are the encoder's (§5.5)"
|
||
+ (f": {bad[0]}" if bad else ""))
|
||
|
||
# The supplied floor (§7.3): its listing, its temporal units and its key frames.
|
||
sup = os.path.join(root, "floor")
|
||
names = tree(sup)
|
||
rep.check(hashlib.sha256(listing(sup, names)).hexdigest() == P["floor"].get("supplied_listing"),
|
||
f"{t}: the supplied floor's listing hashes to floor.supplied_listing (floor-listing-mismatch)")
|
||
stream = f"{comp['id']}.obu"
|
||
if stream not in names:
|
||
rep.check(False, f"{t}: no {stream} in the supplied floor (floor-stream-missing)")
|
||
return
|
||
try:
|
||
units = temporal_units(load(os.path.join(sup, stream)))
|
||
if not units or not any(typ == OBU_SEQ for typ, _, _ in units[0][1]):
|
||
raise Malformed("the first unit holds no sequence header")
|
||
first = next(whole for typ, whole, _ in units[0][1] if typ == OBU_SEQ)
|
||
seq = sequence_header(obus(first)[0][2])
|
||
for u, o in units:
|
||
if unit_frame(o) is None:
|
||
raise Malformed("a unit holding no frame")
|
||
if any(typ == OBU_SEQ and whole != first for typ, whole, _ in o):
|
||
raise Malformed("a sequence header other than the first")
|
||
if shown_key(o, seq) and not any(typ == OBU_SEQ for typ, _, _ in o):
|
||
raise Malformed("a shown key frame without a sequence header")
|
||
rep.check(True, f"{t}: the supplied stream splits into temporal units, each a frame (floor-av1-malformed)")
|
||
except Malformed as x:
|
||
rep.check(False, f"{t}: the supplied stream ({x}) (floor-av1-malformed)")
|
||
return
|
||
rep.check(len(units) == len(frames), f"{t}: one temporal unit per source frame (floor-frame-count)")
|
||
keys = [f for f, (_, o) in enumerate(units) if shown_key(o, seq)]
|
||
starts = [pc["start"] for pc in ix["pieces"]]
|
||
ok = set(starts) <= set(keys) and (P["floor"]["extra_keyframes"] or keys == starts)
|
||
rep.check(ok, f"{t}: shown key frames at the piece starts {starts}, and only there: {keys} (floor-keyframe-mismatch)")
|
||
rep.check([[u for u, _ in units[pc["start"]:pc["start"] + pc["duration"]]] for pc in ix["pieces"]] == units_of,
|
||
f"{t}: each floor object holds its piece's temporal units of the supplied stream (§7.2)")
|
||
|
||
|
||
def mutation_verdict(m, c, used):
|
||
"""A case of mutations/: the index's verdict (§6.2, §6.3), then each entry's object's
|
||
(§6.3), or the receipt's (§9.1)."""
|
||
def get(p):
|
||
used.add(p)
|
||
return load(os.path.join(m, p))
|
||
try:
|
||
if c["kind"] in ("index", "objects"):
|
||
ix = parse_index(get(c["index"]))
|
||
index_rules(ix)
|
||
if c["kind"] == "objects":
|
||
for i, e in enumerate(ix["entries"]):
|
||
p = os.path.join(c["objects"], e["hash"].hex() + ".wai")
|
||
if not os.path.isfile(os.path.join(m, p)):
|
||
return "object-missing"
|
||
object_rules(ix, i, get(p))
|
||
return "ok"
|
||
r = read_receipt(get(c["receipt"]))
|
||
verify_receipt_v2(r, [get(p) for p in c["indexes"]])
|
||
return "ok"
|
||
except Refused as e:
|
||
return e.code
|
||
|
||
|
||
def verify_v1_receipt(rep, name, b, want_hash, refused=False):
|
||
"""§9.3: a version-1 receipt read, its payload rebuilt, its hash, counts, segment map
|
||
root and signature; with `refused`, everything but a signature that every verifier
|
||
refuses (SPEC §7 *Signatures*)."""
|
||
try:
|
||
r = read_receipt(b)
|
||
except Refused as e:
|
||
rep.check(False, f"{name}: refused ({e.code})")
|
||
return
|
||
j = r["json"]
|
||
rep.check(r["version"] == 1, f"{name}: version 1")
|
||
rep.check(j["receipt_hash"] == want_hash, f"{name}: receipt_hash is the corpus's")
|
||
rep.check(blake3(RECEIPT_ID + r["payload"] + bytes.fromhex(j["sig"])).hex() == want_hash,
|
||
f"{name}: receipt_hash is BLAKE3 over the payload and signature")
|
||
segs = j["segments"]
|
||
rep.check(merkle_root([v1_leaf(s) for s in segs]).hex() == j["segment_map_root"],
|
||
f"{name}: segment_map_root is the Merkle root of the segment leaves")
|
||
first = {}
|
||
for s in segs:
|
||
first.setdefault(s["content_hash"], s["byte_len"])
|
||
rep.check([s["index"] for s in segs] == list(range(len(segs))), f"{name}: segment indices 0..n-1")
|
||
rep.check((j["total_segments"], j["unique_segments"], j["total_bytes"], j["stored_bytes"], j["work_segment_ops"])
|
||
== (len(segs), len(first), sum(s["byte_len"] for s in segs), sum(first.values()), len(segs)),
|
||
f"{name}: the segment counts")
|
||
rep.check(ed25519_verifies(bytes.fromhex(j["signer_pubkey"]), bytes.fromhex(j["sig"]), r["payload"]) != refused,
|
||
f"{name}: the signature " + ("is refused" if refused else "verifies"))
|
||
|
||
|
||
def verify(d):
|
||
rep = Report()
|
||
pol = json.loads(load(os.path.join(d, "policy", "expected.json")))
|
||
for c in pol["cases"]:
|
||
P = parse_policy_bytes(load(os.path.join(d, "policy", c["file"])))
|
||
if c.get("overrides", {}).get("royalty_free_only") is True:
|
||
P["royalty_free_only"] = True
|
||
rep.check(jcs(P) == c["canonical"], f"policy/{c['file']}: canonical JSON")
|
||
rep.check(digest(P) == c["digest"], f"policy/{c['file']}: digest")
|
||
names = sorted(n for n in os.listdir(os.path.join(d, "policy")) if n.endswith(".toml"))
|
||
rep.check(sorted({c["file"] for c in pol["cases"]}) == names, "policy/: every policy is a case")
|
||
for n in names:
|
||
try:
|
||
admit(load(os.path.join(d, "policy", n)))
|
||
got = "ok"
|
||
except Refused as r:
|
||
got = r.code
|
||
rep.check(got == "ok", f"policy/{n}: a packager accepts it ({got})")
|
||
for a, b in pol["equal"]:
|
||
da, db = (digest(parse_policy_bytes(load(os.path.join(d, "policy", f)))) for f in (a, b))
|
||
rep.check(da == db, f"policy/{a} and {b}: one policy, one digest")
|
||
|
||
ref = json.loads(load(os.path.join(d, "refusals", "expected.json")))
|
||
listed = set()
|
||
for c in ref["cases"]:
|
||
listed.add(c["file"])
|
||
b = load(os.path.join(d, "refusals", c["file"]))
|
||
if c["file"].startswith("policy/"):
|
||
try:
|
||
admit(b)
|
||
got = "ok"
|
||
except Refused as r:
|
||
got = r.code
|
||
else:
|
||
got = source_verdict(c["file"], b)
|
||
rep.check(got == c["reason"] and got != "ok", f"refusals/{c['file']}: {got}, the corpus says {c['reason']}")
|
||
for sub in ("policy", "source"):
|
||
for n in os.listdir(os.path.join(d, "refusals", sub)):
|
||
rep.check(f"{sub}/{n}" in listed, f"refusals/{sub}/{n} is a case")
|
||
|
||
conv = json.loads(load(os.path.join(d, "conversions.json")))
|
||
for c in conv["ms_to_units"]:
|
||
rep.check(units_from_ms(c["ms"], c["num"], c["den"]) == c["units"], f"ms_to_units {c}")
|
||
for c in conv["align"]:
|
||
rep.check(align(c["start"], c["lead"], c["component"]) == c["units"], f"align {c}")
|
||
for c in conv["y4m_rgb"]:
|
||
_, _, _, _, frames = read_y4m(load(os.path.join(d, c["file"])))
|
||
rep.check([hashlib.sha256(f).hexdigest() for f in frames] == c["rgb_sha256"], f"{c['file']}: RGB8 frames")
|
||
|
||
sc = json.loads(load(os.path.join(d, "scenecut", "expected.json")))
|
||
P = parse_policy_bytes(load(os.path.join(d, "scenecut", sc["policy"])))
|
||
comp = next(c for c in P["component"] if c["id"] == sc["component"])
|
||
tb = (comp["timebase"]["num"], comp["timebase"]["den"])
|
||
s = P["segmentation"]
|
||
p = {"min": units_from_ms(s["min_ms"], *tb), "target": units_from_ms(s["target_ms"], *tb),
|
||
"max": units_from_ms(s["max_ms"], *tb), "cut_abs": s["cut_abs_permille"], "cut_rel": s["cut_rel_permille"],
|
||
"window": s["cut_window"], "lookahead": s["lookahead_frames"]}
|
||
cut = {}
|
||
for fx in sc["fixtures"]:
|
||
b = fixture(fx["name"])
|
||
rep.check(hashlib.sha256(b).hexdigest() == fx["sha256"], f"fixture {fx['name']}: SHA-256")
|
||
w, h, rate, _, frames = read_y4m(b)
|
||
rep.check(len(frames) == fx["frames"] and rate == (25, 1), f"fixture {fx['name']}: frames and rate")
|
||
pieces, scores = segment(frames, w, h, p)
|
||
rep.check(scores == fx["scores"], f"scenecut {fx['name']}: scores")
|
||
got = []
|
||
for pc in pieces:
|
||
kind, mad, chg = classify(pc, P["classify"])
|
||
got.append({"start": pc["start"], "len": pc["len"], "flags": pc["flags"], "kind": kind,
|
||
"mad_milli": mad, "changed_permille": chg, "occupancy": pc["occupancy"]})
|
||
rep.check(got == fx["pieces"], f"scenecut {fx['name']}: pieces")
|
||
rep.check(plan_digest([x["start"] for x in got]) == fx["plan_digest"], f"scenecut {fx['name']}: plan digest")
|
||
cut[fx["name"]] = (frames, got, w, h)
|
||
|
||
enc = json.loads(load(os.path.join(d, "encode", "expected.json")))
|
||
want = []
|
||
for fx in sc["fixtures"]:
|
||
for i, pc in enumerate(cut[fx["name"]][1]):
|
||
for s in ("a", "b"):
|
||
want.append((f"{fx['name']}-p{i}-{s}.wiv1", fx["name"], pc["start"], min(pc["len"], ENCODE_FRAMES)))
|
||
rep.check([(v["file"], v["fixture"], v["first"], v["frames"]) for v in enc["vectors"]] == want,
|
||
"encode: one vector per piece of each fixture and parameter set, at the piece's first frames")
|
||
names = sorted(n for n in os.listdir(os.path.join(d, "encode")) if n.endswith(".wiv1"))
|
||
rep.check(names == sorted(v["file"] for v in enc["vectors"]), "encode/: every payload is a vector")
|
||
for v in enc["vectors"]:
|
||
b = load(os.path.join(d, "encode", v["file"]))
|
||
rep.check(blake3(b).hex() == v["blake3"], f"encode/{v['file']}: BLAKE3")
|
||
try:
|
||
w = IPV.parse_wiv1(b, 0)
|
||
frames = IPV.decode_wiv1_k0(w)
|
||
except IPV.Refused as e:
|
||
rep.check(False, f"encode/{v['file']}: refused {e}")
|
||
continue
|
||
p = v["params"]
|
||
head = (w["block"], w["mv_precision"], w["q"], w["n_frames"])
|
||
rep.check(head == ((p["block"], p["mv_precision"], p["q"], v["frames"]) if v["frames"] > 1 else (1, 1, p["q"], 1)),
|
||
f"encode/{v['file']}: the header's block, precision, step and frames")
|
||
rep.check([hashlib.sha256(f).hexdigest() for f in frames] == v["frame_sha256"], f"encode/{v['file']}: decoded frames")
|
||
src = cut[v["fixture"]][0][v["first"]:v["first"] + v["frames"]]
|
||
sse = sum((a - b) ** 2 for s, f in zip(src, frames) for a, b in zip(s, f))
|
||
rep.check(sse == v["sse"], f"encode/{v['file']}: SSE against the source")
|
||
for why in encoder_choices(w, p, src, frames):
|
||
rep.check(False, f"encode/{v['file']}: {why}")
|
||
rep.check(True, f"encode/{v['file']}: the encoder's choices")
|
||
|
||
qc = json.loads(load(os.path.join(d, "qchoice", "expected.json")))
|
||
cache = {}
|
||
for s in qc["sets"]:
|
||
p = s["params"]
|
||
for pc in s["pieces"]:
|
||
frames, _, w, h = cut[pc["fixture"]]
|
||
src = frames[pc["first"]:pc["first"] + pc["frames"]]
|
||
|
||
def sse_of(q, pc=pc, src=src, p=p, w=w, h=h):
|
||
key = (pc["fixture"], pc["first"], pc["frames"], p["block"], p["search"], p["mv_precision"], q)
|
||
if key not in cache:
|
||
_, sse = closed_loop(src, h, w, p["block"], p["search"], p["mv_precision"], q)
|
||
cache[key] = (sse, sse_px_milli(sse, h, w, len(src)))
|
||
return cache[key]
|
||
got = [{"q": q, "sse": sse_of(q)[0], "sse_px_milli": sse_of(q)[1]} for q in p["q_candidates"]]
|
||
rep.check(got == pc["candidates"], f"qchoice {pc['fixture']} piece {pc['piece']}: each candidate's SSE")
|
||
rep.check(choose_q(lambda q: sse_of(q)[1], p["q_candidates"], p["max_sse_px_milli"]) == pc["q"],
|
||
f"qchoice {pc['fixture']} piece {pc['piece']} bound {p['max_sse_px_milli']}: the step chosen")
|
||
|
||
for name in sorted(os.listdir(os.path.join(d, "packs"))):
|
||
verify_pack(rep, d, name)
|
||
|
||
m = os.path.join(d, "mutations")
|
||
used = {"expected.json"}
|
||
for c in json.loads(load(os.path.join(m, "expected.json")))["cases"]:
|
||
got = mutation_verdict(m, c, used)
|
||
rep.check(got == c["reason"], f"mutations {c['name']}: {got}, the corpus says {c['reason']}")
|
||
rest = [p for p in tree(m) if p not in used]
|
||
rep.check(not rest, f"mutations/: files no case uses: {rest}")
|
||
|
||
rc = json.loads(load(os.path.join(d, "receipts", "expected.json")))
|
||
for c in rc["cases"]:
|
||
verify_v1_receipt(rep, f"receipts/{c['file']}", load(os.path.join(d, "receipts", c["file"])), c["receipt_hash"],
|
||
c.get("signature") == "refused")
|
||
rep.check(tree(os.path.join(d, "receipts")) == sorted([c["file"] for c in rc["cases"]] + ["expected.json"]),
|
||
"receipts/: every receipt is a case")
|
||
|
||
# catalogs/: MoQ catalogs of indexes with refinements on more than one deadline (§8.4).
|
||
cc = json.loads(load(os.path.join(d, "catalogs", "expected.json")))
|
||
for c in cc["cases"]:
|
||
ix = parse_index(load(os.path.join(d, c["index"])))
|
||
index_rules(ix)
|
||
f = c["floor"]
|
||
got = render_moq(ix["component"], ix["entries"], c["layer_lag_ms"], c["default_deadline"], (f["codec"], f["w"], f["h"]))
|
||
rep.check(got == c["moq"].encode(), f"{c['index']}: the MoQ catalog §8.4 gives")
|
||
names = {t["name"] for t in json.loads(got)["tracks"]}
|
||
rep.check(all(x in names for t in json.loads(got)["tracks"] for x in t.get("depends", [])),
|
||
f"{c['index']}: no dependency names a track the catalog does not hold")
|
||
rep.check(tree(os.path.join(d, "catalogs")) == sorted([c["index"][len("catalogs/"):] for c in cc["cases"]] + ["expected.json"]),
|
||
"catalogs/: every index is a case")
|
||
verify_package_mutations(rep, d)
|
||
return rep
|
||
|
||
|
||
def main(argv):
|
||
if len(argv) != 2:
|
||
print(__doc__)
|
||
return 2
|
||
rep = verify(argv[1])
|
||
print(f"pack_verify: {rep.checked - rep.failures}/{rep.checked} checks hold")
|
||
return 0 if rep.failures == 0 else 1
|
||
|
||
|
||
if __name__ == "__main__":
|
||
sys.exit(main(sys.argv))
|