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

↩ module page · 1062 lines · 51708 B
1// nx_h264_pframe_recon.nx -- P-R4b: pixel-exact LUMA reconstruction of frame 1 (inter content).
2// Uses frame 0's PRE-deblock luma plane as the reference (ref_frame0.yuv -- proven byte-exact
3// equal to nx_h264_decode_frame's pre-deblock recon), reconstructs every SKIP + INTER macroblock by
4// motion-compensating each 4x4 block from the reference (per-4x4 MV from the grid) and adding the decoded
5// residual (inv-zigzag -> dequant -> 4x4 IDCT -> add+clip), then compares to ffmpeg's frame-1 PRE-deblock
6// luma (ref_frame1_nodeblock.yuv). Both sides skip deblocking, isolating MC+residual from the loop filter.
7// Intra-in-P macroblocks (179) are decoded for entropy sync but EXCLUDED from the pixel count (P-R4b-2).
8// Exit 0/1. Log knowledge/status/h264_pframe_recon.log. license_tier: ORIGINAL
9import "nx_syscalls.nx"
10import "nx_mp4_demux.nx"
11import "nx_mp4_stbl.nx"
12import "nx_h264_bits.nx"
13import "nx_h264_sps.nx"
14import "nx_h264_pps.nx"
15import "nx_h264_nal.nx"
16import "nx_h264_slice.nx"
17import "nx_h264_mb.nx"
18import "nx_h264_mb_pred.nx"
19import "nx_h264_coeff_token.nx"
20import "nx_h264_cavlc_level.nx"
21import "nx_h264_residual.nx"
22import "nx_h264_nc.nx"
23import "nx_h264_pmb.nx"
24import "nx_h264_mvgrid.nx"
25import "nx_h264_idct.nx"
26import "nx_h264_dequant.nx"
27import "nx_h264_zigzag.nx"
28import "nx_h264_hadamard.nx"
29import "nx_h264_intra16.nx"
30import "nx_h264_intra.nx"
31import "nx_h264_intra_recon.nx"
32import "nx_h264_chroma.nx"
33import "nx_h264_chroma_pred.nx"
34import "nx_h264_deblock.nx"
35import "nx_h264_mc_luma.nx"
36
37func gp(fd: i64, s: *u8) -> i64 {
  var n: i64 = 0
  while s[n] != (0 as u8) { n = n + 1 }
  sys_write(1, s, n); if fd > 0 { sys_write(fd, s, n) }
  return 0
42}
43func gn(fd: i64, v: i64) -> i64 {
  let bb: *u8 = sys_mmap(28); var m: i64 = v
  if m < 0 { sys_write(1, "-\x00" as *u8, 1); if fd > 0 { sys_write(fd, "-\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); if fd > 0 { sys_write(fd, bb, k) }
  return 0
53}
54func 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
58}
59func 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
70}
71func dec_cac(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
82}
83func read_ref(sbr: *BitReader, num_ref: i64) -> i64 {
  if num_ref == 1 { return 0 }
  if num_ref == 2 { let bbit: i64 = br_read_bit(sbr); return 1 - bbit }
  return br_read_ue(sbr)
87}
88// Reconstruct one 4x4 luma block at picture pixel (bpx,bpy) of frame1: motion-compensate from the
89// reference plane with MV (mvx,mvy) [quarter-pel], add residual (coeffscan, qp) when hasRes, write to myY.
90func recon_inter_4x4(myY: *u8, W: i64, ref: *u8, Wr: i64, Hr: i64, bpx: i64, bpy: i64,
                   mvx: i64, mvy: i64, coeffscan: *i64, qp: i64, hasRes: i64) -> i64 {
  let pred: *u8 = sys_mmap(16) as *u8
  var yy: i64 = 0
  while yy < 4 {
      var xx: i64 = 0
      while xx < 4 {
          let fullX: i64 = (bpx + xx) + asr(mvx, 2)
          let fracX: i64 = mvx & 3
          let fullY: i64 = (bpy + yy) + asr(mvy, 2)
          let fracY: i64 = mvy & 3
          pred[yy * 4 + xx] = nx_h264_mc_luma_sample(ref, Wr, Hr, fullX, fullY, fracX, fracY) as u8
          xx = xx + 1
      }
      yy = yy + 1
  }
  if hasRes == 0 {
      yy = 0
      while yy < 4 {
          var xx: i64 = 0
          while xx < 4 { myY[(bpy + yy) * W + (bpx + xx)] = pred[yy * 4 + xx]; xx = xx + 1 }
          yy = yy + 1
      }
      return 0
  }
  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)
  yy = 0
  while yy < 4 {
      var xx: i64 = 0
      while xx < 4 {
          var val: i64 = (pred[yy * 4 + xx] as i64) + dq[yy * 4 + xx]
          if val < 0 { val = 0 }
          if val > 255 { val = 255 }
          myY[(bpy + yy) * W + (bpx + xx)] = val as u8
          xx = xx + 1
      }
      yy = yy + 1
  }
  return 0
133}
134
135func cclamp(v: i64, hi: i64) -> i64 { if v < 0 { return 0 } if v > hi { return hi } return v }
136// one chroma sample (8.4.2.2.2): 1/8-pel bilinear from the reference chroma plane.
137func chroma_mc_sample(refC: *u8, cW: i64, cH: i64, cx: i64, cy: i64, mvx: i64, mvy: i64) -> i64 {
  let xi: i64 = cx + asr(mvx, 3)
  let yi: i64 = cy + asr(mvy, 3)
  let xf: i64 = mvx & 7
  let yf: i64 = mvy & 7
  let x0: i64 = cclamp(xi, cW - 1)
  let x1: i64 = cclamp(xi + 1, cW - 1)
  let y0: i64 = cclamp(yi, cH - 1)
  let y1: i64 = cclamp(yi + 1, cH - 1)
  let A: i64 = refC[y0 * cW + x0] as i64
  let B: i64 = refC[y0 * cW + x1] as i64
  let C: i64 = refC[y1 * cW + x0] as i64
  let D: i64 = refC[y1 * cW + x1] as i64
  return ((8 - xf) * (8 - yf) * A + xf * (8 - yf) * B + (8 - xf) * yf * C + xf * yf * D + 32) >> 6
151}
152// reconstruct one chroma component (U or V) of one inter/skip MB: motion-compensate each of the 4
153// chroma 4x4 blocks (per-sample MV from the luma grid) + add residual (chroma DC 2x2 + AC), -> myC.
154// dc4 = 4 decoded chroma-DC levels (consumed by the scale); ac4[q*16+0..14] = the 15 AC per block q.
155func recon_chroma_inter_mb(myC: *u8, refC: *u8, cW: i64, cH: i64, mbX: i64, mbY: i64,
                         gmvx: *i64, gmvy: *i64, lbW: i64, dc4: *i64, ac4: *i64, cbpC: i64, QPc: i64) -> i64 {
  let sdc: *i64 = sys_mmap(4 * 8) as *i64
  if cbpC >= 1 { nx_h264_chroma_dc_scale(dc4, QPc, sdc) }
  var q: i64 = 0
  while q < 4 {
      let bcx: i64 = mbX * 8 + (q % 2) * 4
      let bcy: i64 = mbY * 8 + (q / 2) * 4
      let pred: *i64 = sys_mmap(16 * 8) as *i64
      var yy: i64 = 0
      while yy < 4 {
          var xx: i64 = 0
          while xx < 4 {
              let cx: i64 = bcx + xx
              let cy: i64 = bcy + yy
              let mvx: i64 = gmvx[(cy / 2) * lbW + (cx / 2)]
              let mvy: i64 = gmvy[(cy / 2) * lbW + (cx / 2)]
              pred[yy * 4 + xx] = chroma_mc_sample(refC, cW, cH, cx, cy, mvx, mvy)
              xx = xx + 1
          }
          yy = yy + 1
      }
      if cbpC == 0 {
          yy = 0
          while yy < 4 {
              var xx: i64 = 0
              while xx < 4 { myC[(bcy + yy) * cW + (bcx + xx)] = pred[yy * 4 + xx] as u8; xx = xx + 1 }
              yy = yy + 1
          }
      }
      if cbpC >= 1 {
          let scan: *i64 = sys_mmap(16 * 8) as *i64
          var z2: i64 = 0
          while z2 < 16 { scan[z2] = 0; z2 = z2 + 1 }
          if cbpC == 2 { z2 = 0; while z2 < 15 { scan[1 + z2] = ac4[q * 16 + z2]; z2 = z2 + 1 } }
          let rast: *i64 = sys_mmap(16 * 8) as *i64
          nx_h264_inv_zigzag4x4(scan, rast)
          let dq: *i64 = sys_mmap(16 * 8) as *i64
          nx_h264_dequant4x4(rast, QPc, dq)
          dq[0] = sdc[q]
          nx_idct4x4(dq)
          yy = 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 }
                  myC[(bcy + yy) * cW + (bcx + xx)] = val as u8
                  xx = xx + 1
              }
              yy = yy + 1
          }
      }
      q = q + 1
  }
  return 0
