code wiki / _hdl_build / nx_h264_iframe.nx
`nx_h264_iframe.nx` source

↩ module page · 496 lines · 20764 B
1// nx_h264_iframe.nx -- reusable CAVLC I-slice -> YUV420 decode driver (STEP 3 core for the cam poster).
2// Lifts the proven full-frame reconstruction from nx_h264_decode_frame.nx into a callable function that
3// takes an already-extracted, de-emulated IDR slice RBSP + parsed SPS/PPS + output planes, decodes every
4// macroblock (I_4x4 / I_16x16 / I_PCM), and reconstructs Y/U/V. Two engineering fixes vs the original main:
5//   (1) uses CODED MB dims (mbW=sps[4]+1, mbH=sps[5]+1) so non-16-aligned crops (e.g. 1080) decode fully;
6//   (2) HOISTS all per-call scratch out of the recon kernels (the toolchain's sys_mmap has no munmap; a
7//       per-MB mmap would exhaust the kernel map_count on a full-HD frame) -> bounded, constant map count.
8// Deblocking is intentionally omitted here (a downscaled poster averages block edges away); add for full res.
9// LIB (no main). license_tier: ORIGINAL   genealogy_id: itu_t_h264_islice_cavlc_recon (lifted from decode_frame)
10import "nx_syscalls.nx"
11import "nx_h264_bits.nx"
12import "nx_h264_slice.nx"
13import "nx_h264_mb.nx"
14import "nx_h264_mb_pred.nx"
15import "nx_h264_coeff_token.nx"
16import "nx_h264_cavlc_level.nx"
17import "nx_h264_residual.nx"
18import "nx_h264_nc.nx"
19import "nx_h264_zigzag.nx"
20import "nx_h264_hadamard.nx"
21import "nx_h264_dequant.nx"
22import "nx_h264_idct.nx"
23import "nx_h264_intra16.nx"
24import "nx_h264_intra.nx"
25import "nx_h264_chroma_pred.nx"
26import "nx_h264_chroma.nx"
27
28// shared recon scratch layout (i64 offsets into one buffer; recon calls are strictly sequential)
29const SC_PRED: i64 = 0      // 256 (i16 pred) / 64 (chroma)
30const SC_TOP:  i64 = 256    // up to 16
31const SC_LEFT: i64 = 288    // up to 16
32const SC_SCAN: i64 = 320    // 16
33const SC_RAST: i64 = 336    // 16
34const SC_DQ:   i64 = 352    // 16
35const SC_DCY:  i64 = 368    // 16 (I16 luma DC scaled)
36const SC_NA:   i64 = 384    // 6
37const SC_CC:   i64 = 392    // 4
38const SC_DCC:  i64 = 400    // 4
39const SC_IDCT: i64 = 408   // 16 words: nx_idct4x4 scratch, hoisted 2026-08-01 (SC_WORDS=512, so 408+16 fits)
40const SC_WORDS: i64 = 512
41
42func scp(sc: *i64, off: i64) -> *i64 { return ((sc as i64) + off * 8) as *i64 }
43
44// decode one luma 4x4 residual block (nC neighbour context). bx,by absolute 4x4 coords.
45func 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
56}
57
58func 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
69}
70
71func 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)
76}
77
78// I_16x16 luma DC -> scaled dcY[16] written into sc[SC_DCY..].
79func i16_dc_scale_h(dcblk: *i64, qp: i64, sc: *i64) -> i64 {
  let dcras: *i64 = scp(sc, SC_SCAN)
  nx_h264_inv_zigzag4x4(dcblk, dcras)
  nx_h264_hadamard4x4(dcras)
  let na: *i64 = scp(sc, SC_NA)
  na[0]=10; na[1]=11; na[2]=13; na[3]=14; na[4]=16; na[5]=18
  let dcY: *i64 = scp(sc, SC_DCY)
  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
99func recon_i16_luma_h(yf: *u8, W: i64, px: i64, py: i64, predMode: i64, sc: *i64, acstore: *i64, qp: i64) -> i64 {
  var aT: i64 = 0
  if py > 0 { aT = 1 }
  var aL: i64 = 0
  if px > 0 { aL = 1 }
  let top: *i64 = scp(sc, SC_TOP)
  let left: *i64 = scp(sc, SC_LEFT)
  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 = scp(sc, SC_PRED)
  nx_intra16x16_pred_full(predMode, top, left, tl, aT, aL, pred)
  let scan: *i64 = scp(sc, SC_SCAN)
  let dq: *i64 = scp(sc, SC_DQ)
  let dcY: *i64 = scp(sc, SC_DCY)
  let rast: *i64 = scp(sc, SC_RAST)
  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 }
          nx_h264_inv_zigzag4x4(scan, rast)
          nx_h264_dequant4x4(rast, qp, dq)
          dq[0] = dcY[r]
          nx_idct4x4_s(dq, scp(sc, SC_IDCT))
          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
152}
153
154func recon_i4_block_h(yf: *u8, W: i64, bpx: i64, bpy: i64, mode: i64, aT: i64, aL: i64, aTL: i64, aTR: i64, coeffscan: *i64, qp: i64, sc: *i64) -> i64 {
  let top: *i64 = scp(sc, SC_TOP)
  let left: *i64 = scp(sc, SC_LEFT)
  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
  }
  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 = scp(sc, SC_PRED)
  nx_intra4x4_pred_full(mode, top, left, tl, aT, aL, pred)
  let rast: *i64 = scp(sc, SC_RAST)
  nx_h264_inv_zigzag4x4(coeffscan, rast)
  let dq: *i64 = scp(sc, SC_DQ)
  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
