nx_fidelity_gate.nx source
↩ module page · 128 lines · 4347 B
1// nx_fidelity_gate.nx -- REFEREE for the fidelity metric (nx_segsnr).
2//
3// A reference sine; four reconstructions of decreasing quality:
4// exact copy -> capped ~99 dB
5// + small noise (200)-> high SegSNR
6// + large noise(4000)-> lower SegSNR
7// unrelated (noise) -> near 0 dB (neg-control)
8// The metric must rank them MONOTONICALLY (exact > small > large > unrelated),
9// and the unrelated case must be low -- otherwise it can't tell good from bad.
10//
11// Evidence -> stdout + knowledge/status/fidelity_gate.log. Exit 0 GREEN / 1 RED.
12// Sovereign x86_64 throughout. license_tier: ORIGINAL
13import "nx_syscalls_x86_64.nx"
14import "nx_fidelity.nx"
15import "nx_polypitch.nx"
16
17const N: i64 = 2048
18const FRAME: i64 = 256
19const FS: i64 = 8000
20const TWO_PI: i64 = 411775
21
22func gp(logfd: i64, s: *u8) -> i64 {
23 var n: i64 = 0
24 while s[n] != (0 as u8) { n = n + 1 }
25 sys_write(1, s, n)
26 if logfd > 0 { sys_write(logfd, s, n) }
27 return 0
28}
29func gn(logfd: i64, v: i64) -> i64 {
30 let bb: *u8 = sys_mmap(28)
31 var m: i64 = v
32 if m < 0 { sys_write(1, "-\x00" as *u8, 1); if logfd > 0 { sys_write(logfd, "-\x00" as *u8, 1) } m = 0 - m }
33 let t: *u8 = sys_mmap(28)
34 var k: i64 = 0
35 if m == 0 { t[0] = 48 as u8; k = 1 }
36 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
37 var i: i64 = 0
38 while i < k { bb[i] = t[k - 1 - i]; i = i + 1 }
39 sys_write(1, bb, k)
40 if logfd > 0 { sys_write(logfd, bb, k) }
41 return 0
42}
43func store16(buf: *u8, i: i64, v: i64) -> i64 {
44 var x: i64 = v
45 if x > 32767 { x = 32767 }
46 if x < -32768 { x = -32768 }
47 if x < 0 { x = x + 0x10000 }
48 buf[i * 2] = (x & 0xff) as u8
49 buf[i * 2 + 1] = ((x >> 8) & 0xff) as u8
50 return 0
51}
52func load16(buf: *u8, i: i64) -> i64 {
53 let lo: i64 = buf[i * 2]
54 let hi: i64 = buf[i * 2 + 1]
55 var v: i64 = lo | (hi << 8)
56 if v >= 0x8000 { v = v - 0x10000 }
57 return v
58}
59// reference sine at f Hz, amplitude amp
60func gen_sine(buf: *u8, f: i64, amp: i64) -> i64 {
61 let dph: i64 = (TWO_PI * f) / FS
62 var ph: i64 = 0
63 var i: i64 = 0
64 while i < N {
65 store16(buf, i, (amp * nx_pp_sinfull(ph)) >> 16)
66 ph = ph + dph
67 if ph >= TWO_PI { ph = ph - TWO_PI }
68 i = i + 1
69 }
70 return 0
71}
72// copy ref then add uniform noise of +-mag (deterministic LCG)
73func copy_plus_noise(ref: *u8, dst: *u8, mag: i64, seed0: i64) -> i64 {
74 var s: i64 = seed0
75 var i: i64 = 0
76 while i < N {
77 s = (s * 1103515245 + 12345) & 0x7fffffff
78 var nz: i64 = 0
79 if mag > 0 { nz = (s % (2 * mag + 1)) - mag }
80 store16(dst, i, load16(ref, i) + nz)
81 i = i + 1
82 }
83 return 0
84}
85
86func main() -> i64 {
87 let logfd: i64 = sys_openat_append("knowledge/status/fidelity_gate.log\x00" as *u8, 0x1a4)
88 gp(logfd, "FIDELITY-GATE R6 (SegSNR deci-dB)\n\x00" as *u8)
89
90 let ref: *u8 = sys_mmap(N * 2)
91 let t1: *u8 = sys_mmap(N * 2)
92 let t2: *u8 = sys_mmap(N * 2)
93 let t3: *u8 = sys_mmap(N * 2)
94 let t4: *u8 = sys_mmap(N * 2)
95 gen_sine(ref, 220, 16000)
96 copy_plus_noise(ref, t1, 0, 1) // exact copy
97 copy_plus_noise(ref, t2, 200, 7) // small noise
98 copy_plus_noise(ref, t3, 4000, 13) // large noise
99 gen_sine(t4, 330, 16000) // unrelated signal
100
101 let s1: i64 = nx_segsnr(ref, t1, N, FRAME)
102 let s2: i64 = nx_segsnr(ref, t2, N, FRAME)
103 let s3: i64 = nx_segsnr(ref, t3, N, FRAME)
104 let s4: i64 = nx_segsnr(ref, t4, N, FRAME)
105 gp(logfd, " exact=\x00" as *u8); gn(logfd, s1)
106 gp(logfd, " small=\x00" as *u8); gn(logfd, s2)
107 gp(logfd, " large=\x00" as *u8); gn(logfd, s3)
108 gp(logfd, " unrelated=\x00" as *u8); gn(logfd, s4)
109 gp(logfd, " (deci-dB)\n\x00" as *u8)
110
111 var ok: i64 = 1
112 if s1 <= s2 { ok = 0 } // monotonic degradation
113 if s2 <= s3 { ok = 0 }
114 if s3 <= s4 { ok = 0 }
115 if s1 < 800 { ok = 0 } // exact copy ~ capped high (>=80 dB)
116 if s4 > 80 { ok = 0 } // unrelated must be low (< 8 dB)
117
118 if ok == 1 {
119 gp(logfd, "FIDELITY-GATE result=ALL-PASS verdict=GREEN\n\x00" as *u8)
120 if logfd > 0 { sys_close(logfd) }
121 sys_exit(0)
122 return 0
123 }
124 gp(logfd, "FIDELITY-GATE result=FAIL verdict=RED\n\x00" as *u8)
125 if logfd > 0 { sys_close(logfd) }
126 sys_exit(1)
127 return 1
128}