212}
213
214// reconstruct one chroma component of an INTRA-in-P MB: intra chroma prediction (DC/H/V/Plane) from
215// reconstructed neighbours in myC + residual (chroma DC 2x2 + AC). mode = intra_chroma_pred_mode.
216func recon_chroma_intra_mb(myC: *u8, cW: i64, cH: i64, mbX: i64, mbY: i64, mode: i64,
                         availTop: i64, availLeft: i64, dc4: *i64, ac4: *i64, cbpC: i64, QPc: i64) -> i64 {
  let bx0: i64 = mbX * 8
  let by0: i64 = mbY * 8
  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 availTop == 1 { tv = myC[(by0 - 1) * cW + (bx0 + k)] as i64 }
      top[k] = tv
      var lv: i64 = 0
      if availLeft == 1 { lv = myC[(by0 + k) * cW + (bx0 - 1)] as i64 }
      left[k] = lv
      k = k + 1
  }
  var tl: i64 = 0
  if availTop == 1 { if availLeft == 1 { tl = myC[(by0 - 1) * cW + (bx0 - 1)] as i64 } }
  let pred: *i64 = sys_mmap(64 * 8) as *i64
  nx_intra_chroma_pred(mode, top, left, tl, availTop, availLeft, pred)
  let sdc: *i64 = sys_mmap(4 * 8) as *i64
  if cbpC >= 1 { nx_h264_chroma_dc_scale(dc4, QPc, sdc) }
  var q: i64 = 0
  while q < 4 {
      let qx: i64 = (q % 2) * 4
      let qy: i64 = (q / 2) * 4
      let p16: *i64 = sys_mmap(16 * 8) as *i64
      var yy: i64 = 0
      while yy < 4 {
          var xx: i64 = 0
          while xx < 4 { p16[yy * 4 + xx] = pred[(qy + yy) * 8 + (qx + xx)]; xx = xx + 1 }
          yy = yy + 1
      }
      if cbpC == 0 {
          yy = 0
          while yy < 4 {
              var xx: i64 = 0
              while xx < 4 { myC[(by0 + qy + yy) * cW + (bx0 + qx + xx)] = p16[yy * 4 + xx] as u8; xx = xx + 1 }
              yy = yy + 1
          }
      }
      if cbpC >= 1 {
          let scan: *i64 = sys_mmap(16 * 8) as *i64
          var z2: i64 = 0
          while z2 < 16 { scan[z2] = 0; z2 = z2 + 1 }
          if cbpC == 2 { z2 = 0; while z2 < 15 { scan[1 + z2] = ac4[q * 16 + z2]; z2 = z2 + 1 } }
          let rast: *i64 = sys_mmap(16 * 8) as *i64
          nx_h264_inv_zigzag4x4(scan, rast)
          let dq: *i64 = sys_mmap(16 * 8) as *i64
          nx_h264_dequant4x4(rast, QPc, dq)
          dq[0] = sdc[q]
          nx_idct4x4(dq)
          yy = 0
          while yy < 4 {
              var xx: i64 = 0
              while xx < 4 {
                  var val: i64 = p16[yy * 4 + xx] + dq[yy * 4 + xx]
                  if val < 0 { val = 0 }
                  if val > 255 { val = 255 }
                  myC[(by0 + qy + yy) * cW + (bx0 + qx + xx)] = val as u8
                  xx = xx + 1
              }
              yy = yy + 1
          }
      }
      q = q + 1
  }
  return 0