197}
198
199func recon_chroma_comp_h(cf: *u8, cW: i64, cpx: i64, cpy: i64, predMode: i64, cdc: *i64, acstore: *i64, qpc: i64, availT: i64, availL: i64, sc: *i64) -> i64 {
  let top: *i64 = scp(sc, SC_TOP)
  let left: *i64 = scp(sc, SC_LEFT)
  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 = scp(sc, SC_PRED)
  nx_intra_chroma_pred(predMode, top, left, tl, availT, availL, pred)
  let cc: *i64 = scp(sc, SC_CC)
  var di: i64 = 0
  while di < 4 { cc[di] = cdc[di]; di = di + 1 }
  let dcC: *i64 = scp(sc, SC_DCC)
  nx_h264_chroma_dc_scale(cc, qpc, dcC)
  let scan: *i64 = scp(sc, SC_SCAN)
  let rast: *i64 = scp(sc, SC_RAST)
  let dq: *i64 = scp(sc, SC_DQ)
  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_s(dq, scp(sc, SC_IDCT))
          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
252}
253
254// Decode a single CAVLC I-slice (all MBs) into yf/uf/vf. Caller: mbW=sps[4]+1, mbH=sps[5]+1 (coded);
255// yf sized (mbW*16)*(mbH*16), uf/vf sized (mbW*8)*(mbH*8); planes pre-zeroed by caller.
256// Returns 1 iff all MBs parsed and the reader landed at the rbsp end; else 0 (desync / partial).
257func nx_h264_decode_iframe(sl_dst: *u8, sl_rbsp: i64, ntype: i64, sps: *i64, pps: *i64, yf: *u8, uf: *u8, vf: *u8, mbW: i64, mbH: i64) -> i64 {
  let W: i64 = mbW * 16
  let cpW: i64 = mbW * 8
  let lbW: i64 = mbW * 4
  let lbH: i64 = mbH * 4
  let cbW: i64 = mbW * 2
  let cbH: i64 = mbH * 2
  let sbr: *BitReader = sys_mmap(NX_BR_BYTES) as *BitReader
  br_init(sbr, sl_dst, sl_rbsp)
  let sh: *i64 = sys_mmap(64) as *i64
  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)
  var qp: i64 = sh[7]
269
  // hoisted state (allocate ONCE)
  let sc: *i64 = sys_mmap(SC_WORDS * 8) as *i64
  let lumaTC: *i64 = sys_mmap(lbW * lbH * 8) as *i64
  let i4m: *i64 = sys_mmap(lbW * lbH * 8) as *i64
  let decoded: *i64 = sys_mmap(lbW * lbH * 8) as *i64
  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; i4m[z] = 2; decoded[z] = 0; z = z + 1 }
  z = 0
  while z < cbW * cbH { uTC[z] = 0; vTC[z] = 0; z = z + 1 }
  let acstore: *i64 = sys_mmap(16 * 16 * 8) as *i64
  let ucstore: *i64 = sys_mmap(4 * 16 * 8) as *i64
  let vcstore: *i64 = sys_mmap(4 * 16 * 8) as *i64
  let coeff: *i64 = sys_mmap(32 * 8) as *i64
  let der: *i64 = sys_mmap(32 * 8) as *i64
  let dcblk: *i64 = sys_mmap(16 * 8) as *i64
  let ucdc: *i64 = sys_mmap(8 * 8) as *i64
  let vcdc: *i64 = sys_mmap(8 * 8) as *i64
  let modes: *i64 = sys_mmap(24 * 8) as *i64
  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
296
  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; mbAddr = totalMB }
      if ok == 1 { if mb_type > 25 { ok = 0; mbAddr = totalMB } }
      if ok == 1 {
          let cls: i64 = nx_h264_mb_type_class(mb_type)
308
          if cls == 2 {
              // I_PCM: byte-align, consume 384 raw samples (pixels not reconstructed -> rare), neighbours=16
              br_align(sbr)
              var pp: i64 = 0
              while pp < 384 { 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
              }
          }
323
          if cls == 1 {
              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
              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)
              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
              }
              i16_dc_scale_h(dcblk, qp, sc)
              recon_i16_luma_h(yf, W, mbX * 16, mbY * 16, der[0], sc, acstore, qp)
              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)
                  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_h(uf, cpW, mbX*8, mbY*8, chroma_pred, ucdc, ucstore, qpc16, caT16, caL16, sc)
              recon_chroma_comp_h(vf, cpW, mbX*8, mbY*8, chroma_pred, vcdc, vcstore, qpc16, caT16, caL16, sc)
          }
399
          if cls == 0 {
              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
              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
                  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
                  let i8: i64 = bl / 4
                  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 }
                  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_h(yf, W, bpx, bpy, mode, aT, aL, aTL, aTR, coeff, qp, sc)
                  decoded[aby*lbW + abx] = 1
                  bl = bl + 1
              }
              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)
                  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_h(uf, cpW, mbX*8, mbY*8, modes[16], ucdc, ucstore, qpc4, caT4, caL4, sc)
              recon_chroma_comp_h(vf, cpW, mbX*8, mbY*8, modes[16], vcdc, vcstore, qpc4, caT4, caL4, sc)
          }
490
          mbAddr = mbAddr + 1
      }
  }
  if ok == 1 { if mbAddr == totalMB { if sbr.byte_pos >= sl_rbsp - 2 { return 1 } } }
  return 0
496}
nx_h264_iframe.nx source

`nx_h264_iframe.nx` source
