Skip to main content

threers_codec/decode/h264/
parse_cabac.rs

1//! CABAC macroblock layer parsing (§7.3.5 with `entropy_coding_mode_flag`
2//! 1): binarisations (§9.3.2) and context selection (§9.3.3.1).
3
4use super::params::SliceType;
5use super::parse_cavlc::classify;
6use super::slice::{Result, SliceDec};
7use super::tables::{BLK_XY, FIELD4, FIELD8, LAST8, SIG8, SIG8_FIELD, ZIGZAG4, ZIGZAG8};
8use super::types::*;
9use crate::decode::bits::BitReader;
10use crate::decode::cabac::Cabac;
11
12const CBF_OFF: [usize; 5] = [0, 4, 8, 12, 16];
13const SIG_OFF: [usize; 5] = [0, 15, 29, 44, 47];
14const ABS_OFF: [usize; 5] = [0, 10, 20, 30, 39];
15
16impl SliceDec<'_> {
17    #[inline(always)]
18    fn bin(&mut self, c: &mut Cabac, idx: usize) -> u32 {
19        c.decision(&mut self.ctx[idx])
20    }
21
22    /// `mb_field_decoding_flag` (ctxIdx 70-72), read at a pair's top
23    /// macroblock. The left term is the flag the pair inherited, as ffmpeg
24    /// has it (the left pair's, within a slice).
25    pub fn cabac_field_flag(&mut self, c: &mut Cabac) -> bool {
26        let w = self.pic.w_mbs;
27        let mut inc = (self.mb_field && self.mb_x > 0) as usize;
28        if self.mb_y >= 2 {
29            let m = &self.pic.mbs[self.addr - 2 * w];
30            inc += (m.slice == self.slice_num && m.field) as usize;
31        }
32        self.bin(c, 70 + inc) == 1
33    }
34
35    pub fn cabac_skip_flag(&mut self, c: &mut Cabac) -> bool {
36        let cond = |s: &Self, dx, dy| {
37            s.mb_nb(dx, dy)
38                .map_or(0, |a| !s.pic.mbs[a].kind.is_skip() as usize)
39        };
40        let inc = cond(self, -1, 0) + cond(self, 0, -1);
41        let base = if self.hdr.slice_type == SliceType::P {
42            11
43        } else {
44            24
45        };
46        self.bin(c, base + inc) == 1
47    }
48
49    /// `mb_type` for I macroblocks: the whole of it in an I slice
50    /// (`base` 3), or the suffix after an intra prefix in P (17) / B (32).
51    fn mb_type_i(&mut self, c: &mut Cabac, base: usize) -> u32 {
52        let in_i = base == 3;
53        let b0 = if in_i {
54            let cond = |s: &Self, dx, dy| {
55                s.mb_nb(dx, dy)
56                    .map_or(0, |a| !s.pic.mbs[a].kind.is_nxn() as usize)
57            };
58            let inc = cond(self, -1, 0) + cond(self, 0, -1);
59            self.bin(c, 3 + inc)
60        } else {
61            self.bin(c, base)
62        };
63        if b0 == 0 {
64            return 0;
65        }
66        if c.terminate() == 1 {
67            return 25;
68        }
69        let (luma, chroma, pred);
70        if in_i {
71            luma = self.bin(c, 3 + 3);
72            chroma = if self.bin(c, 3 + 4) == 1 {
73                1 + self.bin(c, 3 + 5)
74            } else {
75                0
76            };
77            pred = (self.bin(c, 3 + 6) << 1) | self.bin(c, 3 + 7);
78        } else {
79            luma = self.bin(c, base + 1);
80            chroma = if self.bin(c, base + 2) == 1 {
81                1 + self.bin(c, base + 2)
82            } else {
83                0
84            };
85            pred = (self.bin(c, base + 3) << 1) | self.bin(c, base + 3);
86        }
87        1 + pred + 4 * chroma + 12 * luma
88    }
89
90    fn mb_type_p(&mut self, c: &mut Cabac) -> u32 {
91        if self.bin(c, 14) == 1 {
92            return 5 + self.mb_type_i(c, 17);
93        }
94        if self.bin(c, 15) == 0 {
95            if self.bin(c, 16) == 0 {
96                0
97            } else {
98                3
99            }
100        } else if self.bin(c, 17) == 1 {
101            1
102        } else {
103            2
104        }
105    }
106
107    fn mb_type_b(&mut self, c: &mut Cabac) -> u32 {
108        let cond = |s: &Self, dx, dy| {
109            s.mb_nb(dx, dy)
110                .map_or(0, |a| !s.pic.mbs[a].b_direct16 as usize)
111        };
112        let inc = cond(self, -1, 0) + cond(self, 0, -1);
113        if self.bin(c, 27 + inc) == 0 {
114            return 0;
115        }
116        if self.bin(c, 27 + 3) == 0 {
117            return 1 + self.bin(c, 27 + 5);
118        }
119        let mut bits = self.bin(c, 27 + 4) << 3;
120        bits |= self.bin(c, 27 + 5) << 2;
121        bits |= self.bin(c, 27 + 5) << 1;
122        bits |= self.bin(c, 27 + 5);
123        match bits {
124            0..=7 => bits + 3,
125            13 => 23 + self.mb_type_i(c, 32),
126            14 => 11,
127            15 => 22,
128            _ => ((bits << 1) | self.bin(c, 27 + 5)) - 4,
129        }
130    }
131
132    fn sub_mb_type_p(&mut self, c: &mut Cabac) -> u8 {
133        if self.bin(c, 21) == 1 {
134            0
135        } else if self.bin(c, 22) == 0 {
136            1
137        } else if self.bin(c, 23) == 1 {
138            2
139        } else {
140            3
141        }
142    }
143
144    fn sub_mb_type_b(&mut self, c: &mut Cabac) -> u8 {
145        if self.bin(c, 36) == 0 {
146            return 0;
147        }
148        if self.bin(c, 37) == 0 {
149            return 1 + self.bin(c, 39) as u8;
150        }
151        let mut t = 3u8;
152        if self.bin(c, 38) == 1 {
153            if self.bin(c, 39) == 1 {
154                return 11 + self.bin(c, 39) as u8;
155            }
156            t += 4;
157        }
158        t += 2 * self.bin(c, 39) as u8;
159        t += self.bin(c, 39) as u8;
160        t
161    }
162
163    /// Context increment term for `ref_idx_lX` from the neighbouring
164    /// partition at `(x, y)`.
165    fn ref_cond(&self, l: usize, x: isize, y: isize) -> usize {
166        let Some((a, k)) = self.blk_nb(x, y) else {
167            return 0;
168        };
169        let m = &self.pic.mbs[a];
170        if m.kind.is_skip() || m.kind.is_intra() {
171            return 0;
172        }
173        let k8 = (k / 8) * 2 + (k % 4) / 2;
174        if m.direct8 & (1 << k8) != 0 {
175            return 0;
176        }
177        let r = m.ref_idx[l][k8];
178        // MBAFF: a field neighbour of a frame macroblock counts refIdx >> 1.
179        let r = if self.mbaff && !self.mb_field && m.field {
180            r >> 1
181        } else {
182            r
183        };
184        (r > 0) as usize
185    }
186
187    fn ref_idx_cabac(&mut self, c: &mut Cabac, l: usize, x: usize, y: usize) -> Result<i8> {
188        let inc = self.ref_cond(l, x as isize - 1, y as isize)
189            + 2 * self.ref_cond(l, x as isize, y as isize - 1);
190        let mut v = 0u32;
191        if self.bin(c, 54 + inc) == 1 {
192            v = 1;
193            if self.bin(c, 54 + 4) == 1 {
194                v = 2;
195                while self.bin(c, 54 + 5) == 1 {
196                    v += 1;
197                    if v > 32 {
198                        return Err("ref_idx too large".into());
199                    }
200                }
201            }
202        }
203        if v >= self.num_ref(l) {
204            return Err(format!("ref_idx_l{l} {v} out of range"));
205        }
206        Ok(v as i8)
207    }
208
209    fn mvd_abs_nb(&self, l: usize, comp: usize, x: isize, y: isize) -> u32 {
210        let Some((a, k)) = self.blk_nb(x, y) else {
211            return 0;
212        };
213        let m = &self.pic.mbs[a];
214        let v = m.mvd[l][k][comp] as u32;
215        // MBAFF: vertical mvd of a neighbour of the other kind, rescaled
216        // (ffmpeg MAP_F2F, which only touches partitions using the list).
217        if comp == 1
218            && self.mbaff
219            && m.field != self.mb_field
220            && m.ref_idx[l][(k / 8) * 2 + (k % 4) / 2] >= 0
221        {
222            return if self.mb_field { v >> 1 } else { v << 1 };
223        }
224        v
225    }
226
227    fn mvd_cabac(
228        &mut self,
229        c: &mut Cabac,
230        l: usize,
231        comp: usize,
232        x: usize,
233        y: usize,
234    ) -> Result<i32> {
235        let sum = self.mvd_abs_nb(l, comp, x as isize - 1, y as isize)
236            + self.mvd_abs_nb(l, comp, x as isize, y as isize - 1);
237        let inc = if sum < 3 {
238            0
239        } else if sum <= 32 {
240            1
241        } else {
242            2
243        };
244        let base = if comp == 0 { 40 } else { 47 };
245        if self.bin(c, base + inc) == 0 {
246            return Ok(0);
247        }
248        const INC: [usize; 8] = [3, 4, 5, 6, 6, 6, 6, 6];
249        let mut abs = 1i32;
250        while abs < 9 && self.bin(c, base + INC[abs as usize - 1]) == 1 {
251            abs += 1;
252        }
253        if abs >= 9 {
254            let mut k = 3;
255            while c.bypass() == 1 {
256                abs += 1 << k;
257                k += 1;
258                if k > 24 {
259                    return Err("mvd suffix too long".into());
260                }
261            }
262            abs += c.bypass_bits(k) as i32;
263        }
264        Ok(if c.bypass() == 1 { -abs } else { abs })
265    }
266
267    fn parse_mvd_pair(
268        &mut self,
269        c: &mut Cabac,
270        l: usize,
271        x: usize,
272        y: usize,
273        w: usize,
274        h: usize,
275    ) -> Result<()> {
276        let dx = self.mvd_cabac(c, l, 0, x, y)?;
277        let dy = self.mvd_cabac(c, l, 1, x, y)?;
278        self.fill_mvd(l, x, y, w, h, [dx, dy]);
279        Ok(())
280    }
281
282    /// Record parsed reference indices on the current macroblock so later
283    /// partitions' context selection sees them.
284    fn note_ref(&mut self, l: usize, x: usize, y: usize, w: usize, h: usize, r: i8) {
285        let m = &mut self.pic.mbs[self.addr];
286        for yy in (y..y + h).step_by(2) {
287            for xx in (x..x + w).step_by(2) {
288                m.ref_idx[l][(yy / 2) * 2 + xx / 2] = r;
289            }
290        }
291    }
292
293    pub fn parse_mb_cabac(&mut self, c: &mut Cabac) -> Result<()> {
294        let st = self.hdr.slice_type;
295        let raw = match st {
296            SliceType::I => self.mb_type_i(c, 3),
297            SliceType::P => self.mb_type_p(c),
298            SliceType::B => self.mb_type_b(c),
299        };
300        let (kind, t) = classify(st, raw)?;
301        self.syn.kind = kind;
302        self.syn.mb_type = t;
303        if kind == MbKind::IPcm {
304            let start = c.aligned_byte_pos();
305            let data = c.data();
306            let mut r = BitReader::new(data);
307            r.set_pos(start * 8);
308            self.read_pcm(&mut r);
309            c.restart(r.byte_pos());
310            return Ok(());
311        }
312        let mut no_sub_lt8x8 = true;
313        let is_8x8 = (kind == MbKind::P && t >= 3) || (kind == MbKind::B && t == 22);
314        let b_direct16 = kind == MbKind::B && t == 0;
315        if b_direct16 {
316            self.pic.mbs[self.addr].b_direct16 = true;
317            self.pic.mbs[self.addr].direct8 = 0xF;
318        }
319        match kind {
320            MbKind::I4x4 => {
321                if self.pps.transform_8x8_mode && self.t8x8_flag(c) {
322                    self.syn.t8x8 = true;
323                    self.syn.kind = MbKind::I8x8;
324                }
325                let n = if self.syn.t8x8 { 4 } else { 16 };
326                for i in 0..n {
327                    self.syn.prev_flag[i] = self.bin(c, 68) == 1;
328                    if !self.syn.prev_flag[i] {
329                        let b0 = self.bin(c, 69);
330                        let b1 = self.bin(c, 69);
331                        let b2 = self.bin(c, 69);
332                        self.syn.rem[i] = (b0 | (b1 << 1) | (b2 << 2)) as u8;
333                    }
334                }
335                if self.chroma {
336                    self.syn.chroma_mode = self.chroma_mode_cabac(c);
337                }
338            }
339            MbKind::I16x16 => {
340                self.set_i16(t);
341                if self.chroma {
342                    self.syn.chroma_mode = self.chroma_mode_cabac(c);
343                }
344            }
345            _ if b_direct16 => {}
346            _ if is_8x8 => {
347                for s in 0..4 {
348                    self.syn.sub[s] = if kind == MbKind::B {
349                        self.sub_mb_type_b(c)
350                    } else {
351                        self.sub_mb_type_p(c)
352                    };
353                }
354                let subs: [(PredFlags, usize, usize); 4] = std::array::from_fn(|s| {
355                    if kind == MbKind::B {
356                        b_sub_layout(self.syn.sub[s])
357                    } else {
358                        p_sub_layout(self.syn.sub[s])
359                    }
360                });
361                let mut direct = 0u8;
362                for (s, &(pred, w, h)) in subs.iter().enumerate() {
363                    if pred == 0 {
364                        direct |= 1 << s;
365                        if !self.sps.direct_8x8_inference {
366                            no_sub_lt8x8 = false;
367                        }
368                    } else if w * h < 4 {
369                        no_sub_lt8x8 = false;
370                    }
371                }
372                self.pic.mbs[self.addr].direct8 = direct;
373                let ref0 = kind == MbKind::P && t == 4;
374                for l in 0..2 {
375                    for s in 0..4 {
376                        let (sx, sy) = ((s % 2) * 2, (s / 2) * 2);
377                        if subs[s].0 & (1 << l) != 0 {
378                            let r = if ref0 || self.num_ref(l) <= 1 {
379                                0
380                            } else {
381                                self.ref_idx_cabac(c, l, sx, sy)?
382                            };
383                            self.syn.ref_idx[l][s] = r;
384                            self.note_ref(l, sx, sy, 2, 2, r);
385                        }
386                    }
387                }
388                for l in 0..2 {
389                    for s in 0..4 {
390                        let (pred, w, h) = subs[s];
391                        if pred & (1 << l) == 0 {
392                            continue;
393                        }
394                        let (sx, sy) = ((s % 2) * 2, (s / 2) * 2);
395                        for py in (0..2).step_by(h) {
396                            for px in (0..2).step_by(w) {
397                                self.parse_mvd_pair(c, l, sx + px, sy + py, w, h)?;
398                            }
399                        }
400                    }
401                }
402            }
403            _ => {
404                let (shape, preds) = if kind == MbKind::B {
405                    b_mb_layout(t)
406                } else {
407                    p_mb_layout(t)
408                };
409                let parts = shape.parts();
410                for l in 0..2 {
411                    for (i, &(x, y, w, h)) in parts.iter().enumerate() {
412                        if preds[i] & (1 << l) != 0 {
413                            let r = if self.num_ref(l) <= 1 {
414                                0
415                            } else {
416                                self.ref_idx_cabac(c, l, x, y)?
417                            };
418                            self.syn.ref_idx[l][i] = r;
419                            self.note_ref(l, x, y, w, h, r);
420                        }
421                    }
422                }
423                for l in 0..2 {
424                    for (i, &(x, y, w, h)) in parts.iter().enumerate() {
425                        if preds[i] & (1 << l) != 0 {
426                            self.parse_mvd_pair(c, l, x, y, w, h)?;
427                        }
428                    }
429                }
430            }
431        }
432        if self.syn.kind != MbKind::I16x16 {
433            self.syn.cbp = self.cbp_cabac(c);
434            if self.syn.cbp & 15 != 0
435                && self.pps.transform_8x8_mode
436                && !self.syn.kind.is_intra()
437                && no_sub_lt8x8
438                && (!b_direct16 || self.sps.direct_8x8_inference)
439            {
440                self.syn.t8x8 = self.t8x8_flag(c);
441            }
442        }
443        // Visible to neighbours' cbf contexts from here on.
444        self.pic.mbs[self.addr].cbp = self.syn.cbp;
445        self.pic.mbs[self.addr].t8x8 = self.syn.t8x8;
446        self.pic.mbs[self.addr].kind = self.syn.kind;
447        if self.syn.cbp != 0 || self.syn.kind == MbKind::I16x16 {
448            self.syn.qp_delta = self.qp_delta_cabac(c)?;
449            self.residual_cabac(c)?;
450        }
451        Ok(())
452    }
453
454    fn t8x8_flag(&mut self, c: &mut Cabac) -> bool {
455        let cond = |s: &Self, dx, dy| s.mb_nb(dx, dy).map_or(0, |a| s.pic.mbs[a].t8x8 as usize);
456        let inc = cond(self, -1, 0) + cond(self, 0, -1);
457        self.bin(c, 399 + inc) == 1
458    }
459
460    fn chroma_mode_cabac(&mut self, c: &mut Cabac) -> u8 {
461        let cond = |s: &Self, dx, dy| {
462            s.mb_nb(dx, dy).map_or(0, |a| {
463                let m = &s.pic.mbs[a];
464                (m.kind.is_intra() && m.kind != MbKind::IPcm && m.chroma_mode != 0) as usize
465            })
466        };
467        let inc = cond(self, -1, 0) + cond(self, 0, -1);
468        if self.bin(c, 64 + inc) == 0 {
469            0
470        } else if self.bin(c, 64 + 3) == 0 {
471            1
472        } else if self.bin(c, 64 + 3) == 0 {
473            2
474        } else {
475            3
476        }
477    }
478
479    fn cbp_cabac(&mut self, c: &mut Cabac) -> u8 {
480        // The neighbouring 8×8 block's bit, located through its 4×4 block
481        // (which macroblock of an MBAFF pair, and which row, can differ per
482        // 8×8 row).
483        let nb8 = |s: &Self, x: isize, y: isize| {
484            s.blk_nb(x, y)
485                .map(|(a, k)| (s.pic.mbs[a].cbp >> ((k / 8) * 2 + (k % 4) / 2)) & 1)
486        };
487        let mut cbp = 0u8;
488        for b8 in 0..4usize {
489            // condTerm is 1 when the neighbouring 8×8 had no coefficients.
490            let a = if b8 % 2 == 1 {
491                (cbp >> (b8 - 1)) & 1 == 0
492            } else {
493                nb8(self, -1, 2 * (b8 / 2) as isize) == Some(0)
494            };
495            let b = if b8 >= 2 {
496                (cbp >> (b8 - 2)) & 1 == 0
497            } else {
498                nb8(self, 2 * (b8 % 2) as isize, -1) == Some(0)
499            };
500            let inc = a as usize + 2 * b as usize;
501            cbp |= (self.bin(c, 73 + inc) as u8) << b8;
502        }
503        if self.chroma {
504            let left = self.mb_nb(-1, 0).map(|a| self.pic.mbs[a].cbp);
505            let top = self.mb_nb(0, -1).map(|a| self.pic.mbs[a].cbp);
506            let ca = left.map_or(0, |l| l >> 4);
507            let cb = top.map_or(0, |t| t >> 4);
508            let inc = (ca > 0) as usize + 2 * (cb > 0) as usize;
509            if self.bin(c, 77 + inc) == 1 {
510                let inc = (ca == 2) as usize + 2 * (cb == 2) as usize;
511                let v = 1 + self.bin(c, 77 + 4 + inc) as u8;
512                cbp |= v << 4;
513            }
514        }
515        cbp
516    }
517
518    fn qp_delta_cabac(&mut self, c: &mut Cabac) -> Result<i32> {
519        let inc = self.prev_qp_nz as usize;
520        if self.bin(c, 60 + inc) == 0 {
521            return Ok(0);
522        }
523        let mut k = 1i32;
524        if self.bin(c, 60 + 2) == 1 {
525            k = 2;
526            while self.bin(c, 60 + 3) == 1 {
527                k += 1;
528                if k > 200 {
529                    return Err("mb_qp_delta too long".into());
530                }
531            }
532        }
533        Ok(if k & 1 == 1 { (k + 1) / 2 } else { -(k / 2) })
534    }
535
536    /// `coded_block_flag` context term from a neighbour: `None` when the
537    /// neighbouring macroblock is unavailable.
538    fn cbf_term(&self, v: Option<bool>) -> usize {
539        match v {
540            Some(b) => b as usize,
541            None => self.syn.kind.is_intra() as usize,
542        }
543    }
544
545    fn cbf_luma4(&self, x: isize, y: isize) -> Option<bool> {
546        let (a, k) = self.blk_nb(x, y)?;
547        Some(self.pic.mbs[a].nnz[k] != 0)
548    }
549
550    fn cbf_chroma_ac(&self, comp: usize, x: isize, y: isize) -> Option<bool> {
551        let (a, k) = self.cblk_nb(x, y)?;
552        Some(self.pic.mbs[a].nnz_c[comp][k] != 0)
553    }
554
555    fn cbf_dc(&self, bit: u8, dx: isize, dy: isize) -> Option<bool> {
556        let a = self.mb_nb(dx, dy)?;
557        Some(self.pic.mbs[a].cbf_dc & (1 << bit) != 0)
558    }
559
560    /// One `residual_block_cabac` (§7.3.5.3.3). `cbf_inc` is the
561    /// `coded_block_flag` increment, `None` for 8×8 blocks (no flag).
562    /// Levels land in `out` by list index; returns how many are non-zero.
563    fn block_cabac(
564        &mut self,
565        c: &mut Cabac,
566        cat: usize,
567        max: usize,
568        cbf_inc: Option<usize>,
569        out: &mut [i32],
570    ) -> Result<usize> {
571        if let Some(inc) = cbf_inc
572            && self.bin(c, 85 + CBF_OFF[cat] + inc) == 0
573        {
574            return Ok(0);
575        }
576        let field = self.field_coded();
577        let (sig_base, last_base, abs_base) = match (cat == 5, field) {
578            (true, false) => (402, 417, 426),
579            (true, true) => (436, 451, 426),
580            (false, false) => (105 + SIG_OFF[cat], 166 + SIG_OFF[cat], 227 + ABS_OFF[cat]),
581            (false, true) => (277 + SIG_OFF[cat], 338 + SIG_OFF[cat], 227 + ABS_OFF[cat]),
582        };
583        let sig8 = if field { &SIG8_FIELD } else { &SIG8 };
584        let mut sig = [0u8; 64];
585        let mut n = 0usize;
586        let mut last = max - 1;
587        for i in 0..max - 1 {
588            let (si, li) = match cat {
589                // Chroma DC: Min(numDecod / NumC8x8, 2), NumC8x8 = max / 4.
590                3 => ((i / (max / 4)).min(2), (i / (max / 4)).min(2)),
591                5 => (sig8[i] as usize, LAST8[i] as usize),
592                _ => (i, i),
593            };
594            if self.bin(c, sig_base + si) == 1 {
595                sig[n] = i as u8;
596                n += 1;
597                if self.bin(c, last_base + li) == 1 {
598                    last = i;
599                    break;
600                }
601            }
602        }
603        if last == max - 1 && (n == 0 || sig[n - 1] as usize != max - 1) {
604            sig[n] = (max - 1) as u8;
605            n += 1;
606        }
607        let mut gt1 = 0usize;
608        let mut eq1 = 0usize;
609        let gt1_cap = if cat == 3 { 3 } else { 4 };
610        for j in (0..n).rev() {
611            let inc0 = if gt1 != 0 { 0 } else { (1 + eq1).min(4) };
612            let mut v = 0i32;
613            if self.bin(c, abs_base + inc0) == 1 {
614                v = 1;
615                let inc = 5 + gt1.min(gt1_cap);
616                while v < 14 && self.bin(c, abs_base + inc) == 1 {
617                    v += 1;
618                }
619                if v == 14 {
620                    let mut k = 0;
621                    while c.bypass() == 1 {
622                        v += 1 << k;
623                        k += 1;
624                        if k > 24 {
625                            return Err("coeff_abs_level suffix too long".into());
626                        }
627                    }
628                    v += c.bypass_bits(k) as i32;
629                }
630            }
631            let abs = v + 1;
632            if abs == 1 {
633                eq1 += 1;
634            } else {
635                gt1 += 1;
636            }
637            out[sig[j] as usize] = if c.bypass() == 1 { -abs } else { abs };
638        }
639        Ok(n)
640    }
641
642    fn residual_cabac(&mut self, c: &mut Cabac) -> Result<()> {
643        let (z4, z8) = if self.field_coded() {
644            (&FIELD4, &FIELD8)
645        } else {
646            (&ZIGZAG4, &ZIGZAG8)
647        };
648        let cbp_l = self.syn.cbp & 15;
649        let cbp_c = self.syn.cbp >> 4;
650        let i16 = self.syn.kind == MbKind::I16x16;
651        let t8 = self.syn.t8x8;
652        let mut tmp = [0i32; 64];
653        if i16 {
654            let inc =
655                self.cbf_term(self.cbf_dc(0, -1, 0)) + 2 * self.cbf_term(self.cbf_dc(0, 0, -1));
656            tmp[..16].fill(0);
657            let n = self.block_cabac(c, 0, 16, Some(inc), &mut tmp)?;
658            for k in 0..16 {
659                self.syn.dc_luma[z4[k]] = tmp[k];
660            }
661            if n > 0 {
662                self.pic.mbs[self.addr].cbf_dc |= 1;
663            }
664        }
665        for b8 in 0..4 {
666            if cbp_l & (1 << b8) == 0 {
667                continue;
668            }
669            if t8 {
670                tmp.fill(0);
671                let n = self.block_cabac(c, 5, 64, None, &mut tmp)?;
672                for k in 0..64 {
673                    self.syn.coef8[b8][z8[k]] = tmp[k];
674                }
675                if n > 0 {
676                    self.syn.coded8 |= 1 << b8;
677                }
678                let (bx, by) = ((b8 % 2) * 2, (b8 / 2) * 2);
679                for d in [0, 1, 4, 5] {
680                    self.pic.mbs[self.addr].nnz[by * 4 + bx + d] = n as u8;
681                }
682                continue;
683            }
684            for b4 in 0..4 {
685                let blk = b8 * 4 + b4;
686                let (bx, by) = BLK_XY[blk];
687                let inc = self.cbf_term(self.cbf_luma4(bx as isize - 1, by as isize))
688                    + 2 * self.cbf_term(self.cbf_luma4(bx as isize, by as isize - 1));
689                tmp[..16].fill(0);
690                let n = if i16 {
691                    let n = self.block_cabac(c, 1, 15, Some(inc), &mut tmp)?;
692                    for k in 0..15 {
693                        self.syn.coef[blk][z4[k + 1]] = tmp[k];
694                    }
695                    n
696                } else {
697                    let n = self.block_cabac(c, 2, 16, Some(inc), &mut tmp)?;
698                    for k in 0..16 {
699                        self.syn.coef[blk][z4[k]] = tmp[k];
700                    }
701                    n
702                };
703                if n > 0 {
704                    self.syn.coded |= 1 << blk;
705                }
706                self.pic.mbs[self.addr].nnz[by * 4 + bx] = n as u8;
707            }
708        }
709        if self.chroma && cbp_c != 0 {
710            for comp in 0..2 {
711                let bit = 1 + comp as u8;
712                let inc = self.cbf_term(self.cbf_dc(bit, -1, 0))
713                    + 2 * self.cbf_term(self.cbf_dc(bit, 0, -1));
714                let nmax = if self.c422 { 8 } else { 4 };
715                tmp[..nmax].fill(0);
716                let n = self.block_cabac(c, 3, nmax, Some(inc), &mut tmp)?;
717                self.syn.dc_c[comp][..nmax].copy_from_slice(&tmp[..nmax]);
718                if n > 0 {
719                    self.pic.mbs[self.addr].cbf_dc |= 1 << bit;
720                }
721            }
722            if cbp_c & 2 != 0 {
723                for comp in 0..2 {
724                    for blk in 0..if self.c422 { 8 } else { 4 } {
725                        let (bx, by) = ((blk % 2) as isize, (blk / 2) as isize);
726                        let inc = self.cbf_term(self.cbf_chroma_ac(comp, bx - 1, by))
727                            + 2 * self.cbf_term(self.cbf_chroma_ac(comp, bx, by - 1));
728                        tmp[..16].fill(0);
729                        let n = self.block_cabac(c, 4, 15, Some(inc), &mut tmp)?;
730                        for k in 0..15 {
731                            self.syn.ac_c[comp][blk][z4[k + 1]] = tmp[k];
732                        }
733                        if n > 0 {
734                            self.syn.coded_c[comp] |= 1 << blk;
735                        }
736                        self.pic.mbs[self.addr].nnz_c[comp][blk] = n as u8;
737                    }
738                }
739            }
740        }
741        Ok(())
742    }
743}