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 {
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 let mut udc_cb: mem::MaybeUninit::<[Codebook<u8>; 5]> = mem::MaybeUninit::uninit();
42 let mut uac_i_cb: mem::MaybeUninit::<[Codebook<u8>; 5]> = mem::MaybeUninit::uninit();
43 let mut uac_p_cb: mem::MaybeUninit::<[Codebook<u8>; 5]> = mem::MaybeUninit::uninit();
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 (*udc_cb.as_mut_ptr())[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 (*uac_i_cb.as_mut_ptr())[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 (*uac_p_cb.as_mut_ptr())[i], cb);
55 dc_cb = udc_cb.assume_init();
56 ac_i_cb = uac_i_cb.assume_init();
57 ac_p_cb = uac_p_cb.assume_init();
59 Self { dc_cb, ac_i_cb, ac_p_cb, mbtype_cb }
64 dc_cb: [Codebook<u8>; 16],
65 ac0_cb: [Codebook<u8>; 16],
66 ac1_cb: [Codebook<u8>; 16],
67 ac2_cb: [Codebook<u8>; 16],
68 ac3_cb: [Codebook<u8>; 16],
79 let mut udc_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
80 let mut uac0_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
81 let mut uac1_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
82 let mut uac2_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
83 let mut uac3_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
85 let mut cr = TableCodebookDescReader::new(&VP31_DC_CODES[i], &VP31_DC_BITS[i], map_idx);
86 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
87 ptr::write(&mut (*udc_cb.as_mut_ptr())[i], cb);
89 let mut cr = TableCodebookDescReader::new(&VP31_AC_CAT0_CODES[i], &VP31_AC_CAT0_BITS[i], map_idx);
90 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
91 ptr::write(&mut (*uac0_cb.as_mut_ptr())[i], cb);
92 let mut cr = TableCodebookDescReader::new(&VP31_AC_CAT1_CODES[i], &VP31_AC_CAT1_BITS[i], map_idx);
93 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
94 ptr::write(&mut (*uac1_cb.as_mut_ptr())[i], cb);
95 let mut cr = TableCodebookDescReader::new(&VP31_AC_CAT2_CODES[i], &VP31_AC_CAT2_BITS[i], map_idx);
96 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
97 ptr::write(&mut (*uac2_cb.as_mut_ptr())[i], cb);
98 let mut cr = TableCodebookDescReader::new(&VP31_AC_CAT3_CODES[i], &VP31_AC_CAT3_BITS[i], map_idx);
99 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
100 ptr::write(&mut (*uac3_cb.as_mut_ptr())[i], cb);
102 dc_cb = udc_cb.assume_init();
103 ac0_cb = uac0_cb.assume_init();
104 ac1_cb = uac1_cb.assume_init();
105 ac2_cb = uac2_cb.assume_init();
106 ac3_cb = uac3_cb.assume_init();
108 Self { dc_cb, ac0_cb, ac1_cb, ac2_cb, ac3_cb }
110 fn new_vp4() -> VP31Codes {
117 let mut udc_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
118 let mut uac0_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
119 let mut uac1_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
120 let mut uac2_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
121 let mut uac3_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
123 let mut cr = TableCodebookDescReader::new(&VP40_DC_CODES[i], &VP40_DC_BITS[i], map_idx);
124 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
125 ptr::write(&mut (*udc_cb.as_mut_ptr())[i], cb);
127 let mut cr = TableCodebookDescReader::new(&VP40_AC_CAT0_CODES[i], &VP40_AC_CAT0_BITS[i], map_idx);
128 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
129 ptr::write(&mut (*uac0_cb.as_mut_ptr())[i], cb);
130 let mut cr = TableCodebookDescReader::new(&VP40_AC_CAT1_CODES[i], &VP40_AC_CAT1_BITS[i], map_idx);
131 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
132 ptr::write(&mut (*uac1_cb.as_mut_ptr())[i], cb);
133 let mut cr = TableCodebookDescReader::new(&VP40_AC_CAT2_CODES[i], &VP40_AC_CAT2_BITS[i], map_idx);
134 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
135 ptr::write(&mut (*uac2_cb.as_mut_ptr())[i], cb);
136 let mut cr = TableCodebookDescReader::new(&VP40_AC_CAT3_CODES[i], &VP40_AC_CAT3_BITS[i], map_idx);
137 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
138 ptr::write(&mut (*uac3_cb.as_mut_ptr())[i], cb);
140 dc_cb = udc_cb.assume_init();
141 ac0_cb = uac0_cb.assume_init();
142 ac1_cb = uac1_cb.assume_init();
143 ac2_cb = uac2_cb.assume_init();
144 ac3_cb = uac3_cb.assume_init();
146 VP31Codes { dc_cb, ac0_cb, ac1_cb, ac2_cb, ac3_cb }
150 struct VP40AuxCodes {
151 mv_x_cb: [Codebook<i8>; 7],
152 mv_y_cb: [Codebook<i8>; 7],
153 mbpat_cb: [Codebook<u8>; 2],
156 fn map_mv(idx: usize) -> i8 {
165 let mut umv_x_cb: mem::MaybeUninit::<[Codebook<i8>; 7]> = mem::MaybeUninit::uninit();
166 let mut umv_y_cb: mem::MaybeUninit::<[Codebook<i8>; 7]> = mem::MaybeUninit::uninit();
168 let mut cr = TableCodebookDescReader::new(&VP40_MV_X_CODES[i], &VP40_MV_X_BITS[i], map_mv);
169 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
170 ptr::write(&mut (*umv_x_cb.as_mut_ptr())[i], cb);
171 let mut cr = TableCodebookDescReader::new(&VP40_MV_Y_CODES[i], &VP40_MV_Y_BITS[i], map_mv);
172 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
173 ptr::write(&mut (*umv_y_cb.as_mut_ptr())[i], cb);
175 mv_x_cb = umv_x_cb.assume_init();
176 mv_y_cb = umv_y_cb.assume_init();
178 let mut cr0 = TableCodebookDescReader::new(&VP40_MBPAT_CODES[0], &VP40_MBPAT_BITS[0], map_idx);
179 let mut cr1 = TableCodebookDescReader::new(&VP40_MBPAT_CODES[1], &VP40_MBPAT_BITS[1], map_idx);
180 let mbpat_cb = [Codebook::new(&mut cr0, CodebookMode::MSB).unwrap(),
181 Codebook::new(&mut cr1, CodebookMode::MSB).unwrap()];
182 Self { mv_x_cb, mv_y_cb, mbpat_cb }
186 #[allow(clippy::large_enum_variant)]
206 btype: VPMBType::Intra,
216 type ReadRunFunc = fn (&mut BitReader) -> DecoderResult<usize>;
218 const VP31_LONG_RUN_BASE: [usize; 7] = [ 1, 2, 4, 6, 10, 18, 34 ];
219 const VP31_LONG_RUN_BITS: [u8; 7] = [ 0, 1, 1, 2, 3, 4, 12 ];
220 fn read_long_run(br: &mut BitReader) -> DecoderResult<usize> {
221 let pfx = br.read_code(UintCodeType::LimitedUnary(6, 0))? as usize;
222 if pfx == 0 { return Ok(1); }
223 Ok(VP31_LONG_RUN_BASE[pfx] + (br.read(VP31_LONG_RUN_BITS[pfx])? as usize))
226 const VP31_SHORT_RUN_BASE: [usize; 6] = [ 1, 3, 5, 7, 11, 15 ];
227 const VP31_SHORT_RUN_BITS: [u8; 6] = [ 1, 1, 1, 2, 2, 4 ];
228 fn read_short_run(br: &mut BitReader) -> DecoderResult<usize> {
229 let pfx = br.read_code(UintCodeType::LimitedUnary(5, 0))? as usize;
230 Ok(VP31_SHORT_RUN_BASE[pfx] + (br.read(VP31_SHORT_RUN_BITS[pfx])? as usize))
233 fn read_mb_run(br: &mut BitReader) -> DecoderResult<usize> {
234 let pfx = br.read_code(UintCodeType::LimitedUnary(10, 0))? as usize;
235 if pfx == 10 { unimplemented!(); }
239 let base = (1 << (pfx - 1)) + 1;
240 let bits = (pfx - 1) as u8;
241 let add_bits = br.read(bits)? as usize;
246 struct BitRunDecoder {
249 read_run: ReadRunFunc,
253 fn new(br: &mut BitReader, read_run: ReadRunFunc) -> DecoderResult<Self> {
254 let value = !br.read_bool()?; // it will be flipped before run decoding
255 Ok(Self { value, run: 0, read_run })
257 fn get_val(&mut self, br: &mut BitReader) -> DecoderResult<bool> {
259 self.value = !self.value;
260 self.run = (self.read_run)(br)?;
267 const VP30_NE0_BITS: [u8; 5] = [ 2, 2, 3, 4, 8 ];
268 const VP30_NE0_BASE: [usize; 5] = [ 1, 5, 9, 17, 33 ];
269 fn vp30_read_ne_run0(br: &mut BitReader) -> DecoderResult<usize> {
270 let len = br.read_code(UintCodeType::LimitedUnary(4, 0))? as usize;
271 Ok(VP30_NE0_BASE[len] + (br.read(VP30_NE0_BITS[len])? as usize))
273 fn vp30_read_ne_run1(br: &mut BitReader) -> DecoderResult<usize> {
274 let len = br.read_code(UintCodeType::LimitedUnary(6, 0))? as usize;
276 Ok((br.read(1)? as usize) + 1)
280 Ok((br.read(8)? as usize) + 8)
283 fn vp30_read_coded_run0(br: &mut BitReader) -> DecoderResult<usize> {
284 let len = br.read_code(UintCodeType::LimitedUnary(5, 0))? as usize;
294 10010 - 7 + get_bits(3)
295 101100 - 15 + get_bits(5)
296 1011010 - 47 + get_bits(8)
297 1011011 - 303 + get_bits(16)
299 const VP30_CRUN1_LUT: [u8; 32] = [
300 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
301 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
302 0x34, 0x34, 0x75, 0x55, 0x44, 0x44, 0x85, 0x65,
303 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22
305 fn vp30_read_coded_run1(br: &mut BitReader) -> DecoderResult<usize> {
306 let idx = br.peek(5) as usize;
307 let sym = (VP30_CRUN1_LUT[idx] >> 4) as usize;
308 let bits = VP30_CRUN1_LUT[idx] & 0xF;
309 br.skip(u32::from(bits))?;
313 Ok(7 + (br.read(3)? as usize))
315 let len = br.read_code(UintCodeType::Unary012)?;
317 0 => Ok(15 + (br.read(5)? as usize)),
318 1 => Ok(47 + (br.read(8)? as usize)),
319 _ => Ok(303 + (br.read(16)? as usize)),
325 info: NACodecInfoRef,
336 aux_codes: Option<VP40AuxCodes>,
338 mc_buf: NAVideoBufferRef<u8>,
342 mb_partial: Vec<bool>,
353 blk_addr: Vec<usize>,
355 sb_info: Vec<SBState>,
361 fn vp30_read_mv_comp(br: &mut BitReader) -> DecoderResult<i16> {
362 let mode = br.read(2)?;
363 if mode == 0 { return Ok(0); }
364 let sign = br.read_bool()?;
365 let val = match mode - 1 {
367 1 => 2 + (br.read(2)? as i16),
368 _ => br.read(5)? as i16,
377 fn vp30_read_mv(br: &mut BitReader) -> DecoderResult<MV> {
378 let x = vp30_read_mv_comp(br)?;
379 let y = vp30_read_mv_comp(br)?;
383 fn read_mv_comp_packed(br: &mut BitReader) -> DecoderResult<i16> {
384 let code = br.read(3)?;
389 3 => if br.read_bool()? { Ok(-2) } else { Ok(2) },
390 4 => if br.read_bool()? { Ok(-3) } else { Ok(3) },
392 let val = (br.read(2)? as i16) + 4;
400 let val = (br.read(3)? as i16) + 8;
408 let val = (br.read(4)? as i16) + 16;
418 fn read_mv_packed(br: &mut BitReader) -> DecoderResult<MV> {
419 let x = read_mv_comp_packed(br)?;
420 let y = read_mv_comp_packed(br)?;
424 fn read_mv_comp_raw(br: &mut BitReader) -> DecoderResult<i16> {
425 let val = br.read(5)? as i16;
433 fn read_mv_raw(br: &mut BitReader) -> DecoderResult<MV> {
434 let x = read_mv_comp_raw(br)?;
435 let y = read_mv_comp_raw(br)?;
439 fn rescale_qmat(dst_qmat: &mut [i16; 64], base_qmat: &[i16; 64], dc_quant: i16, ac_quant: i16, minval: i16) {
440 for (dst, src) in dst_qmat.iter_mut().zip(base_qmat.iter()) {
441 *dst = (src.wrapping_mul(ac_quant) / 100).max(minval) << 2;
443 dst_qmat[0] = (base_qmat[0] * dc_quant / 100).max(minval * 2) << 2;
446 fn rescale_qmat_vp4(dst_qmat: &mut [i16; 64], base_qmat: &[i16; 64], dc_quant: i16, ac_quant: i16, is_intra: bool) {
447 let (bias, minval) = if is_intra { (3, 4) } else { (6, 8) };
448 for (dst, src) in dst_qmat.iter_mut().zip(base_qmat.iter()) {
449 *dst = ((src - bias).wrapping_mul(ac_quant) / 100 + bias) << 2;
451 dst_qmat[0] = (base_qmat[0] * dc_quant / 100).max(minval) << 2;
454 fn expand_token(blk: &mut Block, br: &mut BitReader, eob_run: &mut usize, token: u8) -> DecoderResult<()> {
457 0 | 1 | 2 => { *eob_run = (token as usize) + 1; },
459 let bits = token - 1;
460 *eob_run = (br.read(bits)? as usize) + (1 << bits);
462 6 => { *eob_run = br.read(12)? as usize; },
465 let bits = if token == 7 { 3 } else { 6 };
466 let run = (br.read(bits)? as usize) + 1;
468 validate!(blk.idx <= 64);
470 // single coefficients
471 9 | 10 | 11 | 12 => {
472 let val = (i16::from(token) - 7) >> 1;
473 if (token & 1) == 1 {
474 blk.coeffs[ZIGZAG[blk.idx]] = val;
476 blk.coeffs[ZIGZAG[blk.idx]] = -val;
480 13 | 14 | 15 | 16 => {
481 let val = i16::from(token) - 10;
482 if !br.read_bool()? {
483 blk.coeffs[ZIGZAG[blk.idx]] = val;
485 blk.coeffs[ZIGZAG[blk.idx]] = -val;
489 17 | 18 | 19 | 20 | 21 | 22 => {
490 let add_bits = if token == 22 { 9 } else { token - 16 };
491 let sign = br.read_bool()?;
492 let val = (br.read(add_bits)? as i16) + VP3_LITERAL_BASE[(token - 17) as usize];
494 blk.coeffs[ZIGZAG[blk.idx]] = val;
496 blk.coeffs[ZIGZAG[blk.idx]] = -val;
500 // zero run plus coefficient
501 23 | 24 | 25 | 26 | 27 => {
502 blk.idx += (token - 22) as usize;
503 validate!(blk.idx < 64);
504 if !br.read_bool()? {
505 blk.coeffs[ZIGZAG[blk.idx]] = 1;
507 blk.coeffs[ZIGZAG[blk.idx]] = -1;
512 let run_bits = token - 26;
518 let sign = br.read_bool()?;
519 blk.idx += br.read(run_bits)? as usize;
520 validate!(blk.idx < 64);
522 blk.coeffs[ZIGZAG[blk.idx]] = 1;
524 blk.coeffs[ZIGZAG[blk.idx]] = -1;
530 validate!(blk.idx < 64);
531 let sign = br.read_bool()?;
532 let val = (br.read(1)? as i16) + 2;
534 blk.coeffs[ZIGZAG[blk.idx]] = val;
536 blk.coeffs[ZIGZAG[blk.idx]] = -val;
541 let sign = br.read_bool()?;
542 let val = (br.read(1)? as i16) + 2;
543 blk.idx += (br.read(1)? as usize) + 2;
544 validate!(blk.idx < 64);
546 blk.coeffs[ZIGZAG[blk.idx]] = val;
548 blk.coeffs[ZIGZAG[blk.idx]] = -val;
556 } else if (token > 8) && (blk.idx > 1) {
562 macro_rules! fill_dc_pred {
563 ($self: expr, $ref_id: expr, $pred: expr, $pp: expr, $bit: expr, $idx: expr) => {
564 if $self.blocks[$idx].coded && $self.blocks[$idx].btype.get_ref_id() == $ref_id {
565 $pred[$bit] = i32::from($self.blocks[$idx].coeffs[0]);
571 fn vp31_loop_filter_v(frm: &mut NASimpleVideoFrame<u8>, x: usize, y: usize, plane: usize, loop_str: i16) {
572 let off = frm.offset[plane] + x + y * frm.stride[plane];
573 vp31_loop_filter(frm.data, off, 1, frm.stride[plane], 8, loop_str);
576 fn vp31_loop_filter_h(frm: &mut NASimpleVideoFrame<u8>, x: usize, y: usize, plane: usize, loop_str: i16) {
577 let off = frm.offset[plane] + x + y * frm.stride[plane];
578 vp31_loop_filter(frm.data, off, frm.stride[plane], 1, 8, loop_str);
581 fn vp3_mv_mode(mvx: i16, mvy: i16) -> usize {
582 let mode = ((mvx & 1) + (mvy & 1) * 2) as usize;
583 if (mode == 3) && (mvx ^ mvy < 0) {
591 fn new(version: u8) -> Self {
592 let vt = alloc_video_buffer(NAVideoInfo::new(24, 24, false, YUV420_FORMAT), 4).unwrap();
593 let mc_buf = vt.get_vbuf().unwrap();
595 info: NACodecInfoRef::default(),
604 shuf: VPShuffler::new(),
611 mb_coded: Vec::new(),
612 mb_partial: Vec::new(),
624 blk_addr: Vec::new(),
627 sb_blocks: Vec::new(),
629 mb_blocks: Vec::new(),
632 fn parse_header(&mut self, br: &mut BitReader) -> DecoderResult<()> {
633 self.is_intra = !br.read_bool()?;
635 self.quant = br.read(6)? as usize;
638 validate!(self.version == 3 || self.version == 30);
639 let mb_w = br.read(8)? as usize;
640 let mb_h = br.read(8)? as usize;
641 validate!(mb_w == self.mb_w && mb_h == self.mb_h);
642 if self.version == 3 {
644 self.codes = Codes::VP30(VP30Codes::new());
647 let version = br.read(13)?;
648 let coding_type = br.read(1)?;
649 validate!(coding_type == 0);
652 validate!(self.version == 3 || self.version == 31);
653 if self.version == 3 {
655 self.codes = Codes::VP31(VP31Codes::new());
657 } else if version == 3 {
658 validate!(self.version == 4);
659 let mb_h = br.read(8)? as usize;
660 let mb_w = br.read(8)? as usize;
661 validate!(mb_w == self.mb_w && mb_h == self.mb_h);
662 let fact1 = br.read(5)?;
663 let fact2 = br.read(3)?;
664 validate!(fact1 == 1 && fact2 == 1);
665 let fact1 = br.read(5)?;
666 let fact2 = br.read(3)?;
667 validate!(fact1 == 1 && fact2 == 1);
670 return Err(DecoderError::InvalidData);
674 self.loop_str = if self.version != 4 {
675 VP31_LOOP_STRENGTH[self.quant]
677 VP40_LOOP_STRENGTH[self.quant]
681 fn vp30_unpack_sb_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
682 let mut has_nonempty = false;
684 let mut bit = !br.read_bool()?;
686 for sb in self.sb_info.iter_mut() {
689 run = if bit { vp30_read_ne_run1(br)? } else { vp30_read_ne_run0(br)? };
691 *sb = if bit { has_nonempty = true; SBState::Partial } else { SBState::Uncoded };
697 for el in self.mb_coded.iter_mut() { *el = false; }
698 let mut bit = !br.read_bool()?;
700 let mut mbiter = self.mb_coded.iter_mut();
701 for (sb, nmb) in self.sb_info.iter_mut().zip(self.sb_mbs.iter()) {
702 let nmbs = *nmb as usize;
703 if *sb == SBState::Partial {
707 run = if bit { vp30_read_coded_run1(br)? } else { vp30_read_coded_run0(br)? };
710 *mbiter.next().unwrap() = bit;
714 mbiter.next().unwrap();
719 let mut bit = !br.read_bool()?;
722 for (coded, nblk) in self.mb_coded.iter().zip(self.mb_blocks.iter()) {
723 let nblks = *nblk as usize;
725 let mut cb = [false; 4];
729 run = if bit { vp30_read_coded_run1(br)? } else { vp30_read_coded_run0(br)? };
735 let addr = self.blk_addr[cur_blk + j] >> 2;
736 self.blocks[addr].coded = cb[j];
745 fn vp30_unpack_mb_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
747 if let Codes::VP30(ref codes) = self.codes {
748 for (sb, nblk) in self.sb_info.iter_mut().zip(self.sb_blocks.iter()).take(self.y_sbs) {
749 let nblks = *nblk as usize;
750 if *sb == SBState::Uncoded {
752 self.blocks[self.blk_addr[cur_blk] >> 2].btype = VPMBType::InterNoMV;
756 for _ in 0..nblks/4 {
757 let mut coded = *sb == SBState::Coded;
760 if self.blocks[self.blk_addr[cur_blk + blk] >> 2].coded {
766 let mode = if !coded {
769 br.read_cb(&codes.mbtype_cb)?
772 self.blocks[self.blk_addr[cur_blk] >> 2].btype = mode;
779 return Err(DecoderError::Bug);
781 // replicate types for chroma
783 let mut off_u = self.y_blocks;
784 let mut off_v = off_u + self.mb_w * self.mb_h;
785 for _blk_y in 0..self.mb_h {
786 for blk_x in 0..self.mb_w {
787 let btype = self.blocks[off_y + blk_x * 2].btype;
788 self.blocks[off_u + blk_x].btype = btype;
789 self.blocks[off_v + blk_x].btype = btype;
791 off_y += self.mb_w * 2 * 2;
797 fn vp30_unpack_mv_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
798 let mut last_mv = ZERO_MV;
801 for _ in 0..self.y_blocks/4 {
802 let baddr = self.blk_addr[cur_blk] >> 2;
803 if self.blocks[baddr].btype == VPMBType::InterFourMV {
804 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);
806 let blk = &mut self.blocks[saddr + (i & 1) + (i & 2) * self.mb_w];
808 blk.mv = vp30_read_mv(br)?;
814 match self.blocks[baddr].btype {
815 VPMBType::Intra | VPMBType::InterNoMV | VPMBType::GoldenNoMV => {
818 VPMBType::InterMV => {
819 cur_mv = vp30_read_mv(br)?;
822 VPMBType::InterNearest => {
826 cur_mv = vp30_read_mv(br)?;
830 self.blocks[self.blk_addr[cur_blk] >> 2].mv = cur_mv;
837 fn vp30_unpack_coeffs(&mut self, br: &mut BitReader, coef_no: usize, table: usize) -> DecoderResult<()> {
838 if let Codes::VP30(ref codes) = self.codes {
839 for blkaddr in self.blk_addr.iter() {
840 let blk: &mut Block = &mut self.blocks[blkaddr >> 2];
841 if !blk.coded || blk.idx != coef_no { continue; }
842 if self.eob_run > 0 {
847 let cb = if coef_no == 0 {
849 } else if blk.btype.is_intra() {
850 &codes.ac_i_cb[table]
852 &codes.ac_p_cb[table]
854 let token = br.read_cb(cb)?;
855 expand_token(blk, br, &mut self.eob_run, token)?;
859 Err(DecoderError::Bug)
862 fn vp31_unpack_sb_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
863 let mut has_uncoded = false;
864 let mut has_partial = false;
866 let mut brun = BitRunDecoder::new(br, read_long_run)?;
867 for sb in self.sb_info.iter_mut() {
868 if brun.get_val(br)? {
869 *sb = SBState::Partial;
872 *sb = SBState::Uncoded;
878 let mut brun = BitRunDecoder::new(br, read_long_run)?;
880 for (sb, nblk) in self.sb_info.iter_mut().zip(self.sb_blocks.iter()) {
881 let nblks = *nblk as usize;
882 if *sb != SBState::Partial && brun.get_val(br)? {
883 *sb = SBState::Coded;
885 let blk_idx = self.blk_addr[cur_blk] >> 2;
886 self.blocks[blk_idx].coded = true;
891 let blk_idx = self.blk_addr[cur_blk] >> 2;
892 self.blocks[blk_idx].coded = false;
899 let mut brun = BitRunDecoder::new(br, read_short_run)?;
901 for (sb, nblk) in self.sb_info.iter_mut().zip(self.sb_blocks.iter()) {
902 let nblks = *nblk as usize;
903 if *sb == SBState::Partial {
905 let blk_idx = self.blk_addr[cur_blk] >> 2;
906 self.blocks[blk_idx].coded = brun.get_val(br)?;
916 fn vp31_unpack_mb_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
917 let mut modes = [VPMBType::InterNoMV; 8];
918 let alphabet = br.read(3)? as usize;
919 let raw_modes = alphabet >= 7;
921 for mode in VP31_DEFAULT_MB_MODES.iter() {
922 modes[br.read(3)? as usize] = *mode;
924 } else if alphabet < 7 {
925 modes.copy_from_slice(&VP31_MB_MODES[alphabet - 1]);
929 for (sb, nblk) in self.sb_info.iter_mut().zip(self.sb_blocks.iter()).take(self.y_sbs) {
930 let nblks = *nblk as usize;
931 if *sb == SBState::Uncoded {
933 self.blocks[self.blk_addr[cur_blk] >> 2].btype = VPMBType::InterNoMV;
937 for _ in 0..nblks/4 {
938 let mut coded = *sb == SBState::Coded;
941 if self.blocks[self.blk_addr[cur_blk + blk] >> 2].coded {
947 let mode = if !coded {
949 } else if !raw_modes {
950 let code = br.read_code(UintCodeType::LimitedUnary(7, 0))?;
953 VP31_DEFAULT_MB_MODES[br.read(3)? as usize]
956 self.blocks[self.blk_addr[cur_blk] >> 2].btype = mode;
962 // replicate types for chroma
964 let mut off_u = self.y_blocks;
965 let mut off_v = off_u + self.mb_w * self.mb_h;
966 for _blk_y in 0..self.mb_h {
967 for blk_x in 0..self.mb_w {
968 let btype = self.blocks[off_y + blk_x * 2].btype;
969 self.blocks[off_u + blk_x].btype = btype;
970 self.blocks[off_v + blk_x].btype = btype;
972 off_y += self.mb_w * 2 * 2;
978 fn vp31_unpack_mv_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
979 let mut last_mv = ZERO_MV;
980 let mut last2_mv = ZERO_MV;
981 let read_mv = if br.read_bool()? { read_mv_raw } else { read_mv_packed };
984 for _ in 0..self.y_blocks/4 {
985 if self.blocks[self.blk_addr[cur_blk] >> 2].btype == VPMBType::InterFourMV {
986 let a0 = self.blk_addr[cur_blk + 0] >> 2;
987 let a1 = self.blk_addr[cur_blk + 1] >> 2;
988 let a2 = self.blk_addr[cur_blk + 2] >> 2;
989 let a3 = self.blk_addr[cur_blk + 3] >> 2;
990 let first = a0.min(a1).min(a2).min(a3);
991 let last = a0.max(a1).max(a2).max(a3);
992 self.blocks[first + 0].mv = (read_mv)(br)?;
993 self.blocks[first + 1].mv = (read_mv)(br)?;
994 self.blocks[last - 1].mv = (read_mv)(br)?;
995 self.blocks[last + 0].mv = (read_mv)(br)?;
997 last_mv = self.blocks[last].mv;
1001 match self.blocks[self.blk_addr[cur_blk] >> 2].btype {
1002 VPMBType::Intra | VPMBType::InterNoMV | VPMBType::GoldenNoMV => {
1005 VPMBType::InterMV => {
1006 cur_mv = (read_mv)(br)?;
1010 VPMBType::InterNearest => {
1013 VPMBType::InterNear => {
1015 std::mem::swap(&mut last_mv, &mut last2_mv);
1018 cur_mv = (read_mv)(br)?;
1022 self.blocks[self.blk_addr[cur_blk] >> 2].mv = cur_mv;
1029 fn vp31_unpack_coeffs(&mut self, br: &mut BitReader, coef_no: usize, table_y: usize, table_c: usize) -> DecoderResult<()> {
1030 if let Codes::VP31(ref codes) = self.codes {
1031 let cbs = if coef_no == 0 {
1032 [&codes.dc_cb[table_y], &codes.dc_cb[table_c]]
1033 } else if coef_no < 6 {
1034 [&codes.ac0_cb[table_y], &codes.ac0_cb[table_c]]
1035 } else if coef_no < 15 {
1036 [&codes.ac1_cb[table_y], &codes.ac1_cb[table_c]]
1037 } else if coef_no < 28 {
1038 [&codes.ac2_cb[table_y], &codes.ac2_cb[table_c]]
1040 [&codes.ac3_cb[table_y], &codes.ac3_cb[table_c]]
1042 for blkaddr in self.blk_addr.iter() {
1043 let blk: &mut Block = &mut self.blocks[blkaddr >> 2];
1044 if !blk.coded || blk.idx != coef_no { continue; }
1045 if self.eob_run > 0 {
1050 let cb = if (blkaddr & 3) == 0 { cbs[0] } else { cbs[1] };
1051 let token = br.read_cb(cb)?;
1052 expand_token(blk, br, &mut self.eob_run, token)?;
1056 Err(DecoderError::Bug)
1059 fn vp40_unpack_sb_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
1060 let mut has_uncoded = false;
1062 if let Some(ref aux_codes) = self.aux_codes {
1063 for el in self.sb_info.iter_mut() {
1064 *el = SBState::Partial;
1067 let mut mbiter = self.mb_coded.iter_mut();
1068 let mut brun = BitRunDecoder::new(br, read_mb_run)?;
1069 for nmb in self.sb_mbs.iter() {
1070 let nmbs = *nmb as usize;
1072 let coded = brun.get_val(br)?;
1073 *mbiter.next().unwrap() = coded;
1074 has_uncoded |= !coded;
1079 let mut mbiter = self.mb_coded.iter().zip(self.mb_partial.iter_mut());
1080 let mut brun = BitRunDecoder::new(br, read_mb_run)?;
1081 for nmb in self.sb_mbs.iter() {
1082 let nmbs = *nmb as usize;
1084 let (coded, partial) = mbiter.next().unwrap();
1088 *partial = brun.get_val(br)?;
1094 let mut cur_blk = 0;
1095 for ((coded, partial), nblk) in self.mb_coded.iter().zip(self.mb_partial.iter()).zip(self.mb_blocks.iter()) {
1096 let nblks = *nblk as usize;
1099 let addr = self.blk_addr[cur_blk] >> 2;
1100 self.blocks[addr].coded = true;
1103 } else if !*partial {
1105 let addr = self.blk_addr[cur_blk] >> 2;
1106 self.blocks[addr].coded = false;
1110 let mut pat = br.read_cb(&aux_codes.mbpat_cb[bpmode])? + 1;
1111 bpmode = VP40_BP_PREDICTOR[pat as usize] as usize;
1113 let mut addrs = [0; 4];
1115 addrs[i] = self.blk_addr[cur_blk + i] >> 2;
1116 for j in (0..i).rev() {
1117 if addrs[j] > addrs[j + 1] {
1118 addrs.swap(j, j + 1);
1123 self.blocks[addrs[i]].coded = (pat & 8) != 0;
1132 Err(DecoderError::Bug)
1135 fn vp40_unpack_mv_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
1136 let mut last_mv = ZERO_MV;
1137 let mut last2_mv = ZERO_MV;
1138 let mut last_mv_g = ZERO_MV;
1140 let mut cur_blk = 0;
1141 if let Some(ref codes) = self.aux_codes {
1142 for _ in 0..self.y_blocks/4 {
1143 if self.blocks[self.blk_addr[cur_blk] >> 2].btype == VPMBType::InterFourMV {
1144 let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv.x.abs() as usize]];
1145 let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv.y.abs() as usize]];
1146 let x_sign = last_mv.x < 0;
1147 let y_sign = last_mv.y < 0;
1149 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);
1151 let blk = &mut self.blocks[saddr + (i & 1) + (i >> 1) * self.mb_w * 2];
1152 blk.mv.x = i16::from(br.read_cb(x_cb)?);
1154 blk.mv.x = -blk.mv.x;
1156 blk.mv.y = i16::from(br.read_cb(y_cb)?);
1158 blk.mv.y = -blk.mv.y;
1165 match self.blocks[self.blk_addr[cur_blk] >> 2].btype {
1166 VPMBType::Intra | VPMBType::InterNoMV | VPMBType::GoldenNoMV => {
1169 VPMBType::InterMV => {
1170 let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv.x.abs() as usize]];
1171 let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv.y.abs() as usize]];
1172 let x_sign = last_mv.x < 0;
1173 let y_sign = last_mv.y < 0;
1174 let x = i16::from(br.read_cb(x_cb)?);
1175 let y = i16::from(br.read_cb(y_cb)?);
1176 cur_mv = MV { x: if !x_sign { x } else { -x }, y: if !y_sign { y } else { -y } };
1180 VPMBType::InterNearest => {
1183 VPMBType::InterNear => {
1185 std::mem::swap(&mut last_mv, &mut last2_mv);
1188 let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv_g.x.abs() as usize]];
1189 let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv_g.y.abs() as usize]];
1190 let x_sign = last_mv_g.x < 0;
1191 let y_sign = last_mv_g.y < 0;
1192 let x = i16::from(br.read_cb(x_cb)?);
1193 let y = i16::from(br.read_cb(y_cb)?);
1194 cur_mv = MV { x: if !x_sign { x } else { -x }, y: if !y_sign { y } else { -y } };
1199 self.blocks[self.blk_addr[cur_blk] >> 2].mv = cur_mv;
1206 Err(DecoderError::Bug)
1209 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<()> {
1210 const VP40_PRED_MASKS: [usize; 16] = [ // top, bottom, left, right
1211 0b1010, 0b1010, 0b1000, 0b1011,
1212 0b1010, 0b1010, 0b0010, 0b1110,
1213 0b0010, 0b1010, 0b0010, 0b0110,
1214 0b0100, 0b0111, 0b1110, 0b1110
1216 self.last_dc = [0; 3];
1217 if let Codes::VP31(ref codes) = self.codes {
1218 let mut coef_eob: [usize; 64] = [0; 64];
1219 for (blkaddr, bsub) in self.blk_addr.iter().zip(self.blk_sub.iter()) {
1220 let blk: &mut Block = &mut self.blocks[blkaddr >> 2];
1221 if !blk.coded { continue; }
1222 let mut idx = blkaddr >> 2;
1223 let (bx, by) = if (blkaddr & 3) == 0 {
1224 (idx % (self.mb_w * 2), idx / (self.mb_w * 2))
1226 idx -= self.mb_w * self.mb_h * 4;
1227 if idx >= self.mb_w * self.mb_h {
1228 idx -= self.mb_w * self.mb_h;
1230 (idx % self.mb_w, idx / self.mb_w)
1232 while blk.idx < 64 {
1233 if coef_eob[blk.idx] > 0 {
1234 coef_eob[blk.idx] -= 1;
1238 let cbs = if blk.idx == 0 {
1239 [&codes.dc_cb[dc_table_y], &codes.dc_cb[dc_table_c]]
1240 } else if blk.idx < 6 {
1241 [&codes.ac0_cb[ac_table_y], &codes.ac0_cb[ac_table_c]]
1242 } else if blk.idx < 15 {
1243 [&codes.ac1_cb[ac_table_y], &codes.ac1_cb[ac_table_c]]
1244 } else if blk.idx < 28 {
1245 [&codes.ac2_cb[ac_table_y], &codes.ac2_cb[ac_table_c]]
1247 [&codes.ac3_cb[ac_table_y], &codes.ac3_cb[ac_table_c]]
1249 let cb = if (blkaddr & 3) == 0 { cbs[0] } else { cbs[1] };
1250 let token = br.read_cb(cb)?;
1251 expand_token(blk, br, &mut coef_eob[blk.idx], token)?;
1252 if blk.idx == 64 { break; }
1254 let idx = blkaddr >> 2;
1255 let mask = VP40_PRED_MASKS[*bsub as usize];
1256 if (blkaddr & 3) == 0 {
1257 let pred_dc = self.vp40_predict_dc(bx, by, self.mb_w * 2, self.mb_h * 2, idx, mask, true);
1258 let blk: &mut Block = &mut self.blocks[blkaddr >> 2];
1259 blk.coeffs[0] += pred_dc;
1260 self.last_dc[blk.btype.get_ref_id() as usize] = blk.coeffs[0];
1262 let pred_dc = self.vp40_predict_dc(bx, by, self.mb_w, self.mb_h, idx, mask, false);
1263 let blk: &mut Block = &mut self.blocks[blkaddr >> 2];
1264 blk.coeffs[0] += pred_dc;
1265 self.last_dc[blk.btype.get_ref_id() as usize] = blk.coeffs[0];
1270 Err(DecoderError::Bug)
1273 fn decode_vp30(&mut self, br: &mut BitReader, frm: &mut NASimpleVideoFrame<u8>) -> DecoderResult<()> {
1274 for blk in self.blocks.iter_mut() {
1275 blk.coeffs = [0; 64];
1281 for sb in self.sb_info.iter_mut() { *sb = SBState::Coded; }
1282 for blk in self.blocks.iter_mut() {
1283 blk.btype = VPMBType::Intra;
1287 if self.shuf.get_last().is_none() || self.shuf.get_golden().is_none() {
1288 return Err(DecoderError::MissingReference);
1290 self.vp30_unpack_sb_info(br)?;
1291 self.vp30_unpack_mb_info(br)?;
1292 self.vp30_unpack_mv_info(br)?;
1294 let dc_quant = VP30_DC_SCALES[self.quant] * 10;
1295 let ac_quant = VP30_AC_SCALES[self.quant];
1297 self.update_gf = ac_quant <= 50;
1299 rescale_qmat(&mut self.qmat_y, VP3_QMAT_Y, dc_quant, ac_quant, 2);
1300 rescale_qmat(&mut self.qmat_c, VP3_QMAT_C, dc_quant, ac_quant, 2);
1301 rescale_qmat(&mut self.qmat_y_p, VP3_QMAT_INTER, dc_quant, ac_quant, 4);
1302 if self.quant == 10 {
1303 self.qmat_y[29] = 980;
1304 self.qmat_y[58] = 1636;
1305 self.qmat_y[59] = 1964;
1306 } else if self.quant == 31 {
1307 self.qmat_y[58] = 456;
1308 } else if self.quant == 44 {
1309 self.qmat_y[58] = 224;
1311 self.qmat_c_p.copy_from_slice(&self.qmat_y_p);
1313 let table = if ac_quant <= 50 {
1315 } else if ac_quant <= 150 {
1317 } else if ac_quant <= 300 {
1319 } else if ac_quant <= 600 {
1326 self.vp30_unpack_coeffs(br, 0, table)?;
1327 let mut last_dc_i = 0;
1328 let mut last_dc_p = 0;
1329 for blkaddr in self.blk_addr.iter() {
1330 let blk: &mut Block = &mut self.blocks[blkaddr >> 2];
1331 if !blk.coded { continue; }
1332 if blk.btype.is_intra() {
1333 blk.coeffs[0] += last_dc_i;
1334 last_dc_i = blk.coeffs[0];
1336 blk.coeffs[0] += last_dc_p;
1337 last_dc_p = blk.coeffs[0];
1341 for coef_no in 1..64 {
1342 self.vp30_unpack_coeffs(br, coef_no, table)?;
1346 self.output_blocks_intra(frm);
1348 self.output_blocks_inter(frm);
1353 fn decode_vp31(&mut self, br: &mut BitReader, frm: &mut NASimpleVideoFrame<u8>) -> DecoderResult<()> {
1354 for blk in self.blocks.iter_mut() {
1355 blk.coeffs = [0; 64];
1361 for sb in self.sb_info.iter_mut() { *sb = SBState::Coded; }
1362 for blk in self.blocks.iter_mut() {
1363 blk.btype = VPMBType::Intra;
1367 if self.shuf.get_last().is_none() || self.shuf.get_golden().is_none() {
1368 return Err(DecoderError::MissingReference);
1370 self.vp31_unpack_sb_info(br)?;
1371 self.vp31_unpack_mb_info(br)?;
1372 self.vp31_unpack_mv_info(br)?;
1374 let dc_quant = VP31_DC_SCALES[self.quant];
1375 let ac_quant = VP31_AC_SCALES[self.quant];
1376 rescale_qmat(&mut self.qmat_y, VP3_QMAT_Y, dc_quant, ac_quant, 2);
1377 rescale_qmat(&mut self.qmat_c, VP3_QMAT_C, dc_quant, ac_quant, 2);
1378 rescale_qmat(&mut self.qmat_y_p, VP3_QMAT_INTER, dc_quant, ac_quant, 4);
1379 rescale_qmat(&mut self.qmat_c_p, VP3_QMAT_INTER, dc_quant, ac_quant, 4);
1382 let dc_table_y = br.read(4)? as usize;
1383 let dc_table_c = br.read(4)? as usize;
1384 self.vp31_unpack_coeffs(br, 0, dc_table_y, dc_table_c)?;
1387 let ac_table_y = br.read(4)? as usize;
1388 let ac_table_c = br.read(4)? as usize;
1389 for coef_no in 1..64 {
1390 self.vp31_unpack_coeffs(br, coef_no, ac_table_y, ac_table_c)?;
1394 self.output_blocks_intra(frm);
1396 self.output_blocks_inter(frm);
1398 if self.loop_str > 0 {
1399 self.vp31_loop_filter(frm);
1404 fn decode_vp4(&mut self, br: &mut BitReader, frm: &mut NASimpleVideoFrame<u8>) -> DecoderResult<()> {
1405 for blk in self.blocks.iter_mut() {
1406 blk.coeffs = [0; 64];
1412 for sb in self.sb_info.iter_mut() { *sb = SBState::Coded; }
1413 for blk in self.blocks.iter_mut() {
1414 blk.btype = VPMBType::Intra;
1418 if self.shuf.get_last().is_none() || self.shuf.get_golden().is_none() {
1419 return Err(DecoderError::MissingReference);
1421 self.vp40_unpack_sb_info(br)?;
1422 self.vp31_unpack_mb_info(br)?;
1423 self.vp40_unpack_mv_info(br)?;
1425 let dc_y_quant = VP40_DC_Y_SCALES[self.quant];
1426 let dc_c_quant = VP40_DC_C_SCALES[self.quant];
1427 let ac_quant = VP40_AC_SCALES[self.quant];
1428 rescale_qmat_vp4(&mut self.qmat_y, VP40_QMAT, dc_y_quant, ac_quant, true);
1429 rescale_qmat_vp4(&mut self.qmat_y_p, VP40_QMAT, dc_c_quant, ac_quant, false);
1430 self.qmat_c.copy_from_slice(&self.qmat_y);
1431 self.qmat_c_p.copy_from_slice(&self.qmat_y_p);
1434 let dc_table_y = br.read(4)? as usize;
1435 let dc_table_c = br.read(4)? as usize;
1436 let ac_table_y = br.read(4)? as usize;
1437 let ac_table_c = br.read(4)? as usize;
1438 self.vp40_unpack_coeffs(br, dc_table_y, dc_table_c, ac_table_y, ac_table_c)?;
1441 self.output_blocks_intra(frm);
1443 self.output_blocks_inter(frm);
1448 fn vp31_predict_dc(&self, bx: usize, by: usize, bw: usize, blk_idx: usize) -> i16 {
1449 let mut preds = [0i32; 4];
1450 let mut pp: usize = 0;
1451 let ref_id = self.blocks[blk_idx].btype.get_ref_id();
1452 let is_right = bx == bw - 1;
1454 fill_dc_pred!(self, ref_id, preds, pp, 0, blk_idx - 1);
1456 fill_dc_pred!(self, ref_id, preds, pp, 1, blk_idx - 1 - bw);
1460 fill_dc_pred!(self, ref_id, preds, pp, 2, blk_idx - bw);
1462 fill_dc_pred!(self, ref_id, preds, pp, 3, blk_idx + 1 - bw);
1465 if pp == 0 { return self.last_dc[ref_id as usize]; }
1466 let mut pred = 0i32;
1468 if (pp & (1 << i)) != 0 {
1469 pred += (preds[i] as i32) * i32::from(VP31_DC_WEIGHTS[pp][i]);
1472 pred /= i32::from(VP31_DC_WEIGHTS[pp][4]);
1474 if (pred - preds[2]).abs() > 128 { return preds[2] as i16; }
1475 if (pred - preds[0]).abs() > 128 { return preds[0] as i16; }
1476 if (pred - preds[1]).abs() > 128 { return preds[1] as i16; }
1480 fn vp40_predict_dc(&self, bx: usize, by: usize, bw: usize, bh: usize, blk_idx: usize, mask: usize, is_luma: bool) -> i16 {
1481 let mut preds = [0i32; 4];
1482 let mut pp: usize = 0;
1483 let ref_id = self.blocks[blk_idx].btype.get_ref_id();
1484 if (by > 0) && (((mask >> 3) & 1) == 1) { //top
1485 fill_dc_pred!(self, ref_id, preds, pp, 0, blk_idx - bw);
1487 if (by < bh - 1) && (((mask >> 2) & 1) == 1) { //bottom
1488 fill_dc_pred!(self, ref_id, preds, pp, 1, blk_idx + bw);
1490 if (bx > 0) && (((mask >> 1) & 1) == 1) { //left
1491 fill_dc_pred!(self, ref_id, preds, pp, 2, blk_idx - 1);
1493 if (is_luma && bx == 0 && (by >= 4)) && (((mask >> 1) & 1) == 1) { //left wrap
1494 fill_dc_pred!(self, ref_id, preds, pp, 2, blk_idx - 1 - 3 * bw);
1496 if (bx < bw - 1) && (((mask >> 0) & 1) == 1) { //right
1497 fill_dc_pred!(self, ref_id, preds, pp, 3, blk_idx + 1);
1499 if pp == 0 { return self.last_dc[ref_id as usize]; }
1500 let mut pred = 0i32;
1503 if (pp & (1 << i)) != 0 {
1504 pred += preds[i] as i32;
1507 return (pred / 2) as i16;
1511 self.last_dc[ref_id as usize]
1513 fn restore_dcs(&mut self) {
1514 let blk_stride = self.mb_w * 2;
1515 let mut blk_idx = 0;
1516 self.last_dc = [0; 3];
1517 for by in 0..self.mb_h*2 {
1518 for bx in 0..self.mb_w*2 {
1519 if !self.blocks[blk_idx + bx].coded { continue; }
1520 let dc = self.vp31_predict_dc(bx, by, self.mb_w*2, blk_idx + bx);
1521 self.blocks[blk_idx + bx].coeffs[0] += dc;
1522 self.last_dc[self.blocks[blk_idx + bx].btype.get_ref_id() as usize] = self.blocks[blk_idx + bx].coeffs[0];
1524 blk_idx += blk_stride;
1526 let blk_stride = self.mb_w;
1527 for _plane in 1..3 {
1528 self.last_dc = [0; 3];
1529 for by in 0..self.mb_h {
1530 for bx in 0..self.mb_w {
1531 if !self.blocks[blk_idx + bx].coded { continue; }
1532 let dc = self.vp31_predict_dc(bx, by, self.mb_w, blk_idx + bx);
1533 self.blocks[blk_idx + bx].coeffs[0] += dc;
1534 self.last_dc[self.blocks[blk_idx + bx].btype.get_ref_id() as usize] = self.blocks[blk_idx + bx].coeffs[0];
1536 blk_idx += blk_stride;
1540 fn output_blocks_intra(&mut self, frm: &mut NASimpleVideoFrame<u8>) {
1541 let mut biter = self.blocks.iter_mut();
1542 for by in 0..self.mb_h*2 {
1543 for bx in 0..self.mb_w*2 {
1544 let mut blk = biter.next().unwrap();
1545 let qmat = &self.qmat_y;
1546 blk.coeffs[0] *= qmat[0];
1548 unquant(&mut blk.coeffs, qmat);
1549 vp_put_block(&mut blk.coeffs, bx, by, 0, frm);
1551 vp_put_block_dc(&mut blk.coeffs, bx, by, 0, frm);
1556 for by in 0..self.mb_h {
1557 for bx in 0..self.mb_w {
1558 let mut blk = biter.next().unwrap();
1559 let qmat = &self.qmat_c;
1560 blk.coeffs[0] *= qmat[0];
1562 unquant(&mut blk.coeffs, qmat);
1563 vp_put_block(&mut blk.coeffs, bx, by, plane, frm);
1565 vp_put_block_dc(&mut blk.coeffs, bx, by, plane, frm);
1571 #[allow(clippy::cognitive_complexity)]
1572 fn output_blocks_inter(&mut self, frm: &mut NASimpleVideoFrame<u8>) {
1573 let mut blk_idx = 0;
1574 let bstride = self.mb_w * 2;
1575 for by in (0..self.mb_h*2).step_by(2) {
1576 for bx in (0..self.mb_w*2).step_by(2) {
1577 if self.blocks[blk_idx + bx].btype != VPMBType::InterFourMV {
1580 let mvs = [ self.blocks[blk_idx + bx].mv,
1581 self.blocks[blk_idx + bx + 1].mv,
1582 self.blocks[blk_idx + bx + bstride].mv,
1583 self.blocks[blk_idx + bx + 1 + bstride].mv ];
1584 let mut mv_sum = mvs[0] + mvs[1] + mvs[2] + mvs[3];
1585 mv_sum.x = (mv_sum.x + 2) >> 2;
1586 mv_sum.y = (mv_sum.y + 2) >> 2;
1588 let src = self.shuf.get_last().unwrap();
1590 let xoff = (i & 1) * 8;
1591 let yoff = (i >> 1) * 8;
1593 let mode = vp3_mv_mode(mvs[i].x, mvs[i].y);
1594 if self.version != 4 {
1595 copy_block(frm, src.clone(), 0, bx * 8 + xoff, by * 8 + yoff,
1596 mvs[i].x >> 1, mvs[i].y >> 1, 8, 8, 0, 1, mode, VP3_INTERP_FUNCS);
1598 vp_copy_block(frm, src.clone(), 0, bx * 8 + xoff, by * 8 + yoff,
1599 mvs[i].x >> 1, mvs[i].y >> 1, 0, 1, self.loop_str,
1600 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1604 let mx = (mv_sum.x >> 1) | (mv_sum.x & 1);
1605 let my = (mv_sum.y >> 1) | (mv_sum.y & 1);
1606 let mode = vp3_mv_mode(mx, my);
1607 copy_block(frm, src.clone(), 1, bx * 4, by * 4, mx >> 1, my >> 1, 8, 8, 0, 1, mode, VP3_INTERP_FUNCS);
1608 copy_block(frm, src.clone(), 2, bx * 4, by * 4, mx >> 1, my >> 1, 8, 8, 0, 1, mode, VP3_INTERP_FUNCS);
1610 blk_idx += bstride * 2;
1613 let mut biter = self.blocks.iter_mut();
1614 for by in 0..self.mb_h*2 {
1615 for bx in 0..self.mb_w*2 {
1616 let mut blk = biter.next().unwrap();
1617 // do MC for whole macroblock
1618 if !blk.btype.is_intra() && (((bx | by) & 1) == 0) && (blk.btype != VPMBType::InterFourMV) {
1619 let src = if blk.btype.get_ref_id() == 1 {
1620 self.shuf.get_last().unwrap()
1622 self.shuf.get_golden().unwrap()
1624 let mode = vp3_mv_mode(blk.mv.x, blk.mv.y);
1625 if self.version != 4 {
1626 copy_block(frm, src.clone(), 0, bx * 8, by * 8,
1627 blk.mv.x >> 1, blk.mv.y >> 1, 16, 16, 0, 1, mode, VP3_INTERP_FUNCS);
1629 vp_copy_block(frm, src.clone(), 0, bx * 8, by * 8,
1630 blk.mv.x >> 1, blk.mv.y >> 1, 0, 1, self.loop_str,
1631 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1632 vp_copy_block(frm, src.clone(), 0, bx * 8 + 8, by * 8,
1633 blk.mv.x >> 1, blk.mv.y >> 1, 0, 1, self.loop_str,
1634 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1635 vp_copy_block(frm, src.clone(), 0, bx * 8, by * 8 + 8,
1636 blk.mv.x >> 1, blk.mv.y >> 1, 0, 1, self.loop_str,
1637 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1638 vp_copy_block(frm, src.clone(), 0, bx * 8 + 8, by * 8 + 8,
1639 blk.mv.x >> 1, blk.mv.y >> 1, 0, 1, self.loop_str,
1640 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1642 let mx = (blk.mv.x >> 1) | (blk.mv.x & 1);
1643 let my = (blk.mv.y >> 1) | (blk.mv.y & 1);
1644 let mode = vp3_mv_mode(mx, my);
1645 if self.version != 4 {
1646 copy_block(frm, src.clone(), 1, bx * 4, by * 4,
1647 mx >> 1, my >> 1, 8, 8, 0, 1, mode, VP3_INTERP_FUNCS);
1648 copy_block(frm, src.clone(), 2, bx * 4, by * 4,
1649 mx >> 1, my >> 1, 8, 8, 0, 1, mode, VP3_INTERP_FUNCS);
1651 vp_copy_block(frm, src.clone(), 1, bx * 4, by * 4,
1652 mx >> 1, my >> 1, 0, 1, self.loop_str,
1653 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1654 vp_copy_block(frm, src.clone(), 2, bx * 4, by * 4,
1655 mx >> 1, my >> 1, 0, 1, self.loop_str,
1656 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1659 let qmat = if blk.btype.is_intra() { &self.qmat_y } else { &self.qmat_y_p };
1660 blk.coeffs[0] *= qmat[0];
1662 unquant(&mut blk.coeffs, qmat);
1665 copy_block(frm, self.shuf.get_last().unwrap(), 0, bx * 8, by * 8, 0, 0, 8, 8, 0, 1, 0, VP3_INTERP_FUNCS);
1666 } else if blk.btype.is_intra() {
1668 vp_put_block(&mut blk.coeffs, bx, by, 0, frm);
1670 vp_put_block_dc(&mut blk.coeffs, bx, by, 0, frm);
1674 vp_add_block(&mut blk.coeffs, bx, by, 0, frm);
1676 vp_add_block_dc(&mut blk.coeffs, bx, by, 0, frm);
1682 for by in 0..self.mb_h {
1683 for bx in 0..self.mb_w {
1684 let mut blk = biter.next().unwrap();
1685 let qmat = if blk.btype.is_intra() { &self.qmat_c } else { &self.qmat_c_p };
1686 blk.coeffs[0] *= qmat[0];
1688 unquant(&mut blk.coeffs, qmat);
1691 copy_block(frm, self.shuf.get_last().unwrap(), plane, bx * 8, by * 8, 0, 0, 8, 8, 0, 1, 0, VP3_INTERP_FUNCS);
1692 } else if blk.btype.is_intra() {
1694 vp_put_block(&mut blk.coeffs, bx, by, plane, frm);
1696 vp_put_block_dc(&mut blk.coeffs, bx, by, plane, frm);
1700 vp_add_block(&mut blk.coeffs, bx, by, plane, frm);
1702 vp_add_block_dc(&mut blk.coeffs, bx, by, plane, frm);
1709 fn vp31_loop_filter(&mut self, frm: &mut NASimpleVideoFrame<u8>) {
1710 let mut blk_idx = 0;
1711 let blk_w = self.mb_w * 2;
1712 for by in 0..self.mb_h*2 {
1713 for bx in 0..blk_w {
1714 let blk = &self.blocks[blk_idx + bx];
1715 if (bx > 0) && blk.coded {
1716 vp31_loop_filter_v(frm, bx * 8, by * 8, 0, self.loop_str);
1718 if (by > 0) && blk.coded {
1719 vp31_loop_filter_h(frm, bx * 8, by * 8, 0, self.loop_str);
1721 if (bx < blk_w - 1) && !self.blocks[blk_idx + bx + 1].coded {
1722 vp31_loop_filter_v(frm, bx * 8 + 8, by * 8, 0, self.loop_str);
1724 if (by < self.mb_h * 2 - 1) && !self.blocks[blk_idx + bx + blk_w].coded {
1725 vp31_loop_filter_h(frm, bx * 8, by * 8 + 8, 0, self.loop_str);
1730 let blk_w = self.mb_w;
1732 for by in 0..self.mb_h {
1733 for bx in 0..self.mb_w {
1734 let blk = &self.blocks[blk_idx + bx];
1735 if (bx > 0) && blk.coded {
1736 vp31_loop_filter_v(frm, bx * 8, by * 8, plane, self.loop_str);
1738 if (by > 0) && blk.coded {
1739 vp31_loop_filter_h(frm, bx * 8, by * 8, plane, self.loop_str);
1741 if (bx < blk_w - 1) && !self.blocks[blk_idx + bx + 1].coded {
1742 vp31_loop_filter_v(frm, bx * 8 + 8, by * 8, plane, self.loop_str);
1744 if (by < self.mb_h - 1) && !self.blocks[blk_idx + bx + blk_w].coded {
1745 vp31_loop_filter_h(frm, bx * 8, by * 8 + 8, plane, self.loop_str);
1752 fn generate_block_addr(&mut self) {
1753 let sb_w_y = (self.width + 31) >> 5;
1754 let sb_h_y = (self.height + 31) >> 5;
1755 let sb_w_c = ((self.width >> 1) + 31) >> 5;
1756 let sb_h_c = ((self.height >> 1) + 31) >> 5;
1757 self.y_sbs = sb_w_y * sb_h_y;
1758 let tot_sb = sb_w_y * sb_h_y + 2 * sb_w_c * sb_h_c;
1759 let tot_mb = self.mb_w * self.mb_h * 2 + ((self.mb_w + 1) & !1) * ((self.mb_h + 1) & !1) * 2;
1760 let bw = self.width >> 3;
1761 let bh = self.height >> 3;
1762 let tot_blk = bw * bh * 3 / 2;
1763 self.sb_info.resize(tot_sb, SBState::Uncoded);
1764 self.sb_blocks = Vec::with_capacity(tot_sb);
1765 self.mb_blocks = Vec::with_capacity(tot_mb);
1766 self.sb_mbs = Vec::with_capacity(tot_sb);
1767 self.blk_addr = Vec::with_capacity(tot_blk);
1768 self.blk_sub = Vec::with_capacity(tot_blk);
1769 self.y_blocks = bw * bh;
1770 let mut base_idx = 0;
1772 let w = if plane > 0 { self.width >> 1 } else { self.width };
1773 let h = if plane > 0 { self.height >> 1 } else { self.height };
1774 let sb_w = (w + 31) >> 5;
1775 let sb_h = (h + 31) >> 5;
1782 let bx = x * 4 + HILBERT_ORDER[mb_no * 4][0];
1783 let by = y * 4 + HILBERT_ORDER[mb_no * 4][1];
1784 if (bx >= blk_w) || (by >= blk_h) { continue; }
1785 let mut nblocks = 0;
1786 for blk_no in 0..4 {
1787 let bx = x * 4 + HILBERT_ORDER[mb_no * 4 + blk_no][0];
1788 let by = y * 4 + HILBERT_ORDER[mb_no * 4 + blk_no][1];
1789 if (bx >= blk_w) || (by >= blk_h) { continue; }
1792 self.mb_blocks.push(nblocks);
1795 self.sb_mbs.push(nmbs);
1797 let mut nblocks = 0;
1798 for blk_no in 0..16 {
1799 let bx = x * 4 + HILBERT_ORDER[blk_no][0];
1800 let by = y * 4 + HILBERT_ORDER[blk_no][1];
1801 if (bx >= blk_w) || (by >= blk_h) { continue; }
1802 let idx = base_idx + bx + by * blk_w;
1803 self.blk_addr.push(idx * 4 + plane);
1804 self.blk_sub.push(blk_no as u8);
1807 self.sb_blocks.push(nblocks);
1810 base_idx += blk_w * blk_h;
1812 self.blocks.resize(tot_blk, Block::new());
1813 self.mb_coded.resize(tot_mb, false);
1814 self.mb_partial.resize(tot_mb, false);
1818 impl NADecoder for VP34Decoder {
1819 fn init(&mut self, supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
1820 if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
1821 let fmt = YUV420_FORMAT;
1822 self.width = vinfo.get_width();
1823 self.height = vinfo.get_height();
1824 validate!(((self.width | self.height) & 15) == 0);
1825 self.mb_w = self.width >> 4;
1826 self.mb_h = self.height >> 4;
1827 let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), true, fmt));
1828 self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
1829 supp.pool_u8.set_dec_bufs(3);
1830 supp.pool_u8.prealloc_video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), true, fmt), 4)?;
1832 self.generate_block_addr();
1833 if self.version == 4 {
1834 self.codes = Codes::VP31(VP31Codes::new_vp4());
1835 self.aux_codes = Some(VP40AuxCodes::new());
1839 Err(DecoderError::InvalidData)
1842 fn decode(&mut self, supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
1843 let src = pkt.get_buffer();
1844 validate!(src.len() > 0);
1845 let mut br = BitReader::new(&src, BitReaderMode::BE);
1847 self.parse_header(&mut br)?;
1851 if !self.shuf.has_refs() {
1852 return Err(DecoderError::MissingReference);
1856 let ret = supp.pool_u8.get_free();
1858 return Err(DecoderError::AllocError);
1860 let mut buf = ret.unwrap();
1861 let mut dframe = NASimpleVideoFrame::from_video_buf(&mut buf).unwrap();
1862 match self.version {
1863 30 => self.decode_vp30(&mut br, &mut dframe)?,
1864 31 => self.decode_vp31(&mut br, &mut dframe)?,
1865 4 => self.decode_vp4(&mut br, &mut dframe)?,
1866 _ => return Err(DecoderError::Bug),
1869 if self.is_intra || self.update_gf {
1870 self.shuf.add_golden_frame(buf.clone());
1872 self.shuf.add_frame(buf.clone());
1874 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), NABufferType::Video(buf));
1875 frm.set_keyframe(self.is_intra);
1876 frm.set_frame_type(if self.is_intra { FrameType::I } else { FrameType::P });
1879 fn flush(&mut self) {
1884 impl NAOptionHandler for VP34Decoder {
1885 fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
1886 fn set_options(&mut self, _options: &[NAOption]) { }
1887 fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
1890 pub fn get_decoder_vp3() -> Box<dyn NADecoder + Send> {
1891 Box::new(VP34Decoder::new(3))
1894 pub fn get_decoder_vp4() -> Box<dyn NADecoder + Send> {
1895 Box::new(VP34Decoder::new(4))
1900 use nihav_core::codecs::RegisteredDecoders;
1901 use nihav_core::demuxers::RegisteredDemuxers;
1902 use nihav_codec_support::test::dec_video::*;
1903 use crate::duck_register_all_decoders;
1904 use nihav_commonfmt::generic_register_all_demuxers;
1908 let mut dmx_reg = RegisteredDemuxers::new();
1909 generic_register_all_demuxers(&mut dmx_reg);
1910 let mut dec_reg = RegisteredDecoders::new();
1911 duck_register_all_decoders(&mut dec_reg);
1913 // sample: https://samples.mplayerhq.hu/V-codecs/VP3/vp30-logo.avi
1914 test_decoding("avi", "vp3", "assets/Duck/vp30-logo.avi", Some(23), &dmx_reg, &dec_reg,
1915 ExpectedTestResult::MD5([0x51aba7df, 0x6e42534d, 0xef6c5b13, 0x26c38d1f]));
1920 let mut dmx_reg = RegisteredDemuxers::new();
1921 generic_register_all_demuxers(&mut dmx_reg);
1922 let mut dec_reg = RegisteredDecoders::new();
1923 duck_register_all_decoders(&mut dec_reg);
1925 // let file = "assets/Duck/vp31.avi";
1926 // let file = "assets/Duck/vp31_crash.avi";
1927 // let file = "assets/Duck/01-vp31-0500.avi";
1928 // test_file_decoding("avi", file, Some(3), true, false, None/*Some("vp31")*/, &dmx_reg, &dec_reg);
1930 // sample: https://samples.mplayerhq.hu/V-codecs/VP3/01-vp31-0500.avi
1931 test_decoding("avi", "vp3", "assets/Duck/01-vp31-0500.avi", Some(16), &dmx_reg, &dec_reg,
1932 ExpectedTestResult::MD5([0x65112f7e, 0x2914f29b, 0x2908ed2f, 0xce5fc8c5]));
1937 let mut dmx_reg = RegisteredDemuxers::new();
1938 generic_register_all_demuxers(&mut dmx_reg);
1939 let mut dec_reg = RegisteredDecoders::new();
1940 duck_register_all_decoders(&mut dec_reg);
1942 // sample: https://samples.mplayerhq.hu/V-codecs/VP4/ot171_vp40.avi
1943 test_decoding("avi", "vp3", "assets/Duck/ot171_vp40.avi", Some(86), &dmx_reg, &dec_reg,
1944 ExpectedTestResult::MD5([0xd41d8cd9, 0x8f00b204, 0xe9800998, 0xecf8427e]));
1948 const HILBERT_ORDER: [[usize; 2]; 16] = [
1949 [ 0, 0 ], [ 1, 0 ], [ 1, 1 ], [ 0, 1 ],
1950 [ 0, 2 ], [ 0, 3 ], [ 1, 3 ], [ 1, 2 ],
1951 [ 2, 2 ], [ 2, 3 ], [ 3, 3 ], [ 3, 2 ],
1952 [ 3, 1 ], [ 2, 1 ], [ 2, 0 ], [ 3, 0 ]
1955 const VP31_LOOP_STRENGTH: [i16; 64] = [
1956 30, 25, 20, 20, 15, 15, 14, 14,
1957 13, 13, 12, 12, 11, 11, 10, 10,
1958 9, 9, 8, 8, 7, 7, 7, 7,
1959 6, 6, 6, 6, 5, 5, 5, 5,
1960 4, 4, 4, 4, 3, 3, 3, 3,
1961 2, 2, 2, 2, 2, 2, 2, 2,
1962 0, 0, 0, 0, 0, 0, 0, 0,
1963 0, 0, 0, 0, 0, 0, 0, 0
1966 const VP31_DEFAULT_MB_MODES: [VPMBType; 8] = [
1967 VPMBType::InterNoMV, VPMBType::Intra, VPMBType::InterMV, VPMBType::InterNearest,
1968 VPMBType::InterNear, VPMBType::GoldenNoMV, VPMBType::GoldenMV, VPMBType::InterFourMV
1971 const VP31_MB_MODES: [[VPMBType; 8]; 6] = [
1973 VPMBType::InterNearest, VPMBType::InterNear, VPMBType::InterMV, VPMBType::InterNoMV,
1974 VPMBType::Intra, VPMBType::GoldenNoMV, VPMBType::GoldenMV, VPMBType::InterFourMV
1976 VPMBType::InterNearest, VPMBType::InterNear, VPMBType::InterNoMV, VPMBType::InterMV,
1977 VPMBType::Intra, VPMBType::GoldenNoMV, VPMBType::GoldenMV, VPMBType::InterFourMV
1979 VPMBType::InterNearest, VPMBType::InterMV, VPMBType::InterNear, VPMBType::InterNoMV,
1980 VPMBType::Intra, VPMBType::GoldenNoMV, VPMBType::GoldenMV, VPMBType::InterFourMV
1982 VPMBType::InterNearest, VPMBType::InterMV, VPMBType::InterNoMV, VPMBType::InterNear,
1983 VPMBType::Intra, VPMBType::GoldenNoMV, VPMBType::GoldenMV, VPMBType::InterFourMV
1985 VPMBType::InterNoMV, VPMBType::InterNearest, VPMBType::InterNear, VPMBType::InterMV,
1986 VPMBType::Intra, VPMBType::GoldenNoMV, VPMBType::GoldenMV, VPMBType::InterFourMV
1988 VPMBType::InterNoMV, VPMBType::GoldenNoMV, VPMBType::InterNearest, VPMBType::InterNear,
1989 VPMBType::InterMV, VPMBType::Intra, VPMBType::GoldenMV, VPMBType::InterFourMV
1993 const VP3_LITERAL_BASE: [i16; 6] = [ 7, 9, 13, 21, 37, 69 ];
1995 const VP31_AC_SCALES: [i16; 64] = [
1996 500, 450, 400, 370, 340, 310, 285, 265,
1997 245, 225, 210, 195, 185, 180, 170, 160,
1998 150, 145, 135, 130, 125, 115, 110, 107,
1999 100, 96, 93, 89, 85, 82, 75, 74,
2000 70, 68, 64, 60, 57, 56, 52, 50,
2001 49, 45, 44, 43, 40, 38, 37, 35,
2002 33, 32, 30, 29, 28, 25, 24, 22,
2003 21, 19, 18, 17, 15, 13, 12, 10
2006 const VP31_DC_SCALES: [i16; 64] = [
2007 220, 200, 190, 180, 170, 170, 160, 160,
2008 150, 150, 140, 140, 130, 130, 120, 120,
2009 110, 110, 100, 100, 90, 90, 90, 80,
2010 80, 80, 70, 70, 70, 60, 60, 60,
2011 60, 50, 50, 50, 50, 40, 40, 40,
2012 40, 40, 30, 30, 30, 30, 30, 30,
2013 30, 20, 20, 20, 20, 20, 20, 20,
2014 20, 10, 10, 10, 10, 10, 10, 10
2017 const VP3_QMAT_Y: &[i16; 64] = &[
2018 16, 11, 10, 16, 24, 40, 51, 61,
2019 12, 12, 14, 19, 26, 58, 60, 55,
2020 14, 13, 16, 24, 40, 57, 69, 56,
2021 14, 17, 22, 29, 51, 87, 80, 62,
2022 18, 22, 37, 58, 68, 109, 103, 77,
2023 24, 35, 55, 64, 81, 104, 113, 92,
2024 49, 64, 78, 87, 103, 121, 120, 101,
2025 72, 92, 95, 98, 112, 100, 103, 99
2028 const VP3_QMAT_C: &[i16; 64] = &[
2029 17, 18, 24, 47, 99, 99, 99, 99,
2030 18, 21, 26, 66, 99, 99, 99, 99,
2031 24, 26, 56, 99, 99, 99, 99, 99,
2032 47, 66, 99, 99, 99, 99, 99, 99,
2033 99, 99, 99, 99, 99, 99, 99, 99,
2034 99, 99, 99, 99, 99, 99, 99, 99,
2035 99, 99, 99, 99, 99, 99, 99, 99,
2036 99, 99, 99, 99, 99, 99, 99, 99
2039 const VP3_QMAT_INTER: &[i16; 64] = &[
2040 16, 16, 16, 20, 24, 28, 32, 40,
2041 16, 16, 20, 24, 28, 32, 40, 48,
2042 16, 20, 24, 28, 32, 40, 48, 64,
2043 20, 24, 28, 32, 40, 48, 64, 64,
2044 24, 28, 32, 40, 48, 64, 64, 64,
2045 28, 32, 40, 48, 64, 64, 64, 96,
2046 32, 40, 48, 64, 64, 64, 96, 128,
2047 40, 48, 64, 64, 64, 96, 128, 128
2050 const VP31_DC_CODES: [[u16; 32]; 16] = [
2052 0x002D, 0x0026, 0x0166, 0x004E, 0x02CE, 0x059E, 0x027D, 0x0008,
2053 0x04F9, 0x000F, 0x000E, 0x001B, 0x0006, 0x0008, 0x0005, 0x001A,
2054 0x0015, 0x0007, 0x000C, 0x0001, 0x0000, 0x0009, 0x0017, 0x0029,
2055 0x0028, 0x00B2, 0x04F8, 0x059F, 0x009E, 0x013F, 0x0012, 0x0058,
2057 0x0010, 0x0047, 0x01FF, 0x008C, 0x03FC, 0x046A, 0x0469, 0x0022,
2058 0x11A1, 0x000E, 0x000D, 0x0004, 0x0005, 0x0009, 0x0006, 0x001E,
2059 0x0016, 0x0007, 0x000C, 0x0001, 0x0000, 0x000A, 0x0017, 0x007D,
2060 0x007E, 0x011B, 0x08D1, 0x03FD, 0x046B, 0x11A0, 0x007C, 0x00FE,
2062 0x0016, 0x0020, 0x0086, 0x0087, 0x0367, 0x06CC, 0x06CB, 0x006E,
2063 0x366D, 0x000F, 0x000E, 0x0004, 0x0005, 0x000A, 0x0006, 0x001A,
2064 0x0011, 0x0007, 0x000C, 0x0001, 0x0000, 0x0009, 0x0017, 0x006F,
2065 0x006D, 0x0364, 0x0D9A, 0x06CA, 0x1B37, 0x366C, 0x0042, 0x00D8,
2067 0x0000, 0x002D, 0x00F7, 0x0058, 0x0167, 0x02CB, 0x02CA, 0x000E,
2068 0x1661, 0x0003, 0x0002, 0x0008, 0x0009, 0x000D, 0x0002, 0x001F,
2069 0x0017, 0x0001, 0x000C, 0x000E, 0x000A, 0x0006, 0x0078, 0x000F,
2070 0x007A, 0x0164, 0x0599, 0x02CD, 0x0B31, 0x1660, 0x0079, 0x00F6,
2072 0x0003, 0x003C, 0x000F, 0x007A, 0x001D, 0x0020, 0x0072, 0x0006,
2073 0x0399, 0x0004, 0x0005, 0x0005, 0x0006, 0x000E, 0x0004, 0x0000,
2074 0x0019, 0x0002, 0x000D, 0x0007, 0x001F, 0x0030, 0x0011, 0x0031,
2075 0x0005, 0x0021, 0x00E7, 0x0038, 0x01CD, 0x0398, 0x007B, 0x0009,
2077 0x0009, 0x0002, 0x0074, 0x0007, 0x00EC, 0x00D1, 0x01A6, 0x0006,
2078 0x0D21, 0x0005, 0x0006, 0x0008, 0x0007, 0x000F, 0x0004, 0x0000,
2079 0x001C, 0x0002, 0x0005, 0x0003, 0x000C, 0x0035, 0x01A7, 0x001B,
2080 0x0077, 0x01A5, 0x0349, 0x00D0, 0x0691, 0x0D20, 0x0075, 0x00ED,
2082 0x000A, 0x000C, 0x0012, 0x001B, 0x00B7, 0x016C, 0x0099, 0x005A,
2083 0x16D8, 0x0007, 0x0006, 0x0009, 0x0008, 0x0000, 0x0005, 0x0017,
2084 0x000E, 0x0002, 0x0003, 0x000F, 0x001A, 0x004D, 0x2DB3, 0x002C,
2085 0x0011, 0x02DA, 0x05B7, 0x0098, 0x0B6D, 0x2DB2, 0x0010, 0x0027,
2087 0x000D, 0x000F, 0x001D, 0x0008, 0x0051, 0x0056, 0x00AF, 0x002A,
2088 0x148A, 0x0007, 0x0000, 0x0008, 0x0009, 0x000C, 0x0006, 0x0017,
2089 0x000B, 0x0016, 0x0015, 0x0009, 0x0050, 0x00AE, 0x2917, 0x001C,
2090 0x0014, 0x0290, 0x0523, 0x0149, 0x0A44, 0x2916, 0x0053, 0x00A5,
2092 0x0001, 0x001D, 0x00F5, 0x00F4, 0x024D, 0x0499, 0x0498, 0x0001,
2093 0x0021, 0x0006, 0x0005, 0x0006, 0x0005, 0x0002, 0x0007, 0x0025,
2094 0x007B, 0x001C, 0x0020, 0x000D, 0x0048, 0x0092, 0x0127, 0x000E,
2095 0x0004, 0x0011, 0x000C, 0x003C, 0x000F, 0x0000, 0x001F, 0x0013,
2097 0x0005, 0x003C, 0x0040, 0x000D, 0x0031, 0x0061, 0x0060, 0x0002,
2098 0x00F5, 0x0006, 0x0005, 0x0007, 0x0006, 0x0002, 0x0009, 0x0025,
2099 0x0007, 0x0021, 0x0024, 0x0010, 0x0041, 0x00F4, 0x0019, 0x000E,
2100 0x0003, 0x0011, 0x0011, 0x003F, 0x003E, 0x007B, 0x0000, 0x0013,
2102 0x000A, 0x0007, 0x0001, 0x0009, 0x0131, 0x0261, 0x0260, 0x0015,
2103 0x0001, 0x0007, 0x0006, 0x0008, 0x0007, 0x0006, 0x0012, 0x002F,
2104 0x0014, 0x0027, 0x002D, 0x0016, 0x004D, 0x0099, 0x0000, 0x0004,
2105 0x0001, 0x0005, 0x0017, 0x002E, 0x002C, 0x0008, 0x0006, 0x0001,
2107 0x0000, 0x000E, 0x0017, 0x002A, 0x0010, 0x00F9, 0x00F8, 0x001E,
2108 0x003F, 0x0007, 0x0006, 0x0009, 0x0008, 0x0006, 0x000F, 0x0005,
2109 0x0016, 0x0029, 0x002B, 0x0015, 0x0050, 0x0011, 0x007D, 0x0004,
2110 0x0017, 0x0006, 0x0014, 0x002C, 0x002D, 0x000E, 0x0009, 0x0051,
2112 0x0002, 0x0018, 0x002F, 0x000D, 0x0053, 0x0295, 0x0294, 0x00A4,
2113 0x007C, 0x0000, 0x0007, 0x0009, 0x0008, 0x001B, 0x000C, 0x0028,
2114 0x006A, 0x001E, 0x001D, 0x0069, 0x00D7, 0x007D, 0x014B, 0x0019,
2115 0x0016, 0x002E, 0x001C, 0x002B, 0x002A, 0x0068, 0x003F, 0x00D6,
2117 0x0002, 0x001B, 0x000C, 0x0018, 0x0029, 0x007F, 0x02F0, 0x0198,
2118 0x0179, 0x0000, 0x0007, 0x0009, 0x0008, 0x001A, 0x000D, 0x002A,
2119 0x0064, 0x001E, 0x0067, 0x005F, 0x00CD, 0x007E, 0x02F1, 0x0016,
2120 0x000E, 0x002E, 0x0065, 0x002B, 0x0028, 0x003E, 0x00BD, 0x0199,
2122 0x0002, 0x0007, 0x0016, 0x0006, 0x0036, 0x005C, 0x015D, 0x015C,
2123 0x02BF, 0x0000, 0x0007, 0x0009, 0x0008, 0x0018, 0x0034, 0x002A,
2124 0x005E, 0x006A, 0x0064, 0x005D, 0x00CB, 0x00AD, 0x02BE, 0x0014,
2125 0x0033, 0x006E, 0x005F, 0x006F, 0x006B, 0x00CA, 0x00AC, 0x015E,
2127 0x000F, 0x001D, 0x0018, 0x000B, 0x0019, 0x0029, 0x00D6, 0x0551,
2128 0x0AA1, 0x0001, 0x0000, 0x0009, 0x0008, 0x001B, 0x0038, 0x0028,
2129 0x0057, 0x006A, 0x0068, 0x0056, 0x00E5, 0x0155, 0x0AA0, 0x0073,
2130 0x0069, 0x00D7, 0x00AB, 0x00E4, 0x00A9, 0x0151, 0x0150, 0x02A9,
2134 const VP31_DC_BITS: [[u8; 32]; 16] = [
2136 6, 7, 9, 8, 10, 11, 11, 5, 12, 4, 4, 5, 4, 4, 4, 5,
2137 5, 4, 4, 3, 3, 4, 5, 6, 6, 8, 12, 11, 9, 10, 6, 7,
2139 5, 7, 9, 8, 10, 11, 11, 6, 13, 4, 4, 4, 4, 4, 4, 5,
2140 5, 4, 4, 3, 3, 4, 5, 7, 7, 9, 12, 10, 11, 13, 7, 8,
2142 5, 6, 8, 8, 10, 11, 11, 7, 14, 4, 4, 4, 4, 4, 4, 5,
2143 5, 4, 4, 3, 3, 4, 5, 7, 7, 10, 12, 11, 13, 14, 7, 8,
2145 4, 6, 8, 7, 9, 10, 10, 6, 13, 3, 3, 4, 4, 4, 4, 5,
2146 5, 4, 4, 4, 4, 5, 7, 6, 7, 9, 11, 10, 12, 13, 7, 8,
2148 4, 6, 7, 7, 8, 9, 10, 6, 13, 3, 3, 4, 4, 4, 4, 4,
2149 5, 4, 4, 4, 5, 6, 8, 6, 6, 9, 11, 9, 12, 13, 7, 7,
2151 4, 5, 7, 6, 8, 9, 10, 6, 13, 3, 3, 4, 4, 4, 4, 4,
2152 5, 4, 4, 4, 5, 7, 10, 6, 7, 10, 11, 9, 12, 13, 7, 8,
2154 4, 5, 6, 6, 8, 9, 9, 7, 13, 3, 3, 4, 4, 3, 4, 5,
2155 5, 4, 4, 5, 6, 8, 14, 6, 6, 10, 11, 9, 12, 14, 6, 7,
2157 4, 5, 6, 5, 7, 8, 9, 7, 13, 3, 2, 4, 4, 4, 4, 5,
2158 5, 5, 5, 5, 7, 9, 14, 6, 6, 10, 11, 9, 12, 14, 7, 8,
2160 4, 6, 8, 8, 10, 11, 11, 5, 6, 3, 3, 4, 4, 4, 5, 6,
2161 7, 6, 6, 6, 7, 8, 9, 4, 4, 5, 6, 6, 5, 5, 5, 5,
2163 4, 6, 7, 7, 9, 10, 10, 5, 8, 3, 3, 4, 4, 4, 5, 6,
2164 6, 6, 6, 6, 7, 8, 8, 4, 4, 5, 6, 6, 6, 7, 4, 5,
2166 4, 5, 6, 6, 9, 10, 10, 6, 7, 3, 3, 4, 4, 4, 5, 6,
2167 6, 6, 6, 6, 7, 8, 7, 4, 4, 5, 6, 6, 6, 6, 5, 5,
2169 3, 5, 6, 6, 7, 10, 10, 7, 8, 3, 3, 4, 4, 4, 5, 5,
2170 6, 6, 6, 6, 7, 7, 9, 4, 5, 5, 6, 6, 6, 6, 6, 7,
2172 3, 5, 6, 5, 7, 10, 10, 8, 8, 2, 3, 4, 4, 5, 5, 6,
2173 7, 6, 6, 7, 8, 8, 9, 5, 5, 6, 6, 6, 6, 7, 7, 8,
2175 3, 5, 5, 5, 6, 8, 10, 9, 9, 2, 3, 4, 4, 5, 5, 6,
2176 7, 6, 7, 7, 8, 8, 10, 5, 5, 6, 7, 6, 6, 7, 8, 9,
2178 3, 4, 5, 4, 6, 7, 9, 9, 10, 2, 3, 4, 4, 5, 6, 6,
2179 7, 7, 7, 7, 8, 8, 10, 5, 6, 7, 7, 7, 7, 8, 8, 9,
2181 4, 5, 5, 4, 5, 6, 8, 11, 12, 2, 2, 4, 4, 5, 6, 6,
2182 7, 7, 7, 7, 8, 9, 12, 7, 7, 8, 8, 8, 8, 9, 9, 10,
2186 const VP31_AC_CAT0_CODES: [[u16; 32]; 16] = [
2188 0x0008, 0x0025, 0x017A, 0x02F7, 0x0BDB, 0x17B4, 0x2F6B, 0x001D,
2189 0x2F6A, 0x0008, 0x0007, 0x0001, 0x0002, 0x000A, 0x0006, 0x0000,
2190 0x001C, 0x0009, 0x000D, 0x000F, 0x000C, 0x0003, 0x000A, 0x0016,
2191 0x0013, 0x005D, 0x0024, 0x00BC, 0x005C, 0x05EC, 0x000B, 0x005F,
2193 0x000F, 0x0010, 0x004B, 0x00C6, 0x031D, 0x0C71, 0x0C70, 0x0001,
2194 0x0C73, 0x0008, 0x0009, 0x0002, 0x0003, 0x000B, 0x0006, 0x0000,
2195 0x001C, 0x0005, 0x000D, 0x000F, 0x000A, 0x0019, 0x0013, 0x001D,
2196 0x0030, 0x0062, 0x0024, 0x004A, 0x018F, 0x0C72, 0x000E, 0x0011,
2198 0x001B, 0x0003, 0x008D, 0x0040, 0x0239, 0x0471, 0x08E0, 0x0003,
2199 0x11C3, 0x000A, 0x0009, 0x0004, 0x0005, 0x000E, 0x0007, 0x0001,
2200 0x001E, 0x0006, 0x000C, 0x000B, 0x0002, 0x0000, 0x0041, 0x001F,
2201 0x0022, 0x0002, 0x008F, 0x008C, 0x011D, 0x11C2, 0x001A, 0x0021,
2203 0x001F, 0x0003, 0x0003, 0x0043, 0x000B, 0x0015, 0x0051, 0x0003,
2204 0x0050, 0x000D, 0x000C, 0x0004, 0x0006, 0x000E, 0x000A, 0x0001,
2205 0x001E, 0x0005, 0x0009, 0x0007, 0x0011, 0x0002, 0x0004, 0x0002,
2206 0x002D, 0x0020, 0x0042, 0x0001, 0x0000, 0x0029, 0x0017, 0x002C,
2208 0x0003, 0x001F, 0x003A, 0x005D, 0x0173, 0x02E4, 0x172D, 0x0004,
2209 0x172C, 0x000F, 0x000E, 0x0009, 0x0008, 0x000C, 0x000A, 0x0001,
2210 0x0016, 0x0002, 0x0005, 0x001A, 0x002F, 0x0038, 0x05CA, 0x0006,
2211 0x0037, 0x001E, 0x003B, 0x0039, 0x00B8, 0x0B97, 0x0000, 0x0036,
2213 0x0006, 0x0037, 0x005D, 0x000C, 0x00B9, 0x02E3, 0x05C4, 0x0004,
2214 0x1715, 0x0000, 0x000F, 0x0008, 0x0007, 0x000C, 0x0009, 0x001D,
2215 0x0016, 0x001C, 0x001A, 0x000B, 0x005E, 0x0170, 0x1714, 0x000A,
2216 0x000A, 0x0036, 0x005F, 0x001B, 0x001A, 0x0B8B, 0x0002, 0x0007,
2218 0x000C, 0x000B, 0x0079, 0x0022, 0x00F0, 0x0119, 0x0230, 0x001D,
2219 0x08C4, 0x0001, 0x0000, 0x000A, 0x0009, 0x000B, 0x0007, 0x001C,
2220 0x003D, 0x000D, 0x0008, 0x0015, 0x008D, 0x118B, 0x118A, 0x000D,
2221 0x0010, 0x0009, 0x0014, 0x0047, 0x00F1, 0x0463, 0x001F, 0x000C,
2223 0x0000, 0x001A, 0x0033, 0x000C, 0x0046, 0x01E3, 0x03C5, 0x0017,
2224 0x1E21, 0x0002, 0x0001, 0x0009, 0x000A, 0x0007, 0x001B, 0x003D,
2225 0x001B, 0x0022, 0x0079, 0x00F0, 0x1E20, 0x1E23, 0x1E22, 0x000E,
2226 0x0016, 0x0018, 0x0032, 0x001A, 0x0047, 0x0789, 0x001F, 0x0010,
2228 0x001D, 0x0061, 0x004E, 0x009E, 0x027C, 0x09F5, 0x09F4, 0x0003,
2229 0x0060, 0x0000, 0x000F, 0x000B, 0x000A, 0x0009, 0x0005, 0x000D,
2230 0x0031, 0x0008, 0x0038, 0x0012, 0x0026, 0x013F, 0x04FB, 0x000D,
2231 0x0002, 0x000C, 0x0039, 0x001C, 0x000F, 0x001D, 0x0008, 0x0019,
2233 0x0007, 0x0019, 0x00AB, 0x00AA, 0x0119, 0x0461, 0x0460, 0x001B,
2234 0x0047, 0x0001, 0x0000, 0x000C, 0x000B, 0x0009, 0x0005, 0x000D,
2235 0x0035, 0x003D, 0x003C, 0x0018, 0x0022, 0x008D, 0x0231, 0x000E,
2236 0x001F, 0x0009, 0x002B, 0x0010, 0x0034, 0x0054, 0x0008, 0x0014,
2238 0x000C, 0x0005, 0x0008, 0x005B, 0x004D, 0x0131, 0x0261, 0x001A,
2239 0x0012, 0x0000, 0x000F, 0x000A, 0x0009, 0x0006, 0x001B, 0x0006,
2240 0x001C, 0x002C, 0x0015, 0x005A, 0x0027, 0x0099, 0x0260, 0x000E,
2241 0x0004, 0x000F, 0x0007, 0x001D, 0x000B, 0x0014, 0x0008, 0x0017,
2243 0x000F, 0x0013, 0x0075, 0x0024, 0x0095, 0x0251, 0x04A0, 0x0010,
2244 0x00C8, 0x0002, 0x0001, 0x0001, 0x0000, 0x001A, 0x0011, 0x002C,
2245 0x0065, 0x0074, 0x004B, 0x00C9, 0x0129, 0x0943, 0x0942, 0x0003,
2246 0x000A, 0x001C, 0x0018, 0x0033, 0x0017, 0x002D, 0x001B, 0x003B,
2248 0x0003, 0x001A, 0x002D, 0x0038, 0x0028, 0x0395, 0x0E51, 0x0037,
2249 0x00E4, 0x0001, 0x0000, 0x001F, 0x001E, 0x0017, 0x003A, 0x0073,
2250 0x002A, 0x002B, 0x0029, 0x01CB, 0x0729, 0x1CA1, 0x1CA0, 0x0004,
2251 0x000A, 0x0004, 0x0018, 0x0036, 0x000B, 0x002C, 0x0019, 0x003B,
2253 0x0004, 0x0004, 0x003F, 0x0017, 0x0075, 0x01F5, 0x07D1, 0x0017,
2254 0x01F6, 0x0001, 0x0000, 0x001B, 0x001A, 0x000A, 0x0032, 0x0074,
2255 0x00F8, 0x00F9, 0x01F7, 0x03E9, 0x0FA0, 0x1F43, 0x1F42, 0x0003,
2256 0x000A, 0x001E, 0x001C, 0x003B, 0x0018, 0x0016, 0x0016, 0x0033,
2258 0x0004, 0x0007, 0x0018, 0x001E, 0x0036, 0x0031, 0x0177, 0x0077,
2259 0x0176, 0x0001, 0x0000, 0x001A, 0x0019, 0x003A, 0x0019, 0x005C,
2260 0x00BA, 0x0061, 0x00C1, 0x0180, 0x0302, 0x0607, 0x0606, 0x0002,
2261 0x000A, 0x001F, 0x001C, 0x0037, 0x0016, 0x0076, 0x000D, 0x002F,
2263 0x0000, 0x000A, 0x001A, 0x000C, 0x001D, 0x0039, 0x0078, 0x005E,
2264 0x0393, 0x0002, 0x0001, 0x0016, 0x000F, 0x002E, 0x005F, 0x0073,
2265 0x00E5, 0x01C8, 0x0E4A, 0x1C97, 0x1C96, 0x0E49, 0x0E48, 0x0004,
2266 0x0006, 0x001F, 0x001B, 0x001D, 0x0038, 0x0038, 0x003D, 0x0079,
2270 const VP31_AC_CAT0_BITS: [[u8; 32]; 16] = [
2272 5, 7, 9, 10, 12, 13, 14, 5, 14, 4, 4, 4, 4, 4, 4, 4,
2273 5, 4, 4, 4, 4, 4, 5, 5, 6, 7, 7, 8, 7, 11, 5, 7,
2275 5, 6, 8, 8, 10, 12, 12, 4, 12, 4, 4, 4, 4, 4, 4, 4,
2276 5, 4, 4, 4, 4, 5, 6, 5, 6, 7, 7, 8, 9, 12, 5, 6,
2278 5, 6, 8, 7, 10, 11, 12, 4, 13, 4, 4, 4, 4, 4, 4, 4,
2279 5, 4, 4, 4, 4, 5, 7, 5, 6, 6, 8, 8, 9, 13, 5, 6,
2281 5, 6, 7, 7, 9, 10, 12, 4, 12, 4, 4, 4, 4, 4, 4, 4,
2282 5, 4, 4, 4, 5, 6, 8, 4, 6, 6, 7, 7, 7, 11, 5, 6,
2284 4, 6, 7, 7, 9, 10, 13, 4, 13, 4, 4, 4, 4, 4, 4, 4,
2285 5, 4, 4, 5, 6, 7, 11, 4, 6, 6, 7, 7, 8, 12, 4, 6,
2287 4, 6, 7, 6, 8, 10, 11, 4, 13, 3, 4, 4, 4, 4, 4, 5,
2288 5, 5, 5, 5, 7, 9, 13, 4, 5, 6, 7, 7, 7, 12, 4, 5,
2290 4, 5, 7, 6, 8, 9, 10, 5, 12, 3, 3, 4, 4, 4, 4, 5,
2291 6, 5, 5, 6, 8, 13, 13, 4, 5, 5, 6, 7, 8, 11, 5, 5,
2293 3, 5, 6, 5, 7, 9, 10, 5, 13, 3, 3, 4, 4, 4, 5, 6,
2294 6, 6, 7, 8, 13, 13, 13, 4, 5, 5, 6, 6, 7, 11, 5, 5,
2296 5, 7, 8, 9, 11, 13, 13, 4, 7, 3, 4, 4, 4, 4, 4, 5,
2297 6, 5, 6, 6, 7, 10, 12, 4, 4, 5, 6, 6, 5, 6, 4, 5,
2299 4, 6, 8, 8, 10, 12, 12, 5, 8, 3, 3, 4, 4, 4, 4, 5,
2300 6, 6, 6, 6, 7, 9, 11, 4, 5, 5, 6, 6, 6, 7, 4, 5,
2302 4, 5, 6, 7, 9, 11, 12, 5, 7, 3, 4, 4, 4, 4, 5, 5,
2303 6, 6, 6, 7, 8, 10, 12, 4, 4, 5, 5, 6, 5, 6, 4, 5,
2305 4, 5, 7, 6, 8, 10, 11, 5, 8, 3, 3, 4, 4, 5, 5, 6,
2306 7, 7, 7, 8, 9, 12, 12, 3, 4, 5, 5, 6, 5, 6, 5, 6,
2308 3, 5, 6, 6, 7, 10, 12, 6, 8, 3, 3, 5, 5, 5, 6, 7,
2309 7, 7, 7, 9, 11, 13, 13, 3, 4, 4, 5, 6, 5, 6, 5, 6,
2311 3, 4, 6, 5, 7, 9, 11, 6, 9, 3, 3, 5, 5, 5, 6, 7,
2312 8, 8, 9, 10, 12, 13, 13, 3, 4, 5, 5, 6, 5, 6, 5, 6,
2314 3, 4, 5, 5, 6, 7, 9, 7, 9, 3, 3, 5, 5, 6, 6, 7,
2315 8, 8, 9, 10, 11, 12, 12, 3, 4, 5, 5, 6, 5, 7, 5, 6,
2317 3, 4, 5, 4, 5, 6, 7, 7, 11, 3, 3, 5, 5, 6, 7, 8,
2318 9, 10, 13, 14, 14, 13, 13, 3, 4, 5, 5, 6, 6, 7, 6, 7,
2322 const VP31_AC_CAT1_CODES: [[u16; 32]; 16] = [
2324 0x000B, 0x002B, 0x0054, 0x01B7, 0x06D9, 0x0DB1, 0x0DB0, 0x0002,
2325 0x00AB, 0x0009, 0x000A, 0x0007, 0x0008, 0x000F, 0x000C, 0x0003,
2326 0x001D, 0x0004, 0x000B, 0x0006, 0x001A, 0x0003, 0x00AA, 0x0001,
2327 0x0000, 0x0014, 0x006C, 0x00DA, 0x0002, 0x036D, 0x001C, 0x0037,
2329 0x001D, 0x0004, 0x00B6, 0x006A, 0x05B9, 0x16E1, 0x16E0, 0x0007,
2330 0x016F, 0x000C, 0x000D, 0x0009, 0x0008, 0x000F, 0x000A, 0x0003,
2331 0x0017, 0x0002, 0x0004, 0x001C, 0x002C, 0x006B, 0x0B71, 0x0005,
2332 0x0003, 0x001B, 0x005A, 0x0034, 0x0005, 0x02DD, 0x0000, 0x000C,
2334 0x0003, 0x007F, 0x00A1, 0x00A0, 0x020C, 0x0834, 0x106B, 0x0007,
2335 0x0082, 0x000E, 0x000D, 0x000B, 0x000C, 0x0000, 0x0009, 0x0002,
2336 0x0011, 0x001E, 0x0015, 0x003E, 0x0040, 0x041B, 0x106A, 0x0006,
2337 0x000A, 0x0029, 0x007E, 0x0051, 0x0021, 0x0107, 0x0004, 0x000B,
2339 0x0007, 0x001B, 0x00F6, 0x00E9, 0x03A1, 0x0740, 0x0E82, 0x001F,
2340 0x01EF, 0x0001, 0x0002, 0x000B, 0x000C, 0x000D, 0x0008, 0x001C,
2341 0x0003, 0x0012, 0x0002, 0x0075, 0x01D1, 0x1D07, 0x1D06, 0x000A,
2342 0x0013, 0x003B, 0x001A, 0x007A, 0x003C, 0x01EE, 0x0000, 0x000C,
2344 0x000D, 0x003D, 0x0042, 0x0037, 0x00D9, 0x0362, 0x06C6, 0x001F,
2345 0x0086, 0x0001, 0x0002, 0x000C, 0x000B, 0x000A, 0x0001, 0x000F,
2346 0x0025, 0x003C, 0x001A, 0x0087, 0x01B0, 0x0D8F, 0x0D8E, 0x000E,
2347 0x0013, 0x000C, 0x0024, 0x0020, 0x0011, 0x006D, 0x0000, 0x000E,
2349 0x0000, 0x0012, 0x0076, 0x0077, 0x014D, 0x0533, 0x14C9, 0x0013,
2350 0x00A5, 0x0002, 0x0003, 0x000B, 0x000C, 0x0008, 0x001A, 0x002B,
2351 0x0075, 0x0074, 0x00A7, 0x0298, 0x14C8, 0x14CB, 0x14CA, 0x000F,
2352 0x001C, 0x0007, 0x002A, 0x0028, 0x001B, 0x00A4, 0x0002, 0x0006,
2354 0x0002, 0x001A, 0x002B, 0x003A, 0x00ED, 0x0283, 0x0A0A, 0x0004,
2355 0x00A1, 0x0004, 0x0003, 0x000B, 0x000C, 0x001F, 0x0006, 0x0077,
2356 0x00A3, 0x00A2, 0x0140, 0x1417, 0x1416, 0x0A09, 0x0A08, 0x0000,
2357 0x001E, 0x0007, 0x002A, 0x0029, 0x001C, 0x00EC, 0x001B, 0x0005,
2359 0x0002, 0x0002, 0x0018, 0x001D, 0x0035, 0x00E4, 0x01CF, 0x001D,
2360 0x0072, 0x0004, 0x0005, 0x0006, 0x0007, 0x0006, 0x0073, 0x0038,
2361 0x01CE, 0x039B, 0x0398, 0x0733, 0x0732, 0x0735, 0x0734, 0x0000,
2362 0x001F, 0x001B, 0x0034, 0x000F, 0x001E, 0x00E5, 0x0019, 0x0038,
2364 0x0016, 0x0050, 0x0172, 0x02E7, 0x1732, 0x2E67, 0x2E66, 0x0006,
2365 0x0051, 0x0001, 0x0000, 0x000D, 0x000C, 0x0009, 0x001C, 0x0009,
2366 0x001C, 0x001D, 0x005D, 0x00B8, 0x05CD, 0x1731, 0x1730, 0x000F,
2367 0x0005, 0x000F, 0x0008, 0x0029, 0x001D, 0x002F, 0x0008, 0x0015,
2369 0x0009, 0x0021, 0x0040, 0x00AD, 0x02B0, 0x1589, 0x1588, 0x001C,
2370 0x005F, 0x0000, 0x000F, 0x000D, 0x000C, 0x0006, 0x0011, 0x002A,
2371 0x0057, 0x005E, 0x0041, 0x0159, 0x0563, 0x158B, 0x158A, 0x0001,
2372 0x0005, 0x0014, 0x003B, 0x002E, 0x0004, 0x003A, 0x0007, 0x0016,
2374 0x000E, 0x0007, 0x0046, 0x0045, 0x0064, 0x032A, 0x0657, 0x0018,
2375 0x000D, 0x0000, 0x000F, 0x000A, 0x000B, 0x001A, 0x0036, 0x0047,
2376 0x0044, 0x0018, 0x0033, 0x00CB, 0x0656, 0x0329, 0x0328, 0x0002,
2377 0x0006, 0x0019, 0x000E, 0x0037, 0x0009, 0x000F, 0x0002, 0x0010,
2379 0x0003, 0x0018, 0x0023, 0x0077, 0x0194, 0x1956, 0x32AF, 0x003A,
2380 0x0076, 0x0002, 0x0001, 0x001F, 0x001E, 0x0014, 0x0022, 0x0064,
2381 0x0197, 0x0196, 0x032B, 0x0654, 0x32AE, 0x1955, 0x1954, 0x0000,
2382 0x0009, 0x001C, 0x0015, 0x0010, 0x000D, 0x0017, 0x0016, 0x0033,
2384 0x0005, 0x0006, 0x003E, 0x0010, 0x0048, 0x093F, 0x24FA, 0x0032,
2385 0x0067, 0x0002, 0x0001, 0x001B, 0x001E, 0x0034, 0x0066, 0x0092,
2386 0x0126, 0x024E, 0x049E, 0x49F7, 0x49F6, 0x24F9, 0x24F8, 0x0000,
2387 0x0007, 0x0018, 0x0011, 0x003F, 0x000E, 0x0013, 0x0035, 0x0025,
2389 0x0005, 0x0008, 0x0012, 0x001C, 0x001C, 0x00EA, 0x1D75, 0x001E,
2390 0x0066, 0x0001, 0x0002, 0x001B, 0x001A, 0x001F, 0x003B, 0x0074,
2391 0x01D6, 0x03AF, 0x1D74, 0x1D77, 0x1D76, 0x0EB9, 0x0EB8, 0x000F,
2392 0x0006, 0x0013, 0x003B, 0x003A, 0x0000, 0x0018, 0x0032, 0x0067,
2394 0x0004, 0x000A, 0x001B, 0x000C, 0x000D, 0x00E6, 0x0684, 0x0072,
2395 0x00E7, 0x0002, 0x0001, 0x0017, 0x0016, 0x0018, 0x00D1, 0x01A0,
2396 0x0686, 0x0D0F, 0x0D0A, 0x1A17, 0x1A16, 0x1A1D, 0x1A1C, 0x000F,
2397 0x001D, 0x000E, 0x0035, 0x0038, 0x0000, 0x000F, 0x0019, 0x0069,
2399 0x0003, 0x000C, 0x001B, 0x0000, 0x0003, 0x002E, 0x0051, 0x00BC,
2400 0x0053, 0x0004, 0x0002, 0x0016, 0x0015, 0x0015, 0x0050, 0x00A4,
2401 0x0294, 0x052B, 0x052A, 0x052D, 0x052C, 0x052F, 0x052E, 0x000E,
2402 0x001A, 0x0004, 0x0028, 0x0029, 0x000F, 0x000B, 0x005F, 0x00BD,
2406 const VP31_AC_CAT1_BITS: [[u8; 32]; 16] = [
2408 5, 7, 8, 9, 11, 12, 12, 4, 9, 4, 4, 4, 4, 4, 4, 4,
2409 5, 4, 4, 4, 5, 6, 9, 4, 5, 6, 7, 8, 6, 10, 5, 6,
2411 5, 6, 8, 8, 11, 13, 13, 4, 9, 4, 4, 4, 4, 4, 4, 4,
2412 5, 4, 4, 5, 6, 8, 12, 4, 5, 6, 7, 7, 6, 10, 4, 5,
2414 4, 7, 8, 8, 10, 12, 13, 4, 8, 4, 4, 4, 4, 3, 4, 4,
2415 5, 5, 5, 6, 7, 11, 13, 4, 5, 6, 7, 7, 6, 9, 4, 5,
2417 4, 6, 8, 8, 10, 11, 12, 5, 9, 3, 3, 4, 4, 4, 4, 5,
2418 5, 5, 5, 7, 9, 13, 13, 4, 5, 6, 6, 7, 6, 9, 4, 5,
2420 4, 6, 7, 7, 9, 11, 12, 5, 8, 3, 3, 4, 4, 4, 4, 5,
2421 6, 6, 6, 8, 10, 13, 13, 4, 5, 5, 6, 6, 5, 8, 4, 5,
2423 3, 5, 7, 7, 9, 11, 13, 5, 8, 3, 3, 4, 4, 4, 5, 6,
2424 7, 7, 8, 10, 13, 13, 13, 4, 5, 5, 6, 6, 5, 8, 4, 5,
2426 3, 5, 6, 6, 8, 10, 12, 5, 8, 3, 3, 4, 4, 5, 5, 7,
2427 8, 8, 9, 13, 13, 12, 12, 3, 5, 5, 6, 6, 5, 8, 5, 5,
2429 3, 4, 5, 5, 6, 8, 11, 7, 9, 3, 3, 4, 4, 5, 7, 8,
2430 11, 12, 12, 13, 13, 13, 13, 3, 5, 5, 6, 6, 5, 8, 5, 6,
2432 5, 7, 9, 10, 13, 14, 14, 4, 7, 3, 3, 4, 4, 4, 5, 5,
2433 6, 6, 7, 8, 11, 13, 13, 4, 4, 5, 5, 6, 5, 6, 4, 5,
2435 4, 6, 7, 8, 10, 13, 13, 5, 7, 3, 4, 4, 4, 4, 5, 6,
2436 7, 7, 7, 9, 11, 13, 13, 3, 4, 5, 6, 6, 4, 6, 4, 5,
2438 4, 5, 7, 7, 9, 12, 13, 5, 6, 3, 4, 4, 4, 5, 6, 7,
2439 7, 7, 8, 10, 13, 12, 12, 3, 4, 5, 5, 6, 4, 5, 4, 5,
2441 3, 5, 6, 7, 9, 13, 14, 6, 7, 3, 3, 5, 5, 5, 6, 7,
2442 9, 9, 10, 11, 14, 13, 13, 3, 4, 5, 5, 5, 4, 5, 5, 6,
2444 3, 4, 6, 5, 7, 12, 14, 6, 7, 3, 3, 5, 5, 6, 7, 8,
2445 9, 10, 11, 15, 15, 14, 14, 3, 4, 5, 5, 6, 4, 5, 6, 6,
2447 3, 4, 5, 5, 6, 9, 14, 6, 7, 3, 3, 5, 5, 6, 7, 8,
2448 10, 11, 14, 14, 14, 13, 13, 4, 4, 5, 6, 6, 3, 5, 6, 7,
2450 3, 4, 5, 4, 5, 8, 11, 7, 8, 3, 3, 5, 5, 6, 8, 9,
2451 11, 12, 12, 13, 13, 13, 13, 4, 5, 5, 6, 6, 3, 5, 6, 7,
2453 3, 4, 5, 3, 4, 6, 9, 8, 9, 3, 3, 5, 5, 7, 9, 10,
2454 12, 13, 13, 13, 13, 13, 13, 4, 5, 5, 6, 6, 4, 6, 7, 8,
2458 const VP31_AC_CAT2_CODES: [[u16; 32]; 16] = [
2460 0x0003, 0x0009, 0x00D0, 0x01A3, 0x0344, 0x0D14, 0x1A2B, 0x0004,
2461 0x0015, 0x0000, 0x000F, 0x000B, 0x000C, 0x000E, 0x0009, 0x001B,
2462 0x000A, 0x0014, 0x000D, 0x002A, 0x0014, 0x068B, 0x1A2A, 0x0008,
2463 0x000B, 0x002B, 0x000B, 0x0069, 0x0035, 0x0008, 0x0007, 0x000C,
2465 0x000A, 0x003C, 0x0032, 0x0030, 0x00C5, 0x0621, 0x0620, 0x001F,
2466 0x0033, 0x0001, 0x0000, 0x000E, 0x000D, 0x000C, 0x0004, 0x000D,
2467 0x0026, 0x0027, 0x0014, 0x0063, 0x0189, 0x0623, 0x0622, 0x000B,
2468 0x0012, 0x003D, 0x0022, 0x0015, 0x000B, 0x0023, 0x0007, 0x0010,
2470 0x000F, 0x000C, 0x0043, 0x0010, 0x0044, 0x0114, 0x0455, 0x0018,
2471 0x0023, 0x0001, 0x0000, 0x000E, 0x000D, 0x0009, 0x0019, 0x0009,
2472 0x0017, 0x0016, 0x0042, 0x008B, 0x0454, 0x0457, 0x0456, 0x000B,
2473 0x0015, 0x000A, 0x0029, 0x0020, 0x000D, 0x0028, 0x0007, 0x0011,
2475 0x0001, 0x001A, 0x0029, 0x002A, 0x00A0, 0x0285, 0x1425, 0x0002,
2476 0x0000, 0x0002, 0x0003, 0x000C, 0x000B, 0x0008, 0x0012, 0x0001,
2477 0x0051, 0x0001, 0x0143, 0x0508, 0x1424, 0x1427, 0x1426, 0x000F,
2478 0x001C, 0x0003, 0x0037, 0x002B, 0x0013, 0x0036, 0x001D, 0x0001,
2480 0x0004, 0x001F, 0x003D, 0x0006, 0x0016, 0x0053, 0x014A, 0x0034,
2481 0x002A, 0x0002, 0x0003, 0x000B, 0x000C, 0x001C, 0x0037, 0x0017,
2482 0x002B, 0x0028, 0x00A4, 0x052D, 0x052C, 0x052F, 0x052E, 0x0000,
2483 0x001D, 0x0007, 0x0004, 0x0035, 0x0014, 0x0036, 0x0015, 0x003C,
2485 0x0004, 0x000A, 0x0007, 0x001D, 0x0009, 0x01F3, 0x07C7, 0x0008,
2486 0x01F0, 0x0003, 0x0002, 0x000D, 0x000C, 0x0017, 0x007D, 0x01F2,
2487 0x07C6, 0x07C5, 0x1F12, 0x3E27, 0x3E26, 0x1F11, 0x1F10, 0x0000,
2488 0x001E, 0x0006, 0x0039, 0x0038, 0x003F, 0x002C, 0x0005, 0x002D,
2490 0x0002, 0x0007, 0x0018, 0x0003, 0x0005, 0x0035, 0x004F, 0x0012,
2491 0x04E5, 0x0005, 0x0004, 0x000D, 0x000E, 0x0033, 0x0026, 0x009D,
2492 0x04E4, 0x04E7, 0x04E6, 0x04E1, 0x04E0, 0x04E3, 0x04E2, 0x0000,
2493 0x001F, 0x000C, 0x003D, 0x003C, 0x0032, 0x0034, 0x001B, 0x0008,
2495 0x0000, 0x0004, 0x001C, 0x000F, 0x0002, 0x0007, 0x0075, 0x00E8,
2496 0x1D2A, 0x0005, 0x0004, 0x000D, 0x000C, 0x0077, 0x0E96, 0x3A57,
2497 0x3A56, 0x3A5D, 0x3A5C, 0x3A5F, 0x3A5E, 0x1D29, 0x1D28, 0x0003,
2498 0x0006, 0x000A, 0x002C, 0x0017, 0x0076, 0x01D3, 0x03A4, 0x002D,
2500 0x000A, 0x0024, 0x00BF, 0x0085, 0x0211, 0x0842, 0x1087, 0x0018,
2501 0x0020, 0x0001, 0x0002, 0x000E, 0x000D, 0x0007, 0x0013, 0x0025,
2502 0x005E, 0x0043, 0x00BE, 0x0109, 0x1086, 0x0841, 0x0840, 0x000F,
2503 0x0001, 0x0011, 0x0000, 0x002E, 0x0019, 0x0001, 0x0006, 0x0016,
2505 0x0002, 0x000F, 0x006F, 0x0061, 0x0374, 0x1BA8, 0x3753, 0x0012,
2506 0x0036, 0x0000, 0x0001, 0x000A, 0x000B, 0x001A, 0x0031, 0x0060,
2507 0x00DC, 0x01BB, 0x06EB, 0x1BAB, 0x3752, 0x3755, 0x3754, 0x000E,
2508 0x0006, 0x0013, 0x000E, 0x003E, 0x0008, 0x001E, 0x0019, 0x003F,
2510 0x0003, 0x001C, 0x0025, 0x0024, 0x01DA, 0x1DBD, 0x3B7C, 0x003C,
2511 0x003D, 0x0000, 0x0001, 0x000B, 0x000A, 0x000B, 0x0077, 0x00EC,
2512 0x03B6, 0x076E, 0x1DBF, 0x76FB, 0x76FA, 0x3B79, 0x3B78, 0x000D,
2513 0x001F, 0x0013, 0x000A, 0x0008, 0x000C, 0x0008, 0x0009, 0x003A,
2515 0x0005, 0x0003, 0x0004, 0x0010, 0x008F, 0x0475, 0x11D1, 0x0079,
2516 0x0027, 0x0002, 0x0003, 0x0001, 0x0000, 0x0026, 0x0046, 0x011C,
2517 0x0477, 0x08ED, 0x11D0, 0x11D3, 0x11D2, 0x11D9, 0x11D8, 0x000D,
2518 0x001F, 0x0012, 0x0005, 0x003D, 0x000C, 0x000E, 0x0022, 0x0078,
2520 0x0005, 0x000C, 0x001B, 0x0000, 0x0006, 0x03E2, 0x3E3D, 0x000F,
2521 0x0034, 0x0003, 0x0002, 0x001E, 0x001D, 0x007D, 0x01F0, 0x07C6,
2522 0x3E3C, 0x3E3F, 0x3E3E, 0x3E39, 0x3E38, 0x3E3B, 0x3E3A, 0x0008,
2523 0x001C, 0x0002, 0x003F, 0x0035, 0x0009, 0x0001, 0x000E, 0x00F9,
2525 0x0004, 0x000B, 0x0001, 0x000A, 0x001E, 0x00E0, 0x0E1E, 0x0071,
2526 0x0039, 0x0007, 0x0006, 0x000D, 0x000C, 0x0020, 0x01C2, 0x1C3F,
2527 0x1C3E, 0x0E19, 0x0E18, 0x0E1B, 0x0E1A, 0x0E1D, 0x0E1C, 0x0000,
2528 0x0009, 0x001D, 0x001F, 0x0011, 0x0005, 0x0001, 0x0043, 0x0042,
2530 0x0004, 0x000D, 0x0007, 0x0002, 0x0014, 0x016C, 0x16D1, 0x02DF,
2531 0x016E, 0x0000, 0x0007, 0x002C, 0x002B, 0x02DE, 0x16D0, 0x16D3,
2532 0x16D2, 0x2DB5, 0x2DB4, 0x2DB7, 0x2DB6, 0x16D9, 0x16D8, 0x000C,
2533 0x002A, 0x005A, 0x001B, 0x001A, 0x0017, 0x000C, 0x05B7, 0x05B5,
2535 0x0002, 0x000F, 0x001C, 0x000C, 0x003B, 0x01AC, 0x1AD8, 0x35B3,
2536 0x35B2, 0x0001, 0x0000, 0x0069, 0x0068, 0x35BD, 0x35BC, 0x35BF,
2537 0x35BE, 0x35B9, 0x35B8, 0x35BB, 0x35BA, 0x35B5, 0x35B4, 0x01A9,
2538 0x01A8, 0x035A, 0x00D7, 0x00D5, 0x003A, 0x001B, 0x35B7, 0x35B6,
2542 const VP31_AC_CAT2_BITS: [[u8; 32]; 16] = [
2544 4, 6, 8, 9, 10, 12, 13, 4, 7, 3, 4, 4, 4, 4, 4, 5,
2545 5, 5, 5, 6, 7, 11, 13, 4, 5, 6, 6, 7, 6, 6, 4, 5,
2547 4, 6, 7, 7, 9, 12, 12, 5, 7, 3, 3, 4, 4, 4, 4, 5,
2548 6, 6, 6, 8, 10, 12, 12, 4, 5, 6, 6, 6, 5, 6, 4, 5,
2550 4, 5, 7, 6, 8, 10, 12, 5, 7, 3, 3, 4, 4, 4, 5, 5,
2551 6, 6, 7, 9, 12, 12, 12, 4, 5, 5, 6, 6, 5, 6, 4, 5,
2553 3, 5, 6, 6, 8, 10, 13, 5, 7, 3, 3, 4, 4, 4, 5, 6,
2554 7, 7, 9, 11, 13, 13, 13, 4, 5, 5, 6, 6, 5, 6, 5, 5,
2556 3, 5, 6, 5, 7, 9, 11, 6, 8, 3, 3, 4, 4, 5, 6, 7,
2557 8, 8, 10, 13, 13, 13, 13, 3, 5, 5, 5, 6, 5, 6, 5, 6,
2559 3, 4, 5, 5, 6, 9, 11, 6, 9, 3, 3, 4, 4, 5, 7, 9,
2560 11, 11, 13, 14, 14, 13, 13, 3, 5, 5, 6, 6, 6, 6, 5, 6,
2562 3, 4, 5, 4, 5, 7, 9, 7, 13, 3, 3, 4, 4, 6, 8, 10,
2563 13, 13, 13, 13, 13, 13, 13, 3, 5, 5, 6, 6, 6, 7, 6, 6,
2565 3, 4, 5, 4, 4, 5, 7, 8, 13, 3, 3, 4, 4, 7, 12, 14,
2566 14, 14, 14, 14, 14, 13, 13, 3, 5, 5, 7, 6, 7, 9, 10, 7,
2568 4, 6, 8, 8, 10, 12, 13, 5, 6, 3, 3, 4, 4, 4, 5, 6,
2569 7, 7, 8, 9, 13, 12, 12, 4, 4, 5, 5, 6, 5, 5, 4, 5,
2571 3, 5, 7, 7, 10, 13, 14, 5, 6, 3, 3, 4, 4, 5, 6, 7,
2572 8, 9, 11, 13, 14, 14, 14, 4, 4, 5, 5, 6, 4, 5, 5, 6,
2574 3, 5, 6, 6, 9, 13, 14, 6, 6, 3, 3, 4, 4, 5, 7, 8,
2575 10, 11, 13, 15, 15, 14, 14, 4, 5, 5, 5, 5, 4, 4, 5, 6,
2577 3, 4, 5, 5, 8, 11, 13, 7, 6, 3, 3, 4, 4, 6, 7, 9,
2578 11, 12, 13, 13, 13, 13, 13, 4, 5, 5, 5, 6, 4, 4, 6, 7,
2580 3, 4, 5, 4, 6, 10, 14, 7, 6, 3, 3, 5, 5, 7, 9, 11,
2581 14, 14, 14, 14, 14, 14, 14, 4, 5, 5, 6, 6, 4, 3, 7, 8,
2583 3, 4, 4, 4, 6, 9, 13, 8, 7, 3, 3, 5, 5, 7, 10, 14,
2584 14, 13, 13, 13, 13, 13, 13, 4, 5, 6, 6, 6, 4, 3, 8, 8,
2586 3, 4, 4, 3, 5, 9, 13, 10, 9, 2, 3, 6, 6, 10, 13, 13,
2587 13, 14, 14, 14, 14, 13, 13, 5, 6, 7, 6, 6, 5, 4, 11, 11,
2589 2, 4, 5, 4, 6, 9, 13, 14, 14, 2, 2, 7, 7, 14, 14, 14,
2590 14, 14, 14, 14, 14, 14, 14, 9, 9, 10, 8, 8, 6, 5, 14, 14,
2594 const VP31_AC_CAT3_CODES: [[u16; 32]; 16] = [
2596 0x0000, 0x0010, 0x0072, 0x0071, 0x0154, 0x0AAB, 0x0AA8, 0x0014,
2597 0x0070, 0x0002, 0x0003, 0x000C, 0x000B, 0x0003, 0x0011, 0x0073,
2598 0x0054, 0x00AB, 0x02AB, 0x1553, 0x1552, 0x1555, 0x1554, 0x000D,
2599 0x001E, 0x0012, 0x003E, 0x002B, 0x0002, 0x003F, 0x001D, 0x0013,
2601 0x0003, 0x001F, 0x0029, 0x003D, 0x000C, 0x0069, 0x0345, 0x0002,
2602 0x0028, 0x0002, 0x0001, 0x000E, 0x000C, 0x0015, 0x0007, 0x001B,
2603 0x006B, 0x006A, 0x0344, 0x0347, 0x0346, 0x01A1, 0x01A0, 0x000B,
2604 0x001A, 0x0012, 0x0000, 0x003C, 0x0008, 0x001B, 0x0013, 0x0001,
2606 0x0004, 0x0004, 0x003F, 0x0014, 0x0056, 0x015C, 0x15D5, 0x003C,
2607 0x002A, 0x0000, 0x0001, 0x000E, 0x000D, 0x000C, 0x00AF, 0x02BB,
2608 0x15D4, 0x15D7, 0x15D6, 0x15D1, 0x15D0, 0x15D3, 0x15D2, 0x000B,
2609 0x0019, 0x000D, 0x003E, 0x0031, 0x0007, 0x0005, 0x003D, 0x0030,
2611 0x0005, 0x0008, 0x001A, 0x0000, 0x0036, 0x0011, 0x0106, 0x000A,
2612 0x006E, 0x0002, 0x0003, 0x0003, 0x0002, 0x006F, 0x0021, 0x020F,
2613 0x020E, 0x0101, 0x0100, 0x0103, 0x0102, 0x0105, 0x0104, 0x000C,
2614 0x001E, 0x0003, 0x003E, 0x003F, 0x0009, 0x000E, 0x000B, 0x0009,
2616 0x0002, 0x000E, 0x001E, 0x000C, 0x001F, 0x006E, 0x00AD, 0x00AF,
2617 0x0014, 0x0004, 0x0003, 0x001A, 0x0017, 0x002A, 0x0576, 0x0AEF,
2618 0x0AEE, 0x0571, 0x0570, 0x0573, 0x0572, 0x0575, 0x0574, 0x0003,
2619 0x0016, 0x0004, 0x0036, 0x000B, 0x000A, 0x0000, 0x006F, 0x00AC,
2621 0x0004, 0x0005, 0x0003, 0x0001, 0x0004, 0x002F, 0x0526, 0x1495,
2622 0x00A6, 0x0007, 0x0006, 0x002D, 0x002C, 0x1494, 0x1497, 0x1496,
2623 0x1491, 0x1490, 0x1493, 0x1492, 0x293D, 0x293C, 0x293F, 0x0000,
2624 0x0028, 0x00A5, 0x0148, 0x00A7, 0x002E, 0x0015, 0x0A4E, 0x293E,
2626 0x0004, 0x0005, 0x0003, 0x0001, 0x0004, 0x002F, 0x0526, 0x1495,
2627 0x00A6, 0x0007, 0x0006, 0x002D, 0x002C, 0x1494, 0x1497, 0x1496,
2628 0x1491, 0x1490, 0x1493, 0x1492, 0x293D, 0x293C, 0x293F, 0x0000,
2629 0x0028, 0x00A5, 0x0148, 0x00A7, 0x002E, 0x0015, 0x0A4E, 0x293E,
2631 0x0004, 0x0005, 0x0003, 0x0001, 0x0004, 0x002F, 0x0526, 0x1495,
2632 0x00A6, 0x0007, 0x0006, 0x002D, 0x002C, 0x1494, 0x1497, 0x1496,
2633 0x1491, 0x1490, 0x1493, 0x1492, 0x293D, 0x293C, 0x293F, 0x0000,
2634 0x0028, 0x00A5, 0x0148, 0x00A7, 0x002E, 0x0015, 0x0A4E, 0x293E,
2636 0x0003, 0x0011, 0x0020, 0x0074, 0x010D, 0x0863, 0x0860, 0x000A,
2637 0x0075, 0x0001, 0x0000, 0x000B, 0x000A, 0x0018, 0x0038, 0x0042,
2638 0x010F, 0x010E, 0x0219, 0x10C3, 0x10C2, 0x10C5, 0x10C4, 0x000F,
2639 0x0004, 0x0019, 0x000B, 0x0039, 0x0009, 0x001B, 0x001A, 0x003B,
2641 0x0005, 0x0001, 0x003E, 0x0001, 0x00E2, 0x1C6F, 0x38D9, 0x0039,
2642 0x001F, 0x0002, 0x0001, 0x0009, 0x0008, 0x0000, 0x0070, 0x01C7,
2643 0x038C, 0x071A, 0x38D8, 0x38DB, 0x38DA, 0x38DD, 0x38DC, 0x000D,
2644 0x001D, 0x000E, 0x003F, 0x003C, 0x000C, 0x0006, 0x003D, 0x001E,
2646 0x0006, 0x000B, 0x0011, 0x001E, 0x0074, 0x03AA, 0x1D5C, 0x0001,
2647 0x0021, 0x0001, 0x0002, 0x0007, 0x0006, 0x003E, 0x00EB, 0x01D4,
2648 0x0EAF, 0x3ABB, 0x3ABA, 0x1D59, 0x1D58, 0x1D5B, 0x1D5A, 0x000A,
2649 0x001C, 0x0001, 0x003F, 0x003B, 0x0001, 0x0009, 0x0020, 0x0000,
2651 0x0004, 0x000A, 0x0017, 0x0004, 0x0016, 0x016A, 0x16B1, 0x0017,
2652 0x005B, 0x0006, 0x0007, 0x0001, 0x0000, 0x000A, 0x02D7, 0x0B5A,
2653 0x16B0, 0x16B3, 0x16B2, 0x2D6D, 0x2D6C, 0x2D6F, 0x2D6E, 0x0006,
2654 0x000A, 0x0004, 0x002C, 0x0017, 0x0003, 0x0007, 0x0016, 0x00B4,
2656 0x0005, 0x000D, 0x0005, 0x0009, 0x0033, 0x0193, 0x192C, 0x0061,
2657 0x0031, 0x0000, 0x0007, 0x0010, 0x0011, 0x00C8, 0x192F, 0x325B,
2658 0x325A, 0x1929, 0x1928, 0x192B, 0x192A, 0x325D, 0x325C, 0x0018,
2659 0x001A, 0x001B, 0x0065, 0x0019, 0x0004, 0x0007, 0x0060, 0x0324,
2661 0x0006, 0x0000, 0x0002, 0x000F, 0x0039, 0x01D9, 0x1D82, 0x0761,
2662 0x03BE, 0x0001, 0x0002, 0x000F, 0x000E, 0x0762, 0x3B07, 0x3B06,
2663 0x3B1D, 0x3B1C, 0x3B1F, 0x3B1E, 0x3B19, 0x3B18, 0x3B1B, 0x0038,
2664 0x01DE, 0x00ED, 0x03BF, 0x00EE, 0x003A, 0x0006, 0x0EC0, 0x3B1A,
2666 0x0000, 0x0002, 0x000F, 0x0006, 0x001C, 0x01D0, 0x0E8C, 0x1D1B,
2667 0x1D1A, 0x0003, 0x0002, 0x00EA, 0x00E9, 0x0E89, 0x0E88, 0x0E8B,
2668 0x0E8A, 0x1D65, 0x1D64, 0x1D67, 0x1D66, 0x1D61, 0x1D60, 0x03AD,
2669 0x1D63, 0x1D62, 0x1D1D, 0x1D1C, 0x003B, 0x01D7, 0x1D1F, 0x1D1E,
2671 0x0002, 0x000F, 0x001C, 0x000C, 0x003B, 0x01AC, 0x1AD8, 0x35B3,
2672 0x35B2, 0x0001, 0x0000, 0x0069, 0x0068, 0x35BD, 0x35BC, 0x35BF,
2673 0x35BE, 0x35B9, 0x35B8, 0x35BB, 0x35BA, 0x35B5, 0x35B4, 0x01A9,
2674 0x01A8, 0x035A, 0x00D7, 0x00D5, 0x003A, 0x001B, 0x35B7, 0x35B6,
2678 const VP31_AC_CAT3_BITS: [[u8; 32]; 16] = [
2680 3, 5, 7, 7, 9, 12, 12, 5, 7, 3, 3, 4, 4, 4, 5, 7,
2681 7, 8, 10, 13, 13, 13, 13, 4, 5, 5, 6, 6, 4, 6, 5, 5,
2683 3, 5, 6, 6, 7, 10, 13, 5, 6, 3, 3, 4, 4, 5, 6, 8,
2684 10, 10, 13, 13, 13, 12, 12, 4, 5, 5, 5, 6, 4, 5, 5, 5,
2686 3, 4, 6, 5, 7, 9, 13, 6, 6, 3, 3, 4, 4, 5, 8, 10,
2687 13, 13, 13, 13, 13, 13, 13, 4, 5, 5, 6, 6, 4, 4, 6, 6,
2689 3, 4, 5, 4, 6, 8, 12, 7, 7, 3, 3, 4, 4, 7, 9, 13,
2690 13, 12, 12, 12, 12, 12, 12, 4, 5, 5, 6, 6, 4, 4, 7, 7,
2692 3, 4, 5, 4, 5, 7, 10, 10, 7, 3, 3, 5, 5, 8, 13, 14,
2693 14, 13, 13, 13, 13, 13, 13, 4, 5, 5, 6, 6, 4, 3, 7, 10,
2695 3, 4, 3, 3, 4, 6, 11, 13, 8, 3, 3, 6, 6, 13, 13, 13,
2696 13, 13, 13, 13, 14, 14, 14, 3, 6, 8, 9, 8, 6, 5, 12, 14,
2698 3, 4, 3, 3, 4, 6, 11, 13, 8, 3, 3, 6, 6, 13, 13, 13,
2699 13, 13, 13, 13, 14, 14, 14, 3, 6, 8, 9, 8, 6, 5, 12, 14,
2701 3, 4, 3, 3, 4, 6, 11, 13, 8, 3, 3, 6, 6, 13, 13, 13,
2702 13, 13, 13, 13, 14, 14, 14, 3, 6, 8, 9, 8, 6, 5, 12, 14,
2704 3, 5, 6, 7, 9, 12, 12, 5, 7, 3, 3, 4, 4, 5, 6, 7,
2705 9, 9, 10, 13, 13, 13, 13, 4, 4, 5, 5, 6, 4, 5, 5, 6,
2707 3, 4, 6, 5, 8, 13, 14, 6, 6, 3, 3, 4, 4, 5, 7, 9,
2708 10, 11, 14, 14, 14, 14, 14, 4, 5, 5, 6, 6, 4, 4, 6, 6,
2710 3, 4, 5, 5, 7, 10, 13, 6, 6, 3, 3, 4, 4, 6, 8, 9,
2711 12, 14, 14, 13, 13, 13, 13, 4, 5, 5, 6, 6, 4, 4, 6, 6,
2713 3, 4, 5, 4, 6, 9, 13, 7, 7, 3, 3, 4, 4, 6, 10, 12,
2714 13, 13, 13, 14, 14, 14, 14, 4, 5, 5, 6, 6, 4, 4, 7, 8,
2716 3, 4, 4, 4, 6, 9, 13, 8, 7, 2, 3, 5, 5, 8, 13, 14,
2717 14, 13, 13, 13, 13, 14, 14, 5, 6, 6, 7, 6, 4, 4, 8, 10,
2719 3, 3, 4, 4, 6, 9, 13, 11, 10, 2, 2, 6, 6, 11, 14, 14,
2720 14, 14, 14, 14, 14, 14, 14, 6, 9, 8, 10, 8, 6, 5, 12, 14,
2722 2, 3, 5, 4, 6, 10, 13, 14, 14, 2, 2, 9, 9, 13, 13, 13,
2723 13, 14, 14, 14, 14, 14, 14, 11, 14, 14, 14, 14, 7, 10, 14, 14,
2725 2, 4, 5, 4, 6, 9, 13, 14, 14, 2, 2, 7, 7, 14, 14, 14,
2726 14, 14, 14, 14, 14, 14, 14, 9, 9, 10, 8, 8, 6, 5, 14, 14,
2730 const VP31_DC_WEIGHTS: [[i16; 5]; 16] = [
2739 [ 29, -26, 29, 0, 32 ],
2742 [ 75, 0, 0, 53, 128 ],
2744 [ 75, 0, 0, 53, 128 ],
2747 [ 75, 0, 0, 53, 128 ],
2748 [ 0, 3, 10, 3, 16 ],
2749 [ 29, -26, 29, 0, 32 ],
2752 const VP30_DC_SCALES: [i16; 64] = [
2753 24, 20, 20, 20, 20, 20, 20, 20,
2754 19, 19, 19, 19, 18, 18, 18, 18,
2755 17, 17, 17, 17, 16, 16, 15, 15,
2756 14, 14, 13, 13, 12, 12, 11, 11,
2757 10, 10, 9, 9, 8, 8, 7, 7,
2758 6, 6, 6, 6, 5, 5, 5, 5,
2759 4, 4, 4, 4, 3, 3, 3, 3,
2760 2, 2, 2, 2, 1, 1, 1, 1
2763 const VP30_AC_SCALES: [i16; 64] = [
2764 3000, 2500, 2000, 1500, 1200, 1000, 900, 800,
2765 750, 700, 650, 630, 600, 550, 500, 450,
2766 410, 380, 350, 320, 290, 260, 240, 220,
2767 200, 180, 165, 150, 140, 130, 120, 115,
2768 110, 100, 95, 90, 85, 80, 75, 70,
2769 67, 65, 63, 61, 57, 55, 53, 50,
2770 49, 46, 44, 42, 39, 36, 33, 30,
2771 27, 24, 21, 19, 17, 15, 12, 10
2774 const VP30_DC_CODES: [[u16; 32]; 5] = [
2776 0x0005, 0x002D, 0x0004, 0x0009, 0x0088, 0x0225, 0x0224, 0x0005,
2777 0x0011, 0x0007, 0x0006, 0x0009, 0x000A, 0x0007, 0x0017, 0x000C,
2778 0x002C, 0x0005, 0x0008, 0x0003, 0x0012, 0x0010, 0x0113, 0x0003,
2779 0x0010, 0x0000, 0x0013, 0x001A, 0x0023, 0x0045, 0x0001, 0x001B
2781 0x000B, 0x0012, 0x0029, 0x0010, 0x000D, 0x00A2, 0x0020, 0x0009,
2782 0x0050, 0x0007, 0x0006, 0x0006, 0x0005, 0x0002, 0x0008, 0x0027,
2783 0x0005, 0x0022, 0x0023, 0x0057, 0x00A3, 0x0011, 0x0021, 0x0007,
2784 0x0000, 0x0009, 0x002A, 0x0003, 0x0007, 0x0026, 0x000C, 0x0056
2786 0x000D, 0x0018, 0x0009, 0x0017, 0x0033, 0x0056, 0x00F7, 0x00F1,
2787 0x007A, 0x0000, 0x0007, 0x0009, 0x0008, 0x0005, 0x000D, 0x002D,
2788 0x0010, 0x001D, 0x001C, 0x0057, 0x00CB, 0x00F6, 0x00F0, 0x0014,
2789 0x000C, 0x002C, 0x0011, 0x001F, 0x002A, 0x0064, 0x00CA, 0x0079
2791 0x000F, 0x001A, 0x0013, 0x001B, 0x003B, 0x0072, 0x01D3, 0x0707,
2792 0x0E0D, 0x0001, 0x0000, 0x000C, 0x000B, 0x0008, 0x0012, 0x002A,
2793 0x0073, 0x0028, 0x0075, 0x0056, 0x0052, 0x01C0, 0x0E0C, 0x0071,
2794 0x0057, 0x00E1, 0x00A6, 0x00E8, 0x00A7, 0x03A5, 0x03A4, 0x0382
2796 0x000F, 0x001B, 0x0014, 0x001D, 0x0010, 0x0073, 0x00E2, 0x023C,
2797 0x11C9, 0x0001, 0x0000, 0x000C, 0x000B, 0x0009, 0x0015, 0x0035,
2798 0x0072, 0x0034, 0x0022, 0x0070, 0x0046, 0x011D, 0x11C8, 0x01C7,
2799 0x01C6, 0x0238, 0x047E, 0x023E, 0x0473, 0x08E5, 0x023D, 0x047F
2802 const VP30_DC_BITS: [[u8; 32]; 5] = [
2804 4, 6, 6, 6, 8, 10, 10, 6, 7, 3, 3, 4, 4, 4, 5, 5,
2805 6, 5, 5, 5, 6, 7, 9, 4, 5, 5, 6, 6, 6, 7, 5, 6
2807 4, 5, 6, 5, 6, 8, 9, 7, 7, 3, 3, 4, 4, 4, 5, 6,
2808 6, 6, 6, 7, 8, 8, 9, 4, 4, 5, 6, 5, 5, 6, 6, 7
2810 4, 5, 5, 5, 6, 7, 9, 9, 8, 2, 3, 4, 4, 4, 5, 6,
2811 6, 6, 6, 7, 8, 9, 9, 5, 5, 6, 6, 6, 6, 7, 8, 8
2813 4, 5, 5, 5, 6, 7, 9, 11, 12, 2, 2, 4, 4, 4, 5, 6,
2814 7, 6, 7, 7, 7, 9, 12, 7, 7, 8, 8, 8, 8, 10, 10, 10
2816 4, 5, 5, 5, 5, 7, 8, 10, 13, 2, 2, 4, 4, 4, 5, 6,
2817 7, 6, 6, 7, 7, 9, 13, 9, 9, 10, 11, 10, 11, 12, 10, 11
2820 const VP30_AC_INTRA_CODES: [[u16; 32]; 5] = [
2822 0x0008, 0x0033, 0x0008, 0x004B, 0x0089, 0x0221, 0x0220, 0x001F,
2823 0x0045, 0x0000, 0x000E, 0x000B, 0x000A, 0x000D, 0x0006, 0x001E,
2824 0x000A, 0x0018, 0x0013, 0x0005, 0x0009, 0x0046, 0x0111, 0x0007,
2825 0x000B, 0x0032, 0x0010, 0x004A, 0x0024, 0x0047, 0x0003, 0x0009
2827 0x000E, 0x000E, 0x007B, 0x001E, 0x007E, 0x03EF, 0x07DD, 0x0018,
2828 0x00FA, 0x0002, 0x0000, 0x000A, 0x0008, 0x000B, 0x0003, 0x0012,
2829 0x0033, 0x000C, 0x003C, 0x001A, 0x007F, 0x01F6, 0x07DC, 0x000D,
2830 0x0013, 0x0004, 0x001B, 0x007A, 0x0032, 0x007C, 0x001F, 0x0005
2832 0x0000, 0x0018, 0x0034, 0x000C, 0x006A, 0x01F9, 0x07EA, 0x0016,
2833 0x0FD7, 0x0002, 0x0001, 0x000A, 0x0009, 0x0007, 0x001B, 0x003E,
2834 0x0020, 0x0021, 0x006B, 0x01FB, 0x03F4, 0x1FAD, 0x1FAC, 0x000E,
2835 0x0019, 0x0011, 0x002F, 0x007F, 0x002E, 0x01F8, 0x001E, 0x000D
2837 0x000E, 0x0016, 0x002E, 0x0003, 0x006E, 0x008B, 0x0113, 0x0018,
2838 0x0221, 0x0001, 0x0002, 0x000A, 0x0009, 0x0007, 0x001A, 0x0002,
2839 0x001B, 0x0023, 0x006F, 0x008A, 0x0111, 0x0441, 0x0440, 0x000F,
2840 0x0019, 0x0010, 0x0036, 0x001A, 0x002F, 0x0112, 0x0000, 0x000C
2842 0x000E, 0x000F, 0x001B, 0x0033, 0x005A, 0x00B6, 0x0008, 0x001A,
2843 0x004D, 0x0001, 0x0002, 0x000A, 0x0009, 0x0008, 0x001B, 0x0003,
2844 0x002C, 0x002E, 0x0005, 0x00B7, 0x0027, 0x0099, 0x0098, 0x000F,
2845 0x0018, 0x000E, 0x002F, 0x001A, 0x0032, 0x0012, 0x0000, 0x000C
2848 const VP30_AC_INTRA_BITS: [[u8; 32]; 5] = [
2850 4, 6, 6, 7, 9, 11, 11, 5, 8, 3, 4, 4, 4, 4, 4, 5,
2851 5, 5, 5, 5, 6, 8, 10, 4, 5, 6, 6, 7, 6, 8, 4, 5
2853 4, 5, 7, 6, 8, 11, 12, 5, 9, 3, 3, 4, 4, 4, 4, 5,
2854 6, 5, 6, 6, 8, 10, 12, 4, 5, 5, 6, 7, 6, 8, 5, 5
2856 3, 5, 6, 5, 7, 9, 11, 5, 12, 3, 3, 4, 4, 4, 5, 6,
2857 6, 6, 7, 9, 10, 13, 13, 4, 5, 5, 6, 7, 6, 9, 5, 5
2859 4, 5, 6, 5, 7, 8, 9, 5, 10, 3, 3, 4, 4, 4, 5, 5,
2860 6, 6, 7, 8, 9, 11, 11, 4, 5, 5, 6, 6, 6, 9, 4, 5
2862 4, 5, 6, 6, 7, 8, 7, 5, 10, 3, 3, 4, 4, 4, 5, 5,
2863 6, 6, 6, 8, 9, 11, 11, 4, 5, 5, 6, 6, 6, 8, 4, 5
2866 const VP30_AC_INTER_CODES: [[u16; 32]; 5] = [
2868 0x000D, 0x0038, 0x0061, 0x0060, 0x0393, 0x1C95, 0x1C94, 0x0014,
2869 0x0073, 0x0001, 0x0000, 0x000B, 0x0009, 0x001D, 0x000E, 0x0022,
2870 0x0046, 0x0047, 0x00E5, 0x01C8, 0x0724, 0x1C97, 0x1C96, 0x000F,
2871 0x0006, 0x0019, 0x000F, 0x0031, 0x0004, 0x0010, 0x0005, 0x0015
2873 0x0004, 0x001B, 0x0030, 0x0034, 0x00D5, 0x06B3, 0x3595, 0x0031,
2874 0x001A, 0x0002, 0x0001, 0x001F, 0x001E, 0x000C, 0x001B, 0x00D7,
2875 0x00D4, 0x01AD, 0x0358, 0x0D64, 0x3594, 0x3597, 0x3596, 0x0000,
2876 0x000A, 0x001D, 0x0017, 0x0039, 0x0007, 0x0019, 0x0016, 0x0038
2878 0x0005, 0x0009, 0x001A, 0x001E, 0x001F, 0x00E2, 0x038E, 0x0070,
2879 0x003B, 0x0001, 0x0000, 0x0019, 0x0018, 0x001E, 0x003A, 0x01C6,
2880 0x071E, 0x0E3E, 0x1C7E, 0x71FD, 0x71FC, 0x71FF, 0x71FE, 0x0002,
2881 0x0008, 0x001D, 0x001B, 0x0039, 0x001F, 0x000D, 0x000C, 0x001C
2883 0x0003, 0x000B, 0x001C, 0x000D, 0x0004, 0x000A, 0x0076, 0x00E8,
2884 0x01DC, 0x0001, 0x0000, 0x0033, 0x0032, 0x00E9, 0x03BB, 0x0774,
2885 0x1DD5, 0x3BAD, 0x3BAC, 0x3BAF, 0x3BAE, 0x3BA9, 0x3BA8, 0x0004,
2886 0x000A, 0x001F, 0x001E, 0x0030, 0x000B, 0x0075, 0x0031, 0x00EF
2888 0x0009, 0x001E, 0x000F, 0x000E, 0x000C, 0x0008, 0x0001, 0x00E3,
2889 0x00E2, 0x0002, 0x0000, 0x003A, 0x0039, 0x0070, 0x01DC, 0x0776,
2890 0x0775, 0x0EEF, 0x0EE8, 0x1DD3, 0x1DD2, 0x1DDD, 0x1DDC, 0x0005,
2891 0x001F, 0x001B, 0x0006, 0x006A, 0x0034, 0x0076, 0x006B, 0x00EF
2894 const VP30_AC_INTER_BITS: [[u8; 32]; 5] = [
2896 4, 6, 7, 7, 10, 13, 13, 5, 7, 3, 3, 4, 4, 5, 5, 6,
2897 7, 7, 8, 9, 11, 13, 13, 4, 4, 5, 5, 6, 4, 5, 4, 5
2899 3, 5, 6, 6, 8, 11, 14, 6, 6, 3, 3, 5, 5, 5, 6, 8,
2900 8, 9, 10, 12, 14, 14, 14, 3, 4, 5, 5, 6, 4, 5, 5, 6
2902 3, 4, 5, 5, 6, 8, 10, 7, 7, 3, 3, 5, 5, 6, 7, 9,
2903 11, 12, 13, 15, 15, 15, 15, 3, 4, 5, 5, 6, 5, 5, 5, 6
2905 3, 4, 5, 4, 4, 5, 7, 8, 9, 3, 3, 6, 6, 8, 10, 11,
2906 13, 14, 14, 14, 14, 14, 14, 3, 4, 5, 5, 6, 5, 7, 6, 8
2908 4, 5, 5, 4, 4, 4, 3, 9, 9, 3, 3, 7, 7, 8, 10, 12,
2909 12, 13, 13, 14, 14, 14, 14, 3, 5, 5, 4, 7, 6, 8, 7, 9
2912 const VP30_MBTYPE_CODES: [u8; 7] = [ 0x00, 0x08, 0x0A, 0x03, 0x0B, 0x13, 0x12 ];
2913 const VP30_MBTYPE_BITS: [u8; 7] = [ 1, 4, 4, 2, 4, 5, 5 ];
2914 const VP30_MBTYPE_SYMS: [VPMBType; 7] = [
2915 VPMBType::InterNoMV, VPMBType::Intra, VPMBType::InterMV, VPMBType::InterNearest,
2916 VPMBType::GoldenNoMV, VPMBType::GoldenMV, VPMBType::InterFourMV
2919 const VP40_DC_CODES: [[u32; 32]; 16] = [
2921 0x000C, 0x0070, 0x01CA, 0x01CB, 0x0391, 0x1C9B, 0x3935, 0x0071,
2922 0x3934, 0x000B, 0x000F, 0x0019, 0x0002, 0x0009, 0x0003, 0x001D,
2923 0x0018, 0x0007, 0x000D, 0x0002, 0x0000, 0x000A, 0x0008, 0x001A,
2924 0x0073, 0x006F, 0x0E4C, 0x0727, 0x0392, 0x0390, 0x0036, 0x006E
2926 0x0011, 0x007A, 0x0083, 0x0040, 0x0105, 0x0413, 0x0410, 0x007B,
2927 0x0822, 0x000E, 0x0002, 0x0002, 0x0006, 0x000A, 0x0007, 0x001F,
2928 0x0017, 0x0009, 0x000D, 0x0000, 0x000C, 0x0003, 0x003C, 0x002C,
2929 0x0021, 0x0169, 0x0412, 0x02D0, 0x02D1, 0x0823, 0x005B, 0x00B5
2931 0x0017, 0x0010, 0x00B6, 0x0022, 0x016A, 0x02D0, 0x0B48, 0x0077,
2932 0x1692, 0x0000, 0x0003, 0x0003, 0x0009, 0x000C, 0x0005, 0x0002,
2933 0x001C, 0x0008, 0x000D, 0x000F, 0x000A, 0x0009, 0x0023, 0x003A,
2934 0x002C, 0x016B, 0x05A5, 0x02D3, 0x02D1, 0x1693, 0x0076, 0x00B7
2936 0x001E, 0x0013, 0x00FB, 0x007C, 0x0046, 0x07D6, 0x0FA9, 0x0012,
2937 0x1F50, 0x0001, 0x0004, 0x0005, 0x000A, 0x000E, 0x0007, 0x0000,
2938 0x0017, 0x0006, 0x000D, 0x000C, 0x0001, 0x002C, 0x008F, 0x003F,
2939 0x002D, 0x01F4, 0x07D5, 0x008E, 0x07D7, 0x1F51, 0x0010, 0x0022
2941 0x0001, 0x002B, 0x0012, 0x0055, 0x0027, 0x03B0, 0x0762, 0x0077,
2942 0x0261, 0x0002, 0x0006, 0x0007, 0x000B, 0x000F, 0x0008, 0x0000,
2943 0x001C, 0x0003, 0x0009, 0x0006, 0x0014, 0x0054, 0x0131, 0x0005,
2944 0x003A, 0x01D9, 0x0099, 0x004D, 0x0763, 0x0260, 0x0008, 0x00ED
2946 0x0004, 0x0033, 0x0060, 0x0065, 0x00C2, 0x030D, 0x0619, 0x0064,
2947 0x1862, 0x0004, 0x0007, 0x000A, 0x000B, 0x000D, 0x0006, 0x0000,
2948 0x000F, 0x0003, 0x0005, 0x0002, 0x0002, 0x0077, 0x0C30, 0x0003,
2949 0x0031, 0x0187, 0x01D9, 0x00ED, 0x01D8, 0x1863, 0x001C, 0x003A
2951 0x0008, 0x000A, 0x006A, 0x0016, 0x001E, 0x034E, 0x069F, 0x0068,
2952 0x0D28, 0x0005, 0x0007, 0x0007, 0x000C, 0x0000, 0x0006, 0x001B,
2953 0x0012, 0x0002, 0x0004, 0x0013, 0x000E, 0x034B, 0x1A53, 0x0006,
2954 0x0017, 0x01A6, 0x069E, 0x01A4, 0x0695, 0x1A52, 0x006B, 0x001F
2956 0x000E, 0x000F, 0x0017, 0x0025, 0x009F, 0x0138, 0x024B, 0x0093,
2957 0x092A, 0x0005, 0x0000, 0x0008, 0x000D, 0x000F, 0x0006, 0x0004,
2958 0x000E, 0x0019, 0x0018, 0x000A, 0x009E, 0x0494, 0x1256, 0x0026,
2959 0x0016, 0x0124, 0x04E5, 0x0273, 0x04E4, 0x1257, 0x0048, 0x009D
2961 0x0004, 0x002C, 0x0050, 0x001E, 0x0071, 0x00E1, 0x00E0, 0x001D,
2962 0x0006, 0x0007, 0x0006, 0x0007, 0x0005, 0x0006, 0x0015, 0x0000,
2963 0x0029, 0x0002, 0x0006, 0x0001, 0x0023, 0x001F, 0x0039, 0x0009,
2964 0x0002, 0x0010, 0x0007, 0x002D, 0x002F, 0x002E, 0x0022, 0x0051
2966 0x0008, 0x002F, 0x0051, 0x0050, 0x02ED, 0x05D9, 0x05D8, 0x00BA,
2967 0x005C, 0x0007, 0x0006, 0x0009, 0x0006, 0x0007, 0x0016, 0x0005,
2968 0x002B, 0x0006, 0x000A, 0x0001, 0x000F, 0x001D, 0x0177, 0x0004,
2969 0x0001, 0x0004, 0x0001, 0x002A, 0x000B, 0x0029, 0x0000, 0x001C
2971 0x000A, 0x003C, 0x0074, 0x004E, 0x026D, 0x04D9, 0x04D8, 0x009A,
2972 0x004C, 0x0000, 0x0006, 0x0008, 0x0007, 0x0006, 0x0016, 0x0008,
2973 0x002E, 0x000A, 0x000B, 0x003D, 0x0024, 0x00EB, 0x0137, 0x001F,
2974 0x001C, 0x003B, 0x0012, 0x0025, 0x002F, 0x0013, 0x004F, 0x00EA
2976 0x000A, 0x000A, 0x0003, 0x0016, 0x0009, 0x0021, 0x0020, 0x00B3,
2977 0x0058, 0x0007, 0x0006, 0x0007, 0x0006, 0x0004, 0x0013, 0x0002,
2978 0x0025, 0x0000, 0x0003, 0x002D, 0x005D, 0x00B2, 0x0011, 0x0008,
2979 0x0002, 0x0006, 0x0017, 0x002F, 0x0007, 0x0024, 0x005C, 0x0005
2981 0x000B, 0x0013, 0x001F, 0x0031, 0x0021, 0x0295, 0x0528, 0x00A4,
2982 0x003C, 0x0000, 0x0007, 0x0006, 0x0005, 0x001B, 0x0012, 0x0032,
2983 0x001D, 0x002B, 0x0030, 0x001C, 0x003D, 0x014B, 0x0529, 0x0008,
2984 0x001A, 0x0033, 0x0011, 0x002A, 0x0009, 0x0028, 0x0053, 0x0020
2986 0x000E, 0x0015, 0x0029, 0x003F, 0x004D, 0x02F1, 0x05E0, 0x0092,
2987 0x0048, 0x0000, 0x0006, 0x0006, 0x0005, 0x0004, 0x000F, 0x002E,
2988 0x001D, 0x0028, 0x0027, 0x005F, 0x00BD, 0x0179, 0x05E1, 0x0008,
2989 0x001E, 0x002D, 0x001C, 0x002C, 0x003E, 0x0025, 0x004C, 0x0093
2991 0x000C, 0x0017, 0x0035, 0x0013, 0x0021, 0x00AD, 0x06F1, 0x01BD,
2992 0x00D9, 0x0000, 0x0007, 0x0007, 0x0006, 0x0004, 0x0011, 0x002A,
2993 0x006E, 0x0025, 0x0024, 0x0057, 0x00D8, 0x0379, 0x06F0, 0x0005,
2994 0x0016, 0x0029, 0x006D, 0x0028, 0x0034, 0x0020, 0x00DF, 0x00AC
2996 0x0000, 0x001A, 0x0006, 0x0019, 0x0030, 0x005A, 0x018A, 0x02DD,
2997 0x018B, 0x0001, 0x0007, 0x000A, 0x0009, 0x0002, 0x0010, 0x002E,
2998 0x006E, 0x002C, 0x000E, 0x005E, 0x00C4, 0x05B9, 0x05B8, 0x0011,
2999 0x0036, 0x005F, 0x001E, 0x0063, 0x006F, 0x001F, 0x00B6, 0x016F
3002 const VP40_DC_BITS: [[u8; 32]; 16] = [
3004 5, 7, 9, 9, 10, 13, 14, 7, 14, 4, 4, 5, 4, 4, 4, 5,
3005 5, 4, 4, 3, 3, 4, 4, 6, 7, 8, 12, 11, 10, 10, 7, 8
3007 5, 7, 8, 7, 9, 11, 11, 7, 12, 4, 3, 4, 4, 4, 4, 5,
3008 5, 4, 4, 3, 4, 4, 6, 6, 6, 9, 11, 10, 10, 12, 7, 8
3010 5, 6, 8, 7, 9, 10, 12, 7, 13, 3, 3, 4, 4, 4, 4, 4,
3011 5, 4, 4, 4, 4, 5, 7, 6, 6, 9, 11, 10, 10, 13, 7, 8
3013 5, 6, 8, 7, 8, 11, 12, 6, 13, 3, 3, 4, 4, 4, 4, 4,
3014 5, 4, 4, 4, 4, 6, 9, 6, 6, 9, 11, 9, 11, 13, 6, 7
3016 4, 6, 7, 7, 8, 10, 11, 7, 12, 3, 3, 4, 4, 4, 4, 4,
3017 5, 4, 4, 4, 5, 7, 11, 5, 6, 9, 10, 9, 11, 12, 6, 8
3019 4, 6, 7, 7, 8, 10, 11, 7, 13, 3, 3, 4, 4, 4, 4, 4,
3020 5, 4, 4, 4, 5, 8, 12, 5, 6, 9, 10, 9, 10, 13, 6, 7
3022 4, 5, 7, 6, 7, 10, 11, 7, 12, 3, 3, 4, 4, 3, 4, 5,
3023 5, 4, 4, 5, 6, 10, 13, 5, 6, 9, 11, 9, 11, 13, 7, 7
3025 4, 5, 6, 6, 8, 9, 10, 8, 12, 3, 2, 4, 4, 4, 4, 4,
3026 5, 5, 5, 5, 8, 11, 13, 6, 6, 9, 11, 10, 11, 13, 7, 8
3028 4, 6, 7, 7, 9, 10, 10, 7, 6, 3, 3, 4, 4, 4, 5, 5,
3029 6, 5, 5, 5, 6, 7, 8, 4, 4, 5, 6, 6, 6, 6, 6, 7
3031 4, 6, 7, 7, 10, 11, 11, 8, 7, 3, 3, 4, 4, 4, 5, 5,
3032 6, 5, 5, 5, 6, 7, 9, 4, 4, 5, 6, 6, 5, 6, 6, 7
3034 4, 6, 7, 7, 10, 11, 11, 8, 7, 2, 3, 4, 4, 4, 5, 5,
3035 6, 5, 5, 6, 6, 8, 9, 5, 5, 6, 6, 6, 6, 6, 7, 8
3037 4, 5, 6, 6, 8, 10, 10, 8, 7, 3, 3, 4, 4, 4, 5, 5,
3038 6, 5, 5, 6, 7, 8, 9, 4, 4, 5, 6, 6, 5, 6, 7, 7
3040 4, 5, 6, 6, 7, 10, 11, 8, 7, 2, 3, 4, 4, 5, 5, 6,
3041 6, 6, 6, 6, 7, 9, 11, 4, 5, 6, 6, 6, 5, 6, 7, 7
3043 4, 5, 6, 6, 7, 10, 11, 8, 7, 2, 3, 4, 4, 4, 5, 6,
3044 6, 6, 6, 7, 8, 9, 11, 4, 5, 6, 6, 6, 6, 6, 7, 8
3046 4, 5, 6, 5, 6, 8, 11, 9, 8, 2, 3, 4, 4, 4, 5, 6,
3047 7, 6, 6, 7, 8, 10, 11, 4, 5, 6, 7, 6, 6, 6, 8, 8
3049 3, 5, 5, 5, 6, 7, 9, 10, 9, 2, 3, 4, 4, 4, 5, 6,
3050 7, 6, 6, 7, 8, 11, 11, 5, 6, 7, 7, 7, 7, 7, 8, 9
3053 const VP40_AC_CAT0_CODES: [[u32; 32]; 16] = [
3055 0x0006, 0x001E, 0x01CC, 0x01CE, 0x0734, 0x1CD5, 0x1CD4, 0x0018,
3056 0x0E6B, 0x0000, 0x000F, 0x0006, 0x0007, 0x000D, 0x0008, 0x0002,
3057 0x0019, 0x0005, 0x000B, 0x000A, 0x001D, 0x0027, 0x01CF, 0x0004,
3058 0x0038, 0x000E, 0x004C, 0x001F, 0x004D, 0x039B, 0x0012, 0x0072
3060 0x0009, 0x004B, 0x0090, 0x0091, 0x0745, 0x1D11, 0x1D10, 0x0019,
3061 0x0E89, 0x0000, 0x000F, 0x0008, 0x0007, 0x000D, 0x000B, 0x0002,
3062 0x001C, 0x0003, 0x000A, 0x0005, 0x0018, 0x0010, 0x01D0, 0x0006,
3063 0x003B, 0x0011, 0x004A, 0x0049, 0x00E9, 0x03A3, 0x0013, 0x0075
3065 0x0019, 0x0074, 0x001D, 0x00EA, 0x0073, 0x01CA, 0x0396, 0x001C,
3066 0x00E4, 0x0002, 0x0001, 0x0007, 0x0008, 0x000D, 0x0009, 0x001F,
3067 0x0018, 0x0000, 0x0006, 0x001E, 0x003B, 0x00EB, 0x0397, 0x000A,
3068 0x0002, 0x002C, 0x005B, 0x005A, 0x000F, 0x0038, 0x0017, 0x0006
3070 0x001E, 0x006F, 0x00AE, 0x00AF, 0x0187, 0x061B, 0x0C35, 0x001A,
3071 0x030C, 0x0002, 0x0001, 0x0007, 0x0008, 0x000E, 0x0009, 0x001F,
3072 0x0014, 0x0000, 0x0001, 0x0019, 0x002A, 0x0060, 0x0C34, 0x000B,
3073 0x000D, 0x0036, 0x006E, 0x0056, 0x0031, 0x00C2, 0x0018, 0x0019
3075 0x0001, 0x002C, 0x0005, 0x0015, 0x0008, 0x0097, 0x012D, 0x0017,
3076 0x004A, 0x0003, 0x0002, 0x0009, 0x000A, 0x000E, 0x0008, 0x001F,
3077 0x0007, 0x001E, 0x001B, 0x0004, 0x005A, 0x0024, 0x012C, 0x000C,
3078 0x0006, 0x0000, 0x0003, 0x005B, 0x0014, 0x0013, 0x001A, 0x000B
3080 0x0004, 0x0000, 0x0017, 0x0063, 0x018B, 0x0310, 0x0C44, 0x0019,
3081 0x0623, 0x0004, 0x0003, 0x000A, 0x000B, 0x000D, 0x0003, 0x001C,
3082 0x0003, 0x000A, 0x0004, 0x0003, 0x018A, 0x188B, 0x188A, 0x000F,
3083 0x000B, 0x0002, 0x000A, 0x0002, 0x0016, 0x0189, 0x001D, 0x0030
3085 0x000D, 0x0003, 0x0077, 0x000D, 0x0082, 0x020D, 0x0830, 0x0019,
3086 0x0419, 0x0003, 0x0002, 0x000A, 0x0009, 0x000B, 0x0002, 0x0011,
3087 0x0039, 0x0002, 0x0021, 0x0040, 0x1063, 0x20C5, 0x20C4, 0x000F,
3088 0x0018, 0x0007, 0x0038, 0x000C, 0x0076, 0x0107, 0x0000, 0x003A
3090 0x000F, 0x001C, 0x0036, 0x0008, 0x0061, 0x0091, 0x0243, 0x0009,
3091 0x0120, 0x0005, 0x0003, 0x0008, 0x0005, 0x0001, 0x0013, 0x0031,
3092 0x0076, 0x0060, 0x0093, 0x0909, 0x0908, 0x090B, 0x090A, 0x0001,
3093 0x001A, 0x0019, 0x003A, 0x0025, 0x0077, 0x0092, 0x0000, 0x0037
3095 0x001F, 0x0079, 0x00F1, 0x00F0, 0x011B, 0x0469, 0x0468, 0x003B,
3096 0x0022, 0x0005, 0x0004, 0x0007, 0x0005, 0x0006, 0x001C, 0x0001,
3097 0x0035, 0x003D, 0x003A, 0x0010, 0x0047, 0x008C, 0x0235, 0x0001,
3098 0x0001, 0x0019, 0x0000, 0x0030, 0x0009, 0x0031, 0x001B, 0x0034
3100 0x0003, 0x001B, 0x00F3, 0x00FD, 0x03C9, 0x0F20, 0x1E42, 0x003D,
3101 0x00FC, 0x0006, 0x0004, 0x0002, 0x0000, 0x0001, 0x0017, 0x003E,
3102 0x001A, 0x0039, 0x002B, 0x0078, 0x01E5, 0x0791, 0x1E43, 0x0002,
3103 0x0007, 0x001D, 0x000C, 0x0038, 0x0014, 0x007F, 0x0016, 0x002A
3105 0x0007, 0x0039, 0x0051, 0x0078, 0x03CB, 0x0F29, 0x1E51, 0x003D,
3106 0x00F3, 0x0006, 0x0004, 0x0002, 0x0000, 0x0001, 0x0017, 0x003E,
3107 0x007F, 0x002B, 0x007E, 0x0050, 0x01E4, 0x0795, 0x1E50, 0x0002,
3108 0x0006, 0x001D, 0x0006, 0x0038, 0x0007, 0x0029, 0x0016, 0x002A
3110 0x0008, 0x003B, 0x001D, 0x0072, 0x01CC, 0x0734, 0x1CD5, 0x003A,
3111 0x001C, 0x0006, 0x0005, 0x0002, 0x0001, 0x0000, 0x0012, 0x003E,
3112 0x007F, 0x001E, 0x007E, 0x00E7, 0x039B, 0x0E6B, 0x1CD4, 0x0002,
3113 0x0006, 0x001E, 0x000E, 0x0038, 0x0006, 0x000F, 0x0013, 0x001F
3115 0x000D, 0x003F, 0x0073, 0x000C, 0x00E4, 0x072B, 0x0E54, 0x003A,
3116 0x001A, 0x0005, 0x0004, 0x0002, 0x0001, 0x0000, 0x0007, 0x0038,
3117 0x0076, 0x0077, 0x001B, 0x01CB, 0x0394, 0x1CAB, 0x1CAA, 0x0002,
3118 0x0006, 0x001E, 0x000E, 0x003E, 0x0019, 0x001F, 0x0018, 0x001E
3120 0x000E, 0x0007, 0x000C, 0x001C, 0x00BD, 0x02F3, 0x0BC9, 0x001F,
3121 0x00BF, 0x0006, 0x0004, 0x0002, 0x0001, 0x001E, 0x0001, 0x000D,
3122 0x003A, 0x003B, 0x00BE, 0x0178, 0x05E5, 0x1791, 0x1790, 0x0002,
3123 0x0006, 0x001F, 0x0016, 0x0000, 0x0015, 0x002E, 0x0014, 0x001E
3125 0x0000, 0x001B, 0x0031, 0x003A, 0x0060, 0x006F, 0x01B9, 0x000E,
3126 0x001A, 0x0005, 0x0003, 0x0002, 0x001F, 0x001A, 0x0039, 0x000C,
3127 0x00C3, 0x00C2, 0x0036, 0x00DD, 0x0370, 0x06E3, 0x06E2, 0x0002,
3128 0x0008, 0x001E, 0x0019, 0x003B, 0x0012, 0x000F, 0x0013, 0x0038
3130 0x0002, 0x0000, 0x0003, 0x001C, 0x0032, 0x001C, 0x0199, 0x0004,
3131 0x00CD, 0x0004, 0x0003, 0x001B, 0x001A, 0x003D, 0x0067, 0x003B,
3132 0x0198, 0x0075, 0x00E9, 0x03A1, 0x03A0, 0x03A3, 0x03A2, 0x0005,
3133 0x0002, 0x001F, 0x001D, 0x003C, 0x0018, 0x000F, 0x0006, 0x0005
3136 const VP40_AC_CAT0_BITS: [[u8; 32]; 16] = [
3138 5, 7, 9, 9, 11, 13, 13, 5, 12, 3, 4, 4, 4, 4, 4, 4,
3139 5, 4, 4, 4, 5, 6, 9, 4, 6, 6, 7, 7, 7, 10, 5, 7
3141 5, 7, 8, 8, 11, 13, 13, 5, 12, 3, 4, 4, 4, 4, 4, 4,
3142 5, 4, 4, 4, 5, 6, 9, 4, 6, 6, 7, 7, 8, 10, 5, 7
3144 5, 7, 8, 8, 10, 12, 13, 5, 11, 3, 3, 4, 4, 4, 4, 5,
3145 5, 4, 4, 5, 6, 8, 13, 4, 5, 6, 7, 7, 7, 9, 5, 6
3147 5, 7, 8, 8, 10, 12, 13, 5, 11, 3, 3, 4, 4, 4, 4, 5,
3148 5, 4, 4, 5, 6, 8, 13, 4, 5, 6, 7, 7, 7, 9, 5, 6
3150 4, 6, 7, 7, 8, 12, 13, 5, 11, 3, 3, 4, 4, 4, 4, 5,
3151 5, 5, 5, 5, 7, 10, 13, 4, 5, 5, 6, 7, 7, 9, 5, 6
3153 4, 5, 7, 7, 9, 10, 12, 5, 11, 3, 3, 4, 4, 4, 4, 5,
3154 5, 5, 5, 6, 9, 13, 13, 4, 5, 5, 6, 6, 7, 9, 5, 6
3156 4, 5, 7, 6, 8, 10, 12, 5, 11, 3, 3, 4, 4, 4, 4, 5,
3157 6, 5, 6, 7, 13, 14, 14, 4, 5, 5, 6, 6, 7, 9, 4, 6
3159 4, 5, 6, 5, 7, 8, 10, 5, 9, 3, 3, 4, 4, 4, 5, 6,
3160 7, 7, 8, 12, 12, 12, 12, 3, 5, 5, 6, 6, 7, 8, 4, 6
3162 5, 7, 8, 8, 10, 12, 12, 6, 7, 3, 3, 4, 4, 4, 5, 5,
3163 6, 6, 6, 6, 8, 9, 11, 3, 4, 5, 5, 6, 5, 6, 5, 6
3165 4, 6, 8, 8, 10, 12, 13, 6, 8, 3, 3, 4, 4, 4, 5, 6,
3166 6, 6, 6, 7, 9, 11, 13, 3, 4, 5, 5, 6, 5, 7, 5, 6
3168 4, 6, 7, 7, 10, 12, 13, 6, 8, 3, 3, 4, 4, 4, 5, 6,
3169 7, 6, 7, 7, 9, 11, 13, 3, 4, 5, 5, 6, 5, 6, 5, 6
3171 4, 6, 7, 7, 9, 11, 13, 6, 7, 3, 3, 4, 4, 4, 5, 6,
3172 7, 6, 7, 8, 10, 12, 13, 3, 4, 5, 5, 6, 5, 6, 5, 6
3174 4, 6, 7, 6, 8, 11, 12, 6, 7, 3, 3, 4, 4, 4, 5, 6,
3175 7, 7, 7, 9, 10, 13, 13, 3, 4, 5, 5, 6, 5, 6, 5, 6
3177 4, 5, 6, 6, 8, 10, 12, 6, 8, 3, 3, 4, 4, 5, 5, 6,
3178 7, 7, 8, 9, 11, 13, 13, 3, 4, 5, 5, 5, 5, 6, 5, 6
3180 3, 5, 6, 6, 7, 9, 11, 6, 7, 3, 3, 4, 5, 5, 6, 6,
3181 8, 8, 8, 10, 12, 13, 13, 3, 4, 5, 5, 6, 5, 6, 5, 6
3183 3, 4, 5, 5, 6, 7, 9, 6, 8, 3, 3, 5, 5, 6, 7, 8,
3184 9, 9, 10, 12, 12, 12, 12, 3, 4, 5, 5, 6, 5, 6, 5, 6
3187 const VP40_AC_CAT1_CODES: [[u32; 32]; 16] = [
3189 0x0004, 0x00F5, 0x0182, 0x060F, 0x1839, 0x1838, 0x183B, 0x0013,
3190 0x00C0, 0x0003, 0x0002, 0x000B, 0x000A, 0x000E, 0x0008, 0x0001,
3191 0x0012, 0x001F, 0x0000, 0x0006, 0x007B, 0x0306, 0x183A, 0x000D,
3192 0x0007, 0x0031, 0x000A, 0x0061, 0x003C, 0x00F4, 0x0019, 0x000B
3194 0x000A, 0x001A, 0x01D8, 0x03B3, 0x0ECA, 0x1D96, 0x3B2F, 0x0014,
3195 0x0036, 0x0004, 0x0003, 0x000C, 0x000B, 0x0000, 0x0004, 0x001C,
3196 0x0005, 0x0015, 0x0007, 0x0017, 0x0037, 0x0764, 0x3B2E, 0x000F,
3197 0x001A, 0x003A, 0x000C, 0x0077, 0x0004, 0x00ED, 0x001B, 0x0016
3199 0x001A, 0x002D, 0x0058, 0x01F4, 0x07D4, 0x1F55, 0x1F54, 0x0014,
3200 0x0059, 0x0004, 0x0003, 0x000B, 0x000C, 0x000E, 0x0004, 0x0015,
3201 0x0005, 0x0007, 0x0004, 0x007C, 0x03EB, 0x1F57, 0x1F56, 0x0000,
3202 0x001B, 0x003F, 0x000D, 0x000C, 0x000A, 0x00FB, 0x001E, 0x0017
3204 0x0000, 0x0075, 0x004A, 0x0097, 0x025B, 0x0969, 0x0968, 0x000B,
3205 0x00E8, 0x0005, 0x0004, 0x0007, 0x000C, 0x000D, 0x0001, 0x000A,
3206 0x0039, 0x003B, 0x0018, 0x00E9, 0x012C, 0x096B, 0x096A, 0x0001,
3207 0x001F, 0x0008, 0x0019, 0x0013, 0x000D, 0x0024, 0x001E, 0x0038
3209 0x0004, 0x0014, 0x006E, 0x0057, 0x0159, 0x0562, 0x0AC7, 0x000B,
3210 0x006F, 0x0006, 0x0005, 0x0008, 0x0009, 0x0007, 0x001E, 0x0002,
3211 0x0007, 0x0006, 0x002A, 0x00AD, 0x0AC6, 0x0561, 0x0560, 0x0001,
3212 0x001F, 0x000C, 0x0039, 0x001A, 0x0000, 0x0036, 0x001D, 0x0038
3214 0x0007, 0x001B, 0x000E, 0x000D, 0x03E1, 0x1F06, 0x3E0F, 0x0002,
3215 0x00F9, 0x0005, 0x0006, 0x0008, 0x0009, 0x0004, 0x000C, 0x001A,
3216 0x000F, 0x000C, 0x01F1, 0x07C0, 0x3E0E, 0x1F05, 0x1F04, 0x0001,
3217 0x0000, 0x001C, 0x003F, 0x003D, 0x0005, 0x007D, 0x001D, 0x003C
3219 0x000F, 0x000A, 0x0071, 0x0006, 0x01C2, 0x0702, 0x1C0E, 0x0002,
3220 0x000E, 0x0005, 0x0004, 0x0006, 0x0007, 0x001D, 0x0017, 0x000F,
3221 0x01C3, 0x01C1, 0x0380, 0x381F, 0x381E, 0x1C0D, 0x1C0C, 0x0001,
3222 0x0004, 0x0018, 0x0001, 0x0000, 0x000D, 0x0016, 0x0019, 0x0039
3224 0x0002, 0x001E, 0x003B, 0x000D, 0x0061, 0x01FA, 0x1FB5, 0x0031,
3225 0x00FC, 0x0004, 0x0005, 0x0001, 0x0007, 0x003A, 0x0060, 0x03F7,
3226 0x07EC, 0x1FB7, 0x3F6C, 0x7EDB, 0x7EDA, 0x3F69, 0x3F68, 0x0001,
3227 0x0000, 0x0019, 0x003E, 0x0039, 0x000D, 0x0038, 0x000C, 0x007F
3229 0x001E, 0x0070, 0x0127, 0x0126, 0x0492, 0x124D, 0x124C, 0x0001,
3230 0x007F, 0x0006, 0x0005, 0x0005, 0x0004, 0x0001, 0x0007, 0x0025,
3231 0x0071, 0x007E, 0x0048, 0x0125, 0x0248, 0x124F, 0x124E, 0x0003,
3232 0x0008, 0x001D, 0x0006, 0x003E, 0x0002, 0x0000, 0x0013, 0x0039
3234 0x0001, 0x0001, 0x00E7, 0x0091, 0x0240, 0x120D, 0x120C, 0x003C,
3235 0x0000, 0x0006, 0x0005, 0x0005, 0x0004, 0x001F, 0x0004, 0x0025,
3236 0x0072, 0x0049, 0x00E6, 0x0121, 0x0482, 0x120F, 0x120E, 0x0003,
3237 0x0008, 0x001D, 0x0005, 0x003D, 0x0003, 0x0001, 0x0013, 0x0038
3239 0x0004, 0x000F, 0x00F4, 0x005B, 0x02D3, 0x0B4A, 0x1697, 0x003C,
3240 0x000E, 0x0006, 0x0005, 0x0002, 0x0001, 0x001D, 0x0000, 0x007B,
3241 0x002C, 0x00F5, 0x00B5, 0x0168, 0x1696, 0x0B49, 0x0B48, 0x0003,
3242 0x0009, 0x001F, 0x000A, 0x0001, 0x0008, 0x0006, 0x001C, 0x0017
3244 0x0008, 0x0039, 0x001A, 0x0003, 0x00DB, 0x06D6, 0x0DAF, 0x003C,
3245 0x000C, 0x0006, 0x0005, 0x0002, 0x0001, 0x001D, 0x003D, 0x0000,
3246 0x0002, 0x0037, 0x006C, 0x01B4, 0x0DAE, 0x06D5, 0x06D4, 0x0002,
3247 0x0007, 0x001F, 0x0007, 0x0001, 0x0009, 0x000D, 0x000C, 0x0038
3249 0x000F, 0x0004, 0x002F, 0x002E, 0x0054, 0x0555, 0x0554, 0x0016,
3250 0x000E, 0x0006, 0x0005, 0x0001, 0x0000, 0x0009, 0x000B, 0x0014,
3251 0x0057, 0x0056, 0x00AB, 0x0557, 0x0556, 0x02A9, 0x02A8, 0x0003,
3252 0x0008, 0x0013, 0x000A, 0x0008, 0x000E, 0x0012, 0x0006, 0x000F
3254 0x0001, 0x000E, 0x0006, 0x0004, 0x00DA, 0x0DBE, 0x1B7E, 0x0007,
3255 0x001A, 0x0005, 0x0004, 0x001C, 0x001B, 0x003A, 0x0037, 0x006C,
3256 0x01B6, 0x036E, 0x0DBD, 0x36FF, 0x36FE, 0x1B79, 0x1B78, 0x0002,
3257 0x000C, 0x0000, 0x000F, 0x000C, 0x000F, 0x001A, 0x003B, 0x0005
3259 0x0005, 0x001E, 0x003A, 0x003E, 0x00FC, 0x0FD7, 0x3F55, 0x0077,
3260 0x0030, 0x0003, 0x0004, 0x001A, 0x0019, 0x007F, 0x01FB, 0x03F4,
3261 0x0FD6, 0x1FA9, 0x3F54, 0x3F57, 0x3F56, 0x3F51, 0x3F50, 0x0001,
3262 0x0004, 0x001C, 0x000B, 0x000A, 0x0000, 0x001B, 0x0031, 0x0076
3264 0x0005, 0x000C, 0x001B, 0x0008, 0x0038, 0x0015, 0x00A3, 0x00E6,
3265 0x0004, 0x0001, 0x0002, 0x0012, 0x0003, 0x000B, 0x0029, 0x00A0,
3266 0x0142, 0x0287, 0x0286, 0x0289, 0x0288, 0x028B, 0x028A, 0x000F,
3267 0x001D, 0x0013, 0x0001, 0x0000, 0x0003, 0x001A, 0x0072, 0x00E7
3270 const VP40_AC_CAT1_BITS: [[u8; 32]; 16] = [
3272 5, 8, 9, 11, 13, 13, 13, 5, 8, 3, 3, 4, 4, 4, 4, 4,
3273 5, 5, 4, 5, 7, 10, 13, 4, 5, 6, 6, 7, 6, 8, 5, 6
3275 5, 7, 9, 10, 12, 13, 14, 5, 8, 3, 3, 4, 4, 3, 4, 5,
3276 5, 5, 5, 6, 8, 11, 14, 4, 5, 6, 6, 7, 5, 8, 5, 6
3278 5, 7, 8, 9, 11, 13, 13, 5, 8, 3, 3, 4, 4, 4, 4, 5,
3279 5, 5, 5, 7, 10, 13, 13, 3, 5, 6, 6, 6, 5, 8, 5, 6
3281 4, 7, 8, 9, 11, 13, 13, 5, 8, 3, 3, 4, 4, 4, 4, 5,
3282 6, 6, 6, 8, 10, 13, 13, 3, 5, 5, 6, 6, 5, 7, 5, 6
3284 4, 6, 8, 8, 10, 12, 13, 5, 8, 3, 3, 4, 4, 4, 5, 5,
3285 6, 6, 7, 9, 13, 12, 12, 3, 5, 5, 6, 6, 4, 7, 5, 6
3287 4, 6, 7, 7, 10, 13, 14, 5, 8, 3, 3, 4, 4, 4, 5, 6,
3288 7, 7, 9, 11, 14, 13, 13, 3, 4, 5, 6, 6, 4, 7, 5, 6
3290 4, 5, 7, 6, 9, 11, 13, 5, 7, 3, 3, 4, 4, 5, 6, 7,
3291 9, 9, 10, 14, 14, 13, 13, 3, 4, 5, 5, 5, 4, 6, 5, 6
3293 3, 5, 6, 5, 7, 9, 13, 6, 8, 3, 3, 4, 4, 6, 7, 10,
3294 11, 13, 14, 15, 15, 14, 14, 3, 4, 5, 6, 6, 4, 6, 5, 7
3296 5, 7, 9, 9, 11, 13, 13, 5, 7, 3, 3, 4, 4, 4, 5, 6,
3297 7, 7, 7, 9, 10, 13, 13, 3, 4, 5, 5, 6, 4, 5, 5, 6
3299 4, 6, 8, 8, 10, 13, 13, 6, 6, 3, 3, 4, 4, 5, 5, 6,
3300 7, 7, 8, 9, 11, 13, 13, 3, 4, 5, 5, 6, 4, 5, 5, 6
3302 4, 6, 8, 8, 11, 13, 14, 6, 6, 3, 3, 4, 4, 5, 5, 7,
3303 7, 8, 9, 10, 14, 13, 13, 3, 4, 5, 5, 5, 4, 5, 5, 6
3305 4, 6, 7, 7, 10, 13, 14, 6, 6, 3, 3, 4, 4, 5, 6, 6,
3306 7, 8, 9, 11, 14, 13, 13, 3, 4, 5, 5, 5, 4, 5, 5, 6
3308 4, 5, 7, 7, 9, 13, 13, 6, 6, 3, 3, 4, 4, 5, 6, 7,
3309 9, 9, 10, 13, 13, 12, 12, 3, 4, 5, 5, 5, 4, 5, 5, 6
3311 3, 5, 6, 6, 9, 13, 14, 6, 6, 3, 3, 5, 5, 6, 7, 8,
3312 10, 11, 13, 15, 15, 14, 14, 3, 4, 4, 5, 5, 4, 5, 6, 6
3314 3, 5, 6, 6, 8, 12, 14, 7, 6, 3, 3, 5, 5, 7, 9, 10,
3315 12, 13, 14, 14, 14, 14, 14, 3, 4, 5, 5, 5, 3, 5, 6, 7
3317 3, 4, 5, 4, 6, 8, 11, 8, 6, 3, 3, 5, 5, 7, 9, 11,
3318 12, 13, 13, 13, 13, 13, 13, 4, 5, 5, 5, 5, 3, 5, 7, 8
3321 const VP40_AC_CAT2_CODES: [[u32; 32]; 16] = [
3323 0x0009, 0x0015, 0x0028, 0x0052, 0x029A, 0x0537, 0x0536, 0x000A,
3324 0x0054, 0x0004, 0x0003, 0x000C, 0x000B, 0x000D, 0x0003, 0x0014,
3325 0x003A, 0x0004, 0x0038, 0x0055, 0x00A7, 0x0299, 0x0298, 0x0000,
3326 0x001E, 0x0008, 0x002B, 0x000B, 0x000B, 0x003B, 0x001F, 0x0039
3328 0x001D, 0x002F, 0x0002, 0x0007, 0x0019, 0x0035, 0x0034, 0x0009,
3329 0x002E, 0x0006, 0x0005, 0x0009, 0x0008, 0x0007, 0x001F, 0x0008,
3330 0x0018, 0x0019, 0x0001, 0x0000, 0x0018, 0x0037, 0x0036, 0x0001,
3331 0x0001, 0x000A, 0x0039, 0x0016, 0x000D, 0x0001, 0x001E, 0x0038
3333 0x0001, 0x0071, 0x00E0, 0x01C3, 0x0708, 0x1C26, 0x384F, 0x0001,
3334 0x0031, 0x0006, 0x0005, 0x0009, 0x0008, 0x0005, 0x000F, 0x0039,
3335 0x0077, 0x0076, 0x0030, 0x0385, 0x384E, 0x1C25, 0x1C24, 0x0001,
3336 0x0004, 0x000D, 0x0000, 0x0019, 0x001F, 0x000E, 0x001E, 0x003A
3338 0x0006, 0x000C, 0x00D6, 0x007B, 0x01E8, 0x07A4, 0x0F4B, 0x0036,
3339 0x006A, 0x0007, 0x0005, 0x0008, 0x0009, 0x0001, 0x0007, 0x000D,
3340 0x003C, 0x00D7, 0x00F5, 0x07A7, 0x0F4A, 0x0F4D, 0x0F4C, 0x0002,
3341 0x0002, 0x000E, 0x0037, 0x0034, 0x0000, 0x0019, 0x0018, 0x001F
3343 0x000A, 0x0027, 0x00BF, 0x00BE, 0x0224, 0x225D, 0x225C, 0x0026,
3344 0x005E, 0x0007, 0x0006, 0x0006, 0x0007, 0x0016, 0x002E, 0x0045,
3345 0x0088, 0x0113, 0x044A, 0x225F, 0x225E, 0x112D, 0x112C, 0x0002,
3346 0x0002, 0x0012, 0x0003, 0x0002, 0x0003, 0x0000, 0x0010, 0x0023
3348 0x000F, 0x0006, 0x0075, 0x0074, 0x000A, 0x00BF, 0x00B9, 0x0022,
3349 0x0003, 0x0005, 0x0006, 0x0001, 0x0002, 0x0007, 0x0000, 0x0004,
3350 0x0016, 0x005E, 0x00B8, 0x00BB, 0x00BA, 0x017D, 0x017C, 0x0002,
3351 0x0006, 0x001C, 0x0010, 0x003B, 0x0009, 0x0007, 0x0001, 0x0023
3353 0x0001, 0x001C, 0x0036, 0x003B, 0x00EA, 0x075B, 0x1D65, 0x0019,
3354 0x0074, 0x0004, 0x0005, 0x0000, 0x0001, 0x0037, 0x01D7, 0x075A,
3355 0x1D64, 0x1D67, 0x1D66, 0x1D61, 0x1D60, 0x1D63, 0x1D62, 0x0002,
3356 0x001F, 0x001A, 0x000D, 0x003D, 0x000C, 0x0007, 0x003C, 0x0018
3358 0x0002, 0x0001, 0x0014, 0x0000, 0x002F, 0x00BB, 0x02E4, 0x007D,
3359 0x00BA, 0x0003, 0x0004, 0x0016, 0x001A, 0x00B8, 0x172E, 0x2E5F,
3360 0x2E5E, 0x1729, 0x1728, 0x172B, 0x172A, 0x172D, 0x172C, 0x0001,
3361 0x001E, 0x0015, 0x001B, 0x003F, 0x000C, 0x000E, 0x007C, 0x0173
3363 0x0003, 0x007B, 0x0058, 0x01EA, 0x1EB1, 0x1EB0, 0x1EB3, 0x0013,
3364 0x0012, 0x0005, 0x0006, 0x0002, 0x0001, 0x0013, 0x003C, 0x002D,
3365 0x00F4, 0x0059, 0x03D7, 0x0F5B, 0x1EB2, 0x1EB5, 0x1EB4, 0x0003,
3366 0x000E, 0x001F, 0x0012, 0x0008, 0x0008, 0x0000, 0x000A, 0x0017
3368 0x0008, 0x003C, 0x00F5, 0x00F4, 0x1EF7, 0x3DE9, 0x3DE8, 0x001C,
3369 0x000D, 0x0005, 0x0006, 0x0001, 0x0000, 0x0007, 0x000C, 0x00F6,
3370 0x01EE, 0x03DF, 0x07BC, 0x3DEB, 0x3DEA, 0x3DED, 0x3DEC, 0x0002,
3371 0x0009, 0x001F, 0x000F, 0x0005, 0x000E, 0x0006, 0x0004, 0x001D
3373 0x0009, 0x0039, 0x0019, 0x0018, 0x0706, 0x383D, 0x383C, 0x000D,
3374 0x000F, 0x0005, 0x0006, 0x0000, 0x001D, 0x0003, 0x0071, 0x00E1,
3375 0x01C0, 0x0382, 0x1C1D, 0x383F, 0x383E, 0x3839, 0x3838, 0x0002,
3376 0x0008, 0x0002, 0x000D, 0x000C, 0x000F, 0x0007, 0x0002, 0x000E
3378 0x0000, 0x0006, 0x0035, 0x0034, 0x0777, 0x1DD4, 0x3BAB, 0x000E,
3379 0x000F, 0x0005, 0x0004, 0x001C, 0x0019, 0x003A, 0x00EF, 0x01DC,
3380 0x0776, 0x0774, 0x3BAA, 0x3BAD, 0x3BAC, 0x3BAF, 0x3BAE, 0x0002,
3381 0x0007, 0x0002, 0x0018, 0x000C, 0x000F, 0x000D, 0x001B, 0x0076
3383 0x0002, 0x0011, 0x0006, 0x004F, 0x0130, 0x1319, 0x1318, 0x004E,
3384 0x0007, 0x0006, 0x0005, 0x0010, 0x000D, 0x0005, 0x0099, 0x0262,
3385 0x098E, 0x131B, 0x131A, 0x263D, 0x263C, 0x263F, 0x263E, 0x0001,
3386 0x0007, 0x0000, 0x0012, 0x000C, 0x000E, 0x000F, 0x0004, 0x004D
3388 0x0003, 0x0000, 0x0002, 0x0037, 0x01B7, 0x0DB5, 0x36DD, 0x006C,
3389 0x0016, 0x0005, 0x0004, 0x0003, 0x000A, 0x002E, 0x036C, 0x0DB4,
3390 0x36DC, 0x36DF, 0x36DE, 0x36D9, 0x36D8, 0x36DB, 0x36DA, 0x000E,
3391 0x0004, 0x001A, 0x0019, 0x0018, 0x000F, 0x0001, 0x002F, 0x00DA
3393 0x0006, 0x0006, 0x000F, 0x0000, 0x0075, 0x03B8, 0x1DCA, 0x0074,
3394 0x0076, 0x0004, 0x0005, 0x0003, 0x0002, 0x01DE, 0x0EE6, 0x3B97,
3395 0x3B96, 0x3B9D, 0x3B9C, 0x3B9F, 0x3B9E, 0x1DC9, 0x1DC8, 0x0005,
3396 0x001C, 0x0009, 0x000E, 0x0008, 0x000F, 0x0001, 0x01DF, 0x01DD
3398 0x0004, 0x000B, 0x001D, 0x000C, 0x0014, 0x00E0, 0x3875, 0x0386,
3399 0x01C2, 0x0000, 0x0001, 0x0071, 0x0072, 0x1C3F, 0x3874, 0x3877,
3400 0x3876, 0x3871, 0x3870, 0x3873, 0x3872, 0x3879, 0x3878, 0x003C,
3401 0x0073, 0x002A, 0x003D, 0x002B, 0x001F, 0x000D, 0x1C3E, 0x1C3D
3404 const VP40_AC_CAT2_BITS: [[u8; 32]; 16] = [
3406 5, 7, 8, 9, 12, 13, 13, 5, 7, 3, 3, 4, 4, 4, 4, 5,
3407 6, 5, 6, 7, 10, 12, 12, 3, 5, 5, 6, 6, 5, 6, 5, 6
3409 5, 7, 8, 9, 11, 12, 12, 5, 7, 3, 3, 4, 4, 4, 5, 5,
3410 6, 6, 6, 7, 11, 12, 12, 3, 4, 5, 6, 6, 5, 5, 5, 6
3412 4, 7, 8, 9, 11, 13, 14, 5, 7, 3, 3, 4, 4, 4, 5, 6,
3413 7, 7, 7, 10, 14, 13, 13, 3, 4, 5, 5, 6, 5, 5, 5, 6
3415 4, 6, 8, 8, 10, 12, 13, 6, 7, 3, 3, 4, 4, 4, 5, 6,
3416 7, 8, 9, 12, 13, 13, 13, 3, 4, 5, 6, 6, 4, 5, 5, 6
3418 4, 6, 8, 8, 10, 14, 14, 6, 7, 3, 3, 4, 4, 5, 6, 7,
3419 8, 9, 11, 14, 14, 13, 13, 3, 4, 5, 5, 5, 4, 4, 5, 6
3421 4, 5, 7, 7, 9, 13, 13, 6, 7, 3, 3, 4, 4, 5, 6, 8,
3422 10, 12, 13, 13, 13, 14, 14, 3, 4, 5, 5, 6, 4, 4, 5, 6
3424 3, 5, 6, 6, 8, 11, 13, 6, 7, 3, 3, 4, 4, 6, 9, 11,
3425 13, 13, 13, 13, 13, 13, 13, 3, 5, 5, 5, 6, 4, 4, 6, 6
3427 3, 4, 5, 4, 6, 8, 10, 7, 8, 3, 3, 5, 5, 8, 13, 14,
3428 14, 13, 13, 13, 13, 13, 13, 3, 5, 5, 5, 6, 4, 4, 7, 9
3430 4, 7, 8, 9, 13, 13, 13, 6, 6, 3, 3, 4, 4, 5, 6, 7,
3431 8, 8, 10, 12, 13, 13, 13, 3, 4, 5, 5, 5, 4, 4, 5, 6
3433 4, 6, 8, 8, 13, 14, 14, 6, 6, 3, 3, 4, 4, 5, 6, 8,
3434 9, 10, 11, 14, 14, 14, 14, 3, 4, 5, 5, 5, 4, 4, 5, 6
3436 4, 6, 7, 7, 11, 14, 14, 6, 6, 3, 3, 4, 5, 5, 7, 8,
3437 9, 10, 13, 14, 14, 14, 14, 3, 4, 4, 5, 5, 4, 4, 5, 6
3439 3, 5, 7, 7, 11, 13, 14, 6, 6, 3, 3, 5, 5, 6, 8, 9,
3440 11, 11, 14, 14, 14, 14, 14, 3, 4, 4, 5, 5, 4, 4, 6, 7
3442 3, 5, 6, 7, 9, 13, 13, 7, 6, 3, 3, 5, 5, 6, 8, 10,
3443 12, 13, 13, 14, 14, 14, 14, 3, 4, 4, 5, 5, 4, 4, 6, 7
3445 3, 4, 5, 6, 9, 12, 14, 7, 6, 3, 3, 5, 5, 7, 10, 12,
3446 14, 14, 14, 14, 14, 14, 14, 4, 4, 5, 5, 5, 4, 3, 7, 8
3448 3, 4, 5, 4, 7, 10, 13, 7, 7, 3, 3, 5, 5, 9, 12, 14,
3449 14, 14, 14, 14, 14, 13, 13, 4, 5, 5, 5, 5, 4, 3, 9, 9
3451 3, 4, 5, 4, 5, 8, 14, 10, 9, 2, 2, 7, 7, 13, 14, 14,
3452 14, 14, 14, 14, 14, 14, 14, 6, 7, 6, 6, 6, 5, 4, 13, 13
3455 const VP40_AC_CAT3_CODES: [[u32; 32]; 16] = [
3457 0x0007, 0x000F, 0x00BB, 0x00BA, 0x05CF, 0x173A, 0x2E77, 0x0029,
3458 0x0172, 0x0007, 0x0006, 0x0009, 0x0008, 0x0001, 0x0005, 0x000D,
3459 0x001D, 0x001C, 0x00B8, 0x02E6, 0x2E76, 0x1739, 0x1738, 0x0002,
3460 0x0006, 0x0016, 0x0004, 0x0028, 0x0015, 0x000C, 0x0000, 0x002F
3462 0x000B, 0x0002, 0x0054, 0x002F, 0x02AC, 0x156B, 0x1568, 0x0016,
3463 0x0154, 0x0007, 0x0006, 0x0004, 0x0003, 0x0013, 0x0028, 0x002E,
3464 0x0157, 0x0155, 0x055B, 0x2AD3, 0x2AD2, 0x2AD5, 0x2AD4, 0x0003,
3465 0x0008, 0x0000, 0x000A, 0x0003, 0x0002, 0x002B, 0x0012, 0x0029
3467 0x000F, 0x0007, 0x0001, 0x0000, 0x01C4, 0x0703, 0x0E02, 0x0011,
3468 0x00E1, 0x0005, 0x0006, 0x0002, 0x0001, 0x0009, 0x0010, 0x00E3,
3469 0x01C5, 0x01C1, 0x0702, 0x1C07, 0x1C06, 0x0E01, 0x0E00, 0x0004,
3470 0x0007, 0x001D, 0x000D, 0x0001, 0x0005, 0x0006, 0x000C, 0x0039
3472 0x0001, 0x001C, 0x0011, 0x0013, 0x0042, 0x0207, 0x0815, 0x0075,
3473 0x0041, 0x0005, 0x0006, 0x0000, 0x001F, 0x003B, 0x0074, 0x0043,
3474 0x0080, 0x0206, 0x0814, 0x0817, 0x0816, 0x0409, 0x0408, 0x0003,
3475 0x0009, 0x001E, 0x0011, 0x0003, 0x0005, 0x0010, 0x0002, 0x0012
3477 0x0001, 0x001F, 0x0027, 0x0001, 0x004B, 0x0123, 0x0915, 0x0000,
3478 0x0049, 0x0005, 0x0006, 0x001D, 0x001C, 0x0013, 0x004A, 0x0090,
3479 0x0914, 0x0917, 0x0916, 0x0911, 0x0910, 0x0913, 0x0912, 0x0003,
3480 0x0005, 0x0001, 0x0012, 0x0008, 0x0008, 0x001E, 0x0026, 0x0001
3482 0x0003, 0x0001, 0x003F, 0x000B, 0x004E, 0x0132, 0x099A, 0x004F,
3483 0x0098, 0x0006, 0x0005, 0x001D, 0x001C, 0x007C, 0x0267, 0x1331,
3484 0x1330, 0x1333, 0x1332, 0x266D, 0x266C, 0x266F, 0x266E, 0x0001,
3485 0x0004, 0x001E, 0x0012, 0x000A, 0x0008, 0x0000, 0x007D, 0x004D
3487 0x0002, 0x0007, 0x0015, 0x0003, 0x0004, 0x00A7, 0x0536, 0x0028,
3488 0x029A, 0x0006, 0x0004, 0x001C, 0x0017, 0x00A4, 0x29BE, 0x537F,
3489 0x537E, 0x29B9, 0x29B8, 0x29BB, 0x29BA, 0x29BD, 0x29BC, 0x000F,
3490 0x0000, 0x0005, 0x0016, 0x001D, 0x0006, 0x0001, 0x00A5, 0x014C
3492 0x0004, 0x0007, 0x001A, 0x000C, 0x0006, 0x0029, 0x01BD, 0x1BE3,
3493 0x1BE0, 0x0000, 0x0007, 0x006E, 0x01BC, 0x37C3, 0x37C2, 0x37CD,
3494 0x37CC, 0x37CF, 0x37CE, 0x37C9, 0x37C8, 0x37CB, 0x37CA, 0x0015,
3495 0x01BF, 0x037D, 0x0036, 0x0002, 0x000B, 0x0028, 0x37C5, 0x37C4
3497 0x0001, 0x0009, 0x0003, 0x0002, 0x011F, 0x08E9, 0x08E8, 0x002D,
3498 0x0022, 0x0006, 0x0007, 0x0010, 0x0011, 0x0017, 0x002C, 0x0046,
3499 0x011E, 0x011C, 0x0477, 0x08EB, 0x08EA, 0x08ED, 0x08EC, 0x0003,
3500 0x000B, 0x0001, 0x0014, 0x000A, 0x0009, 0x0015, 0x0000, 0x0010
3502 0x0001, 0x001D, 0x0022, 0x0013, 0x011E, 0x08FC, 0x23F5, 0x0023,
3503 0x0022, 0x0005, 0x0006, 0x0010, 0x000B, 0x0010, 0x008E, 0x023E,
3504 0x08FF, 0x11FD, 0x23F4, 0x23F7, 0x23F6, 0x23F9, 0x23F8, 0x0003,
3505 0x0009, 0x0000, 0x001C, 0x000A, 0x000F, 0x0001, 0x0012, 0x0046
3507 0x0003, 0x001F, 0x003C, 0x003D, 0x0086, 0x0877, 0x10E8, 0x0041,
3508 0x0040, 0x0005, 0x0006, 0x0007, 0x0006, 0x0004, 0x010F, 0x021C,
3509 0x0875, 0x21D3, 0x21D2, 0x21D9, 0x21D8, 0x21DB, 0x21DA, 0x0002,
3510 0x0009, 0x0000, 0x0011, 0x0003, 0x000E, 0x0002, 0x0005, 0x0042
3512 0x0004, 0x0001, 0x003D, 0x0009, 0x00F3, 0x0793, 0x1E45, 0x0000,
3513 0x0002, 0x0005, 0x0006, 0x0008, 0x0001, 0x0003, 0x01E5, 0x0792,
3514 0x1E44, 0x1E47, 0x1E46, 0x1E41, 0x1E40, 0x1E43, 0x1E42, 0x0001,
3515 0x0006, 0x001F, 0x000F, 0x000E, 0x000E, 0x0005, 0x0078, 0x0001
3517 0x0004, 0x0005, 0x000E, 0x0017, 0x003E, 0x00F0, 0x0F1E, 0x007A,
3518 0x007F, 0x0006, 0x0007, 0x0005, 0x0004, 0x007B, 0x01E2, 0x1E3F,
3519 0x1E3E, 0x0F19, 0x0F18, 0x0F1B, 0x0F1A, 0x0F1D, 0x0F1C, 0x0000,
3520 0x0003, 0x0016, 0x0009, 0x0008, 0x000A, 0x0006, 0x007E, 0x0079
3522 0x0005, 0x000C, 0x001A, 0x0004, 0x001A, 0x00DE, 0x0DF4, 0x00DD,
3523 0x006D, 0x0000, 0x0007, 0x0025, 0x0024, 0x00DC, 0x0DF7, 0x1BEB,
3524 0x1BEA, 0x0DF1, 0x0DF0, 0x0DF3, 0x0DF2, 0x1BED, 0x1BEC, 0x0008,
3525 0x0013, 0x000C, 0x0037, 0x0036, 0x0005, 0x0007, 0x006C, 0x01BF
3527 0x0005, 0x000D, 0x001F, 0x000C, 0x003B, 0x0040, 0x041A, 0x0104,
3528 0x0107, 0x0001, 0x0000, 0x0024, 0x0021, 0x020B, 0x106E, 0x20DF,
3529 0x20DE, 0x1055, 0x1054, 0x1057, 0x1056, 0x106D, 0x106C, 0x0011,
3530 0x003A, 0x0025, 0x0038, 0x0039, 0x0013, 0x001E, 0x020C, 0x0414
3532 0x0000, 0x0007, 0x000D, 0x0005, 0x0009, 0x0022, 0x0CD1, 0x0CD0,
3533 0x0CD3, 0x0003, 0x0002, 0x008D, 0x00CC, 0x066B, 0x0CD2, 0x19B5,
3534 0x19B4, 0x19B7, 0x19B6, 0x19B1, 0x19B0, 0x19B3, 0x19B2, 0x0047,
3535 0x008C, 0x0337, 0x0067, 0x0018, 0x0010, 0x0032, 0x0CD5, 0x0CD4
3538 const VP40_AC_CAT3_BITS: [[u8; 32]; 16] = [
3540 4, 6, 8, 8, 11, 13, 14, 6, 9, 3, 3, 4, 4, 4, 5, 6,
3541 7, 7, 8, 10, 14, 13, 13, 3, 4, 5, 5, 6, 5, 6, 4, 6
3543 4, 5, 7, 7, 10, 13, 13, 6, 9, 3, 3, 4, 4, 5, 6, 7,
3544 9, 9, 11, 14, 14, 14, 14, 3, 4, 4, 5, 5, 4, 6, 5, 6
3546 4, 5, 6, 6, 9, 11, 12, 6, 8, 3, 3, 4, 4, 5, 6, 8,
3547 9, 9, 11, 13, 13, 12, 12, 3, 4, 5, 5, 5, 4, 5, 5, 6
3549 3, 5, 6, 6, 8, 11, 13, 7, 8, 3, 3, 4, 5, 6, 7, 8,
3550 9, 11, 13, 13, 13, 12, 12, 3, 4, 5, 5, 5, 4, 5, 5, 6
3552 3, 5, 6, 5, 8, 10, 13, 6, 8, 3, 3, 5, 5, 6, 8, 9,
3553 13, 13, 13, 13, 13, 13, 13, 3, 4, 4, 5, 5, 4, 5, 6, 6
3555 3, 4, 6, 5, 7, 9, 12, 7, 8, 3, 3, 5, 5, 7, 10, 13,
3556 13, 13, 13, 14, 14, 14, 14, 3, 4, 5, 5, 5, 4, 4, 7, 7
3558 3, 4, 5, 4, 5, 8, 11, 6, 10, 3, 3, 5, 5, 8, 14, 15,
3559 15, 14, 14, 14, 14, 14, 14, 4, 4, 5, 5, 5, 4, 4, 8, 9
3561 3, 4, 5, 4, 4, 6, 9, 13, 13, 2, 3, 7, 9, 14, 14, 14,
3562 14, 14, 14, 14, 14, 14, 14, 5, 9, 10, 6, 3, 4, 6, 14, 14
3564 3, 5, 6, 6, 10, 13, 13, 7, 7, 3, 3, 5, 5, 6, 7, 8,
3565 10, 10, 12, 13, 13, 13, 13, 3, 4, 4, 5, 5, 4, 5, 5, 6
3567 3, 5, 6, 6, 9, 12, 14, 7, 7, 3, 3, 5, 5, 6, 8, 10,
3568 12, 13, 14, 14, 14, 14, 14, 3, 4, 4, 5, 5, 4, 4, 6, 7
3570 3, 5, 6, 6, 8, 12, 13, 7, 7, 3, 3, 5, 5, 6, 9, 10,
3571 12, 14, 14, 14, 14, 14, 14, 3, 4, 4, 5, 5, 4, 4, 6, 7
3573 3, 4, 6, 5, 8, 11, 13, 7, 7, 3, 3, 5, 5, 7, 9, 11,
3574 13, 13, 13, 13, 13, 13, 13, 3, 4, 5, 5, 5, 4, 4, 7, 7
3576 3, 4, 5, 5, 7, 9, 13, 8, 8, 3, 3, 5, 5, 8, 10, 14,
3577 14, 13, 13, 13, 13, 13, 13, 3, 4, 5, 5, 5, 4, 4, 8, 8
3579 3, 4, 5, 4, 6, 9, 13, 9, 8, 2, 3, 6, 6, 9, 13, 14,
3580 14, 13, 13, 13, 13, 14, 14, 4, 5, 5, 6, 6, 4, 4, 8, 10
3582 3, 4, 5, 4, 6, 7, 11, 9, 9, 2, 2, 6, 6, 10, 13, 14,
3583 14, 13, 13, 13, 13, 13, 13, 5, 6, 6, 6, 6, 5, 5, 10, 11
3585 2, 4, 5, 4, 5, 7, 13, 13, 13, 2, 2, 9, 9, 12, 13, 14,
3586 14, 14, 14, 14, 14, 14, 14, 8, 9, 11, 8, 6, 6, 7, 13, 13
3590 const VP40_QMAT: &[i16; 64] = &[
3591 16, 17, 18, 20, 22, 24, 26, 28,
3592 17, 18, 20, 22, 24, 26, 28, 32,
3593 18, 20, 22, 24, 26, 28, 32, 36,
3594 20, 22, 24, 26, 28, 32, 36, 40,
3595 22, 24, 26, 28, 32, 36, 40, 44,
3596 24, 26, 28, 32, 36, 40, 44, 48,
3597 26, 28, 32, 36, 40, 44, 48, 52,
3598 28, 32, 36, 40, 44, 48, 52, 56
3600 const VP40_DC_Y_SCALES: [i16; 64] = [
3601 180, 180, 180, 180, 180, 180, 175, 170,
3602 165, 160, 157, 155, 152, 150, 147, 145,
3603 142, 140, 137, 135, 132, 130, 127, 125,
3604 122, 120, 117, 115, 112, 110, 107, 105,
3605 102, 100, 97, 95, 92, 90, 87, 85,
3606 82, 80, 77, 75, 72, 70, 67, 65,
3607 62, 60, 57, 55, 52, 50, 47, 45,
3608 42, 40, 37, 35, 32, 30, 27, 25
3610 const VP40_DC_C_SCALES: [i16; 64] = [
3611 150, 150, 150, 150, 150, 150, 150, 150,
3612 150, 150, 150, 150, 150, 150, 147, 145,
3613 142, 140, 137, 135, 132, 130, 127, 125,
3614 122, 120, 117, 115, 112, 110, 107, 105,
3615 102, 100, 97, 95, 92, 90, 87, 85,
3616 82, 80, 77, 75, 72, 70, 67, 65,
3617 62, 60, 57, 55, 52, 50, 47, 45,
3618 42, 40, 37, 35, 32, 30, 27, 25
3620 const VP40_AC_SCALES: [i16; 64] = [
3621 500, 475, 450, 430, 410, 390, 370, 350,
3622 330, 315, 300, 285, 270, 260, 250, 240,
3623 230, 220, 210, 200, 190, 185, 180, 170,
3624 160, 150, 143, 135, 128, 120, 113, 106,
3625 100, 94, 90, 85, 80, 75, 70, 66,
3626 62, 57, 52, 49, 45, 41, 38, 35,
3627 33, 30, 27, 24, 22, 20, 18, 16,
3628 14, 12, 10, 9, 7, 6, 4, 1
3631 const VP40_MBPAT_CODES: [[u8; 14]; 2] = [
3632 [ 0b000, 0b1111, 0b1001, 0b010, 0b1101, 0b01110, 0b1011, 0b001, 0b01111, 0b1000, 0b0110, 0b1110, 0b1100, 0b1010 ],
3633 [ 0b0111, 0b1010, 0b1001, 0b1100, 0b1000, 0b01101, 0b000, 0b1110, 0b01100, 0b1101, 0b001, 0b1011, 0b1111, 0b010 ]
3635 const VP40_MBPAT_BITS: [[u8; 14]; 2] = [
3636 [ 3, 4, 4, 3, 4, 5, 4, 3, 5, 4, 4, 4, 4, 4 ],
3637 [ 4, 4, 4, 4, 4, 5, 3, 4, 5, 4, 3, 4, 4, 3 ]
3639 const VP40_BP_PREDICTOR: [u8; 15] = [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1 ];
3640 const VP40_MV_X_CODES: [[u32; 63]; 7] = [
3642 0x06A, 0x11A, 0x18E, 0x237, 0x04A, 0x236, 0x07A, 0x0D6,
3643 0x07E, 0x1FD, 0x08C, 0x0D7, 0x087, 0x183, 0x03C, 0x061,
3644 0x047, 0x069, 0x040, 0x048, 0x049, 0x086, 0x013, 0x0D2,
3645 0x01C, 0x042, 0x025, 0x01B, 0x013, 0x005, 0x000, 0x007,
3646 0x005, 0x01B, 0x019, 0x019, 0x008, 0x045, 0x01D, 0x0C6,
3647 0x068, 0x090, 0x041, 0x04B, 0x031, 0x18F, 0x062, 0x03E,
3648 0x044, 0x068, 0x030, 0x182, 0x0C0, 0x1A7, 0x091, 0x092,
3649 0x07B, 0x0FF, 0x1A6, 0x1FC, 0x06A, 0x093, 0x06B
3651 0x039, 0x259, 0x01B, 0x1D1, 0x137, 0x1D0, 0x01A, 0x1B5,
3652 0x01D, 0x4BC, 0x06C, 0x038, 0x071, 0x02D, 0x07D, 0x075,
3653 0x019, 0x0E9, 0x037, 0x015, 0x01E, 0x0DB, 0x04C, 0x070,
3654 0x00D, 0x00C, 0x027, 0x004, 0x002, 0x000, 0x005, 0x007,
3655 0x006, 0x002, 0x008, 0x024, 0x00C, 0x03B, 0x01E, 0x09A,
3656 0x00E, 0x069, 0x04A, 0x12D, 0x035, 0x0F9, 0x018, 0x07F,
3657 0x00F, 0x0F8, 0x07E, 0x25F, 0x068, 0x02C, 0x014, 0x258,
3658 0x136, 0x4BD, 0x12E, 0x1B4, 0x017, 0x039, 0x01F
3660 0x029, 0x3CB, 0x1F5, 0x263, 0x1F4, 0x3DA, 0x050, 0x260,
3661 0x1EC, 0x3D3, 0x109, 0x3D2, 0x051, 0x792, 0x0F3, 0x09A,
3662 0x0F7, 0x132, 0x0C1, 0x1E8, 0x02A, 0x085, 0x061, 0x1F7,
3663 0x078, 0x0C7, 0x023, 0x07C, 0x012, 0x00B, 0x00E, 0x00D,
3664 0x000, 0x005, 0x003, 0x004, 0x019, 0x020, 0x03F, 0x043,
3665 0x062, 0x09F, 0x04E, 0x181, 0x02B, 0x137, 0x0F5, 0x089,
3666 0x0C6, 0x262, 0x088, 0x3C8, 0x1F6, 0x3CA, 0x09E, 0x261,
3667 0x136, 0x108, 0x133, 0x793, 0x180, 0x3DB, 0x045
3669 0x001, 0x1C7, 0x067, 0x0B5, 0x066, 0x139, 0x099, 0x0B4,
3670 0x0C3, 0x130, 0x000, 0x131, 0x09E, 0x0B7, 0x02C, 0x001,
3671 0x028, 0x138, 0x04B, 0x031, 0x060, 0x091, 0x003, 0x09D,
3672 0x017, 0x04D, 0x031, 0x070, 0x007, 0x03A, 0x007, 0x002,
3673 0x00B, 0x001, 0x00F, 0x008, 0x00D, 0x004, 0x00A, 0x00D,
3674 0x019, 0x002, 0x03B, 0x04A, 0x015, 0x0C2, 0x018, 0x032,
3675 0x072, 0x1C6, 0x029, 0x1C5, 0x049, 0x121, 0x01B, 0x030,
3676 0x01A, 0x1C4, 0x09F, 0x0B6, 0x019, 0x120, 0x073
3678 0x023, 0x1C8, 0x043, 0x110, 0x00C, 0x153, 0x022, 0x111,
3679 0x00F, 0x042, 0x023, 0x1C9, 0x02A, 0x01B, 0x073, 0x045,
3680 0x06E, 0x089, 0x06C, 0x01A, 0x06F, 0x0B6, 0x00B, 0x0E5,
3681 0x025, 0x020, 0x029, 0x04D, 0x002, 0x014, 0x01A, 0x017,
3682 0x01E, 0x027, 0x018, 0x028, 0x01F, 0x000, 0x006, 0x010,
3683 0x007, 0x00B, 0x003, 0x004, 0x01D, 0x02C, 0x019, 0x02B,
3684 0x009, 0x055, 0x038, 0x00E, 0x024, 0x0A8, 0x00A, 0x099,
3685 0x05A, 0x098, 0x06D, 0x152, 0x02B, 0x0B7, 0x001
3687 0x03D, 0x0B1, 0x0DD, 0x1F6, 0x0C5, 0x188, 0x037, 0x03F,
3688 0x01E, 0x189, 0x00F, 0x03E, 0x06A, 0x1F7, 0x061, 0x079,
3689 0x018, 0x0B0, 0x00E, 0x0B3, 0x00C, 0x0DF, 0x006, 0x0DC,
3690 0x019, 0x0DE, 0x027, 0x00E, 0x01A, 0x063, 0x00F, 0x00E,
3691 0x014, 0x07C, 0x036, 0x06B, 0x03F, 0x060, 0x008, 0x074,
3692 0x009, 0x078, 0x012, 0x00D, 0x015, 0x02D, 0x002, 0x01C,
3693 0x005, 0x03B, 0x000, 0x034, 0x019, 0x026, 0x010, 0x075,
3694 0x002, 0x036, 0x023, 0x0B2, 0x022, 0x0FA, 0x017
3696 0x015, 0x0DD, 0x03E, 0x16E, 0x04C, 0x012, 0x05D, 0x0B6,
3697 0x06F, 0x1F1, 0x069, 0x1F0, 0x01D, 0x16F, 0x002, 0x06B,
3698 0x00C, 0x0DC, 0x068, 0x09B, 0x07D, 0x09A, 0x00D, 0x013,
3699 0x008, 0x0F9, 0x02C, 0x012, 0x033, 0x04F, 0x00D, 0x005,
3700 0x012, 0x03F, 0x032, 0x013, 0x03B, 0x005, 0x02F, 0x05A,
3701 0x03F, 0x01C, 0x03A, 0x008, 0x036, 0x05C, 0x010, 0x000,
3702 0x00C, 0x04E, 0x003, 0x06A, 0x00E, 0x003, 0x014, 0x01E,
3703 0x01C, 0x00F, 0x018, 0x023, 0x01E, 0x022, 0x002
3706 const VP40_MV_X_BITS: [[u8; 63]; 7] = [
3708 7, 9, 9, 10, 8, 10, 8, 9, 8, 10, 8, 9, 8, 9, 7, 7,
3709 7, 8, 7, 8, 7, 8, 6, 8, 6, 7, 6, 6, 5, 4, 2, 3,
3710 3, 5, 5, 6, 5, 7, 6, 8, 7, 8, 7, 8, 7, 9, 7, 7,
3711 7, 8, 7, 9, 8, 9, 8, 9, 8, 9, 9, 10, 8, 9, 7
3713 7, 10, 8, 10, 9, 10, 8, 10, 8, 11, 8, 9, 8, 9, 8, 8,
3714 7, 9, 7, 8, 7, 9, 7, 8, 6, 7, 6, 6, 4, 4, 3, 3,
3715 3, 3, 4, 6, 5, 7, 6, 8, 6, 8, 7, 9, 7, 9, 7, 8,
3716 7, 9, 8, 10, 8, 9, 8, 10, 9, 11, 9, 10, 8, 9, 7
3718 7, 10, 9, 10, 9, 10, 8, 10, 9, 10, 9, 10, 8, 11, 8, 8,
3719 8, 9, 8, 9, 7, 8, 7, 9, 7, 8, 6, 7, 5, 5, 4, 4,
3720 2, 3, 3, 4, 5, 6, 6, 7, 7, 8, 7, 9, 7, 9, 8, 8,
3721 8, 10, 8, 10, 9, 10, 8, 10, 9, 9, 9, 11, 9, 10, 7
3723 6, 9, 8, 9, 8, 9, 8, 9, 8, 9, 7, 9, 8, 9, 7, 7,
3724 7, 9, 7, 8, 7, 8, 6, 8, 6, 7, 6, 7, 5, 6, 4, 4,
3725 4, 4, 4, 4, 4, 4, 4, 5, 5, 6, 6, 7, 6, 8, 6, 7,
3726 7, 9, 7, 9, 7, 9, 7, 8, 7, 9, 8, 9, 7, 9, 7
3728 6, 9, 8, 9, 7, 9, 7, 9, 7, 8, 7, 9, 7, 8, 7, 7,
3729 7, 8, 7, 8, 7, 8, 6, 8, 6, 7, 6, 7, 5, 6, 5, 5,
3730 5, 6, 5, 6, 5, 5, 4, 5, 4, 5, 4, 5, 5, 6, 5, 6,
3731 5, 7, 6, 7, 6, 8, 6, 8, 7, 8, 7, 9, 7, 8, 5
3733 6, 8, 8, 9, 8, 9, 7, 8, 7, 9, 7, 8, 7, 9, 7, 7,
3734 6, 8, 6, 8, 6, 8, 6, 8, 6, 8, 6, 7, 6, 7, 5, 5,
3735 5, 7, 6, 7, 6, 7, 5, 7, 5, 7, 5, 6, 5, 6, 4, 5,
3736 4, 6, 4, 6, 5, 6, 5, 7, 5, 7, 6, 8, 6, 8, 5
3738 5, 8, 7, 9, 7, 8, 7, 8, 7, 9, 7, 9, 7, 9, 6, 7,
3739 6, 8, 7, 8, 7, 8, 6, 8, 6, 8, 6, 7, 6, 7, 5, 5,
3740 5, 7, 6, 7, 6, 6, 6, 7, 6, 7, 6, 7, 6, 7, 5, 5,
3741 5, 7, 5, 7, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 3
3744 const VP40_MV_Y_CODES: [[u32; 63]; 7] = [
3746 0x052, 0x14C, 0x1FA, 0x124, 0x082, 0x29E, 0x08E, 0x24B,
3747 0x09C, 0x3F7, 0x086, 0x114, 0x083, 0x3A5, 0x0FA, 0x04F,
3748 0x0FB, 0x13B, 0x0FC, 0x172, 0x044, 0x173, 0x051, 0x087,
3749 0x05F, 0x0BA, 0x026, 0x05E, 0x016, 0x015, 0x006, 0x001,
3750 0x000, 0x01C, 0x01E, 0x075, 0x03B, 0x0FF, 0x025, 0x0BB,
3751 0x07C, 0x08B, 0x048, 0x171, 0x042, 0x14E, 0x046, 0x0FE,
3752 0x040, 0x13A, 0x093, 0x115, 0x08F, 0x3F6, 0x170, 0x29F,
3753 0x1D1, 0x24A, 0x1D3, 0x3A4, 0x1D0, 0x14D, 0x050
3755 0x0DE, 0x223, 0x136, 0x7C5, 0x12F, 0x4A1, 0x3D7, 0x7AC,
3756 0x133, 0x7C4, 0x1B8, 0x222, 0x096, 0x251, 0x095, 0x1F0,
3757 0x0DA, 0x110, 0x09A, 0x360, 0x0DD, 0x12E, 0x048, 0x092,
3758 0x078, 0x098, 0x027, 0x045, 0x01A, 0x010, 0x005, 0x000,
3759 0x001, 0x00E, 0x00C, 0x023, 0x03F, 0x0F4, 0x07D, 0x089,
3760 0x07B, 0x1BE, 0x0F9, 0x3E3, 0x0F3, 0x127, 0x0DB, 0x1EA,
3761 0x0D9, 0x6E7, 0x1BF, 0x4A0, 0x1B1, 0x6E6, 0x137, 0x7AD,
3762 0x126, 0x6C2, 0x132, 0x6C3, 0x129, 0x372, 0x0F2
3764 0x016, 0x09C, 0x13C, 0x09E, 0x12B, 0x0BA, 0x181, 0x317,
3765 0x084, 0x04E, 0x026, 0x316, 0x180, 0x05C, 0x0C1, 0x02F,
3766 0x010, 0x045, 0x012, 0x189, 0x024, 0x13D, 0x066, 0x023,
3767 0x067, 0x0C6, 0x024, 0x04B, 0x011, 0x032, 0x00D, 0x000,
3768 0x007, 0x005, 0x003, 0x003, 0x005, 0x020, 0x008, 0x025,
3769 0x026, 0x04F, 0x061, 0x02B, 0x04E, 0x18A, 0x043, 0x09F,
3770 0x014, 0x254, 0x094, 0x310, 0x085, 0x311, 0x02A, 0x0BB,
3771 0x18F, 0x255, 0x09D, 0x09F, 0x18E, 0x044, 0x026
3773 0x061, 0x12A, 0x00D, 0x3BD, 0x089, 0x109, 0x18E, 0x210,
3774 0x1D3, 0x211, 0x088, 0x019, 0x085, 0x018, 0x0E8, 0x0CE,
3775 0x040, 0x119, 0x045, 0x1D2, 0x04B, 0x1DD, 0x062, 0x094,
3776 0x075, 0x00C, 0x027, 0x00D, 0x002, 0x026, 0x006, 0x01E,
3777 0x00D, 0x01F, 0x001, 0x00A, 0x002, 0x007, 0x00B, 0x000,
3778 0x01C, 0x076, 0x032, 0x007, 0x024, 0x0C0, 0x007, 0x041,
3779 0x002, 0x18F, 0x047, 0x1DC, 0x043, 0x12B, 0x0CF, 0x118,
3780 0x0C6, 0x3BC, 0x08D, 0x3BF, 0x0C1, 0x3BE, 0x066
3782 0x007, 0x14D, 0x0A0, 0x09E, 0x0CF, 0x39C, 0x0A1, 0x39D,
3783 0x0AB, 0x1C5, 0x026, 0x14C, 0x025, 0x19C, 0x03F, 0x0E1,
3784 0x066, 0x1CF, 0x03E, 0x1C4, 0x072, 0x04E, 0x006, 0x0AA,
3785 0x01C, 0x0E6, 0x032, 0x051, 0x03B, 0x005, 0x01F, 0x018,
3786 0x002, 0x03A, 0x000, 0x036, 0x005, 0x008, 0x008, 0x016,
3787 0x009, 0x00D, 0x003, 0x02F, 0x01E, 0x02E, 0x01A, 0x02B,
3788 0x00C, 0x024, 0x01E, 0x0E0, 0x004, 0x0A7, 0x054, 0x1C7,
3789 0x052, 0x19D, 0x03A, 0x09F, 0x03B, 0x1C6, 0x037
3791 0x02A, 0x039, 0x025, 0x115, 0x024, 0x1FA, 0x02F, 0x114,
3792 0x075, 0x038, 0x0FC, 0x036, 0x01E, 0x1FB, 0x07F, 0x068,
3793 0x016, 0x037, 0x01F, 0x05C, 0x013, 0x08B, 0x001, 0x0FB,
3794 0x021, 0x044, 0x02B, 0x06B, 0x03B, 0x00C, 0x01C, 0x019,
3795 0x001, 0x020, 0x016, 0x07C, 0x00C, 0x074, 0x00A, 0x01C,
3796 0x012, 0x069, 0x00F, 0x06A, 0x014, 0x011, 0x01E, 0x017,
3797 0x002, 0x031, 0x01B, 0x030, 0x00D, 0x000, 0x001, 0x01D,
3798 0x023, 0x01A, 0x01D, 0x05D, 0x010, 0x0FA, 0x013
3800 0x012, 0x026, 0x041, 0x022, 0x01A, 0x0A9, 0x04C, 0x1B2,
3801 0x05C, 0x0A8, 0x058, 0x1B3, 0x040, 0x079, 0x00C, 0x055,
3802 0x01F, 0x0D8, 0x076, 0x023, 0x05F, 0x078, 0x00B, 0x01B,
3803 0x02D, 0x010, 0x037, 0x06D, 0x032, 0x00A, 0x01A, 0x01E,
3804 0x01F, 0x02B, 0x00D, 0x077, 0x031, 0x05D, 0x038, 0x027,
3805 0x00C, 0x0E9, 0x033, 0x05E, 0x030, 0x04D, 0x00A, 0x021,
3806 0x007, 0x03D, 0x039, 0x0E8, 0x00B, 0x059, 0x014, 0x027,
3807 0x011, 0x075, 0x00E, 0x009, 0x008, 0x012, 0x000
3810 const VP40_MV_Y_BITS: [[u8; 63]; 7] = [
3812 7, 9, 9, 9, 8, 10, 8, 10, 8, 10, 8, 9, 8, 10, 8, 7,
3813 8, 9, 8, 9, 7, 9, 7, 8, 7, 8, 6, 7, 5, 5, 3, 2,
3814 2, 5, 5, 7, 6, 8, 6, 8, 7, 8, 7, 9, 7, 9, 7, 8,
3815 7, 9, 8, 9, 8, 10, 9, 10, 9, 10, 9, 10, 9, 9, 7
3817 8, 10, 9, 11, 9, 11, 10, 11, 9, 11, 9, 10, 8, 10, 8, 9,
3818 8, 9, 8, 10, 8, 9, 7, 8, 7, 8, 6, 7, 5, 5, 3, 2,
3819 2, 4, 4, 6, 6, 8, 7, 8, 7, 9, 8, 10, 8, 9, 8, 9,
3820 8, 11, 9, 11, 9, 11, 9, 11, 9, 11, 9, 11, 9, 10, 8
3822 7, 9, 9, 10, 9, 10, 9, 10, 8, 9, 8, 10, 9, 9, 8, 8,
3823 7, 9, 7, 9, 7, 9, 7, 8, 7, 8, 6, 7, 5, 6, 4, 3,
3824 3, 3, 3, 4, 4, 6, 5, 7, 6, 8, 7, 8, 7, 9, 7, 8,
3825 7, 10, 8, 10, 8, 10, 8, 10, 9, 10, 9, 10, 9, 9, 7
3827 7, 9, 8, 10, 8, 9, 9, 10, 9, 10, 8, 9, 8, 9, 8, 8,
3828 7, 9, 7, 9, 7, 9, 7, 8, 7, 7, 6, 7, 5, 6, 4, 5,
3829 4, 5, 3, 4, 3, 4, 4, 5, 5, 7, 6, 7, 6, 8, 6, 7,
3830 6, 9, 7, 9, 7, 9, 8, 9, 8, 10, 8, 10, 8, 10, 7
3832 6, 9, 8, 9, 8, 10, 8, 10, 8, 9, 7, 9, 7, 9, 7, 8,
3833 7, 9, 7, 9, 7, 8, 6, 8, 6, 8, 6, 7, 6, 6, 5, 5,
3834 4, 6, 4, 6, 4, 5, 4, 5, 4, 5, 4, 6, 5, 6, 5, 6,
3835 5, 7, 6, 8, 6, 8, 7, 9, 7, 9, 7, 9, 7, 9, 6
3837 6, 8, 7, 9, 7, 9, 7, 9, 7, 8, 8, 8, 7, 9, 7, 7,
3838 6, 8, 7, 8, 6, 8, 6, 8, 6, 7, 6, 7, 6, 6, 5, 5,
3839 4, 6, 5, 7, 5, 7, 5, 6, 5, 7, 5, 7, 5, 6, 5, 5,
3840 4, 6, 5, 6, 5, 6, 5, 7, 6, 7, 6, 8, 6, 8, 5
3842 5, 7, 7, 8, 7, 8, 7, 9, 7, 8, 7, 9, 7, 8, 6, 7,
3843 6, 8, 7, 8, 7, 8, 6, 7, 6, 7, 6, 7, 6, 6, 5, 5,
3844 5, 6, 5, 7, 6, 7, 6, 7, 5, 8, 6, 7, 6, 7, 5, 6,
3845 5, 7, 6, 8, 5, 7, 5, 6, 5, 7, 5, 6, 5, 6, 3
3849 const VP40_LOOP_STRENGTH: [i16; 64] = [
3850 30, 25, 20, 20, 15, 15, 14, 14,
3851 13, 13, 12, 12, 11, 11, 10, 10,
3852 9, 9, 8, 8, 7, 7, 7, 7,
3853 6, 6, 6, 6, 5, 5, 5, 5,
3854 4, 4, 4, 4, 3, 3, 3, 3,
3855 2, 2, 2, 2, 2, 2, 2, 2,
3856 2, 2, 2, 2, 2, 2, 2, 2,
3857 1, 1, 1, 1, 1, 1, 1, 1
3859 const VP40_MV_LUT_INDEX: [usize; 32] = [
3860 0, 1, 2, 2, 3, 3, 3, 3,
3861 4, 4, 4, 4, 4, 4, 4, 4,
3862 5, 5, 5, 5, 5, 5, 5, 5,
3863 6, 6, 6, 6, 6, 6, 6, 6