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