Skip to main content

threers_codec/decode/h264/
parse_cavlc.rs

1//! CAVLC macroblock layer parsing (§7.3.5 with `entropy_coding_mode_flag`
2//! 0).
3
4use 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
10/// Map a raw `mb_type` to its kind and the index within that kind's table.
11pub 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    /// Set up `syn` for an Intra 16×16 `mb_type` (1-24).
31    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    /// Record an `mvd` over a partition's 4×4 blocks — CABAC context
212    /// selection reads it back from neighbours, and motion derivation from
213    /// the partition's top-left block.
214    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    /// `TotalCoeff` of the luma 4×4 block at `(x, y)` relative to the
229    /// macroblock, if available.
230    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}