1use super::data::*;
5use super::probs::{Counts, ProbContext};
6use super::rac::Rac;
7use super::*;
8
9#[derive(Clone)]
11pub struct LfMask {
12 pub level: [u8; 64],
13 pub mask: [[[[u8; 4]; 8]; 2]; 2],
15}
16
17#[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
36pub 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 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 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 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 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
145const 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
153pub 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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
1297fn 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
1307fn splat(la: &mut [u8], end: usize, step: usize, whole: bool) {
1310 if step == 2 {
1311 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#[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 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#[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}