3 use nihav_core::codecs::*;
4 use nihav_codec_support::codecs::{MV, ZERO_MV, ZIGZAG};
5 use nihav_codec_support::codecs::blockdsp::*;
6 use nihav_core::io::bitreader::*;
7 use nihav_core::io::codebook::*;
8 use nihav_core::io::intcode::*;
9 use super::vpcommon::*;
11 #[derive(Clone,Copy,Debug,PartialEq)]
18 fn map_idx(idx: usize) -> u8 {
23 dc_cb: [Codebook<u8>; 5],
24 ac_i_cb: [Codebook<u8>; 5],
25 ac_p_cb: [Codebook<u8>; 5],
26 mbtype_cb: Codebook<VPMBType>,
29 fn map_mbt(idx: usize) -> VPMBType {
35 let mut dc_cb: [Codebook<u8>; 5];
36 let mut ac_i_cb: [Codebook<u8>; 5];
37 let mut ac_p_cb: [Codebook<u8>; 5];
38 let mut cr = TableCodebookDescReader::new(&VP30_MBTYPE_CODES, &VP30_MBTYPE_BITS, map_mbt);
39 let mbtype_cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
41 dc_cb = mem::uninitialized();
42 ac_i_cb = mem::uninitialized();
43 ac_p_cb = mem::uninitialized();
45 let mut cr = TableCodebookDescReader::new(&VP30_DC_CODES[i], &VP30_DC_BITS[i], map_idx);
46 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
47 ptr::write(&mut dc_cb[i], cb);
48 let mut cr = TableCodebookDescReader::new(&VP30_AC_INTRA_CODES[i], &VP30_AC_INTRA_BITS[i], map_idx);
49 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
50 ptr::write(&mut ac_i_cb[i], cb);
51 let mut cr = TableCodebookDescReader::new(&VP30_AC_INTER_CODES[i], &VP30_AC_INTER_BITS[i], map_idx);
52 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
53 ptr::write(&mut ac_p_cb[i], cb);
56 Self { dc_cb, ac_i_cb, ac_p_cb, mbtype_cb }
61 dc_cb: [Codebook<u8>; 16],
62 ac0_cb: [Codebook<u8>; 16],
63 ac1_cb: [Codebook<u8>; 16],
64 ac2_cb: [Codebook<u8>; 16],
65 ac3_cb: [Codebook<u8>; 16],
70 let mut dc_cb: [Codebook<u8>; 16];
71 let mut ac0_cb: [Codebook<u8>; 16];
72 let mut ac1_cb: [Codebook<u8>; 16];
73 let mut ac2_cb: [Codebook<u8>; 16];
74 let mut ac3_cb: [Codebook<u8>; 16];
76 dc_cb = mem::uninitialized();
77 ac0_cb = mem::uninitialized();
78 ac1_cb = mem::uninitialized();
79 ac2_cb = mem::uninitialized();
80 ac3_cb = mem::uninitialized();
82 let mut cr = TableCodebookDescReader::new(&VP31_DC_CODES[i], &VP31_DC_BITS[i], map_idx);
83 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
84 ptr::write(&mut dc_cb[i], cb);
86 let mut cr = TableCodebookDescReader::new(&VP31_AC_CAT0_CODES[i], &VP31_AC_CAT0_BITS[i], map_idx);
87 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
88 ptr::write(&mut ac0_cb[i], cb);
89 let mut cr = TableCodebookDescReader::new(&VP31_AC_CAT1_CODES[i], &VP31_AC_CAT1_BITS[i], map_idx);
90 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
91 ptr::write(&mut ac1_cb[i], cb);
92 let mut cr = TableCodebookDescReader::new(&VP31_AC_CAT2_CODES[i], &VP31_AC_CAT2_BITS[i], map_idx);
93 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
94 ptr::write(&mut ac2_cb[i], cb);
95 let mut cr = TableCodebookDescReader::new(&VP31_AC_CAT3_CODES[i], &VP31_AC_CAT3_BITS[i], map_idx);
96 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
97 ptr::write(&mut ac3_cb[i], cb);
100 Self { dc_cb, ac0_cb, ac1_cb, ac2_cb, ac3_cb }
102 fn new_vp4() -> VP31Codes {
103 let mut dc_cb: [Codebook<u8>; 16];
104 let mut ac0_cb: [Codebook<u8>; 16];
105 let mut ac1_cb: [Codebook<u8>; 16];
106 let mut ac2_cb: [Codebook<u8>; 16];
107 let mut ac3_cb: [Codebook<u8>; 16];
109 dc_cb = mem::uninitialized();
110 ac0_cb = mem::uninitialized();
111 ac1_cb = mem::uninitialized();
112 ac2_cb = mem::uninitialized();
113 ac3_cb = mem::uninitialized();
115 let mut cr = TableCodebookDescReader::new(&VP40_DC_CODES[i], &VP40_DC_BITS[i], map_idx);
116 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
117 ptr::write(&mut dc_cb[i], cb);
119 let mut cr = TableCodebookDescReader::new(&VP40_AC_CAT0_CODES[i], &VP40_AC_CAT0_BITS[i], map_idx);
120 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
121 ptr::write(&mut ac0_cb[i], cb);
122 let mut cr = TableCodebookDescReader::new(&VP40_AC_CAT1_CODES[i], &VP40_AC_CAT1_BITS[i], map_idx);
123 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
124 ptr::write(&mut ac1_cb[i], cb);
125 let mut cr = TableCodebookDescReader::new(&VP40_AC_CAT2_CODES[i], &VP40_AC_CAT2_BITS[i], map_idx);
126 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
127 ptr::write(&mut ac2_cb[i], cb);
128 let mut cr = TableCodebookDescReader::new(&VP40_AC_CAT3_CODES[i], &VP40_AC_CAT3_BITS[i], map_idx);
129 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
130 ptr::write(&mut ac3_cb[i], cb);
133 VP31Codes { dc_cb, ac0_cb, ac1_cb, ac2_cb, ac3_cb }
137 struct VP40AuxCodes {
138 mv_x_cb: [Codebook<i8>; 7],
139 mv_y_cb: [Codebook<i8>; 7],
140 mbpat_cb: [Codebook<u8>; 2],
143 fn map_mv(idx: usize) -> i8 {
149 let mut mv_x_cb: [Codebook<i8>; 7];
150 let mut mv_y_cb: [Codebook<i8>; 7];
152 mv_x_cb = mem::uninitialized();
153 mv_y_cb = mem::uninitialized();
155 let mut cr = TableCodebookDescReader::new(&VP40_MV_X_CODES[i], &VP40_MV_X_BITS[i], map_mv);
156 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
157 ptr::write(&mut mv_x_cb[i], cb);
158 let mut cr = TableCodebookDescReader::new(&VP40_MV_Y_CODES[i], &VP40_MV_Y_BITS[i], map_mv);
159 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
160 ptr::write(&mut mv_y_cb[i], cb);
163 let mut cr0 = TableCodebookDescReader::new(&VP40_MBPAT_CODES[0], &VP40_MBPAT_BITS[0], map_idx);
164 let mut cr1 = TableCodebookDescReader::new(&VP40_MBPAT_CODES[1], &VP40_MBPAT_BITS[1], map_idx);
165 let mbpat_cb = [Codebook::new(&mut cr0, CodebookMode::MSB).unwrap(),
166 Codebook::new(&mut cr1, CodebookMode::MSB).unwrap()];
167 Self { mv_x_cb, mv_y_cb, mbpat_cb }
190 btype: VPMBType::Intra,
200 type ReadRunFunc = fn (&mut BitReader) -> DecoderResult<usize>;
202 const VP31_LONG_RUN_BASE: [usize; 7] = [ 1, 2, 4, 6, 10, 18, 34 ];
203 const VP31_LONG_RUN_BITS: [u8; 7] = [ 0, 1, 1, 2, 3, 4, 12 ];
204 fn read_long_run(br: &mut BitReader) -> DecoderResult<usize> {
205 let pfx = br.read_code(UintCodeType::LimitedUnary(6, 0))? as usize;
206 if pfx == 0 { return Ok(1); }
207 Ok(VP31_LONG_RUN_BASE[pfx] + (br.read(VP31_LONG_RUN_BITS[pfx])? as usize))
210 const VP31_SHORT_RUN_BASE: [usize; 6] = [ 1, 3, 5, 7, 11, 15 ];
211 const VP31_SHORT_RUN_BITS: [u8; 6] = [ 1, 1, 1, 2, 2, 4 ];
212 fn read_short_run(br: &mut BitReader) -> DecoderResult<usize> {
213 let pfx = br.read_code(UintCodeType::LimitedUnary(5, 0))? as usize;
214 Ok(VP31_SHORT_RUN_BASE[pfx] + (br.read(VP31_SHORT_RUN_BITS[pfx])? as usize))
217 fn read_mb_run(br: &mut BitReader) -> DecoderResult<usize> {
218 let pfx = br.read_code(UintCodeType::LimitedUnary(10, 0))? as usize;
219 if pfx == 10 { unimplemented!(); }
223 let base = (1 << (pfx - 1)) + 1;
224 let bits = (pfx - 1) as u8;
225 let add_bits = br.read(bits)? as usize;
230 struct BitRunDecoder {
233 read_run: ReadRunFunc,
237 fn new(br: &mut BitReader, read_run: ReadRunFunc) -> DecoderResult<Self> {
238 let value = !br.read_bool()?; // it will be flipped before run decoding
239 Ok(Self { value, run: 0, read_run })
241 fn get_val(&mut self, br: &mut BitReader) -> DecoderResult<bool> {
243 self.value = !self.value;
244 self.run = (self.read_run)(br)?;
251 const VP30_NE0_BITS: [u8; 5] = [ 2, 2, 3, 4, 8 ];
252 const VP30_NE0_BASE: [usize; 5] = [ 1, 5, 9, 17, 33 ];
253 fn vp30_read_ne_run0(br: &mut BitReader) -> DecoderResult<usize> {
254 let len = br.read_code(UintCodeType::LimitedUnary(4, 0))? as usize;
255 Ok(VP30_NE0_BASE[len] + (br.read(VP30_NE0_BITS[len])? as usize))
257 fn vp30_read_ne_run1(br: &mut BitReader) -> DecoderResult<usize> {
258 let len = br.read_code(UintCodeType::LimitedUnary(6, 0))? as usize;
260 Ok((br.read(1)? as usize) + 1)
264 Ok((br.read(8)? as usize) + 8)
267 fn vp30_read_coded_run0(br: &mut BitReader) -> DecoderResult<usize> {
268 let len = br.read_code(UintCodeType::LimitedUnary(5, 0))? as usize;
278 10010 - 7 + get_bits(3)
279 101100 - 15 + get_bits(5)
280 1011010 - 47 + get_bits(8)
281 1011011 - 303 + get_bits(16)
283 const VP30_CRUN1_LUT: [u8; 32] = [
284 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
285 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
286 0x34, 0x34, 0x75, 0x55, 0x44, 0x44, 0x85, 0x65,
287 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22
289 fn vp30_read_coded_run1(br: &mut BitReader) -> DecoderResult<usize> {
290 let idx = br.peek(5) as usize;
291 let sym = (VP30_CRUN1_LUT[idx] >> 4) as usize;
292 let bits = VP30_CRUN1_LUT[idx] & 0xF;
293 br.skip(bits as u32)?;
297 Ok(7 + (br.read(3)? as usize))
299 let len = br.read_code(UintCodeType::Unary012)?;
301 0 => Ok(15 + (br.read(5)? as usize)),
302 1 => Ok(47 + (br.read(8)? as usize)),
303 _ => Ok(303 + (br.read(16)? as usize)),
309 info: NACodecInfoRef,
320 aux_codes: Option<VP40AuxCodes>,
322 mc_buf: NAVideoBufferRef<u8>,
326 mb_partial: Vec<bool>,
337 blk_addr: Vec<usize>,
339 sb_info: Vec<SBState>,
345 fn vp30_read_mv_comp(br: &mut BitReader) -> DecoderResult<i16> {
346 let mode = br.read(2)?;
347 if mode == 0 { return Ok(0); }
348 let sign = br.read_bool()?;
349 let val = match mode - 1 {
351 1 => 2 + (br.read(2)? as i16),
352 _ => br.read(5)? as i16,
361 fn vp30_read_mv(br: &mut BitReader) -> DecoderResult<MV> {
362 let x = vp30_read_mv_comp(br)?;
363 let y = vp30_read_mv_comp(br)?;
367 fn read_mv_comp_packed(br: &mut BitReader) -> DecoderResult<i16> {
368 let code = br.read(3)?;
373 3 => if br.read_bool()? { Ok(-2) } else { Ok(2) },
374 4 => if br.read_bool()? { Ok(-3) } else { Ok(3) },
376 let val = (br.read(2)? as i16) + 4;
384 let val = (br.read(3)? as i16) + 8;
392 let val = (br.read(4)? as i16) + 16;
402 fn read_mv_packed(br: &mut BitReader) -> DecoderResult<MV> {
403 let x = read_mv_comp_packed(br)?;
404 let y = read_mv_comp_packed(br)?;
408 fn read_mv_comp_raw(br: &mut BitReader) -> DecoderResult<i16> {
409 let val = br.read(5)? as i16;
417 fn read_mv_raw(br: &mut BitReader) -> DecoderResult<MV> {
418 let x = read_mv_comp_raw(br)?;
419 let y = read_mv_comp_raw(br)?;
423 fn rescale_qmat(dst_qmat: &mut [i16; 64], base_qmat: &[i16; 64], dc_quant: i16, ac_quant: i16, minval: i16) {
424 for (dst, src) in dst_qmat.iter_mut().zip(base_qmat.iter()) {
425 *dst = (src.wrapping_mul(ac_quant) / 100).max(minval) << 2;
427 dst_qmat[0] = (base_qmat[0] * dc_quant / 100).max(minval * 2) << 2;
430 fn rescale_qmat_vp4(dst_qmat: &mut [i16; 64], base_qmat: &[i16; 64], dc_quant: i16, ac_quant: i16, is_intra: bool) {
431 let (bias, minval) = if is_intra { (3, 4) } else { (6, 8) };
432 for (dst, src) in dst_qmat.iter_mut().zip(base_qmat.iter()) {
433 *dst = ((src - bias).wrapping_mul(ac_quant) / 100 + bias) << 2;
435 dst_qmat[0] = (base_qmat[0] * dc_quant / 100).max(minval) << 2;
438 fn expand_token(blk: &mut Block, br: &mut BitReader, eob_run: &mut usize, token: u8) -> DecoderResult<()> {
441 0 | 1 | 2 => { *eob_run = (token as usize) + 1; },
443 let bits = token - 1;
444 *eob_run = (br.read(bits)? as usize) + (1 << bits);
446 6 => { *eob_run = br.read(12)? as usize; },
449 let bits = if token == 7 { 3 } else { 6 };
450 let run = (br.read(bits)? as usize) + 1;
452 validate!(blk.idx <= 64);
454 // single coefficients
455 9 | 10 | 11 | 12 => {
456 let val = (i16::from(token) - 7) >> 1;
457 if (token & 1) == 1 {
458 blk.coeffs[ZIGZAG[blk.idx]] = val;
460 blk.coeffs[ZIGZAG[blk.idx]] = -val;
464 13 | 14 | 15 | 16 => {
465 let val = i16::from(token) - 10;
466 if !br.read_bool()? {
467 blk.coeffs[ZIGZAG[blk.idx]] = val;
469 blk.coeffs[ZIGZAG[blk.idx]] = -val;
473 17 | 18 | 19 | 20 | 21 | 22 => {
474 let add_bits = if token == 22 { 9 } else { token - 16 };
475 let sign = br.read_bool()?;
476 let val = (br.read(add_bits)? as i16) + VP3_LITERAL_BASE[(token - 17) as usize];
478 blk.coeffs[ZIGZAG[blk.idx]] = val;
480 blk.coeffs[ZIGZAG[blk.idx]] = -val;
484 // zero run plus coefficient
485 23 | 24 | 25 | 26 | 27 => {
486 blk.idx += (token - 22) as usize;
487 validate!(blk.idx < 64);
488 if !br.read_bool()? {
489 blk.coeffs[ZIGZAG[blk.idx]] = 1;
491 blk.coeffs[ZIGZAG[blk.idx]] = -1;
496 let run_bits = token - 26;
502 let sign = br.read_bool()?;
503 blk.idx += br.read(run_bits)? as usize;
504 validate!(blk.idx < 64);
506 blk.coeffs[ZIGZAG[blk.idx]] = 1;
508 blk.coeffs[ZIGZAG[blk.idx]] = -1;
514 validate!(blk.idx < 64);
515 let sign = br.read_bool()?;
516 let val = (br.read(1)? as i16) + 2;
518 blk.coeffs[ZIGZAG[blk.idx]] = val;
520 blk.coeffs[ZIGZAG[blk.idx]] = -val;
525 let sign = br.read_bool()?;
526 let val = (br.read(1)? as i16) + 2;
527 blk.idx += (br.read(1)? as usize) + 2;
528 validate!(blk.idx < 64);
530 blk.coeffs[ZIGZAG[blk.idx]] = val;
532 blk.coeffs[ZIGZAG[blk.idx]] = -val;
540 } else if (token > 8) && (blk.idx > 1) {
546 macro_rules! fill_dc_pred {
547 ($self: expr, $ref_id: expr, $pred: expr, $pp: expr, $bit: expr, $idx: expr) => {
548 if $self.blocks[$idx].coded && $self.blocks[$idx].btype.get_ref_id() == $ref_id {
549 $pred[$bit] = $self.blocks[$idx].coeffs[0] as i32;
555 fn vp31_loop_filter_v(frm: &mut NASimpleVideoFrame<u8>, x: usize, y: usize, plane: usize, loop_str: i16) {
556 let off = frm.offset[plane] + x + y * frm.stride[plane];
557 vp31_loop_filter(frm.data, off, 1, frm.stride[plane], 8, loop_str);
560 fn vp31_loop_filter_h(frm: &mut NASimpleVideoFrame<u8>, x: usize, y: usize, plane: usize, loop_str: i16) {
561 let off = frm.offset[plane] + x + y * frm.stride[plane];
562 vp31_loop_filter(frm.data, off, frm.stride[plane], 1, 8, loop_str);
565 fn vp3_mv_mode(mvx: i16, mvy: i16) -> usize {
566 let mode = ((mvx & 1) + (mvy & 1) * 2) as usize;
567 if (mode == 3) && (mvx ^ mvy < 0) {
575 fn new(version: u8) -> Self {
576 let vt = alloc_video_buffer(NAVideoInfo::new(24, 24, false, YUV420_FORMAT), 4).unwrap();
577 let mc_buf = vt.get_vbuf().unwrap();
579 info: NACodecInfoRef::default(),
588 shuf: VPShuffler::new(),
595 mb_coded: Vec::new(),
596 mb_partial: Vec::new(),
608 blk_addr: Vec::new(),
611 sb_blocks: Vec::new(),
613 mb_blocks: Vec::new(),
616 fn parse_header(&mut self, br: &mut BitReader) -> DecoderResult<()> {
617 self.is_intra = !br.read_bool()?;
619 self.quant = br.read(6)? as usize;
622 validate!(self.version == 3 || self.version == 30);
623 let mb_w = br.read(8)? as usize;
624 let mb_h = br.read(8)? as usize;
625 validate!(mb_w == self.mb_w && mb_h == self.mb_h);
626 if self.version == 3 {
628 self.codes = Codes::VP30(VP30Codes::new());
631 let version = br.read(13)?;
632 let coding_type = br.read(1)?;
633 validate!(coding_type == 0);
636 validate!(self.version == 3 || self.version == 31);
637 if self.version == 3 {
639 self.codes = Codes::VP31(VP31Codes::new());
641 } else if version == 3 {
642 validate!(self.version == 4);
643 let mb_h = br.read(8)? as usize;
644 let mb_w = br.read(8)? as usize;
645 validate!(mb_w == self.mb_w && mb_h == self.mb_h);
646 let fact1 = br.read(5)?;
647 let fact2 = br.read(3)?;
648 validate!(fact1 == 1 && fact2 == 1);
649 let fact1 = br.read(5)?;
650 let fact2 = br.read(3)?;
651 validate!(fact1 == 1 && fact2 == 1);
654 return Err(DecoderError::InvalidData);
658 self.loop_str = if self.version != 4 {
659 VP31_LOOP_STRENGTH[self.quant]
661 VP40_LOOP_STRENGTH[self.quant]
665 fn vp30_unpack_sb_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
666 let mut has_nonempty = false;
668 let mut bit = !br.read_bool()?;
670 for sb in self.sb_info.iter_mut() {
673 run = if bit { vp30_read_ne_run1(br)? } else { vp30_read_ne_run0(br)? };
675 *sb = if bit { has_nonempty = true; SBState::Partial } else { SBState::Uncoded };
681 for el in self.mb_coded.iter_mut() { *el = false; }
682 let mut bit = !br.read_bool()?;
684 let mut mbiter = self.mb_coded.iter_mut();
685 for (sb, nmb) in self.sb_info.iter_mut().zip(self.sb_mbs.iter()) {
686 let nmbs = *nmb as usize;
687 if *sb == SBState::Partial {
691 run = if bit { vp30_read_coded_run1(br)? } else { vp30_read_coded_run0(br)? };
694 *mbiter.next().unwrap() = bit;
698 mbiter.next().unwrap();
703 let mut bit = !br.read_bool()?;
706 for (coded, nblk) in self.mb_coded.iter().zip(self.mb_blocks.iter()) {
707 let nblks = *nblk as usize;
709 let mut cb = [false; 4];
713 run = if bit { vp30_read_coded_run1(br)? } else { vp30_read_coded_run0(br)? };
719 let addr = self.blk_addr[cur_blk + j] >> 2;
720 self.blocks[addr].coded = cb[j];
729 fn vp30_unpack_mb_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
731 if let Codes::VP30(ref codes) = self.codes {
732 for (sb, nblk) in self.sb_info.iter_mut().zip(self.sb_blocks.iter()).take(self.y_sbs) {
733 let nblks = *nblk as usize;
734 if *sb == SBState::Uncoded {
736 self.blocks[self.blk_addr[cur_blk] >> 2].btype = VPMBType::InterNoMV;
740 for _ in 0..nblks/4 {
741 let mut coded = *sb == SBState::Coded;
744 if self.blocks[self.blk_addr[cur_blk + blk] >> 2].coded {
750 let mode = if !coded {
753 br.read_cb(&codes.mbtype_cb)?
756 self.blocks[self.blk_addr[cur_blk] >> 2].btype = mode;
763 return Err(DecoderError::Bug);
765 // replicate types for chroma
767 let mut off_u = self.y_blocks;
768 let mut off_v = off_u + self.mb_w * self.mb_h;
769 for _blk_y in 0..self.mb_h {
770 for blk_x in 0..self.mb_w {
771 let btype = self.blocks[off_y + blk_x * 2].btype;
772 self.blocks[off_u + blk_x].btype = btype;
773 self.blocks[off_v + blk_x].btype = btype;
775 off_y += self.mb_w * 2 * 2;
781 fn vp30_unpack_mv_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
782 let mut last_mv = ZERO_MV;
785 for _ in 0..self.y_blocks/4 {
786 let baddr = self.blk_addr[cur_blk] >> 2;
787 if self.blocks[baddr].btype == VPMBType::InterFourMV {
788 let saddr = baddr.min(self.blk_addr[cur_blk + 1] >> 2).min(self.blk_addr[cur_blk + 2] >> 2).min(self.blk_addr[cur_blk + 3] >> 2);
790 let blk = &mut self.blocks[saddr + (i & 1) + (i & 2) * self.mb_w];
792 blk.mv = vp30_read_mv(br)?;
798 match self.blocks[baddr].btype {
799 VPMBType::Intra | VPMBType::InterNoMV | VPMBType::GoldenNoMV => {
802 VPMBType::InterMV => {
803 cur_mv = vp30_read_mv(br)?;
806 VPMBType::InterNearest => {
810 cur_mv = vp30_read_mv(br)?;
814 self.blocks[self.blk_addr[cur_blk] >> 2].mv = cur_mv;
821 fn vp30_unpack_coeffs(&mut self, br: &mut BitReader, coef_no: usize, table: usize) -> DecoderResult<()> {
822 if let Codes::VP30(ref codes) = self.codes {
823 for blkaddr in self.blk_addr.iter() {
824 let blk: &mut Block = &mut self.blocks[blkaddr >> 2];
825 if !blk.coded || blk.idx != coef_no { continue; }
826 if self.eob_run > 0 {
831 let cb = if coef_no == 0 {
833 } else if blk.btype.is_intra() {
834 &codes.ac_i_cb[table]
836 &codes.ac_p_cb[table]
838 let token = br.read_cb(cb)?;
839 expand_token(blk, br, &mut self.eob_run, token)?;
843 Err(DecoderError::Bug)
846 fn vp31_unpack_sb_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
847 let mut has_uncoded = false;
848 let mut has_partial = false;
850 let mut brun = BitRunDecoder::new(br, read_long_run)?;
851 for sb in self.sb_info.iter_mut() {
852 if brun.get_val(br)? {
853 *sb = SBState::Partial;
856 *sb = SBState::Uncoded;
862 let mut brun = BitRunDecoder::new(br, read_long_run)?;
864 for (sb, nblk) in self.sb_info.iter_mut().zip(self.sb_blocks.iter()) {
865 let nblks = *nblk as usize;
866 if *sb != SBState::Partial && brun.get_val(br)? {
867 *sb = SBState::Coded;
869 let blk_idx = self.blk_addr[cur_blk] >> 2;
870 self.blocks[blk_idx].coded = true;
875 let blk_idx = self.blk_addr[cur_blk] >> 2;
876 self.blocks[blk_idx].coded = false;
883 let mut brun = BitRunDecoder::new(br, read_short_run)?;
885 for (sb, nblk) in self.sb_info.iter_mut().zip(self.sb_blocks.iter()) {
886 let nblks = *nblk as usize;
887 if *sb == SBState::Partial {
889 let blk_idx = self.blk_addr[cur_blk] >> 2;
890 self.blocks[blk_idx].coded = brun.get_val(br)?;
900 fn vp31_unpack_mb_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
901 let mut modes = [VPMBType::InterNoMV; 8];
902 let alphabet = br.read(3)? as usize;
903 let raw_modes = alphabet >= 7;
905 for mode in VP31_DEFAULT_MB_MODES.iter() {
906 modes[br.read(3)? as usize] = *mode;
908 } else if alphabet < 7 {
909 modes.copy_from_slice(&VP31_MB_MODES[alphabet - 1]);
913 for (sb, nblk) in self.sb_info.iter_mut().zip(self.sb_blocks.iter()).take(self.y_sbs) {
914 let nblks = *nblk as usize;
915 if *sb == SBState::Uncoded {
917 self.blocks[self.blk_addr[cur_blk] >> 2].btype = VPMBType::InterNoMV;
921 for _ in 0..nblks/4 {
922 let mut coded = *sb == SBState::Coded;
925 if self.blocks[self.blk_addr[cur_blk + blk] >> 2].coded {
931 let mode = if !coded {
933 } else if !raw_modes {
934 let code = br.read_code(UintCodeType::LimitedUnary(7, 0))?;
937 VP31_DEFAULT_MB_MODES[br.read(3)? as usize]
940 self.blocks[self.blk_addr[cur_blk] >> 2].btype = mode;
946 // replicate types for chroma
948 let mut off_u = self.y_blocks;
949 let mut off_v = off_u + self.mb_w * self.mb_h;
950 for _blk_y in 0..self.mb_h {
951 for blk_x in 0..self.mb_w {
952 let btype = self.blocks[off_y + blk_x * 2].btype;
953 self.blocks[off_u + blk_x].btype = btype;
954 self.blocks[off_v + blk_x].btype = btype;
956 off_y += self.mb_w * 2 * 2;
962 fn vp31_unpack_mv_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
963 let mut last_mv = ZERO_MV;
964 let mut last2_mv = ZERO_MV;
965 let read_mv = if br.read_bool()? { read_mv_raw } else { read_mv_packed };
968 for _ in 0..self.y_blocks/4 {
969 if self.blocks[self.blk_addr[cur_blk] >> 2].btype == VPMBType::InterFourMV {
970 let a0 = self.blk_addr[cur_blk + 0] >> 2;
971 let a1 = self.blk_addr[cur_blk + 1] >> 2;
972 let a2 = self.blk_addr[cur_blk + 2] >> 2;
973 let a3 = self.blk_addr[cur_blk + 3] >> 2;
974 let first = a0.min(a1).min(a2).min(a3);
975 let last = a0.max(a1).max(a2).max(a3);
976 self.blocks[first + 0].mv = (read_mv)(br)?;
977 self.blocks[first + 1].mv = (read_mv)(br)?;
978 self.blocks[last - 1].mv = (read_mv)(br)?;
979 self.blocks[last + 0].mv = (read_mv)(br)?;
981 last_mv = self.blocks[last].mv;
985 match self.blocks[self.blk_addr[cur_blk] >> 2].btype {
986 VPMBType::Intra | VPMBType::InterNoMV | VPMBType::GoldenNoMV => {
989 VPMBType::InterMV => {
990 cur_mv = (read_mv)(br)?;
994 VPMBType::InterNearest => {
997 VPMBType::InterNear => {
999 std::mem::swap(&mut last_mv, &mut last2_mv);
1002 cur_mv = (read_mv)(br)?;
1006 self.blocks[self.blk_addr[cur_blk] >> 2].mv = cur_mv;
1013 fn vp31_unpack_coeffs(&mut self, br: &mut BitReader, coef_no: usize, table_y: usize, table_c: usize) -> DecoderResult<()> {
1014 if let Codes::VP31(ref codes) = self.codes {
1015 let cbs = if coef_no == 0 {
1016 [&codes.dc_cb[table_y], &codes.dc_cb[table_c]]
1017 } else if coef_no < 6 {
1018 [&codes.ac0_cb[table_y], &codes.ac0_cb[table_c]]
1019 } else if coef_no < 15 {
1020 [&codes.ac1_cb[table_y], &codes.ac1_cb[table_c]]
1021 } else if coef_no < 28 {
1022 [&codes.ac2_cb[table_y], &codes.ac2_cb[table_c]]
1024 [&codes.ac3_cb[table_y], &codes.ac3_cb[table_c]]
1026 for blkaddr in self.blk_addr.iter() {
1027 let blk: &mut Block = &mut self.blocks[blkaddr >> 2];
1028 if !blk.coded || blk.idx != coef_no { continue; }
1029 if self.eob_run > 0 {
1034 let cb = if (blkaddr & 3) == 0 { cbs[0] } else { cbs[1] };
1035 let token = br.read_cb(cb)?;
1036 expand_token(blk, br, &mut self.eob_run, token)?;
1040 Err(DecoderError::Bug)
1043 fn vp40_unpack_sb_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
1044 let mut has_uncoded = false;
1046 if let Some(ref aux_codes) = self.aux_codes {
1047 for el in self.sb_info.iter_mut() {
1048 *el = SBState::Partial;
1051 let mut mbiter = self.mb_coded.iter_mut();
1052 let mut brun = BitRunDecoder::new(br, read_mb_run)?;
1053 for nmb in self.sb_mbs.iter() {
1054 let nmbs = *nmb as usize;
1056 let coded = brun.get_val(br)?;
1057 *mbiter.next().unwrap() = coded;
1058 has_uncoded |= !coded;
1063 let mut mbiter = self.mb_coded.iter().zip(self.mb_partial.iter_mut());
1064 let mut brun = BitRunDecoder::new(br, read_mb_run)?;
1065 for nmb in self.sb_mbs.iter() {
1066 let nmbs = *nmb as usize;
1068 let (coded, partial) = mbiter.next().unwrap();
1072 *partial = brun.get_val(br)?;
1078 let mut cur_blk = 0;
1079 for ((coded, partial), nblk) in self.mb_coded.iter().zip(self.mb_partial.iter()).zip(self.mb_blocks.iter()) {
1080 let nblks = *nblk as usize;
1083 let addr = self.blk_addr[cur_blk] >> 2;
1084 self.blocks[addr].coded = true;
1087 } else if !*partial {
1089 let addr = self.blk_addr[cur_blk] >> 2;
1090 self.blocks[addr].coded = false;
1094 let mut pat = br.read_cb(&aux_codes.mbpat_cb[bpmode])? + 1;
1095 bpmode = VP40_BP_PREDICTOR[pat as usize] as usize;
1097 let mut addrs = [0; 4];
1099 addrs[i] = self.blk_addr[cur_blk + i] >> 2;
1100 for j in (0..i).rev() {
1101 if addrs[j] > addrs[j + 1] {
1102 addrs.swap(j, j + 1);
1107 self.blocks[addrs[i]].coded = (pat & 8) != 0;
1116 Err(DecoderError::Bug)
1119 fn vp40_unpack_mv_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
1120 let mut last_mv = ZERO_MV;
1121 let mut last2_mv = ZERO_MV;
1122 let mut last_mv_g = ZERO_MV;
1124 let mut cur_blk = 0;
1125 if let Some(ref codes) = self.aux_codes {
1126 for _ in 0..self.y_blocks/4 {
1127 if self.blocks[self.blk_addr[cur_blk] >> 2].btype == VPMBType::InterFourMV {
1128 let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv.x.abs() as usize]];
1129 let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv.y.abs() as usize]];
1130 let x_sign = last_mv.x < 0;
1131 let y_sign = last_mv.y < 0;
1133 let saddr = (self.blk_addr[cur_blk] >> 2).min(self.blk_addr[cur_blk + 1] >> 2).min(self.blk_addr[cur_blk + 2] >> 2).min(self.blk_addr[cur_blk + 3] >> 2);
1135 let blk = &mut self.blocks[saddr + (i & 1) + (i >> 1) * self.mb_w * 2];
1136 blk.mv.x = br.read_cb(x_cb)? as i16;
1138 blk.mv.x = -blk.mv.x;
1140 blk.mv.y = br.read_cb(y_cb)? as i16;
1142 blk.mv.y = -blk.mv.y;
1149 match self.blocks[self.blk_addr[cur_blk] >> 2].btype {
1150 VPMBType::Intra | VPMBType::InterNoMV | VPMBType::GoldenNoMV => {
1153 VPMBType::InterMV => {
1154 let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv.x.abs() as usize]];
1155 let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv.y.abs() as usize]];
1156 let x_sign = last_mv.x < 0;
1157 let y_sign = last_mv.y < 0;
1158 let x = br.read_cb(x_cb)? as i16;
1159 let y = br.read_cb(y_cb)? as i16;
1160 cur_mv = MV { x: if !x_sign { x } else { -x }, y: if !y_sign { y } else { -y } };
1164 VPMBType::InterNearest => {
1167 VPMBType::InterNear => {
1169 std::mem::swap(&mut last_mv, &mut last2_mv);
1172 let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv_g.x.abs() as usize]];
1173 let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv_g.y.abs() as usize]];
1174 let x_sign = last_mv_g.x < 0;
1175 let y_sign = last_mv_g.y < 0;
1176 let x = br.read_cb(x_cb)? as i16;
1177 let y = br.read_cb(y_cb)? as i16;
1178 cur_mv = MV { x: if !x_sign { x } else { -x }, y: if !y_sign { y } else { -y } };
1183 self.blocks[self.blk_addr[cur_blk] >> 2].mv = cur_mv;
1190 Err(DecoderError::Bug)
1193 fn vp40_unpack_coeffs(&mut self, br: &mut BitReader, dc_table_y: usize, dc_table_c: usize, ac_table_y: usize, ac_table_c: usize) -> DecoderResult<()> {
1194 const VP40_PRED_MASKS: [usize; 16] = [ // top, bottom, left, right
1195 0b1010, 0b1010, 0b1000, 0b1011,
1196 0b1010, 0b1010, 0b0010, 0b1110,
1197 0b0010, 0b1010, 0b0010, 0b0110,
1198 0b0100, 0b0111, 0b1110, 0b1110
1200 self.last_dc = [0; 3];
1201 if let Codes::VP31(ref codes) = self.codes {
1202 let mut coef_eob: [usize; 64] = [0; 64];
1203 for (blkaddr, bsub) in self.blk_addr.iter().zip(self.blk_sub.iter()) {
1204 let blk: &mut Block = &mut self.blocks[blkaddr >> 2];
1205 if !blk.coded { continue; }
1206 let mut idx = blkaddr >> 2;
1207 let (bx, by) = if (blkaddr & 3) == 0 {
1208 (idx % (self.mb_w * 2), idx / (self.mb_w * 2))
1210 idx -= self.mb_w * self.mb_h * 4;
1211 if idx >= self.mb_w * self.mb_h {
1212 idx -= self.mb_w * self.mb_h;
1214 (idx % self.mb_w, idx / self.mb_w)
1216 while blk.idx < 64 {
1217 if coef_eob[blk.idx] > 0 {
1218 coef_eob[blk.idx] -= 1;
1222 let cbs = if blk.idx == 0 {
1223 [&codes.dc_cb[dc_table_y], &codes.dc_cb[dc_table_c]]
1224 } else if blk.idx < 6 {
1225 [&codes.ac0_cb[ac_table_y], &codes.ac0_cb[ac_table_c]]
1226 } else if blk.idx < 15 {
1227 [&codes.ac1_cb[ac_table_y], &codes.ac1_cb[ac_table_c]]
1228 } else if blk.idx < 28 {
1229 [&codes.ac2_cb[ac_table_y], &codes.ac2_cb[ac_table_c]]
1231 [&codes.ac3_cb[ac_table_y], &codes.ac3_cb[ac_table_c]]
1233 let cb = if (blkaddr & 3) == 0 { cbs[0] } else { cbs[1] };
1234 let token = br.read_cb(cb)?;
1235 expand_token(blk, br, &mut coef_eob[blk.idx], token)?;
1236 if blk.idx == 64 { break; }
1238 let idx = blkaddr >> 2;
1239 let mask = VP40_PRED_MASKS[*bsub as usize];
1240 if (blkaddr & 3) == 0 {
1241 let pred_dc = self.vp40_predict_dc(bx, by, self.mb_w * 2, self.mb_h * 2, idx, mask, true);
1242 let blk: &mut Block = &mut self.blocks[blkaddr >> 2];
1243 blk.coeffs[0] += pred_dc;
1244 self.last_dc[blk.btype.get_ref_id() as usize] = blk.coeffs[0];
1246 let pred_dc = self.vp40_predict_dc(bx, by, self.mb_w, self.mb_h, idx, mask, false);
1247 let blk: &mut Block = &mut self.blocks[blkaddr >> 2];
1248 blk.coeffs[0] += pred_dc;
1249 self.last_dc[blk.btype.get_ref_id() as usize] = blk.coeffs[0];
1254 Err(DecoderError::Bug)
1257 fn decode_vp30(&mut self, br: &mut BitReader, frm: &mut NASimpleVideoFrame<u8>) -> DecoderResult<()> {
1258 for blk in self.blocks.iter_mut() {
1259 blk.coeffs = [0; 64];
1265 for sb in self.sb_info.iter_mut() { *sb = SBState::Coded; }
1266 for blk in self.blocks.iter_mut() {
1267 blk.btype = VPMBType::Intra;
1271 if self.shuf.get_last().is_none() || self.shuf.get_golden().is_none() {
1272 return Err(DecoderError::MissingReference);
1274 self.vp30_unpack_sb_info(br)?;
1275 self.vp30_unpack_mb_info(br)?;
1276 self.vp30_unpack_mv_info(br)?;
1278 let dc_quant = VP30_DC_SCALES[self.quant] * 10;
1279 let ac_quant = VP30_AC_SCALES[self.quant];
1281 self.update_gf = ac_quant <= 50;
1283 rescale_qmat(&mut self.qmat_y, VP3_QMAT_Y, dc_quant, ac_quant, 2);
1284 rescale_qmat(&mut self.qmat_c, VP3_QMAT_C, dc_quant, ac_quant, 2);
1285 rescale_qmat(&mut self.qmat_y_p, VP3_QMAT_INTER, dc_quant, ac_quant, 4);
1286 if self.quant == 10 {
1287 self.qmat_y[29] = 980;
1288 self.qmat_y[58] = 1636;
1289 self.qmat_y[59] = 1964;
1290 } else if self.quant == 31 {
1291 self.qmat_y[58] = 456;
1292 } else if self.quant == 44 {
1293 self.qmat_y[58] = 224;
1295 self.qmat_c_p.copy_from_slice(&self.qmat_y_p);
1297 let table = if ac_quant <= 50 {
1299 } else if ac_quant <= 150 {
1301 } else if ac_quant <= 300 {
1303 } else if ac_quant <= 600 {
1310 self.vp30_unpack_coeffs(br, 0, table)?;
1311 let mut last_dc_i = 0;
1312 let mut last_dc_p = 0;
1313 for blkaddr in self.blk_addr.iter() {
1314 let blk: &mut Block = &mut self.blocks[blkaddr >> 2];
1315 if !blk.coded { continue; }
1316 if blk.btype.is_intra() {
1317 blk.coeffs[0] += last_dc_i;
1318 last_dc_i = blk.coeffs[0];
1320 blk.coeffs[0] += last_dc_p;
1321 last_dc_p = blk.coeffs[0];
1325 for coef_no in 1..64 {
1326 self.vp30_unpack_coeffs(br, coef_no, table)?;
1330 self.output_blocks_intra(frm);
1332 self.output_blocks_inter(frm);
1337 fn decode_vp31(&mut self, br: &mut BitReader, frm: &mut NASimpleVideoFrame<u8>) -> DecoderResult<()> {
1338 for blk in self.blocks.iter_mut() {
1339 blk.coeffs = [0; 64];
1345 for sb in self.sb_info.iter_mut() { *sb = SBState::Coded; }
1346 for blk in self.blocks.iter_mut() {
1347 blk.btype = VPMBType::Intra;
1351 if self.shuf.get_last().is_none() || self.shuf.get_golden().is_none() {
1352 return Err(DecoderError::MissingReference);
1354 self.vp31_unpack_sb_info(br)?;
1355 self.vp31_unpack_mb_info(br)?;
1356 self.vp31_unpack_mv_info(br)?;
1358 let dc_quant = VP31_DC_SCALES[self.quant];
1359 let ac_quant = VP31_AC_SCALES[self.quant];
1360 rescale_qmat(&mut self.qmat_y, VP3_QMAT_Y, dc_quant, ac_quant, 2);
1361 rescale_qmat(&mut self.qmat_c, VP3_QMAT_C, dc_quant, ac_quant, 2);
1362 rescale_qmat(&mut self.qmat_y_p, VP3_QMAT_INTER, dc_quant, ac_quant, 4);
1363 rescale_qmat(&mut self.qmat_c_p, VP3_QMAT_INTER, dc_quant, ac_quant, 4);
1366 let dc_table_y = br.read(4)? as usize;
1367 let dc_table_c = br.read(4)? as usize;
1368 self.vp31_unpack_coeffs(br, 0, dc_table_y, dc_table_c)?;
1371 let ac_table_y = br.read(4)? as usize;
1372 let ac_table_c = br.read(4)? as usize;
1373 for coef_no in 1..64 {
1374 self.vp31_unpack_coeffs(br, coef_no, ac_table_y, ac_table_c)?;
1378 self.output_blocks_intra(frm);
1380 self.output_blocks_inter(frm);
1382 if self.loop_str > 0 {
1383 self.vp31_loop_filter(frm);
1388 fn decode_vp4(&mut self, br: &mut BitReader, frm: &mut NASimpleVideoFrame<u8>) -> DecoderResult<()> {
1389 for blk in self.blocks.iter_mut() {
1390 blk.coeffs = [0; 64];
1396 for sb in self.sb_info.iter_mut() { *sb = SBState::Coded; }
1397 for blk in self.blocks.iter_mut() {
1398 blk.btype = VPMBType::Intra;
1402 if self.shuf.get_last().is_none() || self.shuf.get_golden().is_none() {
1403 return Err(DecoderError::MissingReference);
1405 self.vp40_unpack_sb_info(br)?;
1406 self.vp31_unpack_mb_info(br)?;
1407 self.vp40_unpack_mv_info(br)?;
1409 let dc_y_quant = VP40_DC_Y_SCALES[self.quant];
1410 let dc_c_quant = VP40_DC_C_SCALES[self.quant];
1411 let ac_quant = VP40_AC_SCALES[self.quant];
1412 rescale_qmat_vp4(&mut self.qmat_y, VP40_QMAT, dc_y_quant, ac_quant, true);
1413 rescale_qmat_vp4(&mut self.qmat_y_p, VP40_QMAT, dc_c_quant, ac_quant, false);
1414 self.qmat_c.copy_from_slice(&self.qmat_y);
1415 self.qmat_c_p.copy_from_slice(&self.qmat_y_p);
1418 let dc_table_y = br.read(4)? as usize;
1419 let dc_table_c = br.read(4)? as usize;
1420 let ac_table_y = br.read(4)? as usize;
1421 let ac_table_c = br.read(4)? as usize;
1422 self.vp40_unpack_coeffs(br, dc_table_y, dc_table_c, ac_table_y, ac_table_c)?;
1425 self.output_blocks_intra(frm);
1427 self.output_blocks_inter(frm);
1432 fn vp31_predict_dc(&self, bx: usize, by: usize, bw: usize, blk_idx: usize) -> i16 {
1433 let mut preds = [0i32; 4];
1434 let mut pp: usize = 0;
1435 let ref_id = self.blocks[blk_idx].btype.get_ref_id();
1436 let is_right = bx == bw - 1;
1438 fill_dc_pred!(self, ref_id, preds, pp, 0, blk_idx - 1);
1440 fill_dc_pred!(self, ref_id, preds, pp, 1, blk_idx - 1 - bw);
1444 fill_dc_pred!(self, ref_id, preds, pp, 2, blk_idx - bw);
1446 fill_dc_pred!(self, ref_id, preds, pp, 3, blk_idx + 1 - bw);
1449 if pp == 0 { return self.last_dc[ref_id as usize]; }
1450 let mut pred = 0i32;
1452 if (pp & (1 << i)) != 0 {
1453 pred += (preds[i] as i32) * (VP31_DC_WEIGHTS[pp][i] as i32);
1456 pred /= VP31_DC_WEIGHTS[pp][4] as i32;
1458 if (pred - preds[2]).abs() > 128 { return preds[2] as i16; }
1459 if (pred - preds[0]).abs() > 128 { return preds[0] as i16; }
1460 if (pred - preds[1]).abs() > 128 { return preds[1] as i16; }
1464 fn vp40_predict_dc(&self, bx: usize, by: usize, bw: usize, bh: usize, blk_idx: usize, mask: usize, is_luma: bool) -> i16 {
1465 let mut preds = [0i32; 4];
1466 let mut pp: usize = 0;
1467 let ref_id = self.blocks[blk_idx].btype.get_ref_id();
1468 if (by > 0) && (((mask >> 3) & 1) == 1) { //top
1469 fill_dc_pred!(self, ref_id, preds, pp, 0, blk_idx - bw);
1471 if (by < bh - 1) && (((mask >> 2) & 1) == 1) { //bottom
1472 fill_dc_pred!(self, ref_id, preds, pp, 1, blk_idx + bw);
1474 if (bx > 0) && (((mask >> 1) & 1) == 1) { //left
1475 fill_dc_pred!(self, ref_id, preds, pp, 2, blk_idx - 1);
1477 if (is_luma && bx == 0 && (by >= 4)) && (((mask >> 1) & 1) == 1) { //left wrap
1478 fill_dc_pred!(self, ref_id, preds, pp, 2, blk_idx - 1 - 3 * bw);
1480 if (bx < bw - 1) && (((mask >> 0) & 1) == 1) { //right
1481 fill_dc_pred!(self, ref_id, preds, pp, 3, blk_idx + 1);
1483 if pp == 0 { return self.last_dc[ref_id as usize]; }
1484 let mut pred = 0i32;
1487 if (pp & (1 << i)) != 0 {
1488 pred += preds[i] as i32;
1491 return (pred / 2) as i16;
1495 self.last_dc[ref_id as usize]
1497 fn restore_dcs(&mut self) {
1498 let blk_stride = self.mb_w * 2;
1499 let mut blk_idx = 0;
1500 self.last_dc = [0; 3];
1501 for by in 0..self.mb_h*2 {
1502 for bx in 0..self.mb_w*2 {
1503 if !self.blocks[blk_idx + bx].coded { continue; }
1504 let dc = self.vp31_predict_dc(bx, by, self.mb_w*2, blk_idx + bx);
1505 self.blocks[blk_idx + bx].coeffs[0] += dc;
1506 self.last_dc[self.blocks[blk_idx + bx].btype.get_ref_id() as usize] = self.blocks[blk_idx + bx].coeffs[0];
1508 blk_idx += blk_stride;
1510 let blk_stride = self.mb_w;
1511 for _plane in 1..3 {
1512 self.last_dc = [0; 3];
1513 for by in 0..self.mb_h {
1514 for bx in 0..self.mb_w {
1515 if !self.blocks[blk_idx + bx].coded { continue; }
1516 let dc = self.vp31_predict_dc(bx, by, self.mb_w, blk_idx + bx);
1517 self.blocks[blk_idx + bx].coeffs[0] += dc;
1518 self.last_dc[self.blocks[blk_idx + bx].btype.get_ref_id() as usize] = self.blocks[blk_idx + bx].coeffs[0];
1520 blk_idx += blk_stride;
1524 fn output_blocks_intra(&mut self, frm: &mut NASimpleVideoFrame<u8>) {
1525 let mut biter = self.blocks.iter_mut();
1526 for by in 0..self.mb_h*2 {
1527 for bx in 0..self.mb_w*2 {
1528 let mut blk = biter.next().unwrap();
1529 let qmat = &self.qmat_y;
1530 blk.coeffs[0] *= qmat[0];
1532 unquant(&mut blk.coeffs, qmat);
1533 vp_put_block(&mut blk.coeffs, bx, by, 0, frm);
1535 vp_put_block_dc(&mut blk.coeffs, bx, by, 0, frm);
1540 for by in 0..self.mb_h {
1541 for bx in 0..self.mb_w {
1542 let mut blk = biter.next().unwrap();
1543 let qmat = &self.qmat_c;
1544 blk.coeffs[0] *= qmat[0];
1546 unquant(&mut blk.coeffs, qmat);
1547 vp_put_block(&mut blk.coeffs, bx, by, plane, frm);
1549 vp_put_block_dc(&mut blk.coeffs, bx, by, plane, frm);
1555 fn output_blocks_inter(&mut self, frm: &mut NASimpleVideoFrame<u8>) {
1556 let mut blk_idx = 0;
1557 let bstride = self.mb_w * 2;
1558 for by in (0..self.mb_h*2).step_by(2) {
1559 for bx in (0..self.mb_w*2).step_by(2) {
1560 if self.blocks[blk_idx + bx].btype != VPMBType::InterFourMV {
1563 let mvs = [ self.blocks[blk_idx + bx].mv,
1564 self.blocks[blk_idx + bx + 1].mv,
1565 self.blocks[blk_idx + bx + bstride].mv,
1566 self.blocks[blk_idx + bx + 1 + bstride].mv ];
1567 let mut mv_sum = mvs[0] + mvs[1] + mvs[2] + mvs[3];
1568 mv_sum.x = (mv_sum.x + 2) >> 2;
1569 mv_sum.y = (mv_sum.y + 2) >> 2;
1571 let src = self.shuf.get_last().unwrap();
1573 let xoff = (i & 1) * 8;
1574 let yoff = (i >> 1) * 8;
1576 let mode = vp3_mv_mode(mvs[i].x, mvs[i].y);
1577 if self.version != 4 {
1578 copy_block(frm, src.clone(), 0, bx * 8 + xoff, by * 8 + yoff,
1579 mvs[i].x >> 1, mvs[i].y >> 1, 8, 8, 0, 1, mode, VP3_INTERP_FUNCS);
1581 vp_copy_block(frm, src.clone(), 0, bx * 8 + xoff, by * 8 + yoff,
1582 mvs[i].x >> 1, mvs[i].y >> 1, 0, 1, self.loop_str,
1583 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1587 let mx = (mv_sum.x >> 1) | (mv_sum.x & 1);
1588 let my = (mv_sum.y >> 1) | (mv_sum.y & 1);
1589 let mode = vp3_mv_mode(mx, my);
1590 copy_block(frm, src.clone(), 1, bx * 4, by * 4, mx >> 1, my >> 1, 8, 8, 0, 1, mode, VP3_INTERP_FUNCS);
1591 copy_block(frm, src.clone(), 2, bx * 4, by * 4, mx >> 1, my >> 1, 8, 8, 0, 1, mode, VP3_INTERP_FUNCS);
1593 blk_idx += bstride * 2;
1596 let mut biter = self.blocks.iter_mut();
1597 for by in 0..self.mb_h*2 {
1598 for bx in 0..self.mb_w*2 {
1599 let mut blk = biter.next().unwrap();
1600 // do MC for whole macroblock
1601 if !blk.btype.is_intra() && (((bx | by) & 1) == 0) && (blk.btype != VPMBType::InterFourMV) {
1602 let src = if blk.btype.get_ref_id() == 1 {
1603 self.shuf.get_last().unwrap()
1605 self.shuf.get_golden().unwrap()
1607 let mode = vp3_mv_mode(blk.mv.x, blk.mv.y);
1608 if self.version != 4 {
1609 copy_block(frm, src.clone(), 0, bx * 8, by * 8,
1610 blk.mv.x >> 1, blk.mv.y >> 1, 16, 16, 0, 1, mode, VP3_INTERP_FUNCS);
1612 vp_copy_block(frm, src.clone(), 0, bx * 8, by * 8,
1613 blk.mv.x >> 1, blk.mv.y >> 1, 0, 1, self.loop_str,
1614 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1615 vp_copy_block(frm, src.clone(), 0, bx * 8 + 8, by * 8,
1616 blk.mv.x >> 1, blk.mv.y >> 1, 0, 1, self.loop_str,
1617 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1618 vp_copy_block(frm, src.clone(), 0, bx * 8, by * 8 + 8,
1619 blk.mv.x >> 1, blk.mv.y >> 1, 0, 1, self.loop_str,
1620 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1621 vp_copy_block(frm, src.clone(), 0, bx * 8 + 8, by * 8 + 8,
1622 blk.mv.x >> 1, blk.mv.y >> 1, 0, 1, self.loop_str,
1623 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1625 let mx = (blk.mv.x >> 1) | (blk.mv.x & 1);
1626 let my = (blk.mv.y >> 1) | (blk.mv.y & 1);
1627 let mode = vp3_mv_mode(mx, my);
1628 if self.version != 4 {
1629 copy_block(frm, src.clone(), 1, bx * 4, by * 4,
1630 mx >> 1, my >> 1, 8, 8, 0, 1, mode, VP3_INTERP_FUNCS);
1631 copy_block(frm, src.clone(), 2, bx * 4, by * 4,
1632 mx >> 1, my >> 1, 8, 8, 0, 1, mode, VP3_INTERP_FUNCS);
1634 vp_copy_block(frm, src.clone(), 1, bx * 4, by * 4,
1635 mx >> 1, my >> 1, 0, 1, self.loop_str,
1636 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1637 vp_copy_block(frm, src.clone(), 2, bx * 4, by * 4,
1638 mx >> 1, my >> 1, 0, 1, self.loop_str,
1639 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1642 let qmat = if blk.btype.is_intra() { &self.qmat_y } else { &self.qmat_y_p };
1643 blk.coeffs[0] *= qmat[0];
1645 unquant(&mut blk.coeffs, qmat);
1648 copy_block(frm, self.shuf.get_last().unwrap(), 0, bx * 8, by * 8, 0, 0, 8, 8, 0, 1, 0, VP3_INTERP_FUNCS);
1649 } else if blk.btype.is_intra() {
1651 vp_put_block(&mut blk.coeffs, bx, by, 0, frm);
1653 vp_put_block_dc(&mut blk.coeffs, bx, by, 0, frm);
1657 vp_add_block(&mut blk.coeffs, bx, by, 0, frm);
1659 vp_add_block_dc(&mut blk.coeffs, bx, by, 0, frm);
1665 for by in 0..self.mb_h {
1666 for bx in 0..self.mb_w {
1667 let mut blk = biter.next().unwrap();
1668 let qmat = if blk.btype.is_intra() { &self.qmat_c } else { &self.qmat_c_p };
1669 blk.coeffs[0] *= qmat[0];
1671 unquant(&mut blk.coeffs, qmat);
1674 copy_block(frm, self.shuf.get_last().unwrap(), plane, bx * 8, by * 8, 0, 0, 8, 8, 0, 1, 0, VP3_INTERP_FUNCS);
1675 } else if blk.btype.is_intra() {
1677 vp_put_block(&mut blk.coeffs, bx, by, plane, frm);
1679 vp_put_block_dc(&mut blk.coeffs, bx, by, plane, frm);
1683 vp_add_block(&mut blk.coeffs, bx, by, plane, frm);
1685 vp_add_block_dc(&mut blk.coeffs, bx, by, plane, frm);
1692 fn vp31_loop_filter(&mut self, frm: &mut NASimpleVideoFrame<u8>) {
1693 let mut blk_idx = 0;
1694 let blk_w = self.mb_w * 2;
1695 for by in 0..self.mb_h*2 {
1696 for bx in 0..blk_w {
1697 let blk = &self.blocks[blk_idx + bx];
1698 if (bx > 0) && blk.coded {
1699 vp31_loop_filter_v(frm, bx * 8, by * 8, 0, self.loop_str);
1701 if (by > 0) && blk.coded {
1702 vp31_loop_filter_h(frm, bx * 8, by * 8, 0, self.loop_str);
1704 if (bx < blk_w - 1) && !self.blocks[blk_idx + bx + 1].coded {
1705 vp31_loop_filter_v(frm, bx * 8 + 8, by * 8, 0, self.loop_str);
1707 if (by < self.mb_h * 2 - 1) && !self.blocks[blk_idx + bx + blk_w].coded {
1708 vp31_loop_filter_h(frm, bx * 8, by * 8 + 8, 0, self.loop_str);
1713 let blk_w = self.mb_w;
1715 for by in 0..self.mb_h {
1716 for bx in 0..self.mb_w {
1717 let blk = &self.blocks[blk_idx + bx];
1718 if (bx > 0) && blk.coded {
1719 vp31_loop_filter_v(frm, bx * 8, by * 8, plane, self.loop_str);
1721 if (by > 0) && blk.coded {
1722 vp31_loop_filter_h(frm, bx * 8, by * 8, plane, self.loop_str);
1724 if (bx < blk_w - 1) && !self.blocks[blk_idx + bx + 1].coded {
1725 vp31_loop_filter_v(frm, bx * 8 + 8, by * 8, plane, self.loop_str);
1727 if (by < self.mb_h - 1) && !self.blocks[blk_idx + bx + blk_w].coded {
1728 vp31_loop_filter_h(frm, bx * 8, by * 8 + 8, plane, self.loop_str);
1735 fn generate_block_addr(&mut self) {
1736 let sb_w_y = (self.width + 31) >> 5;
1737 let sb_h_y = (self.height + 31) >> 5;
1738 let sb_w_c = ((self.width >> 1) + 31) >> 5;
1739 let sb_h_c = ((self.height >> 1) + 31) >> 5;
1740 self.y_sbs = sb_w_y * sb_h_y;
1741 let tot_sb = sb_w_y * sb_h_y + 2 * sb_w_c * sb_h_c;
1742 let tot_mb = self.mb_w * self.mb_h * 2 + ((self.mb_w + 1) & !1) * ((self.mb_h + 1) & !1) * 2;
1743 let bw = self.width >> 3;
1744 let bh = self.height >> 3;
1745 let tot_blk = bw * bh * 3 / 2;
1746 self.sb_info.resize(tot_sb, SBState::Uncoded);
1747 self.sb_blocks = Vec::with_capacity(tot_sb);
1748 self.mb_blocks = Vec::with_capacity(tot_mb);
1749 self.sb_mbs = Vec::with_capacity(tot_sb);
1750 self.blk_addr = Vec::with_capacity(tot_blk);
1751 self.blk_sub = Vec::with_capacity(tot_blk);
1752 self.y_blocks = bw * bh;
1753 let mut base_idx = 0;
1755 let w = if plane > 0 { self.width >> 1 } else { self.width };
1756 let h = if plane > 0 { self.height >> 1 } else { self.height };
1757 let sb_w = (w + 31) >> 5;
1758 let sb_h = (h + 31) >> 5;
1765 let bx = x * 4 + HILBERT_ORDER[mb_no * 4][0];
1766 let by = y * 4 + HILBERT_ORDER[mb_no * 4][1];
1767 if (bx >= blk_w) || (by >= blk_h) { continue; }
1768 let mut nblocks = 0;
1769 for blk_no in 0..4 {
1770 let bx = x * 4 + HILBERT_ORDER[mb_no * 4 + blk_no][0];
1771 let by = y * 4 + HILBERT_ORDER[mb_no * 4 + blk_no][1];
1772 if (bx >= blk_w) || (by >= blk_h) { continue; }
1775 self.mb_blocks.push(nblocks);
1778 self.sb_mbs.push(nmbs);
1780 let mut nblocks = 0;
1781 for blk_no in 0..16 {
1782 let bx = x * 4 + HILBERT_ORDER[blk_no][0];
1783 let by = y * 4 + HILBERT_ORDER[blk_no][1];
1784 if (bx >= blk_w) || (by >= blk_h) { continue; }
1785 let idx = base_idx + bx + by * blk_w;
1786 self.blk_addr.push(idx * 4 + plane);
1787 self.blk_sub.push(blk_no as u8);
1790 self.sb_blocks.push(nblocks);
1793 base_idx += blk_w * blk_h;
1795 self.blocks.resize(tot_blk, Block::new());
1796 self.mb_coded.resize(tot_mb, false);
1797 self.mb_partial.resize(tot_mb, false);
1801 impl NADecoder for VP34Decoder {
1802 fn init(&mut self, supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
1803 if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
1804 let fmt = YUV420_FORMAT;
1805 self.width = vinfo.get_width();
1806 self.height = vinfo.get_height();
1807 validate!(((self.width | self.height) & 15) == 0);
1808 self.mb_w = self.width >> 4;
1809 self.mb_h = self.height >> 4;
1810 let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), true, fmt));
1811 self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
1812 supp.pool_u8.set_dec_bufs(3);
1813 supp.pool_u8.prealloc_video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), true, fmt), 4)?;
1815 self.generate_block_addr();
1816 if self.version == 4 {
1817 self.codes = Codes::VP31(VP31Codes::new_vp4());
1818 self.aux_codes = Some(VP40AuxCodes::new());
1822 Err(DecoderError::InvalidData)
1825 fn decode(&mut self, supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
1826 let src = pkt.get_buffer();
1827 validate!(src.len() > 0);
1828 let mut br = BitReader::new(&src, BitReaderMode::BE);
1830 self.parse_header(&mut br)?;
1834 if !self.shuf.has_refs() {
1835 return Err(DecoderError::MissingReference);
1839 let ret = supp.pool_u8.get_free();
1841 return Err(DecoderError::AllocError);
1843 let mut buf = ret.unwrap();
1844 let mut dframe = NASimpleVideoFrame::from_video_buf(&mut buf).unwrap();
1845 match self.version {
1846 30 => self.decode_vp30(&mut br, &mut dframe)?,
1847 31 => self.decode_vp31(&mut br, &mut dframe)?,
1848 4 => self.decode_vp4(&mut br, &mut dframe)?,
1849 _ => return Err(DecoderError::Bug),
1852 if self.is_intra || self.update_gf {
1853 self.shuf.add_golden_frame(buf.clone());
1855 self.shuf.add_frame(buf.clone());
1857 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), NABufferType::Video(buf));
1858 frm.set_keyframe(self.is_intra);
1859 frm.set_frame_type(if self.is_intra { FrameType::I } else { FrameType::P });
1862 fn flush(&mut self) {
1867 pub fn get_decoder_vp3() -> Box<NADecoder + Send> {
1868 Box::new(VP34Decoder::new(3))
1871 pub fn get_decoder_vp4() -> Box<NADecoder + Send> {
1872 Box::new(VP34Decoder::new(4))
1877 use nihav_core::codecs::RegisteredDecoders;
1878 use nihav_core::demuxers::RegisteredDemuxers;
1879 use nihav_codec_support::test::dec_video::*;
1880 use crate::duck_register_all_codecs;
1881 use nihav_commonfmt::generic_register_all_demuxers;
1885 let mut dmx_reg = RegisteredDemuxers::new();
1886 generic_register_all_demuxers(&mut dmx_reg);
1887 let mut dec_reg = RegisteredDecoders::new();
1888 duck_register_all_codecs(&mut dec_reg);
1890 test_decoding("avi", "vp3", "assets/Duck/vp30-logo.avi", Some(23), &dmx_reg, &dec_reg,
1891 ExpectedTestResult::MD5([0x51aba7df, 0x6e42534d, 0xef6c5b13, 0x26c38d1f]));
1896 let mut dmx_reg = RegisteredDemuxers::new();
1897 generic_register_all_demuxers(&mut dmx_reg);
1898 let mut dec_reg = RegisteredDecoders::new();
1899 duck_register_all_codecs(&mut dec_reg);
1901 // let file = "assets/Duck/vp31.avi";
1902 // let file = "assets/Duck/vp31_crash.avi";
1903 // let file = "assets/Duck/01-vp31-0500.avi";
1904 // test_file_decoding("avi", file, Some(3), true, false, None/*Some("vp31")*/, &dmx_reg, &dec_reg);
1906 test_decoding("avi", "vp3", "assets/Duck/01-vp31-0500.avi", Some(16), &dmx_reg, &dec_reg,
1907 ExpectedTestResult::MD5([0x65112f7e, 0x2914f29b, 0x2908ed2f, 0xce5fc8c5]));
1912 let mut dmx_reg = RegisteredDemuxers::new();
1913 generic_register_all_demuxers(&mut dmx_reg);
1914 let mut dec_reg = RegisteredDecoders::new();
1915 duck_register_all_codecs(&mut dec_reg);
1917 test_decoding("avi", "vp3", "assets/Duck/ot171_vp40.avi", Some(86), &dmx_reg, &dec_reg,
1918 ExpectedTestResult::MD5([0xd41d8cd9, 0x8f00b204, 0xe9800998, 0xecf8427e]));
1922 const HILBERT_ORDER: [[usize; 2]; 16] = [
1923 [ 0, 0 ], [ 1, 0 ], [ 1, 1 ], [ 0, 1 ],
1924 [ 0, 2 ], [ 0, 3 ], [ 1, 3 ], [ 1, 2 ],
1925 [ 2, 2 ], [ 2, 3 ], [ 3, 3 ], [ 3, 2 ],
1926 [ 3, 1 ], [ 2, 1 ], [ 2, 0 ], [ 3, 0 ]
1929 const VP31_LOOP_STRENGTH: [i16; 64] = [
1930 30, 25, 20, 20, 15, 15, 14, 14,
1931 13, 13, 12, 12, 11, 11, 10, 10,
1932 9, 9, 8, 8, 7, 7, 7, 7,
1933 6, 6, 6, 6, 5, 5, 5, 5,
1934 4, 4, 4, 4, 3, 3, 3, 3,
1935 2, 2, 2, 2, 2, 2, 2, 2,
1936 0, 0, 0, 0, 0, 0, 0, 0,
1937 0, 0, 0, 0, 0, 0, 0, 0
1940 const VP31_DEFAULT_MB_MODES: [VPMBType; 8] = [
1941 VPMBType::InterNoMV, VPMBType::Intra, VPMBType::InterMV, VPMBType::InterNearest,
1942 VPMBType::InterNear, VPMBType::GoldenNoMV, VPMBType::GoldenMV, VPMBType::InterFourMV
1945 const VP31_MB_MODES: [[VPMBType; 8]; 6] = [
1947 VPMBType::InterNearest, VPMBType::InterNear, VPMBType::InterMV, VPMBType::InterNoMV,
1948 VPMBType::Intra, VPMBType::GoldenNoMV, VPMBType::GoldenMV, VPMBType::InterFourMV
1950 VPMBType::InterNearest, VPMBType::InterNear, VPMBType::InterNoMV, VPMBType::InterMV,
1951 VPMBType::Intra, VPMBType::GoldenNoMV, VPMBType::GoldenMV, VPMBType::InterFourMV
1953 VPMBType::InterNearest, VPMBType::InterMV, VPMBType::InterNear, VPMBType::InterNoMV,
1954 VPMBType::Intra, VPMBType::GoldenNoMV, VPMBType::GoldenMV, VPMBType::InterFourMV
1956 VPMBType::InterNearest, VPMBType::InterMV, VPMBType::InterNoMV, VPMBType::InterNear,
1957 VPMBType::Intra, VPMBType::GoldenNoMV, VPMBType::GoldenMV, VPMBType::InterFourMV
1959 VPMBType::InterNoMV, VPMBType::InterNearest, VPMBType::InterNear, VPMBType::InterMV,
1960 VPMBType::Intra, VPMBType::GoldenNoMV, VPMBType::GoldenMV, VPMBType::InterFourMV
1962 VPMBType::InterNoMV, VPMBType::GoldenNoMV, VPMBType::InterNearest, VPMBType::InterNear,
1963 VPMBType::InterMV, VPMBType::Intra, VPMBType::GoldenMV, VPMBType::InterFourMV
1967 const VP3_LITERAL_BASE: [i16; 6] = [ 7, 9, 13, 21, 37, 69 ];
1969 const VP31_AC_SCALES: [i16; 64] = [
1970 500, 450, 400, 370, 340, 310, 285, 265,
1971 245, 225, 210, 195, 185, 180, 170, 160,
1972 150, 145, 135, 130, 125, 115, 110, 107,
1973 100, 96, 93, 89, 85, 82, 75, 74,
1974 70, 68, 64, 60, 57, 56, 52, 50,
1975 49, 45, 44, 43, 40, 38, 37, 35,
1976 33, 32, 30, 29, 28, 25, 24, 22,
1977 21, 19, 18, 17, 15, 13, 12, 10
1980 const VP31_DC_SCALES: [i16; 64] = [
1981 220, 200, 190, 180, 170, 170, 160, 160,
1982 150, 150, 140, 140, 130, 130, 120, 120,
1983 110, 110, 100, 100, 90, 90, 90, 80,
1984 80, 80, 70, 70, 70, 60, 60, 60,
1985 60, 50, 50, 50, 50, 40, 40, 40,
1986 40, 40, 30, 30, 30, 30, 30, 30,
1987 30, 20, 20, 20, 20, 20, 20, 20,
1988 20, 10, 10, 10, 10, 10, 10, 10
1991 const VP3_QMAT_Y: &[i16; 64] = &[
1992 16, 11, 10, 16, 24, 40, 51, 61,
1993 12, 12, 14, 19, 26, 58, 60, 55,
1994 14, 13, 16, 24, 40, 57, 69, 56,
1995 14, 17, 22, 29, 51, 87, 80, 62,
1996 18, 22, 37, 58, 68, 109, 103, 77,
1997 24, 35, 55, 64, 81, 104, 113, 92,
1998 49, 64, 78, 87, 103, 121, 120, 101,
1999 72, 92, 95, 98, 112, 100, 103, 99
2002 const VP3_QMAT_C: &[i16; 64] = &[
2003 17, 18, 24, 47, 99, 99, 99, 99,
2004 18, 21, 26, 66, 99, 99, 99, 99,
2005 24, 26, 56, 99, 99, 99, 99, 99,
2006 47, 66, 99, 99, 99, 99, 99, 99,
2007 99, 99, 99, 99, 99, 99, 99, 99,
2008 99, 99, 99, 99, 99, 99, 99, 99,
2009 99, 99, 99, 99, 99, 99, 99, 99,
2010 99, 99, 99, 99, 99, 99, 99, 99
2013 const VP3_QMAT_INTER: &[i16; 64] = &[
2014 16, 16, 16, 20, 24, 28, 32, 40,
2015 16, 16, 20, 24, 28, 32, 40, 48,
2016 16, 20, 24, 28, 32, 40, 48, 64,
2017 20, 24, 28, 32, 40, 48, 64, 64,
2018 24, 28, 32, 40, 48, 64, 64, 64,
2019 28, 32, 40, 48, 64, 64, 64, 96,
2020 32, 40, 48, 64, 64, 64, 96, 128,
2021 40, 48, 64, 64, 64, 96, 128, 128
2024 const VP31_DC_CODES: [[u16; 32]; 16] = [
2026 0x002D, 0x0026, 0x0166, 0x004E, 0x02CE, 0x059E, 0x027D, 0x0008,
2027 0x04F9, 0x000F, 0x000E, 0x001B, 0x0006, 0x0008, 0x0005, 0x001A,
2028 0x0015, 0x0007, 0x000C, 0x0001, 0x0000, 0x0009, 0x0017, 0x0029,
2029 0x0028, 0x00B2, 0x04F8, 0x059F, 0x009E, 0x013F, 0x0012, 0x0058,
2031 0x0010, 0x0047, 0x01FF, 0x008C, 0x03FC, 0x046A, 0x0469, 0x0022,
2032 0x11A1, 0x000E, 0x000D, 0x0004, 0x0005, 0x0009, 0x0006, 0x001E,
2033 0x0016, 0x0007, 0x000C, 0x0001, 0x0000, 0x000A, 0x0017, 0x007D,
2034 0x007E, 0x011B, 0x08D1, 0x03FD, 0x046B, 0x11A0, 0x007C, 0x00FE,
2036 0x0016, 0x0020, 0x0086, 0x0087, 0x0367, 0x06CC, 0x06CB, 0x006E,
2037 0x366D, 0x000F, 0x000E, 0x0004, 0x0005, 0x000A, 0x0006, 0x001A,
2038 0x0011, 0x0007, 0x000C, 0x0001, 0x0000, 0x0009, 0x0017, 0x006F,
2039 0x006D, 0x0364, 0x0D9A, 0x06CA, 0x1B37, 0x366C, 0x0042, 0x00D8,
2041 0x0000, 0x002D, 0x00F7, 0x0058, 0x0167, 0x02CB, 0x02CA, 0x000E,
2042 0x1661, 0x0003, 0x0002, 0x0008, 0x0009, 0x000D, 0x0002, 0x001F,
2043 0x0017, 0x0001, 0x000C, 0x000E, 0x000A, 0x0006, 0x0078, 0x000F,
2044 0x007A, 0x0164, 0x0599, 0x02CD, 0x0B31, 0x1660, 0x0079, 0x00F6,
2046 0x0003, 0x003C, 0x000F, 0x007A, 0x001D, 0x0020, 0x0072, 0x0006,
2047 0x0399, 0x0004, 0x0005, 0x0005, 0x0006, 0x000E, 0x0004, 0x0000,
2048 0x0019, 0x0002, 0x000D, 0x0007, 0x001F, 0x0030, 0x0011, 0x0031,
2049 0x0005, 0x0021, 0x00E7, 0x0038, 0x01CD, 0x0398, 0x007B, 0x0009,
2051 0x0009, 0x0002, 0x0074, 0x0007, 0x00EC, 0x00D1, 0x01A6, 0x0006,
2052 0x0D21, 0x0005, 0x0006, 0x0008, 0x0007, 0x000F, 0x0004, 0x0000,
2053 0x001C, 0x0002, 0x0005, 0x0003, 0x000C, 0x0035, 0x01A7, 0x001B,
2054 0x0077, 0x01A5, 0x0349, 0x00D0, 0x0691, 0x0D20, 0x0075, 0x00ED,
2056 0x000A, 0x000C, 0x0012, 0x001B, 0x00B7, 0x016C, 0x0099, 0x005A,
2057 0x16D8, 0x0007, 0x0006, 0x0009, 0x0008, 0x0000, 0x0005, 0x0017,
2058 0x000E, 0x0002, 0x0003, 0x000F, 0x001A, 0x004D, 0x2DB3, 0x002C,
2059 0x0011, 0x02DA, 0x05B7, 0x0098, 0x0B6D, 0x2DB2, 0x0010, 0x0027,
2061 0x000D, 0x000F, 0x001D, 0x0008, 0x0051, 0x0056, 0x00AF, 0x002A,
2062 0x148A, 0x0007, 0x0000, 0x0008, 0x0009, 0x000C, 0x0006, 0x0017,
2063 0x000B, 0x0016, 0x0015, 0x0009, 0x0050, 0x00AE, 0x2917, 0x001C,
2064 0x0014, 0x0290, 0x0523, 0x0149, 0x0A44, 0x2916, 0x0053, 0x00A5,
2066 0x0001, 0x001D, 0x00F5, 0x00F4, 0x024D, 0x0499, 0x0498, 0x0001,
2067 0x0021, 0x0006, 0x0005, 0x0006, 0x0005, 0x0002, 0x0007, 0x0025,
2068 0x007B, 0x001C, 0x0020, 0x000D, 0x0048, 0x0092, 0x0127, 0x000E,
2069 0x0004, 0x0011, 0x000C, 0x003C, 0x000F, 0x0000, 0x001F, 0x0013,
2071 0x0005, 0x003C, 0x0040, 0x000D, 0x0031, 0x0061, 0x0060, 0x0002,
2072 0x00F5, 0x0006, 0x0005, 0x0007, 0x0006, 0x0002, 0x0009, 0x0025,
2073 0x0007, 0x0021, 0x0024, 0x0010, 0x0041, 0x00F4, 0x0019, 0x000E,
2074 0x0003, 0x0011, 0x0011, 0x003F, 0x003E, 0x007B, 0x0000, 0x0013,
2076 0x000A, 0x0007, 0x0001, 0x0009, 0x0131, 0x0261, 0x0260, 0x0015,
2077 0x0001, 0x0007, 0x0006, 0x0008, 0x0007, 0x0006, 0x0012, 0x002F,
2078 0x0014, 0x0027, 0x002D, 0x0016, 0x004D, 0x0099, 0x0000, 0x0004,
2079 0x0001, 0x0005, 0x0017, 0x002E, 0x002C, 0x0008, 0x0006, 0x0001,
2081 0x0000, 0x000E, 0x0017, 0x002A, 0x0010, 0x00F9, 0x00F8, 0x001E,
2082 0x003F, 0x0007, 0x0006, 0x0009, 0x0008, 0x0006, 0x000F, 0x0005,
2083 0x0016, 0x0029, 0x002B, 0x0015, 0x0050, 0x0011, 0x007D, 0x0004,
2084 0x0017, 0x0006, 0x0014, 0x002C, 0x002D, 0x000E, 0x0009, 0x0051,
2086 0x0002, 0x0018, 0x002F, 0x000D, 0x0053, 0x0295, 0x0294, 0x00A4,
2087 0x007C, 0x0000, 0x0007, 0x0009, 0x0008, 0x001B, 0x000C, 0x0028,
2088 0x006A, 0x001E, 0x001D, 0x0069, 0x00D7, 0x007D, 0x014B, 0x0019,
2089 0x0016, 0x002E, 0x001C, 0x002B, 0x002A, 0x0068, 0x003F, 0x00D6,
2091 0x0002, 0x001B, 0x000C, 0x0018, 0x0029, 0x007F, 0x02F0, 0x0198,
2092 0x0179, 0x0000, 0x0007, 0x0009, 0x0008, 0x001A, 0x000D, 0x002A,
2093 0x0064, 0x001E, 0x0067, 0x005F, 0x00CD, 0x007E, 0x02F1, 0x0016,
2094 0x000E, 0x002E, 0x0065, 0x002B, 0x0028, 0x003E, 0x00BD, 0x0199,
2096 0x0002, 0x0007, 0x0016, 0x0006, 0x0036, 0x005C, 0x015D, 0x015C,
2097 0x02BF, 0x0000, 0x0007, 0x0009, 0x0008, 0x0018, 0x0034, 0x002A,
2098 0x005E, 0x006A, 0x0064, 0x005D, 0x00CB, 0x00AD, 0x02BE, 0x0014,
2099 0x0033, 0x006E, 0x005F, 0x006F, 0x006B, 0x00CA, 0x00AC, 0x015E,
2101 0x000F, 0x001D, 0x0018, 0x000B, 0x0019, 0x0029, 0x00D6, 0x0551,
2102 0x0AA1, 0x0001, 0x0000, 0x0009, 0x0008, 0x001B, 0x0038, 0x0028,
2103 0x0057, 0x006A, 0x0068, 0x0056, 0x00E5, 0x0155, 0x0AA0, 0x0073,
2104 0x0069, 0x00D7, 0x00AB, 0x00E4, 0x00A9, 0x0151, 0x0150, 0x02A9,
2108 const VP31_DC_BITS: [[u8; 32]; 16] = [
2110 6, 7, 9, 8, 10, 11, 11, 5, 12, 4, 4, 5, 4, 4, 4, 5,
2111 5, 4, 4, 3, 3, 4, 5, 6, 6, 8, 12, 11, 9, 10, 6, 7,
2113 5, 7, 9, 8, 10, 11, 11, 6, 13, 4, 4, 4, 4, 4, 4, 5,
2114 5, 4, 4, 3, 3, 4, 5, 7, 7, 9, 12, 10, 11, 13, 7, 8,
2116 5, 6, 8, 8, 10, 11, 11, 7, 14, 4, 4, 4, 4, 4, 4, 5,
2117 5, 4, 4, 3, 3, 4, 5, 7, 7, 10, 12, 11, 13, 14, 7, 8,
2119 4, 6, 8, 7, 9, 10, 10, 6, 13, 3, 3, 4, 4, 4, 4, 5,
2120 5, 4, 4, 4, 4, 5, 7, 6, 7, 9, 11, 10, 12, 13, 7, 8,
2122 4, 6, 7, 7, 8, 9, 10, 6, 13, 3, 3, 4, 4, 4, 4, 4,
2123 5, 4, 4, 4, 5, 6, 8, 6, 6, 9, 11, 9, 12, 13, 7, 7,
2125 4, 5, 7, 6, 8, 9, 10, 6, 13, 3, 3, 4, 4, 4, 4, 4,
2126 5, 4, 4, 4, 5, 7, 10, 6, 7, 10, 11, 9, 12, 13, 7, 8,
2128 4, 5, 6, 6, 8, 9, 9, 7, 13, 3, 3, 4, 4, 3, 4, 5,
2129 5, 4, 4, 5, 6, 8, 14, 6, 6, 10, 11, 9, 12, 14, 6, 7,
2131 4, 5, 6, 5, 7, 8, 9, 7, 13, 3, 2, 4, 4, 4, 4, 5,
2132 5, 5, 5, 5, 7, 9, 14, 6, 6, 10, 11, 9, 12, 14, 7, 8,
2134 4, 6, 8, 8, 10, 11, 11, 5, 6, 3, 3, 4, 4, 4, 5, 6,
2135 7, 6, 6, 6, 7, 8, 9, 4, 4, 5, 6, 6, 5, 5, 5, 5,
2137 4, 6, 7, 7, 9, 10, 10, 5, 8, 3, 3, 4, 4, 4, 5, 6,
2138 6, 6, 6, 6, 7, 8, 8, 4, 4, 5, 6, 6, 6, 7, 4, 5,
2140 4, 5, 6, 6, 9, 10, 10, 6, 7, 3, 3, 4, 4, 4, 5, 6,
2141 6, 6, 6, 6, 7, 8, 7, 4, 4, 5, 6, 6, 6, 6, 5, 5,
2143 3, 5, 6, 6, 7, 10, 10, 7, 8, 3, 3, 4, 4, 4, 5, 5,
2144 6, 6, 6, 6, 7, 7, 9, 4, 5, 5, 6, 6, 6, 6, 6, 7,
2146 3, 5, 6, 5, 7, 10, 10, 8, 8, 2, 3, 4, 4, 5, 5, 6,
2147 7, 6, 6, 7, 8, 8, 9, 5, 5, 6, 6, 6, 6, 7, 7, 8,
2149 3, 5, 5, 5, 6, 8, 10, 9, 9, 2, 3, 4, 4, 5, 5, 6,
2150 7, 6, 7, 7, 8, 8, 10, 5, 5, 6, 7, 6, 6, 7, 8, 9,
2152 3, 4, 5, 4, 6, 7, 9, 9, 10, 2, 3, 4, 4, 5, 6, 6,
2153 7, 7, 7, 7, 8, 8, 10, 5, 6, 7, 7, 7, 7, 8, 8, 9,
2155 4, 5, 5, 4, 5, 6, 8, 11, 12, 2, 2, 4, 4, 5, 6, 6,
2156 7, 7, 7, 7, 8, 9, 12, 7, 7, 8, 8, 8, 8, 9, 9, 10,
2160 const VP31_AC_CAT0_CODES: [[u16; 32]; 16] = [
2162 0x0008, 0x0025, 0x017A, 0x02F7, 0x0BDB, 0x17B4, 0x2F6B, 0x001D,
2163 0x2F6A, 0x0008, 0x0007, 0x0001, 0x0002, 0x000A, 0x0006, 0x0000,
2164 0x001C, 0x0009, 0x000D, 0x000F, 0x000C, 0x0003, 0x000A, 0x0016,
2165 0x0013, 0x005D, 0x0024, 0x00BC, 0x005C, 0x05EC, 0x000B, 0x005F,
2167 0x000F, 0x0010, 0x004B, 0x00C6, 0x031D, 0x0C71, 0x0C70, 0x0001,
2168 0x0C73, 0x0008, 0x0009, 0x0002, 0x0003, 0x000B, 0x0006, 0x0000,
2169 0x001C, 0x0005, 0x000D, 0x000F, 0x000A, 0x0019, 0x0013, 0x001D,
2170 0x0030, 0x0062, 0x0024, 0x004A, 0x018F, 0x0C72, 0x000E, 0x0011,
2172 0x001B, 0x0003, 0x008D, 0x0040, 0x0239, 0x0471, 0x08E0, 0x0003,
2173 0x11C3, 0x000A, 0x0009, 0x0004, 0x0005, 0x000E, 0x0007, 0x0001,
2174 0x001E, 0x0006, 0x000C, 0x000B, 0x0002, 0x0000, 0x0041, 0x001F,
2175 0x0022, 0x0002, 0x008F, 0x008C, 0x011D, 0x11C2, 0x001A, 0x0021,
2177 0x001F, 0x0003, 0x0003, 0x0043, 0x000B, 0x0015, 0x0051, 0x0003,
2178 0x0050, 0x000D, 0x000C, 0x0004, 0x0006, 0x000E, 0x000A, 0x0001,
2179 0x001E, 0x0005, 0x0009, 0x0007, 0x0011, 0x0002, 0x0004, 0x0002,
2180 0x002D, 0x0020, 0x0042, 0x0001, 0x0000, 0x0029, 0x0017, 0x002C,
2182 0x0003, 0x001F, 0x003A, 0x005D, 0x0173, 0x02E4, 0x172D, 0x0004,
2183 0x172C, 0x000F, 0x000E, 0x0009, 0x0008, 0x000C, 0x000A, 0x0001,
2184 0x0016, 0x0002, 0x0005, 0x001A, 0x002F, 0x0038, 0x05CA, 0x0006,
2185 0x0037, 0x001E, 0x003B, 0x0039, 0x00B8, 0x0B97, 0x0000, 0x0036,
2187 0x0006, 0x0037, 0x005D, 0x000C, 0x00B9, 0x02E3, 0x05C4, 0x0004,
2188 0x1715, 0x0000, 0x000F, 0x0008, 0x0007, 0x000C, 0x0009, 0x001D,
2189 0x0016, 0x001C, 0x001A, 0x000B, 0x005E, 0x0170, 0x1714, 0x000A,
2190 0x000A, 0x0036, 0x005F, 0x001B, 0x001A, 0x0B8B, 0x0002, 0x0007,
2192 0x000C, 0x000B, 0x0079, 0x0022, 0x00F0, 0x0119, 0x0230, 0x001D,
2193 0x08C4, 0x0001, 0x0000, 0x000A, 0x0009, 0x000B, 0x0007, 0x001C,
2194 0x003D, 0x000D, 0x0008, 0x0015, 0x008D, 0x118B, 0x118A, 0x000D,
2195 0x0010, 0x0009, 0x0014, 0x0047, 0x00F1, 0x0463, 0x001F, 0x000C,
2197 0x0000, 0x001A, 0x0033, 0x000C, 0x0046, 0x01E3, 0x03C5, 0x0017,
2198 0x1E21, 0x0002, 0x0001, 0x0009, 0x000A, 0x0007, 0x001B, 0x003D,
2199 0x001B, 0x0022, 0x0079, 0x00F0, 0x1E20, 0x1E23, 0x1E22, 0x000E,
2200 0x0016, 0x0018, 0x0032, 0x001A, 0x0047, 0x0789, 0x001F, 0x0010,
2202 0x001D, 0x0061, 0x004E, 0x009E, 0x027C, 0x09F5, 0x09F4, 0x0003,
2203 0x0060, 0x0000, 0x000F, 0x000B, 0x000A, 0x0009, 0x0005, 0x000D,
2204 0x0031, 0x0008, 0x0038, 0x0012, 0x0026, 0x013F, 0x04FB, 0x000D,
2205 0x0002, 0x000C, 0x0039, 0x001C, 0x000F, 0x001D, 0x0008, 0x0019,
2207 0x0007, 0x0019, 0x00AB, 0x00AA, 0x0119, 0x0461, 0x0460, 0x001B,
2208 0x0047, 0x0001, 0x0000, 0x000C, 0x000B, 0x0009, 0x0005, 0x000D,
2209 0x0035, 0x003D, 0x003C, 0x0018, 0x0022, 0x008D, 0x0231, 0x000E,
2210 0x001F, 0x0009, 0x002B, 0x0010, 0x0034, 0x0054, 0x0008, 0x0014,
2212 0x000C, 0x0005, 0x0008, 0x005B, 0x004D, 0x0131, 0x0261, 0x001A,
2213 0x0012, 0x0000, 0x000F, 0x000A, 0x0009, 0x0006, 0x001B, 0x0006,
2214 0x001C, 0x002C, 0x0015, 0x005A, 0x0027, 0x0099, 0x0260, 0x000E,
2215 0x0004, 0x000F, 0x0007, 0x001D, 0x000B, 0x0014, 0x0008, 0x0017,
2217 0x000F, 0x0013, 0x0075, 0x0024, 0x0095, 0x0251, 0x04A0, 0x0010,
2218 0x00C8, 0x0002, 0x0001, 0x0001, 0x0000, 0x001A, 0x0011, 0x002C,
2219 0x0065, 0x0074, 0x004B, 0x00C9, 0x0129, 0x0943, 0x0942, 0x0003,
2220 0x000A, 0x001C, 0x0018, 0x0033, 0x0017, 0x002D, 0x001B, 0x003B,
2222 0x0003, 0x001A, 0x002D, 0x0038, 0x0028, 0x0395, 0x0E51, 0x0037,
2223 0x00E4, 0x0001, 0x0000, 0x001F, 0x001E, 0x0017, 0x003A, 0x0073,
2224 0x002A, 0x002B, 0x0029, 0x01CB, 0x0729, 0x1CA1, 0x1CA0, 0x0004,
2225 0x000A, 0x0004, 0x0018, 0x0036, 0x000B, 0x002C, 0x0019, 0x003B,
2227 0x0004, 0x0004, 0x003F, 0x0017, 0x0075, 0x01F5, 0x07D1, 0x0017,
2228 0x01F6, 0x0001, 0x0000, 0x001B, 0x001A, 0x000A, 0x0032, 0x0074,
2229 0x00F8, 0x00F9, 0x01F7, 0x03E9, 0x0FA0, 0x1F43, 0x1F42, 0x0003,
2230 0x000A, 0x001E, 0x001C, 0x003B, 0x0018, 0x0016, 0x0016, 0x0033,
2232 0x0004, 0x0007, 0x0018, 0x001E, 0x0036, 0x0031, 0x0177, 0x0077,
2233 0x0176, 0x0001, 0x0000, 0x001A, 0x0019, 0x003A, 0x0019, 0x005C,
2234 0x00BA, 0x0061, 0x00C1, 0x0180, 0x0302, 0x0607, 0x0606, 0x0002,
2235 0x000A, 0x001F, 0x001C, 0x0037, 0x0016, 0x0076, 0x000D, 0x002F,
2237 0x0000, 0x000A, 0x001A, 0x000C, 0x001D, 0x0039, 0x0078, 0x005E,
2238 0x0393, 0x0002, 0x0001, 0x0016, 0x000F, 0x002E, 0x005F, 0x0073,
2239 0x00E5, 0x01C8, 0x0E4A, 0x1C97, 0x1C96, 0x0E49, 0x0E48, 0x0004,
2240 0x0006, 0x001F, 0x001B, 0x001D, 0x0038, 0x0038, 0x003D, 0x0079,
2244 const VP31_AC_CAT0_BITS: [[u8; 32]; 16] = [
2246 5, 7, 9, 10, 12, 13, 14, 5, 14, 4, 4, 4, 4, 4, 4, 4,
2247 5, 4, 4, 4, 4, 4, 5, 5, 6, 7, 7, 8, 7, 11, 5, 7,
2249 5, 6, 8, 8, 10, 12, 12, 4, 12, 4, 4, 4, 4, 4, 4, 4,
2250 5, 4, 4, 4, 4, 5, 6, 5, 6, 7, 7, 8, 9, 12, 5, 6,
2252 5, 6, 8, 7, 10, 11, 12, 4, 13, 4, 4, 4, 4, 4, 4, 4,
2253 5, 4, 4, 4, 4, 5, 7, 5, 6, 6, 8, 8, 9, 13, 5, 6,
2255 5, 6, 7, 7, 9, 10, 12, 4, 12, 4, 4, 4, 4, 4, 4, 4,
2256 5, 4, 4, 4, 5, 6, 8, 4, 6, 6, 7, 7, 7, 11, 5, 6,
2258 4, 6, 7, 7, 9, 10, 13, 4, 13, 4, 4, 4, 4, 4, 4, 4,
2259 5, 4, 4, 5, 6, 7, 11, 4, 6, 6, 7, 7, 8, 12, 4, 6,
2261 4, 6, 7, 6, 8, 10, 11, 4, 13, 3, 4, 4, 4, 4, 4, 5,
2262 5, 5, 5, 5, 7, 9, 13, 4, 5, 6, 7, 7, 7, 12, 4, 5,
2264 4, 5, 7, 6, 8, 9, 10, 5, 12, 3, 3, 4, 4, 4, 4, 5,
2265 6, 5, 5, 6, 8, 13, 13, 4, 5, 5, 6, 7, 8, 11, 5, 5,
2267 3, 5, 6, 5, 7, 9, 10, 5, 13, 3, 3, 4, 4, 4, 5, 6,
2268 6, 6, 7, 8, 13, 13, 13, 4, 5, 5, 6, 6, 7, 11, 5, 5,
2270 5, 7, 8, 9, 11, 13, 13, 4, 7, 3, 4, 4, 4, 4, 4, 5,
2271 6, 5, 6, 6, 7, 10, 12, 4, 4, 5, 6, 6, 5, 6, 4, 5,
2273 4, 6, 8, 8, 10, 12, 12, 5, 8, 3, 3, 4, 4, 4, 4, 5,
2274 6, 6, 6, 6, 7, 9, 11, 4, 5, 5, 6, 6, 6, 7, 4, 5,
2276 4, 5, 6, 7, 9, 11, 12, 5, 7, 3, 4, 4, 4, 4, 5, 5,
2277 6, 6, 6, 7, 8, 10, 12, 4, 4, 5, 5, 6, 5, 6, 4, 5,
2279 4, 5, 7, 6, 8, 10, 11, 5, 8, 3, 3, 4, 4, 5, 5, 6,
2280 7, 7, 7, 8, 9, 12, 12, 3, 4, 5, 5, 6, 5, 6, 5, 6,
2282 3, 5, 6, 6, 7, 10, 12, 6, 8, 3, 3, 5, 5, 5, 6, 7,
2283 7, 7, 7, 9, 11, 13, 13, 3, 4, 4, 5, 6, 5, 6, 5, 6,
2285 3, 4, 6, 5, 7, 9, 11, 6, 9, 3, 3, 5, 5, 5, 6, 7,
2286 8, 8, 9, 10, 12, 13, 13, 3, 4, 5, 5, 6, 5, 6, 5, 6,
2288 3, 4, 5, 5, 6, 7, 9, 7, 9, 3, 3, 5, 5, 6, 6, 7,
2289 8, 8, 9, 10, 11, 12, 12, 3, 4, 5, 5, 6, 5, 7, 5, 6,
2291 3, 4, 5, 4, 5, 6, 7, 7, 11, 3, 3, 5, 5, 6, 7, 8,
2292 9, 10, 13, 14, 14, 13, 13, 3, 4, 5, 5, 6, 6, 7, 6, 7,
2296 const VP31_AC_CAT1_CODES: [[u16; 32]; 16] = [
2298 0x000B, 0x002B, 0x0054, 0x01B7, 0x06D9, 0x0DB1, 0x0DB0, 0x0002,
2299 0x00AB, 0x0009, 0x000A, 0x0007, 0x0008, 0x000F, 0x000C, 0x0003,
2300 0x001D, 0x0004, 0x000B, 0x0006, 0x001A, 0x0003, 0x00AA, 0x0001,
2301 0x0000, 0x0014, 0x006C, 0x00DA, 0x0002, 0x036D, 0x001C, 0x0037,
2303 0x001D, 0x0004, 0x00B6, 0x006A, 0x05B9, 0x16E1, 0x16E0, 0x0007,
2304 0x016F, 0x000C, 0x000D, 0x0009, 0x0008, 0x000F, 0x000A, 0x0003,
2305 0x0017, 0x0002, 0x0004, 0x001C, 0x002C, 0x006B, 0x0B71, 0x0005,
2306 0x0003, 0x001B, 0x005A, 0x0034, 0x0005, 0x02DD, 0x0000, 0x000C,
2308 0x0003, 0x007F, 0x00A1, 0x00A0, 0x020C, 0x0834, 0x106B, 0x0007,
2309 0x0082, 0x000E, 0x000D, 0x000B, 0x000C, 0x0000, 0x0009, 0x0002,
2310 0x0011, 0x001E, 0x0015, 0x003E, 0x0040, 0x041B, 0x106A, 0x0006,
2311 0x000A, 0x0029, 0x007E, 0x0051, 0x0021, 0x0107, 0x0004, 0x000B,
2313 0x0007, 0x001B, 0x00F6, 0x00E9, 0x03A1, 0x0740, 0x0E82, 0x001F,
2314 0x01EF, 0x0001, 0x0002, 0x000B, 0x000C, 0x000D, 0x0008, 0x001C,
2315 0x0003, 0x0012, 0x0002, 0x0075, 0x01D1, 0x1D07, 0x1D06, 0x000A,
2316 0x0013, 0x003B, 0x001A, 0x007A, 0x003C, 0x01EE, 0x0000, 0x000C,
2318 0x000D, 0x003D, 0x0042, 0x0037, 0x00D9, 0x0362, 0x06C6, 0x001F,
2319 0x0086, 0x0001, 0x0002, 0x000C, 0x000B, 0x000A, 0x0001, 0x000F,
2320 0x0025, 0x003C, 0x001A, 0x0087, 0x01B0, 0x0D8F, 0x0D8E, 0x000E,
2321 0x0013, 0x000C, 0x0024, 0x0020, 0x0011, 0x006D, 0x0000, 0x000E,
2323 0x0000, 0x0012, 0x0076, 0x0077, 0x014D, 0x0533, 0x14C9, 0x0013,
2324 0x00A5, 0x0002, 0x0003, 0x000B, 0x000C, 0x0008, 0x001A, 0x002B,
2325 0x0075, 0x0074, 0x00A7, 0x0298, 0x14C8, 0x14CB, 0x14CA, 0x000F,
2326 0x001C, 0x0007, 0x002A, 0x0028, 0x001B, 0x00A4, 0x0002, 0x0006,
2328 0x0002, 0x001A, 0x002B, 0x003A, 0x00ED, 0x0283, 0x0A0A, 0x0004,
2329 0x00A1, 0x0004, 0x0003, 0x000B, 0x000C, 0x001F, 0x0006, 0x0077,
2330 0x00A3, 0x00A2, 0x0140, 0x1417, 0x1416, 0x0A09, 0x0A08, 0x0000,
2331 0x001E, 0x0007, 0x002A, 0x0029, 0x001C, 0x00EC, 0x001B, 0x0005,
2333 0x0002, 0x0002, 0x0018, 0x001D, 0x0035, 0x00E4, 0x01CF, 0x001D,
2334 0x0072, 0x0004, 0x0005, 0x0006, 0x0007, 0x0006, 0x0073, 0x0038,
2335 0x01CE, 0x039B, 0x0398, 0x0733, 0x0732, 0x0735, 0x0734, 0x0000,
2336 0x001F, 0x001B, 0x0034, 0x000F, 0x001E, 0x00E5, 0x0019, 0x0038,
2338 0x0016, 0x0050, 0x0172, 0x02E7, 0x1732, 0x2E67, 0x2E66, 0x0006,
2339 0x0051, 0x0001, 0x0000, 0x000D, 0x000C, 0x0009, 0x001C, 0x0009,
2340 0x001C, 0x001D, 0x005D, 0x00B8, 0x05CD, 0x1731, 0x1730, 0x000F,
2341 0x0005, 0x000F, 0x0008, 0x0029, 0x001D, 0x002F, 0x0008, 0x0015,
2343 0x0009, 0x0021, 0x0040, 0x00AD, 0x02B0, 0x1589, 0x1588, 0x001C,
2344 0x005F, 0x0000, 0x000F, 0x000D, 0x000C, 0x0006, 0x0011, 0x002A,
2345 0x0057, 0x005E, 0x0041, 0x0159, 0x0563, 0x158B, 0x158A, 0x0001,
2346 0x0005, 0x0014, 0x003B, 0x002E, 0x0004, 0x003A, 0x0007, 0x0016,
2348 0x000E, 0x0007, 0x0046, 0x0045, 0x0064, 0x032A, 0x0657, 0x0018,
2349 0x000D, 0x0000, 0x000F, 0x000A, 0x000B, 0x001A, 0x0036, 0x0047,
2350 0x0044, 0x0018, 0x0033, 0x00CB, 0x0656, 0x0329, 0x0328, 0x0002,
2351 0x0006, 0x0019, 0x000E, 0x0037, 0x0009, 0x000F, 0x0002, 0x0010,
2353 0x0003, 0x0018, 0x0023, 0x0077, 0x0194, 0x1956, 0x32AF, 0x003A,
2354 0x0076, 0x0002, 0x0001, 0x001F, 0x001E, 0x0014, 0x0022, 0x0064,
2355 0x0197, 0x0196, 0x032B, 0x0654, 0x32AE, 0x1955, 0x1954, 0x0000,
2356 0x0009, 0x001C, 0x0015, 0x0010, 0x000D, 0x0017, 0x0016, 0x0033,
2358 0x0005, 0x0006, 0x003E, 0x0010, 0x0048, 0x093F, 0x24FA, 0x0032,
2359 0x0067, 0x0002, 0x0001, 0x001B, 0x001E, 0x0034, 0x0066, 0x0092,
2360 0x0126, 0x024E, 0x049E, 0x49F7, 0x49F6, 0x24F9, 0x24F8, 0x0000,
2361 0x0007, 0x0018, 0x0011, 0x003F, 0x000E, 0x0013, 0x0035, 0x0025,
2363 0x0005, 0x0008, 0x0012, 0x001C, 0x001C, 0x00EA, 0x1D75, 0x001E,
2364 0x0066, 0x0001, 0x0002, 0x001B, 0x001A, 0x001F, 0x003B, 0x0074,
2365 0x01D6, 0x03AF, 0x1D74, 0x1D77, 0x1D76, 0x0EB9, 0x0EB8, 0x000F,
2366 0x0006, 0x0013, 0x003B, 0x003A, 0x0000, 0x0018, 0x0032, 0x0067,
2368 0x0004, 0x000A, 0x001B, 0x000C, 0x000D, 0x00E6, 0x0684, 0x0072,
2369 0x00E7, 0x0002, 0x0001, 0x0017, 0x0016, 0x0018, 0x00D1, 0x01A0,
2370 0x0686, 0x0D0F, 0x0D0A, 0x1A17, 0x1A16, 0x1A1D, 0x1A1C, 0x000F,
2371 0x001D, 0x000E, 0x0035, 0x0038, 0x0000, 0x000F, 0x0019, 0x0069,
2373 0x0003, 0x000C, 0x001B, 0x0000, 0x0003, 0x002E, 0x0051, 0x00BC,
2374 0x0053, 0x0004, 0x0002, 0x0016, 0x0015, 0x0015, 0x0050, 0x00A4,
2375 0x0294, 0x052B, 0x052A, 0x052D, 0x052C, 0x052F, 0x052E, 0x000E,
2376 0x001A, 0x0004, 0x0028, 0x0029, 0x000F, 0x000B, 0x005F, 0x00BD,
2380 const VP31_AC_CAT1_BITS: [[u8; 32]; 16] = [
2382 5, 7, 8, 9, 11, 12, 12, 4, 9, 4, 4, 4, 4, 4, 4, 4,
2383 5, 4, 4, 4, 5, 6, 9, 4, 5, 6, 7, 8, 6, 10, 5, 6,
2385 5, 6, 8, 8, 11, 13, 13, 4, 9, 4, 4, 4, 4, 4, 4, 4,
2386 5, 4, 4, 5, 6, 8, 12, 4, 5, 6, 7, 7, 6, 10, 4, 5,
2388 4, 7, 8, 8, 10, 12, 13, 4, 8, 4, 4, 4, 4, 3, 4, 4,
2389 5, 5, 5, 6, 7, 11, 13, 4, 5, 6, 7, 7, 6, 9, 4, 5,
2391 4, 6, 8, 8, 10, 11, 12, 5, 9, 3, 3, 4, 4, 4, 4, 5,
2392 5, 5, 5, 7, 9, 13, 13, 4, 5, 6, 6, 7, 6, 9, 4, 5,
2394 4, 6, 7, 7, 9, 11, 12, 5, 8, 3, 3, 4, 4, 4, 4, 5,
2395 6, 6, 6, 8, 10, 13, 13, 4, 5, 5, 6, 6, 5, 8, 4, 5,
2397 3, 5, 7, 7, 9, 11, 13, 5, 8, 3, 3, 4, 4, 4, 5, 6,
2398 7, 7, 8, 10, 13, 13, 13, 4, 5, 5, 6, 6, 5, 8, 4, 5,
2400 3, 5, 6, 6, 8, 10, 12, 5, 8, 3, 3, 4, 4, 5, 5, 7,
2401 8, 8, 9, 13, 13, 12, 12, 3, 5, 5, 6, 6, 5, 8, 5, 5,
2403 3, 4, 5, 5, 6, 8, 11, 7, 9, 3, 3, 4, 4, 5, 7, 8,
2404 11, 12, 12, 13, 13, 13, 13, 3, 5, 5, 6, 6, 5, 8, 5, 6,
2406 5, 7, 9, 10, 13, 14, 14, 4, 7, 3, 3, 4, 4, 4, 5, 5,
2407 6, 6, 7, 8, 11, 13, 13, 4, 4, 5, 5, 6, 5, 6, 4, 5,
2409 4, 6, 7, 8, 10, 13, 13, 5, 7, 3, 4, 4, 4, 4, 5, 6,
2410 7, 7, 7, 9, 11, 13, 13, 3, 4, 5, 6, 6, 4, 6, 4, 5,
2412 4, 5, 7, 7, 9, 12, 13, 5, 6, 3, 4, 4, 4, 5, 6, 7,
2413 7, 7, 8, 10, 13, 12, 12, 3, 4, 5, 5, 6, 4, 5, 4, 5,
2415 3, 5, 6, 7, 9, 13, 14, 6, 7, 3, 3, 5, 5, 5, 6, 7,
2416 9, 9, 10, 11, 14, 13, 13, 3, 4, 5, 5, 5, 4, 5, 5, 6,
2418 3, 4, 6, 5, 7, 12, 14, 6, 7, 3, 3, 5, 5, 6, 7, 8,
2419 9, 10, 11, 15, 15, 14, 14, 3, 4, 5, 5, 6, 4, 5, 6, 6,
2421 3, 4, 5, 5, 6, 9, 14, 6, 7, 3, 3, 5, 5, 6, 7, 8,
2422 10, 11, 14, 14, 14, 13, 13, 4, 4, 5, 6, 6, 3, 5, 6, 7,
2424 3, 4, 5, 4, 5, 8, 11, 7, 8, 3, 3, 5, 5, 6, 8, 9,
2425 11, 12, 12, 13, 13, 13, 13, 4, 5, 5, 6, 6, 3, 5, 6, 7,
2427 3, 4, 5, 3, 4, 6, 9, 8, 9, 3, 3, 5, 5, 7, 9, 10,
2428 12, 13, 13, 13, 13, 13, 13, 4, 5, 5, 6, 6, 4, 6, 7, 8,
2432 const VP31_AC_CAT2_CODES: [[u16; 32]; 16] = [
2434 0x0003, 0x0009, 0x00D0, 0x01A3, 0x0344, 0x0D14, 0x1A2B, 0x0004,
2435 0x0015, 0x0000, 0x000F, 0x000B, 0x000C, 0x000E, 0x0009, 0x001B,
2436 0x000A, 0x0014, 0x000D, 0x002A, 0x0014, 0x068B, 0x1A2A, 0x0008,
2437 0x000B, 0x002B, 0x000B, 0x0069, 0x0035, 0x0008, 0x0007, 0x000C,
2439 0x000A, 0x003C, 0x0032, 0x0030, 0x00C5, 0x0621, 0x0620, 0x001F,
2440 0x0033, 0x0001, 0x0000, 0x000E, 0x000D, 0x000C, 0x0004, 0x000D,
2441 0x0026, 0x0027, 0x0014, 0x0063, 0x0189, 0x0623, 0x0622, 0x000B,
2442 0x0012, 0x003D, 0x0022, 0x0015, 0x000B, 0x0023, 0x0007, 0x0010,
2444 0x000F, 0x000C, 0x0043, 0x0010, 0x0044, 0x0114, 0x0455, 0x0018,
2445 0x0023, 0x0001, 0x0000, 0x000E, 0x000D, 0x0009, 0x0019, 0x0009,
2446 0x0017, 0x0016, 0x0042, 0x008B, 0x0454, 0x0457, 0x0456, 0x000B,
2447 0x0015, 0x000A, 0x0029, 0x0020, 0x000D, 0x0028, 0x0007, 0x0011,
2449 0x0001, 0x001A, 0x0029, 0x002A, 0x00A0, 0x0285, 0x1425, 0x0002,
2450 0x0000, 0x0002, 0x0003, 0x000C, 0x000B, 0x0008, 0x0012, 0x0001,
2451 0x0051, 0x0001, 0x0143, 0x0508, 0x1424, 0x1427, 0x1426, 0x000F,
2452 0x001C, 0x0003, 0x0037, 0x002B, 0x0013, 0x0036, 0x001D, 0x0001,
2454 0x0004, 0x001F, 0x003D, 0x0006, 0x0016, 0x0053, 0x014A, 0x0034,
2455 0x002A, 0x0002, 0x0003, 0x000B, 0x000C, 0x001C, 0x0037, 0x0017,
2456 0x002B, 0x0028, 0x00A4, 0x052D, 0x052C, 0x052F, 0x052E, 0x0000,
2457 0x001D, 0x0007, 0x0004, 0x0035, 0x0014, 0x0036, 0x0015, 0x003C,
2459 0x0004, 0x000A, 0x0007, 0x001D, 0x0009, 0x01F3, 0x07C7, 0x0008,
2460 0x01F0, 0x0003, 0x0002, 0x000D, 0x000C, 0x0017, 0x007D, 0x01F2,
2461 0x07C6, 0x07C5, 0x1F12, 0x3E27, 0x3E26, 0x1F11, 0x1F10, 0x0000,
2462 0x001E, 0x0006, 0x0039, 0x0038, 0x003F, 0x002C, 0x0005, 0x002D,
2464 0x0002, 0x0007, 0x0018, 0x0003, 0x0005, 0x0035, 0x004F, 0x0012,
2465 0x04E5, 0x0005, 0x0004, 0x000D, 0x000E, 0x0033, 0x0026, 0x009D,
2466 0x04E4, 0x04E7, 0x04E6, 0x04E1, 0x04E0, 0x04E3, 0x04E2, 0x0000,
2467 0x001F, 0x000C, 0x003D, 0x003C, 0x0032, 0x0034, 0x001B, 0x0008,
2469 0x0000, 0x0004, 0x001C, 0x000F, 0x0002, 0x0007, 0x0075, 0x00E8,
2470 0x1D2A, 0x0005, 0x0004, 0x000D, 0x000C, 0x0077, 0x0E96, 0x3A57,
2471 0x3A56, 0x3A5D, 0x3A5C, 0x3A5F, 0x3A5E, 0x1D29, 0x1D28, 0x0003,
2472 0x0006, 0x000A, 0x002C, 0x0017, 0x0076, 0x01D3, 0x03A4, 0x002D,
2474 0x000A, 0x0024, 0x00BF, 0x0085, 0x0211, 0x0842, 0x1087, 0x0018,
2475 0x0020, 0x0001, 0x0002, 0x000E, 0x000D, 0x0007, 0x0013, 0x0025,
2476 0x005E, 0x0043, 0x00BE, 0x0109, 0x1086, 0x0841, 0x0840, 0x000F,
2477 0x0001, 0x0011, 0x0000, 0x002E, 0x0019, 0x0001, 0x0006, 0x0016,
2479 0x0002, 0x000F, 0x006F, 0x0061, 0x0374, 0x1BA8, 0x3753, 0x0012,
2480 0x0036, 0x0000, 0x0001, 0x000A, 0x000B, 0x001A, 0x0031, 0x0060,
2481 0x00DC, 0x01BB, 0x06EB, 0x1BAB, 0x3752, 0x3755, 0x3754, 0x000E,
2482 0x0006, 0x0013, 0x000E, 0x003E, 0x0008, 0x001E, 0x0019, 0x003F,
2484 0x0003, 0x001C, 0x0025, 0x0024, 0x01DA, 0x1DBD, 0x3B7C, 0x003C,
2485 0x003D, 0x0000, 0x0001, 0x000B, 0x000A, 0x000B, 0x0077, 0x00EC,
2486 0x03B6, 0x076E, 0x1DBF, 0x76FB, 0x76FA, 0x3B79, 0x3B78, 0x000D,
2487 0x001F, 0x0013, 0x000A, 0x0008, 0x000C, 0x0008, 0x0009, 0x003A,
2489 0x0005, 0x0003, 0x0004, 0x0010, 0x008F, 0x0475, 0x11D1, 0x0079,
2490 0x0027, 0x0002, 0x0003, 0x0001, 0x0000, 0x0026, 0x0046, 0x011C,
2491 0x0477, 0x08ED, 0x11D0, 0x11D3, 0x11D2, 0x11D9, 0x11D8, 0x000D,
2492 0x001F, 0x0012, 0x0005, 0x003D, 0x000C, 0x000E, 0x0022, 0x0078,
2494 0x0005, 0x000C, 0x001B, 0x0000, 0x0006, 0x03E2, 0x3E3D, 0x000F,
2495 0x0034, 0x0003, 0x0002, 0x001E, 0x001D, 0x007D, 0x01F0, 0x07C6,
2496 0x3E3C, 0x3E3F, 0x3E3E, 0x3E39, 0x3E38, 0x3E3B, 0x3E3A, 0x0008,
2497 0x001C, 0x0002, 0x003F, 0x0035, 0x0009, 0x0001, 0x000E, 0x00F9,
2499 0x0004, 0x000B, 0x0001, 0x000A, 0x001E, 0x00E0, 0x0E1E, 0x0071,
2500 0x0039, 0x0007, 0x0006, 0x000D, 0x000C, 0x0020, 0x01C2, 0x1C3F,
2501 0x1C3E, 0x0E19, 0x0E18, 0x0E1B, 0x0E1A, 0x0E1D, 0x0E1C, 0x0000,
2502 0x0009, 0x001D, 0x001F, 0x0011, 0x0005, 0x0001, 0x0043, 0x0042,
2504 0x0004, 0x000D, 0x0007, 0x0002, 0x0014, 0x016C, 0x16D1, 0x02DF,
2505 0x016E, 0x0000, 0x0007, 0x002C, 0x002B, 0x02DE, 0x16D0, 0x16D3,
2506 0x16D2, 0x2DB5, 0x2DB4, 0x2DB7, 0x2DB6, 0x16D9, 0x16D8, 0x000C,
2507 0x002A, 0x005A, 0x001B, 0x001A, 0x0017, 0x000C, 0x05B7, 0x05B5,
2509 0x0002, 0x000F, 0x001C, 0x000C, 0x003B, 0x01AC, 0x1AD8, 0x35B3,
2510 0x35B2, 0x0001, 0x0000, 0x0069, 0x0068, 0x35BD, 0x35BC, 0x35BF,
2511 0x35BE, 0x35B9, 0x35B8, 0x35BB, 0x35BA, 0x35B5, 0x35B4, 0x01A9,
2512 0x01A8, 0x035A, 0x00D7, 0x00D5, 0x003A, 0x001B, 0x35B7, 0x35B6,
2516 const VP31_AC_CAT2_BITS: [[u8; 32]; 16] = [
2518 4, 6, 8, 9, 10, 12, 13, 4, 7, 3, 4, 4, 4, 4, 4, 5,
2519 5, 5, 5, 6, 7, 11, 13, 4, 5, 6, 6, 7, 6, 6, 4, 5,
2521 4, 6, 7, 7, 9, 12, 12, 5, 7, 3, 3, 4, 4, 4, 4, 5,
2522 6, 6, 6, 8, 10, 12, 12, 4, 5, 6, 6, 6, 5, 6, 4, 5,
2524 4, 5, 7, 6, 8, 10, 12, 5, 7, 3, 3, 4, 4, 4, 5, 5,
2525 6, 6, 7, 9, 12, 12, 12, 4, 5, 5, 6, 6, 5, 6, 4, 5,
2527 3, 5, 6, 6, 8, 10, 13, 5, 7, 3, 3, 4, 4, 4, 5, 6,
2528 7, 7, 9, 11, 13, 13, 13, 4, 5, 5, 6, 6, 5, 6, 5, 5,
2530 3, 5, 6, 5, 7, 9, 11, 6, 8, 3, 3, 4, 4, 5, 6, 7,
2531 8, 8, 10, 13, 13, 13, 13, 3, 5, 5, 5, 6, 5, 6, 5, 6,
2533 3, 4, 5, 5, 6, 9, 11, 6, 9, 3, 3, 4, 4, 5, 7, 9,
2534 11, 11, 13, 14, 14, 13, 13, 3, 5, 5, 6, 6, 6, 6, 5, 6,
2536 3, 4, 5, 4, 5, 7, 9, 7, 13, 3, 3, 4, 4, 6, 8, 10,
2537 13, 13, 13, 13, 13, 13, 13, 3, 5, 5, 6, 6, 6, 7, 6, 6,
2539 3, 4, 5, 4, 4, 5, 7, 8, 13, 3, 3, 4, 4, 7, 12, 14,
2540 14, 14, 14, 14, 14, 13, 13, 3, 5, 5, 7, 6, 7, 9, 10, 7,
2542 4, 6, 8, 8, 10, 12, 13, 5, 6, 3, 3, 4, 4, 4, 5, 6,
2543 7, 7, 8, 9, 13, 12, 12, 4, 4, 5, 5, 6, 5, 5, 4, 5,
2545 3, 5, 7, 7, 10, 13, 14, 5, 6, 3, 3, 4, 4, 5, 6, 7,
2546 8, 9, 11, 13, 14, 14, 14, 4, 4, 5, 5, 6, 4, 5, 5, 6,
2548 3, 5, 6, 6, 9, 13, 14, 6, 6, 3, 3, 4, 4, 5, 7, 8,
2549 10, 11, 13, 15, 15, 14, 14, 4, 5, 5, 5, 5, 4, 4, 5, 6,
2551 3, 4, 5, 5, 8, 11, 13, 7, 6, 3, 3, 4, 4, 6, 7, 9,
2552 11, 12, 13, 13, 13, 13, 13, 4, 5, 5, 5, 6, 4, 4, 6, 7,
2554 3, 4, 5, 4, 6, 10, 14, 7, 6, 3, 3, 5, 5, 7, 9, 11,
2555 14, 14, 14, 14, 14, 14, 14, 4, 5, 5, 6, 6, 4, 3, 7, 8,
2557 3, 4, 4, 4, 6, 9, 13, 8, 7, 3, 3, 5, 5, 7, 10, 14,
2558 14, 13, 13, 13, 13, 13, 13, 4, 5, 6, 6, 6, 4, 3, 8, 8,
2560 3, 4, 4, 3, 5, 9, 13, 10, 9, 2, 3, 6, 6, 10, 13, 13,
2561 13, 14, 14, 14, 14, 13, 13, 5, 6, 7, 6, 6, 5, 4, 11, 11,
2563 2, 4, 5, 4, 6, 9, 13, 14, 14, 2, 2, 7, 7, 14, 14, 14,
2564 14, 14, 14, 14, 14, 14, 14, 9, 9, 10, 8, 8, 6, 5, 14, 14,
2568 const VP31_AC_CAT3_CODES: [[u16; 32]; 16] = [
2570 0x0000, 0x0010, 0x0072, 0x0071, 0x0154, 0x0AAB, 0x0AA8, 0x0014,
2571 0x0070, 0x0002, 0x0003, 0x000C, 0x000B, 0x0003, 0x0011, 0x0073,
2572 0x0054, 0x00AB, 0x02AB, 0x1553, 0x1552, 0x1555, 0x1554, 0x000D,
2573 0x001E, 0x0012, 0x003E, 0x002B, 0x0002, 0x003F, 0x001D, 0x0013,
2575 0x0003, 0x001F, 0x0029, 0x003D, 0x000C, 0x0069, 0x0345, 0x0002,
2576 0x0028, 0x0002, 0x0001, 0x000E, 0x000C, 0x0015, 0x0007, 0x001B,
2577 0x006B, 0x006A, 0x0344, 0x0347, 0x0346, 0x01A1, 0x01A0, 0x000B,
2578 0x001A, 0x0012, 0x0000, 0x003C, 0x0008, 0x001B, 0x0013, 0x0001,
2580 0x0004, 0x0004, 0x003F, 0x0014, 0x0056, 0x015C, 0x15D5, 0x003C,
2581 0x002A, 0x0000, 0x0001, 0x000E, 0x000D, 0x000C, 0x00AF, 0x02BB,
2582 0x15D4, 0x15D7, 0x15D6, 0x15D1, 0x15D0, 0x15D3, 0x15D2, 0x000B,
2583 0x0019, 0x000D, 0x003E, 0x0031, 0x0007, 0x0005, 0x003D, 0x0030,
2585 0x0005, 0x0008, 0x001A, 0x0000, 0x0036, 0x0011, 0x0106, 0x000A,
2586 0x006E, 0x0002, 0x0003, 0x0003, 0x0002, 0x006F, 0x0021, 0x020F,
2587 0x020E, 0x0101, 0x0100, 0x0103, 0x0102, 0x0105, 0x0104, 0x000C,
2588 0x001E, 0x0003, 0x003E, 0x003F, 0x0009, 0x000E, 0x000B, 0x0009,
2590 0x0002, 0x000E, 0x001E, 0x000C, 0x001F, 0x006E, 0x00AD, 0x00AF,
2591 0x0014, 0x0004, 0x0003, 0x001A, 0x0017, 0x002A, 0x0576, 0x0AEF,
2592 0x0AEE, 0x0571, 0x0570, 0x0573, 0x0572, 0x0575, 0x0574, 0x0003,
2593 0x0016, 0x0004, 0x0036, 0x000B, 0x000A, 0x0000, 0x006F, 0x00AC,
2595 0x0004, 0x0005, 0x0003, 0x0001, 0x0004, 0x002F, 0x0526, 0x1495,
2596 0x00A6, 0x0007, 0x0006, 0x002D, 0x002C, 0x1494, 0x1497, 0x1496,
2597 0x1491, 0x1490, 0x1493, 0x1492, 0x293D, 0x293C, 0x293F, 0x0000,
2598 0x0028, 0x00A5, 0x0148, 0x00A7, 0x002E, 0x0015, 0x0A4E, 0x293E,
2600 0x0004, 0x0005, 0x0003, 0x0001, 0x0004, 0x002F, 0x0526, 0x1495,
2601 0x00A6, 0x0007, 0x0006, 0x002D, 0x002C, 0x1494, 0x1497, 0x1496,
2602 0x1491, 0x1490, 0x1493, 0x1492, 0x293D, 0x293C, 0x293F, 0x0000,
2603 0x0028, 0x00A5, 0x0148, 0x00A7, 0x002E, 0x0015, 0x0A4E, 0x293E,
2605 0x0004, 0x0005, 0x0003, 0x0001, 0x0004, 0x002F, 0x0526, 0x1495,
2606 0x00A6, 0x0007, 0x0006, 0x002D, 0x002C, 0x1494, 0x1497, 0x1496,
2607 0x1491, 0x1490, 0x1493, 0x1492, 0x293D, 0x293C, 0x293F, 0x0000,
2608 0x0028, 0x00A5, 0x0148, 0x00A7, 0x002E, 0x0015, 0x0A4E, 0x293E,
2610 0x0003, 0x0011, 0x0020, 0x0074, 0x010D, 0x0863, 0x0860, 0x000A,
2611 0x0075, 0x0001, 0x0000, 0x000B, 0x000A, 0x0018, 0x0038, 0x0042,
2612 0x010F, 0x010E, 0x0219, 0x10C3, 0x10C2, 0x10C5, 0x10C4, 0x000F,
2613 0x0004, 0x0019, 0x000B, 0x0039, 0x0009, 0x001B, 0x001A, 0x003B,
2615 0x0005, 0x0001, 0x003E, 0x0001, 0x00E2, 0x1C6F, 0x38D9, 0x0039,
2616 0x001F, 0x0002, 0x0001, 0x0009, 0x0008, 0x0000, 0x0070, 0x01C7,
2617 0x038C, 0x071A, 0x38D8, 0x38DB, 0x38DA, 0x38DD, 0x38DC, 0x000D,
2618 0x001D, 0x000E, 0x003F, 0x003C, 0x000C, 0x0006, 0x003D, 0x001E,
2620 0x0006, 0x000B, 0x0011, 0x001E, 0x0074, 0x03AA, 0x1D5C, 0x0001,
2621 0x0021, 0x0001, 0x0002, 0x0007, 0x0006, 0x003E, 0x00EB, 0x01D4,
2622 0x0EAF, 0x3ABB, 0x3ABA, 0x1D59, 0x1D58, 0x1D5B, 0x1D5A, 0x000A,
2623 0x001C, 0x0001, 0x003F, 0x003B, 0x0001, 0x0009, 0x0020, 0x0000,
2625 0x0004, 0x000A, 0x0017, 0x0004, 0x0016, 0x016A, 0x16B1, 0x0017,
2626 0x005B, 0x0006, 0x0007, 0x0001, 0x0000, 0x000A, 0x02D7, 0x0B5A,
2627 0x16B0, 0x16B3, 0x16B2, 0x2D6D, 0x2D6C, 0x2D6F, 0x2D6E, 0x0006,
2628 0x000A, 0x0004, 0x002C, 0x0017, 0x0003, 0x0007, 0x0016, 0x00B4,
2630 0x0005, 0x000D, 0x0005, 0x0009, 0x0033, 0x0193, 0x192C, 0x0061,
2631 0x0031, 0x0000, 0x0007, 0x0010, 0x0011, 0x00C8, 0x192F, 0x325B,
2632 0x325A, 0x1929, 0x1928, 0x192B, 0x192A, 0x325D, 0x325C, 0x0018,
2633 0x001A, 0x001B, 0x0065, 0x0019, 0x0004, 0x0007, 0x0060, 0x0324,
2635 0x0006, 0x0000, 0x0002, 0x000F, 0x0039, 0x01D9, 0x1D82, 0x0761,
2636 0x03BE, 0x0001, 0x0002, 0x000F, 0x000E, 0x0762, 0x3B07, 0x3B06,
2637 0x3B1D, 0x3B1C, 0x3B1F, 0x3B1E, 0x3B19, 0x3B18, 0x3B1B, 0x0038,
2638 0x01DE, 0x00ED, 0x03BF, 0x00EE, 0x003A, 0x0006, 0x0EC0, 0x3B1A,
2640 0x0000, 0x0002, 0x000F, 0x0006, 0x001C, 0x01D0, 0x0E8C, 0x1D1B,
2641 0x1D1A, 0x0003, 0x0002, 0x00EA, 0x00E9, 0x0E89, 0x0E88, 0x0E8B,
2642 0x0E8A, 0x1D65, 0x1D64, 0x1D67, 0x1D66, 0x1D61, 0x1D60, 0x03AD,
2643 0x1D63, 0x1D62, 0x1D1D, 0x1D1C, 0x003B, 0x01D7, 0x1D1F, 0x1D1E,
2645 0x0002, 0x000F, 0x001C, 0x000C, 0x003B, 0x01AC, 0x1AD8, 0x35B3,
2646 0x35B2, 0x0001, 0x0000, 0x0069, 0x0068, 0x35BD, 0x35BC, 0x35BF,
2647 0x35BE, 0x35B9, 0x35B8, 0x35BB, 0x35BA, 0x35B5, 0x35B4, 0x01A9,
2648 0x01A8, 0x035A, 0x00D7, 0x00D5, 0x003A, 0x001B, 0x35B7, 0x35B6,
2652 const VP31_AC_CAT3_BITS: [[u8; 32]; 16] = [
2654 3, 5, 7, 7, 9, 12, 12, 5, 7, 3, 3, 4, 4, 4, 5, 7,
2655 7, 8, 10, 13, 13, 13, 13, 4, 5, 5, 6, 6, 4, 6, 5, 5,
2657 3, 5, 6, 6, 7, 10, 13, 5, 6, 3, 3, 4, 4, 5, 6, 8,
2658 10, 10, 13, 13, 13, 12, 12, 4, 5, 5, 5, 6, 4, 5, 5, 5,
2660 3, 4, 6, 5, 7, 9, 13, 6, 6, 3, 3, 4, 4, 5, 8, 10,
2661 13, 13, 13, 13, 13, 13, 13, 4, 5, 5, 6, 6, 4, 4, 6, 6,
2663 3, 4, 5, 4, 6, 8, 12, 7, 7, 3, 3, 4, 4, 7, 9, 13,
2664 13, 12, 12, 12, 12, 12, 12, 4, 5, 5, 6, 6, 4, 4, 7, 7,
2666 3, 4, 5, 4, 5, 7, 10, 10, 7, 3, 3, 5, 5, 8, 13, 14,
2667 14, 13, 13, 13, 13, 13, 13, 4, 5, 5, 6, 6, 4, 3, 7, 10,
2669 3, 4, 3, 3, 4, 6, 11, 13, 8, 3, 3, 6, 6, 13, 13, 13,
2670 13, 13, 13, 13, 14, 14, 14, 3, 6, 8, 9, 8, 6, 5, 12, 14,
2672 3, 4, 3, 3, 4, 6, 11, 13, 8, 3, 3, 6, 6, 13, 13, 13,
2673 13, 13, 13, 13, 14, 14, 14, 3, 6, 8, 9, 8, 6, 5, 12, 14,
2675 3, 4, 3, 3, 4, 6, 11, 13, 8, 3, 3, 6, 6, 13, 13, 13,
2676 13, 13, 13, 13, 14, 14, 14, 3, 6, 8, 9, 8, 6, 5, 12, 14,
2678 3, 5, 6, 7, 9, 12, 12, 5, 7, 3, 3, 4, 4, 5, 6, 7,
2679 9, 9, 10, 13, 13, 13, 13, 4, 4, 5, 5, 6, 4, 5, 5, 6,
2681 3, 4, 6, 5, 8, 13, 14, 6, 6, 3, 3, 4, 4, 5, 7, 9,
2682 10, 11, 14, 14, 14, 14, 14, 4, 5, 5, 6, 6, 4, 4, 6, 6,
2684 3, 4, 5, 5, 7, 10, 13, 6, 6, 3, 3, 4, 4, 6, 8, 9,
2685 12, 14, 14, 13, 13, 13, 13, 4, 5, 5, 6, 6, 4, 4, 6, 6,
2687 3, 4, 5, 4, 6, 9, 13, 7, 7, 3, 3, 4, 4, 6, 10, 12,
2688 13, 13, 13, 14, 14, 14, 14, 4, 5, 5, 6, 6, 4, 4, 7, 8,
2690 3, 4, 4, 4, 6, 9, 13, 8, 7, 2, 3, 5, 5, 8, 13, 14,
2691 14, 13, 13, 13, 13, 14, 14, 5, 6, 6, 7, 6, 4, 4, 8, 10,
2693 3, 3, 4, 4, 6, 9, 13, 11, 10, 2, 2, 6, 6, 11, 14, 14,
2694 14, 14, 14, 14, 14, 14, 14, 6, 9, 8, 10, 8, 6, 5, 12, 14,
2696 2, 3, 5, 4, 6, 10, 13, 14, 14, 2, 2, 9, 9, 13, 13, 13,
2697 13, 14, 14, 14, 14, 14, 14, 11, 14, 14, 14, 14, 7, 10, 14, 14,
2699 2, 4, 5, 4, 6, 9, 13, 14, 14, 2, 2, 7, 7, 14, 14, 14,
2700 14, 14, 14, 14, 14, 14, 14, 9, 9, 10, 8, 8, 6, 5, 14, 14,
2704 const VP31_DC_WEIGHTS: [[i16; 5]; 16] = [
2713 [ 29, -26, 29, 0, 32 ],
2716 [ 75, 0, 0, 53, 128 ],
2718 [ 75, 0, 0, 53, 128 ],
2721 [ 75, 0, 0, 53, 128 ],
2722 [ 0, 3, 10, 3, 16 ],
2723 [ 29, -26, 29, 0, 32 ],
2726 const VP30_DC_SCALES: [i16; 64] = [
2727 24, 20, 20, 20, 20, 20, 20, 20,
2728 19, 19, 19, 19, 18, 18, 18, 18,
2729 17, 17, 17, 17, 16, 16, 15, 15,
2730 14, 14, 13, 13, 12, 12, 11, 11,
2731 10, 10, 9, 9, 8, 8, 7, 7,
2732 6, 6, 6, 6, 5, 5, 5, 5,
2733 4, 4, 4, 4, 3, 3, 3, 3,
2734 2, 2, 2, 2, 1, 1, 1, 1
2737 const VP30_AC_SCALES: [i16; 64] = [
2738 3000, 2500, 2000, 1500, 1200, 1000, 900, 800,
2739 750, 700, 650, 630, 600, 550, 500, 450,
2740 410, 380, 350, 320, 290, 260, 240, 220,
2741 200, 180, 165, 150, 140, 130, 120, 115,
2742 110, 100, 95, 90, 85, 80, 75, 70,
2743 67, 65, 63, 61, 57, 55, 53, 50,
2744 49, 46, 44, 42, 39, 36, 33, 30,
2745 27, 24, 21, 19, 17, 15, 12, 10
2748 const VP30_DC_CODES: [[u16; 32]; 5] = [
2750 0x0005, 0x002D, 0x0004, 0x0009, 0x0088, 0x0225, 0x0224, 0x0005,
2751 0x0011, 0x0007, 0x0006, 0x0009, 0x000A, 0x0007, 0x0017, 0x000C,
2752 0x002C, 0x0005, 0x0008, 0x0003, 0x0012, 0x0010, 0x0113, 0x0003,
2753 0x0010, 0x0000, 0x0013, 0x001A, 0x0023, 0x0045, 0x0001, 0x001B
2755 0x000B, 0x0012, 0x0029, 0x0010, 0x000D, 0x00A2, 0x0020, 0x0009,
2756 0x0050, 0x0007, 0x0006, 0x0006, 0x0005, 0x0002, 0x0008, 0x0027,
2757 0x0005, 0x0022, 0x0023, 0x0057, 0x00A3, 0x0011, 0x0021, 0x0007,
2758 0x0000, 0x0009, 0x002A, 0x0003, 0x0007, 0x0026, 0x000C, 0x0056
2760 0x000D, 0x0018, 0x0009, 0x0017, 0x0033, 0x0056, 0x00F7, 0x00F1,
2761 0x007A, 0x0000, 0x0007, 0x0009, 0x0008, 0x0005, 0x000D, 0x002D,
2762 0x0010, 0x001D, 0x001C, 0x0057, 0x00CB, 0x00F6, 0x00F0, 0x0014,
2763 0x000C, 0x002C, 0x0011, 0x001F, 0x002A, 0x0064, 0x00CA, 0x0079
2765 0x000F, 0x001A, 0x0013, 0x001B, 0x003B, 0x0072, 0x01D3, 0x0707,
2766 0x0E0D, 0x0001, 0x0000, 0x000C, 0x000B, 0x0008, 0x0012, 0x002A,
2767 0x0073, 0x0028, 0x0075, 0x0056, 0x0052, 0x01C0, 0x0E0C, 0x0071,
2768 0x0057, 0x00E1, 0x00A6, 0x00E8, 0x00A7, 0x03A5, 0x03A4, 0x0382
2770 0x000F, 0x001B, 0x0014, 0x001D, 0x0010, 0x0073, 0x00E2, 0x023C,
2771 0x11C9, 0x0001, 0x0000, 0x000C, 0x000B, 0x0009, 0x0015, 0x0035,
2772 0x0072, 0x0034, 0x0022, 0x0070, 0x0046, 0x011D, 0x11C8, 0x01C7,
2773 0x01C6, 0x0238, 0x047E, 0x023E, 0x0473, 0x08E5, 0x023D, 0x047F
2776 const VP30_DC_BITS: [[u8; 32]; 5] = [
2778 4, 6, 6, 6, 8, 10, 10, 6, 7, 3, 3, 4, 4, 4, 5, 5,
2779 6, 5, 5, 5, 6, 7, 9, 4, 5, 5, 6, 6, 6, 7, 5, 6
2781 4, 5, 6, 5, 6, 8, 9, 7, 7, 3, 3, 4, 4, 4, 5, 6,
2782 6, 6, 6, 7, 8, 8, 9, 4, 4, 5, 6, 5, 5, 6, 6, 7
2784 4, 5, 5, 5, 6, 7, 9, 9, 8, 2, 3, 4, 4, 4, 5, 6,
2785 6, 6, 6, 7, 8, 9, 9, 5, 5, 6, 6, 6, 6, 7, 8, 8
2787 4, 5, 5, 5, 6, 7, 9, 11, 12, 2, 2, 4, 4, 4, 5, 6,
2788 7, 6, 7, 7, 7, 9, 12, 7, 7, 8, 8, 8, 8, 10, 10, 10
2790 4, 5, 5, 5, 5, 7, 8, 10, 13, 2, 2, 4, 4, 4, 5, 6,
2791 7, 6, 6, 7, 7, 9, 13, 9, 9, 10, 11, 10, 11, 12, 10, 11
2794 const VP30_AC_INTRA_CODES: [[u16; 32]; 5] = [
2796 0x0008, 0x0033, 0x0008, 0x004B, 0x0089, 0x0221, 0x0220, 0x001F,
2797 0x0045, 0x0000, 0x000E, 0x000B, 0x000A, 0x000D, 0x0006, 0x001E,
2798 0x000A, 0x0018, 0x0013, 0x0005, 0x0009, 0x0046, 0x0111, 0x0007,
2799 0x000B, 0x0032, 0x0010, 0x004A, 0x0024, 0x0047, 0x0003, 0x0009
2801 0x000E, 0x000E, 0x007B, 0x001E, 0x007E, 0x03EF, 0x07DD, 0x0018,
2802 0x00FA, 0x0002, 0x0000, 0x000A, 0x0008, 0x000B, 0x0003, 0x0012,
2803 0x0033, 0x000C, 0x003C, 0x001A, 0x007F, 0x01F6, 0x07DC, 0x000D,
2804 0x0013, 0x0004, 0x001B, 0x007A, 0x0032, 0x007C, 0x001F, 0x0005
2806 0x0000, 0x0018, 0x0034, 0x000C, 0x006A, 0x01F9, 0x07EA, 0x0016,
2807 0x0FD7, 0x0002, 0x0001, 0x000A, 0x0009, 0x0007, 0x001B, 0x003E,
2808 0x0020, 0x0021, 0x006B, 0x01FB, 0x03F4, 0x1FAD, 0x1FAC, 0x000E,
2809 0x0019, 0x0011, 0x002F, 0x007F, 0x002E, 0x01F8, 0x001E, 0x000D
2811 0x000E, 0x0016, 0x002E, 0x0003, 0x006E, 0x008B, 0x0113, 0x0018,
2812 0x0221, 0x0001, 0x0002, 0x000A, 0x0009, 0x0007, 0x001A, 0x0002,
2813 0x001B, 0x0023, 0x006F, 0x008A, 0x0111, 0x0441, 0x0440, 0x000F,
2814 0x0019, 0x0010, 0x0036, 0x001A, 0x002F, 0x0112, 0x0000, 0x000C
2816 0x000E, 0x000F, 0x001B, 0x0033, 0x005A, 0x00B6, 0x0008, 0x001A,
2817 0x004D, 0x0001, 0x0002, 0x000A, 0x0009, 0x0008, 0x001B, 0x0003,
2818 0x002C, 0x002E, 0x0005, 0x00B7, 0x0027, 0x0099, 0x0098, 0x000F,
2819 0x0018, 0x000E, 0x002F, 0x001A, 0x0032, 0x0012, 0x0000, 0x000C
2822 const VP30_AC_INTRA_BITS: [[u8; 32]; 5] = [
2824 4, 6, 6, 7, 9, 11, 11, 5, 8, 3, 4, 4, 4, 4, 4, 5,
2825 5, 5, 5, 5, 6, 8, 10, 4, 5, 6, 6, 7, 6, 8, 4, 5
2827 4, 5, 7, 6, 8, 11, 12, 5, 9, 3, 3, 4, 4, 4, 4, 5,
2828 6, 5, 6, 6, 8, 10, 12, 4, 5, 5, 6, 7, 6, 8, 5, 5
2830 3, 5, 6, 5, 7, 9, 11, 5, 12, 3, 3, 4, 4, 4, 5, 6,
2831 6, 6, 7, 9, 10, 13, 13, 4, 5, 5, 6, 7, 6, 9, 5, 5
2833 4, 5, 6, 5, 7, 8, 9, 5, 10, 3, 3, 4, 4, 4, 5, 5,
2834 6, 6, 7, 8, 9, 11, 11, 4, 5, 5, 6, 6, 6, 9, 4, 5
2836 4, 5, 6, 6, 7, 8, 7, 5, 10, 3, 3, 4, 4, 4, 5, 5,
2837 6, 6, 6, 8, 9, 11, 11, 4, 5, 5, 6, 6, 6, 8, 4, 5
2840 const VP30_AC_INTER_CODES: [[u16; 32]; 5] = [
2842 0x000D, 0x0038, 0x0061, 0x0060, 0x0393, 0x1C95, 0x1C94, 0x0014,
2843 0x0073, 0x0001, 0x0000, 0x000B, 0x0009, 0x001D, 0x000E, 0x0022,
2844 0x0046, 0x0047, 0x00E5, 0x01C8, 0x0724, 0x1C97, 0x1C96, 0x000F,
2845 0x0006, 0x0019, 0x000F, 0x0031, 0x0004, 0x0010, 0x0005, 0x0015
2847 0x0004, 0x001B, 0x0030, 0x0034, 0x00D5, 0x06B3, 0x3595, 0x0031,
2848 0x001A, 0x0002, 0x0001, 0x001F, 0x001E, 0x000C, 0x001B, 0x00D7,
2849 0x00D4, 0x01AD, 0x0358, 0x0D64, 0x3594, 0x3597, 0x3596, 0x0000,
2850 0x000A, 0x001D, 0x0017, 0x0039, 0x0007, 0x0019, 0x0016, 0x0038
2852 0x0005, 0x0009, 0x001A, 0x001E, 0x001F, 0x00E2, 0x038E, 0x0070,
2853 0x003B, 0x0001, 0x0000, 0x0019, 0x0018, 0x001E, 0x003A, 0x01C6,
2854 0x071E, 0x0E3E, 0x1C7E, 0x71FD, 0x71FC, 0x71FF, 0x71FE, 0x0002,
2855 0x0008, 0x001D, 0x001B, 0x0039, 0x001F, 0x000D, 0x000C, 0x001C
2857 0x0003, 0x000B, 0x001C, 0x000D, 0x0004, 0x000A, 0x0076, 0x00E8,
2858 0x01DC, 0x0001, 0x0000, 0x0033, 0x0032, 0x00E9, 0x03BB, 0x0774,
2859 0x1DD5, 0x3BAD, 0x3BAC, 0x3BAF, 0x3BAE, 0x3BA9, 0x3BA8, 0x0004,
2860 0x000A, 0x001F, 0x001E, 0x0030, 0x000B, 0x0075, 0x0031, 0x00EF
2862 0x0009, 0x001E, 0x000F, 0x000E, 0x000C, 0x0008, 0x0001, 0x00E3,
2863 0x00E2, 0x0002, 0x0000, 0x003A, 0x0039, 0x0070, 0x01DC, 0x0776,
2864 0x0775, 0x0EEF, 0x0EE8, 0x1DD3, 0x1DD2, 0x1DDD, 0x1DDC, 0x0005,
2865 0x001F, 0x001B, 0x0006, 0x006A, 0x0034, 0x0076, 0x006B, 0x00EF
2868 const VP30_AC_INTER_BITS: [[u8; 32]; 5] = [
2870 4, 6, 7, 7, 10, 13, 13, 5, 7, 3, 3, 4, 4, 5, 5, 6,
2871 7, 7, 8, 9, 11, 13, 13, 4, 4, 5, 5, 6, 4, 5, 4, 5
2873 3, 5, 6, 6, 8, 11, 14, 6, 6, 3, 3, 5, 5, 5, 6, 8,
2874 8, 9, 10, 12, 14, 14, 14, 3, 4, 5, 5, 6, 4, 5, 5, 6
2876 3, 4, 5, 5, 6, 8, 10, 7, 7, 3, 3, 5, 5, 6, 7, 9,
2877 11, 12, 13, 15, 15, 15, 15, 3, 4, 5, 5, 6, 5, 5, 5, 6
2879 3, 4, 5, 4, 4, 5, 7, 8, 9, 3, 3, 6, 6, 8, 10, 11,
2880 13, 14, 14, 14, 14, 14, 14, 3, 4, 5, 5, 6, 5, 7, 6, 8
2882 4, 5, 5, 4, 4, 4, 3, 9, 9, 3, 3, 7, 7, 8, 10, 12,
2883 12, 13, 13, 14, 14, 14, 14, 3, 5, 5, 4, 7, 6, 8, 7, 9
2886 const VP30_MBTYPE_CODES: [u8; 7] = [ 0x00, 0x08, 0x0A, 0x03, 0x0B, 0x13, 0x12 ];
2887 const VP30_MBTYPE_BITS: [u8; 7] = [ 1, 4, 4, 2, 4, 5, 5 ];
2888 const VP30_MBTYPE_SYMS: [VPMBType; 7] = [
2889 VPMBType::InterNoMV, VPMBType::Intra, VPMBType::InterMV, VPMBType::InterNearest,
2890 VPMBType::GoldenNoMV, VPMBType::GoldenMV, VPMBType::InterFourMV
2893 const VP40_DC_CODES: [[u32; 32]; 16] = [
2895 0x000C, 0x0070, 0x01CA, 0x01CB, 0x0391, 0x1C9B, 0x3935, 0x0071,
2896 0x3934, 0x000B, 0x000F, 0x0019, 0x0002, 0x0009, 0x0003, 0x001D,
2897 0x0018, 0x0007, 0x000D, 0x0002, 0x0000, 0x000A, 0x0008, 0x001A,
2898 0x0073, 0x006F, 0x0E4C, 0x0727, 0x0392, 0x0390, 0x0036, 0x006E
2900 0x0011, 0x007A, 0x0083, 0x0040, 0x0105, 0x0413, 0x0410, 0x007B,
2901 0x0822, 0x000E, 0x0002, 0x0002, 0x0006, 0x000A, 0x0007, 0x001F,
2902 0x0017, 0x0009, 0x000D, 0x0000, 0x000C, 0x0003, 0x003C, 0x002C,
2903 0x0021, 0x0169, 0x0412, 0x02D0, 0x02D1, 0x0823, 0x005B, 0x00B5
2905 0x0017, 0x0010, 0x00B6, 0x0022, 0x016A, 0x02D0, 0x0B48, 0x0077,
2906 0x1692, 0x0000, 0x0003, 0x0003, 0x0009, 0x000C, 0x0005, 0x0002,
2907 0x001C, 0x0008, 0x000D, 0x000F, 0x000A, 0x0009, 0x0023, 0x003A,
2908 0x002C, 0x016B, 0x05A5, 0x02D3, 0x02D1, 0x1693, 0x0076, 0x00B7
2910 0x001E, 0x0013, 0x00FB, 0x007C, 0x0046, 0x07D6, 0x0FA9, 0x0012,
2911 0x1F50, 0x0001, 0x0004, 0x0005, 0x000A, 0x000E, 0x0007, 0x0000,
2912 0x0017, 0x0006, 0x000D, 0x000C, 0x0001, 0x002C, 0x008F, 0x003F,
2913 0x002D, 0x01F4, 0x07D5, 0x008E, 0x07D7, 0x1F51, 0x0010, 0x0022
2915 0x0001, 0x002B, 0x0012, 0x0055, 0x0027, 0x03B0, 0x0762, 0x0077,
2916 0x0261, 0x0002, 0x0006, 0x0007, 0x000B, 0x000F, 0x0008, 0x0000,
2917 0x001C, 0x0003, 0x0009, 0x0006, 0x0014, 0x0054, 0x0131, 0x0005,
2918 0x003A, 0x01D9, 0x0099, 0x004D, 0x0763, 0x0260, 0x0008, 0x00ED
2920 0x0004, 0x0033, 0x0060, 0x0065, 0x00C2, 0x030D, 0x0619, 0x0064,
2921 0x1862, 0x0004, 0x0007, 0x000A, 0x000B, 0x000D, 0x0006, 0x0000,
2922 0x000F, 0x0003, 0x0005, 0x0002, 0x0002, 0x0077, 0x0C30, 0x0003,
2923 0x0031, 0x0187, 0x01D9, 0x00ED, 0x01D8, 0x1863, 0x001C, 0x003A
2925 0x0008, 0x000A, 0x006A, 0x0016, 0x001E, 0x034E, 0x069F, 0x0068,
2926 0x0D28, 0x0005, 0x0007, 0x0007, 0x000C, 0x0000, 0x0006, 0x001B,
2927 0x0012, 0x0002, 0x0004, 0x0013, 0x000E, 0x034B, 0x1A53, 0x0006,
2928 0x0017, 0x01A6, 0x069E, 0x01A4, 0x0695, 0x1A52, 0x006B, 0x001F
2930 0x000E, 0x000F, 0x0017, 0x0025, 0x009F, 0x0138, 0x024B, 0x0093,
2931 0x092A, 0x0005, 0x0000, 0x0008, 0x000D, 0x000F, 0x0006, 0x0004,
2932 0x000E, 0x0019, 0x0018, 0x000A, 0x009E, 0x0494, 0x1256, 0x0026,
2933 0x0016, 0x0124, 0x04E5, 0x0273, 0x04E4, 0x1257, 0x0048, 0x009D
2935 0x0004, 0x002C, 0x0050, 0x001E, 0x0071, 0x00E1, 0x00E0, 0x001D,
2936 0x0006, 0x0007, 0x0006, 0x0007, 0x0005, 0x0006, 0x0015, 0x0000,
2937 0x0029, 0x0002, 0x0006, 0x0001, 0x0023, 0x001F, 0x0039, 0x0009,
2938 0x0002, 0x0010, 0x0007, 0x002D, 0x002F, 0x002E, 0x0022, 0x0051
2940 0x0008, 0x002F, 0x0051, 0x0050, 0x02ED, 0x05D9, 0x05D8, 0x00BA,
2941 0x005C, 0x0007, 0x0006, 0x0009, 0x0006, 0x0007, 0x0016, 0x0005,
2942 0x002B, 0x0006, 0x000A, 0x0001, 0x000F, 0x001D, 0x0177, 0x0004,
2943 0x0001, 0x0004, 0x0001, 0x002A, 0x000B, 0x0029, 0x0000, 0x001C
2945 0x000A, 0x003C, 0x0074, 0x004E, 0x026D, 0x04D9, 0x04D8, 0x009A,
2946 0x004C, 0x0000, 0x0006, 0x0008, 0x0007, 0x0006, 0x0016, 0x0008,
2947 0x002E, 0x000A, 0x000B, 0x003D, 0x0024, 0x00EB, 0x0137, 0x001F,
2948 0x001C, 0x003B, 0x0012, 0x0025, 0x002F, 0x0013, 0x004F, 0x00EA
2950 0x000A, 0x000A, 0x0003, 0x0016, 0x0009, 0x0021, 0x0020, 0x00B3,
2951 0x0058, 0x0007, 0x0006, 0x0007, 0x0006, 0x0004, 0x0013, 0x0002,
2952 0x0025, 0x0000, 0x0003, 0x002D, 0x005D, 0x00B2, 0x0011, 0x0008,
2953 0x0002, 0x0006, 0x0017, 0x002F, 0x0007, 0x0024, 0x005C, 0x0005
2955 0x000B, 0x0013, 0x001F, 0x0031, 0x0021, 0x0295, 0x0528, 0x00A4,
2956 0x003C, 0x0000, 0x0007, 0x0006, 0x0005, 0x001B, 0x0012, 0x0032,
2957 0x001D, 0x002B, 0x0030, 0x001C, 0x003D, 0x014B, 0x0529, 0x0008,
2958 0x001A, 0x0033, 0x0011, 0x002A, 0x0009, 0x0028, 0x0053, 0x0020
2960 0x000E, 0x0015, 0x0029, 0x003F, 0x004D, 0x02F1, 0x05E0, 0x0092,
2961 0x0048, 0x0000, 0x0006, 0x0006, 0x0005, 0x0004, 0x000F, 0x002E,
2962 0x001D, 0x0028, 0x0027, 0x005F, 0x00BD, 0x0179, 0x05E1, 0x0008,
2963 0x001E, 0x002D, 0x001C, 0x002C, 0x003E, 0x0025, 0x004C, 0x0093
2965 0x000C, 0x0017, 0x0035, 0x0013, 0x0021, 0x00AD, 0x06F1, 0x01BD,
2966 0x00D9, 0x0000, 0x0007, 0x0007, 0x0006, 0x0004, 0x0011, 0x002A,
2967 0x006E, 0x0025, 0x0024, 0x0057, 0x00D8, 0x0379, 0x06F0, 0x0005,
2968 0x0016, 0x0029, 0x006D, 0x0028, 0x0034, 0x0020, 0x00DF, 0x00AC
2970 0x0000, 0x001A, 0x0006, 0x0019, 0x0030, 0x005A, 0x018A, 0x02DD,
2971 0x018B, 0x0001, 0x0007, 0x000A, 0x0009, 0x0002, 0x0010, 0x002E,
2972 0x006E, 0x002C, 0x000E, 0x005E, 0x00C4, 0x05B9, 0x05B8, 0x0011,
2973 0x0036, 0x005F, 0x001E, 0x0063, 0x006F, 0x001F, 0x00B6, 0x016F
2976 const VP40_DC_BITS: [[u8; 32]; 16] = [
2978 5, 7, 9, 9, 10, 13, 14, 7, 14, 4, 4, 5, 4, 4, 4, 5,
2979 5, 4, 4, 3, 3, 4, 4, 6, 7, 8, 12, 11, 10, 10, 7, 8
2981 5, 7, 8, 7, 9, 11, 11, 7, 12, 4, 3, 4, 4, 4, 4, 5,
2982 5, 4, 4, 3, 4, 4, 6, 6, 6, 9, 11, 10, 10, 12, 7, 8
2984 5, 6, 8, 7, 9, 10, 12, 7, 13, 3, 3, 4, 4, 4, 4, 4,
2985 5, 4, 4, 4, 4, 5, 7, 6, 6, 9, 11, 10, 10, 13, 7, 8
2987 5, 6, 8, 7, 8, 11, 12, 6, 13, 3, 3, 4, 4, 4, 4, 4,
2988 5, 4, 4, 4, 4, 6, 9, 6, 6, 9, 11, 9, 11, 13, 6, 7
2990 4, 6, 7, 7, 8, 10, 11, 7, 12, 3, 3, 4, 4, 4, 4, 4,
2991 5, 4, 4, 4, 5, 7, 11, 5, 6, 9, 10, 9, 11, 12, 6, 8
2993 4, 6, 7, 7, 8, 10, 11, 7, 13, 3, 3, 4, 4, 4, 4, 4,
2994 5, 4, 4, 4, 5, 8, 12, 5, 6, 9, 10, 9, 10, 13, 6, 7
2996 4, 5, 7, 6, 7, 10, 11, 7, 12, 3, 3, 4, 4, 3, 4, 5,
2997 5, 4, 4, 5, 6, 10, 13, 5, 6, 9, 11, 9, 11, 13, 7, 7
2999 4, 5, 6, 6, 8, 9, 10, 8, 12, 3, 2, 4, 4, 4, 4, 4,
3000 5, 5, 5, 5, 8, 11, 13, 6, 6, 9, 11, 10, 11, 13, 7, 8
3002 4, 6, 7, 7, 9, 10, 10, 7, 6, 3, 3, 4, 4, 4, 5, 5,
3003 6, 5, 5, 5, 6, 7, 8, 4, 4, 5, 6, 6, 6, 6, 6, 7
3005 4, 6, 7, 7, 10, 11, 11, 8, 7, 3, 3, 4, 4, 4, 5, 5,
3006 6, 5, 5, 5, 6, 7, 9, 4, 4, 5, 6, 6, 5, 6, 6, 7
3008 4, 6, 7, 7, 10, 11, 11, 8, 7, 2, 3, 4, 4, 4, 5, 5,
3009 6, 5, 5, 6, 6, 8, 9, 5, 5, 6, 6, 6, 6, 6, 7, 8
3011 4, 5, 6, 6, 8, 10, 10, 8, 7, 3, 3, 4, 4, 4, 5, 5,
3012 6, 5, 5, 6, 7, 8, 9, 4, 4, 5, 6, 6, 5, 6, 7, 7
3014 4, 5, 6, 6, 7, 10, 11, 8, 7, 2, 3, 4, 4, 5, 5, 6,
3015 6, 6, 6, 6, 7, 9, 11, 4, 5, 6, 6, 6, 5, 6, 7, 7
3017 4, 5, 6, 6, 7, 10, 11, 8, 7, 2, 3, 4, 4, 4, 5, 6,
3018 6, 6, 6, 7, 8, 9, 11, 4, 5, 6, 6, 6, 6, 6, 7, 8
3020 4, 5, 6, 5, 6, 8, 11, 9, 8, 2, 3, 4, 4, 4, 5, 6,
3021 7, 6, 6, 7, 8, 10, 11, 4, 5, 6, 7, 6, 6, 6, 8, 8
3023 3, 5, 5, 5, 6, 7, 9, 10, 9, 2, 3, 4, 4, 4, 5, 6,
3024 7, 6, 6, 7, 8, 11, 11, 5, 6, 7, 7, 7, 7, 7, 8, 9
3027 const VP40_AC_CAT0_CODES: [[u32; 32]; 16] = [
3029 0x0006, 0x001E, 0x01CC, 0x01CE, 0x0734, 0x1CD5, 0x1CD4, 0x0018,
3030 0x0E6B, 0x0000, 0x000F, 0x0006, 0x0007, 0x000D, 0x0008, 0x0002,
3031 0x0019, 0x0005, 0x000B, 0x000A, 0x001D, 0x0027, 0x01CF, 0x0004,
3032 0x0038, 0x000E, 0x004C, 0x001F, 0x004D, 0x039B, 0x0012, 0x0072
3034 0x0009, 0x004B, 0x0090, 0x0091, 0x0745, 0x1D11, 0x1D10, 0x0019,
3035 0x0E89, 0x0000, 0x000F, 0x0008, 0x0007, 0x000D, 0x000B, 0x0002,
3036 0x001C, 0x0003, 0x000A, 0x0005, 0x0018, 0x0010, 0x01D0, 0x0006,
3037 0x003B, 0x0011, 0x004A, 0x0049, 0x00E9, 0x03A3, 0x0013, 0x0075
3039 0x0019, 0x0074, 0x001D, 0x00EA, 0x0073, 0x01CA, 0x0396, 0x001C,
3040 0x00E4, 0x0002, 0x0001, 0x0007, 0x0008, 0x000D, 0x0009, 0x001F,
3041 0x0018, 0x0000, 0x0006, 0x001E, 0x003B, 0x00EB, 0x0397, 0x000A,
3042 0x0002, 0x002C, 0x005B, 0x005A, 0x000F, 0x0038, 0x0017, 0x0006
3044 0x001E, 0x006F, 0x00AE, 0x00AF, 0x0187, 0x061B, 0x0C35, 0x001A,
3045 0x030C, 0x0002, 0x0001, 0x0007, 0x0008, 0x000E, 0x0009, 0x001F,
3046 0x0014, 0x0000, 0x0001, 0x0019, 0x002A, 0x0060, 0x0C34, 0x000B,
3047 0x000D, 0x0036, 0x006E, 0x0056, 0x0031, 0x00C2, 0x0018, 0x0019
3049 0x0001, 0x002C, 0x0005, 0x0015, 0x0008, 0x0097, 0x012D, 0x0017,
3050 0x004A, 0x0003, 0x0002, 0x0009, 0x000A, 0x000E, 0x0008, 0x001F,
3051 0x0007, 0x001E, 0x001B, 0x0004, 0x005A, 0x0024, 0x012C, 0x000C,
3052 0x0006, 0x0000, 0x0003, 0x005B, 0x0014, 0x0013, 0x001A, 0x000B
3054 0x0004, 0x0000, 0x0017, 0x0063, 0x018B, 0x0310, 0x0C44, 0x0019,
3055 0x0623, 0x0004, 0x0003, 0x000A, 0x000B, 0x000D, 0x0003, 0x001C,
3056 0x0003, 0x000A, 0x0004, 0x0003, 0x018A, 0x188B, 0x188A, 0x000F,
3057 0x000B, 0x0002, 0x000A, 0x0002, 0x0016, 0x0189, 0x001D, 0x0030
3059 0x000D, 0x0003, 0x0077, 0x000D, 0x0082, 0x020D, 0x0830, 0x0019,
3060 0x0419, 0x0003, 0x0002, 0x000A, 0x0009, 0x000B, 0x0002, 0x0011,
3061 0x0039, 0x0002, 0x0021, 0x0040, 0x1063, 0x20C5, 0x20C4, 0x000F,
3062 0x0018, 0x0007, 0x0038, 0x000C, 0x0076, 0x0107, 0x0000, 0x003A
3064 0x000F, 0x001C, 0x0036, 0x0008, 0x0061, 0x0091, 0x0243, 0x0009,
3065 0x0120, 0x0005, 0x0003, 0x0008, 0x0005, 0x0001, 0x0013, 0x0031,
3066 0x0076, 0x0060, 0x0093, 0x0909, 0x0908, 0x090B, 0x090A, 0x0001,
3067 0x001A, 0x0019, 0x003A, 0x0025, 0x0077, 0x0092, 0x0000, 0x0037
3069 0x001F, 0x0079, 0x00F1, 0x00F0, 0x011B, 0x0469, 0x0468, 0x003B,
3070 0x0022, 0x0005, 0x0004, 0x0007, 0x0005, 0x0006, 0x001C, 0x0001,
3071 0x0035, 0x003D, 0x003A, 0x0010, 0x0047, 0x008C, 0x0235, 0x0001,
3072 0x0001, 0x0019, 0x0000, 0x0030, 0x0009, 0x0031, 0x001B, 0x0034
3074 0x0003, 0x001B, 0x00F3, 0x00FD, 0x03C9, 0x0F20, 0x1E42, 0x003D,
3075 0x00FC, 0x0006, 0x0004, 0x0002, 0x0000, 0x0001, 0x0017, 0x003E,
3076 0x001A, 0x0039, 0x002B, 0x0078, 0x01E5, 0x0791, 0x1E43, 0x0002,
3077 0x0007, 0x001D, 0x000C, 0x0038, 0x0014, 0x007F, 0x0016, 0x002A
3079 0x0007, 0x0039, 0x0051, 0x0078, 0x03CB, 0x0F29, 0x1E51, 0x003D,
3080 0x00F3, 0x0006, 0x0004, 0x0002, 0x0000, 0x0001, 0x0017, 0x003E,
3081 0x007F, 0x002B, 0x007E, 0x0050, 0x01E4, 0x0795, 0x1E50, 0x0002,
3082 0x0006, 0x001D, 0x0006, 0x0038, 0x0007, 0x0029, 0x0016, 0x002A
3084 0x0008, 0x003B, 0x001D, 0x0072, 0x01CC, 0x0734, 0x1CD5, 0x003A,
3085 0x001C, 0x0006, 0x0005, 0x0002, 0x0001, 0x0000, 0x0012, 0x003E,
3086 0x007F, 0x001E, 0x007E, 0x00E7, 0x039B, 0x0E6B, 0x1CD4, 0x0002,
3087 0x0006, 0x001E, 0x000E, 0x0038, 0x0006, 0x000F, 0x0013, 0x001F
3089 0x000D, 0x003F, 0x0073, 0x000C, 0x00E4, 0x072B, 0x0E54, 0x003A,
3090 0x001A, 0x0005, 0x0004, 0x0002, 0x0001, 0x0000, 0x0007, 0x0038,
3091 0x0076, 0x0077, 0x001B, 0x01CB, 0x0394, 0x1CAB, 0x1CAA, 0x0002,
3092 0x0006, 0x001E, 0x000E, 0x003E, 0x0019, 0x001F, 0x0018, 0x001E
3094 0x000E, 0x0007, 0x000C, 0x001C, 0x00BD, 0x02F3, 0x0BC9, 0x001F,
3095 0x00BF, 0x0006, 0x0004, 0x0002, 0x0001, 0x001E, 0x0001, 0x000D,
3096 0x003A, 0x003B, 0x00BE, 0x0178, 0x05E5, 0x1791, 0x1790, 0x0002,
3097 0x0006, 0x001F, 0x0016, 0x0000, 0x0015, 0x002E, 0x0014, 0x001E
3099 0x0000, 0x001B, 0x0031, 0x003A, 0x0060, 0x006F, 0x01B9, 0x000E,
3100 0x001A, 0x0005, 0x0003, 0x0002, 0x001F, 0x001A, 0x0039, 0x000C,
3101 0x00C3, 0x00C2, 0x0036, 0x00DD, 0x0370, 0x06E3, 0x06E2, 0x0002,
3102 0x0008, 0x001E, 0x0019, 0x003B, 0x0012, 0x000F, 0x0013, 0x0038
3104 0x0002, 0x0000, 0x0003, 0x001C, 0x0032, 0x001C, 0x0199, 0x0004,
3105 0x00CD, 0x0004, 0x0003, 0x001B, 0x001A, 0x003D, 0x0067, 0x003B,
3106 0x0198, 0x0075, 0x00E9, 0x03A1, 0x03A0, 0x03A3, 0x03A2, 0x0005,
3107 0x0002, 0x001F, 0x001D, 0x003C, 0x0018, 0x000F, 0x0006, 0x0005
3110 const VP40_AC_CAT0_BITS: [[u8; 32]; 16] = [
3112 5, 7, 9, 9, 11, 13, 13, 5, 12, 3, 4, 4, 4, 4, 4, 4,
3113 5, 4, 4, 4, 5, 6, 9, 4, 6, 6, 7, 7, 7, 10, 5, 7
3115 5, 7, 8, 8, 11, 13, 13, 5, 12, 3, 4, 4, 4, 4, 4, 4,
3116 5, 4, 4, 4, 5, 6, 9, 4, 6, 6, 7, 7, 8, 10, 5, 7
3118 5, 7, 8, 8, 10, 12, 13, 5, 11, 3, 3, 4, 4, 4, 4, 5,
3119 5, 4, 4, 5, 6, 8, 13, 4, 5, 6, 7, 7, 7, 9, 5, 6
3121 5, 7, 8, 8, 10, 12, 13, 5, 11, 3, 3, 4, 4, 4, 4, 5,
3122 5, 4, 4, 5, 6, 8, 13, 4, 5, 6, 7, 7, 7, 9, 5, 6
3124 4, 6, 7, 7, 8, 12, 13, 5, 11, 3, 3, 4, 4, 4, 4, 5,
3125 5, 5, 5, 5, 7, 10, 13, 4, 5, 5, 6, 7, 7, 9, 5, 6
3127 4, 5, 7, 7, 9, 10, 12, 5, 11, 3, 3, 4, 4, 4, 4, 5,
3128 5, 5, 5, 6, 9, 13, 13, 4, 5, 5, 6, 6, 7, 9, 5, 6
3130 4, 5, 7, 6, 8, 10, 12, 5, 11, 3, 3, 4, 4, 4, 4, 5,
3131 6, 5, 6, 7, 13, 14, 14, 4, 5, 5, 6, 6, 7, 9, 4, 6
3133 4, 5, 6, 5, 7, 8, 10, 5, 9, 3, 3, 4, 4, 4, 5, 6,
3134 7, 7, 8, 12, 12, 12, 12, 3, 5, 5, 6, 6, 7, 8, 4, 6
3136 5, 7, 8, 8, 10, 12, 12, 6, 7, 3, 3, 4, 4, 4, 5, 5,
3137 6, 6, 6, 6, 8, 9, 11, 3, 4, 5, 5, 6, 5, 6, 5, 6
3139 4, 6, 8, 8, 10, 12, 13, 6, 8, 3, 3, 4, 4, 4, 5, 6,
3140 6, 6, 6, 7, 9, 11, 13, 3, 4, 5, 5, 6, 5, 7, 5, 6
3142 4, 6, 7, 7, 10, 12, 13, 6, 8, 3, 3, 4, 4, 4, 5, 6,
3143 7, 6, 7, 7, 9, 11, 13, 3, 4, 5, 5, 6, 5, 6, 5, 6
3145 4, 6, 7, 7, 9, 11, 13, 6, 7, 3, 3, 4, 4, 4, 5, 6,
3146 7, 6, 7, 8, 10, 12, 13, 3, 4, 5, 5, 6, 5, 6, 5, 6
3148 4, 6, 7, 6, 8, 11, 12, 6, 7, 3, 3, 4, 4, 4, 5, 6,
3149 7, 7, 7, 9, 10, 13, 13, 3, 4, 5, 5, 6, 5, 6, 5, 6
3151 4, 5, 6, 6, 8, 10, 12, 6, 8, 3, 3, 4, 4, 5, 5, 6,
3152 7, 7, 8, 9, 11, 13, 13, 3, 4, 5, 5, 5, 5, 6, 5, 6
3154 3, 5, 6, 6, 7, 9, 11, 6, 7, 3, 3, 4, 5, 5, 6, 6,
3155 8, 8, 8, 10, 12, 13, 13, 3, 4, 5, 5, 6, 5, 6, 5, 6
3157 3, 4, 5, 5, 6, 7, 9, 6, 8, 3, 3, 5, 5, 6, 7, 8,
3158 9, 9, 10, 12, 12, 12, 12, 3, 4, 5, 5, 6, 5, 6, 5, 6
3161 const VP40_AC_CAT1_CODES: [[u32; 32]; 16] = [
3163 0x0004, 0x00F5, 0x0182, 0x060F, 0x1839, 0x1838, 0x183B, 0x0013,
3164 0x00C0, 0x0003, 0x0002, 0x000B, 0x000A, 0x000E, 0x0008, 0x0001,
3165 0x0012, 0x001F, 0x0000, 0x0006, 0x007B, 0x0306, 0x183A, 0x000D,
3166 0x0007, 0x0031, 0x000A, 0x0061, 0x003C, 0x00F4, 0x0019, 0x000B
3168 0x000A, 0x001A, 0x01D8, 0x03B3, 0x0ECA, 0x1D96, 0x3B2F, 0x0014,
3169 0x0036, 0x0004, 0x0003, 0x000C, 0x000B, 0x0000, 0x0004, 0x001C,
3170 0x0005, 0x0015, 0x0007, 0x0017, 0x0037, 0x0764, 0x3B2E, 0x000F,
3171 0x001A, 0x003A, 0x000C, 0x0077, 0x0004, 0x00ED, 0x001B, 0x0016
3173 0x001A, 0x002D, 0x0058, 0x01F4, 0x07D4, 0x1F55, 0x1F54, 0x0014,
3174 0x0059, 0x0004, 0x0003, 0x000B, 0x000C, 0x000E, 0x0004, 0x0015,
3175 0x0005, 0x0007, 0x0004, 0x007C, 0x03EB, 0x1F57, 0x1F56, 0x0000,
3176 0x001B, 0x003F, 0x000D, 0x000C, 0x000A, 0x00FB, 0x001E, 0x0017
3178 0x0000, 0x0075, 0x004A, 0x0097, 0x025B, 0x0969, 0x0968, 0x000B,
3179 0x00E8, 0x0005, 0x0004, 0x0007, 0x000C, 0x000D, 0x0001, 0x000A,
3180 0x0039, 0x003B, 0x0018, 0x00E9, 0x012C, 0x096B, 0x096A, 0x0001,
3181 0x001F, 0x0008, 0x0019, 0x0013, 0x000D, 0x0024, 0x001E, 0x0038
3183 0x0004, 0x0014, 0x006E, 0x0057, 0x0159, 0x0562, 0x0AC7, 0x000B,
3184 0x006F, 0x0006, 0x0005, 0x0008, 0x0009, 0x0007, 0x001E, 0x0002,
3185 0x0007, 0x0006, 0x002A, 0x00AD, 0x0AC6, 0x0561, 0x0560, 0x0001,
3186 0x001F, 0x000C, 0x0039, 0x001A, 0x0000, 0x0036, 0x001D, 0x0038
3188 0x0007, 0x001B, 0x000E, 0x000D, 0x03E1, 0x1F06, 0x3E0F, 0x0002,
3189 0x00F9, 0x0005, 0x0006, 0x0008, 0x0009, 0x0004, 0x000C, 0x001A,
3190 0x000F, 0x000C, 0x01F1, 0x07C0, 0x3E0E, 0x1F05, 0x1F04, 0x0001,
3191 0x0000, 0x001C, 0x003F, 0x003D, 0x0005, 0x007D, 0x001D, 0x003C
3193 0x000F, 0x000A, 0x0071, 0x0006, 0x01C2, 0x0702, 0x1C0E, 0x0002,
3194 0x000E, 0x0005, 0x0004, 0x0006, 0x0007, 0x001D, 0x0017, 0x000F,
3195 0x01C3, 0x01C1, 0x0380, 0x381F, 0x381E, 0x1C0D, 0x1C0C, 0x0001,
3196 0x0004, 0x0018, 0x0001, 0x0000, 0x000D, 0x0016, 0x0019, 0x0039
3198 0x0002, 0x001E, 0x003B, 0x000D, 0x0061, 0x01FA, 0x1FB5, 0x0031,
3199 0x00FC, 0x0004, 0x0005, 0x0001, 0x0007, 0x003A, 0x0060, 0x03F7,
3200 0x07EC, 0x1FB7, 0x3F6C, 0x7EDB, 0x7EDA, 0x3F69, 0x3F68, 0x0001,
3201 0x0000, 0x0019, 0x003E, 0x0039, 0x000D, 0x0038, 0x000C, 0x007F
3203 0x001E, 0x0070, 0x0127, 0x0126, 0x0492, 0x124D, 0x124C, 0x0001,
3204 0x007F, 0x0006, 0x0005, 0x0005, 0x0004, 0x0001, 0x0007, 0x0025,
3205 0x0071, 0x007E, 0x0048, 0x0125, 0x0248, 0x124F, 0x124E, 0x0003,
3206 0x0008, 0x001D, 0x0006, 0x003E, 0x0002, 0x0000, 0x0013, 0x0039
3208 0x0001, 0x0001, 0x00E7, 0x0091, 0x0240, 0x120D, 0x120C, 0x003C,
3209 0x0000, 0x0006, 0x0005, 0x0005, 0x0004, 0x001F, 0x0004, 0x0025,
3210 0x0072, 0x0049, 0x00E6, 0x0121, 0x0482, 0x120F, 0x120E, 0x0003,
3211 0x0008, 0x001D, 0x0005, 0x003D, 0x0003, 0x0001, 0x0013, 0x0038
3213 0x0004, 0x000F, 0x00F4, 0x005B, 0x02D3, 0x0B4A, 0x1697, 0x003C,
3214 0x000E, 0x0006, 0x0005, 0x0002, 0x0001, 0x001D, 0x0000, 0x007B,
3215 0x002C, 0x00F5, 0x00B5, 0x0168, 0x1696, 0x0B49, 0x0B48, 0x0003,
3216 0x0009, 0x001F, 0x000A, 0x0001, 0x0008, 0x0006, 0x001C, 0x0017
3218 0x0008, 0x0039, 0x001A, 0x0003, 0x00DB, 0x06D6, 0x0DAF, 0x003C,
3219 0x000C, 0x0006, 0x0005, 0x0002, 0x0001, 0x001D, 0x003D, 0x0000,
3220 0x0002, 0x0037, 0x006C, 0x01B4, 0x0DAE, 0x06D5, 0x06D4, 0x0002,
3221 0x0007, 0x001F, 0x0007, 0x0001, 0x0009, 0x000D, 0x000C, 0x0038
3223 0x000F, 0x0004, 0x002F, 0x002E, 0x0054, 0x0555, 0x0554, 0x0016,
3224 0x000E, 0x0006, 0x0005, 0x0001, 0x0000, 0x0009, 0x000B, 0x0014,
3225 0x0057, 0x0056, 0x00AB, 0x0557, 0x0556, 0x02A9, 0x02A8, 0x0003,
3226 0x0008, 0x0013, 0x000A, 0x0008, 0x000E, 0x0012, 0x0006, 0x000F
3228 0x0001, 0x000E, 0x0006, 0x0004, 0x00DA, 0x0DBE, 0x1B7E, 0x0007,
3229 0x001A, 0x0005, 0x0004, 0x001C, 0x001B, 0x003A, 0x0037, 0x006C,
3230 0x01B6, 0x036E, 0x0DBD, 0x36FF, 0x36FE, 0x1B79, 0x1B78, 0x0002,
3231 0x000C, 0x0000, 0x000F, 0x000C, 0x000F, 0x001A, 0x003B, 0x0005
3233 0x0005, 0x001E, 0x003A, 0x003E, 0x00FC, 0x0FD7, 0x3F55, 0x0077,
3234 0x0030, 0x0003, 0x0004, 0x001A, 0x0019, 0x007F, 0x01FB, 0x03F4,
3235 0x0FD6, 0x1FA9, 0x3F54, 0x3F57, 0x3F56, 0x3F51, 0x3F50, 0x0001,
3236 0x0004, 0x001C, 0x000B, 0x000A, 0x0000, 0x001B, 0x0031, 0x0076
3238 0x0005, 0x000C, 0x001B, 0x0008, 0x0038, 0x0015, 0x00A3, 0x00E6,
3239 0x0004, 0x0001, 0x0002, 0x0012, 0x0003, 0x000B, 0x0029, 0x00A0,
3240 0x0142, 0x0287, 0x0286, 0x0289, 0x0288, 0x028B, 0x028A, 0x000F,
3241 0x001D, 0x0013, 0x0001, 0x0000, 0x0003, 0x001A, 0x0072, 0x00E7
3244 const VP40_AC_CAT1_BITS: [[u8; 32]; 16] = [
3246 5, 8, 9, 11, 13, 13, 13, 5, 8, 3, 3, 4, 4, 4, 4, 4,
3247 5, 5, 4, 5, 7, 10, 13, 4, 5, 6, 6, 7, 6, 8, 5, 6
3249 5, 7, 9, 10, 12, 13, 14, 5, 8, 3, 3, 4, 4, 3, 4, 5,
3250 5, 5, 5, 6, 8, 11, 14, 4, 5, 6, 6, 7, 5, 8, 5, 6
3252 5, 7, 8, 9, 11, 13, 13, 5, 8, 3, 3, 4, 4, 4, 4, 5,
3253 5, 5, 5, 7, 10, 13, 13, 3, 5, 6, 6, 6, 5, 8, 5, 6
3255 4, 7, 8, 9, 11, 13, 13, 5, 8, 3, 3, 4, 4, 4, 4, 5,
3256 6, 6, 6, 8, 10, 13, 13, 3, 5, 5, 6, 6, 5, 7, 5, 6
3258 4, 6, 8, 8, 10, 12, 13, 5, 8, 3, 3, 4, 4, 4, 5, 5,
3259 6, 6, 7, 9, 13, 12, 12, 3, 5, 5, 6, 6, 4, 7, 5, 6
3261 4, 6, 7, 7, 10, 13, 14, 5, 8, 3, 3, 4, 4, 4, 5, 6,
3262 7, 7, 9, 11, 14, 13, 13, 3, 4, 5, 6, 6, 4, 7, 5, 6
3264 4, 5, 7, 6, 9, 11, 13, 5, 7, 3, 3, 4, 4, 5, 6, 7,
3265 9, 9, 10, 14, 14, 13, 13, 3, 4, 5, 5, 5, 4, 6, 5, 6
3267 3, 5, 6, 5, 7, 9, 13, 6, 8, 3, 3, 4, 4, 6, 7, 10,
3268 11, 13, 14, 15, 15, 14, 14, 3, 4, 5, 6, 6, 4, 6, 5, 7
3270 5, 7, 9, 9, 11, 13, 13, 5, 7, 3, 3, 4, 4, 4, 5, 6,
3271 7, 7, 7, 9, 10, 13, 13, 3, 4, 5, 5, 6, 4, 5, 5, 6
3273 4, 6, 8, 8, 10, 13, 13, 6, 6, 3, 3, 4, 4, 5, 5, 6,
3274 7, 7, 8, 9, 11, 13, 13, 3, 4, 5, 5, 6, 4, 5, 5, 6
3276 4, 6, 8, 8, 11, 13, 14, 6, 6, 3, 3, 4, 4, 5, 5, 7,
3277 7, 8, 9, 10, 14, 13, 13, 3, 4, 5, 5, 5, 4, 5, 5, 6
3279 4, 6, 7, 7, 10, 13, 14, 6, 6, 3, 3, 4, 4, 5, 6, 6,
3280 7, 8, 9, 11, 14, 13, 13, 3, 4, 5, 5, 5, 4, 5, 5, 6
3282 4, 5, 7, 7, 9, 13, 13, 6, 6, 3, 3, 4, 4, 5, 6, 7,
3283 9, 9, 10, 13, 13, 12, 12, 3, 4, 5, 5, 5, 4, 5, 5, 6
3285 3, 5, 6, 6, 9, 13, 14, 6, 6, 3, 3, 5, 5, 6, 7, 8,
3286 10, 11, 13, 15, 15, 14, 14, 3, 4, 4, 5, 5, 4, 5, 6, 6
3288 3, 5, 6, 6, 8, 12, 14, 7, 6, 3, 3, 5, 5, 7, 9, 10,
3289 12, 13, 14, 14, 14, 14, 14, 3, 4, 5, 5, 5, 3, 5, 6, 7
3291 3, 4, 5, 4, 6, 8, 11, 8, 6, 3, 3, 5, 5, 7, 9, 11,
3292 12, 13, 13, 13, 13, 13, 13, 4, 5, 5, 5, 5, 3, 5, 7, 8
3295 const VP40_AC_CAT2_CODES: [[u32; 32]; 16] = [
3297 0x0009, 0x0015, 0x0028, 0x0052, 0x029A, 0x0537, 0x0536, 0x000A,
3298 0x0054, 0x0004, 0x0003, 0x000C, 0x000B, 0x000D, 0x0003, 0x0014,
3299 0x003A, 0x0004, 0x0038, 0x0055, 0x00A7, 0x0299, 0x0298, 0x0000,
3300 0x001E, 0x0008, 0x002B, 0x000B, 0x000B, 0x003B, 0x001F, 0x0039
3302 0x001D, 0x002F, 0x0002, 0x0007, 0x0019, 0x0035, 0x0034, 0x0009,
3303 0x002E, 0x0006, 0x0005, 0x0009, 0x0008, 0x0007, 0x001F, 0x0008,
3304 0x0018, 0x0019, 0x0001, 0x0000, 0x0018, 0x0037, 0x0036, 0x0001,
3305 0x0001, 0x000A, 0x0039, 0x0016, 0x000D, 0x0001, 0x001E, 0x0038
3307 0x0001, 0x0071, 0x00E0, 0x01C3, 0x0708, 0x1C26, 0x384F, 0x0001,
3308 0x0031, 0x0006, 0x0005, 0x0009, 0x0008, 0x0005, 0x000F, 0x0039,
3309 0x0077, 0x0076, 0x0030, 0x0385, 0x384E, 0x1C25, 0x1C24, 0x0001,
3310 0x0004, 0x000D, 0x0000, 0x0019, 0x001F, 0x000E, 0x001E, 0x003A
3312 0x0006, 0x000C, 0x00D6, 0x007B, 0x01E8, 0x07A4, 0x0F4B, 0x0036,
3313 0x006A, 0x0007, 0x0005, 0x0008, 0x0009, 0x0001, 0x0007, 0x000D,
3314 0x003C, 0x00D7, 0x00F5, 0x07A7, 0x0F4A, 0x0F4D, 0x0F4C, 0x0002,
3315 0x0002, 0x000E, 0x0037, 0x0034, 0x0000, 0x0019, 0x0018, 0x001F
3317 0x000A, 0x0027, 0x00BF, 0x00BE, 0x0224, 0x225D, 0x225C, 0x0026,
3318 0x005E, 0x0007, 0x0006, 0x0006, 0x0007, 0x0016, 0x002E, 0x0045,
3319 0x0088, 0x0113, 0x044A, 0x225F, 0x225E, 0x112D, 0x112C, 0x0002,
3320 0x0002, 0x0012, 0x0003, 0x0002, 0x0003, 0x0000, 0x0010, 0x0023
3322 0x000F, 0x0006, 0x0075, 0x0074, 0x000A, 0x00BF, 0x00B9, 0x0022,
3323 0x0003, 0x0005, 0x0006, 0x0001, 0x0002, 0x0007, 0x0000, 0x0004,
3324 0x0016, 0x005E, 0x00B8, 0x00BB, 0x00BA, 0x017D, 0x017C, 0x0002,
3325 0x0006, 0x001C, 0x0010, 0x003B, 0x0009, 0x0007, 0x0001, 0x0023
3327 0x0001, 0x001C, 0x0036, 0x003B, 0x00EA, 0x075B, 0x1D65, 0x0019,
3328 0x0074, 0x0004, 0x0005, 0x0000, 0x0001, 0x0037, 0x01D7, 0x075A,
3329 0x1D64, 0x1D67, 0x1D66, 0x1D61, 0x1D60, 0x1D63, 0x1D62, 0x0002,
3330 0x001F, 0x001A, 0x000D, 0x003D, 0x000C, 0x0007, 0x003C, 0x0018
3332 0x0002, 0x0001, 0x0014, 0x0000, 0x002F, 0x00BB, 0x02E4, 0x007D,
3333 0x00BA, 0x0003, 0x0004, 0x0016, 0x001A, 0x00B8, 0x172E, 0x2E5F,
3334 0x2E5E, 0x1729, 0x1728, 0x172B, 0x172A, 0x172D, 0x172C, 0x0001,
3335 0x001E, 0x0015, 0x001B, 0x003F, 0x000C, 0x000E, 0x007C, 0x0173
3337 0x0003, 0x007B, 0x0058, 0x01EA, 0x1EB1, 0x1EB0, 0x1EB3, 0x0013,
3338 0x0012, 0x0005, 0x0006, 0x0002, 0x0001, 0x0013, 0x003C, 0x002D,
3339 0x00F4, 0x0059, 0x03D7, 0x0F5B, 0x1EB2, 0x1EB5, 0x1EB4, 0x0003,
3340 0x000E, 0x001F, 0x0012, 0x0008, 0x0008, 0x0000, 0x000A, 0x0017
3342 0x0008, 0x003C, 0x00F5, 0x00F4, 0x1EF7, 0x3DE9, 0x3DE8, 0x001C,
3343 0x000D, 0x0005, 0x0006, 0x0001, 0x0000, 0x0007, 0x000C, 0x00F6,
3344 0x01EE, 0x03DF, 0x07BC, 0x3DEB, 0x3DEA, 0x3DED, 0x3DEC, 0x0002,
3345 0x0009, 0x001F, 0x000F, 0x0005, 0x000E, 0x0006, 0x0004, 0x001D
3347 0x0009, 0x0039, 0x0019, 0x0018, 0x0706, 0x383D, 0x383C, 0x000D,
3348 0x000F, 0x0005, 0x0006, 0x0000, 0x001D, 0x0003, 0x0071, 0x00E1,
3349 0x01C0, 0x0382, 0x1C1D, 0x383F, 0x383E, 0x3839, 0x3838, 0x0002,
3350 0x0008, 0x0002, 0x000D, 0x000C, 0x000F, 0x0007, 0x0002, 0x000E
3352 0x0000, 0x0006, 0x0035, 0x0034, 0x0777, 0x1DD4, 0x3BAB, 0x000E,
3353 0x000F, 0x0005, 0x0004, 0x001C, 0x0019, 0x003A, 0x00EF, 0x01DC,
3354 0x0776, 0x0774, 0x3BAA, 0x3BAD, 0x3BAC, 0x3BAF, 0x3BAE, 0x0002,
3355 0x0007, 0x0002, 0x0018, 0x000C, 0x000F, 0x000D, 0x001B, 0x0076
3357 0x0002, 0x0011, 0x0006, 0x004F, 0x0130, 0x1319, 0x1318, 0x004E,
3358 0x0007, 0x0006, 0x0005, 0x0010, 0x000D, 0x0005, 0x0099, 0x0262,
3359 0x098E, 0x131B, 0x131A, 0x263D, 0x263C, 0x263F, 0x263E, 0x0001,
3360 0x0007, 0x0000, 0x0012, 0x000C, 0x000E, 0x000F, 0x0004, 0x004D
3362 0x0003, 0x0000, 0x0002, 0x0037, 0x01B7, 0x0DB5, 0x36DD, 0x006C,
3363 0x0016, 0x0005, 0x0004, 0x0003, 0x000A, 0x002E, 0x036C, 0x0DB4,
3364 0x36DC, 0x36DF, 0x36DE, 0x36D9, 0x36D8, 0x36DB, 0x36DA, 0x000E,
3365 0x0004, 0x001A, 0x0019, 0x0018, 0x000F, 0x0001, 0x002F, 0x00DA
3367 0x0006, 0x0006, 0x000F, 0x0000, 0x0075, 0x03B8, 0x1DCA, 0x0074,
3368 0x0076, 0x0004, 0x0005, 0x0003, 0x0002, 0x01DE, 0x0EE6, 0x3B97,
3369 0x3B96, 0x3B9D, 0x3B9C, 0x3B9F, 0x3B9E, 0x1DC9, 0x1DC8, 0x0005,
3370 0x001C, 0x0009, 0x000E, 0x0008, 0x000F, 0x0001, 0x01DF, 0x01DD
3372 0x0004, 0x000B, 0x001D, 0x000C, 0x0014, 0x00E0, 0x3875, 0x0386,
3373 0x01C2, 0x0000, 0x0001, 0x0071, 0x0072, 0x1C3F, 0x3874, 0x3877,
3374 0x3876, 0x3871, 0x3870, 0x3873, 0x3872, 0x3879, 0x3878, 0x003C,
3375 0x0073, 0x002A, 0x003D, 0x002B, 0x001F, 0x000D, 0x1C3E, 0x1C3D
3378 const VP40_AC_CAT2_BITS: [[u8; 32]; 16] = [
3380 5, 7, 8, 9, 12, 13, 13, 5, 7, 3, 3, 4, 4, 4, 4, 5,
3381 6, 5, 6, 7, 10, 12, 12, 3, 5, 5, 6, 6, 5, 6, 5, 6
3383 5, 7, 8, 9, 11, 12, 12, 5, 7, 3, 3, 4, 4, 4, 5, 5,
3384 6, 6, 6, 7, 11, 12, 12, 3, 4, 5, 6, 6, 5, 5, 5, 6
3386 4, 7, 8, 9, 11, 13, 14, 5, 7, 3, 3, 4, 4, 4, 5, 6,
3387 7, 7, 7, 10, 14, 13, 13, 3, 4, 5, 5, 6, 5, 5, 5, 6
3389 4, 6, 8, 8, 10, 12, 13, 6, 7, 3, 3, 4, 4, 4, 5, 6,
3390 7, 8, 9, 12, 13, 13, 13, 3, 4, 5, 6, 6, 4, 5, 5, 6
3392 4, 6, 8, 8, 10, 14, 14, 6, 7, 3, 3, 4, 4, 5, 6, 7,
3393 8, 9, 11, 14, 14, 13, 13, 3, 4, 5, 5, 5, 4, 4, 5, 6
3395 4, 5, 7, 7, 9, 13, 13, 6, 7, 3, 3, 4, 4, 5, 6, 8,
3396 10, 12, 13, 13, 13, 14, 14, 3, 4, 5, 5, 6, 4, 4, 5, 6
3398 3, 5, 6, 6, 8, 11, 13, 6, 7, 3, 3, 4, 4, 6, 9, 11,
3399 13, 13, 13, 13, 13, 13, 13, 3, 5, 5, 5, 6, 4, 4, 6, 6
3401 3, 4, 5, 4, 6, 8, 10, 7, 8, 3, 3, 5, 5, 8, 13, 14,
3402 14, 13, 13, 13, 13, 13, 13, 3, 5, 5, 5, 6, 4, 4, 7, 9
3404 4, 7, 8, 9, 13, 13, 13, 6, 6, 3, 3, 4, 4, 5, 6, 7,
3405 8, 8, 10, 12, 13, 13, 13, 3, 4, 5, 5, 5, 4, 4, 5, 6
3407 4, 6, 8, 8, 13, 14, 14, 6, 6, 3, 3, 4, 4, 5, 6, 8,
3408 9, 10, 11, 14, 14, 14, 14, 3, 4, 5, 5, 5, 4, 4, 5, 6
3410 4, 6, 7, 7, 11, 14, 14, 6, 6, 3, 3, 4, 5, 5, 7, 8,
3411 9, 10, 13, 14, 14, 14, 14, 3, 4, 4, 5, 5, 4, 4, 5, 6
3413 3, 5, 7, 7, 11, 13, 14, 6, 6, 3, 3, 5, 5, 6, 8, 9,
3414 11, 11, 14, 14, 14, 14, 14, 3, 4, 4, 5, 5, 4, 4, 6, 7
3416 3, 5, 6, 7, 9, 13, 13, 7, 6, 3, 3, 5, 5, 6, 8, 10,
3417 12, 13, 13, 14, 14, 14, 14, 3, 4, 4, 5, 5, 4, 4, 6, 7
3419 3, 4, 5, 6, 9, 12, 14, 7, 6, 3, 3, 5, 5, 7, 10, 12,
3420 14, 14, 14, 14, 14, 14, 14, 4, 4, 5, 5, 5, 4, 3, 7, 8
3422 3, 4, 5, 4, 7, 10, 13, 7, 7, 3, 3, 5, 5, 9, 12, 14,
3423 14, 14, 14, 14, 14, 13, 13, 4, 5, 5, 5, 5, 4, 3, 9, 9
3425 3, 4, 5, 4, 5, 8, 14, 10, 9, 2, 2, 7, 7, 13, 14, 14,
3426 14, 14, 14, 14, 14, 14, 14, 6, 7, 6, 6, 6, 5, 4, 13, 13
3429 const VP40_AC_CAT3_CODES: [[u32; 32]; 16] = [
3431 0x0007, 0x000F, 0x00BB, 0x00BA, 0x05CF, 0x173A, 0x2E77, 0x0029,
3432 0x0172, 0x0007, 0x0006, 0x0009, 0x0008, 0x0001, 0x0005, 0x000D,
3433 0x001D, 0x001C, 0x00B8, 0x02E6, 0x2E76, 0x1739, 0x1738, 0x0002,
3434 0x0006, 0x0016, 0x0004, 0x0028, 0x0015, 0x000C, 0x0000, 0x002F
3436 0x000B, 0x0002, 0x0054, 0x002F, 0x02AC, 0x156B, 0x1568, 0x0016,
3437 0x0154, 0x0007, 0x0006, 0x0004, 0x0003, 0x0013, 0x0028, 0x002E,
3438 0x0157, 0x0155, 0x055B, 0x2AD3, 0x2AD2, 0x2AD5, 0x2AD4, 0x0003,
3439 0x0008, 0x0000, 0x000A, 0x0003, 0x0002, 0x002B, 0x0012, 0x0029
3441 0x000F, 0x0007, 0x0001, 0x0000, 0x01C4, 0x0703, 0x0E02, 0x0011,
3442 0x00E1, 0x0005, 0x0006, 0x0002, 0x0001, 0x0009, 0x0010, 0x00E3,
3443 0x01C5, 0x01C1, 0x0702, 0x1C07, 0x1C06, 0x0E01, 0x0E00, 0x0004,
3444 0x0007, 0x001D, 0x000D, 0x0001, 0x0005, 0x0006, 0x000C, 0x0039
3446 0x0001, 0x001C, 0x0011, 0x0013, 0x0042, 0x0207, 0x0815, 0x0075,
3447 0x0041, 0x0005, 0x0006, 0x0000, 0x001F, 0x003B, 0x0074, 0x0043,
3448 0x0080, 0x0206, 0x0814, 0x0817, 0x0816, 0x0409, 0x0408, 0x0003,
3449 0x0009, 0x001E, 0x0011, 0x0003, 0x0005, 0x0010, 0x0002, 0x0012
3451 0x0001, 0x001F, 0x0027, 0x0001, 0x004B, 0x0123, 0x0915, 0x0000,
3452 0x0049, 0x0005, 0x0006, 0x001D, 0x001C, 0x0013, 0x004A, 0x0090,
3453 0x0914, 0x0917, 0x0916, 0x0911, 0x0910, 0x0913, 0x0912, 0x0003,
3454 0x0005, 0x0001, 0x0012, 0x0008, 0x0008, 0x001E, 0x0026, 0x0001
3456 0x0003, 0x0001, 0x003F, 0x000B, 0x004E, 0x0132, 0x099A, 0x004F,
3457 0x0098, 0x0006, 0x0005, 0x001D, 0x001C, 0x007C, 0x0267, 0x1331,
3458 0x1330, 0x1333, 0x1332, 0x266D, 0x266C, 0x266F, 0x266E, 0x0001,
3459 0x0004, 0x001E, 0x0012, 0x000A, 0x0008, 0x0000, 0x007D, 0x004D
3461 0x0002, 0x0007, 0x0015, 0x0003, 0x0004, 0x00A7, 0x0536, 0x0028,
3462 0x029A, 0x0006, 0x0004, 0x001C, 0x0017, 0x00A4, 0x29BE, 0x537F,
3463 0x537E, 0x29B9, 0x29B8, 0x29BB, 0x29BA, 0x29BD, 0x29BC, 0x000F,
3464 0x0000, 0x0005, 0x0016, 0x001D, 0x0006, 0x0001, 0x00A5, 0x014C
3466 0x0004, 0x0007, 0x001A, 0x000C, 0x0006, 0x0029, 0x01BD, 0x1BE3,
3467 0x1BE0, 0x0000, 0x0007, 0x006E, 0x01BC, 0x37C3, 0x37C2, 0x37CD,
3468 0x37CC, 0x37CF, 0x37CE, 0x37C9, 0x37C8, 0x37CB, 0x37CA, 0x0015,
3469 0x01BF, 0x037D, 0x0036, 0x0002, 0x000B, 0x0028, 0x37C5, 0x37C4
3471 0x0001, 0x0009, 0x0003, 0x0002, 0x011F, 0x08E9, 0x08E8, 0x002D,
3472 0x0022, 0x0006, 0x0007, 0x0010, 0x0011, 0x0017, 0x002C, 0x0046,
3473 0x011E, 0x011C, 0x0477, 0x08EB, 0x08EA, 0x08ED, 0x08EC, 0x0003,
3474 0x000B, 0x0001, 0x0014, 0x000A, 0x0009, 0x0015, 0x0000, 0x0010
3476 0x0001, 0x001D, 0x0022, 0x0013, 0x011E, 0x08FC, 0x23F5, 0x0023,
3477 0x0022, 0x0005, 0x0006, 0x0010, 0x000B, 0x0010, 0x008E, 0x023E,
3478 0x08FF, 0x11FD, 0x23F4, 0x23F7, 0x23F6, 0x23F9, 0x23F8, 0x0003,
3479 0x0009, 0x0000, 0x001C, 0x000A, 0x000F, 0x0001, 0x0012, 0x0046
3481 0x0003, 0x001F, 0x003C, 0x003D, 0x0086, 0x0877, 0x10E8, 0x0041,
3482 0x0040, 0x0005, 0x0006, 0x0007, 0x0006, 0x0004, 0x010F, 0x021C,
3483 0x0875, 0x21D3, 0x21D2, 0x21D9, 0x21D8, 0x21DB, 0x21DA, 0x0002,
3484 0x0009, 0x0000, 0x0011, 0x0003, 0x000E, 0x0002, 0x0005, 0x0042
3486 0x0004, 0x0001, 0x003D, 0x0009, 0x00F3, 0x0793, 0x1E45, 0x0000,
3487 0x0002, 0x0005, 0x0006, 0x0008, 0x0001, 0x0003, 0x01E5, 0x0792,
3488 0x1E44, 0x1E47, 0x1E46, 0x1E41, 0x1E40, 0x1E43, 0x1E42, 0x0001,
3489 0x0006, 0x001F, 0x000F, 0x000E, 0x000E, 0x0005, 0x0078, 0x0001
3491 0x0004, 0x0005, 0x000E, 0x0017, 0x003E, 0x00F0, 0x0F1E, 0x007A,
3492 0x007F, 0x0006, 0x0007, 0x0005, 0x0004, 0x007B, 0x01E2, 0x1E3F,
3493 0x1E3E, 0x0F19, 0x0F18, 0x0F1B, 0x0F1A, 0x0F1D, 0x0F1C, 0x0000,
3494 0x0003, 0x0016, 0x0009, 0x0008, 0x000A, 0x0006, 0x007E, 0x0079
3496 0x0005, 0x000C, 0x001A, 0x0004, 0x001A, 0x00DE, 0x0DF4, 0x00DD,
3497 0x006D, 0x0000, 0x0007, 0x0025, 0x0024, 0x00DC, 0x0DF7, 0x1BEB,
3498 0x1BEA, 0x0DF1, 0x0DF0, 0x0DF3, 0x0DF2, 0x1BED, 0x1BEC, 0x0008,
3499 0x0013, 0x000C, 0x0037, 0x0036, 0x0005, 0x0007, 0x006C, 0x01BF
3501 0x0005, 0x000D, 0x001F, 0x000C, 0x003B, 0x0040, 0x041A, 0x0104,
3502 0x0107, 0x0001, 0x0000, 0x0024, 0x0021, 0x020B, 0x106E, 0x20DF,
3503 0x20DE, 0x1055, 0x1054, 0x1057, 0x1056, 0x106D, 0x106C, 0x0011,
3504 0x003A, 0x0025, 0x0038, 0x0039, 0x0013, 0x001E, 0x020C, 0x0414
3506 0x0000, 0x0007, 0x000D, 0x0005, 0x0009, 0x0022, 0x0CD1, 0x0CD0,
3507 0x0CD3, 0x0003, 0x0002, 0x008D, 0x00CC, 0x066B, 0x0CD2, 0x19B5,
3508 0x19B4, 0x19B7, 0x19B6, 0x19B1, 0x19B0, 0x19B3, 0x19B2, 0x0047,
3509 0x008C, 0x0337, 0x0067, 0x0018, 0x0010, 0x0032, 0x0CD5, 0x0CD4
3512 const VP40_AC_CAT3_BITS: [[u8; 32]; 16] = [
3514 4, 6, 8, 8, 11, 13, 14, 6, 9, 3, 3, 4, 4, 4, 5, 6,
3515 7, 7, 8, 10, 14, 13, 13, 3, 4, 5, 5, 6, 5, 6, 4, 6
3517 4, 5, 7, 7, 10, 13, 13, 6, 9, 3, 3, 4, 4, 5, 6, 7,
3518 9, 9, 11, 14, 14, 14, 14, 3, 4, 4, 5, 5, 4, 6, 5, 6
3520 4, 5, 6, 6, 9, 11, 12, 6, 8, 3, 3, 4, 4, 5, 6, 8,
3521 9, 9, 11, 13, 13, 12, 12, 3, 4, 5, 5, 5, 4, 5, 5, 6
3523 3, 5, 6, 6, 8, 11, 13, 7, 8, 3, 3, 4, 5, 6, 7, 8,
3524 9, 11, 13, 13, 13, 12, 12, 3, 4, 5, 5, 5, 4, 5, 5, 6
3526 3, 5, 6, 5, 8, 10, 13, 6, 8, 3, 3, 5, 5, 6, 8, 9,
3527 13, 13, 13, 13, 13, 13, 13, 3, 4, 4, 5, 5, 4, 5, 6, 6
3529 3, 4, 6, 5, 7, 9, 12, 7, 8, 3, 3, 5, 5, 7, 10, 13,
3530 13, 13, 13, 14, 14, 14, 14, 3, 4, 5, 5, 5, 4, 4, 7, 7
3532 3, 4, 5, 4, 5, 8, 11, 6, 10, 3, 3, 5, 5, 8, 14, 15,
3533 15, 14, 14, 14, 14, 14, 14, 4, 4, 5, 5, 5, 4, 4, 8, 9
3535 3, 4, 5, 4, 4, 6, 9, 13, 13, 2, 3, 7, 9, 14, 14, 14,
3536 14, 14, 14, 14, 14, 14, 14, 5, 9, 10, 6, 3, 4, 6, 14, 14
3538 3, 5, 6, 6, 10, 13, 13, 7, 7, 3, 3, 5, 5, 6, 7, 8,
3539 10, 10, 12, 13, 13, 13, 13, 3, 4, 4, 5, 5, 4, 5, 5, 6
3541 3, 5, 6, 6, 9, 12, 14, 7, 7, 3, 3, 5, 5, 6, 8, 10,
3542 12, 13, 14, 14, 14, 14, 14, 3, 4, 4, 5, 5, 4, 4, 6, 7
3544 3, 5, 6, 6, 8, 12, 13, 7, 7, 3, 3, 5, 5, 6, 9, 10,
3545 12, 14, 14, 14, 14, 14, 14, 3, 4, 4, 5, 5, 4, 4, 6, 7
3547 3, 4, 6, 5, 8, 11, 13, 7, 7, 3, 3, 5, 5, 7, 9, 11,
3548 13, 13, 13, 13, 13, 13, 13, 3, 4, 5, 5, 5, 4, 4, 7, 7
3550 3, 4, 5, 5, 7, 9, 13, 8, 8, 3, 3, 5, 5, 8, 10, 14,
3551 14, 13, 13, 13, 13, 13, 13, 3, 4, 5, 5, 5, 4, 4, 8, 8
3553 3, 4, 5, 4, 6, 9, 13, 9, 8, 2, 3, 6, 6, 9, 13, 14,
3554 14, 13, 13, 13, 13, 14, 14, 4, 5, 5, 6, 6, 4, 4, 8, 10
3556 3, 4, 5, 4, 6, 7, 11, 9, 9, 2, 2, 6, 6, 10, 13, 14,
3557 14, 13, 13, 13, 13, 13, 13, 5, 6, 6, 6, 6, 5, 5, 10, 11
3559 2, 4, 5, 4, 5, 7, 13, 13, 13, 2, 2, 9, 9, 12, 13, 14,
3560 14, 14, 14, 14, 14, 14, 14, 8, 9, 11, 8, 6, 6, 7, 13, 13
3564 const VP40_QMAT: &[i16; 64] = &[
3565 16, 17, 18, 20, 22, 24, 26, 28,
3566 17, 18, 20, 22, 24, 26, 28, 32,
3567 18, 20, 22, 24, 26, 28, 32, 36,
3568 20, 22, 24, 26, 28, 32, 36, 40,
3569 22, 24, 26, 28, 32, 36, 40, 44,
3570 24, 26, 28, 32, 36, 40, 44, 48,
3571 26, 28, 32, 36, 40, 44, 48, 52,
3572 28, 32, 36, 40, 44, 48, 52, 56
3574 const VP40_DC_Y_SCALES: [i16; 64] = [
3575 180, 180, 180, 180, 180, 180, 175, 170,
3576 165, 160, 157, 155, 152, 150, 147, 145,
3577 142, 140, 137, 135, 132, 130, 127, 125,
3578 122, 120, 117, 115, 112, 110, 107, 105,
3579 102, 100, 97, 95, 92, 90, 87, 85,
3580 82, 80, 77, 75, 72, 70, 67, 65,
3581 62, 60, 57, 55, 52, 50, 47, 45,
3582 42, 40, 37, 35, 32, 30, 27, 25
3584 const VP40_DC_C_SCALES: [i16; 64] = [
3585 150, 150, 150, 150, 150, 150, 150, 150,
3586 150, 150, 150, 150, 150, 150, 147, 145,
3587 142, 140, 137, 135, 132, 130, 127, 125,
3588 122, 120, 117, 115, 112, 110, 107, 105,
3589 102, 100, 97, 95, 92, 90, 87, 85,
3590 82, 80, 77, 75, 72, 70, 67, 65,
3591 62, 60, 57, 55, 52, 50, 47, 45,
3592 42, 40, 37, 35, 32, 30, 27, 25
3594 const VP40_AC_SCALES: [i16; 64] = [
3595 500, 475, 450, 430, 410, 390, 370, 350,
3596 330, 315, 300, 285, 270, 260, 250, 240,
3597 230, 220, 210, 200, 190, 185, 180, 170,
3598 160, 150, 143, 135, 128, 120, 113, 106,
3599 100, 94, 90, 85, 80, 75, 70, 66,
3600 62, 57, 52, 49, 45, 41, 38, 35,
3601 33, 30, 27, 24, 22, 20, 18, 16,
3602 14, 12, 10, 9, 7, 6, 4, 1
3605 const VP40_MBPAT_CODES: [[u8; 14]; 2] = [
3606 [ 0b000, 0b1111, 0b1001, 0b010, 0b1101, 0b01110, 0b1011, 0b001, 0b01111, 0b1000, 0b0110, 0b1110, 0b1100, 0b1010 ],
3607 [ 0b0111, 0b1010, 0b1001, 0b1100, 0b1000, 0b01101, 0b000, 0b1110, 0b01100, 0b1101, 0b001, 0b1011, 0b1111, 0b010 ]
3609 const VP40_MBPAT_BITS: [[u8; 14]; 2] = [
3610 [ 3, 4, 4, 3, 4, 5, 4, 3, 5, 4, 4, 4, 4, 4 ],
3611 [ 4, 4, 4, 4, 4, 5, 3, 4, 5, 4, 3, 4, 4, 3 ]
3613 const VP40_BP_PREDICTOR: [u8; 15] = [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1 ];
3614 const VP40_MV_X_CODES: [[u32; 63]; 7] = [
3616 0x06A, 0x11A, 0x18E, 0x237, 0x04A, 0x236, 0x07A, 0x0D6,
3617 0x07E, 0x1FD, 0x08C, 0x0D7, 0x087, 0x183, 0x03C, 0x061,
3618 0x047, 0x069, 0x040, 0x048, 0x049, 0x086, 0x013, 0x0D2,
3619 0x01C, 0x042, 0x025, 0x01B, 0x013, 0x005, 0x000, 0x007,
3620 0x005, 0x01B, 0x019, 0x019, 0x008, 0x045, 0x01D, 0x0C6,
3621 0x068, 0x090, 0x041, 0x04B, 0x031, 0x18F, 0x062, 0x03E,
3622 0x044, 0x068, 0x030, 0x182, 0x0C0, 0x1A7, 0x091, 0x092,
3623 0x07B, 0x0FF, 0x1A6, 0x1FC, 0x06A, 0x093, 0x06B
3625 0x039, 0x259, 0x01B, 0x1D1, 0x137, 0x1D0, 0x01A, 0x1B5,
3626 0x01D, 0x4BC, 0x06C, 0x038, 0x071, 0x02D, 0x07D, 0x075,
3627 0x019, 0x0E9, 0x037, 0x015, 0x01E, 0x0DB, 0x04C, 0x070,
3628 0x00D, 0x00C, 0x027, 0x004, 0x002, 0x000, 0x005, 0x007,
3629 0x006, 0x002, 0x008, 0x024, 0x00C, 0x03B, 0x01E, 0x09A,
3630 0x00E, 0x069, 0x04A, 0x12D, 0x035, 0x0F9, 0x018, 0x07F,
3631 0x00F, 0x0F8, 0x07E, 0x25F, 0x068, 0x02C, 0x014, 0x258,
3632 0x136, 0x4BD, 0x12E, 0x1B4, 0x017, 0x039, 0x01F
3634 0x029, 0x3CB, 0x1F5, 0x263, 0x1F4, 0x3DA, 0x050, 0x260,
3635 0x1EC, 0x3D3, 0x109, 0x3D2, 0x051, 0x792, 0x0F3, 0x09A,
3636 0x0F7, 0x132, 0x0C1, 0x1E8, 0x02A, 0x085, 0x061, 0x1F7,
3637 0x078, 0x0C7, 0x023, 0x07C, 0x012, 0x00B, 0x00E, 0x00D,
3638 0x000, 0x005, 0x003, 0x004, 0x019, 0x020, 0x03F, 0x043,
3639 0x062, 0x09F, 0x04E, 0x181, 0x02B, 0x137, 0x0F5, 0x089,
3640 0x0C6, 0x262, 0x088, 0x3C8, 0x1F6, 0x3CA, 0x09E, 0x261,
3641 0x136, 0x108, 0x133, 0x793, 0x180, 0x3DB, 0x045
3643 0x001, 0x1C7, 0x067, 0x0B5, 0x066, 0x139, 0x099, 0x0B4,
3644 0x0C3, 0x130, 0x000, 0x131, 0x09E, 0x0B7, 0x02C, 0x001,
3645 0x028, 0x138, 0x04B, 0x031, 0x060, 0x091, 0x003, 0x09D,
3646 0x017, 0x04D, 0x031, 0x070, 0x007, 0x03A, 0x007, 0x002,
3647 0x00B, 0x001, 0x00F, 0x008, 0x00D, 0x004, 0x00A, 0x00D,
3648 0x019, 0x002, 0x03B, 0x04A, 0x015, 0x0C2, 0x018, 0x032,
3649 0x072, 0x1C6, 0x029, 0x1C5, 0x049, 0x121, 0x01B, 0x030,
3650 0x01A, 0x1C4, 0x09F, 0x0B6, 0x019, 0x120, 0x073
3652 0x023, 0x1C8, 0x043, 0x110, 0x00C, 0x153, 0x022, 0x111,
3653 0x00F, 0x042, 0x023, 0x1C9, 0x02A, 0x01B, 0x073, 0x045,
3654 0x06E, 0x089, 0x06C, 0x01A, 0x06F, 0x0B6, 0x00B, 0x0E5,
3655 0x025, 0x020, 0x029, 0x04D, 0x002, 0x014, 0x01A, 0x017,
3656 0x01E, 0x027, 0x018, 0x028, 0x01F, 0x000, 0x006, 0x010,
3657 0x007, 0x00B, 0x003, 0x004, 0x01D, 0x02C, 0x019, 0x02B,
3658 0x009, 0x055, 0x038, 0x00E, 0x024, 0x0A8, 0x00A, 0x099,
3659 0x05A, 0x098, 0x06D, 0x152, 0x02B, 0x0B7, 0x001
3661 0x03D, 0x0B1, 0x0DD, 0x1F6, 0x0C5, 0x188, 0x037, 0x03F,
3662 0x01E, 0x189, 0x00F, 0x03E, 0x06A, 0x1F7, 0x061, 0x079,
3663 0x018, 0x0B0, 0x00E, 0x0B3, 0x00C, 0x0DF, 0x006, 0x0DC,
3664 0x019, 0x0DE, 0x027, 0x00E, 0x01A, 0x063, 0x00F, 0x00E,
3665 0x014, 0x07C, 0x036, 0x06B, 0x03F, 0x060, 0x008, 0x074,
3666 0x009, 0x078, 0x012, 0x00D, 0x015, 0x02D, 0x002, 0x01C,
3667 0x005, 0x03B, 0x000, 0x034, 0x019, 0x026, 0x010, 0x075,
3668 0x002, 0x036, 0x023, 0x0B2, 0x022, 0x0FA, 0x017
3670 0x015, 0x0DD, 0x03E, 0x16E, 0x04C, 0x012, 0x05D, 0x0B6,
3671 0x06F, 0x1F1, 0x069, 0x1F0, 0x01D, 0x16F, 0x002, 0x06B,
3672 0x00C, 0x0DC, 0x068, 0x09B, 0x07D, 0x09A, 0x00D, 0x013,
3673 0x008, 0x0F9, 0x02C, 0x012, 0x033, 0x04F, 0x00D, 0x005,
3674 0x012, 0x03F, 0x032, 0x013, 0x03B, 0x005, 0x02F, 0x05A,
3675 0x03F, 0x01C, 0x03A, 0x008, 0x036, 0x05C, 0x010, 0x000,
3676 0x00C, 0x04E, 0x003, 0x06A, 0x00E, 0x003, 0x014, 0x01E,
3677 0x01C, 0x00F, 0x018, 0x023, 0x01E, 0x022, 0x002
3680 const VP40_MV_X_BITS: [[u8; 63]; 7] = [
3682 7, 9, 9, 10, 8, 10, 8, 9, 8, 10, 8, 9, 8, 9, 7, 7,
3683 7, 8, 7, 8, 7, 8, 6, 8, 6, 7, 6, 6, 5, 4, 2, 3,
3684 3, 5, 5, 6, 5, 7, 6, 8, 7, 8, 7, 8, 7, 9, 7, 7,
3685 7, 8, 7, 9, 8, 9, 8, 9, 8, 9, 9, 10, 8, 9, 7
3687 7, 10, 8, 10, 9, 10, 8, 10, 8, 11, 8, 9, 8, 9, 8, 8,
3688 7, 9, 7, 8, 7, 9, 7, 8, 6, 7, 6, 6, 4, 4, 3, 3,
3689 3, 3, 4, 6, 5, 7, 6, 8, 6, 8, 7, 9, 7, 9, 7, 8,
3690 7, 9, 8, 10, 8, 9, 8, 10, 9, 11, 9, 10, 8, 9, 7
3692 7, 10, 9, 10, 9, 10, 8, 10, 9, 10, 9, 10, 8, 11, 8, 8,
3693 8, 9, 8, 9, 7, 8, 7, 9, 7, 8, 6, 7, 5, 5, 4, 4,
3694 2, 3, 3, 4, 5, 6, 6, 7, 7, 8, 7, 9, 7, 9, 8, 8,
3695 8, 10, 8, 10, 9, 10, 8, 10, 9, 9, 9, 11, 9, 10, 7
3697 6, 9, 8, 9, 8, 9, 8, 9, 8, 9, 7, 9, 8, 9, 7, 7,
3698 7, 9, 7, 8, 7, 8, 6, 8, 6, 7, 6, 7, 5, 6, 4, 4,
3699 4, 4, 4, 4, 4, 4, 4, 5, 5, 6, 6, 7, 6, 8, 6, 7,
3700 7, 9, 7, 9, 7, 9, 7, 8, 7, 9, 8, 9, 7, 9, 7
3702 6, 9, 8, 9, 7, 9, 7, 9, 7, 8, 7, 9, 7, 8, 7, 7,
3703 7, 8, 7, 8, 7, 8, 6, 8, 6, 7, 6, 7, 5, 6, 5, 5,
3704 5, 6, 5, 6, 5, 5, 4, 5, 4, 5, 4, 5, 5, 6, 5, 6,
3705 5, 7, 6, 7, 6, 8, 6, 8, 7, 8, 7, 9, 7, 8, 5
3707 6, 8, 8, 9, 8, 9, 7, 8, 7, 9, 7, 8, 7, 9, 7, 7,
3708 6, 8, 6, 8, 6, 8, 6, 8, 6, 8, 6, 7, 6, 7, 5, 5,
3709 5, 7, 6, 7, 6, 7, 5, 7, 5, 7, 5, 6, 5, 6, 4, 5,
3710 4, 6, 4, 6, 5, 6, 5, 7, 5, 7, 6, 8, 6, 8, 5
3712 5, 8, 7, 9, 7, 8, 7, 8, 7, 9, 7, 9, 7, 9, 6, 7,
3713 6, 8, 7, 8, 7, 8, 6, 8, 6, 8, 6, 7, 6, 7, 5, 5,
3714 5, 7, 6, 7, 6, 6, 6, 7, 6, 7, 6, 7, 6, 7, 5, 5,
3715 5, 7, 5, 7, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 3
3718 const VP40_MV_Y_CODES: [[u32; 63]; 7] = [
3720 0x052, 0x14C, 0x1FA, 0x124, 0x082, 0x29E, 0x08E, 0x24B,
3721 0x09C, 0x3F7, 0x086, 0x114, 0x083, 0x3A5, 0x0FA, 0x04F,
3722 0x0FB, 0x13B, 0x0FC, 0x172, 0x044, 0x173, 0x051, 0x087,
3723 0x05F, 0x0BA, 0x026, 0x05E, 0x016, 0x015, 0x006, 0x001,
3724 0x000, 0x01C, 0x01E, 0x075, 0x03B, 0x0FF, 0x025, 0x0BB,
3725 0x07C, 0x08B, 0x048, 0x171, 0x042, 0x14E, 0x046, 0x0FE,
3726 0x040, 0x13A, 0x093, 0x115, 0x08F, 0x3F6, 0x170, 0x29F,
3727 0x1D1, 0x24A, 0x1D3, 0x3A4, 0x1D0, 0x14D, 0x050
3729 0x0DE, 0x223, 0x136, 0x7C5, 0x12F, 0x4A1, 0x3D7, 0x7AC,
3730 0x133, 0x7C4, 0x1B8, 0x222, 0x096, 0x251, 0x095, 0x1F0,
3731 0x0DA, 0x110, 0x09A, 0x360, 0x0DD, 0x12E, 0x048, 0x092,
3732 0x078, 0x098, 0x027, 0x045, 0x01A, 0x010, 0x005, 0x000,
3733 0x001, 0x00E, 0x00C, 0x023, 0x03F, 0x0F4, 0x07D, 0x089,
3734 0x07B, 0x1BE, 0x0F9, 0x3E3, 0x0F3, 0x127, 0x0DB, 0x1EA,
3735 0x0D9, 0x6E7, 0x1BF, 0x4A0, 0x1B1, 0x6E6, 0x137, 0x7AD,
3736 0x126, 0x6C2, 0x132, 0x6C3, 0x129, 0x372, 0x0F2
3738 0x016, 0x09C, 0x13C, 0x09E, 0x12B, 0x0BA, 0x181, 0x317,
3739 0x084, 0x04E, 0x026, 0x316, 0x180, 0x05C, 0x0C1, 0x02F,
3740 0x010, 0x045, 0x012, 0x189, 0x024, 0x13D, 0x066, 0x023,
3741 0x067, 0x0C6, 0x024, 0x04B, 0x011, 0x032, 0x00D, 0x000,
3742 0x007, 0x005, 0x003, 0x003, 0x005, 0x020, 0x008, 0x025,
3743 0x026, 0x04F, 0x061, 0x02B, 0x04E, 0x18A, 0x043, 0x09F,
3744 0x014, 0x254, 0x094, 0x310, 0x085, 0x311, 0x02A, 0x0BB,
3745 0x18F, 0x255, 0x09D, 0x09F, 0x18E, 0x044, 0x026
3747 0x061, 0x12A, 0x00D, 0x3BD, 0x089, 0x109, 0x18E, 0x210,
3748 0x1D3, 0x211, 0x088, 0x019, 0x085, 0x018, 0x0E8, 0x0CE,
3749 0x040, 0x119, 0x045, 0x1D2, 0x04B, 0x1DD, 0x062, 0x094,
3750 0x075, 0x00C, 0x027, 0x00D, 0x002, 0x026, 0x006, 0x01E,
3751 0x00D, 0x01F, 0x001, 0x00A, 0x002, 0x007, 0x00B, 0x000,
3752 0x01C, 0x076, 0x032, 0x007, 0x024, 0x0C0, 0x007, 0x041,
3753 0x002, 0x18F, 0x047, 0x1DC, 0x043, 0x12B, 0x0CF, 0x118,
3754 0x0C6, 0x3BC, 0x08D, 0x3BF, 0x0C1, 0x3BE, 0x066
3756 0x007, 0x14D, 0x0A0, 0x09E, 0x0CF, 0x39C, 0x0A1, 0x39D,
3757 0x0AB, 0x1C5, 0x026, 0x14C, 0x025, 0x19C, 0x03F, 0x0E1,
3758 0x066, 0x1CF, 0x03E, 0x1C4, 0x072, 0x04E, 0x006, 0x0AA,
3759 0x01C, 0x0E6, 0x032, 0x051, 0x03B, 0x005, 0x01F, 0x018,
3760 0x002, 0x03A, 0x000, 0x036, 0x005, 0x008, 0x008, 0x016,
3761 0x009, 0x00D, 0x003, 0x02F, 0x01E, 0x02E, 0x01A, 0x02B,
3762 0x00C, 0x024, 0x01E, 0x0E0, 0x004, 0x0A7, 0x054, 0x1C7,
3763 0x052, 0x19D, 0x03A, 0x09F, 0x03B, 0x1C6, 0x037
3765 0x02A, 0x039, 0x025, 0x115, 0x024, 0x1FA, 0x02F, 0x114,
3766 0x075, 0x038, 0x0FC, 0x036, 0x01E, 0x1FB, 0x07F, 0x068,
3767 0x016, 0x037, 0x01F, 0x05C, 0x013, 0x08B, 0x001, 0x0FB,
3768 0x021, 0x044, 0x02B, 0x06B, 0x03B, 0x00C, 0x01C, 0x019,
3769 0x001, 0x020, 0x016, 0x07C, 0x00C, 0x074, 0x00A, 0x01C,
3770 0x012, 0x069, 0x00F, 0x06A, 0x014, 0x011, 0x01E, 0x017,
3771 0x002, 0x031, 0x01B, 0x030, 0x00D, 0x000, 0x001, 0x01D,
3772 0x023, 0x01A, 0x01D, 0x05D, 0x010, 0x0FA, 0x013
3774 0x012, 0x026, 0x041, 0x022, 0x01A, 0x0A9, 0x04C, 0x1B2,
3775 0x05C, 0x0A8, 0x058, 0x1B3, 0x040, 0x079, 0x00C, 0x055,
3776 0x01F, 0x0D8, 0x076, 0x023, 0x05F, 0x078, 0x00B, 0x01B,
3777 0x02D, 0x010, 0x037, 0x06D, 0x032, 0x00A, 0x01A, 0x01E,
3778 0x01F, 0x02B, 0x00D, 0x077, 0x031, 0x05D, 0x038, 0x027,
3779 0x00C, 0x0E9, 0x033, 0x05E, 0x030, 0x04D, 0x00A, 0x021,
3780 0x007, 0x03D, 0x039, 0x0E8, 0x00B, 0x059, 0x014, 0x027,
3781 0x011, 0x075, 0x00E, 0x009, 0x008, 0x012, 0x000
3784 const VP40_MV_Y_BITS: [[u8; 63]; 7] = [
3786 7, 9, 9, 9, 8, 10, 8, 10, 8, 10, 8, 9, 8, 10, 8, 7,
3787 8, 9, 8, 9, 7, 9, 7, 8, 7, 8, 6, 7, 5, 5, 3, 2,
3788 2, 5, 5, 7, 6, 8, 6, 8, 7, 8, 7, 9, 7, 9, 7, 8,
3789 7, 9, 8, 9, 8, 10, 9, 10, 9, 10, 9, 10, 9, 9, 7
3791 8, 10, 9, 11, 9, 11, 10, 11, 9, 11, 9, 10, 8, 10, 8, 9,
3792 8, 9, 8, 10, 8, 9, 7, 8, 7, 8, 6, 7, 5, 5, 3, 2,
3793 2, 4, 4, 6, 6, 8, 7, 8, 7, 9, 8, 10, 8, 9, 8, 9,
3794 8, 11, 9, 11, 9, 11, 9, 11, 9, 11, 9, 11, 9, 10, 8
3796 7, 9, 9, 10, 9, 10, 9, 10, 8, 9, 8, 10, 9, 9, 8, 8,
3797 7, 9, 7, 9, 7, 9, 7, 8, 7, 8, 6, 7, 5, 6, 4, 3,
3798 3, 3, 3, 4, 4, 6, 5, 7, 6, 8, 7, 8, 7, 9, 7, 8,
3799 7, 10, 8, 10, 8, 10, 8, 10, 9, 10, 9, 10, 9, 9, 7
3801 7, 9, 8, 10, 8, 9, 9, 10, 9, 10, 8, 9, 8, 9, 8, 8,
3802 7, 9, 7, 9, 7, 9, 7, 8, 7, 7, 6, 7, 5, 6, 4, 5,
3803 4, 5, 3, 4, 3, 4, 4, 5, 5, 7, 6, 7, 6, 8, 6, 7,
3804 6, 9, 7, 9, 7, 9, 8, 9, 8, 10, 8, 10, 8, 10, 7
3806 6, 9, 8, 9, 8, 10, 8, 10, 8, 9, 7, 9, 7, 9, 7, 8,
3807 7, 9, 7, 9, 7, 8, 6, 8, 6, 8, 6, 7, 6, 6, 5, 5,
3808 4, 6, 4, 6, 4, 5, 4, 5, 4, 5, 4, 6, 5, 6, 5, 6,
3809 5, 7, 6, 8, 6, 8, 7, 9, 7, 9, 7, 9, 7, 9, 6
3811 6, 8, 7, 9, 7, 9, 7, 9, 7, 8, 8, 8, 7, 9, 7, 7,
3812 6, 8, 7, 8, 6, 8, 6, 8, 6, 7, 6, 7, 6, 6, 5, 5,
3813 4, 6, 5, 7, 5, 7, 5, 6, 5, 7, 5, 7, 5, 6, 5, 5,
3814 4, 6, 5, 6, 5, 6, 5, 7, 6, 7, 6, 8, 6, 8, 5
3816 5, 7, 7, 8, 7, 8, 7, 9, 7, 8, 7, 9, 7, 8, 6, 7,
3817 6, 8, 7, 8, 7, 8, 6, 7, 6, 7, 6, 7, 6, 6, 5, 5,
3818 5, 6, 5, 7, 6, 7, 6, 7, 5, 8, 6, 7, 6, 7, 5, 6,
3819 5, 7, 6, 8, 5, 7, 5, 6, 5, 7, 5, 6, 5, 6, 3
3823 const VP40_LOOP_STRENGTH: [i16; 64] = [
3824 30, 25, 20, 20, 15, 15, 14, 14,
3825 13, 13, 12, 12, 11, 11, 10, 10,
3826 9, 9, 8, 8, 7, 7, 7, 7,
3827 6, 6, 6, 6, 5, 5, 5, 5,
3828 4, 4, 4, 4, 3, 3, 3, 3,
3829 2, 2, 2, 2, 2, 2, 2, 2,
3830 2, 2, 2, 2, 2, 2, 2, 2,
3831 1, 1, 1, 1, 1, 1, 1, 1
3833 const VP40_MV_LUT_INDEX: [usize; 32] = [
3834 0, 1, 2, 2, 3, 3, 3, 3,
3835 4, 4, 4, 4, 4, 4, 4, 4,
3836 5, 5, 5, 5, 5, 5, 5, 5,
3837 6, 6, 6, 6, 6, 6, 6, 6