nx_jpeg_rst_gate.nx source

1// nx_jpeg_rst_gate.nx -- gate for JPEG restart-marker (DRI/RSTn) support, BOTH sides: jw_write_jpeg_ri 2// EMITS restart intervals and the baseline decoder CONSUMES them (nx_jpeg_decode -> walk_mcus_ri -> 3// _decoder_consume_rst). A synthetic round-trip alone cannot catch a shared wrong assumption (an encoder 4// and a decoder that BOTH forgot the DC-predictor reset still round-trip clean), so T7 decodes a REAL 5// third-party-encoded restart-marker JPEG (knowledge/photoreal_refs/lidia/lidia_nature_02.jpg, ~500 RSTn, 6// previously DECODE_FAIL rc=102 -- debt 1090) as the independent witness. T6 is the bite tooth: a 7// corrupted marker must FAIL the decode while the clean stream passes. Inherits nx_gate_verdict. 8// license_tier: ORIGINAL expect_exit: 0 9import "nx_syscalls.nx" 10import "nx_gate_verdict.nx" 11import "nx_h264_bitwriter.nx" 12import "nx_dct8.nx" 13import "nx_quant_table.nx" 14import "nx_zigzag.nx" 15import "nx_jpeg_huff_enc.nx" 16import "nx_jpeg_block_enc.nx" 17import "nx_jpeg_write.nx" 18import "nx_jpeg_ascii.nx" 19 20func rj_abs(v: i64) -> i64 { if v<0 { return 0-v } return v } 21func rj_u16(b: *u8, o: i64) -> i64 { return ((b[o] as i64)<<8) | (b[o+1] as i64) } 22 23func main() -> i64 { 24 let ctr: *i64 = gv_ctr() 25 gv_head("nx_jpeg_rst_gate -- DRI/RSTn restart intervals: emit + decode + real-web witness" as *u8) 26 let W: i64=64; let H: i64=16; let npx: i64=W*H 27 28 // DC ramp across MCUs so the predictor reset MATTERS: a decoder that skips the 29 // reset shifts every post-restart block's DC and T5's fidelity bound catches it. 30 let img: *i64=sys_mmap(npx*8) as *i64 31 var y: i64=0 32 while y<H { var x: i64=0; while x<W { var v: i64=x*3+y*4; if v>255 { v=255 } img[y*W+x]=v; x=x+1 } y=y+1 } 33 34 let dcB: *i64=sys_mmap(20*8) as *i64; let dcV: *i64=sys_mmap(20*8) as *i64 35 let acB: *i64=sys_mmap(20*8) as *i64; let acV: *i64=sys_mmap(200*8) as *i64 36 let ndc: i64=jhe_dc_bits(dcB); jhe_dc_val(dcV); let nac: i64=jhe_ac_bits(acB); jhe_ac_val(acV) 37 let dcCO: *i64=sys_mmap(256*8) as *i64; let dcSI: *i64=sys_mmap(256*8) as *i64 38 let acCO: *i64=sys_mmap(256*8) as *i64; let acSI: *i64=sys_mmap(256*8) as *i64 39 jhe_gen(dcB, dcV, ndc, dcCO, dcSI); jhe_gen(acB, acV, nac, acCO, acSI) 40 let qt: *i64=sys_mmap(64*8) as *i64; nx_qt_luma(qt, 50) 41 let to_zz: *i64=sys_mmap(64*8) as *i64; let from_zz: *i64=sys_mmap(64*8) as *i64; nx_zigzag_init(to_zz, from_zz) 42 let DM: *i64=sys_mmap(64*8) as *i64; nx_dct8_init(DM) 43 let scratch: *i64=sys_mmap(64*8) as *i64; let ti: *i64=sys_mmap(8*8) as *i64; let to: *i64=sys_mmap(8*8) as *i64 44 45 let out_p: *u8=sys_mmap(npx*4 + 8192) 46 let out_0: *u8=sys_mmap(npx*4 + 8192) 47 let out_r: *u8=sys_mmap(npx*4 + 8192) 48 let jlen_p: i64=jw_write_jpeg(out_p, W, H, qt, dcB, dcV, acB, acV, dcCO, dcSI, acCO, acSI, to_zz, from_zz, DM, scratch, ti, to, img) 49 let jlen_0: i64=jw_write_jpeg_ri(out_0, W, H, qt, dcB, dcV, acB, acV, dcCO, dcSI, acCO, acSI, to_zz, from_zz, DM, scratch, ti, to, img, 0) 50 let jlen_r: i64=jw_write_jpeg_ri(out_r, W, H, qt, dcB, dcV, acB, acV, dcCO, dcSI, acCO, acSI, to_zz, from_zz, DM, scratch, ti, to, img, 2) 51 52 // T1 ri=0 output is byte-identical to the proven jw_write_jpeg (zero-drift proof). 53 var t1: i64=0 54 if jlen_0==jlen_p { var same: i64=1; var ii: i64=0; while ii<jlen_p { if out_0[ii]!=out_p[ii] { same=0; ii=jlen_p } else { ii=ii+1 } } t1=same } 55 gv_check("T1 jw_write_jpeg_ri(ri=0) byte-identical to jw_write_jpeg" as *u8, t1, ctr) 56 57 // T2 the RST file carries a DRI segment with interval 2, before SOS. 58 var have_dri: i64=0; var dri_val: i64=0-1 59 var off: i64=2; var walking: i64=1 60 while walking==1 { 61 if off+4 > jlen_r { walking=0 } else { 62 if out_r[off]!=(0xFF as u8) { walking=0 } else { 63 let m: i64=out_r[off+1] as i64 64 if m==0xDA { walking=0 } else { 65 let seglen: i64=rj_u16(out_r, off+2) 66 if m==0xDD { have_dri=1; dri_val=rj_u16(out_r, off+4) } 67 off=off+2+seglen 68 } 69 } 70 } 71 } 72 var t2: i64=0; if have_dri==1 { if dri_val==2 { t2=1 } } 73 gv_check("T2 DRI segment present, interval=2" as *u8, t2, ctr) 74 75 // T3 exactly (16 MCUs / ri 2) - 1 = 7 restart markers, indices cycling D0..D6. 76 // Safe whole-file scan: stuffed data FF is always followed by 0x00, and no header 77 // in this fixture contains a literal FF payload byte, so FF D0..D7 IS a marker. 78 var nrst: i64=0; var seq_ok: i64=1; var expect: i64=0 79 var si: i64=2 80 while si+1 < jlen_r { 81 if out_r[si]==(0xFF as u8) { 82 let mm: i64=out_r[si+1] as i64 83 if mm>=0xD0 { if mm<=0xD7 { 84 if mm-0xD0 != expect { seq_ok=0 } 85 expect=expect+1; if expect==8 { expect=0 } 86 nrst=nrst+1 87 si=si+1 88 } } 89 } 90 si=si+1 91 } 92 gv_puts(" [rst-markers found=" as *u8); gv_num(nrst); gv_puts("]\n" as *u8) 93 var t3: i64=0; if nrst==7 { if seq_ok==1 { t3=1 } } 94 gv_check("T3 seven RSTn markers, indices cycle D0..D6" as *u8, t3, ctr) 95 96 // T4 the fixed decoder decodes the RST stream, correct dimensions. 97 let d1p: *i64=sys_mmap(8) as *i64; let d1w: *i64=sys_mmap(8) as *i64 98 let d1h: *i64=sys_mmap(8) as *i64; let d1s: *i64=sys_mmap(8) as *i64 99 let dl1: i64=nx_jpeg_decode_luma(out_r, jlen_r, d1p, d1w, d1h, d1s) 100 var t4: i64=0; if dl1==NX_JPEG_ASCII_OK { if d1w[0]==W { if d1h[0]==H { t4=1 } } } 101 gv_check("T4 decoder consumes RST stream, dims 64x16" as *u8, t4, ctr) 102 103 // T5 fidelity: RST decode matches the source within JPEG tolerance AND is 104 // pixel-identical to the no-RST decode (same coefficients, different framing). 105 var t5: i64=0 106 if t4==1 { 107 let d2p: *i64=sys_mmap(8) as *i64; let d2w: *i64=sys_mmap(8) as *i64 108 let d2h: *i64=sys_mmap(8) as *i64; let d2s: *i64=sys_mmap(8) as *i64 109 let dl2: i64=nx_jpeg_decode_luma(out_p, jlen_p, d2p, d2w, d2h, d2s) 110 if dl2==NX_JPEG_ASCII_OK { 111 let pr: *u8=d1p[0] as *u8; let sr: i64=d1s[0] 112 let pp: *u8=d2p[0] as *u8; let sp: i64=d2s[0] 113 var maxe: i64=0; var ident: i64=1 114 var yy: i64=0 115 while yy<H { 116 var xx: i64=0 117 while xx<W { 118 let av: i64=pr[yy*sr+xx] as i64 119 let bv: i64=pp[yy*sp+xx] as i64 120 if av!=bv { ident=0 } 121 let ev: i64=rj_abs(av-img[yy*W+xx]) 122 if ev>maxe { maxe=ev } 123 xx=xx+1 124 } 125 yy=yy+1 126 } 127 gv_puts(" [rst-vs-source maxErr=" as *u8); gv_num(maxe) 128 gv_puts(" rst-vs-plain identical=" as *u8); gv_num(ident); gv_puts("]\n" as *u8) 129 if maxe<=40 { if ident==1 { t5=1 } } 130 } 131 } 132 gv_check("T5 fidelity: maxErr<=40 vs source, identical to no-RST decode" as *u8, t5, ctr) 133 134 // T6 BITE: corrupt the first restart marker -> decode must FAIL (fires on bad), 135 // while the clean RST stream decodes (silent on good). 136 let out_c: *u8=sys_mmap(npx*4 + 8192) 137 var ci: i64=0; while ci<jlen_r { out_c[ci]=out_r[ci]; ci=ci+1 } 138 var fpos: i64=0-1 139 var fi: i64=2 140 while fi+1 < jlen_r { 141 if fpos<0 { if out_c[fi]==(0xFF as u8) { if out_c[fi+1]==(0xD0 as u8) { fpos=fi } } } 142 fi=fi+1 143 } 144 var bite_bad: i64=0 145 if fpos>=0 { 146 out_c[fpos+1]=0xC3 as u8 147 let d3p: *i64=sys_mmap(8) as *i64; let d3w: *i64=sys_mmap(8) as *i64 148 let d3h: *i64=sys_mmap(8) as *i64; let d3s: *i64=sys_mmap(8) as *i64 149 let dl3: i64=nx_jpeg_decode_luma(out_c, jlen_r, d3p, d3w, d3h, d3s) 150 if dl3!=NX_JPEG_ASCII_OK { bite_bad=1 } 151 } 152 var bite_good: i64=0 153 if dl1!=NX_JPEG_ASCII_OK { bite_good=1 } 154 gv_bite("T6 corrupted-RST-marker refusal" as *u8, bite_bad, bite_good, ctr) 155 156 // T7 INDEPENDENT WITNESS: a real web JPEG with restart markers from a real 157 // third-party encoder, previously DECODE_FAIL rc=102. Decodes + has structure. 158 var t7: i64=0 159 var wit_w: i64=0; var wit_h: i64=0; var wit_spread: i64=0; var wit_rc: i64=0-1 160 let wbox: *i64=sys_mmap(16) as *i64 161 let wraw: *u8=sys_read_file("knowledge/photoreal_refs/lidia/lidia_nature_02.jpg" as *u8, wbox) 162 if wraw!=(0 as *u8) { 163 let d4p: *i64=sys_mmap(8) as *i64; let d4w: *i64=sys_mmap(8) as *i64 164 let d4h: *i64=sys_mmap(8) as *i64; let d4s: *i64=sys_mmap(8) as *i64 165 wit_rc=nx_jpeg_decode_luma(wraw, wbox[0], d4p, d4w, d4h, d4s) 166 if wit_rc==NX_JPEG_ASCII_OK { 167 wit_w=d4w[0]; wit_h=d4h[0] 168 let wpl: *u8=d4p[0] as *u8; let wst: i64=d4s[0] 169 var wmin: i64=255; var wmax: i64=0 170 var wi: i64=0 171 while wi < wit_w*wit_h { 172 let wy: i64=wi / wit_w 173 let wx: i64=wi % wit_w 174 let pv: i64=wpl[wy*wst+wx] as i64 175 if pv<wmin { wmin=pv } 176 if pv>wmax { wmax=pv } 177 wi=wi+97 178 } 179 wit_spread=wmax-wmin 180 if wit_w>0 { if wit_h>0 { if wit_spread>20 { t7=1 } } } 181 } 182 } 183 gv_puts(" [witness rc=" as *u8); gv_num(wit_rc) 184 gv_puts(" w=" as *u8); gv_num(wit_w); gv_puts(" h=" as *u8); gv_num(wit_h) 185 gv_puts(" spread=" as *u8); gv_num(wit_spread); gv_puts("]\n" as *u8) 186 gv_check("T7 real third-party RST JPEG decodes (debt-1090 witness)" as *u8, t7, ctr) 187 188 let rc: i64 = gv_verdict("JPEG-RST-GATE" as *u8, ctr, "restart intervals emit+decode, independent witness" as *u8) 189 sys_exit(rc) 190 return rc 191}