nx_vcodec_t8blk_gate.nx source

1import "nx_gate_base.nx" 2// nx_vcodec_t8blk_gate.nx -- REPRODUCE + LOCALIZE the field report "?t8=1 still blocky" (operator, 3// build 786 field test). PSNR-parity gates passed, so the artifact is PERCEPTUAL structure: measure the 4// 8-px-grid BLOCKINESS RATIO (boundary gradient energy / interior gradient energy x100, the deblock 5// gate's metric at the 8 grid) SEPARATELY on the LUMA and CHROMA planes of decoded frames, legacy stream 6// vs t8 stream, at call-ladder qps on (a) flat-gradient synthetic (banding-prone) and (b) the REAL held-out 7// frames. A t8 ratio well above legacy on some plane = the measured culprit. REPORT-ONLY diagnostics plus 8// hard checks that the tool works (decodes bit-exact). license_tier: ORIGINAL 9import "nx_syscalls.nx" 10import "nx_video_codec_wasm.nx" 11 12func grow(name: *u8, ok: i64) -> i64 { if ok==1 { gw(" PASS " as *u8) } else { gw(" FAIL " as *u8) } gw(name); gw(" 13" as *u8); return ok } 14func gn(v: i64) -> i64 { 15 let b: *u8=sys_mmap(28); var m: i64=v; if m<0{sys_write(1,"-" as *u8,1);m=0-m} 16 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} 17 var i: i64=0; while i<k{b[i]=t[k-1-i];i=i+1} sys_write(1,b,k); return 0 } 18func eqb(a: *u8, b: *u8, n: i64) -> i64 { var i: i64=0; while i<n { if (a[i]&0xff)!=(b[i]&0xff) { return 0 } i=i+1 } return 1 } 19func cpb(d: *u8, s: *u8, n: i64) -> i64 { var i: i64=0; while i<n { d[i]=s[i]; i=i+1 } return 0 } 20func absi(x: i64) -> i64 { if x<0 { return 0-x } return x } 21 22// blockiness at the g-px grid: (mean |step| across grid columns+rows) *100 / (mean |step| elsewhere) 23func blki(p: *u8, W: i64, H: i64, g: i64) -> i64 { 24 var bs: i64=0; var bn: i64=0; var isum: i64=0; var iN: i64=0 25 var y: i64=0 26 while y<H { var x: i64=1 27 while x<W { let d: i64=absi((p[y*W+x]&0xff)-(p[y*W+x-1]&0xff)) 28 if (x % g)==0 { bs=bs+d; bn=bn+1 } else { isum=isum+d; iN=iN+1 } x=x+1 } y=y+1 } 29 var y2: i64=1 30 while y2<H { var x2: i64=0 31 while x2<W { let d2: i64=absi((p[y2*W+x2]&0xff)-(p[(y2-1)*W+x2]&0xff)) 32 if (y2 % g)==0 { bs=bs+d2; bn=bn+1 } else { isum=isum+d2; iN=iN+1 } x2=x2+1 } y2=y2+1 } 33 if iN==0 { return 0 } 34 if isum==0 { return 999 } 35 return (bs*iN*100)/(isum*bn) } 36 37// smooth skin-like content: broad gradients + a soft blob; chroma gently varying (banding-prone everywhere) 38func fill_smooth(yuv: *u8, W: i64, H: i64, sh: i64) -> i64 { 39 let N: i64=W*H; let C2: i64=(W/2)*(H/2) 40 var r: i64=0 41 while r<H { var c: i64=0 42 while c<W { 43 var v: i64 = 70 + (c + sh)/6 + r/8 44 let dx: i64 = c - W/2 45 let dy: i64 = r - H/2 46 let d2: i64 = (dx*dx + dy*dy) / 900 47 if d2 < 40 { v = v + 40 - d2 } 48 if v<0{v=0} if v>255{v=255} 49 yuv[r*W+c]=v as u8; c=c+1 } r=r+1 } 50 var i: i64=0 51 while i<C2 { let cr: i64=i/(W/2); let cc: i64=i%(W/2) 52 yuv[N+i]=(110 + (cc+sh)/10 + cr/16) as u8 53 yuv[N+C2+i]=(140 - cc/12 - cr/20) as u8 54 i=i+1 } 55 return 0 } 56 57func seedctx(rctx: *i64, emode: i64, est: *i64, probs: *i64, rcbuf: *u8, t8c: *i64) -> i64 { 58 rctx[0]=emode; rctx[1]=est as i64; rctx[2]=probs as i64; rctx[3]=rcbuf as i64; rctx[4]=t8c as i64 59 rctx[5]=0; rctx[6]=0; rctx[7]=0; return 0 } 60 61// encode+decode a 4-frame chain (key+3P); measure plane blockiness on the LAST decoded frame. 62// kind 0 = legacy vv_enc, 1 = vv_enc_t8. out[0]=luma blk8, out[1]=chroma blk8, out[2]=exact frames. 63func run_blk(src: *u8, W: i64, H: i64, srcstride: i64, nsrc: i64, qp: i64, kind: i64, bufs: *i64, out: *i64) -> i64 { 64 let N: i64=W*H; let C2: i64=(W/2)*(H/2); let sz: i64=N+2*C2 65 let prevE: *u8 = bufs[0] as *u8 66 let reconE: *u8 = bufs[1] as *u8 67 let prevD: *u8 = bufs[2] as *u8 68 let reconD: *u8 = bufs[3] as *u8 69 let wire: *u8 = bufs[4] as *u8 70 let blk: *i64 = bufs[5] as *i64 71 let mv: *i64 = bufs[6] as *i64 72 let est: *i64 = bufs[7] as *i64 73 let probs: *i64 = bufs[8] as *i64 74 let rcbuf: *u8 = bufs[9] as *u8 75 let t8c: *i64 = bufs[10] as *i64 76 let rctx: *i64 = bufs[11] as *i64 77 var z: i64=0 78 while z<sz { prevE[z]=0 as u8; prevD[z]=0 as u8; z=z+1 } 79 var exact: i64=0 80 var f: i64=0 81 while f<4 { 82 var si: i64 = f 83 if si >= nsrc { si = nsrc - 1 } 84 let cur: *u8 = ((src as i64) + si*srcstride) as *u8 85 var key: i64=0 86 if f==0 { key=1 } 87 var nb: i64=0 88 if kind==1 { seedctx(rctx, 0, est, probs, rcbuf, t8c) 89 nb = vv_enc_t8(cur, prevE, reconE, W, H, qp, key, qp*188, wire, 4194304, blk, mv, rctx) } 90 else { nb = vv_enc(cur, prevE, reconE, W, H, qp, key, qp*188, wire, 4194304, blk, mv) } 91 if nb <= 0 { out[0]=0; out[1]=0; out[2]=exact; return 0-1 } 92 if kind==1 { seedctx(rctx, 0, est, probs, rcbuf, t8c) 93 vv_dec_t8(prevD, reconD, W, H, qp, wire, nb, blk, mv, rctx) } 94 else { vv_dec(prevD, reconD, W, H, qp, wire, nb, blk, mv) } 95 if eqb(reconD, reconE, sz)==1 { exact=exact+1 } 96 cpb(prevE, reconE, sz) 97 cpb(prevD, reconD, sz) 98 f=f+1 99 } 100 out[0] = blki(reconD, W, H, 8) 101 let cw: i64 = W/2 102 let ch: i64 = H/2 103 let up: *u8 = ((reconD as i64) + N) as *u8 104 let vp: *u8 = ((reconD as i64) + N + C2) as *u8 105 let bu: i64 = blki(up, cw, ch, 8) 106 let bv: i64 = blki(vp, cw, ch, 8) 107 var bc: i64 = bu 108 if bv > bc { bc = bv } 109 out[1] = bc 110 out[2] = exact 111 return 0 } 112 113func main() -> i64 { 114 gw("=== nx_vcodec_t8blk_gate: WHERE is the field blockiness? 8-grid ratio, legacy vs t8, per plane ===\n" as *u8) 115 let W: i64=256; let H: i64=192 116 let N: i64=W*H; let C2: i64=(W/2)*(H/2); let sz: i64=N+2*C2 117 let syn: *u8 = sys_mmap(4*sz + 64) 118 var f: i64=0 119 while f<4 { fill_smooth(((syn as i64)+f*sz) as *u8, W, H, f*3); f=f+1 } 120 let bufs: *i64 = sys_mmap(16*8) as *i64 121 bufs[0]=sys_mmap(sz+64) as i64 122 bufs[1]=sys_mmap(sz+64) as i64 123 bufs[2]=sys_mmap(sz+64) as i64 124 bufs[3]=sys_mmap(sz+64) as i64 125 bufs[4]=sys_mmap(4194304) as i64 126 bufs[5]=sys_mmap(512) as i64 127 bufs[6]=sys_mmap(128) as i64 128 bufs[7]=sys_mmap(64) as i64 129 bufs[8]=sys_mmap(32*8) as i64 130 bufs[9]=sys_mmap(1048576) as i64 131 bufs[10]=sys_mmap(5120) as i64 132 bufs[11]=sys_mmap(64) as i64 133 vc_t8_init(bufs[10] as *i64) 134 let oL: *i64=sys_mmap(32) as *i64 135 let oT: *i64=sys_mmap(32) as *i64 136 let qs: *i64=sys_mmap(32) as *i64 137 qs[0]=20; qs[1]=32; qs[2]=40 138 var pass: i64=0 139 var total: i64=0 140 gw(" SMOOTH synthetic 256x192 (skin/gradient class):\n" as *u8) 141 var qi: i64=0 142 while qi<3 { 143 run_blk(syn, W, H, sz, 4, qs[qi], 0, bufs, oL) 144 run_blk(syn, W, H, sz, 4, qs[qi], 1, bufs, oT) 145 gw(" qp=" as *u8); gn(qs[qi]) 146 gw(" LUMA legacy=" as *u8); gn(oL[0]); gw(" t8=" as *u8); gn(oT[0]) 147 gw(" CHROMA legacy=" as *u8); gn(oL[1]); gw(" t8=" as *u8); gn(oT[1]) 148 gw(" exact=" as *u8); gn(oT[2]); gw("/4\n" as *u8) 149 total=total+1 150 if oT[2]==4 { pass=pass+1 } 151 qi=qi+1 152 } 153 // REAL frames (held-out) at the file geometry 154 let box: *i64=sys_mmap(16) as *i64 155 let yuv: *u8=sys_read_file("/mnt/c/Users/elder/nishi-core/nxc2/knowledge/staging/media/bframe_test_decoded.yuv" as *u8, box) 156 if (yuv as i64) != 0 { 157 let RW: i64=576 158 let RH: i64=1024 159 let rsz: i64=RW*RH + (RW*RH)/2 160 let rb: *i64=sys_mmap(16*8) as *i64 161 let rN: i64=RW*RH 162 let rfull: i64=rN + 2*((RW/2)*(RH/2)) 163 rb[0]=sys_mmap(rfull+64) as i64 164 rb[1]=sys_mmap(rfull+64) as i64 165 rb[2]=sys_mmap(rfull+64) as i64 166 rb[3]=sys_mmap(rfull+64) as i64 167 rb[4]=bufs[4] 168 rb[5]=bufs[5] 169 rb[6]=bufs[6] 170 rb[7]=bufs[7] 171 rb[8]=bufs[8] 172 rb[9]=bufs[9] 173 rb[10]=bufs[10] 174 rb[11]=bufs[11] 175 gw(" REAL frames 8..11 576x1024:\n" as *u8) 176 qi=0 177 while qi<3 { 178 let base: *u8 = ((yuv as i64) + 8*rsz) as *u8 179 run_blk(base, RW, RH, rsz, 4, qs[qi], 0, rb, oL) 180 run_blk(base, RW, RH, rsz, 4, qs[qi], 1, rb, oT) 181 gw(" qp=" as *u8); gn(qs[qi]) 182 gw(" LUMA legacy=" as *u8); gn(oL[0]); gw(" t8=" as *u8); gn(oT[0]) 183 gw(" CHROMA legacy=" as *u8); gn(oL[1]); gw(" t8=" as *u8); gn(oT[1]) 184 gw(" exact=" as *u8); gn(oT[2]); gw("/4\n" as *u8) 185 total=total+1 186 if oT[2]==4 { pass=pass+1 } 187 qi=qi+1 188 } 189 } 190 gw("T8BLK: " as *u8); gn(pass); gw("/" as *u8); gn(total) 191 if pass==total { gw(" decode-sane; READ the ratios above -- t8 >> legacy on a plane = the culprit\n" as *u8); return 0 } 192 gw(" RED (decode broken -- fix before reading ratios)\n" as *u8); return 1 }