nx_h264_cavlc_rt_gate.nx source
↩ module page · 120 lines · 5107 B
1// nx_h264_cavlc_rt_gate.nx -- SOVEREIGN round-trip oracle for CAVLC level codec.
2// No third-party reference: the ENCODER (nx_h264_cavlc_enc) and DECODER
3// (nx_h264_cavlc_level) are gated as an inverse pair.
4// (a) BitWriter sanity: write bits, read them back identically.
5// (b) ANCHOR vs canonical code words: encode(+1,sl0) -> "1" (0x80, 1 bit);
6// encode(-1,sl0) -> "01" (0x40, 2 bits). Pins the encoder to the spec.
7// (c) ROUND-TRIP: for many (level, suffixLength) pairs, encode -> decode ->
8// must recover the exact level. Proves both codecs correct (anchor (b)
9// rules out a shared wrong table on these entries).
10// Every value PRINTED. stdout + knowledge/status/h264_cavlc_rt_gate.log. Exit 0/1.
11// Sovereign: nx_syscalls + nx_h264_bitwriter + nx_h264_cavlc_enc + nx_h264_bits + nx_h264_cavlc_level.
12// license_tier: ORIGINAL
13import "nx_syscalls.nx"
14import "nx_h264_bitwriter.nx"
15import "nx_h264_cavlc_enc.nx"
16import "nx_h264_bits.nx"
17import "nx_h264_cavlc_level.nx"
18
19func gp(logfd: i64, s: *u8) -> i64 {
20 var n: i64 = 0
21 while s[n] != (0 as u8) { n = n + 1 }
22 sys_write(1, s, n)
23 if logfd > 0 { sys_write(logfd, s, n) }
24 return 0
25}
26func gn(logfd: i64, v: i64) -> i64 {
27 let bb: *u8 = sys_mmap(28)
28 var m: i64 = v
29 if m < 0 { sys_write(1, "-\x00" as *u8, 1); if logfd > 0 { sys_write(logfd, "-\x00" as *u8, 1) } m = 0 - m }
30 let t: *u8 = sys_mmap(28)
31 var k: i64 = 0
32 if m == 0 { t[0] = 48 as u8; k = 1 }
33 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
34 var i: i64 = 0
35 while i < k { bb[i] = t[k - 1 - i]; i = i + 1 }
36 sys_write(1, bb, k)
37 if logfd > 0 { sys_write(logfd, bb, k) }
38 return 0
39}
40
41func main() -> i64 {
42 let logfd: i64 = sys_openat_append("knowledge/status/h264_cavlc_rt_gate.log\x00" as *u8, 0x1a4)
43 gp(logfd, "H264-CAVLC-RT-GATE (sovereign encode<->decode oracle)\n\x00" as *u8)
44 var ok: i64 = 1
45
46 // (a) BitWriter sanity: write 1011 0 1, read back
47 let sb: *u8 = sys_mmap(8)
48 let bw0: *BitWriter = sys_mmap(NX_BW_BYTES) as *BitWriter
49 bw_init(bw0, sb, 8)
50 bw_write_bits(bw0, 11, 4) // 1011
51 bw_write_bit(bw0, 0)
52 bw_write_bit(bw0, 1)
53 let nbits: i64 = bw_total_bits(bw0)
54 let br0: *BitReader = sys_mmap(NX_BR_BYTES) as *BitReader
55 br_init(br0, sb, 8)
56 let rb: i64 = br_read_bits(br0, 6) // expect 101101 = 45
57 gp(logfd, " bitwriter: nbits=\x00" as *u8); gn(logfd, nbits); gp(logfd, " readback=\x00" as *u8); gn(logfd, rb); gp(logfd, " (expect 6, 45)\n\x00" as *u8)
58 if nbits != 6 { ok = 0 }
59 if rb != 45 { ok = 0 }
60
61 // (b) anchor encoder to canonical code words
62 let a1: *u8 = sys_mmap(8)
63 let bwa: *BitWriter = sys_mmap(NX_BW_BYTES) as *BitWriter
64 bw_init(bwa, a1, 8)
65 nx_cavlc_encode_level(bwa, 1, 0)
66 gp(logfd, " anchor +1 sl0: byte0=\x00" as *u8); gn(logfd, a1[0] as i64); gp(logfd, " bits=\x00" as *u8); gn(logfd, bw_total_bits(bwa)); gp(logfd, " (expect 128,1)\n\x00" as *u8)
67 if (a1[0] as i64) != 128 { ok = 0 }
68 if bw_total_bits(bwa) != 1 { ok = 0 }
69 let a2: *u8 = sys_mmap(8)
70 let bwb: *BitWriter = sys_mmap(NX_BW_BYTES) as *BitWriter
71 bw_init(bwb, a2, 8)
72 nx_cavlc_encode_level(bwb, 0 - 1, 0)
73 gp(logfd, " anchor -1 sl0: byte0=\x00" as *u8); gn(logfd, a2[0] as i64); gp(logfd, " bits=\x00" as *u8); gn(logfd, bw_total_bits(bwb)); gp(logfd, " (expect 64,2)\n\x00" as *u8)
74 if (a2[0] as i64) != 64 { ok = 0 }
75 if bw_total_bits(bwb) != 2 { ok = 0 }
76
77 // (c) round-trip over many (level, suffixLength) pairs
78 let lv: *i64 = sys_mmap(64 * 8) as *i64
79 let sl: *i64 = sys_mmap(64 * 8) as *i64
80 lv[0]=1; sl[0]=0
81 lv[1]=0-1; sl[1]=0
82 lv[2]=2; sl[2]=0
83 lv[3]=0-2; sl[3]=0
84 lv[4]=3; sl[4]=1
85 lv[5]=0-5; sl[5]=2
86 lv[6]=10; sl[6]=3
87 lv[7]=0-7; sl[7]=2
88 lv[8]=5; sl[8]=1
89 lv[9]=0-3; sl[9]=1
90 lv[10]=13; sl[10]=3
91 lv[11]=0-9; sl[11]=4
92 let n: i64 = 12
93 gp(logfd, " round-trip:\n\x00" as *u8)
94 var i: i64 = 0
95 while i < n {
96 let buf: *u8 = sys_mmap(16)
97 let bw: *BitWriter = sys_mmap(NX_BW_BYTES) as *BitWriter
98 bw_init(bw, buf, 16)
99 let pfx: i64 = nx_cavlc_encode_level(bw, lv[i], sl[i])
100 let br: *BitReader = sys_mmap(NX_BR_BYTES) as *BitReader
101 br_init(br, buf, 16)
102 let got: i64 = nx_cavlc_read_level(br, sl[i])
103 gp(logfd, " level=\x00" as *u8); gn(logfd, lv[i]); gp(logfd, " sl=\x00" as *u8); gn(logfd, sl[i]); gp(logfd, " prefix=\x00" as *u8); gn(logfd, pfx); gp(logfd, " -> decoded=\x00" as *u8); gn(logfd, got)
104 if got != lv[i] { ok = 0; gp(logfd, " MISMATCH\x00" as *u8) }
105 if pfx >= 15 { ok = 0; gp(logfd, " ESCAPE(out-of-range)\x00" as *u8) }
106 gp(logfd, "\n\x00" as *u8)
107 i = i + 1
108 }
109
110 if ok == 1 {
111 gp(logfd, "H264-CAVLC-RT-GATE result=ALL-PASS verdict=GREEN\n\x00" as *u8)
112 if logfd > 0 { sys_close(logfd) }
113 sys_exit(0)
114 return 0
115 }
116 gp(logfd, "H264-CAVLC-RT-GATE result=FAIL verdict=RED\n\x00" as *u8)
117 if logfd > 0 { sys_close(logfd) }
118 sys_exit(1)
119 return 1
120}