nihav-itu/src/codecs/h264/cabac.rs

   1 //use nihav_core::codecs::{DecoderResult, DecoderError};
   2
   3 use super::*;
   4 use super::cabac_coder::*;
   5 use super::dsp::{CHROMA_DC_SCAN, ZIGZAG, ZIGZAG1, ZIGZAG8X8};
   6 use super::slice::SliceHeader;
   7
   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() {
  14         mb_skip_ctx += 1;
  15     }
  16     if top_mbt != CompactMBType::None && !top_mbt.is_skip() {
  17         mb_skip_ctx += 1;
  18     }
  19     if !slice_hdr.slice_type.is_intra() {
  20         cabac.decode_bit(skip_idx + mb_skip_ctx)
  21     } else {
  22         false
  23     }
  24 }
  25
  26 fn decode_i_type(cabac: &mut CABAC, start: usize, ctx: usize) -> MBType {
  27     if !cabac.decode_bit(start + ctx) {
  28         MBType::Intra4x4
  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);
  33
  34         MBType::Intra16x16(ipred, cbpy, cbpc)
  35     } else {
  36         MBType::PCM
  37     }
  38 }
  39
  40 fn decode_i_type_inter(cabac: &mut CABAC, start: usize) -> MBType {
  41     if !cabac.decode_bit(start) {
  42         MBType::Intra4x4
  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) {
  46                 0
  47             } else if !cabac.decode_bit(start + 2) {
  48                 1
  49             } else {
  50                 2
  51             };
  52         let ipred = cabac.decode_bits(start + 3, start + 3, 2);
  53
  54         MBType::Intra16x16(ipred, cbpy, cbpc)
  55     } else {
  56         MBType::PCM
  57     }
  58 }
  59
  60 fn remap_si_mbtype(mbtype: MBType) -> MBType {
  61     match 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;
  65             let nimode = idx & 3;
  66             let (ncbpy, ncbpc) = if (idx >> 2) >= 3 {
  67                     (0xF, (idx >> 2) - 3)
  68                 } else {
  69                     (0x0, idx >> 2)
  70                 };
  71             MBType::Intra16x16(nimode, ncbpy, ncbpc)
  72         },
  73         MBType::PCM => MBType::Intra16x16(3, 1, 2),
  74         _ => mbtype,
  75     }
  76 }
  77
  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 => {
  81             let mut ctx = 0;
  82             if sstate.get_left_mb().mb_type.is_intra16orpcm() {
  83                 ctx += 1;
  84             }
  85             if sstate.get_top_mb().mb_type.is_intra16orpcm() {
  86                 ctx += 1;
  87             }
  88             let mbtype = decode_i_type(cabac, 3, ctx);
  89             if slice_hdr.slice_type == SliceType::I {
  90                 mbtype
  91             } else {
  92                 remap_si_mbtype(mbtype)
  93             }
  94         },
  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) {
 100                     MBType::P16x16
 101                 } else {
 102                     MBType::P8x8
 103                 }
 104             } else {
 105                 if !cabac.decode_bit(17) {
 106                     MBType::P8x16
 107                 } else {
 108                     MBType::P16x8
 109                 }
 110             }
 111         },
 112         SliceType::B => {
 113             let mut ctx = 0;
 114             if !sstate.get_left_mb().mb_type.is_direct() {
 115                 ctx += 1;
 116             }
 117             if !sstate.get_top_mb().mb_type.is_direct() {
 118                 ctx += 1;
 119             }
 120             if !cabac.decode_bit(27 + ctx) {
 121                 MBType::Direct
 122             } else if !cabac.decode_bit(30) {
 123                 if !cabac.decode_bit(32) {
 124                     MBType::B16x16(BMode::L0)
 125                 } else {
 126                     MBType::B16x16(BMode::L1)
 127                 }
 128             } else {
 129                 let idx = cabac.decode_bits(31, 32, 4);
 130                 match idx {
 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),
 140                     0xF => MBType::B8x8,
 141                     0xD => decode_i_type_inter(cabac, 32),
 142                     _ => {
 143                         let idx = (idx - 8) * 2 + (cabac.decode_bit(32) as u8);
 144                         match idx {
 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),
 155                         }
 156                     },
 157                 }
 158             }
 159         },
 160     }
 161 }
 162
 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) {
 167                 SubMBType::P8x8
 168             } else if !cabac.decode_bit(22) {
 169                 SubMBType::P8x4
 170             } else if cabac.decode_bit(23) {
 171                 SubMBType::P4x8
 172             } else {
 173                 SubMBType::P4x4
 174             }
 175         },
 176         SliceType::B => {
 177             if !cabac.decode_bit(36) {
 178                 SubMBType::Direct8x8
 179             } else if !cabac.decode_bit(37) {
 180                 if !cabac.decode_bit(39) {
 181                     SubMBType::B8x8(BMode::L0)
 182                 } else {
 183                     SubMBType::B8x8(BMode::L1)
 184                 }
 185             } else {
 186                 let idx = cabac.decode_bits(38, 39, 3);
 187                 match idx {
 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),
 194                     _ => {
 195                         let idx = (idx - 4) * 2 + (cabac.decode_bit(39) as u8);
 196                         match idx {
 197                             0 => SubMBType::B4x8(BMode::L1),
 198                             1 => SubMBType::B8x4(BMode::Bi),
 199                             2 => SubMBType::B4x8(BMode::Bi),
 200                             _ => SubMBType::B4x4(BMode::L0),
 201                         }
 202                     },
 203                 }
 204             }
 205         },
 206         _ => unreachable!(),
 207     }
 208 }
 209
 210 fn decode_ref_idx(cabac: &mut CABAC, num_refs: usize, ctx: usize) -> PicRef {
 211     if num_refs == 1 {
 212         return ZERO_REF;
 213     }
 214     if !cabac.decode_bit(54 + ctx) {
 215         ZERO_REF
 216     } else if !cabac.decode_bit(54 + 4) {
 217         PicRef::new(1)
 218     } else {
 219         let mut idx = 2;
 220         while cabac.decode_bit(54 + 5) && idx < 32 {
 221             idx += 1;
 222         }
 223         if idx < num_refs {
 224             PicRef::new(idx as u8)
 225         } else {
 226             INVALID_REF
 227         }
 228     }
 229 }
 230
 231 fn decode_mv_component(cabac: &mut CABAC, base: usize, ctx: usize) -> i16 {
 232     if !cabac.decode_bit(base + ctx) {
 233         0
 234     } else {
 235         let mut val = 1;
 236         while val < 9 && cabac.decode_bit(base + (2 + val).min(6)) {
 237             val += 1;
 238         }
 239         if val >= 9 {
 240             let mut pfx = 3;
 241             while pfx < 16 && cabac.decode_bypass() {
 242                 val += 1 << pfx;
 243                 pfx += 1;
 244             }
 245             val += cabac.decode_bypass_bits(pfx) as usize;
 246         }
 247         if val == 0 || !cabac.decode_bypass() {
 248             val as i16
 249         } else {
 250             -(val as i16)
 251         }
 252     }
 253 }
 254
 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);
 258     MV{ x, y }
 259 }
 260
 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();
 266     match mb_type {
 267         MBType::Intra4x4 => {
 268             for &(x, y) in I4X4_SCAN.iter() {
 269                 let x = x as usize;
 270                 let y = y as usize;
 271                 let top_pred  = sstate.get_top_blk4(x + y * 4).ipred;
 272                 let left_pred = sstate.get_left_blk4(x + y * 4).ipred;
 273
 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 };
 278
 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 {
 285                             new_mode + 1
 286                         } else { new_mode };
 287                 }
 288                 mb_info.ipred[x + y * 4] = pred_mode.into();
 289                 sstate.get_cur_blk4(x + y * 4).ipred = (pred_mode as u8).into();
 290             }
 291             let mut ctx = 0;
 292             if sstate.get_left_mb().cmode != 0 {
 293                 ctx += 1;
 294             }
 295             if sstate.get_top_mb().cmode != 0 {
 296                 ctx += 1;
 297             }
 298             mb_info.chroma_ipred = if !cabac.decode_bit(64 + ctx) {
 299                     0
 300                 } else if !cabac.decode_bit(67) {
 301                     1
 302                 } else if !cabac.decode_bit(67) {
 303                     2
 304                 } else {
 305                     3
 306                 };
 307         },
 308         MBType::Intra8x8 => {
 309             for part in 0..4 {
 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;
 313
 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 {
 324                             new_mode + 1
 325                         } else { new_mode };
 326                 }
 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();
 335             }
 336             let mut ctx = 0;
 337             if sstate.get_left_mb().cmode != 0 {
 338                 ctx += 1;
 339             }
 340             if sstate.get_top_mb().cmode != 0 {
 341                 ctx += 1;
 342             }
 343             mb_info.chroma_ipred = if !cabac.decode_bit(64 + ctx) {
 344                     0
 345                 } else if !cabac.decode_bit(67) {
 346                     1
 347                 } else if !cabac.decode_bit(67) {
 348                     2
 349                 } else {
 350                     3
 351                 };
 352         },
 353         MBType::Intra16x16(_ipred, _, _) => {
 354             let mut ctx = 0;
 355             if sstate.get_left_mb().cmode != 0 {
 356                 ctx += 1;
 357             }
 358             if sstate.get_top_mb().cmode != 0 {
 359                 ctx += 1;
 360             }
 361             mb_info.chroma_ipred = if !cabac.decode_bit(64 + ctx) {
 362                     0
 363                 } else if !cabac.decode_bit(67) {
 364                     1
 365                 } else if !cabac.decode_bit(67) {
 366                     2
 367                 } else {
 368                     3
 369                 };
 370         },
 371         MBType::P16x16 | MBType::P16x8 | MBType::P8x16 => {
 372             let num_subparts = mb_type.num_parts();
 373             let (pw, ph) = mb_type.size();
 374             let mut xoff = 0;
 375             let mut yoff = 0;
 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);
 381                 xoff += pw;
 382                 if xoff == 16 {
 383                     xoff = 0;
 384                     yoff += ph;
 385                 }
 386             }
 387             let mut xoff = 0;
 388             let mut yoff = 0;
 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);
 394                 xoff += pw;
 395                 if xoff == 16 {
 396                     xoff = 0;
 397                     yoff += ph;
 398                 }
 399             }
 400         },
 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);
 407             }
 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);
 413             }
 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);
 419             }
 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);
 425             }
 426         },
 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);
 435             }
 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);
 441             }
 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);
 447             }
 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);
 453             }
 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);
 459             }
 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);
 465             }
 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);
 471             }
 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);
 477             }
 478         },
 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);
 482             }
 483             let num_l = [num_l0, num_l1];
 484             let dst_ref = [&mut mb_info.ref_l0, &mut mb_info.ref_l1];
 485             for ref_l in 0..2 {
 486                 for spart in 0..4 {
 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;
 493                     }
 494                 }
 495             }
 496             let dst_mv = [&mut mb_info.mv_l0, &mut mb_info.mv_l1];
 497             for ref_l in 0..2 {
 498                 for spart in 0..4 {
 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()) {
 501                         continue;
 502                     }
 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();
 507                     let orig_x = xoff;
 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);
 513                         xoff += pw;
 514                         if xoff == orig_x + 8 {
 515                             xoff -= 8;
 516                             yoff += ph;
 517                         }
 518                     }
 519                 }
 520             }
 521         },
 522         _ => {},
 523     };
 524 }
 525
 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 {
 530             0x3F
 531         } else if !mbt_a.is_skip() {
 532             sstate.get_left_mb().cbp
 533         } else {
 534             0
 535         };
 536     let top = if mbt_b == CompactMBType::None || mbt_b == CompactMBType::PCM {
 537             0x3F
 538         } else if !mbt_b.is_skip() {
 539             sstate.get_top_mb().cbp
 540         } else {
 541             0
 542         };
 543
 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;
 552
 553     let left = if mbt_a == CompactMBType::PCM {
 554             0x2F
 555         } else if mbt_a == CompactMBType::None || !mbt_a.is_skip() {
 556             sstate.get_left_mb().cbp
 557         } else {
 558             0
 559         };
 560     let top = if mbt_b == CompactMBType::PCM {
 561             0x2F
 562         } else if mbt_b == CompactMBType::None || !mbt_b.is_skip() {
 563             sstate.get_top_mb().cbp
 564         } else {
 565             0
 566         };
 567     let cleft = left >> 4;
 568     let ctop  = top  >> 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) {
 572             0
 573         } else {
 574             cabac.decode_bit(81 + cbp_ctx1) as u8 + 1
 575         };
 576
 577     (cbpy, cbpc)
 578 }
 579
 580 pub fn decode_mb_qp_delta_cabac(cabac: &mut CABAC, ctx: usize) -> i32 {
 581     if !cabac.decode_bit(60 + ctx) {
 582         0
 583     } else if !cabac.decode_bit(62) {
 584         1
 585     } else {
 586         let mut val = 0;
 587         while val < 128 && cabac.decode_bit(63) {
 588             val += 1;
 589         }
 590         if (val & 1) != 0 {
 591             ((val >> 1) as i32) + 2
 592         } else {
 593             -((val >> 1) as i32) - 1
 594         }
 595     }
 596 }
 597
 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)
 601     ];
 602     let (flag_off, coef_off) = CTX_BASE[cat];
 603     let scan: &[usize] = match coeffs.len() {
 604             4 => &CHROMA_DC_SCAN,
 605             15 => &ZIGZAG1,
 606             16 => &ZIGZAG,
 607             _ => unreachable!(),
 608         };
 609
 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
 616             if coded[i] {
 617                 let last = cabac.decode_bit(166 + flag_off + i); // or 338 for interlaced
 618                 if last {
 619                     last_idx = i;
 620                     break;
 621                 }
 622             }
 623         }
 624         coded[last_idx] = true;
 625         let mut coef_ctx = 0;
 626         for i in (0..=last_idx).rev() {
 627             if coded[i] {
 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) {
 630                         if coef_ctx < 3 {
 631                             coef_ctx += 1;
 632                         }
 633                         1
 634                     } else {
 635                         let cur_ctx = 227 + coef_off + (coef_ctx + 2).max(5);
 636                         coef_ctx = (coef_ctx + 1).max(4).min(7);
 637
 638                         let mut coef = 2;
 639                         while coef < 15 && cabac.decode_bit(cur_ctx) {
 640                             coef += 1;
 641                         }
 642                         if coef == 15 {
 643                             let mut pfx = 0;
 644                             while pfx < 15 && cabac.decode_bypass() {
 645                                 pfx += 1;
 646                             }
 647                             let mut tail = 1;
 648                             for _ in 0..pfx {
 649                                 tail = (tail << 1) + (cabac.decode_bypass() as i16);
 650                             }
 651                             coef + tail - 1
 652                         } else {
 653                             coef
 654                         }
 655                     };
 656                 if cabac.decode_bypass() {
 657                     coeffs[scan[i]] = -coeffs[scan[i]];
 658                 }
 659             }
 660         }
 661     }
 662     coded_block_flag
 663 }
 664
 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
 671     ];
 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
 677     ];
 678     let (flag_off, coef_off) = (0, 0);
 679     let scan = &ZIGZAG8X8;
 680
 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]);
 685         if coded[i] {
 686             let last = cabac.decode_bit(417 + flag_off + LAST_SIG_FLAG_MAP[i]);
 687             if last {
 688                 last_idx = i;
 689                 break;
 690             }
 691         }
 692     }
 693     coded[last_idx] = true;
 694     let mut coef_ctx = 0;
 695     for i in (0..=last_idx).rev() {
 696         if coded[i] {
 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) {
 699                     if coef_ctx < 3 {
 700                         coef_ctx += 1;
 701                     }
 702                     1
 703                 } else {
 704                     let cur_ctx = 426 + coef_off + (coef_ctx + 2).max(5);
 705                     coef_ctx = (coef_ctx + 1).max(4).min(7);
 706
 707                     let mut coef = 2;
 708                     while coef < 15 && cabac.decode_bit(cur_ctx) {
 709                         coef += 1;
 710                     }
 711                     if coef == 15 {
 712                         let mut pfx = 0;
 713                         while pfx < 15 && cabac.decode_bypass() {
 714                             pfx += 1;
 715                         }
 716                         let mut tail = 1;
 717                         for _ in 0..pfx {
 718                             tail = (tail << 1) + (cabac.decode_bypass() as i16);
 719                         }
 720                         coef + tail - 1
 721                     } else {
 722                         coef
 723                     }
 724                 };
 725             if cabac.decode_bypass() {
 726                 coeffs[scan[i]] = -coeffs[scan[i]];
 727             }
 728         }
 729     }
 730 }
 731
 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 {
 737             0 => {
 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)
 742             },
 743             1 | 2 => {
 744                 if (blk_no & 3) != 0 {
 745                     mbt_a = mbt;
 746                 }
 747                 if blk_no >= 4 {
 748                     mbt_b = mbt;
 749                 }
 750                 let nc_left = sstate.get_left_blk4(blk_no).ncoded;
 751                 let nc_top  = sstate.get_top_blk4(blk_no).ncoded;
 752                 (nc_left != 0,
 753                  nc_top != 0,
 754                  (nc_left != 0) as usize,
 755                  (nc_top != 0) as usize)
 756             },
 757             3 => {
 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)
 762             },
 763             4 => {
 764                 let chroma = blk_no >> 2;
 765                 if (blk_no & 1) != 0 {
 766                     mbt_a = mbt;
 767                 }
 768                 if (blk_no & 2) != 0 {
 769                     mbt_b = mbt;
 770                 }
 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)
 775             },
 776             _ => unreachable!(),
 777         };
 778     /*let coded_no = match cat {
 779             0     => 0,
 780             1 | 2 => blk_no + 1,
 781             3     => 1 + 16 + blk_no,
 782             4     => 1 + 16 + 2 + blk_no,
 783             _ => unreachable!(),
 784         };*/
 785
 786     if mbt_a == CompactMBType::None && mbt.is_inter() {
 787         cond_term_a = 0;
 788     }
 789     if !trans_a && mbt_a != CompactMBType::PCM {
 790         cond_term_a = 0;
 791     }
 792     /*if mbt.is_intra() && pps.constrained_intra_pred && mbt_a.is_inter() && slice_partitioning {
 793         cond_term_a = 0;
 794     }*/
 795     if (mbt_a == CompactMBType::PCM) || (mbt_a == CompactMBType::None && mbt.is_intra()) {
 796         cond_term_a = 1;
 797     }
 798
 799     if mbt_b == CompactMBType::None && mbt.is_inter() {
 800         cond_term_b = 0;
 801     }
 802     if !trans_b && mbt_b != CompactMBType::PCM {
 803         cond_term_b = 0;
 804     }
 805     /*if mbt.is_intra() && pps.constrained_intra_pred && mbt_b.is_inter() && slice_partitioning {
 806         cond_term_b = 0;
 807     }*/
 808     if (mbt_b == CompactMBType::PCM) || (mbt_b == CompactMBType::None && mbt.is_intra()) {
 809         cond_term_b = 1;
 810     }
 811
 812     cat * 4 + cond_term_b * 2 + cond_term_a
 813 }
 814
 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;
 822         if coded {
 823             coded_flags |= 1;
 824         }
 825     }
 826     if !mb_info.transform_size_8x8 {
 827         for blk8 in 0..4 {
 828             if (mb_info.cbpy & (1 << blk8)) != 0 {
 829                 for blk4 in 0..4 {
 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)
 834                         } else {
 835                             let off = derive_ctx_off(sstate, 2, blk_no);
 836                             decode_block(cabac, &mut mb_info.coeffs[blk_no], 2, off)
 837                         };
 838                     sstate.get_cur_blk4(blk_no).ncoded = coded as u8;
 839                     mb_info.coded[blk_no] = coded;
 840                     if coded {
 841                         coded_flags |= 1 << (1 + blk_no);
 842                     }
 843                 }
 844             }
 845         }
 846     } else {
 847         for blk8 in 0..4 {
 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;
 860             }
 861         }
 862     }
 863     for chroma in 0..2 {
 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);
 867             if coded {
 868                 coded_flags |= 1 << (16 + 1 + chroma);
 869             }
 870         }
 871     }
 872     for chroma in 0..2 {
 873         if (mb_info.cbpc & 2) != 0 {
 874             for blk4 in 0..4 {
 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;
 880                 if coded {
 881                     coded_flags |= 1 << (1 + 2 + blk_no);
 882                 }
 883             }
 884         }
 885     }
 886     sstate.get_cur_mb().coded_flags = coded_flags;
 887 }