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