nx_media_run_gate.nx source
↩ module page · 147 lines · 5664 B
1// nx_media_run_gate.nx -- REFEREE for EXPOSURE rung X0 (nx_ppm + nx_media_run).
2//
3// Proves the REAL-FILE path end to end (not synthetic in-memory pixels):
4// 1. build a 64x64 person frame (gray bg + 32x32 skin blob), WRITE it as a
5// real PPM to the staging input path the tool reads.
6// 2. READ it back from disk and PARSE the PPM -> *Image.
7// 3. run presence on the PARSED-FROM-FILE image -> must be PRESENT, skin 250
8// permille, bbox [16,16..47,47].
9// 4. PPM write/read ROUND-TRIP: write the parsed image again, re-read, and
10// confirm dims + sample pixels survive (blob pixel = skin, bg pixel = gray).
11// Side effect: leaves knowledge/staging/media/frame.ppm in place so
12// `nx_media_run` can be run immediately afterwards on real input.
13//
14// Every measured value PRINTED. stdout + knowledge/status/media_run_gate.log.
15// Exit 0 GREEN / 1 RED. Sovereign: syscalls + nx_image + nx_ppm + nx_presence.
16// license_tier: ORIGINAL
17import "syscalls.nx"
18import "nx_image.nx"
19import "nx_ppm.nx"
20import "nx_presence.nx"
21
22const W: i64 = 64
23const H: i64 = 64
24
25func gp(logfd: i64, s: *u8) -> i64 {
26 var n: i64 = 0
27 while s[n] != (0 as u8) { n = n + 1 }
28 sys_write(1, s, n)
29 if logfd > 0 { sys_write(logfd, s, n) }
30 return 0
31}
32func gn(logfd: i64, v: i64) -> i64 {
33 let bb: *u8 = sys_mmap(28)
34 var m: i64 = v
35 if m < 0 { sys_write(1, "-\x00" as *u8, 1); if logfd > 0 { sys_write(logfd, "-\x00" as *u8, 1) } m = 0 - m }
36 let t: *u8 = sys_mmap(28)
37 var k: i64 = 0
38 if m == 0 { t[0] = 48 as u8; k = 1 }
39 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
40 var i: i64 = 0
41 while i < k { bb[i] = t[k - 1 - i]; i = i + 1 }
42 sys_write(1, bb, k)
43 if logfd > 0 { sys_write(logfd, bb, k) }
44 return 0
45}
46func fill_rgb(img: *Image, r: i64, g: i64, b: i64) -> i64 {
47 var y: i64 = 0
48 while y < H {
49 var x: i64 = 0
50 while x < W {
51 nx_image_set(img, x, y, 0, r); nx_image_set(img, x, y, 1, g); nx_image_set(img, x, y, 2, b)
52 x = x + 1
53 }
54 y = y + 1
55 }
56 return 0
57}
58func block_rgb(img: *Image, x0: i64, y0: i64, bw: i64, bh: i64, r: i64, g: i64, b: i64) -> i64 {
59 var y: i64 = y0
60 while y < y0 + bh {
61 var x: i64 = x0
62 while x < x0 + bw {
63 nx_image_set(img, x, y, 0, r); nx_image_set(img, x, y, 1, g); nx_image_set(img, x, y, 2, b)
64 x = x + 1
65 }
66 y = y + 1
67 }
68 return 0
69}
70
71func main() -> i64 {
72 let logfd: i64 = sys_openat_append("knowledge/status/media_run_gate.log\x00" as *u8, 0x1a4)
73 gp(logfd, "MEDIA-RUN-GATE X0 (real PPM file path)\n\x00" as *u8)
74
75 let img: *Image = nx_image_alloc(W, H, 3)
76 fill_rgb(img, 128, 128, 128)
77 block_rgb(img, 16, 16, 32, 32, 200, 120, 90)
78 let w1: i64 = ppm_write(img, "knowledge/staging/media/frame.ppm\x00" as *u8)
79 gp(logfd, " wrote frame.ppm rc=\x00" as *u8); gn(logfd, w1); gp(logfd, "\n\x00" as *u8)
80
81 let szp: *i64 = sys_mmap(8) as *i64
82 let buf: *u8 = sys_read_file("knowledge/staging/media/frame.ppm\x00" as *u8, szp)
83 var read_ok: i64 = 1
84 if (buf as i64) == 0 { read_ok = 0 }
85 gp(logfd, " read frame.ppm bytes=\x00" as *u8); gn(logfd, szp[0]); gp(logfd, "\n\x00" as *u8)
86
87 let img2: *Image = ppm_parse(buf, szp[0])
88 var parse_ok: i64 = 1
89 if (img2 as i64) == 0 { parse_ok = 0 }
90 var w2: i64 = 0
91 var h2: i64 = 0
92 if parse_ok == 1 { w2 = img2.width; h2 = img2.height }
93 gp(logfd, " parsed dims=\x00" as *u8); gn(logfd, w2); gp(logfd, "x\x00" as *u8); gn(logfd, h2); gp(logfd, "\n\x00" as *u8)
94
95 let out: *i64 = sys_mmap(128) as *i64
96 var cls: i64 = NX_PRES_ABSENT
97 if parse_ok == 1 {
98 nx_presence_scan(img2, out)
99 cls = nx_presence_classify(out[0], out[1], 50, 500)
100 }
101 gp(logfd, " presence skin=\x00" as *u8); gn(logfd, out[0]); gp(logfd, " conc=\x00" as *u8); gn(logfd, out[1])
102 gp(logfd, " bbox=[\x00" as *u8); gn(logfd, out[3]); gp(logfd, ",\x00" as *u8); gn(logfd, out[4])
103 gp(logfd, "..\x00" as *u8); gn(logfd, out[5]); gp(logfd, ",\x00" as *u8); gn(logfd, out[6]); gp(logfd, "] cls=\x00" as *u8); gn(logfd, cls); gp(logfd, "\n\x00" as *u8)
104
105 // round-trip
106 ppm_write(img2, "knowledge/staging/media/rt.ppm\x00" as *u8)
107 let szp2: *i64 = sys_mmap(8) as *i64
108 let buf2: *u8 = sys_read_file("knowledge/staging/media/rt.ppm\x00" as *u8, szp2)
109 let img3: *Image = ppm_parse(buf2, szp2[0])
110 var w3: i64 = 0
111 var blob_r: i64 = 0
112 var bg_r: i64 = 0
113 if (img3 as i64) != 0 {
114 w3 = img3.width
115 blob_r = nx_image_get(img3, 32, 32, 0) // inside blob -> 200
116 bg_r = nx_image_get(img3, 0, 0, 0) // background -> 128
117 }
118 gp(logfd, " roundtrip w=\x00" as *u8); gn(logfd, w3); gp(logfd, " blobR=\x00" as *u8); gn(logfd, blob_r)
119 gp(logfd, " bgR=\x00" as *u8); gn(logfd, bg_r); gp(logfd, "\n\x00" as *u8)
120
121 var ok: i64 = 1
122 if w1 != 0 { ok = 0 }
123 if read_ok != 1 { ok = 0 }
124 if parse_ok != 1 { ok = 0 }
125 if w2 != 64 { ok = 0 }
126 if h2 != 64 { ok = 0 }
127 if cls != NX_PRES_PRESENT { ok = 0 }
128 if out[0] != 250 { ok = 0 }
129 if out[3] != 16 { ok = 0 }
130 if out[4] != 16 { ok = 0 }
131 if out[5] != 47 { ok = 0 }
132 if out[6] != 47 { ok = 0 }
133 if w3 != 64 { ok = 0 }
134 if blob_r != 200 { ok = 0 }
135 if bg_r != 128 { ok = 0 }
136
137 if ok == 1 {
138 gp(logfd, "MEDIA-RUN-GATE result=ALL-PASS verdict=GREEN\n\x00" as *u8)
139 if logfd > 0 { sys_close(logfd) }
140 sys_exit(0)
141 return 0
142 }
143 gp(logfd, "MEDIA-RUN-GATE result=FAIL verdict=RED\n\x00" as *u8)
144 if logfd > 0 { sys_close(logfd) }
145 sys_exit(1)
146 return 1
147}