nx_h264_fdct_gate.nx source

1// nx_h264_fdct_gate.nx -- SOVEREIGN gate for the H.264 forward transform + quant (the encoder core, R6). 2// Proof = CROSS-VALIDATION against the already-proven decode-side inverse: residual X --fdct--> --fquant(qp)--> 3// levels --nx_h264_dequant--> --nx_idct4x4--> X'. If the forward pair matches the spec (and the inverse), X' 4// reconstructs X within the quantization error. Plus a known-vector: a FLAT residual must transform to DC-only. 5// Every number PRINTED (no overclaim). GREEN iff flat->DC-only AND the fine-quant (qp6) round-trip is faithful. 6// license_tier: ORIGINAL 7import "nx_syscalls.nx" 8import "nx_h264_fdct.nx" 9import "nx_h264_dequant.nx" 10import "nx_h264_idct.nx" 11import "nx_h264_zigzag.nx" // inverse zigzag, to round-trip the forward 12 13func 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 } 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 iabs(v: i64) -> i64 { if v<0 { return 0-v } return v } 16 17// one round-trip at qp -> returns maxErr; prints qp/maxErr/nonzero-levels. 18func rt(X: *i64, qp: i64) -> i64 { 19 let Y: *i64=sys_mmap(16*8) as *i64; var i: i64=0; while i<16 { Y[i]=X[i]; i=i+1 } 20 nx_h264_fdct4x4(Y) 21 let Z: *i64=sys_mmap(16*8) as *i64; nx_h264_fquant4x4(Y, qp, Z) 22 let W: *i64=sys_mmap(16*8) as *i64; nx_h264_dequant4x4(Z, qp, W) 23 nx_idct4x4(W) 24 var maxe: i64=0; var nnz: i64=0; i=0 25 while i<16 { let e: i64=iabs(W[i]-X[i]); if e>maxe{maxe=e} if Z[i]!=0{nnz=nnz+1} i=i+1 } 26 g_puts(" qp="); g_num(qp); g_puts(" maxErr="); g_num(maxe); g_puts(" nonzero_levels="); g_num(nnz); g_puts("/16\n") 27 return maxe 28} 29 30func main() -> i64 { 31 g_puts("=== H264 FDCT/FQUANT GATE: forward transform+quant cross-validated vs the proven inverse ===\n") 32 33 // T1: flat residual all=8 -> forward transform -> DC=128, every AC = 0 34 let F: *i64=sys_mmap(16*8) as *i64; var i: i64=0; while i<16 { F[i]=8; i=i+1 } 35 nx_h264_fdct4x4(F) 36 var flatok: i64=1; if F[0]!=128 { flatok=0 } i=1; while i<16 { if F[i]!=0 { flatok=0 } i=i+1 } 37 g_puts(" T1 flat[8] -> DC="); g_num(F[0]); g_puts(" (expect 128) + AC all zero: "); if flatok==1 { g_puts("PASS\n" as *u8) } else { g_puts("FAIL\n" as *u8) } 38 39 // T2: round-trip a smooth residual at several qp (fine -> coarse) 40 let X: *i64=sys_mmap(16*8) as *i64; i=0 41 while i<16 { let r: i64=i/4; let c: i64=i%4; X[i]=(r+c)*6 - 18; i=i+1 } // smooth, range -18..+18 42 g_puts(" T2 round-trip (fdct -> fquant -> dequant -> idct), smooth residual:\n" as *u8) 43 let e6: i64=rt(X, 6) 44 let e16: i64=rt(X, 16) 45 let e28: i64=rt(X, 28) 46 var rtok: i64=1; if e6 > 6 { rtok=0 } 47 48 // T3: forward zigzag round-trips with the inverse (raster -> scan -> raster') 49 let RA: *i64=sys_mmap(16*8) as *i64; i=0; while i<16 { RA[i]=i*3 - 20; i=i+1 } 50 let SC: *i64=sys_mmap(16*8) as *i64; nx_h264_fwd_zigzag4x4(RA, SC) 51 let RB: *i64=sys_mmap(16*8) as *i64; nx_h264_inv_zigzag4x4(SC, RB) 52 var zzok: i64=1; i=0; while i<16 { if RB[i]!=RA[i] { zzok=0 } i=i+1 } 53 g_puts(" T3 forward-zigzag round-trip (raster->scan->raster): " as *u8); if zzok==1 { g_puts("PASS\n" as *u8) } else { g_puts("FAIL\n" as *u8) } 54 55 g_puts("----\n" as *u8) 56 var pass: i64=0 57 if flatok==1 { pass=pass+1 } 58 if rtok==1 { pass=pass+1 } 59 if zzok==1 { pass=pass+1 } 60 g_puts("H264FDCT flat_DC=" as *u8); if flatok==1 { g_puts("ok" as *u8) } else { g_puts("BAD" as *u8) } 61 g_puts(" qp6_maxErr=" as *u8); g_num(e6); g_puts(" (faithful<=6) qp16=" as *u8); g_num(e16); g_puts(" qp28=" as *u8); g_num(e28); g_puts("\n" as *u8) 62 if pass==3 { g_puts("H264FDCT GREEN (forward transform+quant round-trips the inverse; forward zigzag round-trips)\n" as *u8); sys_exit(0); return 0 } 63 g_puts("H264FDCT RED\n" as *u8); sys_exit(1); return 1 64}