nx_h264_cabac_gate.nx source
↩ module page · 93 lines · 4423 B
1// nx_h264_cabac_gate.nx -- REFEREE for the H.264 CABAC arithmetic engine (STEP 1 core).
2// Three known-answer checks:
3// (1) tables: rangeTabLps/transIdxLps/transIdxMps parse to 256/64/64 (fail-closed loader).
4// (2) engine KAT: the arithmetic engine is byte-identical to the GATED nx_hevc_cabac engine,
5// so on the SAME self-test (buf[i]=(i*37+11)&0xff, ctxInit initValue=154 @ QP26) it MUST
6// reproduce the exact captured answer: init range=510 offset=22; ctx0 pState=0 mps=1;
7// 16 bypass bins = 0x0B3B; 16 decision bins = 0x0708; terminate=0; range stays in [256,510].
8// (3) (m,n) context init: two hand-computed vectors verify the H.264 clause-9.3.1.1 formula
9// (m=20,n=-15,QP26 -> pre=17 -> pState=46,mps=0) and (m=20,n=60,QP40 -> pre=110 -> pState=46,mps=1).
10// stdout + knowledge/status/h264_cabac_gate.log. Exit 0/1. Sovereign. license_tier: ORIGINAL
11import "nx_syscalls.nx"
12import "nx_h264_cabac.nx"
13
14func gp(logfd: i64, s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); if logfd > 0 { sys_write(logfd, s, n) } return 0 }
15func gn(logfd: i64, v: i64) -> i64 {
16 let bb: *u8 = sys_mmap(28); var m: i64 = v
17 if m < 0 { sys_write(1, "-\x00" as *u8, 1); if logfd > 0 { sys_write(logfd, "-\x00" as *u8, 1) } m = 0 - m }
18 let t: *u8 = sys_mmap(28); var k: i64 = 0
19 if m == 0 { t[0] = 48 as u8; k = 1 }
20 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
21 var i: i64 = 0
22 while i < k { bb[i] = t[k - 1 - i]; i = i + 1 }
23 sys_write(1, bb, k); if logfd > 0 { sys_write(logfd, bb, k) }
24 return 0
25}
26
27// engine KAT: reproduce nx_hevc_cabac's self-test; return 1 iff byte-identical to captured answer.
28func kat_engine(rlps: *i64, tlps: *i64, tmps: *i64) -> i64 {
29 let buf: *u8 = sys_mmap(64)
30 var bi: i64 = 0
31 while bi < 64 { buf[bi] = ((bi * 37 + 11) & 0xff) as u8; bi = bi + 1 }
32 let cab: *i64 = sys_mmap(8 * 8) as *i64
33 cab_init(cab, buf, 0, 64)
34 var ok: i64 = 1
35 if cab[0] != 510 { ok = 0 } // init range
36 if cab[1] != 22 { ok = 0 } // init offset
37 let ctx: *i64 = sys_mmap(8 * 4) as *i64
38 cab_ctx_init_iv(ctx, 0, 154, 26)
39 if ctx[0] != 0 { ok = 0 } // pStateIdx
40 if ctx[1] != 1 { ok = 0 } // valMps
41 var by: i64 = 0
42 var t: i64 = 0
43 while t < 16 { by = (by << 1) | cab_bypass(cab); t = t + 1 }
44 if by != 2875 { ok = 0 } // 0x0B3B captured bypass bins
45 var dc: i64 = 0
46 t = 0
47 while t < 16 {
48 let b: i64 = cab_decision(cab, ctx, 0, rlps, tlps, tmps)
49 dc = (dc << 1) | b
50 if cab[0] < 256 { ok = 0 } // renorm invariant lower
51 if cab[0] > 510 { ok = 0 } // renorm invariant upper
52 t = t + 1
53 }
54 if dc != 1800 { ok = 0 } // 0x0708 captured decision bins
55 if cab_terminate(cab) != 0 { ok = 0 } // captured terminate bin
56 return ok
57}
58
59// (m,n) context-init formula check with two hand-computed vectors.
60func kat_ctxinit_mn() -> i64 {
61 let ctx: *i64 = sys_mmap(8 * 4) as *i64
62 var ok: i64 = 1
63 cab_ctx_init_mn(ctx, 0, 20, 0 - 15, 26) // pre=17 -> pState=46 mps=0
64 if ctx[0] != 46 { ok = 0 }
65 if ctx[1] != 0 { ok = 0 }
66 cab_ctx_init_mn(ctx, 0, 20, 60, 40) // pre=110 -> pState=46 mps=1
67 if ctx[0] != 46 { ok = 0 }
68 if ctx[1] != 1 { ok = 0 }
69 return ok
70}
71
72func main() -> i64 {
73 let logfd: i64 = sys_openat_append("knowledge/status/h264_cabac_gate.log\x00" as *u8, 0x1a4)
74 gp(logfd, "H264-CABAC-GATE (STEP 1 arithmetic engine)\n\x00" as *u8)
75 let rlps: *i64 = sys_mmap(8 * 300) as *i64
76 let tlps: *i64 = sys_mmap(8 * 80) as *i64
77 let tmps: *i64 = sys_mmap(8 * 80) as *i64
78 let tabok: i64 = cab_load_tables(rlps, tlps, tmps)
79 let st: i64 = kat_engine(rlps, tlps, tmps)
80 let mn: i64 = kat_ctxinit_mn()
81 gp(logfd, " tables=\x00" as *u8); gn(logfd, tabok); gp(logfd, " engine_kat=\x00" as *u8); gn(logfd, st)
82 gp(logfd, " ctxinit_mn=\x00" as *u8); gn(logfd, mn); gp(logfd, "\n\x00" as *u8)
83 if tabok == 1 { if st == 1 { if mn == 1 {
84 gp(logfd, "H264-CABAC-GATE result=ALL-PASS verdict=GREEN\n\x00" as *u8)
85 if logfd > 0 { sys_close(logfd) }
86 sys_exit(0)
87 return 0
88 } } }
89 gp(logfd, "H264-CABAC-GATE result=FAIL verdict=RED\n\x00" as *u8)
90 if logfd > 0 { sys_close(logfd) }
91 sys_exit(1)
92 return 1
93}