code wiki / (root) / nx_h264_decode_frame.nx
`nx_h264_decode_frame.nx` source

↩ module page · 927 lines · 42831 B
1// nx_h264_decode_frame.nx -- FULL-FRAME H.264 decoder (Constrained Baseline, CAVLC,
2// 4:2:0, single I-slice).  STAGE 5a: walk EVERY macroblock of frame 0 of realtest.mp4,
3// fully entropy-decoding it (consuming bits exactly) while tracking per-4x4-block
4// TotalCoeff (for nC neighbour context), running QP, and intra4x4 modes.  Proves
5// frame-wide entropy sync: all mbW*mbH MBs parse with valid mb_type and the reader
6// lands at the rbsp end.  Reconstruction + pixel compare come in the next stages.
7// license_tier: ORIGINAL
8import "nx_syscalls.nx"
9import "nx_mp4_demux.nx"
10import "nx_mp4_stbl.nx"
11import "nx_h264_bits.nx"
12import "nx_h264_sps.nx"
13import "nx_h264_pps.nx"
14import "nx_h264_nal.nx"
15import "nx_h264_slice.nx"
16import "nx_h264_mb.nx"
17import "nx_h264_mb_pred.nx"
18import "nx_h264_coeff_token.nx"
19import "nx_h264_cavlc_level.nx"
20import "nx_h264_residual.nx"
21import "nx_h264_nc.nx"
22import "nx_h264_zigzag.nx"
23import "nx_h264_hadamard.nx"
24import "nx_h264_dequant.nx"
25import "nx_h264_idct.nx"
26import "nx_h264_intra16.nx"
27import "nx_h264_intra.nx"
28import "nx_h264_deblock.nx"
29import "nx_h264_chroma_pred.nx"
30import "nx_h264_chroma.nx"
31
32func gp(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
33func gn(v: i64) -> i64 {
  let bb: *u8 = sys_mmap(28); var m: i64 = v
  if m < 0 { sys_write(1, "-\x00" as *u8, 1); 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(1, bb, k)
  return 0
43}
44func find_tag(b: *u8, start: i64, end: i64, s: *u8) -> i64 {
  var i: i64 = start
  while i + 4 <= end { if mp4_t4(b, i, s) == 1 { return i - 4 } i = i + 1 }
  return 0 - 1
48}
49
50// decode one luma 4x4 residual block: look up nC from neighbour TotalCoeff, decode,
51// store this block's TotalCoeff. bx,by = absolute 4x4 block coords. returns TotalCoeff.
52func dec_luma(br: *BitReader, lumaTC: *i64, lbW: i64, bx: i64, by: i64, maxc: i64, coeff: *i64) -> i64 {
  var nA: i64 = 0
  var avA: i64 = 0
  if bx > 0 { nA = lumaTC[by * lbW + (bx - 1)]; avA = 1 }
  var nB: i64 = 0
  var avB: i64 = 0
  if by > 0 { nB = lumaTC[(by - 1) * lbW + bx]; avB = 1 }
  let nC: i64 = nx_h264_nc_luma(nA, avA, nB, avB)
  let tc: i64 = nx_h264_residual_decode(br, maxc, nC, coeff)
  lumaTC[by * lbW + bx] = tc
  return tc
63}
64
65// decode one chroma 4x4 AC block (component map cTC). cbx,cby absolute chroma 4x4 coords.
66func dec_chroma_ac(br: *BitReader, cTC: *i64, cbW: i64, cbx: i64, cby: i64, coeff: *i64) -> i64 {
  var nA: i64 = 0
  var avA: i64 = 0
  if cbx > 0 { nA = cTC[cby * cbW + (cbx - 1)]; avA = 1 }
  var nB: i64 = 0
  var avB: i64 = 0
  if cby > 0 { nB = cTC[(cby - 1) * cbW + cbx]; avB = 1 }
  let nC: i64 = nx_h264_nc_luma(nA, avA, nB, avB)
  let tc: i64 = nx_h264_residual_decode(br, 15, nC, coeff)
  cTC[cby * cbW + cbx] = tc
  return tc
77}
78
79// I_16x16 luma DC: scan dc block -> raster -> 4x4 Hadamard -> QP scale -> dcY[16] raster
80func i16_dc_scale(dcblk: *i64, qp: i64, dcY: *i64) -> i64 {
  let dcras: *i64 = sys_mmap(16*8) as *i64
  nx_h264_inv_zigzag4x4(dcblk, dcras)
  nx_h264_hadamard4x4(dcras)
  let na: *i64 = sys_mmap(8*8) as *i64
  na[0]=10; na[1]=11; na[2]=13; na[3]=14; na[4]=16; na[5]=18
  let ls: i64 = 16 * na[qp % 6]
  let sh6: i64 = qp / 6
  var qi: i64 = 0
  while qi < 16 {
      var v: i64 = 0
      if qp >= 36 { v = (dcras[qi] * ls) << (sh6 - 6) }
      if qp < 36 { v = asr(dcras[qi] * ls + (1 << (5 - sh6)), 6 - sh6) }
      dcY[qi] = v
      qi = qi + 1
  }
  return 0
97}
98
99// reconstruct a full I_16x16 luma MB at (px,py) into yf. acstore[r*16+0..15] holds the
100// AC scan block (pos0=0) per raster 4x4 block r; dcY[r] the scaled DC. predMode 0..3.
101func recon_i16_luma(yf: *u8, W: i64, px: i64, py: i64, predMode: i64, dcY: *i64, acstore: *i64, qp: i64) -> i64 {
  let availT: i64 = 0
  var aT: i64 = 0
  if py > 0 { aT = 1 }
  var aL: i64 = 0
  if px > 0 { aL = 1 }
  let top: *i64 = sys_mmap(16*8) as *i64
  let left: *i64 = sys_mmap(16*8) as *i64
  var k: i64 = 0
  while k < 16 {
      var tv: i64 = 0
      if aT == 1 { tv = yf[(py-1)*W + px + k] as i64 }
      top[k] = tv
      var lv: i64 = 0
      if aL == 1 { lv = yf[(py+k)*W + px - 1] as i64 }
      left[k] = lv
      k = k + 1
  }
  var tl: i64 = 0
  if aT == 1 { if aL == 1 { tl = yf[(py-1)*W + px - 1] as i64 } }
  let pred: *i64 = sys_mmap(256*8) as *i64
  nx_intra16x16_pred_full(predMode, top, left, tl, aT, aL, pred)
  let scan: *i64 = sys_mmap(16*8) as *i64
  let dq: *i64 = sys_mmap(16*8) as *i64
  var br: i64 = 0
  while br < 4 {
      var bc: i64 = 0
      while bc < 4 {
          let r: i64 = br * 4 + bc
          var z: i64 = 0
          while z < 16 { scan[z] = acstore[r*16 + z]; z = z + 1 }
          let rast: *i64 = sys_mmap(16*8) as *i64
          nx_h264_inv_zigzag4x4(scan, rast)
          nx_h264_dequant4x4(rast, qp, dq)
          dq[0] = dcY[r]
          nx_idct4x4(dq)
          var py4: i64 = 0
          while py4 < 4 {
              var px4: i64 = 0
              while px4 < 4 {
                  var val: i64 = pred[(br*4 + py4)*16 + (bc*4 + px4)] + dq[py4*4 + px4]
                  if val < 0 { val = 0 }
                  if val > 255 { val = 255 }
                  yf[(py + br*4 + py4)*W + (px + bc*4 + px4)] = val as u8
                  px4 = px4 + 1
              }
              py4 = py4 + 1
          }
          bc = bc + 1
      }
      br = br + 1
  }
  return 0
154}
155
156// reconstruct ONE I_4x4 luma block at pixel (bpx,bpy). coeffscan = 16 scan-order levels.
157// availability flags pre-computed by caller from the decoded-block bitmap.
158func recon_i4_block(yf: *u8, W: i64, bpx: i64, bpy: i64, mode: i64, aT: i64, aL: i64, aTL: i64, aTR: i64, coeffscan: *i64, qp: i64) -> i64 {
  let top: *i64 = sys_mmap(8*8) as *i64
  let left: *i64 = sys_mmap(4*8) as *i64
  var k: i64 = 0
  while k < 4 {
      var tv: i64 = 0
      if aT == 1 { tv = yf[(bpy-1)*W + bpx + k] as i64 }
      top[k] = tv
      var lv: i64 = 0
      if aL == 1 { lv = yf[(bpy+k)*W + bpx - 1] as i64 }
      left[k] = lv
      k = k + 1
  }
  // top-right (top[4..7]): from above-right block if available, else replicate top[3]
  k = 0
  while k < 4 {
      var tv: i64 = top[3]
      if aTR == 1 { tv = yf[(bpy-1)*W + bpx + 4 + k] as i64 }
      if aT == 0 { tv = 0 }
      top[4 + k] = tv
      k = k + 1
  }
  var tl: i64 = 0
  if aTL == 1 { tl = yf[(bpy-1)*W + bpx - 1] as i64 }
  let pred: *i64 = sys_mmap(16*8) as *i64
  nx_intra4x4_pred_full(mode, top, left, tl, aT, aL, pred)
  let rast: *i64 = sys_mmap(16*8) as *i64
  nx_h264_inv_zigzag4x4(coeffscan, rast)
  let dq: *i64 = sys_mmap(16*8) as *i64
  nx_h264_dequant4x4(rast, qp, dq)
  nx_idct4x4(dq)
  var yy: i64 = 0
  while yy < 4 {
      var xx: i64 = 0
      while xx < 4 {
          var val: i64 = pred[yy*4 + xx] + dq[yy*4 + xx]
          if val < 0 { val = 0 }
          if val > 255 { val = 255 }
          yf[(bpy + yy)*W + (bpx + xx)] = val as u8
          xx = xx + 1
      }
      yy = yy + 1
  }
  return 0
202}
203
204// reconstruct one 8x8 chroma component (4:2:0) into cf at chroma-plane pixel (cpx,cpy).
205// cdc[4] = decoded 2x2 DC levels (raster c00,c01,c10,c11); acstore[blk*16+0..15] = AC scan per 4x4
206// block (blk=by*2+bx, pos0 unused -> 0); predMode 0 DC/1 H/2 V/3 plane; qpc = chroma QP. Mirrors
207// recon_i16_luma: predict -> per-block (AC dequant, DC := scaled chroma DC) -> idct -> +pred -> clip.
208func recon_chroma_comp(cf: *u8, cW: i64, cpx: i64, cpy: i64, predMode: i64, cdc: *i64, acstore: *i64, qpc: i64, availT: i64, availL: i64) -> i64 {
  let top: *i64 = sys_mmap(8*8) as *i64
  let left: *i64 = sys_mmap(8*8) as *i64
  var k: i64 = 0
  while k < 8 {
      var tv: i64 = 0
      if availT == 1 { tv = cf[(cpy-1)*cW + cpx + k] as i64 }
      top[k] = tv
      var lv: i64 = 0
      if availL == 1 { lv = cf[(cpy+k)*cW + cpx - 1] as i64 }
      left[k] = lv
      k = k + 1
  }
  var tl: i64 = 0
  if availT == 1 { if availL == 1 { tl = cf[(cpy-1)*cW + cpx - 1] as i64 } }
  let pred: *i64 = sys_mmap(64*8) as *i64
  nx_intra_chroma_pred(predMode, top, left, tl, availT, availL, pred)
  let cc: *i64 = sys_mmap(8*8) as *i64
  var di: i64 = 0
  while di < 4 { cc[di] = cdc[di]; di = di + 1 }
  let dcC: *i64 = sys_mmap(8*8) as *i64
  nx_h264_chroma_dc_scale(cc, qpc, dcC)
  let scan: *i64 = sys_mmap(16*8) as *i64
  let rast: *i64 = sys_mmap(16*8) as *i64
  let dq: *i64 = sys_mmap(16*8) as *i64
  var by: i64 = 0
  while by < 2 {
      var bx: i64 = 0
      while bx < 2 {
          let blk: i64 = by*2 + bx
          var z: i64 = 0
          while z < 16 { scan[z] = acstore[blk*16 + z]; z = z + 1 }
          nx_h264_inv_zigzag4x4(scan, rast)
          nx_h264_dequant4x4(rast, qpc, dq)
          dq[0] = dcC[blk]
          nx_idct4x4(dq)
          var yy: i64 = 0
          while yy < 4 {
              var xx: i64 = 0
              while xx < 4 {
                  var val: i64 = pred[(by*4+yy)*8 + (bx*4+xx)] + dq[yy*4 + xx]
                  if val < 0 { val = 0 }
                  if val > 255 { val = 255 }
                  cf[(cpy + by*4 + yy)*cW + (cpx + bx*4 + xx)] = val as u8
                  xx = xx + 1
              }
              yy = yy + 1
          }
          bx = bx + 1
      }
      by = by + 1
  }
  return 0
261}
262
263// chroma QPc from luma QP + chroma_qp_index_offset (clip to [0,51], 8-bit).
264func chroma_qpc(qpL: i64, cqo: i64) -> i64 {
  var q: i64 = qpL + cqo
  if q < 0 { q = 0 }
  if q > 51 { q = 51 }
  return nx_h264_chroma_qp(q)
269}
270
271func main(argc: i64, argv: *i64) -> i64 {
  let szp: *i64 = sys_mmap(16) as *i64
  // PARAMETERISED 2026-08-01: this whole mp4 -> pixels chain already existed
  // (avcC -> SPS/PPS -> nx_mp4_video_info -> per-macroblock recon) but was
  // hardcoded to a test fixture, so the capability was unreachable. The
  // container share is 386 of the sweep refusals vs 121 for CABAC.
  var inpath: *u8 = "knowledge/staging/media/realtest.mp4\x00" as *u8
  if argc >= 2 { inpath = argv[1] as *u8 }
  let b: *u8 = sys_read_file(inpath, szp)
  if (b as i64) == 0 { gp("decode_frame: cannot read input mp4\n\x00" as *u8); return 1 }
  let len: i64 = szp[0]
282
  // SPS + PPS
  let avcc: i64 = find_tag(b, 0, len, "avcC\x00" as *u8)
  let pay: i64 = avcc + 8
  let spsLen: i64 = (b[pay + 6] as i64) * 256 + (b[pay + 7] as i64)
  let spsdst: *u8 = sys_mmap(spsLen + 16)
  let spsrbsp: i64 = nx_h264_unescape_rbsp((b as i64 + pay + 9) as *u8, spsLen - 1, spsdst)
  let sps: *i64 = sys_mmap(128) as *i64
  nx_h264_parse_sps(spsdst, spsrbsp, sps)
  let ppspos: i64 = pay + 8 + spsLen
  let ppsLen: i64 = (b[ppspos + 1] as i64) * 256 + (b[ppspos + 2] as i64)
  let ppsdst: *u8 = sys_mmap(ppsLen + 16)
  let ppsrbsp: i64 = nx_h264_unescape_rbsp((b as i64 + ppspos + 3 + 1) as *u8, ppsLen - 1, ppsdst)
  let pps: *i64 = sys_mmap(128) as *i64
  nx_h264_parse_pps(ppsdst, ppsrbsp, pps)
  let W: i64 = sps[2]
  let H: i64 = sps[3]
  let mbW: i64 = W / 16
  let mbH: i64 = H / 16
  gp("  res=\x00" as *u8); gn(W); gp("x\x00" as *u8); gn(H); gp(" mbW=\x00" as *u8); gn(mbW); gp(" mbH=\x00" as *u8); gn(mbH); gp(" totalMBs=\x00" as *u8); gn(mbW * mbH); gp("\n\x00" as *u8)
302
  // sample 0 + slice NAL
  let vi: *i64 = sys_mmap(64) as *i64
  nx_mp4_video_info(b, len, vi)
  let stbl0: i64 = vi[5]
  let stbl1: i64 = vi[6]
  let rco: *i64 = sys_mmap(16) as *i64
  let rsz: *i64 = sys_mmap(16) as *i64
  mp4_find_box(b, stbl0, stbl1, "stco\x00" as *u8, rco)
  mp4_find_box(b, stbl0, stbl1, "stsz\x00" as *u8, rsz)
  let chunk0: i64 = mp4_be32(b, rco[0] + 8)
  let samp_sz_field: i64 = mp4_be32(b, rsz[0] + 4)
  var samp0: i64 = samp_sz_field
  if samp_sz_field == 0 { samp0 = mp4_be32(b, rsz[0] + 12) }
  let offs: *i64 = sys_mmap(256 * 8) as *i64
  let types: *i64 = sys_mmap(256 * 8) as *i64
  let nc: i64 = nx_nal_split_avcc(b, chunk0, chunk0 + samp0, 4, offs, types, 256)
  var sidx: i64 = 0 - 1
  var i: i64 = 0
  while i < nc {
      if types[i] == 5 { if sidx < 0 { sidx = i } }
      if types[i] == 1 { if sidx < 0 { sidx = i } }
      i = i + 1
  }
  let noff: i64 = offs[sidx]
  let ntype: i64 = b[noff] as i64
  let nlen: i64 = mp4_be32(b, noff - 4)
  let sl_dst: *u8 = sys_mmap(nlen + 64)
  let sl_rbsp: i64 = nx_h264_unescape_rbsp((b as i64 + noff + 1) as *u8, nlen - 1, sl_dst)
  let sh: *i64 = sys_mmap(64) as *i64
  let sbr: *BitReader = sys_mmap(NX_BR_BYTES) as *BitReader
  br_init(sbr, sl_dst, sl_rbsp)
  nx_h264_parse_slice_header_br(sbr, ntype & 31, (ntype >> 5) & 3, sps[9], sps[11], sps[10], sps[6], pps[3], pps[6], sh)
  gp("  slice_type=\x00" as *u8); gn(sh[8]); gp(" sliceQP=\x00" as *u8); gn(sh[7]); gp(" rbsp_bytes=\x00" as *u8); gn(sl_rbsp)
  gp(" | deblock_idc=\x00" as *u8); gn(sh[9]); gp(" offA=\x00" as *u8); gn(sh[10]); gp(" offB=\x00" as *u8); gn(sh[11]); gp("\n\x00" as *u8)
337
  // per-4x4 TotalCoeff + intra4x4 mode maps
  let lbW: i64 = mbW * 4
  let lbH: i64 = mbH * 4
  let lumaTC: *i64 = sys_mmap(lbW * lbH * 8) as *i64
  let i4m: *i64 = sys_mmap(lbW * lbH * 8) as *i64
  let cbW: i64 = mbW * 2
  let cbH: i64 = mbH * 2
  let uTC: *i64 = sys_mmap(cbW * cbH * 8) as *i64
  let vTC: *i64 = sys_mmap(cbW * cbH * 8) as *i64
  let decoded: *i64 = sys_mmap(lbW * lbH * 8) as *i64
  let yf: *u8 = sys_mmap(W * H + 64)
  let cpW: i64 = W / 2
  let cpH: i64 = H / 2
  let uf: *u8 = sys_mmap(cpW * cpH + 64)
  let vf: *u8 = sys_mmap(cpW * cpH + 64)
  let ucstore: *i64 = sys_mmap(4 * 16 * 8) as *i64
  let vcstore: *i64 = sys_mmap(4 * 16 * 8) as *i64
  var z: i64 = 0
  while z < lbW * lbH { lumaTC[z] = 0; i4m[z] = 2; decoded[z] = 0; z = z + 1 }
  z = 0
  while z < cbW * cbH { uTC[z] = 0; vTC[z] = 0; z = z + 1 }
  z = 0
  while z < W * H { yf[z] = 0 as u8; z = z + 1 }
  let acstore: *i64 = sys_mmap(16 * 16 * 8) as *i64
  let mbQP: *i64 = sys_mmap(mbW * mbH * 8) as *i64
  let mbCls: *i64 = sys_mmap(mbW * mbH * 8) as *i64
364
  // 4x4 luma block scan order -> (blkX,blkY)
  let bx4: *i64 = sys_mmap(16 * 8) as *i64
  let by4: *i64 = sys_mmap(16 * 8) as *i64
  bx4[0]=0; by4[0]=0; bx4[1]=1; by4[1]=0; bx4[2]=0; by4[2]=1; bx4[3]=1; by4[3]=1
  bx4[4]=2; by4[4]=0; bx4[5]=3; by4[5]=0; bx4[6]=2; by4[6]=1; bx4[7]=3; by4[7]=1
  bx4[8]=0; by4[8]=2; bx4[9]=1; by4[9]=2; bx4[10]=0; by4[10]=3; bx4[11]=1; by4[11]=3
  bx4[12]=2; by4[12]=2; bx4[13]=3; by4[13]=2; bx4[14]=2; by4[14]=3; bx4[15]=3; by4[15]=3
372
  let coeff: *i64 = sys_mmap(32 * 8) as *i64
  var qp: i64 = sh[7]
  var coeffsum: i64 = 0
  var nzblocks: i64 = 0
  var i16count: i64 = 0
  var i4count: i64 = 0
  var pcmcount: i64 = 0
  var ok: i64 = 1
  var mbAddr: i64 = 0
  let totalMB: i64 = mbW * mbH
  while mbAddr < totalMB {
      let mbX: i64 = mbAddr % mbW
      let mbY: i64 = mbAddr / mbW
      let mb_type: i64 = nx_h264_mb_parse_itype(sbr)
      if mb_type < 0 { ok = 0; gp("  DESYNC mb_type<0 at mbAddr=\x00" as *u8); gn(mbAddr); gp("\n\x00" as *u8); mbAddr = totalMB; }
      if ok == 1 {
          if mb_type > 25 { ok = 0; gp("  DESYNC mb_type>25 (\x00" as *u8); gn(mb_type); gp(") at mbAddr=\x00" as *u8); gn(mbAddr); gp("\n\x00" as *u8); mbAddr = totalMB; }
      }
      if ok == 1 {
          let cls: i64 = nx_h264_mb_type_class(mb_type)
393
          if cls == 2 {
              // I_PCM: byte-align then raw samples; neighbours count as 16 for nC
              pcmcount = pcmcount + 1
              br_align(sbr)
              var pp: i64 = 0
              while pp < 256 + 64 + 64 { let dummy: i64 = br_read_bits(sbr, 8); pp = pp + 1 }
              var bl: i64 = 0
              while bl < 16 { lumaTC[(mbY*4 + by4[bl]) * lbW + (mbX*4 + bx4[bl])] = 16; bl = bl + 1 }
              var cc: i64 = 0
              while cc < 4 {
                  uTC[(mbY*2 + cc/2) * cbW + (mbX*2 + cc%2)] = 16
                  vTC[(mbY*2 + cc/2) * cbW + (mbX*2 + cc%2)] = 16
                  cc = cc + 1
              }
          }
409
          if cls == 1 {
              // I_16x16
              i16count = i16count + 1
              let der: *i64 = sys_mmap(32) as *i64
              nx_h264_i16x16_derive(mb_type, der)
              let cbpL: i64 = der[2]
              let cbpC: i64 = der[1]
              let chroma_pred: i64 = br_read_ue(sbr)
              let mqd: i64 = br_read_se(sbr)
              qp = (qp + mqd + 52) % 52
              // luma DC (16 coeffs) at block-0 neighbour context
              let bx0: i64 = mbX * 4
              let by0: i64 = mbY * 4
              var nA: i64 = 0
              var avA: i64 = 0
              if bx0 > 0 { nA = lumaTC[by0 * lbW + (bx0 - 1)]; avA = 1 }
              var nB: i64 = 0
              var avB: i64 = 0
              if by0 > 0 { nB = lumaTC[(by0 - 1) * lbW + bx0]; avB = 1 }
              let nCdc: i64 = nx_h264_nc_luma(nA, avA, nB, avB)
              let dcblk: *i64 = sys_mmap(16 * 8) as *i64
              let dctc: i64 = nx_h264_residual_decode(sbr, 16, nCdc, dcblk)
              z = 0
              while z < 16 { coeffsum = coeffsum + dcblk[z] * (z + 1); z = z + 1 }
              z = 0
              while z < 256 { acstore[z] = 0; z = z + 1 }
              var bl: i64 = 0
              while bl < 16 {
                  let abx: i64 = bx0 + bx4[bl]
                  let aby: i64 = by0 + by4[bl]
                  let r: i64 = by4[bl] * 4 + bx4[bl]
                  i4m[aby * lbW + abx] = 2
                  if cbpL != 0 {
                      let tc: i64 = dec_luma(sbr, lumaTC, lbW, abx, aby, 15, coeff)
                      if tc > 0 { nzblocks = nzblocks + 1 }
                      z = 0
                      while z < 15 { coeffsum = coeffsum + coeff[z] * (z + 1); acstore[r*16 + 1 + z] = coeff[z]; z = z + 1 }
                  }
                  if cbpL == 0 { lumaTC[aby * lbW + abx] = 0 }
                  decoded[aby * lbW + abx] = 1
                  bl = bl + 1
              }
              // RECONSTRUCT I_16x16 luma into the frame buffer
              let dcY: *i64 = sys_mmap(16 * 8) as *i64
              i16_dc_scale(dcblk, qp, dcY)
              recon_i16_luma(yf, W, mbX * 16, mbY * 16, der[0], dcY, acstore, qp)
              // chroma DC (U,V) + AC, then RECONSTRUCT into uf/vf
              let ucdc: *i64 = sys_mmap(8 * 8) as *i64
              let vcdc: *i64 = sys_mmap(8 * 8) as *i64
              z = 0
              while z < 4 { ucdc[z] = 0; vcdc[z] = 0; z = z + 1 }
              z = 0
              while z < 64 { ucstore[z] = 0; vcstore[z] = 0; z = z + 1 }
              if cbpC != 0 {
                  nx_h264_residual_decode_cdc(sbr, ucdc)
                  nx_h264_residual_decode_cdc(sbr, vcdc)
                  z = 0
                  while z < 4 { coeffsum = coeffsum + (ucdc[z] + vcdc[z]) * (z + 1); z = z + 1 }
                  if cbpC == 2 {
                      var cc: i64 = 0
                      while cc < 4 {
                          dec_chroma_ac(sbr, uTC, cbW, mbX*2 + (cc%2), mbY*2 + (cc/2), coeff)
                          z = 0
                          while z < 15 { ucstore[cc*16 + 1 + z] = coeff[z]; z = z + 1 }
                          cc = cc + 1
                      }
                      cc = 0
                      while cc < 4 {
                          dec_chroma_ac(sbr, vTC, cbW, mbX*2 + (cc%2), mbY*2 + (cc/2), coeff)
                          z = 0
                          while z < 15 { vcstore[cc*16 + 1 + z] = coeff[z]; z = z + 1 }
                          cc = cc + 1
                      }
                  }
              }
              if cbpC == 0 {
                  var cc: i64 = 0
                  while cc < 4 { uTC[(mbY*2 + cc/2) * cbW + (mbX*2 + cc%2)] = 0; vTC[(mbY*2 + cc/2) * cbW + (mbX*2 + cc%2)] = 0; cc = cc + 1 }
              }
              var qpi16: i64 = qp + pps[9]
              if qpi16 < 0 { qpi16 = 0 }
              if qpi16 > 51 { qpi16 = 51 }
              let qpc16: i64 = nx_h264_chroma_qp(qpi16)
              var caT16: i64 = 0
              if mbY > 0 { caT16 = 1 }
              var caL16: i64 = 0
              if mbX > 0 { caL16 = 1 }
              recon_chroma_comp(uf, cpW, mbX*8, mbY*8, chroma_pred, ucdc, ucstore, qpc16, caT16, caL16)
              recon_chroma_comp(vf, cpW, mbX*8, mbY*8, chroma_pred, vcdc, vcstore, qpc16, caT16, caL16)
          }
500
          if cls == 0 {
              // I_NxN (I_4x4)
              i4count = i4count + 1
              let modes: *i64 = sys_mmap(24 * 8) as *i64
              nx_h264_parse_inxn_predmodes(sbr, modes)
              let cbp: i64 = nx_h264_decode_cbp_intra(sbr)
              let cbpL: i64 = cbp & 15
              let cbpC: i64 = (cbp >> 4) & 3
              if cbp != 0 { let mqd: i64 = br_read_se(sbr); qp = (qp + mqd + 52) % 52 }
              let bx0: i64 = mbX * 4
              let by0: i64 = mbY * 4
              // luma 4x4 blocks: derive mode, decode residual (per 8x8 CBP), reconstruct in scan order
              var bl: i64 = 0
              while bl < 16 {
                  let abx: i64 = bx0 + bx4[bl]
                  let aby: i64 = by0 + by4[bl]
                  let bpx: i64 = mbX * 16 + bx4[bl] * 4
                  let bpy: i64 = mbY * 16 + by4[bl] * 4
                  // intra4x4 mode derivation (8.3.1.1)
                  var avAm: i64 = 0
                  if abx > 0 { if decoded[aby*lbW + abx - 1] == 1 { avAm = 1 } }
                  var avBm: i64 = 0
                  if aby > 0 { if decoded[(aby-1)*lbW + abx] == 1 { avBm = 1 } }
                  var predMode: i64 = 2
                  if avAm == 1 { if avBm == 1 {
                      let ma: i64 = i4m[aby*lbW + abx - 1]
                      let mbb: i64 = i4m[(aby-1)*lbW + abx]
                      predMode = ma
                      if mbb < ma { predMode = mbb }
                  } }
                  var mode: i64 = predMode
                  if modes[bl] >= 0 {
                      let rem: i64 = modes[bl]
                      if rem < predMode { mode = rem }
                      if rem >= predMode { mode = rem + 1 }
                  }
                  i4m[aby*lbW + abx] = mode
                  // residual (only if this 8x8 is luma-coded)
                  let i8: i64 = bl / 4
                  z = 0
                  while z < 16 { coeff[z] = 0; z = z + 1 }
                  if ((cbpL >> i8) & 1) != 0 {
                      let tc: i64 = dec_luma(sbr, lumaTC, lbW, abx, aby, 16, coeff)
                      if tc > 0 { nzblocks = nzblocks + 1 }
                      z = 0
                      while z < 16 { coeffsum = coeffsum + coeff[z] * (z + 1); z = z + 1 }
                  }
                  if ((cbpL >> i8) & 1) == 0 { lumaTC[aby*lbW + abx] = 0 }
                  // reconstruct (availabilities from decoded-block bitmap)
                  var aT: i64 = 0
                  if avBm == 1 { aT = 1 }
                  var aL: i64 = 0
                  if avAm == 1 { aL = 1 }
                  var aTL: i64 = 0
                  if abx > 0 { if aby > 0 { if decoded[(aby-1)*lbW + abx - 1] == 1 { aTL = 1 } } }
                  var aTR: i64 = 0
                  if aby > 0 { if abx + 1 < lbW { if decoded[(aby-1)*lbW + abx + 1] == 1 { aTR = 1 } } }
                  recon_i4_block(yf, W, bpx, bpy, mode, aT, aL, aTL, aTR, coeff, qp)
                  decoded[aby*lbW + abx] = 1
                  bl = bl + 1
              }
              let ucdc4: *i64 = sys_mmap(8 * 8) as *i64
              let vcdc4: *i64 = sys_mmap(8 * 8) as *i64
              z = 0
              while z < 4 { ucdc4[z] = 0; vcdc4[z] = 0; z = z + 1 }
              z = 0
              while z < 64 { ucstore[z] = 0; vcstore[z] = 0; z = z + 1 }
              if cbpC != 0 {
                  nx_h264_residual_decode_cdc(sbr, ucdc4)
                  nx_h264_residual_decode_cdc(sbr, vcdc4)
                  z = 0
                  while z < 4 { coeffsum = coeffsum + (ucdc4[z] + vcdc4[z]) * (z + 1); z = z + 1 }
                  if cbpC == 2 {
                      var cc: i64 = 0
                      while cc < 4 {
                          dec_chroma_ac(sbr, uTC, cbW, mbX*2 + (cc%2), mbY*2 + (cc/2), coeff)
                          z = 0
                          while z < 15 { ucstore[cc*16 + 1 + z] = coeff[z]; z = z + 1 }
                          cc = cc + 1
                      }
                      cc = 0
                      while cc < 4 {
                          dec_chroma_ac(sbr, vTC, cbW, mbX*2 + (cc%2), mbY*2 + (cc/2), coeff)
                          z = 0
                          while z < 15 { vcstore[cc*16 + 1 + z] = coeff[z]; z = z + 1 }
                          cc = cc + 1
                      }
                  }
              }
              if cbpC == 0 {
                  var cc: i64 = 0
                  while cc < 4 { uTC[(mbY*2 + cc/2) * cbW + (mbX*2 + cc%2)] = 0; vTC[(mbY*2 + cc/2) * cbW + (mbX*2 + cc%2)] = 0; cc = cc + 1 }
              }
              var qpi4: i64 = qp + pps[9]
              if qpi4 < 0 { qpi4 = 0 }
              if qpi4 > 51 { qpi4 = 51 }
              let qpc4: i64 = nx_h264_chroma_qp(qpi4)
              var caT4: i64 = 0
              if mbY > 0 { caT4 = 1 }
              var caL4: i64 = 0
              if mbX > 0 { caL4 = 1 }
              recon_chroma_comp(uf, cpW, mbX*8, mbY*8, modes[16], ucdc4, ucstore, qpc4, caT4, caL4)
              recon_chroma_comp(vf, cpW, mbX*8, mbY*8, modes[16], vcdc4, vcstore, qpc4, caT4, caL4)
          }
605
          mbQP[mbAddr] = qp
          mbCls[mbAddr] = cls
          mbAddr = mbAddr + 1
      }
  }
611
  // snapshot pre-deblock recon, then compare vs ffmpeg's no-loop-filter output (isolates recon)
  var bexact: i64 = 1   // strict gate: any plane/pass with MAXDIFF!=0 flips this -> verdict RED
  let yf0: *u8 = sys_mmap(W * H + 64)
  z = 0
  while z < W * H { yf0[z] = yf[z]; z = z + 1 }
  let nzp: *i64 = sys_mmap(16) as *i64
  let refnd: *u8 = sys_read_file("knowledge/staging/media/ref_frame0_nodeblock.yuv\x00" as *u8, nzp)
  if (refnd as i64) != 0 {
      var ndmax: i64 = 0
      var ndexact: i64 = 0
      var pnd: i64 = 0
      while pnd < W * H {
          var dd: i64 = (yf0[pnd] as i64) - (refnd[pnd] as i64)
          if dd < 0 { dd = 0 - dd }
          if dd > ndmax { ndmax = dd }
          if dd == 0 { ndexact = ndexact + 1 }
          pnd = pnd + 1
      }
      gp("  PRE-deblock recon vs ffmpeg(no-loop-filter): exact=\x00" as *u8); gn(ndexact); gp("/\x00" as *u8); gn(W * H)
      gp(" (\x00" as *u8); gn(ndexact * 100 / (W * H)); gp("%) MAXDIFF=\x00" as *u8); gn(ndmax)
      if ndmax == 0 { gp(" *** RECON BIT-EXACT -> remaining diff is purely deblocking ***\n\x00" as *u8) }
      if ndmax != 0 { gp(" (recon has residual diff -> investigate prediction/qp)\n\x00" as *u8) }
      // CHROMA (U,V) pre-deblock vs ffmpeg no-loop-filter ref (planes after luma in the .yuv)
      var cuex: i64 = 0
      var cumax: i64 = 0
      var cvex: i64 = 0
      var cvmax: i64 = 0
      let cbaseo: i64 = W * H
      let csz: i64 = cpW * cpH
      var cp: i64 = 0
      while cp < csz {
          var du: i64 = (uf[cp] as i64) - (refnd[cbaseo + cp] as i64)
          if du < 0 { du = 0 - du }
          if du > cumax { cumax = du }
          if du == 0 { cuex = cuex + 1 }
          var dv: i64 = (vf[cp] as i64) - (refnd[cbaseo + csz + cp] as i64)
          if dv < 0 { dv = 0 - dv }
          if dv > cvmax { cvmax = dv }
          if dv == 0 { cvex = cvex + 1 }
          cp = cp + 1
      }
      gp("  PRE-deblock CHROMA U vs ffmpeg: exact=\x00" as *u8); gn(cuex); gp("/\x00" as *u8); gn(csz); gp(" MAXDIFF=\x00" as *u8); gn(cumax); gp("\n\x00" as *u8)
      gp("  PRE-deblock CHROMA V vs ffmpeg: exact=\x00" as *u8); gn(cvex); gp("/\x00" as *u8); gn(csz); gp(" MAXDIFF=\x00" as *u8); gn(cvmax); gp("\n\x00" as *u8)
      if ndmax != 0 { bexact = 0 }
      if cumax != 0 { bexact = 0 }
      if cvmax != 0 { bexact = 0 }
  }
659
  // ===== in-loop deblocking (luma), per-MB raster order: each MB filters its 4
  // vertical edges (left->right) then its 4 horizontal edges (top->bottom).
  // MB-boundary edges bS=4 (intra), internal 4x4 edges bS=3. =====
  if ok == 1 {
      let s: *i64 = sys_mmap(8 * 8) as *i64
      let ve: *i64 = sys_mmap(8 * 8) as *i64
      ve[0]=0; ve[1]=4; ve[2]=8; ve[3]=12
      var dmy: i64 = 0
      while dmy < mbH {
          var dmx: i64 = 0
          while dmx < mbW {
              let px: i64 = dmx * 16
              let py: i64 = dmy * 16
              let qpMB: i64 = mbQP[dmy * mbW + dmx]
              var ei: i64 = 0
              while ei < 4 {
                  let eo: i64 = ve[ei]
                  let ex: i64 = px + eo
                  var doit: i64 = 1
                  var bs: i64 = 3
                  var qpe: i64 = qpMB
                  if eo == 0 {
                      if dmx == 0 { doit = 0 }
                      if dmx > 0 { bs = 4; qpe = (mbQP[dmy * mbW + (dmx - 1)] + qpMB + 1) >> 1 }
                  }
                  if doit == 1 {
                      var ry: i64 = 0
                      while ry < 16 {
                          let base: i64 = (py + ry) * W + ex
                          s[0] = yf[base - 4] as i64; s[1] = yf[base - 3] as i64; s[2] = yf[base - 2] as i64; s[3] = yf[base - 1] as i64
                          s[4] = yf[base] as i64; s[5] = yf[base + 1] as i64; s[6] = yf[base + 2] as i64; s[7] = yf[base + 3] as i64
                          if bs == 4 { nx_deblock_luma_bs4(s, qpe) }
                          if bs < 4 { nx_deblock_luma_edge(s, bs, qpe) }
                          yf[base - 3] = s[1] as u8; yf[base - 2] = s[2] as u8; yf[base - 1] = s[3] as u8
                          yf[base] = s[4] as u8; yf[base + 1] = s[5] as u8; yf[base + 2] = s[6] as u8
                          ry = ry + 1
                      }
                  }
                  ei = ei + 1
              }
              ei = 0
              while ei < 4 {
                  let eo: i64 = ve[ei]
                  let ey: i64 = py + eo
                  var doit: i64 = 1
                  var bs: i64 = 3
                  var qpe: i64 = qpMB
                  if eo == 0 {
                      if dmy == 0 { doit = 0 }
                      if dmy > 0 { bs = 4; qpe = (mbQP[(dmy - 1) * mbW + dmx] + qpMB + 1) >> 1 }
                  }
                  if doit == 1 {
                      var rx: i64 = 0
                      while rx < 16 {
                          let col: i64 = px + rx
                          s[0] = yf[(ey - 4) * W + col] as i64; s[1] = yf[(ey - 3) * W + col] as i64; s[2] = yf[(ey - 2) * W + col] as i64; s[3] = yf[(ey - 1) * W + col] as i64
                          s[4] = yf[ey * W + col] as i64; s[5] = yf[(ey + 1) * W + col] as i64; s[6] = yf[(ey + 2) * W + col] as i64; s[7] = yf[(ey + 3) * W + col] as i64
                          if bs == 4 { nx_deblock_luma_bs4(s, qpe) }
                          if bs < 4 { nx_deblock_luma_edge(s, bs, qpe) }
                          yf[(ey - 3) * W + col] = s[1] as u8; yf[(ey - 2) * W + col] = s[2] as u8; yf[(ey - 1) * W + col] = s[3] as u8
                          yf[ey * W + col] = s[4] as u8; yf[(ey + 1) * W + col] = s[5] as u8; yf[(ey + 2) * W + col] = s[6] as u8
                          rx = rx + 1
                      }
                  }
                  ei = ei + 1
              }
              dmx = dmx + 1
          }
          dmy = dmy + 1
      }
  }
  // ===== in-loop deblocking (chroma U+V), 4:2:0: edges at chroma x/y in {0,4}; bS reuses luma
  // (4 at MB boundary, 3 internal); qp = chroma QPc (averaged across the boundary). =====
  if ok == 1 {
      let cs: *i64 = sys_mmap(8 * 8) as *i64
      let cve: *i64 = sys_mmap(8 * 8) as *i64
      cve[0] = 0; cve[1] = 4
      var dmy: i64 = 0
      while dmy < mbH {
          var dmx: i64 = 0
          while dmx < mbW {
              let ccpx: i64 = dmx * 8
              let ccpy: i64 = dmy * 8
              let qpcCur: i64 = chroma_qpc(mbQP[dmy * mbW + dmx], pps[9])
              var ei: i64 = 0
              while ei < 2 {
                  let eo: i64 = cve[ei]
                  let ex: i64 = ccpx + eo
                  var doit: i64 = 1
                  var bs: i64 = 3
                  var qpe: i64 = qpcCur
                  if eo == 0 {
                      if dmx == 0 { doit = 0 }
                      if dmx > 0 { bs = 4; qpe = (chroma_qpc(mbQP[dmy * mbW + (dmx - 1)], pps[9]) + qpcCur + 1) >> 1 }
                  }
                  if doit == 1 {
                      var ry: i64 = 0
                      while ry < 8 {
                          let base: i64 = (ccpy + ry) * cpW + ex
                          cs[0] = uf[base - 2] as i64; cs[1] = uf[base - 1] as i64; cs[2] = uf[base] as i64; cs[3] = uf[base + 1] as i64
                          nx_deblock_chroma_edge(cs, bs, qpe)
                          uf[base - 1] = cs[1] as u8; uf[base] = cs[2] as u8
                          cs[0] = vf[base - 2] as i64; cs[1] = vf[base - 1] as i64; cs[2] = vf[base] as i64; cs[3] = vf[base + 1] as i64
                          nx_deblock_chroma_edge(cs, bs, qpe)
                          vf[base - 1] = cs[1] as u8; vf[base] = cs[2] as u8
                          ry = ry + 1
                      }
                  }
                  ei = ei + 1
              }
              ei = 0
              while ei < 2 {
                  let eo: i64 = cve[ei]
                  let ey: i64 = ccpy + eo
                  var doit: i64 = 1
                  var bs: i64 = 3
                  var qpe: i64 = qpcCur
                  if eo == 0 {
                      if dmy == 0 { doit = 0 }
                      if dmy > 0 { bs = 4; qpe = (chroma_qpc(mbQP[(dmy - 1) * mbW + dmx], pps[9]) + qpcCur + 1) >> 1 }
                  }
                  if doit == 1 {
                      var rx: i64 = 0
                      while rx < 8 {
                          let col: i64 = ccpx + rx
                          cs[0] = uf[(ey - 2) * cpW + col] as i64; cs[1] = uf[(ey - 1) * cpW + col] as i64; cs[2] = uf[ey * cpW + col] as i64; cs[3] = uf[(ey + 1) * cpW + col] as i64
                          nx_deblock_chroma_edge(cs, bs, qpe)
                          uf[(ey - 1) * cpW + col] = cs[1] as u8; uf[ey * cpW + col] = cs[2] as u8
                          cs[0] = vf[(ey - 2) * cpW + col] as i64; cs[1] = vf[(ey - 1) * cpW + col] as i64; cs[2] = vf[ey * cpW + col] as i64; cs[3] = vf[(ey + 1) * cpW + col] as i64
                          nx_deblock_chroma_edge(cs, bs, qpe)
                          vf[(ey - 1) * cpW + col] = cs[1] as u8; vf[ey * cpW + col] = cs[2] as u8
                          rx = rx + 1
                      }
                  }
                  ei = ei + 1
              }
              dmx = dmx + 1
          }
          dmy = dmy + 1
      }
  }
  gp("  parsed MBs=\x00" as *u8); gn(mbAddr); gp("/\x00" as *u8); gn(totalMB)
  gp(" (I16=\x00" as *u8); gn(i16count); gp(" I4=\x00" as *u8); gn(i4count); gp(" PCM=\x00" as *u8); gn(pcmcount); gp(")\n\x00" as *u8)
  gp("  nz_luma_ac_blocks=\x00" as *u8); gn(nzblocks); gp(" coeff_checksum=\x00" as *u8); gn(coeffsum); gp(" finalQP=\x00" as *u8); gn(qp); gp("\n\x00" as *u8)
  gp("  reader byte_pos=\x00" as *u8); gn(sbr.byte_pos); gp("/\x00" as *u8); gn(sl_rbsp); gp(" bit_pos=\x00" as *u8); gn(sbr.bit_pos); gp("\n\x00" as *u8)
805
  // ===== compare reconstructed luma (PRE-deblock) vs ffmpeg post-deblock Y plane =====
  let rzp: *i64 = sys_mmap(16) as *i64
  let refp: *u8 = sys_read_file("knowledge/staging/media/ref_frame0.yuv\x00" as *u8, rzp)
  if (refp as i64) != 0 {
      var maxd: i64 = 0
      var sumd: i64 = 0
      var nexact: i64 = 0
      var npix: i64 = W * H
      var p: i64 = 0
      while p < npix {
          var dd: i64 = (yf[p] as i64) - (refp[p] as i64)
          if dd < 0 { dd = 0 - dd }
          if dd > maxd { maxd = dd }
          if dd == 0 { nexact = nexact + 1 }
          sumd = sumd + dd
          p = p + 1
      }
      gp("  vs ffmpeg Y (POST-deblock): exact=\x00" as *u8); gn(nexact); gp("/\x00" as *u8); gn(npix)
      gp(" (\x00" as *u8); gn(nexact * 100 / npix); gp("%) MAXDIFF=\x00" as *u8); gn(maxd); gp(" meandiff_x1000=\x00" as *u8); gn(sumd * 1000 / npix); gp("\n\x00" as *u8)
      // CHROMA post-deblock vs ffmpeg ref_frame0.yuv U/V planes
      var pcuex: i64 = 0
      var pcumax: i64 = 0
      var pcvex: i64 = 0
      var pcvmax: i64 = 0
      let pcbase: i64 = W * H
      let pcsz: i64 = cpW * cpH
      var pcp: i64 = 0
      while pcp < pcsz {
          var du2: i64 = (uf[pcp] as i64) - (refp[pcbase + pcp] as i64)
          if du2 < 0 { du2 = 0 - du2 }
          if du2 > pcumax { pcumax = du2 }
          if du2 == 0 { pcuex = pcuex + 1 }
          var dv2: i64 = (vf[pcp] as i64) - (refp[pcbase + pcsz + pcp] as i64)
          if dv2 < 0 { dv2 = 0 - dv2 }
          if dv2 > pcvmax { pcvmax = dv2 }
          if dv2 == 0 { pcvex = pcvex + 1 }
          pcp = pcp + 1
      }
      gp("  POST-deblock CHROMA U vs ffmpeg: exact=\x00" as *u8); gn(pcuex); gp("/\x00" as *u8); gn(pcsz); gp(" MAXDIFF=\x00" as *u8); gn(pcumax); gp("\n\x00" as *u8)
      gp("  POST-deblock CHROMA V vs ffmpeg: exact=\x00" as *u8); gn(pcvex); gp("/\x00" as *u8); gn(pcsz); gp(" MAXDIFF=\x00" as *u8); gn(pcvmax); gp("\n\x00" as *u8)
      if maxd != 0 { bexact = 0 }
      if pcumax != 0 { bexact = 0 }
      if pcvmax != 0 { bexact = 0 }
      // histogram + interior-vs-edge split: deblocking changes pixels near the 4-pel grid;
      // a recon bug shows as large diffs in block INTERIORS (col%4 in {1,2}, row%4 in {1,2}).
      var b1: i64 = 0
      var b2: i64 = 0
      var b3: i64 = 0
      var b4: i64 = 0
      var interior_bad: i64 = 0
      var interior_tot: i64 = 0
      var mx: i64 = 0
      var my: i64 = 0
      var p2: i64 = 0
      while p2 < npix {
          var dd: i64 = (yf[p2] as i64) - (refp[p2] as i64)
          if dd < 0 { dd = 0 - dd }
          if dd >= 1 { if dd <= 4 { b1 = b1 + 1 } }
          if dd >= 5 { if dd <= 12 { b2 = b2 + 1 } }
          if dd >= 13 { if dd <= 25 { b3 = b3 + 1 } }
          if dd > 25 { b4 = b4 + 1; if dd == maxd { mx = p2 % W; my = p2 / W } }
          let cx: i64 = p2 % W
          let cy: i64 = p2 / W
          let mcx: i64 = cx % 4
          let mcy: i64 = cy % 4
          if mcx == 1 { if mcy == 1 { interior_tot = interior_tot + 1; if dd > 6 { interior_bad = interior_bad + 1 } } }
          p2 = p2 + 1
      }
      gp("  diff histogram: [1-4]=\x00" as *u8); gn(b1); gp(" [5-12]=\x00" as *u8); gn(b2); gp(" [13-25]=\x00" as *u8); gn(b3); gp(" [>25]=\x00" as *u8); gn(b4); gp(" maxAt=(\x00" as *u8); gn(mx); gp(",\x00" as *u8); gn(my); gp(")\n\x00" as *u8)
      gp("  block-interior(col%4=1,row%4=1) pixels with diff>6: \x00" as *u8); gn(interior_bad); gp("/\x00" as *u8); gn(interior_tot); gp(" (should be ~0 if recon is correct; deblock barely touches interiors)\n\x00" as *u8)
      // localize: per-MB exactness by type (does the diff track I16 vs I4 MBs?)
      var badI16: i64 = 0
      var badI4: i64 = 0
      var totI16: i64 = 0
      var totI4: i64 = 0
      var firstBadX: i64 = 0 - 1
      var firstBadY: i64 = 0 - 1
      var firstBadCls: i64 = 0 - 1
      var dmy2: i64 = 0
      while dmy2 < mbH {
          var dmx2: i64 = 0
          while dmx2 < mbW {
              let c: i64 = mbCls[dmy2 * mbW + dmx2]
              var bad: i64 = 0
              var yy2: i64 = 0
              while yy2 < 16 {
                  var xx2: i64 = 0
                  while xx2 < 16 {
                      let pp: i64 = (dmy2*16 + yy2) * W + (dmx2*16 + xx2)
                      var dd2: i64 = (yf[pp] as i64) - (refp[pp] as i64)
                      if dd2 < 0 { dd2 = 0 - dd2 }
                      if dd2 > 0 { bad = 1 }
                      xx2 = xx2 + 1
                  }
                  yy2 = yy2 + 1
              }
              if c == 1 { totI16 = totI16 + 1; if bad == 1 { badI16 = badI16 + 1 } }
              if c == 0 { totI4 = totI4 + 1; if bad == 1 { badI4 = badI4 + 1 } }
              if bad == 1 { if firstBadX < 0 { firstBadX = dmx2; firstBadY = dmy2; firstBadCls = c } }
              dmx2 = dmx2 + 1
          }
          dmy2 = dmy2 + 1
      }
      gp("  MBs-with-any-diff: I16=\x00" as *u8); gn(badI16); gp("/\x00" as *u8); gn(totI16); gp(" I4=\x00" as *u8); gn(badI4); gp("/\x00" as *u8); gn(totI4)
      gp(" firstBad=(\x00" as *u8); gn(firstBadX); gp(",\x00" as *u8); gn(firstBadY); gp(") cls=\x00" as *u8); gn(firstBadCls); gp("\n\x00" as *u8)
  }
  if ok == 1 {
      if mbAddr == totalMB {
          // landed within the final byte (<=1 byte slack for rbsp trailing bits)
          if sbr.byte_pos >= sl_rbsp - 2 {
              gp("  *** FRAME-WIDE ENTROPY SYNC: all MBs parsed, reader at rbsp end -> ENTROPY VERIFIED ***\n\x00" as *u8)
              if bexact == 1 { gp("  *** FULL-FRAME Y+U+V BIT-EXACT (pre+post deblock) vs ffmpeg -> verdict=GREEN ***\n\x00" as *u8); return 0 }
              gp("  *** entropy synced but a plane is NOT bit-exact -> verdict=RED ***\n\x00" as *u8)
              return 7
          }
          gp("  all MBs parsed but reader NOT at rbsp end (over/under-read)\n\x00" as *u8)
          return 5
      }
  }
  gp("  DESYNC: did not cleanly parse all MBs\n\x00" as *u8)
  return 6
927}
nx_h264_decode_frame.nx source

`nx_h264_decode_frame.nx` source
