nx_av1_tile_gate.nx source
↩ module page · 170 lines · 7484 B
1// nx_av1_tile_gate.nx -- proves AV1/AV2 tile geometry and tile_info.
2//
3// T2 pins the mode-info count against the OBVIOUS-BUT-WRONG formula. MiCols is
4// 2 * ((w + 7) >> 3): round to 8 pixels first, THEN count 4x4 units. The
5// natural (w + 3) >> 2 agrees on multiples of 8 and disagrees everywhere else,
6// so the test uses 1, 4, 7, 8, 9 and 1920 -- a 1x1 frame has TWO mode-info
7// columns, not one, and only the correct formula gives that.
8//
9// T3 pins ns(): small values cost w-1 bits and large ones w. Reading it as a
10// fixed-width field consumes one bit too few on every large value. The test
11// round-trips every value of several non-power-of-two alphabets, so a
12// fixed-width reader cannot pass.
13//
14// T4 round-trips real tile_info at 1920x1080 and 3840x2160, with both 64 and
15// 128 superblocks, across the legal log2 range.
16//
17// license_tier: ORIGINAL
18import "nx_syscalls.nx"
19import "nx_bitstream.nx"
20import "nx_av1_seq.nx"
21import "nx_av1_tile.nx"
22
23func g_puts(s: *u8) -> i64 {
24 var i: i64 = 0
25 while s[i] != (0 as u8) { i = i + 1 }
26 sys_write(1, s, i)
27 return i
28}
29
30func g_putn(v: i64) -> i64 {
31 let buf: *u8 = sys_mmap(32)
32 var x: i64 = v
33 if x < 0 { g_puts("-" as *u8); x = 0 - x }
34 if x == 0 { buf[0] = 0x30 as u8; sys_write(1, buf, 1); return 1 }
35 let tmp: *u8 = sys_mmap(32)
36 var d: i64 = 0
37 while x > 0 { tmp[d] = ((x % 10) + 0x30) as u8; x = x / 10; d = d + 1 }
38 var i: i64 = 0
39 while i < d { buf[i] = tmp[d - 1 - i]; i = i + 1 }
40 sys_write(1, buf, d)
41 return d
42}
43
44func main() -> i64 {
45 var fails: i64 = 0
46 var mark: i64 = 0
47
48 // ---- T1: tile_log2 is the smallest k with (blk << k) >= target ----
49 if nx_av1_tile_log2(1, 1) != 0 { fails = fails + 1 }
50 if nx_av1_tile_log2(1, 2) != 1 { fails = fails + 1 }
51 if nx_av1_tile_log2(1, 5) != 3 { fails = fails + 1 }
52 if nx_av1_tile_log2(1, 8) != 3 { fails = fails + 1 }
53 if nx_av1_tile_log2(4, 8) != 1 { fails = fails + 1 }
54 if nx_av1_tile_log2(8, 8) != 0 { fails = fails + 1 }
55 if nx_av1_tile_log2(0, 8) != (0 - 1) { fails = fails + 1 }
56 if fails > 0 { if mark == 0 { mark = 1 } }
57
58 // ---- T2: MiCols rounds to 8 pixels BEFORE counting 4x4 units ----
59 // a 1x1 frame has TWO mode-info columns, which (w+3)>>2 would give as 1
60 if nx_av1_mi_cols(1) != 2 { fails = fails + 1 }
61 if nx_av1_mi_cols(4) != 2 { fails = fails + 1 }
62 if nx_av1_mi_cols(7) != 2 { fails = fails + 1 }
63 if nx_av1_mi_cols(8) != 2 { fails = fails + 1 }
64 if nx_av1_mi_cols(9) != 4 { fails = fails + 1 }
65 if nx_av1_mi_cols(1920) != 480 { fails = fails + 1 }
66 if nx_av1_mi_rows(1080) != 270 { fails = fails + 1 }
67 if nx_av1_mi_rows(1) != 2 { fails = fails + 1 }
68 if fails > 0 { if mark == 0 { mark = 2 } }
69
70 // ---- superblock counts at both sizes ----
71 // 1920 wide -> 480 mi cols -> 30 superblocks at 64, 15 at 128
72 if nx_av1_sb_cols(480, 0) != 30 { fails = fails + 1 }
73 if nx_av1_sb_cols(480, 1) != 15 { fails = fails + 1 }
74 if nx_av1_sb_rows(270, 0) != 17 { fails = fails + 1 }
75 if nx_av1_sb_rows(270, 1) != 9 { fails = fails + 1 }
76 if fails > 0 { if mark == 0 { mark = 3 } }
77
78 // ---- T3: ns() round-trips every value of non-power-of-two alphabets ----
79 let nb: *u8 = sys_mmap(256)
80 let sizes: *i64 = sys_mmap(64) as *i64
81 sizes[0] = 3; sizes[1] = 5; sizes[2] = 6; sizes[3] = 7; sizes[4] = 9; sizes[5] = 100
82 var si: i64 = 0
83 while si < 6 {
84 let nn: i64 = sizes[si]
85 var v: i64 = 0
86 while v < nn {
87 let w: *NxAv1Bw = nx_av1_bw_new(nb, 256)
88 if nx_av1_ns_write(w, v, nn) != 1 { fails = fails + 1 } else {
89 let bs: *NxBitStream = nx_bitstream_alloc(nb, 256)
90 if nx_av1_ns_read(bs, nn) != v { fails = fails + 1 }
91 }
92 v = v + 1
93 }
94 si = si + 1
95 }
96 // an alphabet of one costs zero bits
97 let w1: *NxAv1Bw = nx_av1_bw_new(nb, 256)
98 if nx_av1_ns_write(w1, 0, 1) != 1 { fails = fails + 1 }
99 if w1.bitpos != 0 { fails = fails + 1 }
100 // out-of-range values are refused
101 if nx_av1_ns_write(w1, 5, 5) != 0 { fails = fails + 1 }
102 if nx_av1_ns_write(w1, 0 - 1, 5) != 0 { fails = fails + 1 }
103 if fails > 0 { if mark == 0 { mark = 4 } }
104
105 // ---- T4: real tile_info round-trip ----
106 let tb: *u8 = sys_mmap(256)
107 let fld: *i64 = sys_mmap(128) as *i64
108 // 1920x1080, 64px superblocks: sbCols 30, sbRows 17
109 var cl: i64 = 0
110 while cl < 5 {
111 var rl: i64 = 0
112 while rl < 5 {
113 let w: *NxAv1Bw = nx_av1_bw_new(tb, 256)
114 if nx_av1_tile_write_uniform(w, 1920, 1080, 0, cl, rl) == 1 {
115 let bs: *NxBitStream = nx_bitstream_alloc(tb, 256)
116 if nx_av1_tile_parse(bs, 1920, 1080, 0, fld) != 1 { fails = fails + 1 } else {
117 if fld[NX_TILE_FLD_COLSLOG2] != cl { fails = fails + 1 }
118 if fld[NX_TILE_FLD_ROWSLOG2] != rl { fails = fails + 1 }
119 if fld[NX_TILE_FLD_COLS] != (1 << cl) { fails = fails + 1 }
120 if fld[NX_TILE_FLD_SBCOLS] != 30 { fails = fails + 1 }
121 if fld[NX_TILE_FLD_SBROWS] != 17 { fails = fails + 1 }
122 }
123 }
124 rl = rl + 1
125 }
126 cl = cl + 1
127 }
128 if fails > 0 { if mark == 0 { mark = 5 } }
129
130 // ---- T5: 4K with 128px superblocks ----
131 let w4: *NxAv1Bw = nx_av1_bw_new(tb, 256)
132 if nx_av1_tile_write_uniform(w4, 3840, 2160, 1, 2, 1) != 1 { fails = fails + 1 } else {
133 let bs4: *NxBitStream = nx_bitstream_alloc(tb, 256)
134 if nx_av1_tile_parse(bs4, 3840, 2160, 1, fld) != 1 { fails = fails + 1 } else {
135 if fld[NX_TILE_FLD_COLSLOG2] != 2 { fails = fails + 1 }
136 if fld[NX_TILE_FLD_ROWSLOG2] != 1 { fails = fails + 1 }
137 if fld[NX_TILE_FLD_COLS] != 4 { fails = fails + 1 }
138 if fld[NX_TILE_FLD_ROWS] != 2 { fails = fails + 1 }
139 // 3840 -> 960 mi cols -> 30 superblocks at 128px
140 if fld[NX_TILE_FLD_SBCOLS] != 30 { fails = fails + 1 }
141 }
142 }
143 if fails > 0 { if mark == 0 { mark = 6 } }
144
145 // ---- T6 NEG: refusals ----
146 let wn: *NxAv1Bw = nx_av1_bw_new(tb, 256)
147 // a column log2 beyond the legal maximum
148 if nx_av1_tile_write_uniform(wn, 1920, 1080, 0, 30, 0) != 0 { fails = fails + 1 }
149 // zero dimensions
150 if nx_av1_tile_write_uniform(wn, 0, 1080, 0, 0, 0) != 0 { fails = fails + 1 }
151 if nx_av1_tile_write_uniform(wn, 1920, 0, 0, 0, 0) != 0 { fails = fails + 1 }
152 // a non-uniform flag is unsupported here and must be REFUSED, not guessed
153 tb[0] = 0x00 as u8
154 let bsn: *NxBitStream = nx_bitstream_alloc(tb, 256)
155 if nx_av1_tile_parse(bsn, 1920, 1080, 0, fld) != 0 { fails = fails + 1 }
156 if fails > 0 { if mark == 0 { mark = 7 } }
157
158 if fails == 0 {
159 g_puts("GATE nx_av1_tile verdict=GREEN pass=7/7 (tile_log2; MiCols rounds to 8px BEFORE 4x4 counting -- 1x1 gives 2 not 1, pinned at 1/4/7/8/9/1920; superblock counts at 64 and 128; ns() round-trips EVERY value of alphabets 3/5/6/7/9/100 so a fixed-width reader cannot pass, 1-symbol costs zero bits; tile_info round-trip 1920x1080 over 25 log2 pairs and 3840x2160 at 128px; NEG oversize-log2/zero-dims/non-uniform refused)\n" as *u8)
160 sys_exit(0)
161 return 0
162 }
163 g_puts("GATE nx_av1_tile verdict=RED fails=" as *u8)
164 g_putn(fails)
165 g_puts(" first_stage=" as *u8)
166 g_putn(mark)
167 g_puts("\n" as *u8)
168 sys_exit(1)
169 return 1
170}