nx_video_h2h.nx source
↩ module page · 614 lines · 34958 B
1// nx_video_h2h.nx -- THE VIDEO-CALL HEAD-TO-HEAD JUDGE, SOVEREIGN AND RECEIPTED (2026-09-02).
2// Operator: "get nishifamily.com/video properly evaluated ... true jitsi and above performance ... using MSU VQMT as the
3// benchmark and oracle ... native first byte up nishi on everything". Jitsi and native WebRTC are REFEREES here, never the
4// direction: every arm plays the SAME index-strip test card (akiyo_cif + a machine-readable frame index burned into the top
5// luma rows) through a real browser client, and the SAME 20 ms strip reader records what each receiver actually RENDERED.
6// This organ is the only thing that computes or judges: the drivers dump raw samples and never a number.
7// GLASS-TRUTH DELIVERY (per receiver): effective displayed fps, delivered fraction (distinct frames shown over the source
8// index span), stalls (a gap longer than VH_STALL_MULT source intervals, the WebRTC freezeCount rule), glass-to-glass
9// latency (receiver first shows index i minus the sender's own preview first showing index i -- one machine clock).
10// FULL-REFERENCE FIDELITY (VQMT class): PSNR and SSIM of the received 352x288 luma against the SENDER'S preview of the
11// same index (both rendered by the same browser pixel pipeline = the fair reference), strip band excluded, using the
12// estate's sovereign metric organ nx_quality_metric (the seed of the sovereign VQMT; MS-SSIM/VMAF-class are the gap).
13// Writes ONE receipt (<dom>.bench grammar, nx_bench_receipt_lib -- the reader the /compare generators and gates share):
14// min_us/median_us = glass-to-glass latency, checksum = the test card (every arm must have played the same card or its
15// row is VOID), note = the delivery + fidelity numbers. A receiver that never rendered a remote is a RUN-FAIL row that
16// SAYS so, never a missing row.
17// usage: nx_video_h2h <out.bench> <ref-arm-name> <samples.txt> [samples2.txt ...] (frames come from <samples>.frames.idx/.bin)
18// exit: 0 VALID . 1 VOID (an arm played a different card) . 2 usage . 3 UNMEASURABLE (no ref arm / ref not VALID)
19// license_tier: ORIGINAL No hw writes (Rule 26).
20import "nx_syscalls.nx"
21import "nx_bench_receipt_lib.nx"
22import "nx_quality_metric.nx"
23
24const VH_MAX_ROWS: i64 = 262144
25const VH_MAX_SERIES: i64 = 128
26const VH_KEY_BYTES: i64 = 160
27const VH_MAX_FILES: i64 = 8
28const VH_STR_BYTES: i64 = 512
29const VH_MAX_CHG: i64 = 65536
30const VH_MAX_FRAMES: i64 = 4096
31const VH_WRAP: i64 = 256
32const VH_HALF_WRAP: i64 = 128
33const VH_LAT_WINDOW_MS: i64 = 8000
34const VH_STALL_MULT: i64 = 3
35const VH_FREEZE_ADD_MS: i64 = 150 // WebRTC freezeCount: gap > max(3*avg_frame_duration, avg_frame_duration + 150 ms)
36const VH_SNAP_W: i64 = 352
37const VH_SNAP_H: i64 = 288
38const VH_STRIP_ROWS: i64 = 32
39const VH_MIN_PAIRS: i64 = 10
40const VH_MIN_DISTINCT: i64 = 30
41const VH_CAP_RECEIPT: i64 = 65536
42const VH_NOTE_BYTES: i64 = 1024
43const VH_MODE_RW: i64 = 420
44const VH_PATH: i64 = 1024
45const VH_EXIT_VALID: i64 = 0
46const VH_EXIT_VOID: i64 = 1
47const VH_EXIT_USAGE: i64 = 2
48const VH_EXIT_UNMEASURABLE: i64 = 3
49const VH_ROLE_IGNORE: i64 = 0
50const VH_ROLE_SELF: i64 = 1
51const VH_ROLE_REMOTE: i64 = 2
52const VH_FILE_STRIDE: i64 = 8
53const VH_F_ARM: i64 = 0
54const VH_F_HOST: i64 = 1
55const VH_F_CARDSHA: i64 = 2
56const VH_F_FPS: i64 = 3
57const VH_F_START: i64 = 4
58const VH_F_DUR: i64 = 5
59const VH_F_URLA: i64 = 6
60const VH_F_URLB: i64 = 7
61const VH_CH_NL: i64 = 10
62const VH_CH_HASH: i64 = 35
63const VH_CH_SPACE: i64 = 32
64const VH_CH_PIPE: i64 = 124
65const VH_CH_EQ: i64 = 61
66const VH_CH_MINUS: i64 = 45
67const VH_CH_ZERO: i64 = 48
68const VH_CH_A: i64 = 65
69const VH_CH_B: i64 = 66
70const VH_HEX_DIGITS: i64 = 15
71const VH_DEFAULT_FPS: i64 = 30
72const VH_MS_PER_S: i64 = 1000
73const VH_US_PER_MS: i64 = 1000
74const VH_PERMIL: i64 = 1000
75const VH_P90_NUM: i64 = 9
76const VH_P90_DEN: i64 = 10
77const VH_UA_KEEP: i64 = 96
78const VH_URL_KEEP: i64 = 200
79
80func vh_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
81func vh_catn(dst: *u8, off: i64, v: i64) -> i64 {
82 var o: i64 = off
83 var m: i64 = v
84 if m < 0 { dst[o] = VH_CH_MINUS as u8; o = o + 1; m = 0 - m }
85 let t: *u8 = sys_mmap(32)
86 var k: i64 = 0
87 if m == 0 { t[0] = VH_CH_ZERO as u8; k = 1 }
88 while m > 0 { t[k] = (VH_CH_ZERO + (m % 10)) as u8; m = m / 10; k = k + 1 }
89 var j: i64 = 0
90 while j < k { dst[o + j] = t[k - 1 - j]; j = j + 1 }
91 dst[o + k] = 0 as u8
92 return o + k
93}
94func vh_putn(v: i64) -> i64 { let b: *u8 = sys_mmap(32); let o: i64 = vh_catn(b, 0, v); sys_write(1, b, o); return 0 }
95// substring test on NUL-terminated strings
96func vh_has(s: *u8, needle: *u8) -> i64 {
97 var nl: i64 = 0
98 while needle[nl] != (0 as u8) { nl = nl + 1 }
99 if nl == 0 { return 0 }
100 var i: i64 = 0
101 while s[i] != (0 as u8) {
102 var j: i64 = 0
103 var ok: i64 = 1
104 while j < nl { if s[i + j] == (0 as u8) { ok = 0; j = nl } else { if s[i + j] != needle[j] { ok = 0; j = nl } else { j = j + 1 } } }
105 if ok == 1 { return 1 }
106 i = i + 1
107 }
108 return 0
109}
110func vh_line_end(b: *u8, n: i64, p: i64) -> i64 { var e: i64 = p; while e < n { if b[e] == (VH_CH_NL as u8) { return e } e = e + 1 } return n }
111// k-th '|'-separated field of [s,e) -> fs/fe; 1 if it exists
112func vh_field(b: *u8, s: i64, e: i64, k: i64, fs: *i64, fe: *i64) -> i64 {
113 var p: i64 = s
114 var f: i64 = 0
115 var start: i64 = s
116 while p <= e {
117 var atsep: i64 = 0
118 if p == e { atsep = 1 } else { if b[p] == (VH_CH_PIPE as u8) { atsep = 1 } }
119 if atsep == 1 {
120 if f == k { fs[0] = start; fe[0] = p; return 1 }
121 f = f + 1
122 start = p + 1
123 }
124 p = p + 1
125 }
126 return 0
127}
128func vh_atoi_range(b: *u8, s: i64, e: i64) -> i64 {
129 var p: i64 = s
130 var neg: i64 = 0
131 if p < e { if b[p] == (VH_CH_MINUS as u8) { neg = 1; p = p + 1 } }
132 var v: i64 = 0
133 while p < e {
134 let c: i64 = b[p] as i64
135 if c >= VH_CH_ZERO { if c <= VH_CH_ZERO + 9 { v = v * 10 + (c - VH_CH_ZERO) } else { p = e } } else { p = e }
136 p = p + 1
137 }
138 if neg == 1 { return 0 - v }
139 return v
140}
141func vh_copy_range(dst: *u8, cap: i64, b: *u8, s: i64, e: i64) -> i64 {
142 var n: i64 = e - s
143 if n > cap - 1 { n = cap - 1 }
144 if n < 0 { n = 0 }
145 var i: i64 = 0
146 while i < n { dst[i] = b[s + i]; i = i + 1 }
147 dst[n] = 0 as u8
148 return n
149}
150// "key=value" inside [s,e): key must start the line or follow a space; value runs to the next space or e
151func vh_kv(b: *u8, s: i64, e: i64, key: *u8, vs: *i64, ve: *i64) -> i64 {
152 var kl: i64 = 0
153 while key[kl] != (0 as u8) { kl = kl + 1 }
154 var p: i64 = s
155 while p + kl < e {
156 var okb: i64 = 0
157 if p == s { okb = 1 } else { if b[p - 1] == (VH_CH_SPACE as u8) { okb = 1 } }
158 if okb == 1 {
159 var j: i64 = 0
160 var ok: i64 = 1
161 while j < kl { if b[p + j] != key[j] { ok = 0; j = kl } else { j = j + 1 } }
162 if ok == 1 { if b[p + kl] == (VH_CH_EQ as u8) {
163 let v0: i64 = p + kl + 1
164 var v1: i64 = v0
165 while v1 < e { if b[v1] == (VH_CH_SPACE as u8) { vs[0] = v0; ve[0] = v1; return 1 } v1 = v1 + 1 }
166 vs[0] = v0; ve[0] = e; return 1
167 } }
168 }
169 p = p + 1
170 }
171 return 0
172}
173func vh_hexval(c: i64) -> i64 {
174 if c >= VH_CH_ZERO { if c <= VH_CH_ZERO + 9 { return c - VH_CH_ZERO } }
175 if c >= 97 { if c <= 102 { return c - 97 + 10 } }
176 if c >= VH_CH_A { if c <= VH_CH_A + 5 { return c - VH_CH_A + 10 } }
177 return 0 - 1
178}
179// the first VH_HEX_DIGITS hex digits of a sha256 as one i64: the card identity every arm must share
180func vh_hex15(s: *u8) -> i64 {
181 var v: i64 = 0
182 var i: i64 = 0
183 while i < VH_HEX_DIGITS {
184 let h: i64 = vh_hexval(s[i] as i64)
185 if h < 0 { return v }
186 v = v * 16 + h
187 i = i + 1
188 }
189 return v
190}
191// role of a sampled element from its key: the driver tags elements by tag#id@tile-class<parent-id, one grammar per stack
192func vh_role(key: *u8) -> i64 {
193 if vh_has(key, "tile.self" as *u8) == 1 { return VH_ROLE_SELF }
194 if vh_has(key, "#local" as *u8) == 1 { return VH_ROLE_SELF }
195 if vh_has(key, "lk.local" as *u8) == 1 { return VH_ROLE_SELF }
196 if vh_has(key, "gal.local" as *u8) == 1 { return VH_ROLE_SELF }
197 if vh_has(key, "lk.remote" as *u8) == 1 { return VH_ROLE_REMOTE }
198 if vh_has(key, "gal.remote" as *u8) == 1 { return VH_ROLE_REMOTE }
199 if vh_has(key, "prejoinVideo" as *u8) == 1 { return VH_ROLE_IGNORE }
200 if vh_has(key, "largeVideo" as *u8) == 1 { return VH_ROLE_IGNORE }
201 if vh_has(key, "recview" as *u8) == 1 { return VH_ROLE_IGNORE }
202 if vh_has(key, "@tile" as *u8) == 1 { return VH_ROLE_REMOTE }
203 if vh_has(key, "#remote" as *u8) == 1 { return VH_ROLE_REMOTE }
204 if vh_has(key, "remoteVideo_" as *u8) == 1 { return VH_ROLE_REMOTE }
205 return VH_ROLE_IGNORE
206}
207func vh_isort(a: *i64, n: i64) -> i64 {
208 var i: i64 = 1
209 while i < n {
210 let v: i64 = a[i]
211 var j: i64 = i - 1
212 var go: i64 = 1
213 while go == 1 {
214 if j < 0 { go = 0 } else { if a[j] > v { a[j + 1] = a[j]; j = j - 1 } else { go = 0 } }
215 }
216 a[j + 1] = v
217 i = i + 1
218 }
219 return 0
220}
221func vh_write_atomic(path: *u8, buf: *u8, n: i64) -> i64 {
222 let tmp: *u8 = sys_mmap(VH_PATH)
223 var o: i64 = br_cat(tmp, 0, path)
224 o = br_cat(tmp, o, ".new" as *u8)
225 let fd: i64 = sys_openat_wr(tmp, VH_MODE_RW)
226 if fd < 0 { return 0 - 1 }
227 var off: i64 = 0
228 while off < n { let r: i64 = sys_write(fd, (buf as i64 + off) as *u8, n - off); if r <= 0 { sys_close(fd); return 0 - 2 } off = off + r }
229 sys_close(fd)
230 if sys_renameat(tmp, path) != 0 { return 0 - 3 }
231 return 0
232}
233
234// ---------------- the parsed corpus (global tables, sized by the declared caps, over-cap is COUNTED) ----------------
235// rows: ser[], t[], idx[], w[], h[] series: file, browser, role, key text
236func vh_ser_find(ser_file: *i64, ser_br: *i64, ser_keys: *u8, nser: i64, f: i64, br: i64, key: *u8) -> i64 {
237 var i: i64 = 0
238 while i < nser {
239 if ser_file[i] == f { if ser_br[i] == br {
240 if br_streq((ser_keys as i64 + i * VH_KEY_BYTES) as *u8, key) == 1 { return i }
241 } }
242 i = i + 1
243 }
244 return 0 - 1
245}
246
247// change list of one series: (t, unwrapped idx) at every index CHANGE, heartbeats and unreadable (-1) dropped
248func vh_changes(ser: i64, row_ser: *i64, row_t: *i64, row_idx: *i64, nrows: i64, out_t: *i64, out_u: *i64, out_raw: *i64, cap: i64) -> i64 {
249 var n: i64 = 0
250 var last: i64 = 0 - 1
251 var u: i64 = 0
252 var r: i64 = 0
253 while r < nrows {
254 if row_ser[r] == ser { if row_idx[r] >= 0 {
255 let ix: i64 = row_idx[r]
256 if ix != last {
257 if last >= 0 {
258 let d: i64 = ((ix - last) + VH_WRAP) % VH_WRAP
259 if d <= VH_HALF_WRAP { u = u + d } else { u = u - (VH_WRAP - d) }
260 }
261 if n < cap { out_t[n] = row_t[r]; out_u[n] = u; out_raw[n] = ix; n = n + 1 }
262 last = ix
263 }
264 } }
265 r = r + 1
266 }
267 return n
268}
269
270func main(argc: i64, argv: *i64) -> i64 {
271 if argc < 4 {
272 vh_puts("usage: nx_video_h2h <out.bench> <ref-arm-name> <samples.txt> [samples2.txt ...]\n" as *u8)
273 sys_exit(VH_EXIT_USAGE); return VH_EXIT_USAGE
274 }
275 let outp: *u8 = argv[1] as *u8
276 let refarm: *u8 = argv[2] as *u8
277 var nfiles: i64 = argc - 3
278 if nfiles > VH_MAX_FILES { vh_puts("nx_video_h2h: files over cap, judging the first " as *u8); vh_putn(VH_MAX_FILES); vh_puts("\n" as *u8); nfiles = VH_MAX_FILES }
279
280 let row_ser: *i64 = sys_mmap(8 * VH_MAX_ROWS) as *i64
281 let row_t: *i64 = sys_mmap(8 * VH_MAX_ROWS) as *i64
282 let row_idx: *i64 = sys_mmap(8 * VH_MAX_ROWS) as *i64
283 let row_w: *i64 = sys_mmap(8 * VH_MAX_ROWS) as *i64
284 let row_h: *i64 = sys_mmap(8 * VH_MAX_ROWS) as *i64
285 var nrows: i64 = 0
286 var rows_dropped: i64 = 0
287 let ser_file: *i64 = sys_mmap(8 * VH_MAX_SERIES) as *i64
288 let ser_br: *i64 = sys_mmap(8 * VH_MAX_SERIES) as *i64
289 let ser_role: *i64 = sys_mmap(8 * VH_MAX_SERIES) as *i64
290 let ser_keys: *u8 = sys_mmap(VH_KEY_BYTES * VH_MAX_SERIES)
291 var nser: i64 = 0
292 // per-file meta: strings live in a pool, ints in fmeta
293 let fmeta: *i64 = sys_mmap(8 * VH_FILE_STRIDE * VH_MAX_FILES) as *i64
294 let spool: *u8 = sys_mmap(VH_STR_BYTES * VH_FILE_STRIDE * VH_MAX_FILES)
295 let fpaths: *i64 = sys_mmap(8 * VH_MAX_FILES) as *i64
296 let fs: *i64 = sys_mmap(16) as *i64
297 let fe: *i64 = sys_mmap(16) as *i64
298 let vs: *i64 = sys_mmap(16) as *i64
299 let ve: *i64 = sys_mmap(16) as *i64
300 let lenp: *i64 = sys_mmap(16) as *i64
301 let keytmp: *u8 = sys_mmap(VH_KEY_BYTES)
302
303 var f: i64 = 0
304 while f < nfiles {
305 let path: *u8 = argv[3 + f] as *u8
306 fpaths[f] = path as i64
307 let fb: i64 = f * VH_FILE_STRIDE
308 var q: i64 = 0
309 while q < VH_FILE_STRIDE { let sp: *u8 = (spool as i64 + (fb + q) * VH_STR_BYTES) as *u8; sp[0] = 0 as u8; fmeta[fb + q] = sp as i64; q = q + 1 }
310 fmeta[fb + VH_F_FPS] = VH_DEFAULT_FPS
311 fmeta[fb + VH_F_START] = 0
312 fmeta[fb + VH_F_DUR] = 0
313 let buf: *u8 = sys_read_file(path, lenp)
314 if (buf as i64) == 0 { vh_puts("nx_video_h2h REFUSED: cannot read " as *u8); vh_puts(path); vh_puts("\n" as *u8); sys_exit(VH_EXIT_USAGE); return VH_EXIT_USAGE }
315 let n: i64 = lenp[0]
316 var p: i64 = 0
317 while p < n {
318 let e: i64 = vh_line_end(buf, n, p)
319 if e > p {
320 if buf[p] == (VH_CH_HASH as u8) {
321 if vh_kv(buf, p, e, "arm" as *u8, vs, ve) == 1 { vh_copy_range((spool as i64 + (fb + VH_F_ARM) * VH_STR_BYTES) as *u8, VH_STR_BYTES, buf, vs[0], ve[0]) }
322 if vh_kv(buf, p, e, "host" as *u8, vs, ve) == 1 { vh_copy_range((spool as i64 + (fb + VH_F_HOST) * VH_STR_BYTES) as *u8, VH_STR_BYTES, buf, vs[0], ve[0]) }
323 if vh_kv(buf, p, e, "card_sha256" as *u8, vs, ve) == 1 { vh_copy_range((spool as i64 + (fb + VH_F_CARDSHA) * VH_STR_BYTES) as *u8, VH_STR_BYTES, buf, vs[0], ve[0]) }
324 if vh_kv(buf, p, e, "card_fps" as *u8, vs, ve) == 1 { fmeta[fb + VH_F_FPS] = vh_atoi_range(buf, vs[0], ve[0]) }
325 if vh_kv(buf, p, e, "start_ms" as *u8, vs, ve) == 1 { fmeta[fb + VH_F_START] = vh_atoi_range(buf, vs[0], ve[0]) }
326 if vh_kv(buf, p, e, "dur" as *u8, vs, ve) == 1 { fmeta[fb + VH_F_DUR] = vh_atoi_range(buf, vs[0], ve[0]) }
327 if vh_kv(buf, p, e, "url" as *u8, vs, ve) == 1 {
328 // "#meta browser=X url=..." -- which browser
329 if vh_kv(buf, p, e, "browser" as *u8, fs, fe) == 1 {
330 let bch: i64 = buf[fs[0]] as i64
331 if bch == VH_CH_A { vh_copy_range((spool as i64 + (fb + VH_F_URLA) * VH_STR_BYTES) as *u8, VH_STR_BYTES, buf, vs[0], ve[0]) }
332 if bch == VH_CH_B { vh_copy_range((spool as i64 + (fb + VH_F_URLB) * VH_STR_BYTES) as *u8, VH_STR_BYTES, buf, vs[0], ve[0]) }
333 }
334 }
335 } else {
336 // arm|browser|t_ms|key|w|h|idx|hi|lo
337 if vh_field(buf, p, e, 8, fs, fe) == 1 {
338 vh_field(buf, p, e, 1, fs, fe); let br: i64 = buf[fs[0]] as i64
339 vh_field(buf, p, e, 2, fs, fe); let tt: i64 = vh_atoi_range(buf, fs[0], fe[0])
340 vh_field(buf, p, e, 3, fs, fe); vh_copy_range(keytmp, VH_KEY_BYTES, buf, fs[0], fe[0])
341 vh_field(buf, p, e, 4, fs, fe); let ww: i64 = vh_atoi_range(buf, fs[0], fe[0])
342 vh_field(buf, p, e, 5, fs, fe); let hh: i64 = vh_atoi_range(buf, fs[0], fe[0])
343 vh_field(buf, p, e, 6, fs, fe); let ii: i64 = vh_atoi_range(buf, fs[0], fe[0])
344 var sid: i64 = vh_ser_find(ser_file, ser_br, ser_keys, nser, f, br, keytmp)
345 if sid < 0 { if nser < VH_MAX_SERIES {
346 sid = nser
347 ser_file[sid] = f; ser_br[sid] = br; ser_role[sid] = vh_role(keytmp)
348 br_cat((ser_keys as i64 + sid * VH_KEY_BYTES) as *u8, 0, keytmp)
349 nser = nser + 1
350 } }
351 if sid >= 0 {
352 if nrows < VH_MAX_ROWS { row_ser[nrows] = sid; row_t[nrows] = tt; row_idx[nrows] = ii; row_w[nrows] = ww; row_h[nrows] = hh; nrows = nrows + 1 }
353 else { rows_dropped = rows_dropped + 1 }
354 }
355 }
356 }
357 }
358 p = e + 1
359 }
360 f = f + 1
361 }
362 vh_puts("nx_video_h2h: files=" as *u8); vh_putn(nfiles); vh_puts(" rows=" as *u8); vh_putn(nrows); vh_puts(" series=" as *u8); vh_putn(nser)
363 if rows_dropped > 0 { vh_puts(" ROWS-OVER-CAP=" as *u8); vh_putn(rows_dropped); vh_puts(" (partial: raise VH_MAX_ROWS deliberately)" as *u8) }
364 vh_puts("\n" as *u8)
365
366 // ---------------- per receiver: delivery + latency + fidelity -> one receipt arm ----------------
367 let hdr: *i64 = sys_mmap(8 * BR_H_N) as *i64
368 let arms: *i64 = sys_mmap(8 * BR_MAXARMS * BR_STRIDE) as *i64
369 br_init(hdr, arms)
370 var narms: i64 = 0
371 let ct: *i64 = sys_mmap(8 * VH_MAX_CHG) as *i64
372 let cu: *i64 = sys_mmap(8 * VH_MAX_CHG) as *i64
373 let craw: *i64 = sys_mmap(8 * VH_MAX_CHG) as *i64
374 let st: *i64 = sys_mmap(8 * VH_MAX_CHG) as *i64
375 let su: *i64 = sys_mmap(8 * VH_MAX_CHG) as *i64
376 let sraw: *i64 = sys_mmap(8 * VH_MAX_CHG) as *i64
377 let lat: *i64 = sys_mmap(8 * VH_MAX_CHG) as *i64
378 let apool: *u8 = sys_mmap(BR_MAXARMS * (VH_NOTE_BYTES + 4 * VH_STR_BYTES))
379 // frame tables (per file, re-parsed per remote series -- files are small)
380 let fr_br: *i64 = sys_mmap(8 * VH_MAX_FRAMES) as *i64
381 let fr_t: *i64 = sys_mmap(8 * VH_MAX_FRAMES) as *i64
382 let fr_idx: *i64 = sys_mmap(8 * VH_MAX_FRAMES) as *i64
383 let fr_off: *i64 = sys_mmap(8 * VH_MAX_FRAMES) as *i64
384 let fr_role: *i64 = sys_mmap(8 * VH_MAX_FRAMES) as *i64
385 let fpath: *u8 = sys_mmap(VH_PATH)
386 let flen: *i64 = sys_mmap(16) as *i64
387 let blen: *i64 = sys_mmap(16) as *i64
388
389 var rs: i64 = 0
390 while rs < nser {
391 var emit: i64 = 0
392 var has_remote: i64 = 0
393 if ser_role[rs] == VH_ROLE_REMOTE { emit = 1; has_remote = 1 }
394 // a browser with a SELF series and NO remote series is a receiver that saw nothing: emit a RUN-FAIL row for it
395 if ser_role[rs] == VH_ROLE_SELF {
396 var other_remote: i64 = 0
397 var q2: i64 = 0
398 while q2 < nser { if ser_file[q2] == ser_file[rs] { if ser_br[q2] == ser_br[rs] { if ser_role[q2] == VH_ROLE_REMOTE { other_remote = 1 } } } q2 = q2 + 1 }
399 if other_remote == 0 { emit = 1 }
400 }
401 if emit == 1 { if narms < BR_MAXARMS {
402 let fidx: i64 = ser_file[rs]
403 let fb2: i64 = fidx * VH_FILE_STRIDE
404 let arm: *u8 = fmeta[fb2 + VH_F_ARM] as *u8
405 let fps: i64 = fmeta[fb2 + VH_F_FPS]
406 let ab: i64 = narms * BR_STRIDE
407 let pb: *u8 = (apool as i64 + narms * (VH_NOTE_BYTES + 4 * VH_STR_BYTES)) as *u8
408 let name: *u8 = pb
409 let tool: *u8 = (pb as i64 + VH_STR_BYTES) as *u8
410 let ver: *u8 = (pb as i64 + 2 * VH_STR_BYTES) as *u8
411 let src: *u8 = (pb as i64 + 3 * VH_STR_BYTES) as *u8
412 let note: *u8 = (pb as i64 + 4 * VH_STR_BYTES) as *u8
413 var o: i64 = br_cat(name, 0, arm); o = br_cat(name, o, "-" as *u8); name[o] = ser_br[rs] as u8; name[o + 1] = 0 as u8
414 // arm names are PREFIX-matched so a driver may qualify them (jitsiself, jitsipublic, ours864) without a new table row
415 if vh_has(arm, "ours" as *u8) == 1 { br_cat(tool, 0, "nishifamily.com/video: sovereign integer codec + relay over WSS + ChaCha20 E2EE, no WebRTC (the product under test)" as *u8) }
416 else { if vh_has(arm, "webrtc" as *u8) == 1 { br_cat(tool, 0, "Chromium native WebRTC loopback (VP8/VP9 + jitter buffer + GCC): the delivery primitive every rival runs on" as *u8) }
417 else { if vh_has(arm, "jitsiself" as *u8) == 1 { br_cat(tool, 0, "Jitsi Meet through its JVB SFU, SELF-HOSTED beside the clients (docker-jitsi-meet on the same host: the path-matched referee)" as *u8) }
418 else { if vh_has(arm, "jitsi" as *u8) == 1 { br_cat(tool, 0, "Jitsi Meet through its JVB SFU (public instance over the WAN; the referee, never the direction)" as *u8) }
419 else { if vh_has(arm, "livekit" as *u8) == 1 { br_cat(tool, 0, "LiveKit SFU (livekit-server dev mode on the same host, livekit-client VP8, dynacast and adaptive stream off): the modern open SFU referee" as *u8) }
420 else { br_cat(tool, 0, arm) } } } } }
421 br_cat(ver, 0, "browser " as *u8); ver[8] = ser_br[rs] as u8; ver[9] = 0 as u8
422 var urlp: *u8 = fmeta[fb2 + VH_F_URLA] as *u8
423 if ser_br[rs] == VH_CH_B { urlp = fmeta[fb2 + VH_F_URLB] as *u8 }
424 vh_copy_range(src, VH_URL_KEEP, urlp, 0, br_slen(urlp))
425 arms[ab + BR_A_NAME] = name as i64
426 arms[ab + BR_A_TOOL] = tool as i64
427 arms[ab + BR_A_VER] = ver as i64
428 arms[ab + BR_A_SRC] = src as i64
429 arms[ab + BR_A_SRCSHA] = fmeta[fb2 + VH_F_CARDSHA]
430 arms[ab + BR_A_BINBYTES] = 0
431 arms[ab + BR_A_BINSHA] = ("-" as *u8) as i64
432 arms[ab + BR_A_CHK] = vh_hex15(fmeta[fb2 + VH_F_CARDSHA] as *u8)
433 arms[ab + BR_A_RUNS] = 0
434 arms[ab + BR_A_MIN] = 0
435 arms[ab + BR_A_MED] = 0
436 arms[ab + BR_A_STATUS] = BR_ST_RUNFAIL
437 var no: i64 = 0
438 if has_remote == 0 {
439 no = br_cat(note, 0, "no remote tile ever rendered on this receiver (the sender preview was live) -- the call did not pair" as *u8)
440 } else {
441 let nc: i64 = vh_changes(rs, row_ser, row_t, row_idx, nrows, ct, cu, craw, VH_MAX_CHG)
442 // the sender series: a SELF series in ANOTHER browser of the same file if one exists, else the same browser
443 var sender: i64 = 0 - 1
444 var q3: i64 = 0
445 while q3 < nser { if ser_file[q3] == fidx { if ser_role[q3] == VH_ROLE_SELF { if ser_br[q3] != ser_br[rs] { sender = q3 } } } q3 = q3 + 1 }
446 if sender < 0 { q3 = 0; while q3 < nser { if ser_file[q3] == fidx { if ser_role[q3] == VH_ROLE_SELF { if ser_br[q3] == ser_br[rs] { sender = q3 } } } q3 = q3 + 1 } }
447 var ns: i64 = 0
448 if sender >= 0 { ns = vh_changes(sender, row_ser, row_t, row_idx, nrows, st, su, sraw, VH_MAX_CHG) }
449 var distinct: i64 = nc
450 var span: i64 = 0
451 var dur_ms: i64 = 0
452 if nc > 1 { span = cu[nc - 1] - cu[0] + 1; dur_ms = ct[nc - 1] - ct[0] }
453 var delivered_permil: i64 = 0
454 if span > 0 { delivered_permil = distinct * VH_PERMIL / span; if delivered_permil > VH_PERMIL { delivered_permil = VH_PERMIL } }
455 var eff_fps_milli: i64 = 0
456 if dur_ms > 0 { eff_fps_milli = (distinct - 1) * VH_MS_PER_S * VH_MS_PER_S / dur_ms }
457 let src_iv: i64 = VH_MS_PER_S / fps
458 // STALL RULE = WebRTC's freezeCount definition (a gap longer than max(3 x the receiver's own average
459 // inter-frame interval, average + 150 ms)), NOT a gap measured against the SOURCE interval: a stack that
460 // legitimately delivers 10 fps has 100 ms gaps everywhere, and a source-relative rule counted every one of
461 // them as a stall (measured: 417 "stalls" on a 9.9 fps arm). Low fps is already reported by eff_fps and
462 // delivered_permil; a stall is a gap the RECEIVER's own cadence did not predict.
463 var avg_iv: i64 = src_iv
464 if nc > 1 { if dur_ms > 0 { avg_iv = dur_ms / (nc - 1) } }
465 var stall_bar: i64 = VH_STALL_MULT * avg_iv
466 if avg_iv + VH_FREEZE_ADD_MS > stall_bar { stall_bar = avg_iv + VH_FREEZE_ADD_MS }
467 var stalls: i64 = 0
468 var stall_total: i64 = 0
469 var stall_max: i64 = 0
470 var ci: i64 = 1
471 while ci < nc {
472 let gap: i64 = ct[ci] - ct[ci - 1]
473 if gap > stall_bar { stalls = stalls + 1; stall_total = stall_total + (gap - avg_iv); if gap > stall_max { stall_max = gap } }
474 ci = ci + 1
475 }
476 // glass-to-glass: receiver shows raw index i at t_r; sender preview first showed i at the latest t_s <= t_r inside one wrap
477 var nl: i64 = 0
478 var sp: i64 = 0
479 ci = 0
480 while ci < nc {
481 let tr: i64 = ct[ci]
482 var j: i64 = ns - 1
483 var found: i64 = 0
484 while j >= 0 {
485 if st[j] > tr { j = j - 1 } else {
486 if tr - st[j] > VH_LAT_WINDOW_MS { j = 0 - 1 } else {
487 if sraw[j] == craw[ci] { found = 1; if nl < VH_MAX_CHG { lat[nl] = (tr - st[j]) * VH_US_PER_MS; nl = nl + 1 } j = 0 - 1 } else { j = j - 1 }
488 }
489 }
490 }
491 sp = sp + found
492 ci = ci + 1
493 }
494 var lat_min: i64 = 0
495 var lat_med: i64 = 0
496 var lat_p90: i64 = 0
497 if nl > 0 { vh_isort(lat, nl); lat_min = lat[0]; lat_med = lat[nl / 2]; lat_p90 = lat[(nl * VH_P90_NUM) / VH_P90_DEN] }
498 // resolution as last rendered
499 var rw: i64 = 0
500 var rh: i64 = 0
501 var q4: i64 = 0
502 while q4 < nrows { if row_ser[q4] == rs { rw = row_w[q4]; rh = row_h[q4] } q4 = q4 + 1 }
503 // ---- fidelity from the index-aligned luma snapshots ----
504 var pairs: i64 = 0
505 var psnr_sum: i64 = 0
506 var ssim_sum: i64 = 0
507 var psnr_min: i64 = 0
508 var o2: i64 = br_cat(fpath, 0, fpaths[fidx] as *u8); br_cat(fpath, o2, ".frames.idx" as *u8)
509 let ib: *u8 = sys_read_file(fpath, flen)
510 if (ib as i64) != 0 {
511 let bpath: *u8 = sys_mmap(VH_PATH)
512 var o3: i64 = br_cat(bpath, 0, fpaths[fidx] as *u8); br_cat(bpath, o3, ".frames.bin" as *u8)
513 let bin: *u8 = sys_read_file(bpath, blen)
514 if (bin as i64) != 0 {
515 var nfr: i64 = 0
516 var p2: i64 = 0
517 let inl: i64 = flen[0]
518 while p2 < inl {
519 let e2: i64 = vh_line_end(ib, inl, p2)
520 if e2 > p2 { if vh_field(ib, p2, e2, 6, fs, fe) == 1 { if nfr < VH_MAX_FRAMES {
521 vh_field(ib, p2, e2, 1, fs, fe); fr_br[nfr] = ib[fs[0]] as i64
522 vh_field(ib, p2, e2, 2, fs, fe); fr_t[nfr] = vh_atoi_range(ib, fs[0], fe[0])
523 vh_field(ib, p2, e2, 3, fs, fe); vh_copy_range(keytmp, VH_KEY_BYTES, ib, fs[0], fe[0]); fr_role[nfr] = vh_role(keytmp)
524 vh_field(ib, p2, e2, 4, fs, fe); fr_idx[nfr] = vh_atoi_range(ib, fs[0], fe[0])
525 vh_field(ib, p2, e2, 5, fs, fe); fr_off[nfr] = vh_atoi_range(ib, fs[0], fe[0])
526 nfr = nfr + 1
527 } } }
528 p2 = e2 + 1
529 }
530 let sbr: i64 = ser_br[sender]
531 let sub_off: i64 = VH_STRIP_ROWS * VH_SNAP_W
532 let sub_n: i64 = VH_SNAP_W * (VH_SNAP_H - VH_STRIP_ROWS)
533 let sub_h: i64 = VH_SNAP_H - VH_STRIP_ROWS
534 let binlen: i64 = blen[0]
535 var a1: i64 = 0
536 while a1 < nfr {
537 if fr_br[a1] == ser_br[rs] { if fr_role[a1] == VH_ROLE_REMOTE {
538 // the sender's snapshot of the same index, latest one not after the receiver's by more than a source interval
539 var best: i64 = 0 - 1
540 var a2: i64 = 0
541 while a2 < nfr {
542 if fr_br[a2] == sbr { if fr_role[a2] == VH_ROLE_SELF { if fr_idx[a2] == fr_idx[a1] {
543 if fr_t[a2] <= fr_t[a1] + src_iv { if fr_t[a1] - fr_t[a2] <= VH_LAT_WINDOW_MS { if best < 0 { best = a2 } else { if fr_t[a2] > fr_t[best] { best = a2 } } } }
544 } } }
545 a2 = a2 + 1
546 }
547 if best >= 0 { if fr_off[a1] + VH_SNAP_W * VH_SNAP_H <= binlen { if fr_off[best] + VH_SNAP_W * VH_SNAP_H <= binlen {
548 let ra: *u8 = (bin as i64 + fr_off[a1] + sub_off) as *u8
549 let sa: *u8 = (bin as i64 + fr_off[best] + sub_off) as *u8
550 let ps: i64 = qm_psnr_cdb_exact(sa, ra, sub_n) // sum-based: the integer-MSE floor inflated high-quality frames by up to 0.9 dB vs libvmaf
551 let ss: i64 = qm_ssim_milli(sa, ra, VH_SNAP_W, sub_h)
552 if pairs == 0 { psnr_min = ps } else { if ps < psnr_min { psnr_min = ps } }
553 psnr_sum = psnr_sum + ps; ssim_sum = ssim_sum + ss; pairs = pairs + 1
554 } } }
555 } }
556 a1 = a1 + 1
557 }
558 }
559 }
560 // ---- the arm row ----
561 arms[ab + BR_A_RUNS] = nl
562 arms[ab + BR_A_MIN] = lat_min
563 arms[ab + BR_A_MED] = lat_med
564 if nl >= VH_MIN_PAIRS { if distinct >= VH_MIN_DISTINCT { arms[ab + BR_A_STATUS] = BR_ST_VALID } }
565 no = br_cat(note, 0, "eff_fps_milli=" as *u8); no = vh_catn(note, no, eff_fps_milli)
566 no = br_cat(note, no, " delivered_permil=" as *u8); no = vh_catn(note, no, delivered_permil)
567 no = br_cat(note, no, " distinct=" as *u8); no = vh_catn(note, no, distinct)
568 no = br_cat(note, no, " span=" as *u8); no = vh_catn(note, no, span)
569 no = br_cat(note, no, " window_ms=" as *u8); no = vh_catn(note, no, dur_ms)
570 no = br_cat(note, no, " stalls=" as *u8); no = vh_catn(note, no, stalls)
571 no = br_cat(note, no, " stall_total_ms=" as *u8); no = vh_catn(note, no, stall_total)
572 no = br_cat(note, no, " stall_max_ms=" as *u8); no = vh_catn(note, no, stall_max)
573 no = br_cat(note, no, " g2g_p90_us=" as *u8); no = vh_catn(note, no, lat_p90)
574 no = br_cat(note, no, " g2g_pairs=" as *u8); no = vh_catn(note, no, nl)
575 no = br_cat(note, no, " res=" as *u8); no = vh_catn(note, no, rw); no = br_cat(note, no, "x" as *u8); no = vh_catn(note, no, rh)
576 if pairs > 0 {
577 no = br_cat(note, no, " psnr_cdb_mean=" as *u8); no = vh_catn(note, no, psnr_sum / pairs)
578 no = br_cat(note, no, " psnr_cdb_min=" as *u8); no = vh_catn(note, no, psnr_min)
579 no = br_cat(note, no, " ssim_milli_mean=" as *u8); no = vh_catn(note, no, ssim_sum / pairs)
580 no = br_cat(note, no, " fidelity_pairs=" as *u8); no = vh_catn(note, no, pairs)
581 } else { no = br_cat(note, no, " fidelity=UNMEASURED(no index-aligned snapshot pair)" as *u8) }
582 no = br_cat(note, no, " sender=" as *u8); if sender >= 0 { note[no] = ser_br[sender] as u8; note[no + 1] = 0 as u8; no = no + 1 } else { no = br_cat(note, no, "none" as *u8) }
583 no = br_cat(note, no, " stall_bar_ms=" as *u8); no = vh_catn(note, no, stall_bar)
584 no = br_cat(note, no, " rule=stall>max(3*avg_iv,avg_iv+150ms)[webrtc-freezeCount];g2g=receiver-first-show-minus-sender-preview-first-show;fidelity=luma352x288-minus-strip-vs-sender-preview" as *u8)
585 }
586 arms[ab + BR_A_NOTE] = note as i64
587 vh_puts(" arm " as *u8); vh_puts(name); vh_puts(": " as *u8); vh_puts(br_status_name(arms[ab + BR_A_STATUS]))
588 vh_puts(" median_us=" as *u8); vh_putn(arms[ab + BR_A_MED]); vh_puts(" " as *u8); vh_puts(note); vh_puts("\n" as *u8)
589 narms = narms + 1
590 } }
591 rs = rs + 1
592 }
593
594 // ---------------- header + verdict + receipt ----------------
595 let fb0: i64 = 0
596 hdr[BR_H_TITLE] = ("Family video call head-to-head: glass-truth delivery and full-reference fidelity on one test card" as *u8) as i64
597 hdr[BR_H_WORKLOAD] = ("every arm plays testcard768.y4m (akiyo_cif + an 8-bit frame index burned into the top 32 luma rows) through a real headless Chromium client for the declared seconds; the same 20 ms strip reader records the index every receiver RENDERS; min_us/median_us = glass-to-glass latency (receiver first shows index i minus the sender preview first shows i, one machine clock); checksum = the first 15 hex digits of the card sha256 (a different card = VOID); the note carries effective fps, delivered fraction, stalls, resolution and the PSNR/SSIM of the received luma against the sender preview of the same index" as *u8) as i64
598 hdr[BR_H_HOST] = fmeta[fb0 + VH_F_HOST]
599 hdr[BR_H_RUNS] = fmeta[fb0 + VH_F_DUR]
600 hdr[BR_H_REF] = refarm as i64
601 hdr[BR_H_ASOF] = fmeta[fb0 + VH_F_START] / VH_MS_PER_S
602 hdr[BR_H_REPRO] = ("py -3.10 h2h_run.py <ours|webrtc|jitsi> 60 <arm>.txt [--codec VP8] then nx_video_h2h video.bench webrtc-A ours.txt webrtc.txt jitsi.txt" as *u8) as i64
603 hdr[BR_H_WRITER] = ("nx_video_h2h" as *u8) as i64
604 let verdict: i64 = br_verdict(hdr, arms, narms)
605 let rbuf: *u8 = sys_mmap(VH_CAP_RECEIPT)
606 let rn: i64 = br_write(rbuf, VH_CAP_RECEIPT, "video" as *u8, hdr, arms, narms, verdict)
607 let wr: i64 = vh_write_atomic(outp, rbuf, rn)
608 vh_puts("receipt wrote=" as *u8); vh_putn(rn); vh_puts(" of=" as *u8); vh_puts(outp); vh_puts(" rc=" as *u8); vh_putn(wr)
609 vh_puts(" arms=" as *u8); vh_putn(narms); vh_puts(" verdict=" as *u8); vh_puts(br_verdict_name(verdict)); vh_puts("\n" as *u8)
610 if wr != 0 { sys_exit(VH_EXIT_USAGE); return VH_EXIT_USAGE }
611 if verdict == BR_V_VALID { return VH_EXIT_VALID }
612 if verdict == BR_V_VOID { return VH_EXIT_VOID }
613 return VH_EXIT_UNMEASURABLE
614}