nx_vcodec_color_codec.nx source
↩ module page · 76 lines · 5588 B
1// nx_vcodec_color_codec.nx -- COLOR on the REAL engine. Rather than ship my simpler WHT codec (H5/H6), this
2// runs the proven sophisticated nx_vcodec (directional intra prediction + sovereign H.264 integer DCT + the
3// self-describing packed bitstream) on EACH of the Y/Cb/Cr planes at 4:2:0, fed by the H4 RGB<->YCbCr
4// transform. DRY: the codec engine is the one already wasm-proven + live-deployed; this adds only the color
5// plane orchestration. Chroma planes are W/2 x H/2 (must be >=16 = one macroblock, so W,H are multiples of
6// 32). Pure integer, sovereign. license_tier: ORIGINAL
7import "nx_vcodec.nx"
8import "nx_vcodec_color_frame.nx" // brings H4 (rgb_frame_to_yuv, ycbcr_to_rgb) + 4:2:0 subsample/upsample
9
10// Encode an RGB frame as a KEYFRAME: RGB -> YCbCr -> 4:2:0 -> nx_vcodec on each plane. Writes 3 streams,
11// bits_out[0..2] = per-plane bits. Returns total bits.
12func vc_color_encode_key(rgb: *u8, W: i64, H: i64, qp: i64, sad: i64, strY: *u8, strCb: *u8, strCr: *u8, bits_out: *i64) -> i64 {
13 let N: i64=W*H; let CW: i64=W/2; let CH: i64=H/2; let CN: i64=CW*CH
14 let Y: *u8 = sys_mmap(N); let Cb: *u8 = sys_mmap(N); let Cr: *u8 = sys_mmap(N)
15 let Cbs: *u8 = sys_mmap(CN); let Crs: *u8 = sys_mmap(CN)
16 let prevY: *u8 = sys_mmap(N); let prevC: *u8 = sys_mmap(CN)
17 let reconY: *u8 = sys_mmap(N); let reconCb: *u8 = sys_mmap(CN); let reconCr: *u8 = sys_mmap(CN)
18 let blk: *i64 = sys_mmap(16*8) as *i64; let mv: *i64 = sys_mmap(2*8) as *i64
19 rgb_frame_to_yuv(rgb, N, Y, Cb, Cr)
20 subsample420(Cb, W, H, Cbs); subsample420(Cr, W, H, Crs)
21 let by: i64 = vc_enc_frame_packed(Y, prevY, reconY, W, H, qp, 1, sad, strY, blk, mv)
22 let bu: i64 = vc_enc_frame_packed(Cbs, prevC, reconCb, CW, CH, qp, 1, sad, strCb, blk, mv)
23 let bv: i64 = vc_enc_frame_packed(Crs, prevC, reconCr, CW, CH, qp, 1, sad, strCr, blk, mv)
24 bits_out[0]=by; bits_out[1]=bu; bits_out[2]=bv
25 return by+bu+bv
26}
27// Decode the 3 plane streams -> RGB_OUT[W*H*3].
28func vc_color_decode_key(W: i64, H: i64, qp: i64, strY: *u8, strCb: *u8, strCr: *u8, rgb_out: *u8) -> i64 {
29 let N: i64=W*H; let CW: i64=W/2; let CH: i64=H/2; let CN: i64=CW*CH
30 let prevY: *u8 = sys_mmap(N); let prevC: *u8 = sys_mmap(CN)
31 let decY: *u8 = sys_mmap(N); let decCb: *u8 = sys_mmap(CN); let decCr: *u8 = sys_mmap(CN)
32 let decCbU: *u8 = sys_mmap(N); let decCrU: *u8 = sys_mmap(N)
33 let blk: *i64 = sys_mmap(16*8) as *i64; let mv: *i64 = sys_mmap(2*8) as *i64
34 vc_dec_frame_packed(prevY, decY, W, H, qp, strY, blk, mv)
35 vc_dec_frame_packed(prevC, decCb, CW, CH, qp, strCb, blk, mv)
36 vc_dec_frame_packed(prevC, decCr, CW, CH, qp, strCr, blk, mv)
37 upsample420(decCb, CW, CH, decCbU); upsample420(decCr, CW, CH, decCrU)
38 let o: *i64 = sys_mmap(8*3) as *i64
39 var i: i64=0
40 while i<N { ycbcr_to_rgb(decY[i] as i64, decCbU[i] as i64, decCrU[i] as i64, o); rgb_out[i*3]=o[0] as u8; rgb_out[i*3+1]=o[1] as u8; rgb_out[i*3+2]=o[2] as u8; i=i+1 }
41 return 0
42}
43// Encode an RGB frame as a P-frame (kf=0) against prev recon planes (prevY full-res, prevCbs/prevCrs
44// subsampled CW x CH), OR as a keyframe (kf=1, prev ignored). Mirrors vc_color_encode_key exactly but
45// generalizes the keyframe flag + takes real prev planes -- composes the SAME proven luma engine per
46// plane (the H6 inter rung for COLOR, on the engine, not a separate codec). Returns total bits.
47func vc_color_encode_p(rgb: *u8, W: i64, H: i64, qp: i64, kf: i64, sad: i64, prevY: *u8, prevCbs: *u8, prevCrs: *u8, strY: *u8, strCb: *u8, strCr: *u8, bits_out: *i64) -> i64 {
48 let N: i64=W*H; let CW: i64=W/2; let CH: i64=H/2; let CN: i64=CW*CH
49 let Y: *u8 = sys_mmap(N); let Cb: *u8 = sys_mmap(N); let Cr: *u8 = sys_mmap(N)
50 let Cbs: *u8 = sys_mmap(CN); let Crs: *u8 = sys_mmap(CN)
51 let reconY: *u8 = sys_mmap(N); let reconCb: *u8 = sys_mmap(CN); let reconCr: *u8 = sys_mmap(CN)
52 let blk: *i64 = sys_mmap(16*8) as *i64; let mv: *i64 = sys_mmap(2*8) as *i64
53 rgb_frame_to_yuv(rgb, N, Y, Cb, Cr)
54 subsample420(Cb, W, H, Cbs); subsample420(Cr, W, H, Crs)
55 let by: i64 = vc_enc_frame_packed(Y, prevY, reconY, W, H, qp, kf, sad, strY, blk, mv)
56 let bu: i64 = vc_enc_frame_packed(Cbs, prevCbs, reconCb, CW, CH, qp, kf, sad, strCb, blk, mv)
57 let bv: i64 = vc_enc_frame_packed(Crs, prevCrs, reconCr, CW, CH, qp, kf, sad, strCr, blk, mv)
58 bits_out[0]=by; bits_out[1]=bu; bits_out[2]=bv
59 return by+bu+bv
60}
61// Decode the 3 plane streams against prev recon planes -> RGB_OUT + the decoded subsampled planes
62// (decY full-res, decCbs/decCrs subsampled) so the caller can chain prev=dec for the next frame.
63func vc_color_decode_p(W: i64, H: i64, qp: i64, prevY: *u8, prevCbs: *u8, prevCrs: *u8, strY: *u8, strCb: *u8, strCr: *u8, rgb_out: *u8, decY: *u8, decCbs: *u8, decCrs: *u8) -> i64 {
64 let N: i64=W*H; let CW: i64=W/2; let CH: i64=H/2; let CN: i64=CW*CH
65 let decCbU: *u8 = sys_mmap(N); let decCrU: *u8 = sys_mmap(N)
66 let blk: *i64 = sys_mmap(16*8) as *i64; let mv: *i64 = sys_mmap(2*8) as *i64
67 vc_dec_frame_packed(prevY, decY, W, H, qp, strY, blk, mv)
68 vc_dec_frame_packed(prevCbs, decCbs, CW, CH, qp, strCb, blk, mv)
69 vc_dec_frame_packed(prevCrs, decCrs, CW, CH, qp, strCr, blk, mv)
70 upsample420(decCbs, CW, CH, decCbU); upsample420(decCrs, CW, CH, decCrU)
71 let o: *i64 = sys_mmap(8*3) as *i64
72 var i: i64=0
73 while i<N { ycbcr_to_rgb(decY[i] as i64, decCbU[i] as i64, decCrU[i] as i64, o); rgb_out[i*3]=o[0] as u8; rgb_out[i*3+1]=o[1] as u8; rgb_out[i*3+2]=o[2] as u8; i=i+1 }
74 return 0
75}
76func main() -> i64 { return 0 }