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