nx_h264_intra_gate.nx source
↩ module page · 112 lines · 4546 B
1// nx_h264_intra_gate.nx -- REFEREE for Intra_4x4 prediction + the FULL
2// reconstruction math chain. Hand-computed exact vectors:
3// Vertical: top=[10,20,30,40] -> every row [10,20,30,40]
4// Horizontal:left=[50,60,70,80] -> row y all = left[y]
5// DC both: top sum100 + left sum260 -> (360+4)>>3 = 45
6// DC top: (100+2)>>2 = 25 ; DC neither = 128
7// CAPSTONE: pred=DC45 + residual(level16 DC -> dequant160 -> idct = 3)
8// -> clip(45+3) = 48 for all 16 samples. This is the WHOLE
9// reconstruction math chain minus the entropy decode.
10// Every value PRINTED. stdout + knowledge/status/h264_intra_gate.log. Exit 0/1.
11// Sovereign: nx_syscalls + nx_h264_intra + nx_h264_dequant + nx_h264_idct.
12// license_tier: ORIGINAL
13import "nx_syscalls.nx"
14import "nx_h264_intra.nx"
15import "nx_h264_dequant.nx"
16import "nx_h264_idct.nx"
17
18func gp(logfd: i64, s: *u8) -> i64 {
19 var n: i64 = 0
20 while s[n] != (0 as u8) { n = n + 1 }
21 sys_write(1, s, n)
22 if logfd > 0 { sys_write(logfd, s, n) }
23 return 0
24}
25func gn(logfd: i64, v: i64) -> i64 {
26 let bb: *u8 = sys_mmap(28)
27 var m: i64 = v
28 if m < 0 { sys_write(1, "-\x00" as *u8, 1); if logfd > 0 { sys_write(logfd, "-\x00" as *u8, 1) } m = 0 - m }
29 let t: *u8 = sys_mmap(28)
30 var k: i64 = 0
31 if m == 0 { t[0] = 48 as u8; k = 1 }
32 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
33 var i: i64 = 0
34 while i < k { bb[i] = t[k - 1 - i]; i = i + 1 }
35 sys_write(1, bb, k)
36 if logfd > 0 { sys_write(logfd, bb, k) }
37 return 0
38}
39func zero16(d: *i64) -> i64 { var i: i64 = 0; while i < 16 { d[i] = 0; i = i + 1 } return 0 }
40
41func main() -> i64 {
42 let logfd: i64 = sys_openat_append("knowledge/status/h264_intra_gate.log\x00" as *u8, 0x1a4)
43 gp(logfd, "H264-INTRA-GATE (intra4x4 + full reconstruct chain)\n\x00" as *u8)
44
45 let top: *i64 = sys_mmap(8 * 8) as *i64
46 let left: *i64 = sys_mmap(8 * 8) as *i64
47 let pred: *i64 = sys_mmap(16 * 8) as *i64
48 top[0] = 10; top[1] = 20; top[2] = 30; top[3] = 40
49 left[0] = 50; left[1] = 60; left[2] = 70; left[3] = 80
50
51 // vertical
52 nx_intra4x4_pred(0, top, left, 1, 1, pred)
53 var vok: i64 = 1
54 var r: i64 = 0
55 while r < 4 {
56 if pred[r * 4 + 0] != 10 { vok = 0 }
57 if pred[r * 4 + 1] != 20 { vok = 0 }
58 if pred[r * 4 + 2] != 30 { vok = 0 }
59 if pred[r * 4 + 3] != 40 { vok = 0 }
60 r = r + 1
61 }
62 // horizontal
63 nx_intra4x4_pred(1, top, left, 1, 1, pred)
64 var hok: i64 = 1
65 r = 0
66 while r < 4 { var x: i64 = 0; while x < 4 { if pred[r * 4 + x] != left[r] { hok = 0 } x = x + 1 } r = r + 1 }
67 // DC both / top / neither
68 nx_intra4x4_pred(2, top, left, 1, 1, pred)
69 let dcb: i64 = pred[0]
70 nx_intra4x4_pred(2, top, left, 1, 0, pred)
71 let dct: i64 = pred[0]
72 nx_intra4x4_pred(2, top, left, 0, 0, pred)
73 let dcn: i64 = pred[0]
74 gp(logfd, " vert_ok=\x00" as *u8); gn(logfd, vok); gp(logfd, " horiz_ok=\x00" as *u8); gn(logfd, hok)
75 gp(logfd, " DCboth=\x00" as *u8); gn(logfd, dcb); gp(logfd, " DCtop=\x00" as *u8); gn(logfd, dct); gp(logfd, " DCneither=\x00" as *u8); gn(logfd, dcn); gp(logfd, "\n\x00" as *u8)
76
77 // CAPSTONE: full reconstruct chain
78 let c: *i64 = sys_mmap(16 * 8) as *i64
79 let dq: *i64 = sys_mmap(16 * 8) as *i64
80 zero16(c); c[0] = 16
81 nx_h264_dequant4x4(c, 0, dq) // -> DC coeff 160
82 nx_idct4x4(dq) // -> residual all 3
83 nx_intra4x4_pred(2, top, left, 1, 1, pred) // -> DC pred 45
84 let predU: *u8 = sys_mmap(16)
85 var i: i64 = 0
86 while i < 16 { predU[i] = pred[i] as u8; i = i + 1 }
87 let outU: *u8 = sys_mmap(16)
88 nx_idct_add_clip(predU, dq, outU, 16)
89 gp(logfd, " CAPSTONE pred=\x00" as *u8); gn(logfd, pred[0]); gp(logfd, " +residual=\x00" as *u8); gn(logfd, dq[0]); gp(logfd, " -> pixel=\x00" as *u8); gn(logfd, outU[0] as i64); gp(logfd, " (all16)\n\x00" as *u8)
90 var cap_ok: i64 = 1
91 i = 0
92 while i < 16 { if (outU[i] as i64) != 48 { cap_ok = 0 } i = i + 1 }
93
94 var ok: i64 = 1
95 if vok != 1 { ok = 0 }
96 if hok != 1 { ok = 0 }
97 if dcb != 45 { ok = 0 }
98 if dct != 25 { ok = 0 }
99 if dcn != 128 { ok = 0 }
100 if cap_ok != 1 { ok = 0 }
101
102 if ok == 1 {
103 gp(logfd, "H264-INTRA-GATE result=ALL-PASS verdict=GREEN\n\x00" as *u8)
104 if logfd > 0 { sys_close(logfd) }
105 sys_exit(0)
106 return 0
107 }
108 gp(logfd, "H264-INTRA-GATE result=FAIL verdict=RED\n\x00" as *u8)
109 if logfd > 0 { sys_close(logfd) }
110 sys_exit(1)
111 return 1
112}