code wiki / _hdl_build / nx_intra_image_gate.nx
nx_intra_image_gate.nx source
↩ module page · 165 lines · 8111 B
1// nx_intra_image_gate.nx -- SOVEREIGN proof of the patent-free intra IMAGE codec (Phase-1 capstone):
2// tiles the 8x8 block coder across a full image with ONE amortized static frequency table, and measures
3// image-level compression (freq-table cost INCLUDED in the total -- honest, not hidden) + reconstruction
4// error. Flow: pixels -> per 8x8 block [level-shift -> 2D DCT-II (nx_dct8, foundational EXPIRED math) ->
5// scalar quantize] -> collect ALL quantized coeffs -> 16-bit serialize -> ONE rANS (nx_rans, PUBLIC
6// DOMAIN) over the whole image with ONE shared table -> [decode -> per-block dequant -> inverse DCT] ->
7// reconstruct. Every tool EXPIRED or PUBLIC-DOMAIN; no CABAC; integer-only; nx_cc->nxasm, no gcc.
8// GREEN iff 6/6. Durable knowledge/status/intra_image_gate.log. license_tier: ORIGINAL
9import "nx_syscalls.nx"
10import "nx_gate_emit_lib.nx"
11import "nx_dct8.nx"
12import "nx_rans.nx"
13
14func g_num(v: i64) -> i64 { let bb: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m;sys_write(1,"-" as *u8,1)}; let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=(48 as u8);k=1}; while m>0{t[k]=((48+(m%10)) as u8);m=m/10;k=k+1}; var i: i64=0; while i<k{bb[i]=t[k-1-i];i=i+1}; sys_write(1,bb,k); return 0 }
15func g_w(fd: i64, s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(fd,s,n); return 0 }
16func g_wn(fd: i64, v: i64) -> i64 { let bb: *u8=sys_mmap(28); var m: i64=v; let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=(48 as u8);k=1}; while m>0{t[k]=((48+(m%10)) as u8);m=m/10;k=k+1}; var i: i64=0; while i<k{bb[i]=t[k-1-i];i=i+1}; sys_write(fd,bb,k); return 0 }
17func iabs(v: i64) -> i64 { if v<0 { return 0-v } return v }
18func qround(v: i64, q: i64) -> i64 { if v>=0 { return (v + q/2)/q } return 0 - (((0-v) + q/2)/q) }
19
20func main() -> i64 {
21 g_puts("=== INTRA IMAGE GATE: patent-free intra image codec (tiled + amortized table, sovereign) ===\n" as *u8)
22 let W: i64=128; let H: i64=128; let sb: i64=12; let Q: i64=16
23 let npx: i64 = W*H
24
25 // synthetic test image: smooth diagonal gradient + a bright square (an edge feature)
26 let img: *i64 = sys_mmap(npx*8) as *i64
27 var y: i64=0
28 while y<H {
29 var x: i64=0
30 while x<W {
31 var v: i64 = x+y
32 if v>255 { v=255 }
33 if x>=36 { if x<68 { if y>=36 { if y<68 { v=200 } } } }
34 img[y*W+x]=v
35 x=x+1
36 }
37 y=y+1
38 }
39
40 let DM: *i64=sys_mmap(64*8) as *i64; nx_dct8_init(DM)
41 let scratch: *i64=sys_mmap(64*8) as *i64
42 let ti: *i64=sys_mmap(8*8) as *i64
43 let to: *i64=sys_mmap(8*8) as *i64
44
45 let bw: i64=W/8; let bh: i64=H/8; let nblk: i64=bw*bh
46 let ncoef: i64=nblk*64
47 let qall: *i64=sys_mmap(ncoef*8) as *i64
48
49 // forward: each 8x8 block -> quantized coeffs into qall
50 let sh: *i64=sys_mmap(64*8) as *i64
51 let co: *i64=sys_mmap(64*8) as *i64
52 var byi: i64=0
53 while byi<bh {
54 var bxi: i64=0
55 while bxi<bw {
56 let bidx: i64=byi*bw+bxi
57 var r: i64=0
58 while r<8 {
59 var c: i64=0
60 while c<8 { sh[r*8+c] = img[(byi*8+r)*W + (bxi*8+c)] - 128; c=c+1 }
61 r=r+1
62 }
63 nx_dct8_forward_2d(DM, sh, co, scratch, ti, to)
64 var i: i64=0
65 while i<64 { qall[bidx*64+i]=qround(co[i], Q); i=i+1 }
66 bxi=bxi+1
67 }
68 byi=byi+1
69 }
70
71 // serialize all coeffs (16-bit LE) then ONE rANS over the whole image
72 let nb: i64=ncoef*2
73 let bytes: *u8=sys_mmap(nb+16)
74 var i: i64=0
75 while i<ncoef { let v: i64=qall[i]&0xffff; bytes[2*i]=(v&0xff) as u8; bytes[2*i+1]=((v>>8)&0xff) as u8; i=i+1 }
76 let counts: *i64=sys_mmap(257*8) as *i64
77 let fr: *i64=sys_mmap(257*8) as *i64
78 let cu: *i64=sys_mmap(257*8) as *i64
79 let s2s: *i64=sys_mmap((1<<sb)*8) as *i64
80 rans_count(bytes, nb, counts)
81 rans_normalize(counts, fr, sb)
82 rans_cum(fr, cu)
83 rans_build_slot2sym(fr, cu, s2s)
84 let cap: i64=nb + (nb/2) + 1024
85 let enc: *u8=sys_mmap(cap)
86 let enclen: i64=rans_encode(bytes, nb, fr, cu, sb, enc, cap)
87
88 // HONEST total: freq table (256 symbols * 2 bytes) + small header + rANS payload (table NOT hidden)
89 let tablebytes: i64=512
90 let headerbytes: i64=8
91 let total: i64=tablebytes+headerbytes+enclen
92
93 // decode -> verify entropy lossless -> reconstruct
94 let bytes2: *u8=sys_mmap(nb+16)
95 rans_decode(enc, enclen, nb, fr, cu, sb, s2s, bytes2)
96 var eloss: i64=1
97 i=0; while i<nb { if bytes2[i]!=bytes[i] { eloss=0 } i=i+1 }
98 let qall2: *i64=sys_mmap(ncoef*8) as *i64
99 i=0; while i<ncoef { var v: i64=(bytes2[2*i] as i64)|((bytes2[2*i+1] as i64)<<8); if v>=32768 { v=v-65536 } qall2[i]=v; i=i+1 }
100 let recon: *i64=sys_mmap(npx*8) as *i64
101 let dq: *i64=sys_mmap(64*8) as *i64
102 let rsh: *i64=sys_mmap(64*8) as *i64
103 byi=0
104 while byi<bh {
105 var bxi: i64=0
106 while bxi<bw {
107 let bidx: i64=byi*bw+bxi
108 var k: i64=0
109 while k<64 { dq[k]=qall2[bidx*64+k]*Q; k=k+1 }
110 nx_dct8_inverse_2d(DM, dq, rsh, scratch, ti, to)
111 var r: i64=0
112 while r<8 {
113 var c: i64=0
114 while c<8 {
115 var p: i64=rsh[r*8+c]+128
116 if p<0 { p=0 }
117 if p>255 { p=255 }
118 recon[(byi*8+r)*W+(bxi*8+c)]=p
119 c=c+1
120 }
121 r=r+1
122 }
123 bxi=bxi+1
124 }
125 byi=byi+1
126 }
127 var maxe: i64=0; var sume: i64=0
128 i=0; while i<npx { let e: i64=iabs(recon[i]-img[i]); if e>maxe { maxe=e } sume=sume+e; i=i+1 }
129 let meane: i64=sume/npx
130
131 // liar-kill: corrupt the stream, redecode, confirm divergence
132 let ec: *u8=sys_mmap(cap)
133 i=0; while i<enclen { ec[i]=enc[i]; i=i+1 }
134 let mid: i64=enclen/2
135 ec[mid]=(((ec[mid] as i64)+1)&0xff) as u8
136 let bytes3: *u8=sys_mmap(nb+16)
137 rans_decode(ec, enclen, nb, fr, cu, sb, s2s, bytes3)
138 var lk: i64=0
139 i=0; while i<nb { if bytes3[i]!=bytes2[i] { lk=1 } i=i+1 }
140
141 let ratiox100: i64=(npx*100)/total
142
143 g_puts("-- image " as *u8); g_num(W); g_puts("x" as *u8); g_num(H); g_puts(" raw=" as *u8); g_num(npx)
144 g_puts("B compressed=" as *u8); g_num(total); g_puts("B (table=" as *u8); g_num(tablebytes); g_puts("+payload=" as *u8); g_num(enclen)
145 g_puts(") ratio=" as *u8); g_num(ratiox100/100); g_puts("." as *u8); let f2: i64=ratiox100%100; if f2<10 { g_puts("0" as *u8) } g_num(f2); g_puts("x\n" as *u8)
146 g_puts("-- quality: maxErr=" as *u8); g_num(maxe); g_puts(" meanErr=" as *u8); g_num(meane); g_puts(" blocks=" as *u8); g_num(nblk); g_puts("\n" as *u8)
147
148 var pass: i64=0; let rows: i64=6
149 pass=pass+g_check(" T1 entropy stage lossless over whole image" as *u8, eloss)
150 var t2: i64=0; if total < npx { t2=1 }
151 pass=pass+g_check(" T2 compresses below raw (table cost included)" as *u8, t2)
152 var t3: i64=0; if meane <= 4 { t3=1 }
153 pass=pass+g_check(" T3 reconstruction faithful (meanErr<=4)" as *u8, t3)
154 var t4: i64=0; if ratiox100 >= 300 { t4=1 }
155 pass=pass+g_check(" T4 amortized table -> >=3x compression" as *u8, t4)
156 var t5: i64=0; if maxe <= 90 { t5=1 }
157 pass=pass+g_check(" T5 bounded worst-case error at edges (maxErr<=90)" as *u8, t5)
158 pass=pass+g_check(" T6 liar-kill: corrupted stream diverges" as *u8, lk)
159
160 g_puts("----\nIMAGE rows=" as *u8); g_num(rows); g_puts(" pass=" as *u8); g_num(pass); g_puts("\n" as *u8)
161 let lg: i64=sys_openat_append("knowledge/status/intra_image_gate.log" as *u8, 0x1a4)
162 if lg>=0 { g_w(lg, "IMAGE rows=" as *u8); g_wn(lg, rows); g_w(lg, " pass=" as *u8); g_wn(lg, pass); g_w(lg, " ratiox100=" as *u8); g_wn(lg, ratiox100); g_w(lg, " maxErr=" as *u8); g_wn(lg, maxe); g_w(lg, " meanErr=" as *u8); g_wn(lg, meane); if pass==rows { g_w(lg, " verdict=GREEN\n" as *u8) } else { g_w(lg, " verdict=RED\n" as *u8) } sys_close(lg) }
163 if pass==rows { g_puts("IMAGE GREEN (sovereign patent-free intra image codec proven, measured)\n" as *u8); sys_exit(0); return 0 }
164 g_puts("IMAGE RED\n" as *u8); sys_exit(1); return 1
165}