threers_codec/decode/h264/
parse_cavlc.rs1use super::params::SliceType;
5use super::slice::{Result, SliceDec};
6use super::tables::{BLK_XY, CBP_400, CBP_420, FIELD4, FIELD8, ZIGZAG4, ZIGZAG8};
7use super::types::*;
8use crate::decode::bits::BitReader;
9
10pub fn classify(st: SliceType, t: u32) -> Result<(MbKind, u32)> {
12 let intra = |t: u32| -> Result<(MbKind, u32)> {
13 match t {
14 0 => Ok((MbKind::I4x4, 0)),
15 1..=24 => Ok((MbKind::I16x16, t)),
16 25 => Ok((MbKind::IPcm, 25)),
17 _ => Err(format!("mb_type {t} out of range")),
18 }
19 };
20 match st {
21 SliceType::I => intra(t),
22 SliceType::P if t < 5 => Ok((MbKind::P, t)),
23 SliceType::P => intra(t - 5),
24 SliceType::B if t < 23 => Ok((MbKind::B, t)),
25 SliceType::B => intra(t - 23),
26 }
27}
28
29impl SliceDec<'_> {
30 pub fn set_i16(&mut self, t: u32) {
32 self.syn.i16_mode = ((t - 1) % 4) as u8;
33 let cbp_c = ((t - 1) / 4) % 3;
34 let cbp_l = if t >= 13 { 15 } else { 0 };
35 self.syn.cbp = (cbp_c << 4) as u8 | cbp_l;
36 }
37
38 pub fn read_pcm(&mut self, r: &mut BitReader) {
39 r.byte_align();
40 for i in 0..256 {
41 self.syn.pcm[i] = r.u(self.bd_y) as u16;
42 }
43 if self.chroma {
44 for i in 0..if self.c422 { 256 } else { 128 } {
45 self.syn.pcm[256 + i] = r.u(self.bd_c) as u16;
46 }
47 }
48 }
49
50 pub fn parse_mb_cavlc(&mut self, r: &mut BitReader) -> Result<()> {
51 let st = self.hdr.slice_type;
52 let (kind, t) = classify(st, r.ue())?;
53 self.syn.kind = kind;
54 self.syn.mb_type = t;
55 if kind == MbKind::IPcm {
56 self.read_pcm(r);
57 return Ok(());
58 }
59 let mut no_sub_lt8x8 = true;
60 let is_8x8 = (kind == MbKind::P && t >= 3) || (kind == MbKind::B && t == 22);
61 let b_direct16 = kind == MbKind::B && t == 0;
62 match kind {
63 MbKind::I4x4 => {
64 if self.pps.transform_8x8_mode && r.flag() {
65 self.syn.t8x8 = true;
66 self.syn.kind = MbKind::I8x8;
67 }
68 let n = if self.syn.t8x8 { 4 } else { 16 };
69 for i in 0..n {
70 self.syn.prev_flag[i] = r.flag();
71 if !self.syn.prev_flag[i] {
72 self.syn.rem[i] = r.u(3) as u8;
73 }
74 }
75 if self.chroma {
76 self.syn.chroma_mode = self.read_chroma_mode(r)?;
77 }
78 }
79 MbKind::I16x16 => {
80 self.set_i16(t);
81 if self.chroma {
82 self.syn.chroma_mode = self.read_chroma_mode(r)?;
83 }
84 }
85 _ if b_direct16 => {}
86 _ if is_8x8 => {
87 for s in 0..4 {
88 let v = r.ue();
89 if (kind == MbKind::P && v > 3) || v > 12 {
90 return Err("sub_mb_type out of range".into());
91 }
92 self.syn.sub[s] = v as u8;
93 }
94 let subs: [(PredFlags, usize, usize); 4] = std::array::from_fn(|s| {
95 if kind == MbKind::B {
96 b_sub_layout(self.syn.sub[s])
97 } else {
98 p_sub_layout(self.syn.sub[s])
99 }
100 });
101 for (pred, w, h) in subs {
102 if pred == 0 {
103 if !self.sps.direct_8x8_inference {
104 no_sub_lt8x8 = false;
105 }
106 } else if w * h < 4 {
107 no_sub_lt8x8 = false;
108 }
109 }
110 let ref0 = kind == MbKind::P && t == 4;
111 for l in 0..2 {
112 for s in 0..4 {
113 let pred = subs[s].0;
114 self.syn.ref_idx[l][s] = if pred & (1 << l) != 0 && !ref0 {
115 self.read_ref_idx(r, l)?
116 } else {
117 0
118 };
119 }
120 }
121 for l in 0..2 {
122 for s in 0..4 {
123 let (pred, w, h) = subs[s];
124 if pred & (1 << l) == 0 {
125 continue;
126 }
127 let (sx, sy) = ((s % 2) * 2, (s / 2) * 2);
128 for py in (0..2).step_by(h) {
129 for px in (0..2).step_by(w) {
130 let d = [r.se(), r.se()];
131 self.fill_mvd(l, sx + px, sy + py, w, h, d);
132 }
133 }
134 }
135 }
136 }
137 _ => {
138 let (shape, preds) = if kind == MbKind::B {
139 b_mb_layout(t)
140 } else {
141 p_mb_layout(t)
142 };
143 let parts = shape.parts();
144 for l in 0..2 {
145 for i in 0..parts.len() {
146 if preds[i] & (1 << l) != 0 {
147 self.syn.ref_idx[l][i] = self.read_ref_idx(r, l)?;
148 }
149 }
150 }
151 for l in 0..2 {
152 for (i, &(x, y, w, h)) in parts.iter().enumerate() {
153 if preds[i] & (1 << l) != 0 {
154 let d = [r.se(), r.se()];
155 self.fill_mvd(l, x, y, w, h, d);
156 }
157 }
158 }
159 }
160 }
161 if self.syn.kind != MbKind::I16x16 {
162 let code = r.ue() as usize;
163 let intra = self.syn.kind.is_intra();
164 let cbp = if self.chroma {
165 *CBP_420[(!intra) as usize]
166 .get(code)
167 .ok_or("coded_block_pattern out of range")?
168 } else {
169 *CBP_400[(!intra) as usize]
170 .get(code)
171 .ok_or("coded_block_pattern out of range")?
172 };
173 self.syn.cbp = cbp;
174 if cbp & 15 != 0
175 && self.pps.transform_8x8_mode
176 && !intra
177 && no_sub_lt8x8
178 && (!b_direct16 || self.sps.direct_8x8_inference)
179 {
180 self.syn.t8x8 = r.flag();
181 }
182 }
183 if self.syn.cbp != 0 || self.syn.kind == MbKind::I16x16 {
184 self.syn.qp_delta = r.se();
185 self.residual_cavlc(r)?;
186 }
187 Ok(())
188 }
189
190 fn read_chroma_mode(&mut self, r: &mut BitReader) -> Result<u8> {
191 let m = r.ue();
192 if m > 3 {
193 return Err("intra_chroma_pred_mode out of range".into());
194 }
195 Ok(m as u8)
196 }
197
198 fn read_ref_idx(&mut self, r: &mut BitReader, l: usize) -> Result<i8> {
199 let n = self.num_ref(l);
200 let v = match n {
201 0 | 1 => 0,
202 2 => 1 - r.u(1),
203 _ => r.ue(),
204 };
205 if v >= n.max(1) {
206 return Err(format!("ref_idx_l{l} {v} out of range"));
207 }
208 Ok(v as i8)
209 }
210
211 pub fn fill_mvd(&mut self, l: usize, x: usize, y: usize, w: usize, h: usize, d: [i32; 2]) {
215 let abs = [
216 d[0].unsigned_abs().min(255) as u8,
217 d[1].unsigned_abs().min(255) as u8,
218 ];
219 let m = &mut self.pic.mbs[self.addr];
220 for yy in y..y + h {
221 for xx in x..x + w {
222 self.syn.mvd[l][yy * 4 + xx] = d;
223 m.mvd[l][yy * 4 + xx] = abs;
224 }
225 }
226 }
227
228 fn nnz_luma(&self, x: isize, y: isize) -> Option<i32> {
231 let (a, k) = self.blk_nb(x, y)?;
232 Some(self.pic.mbs[a].nnz[k] as i32)
233 }
234
235 fn nnz_chroma(&self, c: usize, x: isize, y: isize) -> Option<i32> {
236 let (a, k) = self.cblk_nb(x, y)?;
237 Some(self.pic.mbs[a].nnz_c[c][k] as i32)
238 }
239
240 fn nc_of(a: Option<i32>, b: Option<i32>) -> i32 {
241 match (a, b) {
242 (Some(a), Some(b)) => (a + b + 1) >> 1,
243 (Some(a), None) => a,
244 (None, Some(b)) => b,
245 _ => 0,
246 }
247 }
248
249 fn residual_cavlc(&mut self, r: &mut BitReader) -> Result<()> {
250 let (z4, z8) = if self.field_coded() {
251 (&FIELD4, &FIELD8)
252 } else {
253 (&ZIGZAG4, &ZIGZAG8)
254 };
255 let cbp_l = self.syn.cbp & 15;
256 let cbp_c = self.syn.cbp >> 4;
257 let i16 = self.syn.kind == MbKind::I16x16;
258 let t8 = self.syn.t8x8;
259 let mut tmp;
260 if i16 {
261 let nc = Self::nc_of(self.nnz_luma(-1, 0), self.nnz_luma(0, -1));
262 tmp = [0; 16];
263 self.tables.residual_block(r, nc, 16, &mut tmp)?;
264 for k in 0..16 {
265 self.syn.dc_luma[z4[k]] = tmp[k];
266 }
267 }
268 for b8 in 0..4 {
269 for b4 in 0..4 {
270 let blk = b8 * 4 + b4;
271 let (bx, by) = BLK_XY[blk];
272 let raster = by * 4 + bx;
273 if cbp_l & (1 << b8) == 0 {
274 self.pic.mbs[self.addr].nnz[raster] = 0;
275 continue;
276 }
277 let nc = Self::nc_of(
278 self.nnz_luma(bx as isize - 1, by as isize),
279 self.nnz_luma(bx as isize, by as isize - 1),
280 );
281 tmp = [0; 16];
282 let total = if i16 {
283 let n = self.tables.residual_block(r, nc, 15, &mut tmp)?;
284 for k in 0..15 {
285 self.syn.coef[blk][z4[k + 1]] = tmp[k];
286 }
287 n
288 } else if !t8 {
289 let n = self.tables.residual_block(r, nc, 16, &mut tmp)?;
290 for k in 0..16 {
291 self.syn.coef[blk][z4[k]] = tmp[k];
292 }
293 n
294 } else {
295 let n = self.tables.residual_block(r, nc, 16, &mut tmp)?;
296 for k in 0..16 {
297 self.syn.coef8[b8][z8[4 * k + b4]] = tmp[k];
298 }
299 if n > 0 {
300 self.syn.coded8 |= 1 << b8;
301 }
302 n
303 };
304 if total > 0 && !t8 {
305 self.syn.coded |= 1 << blk;
306 }
307 self.pic.mbs[self.addr].nnz[raster] = total as u8;
308 }
309 }
310 if self.chroma && cbp_c != 0 {
311 for c in 0..2 {
312 tmp = [0; 16];
313 let n = if self.c422 { 8 } else { 4 };
314 self.tables
315 .residual_block(r, if self.c422 { -2 } else { -1 }, n, &mut tmp)?;
316 self.syn.dc_c[c][..n].copy_from_slice(&tmp[..n]);
317 self.pic.mbs[self.addr].cbf_dc |=
318 ((tmp[..n].iter().any(|&v| v != 0)) as u8) << (1 + c);
319 }
320 if cbp_c & 2 != 0 {
321 for c in 0..2 {
322 for blk in 0..if self.c422 { 8 } else { 4 } {
323 let (bx, by) = ((blk % 2) as isize, (blk / 2) as isize);
324 let nc = Self::nc_of(
325 self.nnz_chroma(c, bx - 1, by),
326 self.nnz_chroma(c, bx, by - 1),
327 );
328 tmp = [0; 16];
329 let n = self.tables.residual_block(r, nc, 15, &mut tmp)?;
330 for k in 0..15 {
331 self.syn.ac_c[c][blk][z4[k + 1]] = tmp[k];
332 }
333 if n > 0 {
334 self.syn.coded_c[c] |= 1 << blk;
335 }
336 self.pic.mbs[self.addr].nnz_c[c][blk] = n as u8;
337 }
338 }
339 }
340 }
341 Ok(())
342 }
343}