nx_img_decode_gate.nx source
↩ module page · 196 lines · 10258 B
1// nx_img_decode_gate.nx -- referee for JPEG wired into the shared decode path (nx_img_to_gray /
2// nx_img_to_rgb now route FF-D8-FF to the sovereign baseline JPEG decoder). The real web is JPEG, so
3// this is what unblocks perceptual-fingerprinting real media for the reverse-image discovery engine.
4// row1 JPEG -> gray dims -- the 137-byte all-128 baseline JPEG decodes to 8x8 via nx_img_to_gray.
5// row2 JPEG gray value -- decoded luma is ~128 (real IDCT, not a stub).
6// row3 JPEG -> rgb -- nx_img_to_rgb yields packed RGB ~ (128,128,128).
7// row4 CROSS-FORMAT MATCH -- dHash(JPEG) == dHash(PNG) for the same image (Hamming 0): a site serving
8// JPEG and a site serving PNG of the SAME media now MATCH -- the heart of cross-site reverse-image.
9// row5 PNG REGRESSION -- a red/green PNG still decodes correctly through nx_img_to_rgb (PNG path
10// intact after adding the JPEG branch).
11// GREEN iff 5/5. Durable verdict -> knowledge/status/img_decode_gate.log. license_tier: ORIGINAL
12import "nx_img_to_rgb.nx"
13import "nx_image_gray.nx"
14import "nx_phash.nx"
15import "nx_crc32.nx"
16import "nx_adler32.nx"
17
18func g_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
19func 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 }
20func 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 }
21func g_wn(fd: i64, v: i64) -> i64 { let bb: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m}; 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 }
22func g_abs(v: i64) -> i64 { if v<0 { return 0-v } return v }
23func g_write_bytes(path: *u8, buf: *u8, n: i64) -> i64 { let fd: i64=sys_openat_wr(path, 0x1a4); if fd<0 { return 0-1 } sys_write(fd, buf, n); sys_close(fd); return 0 }
24
25// the canonical 137-byte all-128 grayscale baseline JPEG (byte-identical to nx_jpeg_decode_test).
26func _build_gray_jpeg(jpeg: *u8) -> i64 {
27 var p: i64 = 0
28 jpeg[p]=0xFF; p=p+1; jpeg[p]=0xD8; p=p+1
29 jpeg[p]=0xFF; p=p+1; jpeg[p]=0xDB; p=p+1
30 jpeg[p]=0x00; p=p+1; jpeg[p]=0x43; p=p+1
31 jpeg[p]=0x00; p=p+1
32 var i: i64 = 0
33 while i < 64 { jpeg[p+i] = 1; i = i + 1 }
34 p = p + 64
35 jpeg[p]=0xFF; p=p+1; jpeg[p]=0xC4; p=p+1
36 jpeg[p]=0x00; p=p+1; jpeg[p]=0x26; p=p+1
37 jpeg[p]=0x00; p=p+1
38 jpeg[p]=0x01; p=p+1
39 i = 0
40 while i < 15 { jpeg[p+i] = 0; i = i + 1 }
41 p = p + 15
42 jpeg[p]=0x00; p=p+1
43 jpeg[p]=0x10; p=p+1
44 jpeg[p]=0x01; p=p+1
45 i = 0
46 while i < 15 { jpeg[p+i] = 0; i = i + 1 }
47 p = p + 15
48 jpeg[p]=0x00; p=p+1
49 jpeg[p]=0xFF; p=p+1; jpeg[p]=0xC0; p=p+1
50 jpeg[p]=0x00; p=p+1; jpeg[p]=0x0B; p=p+1
51 jpeg[p]=0x08; p=p+1
52 jpeg[p]=0x00; p=p+1; jpeg[p]=0x08; p=p+1
53 jpeg[p]=0x00; p=p+1; jpeg[p]=0x08; p=p+1
54 jpeg[p]=0x01; p=p+1
55 jpeg[p]=0x01; p=p+1
56 jpeg[p]=0x11; p=p+1
57 jpeg[p]=0x00; p=p+1
58 jpeg[p]=0xFF; p=p+1; jpeg[p]=0xDA; p=p+1
59 jpeg[p]=0x00; p=p+1; jpeg[p]=0x08; p=p+1
60 jpeg[p]=0x01; p=p+1
61 jpeg[p]=0x01; p=p+1
62 jpeg[p]=0x00; p=p+1
63 jpeg[p]=0x00; p=p+1
64 jpeg[p]=0x3F; p=p+1
65 jpeg[p]=0x00; p=p+1
66 jpeg[p]=0x00; p=p+1
67 jpeg[p]=0xFF; p=p+1; jpeg[p]=0xD9; p=p+1
68 return p
69}
70
71// stored-zlib 8-bit RGB PNG, left half (r1,g1,b1) / right half (r2,g2,b2). returns byte length.
72func gp_wbe(buf: *u8, off: i64, val: i64) -> i64 { buf[off]=((val>>24)&255) as u8; buf[off+1]=((val>>16)&255) as u8; buf[off+2]=((val>>8)&255) as u8; buf[off+3]=(val&255) as u8; return 0 }
73func gp_build_lr(out: *u8, w: i64, h: i64, r1: i64, g1: i64, b1: i64, r2: i64, g2: i64, b2: i64) -> i64 {
74 out[0]=137 as u8; out[1]=80 as u8; out[2]=78 as u8; out[3]=71 as u8
75 out[4]=13 as u8; out[5]=10 as u8; out[6]=26 as u8; out[7]=10 as u8
76 var pos: i64=8
77 gp_wbe(out,pos,13); pos=pos+4
78 let ihdr_t: i64=pos
79 out[pos]=73 as u8; out[pos+1]=72 as u8; out[pos+2]=68 as u8; out[pos+3]=82 as u8; pos=pos+4
80 gp_wbe(out,pos,w); pos=pos+4
81 gp_wbe(out,pos,h); pos=pos+4
82 out[pos]=8 as u8; out[pos+1]=2 as u8; out[pos+2]=0 as u8; out[pos+3]=0 as u8; out[pos+4]=0 as u8; pos=pos+5
83 gp_wbe(out,pos, nx_crc32(((out as i64)+ihdr_t) as *u8, 17)); pos=pos+4
84 let payload_len: i64=h*(1+w*3)
85 let zlib_len: i64=2+5+payload_len+4
86 gp_wbe(out,pos,zlib_len); pos=pos+4
87 let idat_t: i64=pos
88 out[pos]=73 as u8; out[pos+1]=68 as u8; out[pos+2]=65 as u8; out[pos+3]=84 as u8; pos=pos+4
89 out[pos]=0x78 as u8; out[pos+1]=0x01 as u8; pos=pos+2
90 out[pos]=0x01 as u8; pos=pos+1
91 out[pos]=(payload_len&255) as u8; out[pos+1]=((payload_len>>8)&255) as u8; pos=pos+2
92 let nlen: i64=(payload_len^0xFFFF)&0xFFFF
93 out[pos]=(nlen&255) as u8; out[pos+1]=((nlen>>8)&255) as u8; pos=pos+2
94 let payload_off: i64=pos
95 var y: i64=0
96 while y<h {
97 out[pos]=0 as u8; pos=pos+1
98 var x: i64=0
99 while x<w {
100 var r: i64=r1
101 var g: i64=g1
102 var b: i64=b1
103 if x>=w/2 { r=r2; g=g2; b=b2 }
104 out[pos]=r as u8; out[pos+1]=g as u8; out[pos+2]=b as u8; pos=pos+3
105 x=x+1
106 }
107 y=y+1
108 }
109 gp_wbe(out,pos, adler32(((out as i64)+payload_off) as *u8, payload_len)); pos=pos+4
110 gp_wbe(out,pos, nx_crc32(((out as i64)+idat_t) as *u8, 4+zlib_len)); pos=pos+4
111 gp_wbe(out,pos,0); pos=pos+4
112 let iend_t: i64=pos
113 out[pos]=73 as u8; out[pos+1]=69 as u8; out[pos+2]=78 as u8; out[pos+3]=68 as u8; pos=pos+4
114 gp_wbe(out,pos, nx_crc32(((out as i64)+iend_t) as *u8, 4)); pos=pos+4
115 return pos
116}
117
118func main() -> i64 {
119 g_puts("=== IMG-DECODE GATE (JPEG wired into nx_img_to_gray/rgb; cross-format fingerprint match) ===\n" as *u8)
120
121 // write the test JPEG + two PNGs (flat-128 for the cross-format match; red/green for the regression)
122 let jb: *u8 = sys_mmap(256)
123 let jlen: i64 = _build_gray_jpeg(jb)
124 g_write_bytes("/tmp/nx_t.jpg" as *u8, jb, jlen)
125 let pb: *u8 = sys_mmap(8192)
126 let pf: i64 = gp_build_lr(pb, 16, 16, 128,128,128, 128,128,128); g_write_bytes("/tmp/nx_flat.png" as *u8, pb, pf)
127 let pr: i64 = gp_build_lr(pb, 16, 16, 200,0,0, 0,200,0); g_write_bytes("/tmp/nx_rg.png" as *u8, pb, pr)
128
129 var pass: i64 = 0
130 let rows: i64 = 5
131
132 // ---- row1: JPEG -> gray dims ----
133 let jwh: *i64 = sys_mmap(16) as *i64
134 let jgray: *u8 = nx_img_to_gray("/tmp/nx_t.jpg" as *u8, jwh)
135 var jdec: i64 = 0
136 if jgray!=(0 as *u8) { jdec=1 }
137 g_puts(" row1 JPEG->gray dims -> " as *u8)
138 if jdec==1 { g_num(jwh[0]); g_puts("x" as *u8); g_num(jwh[1]) }
139 g_puts(" -> " as *u8)
140 if jdec==1 { if jwh[0]==8 { if jwh[1]==8 { pass=pass+1; g_puts("PASS\n" as *u8) } else { g_puts("FAIL\n" as *u8) } } else { g_puts("FAIL\n" as *u8) } } else { g_puts("FAIL (decode 0)\n" as *u8) }
141
142 // ---- row2: JPEG gray value ~128 ----
143 var gv: i64 = 0
144 if jdec==1 { gv = jgray[0] as i64 }
145 g_puts(" row2 JPEG luma[0]=" as *u8); g_num(gv); g_puts(" (~128) -> " as *u8)
146 if jdec==1 { if g_abs(gv-128)<=16 { pass=pass+1; g_puts("PASS (real IDCT)\n" as *u8) } else { g_puts("FAIL\n" as *u8) } } else { g_puts("FAIL\n" as *u8) }
147
148 // ---- row3: JPEG -> rgb ~ (128,128,128) ----
149 let jrwh: *i64 = sys_mmap(16) as *i64
150 let jrgb: *u8 = nx_img_to_rgb("/tmp/nx_t.jpg" as *u8, jrwh)
151 var rr: i64 = 0
152 var rg: i64 = 0
153 var rbb: i64 = 0
154 var rdec: i64 = 0
155 if jrgb!=(0 as *u8) { rdec=1; rr=jrgb[0] as i64; rg=jrgb[1] as i64; rbb=jrgb[2] as i64 }
156 g_puts(" row3 JPEG->rgb (" as *u8); g_num(rr); g_puts("," as *u8); g_num(rg); g_puts("," as *u8); g_num(rbb); g_puts(") -> " as *u8)
157 if rdec==1 { if g_abs(rr-128)<=16 { if g_abs(rg-128)<=16 { if g_abs(rbb-128)<=16 { pass=pass+1; g_puts("PASS\n" as *u8) } else { g_puts("FAIL\n" as *u8) } } else { g_puts("FAIL\n" as *u8) } } else { g_puts("FAIL\n" as *u8) } } else { g_puts("FAIL\n" as *u8) }
158
159 // ---- row4: CROSS-FORMAT fingerprint match -- dHash(JPEG) == dHash(PNG) for the same image ----
160 let fwh: *i64 = sys_mmap(16) as *i64
161 let fgray: *u8 = nx_img_to_gray("/tmp/nx_flat.png" as *u8, fwh)
162 var cfham: i64 = 99
163 var ok4: i64 = 0
164 if jdec==1 { if fgray!=(0 as *u8) {
165 let dj: i64 = nx_phash_dhash(jgray, jwh[0], jwh[1])
166 let dp: i64 = nx_phash_dhash(fgray, fwh[0], fwh[1])
167 cfham = nx_simhash_hamming(dj, dp)
168 ok4 = 1
169 } }
170 g_puts(" row4 cross-format: dHash(JPEG) vs dHash(PNG) same image, Hamming=" as *u8); g_num(cfham); g_puts(" -> " as *u8)
171 if ok4==1 { if cfham<=2 { pass=pass+1; g_puts("PASS (JPEG and PNG of the same media MATCH)\n" as *u8) } else { g_puts("FAIL\n" as *u8) } } else { g_puts("FAIL\n" as *u8) }
172
173 // ---- row5: PNG regression -- red/green still decodes via nx_img_to_rgb ----
174 let rwh: *i64 = sys_mmap(16) as *i64
175 let rgb: *u8 = nx_img_to_rgb("/tmp/nx_rg.png" as *u8, rwh)
176 var okpng: i64 = 0
177 if rgb!=(0 as *u8) {
178 let tlr: i64 = rgb[0] as i64
179 let o: i64 = (16-1)*3
180 let trg: i64 = rgb[o+1] as i64
181 if tlr>150 { if trg>150 { okpng=1 } }
182 }
183 g_puts(" row5 PNG regression (red/green via nx_img_to_rgb) -> " as *u8)
184 if okpng==1 { pass=pass+1; g_puts("PASS (PNG path intact)\n" as *u8) } else { g_puts("FAIL\n" as *u8) }
185
186 g_puts("----\nIMG-DECODE-GATE rows=" as *u8); g_num(rows); g_puts(" pass=" as *u8); g_num(pass); g_puts("\n" as *u8)
187 let lg: i64 = sys_openat_append("knowledge/status/img_decode_gate.log" as *u8, 0x1a4)
188 if lg>=0 {
189 g_w(lg,"IMG-DECODE-GATE rows=" as *u8); g_wn(lg,rows); g_w(lg," pass=" as *u8); g_wn(lg,pass)
190 g_w(lg," jpeg_luma=" as *u8); g_wn(lg,gv); g_w(lg," crossfmt_ham=" as *u8); g_wn(lg,cfham)
191 if pass==rows { g_w(lg," verdict=GREEN\n" as *u8) } else { g_w(lg," verdict=RED\n" as *u8) }
192 sys_close(lg)
193 }
194 if pass==rows { g_puts("IMG-DECODE-GATE GREEN\n" as *u8); sys_exit(0); return 0 }
195 g_puts("IMG-DECODE-GATE RED\n" as *u8); sys_exit(1); return 1
196}