284}
285
286// P-frame boundary strength (8.7.2.1) for the edge between 4x4 blocks p and q (gref<0 == intra).
287//   intra -> 4 if MB boundary else 3; else nonzero-coeff -> 2; else |mvDiff|>=4 (1 luma sample) -> 1; else 0.
288//   (single reference list here, so the different-reference test never fires.)
289func p_bs(gref: *i64, gmvx: *i64, gmvy: *i64, lumaTC: *i64, pblk: i64, qblk: i64, mbBoundary: i64) -> i64 {
  if gref[pblk] < 0 { if mbBoundary == 1 { return 4 } return 3 }
  if gref[qblk] < 0 { if mbBoundary == 1 { return 4 } return 3 }
  if lumaTC[pblk] > 0 { return 2 }
  if lumaTC[qblk] > 0 { return 2 }
  var dx: i64 = gmvx[pblk] - gmvx[qblk]
  if dx < 0 { dx = 0 - dx }
  var dy: i64 = gmvy[pblk] - gmvy[qblk]
  if dy < 0 { dy = 0 - dy }
  if dx >= 4 { return 1 }
  if dy >= 4 { return 1 }
  return 0
301}
302// In-loop luma deblock for a P-frame: per MB raster order, 4 vertical then 4 horizontal edges, each
303// split into four 4x4 segments with their own bS (p_bs). Reuses the PROVEN luma filters
304// (nx_deblock_luma_bs4 / nx_deblock_luma_edge). bS==0 segments are left untouched.
305func deblock_luma_p(yf: *u8, W: i64, mbW: i64, mbH: i64, mbQP: *i64,
                  gref: *i64, gmvx: *i64, gmvy: *i64, lumaTC: *i64, lbW: i64, bsHist: *i64) -> i64 {
  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]
          // ---- vertical edges ----
          var ei: i64 = 0
          while ei < 4 {
              let eo: i64 = ve[ei]
              let ex: i64 = px + eo
              let qcol: i64 = dmx * 4 + eo / 4
              var doit: i64 = 1
              if eo == 0 { if dmx == 0 { doit = 0 } }
              if doit == 1 {
                  var qpe: i64 = qpMB
                  if eo == 0 { qpe = (mbQP[dmy * mbW + (dmx - 1)] + qpMB + 1) >> 1 }
                  var mbb: i64 = 0
                  if eo == 0 { mbb = 1 }
                  var seg: i64 = 0
                  while seg < 4 {
                      let row4: i64 = dmy * 4 + seg
                      let qblk: i64 = row4 * lbW + qcol
                      let pblk: i64 = row4 * lbW + (qcol - 1)
                      let bs: i64 = p_bs(gref, gmvx, gmvy, lumaTC, pblk, qblk, mbb)
                      bsHist[bs] = bsHist[bs] + 1
                      if bs > 0 {
                          var r: i64 = 0
                          while r < 4 {
                              let ry: i64 = seg * 4 + r
                              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
                              r = r + 1
                          }
                      }
                      seg = seg + 1
                  }
              }
              ei = ei + 1
          }
          // ---- horizontal edges ----
          ei = 0
          while ei < 4 {
              let eo: i64 = ve[ei]
              let ey: i64 = py + eo
              let qrow: i64 = dmy * 4 + eo / 4
              var doit: i64 = 1
              if eo == 0 { if dmy == 0 { doit = 0 } }
              if doit == 1 {
                  var qpe: i64 = qpMB
                  if eo == 0 { qpe = (mbQP[(dmy - 1) * mbW + dmx] + qpMB + 1) >> 1 }
                  var mbb: i64 = 0
                  if eo == 0 { mbb = 1 }
                  var seg: i64 = 0
                  while seg < 4 {
                      let col4: i64 = dmx * 4 + seg
                      let qblk: i64 = qrow * lbW + col4
                      let pblk: i64 = (qrow - 1) * lbW + col4
                      let bs: i64 = p_bs(gref, gmvx, gmvy, lumaTC, pblk, qblk, mbb)
                      bsHist[bs] = bsHist[bs] + 1
                      if bs > 0 {
                          var r: i64 = 0
                          while r < 4 {
                              let col: i64 = px + seg * 4 + r
                              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
                              r = r + 1
                          }
                      }
                      seg = seg + 1
                  }
              }
              ei = ei + 1
          }
          dmx = dmx + 1
      }
      dmy = dmy + 1
  }
  return 0
