nx_jpeg_zigzag_test.nx source
↩ module page · 85 lines · 2854 B
1// nx_jpeg_zigzag_test.nx -- KAT for inverse zig-zag. Uses the
2// canonical scan order from T.81 Fig. A.6 to verify the table
3// matches and that un_zigzag rearranges correctly.
4//
5// expect_exit: 0
6// license_tier: ORIGINAL
7
8import "nx_syscalls.nx"
9import "nx_jpeg_zigzag.nx"
10
11func _fail(n: i64) -> i64 {
12 let b: *u8 = sys_mmap(16)
13 b[0]=0x46; b[1]=0x41; b[2]=0x49; b[3]=0x4C; b[4]=0x3D
14 sys_write(2, b, 5)
15 var x: i64 = n
16 if x < 0 { let m: *u8 = sys_mmap(4); m[0]=0x2D; sys_write(2, m, 1); x = 0 - x }
17 if x == 0 { let z: *u8 = sys_mmap(4); z[0]=0x30; sys_write(2, z, 1) }
18 else {
19 let buf: *u8 = sys_mmap(16)
20 var pos: i64 = 0
21 while x > 0 { buf[pos] = (0x30 + (x % 10)) as u8; x = x / 10; pos = pos + 1 }
22 let out: *u8 = sys_mmap(16)
23 var i: i64 = 0
24 while i < pos { out[i] = buf[pos - 1 - i]; i = i + 1 }
25 sys_write(2, out, pos)
26 }
27 let nl: *u8 = sys_mmap(4); nl[0]=0x0A; sys_write(2, nl, 1)
28 return 0
29}
30
31func main() -> i64 {
32 let table: *i64 = sys_mmap(64 * 8) as *i64
33 nx_jpeg_zigzag_inverse_table(table)
34
35 // Spot-check the canonical table.
36 if table[ 0] != 0 { _fail(1); return 1 } // DC coefficient
37 if table[ 1] != 1 { _fail(2); return 2 }
38 if table[ 2] != 8 { _fail(3); return 3 } // row 1 col 0 in natural order
39 if table[ 3] != 16 { _fail(4); return 4 }
40 if table[ 5] != 2 { _fail(5); return 5 }
41 if table[63] != 63 { _fail(6); return 6 } // highest-freq coefficient stays at end
42
43 // Bijection check: every natural-order position 0..63 must appear
44 // exactly once across the 64 zig-zag entries.
45 let seen: *i64 = sys_mmap(64 * 8) as *i64
46 var k: i64 = 0
47 while k < 64 { seen[k] = 0; k = k + 1 }
48 k = 0
49 while k < 64 {
50 let nat: i64 = table[k]
51 if nat < 0 { _fail(10); return 10 }
52 if nat > 63 { _fail(11); return 11 }
53 if seen[nat] != 0 { _fail(12 + nat); return 12 }
54 seen[nat] = 1
55 k = k + 1
56 }
57 k = 0
58 while k < 64 {
59 if seen[k] != 1 { _fail(80 + k); return 80 }
60 k = k + 1
61 }
62
63 // Round-trip: arrange src as zig-zag of values (0..63), then
64 // un_zigzag, and verify dst[i] equals the zig-zag position at
65 // which natural-order i appears. Equivalently: dst[table[k]] = src[k].
66 let src: *i64 = sys_mmap(64 * 8) as *i64
67 let dst: *i64 = sys_mmap(64 * 8) as *i64
68 k = 0
69 while k < 64 { src[k] = k * 7 + 1; k = k + 1 } // distinct values
70
71 nx_jpeg_un_zigzag(src, dst)
72
73 k = 0
74 while k < 64 {
75 let expected: i64 = src[k]
76 let got: i64 = dst[table[k]]
77 if got != expected { _fail(200 + k); return 200 }
78 k = k + 1
79 }
80
81 let pass: *u8 = sys_mmap(16)
82 pass[0]=0x50; pass[1]=0x41; pass[2]=0x53; pass[3]=0x53; pass[4]=0x0A
83 sys_write(1, pass, 5)
84 return 0
85}