1 //use nihav_core::codecs::{DecoderResult, DecoderError};
4 use super::cabac_coder::*;
5 use super::dsp::{CHROMA_DC_SCAN, ZIGZAG, ZIGZAG1, ZIGZAG8X8};
6 use super::slice::SliceHeader;
8 pub fn cabac_decode_mbskip(cabac: &mut CABAC, sstate: &SliceState, slice_hdr: &SliceHeader) -> bool {
9 let skip_idx = if slice_hdr.slice_type.is_p() { 11 } else { 24 };
10 let mut mb_skip_ctx = 0;
11 let left_mbt = sstate.get_left_mb().mb_type;
12 let top_mbt = sstate.get_top_mb().mb_type;
13 if left_mbt != CompactMBType::None && !left_mbt.is_skip() {
16 if top_mbt != CompactMBType::None && !top_mbt.is_skip() {
19 if !slice_hdr.slice_type.is_intra() {
20 cabac.decode_bit(skip_idx + mb_skip_ctx)
26 fn decode_i_type(cabac: &mut CABAC, start: usize, ctx: usize) -> MBType {
27 if !cabac.decode_bit(start + ctx) {
29 } else if !cabac.decode_terminate() {
30 let cbpy = if cabac.decode_bit(start + 3) { 0xF } else { 0x0 };
31 let cbpc = cabac.decode_012(start + 4);
32 let ipred = cabac.decode_bits(start + 6, start + 7, 2);
34 MBType::Intra16x16(ipred, cbpy, cbpc)
40 fn decode_i_type_inter(cabac: &mut CABAC, start: usize) -> MBType {
41 if !cabac.decode_bit(start) {
43 } else if !cabac.decode_terminate() {
44 let cbpy = if cabac.decode_bit(start + 1) { 0xF } else { 0x0 };
45 let cbpc = if !cabac.decode_bit(start + 2) {
47 } else if !cabac.decode_bit(start + 2) {
52 let ipred = cabac.decode_bits(start + 3, start + 3, 2);
54 MBType::Intra16x16(ipred, cbpy, cbpc)
60 fn remap_si_mbtype(mbtype: MBType) -> MBType {
62 MBType::Intra16x16(0, 0, 0) => MBType::Intra4x4,
63 MBType::Intra16x16(imode, cbpy, cbpc) => {
64 let idx = imode + if cbpy != 0 { 12 } else { 0 } + cbpc * 4 - 1;
66 let (ncbpy, ncbpc) = if (idx >> 2) >= 3 {
71 MBType::Intra16x16(nimode, ncbpy, ncbpc)
73 MBType::PCM => MBType::Intra16x16(3, 1, 2),
78 pub fn cabac_decode_mb_type(cabac: &mut CABAC, slice_hdr: &SliceHeader, sstate: &SliceState) -> MBType {
79 match slice_hdr.slice_type {
80 SliceType::I | SliceType::SI => {
82 if sstate.get_left_mb().mb_type.is_intra16orpcm() {
85 if sstate.get_top_mb().mb_type.is_intra16orpcm() {
88 let mbtype = decode_i_type(cabac, 3, ctx);
89 if slice_hdr.slice_type == SliceType::I {
92 remap_si_mbtype(mbtype)
95 SliceType::P | SliceType::SP => {
96 if cabac.decode_bit(14) {
97 decode_i_type_inter(cabac, 17)
98 } else if !cabac.decode_bit(15) {
99 if !cabac.decode_bit(16) {
105 if !cabac.decode_bit(17) {
114 if !sstate.get_left_mb().mb_type.is_direct() {
117 if !sstate.get_top_mb().mb_type.is_direct() {
120 if !cabac.decode_bit(27 + ctx) {
122 } else if !cabac.decode_bit(30) {
123 if !cabac.decode_bit(32) {
124 MBType::B16x16(BMode::L0)
126 MBType::B16x16(BMode::L1)
129 let idx = cabac.decode_bits(31, 32, 4);
131 0x0 => MBType::B16x16(BMode::Bi),
132 0x1 => MBType::B16x8(BMode::L0, BMode::L0),
133 0x2 => MBType::B8x16(BMode::L0, BMode::L0),
134 0x3 => MBType::B16x8(BMode::L1, BMode::L1),
135 0x4 => MBType::B8x16(BMode::L1, BMode::L1),
136 0x5 => MBType::B16x8(BMode::L0, BMode::L1),
137 0x6 => MBType::B8x16(BMode::L0, BMode::L1),
138 0x7 => MBType::B16x8(BMode::L1, BMode::L0),
139 0xE => MBType::B8x16(BMode::L1, BMode::L0),
141 0xD => decode_i_type_inter(cabac, 32),
143 let idx = (idx - 8) * 2 + (cabac.decode_bit(32) as u8);
145 0 => MBType::B16x8(BMode::L0, BMode::Bi),
146 1 => MBType::B8x16(BMode::L0, BMode::Bi),
147 2 => MBType::B16x8(BMode::L1, BMode::Bi),
148 3 => MBType::B8x16(BMode::L1, BMode::Bi),
149 4 => MBType::B16x8(BMode::Bi, BMode::L0),
150 5 => MBType::B8x16(BMode::Bi, BMode::L0),
151 6 => MBType::B16x8(BMode::Bi, BMode::L1),
152 7 => MBType::B8x16(BMode::Bi, BMode::L1),
153 8 => MBType::B16x8(BMode::Bi, BMode::Bi),
154 _ => MBType::B8x16(BMode::Bi, BMode::Bi),
163 fn decode_sub_mb_type_cabac(cabac: &mut CABAC, slice_hdr: &SliceHeader) -> SubMBType {
164 match slice_hdr.slice_type {
165 SliceType::P | SliceType::SP => {
166 if cabac.decode_bit(21) {
168 } else if !cabac.decode_bit(22) {
170 } else if cabac.decode_bit(23) {
177 if !cabac.decode_bit(36) {
179 } else if !cabac.decode_bit(37) {
180 if !cabac.decode_bit(39) {
181 SubMBType::B8x8(BMode::L0)
183 SubMBType::B8x8(BMode::L1)
186 let idx = cabac.decode_bits(38, 39, 3);
188 0 => SubMBType::B8x8(BMode::Bi),
189 1 => SubMBType::B8x4(BMode::L0),
190 2 => SubMBType::B4x8(BMode::L0),
191 3 => SubMBType::B8x4(BMode::L1),
192 6 => SubMBType::B4x4(BMode::L1),
193 7 => SubMBType::B4x4(BMode::Bi),
195 let idx = (idx - 4) * 2 + (cabac.decode_bit(39) as u8);
197 0 => SubMBType::B4x8(BMode::L1),
198 1 => SubMBType::B8x4(BMode::Bi),
199 2 => SubMBType::B4x8(BMode::Bi),
200 _ => SubMBType::B4x4(BMode::L0),
210 fn decode_ref_idx(cabac: &mut CABAC, num_refs: usize, ctx: usize) -> PicRef {
214 if !cabac.decode_bit(54 + ctx) {
216 } else if !cabac.decode_bit(54 + 4) {
220 while cabac.decode_bit(54 + 5) && idx < 32 {
224 PicRef::new(idx as u8)
231 fn decode_mv_component(cabac: &mut CABAC, base: usize, ctx: usize) -> i16 {
232 if !cabac.decode_bit(base + ctx) {
236 while val < 9 && cabac.decode_bit(base + (2 + val).min(6)) {
241 while pfx < 16 && cabac.decode_bypass() {
245 val += cabac.decode_bypass_bits(pfx) as usize;
247 if val == 0 || !cabac.decode_bypass() {
255 fn decode_mv(cabac: &mut CABAC, ctx0: usize, ctx1: usize) -> MV {
256 let x = decode_mv_component(cabac, 40, ctx0);
257 let y = decode_mv_component(cabac, 47, ctx1);
261 pub fn decode_mb_pred_cabac(cabac: &mut CABAC, slice_hdr: &SliceHeader, mb_type: MBType, sstate: &mut SliceState, mb_info: &mut CurrentMBInfo) {
262 mb_info.mb_type = mb_type;
263 let num_l0 = slice_hdr.num_ref_idx_l0_active;
264 let num_l1 = slice_hdr.num_ref_idx_l1_active;
265 sstate.reset_mb_mv();
267 MBType::Intra4x4 => {
268 for &(x, y) in I4X4_SCAN.iter() {
271 let top_pred = sstate.get_top_blk4(x + y * 4).ipred;
272 let left_pred = sstate.get_left_blk4(x + y * 4).ipred;
274 let top_idx = top_pred.into_pred_idx();
275 let left_idx = left_pred.into_pred_idx();
276 let pred_mode = top_idx.min(left_idx);
277 let mut pred_mode = if pred_mode != -1 { pred_mode as u8 } else { 2 };
279 if !cabac.decode_bit(68) {
280 let m0 = cabac.decode_bit(69) as u8;
281 let m1 = cabac.decode_bit(69) as u8;
282 let m2 = cabac.decode_bit(69) as u8;
283 let new_mode = (m2 << 2) | (m1 << 1) | m0;
284 pred_mode = if new_mode >= pred_mode {
288 mb_info.ipred[x + y * 4] = pred_mode.into();
289 sstate.get_cur_blk4(x + y * 4).ipred = (pred_mode as u8).into();
292 if sstate.get_left_mb().cmode != 0 {
295 if sstate.get_top_mb().cmode != 0 {
298 mb_info.chroma_ipred = if !cabac.decode_bit(64 + ctx) {
300 } else if !cabac.decode_bit(67) {
302 } else if !cabac.decode_bit(67) {
308 MBType::Intra8x8 => {
310 let blk4 = (part & 1) * 2 + (part & 2) * 4;
311 let top_pred = sstate.get_top_blk4(blk4).ipred;
312 let left_pred = sstate.get_left_blk4(blk4).ipred;
314 let top_idx = top_pred.into_pred_idx();
315 let left_idx = left_pred.into_pred_idx();
316 let pred_mode = top_idx.min(left_idx);
317 let mut pred_mode = if pred_mode != -1 { pred_mode as u8 } else { 2 };
318 if !cabac.decode_bit(68) {
319 let m0 = cabac.decode_bit(69) as u8;
320 let m1 = cabac.decode_bit(69) as u8;
321 let m2 = cabac.decode_bit(69) as u8;
322 let new_mode = (m2 << 2) | (m1 << 1) | m0;
323 pred_mode = if new_mode >= pred_mode {
327 mb_info.ipred[blk4] = pred_mode.into();
328 mb_info.ipred[blk4 + 1] = pred_mode.into();
329 mb_info.ipred[blk4 + 4] = pred_mode.into();
330 mb_info.ipred[blk4 + 5] = pred_mode.into();
331 sstate.get_cur_blk4(blk4).ipred = (pred_mode as u8).into();
332 sstate.get_cur_blk4(blk4 + 1).ipred = (pred_mode as u8).into();
333 sstate.get_cur_blk4(blk4 + 4).ipred = (pred_mode as u8).into();
334 sstate.get_cur_blk4(blk4 + 5).ipred = (pred_mode as u8).into();
337 if sstate.get_left_mb().cmode != 0 {
340 if sstate.get_top_mb().cmode != 0 {
343 mb_info.chroma_ipred = if !cabac.decode_bit(64 + ctx) {
345 } else if !cabac.decode_bit(67) {
347 } else if !cabac.decode_bit(67) {
353 MBType::Intra16x16(_ipred, _, _) => {
355 if sstate.get_left_mb().cmode != 0 {
358 if sstate.get_top_mb().cmode != 0 {
361 mb_info.chroma_ipred = if !cabac.decode_bit(64 + ctx) {
363 } else if !cabac.decode_bit(67) {
365 } else if !cabac.decode_bit(67) {
371 MBType::P16x16 | MBType::P16x8 | MBType::P8x16 => {
372 let num_subparts = mb_type.num_parts();
373 let (pw, ph) = mb_type.size();
376 for i in 0..num_subparts {
377 let ctx = sstate.get_mv_ref_ctx(xoff, yoff, 0);
378 let ref_idx = decode_ref_idx(cabac, num_l0, ctx);
379 mb_info.ref_l0[i] = ref_idx;
380 sstate.fill_ref(xoff, yoff, pw, ph, 0, ref_idx);
389 for i in 0..num_subparts {
390 let (ctx0, ctx1) = sstate.get_mv_ctx(xoff, yoff, 0);
391 let mv = decode_mv(cabac, ctx0, ctx1);
392 mb_info.mv_l0[i] = mv;
393 sstate.fill_mvd(xoff, yoff, pw, ph, 0, mv);
401 MBType::B16x16(mode) => {
402 if mode != BMode::L1 {
403 let ctx = sstate.get_mv_ref_ctx(0, 0, 0);
404 let ref_idx = decode_ref_idx(cabac, num_l0, ctx);
405 mb_info.ref_l0[0] = ref_idx;
406 sstate.fill_ref(0, 0, 16, 16, 0, ref_idx);
408 if mode != BMode::L0 {
409 let ctx = sstate.get_mv_ref_ctx(0, 0, 1);
410 let ref_idx = decode_ref_idx(cabac, num_l1, ctx);
411 mb_info.ref_l1[0] = ref_idx;
412 sstate.fill_ref(0, 0, 16, 16, 1, ref_idx);
414 if mode != BMode::L1 {
415 let (ctx0, ctx1) = sstate.get_mv_ctx(0, 0, 0);
416 let mv = decode_mv(cabac, ctx0, ctx1);
417 mb_info.mv_l0[0] = mv;
418 sstate.fill_mvd(0, 0, 16, 16, 0, mv);
420 if mode != BMode::L0 {
421 let (ctx0, ctx1) = sstate.get_mv_ctx(0, 0, 1);
422 let mv = decode_mv(cabac, ctx0, ctx1);
423 mb_info.mv_l1[0] = mv;
424 sstate.fill_mvd(0, 0, 16, 16, 1, mv);
427 MBType::B16x8(mode0, mode1) | MBType::B8x16(mode0, mode1) => {
428 let (pw, ph) = mb_info.mb_type.size();
429 let (px, py) = (pw & 8, ph & 8);
430 if mode0 != BMode::L1 {
431 let ctx = sstate.get_mv_ref_ctx(0, 0, 0);
432 let ref_idx = decode_ref_idx(cabac, num_l0, ctx);
433 mb_info.ref_l0[0] = ref_idx;
434 sstate.fill_ref(0, 0, pw, ph, 0, ref_idx);
436 if mode1 != BMode::L1 {
437 let ctx = sstate.get_mv_ref_ctx(pw & 8, ph & 8, 0);
438 let ref_idx = decode_ref_idx(cabac, num_l0, ctx);
439 mb_info.ref_l0[1] = ref_idx;
440 sstate.fill_ref(px, py, pw, ph, 0, ref_idx);
442 if mode0 != BMode::L0 {
443 let ctx = sstate.get_mv_ref_ctx(0, 0, 1);
444 let ref_idx = decode_ref_idx(cabac, num_l1, ctx);
445 mb_info.ref_l1[0] = ref_idx;
446 sstate.fill_ref(0, 0, pw, ph, 1, ref_idx);
448 if mode1 != BMode::L0 {
449 let ctx = sstate.get_mv_ref_ctx(pw & 8, ph & 8, 1);
450 let ref_idx = decode_ref_idx(cabac, num_l1, ctx);
451 mb_info.ref_l1[1] = ref_idx;
452 sstate.fill_ref(px, py, pw, ph, 1, ref_idx);
454 if mode0 != BMode::L1 {
455 let (ctx0, ctx1) = sstate.get_mv_ctx(0, 0, 0);
456 let mv = decode_mv(cabac, ctx0, ctx1);
457 mb_info.mv_l0[0] = mv;
458 sstate.fill_mvd(0, 0, pw, ph, 0, mv);
460 if mode1 != BMode::L1 {
461 let (ctx0, ctx1) = sstate.get_mv_ctx(pw & 8, ph & 8, 0);
462 let mv = decode_mv(cabac, ctx0, ctx1);
463 mb_info.mv_l0[1] = mv;
464 sstate.fill_mvd(px, py, pw, ph, 0, mv);
466 if mode0 != BMode::L0 {
467 let (ctx0, ctx1) = sstate.get_mv_ctx(0, 0, 1);
468 let mv = decode_mv(cabac, ctx0, ctx1);
469 mb_info.mv_l1[0] = mv;
470 sstate.fill_mvd(0, 0, pw, ph, 1, mv);
472 if mode1 != BMode::L0 {
473 let (ctx0, ctx1) = sstate.get_mv_ctx(pw & 8, ph & 8, 1);
474 let mv = decode_mv(cabac, ctx0, ctx1);
475 mb_info.mv_l1[1] = mv;
476 sstate.fill_mvd(px, py, pw, ph, 1, mv);
479 MBType::P8x8 | MBType::B8x8 => {
480 for sub_type in mb_info.sub_mb_type.iter_mut() {
481 *sub_type = decode_sub_mb_type_cabac(cabac, slice_hdr);
483 let num_l = [num_l0, num_l1];
484 let dst_ref = [&mut mb_info.ref_l0, &mut mb_info.ref_l1];
487 let stype = mb_info.sub_mb_type[spart];
488 if stype != SubMBType::Direct8x8 && ((ref_l == 0 && !stype.is_l1()) || (ref_l == 1 && !stype.is_l0())) {
489 let ctx = sstate.get_mv_ref_ctx((spart & 1) * 8, (spart & 2) * 4, ref_l);
490 let ref_idx = decode_ref_idx(cabac, num_l[ref_l], ctx);
491 dst_ref[ref_l][spart] = ref_idx;
492 sstate.get_cur_blk8(spart).ref_idx[ref_l] = ref_idx;
496 let dst_mv = [&mut mb_info.mv_l0, &mut mb_info.mv_l1];
499 let stype = mb_info.sub_mb_type[spart];
500 if stype == SubMBType::Direct8x8 || (ref_l == 0 && stype.is_l1()) || (ref_l == 1 && stype.is_l0()) {
503 let (pw, ph) = stype.size();
504 let mut xoff = (spart & 1) * 8;
505 let mut yoff = (spart & 2) * 4;
506 let num_sub = stype.num_parts();
508 for i in 0..num_sub {
509 let (ctx0, ctx1) = sstate.get_mv_ctx(xoff, yoff, ref_l);
510 let mv = decode_mv(cabac, ctx0, ctx1);
511 dst_mv[ref_l][spart * 4 + i] = mv;
512 sstate.fill_mvd(xoff, yoff, pw, ph, ref_l, mv);
514 if xoff == orig_x + 8 {
526 pub fn decode_cbp_cabac(cabac: &mut CABAC, sstate: &SliceState) -> (u8, u8) {
527 let mbt_a = sstate.get_left_mb().mb_type;
528 let mbt_b = sstate.get_top_mb().mb_type;
529 let left = if mbt_a == CompactMBType::None || mbt_a == CompactMBType::PCM {
531 } else if !mbt_a.is_skip() {
532 sstate.get_left_mb().cbp
536 let top = if mbt_b == CompactMBType::None || mbt_b == CompactMBType::PCM {
538 } else if !mbt_b.is_skip() {
539 sstate.get_top_mb().cbp
544 let cbp_ctx = if (left & 2) != 0 { 0 } else { 1 } + if (top & 4) != 0 { 0 } else { 2 };
545 let mut cbpy = cabac.decode_bit(73 + cbp_ctx) as u8;
546 let cbp_ctx = if cbpy != 0 { 0 } else { 1 } + if (top & 8) != 0 { 0 } else { 2 };
547 cbpy |= (cabac.decode_bit(73 + cbp_ctx) as u8) << 1;
548 let cbp_ctx = if (left & 8) != 0 { 0 } else { 1 } + if (cbpy & 1) != 0 { 0 } else { 2 };
549 cbpy |= (cabac.decode_bit(73 + cbp_ctx) as u8) << 2;
550 let cbp_ctx = if (cbpy & 4) != 0 { 0 } else { 1 } + if (cbpy & 2) != 0 { 0 } else { 2 };
551 cbpy |= (cabac.decode_bit(73 + cbp_ctx) as u8) << 3;
553 let left = if mbt_a == CompactMBType::PCM {
555 } else if mbt_a == CompactMBType::None || !mbt_a.is_skip() {
556 sstate.get_left_mb().cbp
560 let top = if mbt_b == CompactMBType::PCM {
562 } else if mbt_b == CompactMBType::None || !mbt_b.is_skip() {
563 sstate.get_top_mb().cbp
567 let cleft = left >> 4;
569 let cbp_ctx0 = if cleft != 0 { 1 } else { 0 } + if ctop != 0 { 2 } else { 0 };
570 let cbp_ctx1 = if cleft == 2 { 1 } else { 0 } + if ctop == 2 { 2 } else { 0 };
571 let cbpc = if !cabac.decode_bit(77 + cbp_ctx0) {
574 cabac.decode_bit(81 + cbp_ctx1) as u8 + 1
580 pub fn decode_mb_qp_delta_cabac(cabac: &mut CABAC, ctx: usize) -> i32 {
581 if !cabac.decode_bit(60 + ctx) {
583 } else if !cabac.decode_bit(62) {
587 while val < 128 && cabac.decode_bit(63) {
591 ((val >> 1) as i32) + 2
593 -((val >> 1) as i32) - 1
598 fn decode_block(cabac: &mut CABAC, coeffs: &mut [i16], cat: usize, ctx_off: usize) -> bool {
599 const CTX_BASE: [(usize, usize); 5] = [
600 (0, 0), (15, 10), (29, 20), (44, 30), (47, 39)
602 let (flag_off, coef_off) = CTX_BASE[cat];
603 let scan: &[usize] = match coeffs.len() {
604 4 => &CHROMA_DC_SCAN,
610 let coded_block_flag = cabac.decode_bit(85 + ctx_off);
611 let mut coded = [false; 16];
612 if coded_block_flag {
613 let mut last_idx = coeffs.len() - 1;
614 for i in 0..coeffs.len() - 1 {
615 coded[i] = cabac.decode_bit(105 + flag_off + i); // or 277 for interlaced
617 let last = cabac.decode_bit(166 + flag_off + i); // or 338 for interlaced
624 coded[last_idx] = true;
625 let mut coef_ctx = 0;
626 for i in (0..=last_idx).rev() {
628 let zero_ctx = if coef_ctx < 4 { coef_ctx + 1 } else { 0 };
629 coeffs[scan[i]] = if !cabac.decode_bit(227 + coef_off + zero_ctx) {
635 let cur_ctx = 227 + coef_off + (coef_ctx + 2).max(5);
636 coef_ctx = (coef_ctx + 1).max(4).min(7);
639 while coef < 15 && cabac.decode_bit(cur_ctx) {
644 while pfx < 15 && cabac.decode_bypass() {
649 tail = (tail << 1) + (cabac.decode_bypass() as i16);
656 if cabac.decode_bypass() {
657 coeffs[scan[i]] = -coeffs[scan[i]];
665 fn decode_block8x8(cabac: &mut CABAC, coeffs: &mut [i16; 64], _cat: usize) {
666 const SIG_FLAG_MAP: [usize; 63] = [
667 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
668 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9, 10, 9, 8, 7,
669 7, 6, 11, 12, 13, 11, 6, 7, 8, 9, 14, 10, 9, 8, 6, 11,
670 12, 13, 11, 6, 9, 14, 10, 9, 11, 12, 13, 11, 14, 10, 12
672 const LAST_SIG_FLAG_MAP: [usize; 63] = [
673 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
674 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
675 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
676 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
678 let (flag_off, coef_off) = (0, 0);
679 let scan = &ZIGZAG8X8;
681 let mut coded = [false; 64];
682 let mut last_idx = coeffs.len() - 1;
683 for i in 0..coeffs.len() - 1 {
684 coded[i] = cabac.decode_bit(402 + flag_off + SIG_FLAG_MAP[i]);
686 let last = cabac.decode_bit(417 + flag_off + LAST_SIG_FLAG_MAP[i]);
693 coded[last_idx] = true;
694 let mut coef_ctx = 0;
695 for i in (0..=last_idx).rev() {
697 let zero_ctx = if coef_ctx < 4 { coef_ctx + 1 } else { 0 };
698 coeffs[scan[i]] = if !cabac.decode_bit(426 + coef_off + zero_ctx) {
704 let cur_ctx = 426 + coef_off + (coef_ctx + 2).max(5);
705 coef_ctx = (coef_ctx + 1).max(4).min(7);
708 while coef < 15 && cabac.decode_bit(cur_ctx) {
713 while pfx < 15 && cabac.decode_bypass() {
718 tail = (tail << 1) + (cabac.decode_bypass() as i16);
725 if cabac.decode_bypass() {
726 coeffs[scan[i]] = -coeffs[scan[i]];
732 fn derive_ctx_off(sstate: &mut SliceState, cat: usize, blk_no: usize) -> usize {
733 let mbt = sstate.get_cur_mb().mb_type;
734 let mut mbt_a = sstate.get_left_mb().mb_type;
735 let mut mbt_b = sstate.get_top_mb().mb_type;
736 let (trans_a, trans_b, mut cond_term_a, mut cond_term_b) = match cat {
738 (mbt_a == CompactMBType::Intra16x16,
739 mbt_b == CompactMBType::Intra16x16,
740 (sstate.get_left_mb().coded_flags & 1) as usize,
741 (sstate.get_top_mb().coded_flags & 1) as usize)
744 if (blk_no & 3) != 0 {
750 let nc_left = sstate.get_left_blk4(blk_no).ncoded;
751 let nc_top = sstate.get_top_blk4(blk_no).ncoded;
754 (nc_left != 0) as usize,
755 (nc_top != 0) as usize)
758 ((sstate.get_left_mb().cbp & 0x30) != 0,
759 (sstate.get_top_mb().cbp & 0x30) != 0,
760 ((sstate.get_left_mb().coded_flags & (1 << (blk_no + 1 + 16))) != 0) as usize,
761 ((sstate.get_top_mb().coded_flags & (1 << (blk_no + 1 + 16))) != 0) as usize)
764 let chroma = blk_no >> 2;
765 if (blk_no & 1) != 0 {
768 if (blk_no & 2) != 0 {
771 ((blk_no & 1) != 0 || (sstate.get_left_mb().cbp & 0x20) != 0,
772 (blk_no & 2) != 0 || (sstate.get_top_mb().cbp & 0x20) != 0,
773 (sstate.get_left_blk8(blk_no & 3).ncoded_c[chroma] != 0) as usize,
774 (sstate.get_top_blk8(blk_no & 3).ncoded_c[chroma] != 0) as usize)
778 /*let coded_no = match cat {
781 3 => 1 + 16 + blk_no,
782 4 => 1 + 16 + 2 + blk_no,
786 if mbt_a == CompactMBType::None && mbt.is_inter() {
789 if !trans_a && mbt_a != CompactMBType::PCM {
792 /*if mbt.is_intra() && pps.constrained_intra_pred && mbt_a.is_inter() && slice_partitioning {
795 if (mbt_a == CompactMBType::PCM) || (mbt_a == CompactMBType::None && mbt.is_intra()) {
799 if mbt_b == CompactMBType::None && mbt.is_inter() {
802 if !trans_b && mbt_b != CompactMBType::PCM {
805 /*if mbt.is_intra() && pps.constrained_intra_pred && mbt_b.is_inter() && slice_partitioning {
808 if (mbt_b == CompactMBType::PCM) || (mbt_b == CompactMBType::None && mbt.is_intra()) {
812 cat * 4 + cond_term_b * 2 + cond_term_a
815 pub fn decode_residual_cabac(cabac: &mut CABAC, sstate: &mut SliceState, mb_info: &mut CurrentMBInfo) {
816 sstate.get_cur_mb().mb_type = mb_info.mb_type.into();
817 let mut coded_flags = 0;
818 if mb_info.mb_type.is_intra16x16() {
819 let off = derive_ctx_off(sstate, 0, 0);
820 let coded = decode_block(cabac, &mut mb_info.coeffs[24], 0, off);
821 mb_info.coded[24] = coded;
826 if !mb_info.transform_size_8x8 {
828 if (mb_info.cbpy & (1 << blk8)) != 0 {
830 let blk_no = (blk8 & 1) * 2 + (blk8 & 2) * 4 + (blk4 & 1) + (blk4 & 2) * 2;
831 let coded = if mb_info.mb_type.is_intra16x16() {
832 let off = derive_ctx_off(sstate, 1, blk_no);
833 decode_block(cabac, &mut mb_info.coeffs[blk_no][1..], 1, off)
835 let off = derive_ctx_off(sstate, 2, blk_no);
836 decode_block(cabac, &mut mb_info.coeffs[blk_no], 2, off)
838 sstate.get_cur_blk4(blk_no).ncoded = coded as u8;
839 mb_info.coded[blk_no] = coded;
841 coded_flags |= 1 << (1 + blk_no);
848 if (mb_info.cbpy & (1 << blk8)) != 0 {
849 let blk4 = (blk8 & 1) * 2 + (blk8 & 2) * 4;
850 decode_block8x8(cabac, &mut mb_info.coeffs8x8[blk8].coeffs, 5);
851 coded_flags |= 0x33 << blk4;
852 mb_info.coded[blk4] = true;
853 mb_info.coded[blk4 + 1] = true;
854 mb_info.coded[blk4 + 4] = true;
855 mb_info.coded[blk4 + 5] = true;
856 sstate.get_cur_blk4(blk4).ncoded = 1;
857 sstate.get_cur_blk4(blk4 + 1).ncoded = 1;
858 sstate.get_cur_blk4(blk4 + 4).ncoded = 1;
859 sstate.get_cur_blk4(blk4 + 5).ncoded = 1;
864 if (mb_info.cbpc & 3) != 0 {
865 let off = derive_ctx_off(sstate, 3, chroma);
866 let coded = decode_block(cabac, &mut mb_info.chroma_dc[chroma], 3, off);
868 coded_flags |= 1 << (16 + 1 + chroma);
873 if (mb_info.cbpc & 2) != 0 {
875 let blk_no = 16 + chroma * 4 + blk4;
876 let off = derive_ctx_off(sstate, 4, blk_no - 16);
877 let coded = decode_block(cabac, &mut mb_info.coeffs[blk_no][1..], 4, off);
878 sstate.get_cur_blk8(blk4).ncoded_c[chroma] = coded as u8;
879 mb_info.coded[blk_no] = coded;
881 coded_flags |= 1 << (1 + 2 + blk_no);
886 sstate.get_cur_mb().coded_flags = coded_flags;