399}
400
401// chroma QP for a luma QP (Table 8-15 via offset), clipped.
402func cqp(lumaQP: i64, cqio: i64) -> i64 {
  var q: i64 = lumaQP + cqio
  if q < 0 { q = 0 }
  if q > 51 { q = 51 }
  return nx_h264_chroma_qp(q)
407}
408// In-loop CHROMA deblock for a P-frame (4:2:0): 2 vertical + 2 horizontal chroma edges per MB (x/y in
409// {0,4}). bS is the LUMA bS at the co-located luma 4x4 (each chroma sample maps to luma 2x; 2 chroma
410// samples per luma 4x4). qpc = chroma QP (avg of the two MBs' chroma QP at a MB boundary). Reuses p_bs +
411// the proven nx_deblock_chroma_edge.
412func deblock_chroma_p(myC: *u8, cW: i64, cH: i64, mbW: i64, mbH: i64, mbQP: *i64,
                    gref: *i64, gmvx: *i64, gmvy: *i64, lumaTC: *i64, lbW: i64, cqio: i64) -> i64 {
  let s: *i64 = sys_mmap(8 * 8) as *i64
  let ceo: *i64 = sys_mmap(2 * 8) as *i64
  ceo[0] = 0; ceo[1] = 4
  var dmy: i64 = 0
  while dmy < mbH {
      var dmx: i64 = 0
      while dmx < mbW {
          let qpThis: i64 = cqp(mbQP[dmy * mbW + dmx], cqio)
          var ei: i64 = 0
          while ei < 2 {
              let ce: i64 = ceo[ei]
              let cx: i64 = dmx * 8 + ce
              let qcol: i64 = dmx * 4 + ce / 2
              var doit: i64 = 1
              if ce == 0 { if dmx == 0 { doit = 0 } }
              if doit == 1 {
                  var qpc: i64 = qpThis
                  if ce == 0 { qpc = (cqp(mbQP[dmy * mbW + (dmx - 1)], cqio) + qpThis + 1) >> 1 }
                  var mbb: i64 = 0
                  if ce == 0 { mbb = 1 }
                  var r: i64 = 0
                  while r < 8 {
                      let cy: i64 = dmy * 8 + r
                      let row4: i64 = dmy * 4 + r / 2
                      let qblk: i64 = row4 * lbW + qcol
                      let pblk: i64 = row4 * lbW + (qcol - 1)
                      let bs: i64 = p_bs(gref, gmvx, gmvy, lumaTC, pblk, qblk, mbb)
                      if bs > 0 {
                          s[0] = myC[cy * cW + cx - 2] as i64
                          s[1] = myC[cy * cW + cx - 1] as i64
                          s[2] = myC[cy * cW + cx] as i64
                          s[3] = myC[cy * cW + cx + 1] as i64
                          nx_deblock_chroma_edge(s, bs, qpc)
                          myC[cy * cW + cx - 1] = s[1] as u8
                          myC[cy * cW + cx] = s[2] as u8
                      }
                      r = r + 1
                  }
              }
              ei = ei + 1
          }
          ei = 0
          while ei < 2 {
              let ce: i64 = ceo[ei]
              let cy: i64 = dmy * 8 + ce
              let qrow: i64 = dmy * 4 + ce / 2
              var doit: i64 = 1
              if ce == 0 { if dmy == 0 { doit = 0 } }
              if doit == 1 {
                  var qpc: i64 = qpThis
                  if ce == 0 { qpc = (cqp(mbQP[(dmy - 1) * mbW + dmx], cqio) + qpThis + 1) >> 1 }
                  var mbb: i64 = 0
                  if ce == 0 { mbb = 1 }
                  var c: i64 = 0
                  while c < 8 {
                      let cx: i64 = dmx * 8 + c
                      let col4: i64 = dmx * 4 + c / 2
                      let qblk: i64 = qrow * lbW + col4
                      let pblk: i64 = (qrow - 1) * lbW + col4
                      let bs: i64 = p_bs(gref, gmvx, gmvy, lumaTC, pblk, qblk, mbb)
                      if bs > 0 {
                          s[0] = myC[(cy - 2) * cW + cx] as i64
                          s[1] = myC[(cy - 1) * cW + cx] as i64
                          s[2] = myC[cy * cW + cx] as i64
                          s[3] = myC[(cy + 1) * cW + cx] as i64
                          nx_deblock_chroma_edge(s, bs, qpc)
                          myC[(cy - 1) * cW + cx] = s[1] as u8
                          myC[cy * cW + cx] = s[2] as u8
                      }
                      c = c + 1
                  }
              }
              ei = ei + 1
          }
          dmx = dmx + 1
      }
      dmy = dmy + 1
  }
  return 0
493}
494
495func main() -> i64 {
  let fd: i64 = sys_openat_append("knowledge/status/h264_pframe_recon.log\x00" as *u8, 0x1a4)
  gp(fd, "H264-PFRAME-RECON (P-R4b luma + P-R5 chroma + P-R6 deblock vs ffmpeg)\n\x00" as *u8)
  let szp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = sys_read_file("knowledge/staging/media/realtest.mp4\x00" as *u8, szp)
  if (b as i64) == 0 { gp(fd, "no realtest.mp4\n\x00" as *u8); sys_exit(1); return 1 }
  let len: i64 = szp[0]
  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
  let totalMB: i64 = mbW * mbH
520
  // reference (frame0 pre-deblock) + target (frame1 pre-deblock) luma planes
  let rzp: *i64 = sys_mmap(16) as *i64
  let refY: *u8 = sys_read_file("knowledge/staging/media/ref_frame0.yuv\x00" as *u8, rzp)
  if (refY as i64) == 0 { gp(fd, "no ref_frame0.yuv\n\x00" as *u8); sys_exit(1); return 1 }
  let tzp: *i64 = sys_mmap(16) as *i64
  let tgtY: *u8 = sys_read_file("knowledge/staging/media/ref_frame1_nodeblock.yuv\x00" as *u8, tzp)
  if (tgtY as i64) == 0 { gp(fd, "no ref_frame1_nodeblock.yuv\n\x00" as *u8); sys_exit(1); return 1 }
  let myY: *u8 = sys_mmap(W * H + 16)
  var zz: i64 = 0
  while zz < W * H { myY[zz] = 0 as u8; zz = zz + 1 }
  // chroma planes (4:2:0): U then V after the luma plane in each YUV file
  let cW: i64 = W / 2
  let cH: i64 = H / 2
  let refU: *u8 = (refY as i64 + W * H) as *u8
  let refV: *u8 = (refY as i64 + W * H + cW * cH) as *u8
  let tgtU: *u8 = (tgtY as i64 + W * H) as *u8
  let tgtV: *u8 = (tgtY as i64 + W * H + cW * cH) as *u8
  let myU: *u8 = sys_mmap(cW * cH + 16)
  let myV: *u8 = sys_mmap(cW * cH + 16)
  zz = 0
  while zz < cW * cH { myU[zz] = 0 as u8; myV[zz] = 0 as u8; zz = zz + 1 }
  let cqio: i64 = pps[9]
543
  let vi: *i64 = sys_mmap(64) as *i64
  nx_mp4_video_info(b, len, vi)
  let rco: *i64 = sys_mmap(16) as *i64
  mp4_find_box(b, vi[5], vi[6], "stco\x00" as *u8, rco)
  let s1off: i64 = mp4_be32(b, rco[0] + 12)
  let rsz: *i64 = sys_mmap(16) as *i64
  mp4_find_box(b, vi[5], vi[6], "stsz\x00" as *u8, rsz)
  var samp1: i64 = mp4_be32(b, rsz[0] + 4)
  if samp1 == 0 { samp1 = mp4_be32(b, rsz[0] + 16) }
  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, s1off, s1off + samp1, 4, offs, types, 256)
  var sidx: i64 = 0 - 1
  var i: i64 = 0
  while i < nc { if types[i] == 1 { if sidx < 0 { sidx = i } } i = i + 1 }
  if sidx < 0 { gp(fd, "no P-slice\n\x00" as *u8); sys_exit(1); return 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)
  let num_ref: i64 = sh[12] + 1
  gp(fd, "  DEBLOCK deblock_idc=\x00" as *u8); gn(fd, sh[9]); gp(fd, " offA=\x00" as *u8); gn(fd, sh[10]); gp(fd, " offB=\x00" as *u8); gn(fd, sh[11]); gp(fd, "\n\x00" as *u8)
