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