code wiki / _hdl_build / nx_vclient_loop_test.nx
nx_vclient_loop_test.nx source
↩ module page · 106 lines · 5639 B
1// nx_vclient_loop_test.nx -- RUNG H8 gate: the FIRST-PARTY NISHI CLIENT LOOP, end-to-end and sovereign. A
2// frame goes: capture(synthetic Y) -> ENCODE (H5/H6 codec) -> serialize bitstream (H8 stream) -> FEC block
3// (H7 R8a) -> REAL UDP loopback (H7 R8c.1) with one datagram DELIBERATELY LOST -> FEC RECOVER -> reassemble
4// -> DECODE -> reconstruct. The whole sovereign media spine in one loop -- our codec over our transport,
5// loss-recovered, no third-party anywhere. license_tier: ORIGINAL
6import "nx_vcodec_stream.nx"
7import "nx_quic_fec.nx"
8import "nx_quic_udp.nx"
9
10func g_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
11func g_pn(v: i64) -> i64 {
12 if v==0 { sys_write(1,"0" as *u8,1); return 0 }
13 let b: *u8 = sys_mmap(28); var x: i64 = v; if x<0 { sys_write(1,"-" as *u8,1); x=0-x }
14 var d: i64=0; var y: i64=x
15 while y>0 { d=d+1; y=y/10 }
16 var i: i64=d-1; y=x
17 while i>=0 { b[i]=(48+(y%10)) as u8; y=y/10; i=i-1 }
18 sys_write(1,b,d); return 0
19}
20func g_check(name: *u8, cond: i64) -> i64 {
21 if cond==1 { g_puts(" PASS " as *u8) } else { g_puts(" FAIL " as *u8) }
22 g_puts(name); g_puts("\n" as *u8); return cond
23}
24func iabs(v: i64) -> i64 { if v<0 { return 0-v } return v }
25
26func main() -> i64 {
27 g_puts("nx_vclient_loop gate -- first-party Nishi client loop: capture->encode->FEC->UDP(lose 1)->recover->decode\n" as *u8)
28 var pass: i64=0; var total: i64=0
29 let W: i64=8; let H: i64=8; let N: i64=64; let QSTEP: i64=8
30 let NCH: i64=4; let CLEN: i64=32; let PORT: i64=18402
31
32 // capture: synthetic 8x8 luma frame (gradient)
33 let Y: *u8 = sys_mmap(N)
34 var y: i64=0; while y<H { var x: i64=0; while x<W { Y[y*W+x]=(50+x*10+y*6) as u8; x=x+1 } y=y+1 }
35
36 // ENCODE -> bitstream (4 blocks x 16 coeffs x 2 bytes = 128 bytes)
37 let bits: *u8 = sys_mmap(256)
38 let nbytes: i64 = encode_plane_stream(Y, W, H, QSTEP, bits)
39 // reference decode WITHOUT transport
40 let recY_direct: *u8 = sys_mmap(N)
41 decode_plane_stream(bits, W, H, QSTEP, recY_direct)
42
43 // FEC parity over the NCH source chunks (bitstream laid flat = NCH*CLEN)
44 let parity: *u8 = sys_mmap(CLEN)
45 quic_fec_encode(bits, NCH, CLEN, parity)
46
47 // REAL UDP loopback transport
48 let rfd: i64 = quic_udp_bind(PORT)
49 sys_set_socket_timeout(rfd, 2)
50 let sfd: i64 = quic_udp_socket()
51 let dg: *u8 = sys_mmap(1+CLEN)
52 // send chunks 0,2,3 (chunk 1 DELIBERATELY LOST) + parity (idx 255)
53 var c: i64=0
54 while c<NCH {
55 if c!=1 { dg[0]=c as u8; var k: i64=0; while k<CLEN { dg[1+k]=bits[c*CLEN+k]; k=k+1 } quic_udp_sendto(sfd, PORT, dg, 1+CLEN) }
56 c=c+1
57 }
58 dg[0]=255 as u8; var kp: i64=0; while kp<CLEN { dg[1+kp]=parity[kp]; kp=kp+1 } quic_udp_sendto(sfd, PORT, dg, 1+CLEN)
59
60 // receive + reassemble
61 let recv_source: *u8 = sys_mmap(NCH*CLEN)
62 let present: *i64 = sys_mmap(NCH*8) as *i64
63 var pi: i64=0; while pi<NCH { present[pi]=0; pi=pi+1 }
64 let recv_parity: *u8 = sys_mmap(CLEN)
65 var parity_present: i64=0
66 let rbuf: *u8 = sys_mmap(1+CLEN+8)
67 var got: i64=0; var stop: i64=0
68 while stop==0 {
69 let r: i64 = quic_udp_recv(rfd, rbuf, 1+CLEN)
70 if r < (1+CLEN) { stop=1 } else {
71 let idx: i64 = rbuf[0] as i64
72 if idx==255 { var k: i64=0; while k<CLEN { recv_parity[k]=rbuf[1+k]; k=k+1 } parity_present=1 }
73 else { var k: i64=0; while k<CLEN { recv_source[idx*CLEN+k]=rbuf[1+k]; k=k+1 } present[idx]=1 }
74 got=got+1
75 if got>=4 { stop=1 }
76 }
77 }
78 // FEC recover the lost chunk
79 let outc: *u8 = sys_mmap(CLEN)
80 let rec_idx: i64 = quic_fec_recover_one(recv_source, present, NCH, CLEN, recv_parity, parity_present, outc)
81 if rec_idx>=0 { var k: i64=0; while k<CLEN { recv_source[rec_idx*CLEN+k]=outc[k]; k=k+1 } }
82
83 // DECODE the loss-recovered bitstream
84 let recY_t: *u8 = sys_mmap(N)
85 decode_plane_stream(recv_source, W, H, QSTEP, recY_t)
86
87 // measures
88 var fec_exact: i64=1
89 if rec_idx!=1 { fec_exact=0 } else { var k: i64=0; while k<CLEN { if outc[k]!=bits[CLEN+k] { fec_exact=0 } k=k+1 } }
90 var loop_exact: i64=1; var i: i64=0; while i<N { if recY_t[i]!=recY_direct[i] { loop_exact=0 } i=i+1 }
91 var err: i64=0; i=0; while i<N { err=err+iabs((recY_direct[i] as i64)-(Y[i] as i64)); i=i+1 }
92 let mean_err: i64 = err/N
93 sys_close(rfd); sys_close(sfd)
94
95 g_puts(" bitstream="); g_pn(nbytes); g_puts("B datagrams_recv="); g_pn(got); g_puts("/4 (chunk 1 lost) recovered_idx="); g_pn(rec_idx); g_puts(" mean_err="); g_pn(mean_err); g_puts("\n")
96 pass = pass + g_check("frame encodes to a transmittable bitstream (128B over the wire)" as *u8, (nbytes==128) as i64); total=total+1
97 pass = pass + g_check("FEC block delivered over REAL UDP (3 source + parity, chunk 1 dropped)" as *u8, (got>=4) as i64); total=total+1
98 pass = pass + g_check("FEC recovered the lost chunk BYTE-EXACT (no retransmit)" as *u8, fec_exact); total=total+1
99 pass = pass + g_check("FULL CLIENT LOOP byte-exact: transport-decode == direct-decode (loss recovered losslessly)" as *u8, loop_exact); total=total+1
100 pass = pass + g_check("codec reconstructs the frame within quant error (mean <= 16)" as *u8, (mean_err <= 16) as i64); total=total+1
101
102 g_puts("---- vclient_loop gate: passed " as *u8); g_pn(pass); g_puts(" / " as *u8); g_pn(total); g_puts(" ----\n" as *u8)
103 if pass==total { g_puts("VERDICT: GREEN (sovereign first-party client loop: our codec over our QUIC/FEC transport, loss-recovered, end-to-end)\n" as *u8); return 0 }
104 g_puts("VERDICT: RED\n" as *u8)
105 return 1
106}