571
  let lbW: i64 = mbW * 4
  let lbH: i64 = mbH * 4
  let lumaTC: *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
  var z: i64 = 0
  while z < lbW * lbH { lumaTC[z] = 0; z = z + 1 }
  z = 0
  while z < cbW * cbH { uTC[z] = 0; vTC[z] = 0; z = z + 1 }
  let gmvx: *i64 = sys_mmap(lbW * lbH * 8) as *i64
  let gmvy: *i64 = sys_mmap(lbW * lbH * 8) as *i64
  let gref: *i64 = sys_mmap(lbW * lbH * 8) as *i64
  z = 0
  while z < lbW * lbH { gmvx[z] = 0; gmvy[z] = 0; gref[z] = 0 - 2; z = z + 1 }
  let intraMask: *i64 = sys_mmap(totalMB * 8) as *i64
  let mbKind: *i64 = sys_mmap(totalMB * 8) as *i64
  let mbQP: *i64 = sys_mmap(totalMB * 8) as *i64
  z = 0
  while z < totalMB { intraMask[z] = 0; mbKind[z] = 0 - 9; mbQP[z] = 0; z = z + 1 }
  // intra-pred bookkeeping: decoded[]=1 once a 4x4 block is reconstructed; i4m[]= its intra mode
  // (0..8 for I_4x4, 2 for I_16x16/PCM) or -1 for INTER blocks (not intra -> DC for mode-pred).
  let decoded: *i64 = sys_mmap(lbW * lbH * 8) as *i64
  let i4m: *i64 = sys_mmap(lbW * lbH * 8) as *i64
  z = 0
  while z < lbW * lbH { decoded[z] = 0; i4m[z] = 0 - 1; z = z + 1 }
  let cip: i64 = pps[7]
  let acstore: *i64 = sys_mmap(16 * 16 * 8) as *i64
601
  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
