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};
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;
19 #[derive(Default, Clone,Copy)]
26 fn read_desc(&mut self, br: &mut BitReader) -> DecoderResult<()> {
27 self.id = br.read(4)? as usize;
29 for i in 0..16 { self.syms[i] = i as u8; }
32 let len = br.read(3)? as usize;
33 let mut present: [bool; 16] = [false; 16];
35 self.syms[i] = br.read(4)? as u8;
36 present[self.syms[i] as usize] = true;
38 let mut idx = len + 1;
40 if present[i] { continue; }
41 self.syms[idx] = i as u8;
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];
50 for arr in syms.chunks_mut(size * 2) {
54 while (ptr0 < size) && (ptr1 < size * 2) {
56 tmp[optr] = arr[ptr0];
59 tmp[optr] = arr[ptr1];
65 tmp[optr] = arr[ptr0];
69 while ptr1 < size * 2 {
70 tmp[optr] = arr[ptr1];
74 arr.copy_from_slice(&tmp[0..size * 2]);
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])
89 struct Bundle<T: Copy> {
97 impl<T:Copy> Bundle<T> {
98 fn binkb_reset(&mut self, bits: u8) {
103 fn reset(&mut self) {
107 fn read_desc(&mut self, br: &mut BitReader) -> DecoderResult<()> {
110 self.tree.read_desc(br)?;
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;
117 self.dec_pos = self.data.len();
118 self.read_pos = self.data.len() - 1;
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;
126 self.dec_pos = self.data.len();
127 self.read_pos = self.data.len() - 1;
129 println!(" read {} of {} bits", len, self.bits);
132 fn get_val(&mut self) -> DecoderResult<T> {
133 validate!(self.read_pos < self.dec_pos);
134 let val = self.data[self.read_pos];
140 const BLOCK_TYPE_RUNS: [usize; 4] = [ 4, 8, 12, 32 ];
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());
148 self.data[self.dec_pos + i] = br.read(self.bits)? as u8;
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());
159 let val = br.read(4)? as u8;
160 for i in 0..len { self.data[self.dec_pos + i] = val; }
163 while self.dec_pos < end {
164 self.data[self.dec_pos] = self.tree.read_sym(br, trees)?;
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());
176 let val = br.read(4)? as u8;
177 for i in 0..len { self.data[self.dec_pos + i] = val; }
181 while self.dec_pos < end {
182 let val = self.tree.read_sym(br, trees)?;
184 self.data[self.dec_pos] = val;
188 let run = BLOCK_TYPE_RUNS[(val - 12) as usize];
189 validate!(self.dec_pos + run <= end);
191 self.data[self.dec_pos + i] = last;
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());
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);
212 fn cvt_color(lo: u8, hi: u8, new_bink: bool) -> u8 {
213 let val = lo | (hi << 4);
215 let sign = ((val as i8) >> 7) as u8;
216 ((val & 0x7F) ^ sign).wrapping_sub(sign) ^ 0x80
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;
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; }
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;
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);
255 self.data[self.dec_pos + i] = (br.read(self.bits)? as i8) - bias;
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());
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; }
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];
283 const DC_START_BITS: u8 = 11;
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());
291 self.data[self.dec_pos + i] = br.read(self.bits)? as u16;
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;
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;
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)
313 val.checked_add(diff)
315 validate!(res.is_some());
317 self.data[self.dec_pos] = val;
321 for _ in 0..seg_len {
322 self.data[self.dec_pos] = val;
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);
339 self.data[self.dec_pos + i] = (br.read(self.bits)? as i16) - bias;
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()? {
353 self.data[self.dec_pos] = val;
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;
359 for _ in 0..seg_len {
360 let mut diff = br.read(bits)? as i16;
361 if diff != 0 && br.read_bool()? {
364 let res = val.checked_add(diff);
365 validate!(res.is_some());
367 self.data[self.dec_pos] = val;
371 for _ in 0..seg_len {
372 self.data[self.dec_pos] = val;
382 cb: [Codebook<u8>; 16],
385 fn map_u8(idx: usize) -> u8 { idx as u8 }
387 impl Default for BinkTrees {
388 fn default() -> Self {
389 let mut cb: [Codebook<u8>; 16];
391 cb = std::mem::uninitialized();
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());
401 const A1: i32 = 2896;
402 const A2: i32 = 2217;
403 const A3: i32 = 3784;
404 const A4: i32 = -5352;
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];
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;
423 let c2 = a1 + (a3 - a2);
424 let c3 = a1 - (a3 - a2);
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;
438 intra_qmat: [[i32; 64]; 16],
439 inter_qmat: [[i32; 64]; 16],
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;
448 for i in 0..64 { inv_scan[BINK_SCAN[i]] = i; }
451 let j_scale = if (j != 0) && (j != 4) { (base * (j as f32)).cos() * consts::SQRT_2 } else { 1.0 };
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;
459 let (num, den) = BINKB_REF_QUANTS[q];
460 let quant = (num as f32) * ((1 << 12) as f32) / (den as f32);
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;
470 impl Default for QuantMats {
471 fn default() -> Self {
472 Self { intra_qmat: [[0; 64]; 16], inter_qmat: [[0; 64]; 16] }
478 info: NACodecInfoRef,
493 colhi_tree: [Tree; 16],
502 intradc: Bundle<u16>,
503 interdc: Bundle<i16>,
506 nresidues: Bundle<u8>,
514 fn calc_len(size: usize) -> u8 {
515 (32 - ((size + 511) as u32).leading_zeros()) as u8
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);
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);
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);
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 {
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)?;
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());
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)?;
612 fn put_block(&self, block: &[u8; 64], dst: &mut [u8], mut off: usize, stride: usize, scaled: bool) {
614 for src in block.chunks_exact(8) {
615 let out = &mut dst[off..][..8];
616 out.copy_from_slice(src);
620 for src in block.chunks_exact(8) {
622 dst[off + i * 2 + 0] = src[i];
623 dst[off + i * 2 + 1] = src[i];
627 dst[off + i * 2 + 0] = src[i];
628 dst[off + i * 2 + 1] = src[i];
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();
645 let src = &ppix[poff..][..8];
646 let out = &mut dst[off..][..8];
647 out.copy_from_slice(src);
653 Err(DecoderError::MissingReference)
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;
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)));
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]);
672 for row in block.chunks_exact(8) {
673 let out = &mut dst[off..][..8];
674 out.copy_from_slice(row);
680 fn add_block(&self, coeffs: &[i32; 64], dst: &mut [u8], mut off: usize, stride: usize) {
681 for src in coeffs.chunks_exact(8) {
683 let v = (dst[off + i] as i32) + src[i];
684 dst[off + i] = v as u8;
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];
693 idct!(coeffs, 8, tmp, 8, i, 0, 0);
695 for srow in tmp.chunks_exact(8) {
696 idct!(srow, 1, row, 1, 0, 0x7F, 8);
698 dst[off + i] = row[i] as u8;
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];
707 idct!(coeffs, 8, tmp, 8, i, 0, 0);
709 for srow in tmp.chunks_exact(8) {
710 idct!(srow, 1, row, 1, 0, 0x7F, 8);
712 let v = (dst[off + i] as i32) + row[i];
713 dst[off + i] = v as u8;
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);
733 self.read_bundles_binkb(br)?;
734 println!(" bline {} @ {}", by, br.tell());
736 let mut coeffs: [i32; 64] = [0; 64];
737 let btype = self.btype.get_val()?;
738 println!(" blk {}.{} type {}", bx,by,btype);
743 let scan = BINK_PATTERNS[br.read(4)? as usize];
746 let run = br.read_bool()?;
747 let len = (br.read(BINKB_RUN_BITS[idx])? as usize) + 1;
748 validate!(idx + len <= 64);
750 let val = self.colors.get_val()?;
752 let pos = scan[idx + j] as usize;
753 dst[off + (pos >> 3) * stride + (pos & 7)] = val;
758 let pos = scan[idx] as usize;
759 dst[off + (pos >> 3) * stride + (pos & 7)] = self.colors.get_val()?;
765 let pos = scan[idx] as usize;
766 dst[off + (pos >> 3) * stride + (pos & 7)] = self.colors.get_val()?;
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);
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);
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);
793 let fill = self.colors.get_val()?;
795 for j in 0..8 { dst[off + i * stride + j] = fill; }
799 let clr: [u8; 2] = [ self.colors.get_val()?, self.colors.get_val()? ];
801 let pattern = self.pattern.get_val()? as usize;
803 dst[off + i * stride + j] = clr[(pattern >> j) & 1];
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)?;
815 dst[off + i * stride + j] = self.colors.get_val()?;
819 _ => { return Err(DecoderError::InvalidData); },
823 off += stride * 8 - bw * 8;
825 if (br.tell() & 0x1F) != 0 {
826 let skip = (32 - (br.tell() & 0x1F)) as u32;
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];
838 self.copy_block(dst, off, stride, bx, by, 0, 0)?;
842 let sbtype = self.sbtype.get_val()?;
843 self.handle_block(br, bx, by, dst, off, stride, sbtype, true)?;
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)?;
852 let scan = BINK_PATTERNS[br.read(4)? as usize];
855 let run = (self.run.get_val()? as usize) + 1;
856 validate!(idx + run <= 64);
858 let val = self.colors.get_val()?;
860 oblock[scan[idx + j] as usize] = val;
865 oblock[scan[idx] as usize] = self.colors.get_val()?;
870 if idx == 63 { oblock[scan[63] as usize] = self.colors.get_val()?; }
871 self.put_block(&oblock, dst, off, stride, 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);
883 coeffs[0] = self.intradc.get_val()? as i32;
884 read_dct_coefficients(br, &mut coeffs, &BINK_SCAN, BINK_INTRA_QUANT, None)?;
886 self.idct_put(&coeffs, dst, off, stride);
888 self.idct_put(&coeffs, &mut oblock, 0, 8);
889 self.put_block(&oblock, dst, off, stride, scaled);
893 let fill = self.colors.get_val()?;
895 self.put_block(&oblock, dst, off, stride, 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);
907 let clr: [u8; 2] = [ self.colors.get_val()?, self.colors.get_val()? ];
909 let pattern = self.pattern.get_val()? as usize;
911 oblock[i * 8 + j] = clr[(pattern >> j) & 1];
914 self.put_block(&oblock, dst, off, stride, scaled);
919 oblock[i * 8 + j] = self.colors.get_val()?;
922 self.put_block(&oblock, dst, off, stride, scaled);
924 _ => { return Err(DecoderError::InvalidData); },
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)?;
942 self.read_bundles(br)?;
945 let btype = self.btype.get_val()?;
946 if btype == SCALED_BLOCK && (by & 1) == 1 { // already decoded scaled block, skip
950 self.handle_block(br, bx, by, dst, off + bx * 8, stride, btype, false)?;
951 if btype == SCALED_BLOCK {
958 if (br.tell() & 0x1F) != 0 {
959 let skip = (32 - (br.tell() & 0x1F)) as u32;
966 fn get_coef(br: &mut BitReader, bits1: u8) -> DecoderResult<i32> {
969 t = if br.read_bool()? { -1 } else { 1 };
971 let bits = bits1 - 1;
972 let val = (br.read(bits)? as i32) | (1 << bits);
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;
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;
998 let mut bits1 = br.read(4)? as u8;
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()? {
1011 coef_list[list_pos] = ccoef + 4;
1012 mode_list[list_pos] = 1;
1014 coef_list[list_pos] = 0;
1015 mode_list[list_pos] = 0;
1019 if br.read_bool()? {
1021 coef_list[list_start] = ccoef + i;
1022 mode_list[list_start] = 3;
1024 let idx = (ccoef + i) as usize;
1025 block[scan[idx]] = get_coef(br, bits1)?;
1026 coef_idx[coef_count] = idx;
1032 mode_list[list_pos] = 2;
1034 coef_list[list_end] = ccoef + i * 4 + 4;
1035 mode_list[list_end] = 2;
1040 let idx = ccoef as usize;
1041 block[scan[idx]] = get_coef(br, bits1)?;
1042 coef_idx[coef_count] = idx;
1044 coef_list[list_pos] = 0;
1045 mode_list[list_pos] = 0;
1048 _ => unreachable!(),
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;
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;
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;
1077 let mut mask = 1 << br.read(3)?;
1079 for i in 0..nz_coef_count {
1080 if !br.read_bool()? { continue; }
1081 let idx = nz_coef_idx[i];
1087 if masks_count == 0 {
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()? {
1103 coef_list[list_pos] = ccoef + 4;
1104 mode_list[list_pos] = 1;
1106 coef_list[list_pos] = 0;
1107 mode_list[list_pos] = 0;
1111 if br.read_bool()? {
1113 coef_list[list_start] = ccoef + i;
1114 mode_list[list_start] = 3;
1116 let idx = (ccoef + i) as usize;
1117 nz_coef_idx[nz_coef_count] = BINK_SCAN[idx];
1119 block[BINK_SCAN[idx]] = if br.read_bool()? { -mask } else { mask };
1120 if masks_count == 0 {
1128 mode_list[list_pos] = 2;
1130 coef_list[list_end] = ccoef + i * 4 + 4;
1131 mode_list[list_end] = 2;
1136 let idx = ccoef as usize;
1137 nz_coef_idx[nz_coef_count] = BINK_SCAN[idx];
1139 block[BINK_SCAN[idx]] = if br.read_bool()? { -mask } else { mask };
1140 coef_list[list_pos] = 0;
1141 mode_list[list_pos] = 0;
1143 if masks_count == 0 {
1148 _ => unreachable!(),
1157 const BINK_FLAG_ALPHA: u32 = 0x00100000;
1158 const BINK_FLAG_GRAY: u32 = 0x00020000;
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();
1166 let edata = info.get_extradata().unwrap();
1167 validate!(edata.len() >= 8);
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()?;
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); }
1181 let aplane = if self.has_alpha { Some(NAPixelChromaton::new(0, 0, false, 8, 0, 3, 1)) } else { None };
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)),
1189 0, if self.has_alpha { 4 } else { 3 } );
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);
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();
1198 //self.init_bundle_lengths(w.max(8), (w + 7) >> 3);
1199 self.init_bundle_bufs((w + 7) >> 3, (h + 7) >> 3);
1202 self.qmat_b.calc_binkb_quants();
1207 Err(DecoderError::InvalidData)
1210 fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
1211 let src = pkt.get_buffer();
1213 let mut br = BitReader::new(&src, BitReaderMode::LE);
1216 self.key_frame = pkt.is_keyframe();
1218 let bufret = self.hams.clone_ref();
1219 if let Some(bbuf) = bufret {
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();
1229 let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 4)?;
1230 buf = bufinfo.get_vbuf().unwrap();
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 };
1236 validate!(!self.is_ver_b);
1240 self.decode_plane(&mut br, nplanes, &mut buf)?;
1245 for plane in 0..nplanes {
1247 self.decode_plane_binkb(&mut br, plane, &mut buf)?;
1249 let plane_idx = if plane > 0 && self.swap_uv { plane ^ 3 } else { plane };
1250 self.decode_plane(&mut br, plane_idx, &mut buf)?;
1253 let bufinfo = NABufferType::Video(buf);
1255 self.ips.add_frame(bufinfo.get_vbuf().unwrap());
1258 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
1259 frm.set_frame_type(FrameType::P);
1262 fn flush(&mut self) {
1267 pub fn get_decoder() -> Box<dyn NADecoder + Send> {
1268 Box::new(BinkDecoder::new())
1273 use nihav_core::codecs::RegisteredDecoders;
1274 use nihav_core::demuxers::RegisteredDemuxers;
1275 use nihav_codec_support::test::dec_video::*;
1276 use crate::rad_register_all_codecs;
1277 use crate::rad_register_all_demuxers;
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);
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);
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);
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
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 ]
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 ]
1347 const BINK_PATTERNS: [[u8; 64]; 16] = [
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
1495 const BINK_INTRA_QUANT: &[[i32; 64]; 16] = &[
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
1643 const BINK_INTER_QUANT: &[[i32; 64]; 16] = &[
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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
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
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
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)