nx_jpeg_block_enc_gate.nx source

1// nx_jpeg_block_enc_gate.nx -- SOVEREIGN gate for J2 (JPEG baseline block entropy coder). Proves the 2// FULL per-block JPEG chain end-to-end with no python / no 3rd party: pixels -> level-shift -> 2D DCT-II 3// (nx_dct8) -> quantize (nx_quant_table Annex-K luma @ quality 50) -> zigzag (nx_zigzag) -> DC-diff + 4// AC-RLE Huffman (nx_jpeg_block_enc/J1) -> [decode] -> dequant -> IDCT -> reconstruct. 5// T1 the quantized coeffs round-trip bit-exact through the entropy coder 6// T2 reconstruction is faithful (measured error) 7// T3 the block compresses below raw 64 bytes 8// T4 DC differential works across TWO chained blocks 9// T5 a flat block reconstructs near-exact 10// T6 liar-kill: a corrupted stream diverges 11// GREEN iff 6/6. knowledge/status/jpeg_block_enc_gate.log. license_tier: ORIGINAL 12import "nx_syscalls.nx" 13import "nx_gate_emit_lib.nx" 14import "nx_h264_bitwriter.nx" 15import "nx_dct8.nx" 16import "nx_quant_table.nx" 17import "nx_zigzag.nx" 18import "nx_jpeg_huff_enc.nx" 19import "nx_jpeg_block_enc.nx" 20 21func 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 } 22func 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 } 23func 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 } 24func iabs(v: i64) -> i64 { if v<0 { return 0-v } return v } 25func qrnd(v: i64, q: i64) -> i64 { if v>=0 { return (v + q/2)/q } return 0 - (((0-v) + q/2)/q) } 26func eq64(a: *i64, b: *i64) -> i64 { var i: i64=0; while i<64 { if a[i]!=b[i] { return 0 } i=i+1 } return 1 } 27 28func forward_block(block: *i64, DM: *i64, scratch: *i64, ti: *i64, to: *i64, qt: *i64, to_zz: *i64, zz: *i64) -> i64 { 29 let sh: *i64=sys_mmap(64*8) as *i64 30 var i: i64=0; while i<64 { sh[i]=block[i]-128; i=i+1 } 31 let co: *i64=sys_mmap(64*8) as *i64 32 nx_dct8_forward_2d(DM, sh, co, scratch, ti, to) 33 let q: *i64=sys_mmap(64*8) as *i64 34 i=0; while i<64 { q[i]=qrnd(co[i], qt[i]); i=i+1 } 35 nx_zigzag_scan(q, to_zz, zz) 36 return 0 37} 38func inverse_block(zz: *i64, DM: *i64, scratch: *i64, ti: *i64, to: *i64, qt: *i64, from_zz: *i64, recon: *i64) -> i64 { 39 let q: *i64=sys_mmap(64*8) as *i64 40 nx_zigzag_unscan(zz, from_zz, q) 41 let co: *i64=sys_mmap(64*8) as *i64 42 var i: i64=0; while i<64 { co[i]=q[i]*qt[i]; i=i+1 } 43 let rsh: *i64=sys_mmap(64*8) as *i64 44 nx_dct8_inverse_2d(DM, co, rsh, scratch, ti, to) 45 i=0; while i<64 { var p: i64=rsh[i]+128; if p<0 { p=0 } if p>255 { p=255 } recon[i]=p; i=i+1 } 46 return 0 47} 48func maxerr(a: *i64, b: *i64) -> i64 { var m: i64=0; var i: i64=0; while i<64 { let e: i64=iabs(a[i]-b[i]); if e>m { m=e } i=i+1 } return m } 49 50func main() -> i64 { 51 g_puts("=== JPEG BLOCK ENC GATE: full per-block JPEG chain, round-trip (sovereign) ===\n" as *u8) 52 // huffman tables 53 let dcB: *i64=sys_mmap(20*8) as *i64; let dcV: *i64=sys_mmap(20*8) as *i64 54 let acB: *i64=sys_mmap(20*8) as *i64; let acV: *i64=sys_mmap(200*8) as *i64 55 let ndc: i64=jhe_dc_bits(dcB); jhe_dc_val(dcV); let nac: i64=jhe_ac_bits(acB); jhe_ac_val(acV) 56 let dcCO: *i64=sys_mmap(256*8) as *i64; let dcSI: *i64=sys_mmap(256*8) as *i64 57 let acCO: *i64=sys_mmap(256*8) as *i64; let acSI: *i64=sys_mmap(256*8) as *i64 58 jhe_gen(dcB, dcV, ndc, dcCO, dcSI); jhe_gen(acB, acV, nac, acCO, acSI) 59 // quant table @ quality 50, zigzag, DCT matrix 60 let qt: *i64=sys_mmap(64*8) as *i64; nx_qt_luma(qt, 50) 61 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) 62 let DM: *i64=sys_mmap(64*8) as *i64; nx_dct8_init(DM) 63 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 64 65 // block A: gradient 66 let A: *i64=sys_mmap(64*8) as *i64 67 var r: i64=0 68 while r<8 { var c: i64=0; while c<8 { A[r*8+c]=(r+c)*16; c=c+1 } r=r+1 } 69 let zzA: *i64=sys_mmap(64*8) as *i64 70 forward_block(A, DM, scratch, ti, to, qt, to_zz, zzA) 71 let buf: *u8=sys_mmap(512) 72 let bw: *BitWriter=sys_mmap(64) as *BitWriter; bw_init(bw, buf, 512) 73 jbe_encode_block(bw, dcCO, dcSI, acCO, acSI, zzA, 0) 74 let encbytes: i64=(bw_total_bits(bw)+7)/8 75 let pos: *i64=sys_mmap(8) as *i64; pos[0]=0 76 let zzA2: *i64=sys_mmap(64*8) as *i64 77 jbe_decode_block(buf, pos, dcCO, dcSI, acCO, acSI, 0, zzA2) 78 var t1: i64=0; if eq64(zzA, zzA2)==1 { t1=1 } 79 let reconA: *i64=sys_mmap(64*8) as *i64 80 inverse_block(zzA2, DM, scratch, ti, to, qt, from_zz, reconA) 81 let meA: i64=maxerr(A, reconA) 82 83 // block B: flat 200 84 let B: *i64=sys_mmap(64*8) as *i64 85 var i: i64=0; while i<64 { B[i]=200; i=i+1 } 86 let zzB: *i64=sys_mmap(64*8) as *i64 87 forward_block(B, DM, scratch, ti, to, qt, to_zz, zzB) 88 89 // T4: two-block chained stream A then B, decode both tracking prevdc 90 let buf2: *u8=sys_mmap(512) 91 let bw2: *BitWriter=sys_mmap(64) as *BitWriter; bw_init(bw2, buf2, 512) 92 let dcA: i64=jbe_encode_block(bw2, dcCO, dcSI, acCO, acSI, zzA, 0) 93 jbe_encode_block(bw2, dcCO, dcSI, acCO, acSI, zzB, dcA) 94 let pos2: *i64=sys_mmap(8) as *i64; pos2[0]=0 95 let zzA3: *i64=sys_mmap(64*8) as *i64; let zzB3: *i64=sys_mmap(64*8) as *i64 96 let dcA3: i64=jbe_decode_block(buf2, pos2, dcCO, dcSI, acCO, acSI, 0, zzA3) 97 jbe_decode_block(buf2, pos2, dcCO, dcSI, acCO, acSI, dcA3, zzB3) 98 var t4: i64=0; if eq64(zzA, zzA3)==1 { if eq64(zzB, zzB3)==1 { t4=1 } } 99 let reconB: *i64=sys_mmap(64*8) as *i64 100 inverse_block(zzB3, DM, scratch, ti, to, qt, from_zz, reconB) 101 let meB: i64=maxerr(B, reconB) 102 103 // T6 liar-kill: corrupt the standalone A stream's bit 0 -> DC must mis-decode 104 let bufc: *u8=sys_mmap(512) 105 i=0; while i<512 { bufc[i]=buf[i]; i=i+1 } 106 let b0: i64=bufc[0] as i64 107 if b0>=128 { bufc[0]=(b0-128) as u8 } else { bufc[0]=(b0+128) as u8 } 108 let posc: *i64=sys_mmap(8) as *i64; posc[0]=0 109 let zzC: *i64=sys_mmap(64*8) as *i64 110 jbe_decode_block(bufc, posc, dcCO, dcSI, acCO, acSI, 0, zzC) 111 var t6: i64=0; if zzC[0]!=zzA[0] { t6=1 } 112 113 g_puts("-- block A grad: enc=" as *u8); g_num(encbytes); g_puts("/64B maxErr=" as *u8); g_num(meA) 114 g_puts(" block B flat: maxErr=" as *u8); g_num(meB); g_puts("\n" as *u8) 115 116 var pass: i64=0; let rows: i64=6 117 pass=pass+g_check(" T1 A: quantized coeffs round-trip bit-exact thru entropy" as *u8, t1) 118 var t2: i64=0; if meA <= 24 { t2=1 } 119 pass=pass+g_check(" T2 A: reconstruction faithful (maxErr<=24)" as *u8, t2) 120 var t3: i64=0; if encbytes < 64 { t3=1 } 121 pass=pass+g_check(" T3 A: compresses below raw 64 bytes" as *u8, t3) 122 pass=pass+g_check(" T4 DC differential across TWO chained blocks" as *u8, t4) 123 var t5: i64=0; if meB <= 4 { t5=1 } 124 pass=pass+g_check(" T5 B: flat block near-exact (maxErr<=4)" as *u8, t5) 125 pass=pass+g_check(" T6 liar-kill: corrupted stream diverges" as *u8, t6) 126 127 g_puts("----\nJBLK rows=" as *u8); g_num(rows); g_puts(" pass=" as *u8); g_num(pass); g_puts("\n" as *u8) 128 let lg: i64=sys_openat_append("knowledge/status/jpeg_block_enc_gate.log" as *u8, 0x1a4) 129 if lg>=0 { g_w(lg, "JBLK rows=" as *u8); g_wn(lg, rows); g_w(lg, " pass=" as *u8); g_wn(lg, pass); g_w(lg, " encA=" as *u8); g_wn(lg, encbytes); g_w(lg, " maxErrA=" as *u8); g_wn(lg, meA); if pass==rows { g_w(lg, " verdict=GREEN\n" as *u8) } else { g_w(lg, " verdict=RED\n" as *u8) } sys_close(lg) } 130 if pass==rows { g_puts("JBLK GREEN (sovereign JPEG per-block encode chain proven, round-trip)\n" as *u8); sys_exit(0); return 0 } 131 g_puts("JBLK RED\n" as *u8); sys_exit(1); return 1 132}