608
  let coeff: *i64 = sys_mmap(32 * 8) as *i64
  let mvp: *i64 = sys_mmap(16) as *i64
  let refs: *i64 = sys_mmap(8 * 8) as *i64
  let subs: *i64 = sys_mmap(8 * 8) as *i64
  var qp: i64 = sh[7]
  var ok: i64 = 1
  var mbAddr: i64 = 0
  while mbAddr < totalMB {
      if ok == 0 { mbAddr = totalMB } else {
      let skip_run: i64 = br_read_ue(sbr)
      var s2: i64 = 0
      while s2 < skip_run {
          if mbAddr < totalMB {
              let mbX: i64 = mbAddr % mbW
              let mbY: i64 = mbAddr / mbW
              mbKind[mbAddr] = 10
              nx_mvg_skip_mv(gref, gmvx, gmvy, lbW, lbH, mbX, mbY, mvp)
              nx_mvg_fill(gref, gmvx, gmvy, lbW, mbX * 4, mbY * 4, 4, 4, 0, mvp[0], mvp[1])
              var bl: i64 = 0
              while bl < 16 {
                  let sbx: i64 = mbX * 4 + bx4[bl]
                  let sby: i64 = mbY * 4 + by4[bl]
                  recon_inter_4x4(myY, W, refY, W, H, sbx * 4, sby * 4, mvp[0], mvp[1], coeff, qp, 0)
                  lumaTC[sby * lbW + sbx] = 0
                  decoded[sby * lbW + sbx] = 1
                  i4m[sby * lbW + sbx] = 0 - 1
                  bl = bl + 1
              }
              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 }
              // skip chroma = pure MC (no residual)
              var sqc: i64 = qp + cqio
              if sqc < 0 { sqc = 0 }
              if sqc > 51 { sqc = 51 }
              let sQPc: i64 = nx_h264_chroma_qp(sqc)
              let zdc: *i64 = sys_mmap(8 * 8) as *i64
              let zac: *i64 = sys_mmap(4 * 16 * 8) as *i64
              recon_chroma_inter_mb(myU, refU, cW, cH, mbX, mbY, gmvx, gmvy, lbW, zdc, zac, 0, sQPc)
              recon_chroma_inter_mb(myV, refV, cW, cH, mbX, mbY, gmvx, gmvy, lbW, zdc, zac, 0, sQPc)
              mbQP[mbAddr] = qp
              mbAddr = mbAddr + 1
          }
          s2 = s2 + 1
      }
      if mbAddr < totalMB {
          let mbX: i64 = mbAddr % mbW
          let mbY: i64 = mbAddr / mbW
          let bx0: i64 = mbX * 4
          let by0: i64 = mbY * 4
          let mb_type: i64 = br_read_ue(sbr)
          let kind: i64 = nx_h264_pmb_kind(mb_type)
          if kind >= 0 {
              // ---- INTER ----
              mbKind[mbAddr] = kind
              if nx_h264_pmb_is_8x8(kind) == 1 {
                  var si: i64 = 0
                  while si < 4 { subs[si] = br_read_ue(sbr); si = si + 1 }
                  si = 0
                  while si < 4 { refs[si] = 0; si = si + 1 }
                  if num_ref > 1 { if nx_h264_pmb_codes_ref(kind) == 1 {
                      si = 0
                      while si < 4 { refs[si] = read_ref(sbr, num_ref); si = si + 1 }
                  } }
                  si = 0
                  while si < 4 {
                      let sx: i64 = bx0 + (si % 2) * 2
                      let sy: i64 = by0 + (si / 2) * 2
                      let st: i64 = subs[si]
                      var spn: i64 = nx_h264_psub_nparts(st)
                      var sp: i64 = 0
                      while sp < spn {
                          var px: i64 = sx
                          var py: i64 = sy
                          var pw: i64 = 2
                          var ph: i64 = 2
                          if st == 1 { pw = 2; ph = 1; py = sy + sp }
                          if st == 2 { pw = 1; ph = 2; px = sx + sp }
                          if st == 3 { pw = 1; ph = 1; px = sx + (sp % 2); py = sy + (sp / 2) }
                          let mvdx: i64 = br_read_se(sbr)
                          let mvdy: i64 = br_read_se(sbr)
                          nx_mvg_part_mvp(gref, gmvx, gmvy, lbW, lbH, px, py, pw, refs[si], 0, 0, mvp)
                          nx_mvg_fill(gref, gmvx, gmvy, lbW, px, py, pw, ph, refs[si], mvp[0] + mvdx, mvp[1] + mvdy)
                          sp = sp + 1
                      }
                      si = si + 1
                  }
              }
              if nx_h264_pmb_is_8x8(kind) == 0 {
                  let nparts: i64 = nx_h264_pmb_nparts(kind)
                  var rp: i64 = 0
                  while rp < nparts { refs[rp] = 0; rp = rp + 1 }
                  if num_ref > 1 { if nx_h264_pmb_codes_ref(kind) == 1 {
                      rp = 0
                      while rp < nparts { refs[rp] = read_ref(sbr, num_ref); rp = rp + 1 }
                  } }
                  if kind == 0 {
                      let mvdx: i64 = br_read_se(sbr)
                      let mvdy: i64 = br_read_se(sbr)
                      nx_mvg_part_mvp(gref, gmvx, gmvy, lbW, lbH, bx0, by0, 4, refs[0], 0, 0, mvp)
                      nx_mvg_fill(gref, gmvx, gmvy, lbW, bx0, by0, 4, 4, refs[0], mvp[0] + mvdx, mvp[1] + mvdy)
                  }
                  if kind == 1 {
                      let mvdx0: i64 = br_read_se(sbr)
                      let mvdy0: i64 = br_read_se(sbr)
                      nx_mvg_part_mvp(gref, gmvx, gmvy, lbW, lbH, bx0, by0, 4, refs[0], 1, 0, mvp)
                      nx_mvg_fill(gref, gmvx, gmvy, lbW, bx0, by0, 4, 2, refs[0], mvp[0] + mvdx0, mvp[1] + mvdy0)
                      let mvdx1: i64 = br_read_se(sbr)
                      let mvdy1: i64 = br_read_se(sbr)
                      nx_mvg_part_mvp(gref, gmvx, gmvy, lbW, lbH, bx0, by0 + 2, 4, refs[1], 1, 1, mvp)
                      nx_mvg_fill(gref, gmvx, gmvy, lbW, bx0, by0 + 2, 4, 2, refs[1], mvp[0] + mvdx1, mvp[1] + mvdy1)
                  }
                  if kind == 2 {
                      let mvdx0: i64 = br_read_se(sbr)
                      let mvdy0: i64 = br_read_se(sbr)
                      nx_mvg_part_mvp(gref, gmvx, gmvy, lbW, lbH, bx0, by0, 2, refs[0], 2, 0, mvp)
                      nx_mvg_fill(gref, gmvx, gmvy, lbW, bx0, by0, 2, 4, refs[0], mvp[0] + mvdx0, mvp[1] + mvdy0)
                      let mvdx1: i64 = br_read_se(sbr)
                      let mvdy1: i64 = br_read_se(sbr)
                      nx_mvg_part_mvp(gref, gmvx, gmvy, lbW, lbH, bx0 + 2, by0, 2, refs[1], 2, 1, mvp)
                      nx_mvg_fill(gref, gmvx, gmvy, lbW, bx0 + 2, by0, 2, 4, refs[1], mvp[0] + mvdx1, mvp[1] + mvdy1)
                  }
              }
              // CBP (inter) + residual + LUMA RECON (MC from grid MV + residual)
              let cbp: i64 = nx_h264_decode_cbp_inter(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 }
              var bl: i64 = 0
              while bl < 16 {
                  let abx: i64 = bx0 + bx4[bl]
                  let aby: i64 = by0 + by4[bl]
                  let i8: i64 = bl / 4
                  let mvx: i64 = gmvx[aby * lbW + abx]
                  let mvy: i64 = gmvy[aby * lbW + abx]
                  if ((cbpL >> i8) & 1) != 0 {
                      dec_luma(sbr, lumaTC, lbW, abx, aby, 16, coeff)
                      recon_inter_4x4(myY, W, refY, W, H, abx * 4, aby * 4, mvx, mvy, coeff, qp, 1)
                  }
                  if ((cbpL >> i8) & 1) == 0 {
                      lumaTC[aby * lbW + abx] = 0
                      recon_inter_4x4(myY, W, refY, W, H, abx * 4, aby * 4, mvx, mvy, coeff, qp, 0)
                  }
                  decoded[aby * lbW + abx] = 1
                  i4m[aby * lbW + abx] = 0 - 1
                  bl = bl + 1
              }
              let ucdc: *i64 = sys_mmap(8 * 8) as *i64
              let vcdc: *i64 = sys_mmap(8 * 8) as *i64
              let uac: *i64 = sys_mmap(4 * 16 * 8) as *i64
              let vac: *i64 = sys_mmap(4 * 16 * 8) as *i64
              var zc: i64 = 0
              while zc < 8 { ucdc[zc] = 0; vcdc[zc] = 0; zc = zc + 1 }
              zc = 0
              while zc < 64 { uac[zc] = 0; vac[zc] = 0; zc = zc + 1 }
              if cbpC != 0 {
                  nx_h264_residual_decode_cdc(sbr, ucdc)
                  nx_h264_residual_decode_cdc(sbr, vcdc)
                  if cbpC == 2 {
                      var cc: i64 = 0
                      while cc < 4 {
                          dec_cac(sbr, uTC, cbW, mbX*2 + (cc%2), mbY*2 + (cc/2), coeff)
                          var za: i64 = 0
                          while za < 15 { uac[cc * 16 + za] = coeff[za]; za = za + 1 }
                          cc = cc + 1
                      }
                      cc = 0
                      while cc < 4 {
                          dec_cac(sbr, vTC, cbW, mbX*2 + (cc%2), mbY*2 + (cc/2), coeff)
                          var za: i64 = 0
                          while za < 15 { vac[cc * 16 + za] = coeff[za]; za = za + 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 iqc: i64 = qp + cqio
              if iqc < 0 { iqc = 0 }
              if iqc > 51 { iqc = 51 }
              let iQPc: i64 = nx_h264_chroma_qp(iqc)
              recon_chroma_inter_mb(myU, refU, cW, cH, mbX, mbY, gmvx, gmvy, lbW, ucdc, uac, cbpC, iQPc)
              recon_chroma_inter_mb(myV, refV, cW, cH, mbX, mbY, gmvx, gmvy, lbW, vcdc, vac, cbpC, iQPc)
          }
          if kind < 0 {
              // ---- INTRA in P ---- decode for sync; EXCLUDE from luma compare (P-R4b-2)
              intraMask[mbAddr] = 1
              // mark this MB's grid blocks DECODED-INTRA (gref=-1): available to neighbours, no MV
              var ib: i64 = 0
              while ib < 16 {
                  let iidx: i64 = (by0 + by4[ib]) * lbW + (bx0 + bx4[ib])
                  gref[iidx] = 0 - 1; gmvx[iidx] = 0; gmvy[iidx] = 0
                  ib = ib + 1
              }
              let it: i64 = mb_type - 5
              let cls: i64 = nx_h264_mb_type_class(it)
              // chroma residual capture (filled by whichever intra cls path runs) for P-R5b recon
              let icdcU: *i64 = sys_mmap(8 * 8) as *i64
              let icdcV: *i64 = sys_mmap(8 * 8) as *i64
              let iacU: *i64 = sys_mmap(4 * 16 * 8) as *i64
              let iacV: *i64 = sys_mmap(4 * 16 * 8) as *i64
              var zc2: i64 = 0
              while zc2 < 8 { icdcU[zc2] = 0; icdcV[zc2] = 0; zc2 = zc2 + 1 }
              zc2 = 0
              while zc2 < 64 { iacU[zc2] = 0; iacV[zc2] = 0; zc2 = zc2 + 1 }
              var iChromaMode: i64 = 0
              var iCbpC: i64 = 0
              if cls == 1 {
                  let der: *i64 = sys_mmap(32) as *i64
                  nx_h264_i16x16_derive(it, der)
                  let cbpL: i64 = der[2]
                  let cbpC: i64 = der[1]
                  iCbpC = cbpC
                  iChromaMode = br_read_ue(sbr)
                  let mqd: i64 = br_read_se(sbr); qp = (qp + mqd + 52) % 52
                  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
                  nx_h264_residual_decode(sbr, 16, nCdc, dcblk)
                  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 {
                          dec_luma(sbr, lumaTC, lbW, abx, aby, 15, coeff)
                          z = 0
                          while z < 15 { 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
                  }
                  let dcY: *i64 = sys_mmap(16 * 8) as *i64
                  i16_dc_scale(dcblk, qp, dcY)
                  recon_i16_luma(myY, W, mbX * 16, mbY * 16, der[0], dcY, acstore, qp)
                  if cbpC != 0 {
                      nx_h264_residual_decode_cdc(sbr, icdcU)
                      nx_h264_residual_decode_cdc(sbr, icdcV)
                      if cbpC == 2 {
                          var cc: i64 = 0
                          while cc < 4 {
                              dec_cac(sbr, uTC, cbW, mbX*2 + (cc%2), mbY*2 + (cc/2), coeff)
                              var za: i64 = 0
                              while za < 15 { iacU[cc * 16 + za] = coeff[za]; za = za + 1 }
                              cc = cc + 1
                          }
                          cc = 0
                          while cc < 4 {
                              dec_cac(sbr, vTC, cbW, mbX*2 + (cc%2), mbY*2 + (cc/2), coeff)
                              var za: i64 = 0
                              while za < 15 { iacV[cc * 16 + za] = coeff[za]; za = za + 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 }
                  }
              }
              if cls == 0 {
                  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
                  iCbpC = cbpC
                  iChromaMode = modes[16]
                  if cbp != 0 { let mqd: i64 = br_read_se(sbr); qp = (qp + mqd + 52) % 52 }
                  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
                      let i8: i64 = bl / 4
                      // intra4x4 mode prediction (8.3.1.1): dcPredFlag when a neighbour MB is unavailable,
                      // or (constrained_intra && inter); an inter/I16 neighbour contributes DC(2).
                      var aUnav: i64 = 1
                      if abx > 0 { if decoded[aby * lbW + (abx - 1)] == 1 { aUnav = 0 } }
                      var bUnav: i64 = 1
                      if aby > 0 { if decoded[(aby - 1) * lbW + abx] == 1 { bUnav = 0 } }
                      var dcflag: i64 = 0
                      if aUnav == 1 { dcflag = 1 }
                      if bUnav == 1 { dcflag = 1 }
                      if cip == 1 { if aUnav == 0 { if i4m[aby * lbW + (abx - 1)] < 0 { dcflag = 1 } } }
                      if cip == 1 { if bUnav == 0 { if i4m[(aby - 1) * lbW + abx] < 0 { dcflag = 1 } } }
                      var predMode: i64 = 2
                      if dcflag == 0 {
                          var mA: i64 = i4m[aby * lbW + (abx - 1)]
                          if mA < 0 { mA = 2 }
                          var mBm: i64 = i4m[(aby - 1) * lbW + abx]
                          if mBm < 0 { mBm = 2 }
                          predMode = mA
                          if mBm < mA { predMode = mBm }
                      }
                      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
                      z = 0
                      while z < 16 { coeff[z] = 0; z = z + 1 }
                      if ((cbpL >> i8) & 1) != 0 { dec_luma(sbr, lumaTC, lbW, abx, aby, 16, coeff) }
                      if ((cbpL >> i8) & 1) == 0 { lumaTC[aby * lbW + abx] = 0 }
                      // pixel-pred availability: decoded AND (constrained_intra==0 OR neighbour is intra)
                      var aT: i64 = 0
                      if aby > 0 { if decoded[(aby-1)*lbW + abx] == 1 { if cip == 0 { aT = 1 } if i4m[(aby-1)*lbW + abx] >= 0 { aT = 1 } } }
                      var aL: i64 = 0
                      if abx > 0 { if decoded[aby*lbW + (abx-1)] == 1 { if cip == 0 { aL = 1 } if i4m[aby*lbW + (abx-1)] >= 0 { aL = 1 } } }
                      var aTL: i64 = 0
                      if abx > 0 { if aby > 0 { if decoded[(aby-1)*lbW + (abx-1)] == 1 { if cip == 0 { aTL = 1 } if i4m[(aby-1)*lbW + (abx-1)] >= 0 { aTL = 1 } } } }
                      var aTR: i64 = 0
                      if aby > 0 { if abx + 1 < lbW { if decoded[(aby-1)*lbW + (abx+1)] == 1 { if cip == 0 { aTR = 1 } if i4m[(aby-1)*lbW + (abx+1)] >= 0 { aTR = 1 } } } }
                      recon_i4_block(myY, W, bpx, bpy, mode, aT, aL, aTL, aTR, coeff, qp)
                      decoded[aby * lbW + abx] = 1
                      bl = bl + 1
                  }
                  if cbpC != 0 {
                      nx_h264_residual_decode_cdc(sbr, icdcU)
                      nx_h264_residual_decode_cdc(sbr, icdcV)
                      if cbpC == 2 {
                          var cc: i64 = 0
                          while cc < 4 {
                              dec_cac(sbr, uTC, cbW, mbX*2 + (cc%2), mbY*2 + (cc/2), coeff)
                              var za: i64 = 0
                              while za < 15 { iacU[cc * 16 + za] = coeff[za]; za = za + 1 }
                              cc = cc + 1
                          }
                          cc = 0
                          while cc < 4 {
                              dec_cac(sbr, vTC, cbW, mbX*2 + (cc%2), mbY*2 + (cc/2), coeff)
                              var za: i64 = 0
                              while za < 15 { iacV[cc * 16 + za] = coeff[za]; za = za + 1 }
                              cc = cc + 1
                          }
                      }
                  }
              }
              if cls == 2 {
                  br_align(sbr)
                  let pcmpix: *i64 = sys_mmap(384 * 8) as *i64
                  var pp: i64 = 0
                  while pp < 384 { pcmpix[pp] = br_read_bits(sbr, 8); pp = pp + 1 }
                  var ry: i64 = 0
                  while ry < 16 {
                      var rx: i64 = 0
                      while rx < 16 { myY[(mbY*16 + ry) * W + (mbX*16 + rx)] = pcmpix[ry*16 + rx] as u8; rx = rx + 1 }
                      ry = ry + 1
                  }
                  ry = 0
                  while ry < 8 {
                      var rx: i64 = 0
                      while rx < 8 {
                          myU[(mbY*8 + ry) * cW + (mbX*8 + rx)] = pcmpix[256 + ry*8 + rx] as u8
                          myV[(mbY*8 + ry) * cW + (mbX*8 + rx)] = pcmpix[320 + ry*8 + rx] as u8
                          rx = rx + 1
                      }
                      ry = ry + 1
                  }
                  var bl: i64 = 0
                  while bl < 16 {
                      let abx: i64 = bx0 + bx4[bl]
                      let aby: i64 = by0 + by4[bl]
                      lumaTC[aby * lbW + abx] = 16
                      i4m[aby * lbW + abx] = 2
                      decoded[aby * lbW + abx] = 1
                      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 }
              }
              if cls < 0 { ok = 0 }
              // P-R5b: intra chroma reconstruction (cls 0/1; PCM wrote raw chroma above)
              if cls >= 0 { if cls != 2 {
                  var aTopC: i64 = 0
                  if mbY > 0 { if cip == 0 { aTopC = 1 } if intraMask[(mbY - 1) * mbW + mbX] == 1 { aTopC = 1 } }
                  var aLeftC: i64 = 0
                  if mbX > 0 { if cip == 0 { aLeftC = 1 } if intraMask[mbY * mbW + (mbX - 1)] == 1 { aLeftC = 1 } }
                  var iqc2: i64 = qp + cqio
                  if iqc2 < 0 { iqc2 = 0 }
                  if iqc2 > 51 { iqc2 = 51 }
                  let iQPc2: i64 = nx_h264_chroma_qp(iqc2)
                  recon_chroma_intra_mb(myU, cW, cH, mbX, mbY, iChromaMode, aTopC, aLeftC, icdcU, iacU, iCbpC, iQPc2)
                  recon_chroma_intra_mb(myV, cW, cH, mbX, mbY, iChromaMode, aTopC, aLeftC, icdcV, iacV, iCbpC, iQPc2)
              } }
          }
          mbQP[mbAddr] = qp
          mbAddr = mbAddr + 1
      }
      }
  }
1013
  // ---- full P-frame pipeline proof: reconstruct (done) -> deblock -> compare vs ffmpeg POST-deblock ----
  var nIntraMB: i64 = 0
  var mi: i64 = 0
  while mi < totalMB { if intraMask[mi] == 1 { nIntraMB = nIntraMB + 1 } mi = mi + 1 }
  var atEnd: i64 = 0
  if sbr.byte_pos >= sl_rbsp - 2 { atEnd = 1 }
  gp(fd, "  parsed MBs=\x00" as *u8); gn(fd, mbAddr); gp(fd, "/\x00" as *u8); gn(fd, totalMB)
  gp(fd, " reader=\x00" as *u8); gn(fd, sbr.byte_pos); gp(fd, "/\x00" as *u8); gn(fd, sl_rbsp)
  gp(fd, " intra_MB=\x00" as *u8); gn(fd, nIntraMB); gp(fd, "\n\x00" as *u8)
1023
  // ---- in-loop deblock (P boundary strengths) -> compare vs ffmpeg POST-deblock luma+chroma ----
  let bsHist: *i64 = sys_mmap(8 * 8) as *i64
  var bh: i64 = 0
  while bh < 5 { bsHist[bh] = 0; bh = bh + 1 }
  deblock_luma_p(myY, W, mbW, mbH, mbQP, gref, gmvx, gmvy, lumaTC, lbW, bsHist)
  gp(fd, "  bS-hist: bs0=\x00" as *u8); gn(fd, bsHist[0]); gp(fd, " bs1=\x00" as *u8); gn(fd, bsHist[1]); gp(fd, " bs2=\x00" as *u8); gn(fd, bsHist[2]); gp(fd, " bs3=\x00" as *u8); gn(fd, bsHist[3]); gp(fd, " bs4=\x00" as *u8); gn(fd, bsHist[4]); gp(fd, "\n\x00" as *u8)
  deblock_chroma_p(myU, cW, cH, mbW, mbH, mbQP, gref, gmvx, gmvy, lumaTC, lbW, cqio)
  deblock_chroma_p(myV, cW, cH, mbW, mbH, mbQP, gref, gmvx, gmvy, lumaTC, lbW, cqio)
  let pzp: *i64 = sys_mmap(16) as *i64
  let postY: *u8 = sys_read_file("knowledge/staging/media/ref_frame1.yuv\x00" as *u8, pzp)
  let postU: *u8 = (postY as i64 + W * H) as *u8
  let postV: *u8 = (postY as i64 + W * H + cW * cH) as *u8
  var dbexact: i64 = 0
  var dbp: i64 = 0
  while dbp < W * H {
      if myY[dbp] == postY[dbp] { dbexact = dbexact + 1 }
      dbp = dbp + 1
  }
  var dbcexact: i64 = 0
  var dcp: i64 = 0
  while dcp < cW * cH {
      if myU[dcp] == postU[dcp] { dbcexact = dbcexact + 1 }
      if myV[dcp] == postV[dcp] { dbcexact = dbcexact + 1 }
      dcp = dcp + 1
  }
  gp(fd, "  POST-DEBLOCK LUMA exact=\x00" as *u8); gn(fd, dbexact); gp(fd, "/\x00" as *u8); gn(fd, W * H); gp(fd, " diff=\x00" as *u8); gn(fd, W * H - dbexact); gp(fd, "\n\x00" as *u8)
  gp(fd, "  POST-DEBLOCK CHROMA exact=\x00" as *u8); gn(fd, dbcexact); gp(fd, "/\x00" as *u8); gn(fd, 2 * cW * cH); gp(fd, " diff=\x00" as *u8); gn(fd, 2 * cW * cH - dbcexact); gp(fd, "\n\x00" as *u8)
1051
  if ok == 1 { if atEnd == 1 { if mbAddr == totalMB { if dbexact == W * H { if dbcexact == 2 * cW * cH {
      gp(fd, "H264-PFRAME-RECON result=ALL-PASS verdict=GREEN (FULL frame-1 POST-DEBLOCK luma+chroma bit-exact)\n\x00" as *u8)
      if fd > 0 { sys_close(fd) }
      sys_exit(0)
      return 0
  } } } } }
  gp(fd, "H264-PFRAME-RECON result=FAIL verdict=RED\n\x00" as *u8)
  if fd > 0 { sys_close(fd) }
  sys_exit(1)
  return 1
1062}
nx_h264_pframe_recon.nx source

`nx_h264_pframe_recon.nx` source
