nihav-rad/src/codecs/binkvid.rs

   1 use std::f32::consts;
   2 use nihav_core::codecs::*;
   3 use nihav_core::io::byteio::*;
   4 use nihav_core::io::bitreader::*;
   5 use nihav_core::io::codebook::*;
   6
   7 const SKIP_BLOCK: u8 = 0;
   8 const SCALED_BLOCK: u8 = 1;
   9 const MOTION_BLOCK: u8 = 2;
  10 const RUN_BLOCK: u8 = 3;
  11 const RESIDUE_BLOCK: u8 = 4;
  12 const INTRA_BLOCK: u8 = 5;
  13 const FILL_BLOCK: u8 = 6;
  14 const INTER_BLOCK: u8 = 7;
  15 const PATTERN_BLOCK: u8 = 8;
  16 const RAW_BLOCK: u8 = 9;
  17
  18 #[derive(Default, Clone,Copy)]
  19 struct Tree {
  20     id:     usize,
  21     syms:   [u8; 16],
  22 }
  23
  24 impl Tree {
  25     fn read_desc(&mut self, br: &mut BitReader) -> DecoderResult<()> {
  26         self.id                                 = br.read(4)? as usize;
  27         if self.id == 0 {
  28             for i in 0..16 { self.syms[i] = i as u8; }
  29         } else {
  30             if br.read_bool()? {
  31                 let len                         = br.read(3)? as usize;
  32                 let mut present: [bool; 16] = [false; 16];
  33                 for i in 0..=len {
  34                     self.syms[i]                = br.read(4)? as u8;
  35                     present[self.syms[i] as usize] = true;
  36                 }
  37                 let mut idx = len + 1;
  38                 for i in 0..16 {
  39                     if present[i] { continue; }
  40                     self.syms[idx] = i as u8;
  41                     idx += 1;
  42                 }
  43             } else {
  44                 let len                         = br.read(2)? as usize;
  45                 let mut syms: [u8; 16] = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  46                 let mut tmp: [u8; 16] = [0; 16];
  47                 for bits in 0..=len {
  48                     let size = 1 << bits;
  49                     for arr in syms.chunks_mut(size * 2) {
  50                         let mut ptr0 = 0;
  51                         let mut ptr1 = size;
  52                         let mut optr = 0;
  53                         while (ptr0 < size) && (ptr1 < size * 2) {
  54                             if !br.read_bool()? {
  55                                 tmp[optr] = arr[ptr0];
  56                                 ptr0 += 1;
  57                             } else {
  58                                 tmp[optr] = arr[ptr1];
  59                                 ptr1 += 1;
  60                             }
  61                             optr += 1;
  62                         }
  63                         while ptr0 < size {
  64                             tmp[optr] = arr[ptr0];
  65                             ptr0 += 1;
  66                             optr += 1;
  67                         }
  68                         while ptr1 < size * 2 {
  69                             tmp[optr] = arr[ptr1];
  70                             ptr1 += 1;
  71                             optr += 1;
  72                         }
  73                         arr.copy_from_slice(&tmp[0..size * 2]);
  74                     }
  75                 }
  76                 self.syms = syms;
  77             }
  78         }
  79         Ok(())
  80     }
  81     fn read_sym(&self, br: &mut BitReader, trees: &BinkTrees) -> DecoderResult<u8> {
  82         let idx                                 = br.read_cb(&trees.cb[self.id])?;
  83         Ok(self.syms[idx as usize])
  84     }
  85 }
  86
  87 #[derive(Default)]
  88 struct Bundle<T: Copy> {
  89     tree:       Tree,
  90     data:       Vec<T>,
  91     dec_pos:    usize,
  92     read_pos:   usize,
  93     bits:       u8,
  94 }
  95
  96 impl<T:Copy> Bundle<T> {
  97     fn binkb_reset(&mut self, bits: u8) {
  98         self.bits       = bits;
  99         self.dec_pos    = 0;
 100         self.read_pos   = 0;
 101     }
 102     fn reset(&mut self) {
 103         self.dec_pos = 0;
 104         self.read_pos = 0;
 105     }
 106     fn read_desc(&mut self, br: &mut BitReader) -> DecoderResult<()> {
 107         self.dec_pos = 0;
 108         self.read_pos = 0;
 109         self.tree.read_desc(br)?;
 110         Ok(())
 111     }
 112     fn read_len(&mut self, br: &mut BitReader) -> DecoderResult<usize> {
 113         if self.read_pos < self.dec_pos { return Ok(0); }
 114         let len                                 = br.read(self.bits)? as usize;
 115         if len == 0 {
 116             self.dec_pos = self.data.len();
 117             self.read_pos = self.data.len() - 1;
 118         }
 119         Ok(len)
 120     }
 121     fn read_len_binkb(&mut self, br: &mut BitReader) -> DecoderResult<usize> {
 122         if self.read_pos < self.dec_pos { return Ok(0); }
 123         let len                                 = br.read(13)? as usize;
 124         if len == 0 {
 125             self.dec_pos = self.data.len();
 126             self.read_pos = self.data.len() - 1;
 127         }
 128 println!("    read {} of {} bits", len, self.bits);
 129         Ok(len)
 130     }
 131     fn get_val(&mut self) -> DecoderResult<T> {
 132         validate!(self.read_pos < self.dec_pos);
 133         let val = self.data[self.read_pos];
 134         self.read_pos += 1;
 135         Ok(val)
 136     }
 137 }
 138
 139 const BLOCK_TYPE_RUNS: [usize; 4] = [ 4, 8, 12, 32 ];
 140 impl Bundle<u8> {
 141     fn read_binkb(&mut self, br: &mut BitReader) -> DecoderResult<()> {
 142         let len = self.read_len_binkb(br)?;
 143         if len == 0 { return Ok(()); }
 144         let end = self.dec_pos + len;
 145         validate!(end <= self.data.len());
 146         for i in 0..len {
 147             self.data[self.dec_pos + i]         = br.read(self.bits)? as u8;
 148         }
 149         self.dec_pos += len;
 150         Ok(())
 151     }
 152     fn read_runs(&mut self, br: &mut BitReader, trees: &BinkTrees) -> DecoderResult<()> {
 153         let len = self.read_len(br)?;
 154         if len == 0 { return Ok(()); }
 155         let end = self.dec_pos + len;
 156         validate!(end <= self.data.len());
 157         if br.read_bool()? {
 158             let val                             = br.read(4)? as u8;
 159             for i in 0..len { self.data[self.dec_pos + i] = val; }
 160             self.dec_pos += len;
 161         } else {
 162             while self.dec_pos < end {
 163                 self.data[self.dec_pos] = self.tree.read_sym(br, trees)?;
 164                 self.dec_pos += 1;
 165             }
 166         }
 167         Ok(())
 168     }
 169     fn read_block_types(&mut self, br: &mut BitReader, trees: &BinkTrees) -> DecoderResult<()> {
 170         let len = self.read_len(br)?;
 171         if len == 0 { return Ok(()); }
 172         let end = self.dec_pos + len;
 173         validate!(end <= self.data.len());
 174         if br.read_bool()? {
 175             let val                             = br.read(4)? as u8;
 176             for i in 0..len { self.data[self.dec_pos + i] = val; }
 177             self.dec_pos += len;
 178         } else {
 179             let mut last = 0;
 180             while self.dec_pos < end {
 181                 let val = self.tree.read_sym(br, trees)?;
 182                 if val < 12 {
 183                     self.data[self.dec_pos] = val;
 184                     self.dec_pos += 1;
 185                     last = val;
 186                 } else {
 187                     let run = BLOCK_TYPE_RUNS[(val - 12) as usize];
 188                     validate!(self.dec_pos + run <= end);
 189                     for i in 0..run {
 190                         self.data[self.dec_pos + i] = last;
 191                     }
 192                     self.dec_pos += run;
 193                 }
 194             }
 195         }
 196         Ok(())
 197     }
 198     fn read_patterns(&mut self, br: &mut BitReader, trees: &BinkTrees) -> DecoderResult<()> {
 199         let len = self.read_len(br)?;
 200         if len == 0 { return Ok(()); }
 201         let end = self.dec_pos + len;
 202         validate!(end <= self.data.len());
 203         for i in 0..len {
 204             let pat_lo = self.tree.read_sym(br, trees)?;
 205             let pat_hi = self.tree.read_sym(br, trees)?;
 206             self.data[self.dec_pos + i] = pat_lo | (pat_hi << 4);
 207         }
 208         self.dec_pos += len;
 209         Ok(())
 210     }
 211     fn cvt_color(lo: u8, hi: u8, new_bink: bool) -> u8 {
 212         let val = lo | (hi << 4);
 213         if !new_bink {
 214             let sign = ((val as i8) >> 7) as u8;
 215             ((val & 0x7F) ^ sign).wrapping_sub(sign) ^ 0x80
 216         } else {
 217             val
 218         }
 219     }
 220     fn read_colors(&mut self, br: &mut BitReader, trees: &BinkTrees, col_hi: &[Tree; 16], col_last: &mut u8, new_bink: bool) -> DecoderResult<()> {
 221         let len = self.read_len(br)?;
 222         if len == 0 { return Ok(()); }
 223         let end = self.dec_pos + len;
 224         validate!(end <= self.data.len());
 225         let mut last = *col_last;
 226         if br.read_bool()? {
 227             last = col_hi[last as usize].read_sym(br, trees)?;
 228             let lo = self.tree.read_sym(br, trees)?;
 229             let val = Self::cvt_color(lo, last, new_bink);
 230             for i in 0..len { self.data[self.dec_pos + i] = val as u8; }
 231             self.dec_pos += len;
 232         } else {
 233             while self.dec_pos < end {
 234                 last = col_hi[last as usize].read_sym(br, trees)?;
 235                 let lo = self.tree.read_sym(br, trees)?;
 236                 let val = Self::cvt_color(lo, last, new_bink);
 237                 self.data[self.dec_pos] = val;
 238                 self.dec_pos += 1;
 239             }
 240         }
 241         *col_last = last;
 242         Ok(())
 243     }
 244 }
 245
 246 impl Bundle<i8> {
 247     fn read_binkb(&mut self, br: &mut BitReader) -> DecoderResult<()> {
 248         let len = self.read_len_binkb(br)?;
 249         if len == 0 { return Ok(()); }
 250         let end = self.dec_pos + len;
 251         validate!(end <= self.data.len());
 252         let bias = 1 << (self.bits - 1);
 253         for i in 0..len {
 254             self.data[self.dec_pos + i]         = (br.read(self.bits)? as i8) - bias;
 255         }
 256         self.dec_pos += len;
 257         Ok(())
 258     }
 259     fn read_motion_values(&mut self, br: &mut BitReader, trees: &BinkTrees) -> DecoderResult<()> {
 260         let len = self.read_len(br)?;
 261         if len == 0 { return Ok(()); }
 262         let end = self.dec_pos + len;
 263         validate!(end <= self.data.len());
 264         if br.read_bool()? {
 265             let mut val                         = br.read(4)? as i8;
 266             if val != 0 && br.read_bool()? { val = -val; }
 267             for i in 0..len { self.data[self.dec_pos + i] = val; }
 268             self.dec_pos += len;
 269         } else {
 270             while self.dec_pos < end {
 271                 self.data[self.dec_pos] = self.tree.read_sym(br, trees)? as i8;
 272                 if self.data[self.dec_pos] != 0 && br.read_bool()? {
 273                     self.data[self.dec_pos] = -self.data[self.dec_pos];
 274                 }
 275                 self.dec_pos += 1;
 276             }
 277         }
 278         Ok(())
 279     }
 280 }
 281
 282 const DC_START_BITS: u8 = 11;
 283 impl Bundle<u16> {
 284     fn read_binkb(&mut self, br: &mut BitReader) -> DecoderResult<()> {
 285         let len = self.read_len_binkb(br)?;
 286         if len == 0 { return Ok(()); }
 287         let end = self.dec_pos + len;
 288         validate!(end <= self.data.len());
 289         for i in 0..len {
 290             self.data[self.dec_pos + i]         = br.read(self.bits)? as u16;
 291         }
 292         self.dec_pos += len;
 293         Ok(())
 294     }
 295     fn read_dcs(&mut self, br: &mut BitReader, start_bits: u8) -> DecoderResult<()> {
 296         let len = self.read_len(br)?;
 297         if len == 0 { return Ok(()); }
 298         let end = self.dec_pos + len;
 299         validate!(end <= self.data.len());
 300         let mut val                             = br.read(start_bits)? as u16;
 301         self.data[self.dec_pos] = val;
 302         self.dec_pos += 1;
 303         for i in (1..len).step_by(8) {
 304             let seg_len = (len - i).min(8);
 305             let bits                            = br.read(4)? as u8;
 306             if bits != 0 {
 307                 for _ in 0..seg_len {
 308                     let diff                    = br.read(bits)? as u16;
 309                     let res = if diff != 0 && br.read_bool()? {
 310                             val.checked_sub(diff)
 311                         } else {
 312                             val.checked_add(diff)
 313                         };
 314                     validate!(res.is_some());
 315                     val = res.unwrap();
 316                     self.data[self.dec_pos] = val;
 317                     self.dec_pos += 1;
 318                 }
 319             } else {
 320                 for _ in 0..seg_len {
 321                     self.data[self.dec_pos] = val;
 322                     self.dec_pos += 1;
 323                 }
 324             }
 325         }
 326         Ok(())
 327     }
 328 }
 329
 330 impl Bundle<i16> {
 331     fn read_binkb(&mut self, br: &mut BitReader) -> DecoderResult<()> {
 332         let len = self.read_len_binkb(br)?;
 333         if len == 0 { return Ok(()); }
 334         let end = self.dec_pos + len;
 335         validate!(end <= self.data.len());
 336         let bias = 1 << (self.bits - 1);
 337         for i in 0..len {
 338             self.data[self.dec_pos + i]         = (br.read(self.bits)? as i16) - bias;
 339         }
 340         self.dec_pos += len;
 341         Ok(())
 342     }
 343     fn read_dcs(&mut self, br: &mut BitReader, start_bits: u8) -> DecoderResult<()> {
 344         let len = self.read_len(br)?;
 345         if len == 0 { return Ok(()); }
 346         let end = self.dec_pos + len;
 347         validate!(end <= self.data.len());
 348         let mut val                             = br.read(start_bits - 1)? as i16;
 349         if val != 0 && br.read_bool()? {
 350             val = -val;
 351         }
 352         self.data[self.dec_pos] = val;
 353         self.dec_pos += 1;
 354         for i in (1..len).step_by(8) {
 355             let seg_len = (len - i).min(8);
 356             let bits                            = br.read(4)? as u8;
 357             if bits != 0 {
 358                 for _ in 0..seg_len {
 359                     let mut diff                = br.read(bits)? as i16;
 360                     if diff != 0 && br.read_bool()? {
 361                         diff = -diff;
 362                     }
 363                     let res = val.checked_add(diff);
 364                     validate!(res.is_some());
 365                     val = res.unwrap();
 366                     self.data[self.dec_pos] = val;
 367                     self.dec_pos += 1;
 368                 }
 369             } else {
 370                 for _ in 0..seg_len {
 371                     self.data[self.dec_pos] = val;
 372                     self.dec_pos += 1;
 373                 }
 374             }
 375         }
 376         Ok(())
 377     }
 378 }
 379
 380 struct BinkTrees {
 381     cb:         [Codebook<u8>; 16],
 382 }
 383
 384 fn map_u8(idx: usize) -> u8 { idx as u8 }
 385
 386 impl Default for BinkTrees {
 387     fn default() -> Self {
 388         let mut cb: [Codebook<u8>; 16];
 389         unsafe {
 390             cb = std::mem::uninitialized();
 391             for i in 0..16 {
 392                 let mut cr = TableCodebookDescReader::new(&BINK_TREE_CODES[i], &BINK_TREE_BITS[i], map_u8);
 393                 std::ptr::write(&mut cb[i], Codebook::new(&mut cr, CodebookMode::LSB).unwrap());
 394             }
 395         }
 396         Self { cb }
 397     }
 398 }
 399
 400 const A1: i32 =  2896;
 401 const A2: i32 =  2217;
 402 const A3: i32 =  3784;
 403 const A4: i32 = -5352;
 404
 405 macro_rules! idct {
 406     ($src: expr, $sstep: expr, $dst: expr, $dstep: expr, $off: expr, $bias: expr, $shift: expr) => {
 407         let a0 = $src[$off + 0 * $sstep] + $src[$off + 4 * $sstep];
 408         let a1 = $src[$off + 0 * $sstep] - $src[$off + 4 * $sstep];
 409         let a2 = $src[$off + 2 * $sstep] + $src[$off + 6 * $sstep];
 410         let a3 = A1.wrapping_mul($src[$off + 2 * $sstep] - $src[$off + 6 * $sstep]) >> 11;
 411         let a4 = $src[$off + 5 * $sstep] + $src[$off + 3 * $sstep];
 412         let a5 = $src[$off + 5 * $sstep] - $src[$off + 3 * $sstep];
 413         let a6 = $src[$off + 1 * $sstep] + $src[$off + 7 * $sstep];
 414         let a7 = $src[$off + 1 * $sstep] - $src[$off + 7 * $sstep];
 415         let b0 = a4 + a6;
 416         let b1 = A3.wrapping_mul(a5 + a7) >> 11;
 417         let b2 = (A4.wrapping_mul(a5) >> 11) - b0 + b1;
 418         let b3 = (A1.wrapping_mul(a6 - a4) >> 11) - b2;
 419         let b4 = (A2.wrapping_mul(a7) >> 11) + b3 - b1;
 420         let c0 = a0 + a2;
 421         let c1 = a0 - a2;
 422         let c2 = a1 + (a3 - a2);
 423         let c3 = a1 - (a3 - a2);
 424
 425         $dst[$off + 0 * $dstep] = (c0 + b0 + $bias) >> $shift;
 426         $dst[$off + 1 * $dstep] = (c2 + b2 + $bias) >> $shift;
 427         $dst[$off + 2 * $dstep] = (c3 + b3 + $bias) >> $shift;
 428         $dst[$off + 3 * $dstep] = (c1 - b4 + $bias) >> $shift;
 429         $dst[$off + 4 * $dstep] = (c1 + b4 + $bias) >> $shift;
 430         $dst[$off + 5 * $dstep] = (c3 - b3 + $bias) >> $shift;
 431         $dst[$off + 6 * $dstep] = (c2 - b2 + $bias) >> $shift;
 432         $dst[$off + 7 * $dstep] = (c0 - b0 + $bias) >> $shift;
 433     };
 434 }
 435
 436 struct QuantMats {
 437     intra_qmat: [[i32; 64]; 16],
 438     inter_qmat: [[i32; 64]; 16],
 439 }
 440
 441 impl QuantMats {
 442     fn calc_binkb_quants(&mut self) {
 443         let mut inv_scan: [usize; 64] = [0; 64];
 444         let mut mod_mat: [f32; 64] = [0.0; 64];
 445         let base = consts::PI / 16.0;
 446
 447         for i in 0..64 { inv_scan[BINK_SCAN[i]] = i; }
 448
 449         for j in 0..8 {
 450             let j_scale = if (j != 0) && (j != 4) { (base * (j as f32)).cos() * consts::SQRT_2 } else { 1.0 };
 451             for i in 0..8 {
 452                 let i_scale = if (i != 0) && (i != 4) { (base * (i as f32)).cos() * consts::SQRT_2 } else { 1.0 };
 453                 mod_mat[i + j * 8] = i_scale * j_scale;
 454             }
 455         }
 456
 457         for q in 0..16 {
 458             let (num, den) = BINKB_REF_QUANTS[q];
 459             let quant = (num as f32) * ((1 << 12) as f32) / (den as f32);
 460             for c in 0..64 {
 461                 let idx = inv_scan[c];
 462                 self.intra_qmat[q][idx] = ((BINKB_REF_INTRA_Q[c] as f32) * mod_mat[c] * quant) as i32;
 463                 self.inter_qmat[q][idx] = ((BINKB_REF_INTER_Q[c] as f32) * mod_mat[c] * quant) as i32;
 464             }
 465         }
 466     }
 467 }
 468
 469 impl Default for QuantMats {
 470     fn default() -> Self {
 471         Self { intra_qmat: [[0; 64]; 16], inter_qmat: [[0; 64]; 16] }
 472     }
 473 }
 474
 475 #[derive(Default)]
 476 struct BinkDecoder {
 477     info:       NACodecInfoRef,
 478     ips:        IPShuffler,
 479     hams:       HAMShuffler,
 480
 481     is_ver_b:   bool,
 482     is_ver_i:   bool,
 483     has_alpha:  bool,
 484     is_gray:    bool,
 485     swap_uv:    bool,
 486     key_frame:  bool,
 487
 488     cur_w:      usize,
 489     cur_h:      usize,
 490     cur_plane:  usize,
 491
 492     colhi_tree: [Tree; 16],
 493     col_last:   u8,
 494
 495     btype:      Bundle<u8>,
 496     sbtype:     Bundle<u8>,
 497     colors:     Bundle<u8>,
 498     pattern:    Bundle<u8>,
 499     xoff:       Bundle<i8>,
 500     yoff:       Bundle<i8>,
 501     intradc:    Bundle<u16>,
 502     interdc:    Bundle<i16>,
 503     intraq:     Bundle<u8>,
 504     interq:     Bundle<u8>,
 505     nresidues:  Bundle<u8>,
 506     run:        Bundle<u8>,
 507
 508     trees:      BinkTrees,
 509
 510     qmat_b:     QuantMats,
 511 }
 512
 513 fn calc_len(size: usize) -> u8 {
 514     (32 - ((size + 511) as u32).leading_zeros()) as u8
 515 }
 516
 517 impl BinkDecoder {
 518     fn new() -> Self {
 519         Self::default()
 520     }
 521     fn init_bundle_bufs(&mut self, bw: usize, bh: usize) {
 522         let size = bw * bh * 64;
 523         self.btype.data.resize(size, 0);
 524         self.sbtype.data.resize(size, 0);
 525         self.colors.data.resize(size, 0);
 526         self.pattern.data.resize(size, 0);
 527         self.xoff.data.resize(size, 0);
 528         self.yoff.data.resize(size, 0);
 529         self.intradc.data.resize(size, 0);
 530         self.interdc.data.resize(size, 0);
 531         self.intraq.data.resize(size, 0);
 532         self.interq.data.resize(size, 0);
 533         self.nresidues.data.resize(size, 0);
 534         self.run.data.resize(size, 0);
 535     }
 536     fn init_bundle_lengths(&mut self, w: usize, bw: usize) {
 537         self.btype.bits     = calc_len(w >> 3);
 538         self.sbtype.bits    = calc_len(w >> 4);
 539         self.colors.bits    = calc_len(bw * 64);
 540         self.pattern.bits   = calc_len(bw * 8);
 541         self.xoff.bits      = calc_len(w >> 3);
 542         self.yoff.bits      = calc_len(w >> 3);
 543         self.intradc.bits   = calc_len(w >> 3);
 544         self.interdc.bits   = calc_len(w >> 3);
 545         self.run.bits       = calc_len(bw * 48);
 546     }
 547     fn init_bundle_lengths_binkb(&mut self) {
 548         self.btype.binkb_reset(4);
 549         self.colors.binkb_reset(8);
 550         self.pattern.binkb_reset(8);
 551         self.xoff.binkb_reset(5);
 552         self.yoff.binkb_reset(5);
 553         self.intradc.binkb_reset(11);
 554         self.interdc.binkb_reset(11);
 555         self.intraq.binkb_reset(4);
 556         self.interq.binkb_reset(4);
 557         self.nresidues.binkb_reset(7);
 558     }
 559     fn read_bundles_desc(&mut self, br: &mut BitReader) -> DecoderResult<()> {
 560         self.btype.read_desc(br)?;
 561         self.sbtype.read_desc(br)?;
 562         for el in &mut self.colhi_tree {
 563             el.read_desc(br)?;
 564         }
 565         self.col_last = 0;
 566         self.colors.read_desc(br)?;
 567         self.pattern.read_desc(br)?;
 568         self.xoff.read_desc(br)?;
 569         self.yoff.read_desc(br)?;
 570         self.intradc.reset();
 571         self.interdc.reset();
 572         self.run.read_desc(br)?;
 573         Ok(())
 574     }
 575     fn read_bundles_binkb(&mut self, br: &mut BitReader) -> DecoderResult<()> {
 576         self.btype.read_binkb(br)?;
 577 println!("   @ {}", br.tell());
 578         self.colors.read_binkb(br)?;
 579 println!("   @ {}", br.tell());
 580         self.pattern.read_binkb(br)?;
 581 println!("   @ {}", br.tell());
 582         self.xoff.read_binkb(br)?;
 583 println!("   @ {}", br.tell());
 584         self.yoff.read_binkb(br)?;
 585 println!("   @ {}", br.tell());
 586         self.intradc.read_binkb(br)?;
 587 println!("   @ {}", br.tell());
 588         self.interdc.read_binkb(br)?;
 589 println!("   @ {}", br.tell());
 590         self.intraq.read_binkb(br)?;
 591 println!("   @ {}", br.tell());
 592         self.interq.read_binkb(br)?;
 593 println!("   @ {}", br.tell());
 594         self.nresidues.read_binkb(br)?;
 595 println!("   @ {}", br.tell());
 596         Ok(())
 597     }
 598     fn read_bundles(&mut self, br: &mut BitReader) -> DecoderResult<()> {
 599         self.btype.read_block_types(br, &self.trees)?;
 600         self.sbtype.read_block_types(br, &self.trees)?;
 601         self.colors.read_colors(br, &self.trees, &self.colhi_tree, &mut self.col_last, self.is_ver_i)?;
 602         self.pattern.read_patterns(br, &self.trees)?;
 603         self.xoff.read_motion_values(br, &self.trees)?;
 604         self.yoff.read_motion_values(br, &self.trees)?;
 605         self.intradc.read_dcs(br, DC_START_BITS)?;
 606         self.interdc.read_dcs(br, DC_START_BITS)?;
 607         self.run.read_runs(br, &self.trees)?;
 608         Ok(())
 609     }
 610
 611     fn put_block(&self, block: &[u8; 64], dst: &mut [u8], mut off: usize, stride: usize, scaled: bool) {
 612         if !scaled {
 613             for src in block.chunks_exact(8) {
 614                 let out = &mut dst[off..][..8];
 615                 out.copy_from_slice(src);
 616                 off += stride;
 617             }
 618         } else {
 619             for src in block.chunks_exact(8) {
 620                 for i in 0..8 {
 621                     dst[off + i * 2 + 0] = src[i];
 622                     dst[off + i * 2 + 1] = src[i];
 623                 }
 624                 off += stride;
 625                 for i in 0..8 {
 626                     dst[off + i * 2 + 0] = src[i];
 627                     dst[off + i * 2 + 1] = src[i];
 628                 }
 629                 off += stride;
 630             }
 631         }
 632     }
 633     fn copy_block(&mut self, dst: &mut [u8], mut off: usize, stride: usize, bx: usize, by: usize, xoff: i8, yoff: i8) -> DecoderResult<()> {
 634         if let Some(prev_buf) = self.ips.get_ref() {
 635             let xoff = ((bx * 8) as isize) + (xoff as isize);
 636             let yoff = ((by * 8) as isize) + (yoff as isize);
 637             validate!((xoff >= 0) && (xoff + 8 <= (self.cur_w as isize)));
 638             validate!((yoff >= 0) && (yoff + 8 <= (self.cur_h as isize)));
 639             let pstride = prev_buf.get_stride(self.cur_plane);
 640             let mut poff = prev_buf.get_offset(self.cur_plane) + (xoff as usize) + (yoff as usize) * pstride;
 641             let pdata = prev_buf.get_data();
 642             let ppix = pdata.as_slice();
 643             for _ in 0..8 {
 644                 let src = &ppix[poff..][..8];
 645                 let out = &mut dst[off..][..8];
 646                 out.copy_from_slice(src);
 647                 off += stride;
 648                 poff += pstride;
 649             }
 650             Ok(())
 651         } else {
 652             Err(DecoderError::MissingReference)
 653         }
 654     }
 655     fn copy_overlapped(&mut self, dst: &mut [u8], mut off: usize, stride: usize, bx: usize, by: usize, xoff: i8, yoff1: i8) -> DecoderResult<()> {
 656         let ybias = if self.key_frame { -15 } else { 0 };
 657         let yoff = yoff1 + ybias;
 658
 659 println!("     copy from {}.{} + {},{}({})", bx*8, by*8, xoff, yoff, ybias);
 660         let xpos = ((bx * 8) as isize) + (xoff as isize);
 661         let ypos = ((by * 8) as isize) + (yoff as isize);
 662         validate!((xpos >= 0) && (xpos + 8 <= (self.cur_w as isize)));
 663         validate!((ypos >= 0) && (ypos + 8 <= (self.cur_h as isize)));
 664
 665         let mut block: [u8; 64] = [0; 64];
 666         let mut ref_off = ((off as isize) + (xoff as isize) + (yoff as isize) * (stride as isize)) as usize;
 667         for row in block.chunks_exact_mut(8) {
 668             row.copy_from_slice(&dst[ref_off..][..8]);
 669             ref_off += stride;
 670         }
 671         for row in block.chunks_exact(8) {
 672             let out = &mut dst[off..][..8];
 673             out.copy_from_slice(row);
 674             off += stride;
 675         }
 676
 677         Ok(())
 678     }
 679     fn add_block(&self, coeffs: &[i32; 64], dst: &mut [u8], mut off: usize, stride: usize) {
 680         for src in coeffs.chunks_exact(8) {
 681             for i in 0..8 {
 682                 let v = (dst[off + i] as i32) + src[i];
 683                 dst[off + i] = v as u8;
 684             }
 685             off += stride;
 686         }
 687     }
 688     fn idct_put(&self, coeffs: &[i32; 64], dst: &mut [u8], mut off: usize, stride: usize) {
 689         let mut tmp: [i32; 64] = [0; 64];
 690         let mut row: [i32; 8] = [0; 8];
 691         for i in 0..8 {
 692             idct!(coeffs, 8, tmp, 8, i, 0, 0);
 693         }
 694         for srow in tmp.chunks_exact(8) {
 695             idct!(srow, 1, row, 1, 0, 0x7F, 8);
 696             for i in 0..8 {
 697                 dst[off + i] = row[i] as u8;
 698             }
 699             off += stride;
 700         }
 701     }
 702     fn idct_add(&self, coeffs: &[i32; 64], dst: &mut [u8], mut off: usize, stride: usize) {
 703         let mut tmp: [i32; 64] = [0; 64];
 704         let mut row: [i32; 8] = [0; 8];
 705         for i in 0..8 {
 706             idct!(coeffs, 8, tmp, 8, i, 0, 0);
 707         }
 708         for srow in tmp.chunks_exact(8) {
 709             idct!(srow, 1, row, 1, 0, 0x7F, 8);
 710             for i in 0..8 {
 711                 let v = (dst[off + i] as i32) + row[i];
 712                 dst[off + i] = v as u8;
 713             }
 714             off += stride;
 715         }
 716     }
 717
 718     fn decode_plane_binkb(&mut self, br: &mut BitReader, plane_no: usize, buf: &mut NAVideoBuffer<u8>) -> DecoderResult<()> {
 719         let stride = buf.get_stride(plane_no);
 720         let mut off = buf.get_offset(plane_no);
 721         let (width, height) = buf.get_dimensions(plane_no);
 722         let data = buf.get_data_mut().unwrap();
 723         let dst = data.as_mut_slice();
 724         let bw = (width  + 7) >> 3;
 725         let bh = (height + 7) >> 3;
 726         self.cur_w = (width + 7) & !7;
 727         self.cur_h = (height + 7) & !7;
 728         self.cur_plane = plane_no;
 729         self.init_bundle_lengths_binkb();
 730 println!(" plane {}", plane_no);
 731         for by in 0..bh {
 732             self.read_bundles_binkb(br)?;
 733 println!("  bline {} @ {}", by, br.tell());
 734             for bx in 0..bw {
 735                 let mut coeffs: [i32; 64] = [0; 64];
 736                 let btype = self.btype.get_val()?;
 737 println!("  blk {}.{} type {}", bx,by,btype);
 738                 match btype {
 739                     0 => { // skip
 740                         },
 741                     1 => { // run
 742                             let scan = BINK_PATTERNS[br.read(4)? as usize];
 743                             let mut idx = 0;
 744                             while idx < 63 {
 745                                 let run         = br.read_bool()?;
 746                                 let len         = (br.read(BINKB_RUN_BITS[idx])? as usize) + 1;
 747                                 validate!(idx + len <= 64);
 748                                 if run {
 749                                     let val = self.colors.get_val()?;
 750                                     for j in 0..len {
 751                                         let pos = scan[idx + j] as usize;
 752                                         dst[off + (pos >> 3) * stride + (pos & 7)] = val;
 753                                     }
 754                                     idx += len;
 755                                 } else {
 756                                     for _ in 0..len {
 757                                         let pos = scan[idx] as usize;
 758                                         dst[off + (pos >> 3) * stride + (pos & 7)] = self.colors.get_val()?;
 759                                         idx += 1;
 760                                     }
 761                                 }
 762                             }
 763                             if idx == 63 {
 764                                 let pos = scan[idx] as usize;
 765                                 dst[off + (pos >> 3) * stride + (pos & 7)] = self.colors.get_val()?;
 766                             }
 767                         },
 768                     2 => { // intra
 769                             coeffs[0] = self.intradc.get_val()? as i32;
 770                             let q = self.intraq.get_val()? as usize;
 771                             read_dct_coefficients(br, &mut coeffs, &BINK_SCAN, &self.qmat_b.intra_qmat, Some(q))?;
 772                             self.idct_put(&coeffs, dst, off, stride);
 773                         },
 774                     3 => { // residue
 775                             let xoff = self.xoff.get_val()?;
 776                             let yoff = self.yoff.get_val()?;
 777                             self.copy_overlapped(dst, off, stride, bx, by, xoff, yoff)?;
 778                             let nmasks = self.nresidues.get_val()? as usize;
 779                             read_residue(br, &mut coeffs, nmasks)?;
 780                             self.add_block(&coeffs, dst, off, stride);
 781                         },
 782                     4 => { // inter
 783                             let xoff = self.xoff.get_val()?;
 784                             let yoff = self.yoff.get_val()?;
 785                             self.copy_overlapped(dst, off, stride, bx, by, xoff, yoff)?;
 786                             coeffs[0] = self.interdc.get_val()? as i32;
 787                             let q = self.interq.get_val()? as usize;
 788                             read_dct_coefficients(br, &mut coeffs, &BINK_SCAN, &self.qmat_b.inter_qmat, Some(q))?;
 789                             self.idct_add(&coeffs, dst, off, stride);
 790                         },
 791                     5 => { // fill
 792                             let fill = self.colors.get_val()?;
 793                             for i in 0..8 {
 794                                 for j in 0..8 { dst[off + i * stride + j] = fill; }
 795                             }
 796                         },
 797                     6 => { // pattern
 798                             let clr: [u8; 2] = [ self.colors.get_val()?, self.colors.get_val()? ];
 799                             for i in 0..8 {
 800                                 let pattern = self.pattern.get_val()? as usize;
 801                                 for j in 0..8 {
 802                                     dst[off + i * stride + j] = clr[(pattern >> j) & 1];
 803                                 }
 804                             }
 805                         },
 806                     7 => { // motion block
 807                             let xoff = self.xoff.get_val()?;
 808                             let yoff = self.yoff.get_val()?;
 809                             self.copy_overlapped(dst, off, stride, bx, by, xoff, yoff)?;
 810                         },
 811                     8 => { // raw
 812                             for i in 0..8 {
 813                                 for j in 0..8 {
 814                                     dst[off + i * stride + j] = self.colors.get_val()?;
 815                                 }
 816                             }
 817                         },
 818                     _ => { return Err(DecoderError::InvalidData); },
 819                 };
 820                 off += 8;
 821             }
 822             off += stride * 8 - bw * 8;
 823         }
 824         if (br.tell() & 0x1F) != 0 {
 825             let skip = (32 - (br.tell() & 0x1F)) as u32;
 826             br.skip(skip)?;
 827         }
 828         Ok(())
 829     }
 830     fn handle_block(&mut self, br: &mut BitReader, bx: usize, by: usize,
 831                     dst: &mut [u8], off: usize, stride: usize, btype: u8, scaled: bool) -> DecoderResult<()> {
 832         let mut oblock: [u8; 64] = [0; 64];
 833         let mut coeffs: [i32; 64] = [0; 64];
 834         match btype {
 835             SKIP_BLOCK => {
 836                     validate!(!scaled);
 837                     self.copy_block(dst, off, stride, bx, by, 0, 0)?;
 838                 },
 839             SCALED_BLOCK => {
 840                     validate!(!scaled);
 841                     let sbtype = self.sbtype.get_val()?;
 842                     self.handle_block(br, bx, by, dst, off, stride, sbtype, true)?;
 843                 },
 844             MOTION_BLOCK => {
 845                     validate!(!scaled);
 846                     let xoff = self.xoff.get_val()?;
 847                     let yoff = self.yoff.get_val()?;
 848                     self.copy_block(dst, off, stride, bx, by, xoff, yoff)?;
 849                 },
 850             RUN_BLOCK => {
 851                     let scan = BINK_PATTERNS[br.read(4)? as usize];
 852                     let mut idx = 0;
 853                     while idx < 63 {
 854                         let run = (self.run.get_val()? as usize) + 1;
 855                         validate!(idx + run <= 64);
 856                         if br.read_bool()? {
 857                             let val = self.colors.get_val()?;
 858                             for j in 0..run {
 859                                 oblock[scan[idx + j] as usize] = val;
 860                             }
 861                             idx += run;
 862                         } else {
 863                             for _ in 0..run {
 864                                 oblock[scan[idx] as usize] = self.colors.get_val()?;
 865                                 idx += 1;
 866                             }
 867                         }
 868                     }
 869                     if idx == 63 { oblock[scan[63] as usize] = self.colors.get_val()?; }
 870                     self.put_block(&oblock, dst, off, stride, scaled);
 871                 },
 872             RESIDUE_BLOCK => {
 873                     validate!(!scaled);
 874                     let xoff = self.xoff.get_val()?;
 875                     let yoff = self.yoff.get_val()?;
 876                     self.copy_block(dst, off, stride, bx, by, xoff, yoff)?;
 877                     let nmasks                  = br.read(7)? as usize;
 878                     read_residue(br, &mut coeffs, nmasks)?;
 879                     self.add_block(&coeffs, dst, off, stride);
 880                 },
 881             INTRA_BLOCK => {
 882                     coeffs[0] = self.intradc.get_val()? as i32;
 883                     read_dct_coefficients(br, &mut coeffs, &BINK_SCAN, BINK_INTRA_QUANT, None)?;
 884                     if !scaled {
 885                         self.idct_put(&coeffs, dst, off, stride);
 886                     } else {
 887                         self.idct_put(&coeffs, &mut oblock, 0, 8);
 888                         self.put_block(&oblock, dst, off, stride, scaled);
 889                     }
 890                 },
 891             FILL_BLOCK => {
 892                     let fill = self.colors.get_val()?;
 893                     oblock = [fill; 64];
 894                     self.put_block(&oblock, dst, off, stride, scaled);
 895                 },
 896             INTER_BLOCK => {
 897                     validate!(!scaled);
 898                     let xoff = self.xoff.get_val()?;
 899                     let yoff = self.yoff.get_val()?;
 900                     self.copy_block(dst, off, stride, bx, by, xoff, yoff)?;
 901                     coeffs[0] = self.interdc.get_val()? as i32;
 902                     read_dct_coefficients(br, &mut coeffs, &BINK_SCAN, BINK_INTER_QUANT, None)?;
 903                     self.idct_add(&coeffs, dst, off, stride);
 904                 },
 905             PATTERN_BLOCK => {
 906                     let clr: [u8; 2] = [ self.colors.get_val()?, self.colors.get_val()? ];
 907                     for i in 0..8 {
 908                         let pattern = self.pattern.get_val()? as usize;
 909                         for j in 0..8 {
 910                             oblock[i * 8 + j] = clr[(pattern >> j) & 1];
 911                         }
 912                     }
 913                     self.put_block(&oblock, dst, off, stride, scaled);
 914                 },
 915             RAW_BLOCK => {
 916                     for i in 0..8 {
 917                         for j in 0..8 {
 918                             oblock[i * 8 + j] = self.colors.get_val()?;
 919                         }
 920                     }
 921                     self.put_block(&oblock, dst, off, stride, scaled);
 922                 },
 923             _ => { return Err(DecoderError::InvalidData); },
 924         };
 925         Ok(())
 926     }
 927     fn decode_plane(&mut self, br: &mut BitReader, plane_no: usize, buf: &mut NAVideoBuffer<u8>) -> DecoderResult<()> {
 928         let stride = buf.get_stride(plane_no);
 929         let mut off = buf.get_offset(plane_no);
 930         let (width, height) = buf.get_dimensions(plane_no);
 931         let data = buf.get_data_mut().unwrap();
 932         let dst = data.as_mut_slice();
 933         let bw = (width  + 7) >> 3;
 934         let bh = (height + 7) >> 3;
 935         self.cur_w = (width + 7) & !7;
 936         self.cur_h = (height + 7) & !7;
 937         self.cur_plane = plane_no;
 938         self.init_bundle_lengths(width.max(8), bw);
 939         self.read_bundles_desc(br)?;
 940         for by in 0..bh {
 941             self.read_bundles(br)?;
 942             let mut bx = 0;
 943             while bx < bw {
 944                 let btype = self.btype.get_val()?;
 945                 if btype == SCALED_BLOCK && (by & 1) == 1 { // already decoded scaled block, skip
 946                     bx += 2;
 947                     continue;
 948                 }
 949                 self.handle_block(br, bx, by, dst, off + bx * 8, stride, btype, false)?;
 950                 if btype == SCALED_BLOCK {
 951                     bx += 1;
 952                 }
 953                 bx += 1;
 954             }
 955             off += stride * 8;
 956         }
 957         if (br.tell() & 0x1F) != 0 {
 958             let skip = (32 - (br.tell() & 0x1F)) as u32;
 959             br.skip(skip)?;
 960         }
 961         Ok(())
 962     }
 963 }
 964
 965 fn get_coef(br: &mut BitReader, bits1: u8) -> DecoderResult<i32> {
 966     let t;
 967     if bits1 == 1 {
 968         t = if br.read_bool()? { -1 } else { 1 };
 969     } else {
 970         let bits = bits1 - 1;
 971         let val             = (br.read(bits)? as i32) | (1 << bits);
 972         if br.read_bool()? {
 973             t = -val;
 974         } else {
 975             t = val;
 976         }
 977     }
 978     Ok(t)
 979 }
 980
 981 fn read_dct_coefficients(br: &mut BitReader, block: &mut [i32; 64], scan: &[usize; 64],
 982                          quant_matrices: &[[i32; 64]; 16], q: Option<usize>) -> DecoderResult<()> {
 983     let mut coef_list: [i32; 128] = [0; 128];
 984     let mut mode_list: [u8; 128] = [0; 128];
 985     let mut list_start = 64;
 986     let mut list_end   = 64;
 987     let mut coef_idx: [usize; 64] = [0; 64];
 988     let mut coef_count = 0;
 989
 990     coef_list[list_end] =  4;   mode_list[list_end] = 0;    list_end += 1;
 991     coef_list[list_end] = 24;   mode_list[list_end] = 0;    list_end += 1;
 992     coef_list[list_end] = 44;   mode_list[list_end] = 0;    list_end += 1;
 993     coef_list[list_end] =  1;   mode_list[list_end] = 3;    list_end += 1;
 994     coef_list[list_end] =  2;   mode_list[list_end] = 3;    list_end += 1;
 995     coef_list[list_end] =  3;   mode_list[list_end] = 3;    list_end += 1;
 996
 997     let mut bits1                               = br.read(4)? as u8;
 998     while bits1 >= 1 {
 999         let mut list_pos = list_start;
1000         while list_pos < list_end {
1001             let ccoef = coef_list[list_pos];
1002             let mode  = mode_list[list_pos];
1003             if (mode == 0 && ccoef == 0) || !br.read_bool()? {
1004                 list_pos += 1;
1005                 continue;
1006             }
1007             match mode {
1008                 0 | 2 => {
1009                         if mode == 0 {
1010                             coef_list[list_pos] = ccoef + 4;
1011                             mode_list[list_pos] = 1;
1012                         } else {
1013                             coef_list[list_pos] = 0;
1014                             mode_list[list_pos] = 0;
1015                             list_pos += 1;
1016                         }
1017                         for i in 0..4 {
1018                             if br.read_bool()? {
1019                                 list_start -= 1;
1020                                 coef_list[list_start] = ccoef + i;
1021                                 mode_list[list_start] = 3;
1022                             } else {
1023                                 let idx = (ccoef + i) as usize;
1024                                 block[scan[idx]] = get_coef(br, bits1)?;
1025                                 coef_idx[coef_count] = idx;
1026                                 coef_count += 1;
1027                             }
1028                         }
1029                     },
1030                 1 => {
1031                         mode_list[list_pos] = 2;
1032                         for i in 0..3 {
1033                             coef_list[list_end] = ccoef + i * 4 + 4;
1034                             mode_list[list_end] = 2;
1035                             list_end += 1;
1036                         }
1037                     },
1038                 3 => {
1039                         let idx = ccoef as usize;
1040                         block[scan[idx]] = get_coef(br, bits1)?;
1041                         coef_idx[coef_count] = idx;
1042                         coef_count += 1;
1043                         coef_list[list_pos] = 0;
1044                         mode_list[list_pos] = 0;
1045                         list_pos += 1;
1046                     },
1047                 _ => unreachable!(),
1048             };
1049         }
1050         bits1 -= 1;
1051     }
1052
1053     let q_index = if let Some(qidx) = q { qidx } else { br.read(4)? as usize };
1054     let qmat = &quant_matrices[q_index];
1055     block[0] = block[0].wrapping_mul(qmat[0]) >> 11;
1056     for idx in coef_idx.iter().take(coef_count) {
1057         block[scan[*idx]] = block[scan[*idx]].wrapping_mul(qmat[*idx]) >> 11;
1058     }
1059
1060     Ok(())
1061 }
1062
1063 fn read_residue(br: &mut BitReader, block: &mut [i32; 64], mut masks_count: usize) -> DecoderResult<()> {
1064     let mut coef_list: [i32; 128] = [0; 128];
1065     let mut mode_list: [u8; 128] = [0; 128];
1066     let mut list_start = 64;
1067     let mut list_end   = 64;
1068     let mut nz_coef_idx: [usize; 64] = [0; 64];
1069     let mut nz_coef_count = 0;
1070
1071     coef_list[list_end] =  4;   mode_list[list_end] = 0;    list_end += 1;
1072     coef_list[list_end] = 24;   mode_list[list_end] = 0;    list_end += 1;
1073     coef_list[list_end] = 44;   mode_list[list_end] = 0;    list_end += 1;
1074     coef_list[list_end] =  0;   mode_list[list_end] = 2;    list_end += 1;
1075
1076     let mut mask                                = 1 << br.read(3)?;
1077     while mask > 0 {
1078         for i in 0..nz_coef_count {
1079             if !br.read_bool()? { continue; }
1080             let idx = nz_coef_idx[i];
1081             if block[idx] < 0 {
1082                 block[idx] -= mask;
1083             } else {
1084                 block[idx] += mask;
1085             }
1086             if masks_count == 0 {
1087                 return Ok(());
1088             }
1089             masks_count -= 1;
1090         }
1091         let mut list_pos = list_start;
1092         while list_pos < list_end {
1093             let ccoef = coef_list[list_pos];
1094             let mode  = mode_list[list_pos];
1095             if (mode == 0 && ccoef == 0) || !br.read_bool()? {
1096                 list_pos += 1;
1097                 continue;
1098             }
1099             match mode {
1100                 0 | 2 => {
1101                         if mode == 0 {
1102                             coef_list[list_pos] = ccoef + 4;
1103                             mode_list[list_pos] = 1;
1104                         } else {
1105                             coef_list[list_pos] = 0;
1106                             mode_list[list_pos] = 0;
1107                             list_pos += 1;
1108                         }
1109                         for i in 0..4 {
1110                             if br.read_bool()? {
1111                                 list_start -= 1;
1112                                 coef_list[list_start] = ccoef + i;
1113                                 mode_list[list_start] = 3;
1114                             } else {
1115                                 let idx = (ccoef + i) as usize;
1116                                 nz_coef_idx[nz_coef_count] = BINK_SCAN[idx];
1117                                 nz_coef_count += 1;
1118                                 block[BINK_SCAN[idx]] = if br.read_bool()? { -mask } else { mask };
1119                                 if masks_count == 0 {
1120                                     return Ok(());
1121                                 }
1122                                 masks_count -= 1;
1123                             }
1124                         }
1125                     },
1126                 1 => {
1127                         mode_list[list_pos] = 2;
1128                         for i in 0..3 {
1129                             coef_list[list_end] = ccoef + i * 4 + 4;
1130                             mode_list[list_end] = 2;
1131                             list_end += 1;
1132                         }
1133                     },
1134                 3 => {
1135                         let idx = ccoef as usize;
1136                         nz_coef_idx[nz_coef_count] = BINK_SCAN[idx];
1137                         nz_coef_count += 1;
1138                         block[BINK_SCAN[idx]] = if br.read_bool()? { -mask } else { mask };
1139                         coef_list[list_pos] = 0;
1140                         mode_list[list_pos] = 0;
1141                         list_pos += 1;
1142                         if masks_count == 0 {
1143                             return Ok(());
1144                         }
1145                         masks_count -= 1;
1146                     },
1147                 _ => unreachable!(),
1148             };
1149         }
1150         mask >>= 1;
1151     }
1152
1153     Ok(())
1154 }
1155
1156 const BINK_FLAG_ALPHA:  u32 = 0x00100000;
1157 const BINK_FLAG_GRAY:   u32 = 0x00020000;
1158
1159 impl NADecoder for BinkDecoder {
1160     fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
1161         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
1162             let w = vinfo.get_width();
1163             let h = vinfo.get_height();
1164
1165             let edata = info.get_extradata().unwrap();
1166             validate!(edata.len() >= 8);
1167
1168             let mut mr = MemoryReader::new_read(&edata);
1169             let mut br = ByteReader::new(&mut mr);
1170             let magic                   = br.read_u32be()?;
1171             let flags                   = br.read_u32le()?;
1172
1173             self.is_ver_b  = (magic & 0xFF) == (b'b' as u32);
1174             self.is_ver_i  = (magic & 0xFF) >= (b'i' as u32);
1175             self.has_alpha = (flags & BINK_FLAG_ALPHA) != 0;
1176             self.is_gray   = (flags & BINK_FLAG_GRAY) != 0;
1177             self.swap_uv   = (magic & 0xFF) >= (b'h' as u32);
1178             if self.has_alpha && self.is_gray { return Err(DecoderError::NotImplemented); }
1179
1180             let aplane = if self.has_alpha { Some(NAPixelChromaton::new(0, 0, false, 8, 0, 3, 1)) } else { None };
1181             let fmt;
1182             if !self.is_gray {
1183                 fmt = NAPixelFormaton::new(ColorModel::YUV(YUVSubmodel::YUVJ),
1184                                            Some(NAPixelChromaton::new(0, 0, false, 8, 0, 0, 1)),
1185                                            Some(NAPixelChromaton::new(1, 1, false, 8, 0, 1, 1)),
1186                                            Some(NAPixelChromaton::new(1, 1, false, 8, 0, 2, 1)),
1187                                            aplane, None,
1188                                            0, if self.has_alpha { 4 } else { 3 } );
1189             } else {
1190                 fmt = NAPixelFormaton::new(ColorModel::YUV(YUVSubmodel::YUVJ),
1191                                            Some(NAPixelChromaton::new(0, 0, false, 8, 0, 0, 1)),
1192                                            None, None, None, None, 0, 1);
1193             }
1194             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));
1195             self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
1196
1197             //self.init_bundle_lengths(w.max(8), (w + 7) >> 3);
1198             self.init_bundle_bufs((w + 7) >> 3, (h + 7) >> 3);
1199
1200             if self.is_ver_b {
1201                 self.qmat_b.calc_binkb_quants();
1202             }
1203
1204             Ok(())
1205         } else {
1206             Err(DecoderError::InvalidData)
1207         }
1208     }
1209     fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
1210         let src = pkt.get_buffer();
1211
1212         let mut br = BitReader::new(&src, src.len(), BitReaderMode::LE);
1213
1214         let mut buf;
1215         self.key_frame = pkt.is_keyframe();
1216         if self.is_ver_b {
1217             let bufret = self.hams.clone_ref();
1218             if let Some(bbuf) = bufret {
1219                 buf = bbuf;
1220             } else {
1221                 let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 4)?;
1222                 buf = bufinfo.get_vbuf().unwrap();
1223                 self.key_frame = true;
1224                 self.hams.add_frame(buf);
1225                 buf = self.hams.get_output_frame().unwrap();
1226             }
1227         } else {
1228             let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 4)?;
1229             buf = bufinfo.get_vbuf().unwrap();
1230         }
1231
1232 println!("decode frame {} b={} i={}", pkt.get_pts().unwrap(), self.is_ver_b, self.is_ver_i);
1233         let nplanes = if self.is_gray { 1 } else { 3 };
1234         if self.has_alpha {
1235             validate!(!self.is_ver_b);
1236             if self.is_ver_i {
1237                 br.skip(32)?;
1238             }
1239             self.decode_plane(&mut br, nplanes, &mut buf)?;
1240         }
1241         if self.is_ver_i {
1242             br.skip(32)?;
1243         }
1244         for plane in 0..nplanes {
1245             if self.is_ver_b {
1246                 self.decode_plane_binkb(&mut br, plane, &mut buf)?;
1247             } else {
1248                 let plane_idx = if plane > 0 && self.swap_uv { plane ^ 3 } else { plane };
1249                 self.decode_plane(&mut br, plane_idx, &mut buf)?;
1250             }
1251         }
1252         let bufinfo = NABufferType::Video(buf);
1253         if !self.is_ver_b {
1254             self.ips.add_frame(bufinfo.get_vbuf().unwrap());
1255         }
1256
1257         let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
1258         frm.set_frame_type(FrameType::P);
1259         Ok(frm.into_ref())
1260     }
1261 }
1262
1263 pub fn get_decoder() -> Box<dyn NADecoder> {
1264     Box::new(BinkDecoder::new())
1265 }
1266
1267 #[cfg(test)]
1268 mod test {
1269     use nihav_core::codecs::RegisteredDecoders;
1270     use nihav_core::demuxers::RegisteredDemuxers;
1271     use nihav_core::test::dec_video::*;
1272     use crate::codecs::rad_register_all_codecs;
1273     use crate::demuxers::rad_register_all_demuxers;
1274     #[test]
1275     fn test_binkvid() {
1276         let mut dmx_reg = RegisteredDemuxers::new();
1277         rad_register_all_demuxers(&mut dmx_reg);
1278         let mut dec_reg = RegisteredDecoders::new();
1279         rad_register_all_codecs(&mut dec_reg);
1280
1281         let file = "assets/RAD/NEW.BIK";
1282         //let file = "assets/RAD/NWCLOGO.BIK";
1283         test_file_decoding("bink", file, Some(42), true, false, None/*Some("bink-b")*/, &dmx_reg, &dec_reg);
1284
1285         //let file = "assets/RAD/bink_dct.bik";
1286         //let file = "assets/RAD/day3-b.bik";
1287         let file = "assets/RAD/ActivisionLogo.bik";
1288         //let file = "assets/RAD/ATI-9700-Animusic-Movie-v1.0.bik";
1289         //let file = "assets/RAD/original.bik";
1290         test_file_decoding("bink", file, Some(42), true, false, None/*Some("bink-")*/, &dmx_reg, &dec_reg);
1291     }
1292 }
1293
1294 const BINK_SCAN: [usize; 64] = [
1295      0,  1,  8,  9,  2,  3, 10, 11,
1296      4,  5, 12, 13,  6,  7, 14, 15,
1297     20, 21, 28, 29, 22, 23, 30, 31,
1298     16, 17, 24, 25, 32, 33, 40, 41,
1299     34, 35, 42, 43, 48, 49, 56, 57,
1300     50, 51, 58, 59, 18, 19, 26, 27,
1301     36, 37, 44, 45, 38, 39, 46, 47,
1302     52, 53, 60, 61, 54, 55, 62, 63
1303 ];
1304
1305 const BINK_TREE_CODES: [[u8; 16]; 16] = [
1306     [ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F ],
1307     [ 0x00, 0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F ],
1308     [ 0x00, 0x02, 0x01, 0x09, 0x05, 0x15, 0x0D, 0x1D, 0x03, 0x13, 0x0B, 0x1B, 0x07, 0x17, 0x0F, 0x1F ],
1309     [ 0x00, 0x02, 0x06, 0x01, 0x09, 0x05, 0x0D, 0x1D, 0x03, 0x13, 0x0B, 0x1B, 0x07, 0x17, 0x0F, 0x1F ],
1310     [ 0x00, 0x04, 0x02, 0x06, 0x01, 0x09, 0x05, 0x0D, 0x03, 0x13, 0x0B, 0x1B, 0x07, 0x17, 0x0F, 0x1F ],
1311     [ 0x00, 0x04, 0x02, 0x0A, 0x06, 0x0E, 0x01, 0x09, 0x05, 0x0D, 0x03, 0x0B, 0x07, 0x17, 0x0F, 0x1F ],
1312     [ 0x00, 0x02, 0x0A, 0x06, 0x0E, 0x01, 0x09, 0x05, 0x0D, 0x03, 0x0B, 0x1B, 0x07, 0x17, 0x0F, 0x1F ],
1313     [ 0x00, 0x01, 0x05, 0x03, 0x13, 0x0B, 0x1B, 0x3B, 0x07, 0x27, 0x17, 0x37, 0x0F, 0x2F, 0x1F, 0x3F ],
1314     [ 0x00, 0x01, 0x03, 0x13, 0x0B, 0x2B, 0x1B, 0x3B, 0x07, 0x27, 0x17, 0x37, 0x0F, 0x2F, 0x1F, 0x3F ],
1315     [ 0x00, 0x01, 0x05, 0x0D, 0x03, 0x13, 0x0B, 0x1B, 0x07, 0x27, 0x17, 0x37, 0x0F, 0x2F, 0x1F, 0x3F ],
1316     [ 0x00, 0x02, 0x01, 0x05, 0x0D, 0x03, 0x13, 0x0B, 0x1B, 0x07, 0x17, 0x37, 0x0F, 0x2F, 0x1F, 0x3F ],
1317     [ 0x00, 0x01, 0x09, 0x05, 0x0D, 0x03, 0x13, 0x0B, 0x1B, 0x07, 0x17, 0x37, 0x0F, 0x2F, 0x1F, 0x3F ],
1318     [ 0x00, 0x02, 0x01, 0x03, 0x13, 0x0B, 0x1B, 0x3B, 0x07, 0x27, 0x17, 0x37, 0x0F, 0x2F, 0x1F, 0x3F ],
1319     [ 0x00, 0x01, 0x05, 0x03, 0x07, 0x27, 0x17, 0x37, 0x0F, 0x4F, 0x2F, 0x6F, 0x1F, 0x5F, 0x3F, 0x7F ],
1320     [ 0x00, 0x01, 0x05, 0x03, 0x07, 0x17, 0x37, 0x77, 0x0F, 0x4F, 0x2F, 0x6F, 0x1F, 0x5F, 0x3F, 0x7F ],
1321     [ 0x00, 0x02, 0x01, 0x05, 0x03, 0x07, 0x27, 0x17, 0x37, 0x0F, 0x2F, 0x6F, 0x1F, 0x5F, 0x3F, 0x7F ]
1322 ];
1323
1324 const BINK_TREE_BITS: [[u8; 16]; 16] = [
1325     [ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 ],
1326     [ 1, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 ],
1327     [ 2, 2, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 ],
1328     [ 2, 3, 3, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 ],
1329     [ 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5 ],
1330     [ 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5 ],
1331     [ 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5 ],
1332     [ 1, 3, 3, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6 ],
1333     [ 1, 2, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6 ],
1334     [ 1, 3, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6 ],
1335     [ 2, 2, 3, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6 ],
1336     [ 1, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6 ],
1337     [ 2, 2, 2, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6 ],
1338     [ 1, 3, 3, 3, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7 ],
1339     [ 1, 3, 3, 3, 5, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7 ],
1340     [ 2, 2, 3, 3, 3, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7 ]
1341 ];
1342
1343 const BINK_PATTERNS: [[u8; 64]; 16] = [
1344   [
1345     0x00, 0x08, 0x10, 0x18, 0x20, 0x28, 0x30, 0x38,
1346     0x39, 0x31, 0x29, 0x21, 0x19, 0x11, 0x09, 0x01,
1347     0x02, 0x0A, 0x12, 0x1A, 0x22, 0x2A, 0x32, 0x3A,
1348     0x3B, 0x33, 0x2B, 0x23, 0x1B, 0x13, 0x0B, 0x03,
1349     0x04, 0x0C, 0x14, 0x1C, 0x24, 0x2C, 0x34, 0x3C,
1350     0x3D, 0x35, 0x2D, 0x25, 0x1D, 0x15, 0x0D, 0x05,
1351     0x06, 0x0E, 0x16, 0x1E, 0x26, 0x2E, 0x36, 0x3E,
1352     0x3F, 0x37, 0x2F, 0x27, 0x1F, 0x17, 0x0F, 0x07,
1353   ], [
1354     0x3B, 0x3A, 0x39, 0x38, 0x30, 0x31, 0x32, 0x33,
1355     0x2B, 0x2A, 0x29, 0x28, 0x20, 0x21, 0x22, 0x23,
1356     0x1B, 0x1A, 0x19, 0x18, 0x10, 0x11, 0x12, 0x13,
1357     0x0B, 0x0A, 0x09, 0x08, 0x00, 0x01, 0x02, 0x03,
1358     0x04, 0x05, 0x06, 0x07, 0x0F, 0x0E, 0x0D, 0x0C,
1359     0x14, 0x15, 0x16, 0x17, 0x1F, 0x1E, 0x1D, 0x1C,
1360     0x24, 0x25, 0x26, 0x27, 0x2F, 0x2E, 0x2D, 0x2C,
1361     0x34, 0x35, 0x36, 0x37, 0x3F, 0x3E, 0x3D, 0x3C,
1362   ], [
1363     0x19, 0x11, 0x12, 0x1A, 0x1B, 0x13, 0x0B, 0x03,
1364     0x02, 0x0A, 0x09, 0x01, 0x00, 0x08, 0x10, 0x18,
1365     0x20, 0x28, 0x30, 0x38, 0x39, 0x31, 0x29, 0x2A,
1366     0x32, 0x3A, 0x3B, 0x33, 0x2B, 0x23, 0x22, 0x21,
1367     0x1D, 0x15, 0x16, 0x1E, 0x1F, 0x17, 0x0F, 0x07,
1368     0x06, 0x0E, 0x0D, 0x05, 0x04, 0x0C, 0x14, 0x1C,
1369     0x24, 0x2C, 0x34, 0x3C, 0x3D, 0x35, 0x2D, 0x2E,
1370     0x36, 0x3E, 0x3F, 0x37, 0x2F, 0x27, 0x26, 0x25,
1371   ], [
1372     0x03, 0x0B, 0x02, 0x0A, 0x01, 0x09, 0x00, 0x08,
1373     0x10, 0x18, 0x11, 0x19, 0x12, 0x1A, 0x13, 0x1B,
1374     0x23, 0x2B, 0x22, 0x2A, 0x21, 0x29, 0x20, 0x28,
1375     0x30, 0x38, 0x31, 0x39, 0x32, 0x3A, 0x33, 0x3B,
1376     0x3C, 0x34, 0x3D, 0x35, 0x3E, 0x36, 0x3F, 0x37,
1377     0x2F, 0x27, 0x2E, 0x26, 0x2D, 0x25, 0x2C, 0x24,
1378     0x1C, 0x14, 0x1D, 0x15, 0x1E, 0x16, 0x1F, 0x17,
1379     0x0F, 0x07, 0x0E, 0x06, 0x0D, 0x05, 0x0C, 0x04,
1380   ], [
1381     0x18, 0x19, 0x10, 0x11, 0x08, 0x09, 0x00, 0x01,
1382     0x02, 0x03, 0x0A, 0x0B, 0x12, 0x13, 0x1A, 0x1B,
1383     0x1C, 0x1D, 0x14, 0x15, 0x0C, 0x0D, 0x04, 0x05,
1384     0x06, 0x07, 0x0E, 0x0F, 0x16, 0x17, 0x1E, 0x1F,
1385     0x27, 0x26, 0x2F, 0x2E, 0x37, 0x36, 0x3F, 0x3E,
1386     0x3D, 0x3C, 0x35, 0x34, 0x2D, 0x2C, 0x25, 0x24,
1387     0x23, 0x22, 0x2B, 0x2A, 0x33, 0x32, 0x3B, 0x3A,
1388     0x39, 0x38, 0x31, 0x30, 0x29, 0x28, 0x21, 0x20,
1389   ], [
1390     0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
1391     0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B,
1392     0x20, 0x21, 0x22, 0x23, 0x28, 0x29, 0x2A, 0x2B,
1393     0x30, 0x31, 0x32, 0x33, 0x38, 0x39, 0x3A, 0x3B,
1394     0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
1395     0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F,
1396     0x24, 0x25, 0x26, 0x27, 0x2C, 0x2D, 0x2E, 0x2F,
1397     0x34, 0x35, 0x36, 0x37, 0x3C, 0x3D, 0x3E, 0x3F,
1398   ], [
1399     0x06, 0x07, 0x0F, 0x0E, 0x0D, 0x05, 0x0C, 0x04,
1400     0x03, 0x0B, 0x02, 0x0A, 0x09, 0x01, 0x00, 0x08,
1401     0x10, 0x18, 0x11, 0x19, 0x12, 0x1A, 0x13, 0x1B,
1402     0x14, 0x1C, 0x15, 0x1D, 0x16, 0x1E, 0x17, 0x1F,
1403     0x27, 0x2F, 0x26, 0x2E, 0x25, 0x2D, 0x24, 0x2C,
1404     0x23, 0x2B, 0x22, 0x2A, 0x21, 0x29, 0x20, 0x28,
1405     0x31, 0x30, 0x38, 0x39, 0x3A, 0x32, 0x3B, 0x33,
1406     0x3C, 0x34, 0x3D, 0x35, 0x36, 0x37, 0x3F, 0x3E,
1407   ], [
1408     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1409     0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08,
1410     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1411     0x1F, 0x1E, 0x1D, 0x1C, 0x1B, 0x1A, 0x19, 0x18,
1412     0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
1413     0x2F, 0x2E, 0x2D, 0x2C, 0x2B, 0x2A, 0x29, 0x28,
1414     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
1415     0x3F, 0x3E, 0x3D, 0x3C, 0x3B, 0x3A, 0x39, 0x38,
1416   ], [
1417     0x00, 0x08, 0x09, 0x01, 0x02, 0x03, 0x0B, 0x0A,
1418     0x12, 0x13, 0x1B, 0x1A, 0x19, 0x11, 0x10, 0x18,
1419     0x20, 0x28, 0x29, 0x21, 0x22, 0x23, 0x2B, 0x2A,
1420     0x32, 0x31, 0x30, 0x38, 0x39, 0x3A, 0x3B, 0x33,
1421     0x34, 0x3C, 0x3D, 0x3E, 0x3F, 0x37, 0x36, 0x35,
1422     0x2D, 0x2C, 0x24, 0x25, 0x26, 0x2E, 0x2F, 0x27,
1423     0x1F, 0x17, 0x16, 0x1E, 0x1D, 0x1C, 0x14, 0x15,
1424     0x0D, 0x0C, 0x04, 0x05, 0x06, 0x0E, 0x0F, 0x07,
1425   ], [
1426     0x18, 0x19, 0x10, 0x11, 0x08, 0x09, 0x00, 0x01,
1427     0x02, 0x03, 0x0A, 0x0B, 0x12, 0x13, 0x1A, 0x1B,
1428     0x1C, 0x1D, 0x14, 0x15, 0x0C, 0x0D, 0x04, 0x05,
1429     0x06, 0x07, 0x0E, 0x0F, 0x16, 0x17, 0x1E, 0x1F,
1430     0x26, 0x27, 0x2E, 0x2F, 0x36, 0x37, 0x3E, 0x3F,
1431     0x3C, 0x3D, 0x34, 0x35, 0x2C, 0x2D, 0x24, 0x25,
1432     0x22, 0x23, 0x2A, 0x2B, 0x32, 0x33, 0x3A, 0x3B,
1433     0x38, 0x39, 0x30, 0x31, 0x28, 0x29, 0x20, 0x21,
1434   ], [
1435     0x00, 0x08, 0x01, 0x09, 0x02, 0x0A, 0x03, 0x0B,
1436     0x13, 0x1B, 0x12, 0x1A, 0x11, 0x19, 0x10, 0x18,
1437     0x20, 0x28, 0x21, 0x29, 0x22, 0x2A, 0x23, 0x2B,
1438     0x33, 0x3B, 0x32, 0x3A, 0x31, 0x39, 0x30, 0x38,
1439     0x3C, 0x34, 0x3D, 0x35, 0x3E, 0x36, 0x3F, 0x37,
1440     0x2F, 0x27, 0x2E, 0x26, 0x2D, 0x25, 0x2C, 0x24,
1441     0x1F, 0x17, 0x1E, 0x16, 0x1D, 0x15, 0x1C, 0x14,
1442     0x0C, 0x04, 0x0D, 0x05, 0x0E, 0x06, 0x0F, 0x07,
1443   ], [
1444     0x00, 0x08, 0x10, 0x18, 0x19, 0x1A, 0x1B, 0x13,
1445     0x0B, 0x03, 0x02, 0x01, 0x09, 0x11, 0x12, 0x0A,
1446     0x04, 0x0C, 0x14, 0x1C, 0x1D, 0x1E, 0x1F, 0x17,
1447     0x0F, 0x07, 0x06, 0x05, 0x0D, 0x15, 0x16, 0x0E,
1448     0x24, 0x2C, 0x34, 0x3C, 0x3D, 0x3E, 0x3F, 0x37,
1449     0x2F, 0x27, 0x26, 0x25, 0x2D, 0x35, 0x36, 0x2E,
1450     0x20, 0x28, 0x30, 0x38, 0x39, 0x3A, 0x3B, 0x33,
1451     0x2B, 0x23, 0x22, 0x21, 0x29, 0x31, 0x32, 0x2A,
1452   ], [
1453     0x00, 0x08, 0x09, 0x01, 0x02, 0x03, 0x0B, 0x0A,
1454     0x13, 0x1B, 0x1A, 0x12, 0x11, 0x10, 0x18, 0x19,
1455     0x21, 0x20, 0x28, 0x29, 0x2A, 0x22, 0x23, 0x2B,
1456     0x33, 0x3B, 0x3A, 0x32, 0x31, 0x39, 0x38, 0x30,
1457     0x34, 0x3C, 0x3D, 0x35, 0x36, 0x3E, 0x3F, 0x37,
1458     0x2F, 0x27, 0x26, 0x2E, 0x2D, 0x2C, 0x24, 0x25,
1459     0x1D, 0x1C, 0x14, 0x15, 0x16, 0x1E, 0x1F, 0x17,
1460     0x0E, 0x0F, 0x07, 0x06, 0x05, 0x0D, 0x0C, 0x04,
1461   ], [
1462     0x18, 0x10, 0x08, 0x00, 0x01, 0x02, 0x03, 0x0B,
1463     0x13, 0x1B, 0x1A, 0x19, 0x11, 0x0A, 0x09, 0x12,
1464     0x1C, 0x14, 0x0C, 0x04, 0x05, 0x06, 0x07, 0x0F,
1465     0x17, 0x1F, 0x1E, 0x1D, 0x15, 0x0E, 0x0D, 0x16,
1466     0x3C, 0x34, 0x2C, 0x24, 0x25, 0x26, 0x27, 0x2F,
1467     0x37, 0x3F, 0x3E, 0x3D, 0x35, 0x2E, 0x2D, 0x36,
1468     0x38, 0x30, 0x28, 0x20, 0x21, 0x22, 0x23, 0x2B,
1469     0x33, 0x3B, 0x3A, 0x39, 0x31, 0x2A, 0x29, 0x32,
1470   ], [
1471     0x00, 0x08, 0x09, 0x01, 0x02, 0x0A, 0x12, 0x11,
1472     0x10, 0x18, 0x19, 0x1A, 0x1B, 0x13, 0x0B, 0x03,
1473     0x07, 0x06, 0x0E, 0x0F, 0x17, 0x16, 0x15, 0x0D,
1474     0x05, 0x04, 0x0C, 0x14, 0x1C, 0x1D, 0x1E, 0x1F,
1475     0x3F, 0x3E, 0x36, 0x37, 0x2F, 0x2E, 0x2D, 0x35,
1476     0x3D, 0x3C, 0x34, 0x2C, 0x24, 0x25, 0x26, 0x27,
1477     0x38, 0x30, 0x31, 0x39, 0x3A, 0x32, 0x2A, 0x29,
1478     0x28, 0x20, 0x21, 0x22, 0x23, 0x2B, 0x33, 0x3B,
1479   ], [
1480     0x00, 0x01, 0x08, 0x09, 0x10, 0x11, 0x18, 0x19,
1481     0x20, 0x21, 0x28, 0x29, 0x30, 0x31, 0x38, 0x39,
1482     0x3A, 0x3B, 0x32, 0x33, 0x2A, 0x2B, 0x22, 0x23,
1483     0x1A, 0x1B, 0x12, 0x13, 0x0A, 0x0B, 0x02, 0x03,
1484     0x04, 0x05, 0x0C, 0x0D, 0x14, 0x15, 0x1C, 0x1D,
1485     0x24, 0x25, 0x2C, 0x2D, 0x34, 0x35, 0x3C, 0x3D,
1486     0x3E, 0x3F, 0x36, 0x37, 0x2E, 0x2F, 0x26, 0x27,
1487     0x1E, 0x1F, 0x16, 0x17, 0x0E, 0x0F, 0x06, 0x07,
1488   ]
1489 ];
1490
1491 const BINK_INTRA_QUANT: &[[i32; 64]; 16] = &[
1492   [
1493     0x010000, 0x016315, 0x01E83D, 0x02A535, 0x014E7B, 0x016577, 0x02F1E6, 0x02724C,
1494     0x010000, 0x00EEDA, 0x024102, 0x017F9B, 0x00BE80, 0x00611E, 0x01083C, 0x00A552,
1495     0x021F88, 0x01DC53, 0x027FAD, 0x01F697, 0x014819, 0x00A743, 0x015A31, 0x009688,
1496     0x02346F, 0x030EE5, 0x01FBFA, 0x02C096, 0x01D000, 0x028396, 0x019247, 0x01F9AA,
1497     0x02346F, 0x01FBFA, 0x01DC53, 0x0231B8, 0x012F12, 0x01E06C, 0x00CB10, 0x0119A8,
1498     0x01C48C, 0x019748, 0x014E86, 0x0122AF, 0x02C628, 0x027F20, 0x0297B5, 0x023F32,
1499     0x025000, 0x01AB6B, 0x01D122, 0x0159B3, 0x012669, 0x008D43, 0x00EE1F, 0x0075ED,
1500     0x01490C, 0x010288, 0x00F735, 0x00EF51, 0x00E0F1, 0x0072AD, 0x00A4D8, 0x006517,
1501   ], [
1502     0x015555, 0x01D971, 0x028AFC, 0x0386F1, 0x01BDF9, 0x01DC9F, 0x03ED33, 0x034311,
1503     0x015555, 0x013E78, 0x030158, 0x01FF7A, 0x00FE00, 0x00817D, 0x01604F, 0x00DC6D,
1504     0x02D4B5, 0x027B19, 0x0354E7, 0x029E1F, 0x01B577, 0x00DF04, 0x01CD96, 0x00C8B6,
1505     0x02F095, 0x0413DC, 0x02A54E, 0x03AB73, 0x026AAB, 0x035A1E, 0x02185E, 0x02A238,
1506     0x02F095, 0x02A54E, 0x027B19, 0x02ECF5, 0x019418, 0x028090, 0x010EC0, 0x01778A,
1507     0x025B66, 0x021F0B, 0x01BE09, 0x018394, 0x03B2E0, 0x03542A, 0x0374F1, 0x02FEEE,
1508     0x031555, 0x0239E4, 0x026C2D, 0x01CCEE, 0x01888C, 0x00BC59, 0x013D7E, 0x009D3C,
1509     0x01B6BB, 0x0158B5, 0x01499C, 0x013F17, 0x012BEC, 0x0098E6, 0x00DBCB, 0x0086C9,
1510   ], [
1511     0x01AAAB, 0x024FCE, 0x032DBB, 0x0468AD, 0x022D78, 0x0253C7, 0x04E87F, 0x0413D5,
1512     0x01AAAB, 0x018E16, 0x03C1AE, 0x027F58, 0x013D80, 0x00A1DC, 0x01B863, 0x011388,
1513     0x0389E2, 0x0319DF, 0x042A21, 0x0345A7, 0x0222D4, 0x0116C5, 0x0240FC, 0x00FAE3,
1514     0x03ACBA, 0x0518D3, 0x034EA1, 0x04964F, 0x030555, 0x0430A5, 0x029E76, 0x034AC5,
1515     0x03ACBA, 0x034EA1, 0x0319DF, 0x03A833, 0x01F91E, 0x0320B4, 0x015270, 0x01D56D,
1516     0x02F23F, 0x02A6CE, 0x022D8B, 0x01E479, 0x049F98, 0x042935, 0x04522D, 0x03BEA9,
1517     0x03DAAB, 0x02C85D, 0x030738, 0x02402A, 0x01EAAF, 0x00EB6F, 0x018CDE, 0x00C48A,
1518     0x022469, 0x01AEE2, 0x019C02, 0x018EDD, 0x0176E7, 0x00BF20, 0x0112BE, 0x00A87B,
1519   ], [
1520     0x020000, 0x02C62A, 0x03D07A, 0x054A69, 0x029CF6, 0x02CAEF, 0x05E3CC, 0x04E499,
1521     0x020000, 0x01DDB4, 0x048204, 0x02FF36, 0x017D01, 0x00C23C, 0x021077, 0x014AA3,
1522     0x043F0F, 0x03B8A6, 0x04FF5A, 0x03ED2E, 0x029032, 0x014E86, 0x02B461, 0x012D11,
1523     0x0468DF, 0x061DCA, 0x03F7F5, 0x05812C, 0x03A000, 0x05072C, 0x03248D, 0x03F353,
1524     0x0468DF, 0x03F7F5, 0x03B8A6, 0x046370, 0x025E24, 0x03C0D8, 0x019620, 0x02334F,
1525     0x038919, 0x032E91, 0x029D0D, 0x02455E, 0x058C50, 0x04FE3F, 0x052F69, 0x047E65,
1526     0x04A000, 0x0356D6, 0x03A243, 0x02B365, 0x024CD2, 0x011A85, 0x01DC3E, 0x00EBD9,
1527     0x029218, 0x020510, 0x01EE69, 0x01DEA2, 0x01C1E2, 0x00E559, 0x0149B0, 0x00CA2D,
1528   ], [
1529     0x02AAAB, 0x03B2E3, 0x0515F8, 0x070DE2, 0x037BF2, 0x03B93E, 0x07DA65, 0x068621,
1530     0x02AAAB, 0x027CF0, 0x0602B1, 0x03FEF3, 0x01FC01, 0x0102FA, 0x02C09F, 0x01B8DA,
1531     0x05A96A, 0x04F632, 0x06A9CE, 0x053C3E, 0x036AED, 0x01BE09, 0x039B2D, 0x01916B,
1532     0x05E129, 0x0827B8, 0x054A9C, 0x0756E5, 0x04D555, 0x06B43B, 0x0430BC, 0x05446F,
1533     0x05E129, 0x054A9C, 0x04F632, 0x05D9EB, 0x032830, 0x050121, 0x021D80, 0x02EF14,
1534     0x04B6CC, 0x043E16, 0x037C11, 0x030728, 0x0765C0, 0x06A855, 0x06E9E2, 0x05FDDB,
1535     0x062AAB, 0x0473C8, 0x04D85A, 0x0399DC, 0x031118, 0x0178B2, 0x027AFD, 0x013A77,
1536     0x036D76, 0x02B16A, 0x029337, 0x027E2E, 0x0257D8, 0x0131CC, 0x01B796, 0x010D91,
1537   ], [
1538     0x038000, 0x04DACA, 0x06ACD5, 0x094238, 0x0492AE, 0x04E322, 0x0A4EA5, 0x08900C,
1539     0x038000, 0x0343FB, 0x07E388, 0x053E9F, 0x029AC1, 0x0153E8, 0x039CD0, 0x02429E,
1540     0x076E5B, 0x068322, 0x08BEDE, 0x06DF11, 0x047C57, 0x02496B, 0x04BBAB, 0x020EDD,
1541     0x07B786, 0x0AB421, 0x06F1ED, 0x09A20D, 0x065800, 0x08CC8E, 0x057FF7, 0x06E9D2,
1542     0x07B786, 0x06F1ED, 0x068322, 0x07AE04, 0x0424BF, 0x06917B, 0x02C6B8, 0x03D9CB,
1543     0x062FEB, 0x05917D, 0x0492D7, 0x03F964, 0x09B58C, 0x08BCEF, 0x0912F8, 0x07DD30,
1544     0x081800, 0x05D7F7, 0x065BF6, 0x04B9F1, 0x040670, 0x01EE69, 0x03416C, 0x019CBC,
1545     0x047FAA, 0x0388DC, 0x036138, 0x03459C, 0x03134C, 0x01915C, 0x0240F5, 0x0161CF,
1546   ], [
1547     0x040000, 0x058C54, 0x07A0F4, 0x0A94D3, 0x0539EC, 0x0595DD, 0x0BC798, 0x09C932,
1548     0x040000, 0x03BB68, 0x090409, 0x05FE6D, 0x02FA01, 0x018477, 0x0420EE, 0x029547,
1549     0x087E1F, 0x07714C, 0x09FEB5, 0x07DA5D, 0x052064, 0x029D0D, 0x0568C3, 0x025A21,
1550     0x08D1BE, 0x0C3B94, 0x07EFEA, 0x0B0258, 0x074000, 0x0A0E59, 0x06491A, 0x07E6A7,
1551     0x08D1BE, 0x07EFEA, 0x07714C, 0x08C6E0, 0x04BC48, 0x0781B1, 0x032C3F, 0x04669F,
1552     0x071232, 0x065D22, 0x053A1A, 0x048ABC, 0x0B18A0, 0x09FC7F, 0x0A5ED3, 0x08FCC9,
1553     0x094000, 0x06ADAC, 0x074487, 0x0566CA, 0x0499A5, 0x02350B, 0x03B87B, 0x01D7B3,
1554     0x052430, 0x040A20, 0x03DCD3, 0x03BD45, 0x0383C5, 0x01CAB3, 0x029361, 0x01945A,
1555   ], [
1556     0x050000, 0x06EF69, 0x098931, 0x0D3A07, 0x068867, 0x06FB55, 0x0EB97E, 0x0C3B7E,
1557     0x050000, 0x04AA42, 0x0B450B, 0x077E08, 0x03B881, 0x01E595, 0x05292A, 0x033A99,
1558     0x0A9DA7, 0x094D9F, 0x0C7E62, 0x09D0F4, 0x06687D, 0x034450, 0x06C2F4, 0x02F0AA,
1559     0x0B062D, 0x0F4A78, 0x09EBE4, 0x0DC2EE, 0x091000, 0x0C91EF, 0x07DB61, 0x09E050,
1560     0x0B062D, 0x09EBE4, 0x094D9F, 0x0AF898, 0x05EB59, 0x09621D, 0x03F74F, 0x058046,
1561     0x08D6BE, 0x07F46A, 0x0688A0, 0x05AD6B, 0x0DDEC8, 0x0C7B9F, 0x0CF687, 0x0B3BFB,
1562     0x0B9000, 0x085917, 0x0915A8, 0x06C07D, 0x05C00E, 0x02C24D, 0x04A69A, 0x024D9F,
1563     0x066D3C, 0x050CA7, 0x04D407, 0x04AC96, 0x0464B6, 0x023D5F, 0x033839, 0x01F971,
1564   ], [
1565     0x060000, 0x08527E, 0x0B716E, 0x0FDF3C, 0x07D6E1, 0x0860CC, 0x11AB63, 0x0EADCB,
1566     0x060000, 0x05991C, 0x0D860D, 0x08FDA3, 0x047702, 0x0246B3, 0x063165, 0x03DFEA,
1567     0x0CBD2E, 0x0B29F1, 0x0EFE0F, 0x0BC78B, 0x07B096, 0x03EB93, 0x081D24, 0x038732,
1568     0x0D3A9C, 0x12595D, 0x0BE7DF, 0x108384, 0x0AE000, 0x0F1585, 0x096DA8, 0x0BD9FA,
1569     0x0D3A9C, 0x0BE7DF, 0x0B29F1, 0x0D2A50, 0x071A6B, 0x0B4289, 0x04C25F, 0x0699EE,
1570     0x0A9B4A, 0x098BB2, 0x07D727, 0x06D01A, 0x10A4F0, 0x0EFABE, 0x0F8E3C, 0x0D7B2E,
1571     0x0DE000, 0x0A0482, 0x0AE6CA, 0x081A2F, 0x06E677, 0x034F90, 0x0594B9, 0x02C38C,
1572     0x07B649, 0x060F2F, 0x05CB3C, 0x059BE7, 0x0545A7, 0x02B00C, 0x03DD11, 0x025E87,
1573   ], [
1574     0x080000, 0x0B18A8, 0x0F41E8, 0x1529A5, 0x0A73D7, 0x0B2BBB, 0x178F2F, 0x139264,
1575     0x080000, 0x0776CF, 0x120812, 0x0BFCD9, 0x05F402, 0x0308EF, 0x0841DC, 0x052A8E,
1576     0x10FC3E, 0x0EE297, 0x13FD69, 0x0FB4B9, 0x0A40C8, 0x053A1A, 0x0AD186, 0x04B442,
1577     0x11A37B, 0x187727, 0x0FDFD4, 0x1604B0, 0x0E8000, 0x141CB1, 0x0C9235, 0x0FCD4D,
1578     0x11A37B, 0x0FDFD4, 0x0EE297, 0x118DC0, 0x09788F, 0x0F0362, 0x06587F, 0x08CD3D,
1579     0x0E2463, 0x0CBA43, 0x0A7434, 0x091577, 0x163140, 0x13F8FE, 0x14BDA5, 0x11F992,
1580     0x128000, 0x0D5B58, 0x0E890D, 0x0ACD94, 0x093349, 0x046A15, 0x0770F7, 0x03AF65,
1581     0x0A4861, 0x08143F, 0x07B9A6, 0x077A89, 0x070789, 0x039565, 0x0526C2, 0x0328B4,
1582   ], [
1583     0x0C0000, 0x10A4FD, 0x16E2DB, 0x1FBE78, 0x0FADC3, 0x10C198, 0x2356C7, 0x1D5B96,
1584     0x0C0000, 0x0B3237, 0x1B0C1A, 0x11FB46, 0x08EE03, 0x048D66, 0x0C62CA, 0x07BFD5,
1585     0x197A5D, 0x1653E3, 0x1DFC1E, 0x178F16, 0x0F612C, 0x07D727, 0x103A49, 0x070E64,
1586     0x1A7539, 0x24B2BB, 0x17CFBD, 0x210709, 0x15C000, 0x1E2B0A, 0x12DB4F, 0x17B3F4,
1587     0x1A7539, 0x17CFBD, 0x1653E3, 0x1A54A0, 0x0E34D7, 0x168513, 0x0984BE, 0x0D33DC,
1588     0x153695, 0x131765, 0x0FAE4E, 0x0DA033, 0x2149E1, 0x1DF57D, 0x1F1C78, 0x1AF65B,
1589     0x1BC000, 0x140904, 0x15CD94, 0x10345E, 0x0DCCEE, 0x069F20, 0x0B2972, 0x058718,
1590     0x0F6C91, 0x0C1E5E, 0x0B9678, 0x0B37CE, 0x0A8B4E, 0x056018, 0x07BA22, 0x04BD0E,
1591   ], [
1592     0x110000, 0x179466, 0x206C0C, 0x2CF87F, 0x16362A, 0x17BCED, 0x321044, 0x299714,
1593     0x110000, 0x0FDC79, 0x265125, 0x19794E, 0x0CA685, 0x0672FB, 0x118BF4, 0x0AFA6D,
1594     0x241804, 0x1FA181, 0x2A7A80, 0x21600A, 0x15C9A9, 0x0B1B77, 0x16FD3C, 0x09FF0D,
1595     0x257B66, 0x33FD33, 0x21BBA2, 0x2EC9F7, 0x1ED000, 0x2ABCF9, 0x1AB6B0, 0x219444,
1596     0x257B66, 0x21BBA2, 0x1FA181, 0x254D38, 0x142030, 0x1FE730, 0x0D7C0E, 0x12B423,
1597     0x1E0D52, 0x1B0BCF, 0x1636EE, 0x134D9E, 0x2F28A9, 0x2A711B, 0x2C12FF, 0x263256,
1598     0x275000, 0x1C621B, 0x1EE33C, 0x16F4DB, 0x138CFB, 0x09616E, 0x0FD00C, 0x07D4B7,
1599     0x15D9CE, 0x112B06, 0x106A80, 0x0FE464, 0x0EF004, 0x079D77, 0x0AF25B, 0x06B67F,
1600   ], [
1601     0x160000, 0x1E83CF, 0x29F53D, 0x3A3286, 0x1CBE90, 0x1EB842, 0x40C9C2, 0x35D293,
1602     0x160000, 0x1486BA, 0x319630, 0x20F756, 0x105F06, 0x085891, 0x16B51E, 0x0E3506,
1603     0x2EB5AA, 0x28EF20, 0x36F8E1, 0x2B30FE, 0x1C3225, 0x0E5FC7, 0x1DC030, 0x0CEFB7,
1604     0x308193, 0x4347AC, 0x2BA786, 0x3C8CE5, 0x27E000, 0x374EE7, 0x229212, 0x2B7494,
1605     0x308193, 0x2BA786, 0x28EF20, 0x3045D0, 0x1A0B89, 0x29494D, 0x11735D, 0x183469,
1606     0x26E410, 0x230039, 0x1CBF8F, 0x18FB09, 0x3D0771, 0x36ECBA, 0x390986, 0x316E52,
1607     0x32E000, 0x24BB33, 0x27F8E4, 0x1DB557, 0x194D09, 0x0C23BB, 0x1476A6, 0x0A2256,
1608     0x1C470A, 0x1637AD, 0x153E87, 0x1490FA, 0x1354B9, 0x09DAD6, 0x0E2A94, 0x08AFF0,
1609   ], [
1610     0x1C0000, 0x26D64D, 0x3566AA, 0x4A11C2, 0x249572, 0x27190E, 0x527525, 0x44805E,
1611     0x1C0000, 0x1A1FD6, 0x3F1C3E, 0x29F4F9, 0x14D607, 0x0A9F44, 0x1CE683, 0x1214F0,
1612     0x3B72D9, 0x341911, 0x45F6F0, 0x36F889, 0x23E2BB, 0x124B5B, 0x25DD54, 0x1076E9,
1613     0x3DBC30, 0x55A109, 0x378F64, 0x4D1069, 0x32C000, 0x46646C, 0x2BFFB9, 0x374E8E,
1614     0x3DBC30, 0x378F64, 0x341911, 0x3D7020, 0x2125F5, 0x348BD6, 0x1635BC, 0x1ECE57,
1615     0x317F5B, 0x2C8BEB, 0x2496B6, 0x1FCB22, 0x4DAC61, 0x45E778, 0x4897C2, 0x3EE97F,
1616     0x40C000, 0x2EBFB5, 0x32DFAE, 0x25CF86, 0x203380, 0x0F734B, 0x1A0B5F, 0x0CE5E2,
1617     0x23FD53, 0x1C46DC, 0x1B09C4, 0x1A2CE1, 0x189A60, 0x0C8AE2, 0x1207A5, 0x0B0E77,
1618   ], [
1619     0x220000, 0x2F28CC, 0x40D818, 0x59F0FE, 0x2C6C53, 0x2F79DA, 0x642089, 0x532E29,
1620     0x220000, 0x1FB8F1, 0x4CA24B, 0x32F29C, 0x194D09, 0x0CE5F7, 0x2317E8, 0x15F4DB,
1621     0x483007, 0x3F4303, 0x54F4FF, 0x42C014, 0x2B9351, 0x1636EE, 0x2DFA79, 0x13FE1A,
1622     0x4AF6CC, 0x67FA67, 0x437743, 0x5D93EE, 0x3DA000, 0x5579F1, 0x356D61, 0x432888,
1623     0x4AF6CC, 0x437743, 0x3F4303, 0x4A9A70, 0x284060, 0x3FCE60, 0x1AF81B, 0x256845,
1624     0x3C1AA5, 0x36179D, 0x2C6DDD, 0x269B3C, 0x5E5152, 0x54E237, 0x5825FE, 0x4C64AD,
1625     0x4EA000, 0x38C437, 0x3DC678, 0x2DE9B5, 0x2719F7, 0x12C2DB, 0x1FA018, 0x0FA96E,
1626     0x2BB39B, 0x22560C, 0x20D500, 0x1FC8C8, 0x1DE007, 0x0F3AEE, 0x15E4B7, 0x0D6CFE,
1627   ], [
1628     0x2C0000, 0x3D079E, 0x53EA79, 0x74650C, 0x397D20, 0x3D7083, 0x819383, 0x6BA525,
1629     0x2C0000, 0x290D75, 0x632C61, 0x41EEAC, 0x20BE0C, 0x10B121, 0x2D6A3B, 0x1C6A0C,
1630     0x5D6B54, 0x51DE40, 0x6DF1C2, 0x5661FB, 0x38644B, 0x1CBF8F, 0x3B8060, 0x19DF6D,
1631     0x610326, 0x868F57, 0x574F0B, 0x7919CA, 0x4FC000, 0x6E9DCE, 0x452423, 0x56E928,
1632     0x610326, 0x574F0B, 0x51DE40, 0x608BA0, 0x341713, 0x52929A, 0x22E6BA, 0x3068D2,
1633     0x4DC821, 0x460071, 0x397F1E, 0x31F611, 0x7A0EE2, 0x6DD974, 0x72130C, 0x62DCA3,
1634     0x65C000, 0x497665, 0x4FF1C9, 0x3B6AAE, 0x329A12, 0x184776, 0x28ED4D, 0x1444AC,
1635     0x388E14, 0x2C6F5A, 0x2A7D0F, 0x2921F4, 0x26A973, 0x13B5AD, 0x1C5528, 0x115FDF,
1636   ]
1637 ];
1638
1639 const BINK_INTER_QUANT: &[[i32; 64]; 16] = &[
1640   [
1641     0x010000, 0x017946, 0x01A5A9, 0x0248DC, 0x016363, 0x0152A7, 0x0243EC, 0x0209EA,
1642     0x012000, 0x00E248, 0x01BBDA, 0x015CBC, 0x00A486, 0x0053E0, 0x00F036, 0x008095,
1643     0x01B701, 0x016959, 0x01B0B9, 0x0153FD, 0x00F8E7, 0x007EE4, 0x00EA30, 0x007763,
1644     0x01B701, 0x0260EB, 0x019DE9, 0x023E1B, 0x017000, 0x01FE6E, 0x012DB5, 0x01A27B,
1645     0x01E0D1, 0x01B0B9, 0x018A33, 0x01718D, 0x00D87A, 0x014449, 0x007B9A, 0x00AB71,
1646     0x013178, 0x0112EA, 0x00AD08, 0x009BB9, 0x023D97, 0x020437, 0x021CCC, 0x01E6B4,
1647     0x018000, 0x012DB5, 0x0146D9, 0x0100CE, 0x00CFD2, 0x006E5C, 0x00B0E4, 0x005A2D,
1648     0x00E9CC, 0x00B7B1, 0x00846F, 0x006B85, 0x008337, 0x0042E5, 0x004A10, 0x002831,
1649   ], [
1650     0x015555, 0x01F708, 0x023237, 0x030BD0, 0x01D9D9, 0x01C389, 0x03053B, 0x02B7E3,
1651     0x018000, 0x012DB5, 0x024FCE, 0x01D0FA, 0x00DB5D, 0x006FD5, 0x014048, 0x00AB71,
1652     0x024957, 0x01E1CC, 0x0240F7, 0x01C551, 0x014BDE, 0x00A92F, 0x013840, 0x009F2F,
1653     0x024957, 0x032BE4, 0x0227E1, 0x02FD7A, 0x01EAAB, 0x02A893, 0x019247, 0x022DF9,
1654     0x028116, 0x0240F7, 0x020D99, 0x01ECBC, 0x0120A3, 0x01B061, 0x00A4CE, 0x00E497,
1655     0x01974B, 0x016E8E, 0x00E6B5, 0x00CFA2, 0x02FCC9, 0x02B04A, 0x02D110, 0x0288F1,
1656     0x020000, 0x019247, 0x01B3CC, 0x015668, 0x011518, 0x009325, 0x00EBDA, 0x00783D,
1657     0x0137BB, 0x00F4ED, 0x00B093, 0x008F5C, 0x00AEF4, 0x005931, 0x0062BF, 0x003597,
1658   ], [
1659     0x01AAAB, 0x0274CB, 0x02BEC4, 0x03CEC4, 0x02504F, 0x02346C, 0x03C689, 0x0365DC,
1660     0x01E000, 0x017922, 0x02E3C1, 0x024539, 0x011235, 0x008BCA, 0x01905A, 0x00D64D,
1661     0x02DBAD, 0x025A40, 0x02D134, 0x0236A5, 0x019ED6, 0x00D37B, 0x018650, 0x00C6FB,
1662     0x02DBAD, 0x03F6DD, 0x02B1D9, 0x03BCD8, 0x026555, 0x0352B8, 0x01F6D8, 0x02B977,
1663     0x03215C, 0x02D134, 0x029100, 0x0267EB, 0x0168CC, 0x021C7A, 0x00CE01, 0x011DBD,
1664     0x01FD1E, 0x01CA31, 0x012062, 0x01038A, 0x03BBFB, 0x035C5C, 0x038554, 0x032B2D,
1665     0x028000, 0x01F6D8, 0x0220C0, 0x01AC02, 0x015A5E, 0x00B7EF, 0x0126D1, 0x00964C,
1666     0x0185A9, 0x013228, 0x00DCB8, 0x00B333, 0x00DAB2, 0x006F7D, 0x007B6F, 0x0042FC,
1667   ], [
1668     0x020000, 0x02F28D, 0x034B52, 0x0491B8, 0x02C6C5, 0x02A54E, 0x0487D8, 0x0413D5,
1669     0x024000, 0x01C48F, 0x0377B5, 0x02B977, 0x01490C, 0x00A7BF, 0x01E06C, 0x01012A,
1670     0x036E03, 0x02D2B3, 0x036172, 0x02A7FA, 0x01F1CE, 0x00FDC7, 0x01D460, 0x00EEC7,
1671     0x036E03, 0x04C1D6, 0x033BD1, 0x047C37, 0x02E000, 0x03FCDD, 0x025B6A, 0x0344F5,
1672     0x03C1A1, 0x036172, 0x031466, 0x02E31B, 0x01B0F5, 0x028892, 0x00F735, 0x0156E2,
1673     0x0262F1, 0x0225D5, 0x015A10, 0x013772, 0x047B2D, 0x04086E, 0x043998, 0x03CD69,
1674     0x030000, 0x025B6A, 0x028DB3, 0x02019B, 0x019FA3, 0x00DCB8, 0x0161C7, 0x00B45B,
1675     0x01D398, 0x016F63, 0x0108DD, 0x00D70A, 0x01066F, 0x0085C9, 0x00941F, 0x005062,
1676   ], [
1677     0x02AAAB, 0x03EE11, 0x04646D, 0x0617A0, 0x03B3B2, 0x038713, 0x060A75, 0x056FC6,
1678     0x030000, 0x025B6A, 0x049F9B, 0x03A1F4, 0x01B6BB, 0x00DFAA, 0x028090, 0x0156E2,
1679     0x0492AE, 0x03C399, 0x0481ED, 0x038AA2, 0x0297BD, 0x01525F, 0x027080, 0x013E5E,
1680     0x0492AE, 0x0657C8, 0x044FC1, 0x05FAF4, 0x03D555, 0x055126, 0x03248D, 0x045BF2,
1681     0x05022D, 0x0481ED, 0x041B33, 0x03D979, 0x024147, 0x0360C3, 0x01499C, 0x01C92E,
1682     0x032E96, 0x02DD1C, 0x01CD6A, 0x019F43, 0x05F991, 0x056093, 0x05A220, 0x0511E1,
1683     0x040000, 0x03248D, 0x036799, 0x02ACCF, 0x022A2F, 0x01264B, 0x01D7B5, 0x00F079,
1684     0x026F75, 0x01E9D9, 0x016127, 0x011EB8, 0x015DE9, 0x00B262, 0x00C57F, 0x006B2D,
1685   ], [
1686     0x038000, 0x052876, 0x05C3CF, 0x07FF02, 0x04DBD9, 0x04A148, 0x07EDBA, 0x0722B4,
1687     0x03F000, 0x0317FB, 0x06117C, 0x04C491, 0x023FD5, 0x01258F, 0x0348BD, 0x01C209,
1688     0x060085, 0x04F0B9, 0x05EA87, 0x04A5F5, 0x036728, 0x01BC1C, 0x0333A8, 0x01A1DB,
1689     0x060085, 0x085336, 0x05A8AE, 0x07D960, 0x050800, 0x06FA82, 0x041FF9, 0x05B8AE,
1690     0x0692DA, 0x05EA87, 0x0563B2, 0x050D6E, 0x02F5AD, 0x046F00, 0x01B09C, 0x02580C,
1691     0x042D25, 0x03C235, 0x025D9B, 0x022108, 0x07D78F, 0x070EC1, 0x0764CA, 0x06A777,
1692     0x054000, 0x041FF9, 0x0477F9, 0x0382D0, 0x02D75E, 0x018242, 0x026B1D, 0x013B9F,
1693     0x03324A, 0x0282ED, 0x01CF83, 0x017851, 0x01CB42, 0x00EA21, 0x010336, 0x008CAC,
1694   ], [
1695     0x040000, 0x05E519, 0x0696A4, 0x092370, 0x058D8A, 0x054A9C, 0x090FB0, 0x0827AA,
1696     0x048000, 0x03891F, 0x06EF69, 0x0572EE, 0x029218, 0x014F7E, 0x03C0D8, 0x020254,
1697     0x06DC05, 0x05A565, 0x06C2E4, 0x054FF3, 0x03E39B, 0x01FB8E, 0x03A8C0, 0x01DD8D,
1698     0x06DC05, 0x0983AC, 0x0677A2, 0x08F86E, 0x05C000, 0x07F9B9, 0x04B6D4, 0x0689EB,
1699     0x078343, 0x06C2E4, 0x0628CC, 0x05C635, 0x0361EA, 0x051124, 0x01EE69, 0x02ADC5,
1700     0x04C5E1, 0x044BAA, 0x02B41F, 0x026EE5, 0x08F65A, 0x0810DD, 0x087330, 0x079AD1,
1701     0x060000, 0x04B6D4, 0x051B65, 0x040337, 0x033F47, 0x01B970, 0x02C38F, 0x0168B6,
1702     0x03A730, 0x02DEC6, 0x0211BA, 0x01AE14, 0x020CDD, 0x010B93, 0x01283E, 0x00A0C4,
1703   ], [
1704     0x050000, 0x075E60, 0x083C4D, 0x0B6C4C, 0x06F0ED, 0x069D43, 0x0B539C, 0x0A3194,
1705     0x05A000, 0x046B67, 0x08AB44, 0x06CFAA, 0x03369E, 0x01A35E, 0x04B10F, 0x0282E8,
1706     0x089307, 0x070EBF, 0x08739C, 0x06A3F0, 0x04DC82, 0x027A72, 0x0492F0, 0x0254F0,
1707     0x089307, 0x0BE497, 0x08158B, 0x0B3689, 0x073000, 0x09F827, 0x05E489, 0x082C66,
1708     0x096413, 0x08739C, 0x07B2FF, 0x0737C2, 0x043A64, 0x06556D, 0x026A04, 0x035936,
1709     0x05F75A, 0x055E94, 0x036127, 0x030A9E, 0x0B33F1, 0x0A1514, 0x0A8FFC, 0x098186,
1710     0x078000, 0x05E489, 0x06623F, 0x050405, 0x040F19, 0x0227CC, 0x037473, 0x01C2E3,
1711     0x0490FC, 0x039677, 0x029629, 0x021999, 0x029015, 0x014E78, 0x01724E, 0x00C8F5,
1712   ], [
1713     0x060000, 0x08D7A6, 0x09E1F6, 0x0DB528, 0x085450, 0x07EFEA, 0x0D9788, 0x0C3B7E,
1714     0x06C000, 0x054DAE, 0x0A671E, 0x082C66, 0x03DB24, 0x01F73E, 0x05A145, 0x03037D,
1715     0x0A4A08, 0x087818, 0x0A2455, 0x07F7ED, 0x05D569, 0x02F955, 0x057D20, 0x02CC54,
1716     0x0A4A08, 0x0E4582, 0x09B373, 0x0D74A5, 0x08A000, 0x0BF696, 0x07123E, 0x09CEE0,
1717     0x0B44E4, 0x0A2455, 0x093D32, 0x08A950, 0x0512DF, 0x0799B6, 0x02E59E, 0x0404A7,
1718     0x0728D2, 0x06717F, 0x040E2F, 0x03A657, 0x0D7187, 0x0C194B, 0x0CACC8, 0x0B683A,
1719     0x090000, 0x07123E, 0x07A918, 0x0604D2, 0x04DEEA, 0x029629, 0x042556, 0x021D11,
1720     0x057AC8, 0x044E28, 0x031A97, 0x02851E, 0x03134C, 0x01915C, 0x01BC5D, 0x00F126,
1721   ], [
1722     0x080000, 0x0BCA33, 0x0D2D48, 0x1246E0, 0x0B1B15, 0x0A9538, 0x121F5F, 0x104F53,
1723     0x090000, 0x07123E, 0x0DDED2, 0x0AE5DD, 0x052430, 0x029EFD, 0x0781B1, 0x0404A7,
1724     0x0DB80B, 0x0B4ACB, 0x0D85C7, 0x0A9FE7, 0x07C736, 0x03F71D, 0x075180, 0x03BB1A,
1725     0x0DB80B, 0x130757, 0x0CEF44, 0x11F0DC, 0x0B8000, 0x0FF372, 0x096DA8, 0x0D13D6,
1726     0x0F0686, 0x0D85C7, 0x0C5198, 0x0B8C6A, 0x06C3D4, 0x0A2248, 0x03DCD3, 0x055B8A,
1727     0x098BC3, 0x089754, 0x05683E, 0x04DDC9, 0x11ECB4, 0x1021B9, 0x10E661, 0x0F35A3,
1728     0x0C0000, 0x096DA8, 0x0A36CB, 0x08066E, 0x067E8E, 0x0372E1, 0x05871E, 0x02D16B,
1729     0x074E60, 0x05BD8B, 0x042374, 0x035C28, 0x0419BB, 0x021726, 0x02507C, 0x014188,
1730   ], [
1731     0x0C0000, 0x11AF4C, 0x13C3EC, 0x1B6A50, 0x10A89F, 0x0FDFD4, 0x1B2F0F, 0x1876FD,
1732     0x0D8000, 0x0A9B5D, 0x14CE3C, 0x1058CB, 0x07B649, 0x03EE7B, 0x0B4289, 0x0606FB,
1733     0x149410, 0x10F030, 0x1448AB, 0x0FEFDA, 0x0BAAD2, 0x05F2AB, 0x0AFA40, 0x0598A7,
1734     0x149410, 0x1C8B03, 0x1366E6, 0x1AE949, 0x114000, 0x17ED2B, 0x0E247C, 0x139DC1,
1735     0x1689C8, 0x1448AB, 0x127A63, 0x11529F, 0x0A25BE, 0x0F336D, 0x05CB3C, 0x08094E,
1736     0x0E51A4, 0x0CE2FE, 0x081C5D, 0x074CAE, 0x1AE30E, 0x183296, 0x195991, 0x16D074,
1737     0x120000, 0x0E247C, 0x0F5230, 0x0C09A5, 0x09BDD5, 0x052C51, 0x084AAC, 0x043A21,
1738     0x0AF590, 0x089C51, 0x06352E, 0x050A3B, 0x062698, 0x0322B9, 0x0378BA, 0x01E24D,
1739   ], [
1740     0x110000, 0x190DAC, 0x1C0039, 0x26D69C, 0x17998C, 0x167D16, 0x2682AB, 0x22A891,
1741     0x132000, 0x0F06C3, 0x1D797F, 0x172876, 0x0AECE7, 0x0591D9, 0x0FF398, 0x0889E3,
1742     0x1D2717, 0x17FEEF, 0x1CBC47, 0x1693CA, 0x108754, 0x086D1D, 0x0F8D30, 0x07ED98,
1743     0x1D2717, 0x286F9A, 0x1B7C71, 0x261FD3, 0x187000, 0x21E552, 0x140904, 0x1BCA27,
1744     0x1FEDDC, 0x1CBC47, 0x1A2D62, 0x188A62, 0x0E6022, 0x1588DA, 0x083540, 0x0B6284,
1745     0x1448FE, 0x124192, 0x0B7D84, 0x0A574B, 0x2616FF, 0x2247AA, 0x23E98D, 0x2051FA,
1746     0x198000, 0x140904, 0x15B46F, 0x110DAA, 0x0DCCEE, 0x07541E, 0x0BBF1F, 0x05FD04,
1747     0x0F868B, 0x0C32C8, 0x08CB57, 0x0723D4, 0x08B6AD, 0x047130, 0x04EB08, 0x02AB42,
1748   ], [
1749     0x160000, 0x206C0C, 0x243C86, 0x3242E8, 0x1E8A79, 0x1D1A59, 0x31D646, 0x2CDA25,
1750     0x18C000, 0x13722A, 0x2624C3, 0x1DF820, 0x0E2385, 0x073537, 0x14A4A7, 0x0B0CCC,
1751     0x25BA1D, 0x1F0DAE, 0x252FE4, 0x1D37BB, 0x1563D6, 0x0AE78E, 0x142021, 0x0A4288,
1752     0x25BA1D, 0x345430, 0x2391FB, 0x31565C, 0x1FA000, 0x2BDD7A, 0x19ED8D, 0x23F68C,
1753     0x2951EF, 0x252FE4, 0x21E061, 0x1FC224, 0x129A87, 0x1BDE47, 0x0A9F44, 0x0EBBBA,
1754     0x1A4058, 0x17A026, 0x0EDEAB, 0x0D61E9, 0x314AEF, 0x2C5CBE, 0x2E798A, 0x29D380,
1755     0x210000, 0x19ED8D, 0x1C16AE, 0x1611AE, 0x11DC06, 0x097BEA, 0x0F3391, 0x07BFE7,
1756     0x141787, 0x0FC93E, 0x0B617F, 0x093D6D, 0x0B46C1, 0x05BFA8, 0x065D55, 0x037437,
1757   ], [
1758     0x1C0000, 0x2943B2, 0x2E1E7C, 0x3FF810, 0x26DEC9, 0x250A43, 0x3F6DCE, 0x3915A3,
1759     0x1F8000, 0x18BFD8, 0x308BE1, 0x262485, 0x11FEA9, 0x092C75, 0x1A45EB, 0x0E1049,
1760     0x300425, 0x2785C6, 0x2F5439, 0x252FA8, 0x1B393F, 0x0DE0E4, 0x199D41, 0x0D0EDC,
1761     0x300425, 0x4299B2, 0x2D456E, 0x3ECB00, 0x284000, 0x37D40F, 0x20FFCB, 0x2DC56D,
1762     0x3496D3, 0x2F5439, 0x2B1D93, 0x286B74, 0x17AD66, 0x2377FE, 0x0D84E2, 0x12C062,
1763     0x21692A, 0x1E11A5, 0x12ECDA, 0x110840, 0x3EBC76, 0x387608, 0x3B2652, 0x353BBA,
1764     0x2A0000, 0x20FFCB, 0x23BFC6, 0x1C1681, 0x16BAF1, 0x0C1213, 0x1358E8, 0x09DCF8,
1765     0x19924F, 0x141767, 0x0E7C16, 0x0BC28A, 0x0E5A0D, 0x075104, 0x0819B2, 0x04655D,
1766   ], [
1767     0x220000, 0x321B58, 0x380072, 0x4DAD38, 0x2F3318, 0x2CFA2D, 0x4D0556, 0x455122,
1768     0x264000, 0x1E0D86, 0x3AF2FE, 0x2E50EB, 0x15D9CE, 0x0B23B2, 0x1FE730, 0x1113C7,
1769     0x3A4E2D, 0x2FFDDF, 0x39788E, 0x2D2795, 0x210EA8, 0x10DA39, 0x1F1A61, 0x0FDB2F,
1770     0x3A4E2D, 0x50DF33, 0x36F8E1, 0x4C3FA5, 0x30E000, 0x43CAA5, 0x281209, 0x37944D,
1771     0x3FDBB7, 0x39788E, 0x345AC4, 0x3114C3, 0x1CC044, 0x2B11B4, 0x106A80, 0x16C509,
1772     0x2891FC, 0x248324, 0x16FB08, 0x14AE97, 0x4C2DFD, 0x448F54, 0x47D31B, 0x40A3F5,
1773     0x330000, 0x281209, 0x2B68DF, 0x221B53, 0x1B99DB, 0x0EA83B, 0x177E3E, 0x0BFA09,
1774     0x1F0D17, 0x18658F, 0x1196AE, 0x0E47A8, 0x116D5A, 0x08E260, 0x09D60F, 0x055684,
1775   ], [
1776     0x2C0000, 0x40D818, 0x48790C, 0x6485D0, 0x3D14F2, 0x3A34B2, 0x63AC8D, 0x59B44A,
1777     0x318000, 0x26E454, 0x4C4986, 0x3BF03F, 0x1C470A, 0x0E6A6E, 0x29494D, 0x161998,
1778     0x4B743A, 0x3E1B5C, 0x4A5FC7, 0x3A6F75, 0x2AC7AC, 0x15CF1D, 0x284041, 0x148510,
1779     0x4B743A, 0x68A861, 0x4723F6, 0x62ACB8, 0x3F4000, 0x57BAF3, 0x33DB1A, 0x47ED19,
1780     0x52A3DE, 0x4A5FC7, 0x43C0C2, 0x3F8448, 0x25350D, 0x37BC8E, 0x153E87, 0x1D7775,
1781     0x3480B0, 0x2F404C, 0x1DBD56, 0x1AC3D2, 0x6295DE, 0x58B97B, 0x5CF313, 0x53A701,
1782     0x420000, 0x33DB1A, 0x382D5C, 0x2C235D, 0x23B80D, 0x12F7D4, 0x1E6723, 0x0F7FCF,
1783     0x282F0E, 0x1F927D, 0x16C2FF, 0x127AD9, 0x168D83, 0x0B7F50, 0x0CBAAA, 0x06E86E,
1784   ]
1785 ];
1786
1787 const BINKB_RUN_BITS: [u8; 64] = [
1788     6, 6, 6, 6, 6, 6, 6, 6,
1789     6, 6, 6, 6, 6, 6, 6, 6,
1790     6, 6, 6, 6, 6, 6, 6, 6,
1791     6, 6, 6, 6, 6, 6, 6, 6,
1792     5, 5, 5, 5, 5, 5, 5, 5,
1793     5, 5, 5, 5, 5, 5, 5, 5,
1794     4, 4, 4, 4, 4, 4, 4, 4,
1795     3, 3, 3, 3, 2, 2, 1, 0
1796 ];
1797
1798 const BINKB_REF_INTRA_Q: [u8; 64] = [
1799     16, 16, 16, 19, 16, 19, 22, 22,
1800     22, 22, 26, 24, 26, 22, 22, 27,
1801     27, 27, 26, 26, 26, 29, 29, 29,
1802     27, 27, 27, 26, 34, 34, 34, 29,
1803     29, 29, 27, 27, 37, 34, 34, 32,
1804     32, 29, 29, 38, 37, 35, 35, 34,
1805     35, 40, 40, 40, 38, 38, 48, 48,
1806     46, 46, 58, 56, 56, 69, 69, 83
1807 ];
1808
1809 const BINKB_REF_INTER_Q: [u8; 64] = [
1810     16, 17, 17, 18, 18, 18, 19, 19,
1811     19, 19, 20, 20, 20, 20, 20, 21,
1812     21, 21, 21, 21, 21, 22, 22, 22,
1813     22, 22, 22, 22, 23, 23, 23, 23,
1814     23, 23, 23, 23, 24, 24, 24, 25,
1815     24, 24, 24, 25, 26, 26, 26, 26,
1816     25, 27, 27, 27, 27, 27, 28, 28,
1817     28, 28, 30, 30, 30, 31, 31, 33
1818 ];
1819
1820 const BINKB_REF_QUANTS: [(u8, u8); 16] = [
1821     (1, 1), (4, 3), (5, 3), (2, 1), (7, 3), (8, 3), (3, 1), (7, 2),
1822     (4, 1), (9, 2), (5, 1), (6, 1), (7, 1), (8, 1), (9, 1), (10, 1)
1823 ];