code wiki / _hdl_build / nx_jpeg_block_enc.nx
nx_jpeg_block_enc.nx source
↩ module page · 51 lines · 2334 B
1// nx_jpeg_block_enc.nx -- SOVEREIGN JPEG baseline block entropy coder (J2). Encodes one 8x8 block's
2// zigzag-ordered quantized coefficients into JPEG baseline entropy bits: DC as a difference from the
3// previous block's DC (Huffman category + sign-magnitude), AC as run-length of zeros + (run,size)
4// Huffman with ZRL (16-zero) runs and a trailing EOB. The matched decoder reverses it. Composes the
5// audited pieces: nx_jpeg_huff_enc (J1 tables/emit/decode) over nx_h264_bitwriter. Patent-clean
6// (JPEG/Annex K public since 1992). Self-proof = block encode->decode round-trip. license_tier: ORIGINAL
7import "nx_syscalls.nx"
8import "nx_h264_bitwriter.nx"
9import "nx_jpeg_huff_enc.nx"
10
11// Encode zz[64] (zigzag order, zz[0]=DC) into bw. prevdc = previous block's DC. Returns this DC.
12func jbe_encode_block(bw: *BitWriter, dcCO: *i64, dcSI: *i64, acCO: *i64, acSI: *i64, zz: *i64, prevdc: i64) -> i64 {
13 let diff: i64 = zz[0] - prevdc
14 jhe_emit_dc(bw, dcCO, dcSI, diff)
15 var run: i64 = 0
16 var k: i64 = 1
17 while k < 64 {
18 let v: i64 = zz[k]
19 if v == 0 { run = run + 1 } else {
20 while run >= 16 { jhe_emit_ac(bw, acCO, acSI, 15, 0); run = run - 16 }
21 jhe_emit_ac(bw, acCO, acSI, run, v)
22 run = 0
23 }
24 k = k + 1
25 }
26 if run > 0 { jhe_emit_ac(bw, acCO, acSI, 0, 0) } // EOB for trailing zeros
27 return zz[0]
28}
29
30// Decode one block from buf at bit position pos into zz[64] (zigzag order). prevdc = previous DC.
31// Returns this block's DC (for chaining).
32func jbe_decode_block(buf: *u8, pos: *i64, dcCO: *i64, dcSI: *i64, acCO: *i64, acSI: *i64, prevdc: i64, zz: *i64) -> i64 {
33 var i: i64 = 0
34 while i < 64 { zz[i] = 0; i = i + 1 }
35 let dcat: i64 = jhe_decode_sym(buf, pos, dcCO, dcSI)
36 let dc: i64 = prevdc + jhe_decode_mag(buf, pos, dcat)
37 zz[0] = dc
38 var k: i64 = 1
39 while k < 64 {
40 let sym: i64 = jhe_decode_sym(buf, pos, acCO, acSI)
41 if sym == 0 { k = 64 } else { // EOB: remaining stay zero
42 let run: i64 = sym >> 4
43 let size: i64 = sym & 0xf
44 if size == 0 { k = k + 16 } else { // ZRL: skip 16 zeros
45 k = k + run
46 if k < 64 { zz[k] = jhe_decode_mag(buf, pos, size); k = k + 1 }
47 }
48 }
49 }
50 return dc
51}