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);
1263 pub fn get_decoder() -> Box<dyn NADecoder> {
1264 Box::new(BinkDecoder::new())
1269 use nihav_core::codecs::RegisteredDecoders;
1270 use nihav_core::demuxers::RegisteredDemuxers;
1271 use nihav_core::test::dec_video::*;
1272 use crate::codecs::rad_register_all_codecs;
1273 use crate::demuxers::rad_register_all_demuxers;
1276 let mut dmx_reg = RegisteredDemuxers::new();
1277 rad_register_all_demuxers(&mut dmx_reg);
1278 let mut dec_reg = RegisteredDecoders::new();
1279 rad_register_all_codecs(&mut dec_reg);
1281 let file = "assets/RAD/NEW.BIK";
1282 //let file = "assets/RAD/NWCLOGO.BIK";
1283 test_file_decoding("bink", file, Some(42), true, false, None/*Some("bink-b")*/, &dmx_reg, &dec_reg);
1285 //let file = "assets/RAD/bink_dct.bik";
1286 //let file = "assets/RAD/day3-b.bik";
1287 let file = "assets/RAD/ActivisionLogo.bik";
1288 //let file = "assets/RAD/ATI-9700-Animusic-Movie-v1.0.bik";
1289 //let file = "assets/RAD/original.bik";
1290 test_file_decoding("bink", file, Some(42), true, false, None/*Some("bink-")*/, &dmx_reg, &dec_reg);
1294 const BINK_SCAN: [usize; 64] = [
1295 0, 1, 8, 9, 2, 3, 10, 11,
1296 4, 5, 12, 13, 6, 7, 14, 15,
1297 20, 21, 28, 29, 22, 23, 30, 31,
1298 16, 17, 24, 25, 32, 33, 40, 41,
1299 34, 35, 42, 43, 48, 49, 56, 57,
1300 50, 51, 58, 59, 18, 19, 26, 27,
1301 36, 37, 44, 45, 38, 39, 46, 47,
1302 52, 53, 60, 61, 54, 55, 62, 63
1305 const BINK_TREE_CODES: [[u8; 16]; 16] = [
1306 [ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F ],
1307 [ 0x00, 0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F ],
1308 [ 0x00, 0x02, 0x01, 0x09, 0x05, 0x15, 0x0D, 0x1D, 0x03, 0x13, 0x0B, 0x1B, 0x07, 0x17, 0x0F, 0x1F ],
1309 [ 0x00, 0x02, 0x06, 0x01, 0x09, 0x05, 0x0D, 0x1D, 0x03, 0x13, 0x0B, 0x1B, 0x07, 0x17, 0x0F, 0x1F ],
1310 [ 0x00, 0x04, 0x02, 0x06, 0x01, 0x09, 0x05, 0x0D, 0x03, 0x13, 0x0B, 0x1B, 0x07, 0x17, 0x0F, 0x1F ],
1311 [ 0x00, 0x04, 0x02, 0x0A, 0x06, 0x0E, 0x01, 0x09, 0x05, 0x0D, 0x03, 0x0B, 0x07, 0x17, 0x0F, 0x1F ],
1312 [ 0x00, 0x02, 0x0A, 0x06, 0x0E, 0x01, 0x09, 0x05, 0x0D, 0x03, 0x0B, 0x1B, 0x07, 0x17, 0x0F, 0x1F ],
1313 [ 0x00, 0x01, 0x05, 0x03, 0x13, 0x0B, 0x1B, 0x3B, 0x07, 0x27, 0x17, 0x37, 0x0F, 0x2F, 0x1F, 0x3F ],
1314 [ 0x00, 0x01, 0x03, 0x13, 0x0B, 0x2B, 0x1B, 0x3B, 0x07, 0x27, 0x17, 0x37, 0x0F, 0x2F, 0x1F, 0x3F ],
1315 [ 0x00, 0x01, 0x05, 0x0D, 0x03, 0x13, 0x0B, 0x1B, 0x07, 0x27, 0x17, 0x37, 0x0F, 0x2F, 0x1F, 0x3F ],
1316 [ 0x00, 0x02, 0x01, 0x05, 0x0D, 0x03, 0x13, 0x0B, 0x1B, 0x07, 0x17, 0x37, 0x0F, 0x2F, 0x1F, 0x3F ],
1317 [ 0x00, 0x01, 0x09, 0x05, 0x0D, 0x03, 0x13, 0x0B, 0x1B, 0x07, 0x17, 0x37, 0x0F, 0x2F, 0x1F, 0x3F ],
1318 [ 0x00, 0x02, 0x01, 0x03, 0x13, 0x0B, 0x1B, 0x3B, 0x07, 0x27, 0x17, 0x37, 0x0F, 0x2F, 0x1F, 0x3F ],
1319 [ 0x00, 0x01, 0x05, 0x03, 0x07, 0x27, 0x17, 0x37, 0x0F, 0x4F, 0x2F, 0x6F, 0x1F, 0x5F, 0x3F, 0x7F ],
1320 [ 0x00, 0x01, 0x05, 0x03, 0x07, 0x17, 0x37, 0x77, 0x0F, 0x4F, 0x2F, 0x6F, 0x1F, 0x5F, 0x3F, 0x7F ],
1321 [ 0x00, 0x02, 0x01, 0x05, 0x03, 0x07, 0x27, 0x17, 0x37, 0x0F, 0x2F, 0x6F, 0x1F, 0x5F, 0x3F, 0x7F ]
1324 const BINK_TREE_BITS: [[u8; 16]; 16] = [
1325 [ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 ],
1326 [ 1, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 ],
1327 [ 2, 2, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 ],
1328 [ 2, 3, 3, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 ],
1329 [ 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5 ],
1330 [ 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5 ],
1331 [ 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5 ],
1332 [ 1, 3, 3, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6 ],
1333 [ 1, 2, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6 ],
1334 [ 1, 3, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6 ],
1335 [ 2, 2, 3, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6 ],
1336 [ 1, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6 ],
1337 [ 2, 2, 2, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6 ],
1338 [ 1, 3, 3, 3, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7 ],
1339 [ 1, 3, 3, 3, 5, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7 ],
1340 [ 2, 2, 3, 3, 3, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7 ]
1343 const BINK_PATTERNS: [[u8; 64]; 16] = [
1345 0x00, 0x08, 0x10, 0x18, 0x20, 0x28, 0x30, 0x38,
1346 0x39, 0x31, 0x29, 0x21, 0x19, 0x11, 0x09, 0x01,
1347 0x02, 0x0A, 0x12, 0x1A, 0x22, 0x2A, 0x32, 0x3A,
1348 0x3B, 0x33, 0x2B, 0x23, 0x1B, 0x13, 0x0B, 0x03,
1349 0x04, 0x0C, 0x14, 0x1C, 0x24, 0x2C, 0x34, 0x3C,
1350 0x3D, 0x35, 0x2D, 0x25, 0x1D, 0x15, 0x0D, 0x05,
1351 0x06, 0x0E, 0x16, 0x1E, 0x26, 0x2E, 0x36, 0x3E,
1352 0x3F, 0x37, 0x2F, 0x27, 0x1F, 0x17, 0x0F, 0x07,
1354 0x3B, 0x3A, 0x39, 0x38, 0x30, 0x31, 0x32, 0x33,
1355 0x2B, 0x2A, 0x29, 0x28, 0x20, 0x21, 0x22, 0x23,
1356 0x1B, 0x1A, 0x19, 0x18, 0x10, 0x11, 0x12, 0x13,
1357 0x0B, 0x0A, 0x09, 0x08, 0x00, 0x01, 0x02, 0x03,
1358 0x04, 0x05, 0x06, 0x07, 0x0F, 0x0E, 0x0D, 0x0C,
1359 0x14, 0x15, 0x16, 0x17, 0x1F, 0x1E, 0x1D, 0x1C,
1360 0x24, 0x25, 0x26, 0x27, 0x2F, 0x2E, 0x2D, 0x2C,
1361 0x34, 0x35, 0x36, 0x37, 0x3F, 0x3E, 0x3D, 0x3C,
1363 0x19, 0x11, 0x12, 0x1A, 0x1B, 0x13, 0x0B, 0x03,
1364 0x02, 0x0A, 0x09, 0x01, 0x00, 0x08, 0x10, 0x18,
1365 0x20, 0x28, 0x30, 0x38, 0x39, 0x31, 0x29, 0x2A,
1366 0x32, 0x3A, 0x3B, 0x33, 0x2B, 0x23, 0x22, 0x21,
1367 0x1D, 0x15, 0x16, 0x1E, 0x1F, 0x17, 0x0F, 0x07,
1368 0x06, 0x0E, 0x0D, 0x05, 0x04, 0x0C, 0x14, 0x1C,
1369 0x24, 0x2C, 0x34, 0x3C, 0x3D, 0x35, 0x2D, 0x2E,
1370 0x36, 0x3E, 0x3F, 0x37, 0x2F, 0x27, 0x26, 0x25,
1372 0x03, 0x0B, 0x02, 0x0A, 0x01, 0x09, 0x00, 0x08,
1373 0x10, 0x18, 0x11, 0x19, 0x12, 0x1A, 0x13, 0x1B,
1374 0x23, 0x2B, 0x22, 0x2A, 0x21, 0x29, 0x20, 0x28,
1375 0x30, 0x38, 0x31, 0x39, 0x32, 0x3A, 0x33, 0x3B,
1376 0x3C, 0x34, 0x3D, 0x35, 0x3E, 0x36, 0x3F, 0x37,
1377 0x2F, 0x27, 0x2E, 0x26, 0x2D, 0x25, 0x2C, 0x24,
1378 0x1C, 0x14, 0x1D, 0x15, 0x1E, 0x16, 0x1F, 0x17,
1379 0x0F, 0x07, 0x0E, 0x06, 0x0D, 0x05, 0x0C, 0x04,
1381 0x18, 0x19, 0x10, 0x11, 0x08, 0x09, 0x00, 0x01,
1382 0x02, 0x03, 0x0A, 0x0B, 0x12, 0x13, 0x1A, 0x1B,
1383 0x1C, 0x1D, 0x14, 0x15, 0x0C, 0x0D, 0x04, 0x05,
1384 0x06, 0x07, 0x0E, 0x0F, 0x16, 0x17, 0x1E, 0x1F,
1385 0x27, 0x26, 0x2F, 0x2E, 0x37, 0x36, 0x3F, 0x3E,
1386 0x3D, 0x3C, 0x35, 0x34, 0x2D, 0x2C, 0x25, 0x24,
1387 0x23, 0x22, 0x2B, 0x2A, 0x33, 0x32, 0x3B, 0x3A,
1388 0x39, 0x38, 0x31, 0x30, 0x29, 0x28, 0x21, 0x20,
1390 0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
1391 0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B,
1392 0x20, 0x21, 0x22, 0x23, 0x28, 0x29, 0x2A, 0x2B,
1393 0x30, 0x31, 0x32, 0x33, 0x38, 0x39, 0x3A, 0x3B,
1394 0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
1395 0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F,
1396 0x24, 0x25, 0x26, 0x27, 0x2C, 0x2D, 0x2E, 0x2F,
1397 0x34, 0x35, 0x36, 0x37, 0x3C, 0x3D, 0x3E, 0x3F,
1399 0x06, 0x07, 0x0F, 0x0E, 0x0D, 0x05, 0x0C, 0x04,
1400 0x03, 0x0B, 0x02, 0x0A, 0x09, 0x01, 0x00, 0x08,
1401 0x10, 0x18, 0x11, 0x19, 0x12, 0x1A, 0x13, 0x1B,
1402 0x14, 0x1C, 0x15, 0x1D, 0x16, 0x1E, 0x17, 0x1F,
1403 0x27, 0x2F, 0x26, 0x2E, 0x25, 0x2D, 0x24, 0x2C,
1404 0x23, 0x2B, 0x22, 0x2A, 0x21, 0x29, 0x20, 0x28,
1405 0x31, 0x30, 0x38, 0x39, 0x3A, 0x32, 0x3B, 0x33,
1406 0x3C, 0x34, 0x3D, 0x35, 0x36, 0x37, 0x3F, 0x3E,
1408 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1409 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08,
1410 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1411 0x1F, 0x1E, 0x1D, 0x1C, 0x1B, 0x1A, 0x19, 0x18,
1412 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
1413 0x2F, 0x2E, 0x2D, 0x2C, 0x2B, 0x2A, 0x29, 0x28,
1414 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
1415 0x3F, 0x3E, 0x3D, 0x3C, 0x3B, 0x3A, 0x39, 0x38,
1417 0x00, 0x08, 0x09, 0x01, 0x02, 0x03, 0x0B, 0x0A,
1418 0x12, 0x13, 0x1B, 0x1A, 0x19, 0x11, 0x10, 0x18,
1419 0x20, 0x28, 0x29, 0x21, 0x22, 0x23, 0x2B, 0x2A,
1420 0x32, 0x31, 0x30, 0x38, 0x39, 0x3A, 0x3B, 0x33,
1421 0x34, 0x3C, 0x3D, 0x3E, 0x3F, 0x37, 0x36, 0x35,
1422 0x2D, 0x2C, 0x24, 0x25, 0x26, 0x2E, 0x2F, 0x27,
1423 0x1F, 0x17, 0x16, 0x1E, 0x1D, 0x1C, 0x14, 0x15,
1424 0x0D, 0x0C, 0x04, 0x05, 0x06, 0x0E, 0x0F, 0x07,
1426 0x18, 0x19, 0x10, 0x11, 0x08, 0x09, 0x00, 0x01,
1427 0x02, 0x03, 0x0A, 0x0B, 0x12, 0x13, 0x1A, 0x1B,
1428 0x1C, 0x1D, 0x14, 0x15, 0x0C, 0x0D, 0x04, 0x05,
1429 0x06, 0x07, 0x0E, 0x0F, 0x16, 0x17, 0x1E, 0x1F,
1430 0x26, 0x27, 0x2E, 0x2F, 0x36, 0x37, 0x3E, 0x3F,
1431 0x3C, 0x3D, 0x34, 0x35, 0x2C, 0x2D, 0x24, 0x25,
1432 0x22, 0x23, 0x2A, 0x2B, 0x32, 0x33, 0x3A, 0x3B,
1433 0x38, 0x39, 0x30, 0x31, 0x28, 0x29, 0x20, 0x21,
1435 0x00, 0x08, 0x01, 0x09, 0x02, 0x0A, 0x03, 0x0B,
1436 0x13, 0x1B, 0x12, 0x1A, 0x11, 0x19, 0x10, 0x18,
1437 0x20, 0x28, 0x21, 0x29, 0x22, 0x2A, 0x23, 0x2B,
1438 0x33, 0x3B, 0x32, 0x3A, 0x31, 0x39, 0x30, 0x38,
1439 0x3C, 0x34, 0x3D, 0x35, 0x3E, 0x36, 0x3F, 0x37,
1440 0x2F, 0x27, 0x2E, 0x26, 0x2D, 0x25, 0x2C, 0x24,
1441 0x1F, 0x17, 0x1E, 0x16, 0x1D, 0x15, 0x1C, 0x14,
1442 0x0C, 0x04, 0x0D, 0x05, 0x0E, 0x06, 0x0F, 0x07,
1444 0x00, 0x08, 0x10, 0x18, 0x19, 0x1A, 0x1B, 0x13,
1445 0x0B, 0x03, 0x02, 0x01, 0x09, 0x11, 0x12, 0x0A,
1446 0x04, 0x0C, 0x14, 0x1C, 0x1D, 0x1E, 0x1F, 0x17,
1447 0x0F, 0x07, 0x06, 0x05, 0x0D, 0x15, 0x16, 0x0E,
1448 0x24, 0x2C, 0x34, 0x3C, 0x3D, 0x3E, 0x3F, 0x37,
1449 0x2F, 0x27, 0x26, 0x25, 0x2D, 0x35, 0x36, 0x2E,
1450 0x20, 0x28, 0x30, 0x38, 0x39, 0x3A, 0x3B, 0x33,
1451 0x2B, 0x23, 0x22, 0x21, 0x29, 0x31, 0x32, 0x2A,
1453 0x00, 0x08, 0x09, 0x01, 0x02, 0x03, 0x0B, 0x0A,
1454 0x13, 0x1B, 0x1A, 0x12, 0x11, 0x10, 0x18, 0x19,
1455 0x21, 0x20, 0x28, 0x29, 0x2A, 0x22, 0x23, 0x2B,
1456 0x33, 0x3B, 0x3A, 0x32, 0x31, 0x39, 0x38, 0x30,
1457 0x34, 0x3C, 0x3D, 0x35, 0x36, 0x3E, 0x3F, 0x37,
1458 0x2F, 0x27, 0x26, 0x2E, 0x2D, 0x2C, 0x24, 0x25,
1459 0x1D, 0x1C, 0x14, 0x15, 0x16, 0x1E, 0x1F, 0x17,
1460 0x0E, 0x0F, 0x07, 0x06, 0x05, 0x0D, 0x0C, 0x04,
1462 0x18, 0x10, 0x08, 0x00, 0x01, 0x02, 0x03, 0x0B,
1463 0x13, 0x1B, 0x1A, 0x19, 0x11, 0x0A, 0x09, 0x12,
1464 0x1C, 0x14, 0x0C, 0x04, 0x05, 0x06, 0x07, 0x0F,
1465 0x17, 0x1F, 0x1E, 0x1D, 0x15, 0x0E, 0x0D, 0x16,
1466 0x3C, 0x34, 0x2C, 0x24, 0x25, 0x26, 0x27, 0x2F,
1467 0x37, 0x3F, 0x3E, 0x3D, 0x35, 0x2E, 0x2D, 0x36,
1468 0x38, 0x30, 0x28, 0x20, 0x21, 0x22, 0x23, 0x2B,
1469 0x33, 0x3B, 0x3A, 0x39, 0x31, 0x2A, 0x29, 0x32,
1471 0x00, 0x08, 0x09, 0x01, 0x02, 0x0A, 0x12, 0x11,
1472 0x10, 0x18, 0x19, 0x1A, 0x1B, 0x13, 0x0B, 0x03,
1473 0x07, 0x06, 0x0E, 0x0F, 0x17, 0x16, 0x15, 0x0D,
1474 0x05, 0x04, 0x0C, 0x14, 0x1C, 0x1D, 0x1E, 0x1F,
1475 0x3F, 0x3E, 0x36, 0x37, 0x2F, 0x2E, 0x2D, 0x35,
1476 0x3D, 0x3C, 0x34, 0x2C, 0x24, 0x25, 0x26, 0x27,
1477 0x38, 0x30, 0x31, 0x39, 0x3A, 0x32, 0x2A, 0x29,
1478 0x28, 0x20, 0x21, 0x22, 0x23, 0x2B, 0x33, 0x3B,
1480 0x00, 0x01, 0x08, 0x09, 0x10, 0x11, 0x18, 0x19,
1481 0x20, 0x21, 0x28, 0x29, 0x30, 0x31, 0x38, 0x39,
1482 0x3A, 0x3B, 0x32, 0x33, 0x2A, 0x2B, 0x22, 0x23,
1483 0x1A, 0x1B, 0x12, 0x13, 0x0A, 0x0B, 0x02, 0x03,
1484 0x04, 0x05, 0x0C, 0x0D, 0x14, 0x15, 0x1C, 0x1D,
1485 0x24, 0x25, 0x2C, 0x2D, 0x34, 0x35, 0x3C, 0x3D,
1486 0x3E, 0x3F, 0x36, 0x37, 0x2E, 0x2F, 0x26, 0x27,
1487 0x1E, 0x1F, 0x16, 0x17, 0x0E, 0x0F, 0x06, 0x07,
1491 const BINK_INTRA_QUANT: &[[i32; 64]; 16] = &[
1493 0x010000, 0x016315, 0x01E83D, 0x02A535, 0x014E7B, 0x016577, 0x02F1E6, 0x02724C,
1494 0x010000, 0x00EEDA, 0x024102, 0x017F9B, 0x00BE80, 0x00611E, 0x01083C, 0x00A552,
1495 0x021F88, 0x01DC53, 0x027FAD, 0x01F697, 0x014819, 0x00A743, 0x015A31, 0x009688,
1496 0x02346F, 0x030EE5, 0x01FBFA, 0x02C096, 0x01D000, 0x028396, 0x019247, 0x01F9AA,
1497 0x02346F, 0x01FBFA, 0x01DC53, 0x0231B8, 0x012F12, 0x01E06C, 0x00CB10, 0x0119A8,
1498 0x01C48C, 0x019748, 0x014E86, 0x0122AF, 0x02C628, 0x027F20, 0x0297B5, 0x023F32,
1499 0x025000, 0x01AB6B, 0x01D122, 0x0159B3, 0x012669, 0x008D43, 0x00EE1F, 0x0075ED,
1500 0x01490C, 0x010288, 0x00F735, 0x00EF51, 0x00E0F1, 0x0072AD, 0x00A4D8, 0x006517,
1502 0x015555, 0x01D971, 0x028AFC, 0x0386F1, 0x01BDF9, 0x01DC9F, 0x03ED33, 0x034311,
1503 0x015555, 0x013E78, 0x030158, 0x01FF7A, 0x00FE00, 0x00817D, 0x01604F, 0x00DC6D,
1504 0x02D4B5, 0x027B19, 0x0354E7, 0x029E1F, 0x01B577, 0x00DF04, 0x01CD96, 0x00C8B6,
1505 0x02F095, 0x0413DC, 0x02A54E, 0x03AB73, 0x026AAB, 0x035A1E, 0x02185E, 0x02A238,
1506 0x02F095, 0x02A54E, 0x027B19, 0x02ECF5, 0x019418, 0x028090, 0x010EC0, 0x01778A,
1507 0x025B66, 0x021F0B, 0x01BE09, 0x018394, 0x03B2E0, 0x03542A, 0x0374F1, 0x02FEEE,
1508 0x031555, 0x0239E4, 0x026C2D, 0x01CCEE, 0x01888C, 0x00BC59, 0x013D7E, 0x009D3C,
1509 0x01B6BB, 0x0158B5, 0x01499C, 0x013F17, 0x012BEC, 0x0098E6, 0x00DBCB, 0x0086C9,
1511 0x01AAAB, 0x024FCE, 0x032DBB, 0x0468AD, 0x022D78, 0x0253C7, 0x04E87F, 0x0413D5,
1512 0x01AAAB, 0x018E16, 0x03C1AE, 0x027F58, 0x013D80, 0x00A1DC, 0x01B863, 0x011388,
1513 0x0389E2, 0x0319DF, 0x042A21, 0x0345A7, 0x0222D4, 0x0116C5, 0x0240FC, 0x00FAE3,
1514 0x03ACBA, 0x0518D3, 0x034EA1, 0x04964F, 0x030555, 0x0430A5, 0x029E76, 0x034AC5,
1515 0x03ACBA, 0x034EA1, 0x0319DF, 0x03A833, 0x01F91E, 0x0320B4, 0x015270, 0x01D56D,
1516 0x02F23F, 0x02A6CE, 0x022D8B, 0x01E479, 0x049F98, 0x042935, 0x04522D, 0x03BEA9,
1517 0x03DAAB, 0x02C85D, 0x030738, 0x02402A, 0x01EAAF, 0x00EB6F, 0x018CDE, 0x00C48A,
1518 0x022469, 0x01AEE2, 0x019C02, 0x018EDD, 0x0176E7, 0x00BF20, 0x0112BE, 0x00A87B,
1520 0x020000, 0x02C62A, 0x03D07A, 0x054A69, 0x029CF6, 0x02CAEF, 0x05E3CC, 0x04E499,
1521 0x020000, 0x01DDB4, 0x048204, 0x02FF36, 0x017D01, 0x00C23C, 0x021077, 0x014AA3,
1522 0x043F0F, 0x03B8A6, 0x04FF5A, 0x03ED2E, 0x029032, 0x014E86, 0x02B461, 0x012D11,
1523 0x0468DF, 0x061DCA, 0x03F7F5, 0x05812C, 0x03A000, 0x05072C, 0x03248D, 0x03F353,
1524 0x0468DF, 0x03F7F5, 0x03B8A6, 0x046370, 0x025E24, 0x03C0D8, 0x019620, 0x02334F,
1525 0x038919, 0x032E91, 0x029D0D, 0x02455E, 0x058C50, 0x04FE3F, 0x052F69, 0x047E65,
1526 0x04A000, 0x0356D6, 0x03A243, 0x02B365, 0x024CD2, 0x011A85, 0x01DC3E, 0x00EBD9,
1527 0x029218, 0x020510, 0x01EE69, 0x01DEA2, 0x01C1E2, 0x00E559, 0x0149B0, 0x00CA2D,
1529 0x02AAAB, 0x03B2E3, 0x0515F8, 0x070DE2, 0x037BF2, 0x03B93E, 0x07DA65, 0x068621,
1530 0x02AAAB, 0x027CF0, 0x0602B1, 0x03FEF3, 0x01FC01, 0x0102FA, 0x02C09F, 0x01B8DA,
1531 0x05A96A, 0x04F632, 0x06A9CE, 0x053C3E, 0x036AED, 0x01BE09, 0x039B2D, 0x01916B,
1532 0x05E129, 0x0827B8, 0x054A9C, 0x0756E5, 0x04D555, 0x06B43B, 0x0430BC, 0x05446F,
1533 0x05E129, 0x054A9C, 0x04F632, 0x05D9EB, 0x032830, 0x050121, 0x021D80, 0x02EF14,
1534 0x04B6CC, 0x043E16, 0x037C11, 0x030728, 0x0765C0, 0x06A855, 0x06E9E2, 0x05FDDB,
1535 0x062AAB, 0x0473C8, 0x04D85A, 0x0399DC, 0x031118, 0x0178B2, 0x027AFD, 0x013A77,
1536 0x036D76, 0x02B16A, 0x029337, 0x027E2E, 0x0257D8, 0x0131CC, 0x01B796, 0x010D91,
1538 0x038000, 0x04DACA, 0x06ACD5, 0x094238, 0x0492AE, 0x04E322, 0x0A4EA5, 0x08900C,
1539 0x038000, 0x0343FB, 0x07E388, 0x053E9F, 0x029AC1, 0x0153E8, 0x039CD0, 0x02429E,
1540 0x076E5B, 0x068322, 0x08BEDE, 0x06DF11, 0x047C57, 0x02496B, 0x04BBAB, 0x020EDD,
1541 0x07B786, 0x0AB421, 0x06F1ED, 0x09A20D, 0x065800, 0x08CC8E, 0x057FF7, 0x06E9D2,
1542 0x07B786, 0x06F1ED, 0x068322, 0x07AE04, 0x0424BF, 0x06917B, 0x02C6B8, 0x03D9CB,
1543 0x062FEB, 0x05917D, 0x0492D7, 0x03F964, 0x09B58C, 0x08BCEF, 0x0912F8, 0x07DD30,
1544 0x081800, 0x05D7F7, 0x065BF6, 0x04B9F1, 0x040670, 0x01EE69, 0x03416C, 0x019CBC,
1545 0x047FAA, 0x0388DC, 0x036138, 0x03459C, 0x03134C, 0x01915C, 0x0240F5, 0x0161CF,
1547 0x040000, 0x058C54, 0x07A0F4, 0x0A94D3, 0x0539EC, 0x0595DD, 0x0BC798, 0x09C932,
1548 0x040000, 0x03BB68, 0x090409, 0x05FE6D, 0x02FA01, 0x018477, 0x0420EE, 0x029547,
1549 0x087E1F, 0x07714C, 0x09FEB5, 0x07DA5D, 0x052064, 0x029D0D, 0x0568C3, 0x025A21,
1550 0x08D1BE, 0x0C3B94, 0x07EFEA, 0x0B0258, 0x074000, 0x0A0E59, 0x06491A, 0x07E6A7,
1551 0x08D1BE, 0x07EFEA, 0x07714C, 0x08C6E0, 0x04BC48, 0x0781B1, 0x032C3F, 0x04669F,
1552 0x071232, 0x065D22, 0x053A1A, 0x048ABC, 0x0B18A0, 0x09FC7F, 0x0A5ED3, 0x08FCC9,
1553 0x094000, 0x06ADAC, 0x074487, 0x0566CA, 0x0499A5, 0x02350B, 0x03B87B, 0x01D7B3,
1554 0x052430, 0x040A20, 0x03DCD3, 0x03BD45, 0x0383C5, 0x01CAB3, 0x029361, 0x01945A,
1556 0x050000, 0x06EF69, 0x098931, 0x0D3A07, 0x068867, 0x06FB55, 0x0EB97E, 0x0C3B7E,
1557 0x050000, 0x04AA42, 0x0B450B, 0x077E08, 0x03B881, 0x01E595, 0x05292A, 0x033A99,
1558 0x0A9DA7, 0x094D9F, 0x0C7E62, 0x09D0F4, 0x06687D, 0x034450, 0x06C2F4, 0x02F0AA,
1559 0x0B062D, 0x0F4A78, 0x09EBE4, 0x0DC2EE, 0x091000, 0x0C91EF, 0x07DB61, 0x09E050,
1560 0x0B062D, 0x09EBE4, 0x094D9F, 0x0AF898, 0x05EB59, 0x09621D, 0x03F74F, 0x058046,
1561 0x08D6BE, 0x07F46A, 0x0688A0, 0x05AD6B, 0x0DDEC8, 0x0C7B9F, 0x0CF687, 0x0B3BFB,
1562 0x0B9000, 0x085917, 0x0915A8, 0x06C07D, 0x05C00E, 0x02C24D, 0x04A69A, 0x024D9F,
1563 0x066D3C, 0x050CA7, 0x04D407, 0x04AC96, 0x0464B6, 0x023D5F, 0x033839, 0x01F971,
1565 0x060000, 0x08527E, 0x0B716E, 0x0FDF3C, 0x07D6E1, 0x0860CC, 0x11AB63, 0x0EADCB,
1566 0x060000, 0x05991C, 0x0D860D, 0x08FDA3, 0x047702, 0x0246B3, 0x063165, 0x03DFEA,
1567 0x0CBD2E, 0x0B29F1, 0x0EFE0F, 0x0BC78B, 0x07B096, 0x03EB93, 0x081D24, 0x038732,
1568 0x0D3A9C, 0x12595D, 0x0BE7DF, 0x108384, 0x0AE000, 0x0F1585, 0x096DA8, 0x0BD9FA,
1569 0x0D3A9C, 0x0BE7DF, 0x0B29F1, 0x0D2A50, 0x071A6B, 0x0B4289, 0x04C25F, 0x0699EE,
1570 0x0A9B4A, 0x098BB2, 0x07D727, 0x06D01A, 0x10A4F0, 0x0EFABE, 0x0F8E3C, 0x0D7B2E,
1571 0x0DE000, 0x0A0482, 0x0AE6CA, 0x081A2F, 0x06E677, 0x034F90, 0x0594B9, 0x02C38C,
1572 0x07B649, 0x060F2F, 0x05CB3C, 0x059BE7, 0x0545A7, 0x02B00C, 0x03DD11, 0x025E87,
1574 0x080000, 0x0B18A8, 0x0F41E8, 0x1529A5, 0x0A73D7, 0x0B2BBB, 0x178F2F, 0x139264,
1575 0x080000, 0x0776CF, 0x120812, 0x0BFCD9, 0x05F402, 0x0308EF, 0x0841DC, 0x052A8E,
1576 0x10FC3E, 0x0EE297, 0x13FD69, 0x0FB4B9, 0x0A40C8, 0x053A1A, 0x0AD186, 0x04B442,
1577 0x11A37B, 0x187727, 0x0FDFD4, 0x1604B0, 0x0E8000, 0x141CB1, 0x0C9235, 0x0FCD4D,
1578 0x11A37B, 0x0FDFD4, 0x0EE297, 0x118DC0, 0x09788F, 0x0F0362, 0x06587F, 0x08CD3D,
1579 0x0E2463, 0x0CBA43, 0x0A7434, 0x091577, 0x163140, 0x13F8FE, 0x14BDA5, 0x11F992,
1580 0x128000, 0x0D5B58, 0x0E890D, 0x0ACD94, 0x093349, 0x046A15, 0x0770F7, 0x03AF65,
1581 0x0A4861, 0x08143F, 0x07B9A6, 0x077A89, 0x070789, 0x039565, 0x0526C2, 0x0328B4,
1583 0x0C0000, 0x10A4FD, 0x16E2DB, 0x1FBE78, 0x0FADC3, 0x10C198, 0x2356C7, 0x1D5B96,
1584 0x0C0000, 0x0B3237, 0x1B0C1A, 0x11FB46, 0x08EE03, 0x048D66, 0x0C62CA, 0x07BFD5,
1585 0x197A5D, 0x1653E3, 0x1DFC1E, 0x178F16, 0x0F612C, 0x07D727, 0x103A49, 0x070E64,
1586 0x1A7539, 0x24B2BB, 0x17CFBD, 0x210709, 0x15C000, 0x1E2B0A, 0x12DB4F, 0x17B3F4,
1587 0x1A7539, 0x17CFBD, 0x1653E3, 0x1A54A0, 0x0E34D7, 0x168513, 0x0984BE, 0x0D33DC,
1588 0x153695, 0x131765, 0x0FAE4E, 0x0DA033, 0x2149E1, 0x1DF57D, 0x1F1C78, 0x1AF65B,
1589 0x1BC000, 0x140904, 0x15CD94, 0x10345E, 0x0DCCEE, 0x069F20, 0x0B2972, 0x058718,
1590 0x0F6C91, 0x0C1E5E, 0x0B9678, 0x0B37CE, 0x0A8B4E, 0x056018, 0x07BA22, 0x04BD0E,
1592 0x110000, 0x179466, 0x206C0C, 0x2CF87F, 0x16362A, 0x17BCED, 0x321044, 0x299714,
1593 0x110000, 0x0FDC79, 0x265125, 0x19794E, 0x0CA685, 0x0672FB, 0x118BF4, 0x0AFA6D,
1594 0x241804, 0x1FA181, 0x2A7A80, 0x21600A, 0x15C9A9, 0x0B1B77, 0x16FD3C, 0x09FF0D,
1595 0x257B66, 0x33FD33, 0x21BBA2, 0x2EC9F7, 0x1ED000, 0x2ABCF9, 0x1AB6B0, 0x219444,
1596 0x257B66, 0x21BBA2, 0x1FA181, 0x254D38, 0x142030, 0x1FE730, 0x0D7C0E, 0x12B423,
1597 0x1E0D52, 0x1B0BCF, 0x1636EE, 0x134D9E, 0x2F28A9, 0x2A711B, 0x2C12FF, 0x263256,
1598 0x275000, 0x1C621B, 0x1EE33C, 0x16F4DB, 0x138CFB, 0x09616E, 0x0FD00C, 0x07D4B7,
1599 0x15D9CE, 0x112B06, 0x106A80, 0x0FE464, 0x0EF004, 0x079D77, 0x0AF25B, 0x06B67F,
1601 0x160000, 0x1E83CF, 0x29F53D, 0x3A3286, 0x1CBE90, 0x1EB842, 0x40C9C2, 0x35D293,
1602 0x160000, 0x1486BA, 0x319630, 0x20F756, 0x105F06, 0x085891, 0x16B51E, 0x0E3506,
1603 0x2EB5AA, 0x28EF20, 0x36F8E1, 0x2B30FE, 0x1C3225, 0x0E5FC7, 0x1DC030, 0x0CEFB7,
1604 0x308193, 0x4347AC, 0x2BA786, 0x3C8CE5, 0x27E000, 0x374EE7, 0x229212, 0x2B7494,
1605 0x308193, 0x2BA786, 0x28EF20, 0x3045D0, 0x1A0B89, 0x29494D, 0x11735D, 0x183469,
1606 0x26E410, 0x230039, 0x1CBF8F, 0x18FB09, 0x3D0771, 0x36ECBA, 0x390986, 0x316E52,
1607 0x32E000, 0x24BB33, 0x27F8E4, 0x1DB557, 0x194D09, 0x0C23BB, 0x1476A6, 0x0A2256,
1608 0x1C470A, 0x1637AD, 0x153E87, 0x1490FA, 0x1354B9, 0x09DAD6, 0x0E2A94, 0x08AFF0,
1610 0x1C0000, 0x26D64D, 0x3566AA, 0x4A11C2, 0x249572, 0x27190E, 0x527525, 0x44805E,
1611 0x1C0000, 0x1A1FD6, 0x3F1C3E, 0x29F4F9, 0x14D607, 0x0A9F44, 0x1CE683, 0x1214F0,
1612 0x3B72D9, 0x341911, 0x45F6F0, 0x36F889, 0x23E2BB, 0x124B5B, 0x25DD54, 0x1076E9,
1613 0x3DBC30, 0x55A109, 0x378F64, 0x4D1069, 0x32C000, 0x46646C, 0x2BFFB9, 0x374E8E,
1614 0x3DBC30, 0x378F64, 0x341911, 0x3D7020, 0x2125F5, 0x348BD6, 0x1635BC, 0x1ECE57,
1615 0x317F5B, 0x2C8BEB, 0x2496B6, 0x1FCB22, 0x4DAC61, 0x45E778, 0x4897C2, 0x3EE97F,
1616 0x40C000, 0x2EBFB5, 0x32DFAE, 0x25CF86, 0x203380, 0x0F734B, 0x1A0B5F, 0x0CE5E2,
1617 0x23FD53, 0x1C46DC, 0x1B09C4, 0x1A2CE1, 0x189A60, 0x0C8AE2, 0x1207A5, 0x0B0E77,
1619 0x220000, 0x2F28CC, 0x40D818, 0x59F0FE, 0x2C6C53, 0x2F79DA, 0x642089, 0x532E29,
1620 0x220000, 0x1FB8F1, 0x4CA24B, 0x32F29C, 0x194D09, 0x0CE5F7, 0x2317E8, 0x15F4DB,
1621 0x483007, 0x3F4303, 0x54F4FF, 0x42C014, 0x2B9351, 0x1636EE, 0x2DFA79, 0x13FE1A,
1622 0x4AF6CC, 0x67FA67, 0x437743, 0x5D93EE, 0x3DA000, 0x5579F1, 0x356D61, 0x432888,
1623 0x4AF6CC, 0x437743, 0x3F4303, 0x4A9A70, 0x284060, 0x3FCE60, 0x1AF81B, 0x256845,
1624 0x3C1AA5, 0x36179D, 0x2C6DDD, 0x269B3C, 0x5E5152, 0x54E237, 0x5825FE, 0x4C64AD,
1625 0x4EA000, 0x38C437, 0x3DC678, 0x2DE9B5, 0x2719F7, 0x12C2DB, 0x1FA018, 0x0FA96E,
1626 0x2BB39B, 0x22560C, 0x20D500, 0x1FC8C8, 0x1DE007, 0x0F3AEE, 0x15E4B7, 0x0D6CFE,
1628 0x2C0000, 0x3D079E, 0x53EA79, 0x74650C, 0x397D20, 0x3D7083, 0x819383, 0x6BA525,
1629 0x2C0000, 0x290D75, 0x632C61, 0x41EEAC, 0x20BE0C, 0x10B121, 0x2D6A3B, 0x1C6A0C,
1630 0x5D6B54, 0x51DE40, 0x6DF1C2, 0x5661FB, 0x38644B, 0x1CBF8F, 0x3B8060, 0x19DF6D,
1631 0x610326, 0x868F57, 0x574F0B, 0x7919CA, 0x4FC000, 0x6E9DCE, 0x452423, 0x56E928,
1632 0x610326, 0x574F0B, 0x51DE40, 0x608BA0, 0x341713, 0x52929A, 0x22E6BA, 0x3068D2,
1633 0x4DC821, 0x460071, 0x397F1E, 0x31F611, 0x7A0EE2, 0x6DD974, 0x72130C, 0x62DCA3,
1634 0x65C000, 0x497665, 0x4FF1C9, 0x3B6AAE, 0x329A12, 0x184776, 0x28ED4D, 0x1444AC,
1635 0x388E14, 0x2C6F5A, 0x2A7D0F, 0x2921F4, 0x26A973, 0x13B5AD, 0x1C5528, 0x115FDF,
1639 const BINK_INTER_QUANT: &[[i32; 64]; 16] = &[
1641 0x010000, 0x017946, 0x01A5A9, 0x0248DC, 0x016363, 0x0152A7, 0x0243EC, 0x0209EA,
1642 0x012000, 0x00E248, 0x01BBDA, 0x015CBC, 0x00A486, 0x0053E0, 0x00F036, 0x008095,
1643 0x01B701, 0x016959, 0x01B0B9, 0x0153FD, 0x00F8E7, 0x007EE4, 0x00EA30, 0x007763,
1644 0x01B701, 0x0260EB, 0x019DE9, 0x023E1B, 0x017000, 0x01FE6E, 0x012DB5, 0x01A27B,
1645 0x01E0D1, 0x01B0B9, 0x018A33, 0x01718D, 0x00D87A, 0x014449, 0x007B9A, 0x00AB71,
1646 0x013178, 0x0112EA, 0x00AD08, 0x009BB9, 0x023D97, 0x020437, 0x021CCC, 0x01E6B4,
1647 0x018000, 0x012DB5, 0x0146D9, 0x0100CE, 0x00CFD2, 0x006E5C, 0x00B0E4, 0x005A2D,
1648 0x00E9CC, 0x00B7B1, 0x00846F, 0x006B85, 0x008337, 0x0042E5, 0x004A10, 0x002831,
1650 0x015555, 0x01F708, 0x023237, 0x030BD0, 0x01D9D9, 0x01C389, 0x03053B, 0x02B7E3,
1651 0x018000, 0x012DB5, 0x024FCE, 0x01D0FA, 0x00DB5D, 0x006FD5, 0x014048, 0x00AB71,
1652 0x024957, 0x01E1CC, 0x0240F7, 0x01C551, 0x014BDE, 0x00A92F, 0x013840, 0x009F2F,
1653 0x024957, 0x032BE4, 0x0227E1, 0x02FD7A, 0x01EAAB, 0x02A893, 0x019247, 0x022DF9,
1654 0x028116, 0x0240F7, 0x020D99, 0x01ECBC, 0x0120A3, 0x01B061, 0x00A4CE, 0x00E497,
1655 0x01974B, 0x016E8E, 0x00E6B5, 0x00CFA2, 0x02FCC9, 0x02B04A, 0x02D110, 0x0288F1,
1656 0x020000, 0x019247, 0x01B3CC, 0x015668, 0x011518, 0x009325, 0x00EBDA, 0x00783D,
1657 0x0137BB, 0x00F4ED, 0x00B093, 0x008F5C, 0x00AEF4, 0x005931, 0x0062BF, 0x003597,
1659 0x01AAAB, 0x0274CB, 0x02BEC4, 0x03CEC4, 0x02504F, 0x02346C, 0x03C689, 0x0365DC,
1660 0x01E000, 0x017922, 0x02E3C1, 0x024539, 0x011235, 0x008BCA, 0x01905A, 0x00D64D,
1661 0x02DBAD, 0x025A40, 0x02D134, 0x0236A5, 0x019ED6, 0x00D37B, 0x018650, 0x00C6FB,
1662 0x02DBAD, 0x03F6DD, 0x02B1D9, 0x03BCD8, 0x026555, 0x0352B8, 0x01F6D8, 0x02B977,
1663 0x03215C, 0x02D134, 0x029100, 0x0267EB, 0x0168CC, 0x021C7A, 0x00CE01, 0x011DBD,
1664 0x01FD1E, 0x01CA31, 0x012062, 0x01038A, 0x03BBFB, 0x035C5C, 0x038554, 0x032B2D,
1665 0x028000, 0x01F6D8, 0x0220C0, 0x01AC02, 0x015A5E, 0x00B7EF, 0x0126D1, 0x00964C,
1666 0x0185A9, 0x013228, 0x00DCB8, 0x00B333, 0x00DAB2, 0x006F7D, 0x007B6F, 0x0042FC,
1668 0x020000, 0x02F28D, 0x034B52, 0x0491B8, 0x02C6C5, 0x02A54E, 0x0487D8, 0x0413D5,
1669 0x024000, 0x01C48F, 0x0377B5, 0x02B977, 0x01490C, 0x00A7BF, 0x01E06C, 0x01012A,
1670 0x036E03, 0x02D2B3, 0x036172, 0x02A7FA, 0x01F1CE, 0x00FDC7, 0x01D460, 0x00EEC7,
1671 0x036E03, 0x04C1D6, 0x033BD1, 0x047C37, 0x02E000, 0x03FCDD, 0x025B6A, 0x0344F5,
1672 0x03C1A1, 0x036172, 0x031466, 0x02E31B, 0x01B0F5, 0x028892, 0x00F735, 0x0156E2,
1673 0x0262F1, 0x0225D5, 0x015A10, 0x013772, 0x047B2D, 0x04086E, 0x043998, 0x03CD69,
1674 0x030000, 0x025B6A, 0x028DB3, 0x02019B, 0x019FA3, 0x00DCB8, 0x0161C7, 0x00B45B,
1675 0x01D398, 0x016F63, 0x0108DD, 0x00D70A, 0x01066F, 0x0085C9, 0x00941F, 0x005062,
1677 0x02AAAB, 0x03EE11, 0x04646D, 0x0617A0, 0x03B3B2, 0x038713, 0x060A75, 0x056FC6,
1678 0x030000, 0x025B6A, 0x049F9B, 0x03A1F4, 0x01B6BB, 0x00DFAA, 0x028090, 0x0156E2,
1679 0x0492AE, 0x03C399, 0x0481ED, 0x038AA2, 0x0297BD, 0x01525F, 0x027080, 0x013E5E,
1680 0x0492AE, 0x0657C8, 0x044FC1, 0x05FAF4, 0x03D555, 0x055126, 0x03248D, 0x045BF2,
1681 0x05022D, 0x0481ED, 0x041B33, 0x03D979, 0x024147, 0x0360C3, 0x01499C, 0x01C92E,
1682 0x032E96, 0x02DD1C, 0x01CD6A, 0x019F43, 0x05F991, 0x056093, 0x05A220, 0x0511E1,
1683 0x040000, 0x03248D, 0x036799, 0x02ACCF, 0x022A2F, 0x01264B, 0x01D7B5, 0x00F079,
1684 0x026F75, 0x01E9D9, 0x016127, 0x011EB8, 0x015DE9, 0x00B262, 0x00C57F, 0x006B2D,
1686 0x038000, 0x052876, 0x05C3CF, 0x07FF02, 0x04DBD9, 0x04A148, 0x07EDBA, 0x0722B4,
1687 0x03F000, 0x0317FB, 0x06117C, 0x04C491, 0x023FD5, 0x01258F, 0x0348BD, 0x01C209,
1688 0x060085, 0x04F0B9, 0x05EA87, 0x04A5F5, 0x036728, 0x01BC1C, 0x0333A8, 0x01A1DB,
1689 0x060085, 0x085336, 0x05A8AE, 0x07D960, 0x050800, 0x06FA82, 0x041FF9, 0x05B8AE,
1690 0x0692DA, 0x05EA87, 0x0563B2, 0x050D6E, 0x02F5AD, 0x046F00, 0x01B09C, 0x02580C,
1691 0x042D25, 0x03C235, 0x025D9B, 0x022108, 0x07D78F, 0x070EC1, 0x0764CA, 0x06A777,
1692 0x054000, 0x041FF9, 0x0477F9, 0x0382D0, 0x02D75E, 0x018242, 0x026B1D, 0x013B9F,
1693 0x03324A, 0x0282ED, 0x01CF83, 0x017851, 0x01CB42, 0x00EA21, 0x010336, 0x008CAC,
1695 0x040000, 0x05E519, 0x0696A4, 0x092370, 0x058D8A, 0x054A9C, 0x090FB0, 0x0827AA,
1696 0x048000, 0x03891F, 0x06EF69, 0x0572EE, 0x029218, 0x014F7E, 0x03C0D8, 0x020254,
1697 0x06DC05, 0x05A565, 0x06C2E4, 0x054FF3, 0x03E39B, 0x01FB8E, 0x03A8C0, 0x01DD8D,
1698 0x06DC05, 0x0983AC, 0x0677A2, 0x08F86E, 0x05C000, 0x07F9B9, 0x04B6D4, 0x0689EB,
1699 0x078343, 0x06C2E4, 0x0628CC, 0x05C635, 0x0361EA, 0x051124, 0x01EE69, 0x02ADC5,
1700 0x04C5E1, 0x044BAA, 0x02B41F, 0x026EE5, 0x08F65A, 0x0810DD, 0x087330, 0x079AD1,
1701 0x060000, 0x04B6D4, 0x051B65, 0x040337, 0x033F47, 0x01B970, 0x02C38F, 0x0168B6,
1702 0x03A730, 0x02DEC6, 0x0211BA, 0x01AE14, 0x020CDD, 0x010B93, 0x01283E, 0x00A0C4,
1704 0x050000, 0x075E60, 0x083C4D, 0x0B6C4C, 0x06F0ED, 0x069D43, 0x0B539C, 0x0A3194,
1705 0x05A000, 0x046B67, 0x08AB44, 0x06CFAA, 0x03369E, 0x01A35E, 0x04B10F, 0x0282E8,
1706 0x089307, 0x070EBF, 0x08739C, 0x06A3F0, 0x04DC82, 0x027A72, 0x0492F0, 0x0254F0,
1707 0x089307, 0x0BE497, 0x08158B, 0x0B3689, 0x073000, 0x09F827, 0x05E489, 0x082C66,
1708 0x096413, 0x08739C, 0x07B2FF, 0x0737C2, 0x043A64, 0x06556D, 0x026A04, 0x035936,
1709 0x05F75A, 0x055E94, 0x036127, 0x030A9E, 0x0B33F1, 0x0A1514, 0x0A8FFC, 0x098186,
1710 0x078000, 0x05E489, 0x06623F, 0x050405, 0x040F19, 0x0227CC, 0x037473, 0x01C2E3,
1711 0x0490FC, 0x039677, 0x029629, 0x021999, 0x029015, 0x014E78, 0x01724E, 0x00C8F5,
1713 0x060000, 0x08D7A6, 0x09E1F6, 0x0DB528, 0x085450, 0x07EFEA, 0x0D9788, 0x0C3B7E,
1714 0x06C000, 0x054DAE, 0x0A671E, 0x082C66, 0x03DB24, 0x01F73E, 0x05A145, 0x03037D,
1715 0x0A4A08, 0x087818, 0x0A2455, 0x07F7ED, 0x05D569, 0x02F955, 0x057D20, 0x02CC54,
1716 0x0A4A08, 0x0E4582, 0x09B373, 0x0D74A5, 0x08A000, 0x0BF696, 0x07123E, 0x09CEE0,
1717 0x0B44E4, 0x0A2455, 0x093D32, 0x08A950, 0x0512DF, 0x0799B6, 0x02E59E, 0x0404A7,
1718 0x0728D2, 0x06717F, 0x040E2F, 0x03A657, 0x0D7187, 0x0C194B, 0x0CACC8, 0x0B683A,
1719 0x090000, 0x07123E, 0x07A918, 0x0604D2, 0x04DEEA, 0x029629, 0x042556, 0x021D11,
1720 0x057AC8, 0x044E28, 0x031A97, 0x02851E, 0x03134C, 0x01915C, 0x01BC5D, 0x00F126,
1722 0x080000, 0x0BCA33, 0x0D2D48, 0x1246E0, 0x0B1B15, 0x0A9538, 0x121F5F, 0x104F53,
1723 0x090000, 0x07123E, 0x0DDED2, 0x0AE5DD, 0x052430, 0x029EFD, 0x0781B1, 0x0404A7,
1724 0x0DB80B, 0x0B4ACB, 0x0D85C7, 0x0A9FE7, 0x07C736, 0x03F71D, 0x075180, 0x03BB1A,
1725 0x0DB80B, 0x130757, 0x0CEF44, 0x11F0DC, 0x0B8000, 0x0FF372, 0x096DA8, 0x0D13D6,
1726 0x0F0686, 0x0D85C7, 0x0C5198, 0x0B8C6A, 0x06C3D4, 0x0A2248, 0x03DCD3, 0x055B8A,
1727 0x098BC3, 0x089754, 0x05683E, 0x04DDC9, 0x11ECB4, 0x1021B9, 0x10E661, 0x0F35A3,
1728 0x0C0000, 0x096DA8, 0x0A36CB, 0x08066E, 0x067E8E, 0x0372E1, 0x05871E, 0x02D16B,
1729 0x074E60, 0x05BD8B, 0x042374, 0x035C28, 0x0419BB, 0x021726, 0x02507C, 0x014188,
1731 0x0C0000, 0x11AF4C, 0x13C3EC, 0x1B6A50, 0x10A89F, 0x0FDFD4, 0x1B2F0F, 0x1876FD,
1732 0x0D8000, 0x0A9B5D, 0x14CE3C, 0x1058CB, 0x07B649, 0x03EE7B, 0x0B4289, 0x0606FB,
1733 0x149410, 0x10F030, 0x1448AB, 0x0FEFDA, 0x0BAAD2, 0x05F2AB, 0x0AFA40, 0x0598A7,
1734 0x149410, 0x1C8B03, 0x1366E6, 0x1AE949, 0x114000, 0x17ED2B, 0x0E247C, 0x139DC1,
1735 0x1689C8, 0x1448AB, 0x127A63, 0x11529F, 0x0A25BE, 0x0F336D, 0x05CB3C, 0x08094E,
1736 0x0E51A4, 0x0CE2FE, 0x081C5D, 0x074CAE, 0x1AE30E, 0x183296, 0x195991, 0x16D074,
1737 0x120000, 0x0E247C, 0x0F5230, 0x0C09A5, 0x09BDD5, 0x052C51, 0x084AAC, 0x043A21,
1738 0x0AF590, 0x089C51, 0x06352E, 0x050A3B, 0x062698, 0x0322B9, 0x0378BA, 0x01E24D,
1740 0x110000, 0x190DAC, 0x1C0039, 0x26D69C, 0x17998C, 0x167D16, 0x2682AB, 0x22A891,
1741 0x132000, 0x0F06C3, 0x1D797F, 0x172876, 0x0AECE7, 0x0591D9, 0x0FF398, 0x0889E3,
1742 0x1D2717, 0x17FEEF, 0x1CBC47, 0x1693CA, 0x108754, 0x086D1D, 0x0F8D30, 0x07ED98,
1743 0x1D2717, 0x286F9A, 0x1B7C71, 0x261FD3, 0x187000, 0x21E552, 0x140904, 0x1BCA27,
1744 0x1FEDDC, 0x1CBC47, 0x1A2D62, 0x188A62, 0x0E6022, 0x1588DA, 0x083540, 0x0B6284,
1745 0x1448FE, 0x124192, 0x0B7D84, 0x0A574B, 0x2616FF, 0x2247AA, 0x23E98D, 0x2051FA,
1746 0x198000, 0x140904, 0x15B46F, 0x110DAA, 0x0DCCEE, 0x07541E, 0x0BBF1F, 0x05FD04,
1747 0x0F868B, 0x0C32C8, 0x08CB57, 0x0723D4, 0x08B6AD, 0x047130, 0x04EB08, 0x02AB42,
1749 0x160000, 0x206C0C, 0x243C86, 0x3242E8, 0x1E8A79, 0x1D1A59, 0x31D646, 0x2CDA25,
1750 0x18C000, 0x13722A, 0x2624C3, 0x1DF820, 0x0E2385, 0x073537, 0x14A4A7, 0x0B0CCC,
1751 0x25BA1D, 0x1F0DAE, 0x252FE4, 0x1D37BB, 0x1563D6, 0x0AE78E, 0x142021, 0x0A4288,
1752 0x25BA1D, 0x345430, 0x2391FB, 0x31565C, 0x1FA000, 0x2BDD7A, 0x19ED8D, 0x23F68C,
1753 0x2951EF, 0x252FE4, 0x21E061, 0x1FC224, 0x129A87, 0x1BDE47, 0x0A9F44, 0x0EBBBA,
1754 0x1A4058, 0x17A026, 0x0EDEAB, 0x0D61E9, 0x314AEF, 0x2C5CBE, 0x2E798A, 0x29D380,
1755 0x210000, 0x19ED8D, 0x1C16AE, 0x1611AE, 0x11DC06, 0x097BEA, 0x0F3391, 0x07BFE7,
1756 0x141787, 0x0FC93E, 0x0B617F, 0x093D6D, 0x0B46C1, 0x05BFA8, 0x065D55, 0x037437,
1758 0x1C0000, 0x2943B2, 0x2E1E7C, 0x3FF810, 0x26DEC9, 0x250A43, 0x3F6DCE, 0x3915A3,
1759 0x1F8000, 0x18BFD8, 0x308BE1, 0x262485, 0x11FEA9, 0x092C75, 0x1A45EB, 0x0E1049,
1760 0x300425, 0x2785C6, 0x2F5439, 0x252FA8, 0x1B393F, 0x0DE0E4, 0x199D41, 0x0D0EDC,
1761 0x300425, 0x4299B2, 0x2D456E, 0x3ECB00, 0x284000, 0x37D40F, 0x20FFCB, 0x2DC56D,
1762 0x3496D3, 0x2F5439, 0x2B1D93, 0x286B74, 0x17AD66, 0x2377FE, 0x0D84E2, 0x12C062,
1763 0x21692A, 0x1E11A5, 0x12ECDA, 0x110840, 0x3EBC76, 0x387608, 0x3B2652, 0x353BBA,
1764 0x2A0000, 0x20FFCB, 0x23BFC6, 0x1C1681, 0x16BAF1, 0x0C1213, 0x1358E8, 0x09DCF8,
1765 0x19924F, 0x141767, 0x0E7C16, 0x0BC28A, 0x0E5A0D, 0x075104, 0x0819B2, 0x04655D,
1767 0x220000, 0x321B58, 0x380072, 0x4DAD38, 0x2F3318, 0x2CFA2D, 0x4D0556, 0x455122,
1768 0x264000, 0x1E0D86, 0x3AF2FE, 0x2E50EB, 0x15D9CE, 0x0B23B2, 0x1FE730, 0x1113C7,
1769 0x3A4E2D, 0x2FFDDF, 0x39788E, 0x2D2795, 0x210EA8, 0x10DA39, 0x1F1A61, 0x0FDB2F,
1770 0x3A4E2D, 0x50DF33, 0x36F8E1, 0x4C3FA5, 0x30E000, 0x43CAA5, 0x281209, 0x37944D,
1771 0x3FDBB7, 0x39788E, 0x345AC4, 0x3114C3, 0x1CC044, 0x2B11B4, 0x106A80, 0x16C509,
1772 0x2891FC, 0x248324, 0x16FB08, 0x14AE97, 0x4C2DFD, 0x448F54, 0x47D31B, 0x40A3F5,
1773 0x330000, 0x281209, 0x2B68DF, 0x221B53, 0x1B99DB, 0x0EA83B, 0x177E3E, 0x0BFA09,
1774 0x1F0D17, 0x18658F, 0x1196AE, 0x0E47A8, 0x116D5A, 0x08E260, 0x09D60F, 0x055684,
1776 0x2C0000, 0x40D818, 0x48790C, 0x6485D0, 0x3D14F2, 0x3A34B2, 0x63AC8D, 0x59B44A,
1777 0x318000, 0x26E454, 0x4C4986, 0x3BF03F, 0x1C470A, 0x0E6A6E, 0x29494D, 0x161998,
1778 0x4B743A, 0x3E1B5C, 0x4A5FC7, 0x3A6F75, 0x2AC7AC, 0x15CF1D, 0x284041, 0x148510,
1779 0x4B743A, 0x68A861, 0x4723F6, 0x62ACB8, 0x3F4000, 0x57BAF3, 0x33DB1A, 0x47ED19,
1780 0x52A3DE, 0x4A5FC7, 0x43C0C2, 0x3F8448, 0x25350D, 0x37BC8E, 0x153E87, 0x1D7775,
1781 0x3480B0, 0x2F404C, 0x1DBD56, 0x1AC3D2, 0x6295DE, 0x58B97B, 0x5CF313, 0x53A701,
1782 0x420000, 0x33DB1A, 0x382D5C, 0x2C235D, 0x23B80D, 0x12F7D4, 0x1E6723, 0x0F7FCF,
1783 0x282F0E, 0x1F927D, 0x16C2FF, 0x127AD9, 0x168D83, 0x0B7F50, 0x0CBAAA, 0x06E86E,
1787 const BINKB_RUN_BITS: [u8; 64] = [
1788 6, 6, 6, 6, 6, 6, 6, 6,
1789 6, 6, 6, 6, 6, 6, 6, 6,
1790 6, 6, 6, 6, 6, 6, 6, 6,
1791 6, 6, 6, 6, 6, 6, 6, 6,
1792 5, 5, 5, 5, 5, 5, 5, 5,
1793 5, 5, 5, 5, 5, 5, 5, 5,
1794 4, 4, 4, 4, 4, 4, 4, 4,
1795 3, 3, 3, 3, 2, 2, 1, 0
1798 const BINKB_REF_INTRA_Q: [u8; 64] = [
1799 16, 16, 16, 19, 16, 19, 22, 22,
1800 22, 22, 26, 24, 26, 22, 22, 27,
1801 27, 27, 26, 26, 26, 29, 29, 29,
1802 27, 27, 27, 26, 34, 34, 34, 29,
1803 29, 29, 27, 27, 37, 34, 34, 32,
1804 32, 29, 29, 38, 37, 35, 35, 34,
1805 35, 40, 40, 40, 38, 38, 48, 48,
1806 46, 46, 58, 56, 56, 69, 69, 83
1809 const BINKB_REF_INTER_Q: [u8; 64] = [
1810 16, 17, 17, 18, 18, 18, 19, 19,
1811 19, 19, 20, 20, 20, 20, 20, 21,
1812 21, 21, 21, 21, 21, 22, 22, 22,
1813 22, 22, 22, 22, 23, 23, 23, 23,
1814 23, 23, 23, 23, 24, 24, 24, 25,
1815 24, 24, 24, 25, 26, 26, 26, 26,
1816 25, 27, 27, 27, 27, 27, 28, 28,
1817 28, 28, 30, 30, 30, 31, 31, 33
1820 const BINKB_REF_QUANTS: [(u8, u8); 16] = [
1821 (1, 1), (4, 3), (5, 3), (2, 1), (7, 3), (8, 3), (3, 1), (7, 2),
1822 (4, 1), (9, 2), (5, 1), (6, 1), (7, 1), (8, 1), (9, 1), (10, 1)