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