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

↩ module page · 231 lines · 10633 B
1// nx_ts_lumadiff.nx -- VISUAL dead-air measurement.
2// Byte-rate analysis CANNOT see dead air in this corpus (measured 2026-07-31: audio is CBR AAC,
3// video is rate-controlled, p25/p50 = 79-94%). But "nothing is happening" IS visible in the
4// PIXELS. This seeks to NXVI keyframe byte offsets, decodes luma with the gate-proven CAVLC
5// I-frame decoder, reduces each frame to a 16x9 luma signature, and reports the mean absolute
6// difference between consecutive sampled frames. Low MAD run = static = dead air.
7// Reuses nx_ts_es (lifted verbatim from nx_cam_poster, byte-identical proven) + nx_h264_iframe.
8//   nx_ts_lumadiff <in.ts> <in.idx> [max_samples]
9// license_tier: ORIGINAL
10import "nx_syscalls.nx"
11import "nx_itoa_lib.nx"   // shared MSB-first emitter -- _hdl_build MAY import runtime/ (not the reverse)
12import "nx_ts_es.nx"
13import "nx_h264_sps.nx"
14import "nx_h264_pps.nx"
15import "nx_h264_iframe.nx"
16const LD_MAGIC_8388608: i64 = 8388608
17const LD_MAGIC_1048576: i64 = 1048576
18const LD_MAGIC_1024: i64 = 1024
19
20const LD_WIN: i64 = 3145728        // bytes read at each keyframe offset; one IDR access unit fits
21const LD_SIGW: i64 = 16            // signature grid width  (cells)
22const LD_SIGH: i64 = 9             // signature grid height (cells)
23const LD_NALCAP: i64 = 4194304
24const LD_HEAD: i64 = 262144        // head read for SPS/PPS
25const LD_DEFSAMP: i64 = 40         // default number of keyframes sampled across the file
26
27func ld_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
28// MIGRATED to the shared emitter (debt 1785557603). THIS FUNCTION TOOK 28.5GB OF A 36GB HOST.
29// Measured 2026-08-01: this organ held 29166124 kB RSS on a 2,383,652-byte (2MB) input -- ~12,000x
30// the input size -- froze every seat, OOM-killed sibling builds, and made the build admitter DENY.
31// Cause: TWO sys_mmap(28) per call, neither freed; each rounds to a 4096B page, so 8192B leaked per
32// call, and 28.5GB / 8192B is ~3.66 MILLION calls from 9 call sites inside per-sample loops.
33// nxi_out is MSB-first, allocates NOTHING, and emits identical bytes including the sign (gate T9/T10).
34func ld_num(v: i64) -> i64 { nxi_out(v); return 0 }
35func ld_atoi(s: *u8) -> i64 {
  var v: i64 = 0
  var i: i64 = 0
  while s[i] != (0 as u8) { if s[i] >= (48 as u8) { if s[i] <= (57 as u8) { v = v*10 + ((s[i]-(48 as u8)) as i64) } } i = i + 1 }
  return v
40}
41func ld_r32(b: *u8, o: i64) -> i64 {
  return ((b[o] as i64)<<24) | ((b[o+1] as i64)<<16) | ((b[o+2] as i64)<<8) | (b[o+3] as i64)
43}
44func ld_r64(b: *u8, o: i64) -> i64 {
  var v: i64 = 0
  var i: i64 = 0
  while i < 8 { v = (v<<8) | (b[o+i] as i64); i = i + 1 }
  return v
49}
50// reduce a decoded luma plane to a LD_SIGW x LD_SIGH mean-luma signature
51func ld_signature(yf: *u8, W: i64, cropW: i64, cropH: i64, sig: *i64) -> i64 {
  var cy: i64 = 0
  while cy < LD_SIGH {
      var cx: i64 = 0
      while cx < LD_SIGW {
          let x0: i64 = cx * cropW / LD_SIGW
          var x1: i64 = (cx+1) * cropW / LD_SIGW
          let y0: i64 = cy * cropH / LD_SIGH
          var y1: i64 = (cy+1) * cropH / LD_SIGH
          if x1 <= x0 { x1 = x0 + 1 }
          if y1 <= y0 { y1 = y0 + 1 }
          var acc: i64 = 0
          var n: i64 = 0
          var yy: i64 = y0
          while yy < y1 {
              var xx: i64 = x0
              while xx < x1 { acc = acc + (yf[yy*W + xx] as i64); n = n + 1; xx = xx + 1 }
              yy = yy + 1
          }
          if n < 1 { n = 1 }
          sig[cy*LD_SIGW + cx] = acc / n
          cx = cx + 1
      }
      cy = cy + 1
  }
  return 0
77}
78
79func main(argc: i64, argv: *i64) -> i64 {
  if argc < 3 { ld_puts("usage: nx_ts_lumadiff <in.ts> <in.idx> [max_samples]\n\x00" as *u8); return 2 }
  let tspath: *u8 = argv[1] as *u8
  let ixpath: *u8 = argv[2] as *u8
  var maxs: i64 = LD_DEFSAMP
  if argc >= 4 { maxs = ld_atoi(argv[3] as *u8) }
  if maxs < 0 { maxs = 0 }   // arg is WHICH keyframe now; never silently rewrite it
86
  // ---- read the NXVI index
  let ixfd: i64 = sys_openat_rd(ixpath)
  if ixfd < 0 { ld_puts("ERR: cannot open index\n\x00" as *u8); return 1 }
  let ib: *u8 = sys_mmap(LD_MAGIC_8388608)
  var ilen: i64 = 0
  var g: i64 = 1
  while g == 1 {
      let r: i64 = sys_read(ixfd, ((ib as i64)+ilen) as *u8, LD_MAGIC_1048576)
      if r <= 0 { g = 0 }
      if r > 0 { ilen = ilen + r }
  }
  sys_close(ixfd)
  if ilen < 40 { ld_puts("ERR: index too short\n\x00" as *u8); return 3 }
  if ib[0] != (78 as u8) { ld_puts("ERR: not NXVI\n\x00" as *u8); return 3 }
  let ver: i64 = ld_r32(ib, 4)
  var o: i64 = 8
  o = o + 8 + 4 + 4 + 4 + 4          // dur_ms, arate, achan, vidpid, audpid
  // v3 inserted srcsize(8) here. A FORMAT BUMP MUST UPDATE EVERY READER: parsing
  // v3 at v2 offsets reads srcsize AS spslen and seeks out of bounds (core dump).
  if ver >= 3 { o = o + 8 }
  let spl: i64 = ld_r32(ib, o); o = o + 4 + spl
  let ppl: i64 = ld_r32(ib, o); o = o + 4 + ppl
  let nkf: i64 = ld_r64(ib, o); o = o + 8
  if nkf < 2 { ld_puts("REFUSED: index has fewer than 2 keyframes\n\x00" as *u8); return 4 }
  let ktab: i64 = o
112
  // ---- SPS/PPS from the head of the TS
  let tsfd: i64 = sys_openat_rd(tspath)
  if tsfd < 0 { ld_puts("ERR: cannot open ts\n\x00" as *u8); return 1 }
  let hb: *u8 = sys_mmap(LD_HEAD + 512)
  var hl: i64 = 0
  var g2: i64 = 1
  while g2 == 1 {
      let r: i64 = sys_read(tsfd, ((hb as i64)+hl) as *u8, LD_HEAD - hl)
      if r <= 0 { g2 = 0 }
      if r > 0 { hl = hl + r; if hl >= LD_HEAD { g2 = 0 } }
  }
  let es: *u8 = sys_mmap(LD_WIN + 512)
  let pidout: *i64 = sys_mmap(64) as *i64
  var eslen: i64 = demux_video_es(hb, hl, es, pidout)
  let spsn: *u8 = sys_mmap(LD_MAGIC_1024)
  let ppsn: *u8 = sys_mmap(LD_MAGIC_1024)
  let sl: i64 = find_first_nal(es, eslen, 7, spsn, LD_MAGIC_1024)
  let pl: i64 = find_first_nal(es, eslen, 8, ppsn, LD_MAGIC_1024)
  if sl <= 0 { ld_puts("REFUSED: no SPS in head\n\x00" as *u8); return 5 }
  if pl <= 0 { ld_puts("REFUSED: no PPS in head\n\x00" as *u8); return 5 }
  let srb: *u8 = sys_mmap(LD_MAGIC_1024)
  let prb: *u8 = sys_mmap(LD_MAGIC_1024)
  let srl: i64 = nal_to_rbsp(spsn, sl, srb)
  let prl: i64 = nal_to_rbsp(ppsn, pl, prb)
  let sps: *i64 = sys_mmap(8*128) as *i64
  let pps: *i64 = sys_mmap(8*128) as *i64
  nx_h264_parse_sps(srb, srl, sps)
  nx_h264_parse_pps(prb, prl, pps)
  if pps[2] == 1 { ld_puts("SKIP: CABAC stream (CAVLC decoder only)\n\x00" as *u8); return 10 }
  let mbW: i64 = sps[4] + 1
  let mbH: i64 = sps[5] + 1
  let W: i64 = mbW * 16
  let H: i64 = mbH * 16
  let cpW: i64 = mbW * 8
  var cropW: i64 = sps[2]
  var cropH: i64 = sps[3]
  if cropW <= 0 { cropW = W }
  if cropH <= 0 { cropH = H }
  if cropW > W { cropW = W }
  if cropH > H { cropH = H }
  let yf: *u8 = sys_mmap(W*H + 64)
  let uf: *u8 = sys_mmap(cpW*(H/2) + 64)
  let vf: *u8 = sys_mmap(cpW*(H/2) + 64)
  let win: *u8 = sys_mmap(LD_WIN + 512)
  let idrn: *u8 = sys_mmap(LD_NALCAP)
  let irb: *u8 = sys_mmap(LD_NALCAP)
  let sig: *i64 = sys_mmap(8 * LD_SIGW * LD_SIGH) as *i64
  let prev: *i64 = sys_mmap(8 * LD_SIGW * LD_SIGH) as *i64
  let cells: i64 = LD_SIGW * LD_SIGH
162
  ld_puts("LUMADIFF nkf=\x00" as *u8); ld_num(nkf)
  ld_puts(" res=\x00" as *u8); ld_num(cropW); ld_puts("x\x00" as *u8); ld_num(cropH)
  ld_puts(" samples=\x00" as *u8); ld_num(maxs); ld_puts("\n\x00" as *u8)
166
  // GUARD: single-decode mode never uses step, but this line still ran and maxs
  // can legitimately be 0 (decode keyframe 0), so it divided by zero -> SIGFPE on
  // the FIRST child of every scan. A vestigial computation still faults.
  var step: i64 = 1
  if maxs > 0 { step = nkf / maxs }
  if step < 1 { step = 1 }
  var have: i64 = 0
  var decoded: i64 = 0
  var failed: i64 = 0
  var lowruns: i64 = 0
  var k: i64 = maxs
  while k < nkf {
      let t_ms: i64 = ld_r64(ib, ktab + k*16)
      let boff: i64 = ld_r64(ib, ktab + k*16 + 8)
      sys_lseek(tsfd, boff, 0)
      var wl: i64 = 0
      var g3: i64 = 1
      while g3 == 1 {
          let r: i64 = sys_read(tsfd, ((win as i64)+wl) as *u8, LD_WIN - wl)
          if r <= 0 { g3 = 0 }
          if r > 0 { wl = wl + r; if wl >= LD_WIN { g3 = 0 } }
      }
      ld_puts("  [seek] \x00" as *u8); ld_num(boff); ld_puts(" wl=\x00" as *u8); ld_num(wl); ld_puts("\n\x00" as *u8)
      var el: i64 = demux_video_es(win, wl, es, pidout)
      ld_puts("  [demux] el=\x00" as *u8); ld_num(el); ld_puts("\n\x00" as *u8)
      let il: i64 = find_first_nal(es, el, 5, idrn, LD_NALCAP)
      ld_puts("  [nal] il=\x00" as *u8); ld_num(il); ld_puts("\n\x00" as *u8)
      if il > 0 {
          let irl: i64 = nal_to_rbsp(idrn, il, irb)
          ld_puts("  [pre-decode] irl=\x00" as *u8); ld_num(irl); ld_puts("\n\x00" as *u8)
          let ok: i64 = nx_h264_decode_iframe(irb, irl, 5, sps, pps, yf, uf, vf, mbW, mbH)
          ld_puts("  [decode] ok=\x00" as *u8); ld_num(ok); ld_puts("\n\x00" as *u8)
          if ok == 1 {
              ld_signature(yf, W, cropW, cropH, sig)
              ld_puts("SIG k=\x00" as *u8); ld_num(k); ld_puts(" t_ms=\x00" as *u8); ld_num(t_ms)
              var sq: i64 = 0
              while sq < cells { ld_puts(" \x00" as *u8); ld_num(sig[sq]); sq = sq + 1 }
              ld_puts("\n\x00" as *u8)
              return 0
              decoded = decoded + 1
              if have == 1 {
                  var acc: i64 = 0
                  var c: i64 = 0
                  while c < cells { var d: i64 = sig[c] - prev[c]; if d < 0 { d = 0 - d } acc = acc + d; c = c + 1 }
                  let mad: i64 = acc / cells
                  ld_puts("  t_ms=\x00" as *u8); ld_num(t_ms)
                  ld_puts(" mad=\x00" as *u8); ld_num(mad)
                  if mad < 3 { ld_puts("  STATIC\x00" as *u8); lowruns = lowruns + 1 }
                  ld_puts("\n\x00" as *u8)
              }
              var c2: i64 = 0
              while c2 < cells { prev[c2] = sig[c2]; c2 = c2 + 1 }
              have = 1
          } else { failed = failed + 1 }
      } else { failed = failed + 1 }
      k = k + step
  }
  sys_close(tsfd)
  ld_puts("LUMADIFF decoded=\x00" as *u8); ld_num(decoded)
  ld_puts(" failed=\x00" as *u8); ld_num(failed)
  ld_puts(" static_samples=\x00" as *u8); ld_num(lowruns)
  ld_puts("\n\x00" as *u8)
  if decoded < 2 { return 6 }
  return 0
231}
nx_ts_lumadiff.nx source

`nx_ts_lumadiff.nx` source
