Skip to main content

threers_codec/decode/vp9/
block.rs

1//! VP9 tile and block decoding (ffmpeg `vp9.c` decode_tiles/decode_sb and
2//! `vp9block.c`): mode info, coefficient tokens, and loop-filter masks.
3
4use super::data::*;
5use super::probs::{Counts, ProbContext};
6use super::rac::Rac;
7use super::*;
8
9/// `VP9Filter`: per-superblock loop-filter levels and edge masks.
10#[derive(Clone)]
11pub struct LfMask {
12    pub level: [u8; 64],
13    /// `[0 = y, 1 = uv][0 = col, 1 = row][8 rows][0=16, 1=8, 2=4, 3=inner4]`
14    pub mask: [[[[u8; 4]; 8]; 2]; 2],
15}
16
17/// `VP9Block`.
18#[derive(Clone, Copy, Default)]
19pub struct Block {
20    pub seg_id: u8,
21    pub intra: bool,
22    pub comp: bool,
23    pub r#ref: [u8; 2],
24    pub mode: [u8; 4],
25    pub uvmode: u8,
26    pub skip: bool,
27    pub filter: u8,
28    pub mv: [[Mv; 2]; 4],
29    pub bs: u8,
30    pub tx: u8,
31    pub uvtx: u8,
32    pub bl: u8,
33    pub bp: u8,
34}
35
36/// Everything decoding one frame's tiles needs (ffmpeg's `VP9Context` and
37/// `VP9TileData` for a single thread).
38pub struct FrameDec<'a> {
39    pub h: &'a Header,
40    pub p: &'a ProbContext,
41    pub coef: &'a CoefProbs,
42    pub counts: &'a mut Counts,
43    pub cur: &'a mut Frame,
44    pub refs: &'a [Option<Arc<Frame>>; 3],
45    pub segmap_ref: Option<&'a Frame>,
46    pub mvpair: Option<&'a Frame>,
47    pub mvscale: [[u16; 2]; 3],
48    pub mvstep: [[u8; 2]; 3],
49    pub cols: usize,
50    pub rows: usize,
51    pub sb_cols: usize,
52    pub sb_rows: usize,
53    pub ss_h: usize,
54    pub ss_v: usize,
55    pub bpp: u32,
56    // Above contexts.
57    pub above_partition_ctx: Vec<u8>,
58    pub above_mode_ctx: Vec<u8>,
59    pub above_y_nnz_ctx: Vec<u8>,
60    pub above_uv_nnz_ctx: [Vec<u8>; 2],
61    pub above_skip_ctx: Vec<u8>,
62    pub above_txfm_ctx: Vec<u8>,
63    pub above_segpred_ctx: Vec<u8>,
64    pub above_intra_ctx: Vec<u8>,
65    pub above_comp_ctx: Vec<u8>,
66    pub above_ref_ctx: Vec<u8>,
67    pub above_filter_ctx: Vec<u8>,
68    pub above_mv_ctx: Vec<[Mv; 2]>,
69    // Left contexts.
70    pub left_y_nnz_ctx: [u8; 16],
71    pub left_mode_ctx: [u8; 16],
72    pub left_mv_ctx: [[Mv; 2]; 16],
73    pub left_uv_nnz_ctx: [[u8; 16]; 2],
74    pub left_partition_ctx: [u8; 8],
75    pub left_skip_ctx: [u8; 8],
76    pub left_txfm_ctx: [u8; 8],
77    pub left_segpred_ctx: [u8; 8],
78    pub left_intra_ctx: [u8; 8],
79    pub left_comp_ctx: [u8; 8],
80    pub left_ref_ctx: [u8; 8],
81    pub left_filter_ctx: [u8; 8],
82    // Block state.
83    pub b: Block,
84    pub row: usize,
85    pub row7: usize,
86    pub col: usize,
87    pub col7: usize,
88    pub tile_col_start: usize,
89    pub min_mv: (i32, i32),
90    pub max_mv: (i32, i32),
91    pub block: Vec<i32>,
92    pub uvblock: [Vec<i32>; 2],
93    pub eob: Vec<u16>,
94    pub uveob: [Vec<u16>; 2],
95    /// Loop-filter masks, one per superblock (raster).
96    pub lflvl: Vec<LfMask>,
97    pub rac: Option<Rac<'a>>,
98}
99
100const LEFT_CTX: [u8; 13] = [
101    0x0, 0x8, 0x0, 0x8, 0xc, 0x8, 0xc, 0xe, 0xc, 0xe, 0xf, 0xe, 0xf,
102];
103const ABOVE_CTX: [u8; 13] = [
104    0x0, 0x0, 0x8, 0x8, 0x8, 0xc, 0xc, 0xc, 0xe, 0xe, 0xe, 0xf, 0xf,
105];
106const MAX_TX_FOR_BL_BP: [u8; 13] = [3, 3, 3, 3, 2, 2, 2, 1, 1, 1, 0, 0, 0];
107const INTER_MODE_CTX_LUT: [[u8; 14]; 14] = {
108    let mut t = [[6u8; 14]; 14];
109    let mut i = 0;
110    while i < 14 {
111        let mut j = 10;
112        while j < 14 {
113            t[i][j] = 5;
114            j += 1;
115        }
116        i += 1;
117    }
118    let mut j = 0;
119    while j < 10 {
120        t[10][j] = 5;
121        t[11][j] = 5;
122        t[12][j] = 5;
123        t[13][j] = 5;
124        j += 1;
125    }
126    t[10][10] = 2;
127    t[10][11] = 2;
128    t[10][12] = 1;
129    t[10][13] = 3;
130    t[11][10] = 2;
131    t[11][11] = 2;
132    t[11][12] = 1;
133    t[11][13] = 3;
134    t[12][10] = 1;
135    t[12][11] = 1;
136    t[12][12] = 0;
137    t[12][13] = 3;
138    t[13][10] = 3;
139    t[13][11] = 3;
140    t[13][12] = 3;
141    t[13][13] = 4;
142    t
143};
144
145/// `band_counts`.
146const BAND_COUNTS: [[usize; 6]; 4] = [
147    [1, 2, 3, 4, 3, 16 - 13],
148    [1, 2, 3, 4, 11, 64 - 21],
149    [1, 2, 3, 4, 11, 256 - 21],
150    [1, 2, 3, 4, 11, 1024 - 21],
151];
152
153/// `ff_vp9_scans` / `ff_vp9_scans_nb`: `[tx (4 = lossless)][txtp]`.
154pub fn scan(tx: usize, txtp: usize) -> (&'static [i16], &'static [[i16; 2]]) {
155    match (tx, txtp) {
156        (0, 1) => (&COL_SCAN_4X4, &COL_SCAN_4X4_NB),
157        (0, 2) => (&ROW_SCAN_4X4, &ROW_SCAN_4X4_NB),
158        (0, _) | (4, _) => (&DEFAULT_SCAN_4X4, &DEFAULT_SCAN_4X4_NB),
159        (1, 1) => (&COL_SCAN_8X8, &COL_SCAN_8X8_NB),
160        (1, 2) => (&ROW_SCAN_8X8, &ROW_SCAN_8X8_NB),
161        (1, _) => (&DEFAULT_SCAN_8X8, &DEFAULT_SCAN_8X8_NB),
162        (2, 1) => (&COL_SCAN_16X16, &COL_SCAN_16X16_NB),
163        (2, 2) => (&ROW_SCAN_16X16, &ROW_SCAN_16X16_NB),
164        (2, _) => (&DEFAULT_SCAN_16X16, &DEFAULT_SCAN_16X16_NB),
165        _ => (&DEFAULT_SCAN_32X32, &DEFAULT_SCAN_32X32_NB),
166    }
167}
168
169fn set_tile_offset(idx: u32, log2_n: u32, n: usize) -> (usize, usize) {
170    let sb_start = ((idx as usize) * n) >> log2_n;
171    let sb_end = ((idx as usize + 1) * n) >> log2_n;
172    (sb_start.min(n) << 3, sb_end.min(n) << 3)
173}
174
175#[inline]
176fn fill(a: &mut [u8], off: usize, n: usize, v: u8) {
177    a[off..off + n].fill(v);
178}
179
180impl<'a> FrameDec<'a> {
181    #[allow(clippy::too_many_arguments)]
182    pub fn new(
183        h: &'a Header,
184        p: &'a ProbContext,
185        coef: &'a CoefProbs,
186        counts: &'a mut Counts,
187        cur: &'a mut Frame,
188        refs: &'a [Option<Arc<Frame>>; 3],
189        segmap_ref: Option<&'a Frame>,
190        mvpair: Option<&'a Frame>,
191        mvscale: [[u16; 2]; 3],
192        mvstep: [[u8; 2]; 3],
193    ) -> Self {
194        let (w, hh) = (cur.width as usize, cur.height as usize);
195        let sb_cols = (w + 63) >> 6;
196        let sb_rows = (hh + 63) >> 6;
197        let n8 = sb_cols * 8;
198        let n16 = sb_cols * 16;
199        let kf = h.keyframe || h.intraonly;
200        FrameDec {
201            h,
202            p,
203            coef,
204            counts,
205            ss_h: cur.ss_h as usize,
206            ss_v: cur.ss_v as usize,
207            bpp: cur.bpp as u32,
208            cur,
209            refs,
210            segmap_ref,
211            mvpair,
212            mvscale,
213            mvstep,
214            cols: (w + 7) >> 3,
215            rows: (hh + 7) >> 3,
216            sb_cols,
217            sb_rows,
218            above_partition_ctx: vec![0; n8],
219            above_mode_ctx: vec![if kf { DC_PRED as u8 } else { NEARESTMV }; n16],
220            above_y_nnz_ctx: vec![0; n16],
221            above_uv_nnz_ctx: [vec![0; n16], vec![0; n16]],
222            above_skip_ctx: vec![0; n8],
223            above_txfm_ctx: vec![0; n8],
224            above_segpred_ctx: vec![0; n8],
225            above_intra_ctx: vec![0; n8],
226            above_comp_ctx: vec![0; n8],
227            above_ref_ctx: vec![0; n8],
228            above_filter_ctx: vec![0; n8],
229            above_mv_ctx: vec![[Mv::default(); 2]; n16],
230            left_y_nnz_ctx: [0; 16],
231            left_mode_ctx: [0; 16],
232            left_mv_ctx: [[Mv::default(); 2]; 16],
233            left_uv_nnz_ctx: [[0; 16]; 2],
234            left_partition_ctx: [0; 8],
235            left_skip_ctx: [0; 8],
236            left_txfm_ctx: [0; 8],
237            left_segpred_ctx: [0; 8],
238            left_intra_ctx: [0; 8],
239            left_comp_ctx: [0; 8],
240            left_ref_ctx: [0; 8],
241            left_filter_ctx: [0; 8],
242            b: Block::default(),
243            row: 0,
244            row7: 0,
245            col: 0,
246            col7: 0,
247            tile_col_start: 0,
248            min_mv: (0, 0),
249            max_mv: (0, 0),
250            block: vec![0; 64 * 64],
251            uvblock: [vec![0; 64 * 64], vec![0; 64 * 64]],
252            eob: vec![0; 256],
253            uveob: [vec![0; 256], vec![0; 256]],
254            lflvl: vec![
255                LfMask {
256                    level: [0; 64],
257                    mask: [[[[0; 4]; 8]; 2]; 2]
258                };
259                sb_cols * sb_rows
260            ],
261            rac: None,
262        }
263    }
264
265    #[inline]
266    pub fn c(&mut self) -> &mut Rac<'a> {
267        self.rac.as_mut().unwrap()
268    }
269
270    /// `decode_tiles`.
271    pub fn decode_tiles(&mut self, mut data: &'a [u8]) -> Result<(), String> {
272        let h = self.h;
273        let tile_cols = h.tile_cols as usize;
274        for tile_row in 0..h.tile_rows {
275            let (tile_row_start, tile_row_end) =
276                set_tile_offset(tile_row, h.log2_tile_rows, self.sb_rows);
277            let mut racs: Vec<Rac<'a>> = Vec::with_capacity(tile_cols);
278            for tile_col in 0..tile_cols {
279                let tile_size = if tile_col == tile_cols - 1 && tile_row == h.tile_rows - 1 {
280                    data.len()
281                } else {
282                    if data.len() < 4 {
283                        return Err("VP9: truncated tile size".into());
284                    }
285                    let s = u32::from_be_bytes([data[0], data[1], data[2], data[3]]) as usize;
286                    data = &data[4..];
287                    s
288                };
289                if tile_size > data.len() {
290                    return Err("VP9: tile size past the packet".into());
291                }
292                let mut rac = Rac::new(&data[..tile_size])?;
293                if rac.get_prob(128) {
294                    return Err("VP9: tile marker bit set".into());
295                }
296                racs.push(rac);
297                data = &data[tile_size..];
298            }
299            let mut row = tile_row_start;
300            while row < tile_row_end {
301                for tile_col in 0..tile_cols {
302                    let (tile_col_start, tile_col_end) =
303                        set_tile_offset(tile_col as u32, h.log2_tile_cols, self.sb_cols);
304                    self.tile_col_start = tile_col_start;
305                    self.left_partition_ctx = [0; 8];
306                    self.left_skip_ctx = [0; 8];
307                    if h.keyframe || h.intraonly {
308                        self.left_mode_ctx = [DC_PRED as u8; 16];
309                    } else {
310                        self.left_mode_ctx[..8].fill(NEARESTMV);
311                    }
312                    self.left_y_nnz_ctx = [0; 16];
313                    self.left_uv_nnz_ctx = [[0; 16]; 2];
314                    self.left_segpred_ctx = [0; 8];
315                    self.rac = Some(racs[tile_col].clone());
316                    let mut col = tile_col_start;
317                    while col < tile_col_end {
318                        let sb = (row >> 3) * self.sb_cols + (col >> 3);
319                        self.lflvl[sb].mask = [[[[0; 4]; 8]; 2]; 2];
320                        if self.c().is_end() {
321                            return Err("VP9: tile data overrun".into());
322                        }
323                        self.decode_sb(row, col, BL_64X64);
324                        col += 8;
325                    }
326                    racs[tile_col] = self.rac.take().unwrap();
327                }
328                row += 8;
329            }
330        }
331        Ok(())
332    }
333
334    fn decode_sb(&mut self, row: usize, col: usize, bl: u8) {
335        let c = ((self.above_partition_ctx[col] >> (3 - bl)) & 1) as usize
336            | ((((self.left_partition_ctx[row & 7] >> (3 - bl)) & 1) as usize) << 1);
337        let p = if self.h.keyframe || self.h.intraonly {
338            DEFAULT_KF_PARTITION_PROBS[bl as usize][c]
339        } else {
340            self.p.partition[bl as usize][c]
341        };
342        let hbs = 4usize >> bl;
343        let bp;
344        if bl == BL_8X8 {
345            bp = self.c().get_tree(&PARTITION_TREE, &p);
346            self.decode_block(row, col, bl, bp);
347        } else if col + hbs < self.cols {
348            if row + hbs < self.rows {
349                bp = self.c().get_tree(&PARTITION_TREE, &p);
350                match bp {
351                    PARTITION_NONE => self.decode_block(row, col, bl, bp),
352                    PARTITION_H => {
353                        self.decode_block(row, col, bl, bp);
354                        self.decode_block(row + hbs, col, bl, bp);
355                    }
356                    PARTITION_V => {
357                        self.decode_block(row, col, bl, bp);
358                        self.decode_block(row, col + hbs, bl, bp);
359                    }
360                    _ => {
361                        self.decode_sb(row, col, bl + 1);
362                        self.decode_sb(row, col + hbs, bl + 1);
363                        self.decode_sb(row + hbs, col, bl + 1);
364                        self.decode_sb(row + hbs, col + hbs, bl + 1);
365                    }
366                }
367            } else if self.c().get_prob(p[1]) {
368                bp = PARTITION_SPLIT;
369                self.decode_sb(row, col, bl + 1);
370                self.decode_sb(row, col + hbs, bl + 1);
371            } else {
372                bp = PARTITION_H;
373                self.decode_block(row, col, bl, bp);
374            }
375        } else if row + hbs < self.rows {
376            if self.c().get_prob(p[2]) {
377                bp = PARTITION_SPLIT;
378                self.decode_sb(row, col, bl + 1);
379                self.decode_sb(row + hbs, col, bl + 1);
380            } else {
381                bp = PARTITION_V;
382                self.decode_block(row, col, bl, bp);
383            }
384        } else {
385            bp = PARTITION_SPLIT;
386            self.decode_sb(row, col, bl + 1);
387        }
388        self.counts.partition[bl as usize][c][bp as usize] += 1;
389    }
390
391    /// `ff_vp9_decode_block`.
392    fn decode_block(&mut self, row: usize, col: usize, bl: u8, bp: u8) {
393        let bs = bl * 3 + bp;
394        let w4 = BWH_TAB[1][bs as usize][0] as usize;
395        let h4 = BWH_TAB[1][bs as usize][1] as usize;
396        self.row = row;
397        self.row7 = row & 7;
398        self.col = col;
399        self.col7 = col & 7;
400        self.min_mv = (-(128 + col as i32 * 64), -(128 + row as i32 * 64));
401        self.max_mv = (
402            128 + (self.cols as i32 - col as i32 - w4 as i32) * 64,
403            128 + (self.rows as i32 - row as i32 - h4 as i32) * 64,
404        );
405        self.b.bs = bs;
406        self.b.bl = bl;
407        self.b.bp = bp;
408        self.decode_mode();
409        let b = &mut self.b;
410        b.uvtx = b.tx
411            - (((self.ss_h != 0) && w4 * 2 == (1 << b.tx))
412                || ((self.ss_v != 0) && h4 * 2 == (1 << b.tx))) as u8;
413        if !self.b.skip {
414            let has_coeffs = self.decode_coeffs();
415            if !has_coeffs && self.b.bs <= BS_8X8 && !self.b.intra {
416                self.b.skip = true;
417                fill(&mut self.above_skip_ctx, col, w4, 1);
418                fill(&mut self.left_skip_ctx, self.row7, h4, 1);
419            }
420        } else {
421            let row7 = self.row7;
422            fill(&mut self.above_y_nnz_ctx, col * 2, w4 * 2, 0);
423            fill(&mut self.left_y_nnz_ctx, row7 * 2, h4 * 2, 0);
424            for pl in 0..2 {
425                if self.ss_h != 0 {
426                    fill(&mut self.above_uv_nnz_ctx[pl], col, w4, 0);
427                } else {
428                    fill(&mut self.above_uv_nnz_ctx[pl], col * 2, w4 * 2, 0);
429                }
430                if self.ss_v != 0 {
431                    fill(&mut self.left_uv_nnz_ctx[pl], row7, h4, 0);
432                } else {
433                    fill(&mut self.left_uv_nnz_ctx[pl], row7 * 2, h4 * 2, 0);
434                }
435            }
436        }
437        if self.b.intra {
438            self.intra_recon();
439        } else {
440            self.inter_recon();
441        }
442        // Loop-filter level and edges.
443        let b = self.b;
444        let lvl = self.h.segmentation.feat[b.seg_id as usize].lflvl
445            [if b.intra { 0 } else { b.r#ref[0] as usize + 1 }][(b.mode[3] != ZEROMV) as usize];
446        if self.h.filter_level != 0 && lvl > 0 {
447            let x_end = (self.cols - col).min(w4);
448            let y_end = (self.rows - row).min(h4);
449            let skip_inter = !b.intra && b.skip;
450            let (col7, row7) = (self.col7, self.row7);
451            let sb = (row >> 3) * self.sb_cols + (col >> 3);
452            let lf = &mut self.lflvl[sb];
453            for y in 0..h4 {
454                lf.level[(row7 + y) * 8 + col7..(row7 + y) * 8 + col7 + w4].fill(lvl);
455            }
456            mask_edges(
457                &mut lf.mask[0],
458                0,
459                0,
460                row7,
461                col7,
462                x_end,
463                y_end,
464                0,
465                0,
466                b.tx,
467                skip_inter,
468            );
469            if self.ss_h != 0 || self.ss_v != 0 {
470                let col_end = if self.cols & 1 != 0 && col + w4 >= self.cols {
471                    self.cols & 7
472                } else {
473                    0
474                };
475                let row_end = if self.rows & 1 != 0 && row + h4 >= self.rows {
476                    self.rows & 7
477                } else {
478                    0
479                };
480                mask_edges(
481                    &mut lf.mask[1],
482                    self.ss_h,
483                    self.ss_v,
484                    row7,
485                    col7,
486                    x_end,
487                    y_end,
488                    col_end,
489                    row_end,
490                    b.uvtx,
491                    skip_inter,
492                );
493            }
494        }
495    }
496
497    /// `decode_mode`.
498    fn decode_mode(&mut self) {
499        let h = self.h;
500        let (row, col, row7) = (self.row, self.col, self.row7);
501        let bs = self.b.bs as usize;
502        let max_tx = MAX_TX_FOR_BL_BP[bs];
503        let bw4 = BWH_TAB[1][bs][0] as usize;
504        let w4 = (self.cols - col).min(bw4);
505        let bh4 = BWH_TAB[1][bs][1] as usize;
506        let h4 = (self.rows - row).min(bh4);
507        let have_a = row > 0;
508        let have_l = col > self.tile_col_start;
509        let seg = &h.segmentation;
510        let kf = h.keyframe || h.intraonly;
511
512        // Segment id.
513        if !seg.enabled {
514            self.b.seg_id = 0;
515        } else if kf {
516            self.b.seg_id = if !seg.update_map {
517                0
518            } else {
519                self.c().get_tree(&SEGMENTATION_TREE, &seg.prob)
520            };
521        } else if !seg.update_map
522            || (seg.temporal && {
523                let c = (self.above_segpred_ctx[col] + self.left_segpred_ctx[row7]) as usize;
524                let pp = seg.pred_prob[c];
525                self.c().get_prob(pp)
526            })
527        {
528            if let (false, Some(rf)) = (h.errorres, self.segmap_ref) {
529                let mut pred = 8u8;
530                for y in 0..h4 {
531                    let base = (y + row) * 8 * self.sb_cols + col;
532                    for x in 0..w4 {
533                        pred = pred.min(rf.segmap[base + x]);
534                    }
535                }
536                self.b.seg_id = pred.min(7);
537            } else {
538                self.b.seg_id = 0;
539            }
540            fill(&mut self.above_segpred_ctx, col, w4, 1);
541            fill(&mut self.left_segpred_ctx, row7, h4, 1);
542        } else {
543            self.b.seg_id = self.c().get_tree(&SEGMENTATION_TREE, &seg.prob);
544            fill(&mut self.above_segpred_ctx, col, w4, 0);
545            fill(&mut self.left_segpred_ctx, row7, h4, 0);
546        }
547        if seg.enabled && (seg.update_map || kf) {
548            let stride = 8 * self.sb_cols;
549            for y in 0..bh4 {
550                let o = (row + y) * stride + col;
551                if o + bw4 <= self.cur.segmap.len() {
552                    self.cur.segmap[o..o + bw4].fill(self.b.seg_id);
553                }
554            }
555        }
556        let feat = seg.feat[self.b.seg_id as usize];
557
558        // Skip.
559        self.b.skip = seg.enabled && feat.skip_enabled;
560        if !self.b.skip {
561            let c = (self.left_skip_ctx[row7] + self.above_skip_ctx[col]) as usize;
562            let p = self.p.skip[c];
563            self.b.skip = self.c().get_prob(p);
564            self.counts.skip[c][self.b.skip as usize] += 1;
565        }
566
567        // Intra / inter.
568        if kf {
569            self.b.intra = true;
570        } else if seg.enabled && feat.ref_enabled {
571            self.b.intra = feat.ref_val == 0;
572        } else {
573            let c = if have_a && have_l {
574                let c = (self.above_intra_ctx[col] + self.left_intra_ctx[row7]) as usize;
575                c + (c == 2) as usize
576            } else if have_a {
577                2 * self.above_intra_ctx[col] as usize
578            } else if have_l {
579                2 * self.left_intra_ctx[row7] as usize
580            } else {
581                0
582            };
583            let p = self.p.intra[c];
584            let bit = self.c().get_prob(p);
585            self.counts.intra[c][bit as usize] += 1;
586            self.b.intra = !bit;
587        }
588
589        // Transform size.
590        if (self.b.intra || !self.b.skip) && h.txfmmode == TX_SWITCHABLE {
591            let c = if have_a {
592                if have_l {
593                    let a = if self.above_skip_ctx[col] != 0 {
594                        max_tx
595                    } else {
596                        self.above_txfm_ctx[col]
597                    };
598                    let l = if self.left_skip_ctx[row7] != 0 {
599                        max_tx
600                    } else {
601                        self.left_txfm_ctx[row7]
602                    };
603                    (a + l > max_tx) as usize
604                } else if self.above_skip_ctx[col] != 0 {
605                    1
606                } else {
607                    (self.above_txfm_ctx[col] * 2 > max_tx) as usize
608                }
609            } else if have_l {
610                if self.left_skip_ctx[row7] != 0 {
611                    1
612                } else {
613                    (self.left_txfm_ctx[row7] * 2 > max_tx) as usize
614                }
615            } else {
616                1
617            };
618            let p = *self.p;
619            self.b.tx = match max_tx {
620                TX_32X32 => {
621                    let mut t = self.c().get_prob(p.tx32p[c][0]) as u8;
622                    if t != 0 {
623                        t += self.c().get_prob(p.tx32p[c][1]) as u8;
624                        if t == 2 {
625                            t += self.c().get_prob(p.tx32p[c][2]) as u8;
626                        }
627                    }
628                    self.counts.tx32p[c][t as usize] += 1;
629                    t
630                }
631                TX_16X16 => {
632                    let mut t = self.c().get_prob(p.tx16p[c][0]) as u8;
633                    if t != 0 {
634                        t += self.c().get_prob(p.tx16p[c][1]) as u8;
635                    }
636                    self.counts.tx16p[c][t as usize] += 1;
637                    t
638                }
639                TX_8X8 => {
640                    let t = self.c().get_prob(p.tx8p[c]) as u8;
641                    self.counts.tx8p[c][t as usize] += 1;
642                    t
643                }
644                _ => TX_4X4,
645            };
646        } else {
647            self.b.tx = max_tx.min(h.txfmmode);
648        }
649
650        let mut vref = 0u8;
651        let mut filter_id = 0u8;
652        if kf {
653            self.kf_modes();
654        } else if self.b.intra {
655            self.b.comp = false;
656            let p = *self.p;
657            if bs > BS_8X8 as usize {
658                let m0 = self.c().get_tree(&INTRAMODE_TREE, &p.y_mode[0]);
659                self.b.mode[0] = m0;
660                self.counts.y_mode[0][m0 as usize] += 1;
661                if bs != BS_8X4 as usize {
662                    let m = self.c().get_tree(&INTRAMODE_TREE, &p.y_mode[0]);
663                    self.b.mode[1] = m;
664                    self.counts.y_mode[0][m as usize] += 1;
665                } else {
666                    self.b.mode[1] = m0;
667                }
668                if bs != BS_4X8 as usize {
669                    let m2 = self.c().get_tree(&INTRAMODE_TREE, &p.y_mode[0]);
670                    self.b.mode[2] = m2;
671                    self.counts.y_mode[0][m2 as usize] += 1;
672                    if bs != BS_8X4 as usize {
673                        let m = self.c().get_tree(&INTRAMODE_TREE, &p.y_mode[0]);
674                        self.b.mode[3] = m;
675                        self.counts.y_mode[0][m as usize] += 1;
676                    } else {
677                        self.b.mode[3] = m2;
678                    }
679                } else {
680                    self.b.mode[2] = self.b.mode[0];
681                    self.b.mode[3] = self.b.mode[1];
682                }
683            } else {
684                const SIZE_GROUP: [usize; 10] = [3, 3, 3, 3, 2, 2, 2, 1, 1, 1];
685                let sz = SIZE_GROUP[bs];
686                let m = self.c().get_tree(&INTRAMODE_TREE, &p.y_mode[sz]);
687                self.b.mode = [m; 4];
688                self.counts.y_mode[sz][m as usize] += 1;
689            }
690            let m3 = self.b.mode[3] as usize;
691            let uv = self.c().get_tree(&INTRAMODE_TREE, &p.uv_mode[m3]);
692            self.b.uvmode = uv;
693            self.counts.uv_mode[m3][uv as usize] += 1;
694        } else {
695            (vref, filter_id) = self.inter_modes(have_a, have_l);
696        }
697
698        // Contexts.
699        let b = self.b;
700        let kf = h.keyframe || h.intraonly;
701        let switchable = h.filtermode == FilterMode::Switchable;
702        let set = |dir_skip: &mut [u8],
703                   dir_txfm: &mut [u8],
704                   dir_part: &mut [u8],
705                   off: usize,
706                   n: usize,
707                   part: u8| {
708            dir_skip[off..off + n].fill(b.skip as u8);
709            dir_txfm[off..off + n].fill(b.tx);
710            dir_part[off..off + n].fill(part);
711        };
712        let wn = BWH_TAB[1][bs][0] as usize;
713        let hn = BWH_TAB[1][bs][1] as usize;
714        set(
715            &mut self.above_skip_ctx,
716            &mut self.above_txfm_ctx,
717            &mut self.above_partition_ctx,
718            col,
719            wn,
720            ABOVE_CTX[bs],
721        );
722        set(
723            &mut self.left_skip_ctx,
724            &mut self.left_txfm_ctx,
725            &mut self.left_partition_ctx,
726            row7,
727            hn,
728            LEFT_CTX[bs],
729        );
730        if !kf {
731            fill(&mut self.above_intra_ctx, col, wn, b.intra as u8);
732            fill(&mut self.above_comp_ctx, col, wn, b.comp as u8);
733            fill(&mut self.above_mode_ctx, col, wn, b.mode[3]);
734            fill(&mut self.left_intra_ctx, row7, hn, b.intra as u8);
735            fill(&mut self.left_comp_ctx, row7, hn, b.comp as u8);
736            fill(&mut self.left_mode_ctx, row7, hn, b.mode[3]);
737            if !b.intra {
738                fill(&mut self.above_ref_ctx, col, wn, vref);
739                fill(&mut self.left_ref_ctx, row7, hn, vref);
740                if switchable {
741                    fill(&mut self.above_filter_ctx, col, wn, filter_id);
742                    fill(&mut self.left_filter_ctx, row7, hn, filter_id);
743                }
744            }
745        }
746        if !kf {
747            if bs > BS_8X8 as usize {
748                self.left_mv_ctx[row7 * 2] = b.mv[1];
749                self.left_mv_ctx[row7 * 2 + 1] = b.mv[3];
750                self.above_mv_ctx[col * 2] = b.mv[2];
751                self.above_mv_ctx[col * 2 + 1] = b.mv[3];
752            } else {
753                for n in 0..w4 * 2 {
754                    self.above_mv_ctx[col * 2 + n] = b.mv[3];
755                }
756                for n in 0..h4 * 2 {
757                    self.left_mv_ctx[row7 * 2 + n] = b.mv[3];
758                }
759            }
760        }
761        // Motion for later MV prediction.
762        for y in 0..h4 {
763            let o = (row + y) * self.sb_cols * 8 + col;
764            for x in 0..w4 {
765                let m = &mut self.cur.mv[o + x];
766                if b.intra {
767                    m.r#ref = [-1, -1];
768                } else if b.comp {
769                    m.r#ref = [b.r#ref[0] as i8, b.r#ref[1] as i8];
770                    m.mv = b.mv[3];
771                } else {
772                    m.r#ref = [b.r#ref[0] as i8, -1];
773                    m.mv[0] = b.mv[3][0];
774                }
775            }
776        }
777    }
778
779    /// Keyframe / intra-only luma and chroma modes (default probabilities,
780    /// contexts from the above/left modes).
781    fn kf_modes(&mut self) {
782        let bs = self.b.bs;
783        let (ai, li) = (self.col * 2, self.row7 << 1);
784        self.b.comp = false;
785        let probs = |a: u8, l: u8| &DEFAULT_KF_YMODE_PROBS[a as usize][l as usize];
786        if bs > BS_8X8 {
787            let (a0, l0) = (self.above_mode_ctx[ai], self.left_mode_ctx[li]);
788            let m0 = self.c().get_tree(&INTRAMODE_TREE, probs(a0, l0));
789            self.b.mode[0] = m0;
790            self.above_mode_ctx[ai] = m0;
791            if bs != BS_8X4 {
792                let a1 = self.above_mode_ctx[ai + 1];
793                let m1 = self.c().get_tree(&INTRAMODE_TREE, probs(a1, m0));
794                self.b.mode[1] = m1;
795                self.left_mode_ctx[li] = m1;
796                self.above_mode_ctx[ai + 1] = m1;
797            } else {
798                self.b.mode[1] = m0;
799                self.left_mode_ctx[li] = m0;
800                self.above_mode_ctx[ai + 1] = m0;
801            }
802            if bs != BS_4X8 {
803                let (a0, l1) = (self.above_mode_ctx[ai], self.left_mode_ctx[li + 1]);
804                let m2 = self.c().get_tree(&INTRAMODE_TREE, probs(a0, l1));
805                self.b.mode[2] = m2;
806                self.above_mode_ctx[ai] = m2;
807                if bs != BS_8X4 {
808                    let a1 = self.above_mode_ctx[ai + 1];
809                    let m3 = self.c().get_tree(&INTRAMODE_TREE, probs(a1, m2));
810                    self.b.mode[3] = m3;
811                    self.left_mode_ctx[li + 1] = m3;
812                    self.above_mode_ctx[ai + 1] = m3;
813                } else {
814                    self.b.mode[3] = m2;
815                    self.left_mode_ctx[li + 1] = m2;
816                    self.above_mode_ctx[ai + 1] = m2;
817                }
818            } else {
819                self.b.mode[2] = self.b.mode[0];
820                self.b.mode[3] = self.b.mode[1];
821                self.left_mode_ctx[li + 1] = self.b.mode[1];
822                self.above_mode_ctx[ai + 1] = self.b.mode[1];
823            }
824        } else {
825            let (a, l) = (self.above_mode_ctx[ai], self.left_mode_ctx[li]);
826            let m = self.c().get_tree(&INTRAMODE_TREE, probs(a, l));
827            self.b.mode = [m; 4];
828            let wn = BWH_TAB[0][bs as usize][0] as usize;
829            let hn = BWH_TAB[0][bs as usize][1] as usize;
830            self.above_mode_ctx[ai..ai + wn].fill(m);
831            self.left_mode_ctx[li..li + hn].fill(m);
832        }
833        let m3 = self.b.mode[3] as usize;
834        self.b.uvmode = self
835            .c()
836            .get_tree(&INTRAMODE_TREE, &DEFAULT_KF_UVMODE_PROBS[m3]);
837    }
838
839    /// Inter block: comp flag, references, modes, filter and motion
840    /// vectors. Returns `(vref, filter_id)` for the contexts.
841    fn inter_modes(&mut self, have_a: bool, have_l: bool) -> (u8, u8) {
842        let h = self.h;
843        let (col, row7) = (self.col, self.row7);
844        let bs = self.b.bs;
845        let feat = h.segmentation.feat[self.b.seg_id as usize];
846        let p = *self.p;
847        let (ai, li) = (self.above_intra_ctx[col], self.left_intra_ctx[row7]);
848        let (ac, lc) = (self.above_comp_ctx[col], self.left_comp_ctx[row7]);
849        let (ar, lr) = (self.above_ref_ctx[col], self.left_ref_ctx[row7]);
850        let fix = h.fixcompref;
851        let var = h.varcompref;
852        if h.segmentation.enabled && feat.ref_enabled {
853            self.b.comp = false;
854            self.b.r#ref[0] = feat.ref_val - 1;
855        } else {
856            if h.comppredmode != CompPred::Switchable {
857                self.b.comp = h.comppredmode == CompPred::Comp;
858            } else {
859                let c = if have_a {
860                    if have_l {
861                        if ac != 0 && lc != 0 {
862                            4
863                        } else if ac != 0 {
864                            2 + (li != 0 || lr == fix) as usize
865                        } else if lc != 0 {
866                            2 + (ai != 0 || ar == fix) as usize
867                        } else {
868                            ((ai == 0 && ar == fix) ^ (li == 0 && lr == fix)) as usize
869                        }
870                    } else if ac != 0 {
871                        3
872                    } else {
873                        (ai == 0 && ar == fix) as usize
874                    }
875                } else if have_l {
876                    if lc != 0 {
877                        3
878                    } else {
879                        (li == 0 && lr == fix) as usize
880                    }
881                } else {
882                    1
883                };
884                let bit = self.c().get_prob(p.comp[c]);
885                self.b.comp = bit;
886                self.counts.comp[c][bit as usize] += 1;
887            }
888            if self.b.comp {
889                let fix_idx = h.signbias[fix as usize] as usize;
890                let var_idx = 1 - fix_idx;
891                self.b.r#ref[fix_idx] = fix;
892                let c = if have_a {
893                    if have_l {
894                        if ai != 0 {
895                            if li != 0 {
896                                2
897                            } else {
898                                1 + 2 * (lr != var[1]) as usize
899                            }
900                        } else if li != 0 {
901                            1 + 2 * (ar != var[1]) as usize
902                        } else {
903                            let (refl, refa) = (lr, ar);
904                            if refl == refa && refa == var[1] {
905                                0
906                            } else if lc == 0 && ac == 0 {
907                                if (refa == fix && refl == var[0])
908                                    || (refl == fix && refa == var[0])
909                                {
910                                    4
911                                } else if refa == refl {
912                                    3
913                                } else {
914                                    1
915                                }
916                            } else if lc == 0 {
917                                if refa == var[1] && refl != var[1] {
918                                    1
919                                } else if refl == var[1] && refa != var[1] {
920                                    2
921                                } else {
922                                    4
923                                }
924                            } else if ac == 0 {
925                                if refl == var[1] && refa != var[1] {
926                                    1
927                                } else if refa == var[1] && refl != var[1] {
928                                    2
929                                } else {
930                                    4
931                                }
932                            } else if refl == refa {
933                                4
934                            } else {
935                                2
936                            }
937                        }
938                    } else if ai != 0 {
939                        2
940                    } else if ac != 0 {
941                        4 * (ar != var[1]) as usize
942                    } else {
943                        3 * (ar != var[1]) as usize
944                    }
945                } else if have_l {
946                    if li != 0 {
947                        2
948                    } else if lc != 0 {
949                        4 * (lr != var[1]) as usize
950                    } else {
951                        3 * (lr != var[1]) as usize
952                    }
953                } else {
954                    2
955                };
956                let bit = self.c().get_prob(p.comp_ref[c]);
957                self.b.r#ref[var_idx] = var[bit as usize];
958                self.counts.comp_ref[c][bit as usize] += 1;
959            } else {
960                let c = if have_a && ai == 0 {
961                    if have_l && li == 0 {
962                        if lc != 0 {
963                            if ac != 0 {
964                                1 + (fix == 0 || lr == 0 || ar == 0) as usize
965                            } else {
966                                3 * (ar == 0) as usize + (fix == 0 || lr == 0) as usize
967                            }
968                        } else if ac != 0 {
969                            3 * (lr == 0) as usize + (fix == 0 || ar == 0) as usize
970                        } else {
971                            2 * (lr == 0) as usize + 2 * (ar == 0) as usize
972                        }
973                    } else if ai != 0 {
974                        2
975                    } else if ac != 0 {
976                        1 + (fix == 0 || ar == 0) as usize
977                    } else {
978                        4 * (ar == 0) as usize
979                    }
980                } else if have_l && li == 0 {
981                    if lc != 0 {
982                        1 + (fix == 0 || lr == 0) as usize
983                    } else {
984                        4 * (lr == 0) as usize
985                    }
986                } else {
987                    2
988                };
989                let bit = self.c().get_prob(p.single_ref[c][0]);
990                self.counts.single_ref[c][0][bit as usize] += 1;
991                if !bit {
992                    self.b.r#ref[0] = 0;
993                } else {
994                    let c = if have_a {
995                        if have_l {
996                            if li != 0 {
997                                if ai != 0 {
998                                    2
999                                } else if ac != 0 {
1000                                    1 + 2 * (fix == 1 || ar == 1) as usize
1001                                } else if ar == 0 {
1002                                    3
1003                                } else {
1004                                    4 * (ar == 1) as usize
1005                                }
1006                            } else if ai != 0 {
1007                                if li != 0 {
1008                                    2
1009                                } else if lc != 0 {
1010                                    1 + 2 * (fix == 1 || lr == 1) as usize
1011                                } else if lr == 0 {
1012                                    3
1013                                } else {
1014                                    4 * (lr == 1) as usize
1015                                }
1016                            } else if ac != 0 {
1017                                if lc != 0 {
1018                                    if lr == ar {
1019                                        3 * (fix == 1 || lr == 1) as usize
1020                                    } else {
1021                                        2
1022                                    }
1023                                } else if lr == 0 {
1024                                    1 + 2 * (fix == 1 || ar == 1) as usize
1025                                } else {
1026                                    3 * (lr == 1) as usize + (fix == 1 || ar == 1) as usize
1027                                }
1028                            } else if lc != 0 {
1029                                if ar == 0 {
1030                                    1 + 2 * (fix == 1 || lr == 1) as usize
1031                                } else {
1032                                    3 * (ar == 1) as usize + (fix == 1 || lr == 1) as usize
1033                                }
1034                            } else if ar == 0 {
1035                                if lr == 0 {
1036                                    3
1037                                } else {
1038                                    4 * (lr == 1) as usize
1039                                }
1040                            } else if lr == 0 {
1041                                4 * (ar == 1) as usize
1042                            } else {
1043                                2 * (lr == 1) as usize + 2 * (ar == 1) as usize
1044                            }
1045                        } else if ai != 0 || (ac == 0 && ar == 0) {
1046                            2
1047                        } else if ac != 0 {
1048                            3 * (fix == 1 || ar == 1) as usize
1049                        } else {
1050                            4 * (ar == 1) as usize
1051                        }
1052                    } else if have_l {
1053                        if li != 0 || (lc == 0 && lr == 0) {
1054                            2
1055                        } else if lc != 0 {
1056                            3 * (fix == 1 || lr == 1) as usize
1057                        } else {
1058                            4 * (lr == 1) as usize
1059                        }
1060                    } else {
1061                        2
1062                    };
1063                    let bit = self.c().get_prob(p.single_ref[c][1]);
1064                    self.counts.single_ref[c][1][bit as usize] += 1;
1065                    self.b.r#ref[0] = 1 + bit as u8;
1066                }
1067            }
1068        }
1069
1070        if bs <= BS_8X8 {
1071            if h.segmentation.enabled && feat.skip_enabled {
1072                self.b.mode = [ZEROMV; 4];
1073            } else {
1074                const OFF: [usize; 10] = [3, 0, 0, 1, 0, 0, 0, 0, 0, 0];
1075                let o = OFF[bs as usize];
1076                let c = INTER_MODE_CTX_LUT[self.above_mode_ctx[col + o] as usize]
1077                    [self.left_mode_ctx[row7 + o] as usize] as usize;
1078                let m = self.c().get_tree(&INTER_MODE_TREE, &p.mv_mode[c]);
1079                self.b.mode = [m; 4];
1080                self.counts.mv_mode[c][(m - 10) as usize] += 1;
1081            }
1082        }
1083
1084        let filter_id;
1085        if h.filtermode == FilterMode::Switchable {
1086            let c = if have_a && self.above_mode_ctx[col] >= NEARESTMV {
1087                if have_l && self.left_mode_ctx[row7] >= NEARESTMV {
1088                    if self.above_filter_ctx[col] == self.left_filter_ctx[row7] {
1089                        self.left_filter_ctx[row7] as usize
1090                    } else {
1091                        3
1092                    }
1093                } else {
1094                    self.above_filter_ctx[col] as usize
1095                }
1096            } else if have_l && self.left_mode_ctx[row7] >= NEARESTMV {
1097                self.left_filter_ctx[row7] as usize
1098            } else {
1099                3
1100            };
1101            filter_id = self.c().get_tree(&FILTER_TREE, &p.filter[c]);
1102            self.counts.filter[c][filter_id as usize] += 1;
1103            self.b.filter = FILTER_LUT[filter_id as usize];
1104        } else {
1105            filter_id = 0;
1106            self.b.filter = h.filtermode as u8;
1107        }
1108
1109        if bs > BS_8X8 {
1110            let c = INTER_MODE_CTX_LUT[self.above_mode_ctx[col] as usize]
1111                [self.left_mode_ctx[row7] as usize] as usize;
1112            let m0 = self.c().get_tree(&INTER_MODE_TREE, &p.mv_mode[c]);
1113            self.b.mode[0] = m0;
1114            self.counts.mv_mode[c][(m0 - 10) as usize] += 1;
1115            self.fill_mv(0, m0, 0);
1116            if bs != BS_8X4 {
1117                let m1 = self.c().get_tree(&INTER_MODE_TREE, &p.mv_mode[c]);
1118                self.b.mode[1] = m1;
1119                self.counts.mv_mode[c][(m1 - 10) as usize] += 1;
1120                self.fill_mv(1, m1, 1);
1121            } else {
1122                self.b.mode[1] = m0;
1123                self.b.mv[1] = self.b.mv[0];
1124            }
1125            if bs != BS_4X8 {
1126                let m2 = self.c().get_tree(&INTER_MODE_TREE, &p.mv_mode[c]);
1127                self.b.mode[2] = m2;
1128                self.counts.mv_mode[c][(m2 - 10) as usize] += 1;
1129                self.fill_mv(2, m2, 2);
1130                if bs != BS_8X4 {
1131                    let m3 = self.c().get_tree(&INTER_MODE_TREE, &p.mv_mode[c]);
1132                    self.b.mode[3] = m3;
1133                    self.counts.mv_mode[c][(m3 - 10) as usize] += 1;
1134                    self.fill_mv(3, m3, 3);
1135                } else {
1136                    self.b.mode[3] = m2;
1137                    self.b.mv[3] = self.b.mv[2];
1138                }
1139            } else {
1140                self.b.mode[2] = self.b.mode[0];
1141                self.b.mv[2] = self.b.mv[0];
1142                self.b.mode[3] = self.b.mode[1];
1143                self.b.mv[3] = self.b.mv[1];
1144            }
1145        } else {
1146            let m = self.b.mode[0];
1147            self.fill_mv(0, m, -1);
1148            let mv = self.b.mv[0];
1149            self.b.mv = [mv; 4];
1150        }
1151        let vref = self.b.r#ref[if self.b.comp {
1152            h.signbias[h.varcompref[0] as usize] as usize
1153        } else {
1154            0
1155        }];
1156        (vref, filter_id)
1157    }
1158
1159    /// `decode_coeffs`: returns whether any block has coefficients.
1160    fn decode_coeffs(&mut self) -> bool {
1161        let h = self.h;
1162        let b = self.b;
1163        let (row, col) = (self.row, self.col);
1164        let bs = b.bs as usize;
1165        let mut w4 = (BWH_TAB[1][bs][0] as usize) << 1;
1166        let mut h4 = (BWH_TAB[1][bs][1] as usize) << 1;
1167        let mut end_x = (2 * (self.cols - col)).min(w4);
1168        let mut end_y = (2 * (self.rows - row)).min(h4);
1169        let qmul = h.segmentation.feat[b.seg_id as usize].qmul;
1170        let tx = 4 * h.lossless as usize + b.tx as usize;
1171        let inter = !b.intra as usize;
1172        let mut total = false;
1173        let eight = self.bpp == 8;
1174        let bpp = self.bpp;
1175
1176        // Y.
1177        let step = 1usize << b.tx;
1178        let (a_off, l_off) = (col * 2, (row & 7) << 1);
1179        if step > 1 {
1180            merge(&mut self.left_y_nnz_ctx[l_off..], end_y, step);
1181            merge(&mut self.above_y_nnz_ctx[a_off..], end_x, step);
1182        }
1183        let mut n = 0usize;
1184        let mut y = 0;
1185        while y < end_y {
1186            let mut x = 0;
1187            while x < end_x {
1188                let mode = b.mode[if b.tx == TX_4X4 && b.bs > BS_8X8 {
1189                    n
1190                } else {
1191                    0
1192                }] as usize;
1193                let txtp = INTRA_TXFM_TYPE[mode] as usize;
1194                let (sc, nb) = scan(tx, txtp);
1195                let nnz =
1196                    (self.above_y_nnz_ctx[a_off + x] + self.left_y_nnz_ctx[l_off + y]) as usize;
1197                let rac = self.rac.as_mut().unwrap();
1198                let ret = decode_coeffs_b(
1199                    rac,
1200                    &mut self.block[16 * n..16 * n + 16 * step * step],
1201                    16 * step * step,
1202                    b.tx == TX_32X32,
1203                    eight,
1204                    bpp,
1205                    &mut self.counts.coef[b.tx as usize][0][inter],
1206                    &mut self.counts.eob[b.tx as usize][0][inter],
1207                    &self.coef[b.tx as usize][0][inter],
1208                    nnz,
1209                    sc,
1210                    nb,
1211                    &BAND_COUNTS[b.tx as usize],
1212                    &qmul[0],
1213                );
1214                let nz = (ret != 0) as u8;
1215                self.above_y_nnz_ctx[a_off + x] = nz;
1216                self.left_y_nnz_ctx[l_off + y] = nz;
1217                total |= ret != 0;
1218                self.eob[n] = ret as u16;
1219                x += step;
1220                n += step * step;
1221            }
1222            y += step;
1223        }
1224        if step > 1 {
1225            splat(&mut self.above_y_nnz_ctx[a_off..], end_x, step, end_x == w4);
1226            splat(&mut self.left_y_nnz_ctx[l_off..], end_y, step, end_y == h4);
1227        }
1228
1229        // U/V.
1230        let uvstep = 1usize << b.uvtx;
1231        w4 >>= self.ss_h;
1232        end_x >>= self.ss_h;
1233        h4 >>= self.ss_v;
1234        end_y >>= self.ss_v;
1235        let (sc, nb) = scan(b.uvtx as usize, DCT_DCT);
1236        for pl in 0..2 {
1237            let a_off = col << (1 - self.ss_h);
1238            let l_off = (row & 7) << (1 - self.ss_v);
1239            if uvstep > 1 {
1240                merge(&mut self.left_uv_nnz_ctx[pl][l_off..], end_y, uvstep);
1241                merge(&mut self.above_uv_nnz_ctx[pl][a_off..], end_x, uvstep);
1242            }
1243            let mut n = 0usize;
1244            let mut y = 0;
1245            while y < end_y {
1246                let mut x = 0;
1247                while x < end_x {
1248                    let nnz = (self.above_uv_nnz_ctx[pl][a_off + x]
1249                        + self.left_uv_nnz_ctx[pl][l_off + y])
1250                        as usize;
1251                    let rac = self.rac.as_mut().unwrap();
1252                    let ret = decode_coeffs_b(
1253                        rac,
1254                        &mut self.uvblock[pl][16 * n..16 * n + 16 * uvstep * uvstep],
1255                        16 * uvstep * uvstep,
1256                        b.uvtx == TX_32X32,
1257                        eight,
1258                        bpp,
1259                        &mut self.counts.coef[b.uvtx as usize][1][inter],
1260                        &mut self.counts.eob[b.uvtx as usize][1][inter],
1261                        &self.coef[b.uvtx as usize][1][inter],
1262                        nnz,
1263                        sc,
1264                        nb,
1265                        &BAND_COUNTS[b.uvtx as usize],
1266                        &qmul[1],
1267                    );
1268                    let nz = (ret != 0) as u8;
1269                    self.above_uv_nnz_ctx[pl][a_off + x] = nz;
1270                    self.left_uv_nnz_ctx[pl][l_off + y] = nz;
1271                    total |= ret != 0;
1272                    self.uveob[pl][n] = ret as u16;
1273                    x += uvstep;
1274                    n += uvstep * uvstep;
1275                }
1276                y += uvstep;
1277            }
1278            if uvstep > 1 {
1279                splat(
1280                    &mut self.above_uv_nnz_ctx[pl][a_off..],
1281                    end_x,
1282                    uvstep,
1283                    end_x == w4,
1284                );
1285                splat(
1286                    &mut self.left_uv_nnz_ctx[pl][l_off..],
1287                    end_y,
1288                    uvstep,
1289                    end_y == h4,
1290                );
1291            }
1292        }
1293        total
1294    }
1295}
1296
1297/// `MERGE`: an n-entry context run counts as non-zero if any entry is.
1298fn merge(la: &mut [u8], end: usize, step: usize) {
1299    let mut n = 0;
1300    while n < end {
1301        let any = la[n..n + step].iter().any(|&v| v != 0);
1302        la[n] = any as u8;
1303        n += step;
1304    }
1305}
1306
1307/// `SPLAT`: spread each transform's context over its entries, only up to
1308/// the frame edge unless the block is whole.
1309fn splat(la: &mut [u8], end: usize, step: usize, whole: bool) {
1310    if step == 2 {
1311        // `for (n = 1; n < end; n += step) la[n] = la[n - 1]`: stops at the
1312        // frame edge even inside a transform.
1313        let mut n = 1;
1314        while n < end {
1315            la[n] = la[n - 1];
1316            n += 2;
1317        }
1318        return;
1319    }
1320    let mut n = 0;
1321    while n < end {
1322        let v = la[n];
1323        if whole {
1324            la[n + 1..n + step].fill(v);
1325        } else {
1326            let k = (end - n - 1).min(step - 1);
1327            la[n + 1..n + 1 + k].fill(v);
1328        }
1329        n += step;
1330    }
1331}
1332
1333/// `decode_coeffs_b_generic`. Coefficients land in `coef` at raster
1334/// positions; 8-bit streams keep them as `int16_t` (wrapping), as ffmpeg.
1335#[allow(clippy::too_many_arguments)]
1336fn decode_coeffs_b(
1337    c: &mut Rac,
1338    coef: &mut [i32],
1339    n_coeffs: usize,
1340    is_tx32x32: bool,
1341    eight: bool,
1342    bpp: u32,
1343    cnt: &mut [[[u32; 3]; 6]; 6],
1344    eob: &mut [[[u32; 2]; 6]; 6],
1345    p: &[[[u8; 11]; 6]; 6],
1346    mut nnz: usize,
1347    scan: &[i16],
1348    nb: &[[i16; 2]],
1349    band_counts: &[usize; 6],
1350    qmul: &[i16; 2],
1351) -> usize {
1352    let mut i = 0usize;
1353    let mut band = 0usize;
1354    let mut band_left = band_counts[band];
1355    let mut tp = &p[0][nnz];
1356    let mut cache = [0u8; 1024];
1357    'outer: loop {
1358        let val = c.get_prob(tp[0]);
1359        eob[band][nnz][val as usize] += 1;
1360        if !val {
1361            break;
1362        }
1363        // skip_eob:
1364        loop {
1365            if !c.get_prob(tp[1]) {
1366                cnt[band][nnz][0] += 1;
1367                band_left -= 1;
1368                if band_left == 0 {
1369                    band += 1;
1370                    band_left = band_counts[band.min(5)];
1371                }
1372                cache[scan[i] as usize] = 0;
1373                nnz = (1 + cache[nb[i][0] as usize] as usize + cache[nb[i][1] as usize] as usize)
1374                    >> 1;
1375                tp = &p[band.min(5)][nnz];
1376                i += 1;
1377                if i == n_coeffs {
1378                    break 'outer;
1379                }
1380                continue;
1381            }
1382            break;
1383        }
1384        let rc = scan[i] as usize;
1385        let val: i32;
1386        if !c.get_prob(tp[2]) {
1387            cnt[band][nnz][1] += 1;
1388            val = 1;
1389            cache[rc] = 1;
1390        } else {
1391            cnt[band][nnz][2] += 1;
1392            if !c.get_prob(tp[3]) {
1393                if !c.get_prob(tp[4]) {
1394                    cache[rc] = 2;
1395                    val = 2;
1396                } else {
1397                    val = 3 + c.get_prob(tp[5]) as i32;
1398                    cache[rc] = 3;
1399                }
1400            } else if !c.get_prob(tp[6]) {
1401                cache[rc] = 4;
1402                if !c.get_prob(tp[7]) {
1403                    val = c.get_prob(159) as i32 + 5;
1404                } else {
1405                    let mut v = ((c.get_prob(165) as i32) << 1) + 7;
1406                    v += c.get_prob(145) as i32;
1407                    val = v;
1408                }
1409            } else {
1410                cache[rc] = 5;
1411                if !c.get_prob(tp[8]) {
1412                    if !c.get_prob(tp[9]) {
1413                        let mut v = 11 + ((c.get_prob(173) as i32) << 2);
1414                        v += (c.get_prob(148) as i32) << 1;
1415                        v += c.get_prob(140) as i32;
1416                        val = v;
1417                    } else {
1418                        let mut v = 19 + ((c.get_prob(176) as i32) << 3);
1419                        v += (c.get_prob(155) as i32) << 2;
1420                        v += (c.get_prob(140) as i32) << 1;
1421                        v += c.get_prob(135) as i32;
1422                        val = v;
1423                    }
1424                } else if !c.get_prob(tp[10]) {
1425                    let mut v = ((c.get_prob(180) as i32) << 4) + 35;
1426                    v += (c.get_prob(157) as i32) << 3;
1427                    v += (c.get_prob(141) as i32) << 2;
1428                    v += (c.get_prob(134) as i32) << 1;
1429                    v += c.get_prob(130) as i32;
1430                    val = v;
1431                } else {
1432                    let mut v = 67i32;
1433                    if !eight {
1434                        if bpp == 12 {
1435                            v += (c.get_prob(255) as i32) << 17;
1436                            v += (c.get_prob(255) as i32) << 16;
1437                        }
1438                        v += (c.get_prob(255) as i32) << 15;
1439                        v += (c.get_prob(255) as i32) << 14;
1440                    }
1441                    for (shift, pr) in [
1442                        (13, 254),
1443                        (12, 254),
1444                        (11, 254),
1445                        (10, 252),
1446                        (9, 249),
1447                        (8, 243),
1448                        (7, 230),
1449                        (6, 196),
1450                        (5, 177),
1451                        (4, 153),
1452                        (3, 140),
1453                        (2, 133),
1454                        (1, 130),
1455                        (0, 129),
1456                    ] {
1457                        v += (c.get_prob(pr) as i32) << shift;
1458                    }
1459                    val = v;
1460                }
1461            }
1462        }
1463        band_left -= 1;
1464        if band_left == 0 {
1465            band += 1;
1466            band_left = band_counts[band.min(5)];
1467        }
1468        let q = qmul[(i != 0) as usize] as u32;
1469        let s = if c.get() { -val } else { val };
1470        let prod = (s as u32).wrapping_mul(q);
1471        let v = if is_tx32x32 {
1472            (prod as i32) / 2
1473        } else {
1474            prod as i32
1475        };
1476        coef[rc] = if eight { v as i16 as i32 } else { v };
1477        nnz = (1 + cache[nb[i][0] as usize] as usize + cache[nb[i][1] as usize] as usize) >> 1;
1478        tp = &p[band.min(5)][nnz];
1479        i += 1;
1480        if i >= n_coeffs {
1481            break;
1482        }
1483    }
1484    i
1485}
1486
1487/// `mask_edges`.
1488#[allow(clippy::too_many_arguments)]
1489fn mask_edges(
1490    mask: &mut [[[u8; 4]; 8]; 2],
1491    ss_h: usize,
1492    ss_v: usize,
1493    row_and_7: usize,
1494    col_and_7: usize,
1495    mut w: usize,
1496    mut h: usize,
1497    col_end: usize,
1498    row_end: usize,
1499    tx: u8,
1500    skip_inter: bool,
1501) {
1502    const WIDE_FILTER_COL_MASK: [u32; 2] = [0x11, 0x01];
1503    const WIDE_FILTER_ROW_MASK: [usize; 2] = [0x03, 0x07];
1504    if tx == TX_4X4 && (ss_v | ss_h) != 0 {
1505        if h == ss_v {
1506            if row_and_7 & 1 != 0 {
1507                return;
1508            }
1509            if row_end == 0 {
1510                h += 1;
1511            }
1512        }
1513        if w == ss_h {
1514            if col_and_7 & 1 != 0 {
1515                return;
1516            }
1517            if col_end == 0 {
1518                w += 1;
1519            }
1520        }
1521    }
1522    let t = 1u32 << col_and_7;
1523    let m_col = (t << w) - t;
1524    if tx == TX_4X4 && !skip_inter {
1525        let m_row_8 = m_col & WIDE_FILTER_COL_MASK[ss_h];
1526        let m_row_4 = m_col - m_row_8;
1527        for y in row_and_7..h + row_and_7 {
1528            let col_mask_id = 2 - (y & WIDE_FILTER_ROW_MASK[ss_v] == 0) as usize;
1529            mask[0][y][1] |= m_row_8 as u8;
1530            mask[0][y][2] |= m_row_4 as u8;
1531            if (ss_h & ss_v) != 0 && (col_end & 1) != 0 && (y & 1) != 0 {
1532                mask[1][y][col_mask_id] |= ((t << (w - 1)) - t) as u8;
1533            } else {
1534                mask[1][y][col_mask_id] |= m_col as u8;
1535            }
1536            if ss_h == 0 {
1537                mask[0][y][3] |= m_col as u8;
1538            }
1539            if ss_v == 0 {
1540                if ss_h != 0 && (col_end & 1) != 0 {
1541                    mask[1][y][3] |= ((t << (w - 1)) - t) as u8;
1542                } else {
1543                    mask[1][y][3] |= m_col as u8;
1544                }
1545            }
1546        }
1547    } else if !skip_inter {
1548        let mask_id = (tx == TX_8X8) as usize;
1549        let l2 = tx as i32 + ss_h as i32 - 1;
1550        const MASKS: [u32; 4] = [0xff, 0x55, 0x11, 0x01];
1551        let m_row = m_col & MASKS[l2 as usize];
1552        if ss_h != 0 && tx > TX_8X8 && (w ^ (w - 1)) == 1 {
1553            let m_row_16 = ((t << (w - 1)) - t) & MASKS[l2 as usize];
1554            let m_row_8 = m_row - m_row_16;
1555            for y in row_and_7..h + row_and_7 {
1556                mask[0][y][0] |= m_row_16 as u8;
1557                mask[0][y][1] |= m_row_8 as u8;
1558            }
1559        } else {
1560            for y in row_and_7..h + row_and_7 {
1561                mask[0][y][mask_id] |= m_row as u8;
1562            }
1563        }
1564        let l2 = tx as usize + ss_v - 1;
1565        let step1d = 1usize << l2;
1566        if ss_v != 0 && tx > TX_8X8 && (h ^ (h - 1)) == 1 {
1567            let mut y = row_and_7;
1568            while y < h + row_and_7 - 1 {
1569                mask[1][y][0] |= m_col as u8;
1570                y += step1d;
1571            }
1572            if y - row_and_7 == h - 1 {
1573                mask[1][y][1] |= m_col as u8;
1574            }
1575        } else {
1576            let mut y = row_and_7;
1577            while y < h + row_and_7 {
1578                mask[1][y][mask_id] |= m_col as u8;
1579                y += step1d;
1580            }
1581        }
1582    } else if tx != TX_4X4 {
1583        let mask_id = ((tx == TX_8X8) || (h == ss_v)) as usize;
1584        mask[1][row_and_7][mask_id] |= m_col as u8;
1585        let mask_id = ((tx == TX_8X8) || (w == ss_h)) as usize;
1586        for y in row_and_7..h + row_and_7 {
1587            mask[0][y][mask_id] |= t as u8;
1588        }
1589    } else {
1590        let t8 = t & WIDE_FILTER_COL_MASK[ss_h];
1591        let t4 = t - t8;
1592        for y in row_and_7..h + row_and_7 {
1593            mask[0][y][2] |= t4 as u8;
1594            mask[0][y][1] |= t8 as u8;
1595        }
1596        mask[1][row_and_7][2 - (row_and_7 & WIDE_FILTER_ROW_MASK[ss_v] == 0) as usize] |=
1597            m_col as u8;
1598    }
1599}