projects / nihav.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
semi-working VP5/6 decoder
[nihav.git] / nihav-duck / src / codecs / vp3.rs
CommitLineData
5b24175d
KS		 1use std::mem;
2use std::ptr;
3use nihav_core::codecs::*;
4use nihav_core::codecs::blockdsp::*;
5use nihav_core::io::bitreader::*;
6use nihav_core::io::codebook::*;
7use nihav_core::io::intcode::*;
8use super::vpcommon::*;
9
10#[derive(Clone,Copy,Debug,PartialEq)]
11enum SBState {
12 Coded,
13 Partial,
14 Uncoded,
15}
16
6543b6f8
KS		 17fn map_idx(idx: usize) -> u8 {
18 idx as u8
19}
20
3567fcdb
KS		 21struct VP30Codes {
22 dc_cb: [Codebook<u8>; 5],
23 ac_i_cb: [Codebook<u8>; 5],
24 ac_p_cb: [Codebook<u8>; 5],
25 mbtype_cb: Codebook<VPMBType>,
26}
27
28fn map_mbt(idx: usize) -> VPMBType {
29 VP30_MBTYPE_SYMS[idx]
30}
31
32impl VP30Codes {
33 fn new() -> Self {
34 let mut dc_cb: [Codebook<u8>; 5];
35 let mut ac_i_cb: [Codebook<u8>; 5];
36 let mut ac_p_cb: [Codebook<u8>; 5];
37 let mut cr = TableCodebookDescReader::new(&VP30_MBTYPE_CODES, &VP30_MBTYPE_BITS, map_mbt);
38 let mbtype_cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
39 unsafe {
40 dc_cb = mem::uninitialized();
41 ac_i_cb = mem::uninitialized();
42 ac_p_cb = mem::uninitialized();
43 for i in 0..5 {
44 let mut cr = TableCodebookDescReader::new(&VP30_DC_CODES[i], &VP30_DC_BITS[i], map_idx);
45 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
46 ptr::write(&mut dc_cb[i], cb);
47 let mut cr = TableCodebookDescReader::new(&VP30_AC_INTRA_CODES[i], &VP30_AC_INTRA_BITS[i], map_idx);
48 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
49 ptr::write(&mut ac_i_cb[i], cb);
50 let mut cr = TableCodebookDescReader::new(&VP30_AC_INTER_CODES[i], &VP30_AC_INTER_BITS[i], map_idx);
51 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
52 ptr::write(&mut ac_p_cb[i], cb);
53 }
54 }
55 Self { dc_cb, ac_i_cb, ac_p_cb, mbtype_cb }
56 }
57}
58
6543b6f8 59struct VP31Codes {
5b24175d
KS		 60 dc_cb: [Codebook<u8>; 16],
61 ac0_cb: [Codebook<u8>; 16],
62 ac1_cb: [Codebook<u8>; 16],
63 ac2_cb: [Codebook<u8>; 16],
64 ac3_cb: [Codebook<u8>; 16],
65}
66
6543b6f8 67impl VP31Codes {
5b24175d
KS		 68 fn new() -> Self {
69 let mut dc_cb: [Codebook<u8>; 16];
70 let mut ac0_cb: [Codebook<u8>; 16];
71 let mut ac1_cb: [Codebook<u8>; 16];
72 let mut ac2_cb: [Codebook<u8>; 16];
73 let mut ac3_cb: [Codebook<u8>; 16];
74 unsafe {
75 dc_cb = mem::uninitialized();
76 ac0_cb = mem::uninitialized();
77 ac1_cb = mem::uninitialized();
78 ac2_cb = mem::uninitialized();
79 ac3_cb = mem::uninitialized();
80 for i in 0..16 {
6543b6f8 81 let mut cr = TableCodebookDescReader::new(&VP31_DC_CODES[i], &VP31_DC_BITS[i], map_idx);
5b24175d
KS		 82 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
83 ptr::write(&mut dc_cb[i], cb);
84
6543b6f8 85 let mut cr = TableCodebookDescReader::new(&VP31_AC_CAT0_CODES[i], &VP31_AC_CAT0_BITS[i], map_idx);
5b24175d
KS		 86 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
87 ptr::write(&mut ac0_cb[i], cb);
6543b6f8 88 let mut cr = TableCodebookDescReader::new(&VP31_AC_CAT1_CODES[i], &VP31_AC_CAT1_BITS[i], map_idx);
5b24175d
KS		 89 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
90 ptr::write(&mut ac1_cb[i], cb);
6543b6f8 91 let mut cr = TableCodebookDescReader::new(&VP31_AC_CAT2_CODES[i], &VP31_AC_CAT2_BITS[i], map_idx);
5b24175d
KS		 92 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
93 ptr::write(&mut ac2_cb[i], cb);
6543b6f8 94 let mut cr = TableCodebookDescReader::new(&VP31_AC_CAT3_CODES[i], &VP31_AC_CAT3_BITS[i], map_idx);
5b24175d
KS		 95 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
96 ptr::write(&mut ac3_cb[i], cb);
97 }
98 }
99 Self { dc_cb, ac0_cb, ac1_cb, ac2_cb, ac3_cb }
100 }
8e4b2f44
KS		 101 fn new_vp4() -> VP31Codes {
102 let mut dc_cb: [Codebook<u8>; 16];
103 let mut ac0_cb: [Codebook<u8>; 16];
104 let mut ac1_cb: [Codebook<u8>; 16];
105 let mut ac2_cb: [Codebook<u8>; 16];
106 let mut ac3_cb: [Codebook<u8>; 16];
107 unsafe {
108 dc_cb = mem::uninitialized();
109 ac0_cb = mem::uninitialized();
110 ac1_cb = mem::uninitialized();
111 ac2_cb = mem::uninitialized();
112 ac3_cb = mem::uninitialized();
113 for i in 0..16 {
114 let mut cr = TableCodebookDescReader::new(&VP40_DC_CODES[i], &VP40_DC_BITS[i], map_idx);
115 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
116 ptr::write(&mut dc_cb[i], cb);
117
118 let mut cr = TableCodebookDescReader::new(&VP40_AC_CAT0_CODES[i], &VP40_AC_CAT0_BITS[i], map_idx);
119 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
120 ptr::write(&mut ac0_cb[i], cb);
121 let mut cr = TableCodebookDescReader::new(&VP40_AC_CAT1_CODES[i], &VP40_AC_CAT1_BITS[i], map_idx);
122 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
123 ptr::write(&mut ac1_cb[i], cb);
124 let mut cr = TableCodebookDescReader::new(&VP40_AC_CAT2_CODES[i], &VP40_AC_CAT2_BITS[i], map_idx);
125 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
126 ptr::write(&mut ac2_cb[i], cb);
127 let mut cr = TableCodebookDescReader::new(&VP40_AC_CAT3_CODES[i], &VP40_AC_CAT3_BITS[i], map_idx);
128 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
129 ptr::write(&mut ac3_cb[i], cb);
130 }
131 }
132 VP31Codes { dc_cb, ac0_cb, ac1_cb, ac2_cb, ac3_cb }
133 }
134}
135
136struct VP40AuxCodes {
137 mv_x_cb: [Codebook<i8>; 7],
138 mv_y_cb: [Codebook<i8>; 7],
139 mbpat_cb: [Codebook<u8>; 2],
140}
141
142fn map_mv(idx: usize) -> i8 {
143 (idx as i8) - 31
144}
145
146impl VP40AuxCodes {
147 fn new() -> Self {
148 let mut mv_x_cb: [Codebook<i8>; 7];
149 let mut mv_y_cb: [Codebook<i8>; 7];
150 unsafe {
151 mv_x_cb = mem::uninitialized();
152 mv_y_cb = mem::uninitialized();
153 for i in 0..7 {
154 let mut cr = TableCodebookDescReader::new(&VP40_MV_X_CODES[i], &VP40_MV_X_BITS[i], map_mv);
155 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
156 ptr::write(&mut mv_x_cb[i], cb);
157 let mut cr = TableCodebookDescReader::new(&VP40_MV_Y_CODES[i], &VP40_MV_Y_BITS[i], map_mv);
158 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
159 ptr::write(&mut mv_y_cb[i], cb);
160 }
161 }
162 let mut cr0 = TableCodebookDescReader::new(&VP40_MBPAT_CODES[0], &VP40_MBPAT_BITS[0], map_idx);
163 let mut cr1 = TableCodebookDescReader::new(&VP40_MBPAT_CODES[1], &VP40_MBPAT_BITS[1], map_idx);
164 let mbpat_cb = [Codebook::new(&mut cr0, CodebookMode::MSB).unwrap(),
165 Codebook::new(&mut cr1, CodebookMode::MSB).unwrap()];
166 Self { mv_x_cb, mv_y_cb, mbpat_cb }
167 }
5b24175d
KS		 168}
169
347108c9
KS		 170enum Codes {
171 None,
3567fcdb 172 VP30(VP30Codes),
347108c9
KS		 173 VP31(VP31Codes),
174}
175
5b24175d
KS		 176#[derive(Clone)]
177struct Block {
178 btype: VPMBType,
179 coeffs: [i16; 64],
180 has_ac: bool,
181 idx: usize,
182 mv: MV,
183 coded: bool,
184}
185
186impl Block {
187 fn new() -> Self {
188 Self {
189 btype: VPMBType::Intra,
190 coeffs: [0; 64],
191 has_ac: false,
192 idx: 0,
193 mv: ZERO_MV,
194 coded: false,
195 }
196 }
197}
198
199type ReadRunFunc = fn (&mut BitReader) -> DecoderResult<usize>;
200
6543b6f8
KS		 201const VP31_LONG_RUN_BASE: [usize; 7] = [ 1, 2, 4, 6, 10, 18, 34 ];
202const VP31_LONG_RUN_BITS: [u8; 7] = [ 0, 1, 1, 2, 3, 4, 12 ];
5b24175d
KS		 203fn read_long_run(br: &mut BitReader) -> DecoderResult<usize> {
204 let pfx = br.read_code(UintCodeType::LimitedUnary(6, 0))? as usize;
205 if pfx == 0 { return Ok(1); }
6543b6f8 206 Ok(VP31_LONG_RUN_BASE[pfx] + (br.read(VP31_LONG_RUN_BITS[pfx])? as usize))
5b24175d
KS		 207}
208
6543b6f8
KS		 209const VP31_SHORT_RUN_BASE: [usize; 6] = [ 1, 3, 5, 7, 11, 15 ];
210const VP31_SHORT_RUN_BITS: [u8; 6] = [ 1, 1, 1, 2, 2, 4 ];
5b24175d
KS		 211fn read_short_run(br: &mut BitReader) -> DecoderResult<usize> {
212 let pfx = br.read_code(UintCodeType::LimitedUnary(5, 0))? as usize;
6543b6f8 213 Ok(VP31_SHORT_RUN_BASE[pfx] + (br.read(VP31_SHORT_RUN_BITS[pfx])? as usize))
5b24175d
KS		 214}
215
8e4b2f44
KS		 216fn read_mb_run(br: &mut BitReader) -> DecoderResult<usize> {
217 let pfx = br.read_code(UintCodeType::LimitedUnary(10, 0))? as usize;
218 if pfx == 10 { unimplemented!(); }
219 if pfx < 2 {
220 Ok(pfx + 1)
221 } else {
222 let base = (1 << (pfx - 1)) + 1;
223 let bits = (pfx - 1) as u8;
224 let add_bits = br.read(bits)? as usize;
225 Ok(base + add_bits)
226 }
227}
228
5b24175d
KS		 229struct BitRunDecoder {
230 value: bool,
231 run: usize,
232 read_run: ReadRunFunc,
233}
234
235impl BitRunDecoder {
236 fn new(br: &mut BitReader, read_run: ReadRunFunc) -> DecoderResult<Self> {
237 let value = !br.read_bool()?; // it will be flipped before run decoding
238 Ok(Self { value, run: 0, read_run })
239 }
240 fn get_val(&mut self, br: &mut BitReader) -> DecoderResult<bool> {
241 if self.run == 0 {
242 self.value = !self.value;
243 self.run = (self.read_run)(br)?;
244 }
245 self.run -= 1;
246 Ok(self.value)
247 }
248}
249
3567fcdb
KS		 250const VP30_NE0_BITS: [u8; 5] = [ 2, 2, 3, 4, 8 ];
251const VP30_NE0_BASE: [usize; 5] = [ 1, 5, 9, 17, 33 ];
252fn vp30_read_ne_run0(br: &mut BitReader) -> DecoderResult<usize> {
253 let len = br.read_code(UintCodeType::LimitedUnary(4, 0))? as usize;
254 Ok(VP30_NE0_BASE[len] + (br.read(VP30_NE0_BITS[len])? as usize))
255}
256fn vp30_read_ne_run1(br: &mut BitReader) -> DecoderResult<usize> {
257 let len = br.read_code(UintCodeType::LimitedUnary(6, 0))? as usize;
258 if len == 0 {
259 Ok((br.read(1)? as usize) + 1)
260 } else if len < 6 {
261 Ok(len + 2)
262 } else {
263 Ok((br.read(8)? as usize) + 8)
264 }
265}
266fn vp30_read_coded_run0(br: &mut BitReader) -> DecoderResult<usize> {
267 let len = br.read_code(UintCodeType::LimitedUnary(5, 0))? as usize;
268 Ok(len + 1)
269}
270/*
271 0 - 1
272 11 - 2
273 1000 - 3
274 1010 - 4
275 10011 - 5
276 10111 - 6
277 10010 - 7 + get_bits(3)
278 101100 - 15 + get_bits(5)
279 1011010 - 47 + get_bits(8)
280 1011011 - 303 + get_bits(16)
281 */
282const VP30_CRUN1_LUT: [u8; 32] = [
283 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
284 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
285 0x34, 0x34, 0x75, 0x55, 0x44, 0x44, 0x85, 0x65,
286 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22
287];
288fn vp30_read_coded_run1(br: &mut BitReader) -> DecoderResult<usize> {
289 let idx = br.peek(5) as usize;
290 let sym = (VP30_CRUN1_LUT[idx] >> 4) as usize;
291 let bits = VP30_CRUN1_LUT[idx] & 0xF;
292 br.skip(bits as u32)?;
293 if sym < 7 {
294 Ok(sym)
295 } else if sym == 7 {
296 Ok(7 + (br.read(3)? as usize))
297 } else {
298 let len = br.read_code(UintCodeType::Unary012)?;
299 match len {
300 0 => Ok(15 + (br.read(5)? as usize)),
301 1 => Ok(47 + (br.read(8)? as usize)),
302 _ => Ok(303 + (br.read(16)? as usize)),
303 }
304 }
305}
306
5b24175d
KS		 307struct VP34Decoder {
308 info: NACodecInfoRef,
309 width: usize,
310 height: usize,
311 mb_w: usize,
312 mb_h: usize,
313 version: u8,
314 is_intra: bool,
315 quant: usize,
316 shuf: VPShuffler,
347108c9 317 codes: Codes,
8e4b2f44 318 aux_codes: Option<VP40AuxCodes>,
5b24175d 319 loop_str: i16,
8e4b2f44 320 mc_buf: NAVideoBufferRef<u8>,
5b24175d
KS		 321
322 blocks: Vec<Block>,
3567fcdb 323 mb_coded: Vec<bool>,
8e4b2f44 324 mb_partial: Vec<bool>,
5b24175d
KS		 325 y_blocks: usize,
326 y_sbs: usize,
327 qmat_y: [i16; 64],
328 qmat_c: [i16; 64],
8e4b2f44
KS		 329 qmat_y_p: [i16; 64],
330 qmat_c_p: [i16; 64],
5b24175d
KS		 331
332 eob_run: usize,
333 last_dc: [i16; 3],
334
335 blk_addr: Vec<usize>,
8e4b2f44 336 blk_sub: Vec<u8>,
5b24175d
KS		 337 sb_info: Vec<SBState>,
338 sb_blocks: Vec<u8>,
3567fcdb
KS		 339 sb_mbs: Vec<u8>,
340 mb_blocks: Vec<u8>,
341}
342
343fn vp30_read_mv_comp(br: &mut BitReader) -> DecoderResult<i16> {
344 let mode = br.read(2)?;
345 if mode == 0 { return Ok(0); }
346 let sign = br.read_bool()?;
347 let val = match mode - 1 {
348 0 => 1,
349 1 => 2 + (br.read(2)? as i16),
350 _ => br.read(5)? as i16,
351 };
352 if !sign {
353 Ok(val)
354 } else {
355 Ok(-val)
356 }
357}
358
359fn vp30_read_mv(br: &mut BitReader) -> DecoderResult<MV> {
360 let x = vp30_read_mv_comp(br)?;
361 let y = vp30_read_mv_comp(br)?;
362 Ok(MV{ x, y })
5b24175d
KS		 363}
364
365fn read_mv_comp_packed(br: &mut BitReader) -> DecoderResult<i16> {
366 let code = br.read(3)?;
367 match code {
368 0 => Ok(0),
369 1 => Ok(1),
370 2 => Ok(-1),
371 3 => if br.read_bool()? { Ok(-2) } else { Ok(2) },
372 4 => if br.read_bool()? { Ok(-3) } else { Ok(3) },
373 5 => {
374 let val = (br.read(2)? as i16) + 4;
375 if br.read_bool()? {
376 Ok(-val)
377 } else {
378 Ok(val)
379 }
380 },
381 6 => {
382 let val = (br.read(3)? as i16) + 8;
383 if br.read_bool()? {
384 Ok(-val)
385 } else {
386 Ok(val)
387 }
388 },
389 _ => {
390 let val = (br.read(4)? as i16) + 16;
391 if br.read_bool()? {
392 Ok(-val)
393 } else {
394 Ok(val)
395 }
396 },
397 }
398}
399
400fn read_mv_packed(br: &mut BitReader) -> DecoderResult<MV> {
401 let x = read_mv_comp_packed(br)?;
402 let y = read_mv_comp_packed(br)?;
403 Ok(MV{ x, y })
404}
405
406fn read_mv_comp_raw(br: &mut BitReader) -> DecoderResult<i16> {
407 let val = br.read(5)? as i16;
408 if br.read_bool()? {
409 Ok(-val)
410 } else {
411 Ok(val)
412 }
413}
414
415fn read_mv_raw(br: &mut BitReader) -> DecoderResult<MV> {
416 let x = read_mv_comp_raw(br)?;
417 let y = read_mv_comp_raw(br)?;
418 Ok(MV{ x, y })
419}
420
6fbd24ec 421fn rescale_qmat(dst_qmat: &mut [i16; 64], base_qmat: &[i16; 64], dc_quant: i16, ac_quant: i16, minval: i16) {
5b24175d 422 for (dst, src) in dst_qmat.iter_mut().zip(base_qmat.iter()) {
6fbd24ec 423 *dst = (src.wrapping_mul(ac_quant) / 100).max(minval) << 2;
5b24175d 424 }
6fbd24ec 425 dst_qmat[0] = (base_qmat[0] * dc_quant / 100).max(minval * 2) << 2;
5b24175d
KS		 426}
427
6543b6f8
KS		 428fn expand_token(blk: &mut Block, br: &mut BitReader, eob_run: &mut usize, coef_no: usize, token: u8) -> DecoderResult<()> {
429 match token {
430 // EOBs
431 0 | 1 | 2 => { *eob_run = (token as usize) + 1; },
432 3 | 4 | 5 => {
433 let bits = token - 1;
434 *eob_run = (br.read(bits)? as usize) + (1 << bits);
435 },
436 6 => { *eob_run = br.read(12)? as usize; },
437 // zero runs
438 7 | 8 => {
439 let bits = if token == 7 { 3 } else { 6 };
440 let run = (br.read(bits)? as usize) + 1;
441 blk.idx += run;
442 validate!(blk.idx <= 64);
443 },
444 // single coefficients
445 9 | 10 | 11 | 12 => {
446 let val = (i16::from(token) - 7) >> 1;
447 if (token & 1) == 1 {
448 blk.coeffs[ZIGZAG[blk.idx]] = val;
449 } else {
450 blk.coeffs[ZIGZAG[blk.idx]] = -val;
451 }
452 blk.idx += 1;
453 },
454 13 | 14 | 15 | 16 => {
455 let val = i16::from(token) - 10;
456 if !br.read_bool()? {
457 blk.coeffs[ZIGZAG[blk.idx]] = val;
458 } else {
459 blk.coeffs[ZIGZAG[blk.idx]] = -val;
460 }
461 blk.idx += 1;
462 },
463 17 | 18 | 19 | 20 | 21 | 22 => {
464 let add_bits = if token == 22 { 9 } else { token - 16 };
465 let sign = br.read_bool()?;
466 let val = (br.read(add_bits)? as i16) + VP3_LITERAL_BASE[(token - 17) as usize];
467 if !sign {
468 blk.coeffs[ZIGZAG[blk.idx]] = val;
469 } else {
470 blk.coeffs[ZIGZAG[blk.idx]] = -val;
471 }
472 blk.idx += 1;
473 }
474 // zero run plus coefficient
475 23 | 24 | 25 | 26 | 27 => {
476 blk.idx += (token - 22) as usize;
477 validate!(blk.idx < 64);
478 if !br.read_bool()? {
479 blk.coeffs[ZIGZAG[blk.idx]] = 1;
480 } else {
481 blk.coeffs[ZIGZAG[blk.idx]] = -1;
482 }
483 blk.idx += 1;
484 },
485 28 | 29 => {
486 let run_bits = token - 26;
487 if token == 28 {
488 blk.idx += 6;
489 } else {
490 blk.idx += 10;
491 }
492 let sign = br.read_bool()?;
493 blk.idx += br.read(run_bits)? as usize;
494 validate!(blk.idx < 64);
495 if !sign {
496 blk.coeffs[ZIGZAG[blk.idx]] = 1;
497 } else {
498 blk.coeffs[ZIGZAG[blk.idx]] = -1;
499 }
500 blk.idx += 1;
501 },
502 30 => {
503 blk.idx += 1;
504 validate!(blk.idx < 64);
505 let sign = br.read_bool()?;
506 let val = (br.read(1)? as i16) + 2;
507 if !sign {
508 blk.coeffs[ZIGZAG[blk.idx]] = val;
509 } else {
510 blk.coeffs[ZIGZAG[blk.idx]] = -val;
511 }
512 blk.idx += 1;
513 },
514 _ => {
515 let sign = br.read_bool()?;
516 let val = (br.read(1)? as i16) + 2;
517 blk.idx += (br.read(1)? as usize) + 2;
518 validate!(blk.idx < 64);
519 if !sign {
520 blk.coeffs[ZIGZAG[blk.idx]] = val;
521 } else {
522 blk.coeffs[ZIGZAG[blk.idx]] = -val;
523 }
524 blk.idx += 1;
525 },
526 };
527 if *eob_run > 0 {
528 blk.idx = 64;
529 *eob_run -= 1;
530 } else if coef_no > 0 {
531 blk.has_ac = true;
532 }
533 Ok(())
534}
3567fcdb 535
5b24175d
KS		 536macro_rules! fill_dc_pred {
537 ($self: expr, $ref_id: expr, $pred: expr, $pp: expr, $bit: expr, $idx: expr) => {
538 if $self.blocks[$idx].coded && $self.blocks[$idx].btype.get_ref_id() == $ref_id {
539 $pred[$bit] = $self.blocks[$idx].coeffs[0] as i32;
540 $pp |= 1 << $bit;
541 }
542 };
543}
544
6543b6f8 545fn vp31_loop_filter_v(frm: &mut NASimpleVideoFrame<u8>, x: usize, y: usize, plane: usize, loop_str: i16) {
5b24175d 546 let off = frm.offset[plane] + x + y * frm.stride[plane];
8d8ddfe1 547 vp31_loop_filter(frm.data, off, 1, frm.stride[plane], 8, loop_str);
5b24175d
KS		 548}
549
6543b6f8 550fn vp31_loop_filter_h(frm: &mut NASimpleVideoFrame<u8>, x: usize, y: usize, plane: usize, loop_str: i16) {
5b24175d 551 let off = frm.offset[plane] + x + y * frm.stride[plane];
8d8ddfe1 552 vp31_loop_filter(frm.data, off, frm.stride[plane], 1, 8, loop_str);
5b24175d
KS		 553}
554
5b24175d
KS		 555impl VP34Decoder {
556 fn new(version: u8) -> Self {
8e4b2f44
KS		 557 let vt = alloc_video_buffer(NAVideoInfo::new(24, 24, false, YUV420_FORMAT), 4).unwrap();
558 let mc_buf = vt.get_vbuf().unwrap();
5b24175d
KS		 559 Self {
560 info: NACodecInfoRef::default(),
561 width: 0,
562 height: 0,
563 mb_w: 0,
564 mb_h: 0,
565 version,
566 is_intra: true,
567 quant: 0,
568 shuf: VPShuffler::new(),
347108c9 569 codes: Codes::None,
8e4b2f44 570 aux_codes: None,
5b24175d 571 loop_str: 0,
8e4b2f44 572 mc_buf,
5b24175d
KS		 573
574 blocks: Vec::new(),
3567fcdb 575 mb_coded: Vec::new(),
8e4b2f44 576 mb_partial: Vec::new(),
5b24175d
KS		 577 y_blocks: 0,
578 y_sbs: 0,
579
580 qmat_y: [0; 64],
581 qmat_c: [0; 64],
8e4b2f44
KS		 582 qmat_y_p: [0; 64],
583 qmat_c_p: [0; 64],
5b24175d
KS		 584
585 eob_run: 0,
586 last_dc: [0; 3],
587
588 blk_addr: Vec::new(),
8e4b2f44 589 blk_sub: Vec::new(),
5b24175d
KS		 590 sb_info: Vec::new(),
591 sb_blocks: Vec::new(),
3567fcdb
KS		 592 sb_mbs: Vec::new(),
593 mb_blocks: Vec::new(),
5b24175d
KS		 594 }
595 }
596 fn parse_header(&mut self, br: &mut BitReader) -> DecoderResult<()> {
597 self.is_intra = !br.read_bool()?;
598 br.skip(1)?;
599 self.quant = br.read(6)? as usize;
5b24175d
KS		 600 if self.is_intra {
601 if br.peek(8) != 0 {
3567fcdb
KS		 602 validate!(self.version == 3 || self.version == 30);
603 let mb_w = br.read(8)? as usize;
604 let mb_h = br.read(8)? as usize;
605println!(" VP30 {}x{} ({}x{})", mb_w, mb_h, self.mb_w, self.mb_h);
606 validate!(mb_w == self.mb_w && mb_h == self.mb_h);
607 if self.version == 3 {
608 self.version = 30;
609 self.codes = Codes::VP30(VP30Codes::new());
610 }
611 } else {
612 let version = br.read(13)?;
5b24175d 613println!("intra, ver {} (self {})", version, self.version);
3567fcdb
KS		 614 let coding_type = br.read(1)?;
615 validate!(coding_type == 0);
5b24175d 616 br.skip(2)?;
3567fcdb
KS		 617 if version == 1 {
618 validate!(self.version == 3 || self.version == 31);
619 if self.version == 3 {
620 self.version = 31;
621 self.codes = Codes::VP31(VP31Codes::new());
622 }
8e4b2f44 623 } else if version == 3 {
3567fcdb 624 validate!(self.version == 4);
8e4b2f44
KS		 625 let mb_h = br.read(8)? as usize;
626 let mb_w = br.read(8)? as usize;
627//println!(" VP40 {}x{} ({}x{})", mb_w, mb_h, self.mb_w, self.mb_h);
628 validate!(mb_w == self.mb_w && mb_h == self.mb_h);
629 let fact1 = br.read(5)?;
630 let fact2 = br.read(3)?;
631 validate!(fact1 == 1 && fact2 == 1);
632 let fact1 = br.read(5)?;
633 let fact2 = br.read(3)?;
634 validate!(fact1 == 1 && fact2 == 1);
635 br.skip(2)?;
3567fcdb
KS		 636 } else {
637 return Err(DecoderError::InvalidData);
638 }
639 }
640 }
8e4b2f44
KS		 641 self.loop_str = if self.version != 4 {
642 VP31_LOOP_STRENGTH[self.quant]
643 } else {
644 VP40_LOOP_STRENGTH[self.quant]
645 };
3567fcdb
KS		 646//println!("decode frame({},{},{})", self.is_intra as u8, self.is_intra as u8, self.quant);
647 Ok(())
648 }
649 fn vp30_unpack_sb_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
650 let mut has_nonempty = false;
651 {
652 let mut bit = !br.read_bool()?;
653 let mut run = 0;
654 for sb in self.sb_info.iter_mut() {
655 if run == 0 {
656 bit = !bit;
657 run = if bit { vp30_read_ne_run1(br)? } else { vp30_read_ne_run0(br)? };
658 }
659 *sb = if bit { has_nonempty = true; SBState::Partial } else { SBState::Uncoded };
660 run -= 1;
661 }
662 validate!(run == 0);
663 }
664 if has_nonempty {
665 for el in self.mb_coded.iter_mut() { *el = false; }
666 let mut bit = !br.read_bool()?;
667 let mut run = 0;
668 let mut mbiter = self.mb_coded.iter_mut();
669 for (sb, nmb) in self.sb_info.iter_mut().zip(self.sb_mbs.iter()) {
670 let nmbs = *nmb as usize;
671 if *sb == SBState::Partial {
672 for _ in 0..nmbs {
673 if run == 0 {
674 bit = !bit;
675 run = if bit { vp30_read_coded_run1(br)? } else { vp30_read_coded_run0(br)? };
676 }
677 run -= 1;
678 *mbiter.next().unwrap() = bit;
679 }
680 } else {
681 for _ in 0..nmbs {
682 mbiter.next().unwrap();
683 }
684 }
685 }
686 validate!(run == 0);
687 let mut bit = !br.read_bool()?;
688 let mut run = 0;
689 let mut cur_blk = 0;
690 for (coded, nblk) in self.mb_coded.iter().zip(self.mb_blocks.iter()) {
691 let nblks = *nblk as usize;
692 if *coded {
693 let mut cb = [false; 4];
694 for j in 0..nblks {
695 if run == 0 {
696 bit = !bit;
697 run = if bit { vp30_read_coded_run1(br)? } else { vp30_read_coded_run0(br)? };
698 }
699 run -= 1;
700 cb[j] = bit;
701 }
702 for j in 0..nblks {
703 let addr = self.blk_addr[cur_blk + j] >> 2;
704 self.blocks[addr].coded = cb[j];
705 }
706 }
707 cur_blk += nblks;
708 }
709 validate!(run == 0);
710 }
711 Ok(())
712 }
713 fn vp30_unpack_mb_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
714 let mut cur_blk = 0;
715 if let Codes::VP30(ref codes) = self.codes {
716 for (sb, nblk) in self.sb_info.iter_mut().zip(self.sb_blocks.iter()).take(self.y_sbs) {
717 let nblks = *nblk as usize;
718 if *sb == SBState::Uncoded {
719 for _ in 0..nblks {
720 self.blocks[self.blk_addr[cur_blk] >> 2].btype = VPMBType::InterNoMV;
721 cur_blk += 1;
722 }
723 } else {
724 for _ in 0..nblks/4 {
725 let mut coded = *sb == SBState::Coded;
726 if !coded {
727 for blk in 0..4 {
728 if self.blocks[self.blk_addr[cur_blk + blk] >> 2].coded {
729 coded = true;
730 break;
731 }
732 }
733 }
734 let mode = if !coded {
735 VPMBType::InterNoMV
736 } else {
737 br.read_cb(&codes.mbtype_cb)?
738 };
739 for _ in 0..4 {
740 self.blocks[self.blk_addr[cur_blk] >> 2].btype = mode;
741 cur_blk += 1;
742 }
743 }
744 }
745 }
746 } else {
747 return Err(DecoderError::Bug);
748 }
749 // replicate types for chroma
750 let mut off_y = 0;
751 let mut off_u = self.y_blocks;
752 let mut off_v = off_u + self.mb_w * self.mb_h;
753 for _blk_y in 0..self.mb_h {
754 for blk_x in 0..self.mb_w {
755 let btype = self.blocks[off_y + blk_x * 2].btype;
756 self.blocks[off_u + blk_x].btype = btype;
757 self.blocks[off_v + blk_x].btype = btype;
758 }
759 off_y += self.mb_w * 2 * 2;
760 off_u += self.mb_w;
761 off_v += self.mb_w;
762 }
763 Ok(())
764 }
765 fn vp30_unpack_mv_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
766 let mut last_mv = ZERO_MV;
767
768 let mut cur_blk = 0;
769 for _ in 0..self.y_blocks/4 {
770 let baddr = self.blk_addr[cur_blk] >> 2;
771 if self.blocks[baddr].btype == VPMBType::InterFourMV {
772 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);
773 for i in 0..4 {
774 let blk = &mut self.blocks[saddr + (i & 1) + (i & 2) * self.mb_w];
775 if blk.coded {
776 blk.mv = vp30_read_mv(br)?;
777 }
778 cur_blk += 1;
347108c9 779 }
347108c9 780 } else {
3567fcdb
KS		 781 let cur_mv;
782 match self.blocks[baddr].btype {
783 VPMBType::Intra | VPMBType::InterNoMV | VPMBType::GoldenNoMV => {
784 cur_mv = ZERO_MV;
785 },
786 VPMBType::InterMV => {
787 cur_mv = vp30_read_mv(br)?;
788 last_mv = cur_mv;
789 },
790 VPMBType::InterNearest => {
791 cur_mv = last_mv;
792 },
793 _ => { // GoldenMV
794 cur_mv = vp30_read_mv(br)?;
795 },
796 };
797 for _ in 0..4 {
798 self.blocks[self.blk_addr[cur_blk] >> 2].mv = cur_mv;
799 cur_blk += 1;
800 }
347108c9 801 }
5b24175d
KS		 802 }
803 Ok(())
804 }
3567fcdb
KS		 805 fn vp30_unpack_coeffs(&mut self, br: &mut BitReader, coef_no: usize, table: usize) -> DecoderResult<()> {
806 if let Codes::VP30(ref codes) = self.codes {
807 for blkaddr in self.blk_addr.iter() {
808 let blk: &mut Block = &mut self.blocks[blkaddr >> 2];
809 if !blk.coded || blk.idx != coef_no { continue; }
810 if self.eob_run > 0 {
811 blk.idx = 64;
812 self.eob_run -= 1;
813 continue;
814 }
815 let cb = if coef_no == 0 {
816 &codes.dc_cb[table]
817 } else if blk.btype.is_intra() {
818 &codes.ac_i_cb[table]
819 } else {
820 &codes.ac_p_cb[table]
821 };
822 let token = br.read_cb(cb)?;
823 expand_token(blk, br, &mut self.eob_run, coef_no, token)?;
824 }
825 Ok(())
826 } else {
827 Err(DecoderError::Bug)
828 }
829 }
6543b6f8 830 fn vp31_unpack_sb_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
5b24175d
KS		 831 let mut has_uncoded = false;
832 let mut has_partial = false;
833 {
834 let mut brun = BitRunDecoder::new(br, read_long_run)?;
835 for sb in self.sb_info.iter_mut() {
836 if brun.get_val(br)? {
837 *sb = SBState::Partial;
838 has_partial = true;
839 } else {
840 *sb = SBState::Uncoded;
841 has_uncoded = true;
842 }
843 }
844 }
845 if has_uncoded {
846 let mut brun = BitRunDecoder::new(br, read_long_run)?;
847 let mut cur_blk = 0;
848 for (sb, nblk) in self.sb_info.iter_mut().zip(self.sb_blocks.iter()) {
849 let nblks = *nblk as usize;
850 if *sb != SBState::Partial && brun.get_val(br)? {
851 *sb = SBState::Coded;
852 for _ in 0..nblks {
853 let blk_idx = self.blk_addr[cur_blk] >> 2;
854 self.blocks[blk_idx].coded = true;
855 cur_blk += 1;
856 }
857 } else {
858 for _ in 0..nblks {
859 let blk_idx = self.blk_addr[cur_blk] >> 2;
860 self.blocks[blk_idx].coded = false;
861 cur_blk += 1;
862 }
863 }
864 }
865 }
866 if has_partial {
867 let mut brun = BitRunDecoder::new(br, read_short_run)?;
868 let mut cur_blk = 0;
869 for (sb, nblk) in self.sb_info.iter_mut().zip(self.sb_blocks.iter()) {
870 let nblks = *nblk as usize;
871 if *sb == SBState::Partial {
872 for _ in 0..nblks {
873 let blk_idx = self.blk_addr[cur_blk] >> 2;
874 self.blocks[blk_idx].coded = brun.get_val(br)?;
875 cur_blk += 1;
876 }
877 } else {
878 cur_blk += nblks;
879 }
880 }
881 }
882 Ok(())
883 }
6543b6f8 884 fn vp31_unpack_mb_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
5b24175d
KS		 885 let mut modes = [VPMBType::InterNoMV; 8];
886 let alphabet = br.read(3)? as usize;
887 let raw_modes = alphabet >= 7;
888 if alphabet == 0 {
6543b6f8 889 for mode in VP31_DEFAULT_MB_MODES.iter() {
5b24175d
KS		 890 modes[br.read(3)? as usize] = *mode;
891 }
892 } else if alphabet < 7 {
6543b6f8 893 modes.copy_from_slice(&VP31_MB_MODES[alphabet - 1]);
5b24175d
KS		 894 }
895
896 let mut cur_blk = 0;
897 for (sb, nblk) in self.sb_info.iter_mut().zip(self.sb_blocks.iter()).take(self.y_sbs) {
898 let nblks = *nblk as usize;
899 if *sb == SBState::Uncoded {
900 for _ in 0..nblks {
901 self.blocks[self.blk_addr[cur_blk] >> 2].btype = VPMBType::InterNoMV;
902 cur_blk += 1;
903 }
904 } else {
905 for _ in 0..nblks/4 {
906 let mut coded = *sb == SBState::Coded;
907 if !coded {
908 for blk in 0..4 {
909 if self.blocks[self.blk_addr[cur_blk + blk] >> 2].coded {
910 coded = true;
911 break;
912 }
913 }
914 }
915 let mode = if !coded {
916 VPMBType::InterNoMV
917 } else if !raw_modes {
918 let code = br.read_code(UintCodeType::LimitedUnary(7, 0))?;
919 modes[code as usize]
920 } else {
6543b6f8 921 VP31_DEFAULT_MB_MODES[br.read(3)? as usize]
5b24175d
KS		 922 };
923 for _ in 0..4 {
924 self.blocks[self.blk_addr[cur_blk] >> 2].btype = mode;
925 cur_blk += 1;
926 }
927 }
928 }
929 }
930 // replicate types for chroma
931 let mut off_y = 0;
932 let mut off_u = self.y_blocks;
933 let mut off_v = off_u + self.mb_w * self.mb_h;
934 for _blk_y in 0..self.mb_h {
935 for blk_x in 0..self.mb_w {
936 let btype = self.blocks[off_y + blk_x * 2].btype;
937 self.blocks[off_u + blk_x].btype = btype;
938 self.blocks[off_v + blk_x].btype = btype;
939 }
940 off_y += self.mb_w * 2 * 2;
941 off_u += self.mb_w;
942 off_v += self.mb_w;
943 }
944 Ok(())
945 }
6543b6f8 946 fn vp31_unpack_mv_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
5b24175d
KS		 947 let mut last_mv = ZERO_MV;
948 let mut last2_mv = ZERO_MV;
949 let read_mv = if br.read_bool()? { read_mv_raw } else { read_mv_packed };
950
951 let mut cur_blk = 0;
952 for _ in 0..self.y_blocks/4 {
953 if self.blocks[self.blk_addr[cur_blk] >> 2].btype == VPMBType::InterFourMV {
954 for _ in 0..4 {
955 let blk = &mut self.blocks[self.blk_addr[cur_blk] >> 2];
956 if blk.coded {
957 blk.mv = (read_mv)(br)?;
958 last2_mv = last_mv;
959 last_mv = blk.mv;
960 }
961 cur_blk += 1;
962 }
963 } else {
964 let cur_mv;
965 match self.blocks[self.blk_addr[cur_blk] >> 2].btype {
966 VPMBType::Intra | VPMBType::InterNoMV | VPMBType::GoldenNoMV => {
967 cur_mv = ZERO_MV;
968 },
969 VPMBType::InterMV => {
970 cur_mv = (read_mv)(br)?;
971 last2_mv = last_mv;
972 last_mv = cur_mv;
973 },
974 VPMBType::InterNearest => {
975 cur_mv = last_mv;
976 },
977 VPMBType::InterNear => {
978 cur_mv = last2_mv;
979 std::mem::swap(&mut last_mv, &mut last2_mv);
980 },
981 _ => { // GoldenMV
982 cur_mv = (read_mv)(br)?;
983 },
984 };
985 for _ in 0..4 {
986 self.blocks[self.blk_addr[cur_blk] >> 2].mv = cur_mv;
987 cur_blk += 1;
988 }
989 }
990 }
991 Ok(())
992 }
6543b6f8 993 fn vp31_unpack_coeffs(&mut self, br: &mut BitReader, coef_no: usize, table_y: usize, table_c: usize) -> DecoderResult<()> {
347108c9
KS		 994 if let Codes::VP31(ref codes) = self.codes {
995 let cbs = if coef_no == 0 {
996 [&codes.dc_cb[table_y], &codes.dc_cb[table_c]]
997 } else if coef_no < 6 {
998 [&codes.ac0_cb[table_y], &codes.ac0_cb[table_c]]
999 } else if coef_no < 15 {
1000 [&codes.ac1_cb[table_y], &codes.ac1_cb[table_c]]
1001 } else if coef_no < 28 {
1002 [&codes.ac2_cb[table_y], &codes.ac2_cb[table_c]]
1003 } else {
1004 [&codes.ac3_cb[table_y], &codes.ac3_cb[table_c]]
1005 };
1006 for blkaddr in self.blk_addr.iter() {
1007 let blk: &mut Block = &mut self.blocks[blkaddr >> 2];
1008 if !blk.coded || blk.idx != coef_no { continue; }
1009 if self.eob_run > 0 {
1010 blk.idx = 64;
1011 self.eob_run -= 1;
1012 continue;
1013 }
1014 let cb = if (blkaddr & 3) == 0 { cbs[0] } else { cbs[1] };
1015 let token = br.read_cb(cb)?;
1016 expand_token(blk, br, &mut self.eob_run, coef_no, token)?;
5b24175d 1017 }
347108c9
KS		 1018 Ok(())
1019 } else {
1020 Err(DecoderError::Bug)
5b24175d 1021 }
5b24175d 1022 }
8e4b2f44
KS		 1023 fn vp40_unpack_sb_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
1024 let mut has_uncoded = false;
1025
1026 if let Some(ref aux_codes) = self.aux_codes {
1027 for el in self.sb_info.iter_mut() {
1028 *el = SBState::Partial;
1029 }
1030 {
1031 let mut mbiter = self.mb_coded.iter_mut();
1032 let mut brun = BitRunDecoder::new(br, read_mb_run)?;
1033 for nmb in self.sb_mbs.iter() {
1034 let nmbs = *nmb as usize;
1035 for _ in 0..nmbs {
1036 let coded = brun.get_val(br)?;
1037 *mbiter.next().unwrap() = coded;
1038 has_uncoded |= !coded;
1039 }
1040 }
1041 }
1042 if has_uncoded {
1043 let mut mbiter = self.mb_coded.iter().zip(self.mb_partial.iter_mut());
1044 let mut brun = BitRunDecoder::new(br, read_mb_run)?;
1045 for nmb in self.sb_mbs.iter() {
1046 let nmbs = *nmb as usize;
1047 for _ in 0..nmbs {
1048 let (coded, partial) = mbiter.next().unwrap();
1049 if *coded {
1050 *partial = false;
1051 } else {
1052 *partial = brun.get_val(br)?;
1053 }
1054 }
1055 }
1056
1057 let mut bpmode = 0;
1058 let mut cur_blk = 0;
1059 for ((coded, partial), nblk) in self.mb_coded.iter().zip(self.mb_partial.iter()).zip(self.mb_blocks.iter()) {
1060 let nblks = *nblk as usize;
1061 if *coded {
1062 for _ in 0..nblks {
1063 let addr = self.blk_addr[cur_blk] >> 2;
1064 self.blocks[addr].coded = true;
1065 cur_blk += 1;
1066 }
1067 } else if !*partial {
1068 for _ in 0..nblks {
1069 let addr = self.blk_addr[cur_blk] >> 2;
1070 self.blocks[addr].coded = false;
1071 cur_blk += 1;
1072 }
1073 } else {
1074 let mut pat = br.read_cb(&aux_codes.mbpat_cb[bpmode])? + 1;
1075 bpmode = VP40_BP_PREDICTOR[pat as usize] as usize;
1076
1077 let mut addrs = [0; 4];
1078 for i in 0..nblks {
1079 addrs[i] = self.blk_addr[cur_blk + i] >> 2;
1080 for j in (0..i).rev() {
1081 if addrs[j] > addrs[j + 1] {
1082 addrs.swap(j, j + 1);
1083 }
1084 }
1085 }
1086 for i in 0..nblks {
1087 self.blocks[addrs[i]].coded = (pat & 8) != 0;
1088 pat <<= 1;
1089 cur_blk += 1;
1090 }
1091 }
1092 }
1093 }
1094 Ok(())
1095 } else {
1096 Err(DecoderError::Bug)
1097 }
1098 }
1099 fn vp40_unpack_mv_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
1100 let mut last_mv = ZERO_MV;
1101 let mut last2_mv = ZERO_MV;
1102 let mut last_mv_g = ZERO_MV;
1103
1104 let mut cur_blk = 0;
1105 if let Some(ref codes) = self.aux_codes {
1106 for _ in 0..self.y_blocks/4 {
1107 if self.blocks[self.blk_addr[cur_blk] >> 2].btype == VPMBType::InterFourMV {
1108 let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv.x.abs() as usize]];
1109 let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv.y.abs() as usize]];
1110 let x_sign = last_mv.x < 0;
1111 let y_sign = last_mv.y < 0;
1112 last2_mv = last_mv;
1113 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);
1114 for i in 0..4 {
1115 let blk = &mut self.blocks[saddr + (i & 1) + (i >> 1) * self.mb_w];
1116 blk.mv.x = br.read_cb(x_cb)? as i16;
1117 if x_sign {
1118 blk.mv.x = -blk.mv.x;
1119 }
1120 blk.mv.y = br.read_cb(y_cb)? as i16;
1121 if y_sign {
1122 blk.mv.y = -blk.mv.y;
1123 }
1124 last_mv = blk.mv;
1125 cur_blk += 1;
1126 }
1127 } else {
1128 let cur_mv;
1129 match self.blocks[self.blk_addr[cur_blk] >> 2].btype {
1130 VPMBType::Intra | VPMBType::InterNoMV | VPMBType::GoldenNoMV => {
1131 cur_mv = ZERO_MV;
1132 },
1133 VPMBType::InterMV => {
1134 let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv.x.abs() as usize]];
1135 let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv.y.abs() as usize]];
1136 let x_sign = last_mv.x < 0;
1137 let y_sign = last_mv.y < 0;
1138 let x = br.read_cb(x_cb)? as i16;
1139 let y = br.read_cb(y_cb)? as i16;
1140 cur_mv = MV { x: if !x_sign { x } else { -x }, y: if !y_sign { y } else { -y } };
1141 last2_mv = last_mv;
1142 last_mv = cur_mv;
1143 },
1144 VPMBType::InterNearest => {
1145 cur_mv = last_mv;
1146 },
1147 VPMBType::InterNear => {
1148 cur_mv = last2_mv;
1149 std::mem::swap(&mut last_mv, &mut last2_mv);
1150 },
1151 _ => { // GoldenMV
1152 let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv_g.x.abs() as usize]];
1153 let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv_g.y.abs() as usize]];
1154 let x_sign = last_mv_g.x < 0;
1155 let y_sign = last_mv_g.y < 0;
1156 let x = br.read_cb(x_cb)? as i16;
1157 let y = br.read_cb(y_cb)? as i16;
1158 cur_mv = MV { x: if !x_sign { x } else { -x }, y: if !y_sign { y } else { -y } };
1159 last_mv_g = cur_mv;
1160 },
1161 };
1162 for _ in 0..4 {
1163 self.blocks[self.blk_addr[cur_blk] >> 2].mv = cur_mv;
1164 cur_blk += 1;
1165 }
1166 }
1167 }
1168 Ok(())
1169 } else {
1170 Err(DecoderError::Bug)
1171 }
1172 }
1173 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<()> {
1174 const VP40_PRED_MASKS: [usize; 16] = [ // top, bottom, left, right
1175 0b1010, 0b1010, 0b1000, 0b1011,
1176 0b1010, 0b1010, 0b0010, 0b1111,
1177 0b0010, 0b1010, 0b0010, 0b0110,
1178 0b0100, 0b0111, 0b1110, 0b1110
1179 ];
1180 self.last_dc = [0; 3];
1181 if let Codes::VP31(ref codes) = self.codes {
1182 let mut coef_eob: [usize; 64] = [0; 64];
1183 for (blkaddr, bsub) in self.blk_addr.iter().zip(self.blk_sub.iter()) {
1184 let blk: &mut Block = &mut self.blocks[blkaddr >> 2];
1185 if !blk.coded { continue; }
1186 let mut idx = blkaddr >> 2;
1187 let (bx, by) = if (blkaddr & 3) == 0 {
1188 (idx % (self.mb_w * 2), idx / (self.mb_w * 2))
1189 } else {
1190 idx -= self.mb_w * self.mb_h * 4;
1191 if idx >= self.mb_w * self.mb_h {
1192 idx -= self.mb_w * self.mb_h;
1193 }
1194 (idx % self.mb_w, idx / self.mb_w)
1195 };
1196 while blk.idx < 64 {
1197 if coef_eob[blk.idx] > 0 {
1198 coef_eob[blk.idx] -= 1;
1199 blk.idx = 64;
1200 continue;
1201 }
1202 let cbs = if blk.idx == 0 {
1203 [&codes.dc_cb[dc_table_y], &codes.dc_cb[dc_table_c]]
1204 } else if blk.idx < 6 {
1205 [&codes.ac0_cb[ac_table_y], &codes.ac0_cb[ac_table_c]]
1206 } else if blk.idx < 15 {
1207 [&codes.ac1_cb[ac_table_y], &codes.ac1_cb[ac_table_c]]
1208 } else if blk.idx < 28 {
1209 [&codes.ac2_cb[ac_table_y], &codes.ac2_cb[ac_table_c]]
1210 } else {
1211 [&codes.ac3_cb[ac_table_y], &codes.ac3_cb[ac_table_c]]
1212 };
1213 let cb = if (blkaddr & 3) == 0 { cbs[0] } else { cbs[1] };
1214 let token = br.read_cb(cb)?;
1215 expand_token(blk, br, &mut coef_eob[blk.idx], blk.idx, token)?;
1216 if blk.idx == 64 { break; }
1217 }
1218 let idx = blkaddr >> 2;
1219 let mask = VP40_PRED_MASKS[*bsub as usize];
1220 if (blkaddr & 3) == 0 {
1221 let pred_dc = self.vp40_predict_dc(bx, by, self.mb_w * 2, self.mb_h * 2, idx, mask, true);
1222 let blk: &mut Block = &mut self.blocks[blkaddr >> 2];
1223 blk.coeffs[0] += pred_dc;
1224 self.last_dc[blk.btype.get_ref_id() as usize] = blk.coeffs[0];
1225 } else {
1226 let pred_dc = self.vp40_predict_dc(bx, by, self.mb_w, self.mb_h, idx, mask, false);
1227 let blk: &mut Block = &mut self.blocks[blkaddr >> 2];
1228 blk.coeffs[0] += pred_dc;
1229 self.last_dc[blk.btype.get_ref_id() as usize] = blk.coeffs[0];
1230 }
1231 }
1232 Ok(())
1233 } else {
1234 Err(DecoderError::Bug)
1235 }
1236 }
3567fcdb
KS		 1237 fn decode_vp30(&mut self, br: &mut BitReader, frm: &mut NASimpleVideoFrame<u8>) -> DecoderResult<()> {
1238 for blk in self.blocks.iter_mut() {
1239 blk.coeffs = [0; 64];
1240 blk.idx = 0;
1241 blk.coded = false;
1242 blk.has_ac = false;
1243 }
1244 if self.is_intra {
1245 for sb in self.sb_info.iter_mut() { *sb = SBState::Coded; }
1246 for blk in self.blocks.iter_mut() {
1247 blk.btype = VPMBType::Intra;
1248 blk.coded = true;
1249 }
1250 } else {
1251 if self.shuf.get_last().is_none() || self.shuf.get_golden().is_none() {
1252 return Err(DecoderError::MissingReference);
1253 }
1254 self.vp30_unpack_sb_info(br)?;
1255 self.vp30_unpack_mb_info(br)?;
1256 self.vp30_unpack_mv_info(br)?;
1257 }
1258 let dc_quant = VP30_DC_SCALES[self.quant] * 10;
1259 let ac_quant = VP30_AC_SCALES[self.quant];
1260 rescale_qmat(&mut self.qmat_y, VP3_QMAT_Y, dc_quant, ac_quant, 2);
1261 rescale_qmat(&mut self.qmat_c, VP3_QMAT_C, dc_quant, ac_quant, 2);
8e4b2f44 1262 rescale_qmat(&mut self.qmat_y_p, VP3_QMAT_INTER, dc_quant, ac_quant, 4);
3567fcdb
KS		 1263 if self.quant == 10 {
1264 self.qmat_y[29] = 980;
1265 self.qmat_y[58] = 1636;
1266 self.qmat_y[59] = 1964;
1267 } else if self.quant == 31 {
1268 self.qmat_y[58] = 456;
1269 } else if self.quant == 44 {
1270 self.qmat_y[58] = 224;
1271 }
8e4b2f44 1272 self.qmat_c_p.copy_from_slice(&self.qmat_y_p);
3567fcdb
KS		 1273
1274 let table = if ac_quant <= 50 {
1275 0
1276 } else if ac_quant <= 150 {
1277 1
1278 } else if ac_quant <= 300 {
1279 2
1280 } else if ac_quant <= 600 {
1281 3
1282 } else {
1283 4
1284 };
1285
1286 self.eob_run = 0;
1287 self.vp30_unpack_coeffs(br, 0, table)?;
1288 let mut last_dc_i = 0;
1289 let mut last_dc_p = 0;
1290 for blkaddr in self.blk_addr.iter() {
1291 let blk: &mut Block = &mut self.blocks[blkaddr >> 2];
1292 if !blk.coded { continue; }
1293 if blk.btype.is_intra() {
1294 blk.coeffs[0] += last_dc_i;
1295 last_dc_i = blk.coeffs[0];
1296 } else {
1297 blk.coeffs[0] += last_dc_p;
1298 last_dc_p = blk.coeffs[0];
1299 }
1300 }
1301
1302 for coef_no in 1..64 {
1303 self.vp30_unpack_coeffs(br, coef_no, table)?;
1304 }
1305
1306 if self.is_intra {
1307 self.output_blocks_intra(frm);
1308 } else {
1309 self.output_blocks_inter(frm);
1310 }
1311
1312 Ok(())
1313 }
6543b6f8 1314 fn decode_vp31(&mut self, br: &mut BitReader, frm: &mut NASimpleVideoFrame<u8>) -> DecoderResult<()> {
5b24175d
KS		 1315 for blk in self.blocks.iter_mut() {
1316 blk.coeffs = [0; 64];
1317 blk.idx = 0;
1318 blk.coded = false;
1319 blk.has_ac = false;
1320 }
1321 if self.is_intra {
1322 for sb in self.sb_info.iter_mut() { *sb = SBState::Coded; }
1323 for blk in self.blocks.iter_mut() {
1324 blk.btype = VPMBType::Intra;
1325 blk.coded = true;
1326 }
1327 } else {
1328 if self.shuf.get_last().is_none() || self.shuf.get_golden().is_none() {
1329 return Err(DecoderError::MissingReference);
1330 }
6543b6f8
KS		 1331 self.vp31_unpack_sb_info(br)?;
1332 self.vp31_unpack_mb_info(br)?;
1333 self.vp31_unpack_mv_info(br)?;
5b24175d 1334 }
6543b6f8
KS		 1335 let dc_quant = VP31_DC_SCALES[self.quant];
1336 let ac_quant = VP31_AC_SCALES[self.quant];
6fbd24ec
KS		 1337 rescale_qmat(&mut self.qmat_y, VP3_QMAT_Y, dc_quant, ac_quant, 2);
1338 rescale_qmat(&mut self.qmat_c, VP3_QMAT_C, dc_quant, ac_quant, 2);
8e4b2f44
KS		 1339 rescale_qmat(&mut self.qmat_y_p, VP3_QMAT_INTER, dc_quant, ac_quant, 4);
1340 rescale_qmat(&mut self.qmat_c_p, VP3_QMAT_INTER, dc_quant, ac_quant, 4);
5b24175d
KS		 1341
1342 self.eob_run = 0;
1343 let dc_table_y = br.read(4)? as usize;
1344 let dc_table_c = br.read(4)? as usize;
6543b6f8 1345 self.vp31_unpack_coeffs(br, 0, dc_table_y, dc_table_c)?;
5b24175d
KS		 1346 self.restore_dcs();
1347
1348 let ac_table_y = br.read(4)? as usize;
1349 let ac_table_c = br.read(4)? as usize;
1350 for coef_no in 1..64 {
6543b6f8 1351 self.vp31_unpack_coeffs(br, coef_no, ac_table_y, ac_table_c)?;
5b24175d
KS		 1352 }
1353
1354 if self.is_intra {
1355 self.output_blocks_intra(frm);
1356 } else {
1357 self.output_blocks_inter(frm);
1358 }
1359 if self.loop_str > 0 {
6543b6f8 1360 self.vp31_loop_filter(frm);
5b24175d
KS		 1361 }
1362
1363 Ok(())
1364 }
8e4b2f44
KS		 1365 fn decode_vp4(&mut self, br: &mut BitReader, frm: &mut NASimpleVideoFrame<u8>) -> DecoderResult<()> {
1366 for blk in self.blocks.iter_mut() {
1367 blk.coeffs = [0; 64];
1368 blk.idx = 0;
1369 blk.coded = false;
1370 blk.has_ac = false;
1371 }
1372 if self.is_intra {
1373 for sb in self.sb_info.iter_mut() { *sb = SBState::Coded; }
1374 for blk in self.blocks.iter_mut() {
1375 blk.btype = VPMBType::Intra;
1376 blk.coded = true;
1377 }
1378 } else {
1379 if self.shuf.get_last().is_none() || self.shuf.get_golden().is_none() {
1380 return Err(DecoderError::MissingReference);
1381 }
1382 self.vp40_unpack_sb_info(br)?;
1383 self.vp31_unpack_mb_info(br)?;
1384 self.vp40_unpack_mv_info(br)?;
1385 }
1386 let dc_y_quant = VP40_DC_Y_SCALES[self.quant];
1387 let dc_c_quant = VP40_DC_C_SCALES[self.quant];
1388 let ac_quant = VP40_AC_SCALES[self.quant];
1389 rescale_qmat(&mut self.qmat_y, VP40_QMAT, dc_y_quant, ac_quant, 2);
1390 rescale_qmat(&mut self.qmat_c, VP40_QMAT, dc_c_quant, ac_quant, 2);
1391 self.qmat_y_p.copy_from_slice(&self.qmat_y);
1392 self.qmat_c_p.copy_from_slice(&self.qmat_c);
1393
1394 self.eob_run = 0;
1395 let dc_table_y = br.read(4)? as usize;
1396 let dc_table_c = br.read(4)? as usize;
1397 let ac_table_y = br.read(4)? as usize;
1398 let ac_table_c = br.read(4)? as usize;
1399 self.vp40_unpack_coeffs(br, dc_table_y, dc_table_c, ac_table_y, ac_table_c)?;
1400
1401 if self.is_intra {
1402 self.output_blocks_intra(frm);
1403 } else {
1404 self.output_blocks_inter(frm);
1405 }
1406
1407 Ok(())
5b24175d 1408 }
8e4b2f44 1409 fn vp31_predict_dc(&self, bx: usize, by: usize, bw: usize, blk_idx: usize) -> i16 {
5b24175d
KS		 1410 let mut preds = [0i32; 4];
1411 let mut pp: usize = 0;
1412 let ref_id = self.blocks[blk_idx].btype.get_ref_id();
1413 let is_right = bx == bw - 1;
1414 if bx > 0 {
1415 fill_dc_pred!(self, ref_id, preds, pp, 0, blk_idx - 1);
1416 if by > 0 {
1417 fill_dc_pred!(self, ref_id, preds, pp, 1, blk_idx - 1 - bw);
1418 }
1419 }
1420 if by > 0 {
1421 fill_dc_pred!(self, ref_id, preds, pp, 2, blk_idx - bw);
1422 if !is_right {
1423 fill_dc_pred!(self, ref_id, preds, pp, 3, blk_idx + 1 - bw);
1424 }
1425 }
1426 if pp == 0 { return self.last_dc[ref_id as usize]; }
1427 let mut pred = 0i32;
1428 for i in 0..4 {
1429 if (pp & (1 << i)) != 0 {
6543b6f8 1430 pred += (preds[i] as i32) * (VP31_DC_WEIGHTS[pp][i] as i32);
5b24175d
KS		 1431 }
1432 }
6543b6f8 1433 pred /= VP31_DC_WEIGHTS[pp][4] as i32;
5b24175d
KS		 1434 if (pp & 7) == 7 {
1435 if (pred - preds[2]).abs() > 128 { return preds[2] as i16; }
1436 if (pred - preds[0]).abs() > 128 { return preds[0] as i16; }
1437 if (pred - preds[1]).abs() > 128 { return preds[1] as i16; }
1438 }
1439 pred as i16
1440 }
8e4b2f44
KS		 1441 fn vp40_predict_dc(&self, bx: usize, by: usize, bw: usize, bh: usize, blk_idx: usize, mask: usize, is_luma: bool) -> i16 {
1442 let mut preds = [0i32; 4];
1443 let mut pp: usize = 0;
1444 let ref_id = self.blocks[blk_idx].btype.get_ref_id();
1445 if (by > 0) && (((mask >> 3) & 1) == 1) { //top
1446 fill_dc_pred!(self, ref_id, preds, pp, 0, blk_idx - bw);
1447 }
1448 if (by < bh - 1) && (((mask >> 2) & 1) == 1) { //bottom
1449 fill_dc_pred!(self, ref_id, preds, pp, 1, blk_idx + bw);
1450 }
1451 if (bx > 0) && (((mask >> 1) & 1) == 1) { //left
1452 fill_dc_pred!(self, ref_id, preds, pp, 2, blk_idx - 1);
1453 }
1454 if (is_luma && bx == 0 && (by >= 4)) && (((mask >> 1) & 1) == 1) { //left wrap
1455 fill_dc_pred!(self, ref_id, preds, pp, 2, blk_idx - 1 - 3 * bw);
1456 }
1457 if (bx < bw - 1) && (((mask >> 0) & 1) == 1) { //right
1458 fill_dc_pred!(self, ref_id, preds, pp, 3, blk_idx + 1);
1459 }
1460 if pp == 0 { return self.last_dc[ref_id as usize]; }
1461 let mut pred = 0i32;
1462 let mut npred = 0;
1463 for i in 0..4 {
1464 if (pp & (1 << i)) != 0 {
1465 pred += preds[i] as i32;
1466 npred += 1;
1467 if npred == 2 {
1468 return (pred / 2) as i16;
1469 }
1470 }
1471 }
1472 self.last_dc[ref_id as usize]
1473 }
5b24175d
KS		 1474 fn restore_dcs(&mut self) {
1475 let blk_stride = self.mb_w * 2;
1476 let mut blk_idx = 0;
1477 self.last_dc = [0; 3];
1478 for by in 0..self.mb_h*2 {
1479 for bx in 0..self.mb_w*2 {
1480 if !self.blocks[blk_idx + bx].coded { continue; }
8e4b2f44 1481 let dc = self.vp31_predict_dc(bx, by, self.mb_w*2, blk_idx + bx);
5b24175d
KS		 1482 self.blocks[blk_idx + bx].coeffs[0] += dc;
1483 self.last_dc[self.blocks[blk_idx + bx].btype.get_ref_id() as usize] = self.blocks[blk_idx + bx].coeffs[0];
1484 }
1485 blk_idx += blk_stride;
1486 }
1487 let blk_stride = self.mb_w;
1488 for _plane in 1..3 {
1489 self.last_dc = [0; 3];
1490 for by in 0..self.mb_h {
1491 for bx in 0..self.mb_w {
1492 if !self.blocks[blk_idx + bx].coded { continue; }
8e4b2f44 1493 let dc = self.vp31_predict_dc(bx, by, self.mb_w, blk_idx + bx);
5b24175d
KS		 1494 self.blocks[blk_idx + bx].coeffs[0] += dc;
1495 self.last_dc[self.blocks[blk_idx + bx].btype.get_ref_id() as usize] = self.blocks[blk_idx + bx].coeffs[0];
1496 }
1497 blk_idx += blk_stride;
1498 }
1499 }
1500 }
1501 fn output_blocks_intra(&mut self, frm: &mut NASimpleVideoFrame<u8>) {
1502 let mut biter = self.blocks.iter_mut();
1503 for by in 0..self.mb_h*2 {
1504 for bx in 0..self.mb_w*2 {
1505 let mut blk = biter.next().unwrap();
8e4b2f44 1506 let qmat = &self.qmat_y;
5b24175d
KS		 1507 blk.coeffs[0] *= qmat[0];
1508 if blk.has_ac {
1509 unquant(&mut blk.coeffs, qmat);
1510 vp_put_block(&mut blk.coeffs, bx, by, 0, frm);
1511 } else {
1512 vp_put_block_dc(&mut blk.coeffs, bx, by, 0, frm);
1513 }
1514 }
1515 }
1516 for plane in 1..3 {
1517 for by in 0..self.mb_h {
1518 for bx in 0..self.mb_w {
1519 let mut blk = biter.next().unwrap();
8e4b2f44 1520 let qmat = &self.qmat_c;
5b24175d
KS		 1521 blk.coeffs[0] *= qmat[0];
1522 if blk.has_ac {
1523 unquant(&mut blk.coeffs, qmat);
1524 vp_put_block(&mut blk.coeffs, bx, by, plane, frm);
1525 } else {
1526 vp_put_block_dc(&mut blk.coeffs, bx, by, plane, frm);
1527 }
1528 }
1529 }
1530 }
1531 }
1532 fn output_blocks_inter(&mut self, frm: &mut NASimpleVideoFrame<u8>) {
1533 let mut blk_idx = 0;
1534 let bstride = self.mb_w * 2;
1535 for by in (0..self.mb_h*2).step_by(2) {
1536 for bx in (0..self.mb_w*2).step_by(2) {
1537 if self.blocks[blk_idx + bx].btype != VPMBType::InterFourMV {
1538 continue;
1539 }
1540 let mv_a = self.blocks[blk_idx + bx].mv;
1541 let mv_b = self.blocks[blk_idx + bx + 1].mv;
1542 let mv_c = self.blocks[blk_idx + bx + bstride].mv;
1543 let mv_d = self.blocks[blk_idx + bx + 1 + bstride].mv;
1544 let mut mv_sum = mv_a + mv_b + mv_c + mv_d;
1545 mv_sum.x = (mv_sum.x + 2) >> 2;
1546 mv_sum.y = (mv_sum.y + 2) >> 2;
1547
1548 let src = self.shuf.get_last().unwrap();
1549 let mode = ((mv_a.x & 1) + (mv_a.y & 1) * 2) as usize;
8e4b2f44
KS		 1550 if self.version != 4 {
1551 copy_block(frm, src.clone(), 0, bx * 8, by * 8,
1552 mv_a.x >> 1, mv_a.y >> 1, 8, 8, 0, 1, mode, VP3_INTERP_FUNCS);
1553 } else {
1554 vp_copy_block(frm, src.clone(), 0, bx * 8, by * 8,
1555 mv_a.x >> 1, mv_a.y >> 1, 0, 1, self.loop_str,
1556 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1557 }
5b24175d 1558 let mode = ((mv_b.x & 1) + (mv_b.y & 1) * 2) as usize;
8e4b2f44
KS		 1559 if self.version != 4 {
1560 copy_block(frm, src.clone(), 0, bx * 8 + 8, by * 8,
1561 mv_b.x >> 1, mv_b.y >> 1, 8, 8, 0, 1, mode, VP3_INTERP_FUNCS);
1562 } else {
1563 vp_copy_block(frm, src.clone(), 0, bx * 8 + 8, by * 8,
1564 mv_b.x >> 1, mv_b.y >> 1, 0, 1, self.loop_str,
1565 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1566 }
5b24175d 1567 let mode = ((mv_c.x & 1) + (mv_c.y & 1) * 2) as usize;
8e4b2f44
KS		 1568 if self.version != 4 {
1569 copy_block(frm, src.clone(), 0, bx * 8, by * 8 + 8,
1570 mv_c.x >> 1, mv_c.y >> 1, 8, 8, 0, 1, mode, VP3_INTERP_FUNCS);
1571 } else {
1572 vp_copy_block(frm, src.clone(), 0, bx * 8, by * 8 + 8,
1573 mv_c.x >> 1, mv_c.y >> 1, 0, 1, self.loop_str,
1574 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1575 }
5b24175d 1576 let mode = ((mv_d.x & 1) + (mv_d.y & 1) * 2) as usize;
8e4b2f44
KS		 1577 if self.version != 4 {
1578 copy_block(frm, src.clone(), 0, bx * 8 + 8, by * 8 + 8,
1579 mv_d.x >> 1, mv_d.y >> 1, 8, 8, 0, 1, mode, VP3_INTERP_FUNCS);
1580 } else {
1581 vp_copy_block(frm, src.clone(), 0, bx * 8 + 8, by * 8 + 8,
1582 mv_d.x >> 1, mv_d.y >> 1, 0, 1, self.loop_str,
1583 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1584 }
5b24175d
KS		 1585
1586 let mx = (mv_sum.x >> 1) | (mv_sum.x & 1);
1587 let my = (mv_sum.y >> 1) | (mv_sum.y & 1);
1588 let mode = ((mx & 1) + (my & 1) * 2) as usize;
1589 copy_block(frm, src.clone(), 1, bx * 4, by * 4, mx >> 1, my >> 1, 8, 8, 0, 1, mode, VP3_INTERP_FUNCS);
1590 copy_block(frm, src.clone(), 2, bx * 4, by * 4, mx >> 1, my >> 1, 8, 8, 0, 1, mode, VP3_INTERP_FUNCS);
1591 }
96f8649d 1592 blk_idx += bstride * 2;
5b24175d
KS		 1593 }
1594
1595 let mut biter = self.blocks.iter_mut();
1596 for by in 0..self.mb_h*2 {
1597 for bx in 0..self.mb_w*2 {
1598 let mut blk = biter.next().unwrap();
1599 // do MC for whole macroblock
1600 if !blk.btype.is_intra() && (((bx | by) & 1) == 0) && (blk.btype != VPMBType::InterFourMV) {
1601 let src = if blk.btype.get_ref_id() == 1 {
1602 self.shuf.get_last().unwrap()
1603 } else {
1604 self.shuf.get_golden().unwrap()
1605 };
1606 let mode = ((blk.mv.x & 1) + (blk.mv.y & 1) * 2) as usize;
8e4b2f44
KS		 1607 if self.version != 4 {
1608 copy_block(frm, src.clone(), 0, bx * 8, by * 8,
1609 blk.mv.x >> 1, blk.mv.y >> 1, 16, 16, 0, 1, mode, VP3_INTERP_FUNCS);
1610 } else {
1611 vp_copy_block(frm, src.clone(), 0, bx * 8, by * 8,
1612 blk.mv.x >> 1, blk.mv.y >> 1, 0, 1, self.loop_str,
1613 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1614 vp_copy_block(frm, src.clone(), 0, bx * 8 + 8, by * 8,
1615 blk.mv.x >> 1, blk.mv.y >> 1, 0, 1, self.loop_str,
1616 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1617 vp_copy_block(frm, src.clone(), 0, bx * 8, by * 8 + 8,
1618 blk.mv.x >> 1, blk.mv.y >> 1, 0, 1, self.loop_str,
1619 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1620 vp_copy_block(frm, src.clone(), 0, bx * 8 + 8, by * 8 + 8,
1621 blk.mv.x >> 1, blk.mv.y >> 1, 0, 1, self.loop_str,
1622 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1623 }
5b24175d
KS		 1624 let mx = (blk.mv.x >> 1) | (blk.mv.x & 1);
1625 let my = (blk.mv.y >> 1) | (blk.mv.y & 1);
1626 let mode = ((mx & 1) + (my & 1) * 2) as usize;
8e4b2f44
KS		 1627 if self.version != 4 {
1628 copy_block(frm, src.clone(), 1, bx * 4, by * 4,
1629 mx >> 1, my >> 1, 8, 8, 0, 1, mode, VP3_INTERP_FUNCS);
1630 copy_block(frm, src.clone(), 2, bx * 4, by * 4,
1631 mx >> 1, my >> 1, 8, 8, 0, 1, mode, VP3_INTERP_FUNCS);
1632 } else {
1633 vp_copy_block(frm, src.clone(), 1, bx * 4, by * 4,
1634 mx >> 1, my >> 1, 0, 1, self.loop_str,
1635 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1636 vp_copy_block(frm, src.clone(), 2, bx * 4, by * 4,
1637 mx >> 1, my >> 1, 0, 1, self.loop_str,
1638 mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
1639 }
5b24175d 1640 }
8e4b2f44 1641 let qmat = if blk.btype.is_intra() { &self.qmat_y } else { &self.qmat_y_p };
5b24175d
KS		 1642 blk.coeffs[0] *= qmat[0];
1643 if blk.has_ac {
1644 unquant(&mut blk.coeffs, qmat);
1645 }
1646 if blk.btype.is_intra() {
1647 if !blk.coded {
1648 copy_block(frm, self.shuf.get_last().unwrap(), 0, bx * 8, by * 8, 0, 0, 8, 8, 0, 1, 0, VP3_INTERP_FUNCS);
1649 } else if blk.has_ac {
1650 vp_put_block(&mut blk.coeffs, bx, by, 0, frm);
1651 } else {
1652 vp_put_block_dc(&mut blk.coeffs, bx, by, 0, frm);
1653 }
1654 } else if blk.coded {
1655 if blk.has_ac {
1656 vp_add_block(&mut blk.coeffs, bx, by, 0, frm);
1657 } else {
1658 vp_add_block_dc(&mut blk.coeffs, bx, by, 0, frm);
1659 }
1660 }
1661 }
1662 }
1663 for plane in 1..3 {
1664 for by in 0..self.mb_h {
1665 for bx in 0..self.mb_w {
1666 let mut blk = biter.next().unwrap();
8e4b2f44 1667 let qmat = if blk.btype.is_intra() { &self.qmat_c } else { &self.qmat_c_p };
5b24175d
KS		 1668 blk.coeffs[0] *= qmat[0];
1669 if blk.has_ac {
1670 unquant(&mut blk.coeffs, qmat);
1671 }
1672 if blk.btype.is_intra() {
1673 if !blk.coded {
1674 copy_block(frm, self.shuf.get_last().unwrap(), plane, bx * 8, by * 8, 0, 0, 8, 8, 0, 1, 0, VP3_INTERP_FUNCS);
1675 } else if blk.has_ac {
1676 vp_put_block(&mut blk.coeffs, bx, by, plane, frm);
1677 } else {
1678 vp_put_block_dc(&mut blk.coeffs, bx, by, plane, frm);
1679 }
1680 } else if blk.coded {
1681 if blk.has_ac {
1682 vp_add_block(&mut blk.coeffs, bx, by, plane, frm);
1683 } else {
1684 vp_add_block_dc(&mut blk.coeffs, bx, by, plane, frm);
1685 }
1686 }
1687 }
1688 }
1689 }
1690 }
6543b6f8 1691 fn vp31_loop_filter(&mut self, frm: &mut NASimpleVideoFrame<u8>) {
5b24175d
KS		 1692 let mut blk_idx = 0;
1693 let blk_w = self.mb_w * 2;
1694 for by in 0..self.mb_h*2 {
1695 for bx in 0..blk_w {
1696 let blk = &self.blocks[blk_idx + bx];
1697 if (bx > 0) && blk.coded {
6543b6f8 1698 vp31_loop_filter_v(frm, bx * 8, by * 8, 0, self.loop_str);
5b24175d
KS		 1699 }
1700 if (by > 0) && blk.coded {
6543b6f8 1701 vp31_loop_filter_h(frm, bx * 8, by * 8, 0, self.loop_str);
5b24175d
KS		 1702 }
1703 if (bx < blk_w - 1) && !self.blocks[blk_idx + bx + 1].coded {
6543b6f8 1704 vp31_loop_filter_v(frm, bx * 8 + 8, by * 8, 0, self.loop_str);
5b24175d
KS		 1705 }
1706 if (by < self.mb_h * 2 - 1) && !self.blocks[blk_idx + bx + blk_w].coded {
6543b6f8 1707 vp31_loop_filter_h(frm, bx * 8, by * 8 + 8, 0, self.loop_str);
5b24175d
KS		 1708 }
1709 }
1710 blk_idx += blk_w;
1711 }
1712/* for plane in 1..3 {
1713 for by in 0..self.mb_h {
1714 for bx in 0..self.mb_w {
1715 }
1716 }
1717 }*/
1718 }
1719 fn generate_block_addr(&mut self) {
1720 let sb_w_y = (self.width + 31) >> 5;
1721 let sb_h_y = (self.height + 31) >> 5;
1722 let sb_w_c = ((self.width >> 1) + 31) >> 5;
1723 let sb_h_c = ((self.height >> 1) + 31) >> 5;
1724 self.y_sbs = sb_w_y * sb_h_y;
1725 let tot_sb = sb_w_y * sb_h_y + 2 * sb_w_c * sb_h_c;
3567fcdb 1726 let tot_mb = self.mb_w * self.mb_h * 2 + ((self.mb_w + 1) & !1) * ((self.mb_h + 1) & !1) * 2;
5b24175d
KS		 1727 let bw = self.width >> 3;
1728 let bh = self.height >> 3;
1729 let tot_blk = bw * bh * 3 / 2;
1730 self.sb_info.resize(tot_sb, SBState::Uncoded);
1731 self.sb_blocks = Vec::with_capacity(tot_sb);
3567fcdb
KS		 1732 self.mb_blocks = Vec::with_capacity(tot_mb);
1733 self.sb_mbs = Vec::with_capacity(tot_sb);
5b24175d 1734 self.blk_addr = Vec::with_capacity(tot_blk);
8e4b2f44 1735 self.blk_sub = Vec::with_capacity(tot_blk);
5b24175d
KS		 1736 self.y_blocks = bw * bh;
1737 let mut base_idx = 0;
1738 for plane in 0..3 {
1739 let w = if plane > 0 { self.width >> 1 } else { self.width };
1740 let h = if plane > 0 { self.height >> 1 } else { self.height };
1741 let sb_w = (w + 31) >> 5;
1742 let sb_h = (h + 31) >> 5;
1743 let blk_w = w >> 3;
1744 let blk_h = h >> 3;
1745 for y in 0..sb_h {
1746 for x in 0..sb_w {
3567fcdb
KS		 1747 let mut nmbs = 0;
1748 for mb_no in 0..4 {
1749 let bx = x * 4 + HILBERT_ORDER[mb_no * 4][0];
1750 let by = y * 4 + HILBERT_ORDER[mb_no * 4][1];
1751 if (bx >= blk_w) || (by >= blk_h) { continue; }
1752 let mut nblocks = 0;
1753 for blk_no in 0..4 {
1754 let bx = x * 4 + HILBERT_ORDER[mb_no * 4 + blk_no][0];
1755 let by = y * 4 + HILBERT_ORDER[mb_no * 4 + blk_no][1];
1756 if (bx >= blk_w) || (by >= blk_h) { continue; }
1757 nblocks += 1;
1758 }
1759 self.mb_blocks.push(nblocks);
1760 nmbs += 1;
1761 }
1762 self.sb_mbs.push(nmbs);
1763
5b24175d
KS		 1764 let mut nblocks = 0;
1765 for blk_no in 0..16 {
1766 let bx = x * 4 + HILBERT_ORDER[blk_no][0];
1767 let by = y * 4 + HILBERT_ORDER[blk_no][1];
1768 if (bx >= blk_w) || (by >= blk_h) { continue; }
1769 let idx = base_idx + bx + by * blk_w;
1770 self.blk_addr.push(idx * 4 + plane);
8e4b2f44 1771 self.blk_sub.push(blk_no as u8);
5b24175d
KS		 1772 nblocks += 1;
1773 }
1774 self.sb_blocks.push(nblocks);
1775 }
1776 }
1777 base_idx += blk_w * blk_h;
1778 }
1779 self.blocks.resize(tot_blk, Block::new());
3567fcdb 1780 self.mb_coded.resize(tot_mb, false);
8e4b2f44 1781 self.mb_partial.resize(tot_mb, false);
5b24175d
KS		 1782 }
1783}
1784
1785impl NADecoder for VP34Decoder {
1786 fn init(&mut self, supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
1787 if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
1788 let fmt = YUV420_FORMAT;
1789 self.width = vinfo.get_width();
1790 self.height = vinfo.get_height();
1791 validate!(((self.width | self.height) & 15) == 0);
1792 self.mb_w = self.width >> 4;
1793 self.mb_h = self.height >> 4;
1794 let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), true, fmt));
1795 self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
1796 supp.pool_u8.set_dec_bufs(3);
1797 supp.pool_u8.prealloc_video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), false, fmt), 4)?;
1798
8e4b2f44
KS		 1799 self.generate_block_addr();
1800 if self.version == 4 {
1801 self.codes = Codes::VP31(VP31Codes::new_vp4());
1802 self.aux_codes = Some(VP40AuxCodes::new());
5b24175d
KS		 1803 }
1804 Ok(())
1805 } else {
1806 Err(DecoderError::InvalidData)
1807 }
1808 }
1809 fn decode(&mut self, supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
1810 let src = pkt.get_buffer();
1811 validate!(src.len() > 0);
1812 let mut br = BitReader::new(&src, src.len(), BitReaderMode::BE);
1813
1814 self.parse_header(&mut br)?;
1815 if self.is_intra {
1816 self.shuf.clear();
1817 }
1818
1819 let ret = supp.pool_u8.get_free();
1820 if ret.is_none() {
1821 return Err(DecoderError::AllocError);
1822 }
1823 let mut buf = ret.unwrap();
1824 let mut dframe = NASimpleVideoFrame::from_video_buf(&mut buf).unwrap();
347108c9 1825 match self.version {
3567fcdb 1826 30 => self.decode_vp30(&mut br, &mut dframe)?,
347108c9 1827 31 => self.decode_vp31(&mut br, &mut dframe)?,
8e4b2f44 1828 4 => self.decode_vp4(&mut br, &mut dframe)?,
347108c9 1829 _ => return Err(DecoderError::Bug),
5b24175d
KS		 1830 }
1831
1832 if self.is_intra {
1833 self.shuf.add_golden_frame(buf.clone());
1834 }
1835 self.shuf.add_frame(buf.clone());
1836
1837 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), NABufferType::Video(buf));
1838 frm.set_keyframe(self.is_intra);
1839 frm.set_frame_type(if self.is_intra { FrameType::I } else { FrameType::P });
1840 Ok(frm.into_ref())
1841 }
1842}
1843
1844pub fn get_decoder_vp3() -> Box<NADecoder> {
1845 Box::new(VP34Decoder::new(3))
1846}
1847
8e4b2f44 1848pub fn get_decoder_vp4() -> Box<NADecoder> {
5b24175d 1849 Box::new(VP34Decoder::new(4))
8e4b2f44 1850}
5b24175d
KS		 1851
1852#[cfg(test)]
1853mod test {
1854 use nihav_core::codecs::RegisteredDecoders;
1855 use nihav_core::demuxers::RegisteredDemuxers;
1856 use nihav_core::test::dec_video::*;
1857 use crate::codecs::duck_register_all_codecs;
1858 use nihav_commonfmt::demuxers::generic_register_all_demuxers;
1859
1860 #[test]
3567fcdb
KS		 1861 fn test_vp30() {
1862 let mut dmx_reg = RegisteredDemuxers::new();
1863 generic_register_all_demuxers(&mut dmx_reg);
1864 let mut dec_reg = RegisteredDecoders::new();
1865 duck_register_all_codecs(&mut dec_reg);
1866
1867 let file = "assets/Duck/vp30-logo.avi";
8e4b2f44 1868 test_file_decoding("avi", file, Some(23), true, false, None/*Some("vp30")*/, &dmx_reg, &dec_reg);
3567fcdb
KS		 1869 }
1870
1871 #[test]
1872 fn test_vp31() {
5b24175d
KS		 1873 let mut dmx_reg = RegisteredDemuxers::new();
1874 generic_register_all_demuxers(&mut dmx_reg);
1875 let mut dec_reg = RegisteredDecoders::new();
1876 duck_register_all_codecs(&mut dec_reg);
1877
5b24175d
KS		 1878 let file = "assets/Duck/vp31.avi";
1879// let file = "assets/Duck/vp31_crash.avi";
1880// let file = "assets/Duck/01-vp31-0500.avi";
8e4b2f44 1881 test_file_decoding("avi", file, Some(3), true, false, None/*Some("vp31")*/, &dmx_reg, &dec_reg);
5b24175d
KS		 1882//panic!("end");
1883 }
1884
1885 #[test]
1886 fn test_vp4() {
1887 let mut dmx_reg = RegisteredDemuxers::new();
1888 generic_register_all_demuxers(&mut dmx_reg);
1889 let mut dec_reg = RegisteredDecoders::new();
1890 duck_register_all_codecs(&mut dec_reg);
1891
1892 let file = "assets/Duck/ot171_vp40.avi";
8e4b2f44
KS		 1893 test_file_decoding("avi", file, Some(16), true, false, None/*Some("vp4")*/, &dmx_reg, &dec_reg);
1894//panic!("end");
5b24175d
KS		 1895 }
1896}
1897
1898const HILBERT_ORDER: [[usize; 2]; 16] = [
1899 [ 0, 0 ], [ 1, 0 ], [ 1, 1 ], [ 0, 1 ],
1900 [ 0, 2 ], [ 0, 3 ], [ 1, 3 ], [ 1, 2 ],
1901 [ 2, 2 ], [ 2, 3 ], [ 3, 3 ], [ 3, 2 ],
1902 [ 3, 1 ], [ 2, 1 ], [ 2, 0 ], [ 3, 0 ]
1903];
1904
6543b6f8 1905const VP31_LOOP_STRENGTH: [i16; 64] = [
5b24175d
KS		 1906 30, 25, 20, 20, 15, 15, 14, 14,
1907 13, 13, 12, 12, 11, 11, 10, 10,
1908 9, 9, 8, 8, 7, 7, 7, 7,
1909 6, 6, 6, 6, 5, 5, 5, 5,
1910 4, 4, 4, 4, 3, 3, 3, 3,
1911 2, 2, 2, 2, 2, 2, 2, 2,
1912 0, 0, 0, 0, 0, 0, 0, 0,
1913 0, 0, 0, 0, 0, 0, 0, 0
1914];
1915
6543b6f8 1916const VP31_DEFAULT_MB_MODES: [VPMBType; 8] = [
5b24175d
KS		 1917 VPMBType::InterNoMV, VPMBType::Intra, VPMBType::InterMV, VPMBType::InterNearest,
1918 VPMBType::InterNear, VPMBType::GoldenNoMV, VPMBType::GoldenMV, VPMBType::InterFourMV
1919];
1920
6543b6f8 1921const VP31_MB_MODES: [[VPMBType; 8]; 6] = [
5b24175d
KS		 1922 [
1923 VPMBType::InterNearest, VPMBType::InterNear, VPMBType::InterMV, VPMBType::InterNoMV,
1924 VPMBType::Intra, VPMBType::GoldenNoMV, VPMBType::GoldenMV, VPMBType::InterFourMV
1925 ], [
1926 VPMBType::InterNearest, VPMBType::InterNear, VPMBType::InterNoMV, VPMBType::InterMV,
1927 VPMBType::Intra, VPMBType::GoldenNoMV, VPMBType::GoldenMV, VPMBType::InterFourMV
1928 ], [
1929 VPMBType::InterNearest, VPMBType::InterMV, VPMBType::InterNear, VPMBType::InterNoMV,
1930 VPMBType::Intra, VPMBType::GoldenNoMV, VPMBType::GoldenMV, VPMBType::InterFourMV
1931 ], [
1932 VPMBType::InterNearest, VPMBType::InterMV, VPMBType::InterNoMV, VPMBType::InterNear,
1933 VPMBType::Intra, VPMBType::GoldenNoMV, VPMBType::GoldenMV, VPMBType::InterFourMV
1934 ], [
1935 VPMBType::InterNoMV, VPMBType::InterNearest, VPMBType::InterNear, VPMBType::InterMV,
1936 VPMBType::Intra, VPMBType::GoldenNoMV, VPMBType::GoldenMV, VPMBType::InterFourMV
1937 ], [
1938 VPMBType::InterNoMV, VPMBType::GoldenNoMV, VPMBType::InterNearest, VPMBType::InterNear,
1939 VPMBType::InterMV, VPMBType::Intra, VPMBType::GoldenMV, VPMBType::InterFourMV
1940 ]
1941];
1942
1943const VP3_LITERAL_BASE: [i16; 6] = [ 7, 9, 13, 21, 37, 69 ];
1944
6543b6f8 1945const VP31_AC_SCALES: [i16; 64] = [
5b24175d
KS		 1946 500, 450, 400, 370, 340, 310, 285, 265,
1947 245, 225, 210, 195, 185, 180, 170, 160,
1948 150, 145, 135, 130, 125, 115, 110, 107,
1949 100, 96, 93, 89, 85, 82, 75, 74,
1950 70, 68, 64, 60, 57, 56, 52, 50,
1951 49, 45, 44, 43, 40, 38, 37, 35,
1952 33, 32, 30, 29, 28, 25, 24, 22,
1953 21, 19, 18, 17, 15, 13, 12, 10
1954];
1955
6543b6f8 1956const VP31_DC_SCALES: [i16; 64] = [
5b24175d
KS		 1957 220, 200, 190, 180, 170, 170, 160, 160,
1958 150, 150, 140, 140, 130, 130, 120, 120,
1959 110, 110, 100, 100, 90, 90, 90, 80,
1960 80, 80, 70, 70, 70, 60, 60, 60,
1961 60, 50, 50, 50, 50, 40, 40, 40,
1962 40, 40, 30, 30, 30, 30, 30, 30,
1963 30, 20, 20, 20, 20, 20, 20, 20,
1964 20, 10, 10, 10, 10, 10, 10, 10
1965];
1966
1967const VP3_QMAT_Y: &[i16; 64] = &[
1968 16, 11, 10, 16, 24, 40, 51, 61,
1969 12, 12, 14, 19, 26, 58, 60, 55,
1970 14, 13, 16, 24, 40, 57, 69, 56,
1971 14, 17, 22, 29, 51, 87, 80, 62,
1972 18, 22, 37, 58, 68, 109, 103, 77,
1973 24, 35, 55, 64, 81, 104, 113, 92,
1974 49, 64, 78, 87, 103, 121, 120, 101,
1975 72, 92, 95, 98, 112, 100, 103, 99
1976];
1977
1978const VP3_QMAT_C: &[i16; 64] = &[
1979 17, 18, 24, 47, 99, 99, 99, 99,
1980 18, 21, 26, 66, 99, 99, 99, 99,
1981 24, 26, 56, 99, 99, 99, 99, 99,
1982 47, 66, 99, 99, 99, 99, 99, 99,
1983 99, 99, 99, 99, 99, 99, 99, 99,
1984 99, 99, 99, 99, 99, 99, 99, 99,
1985 99, 99, 99, 99, 99, 99, 99, 99,
1986 99, 99, 99, 99, 99, 99, 99, 99
1987];
1988
1989const VP3_QMAT_INTER: &[i16; 64] = &[
1990 16, 16, 16, 20, 24, 28, 32, 40,
1991 16, 16, 20, 24, 28, 32, 40, 48,
1992 16, 20, 24, 28, 32, 40, 48, 64,
1993 20, 24, 28, 32, 40, 48, 64, 64,
1994 24, 28, 32, 40, 48, 64, 64, 64,
1995 28, 32, 40, 48, 64, 64, 64, 96,
1996 32, 40, 48, 64, 64, 64, 96, 128,
1997 40, 48, 64, 64, 64, 96, 128, 128
1998];
1999
6543b6f8 2000const VP31_DC_CODES: [[u16; 32]; 16] = [
5b24175d
KS		 2001 [
2002 0x002D, 0x0026, 0x0166, 0x004E, 0x02CE, 0x059E, 0x027D, 0x0008,
2003 0x04F9, 0x000F, 0x000E, 0x001B, 0x0006, 0x0008, 0x0005, 0x001A,
2004 0x0015, 0x0007, 0x000C, 0x0001, 0x0000, 0x0009, 0x0017, 0x0029,
2005 0x0028, 0x00B2, 0x04F8, 0x059F, 0x009E, 0x013F, 0x0012, 0x0058,
2006 ], [
2007 0x0010, 0x0047, 0x01FF, 0x008C, 0x03FC, 0x046A, 0x0469, 0x0022,
2008 0x11A1, 0x000E, 0x000D, 0x0004, 0x0005, 0x0009, 0x0006, 0x001E,
2009 0x0016, 0x0007, 0x000C, 0x0001, 0x0000, 0x000A, 0x0017, 0x007D,
2010 0x007E, 0x011B, 0x08D1, 0x03FD, 0x046B, 0x11A0, 0x007C, 0x00FE,
2011 ], [
2012 0x0016, 0x0020, 0x0086, 0x0087, 0x0367, 0x06CC, 0x06CB, 0x006E,
2013 0x366D, 0x000F, 0x000E, 0x0004, 0x0005, 0x000A, 0x0006, 0x001A,
2014 0x0011, 0x0007, 0x000C, 0x0001, 0x0000, 0x0009, 0x0017, 0x006F,
2015 0x006D, 0x0364, 0x0D9A, 0x06CA, 0x1B37, 0x366C, 0x0042, 0x00D8,
2016 ], [
2017 0x0000, 0x002D, 0x00F7, 0x0058, 0x0167, 0x02CB, 0x02CA, 0x000E,
2018 0x1661, 0x0003, 0x0002, 0x0008, 0x0009, 0x000D, 0x0002, 0x001F,
2019 0x0017, 0x0001, 0x000C, 0x000E, 0x000A, 0x0006, 0x0078, 0x000F,
2020 0x007A, 0x0164, 0x0599, 0x02CD, 0x0B31, 0x1660, 0x0079, 0x00F6,
2021 ], [
2022 0x0003, 0x003C, 0x000F, 0x007A, 0x001D, 0x0020, 0x0072, 0x0006,
2023 0x0399, 0x0004, 0x0005, 0x0005, 0x0006, 0x000E, 0x0004, 0x0000,
2024 0x0019, 0x0002, 0x000D, 0x0007, 0x001F, 0x0030, 0x0011, 0x0031,
2025 0x0005, 0x0021, 0x00E7, 0x0038, 0x01CD, 0x0398, 0x007B, 0x0009,
2026 ], [
2027 0x0009, 0x0002, 0x0074, 0x0007, 0x00EC, 0x00D1, 0x01A6, 0x0006,
2028 0x0D21, 0x0005, 0x0006, 0x0008, 0x0007, 0x000F, 0x0004, 0x0000,
2029 0x001C, 0x0002, 0x0005, 0x0003, 0x000C, 0x0035, 0x01A7, 0x001B,
2030 0x0077, 0x01A5, 0x0349, 0x00D0, 0x0691, 0x0D20, 0x0075, 0x00ED,
2031 ], [
2032 0x000A, 0x000C, 0x0012, 0x001B, 0x00B7, 0x016C, 0x0099, 0x005A,
2033 0x16D8, 0x0007, 0x0006, 0x0009, 0x0008, 0x0000, 0x0005, 0x0017,
2034 0x000E, 0x0002, 0x0003, 0x000F, 0x001A, 0x004D, 0x2DB3, 0x002C,
2035 0x0011, 0x02DA, 0x05B7, 0x0098, 0x0B6D, 0x2DB2, 0x0010, 0x0027,
2036 ], [
2037 0x000D, 0x000F, 0x001D, 0x0008, 0x0051, 0x0056, 0x00AF, 0x002A,
2038 0x148A, 0x0007, 0x0000, 0x0008, 0x0009, 0x000C, 0x0006, 0x0017,
2039 0x000B, 0x0016, 0x0015, 0x0009, 0x0050, 0x00AE, 0x2917, 0x001C,
2040 0x0014, 0x0290, 0x0523, 0x0149, 0x0A44, 0x2916, 0x0053, 0x00A5,
2041 ], [
2042 0x0001, 0x001D, 0x00F5, 0x00F4, 0x024D, 0x0499, 0x0498, 0x0001,
2043 0x0021, 0x0006, 0x0005, 0x0006, 0x0005, 0x0002, 0x0007, 0x0025,
2044 0x007B, 0x001C, 0x0020, 0x000D, 0x0048, 0x0092, 0x0127, 0x000E,
2045 0x0004, 0x0011, 0x000C, 0x003C, 0x000F, 0x0000, 0x001F, 0x0013,
2046 ], [
2047 0x0005, 0x003C, 0x0040, 0x000D, 0x0031, 0x0061, 0x0060, 0x0002,
2048 0x00F5, 0x0006, 0x0005, 0x0007, 0x0006, 0x0002, 0x0009, 0x0025,
2049 0x0007, 0x0021, 0x0024, 0x0010, 0x0041, 0x00F4, 0x0019, 0x000E,
2050 0x0003, 0x0011, 0x0011, 0x003F, 0x003E, 0x007B, 0x0000, 0x0013,
2051 ], [
2052 0x000A, 0x0007, 0x0001, 0x0009, 0x0131, 0x0261, 0x0260, 0x0015,
2053 0x0001, 0x0007, 0x0006, 0x0008, 0x0007, 0x0006, 0x0012, 0x002F,
2054 0x0014, 0x0027, 0x002D, 0x0016, 0x004D, 0x0099, 0x0000, 0x0004,
2055 0x0001, 0x0005, 0x0017, 0x002E, 0x002C, 0x0008, 0x0006, 0x0001,
2056 ], [
2057 0x0000, 0x000E, 0x0017, 0x002A, 0x0010, 0x00F9, 0x00F8, 0x001E,
2058 0x003F, 0x0007, 0x0006, 0x0009, 0x0008, 0x0006, 0x000F, 0x0005,
2059 0x0016, 0x0029, 0x002B, 0x0015, 0x0050, 0x0011, 0x007D, 0x0004,
2060 0x0017, 0x0006, 0x0014, 0x002C, 0x002D, 0x000E, 0x0009, 0x0051,
2061 ], [
2062 0x0002, 0x0018, 0x002F, 0x000D, 0x0053, 0x0295, 0x0294, 0x00A4,
2063 0x007C, 0x0000, 0x0007, 0x0009, 0x0008, 0x001B, 0x000C, 0x0028,
2064 0x006A, 0x001E, 0x001D, 0x0069, 0x00D7, 0x007D, 0x014B, 0x0019,
2065 0x0016, 0x002E, 0x001C, 0x002B, 0x002A, 0x0068, 0x003F, 0x00D6,
2066 ], [
2067 0x0002, 0x001B, 0x000C, 0x0018, 0x0029, 0x007F, 0x02F0, 0x0198,
2068 0x0179, 0x0000, 0x0007, 0x0009, 0x0008, 0x001A, 0x000D, 0x002A,
2069 0x0064, 0x001E, 0x0067, 0x005F, 0x00CD, 0x007E, 0x02F1, 0x0016,
2070 0x000E, 0x002E, 0x0065, 0x002B, 0x0028, 0x003E, 0x00BD, 0x0199,
2071 ], [
2072 0x0002, 0x0007, 0x0016, 0x0006, 0x0036, 0x005C, 0x015D, 0x015C,
2073 0x02BF, 0x0000, 0x0007, 0x0009, 0x0008, 0x0018, 0x0034, 0x002A,
2074 0x005E, 0x006A, 0x0064, 0x005D, 0x00CB, 0x00AD, 0x02BE, 0x0014,
2075 0x0033, 0x006E, 0x005F, 0x006F, 0x006B, 0x00CA, 0x00AC, 0x015E,
2076 ], [
2077 0x000F, 0x001D, 0x0018, 0x000B, 0x0019, 0x0029, 0x00D6, 0x0551,
2078 0x0AA1, 0x0001, 0x0000, 0x0009, 0x0008, 0x001B, 0x0038, 0x0028,
2079 0x0057, 0x006A, 0x0068, 0x0056, 0x00E5, 0x0155, 0x0AA0, 0x0073,
2080 0x0069, 0x00D7, 0x00AB, 0x00E4, 0x00A9, 0x0151, 0x0150, 0x02A9,
2081 ]
2082];
2083
6543b6f8 2084const VP31_DC_BITS: [[u8; 32]; 16] = [
5b24175d
KS		 2085 [
2086 6, 7, 9, 8, 10, 11, 11, 5, 12, 4, 4, 5, 4, 4, 4, 5,
2087 5, 4, 4, 3, 3, 4, 5, 6, 6, 8, 12, 11, 9, 10, 6, 7,
2088 ], [
2089 5, 7, 9, 8, 10, 11, 11, 6, 13, 4, 4, 4, 4, 4, 4, 5,
2090 5, 4, 4, 3, 3, 4, 5, 7, 7, 9, 12, 10, 11, 13, 7, 8,
2091 ], [
2092 5, 6, 8, 8, 10, 11, 11, 7, 14, 4, 4, 4, 4, 4, 4, 5,
2093 5, 4, 4, 3, 3, 4, 5, 7, 7, 10, 12, 11, 13, 14, 7, 8,
2094 ], [
2095 4, 6, 8, 7, 9, 10, 10, 6, 13, 3, 3, 4, 4, 4, 4, 5,
2096 5, 4, 4, 4, 4, 5, 7, 6, 7, 9, 11, 10, 12, 13, 7, 8,
2097 ], [
2098 4, 6, 7, 7, 8, 9, 10, 6, 13, 3, 3, 4, 4, 4, 4, 4,
2099 5, 4, 4, 4, 5, 6, 8, 6, 6, 9, 11, 9, 12, 13, 7, 7,
2100 ], [
2101 4, 5, 7, 6, 8, 9, 10, 6, 13, 3, 3, 4, 4, 4, 4, 4,
2102 5, 4, 4, 4, 5, 7, 10, 6, 7, 10, 11, 9, 12, 13, 7, 8,
2103 ], [
2104 4, 5, 6, 6, 8, 9, 9, 7, 13, 3, 3, 4, 4, 3, 4, 5,
2105 5, 4, 4, 5, 6, 8, 14, 6, 6, 10, 11, 9, 12, 14, 6, 7,
2106 ], [
2107 4, 5, 6, 5, 7, 8, 9, 7, 13, 3, 2, 4, 4, 4, 4, 5,
2108 5, 5, 5, 5, 7, 9, 14, 6, 6, 10, 11, 9, 12, 14, 7, 8,
2109 ], [
2110 4, 6, 8, 8, 10, 11, 11, 5, 6, 3, 3, 4, 4, 4, 5, 6,
2111 7, 6, 6, 6, 7, 8, 9, 4, 4, 5, 6, 6, 5, 5, 5, 5,
2112 ], [
2113 4, 6, 7, 7, 9, 10, 10, 5, 8, 3, 3, 4, 4, 4, 5, 6,
2114 6, 6, 6, 6, 7, 8, 8, 4, 4, 5, 6, 6, 6, 7, 4, 5,
2115 ], [
2116 4, 5, 6, 6, 9, 10, 10, 6, 7, 3, 3, 4, 4, 4, 5, 6,
2117 6, 6, 6, 6, 7, 8, 7, 4, 4, 5, 6, 6, 6, 6, 5, 5,
2118 ], [
2119 3, 5, 6, 6, 7, 10, 10, 7, 8, 3, 3, 4, 4, 4, 5, 5,
2120 6, 6, 6, 6, 7, 7, 9, 4, 5, 5, 6, 6, 6, 6, 6, 7,
2121 ], [
2122 3, 5, 6, 5, 7, 10, 10, 8, 8, 2, 3, 4, 4, 5, 5, 6,
2123 7, 6, 6, 7, 8, 8, 9, 5, 5, 6, 6, 6, 6, 7, 7, 8,
2124 ], [
2125 3, 5, 5, 5, 6, 8, 10, 9, 9, 2, 3, 4, 4, 5, 5, 6,
2126 7, 6, 7, 7, 8, 8, 10, 5, 5, 6, 7, 6, 6, 7, 8, 9,
2127 ], [
2128 3, 4, 5, 4, 6, 7, 9, 9, 10, 2, 3, 4, 4, 5, 6, 6,
2129 7, 7, 7, 7, 8, 8, 10, 5, 6, 7, 7, 7, 7, 8, 8, 9,
2130 ], [
2131 4, 5, 5, 4, 5, 6, 8, 11, 12, 2, 2, 4, 4, 5, 6, 6,
2132 7, 7, 7, 7, 8, 9, 12, 7, 7, 8, 8, 8, 8, 9, 9, 10,
2133 ]
2134];
2135
6543b6f8 2136const VP31_AC_CAT0_CODES: [[u16; 32]; 16] = [
5b24175d
KS		 2137 [
2138 0x0008, 0x0025, 0x017A, 0x02F7, 0x0BDB, 0x17B4, 0x2F6B, 0x001D,
2139 0x2F6A, 0x0008, 0x0007, 0x0001, 0x0002, 0x000A, 0x0006, 0x0000,
2140 0x001C, 0x0009, 0x000D, 0x000F, 0x000C, 0x0003, 0x000A, 0x0016,
2141 0x0013, 0x005D, 0x0024, 0x00BC, 0x005C, 0x05EC, 0x000B, 0x005F,
2142 ], [
2143 0x000F, 0x0010, 0x004B, 0x00C6, 0x031D, 0x0C71, 0x0C70, 0x0001,
2144 0x0C73, 0x0008, 0x0009, 0x0002, 0x0003, 0x000B, 0x0006, 0x0000,
2145 0x001C, 0x0005, 0x000D, 0x000F, 0x000A, 0x0019, 0x0013, 0x001D,
2146 0x0030, 0x0062, 0x0024, 0x004A, 0x018F, 0x0C72, 0x000E, 0x0011,
2147 ], [
2148 0x001B, 0x0003, 0x008D, 0x0040, 0x0239, 0x0471, 0x08E0, 0x0003,
2149 0x11C3, 0x000A, 0x0009, 0x0004, 0x0005, 0x000E, 0x0007, 0x0001,
2150 0x001E, 0x0006, 0x000C, 0x000B, 0x0002, 0x0000, 0x0041, 0x001F,
2151 0x0022, 0x0002, 0x008F, 0x008C, 0x011D, 0x11C2, 0x001A, 0x0021,
2152 ], [
2153 0x001F, 0x0003, 0x0003, 0x0043, 0x000B, 0x0015, 0x0051, 0x0003,
2154 0x0050, 0x000D, 0x000C, 0x0004, 0x0006, 0x000E, 0x000A, 0x0001,
2155 0x001E, 0x0005, 0x0009, 0x0007, 0x0011, 0x0002, 0x0004, 0x0002,
2156 0x002D, 0x0020, 0x0042, 0x0001, 0x0000, 0x0029, 0x0017, 0x002C,
2157 ], [
2158 0x0003, 0x001F, 0x003A, 0x005D, 0x0173, 0x02E4, 0x172D, 0x0004,
2159 0x172C, 0x000F, 0x000E, 0x0009, 0x0008, 0x000C, 0x000A, 0x0001,
2160 0x0016, 0x0002, 0x0005, 0x001A, 0x002F, 0x0038, 0x05CA, 0x0006,
2161 0x0037, 0x001E, 0x003B, 0x0039, 0x00B8, 0x0B97, 0x0000, 0x0036,
2162 ], [
2163 0x0006, 0x0037, 0x005D, 0x000C, 0x00B9, 0x02E3, 0x05C4, 0x0004,
2164 0x1715, 0x0000, 0x000F, 0x0008, 0x0007, 0x000C, 0x0009, 0x001D,
2165 0x0016, 0x001C, 0x001A, 0x000B, 0x005E, 0x0170, 0x1714, 0x000A,
2166 0x000A, 0x0036, 0x005F, 0x001B, 0x001A, 0x0B8B, 0x0002, 0x0007,
2167 ], [
2168 0x000C, 0x000B, 0x0079, 0x0022, 0x00F0, 0x0119, 0x0230, 0x001D,
2169 0x08C4, 0x0001, 0x0000, 0x000A, 0x0009, 0x000B, 0x0007, 0x001C,
2170 0x003D, 0x000D, 0x0008, 0x0015, 0x008D, 0x118B, 0x118A, 0x000D,
2171 0x0010, 0x0009, 0x0014, 0x0047, 0x00F1, 0x0463, 0x001F, 0x000C,
2172 ], [
2173 0x0000, 0x001A, 0x0033, 0x000C, 0x0046, 0x01E3, 0x03C5, 0x0017,
2174 0x1E21, 0x0002, 0x0001, 0x0009, 0x000A, 0x0007, 0x001B, 0x003D,
2175 0x001B, 0x0022, 0x0079, 0x00F0, 0x1E20, 0x1E23, 0x1E22, 0x000E,
2176 0x0016, 0x0018, 0x0032, 0x001A, 0x0047, 0x0789, 0x001F, 0x0010,
2177 ], [
2178 0x001D, 0x0061, 0x004E, 0x009E, 0x027C, 0x09F5, 0x09F4, 0x0003,
2179 0x0060, 0x0000, 0x000F, 0x000B, 0x000A, 0x0009, 0x0005, 0x000D,
2180 0x0031, 0x0008, 0x0038, 0x0012, 0x0026, 0x013F, 0x04FB, 0x000D,
2181 0x0002, 0x000C, 0x0039, 0x001C, 0x000F, 0x001D, 0x0008, 0x0019,
2182 ], [
2183 0x0007, 0x0019, 0x00AB, 0x00AA, 0x0119, 0x0461, 0x0460, 0x001B,
2184 0x0047, 0x0001, 0x0000, 0x000C, 0x000B, 0x0009, 0x0005, 0x000D,
2185 0x0035, 0x003D, 0x003C, 0x0018, 0x0022, 0x008D, 0x0231, 0x000E,
2186 0x001F, 0x0009, 0x002B, 0x0010, 0x0034, 0x0054, 0x0008, 0x0014,
2187 ], [
2188 0x000C, 0x0005, 0x0008, 0x005B, 0x004D, 0x0131, 0x0261, 0x001A,
2189 0x0012, 0x0000, 0x000F, 0x000A, 0x0009, 0x0006, 0x001B, 0x0006,
2190 0x001C, 0x002C, 0x0015, 0x005A, 0x0027, 0x0099, 0x0260, 0x000E,
2191 0x0004, 0x000F, 0x0007, 0x001D, 0x000B, 0x0014, 0x0008, 0x0017,
2192 ], [
2193 0x000F, 0x0013, 0x0075, 0x0024, 0x0095, 0x0251, 0x04A0, 0x0010,
2194 0x00C8, 0x0002, 0x0001, 0x0001, 0x0000, 0x001A, 0x0011, 0x002C,
2195 0x0065, 0x0074, 0x004B, 0x00C9, 0x0129, 0x0943, 0x0942, 0x0003,
2196 0x000A, 0x001C, 0x0018, 0x0033, 0x0017, 0x002D, 0x001B, 0x003B,
2197 ], [
2198 0x0003, 0x001A, 0x002D, 0x0038, 0x0028, 0x0395, 0x0E51, 0x0037,
2199 0x00E4, 0x0001, 0x0000, 0x001F, 0x001E, 0x0017, 0x003A, 0x0073,
2200 0x002A, 0x002B, 0x0029, 0x01CB, 0x0729, 0x1CA1, 0x1CA0, 0x0004,
2201 0x000A, 0x0004, 0x0018, 0x0036, 0x000B, 0x002C, 0x0019, 0x003B,
2202 ], [
2203 0x0004, 0x0004, 0x003F, 0x0017, 0x0075, 0x01F5, 0x07D1, 0x0017,
2204 0x01F6, 0x0001, 0x0000, 0x001B, 0x001A, 0x000A, 0x0032, 0x0074,
2205 0x00F8, 0x00F9, 0x01F7, 0x03E9, 0x0FA0, 0x1F43, 0x1F42, 0x0003,
2206 0x000A, 0x001E, 0x001C, 0x003B, 0x0018, 0x0016, 0x0016, 0x0033,
2207 ], [
2208 0x0004, 0x0007, 0x0018, 0x001E, 0x0036, 0x0031, 0x0177, 0x0077,
2209 0x0176, 0x0001, 0x0000, 0x001A, 0x0019, 0x003A, 0x0019, 0x005C,
2210 0x00BA, 0x0061, 0x00C1, 0x0180, 0x0302, 0x0607, 0x0606, 0x0002,
2211 0x000A, 0x001F, 0x001C, 0x0037, 0x0016, 0x0076, 0x000D, 0x002F,
2212 ], [
2213 0x0000, 0x000A, 0x001A, 0x000C, 0x001D, 0x0039, 0x0078, 0x005E,
2214 0x0393, 0x0002, 0x0001, 0x0016, 0x000F, 0x002E, 0x005F, 0x0073,
2215 0x00E5, 0x01C8, 0x0E4A, 0x1C97, 0x1C96, 0x0E49, 0x0E48, 0x0004,
2216 0x0006, 0x001F, 0x001B, 0x001D, 0x0038, 0x0038, 0x003D, 0x0079,
2217 ]
2218];
2219
6543b6f8 2220const VP31_AC_CAT0_BITS: [[u8; 32]; 16] = [
5b24175d
KS		 2221 [
2222 5, 7, 9, 10, 12, 13, 14, 5, 14, 4, 4, 4, 4, 4, 4, 4,
2223 5, 4, 4, 4, 4, 4, 5, 5, 6, 7, 7, 8, 7, 11, 5, 7,
2224 ], [
2225 5, 6, 8, 8, 10, 12, 12, 4, 12, 4, 4, 4, 4, 4, 4, 4,
2226 5, 4, 4, 4, 4, 5, 6, 5, 6, 7, 7, 8, 9, 12, 5, 6,
2227 ], [
2228 5, 6, 8, 7, 10, 11, 12, 4, 13, 4, 4, 4, 4, 4, 4, 4,
2229 5, 4, 4, 4, 4, 5, 7, 5, 6, 6, 8, 8, 9, 13, 5, 6,
2230 ], [
2231 5, 6, 7, 7, 9, 10, 12, 4, 12, 4, 4, 4, 4, 4, 4, 4,
2232 5, 4, 4, 4, 5, 6, 8, 4, 6, 6, 7, 7, 7, 11, 5, 6,
2233 ], [
2234 4, 6, 7, 7, 9, 10, 13, 4, 13, 4, 4, 4, 4, 4, 4, 4,
2235 5, 4, 4, 5, 6, 7, 11, 4, 6, 6, 7, 7, 8, 12, 4, 6,
2236 ], [
2237 4, 6, 7, 6, 8, 10, 11, 4, 13, 3, 4, 4, 4, 4, 4, 5,
2238 5, 5, 5, 5, 7, 9, 13, 4, 5, 6, 7, 7, 7, 12, 4, 5,
2239 ], [
2240 4, 5, 7, 6, 8, 9, 10, 5, 12, 3, 3, 4, 4, 4, 4, 5,
2241 6, 5, 5, 6, 8, 13, 13, 4, 5, 5, 6, 7, 8, 11, 5, 5,
2242 ], [
2243 3, 5, 6, 5, 7, 9, 10, 5, 13, 3, 3, 4, 4, 4, 5, 6,
2244 6, 6, 7, 8, 13, 13, 13, 4, 5, 5, 6, 6, 7, 11, 5, 5,
2245 ], [
2246 5, 7, 8, 9, 11, 13, 13, 4, 7, 3, 4, 4, 4, 4, 4, 5,
2247 6, 5, 6, 6, 7, 10, 12, 4, 4, 5, 6, 6, 5, 6, 4, 5,
2248 ], [
2249 4, 6, 8, 8, 10, 12, 12, 5, 8, 3, 3, 4, 4, 4, 4, 5,
2250 6, 6, 6, 6, 7, 9, 11, 4, 5, 5, 6, 6, 6, 7, 4, 5,
2251 ], [
2252 4, 5, 6, 7, 9, 11, 12, 5, 7, 3, 4, 4, 4, 4, 5, 5,
2253 6, 6, 6, 7, 8, 10, 12, 4, 4, 5, 5, 6, 5, 6, 4, 5,
2254 ], [
2255 4, 5, 7, 6, 8, 10, 11, 5, 8, 3, 3, 4, 4, 5, 5, 6,
2256 7, 7, 7, 8, 9, 12, 12, 3, 4, 5, 5, 6, 5, 6, 5, 6,
2257 ], [
2258 3, 5, 6, 6, 7, 10, 12, 6, 8, 3, 3, 5, 5, 5, 6, 7,
2259 7, 7, 7, 9, 11, 13, 13, 3, 4, 4, 5, 6, 5, 6, 5, 6,
2260 ], [
2261 3, 4, 6, 5, 7, 9, 11, 6, 9, 3, 3, 5, 5, 5, 6, 7,
2262 8, 8, 9, 10, 12, 13, 13, 3, 4, 5, 5, 6, 5, 6, 5, 6,
2263 ], [
2264 3, 4, 5, 5, 6, 7, 9, 7, 9, 3, 3, 5, 5, 6, 6, 7,
2265 8, 8, 9, 10, 11, 12, 12, 3, 4, 5, 5, 6, 5, 7, 5, 6,
2266 ], [
2267 3, 4, 5, 4, 5, 6, 7, 7, 11, 3, 3, 5, 5, 6, 7, 8,
2268 9, 10, 13, 14, 14, 13, 13, 3, 4, 5, 5, 6, 6, 7, 6, 7,
2269 ]
2270];
2271
6543b6f8 2272const VP31_AC_CAT1_CODES: [[u16; 32]; 16] = [
5b24175d
KS		 2273 [
2274 0x000B, 0x002B, 0x0054, 0x01B7, 0x06D9, 0x0DB1, 0x0DB0, 0x0002,
2275 0x00AB, 0x0009, 0x000A, 0x0007, 0x0008, 0x000F, 0x000C, 0x0003,
2276 0x001D, 0x0004, 0x000B, 0x0006, 0x001A, 0x0003, 0x00AA, 0x0001,
2277 0x0000, 0x0014, 0x006C, 0x00DA, 0x0002, 0x036D, 0x001C, 0x0037,
2278 ], [
2279 0x001D, 0x0004, 0x00B6, 0x006A, 0x05B9, 0x16E1, 0x16E0, 0x0007,
2280 0x016F, 0x000C, 0x000D, 0x0009, 0x0008, 0x000F, 0x000A, 0x0003,
2281 0x0017, 0x0002, 0x0004, 0x001C, 0x002C, 0x006B, 0x0B71, 0x0005,
2282 0x0003, 0x001B, 0x005A, 0x0034, 0x0005, 0x02DD, 0x0000, 0x000C,
2283 ], [
2284 0x0003, 0x007F, 0x00A1, 0x00A0, 0x020C, 0x0834, 0x106B, 0x0007,
2285 0x0082, 0x000E, 0x000D, 0x000B, 0x000C, 0x0000, 0x0009, 0x0002,
2286 0x0011, 0x001E, 0x0015, 0x003E, 0x0040, 0x041B, 0x106A, 0x0006,
2287 0x000A, 0x0029, 0x007E, 0x0051, 0x0021, 0x0107, 0x0004, 0x000B,
2288 ], [
2289 0x0007, 0x001B, 0x00F6, 0x00E9, 0x03A1, 0x0740, 0x0E82, 0x001F,
2290 0x01EF, 0x0001, 0x0002, 0x000B, 0x000C, 0x000D, 0x0008, 0x001C,
2291 0x0003, 0x0012, 0x0002, 0x0075, 0x01D1, 0x1D07, 0x1D06, 0x000A,
2292 0x0013, 0x003B, 0x001A, 0x007A, 0x003C, 0x01EE, 0x0000, 0x000C,
2293 ], [
2294 0x000D, 0x003D, 0x0042, 0x0037, 0x00D9, 0x0362, 0x06C6, 0x001F,
2295 0x0086, 0x0001, 0x0002, 0x000C, 0x000B, 0x000A, 0x0001, 0x000F,
2296 0x0025, 0x003C, 0x001A, 0x0087, 0x01B0, 0x0D8F, 0x0D8E, 0x000E,
2297 0x0013, 0x000C, 0x0024, 0x0020, 0x0011, 0x006D, 0x0000, 0x000E,
2298 ], [
2299 0x0000, 0x0012, 0x0076, 0x0077, 0x014D, 0x0533, 0x14C9, 0x0013,
2300 0x00A5, 0x0002, 0x0003, 0x000B, 0x000C, 0x0008, 0x001A, 0x002B,
2301 0x0075, 0x0074, 0x00A7, 0x0298, 0x14C8, 0x14CB, 0x14CA, 0x000F,
2302 0x001C, 0x0007, 0x002A, 0x0028, 0x001B, 0x00A4, 0x0002, 0x0006,
2303 ], [
2304 0x0002, 0x001A, 0x002B, 0x003A, 0x00ED, 0x0283, 0x0A0A, 0x0004,
2305 0x00A1, 0x0004, 0x0003, 0x000B, 0x000C, 0x001F, 0x0006, 0x0077,
2306 0x00A3, 0x00A2, 0x0140, 0x1417, 0x1416, 0x0A09, 0x0A08, 0x0000,
2307 0x001E, 0x0007, 0x002A, 0x0029, 0x001C, 0x00EC, 0x001B, 0x0005,
2308 ], [
2309 0x0002, 0x0002, 0x0018, 0x001D, 0x0035, 0x00E4, 0x01CF, 0x001D,
2310 0x0072, 0x0004, 0x0005, 0x0006, 0x0007, 0x0006, 0x0073, 0x0038,
2311 0x01CE, 0x039B, 0x0398, 0x0733, 0x0732, 0x0735, 0x0734, 0x0000,
2312 0x001F, 0x001B, 0x0034, 0x000F, 0x001E, 0x00E5, 0x0019, 0x0038,
2313 ], [
2314 0x0016, 0x0050, 0x0172, 0x02E7, 0x1732, 0x2E67, 0x2E66, 0x0006,
2315 0x0051, 0x0001, 0x0000, 0x000D, 0x000C, 0x0009, 0x001C, 0x0009,
2316 0x001C, 0x001D, 0x005D, 0x00B8, 0x05CD, 0x1731, 0x1730, 0x000F,
2317 0x0005, 0x000F, 0x0008, 0x0029, 0x001D, 0x002F, 0x0008, 0x0015,
2318 ], [
2319 0x0009, 0x0021, 0x0040, 0x00AD, 0x02B0, 0x1589, 0x1588, 0x001C,
2320 0x005F, 0x0000, 0x000F, 0x000D, 0x000C, 0x0006, 0x0011, 0x002A,
2321 0x0057, 0x005E, 0x0041, 0x0159, 0x0563, 0x158B, 0x158A, 0x0001,
2322 0x0005, 0x0014, 0x003B, 0x002E, 0x0004, 0x003A, 0x0007, 0x0016,
2323 ], [
2324 0x000E, 0x0007, 0x0046, 0x0045, 0x0064, 0x032A, 0x0657, 0x0018,
2325 0x000D, 0x0000, 0x000F, 0x000A, 0x000B, 0x001A, 0x0036, 0x0047,
2326 0x0044, 0x0018, 0x0033, 0x00CB, 0x0656, 0x0329, 0x0328, 0x0002,
2327 0x0006, 0x0019, 0x000E, 0x0037, 0x0009, 0x000F, 0x0002, 0x0010,
2328 ], [
2329 0x0003, 0x0018, 0x0023, 0x0077, 0x0194, 0x1956, 0x32AF, 0x003A,
2330 0x0076, 0x0002, 0x0001, 0x001F, 0x001E, 0x0014, 0x0022, 0x0064,
2331 0x0197, 0x0196, 0x032B, 0x0654, 0x32AE, 0x1955, 0x1954, 0x0000,
2332 0x0009, 0x001C, 0x0015, 0x0010, 0x000D, 0x0017, 0x0016, 0x0033,
2333 ], [
2334 0x0005, 0x0006, 0x003E, 0x0010, 0x0048, 0x093F, 0x24FA, 0x0032,
2335 0x0067, 0x0002, 0x0001, 0x001B, 0x001E, 0x0034, 0x0066, 0x0092,
2336 0x0126, 0x024E, 0x049E, 0x49F7, 0x49F6, 0x24F9, 0x24F8, 0x0000,
2337 0x0007, 0x0018, 0x0011, 0x003F, 0x000E, 0x0013, 0x0035, 0x0025,
2338 ], [
2339 0x0005, 0x0008, 0x0012, 0x001C, 0x001C, 0x00EA, 0x1D75, 0x001E,
2340 0x0066, 0x0001, 0x0002, 0x001B, 0x001A, 0x001F, 0x003B, 0x0074,
2341 0x01D6, 0x03AF, 0x1D74, 0x1D77, 0x1D76, 0x0EB9, 0x0EB8, 0x000F,
2342 0x0006, 0x0013, 0x003B, 0x003A, 0x0000, 0x0018, 0x0032, 0x0067,
2343 ], [
2344 0x0004, 0x000A, 0x001B, 0x000C, 0x000D, 0x00E6, 0x0684, 0x0072,
2345 0x00E7, 0x0002, 0x0001, 0x0017, 0x0016, 0x0018, 0x00D1, 0x01A0,
2346 0x0686, 0x0D0F, 0x0D0A, 0x1A17, 0x1A16, 0x1A1D, 0x1A1C, 0x000F,
2347 0x001D, 0x000E, 0x0035, 0x0038, 0x0000, 0x000F, 0x0019, 0x0069,
2348 ], [
2349 0x0003, 0x000C, 0x001B, 0x0000, 0x0003, 0x002E, 0x0051, 0x00BC,
2350 0x0053, 0x0004, 0x0002, 0x0016, 0x0015, 0x0015, 0x0050, 0x00A4,
2351 0x0294, 0x052B, 0x052A, 0x052D, 0x052C, 0x052F, 0x052E, 0x000E,
2352 0x001A, 0x0004, 0x0028, 0x0029, 0x000F, 0x000B, 0x005F, 0x00BD,
2353 ]
2354];
2355
6543b6f8 2356const VP31_AC_CAT1_BITS: [[u8; 32]; 16] = [
5b24175d
KS		 2357 [
2358 5, 7, 8, 9, 11, 12, 12, 4, 9, 4, 4, 4, 4, 4, 4, 4,
2359 5, 4, 4, 4, 5, 6, 9, 4, 5, 6, 7, 8, 6, 10, 5, 6,
2360 ], [
2361 5, 6, 8, 8, 11, 13, 13, 4, 9, 4, 4, 4, 4, 4, 4, 4,
2362 5, 4, 4, 5, 6, 8, 12, 4, 5, 6, 7, 7, 6, 10, 4, 5,
2363 ], [
2364 4, 7, 8, 8, 10, 12, 13, 4, 8, 4, 4, 4, 4, 3, 4, 4,
2365 5, 5, 5, 6, 7, 11, 13, 4, 5, 6, 7, 7, 6, 9, 4, 5,
2366 ], [
2367 4, 6, 8, 8, 10, 11, 12, 5, 9, 3, 3, 4, 4, 4, 4, 5,
2368 5, 5, 5, 7, 9, 13, 13, 4, 5, 6, 6, 7, 6, 9, 4, 5,
2369 ], [
2370 4, 6, 7, 7, 9, 11, 12, 5, 8, 3, 3, 4, 4, 4, 4, 5,
2371 6, 6, 6, 8, 10, 13, 13, 4, 5, 5, 6, 6, 5, 8, 4, 5,
2372 ], [
2373 3, 5, 7, 7, 9, 11, 13, 5, 8, 3, 3, 4, 4, 4, 5, 6,
2374 7, 7, 8, 10, 13, 13, 13, 4, 5, 5, 6, 6, 5, 8, 4, 5,
2375 ], [
2376 3, 5, 6, 6, 8, 10, 12, 5, 8, 3, 3, 4, 4, 5, 5, 7,
2377 8, 8, 9, 13, 13, 12, 12, 3, 5, 5, 6, 6, 5, 8, 5, 5,
2378 ], [
2379 3, 4, 5, 5, 6, 8, 11, 7, 9, 3, 3, 4, 4, 5, 7, 8,
2380 11, 12, 12, 13, 13, 13, 13, 3, 5, 5, 6, 6, 5, 8, 5, 6,
2381 ], [
2382 5, 7, 9, 10, 13, 14, 14, 4, 7, 3, 3, 4, 4, 4, 5, 5,
2383 6, 6, 7, 8, 11, 13, 13, 4, 4, 5, 5, 6, 5, 6, 4, 5,
2384 ], [
2385 4, 6, 7, 8, 10, 13, 13, 5, 7, 3, 4, 4, 4, 4, 5, 6,
2386 7, 7, 7, 9, 11, 13, 13, 3, 4, 5, 6, 6, 4, 6, 4, 5,
2387 ], [
2388 4, 5, 7, 7, 9, 12, 13, 5, 6, 3, 4, 4, 4, 5, 6, 7,
2389 7, 7, 8, 10, 13, 12, 12, 3, 4, 5, 5, 6, 4, 5, 4, 5,
2390 ], [
2391 3, 5, 6, 7, 9, 13, 14, 6, 7, 3, 3, 5, 5, 5, 6, 7,
2392 9, 9, 10, 11, 14, 13, 13, 3, 4, 5, 5, 5, 4, 5, 5, 6,
2393 ], [
2394 3, 4, 6, 5, 7, 12, 14, 6, 7, 3, 3, 5, 5, 6, 7, 8,
2395 9, 10, 11, 15, 15, 14, 14, 3, 4, 5, 5, 6, 4, 5, 6, 6,
2396 ], [
2397 3, 4, 5, 5, 6, 9, 14, 6, 7, 3, 3, 5, 5, 6, 7, 8,
2398 10, 11, 14, 14, 14, 13, 13, 4, 4, 5, 6, 6, 3, 5, 6, 7,
2399 ], [
2400 3, 4, 5, 4, 5, 8, 11, 7, 8, 3, 3, 5, 5, 6, 8, 9,
2401 11, 12, 12, 13, 13, 13, 13, 4, 5, 5, 6, 6, 3, 5, 6, 7,
2402 ], [
2403 3, 4, 5, 3, 4, 6, 9, 8, 9, 3, 3, 5, 5, 7, 9, 10,
2404 12, 13, 13, 13, 13, 13, 13, 4, 5, 5, 6, 6, 4, 6, 7, 8,
2405 ]
2406];
2407
6543b6f8 2408const VP31_AC_CAT2_CODES: [[u16; 32]; 16] = [
5b24175d
KS		 2409 [
2410 0x0003, 0x0009, 0x00D0, 0x01A3, 0x0344, 0x0D14, 0x1A2B, 0x0004,
2411 0x0015, 0x0000, 0x000F, 0x000B, 0x000C, 0x000E, 0x0009, 0x001B,
2412 0x000A, 0x0014, 0x000D, 0x002A, 0x0014, 0x068B, 0x1A2A, 0x0008,
2413 0x000B, 0x002B, 0x000B, 0x0069, 0x0035, 0x0008, 0x0007, 0x000C,
2414 ], [
2415 0x000A, 0x003C, 0x0032, 0x0030, 0x00C5, 0x0621, 0x0620, 0x001F,
2416 0x0033, 0x0001, 0x0000, 0x000E, 0x000D, 0x000C, 0x0004, 0x000D,
2417 0x0026, 0x0027, 0x0014, 0x0063, 0x0189, 0x0623, 0x0622, 0x000B,
2418 0x0012, 0x003D, 0x0022, 0x0015, 0x000B, 0x0023, 0x0007, 0x0010,
2419 ], [
2420 0x000F, 0x000C, 0x0043, 0x0010, 0x0044, 0x0114, 0x0455, 0x0018,
2421 0x0023, 0x0001, 0x0000, 0x000E, 0x000D, 0x0009, 0x0019, 0x0009,
2422 0x0017, 0x0016, 0x0042, 0x008B, 0x0454, 0x0457, 0x0456, 0x000B,
2423 0x0015, 0x000A, 0x0029, 0x0020, 0x000D, 0x0028, 0x0007, 0x0011,
2424 ], [
2425 0x0001, 0x001A, 0x0029, 0x002A, 0x00A0, 0x0285, 0x1425, 0x0002,
2426 0x0000, 0x0002, 0x0003, 0x000C, 0x000B, 0x0008, 0x0012, 0x0001,
2427 0x0051, 0x0001, 0x0143, 0x0508, 0x1424, 0x1427, 0x1426, 0x000F,
2428 0x001C, 0x0003, 0x0037, 0x002B, 0x0013, 0x0036, 0x001D, 0x0001,
2429 ], [
2430 0x0004, 0x001F, 0x003D, 0x0006, 0x0016, 0x0053, 0x014A, 0x0034,
2431 0x002A, 0x0002, 0x0003, 0x000B, 0x000C, 0x001C, 0x0037, 0x0017,
2432 0x002B, 0x0028, 0x00A4, 0x052D, 0x052C, 0x052F, 0x052E, 0x0000,
2433 0x001D, 0x0007, 0x0004, 0x0035, 0x0014, 0x0036, 0x0015, 0x003C,
2434 ], [
2435 0x0004, 0x000A, 0x0007, 0x001D, 0x0009, 0x01F3, 0x07C7, 0x0008,
2436 0x01F0, 0x0003, 0x0002, 0x000D, 0x000C, 0x0017, 0x007D, 0x01F2,
2437 0x07C6, 0x07C5, 0x1F12, 0x3E27, 0x3E26, 0x1F11, 0x1F10, 0x0000,
2438 0x001E, 0x0006, 0x0039, 0x0038, 0x003F, 0x002C, 0x0005, 0x002D,
2439 ], [
2440 0x0002, 0x0007, 0x0018, 0x0003, 0x0005, 0x0035, 0x004F, 0x0012,
2441 0x04E5, 0x0005, 0x0004, 0x000D, 0x000E, 0x0033, 0x0026, 0x009D,
2442 0x04E4, 0x04E7, 0x04E6, 0x04E1, 0x04E0, 0x04E3, 0x04E2, 0x0000,
2443 0x001F, 0x000C, 0x003D, 0x003C, 0x0032, 0x0034, 0x001B, 0x0008,
2444 ], [
2445 0x0000, 0x0004, 0x001C, 0x000F, 0x0002, 0x0007, 0x0075, 0x00E8,
2446 0x1D2A, 0x0005, 0x0004, 0x000D, 0x000C, 0x0077, 0x0E96, 0x3A57,
2447 0x3A56, 0x3A5D, 0x3A5C, 0x3A5F, 0x3A5E, 0x1D29, 0x1D28, 0x0003,
2448 0x0006, 0x000A, 0x002C, 0x0017, 0x0076, 0x01D3, 0x03A4, 0x002D,
2449 ], [
2450 0x000A, 0x0024, 0x00BF, 0x0085, 0x0211, 0x0842, 0x1087, 0x0018,
2451 0x0020, 0x0001, 0x0002, 0x000E, 0x000D, 0x0007, 0x0013, 0x0025,
2452 0x005E, 0x0043, 0x00BE, 0x0109, 0x1086, 0x0841, 0x0840, 0x000F,
2453 0x0001, 0x0011, 0x0000, 0x002E, 0x0019, 0x0001, 0x0006, 0x0016,
2454 ], [
2455 0x0002, 0x000F, 0x006F, 0x0061, 0x0374, 0x1BA8, 0x3753, 0x0012,
2456 0x0036, 0x0000, 0x0001, 0x000A, 0x000B, 0x001A, 0x0031, 0x0060,
2457 0x00DC, 0x01BB, 0x06EB, 0x1BAB, 0x3752, 0x3755, 0x3754, 0x000E,
2458 0x0006, 0x0013, 0x000E, 0x003E, 0x0008, 0x001E, 0x0019, 0x003F,
2459 ], [
2460 0x0003, 0x001C, 0x0025, 0x0024, 0x01DA, 0x1DBD, 0x3B7C, 0x003C,
2461 0x003D, 0x0000, 0x0001, 0x000B, 0x000A, 0x000B, 0x0077, 0x00EC,
2462 0x03B6, 0x076E, 0x1DBF, 0x76FB, 0x76FA, 0x3B79, 0x3B78, 0x000D,
2463 0x001F, 0x0013, 0x000A, 0x0008, 0x000C, 0x0008, 0x0009, 0x003A,
2464 ], [
2465 0x0005, 0x0003, 0x0004, 0x0010, 0x008F, 0x0475, 0x11D1, 0x0079,
2466 0x0027, 0x0002, 0x0003, 0x0001, 0x0000, 0x0026, 0x0046, 0x011C,
2467 0x0477, 0x08ED, 0x11D0, 0x11D3, 0x11D2, 0x11D9, 0x11D8, 0x000D,
2468 0x001F, 0x0012, 0x0005, 0x003D, 0x000C, 0x000E, 0x0022, 0x0078,
2469 ], [
2470 0x0005, 0x000C, 0x001B, 0x0000, 0x0006, 0x03E2, 0x3E3D, 0x000F,
2471 0x0034, 0x0003, 0x0002, 0x001E, 0x001D, 0x007D, 0x01F0, 0x07C6,
2472 0x3E3C, 0x3E3F, 0x3E3E, 0x3E39, 0x3E38, 0x3E3B, 0x3E3A, 0x0008,
2473 0x001C, 0x0002, 0x003F, 0x0035, 0x0009, 0x0001, 0x000E, 0x00F9,
2474 ], [
2475 0x0004, 0x000B, 0x0001, 0x000A, 0x001E, 0x00E0, 0x0E1E, 0x0071,
2476 0x0039, 0x0007, 0x0006, 0x000D, 0x000C, 0x0020, 0x01C2, 0x1C3F,
2477 0x1C3E, 0x0E19, 0x0E18, 0x0E1B, 0x0E1A, 0x0E1D, 0x0E1C, 0x0000,
2478 0x0009, 0x001D, 0x001F, 0x0011, 0x0005, 0x0001, 0x0043, 0x0042,
2479 ], [
2480 0x0004, 0x000D, 0x0007, 0x0002, 0x0014, 0x016C, 0x16D1, 0x02DF,
2481 0x016E, 0x0000, 0x0007, 0x002C, 0x002B, 0x02DE, 0x16D0, 0x16D3,
2482 0x16D2, 0x2DB5, 0x2DB4, 0x2DB7, 0x2DB6, 0x16D9, 0x16D8, 0x000C,
2483 0x002A, 0x005A, 0x001B, 0x001A, 0x0017, 0x000C, 0x05B7, 0x05B5,
2484 ], [
2485 0x0002, 0x000F, 0x001C, 0x000C, 0x003B, 0x01AC, 0x1AD8, 0x35B3,
2486 0x35B2, 0x0001, 0x0000, 0x0069, 0x0068, 0x35BD, 0x35BC, 0x35BF,
2487 0x35BE, 0x35B9, 0x35B8, 0x35BB, 0x35BA, 0x35B5, 0x35B4, 0x01A9,
2488 0x01A8, 0x035A, 0x00D7, 0x00D5, 0x003A, 0x001B, 0x35B7, 0x35B6,
2489 ]
2490];
2491
6543b6f8 2492const VP31_AC_CAT2_BITS: [[u8; 32]; 16] = [
5b24175d
KS		 2493 [
2494 4, 6, 8, 9, 10, 12, 13, 4, 7, 3, 4, 4, 4, 4, 4, 5,
2495 5, 5, 5, 6, 7, 11, 13, 4, 5, 6, 6, 7, 6, 6, 4, 5,
2496 ], [
2497 4, 6, 7, 7, 9, 12, 12, 5, 7, 3, 3, 4, 4, 4, 4, 5,
2498 6, 6, 6, 8, 10, 12, 12, 4, 5, 6, 6, 6, 5, 6, 4, 5,
2499 ], [
2500 4, 5, 7, 6, 8, 10, 12, 5, 7, 3, 3, 4, 4, 4, 5, 5,
2501 6, 6, 7, 9, 12, 12, 12, 4, 5, 5, 6, 6, 5, 6, 4, 5,
2502 ], [
2503 3, 5, 6, 6, 8, 10, 13, 5, 7, 3, 3, 4, 4, 4, 5, 6,
2504 7, 7, 9, 11, 13, 13, 13, 4, 5, 5, 6, 6, 5, 6, 5, 5,
2505 ], [
2506 3, 5, 6, 5, 7, 9, 11, 6, 8, 3, 3, 4, 4, 5, 6, 7,
2507 8, 8, 10, 13, 13, 13, 13, 3, 5, 5, 5, 6, 5, 6, 5, 6,
2508 ], [
2509 3, 4, 5, 5, 6, 9, 11, 6, 9, 3, 3, 4, 4, 5, 7, 9,
2510 11, 11, 13, 14, 14, 13, 13, 3, 5, 5, 6, 6, 6, 6, 5, 6,
2511 ], [
2512 3, 4, 5, 4, 5, 7, 9, 7, 13, 3, 3, 4, 4, 6, 8, 10,
2513 13, 13, 13, 13, 13, 13, 13, 3, 5, 5, 6, 6, 6, 7, 6, 6,
2514 ], [
2515 3, 4, 5, 4, 4, 5, 7, 8, 13, 3, 3, 4, 4, 7, 12, 14,
2516 14, 14, 14, 14, 14, 13, 13, 3, 5, 5, 7, 6, 7, 9, 10, 7,
2517 ], [
2518 4, 6, 8, 8, 10, 12, 13, 5, 6, 3, 3, 4, 4, 4, 5, 6,
2519 7, 7, 8, 9, 13, 12, 12, 4, 4, 5, 5, 6, 5, 5, 4, 5,
2520 ], [
2521 3, 5, 7, 7, 10, 13, 14, 5, 6, 3, 3, 4, 4, 5, 6, 7,
2522 8, 9, 11, 13, 14, 14, 14, 4, 4, 5, 5, 6, 4, 5, 5, 6,
2523 ], [
2524 3, 5, 6, 6, 9, 13, 14, 6, 6, 3, 3, 4, 4, 5, 7, 8,
2525 10, 11, 13, 15, 15, 14, 14, 4, 5, 5, 5, 5, 4, 4, 5, 6,
2526 ], [
2527 3, 4, 5, 5, 8, 11, 13, 7, 6, 3, 3, 4, 4, 6, 7, 9,
2528 11, 12, 13, 13, 13, 13, 13, 4, 5, 5, 5, 6, 4, 4, 6, 7,
2529 ], [
2530 3, 4, 5, 4, 6, 10, 14, 7, 6, 3, 3, 5, 5, 7, 9, 11,
2531 14, 14, 14, 14, 14, 14, 14, 4, 5, 5, 6, 6, 4, 3, 7, 8,
2532 ], [
2533 3, 4, 4, 4, 6, 9, 13, 8, 7, 3, 3, 5, 5, 7, 10, 14,
2534 14, 13, 13, 13, 13, 13, 13, 4, 5, 6, 6, 6, 4, 3, 8, 8,
2535 ], [
2536 3, 4, 4, 3, 5, 9, 13, 10, 9, 2, 3, 6, 6, 10, 13, 13,
2537 13, 14, 14, 14, 14, 13, 13, 5, 6, 7, 6, 6, 5, 4, 11, 11,
2538 ], [
2539 2, 4, 5, 4, 6, 9, 13, 14, 14, 2, 2, 7, 7, 14, 14, 14,
2540 14, 14, 14, 14, 14, 14, 14, 9, 9, 10, 8, 8, 6, 5, 14, 14,
2541 ]
2542];
2543
6543b6f8 2544const VP31_AC_CAT3_CODES: [[u16; 32]; 16] = [
5b24175d
KS		 2545 [
2546 0x0000, 0x0010, 0x0072, 0x0071, 0x0154, 0x0AAB, 0x0AA8, 0x0014,
2547 0x0070, 0x0002, 0x0003, 0x000C, 0x000B, 0x0003, 0x0011, 0x0073,
2548 0x0054, 0x00AB, 0x02AB, 0x1553, 0x1552, 0x1555, 0x1554, 0x000D,
2549 0x001E, 0x0012, 0x003E, 0x002B, 0x0002, 0x003F, 0x001D, 0x0013,
2550 ], [
2551 0x0003, 0x001F, 0x0029, 0x003D, 0x000C, 0x0069, 0x0345, 0x0002,
2552 0x0028, 0x0002, 0x0001, 0x000E, 0x000C, 0x0015, 0x0007, 0x001B,
2553 0x006B, 0x006A, 0x0344, 0x0347, 0x0346, 0x01A1, 0x01A0, 0x000B,
2554 0x001A, 0x0012, 0x0000, 0x003C, 0x0008, 0x001B, 0x0013, 0x0001,
2555 ], [
2556 0x0004, 0x0004, 0x003F, 0x0014, 0x0056, 0x015C, 0x15D5, 0x003C,
2557 0x002A, 0x0000, 0x0001, 0x000E, 0x000D, 0x000C, 0x00AF, 0x02BB,
2558 0x15D4, 0x15D7, 0x15D6, 0x15D1, 0x15D0, 0x15D3, 0x15D2, 0x000B,
2559 0x0019, 0x000D, 0x003E, 0x0031, 0x0007, 0x0005, 0x003D, 0x0030,
2560 ], [
2561 0x0005, 0x0008, 0x001A, 0x0000, 0x0036, 0x0011, 0x0106, 0x000A,
2562 0x006E, 0x0002, 0x0003, 0x0003, 0x0002, 0x006F, 0x0021, 0x020F,
2563 0x020E, 0x0101, 0x0100, 0x0103, 0x0102, 0x0105, 0x0104, 0x000C,
2564 0x001E, 0x0003, 0x003E, 0x003F, 0x0009, 0x000E, 0x000B, 0x0009,
2565 ], [
2566 0x0002, 0x000E, 0x001E, 0x000C, 0x001F, 0x006E, 0x00AD, 0x00AF,
2567 0x0014, 0x0004, 0x0003, 0x001A, 0x0017, 0x002A, 0x0576, 0x0AEF,
2568 0x0AEE, 0x0571, 0x0570, 0x0573, 0x0572, 0x0575, 0x0574, 0x0003,
2569 0x0016, 0x0004, 0x0036, 0x000B, 0x000A, 0x0000, 0x006F, 0x00AC,
2570 ], [
2571 0x0004, 0x0005, 0x0003, 0x0001, 0x0004, 0x002F, 0x0526, 0x1495,
2572 0x00A6, 0x0007, 0x0006, 0x002D, 0x002C, 0x1494, 0x1497, 0x1496,
2573 0x1491, 0x1490, 0x1493, 0x1492, 0x293D, 0x293C, 0x293F, 0x0000,
2574 0x0028, 0x00A5, 0x0148, 0x00A7, 0x002E, 0x0015, 0x0A4E, 0x293E,
2575 ], [
2576 0x0004, 0x0005, 0x0003, 0x0001, 0x0004, 0x002F, 0x0526, 0x1495,
2577 0x00A6, 0x0007, 0x0006, 0x002D, 0x002C, 0x1494, 0x1497, 0x1496,
2578 0x1491, 0x1490, 0x1493, 0x1492, 0x293D, 0x293C, 0x293F, 0x0000,
2579 0x0028, 0x00A5, 0x0148, 0x00A7, 0x002E, 0x0015, 0x0A4E, 0x293E,
2580 ], [
2581 0x0004, 0x0005, 0x0003, 0x0001, 0x0004, 0x002F, 0x0526, 0x1495,
2582 0x00A6, 0x0007, 0x0006, 0x002D, 0x002C, 0x1494, 0x1497, 0x1496,
2583 0x1491, 0x1490, 0x1493, 0x1492, 0x293D, 0x293C, 0x293F, 0x0000,
2584 0x0028, 0x00A5, 0x0148, 0x00A7, 0x002E, 0x0015, 0x0A4E, 0x293E,
2585 ], [
2586 0x0003, 0x0011, 0x0020, 0x0074, 0x010D, 0x0863, 0x0860, 0x000A,
2587 0x0075, 0x0001, 0x0000, 0x000B, 0x000A, 0x0018, 0x0038, 0x0042,
2588 0x010F, 0x010E, 0x0219, 0x10C3, 0x10C2, 0x10C5, 0x10C4, 0x000F,
2589 0x0004, 0x0019, 0x000B, 0x0039, 0x0009, 0x001B, 0x001A, 0x003B,
2590 ], [
2591 0x0005, 0x0001, 0x003E, 0x0001, 0x00E2, 0x1C6F, 0x38D9, 0x0039,
2592 0x001F, 0x0002, 0x0001, 0x0009, 0x0008, 0x0000, 0x0070, 0x01C7,
2593 0x038C, 0x071A, 0x38D8, 0x38DB, 0x38DA, 0x38DD, 0x38DC, 0x000D,
2594 0x001D, 0x000E, 0x003F, 0x003C, 0x000C, 0x0006, 0x003D, 0x001E,
2595 ], [
2596 0x0006, 0x000B, 0x0011, 0x001E, 0x0074, 0x03AA, 0x1D5C, 0x0001,
2597 0x0021, 0x0001, 0x0002, 0x0007, 0x0006, 0x003E, 0x00EB, 0x01D4,
2598 0x0EAF, 0x3ABB, 0x3ABA, 0x1D59, 0x1D58, 0x1D5B, 0x1D5A, 0x000A,
2599 0x001C, 0x0001, 0x003F, 0x003B, 0x0001, 0x0009, 0x0020, 0x0000,
2600 ], [
2601 0x0004, 0x000A, 0x0017, 0x0004, 0x0016, 0x016A, 0x16B1, 0x0017,
2602 0x005B, 0x0006, 0x0007, 0x0001, 0x0000, 0x000A, 0x02D7, 0x0B5A,
2603 0x16B0, 0x16B3, 0x16B2, 0x2D6D, 0x2D6C, 0x2D6F, 0x2D6E, 0x0006,
2604 0x000A, 0x0004, 0x002C, 0x0017, 0x0003, 0x0007, 0x0016, 0x00B4,
2605 ], [
2606 0x0005, 0x000D, 0x0005, 0x0009, 0x0033, 0x0193, 0x192C, 0x0061,
2607 0x0031, 0x0000, 0x0007, 0x0010, 0x0011, 0x00C8, 0x192F, 0x325B,
2608 0x325A, 0x1929, 0x1928, 0x192B, 0x192A, 0x325D, 0x325C, 0x0018,
2609 0x001A, 0x001B, 0x0065, 0x0019, 0x0004, 0x0007, 0x0060, 0x0324,
2610 ], [
2611 0x0006, 0x0000, 0x0002, 0x000F, 0x0039, 0x01D9, 0x1D82, 0x0761,
2612 0x03BE, 0x0001, 0x0002, 0x000F, 0x000E, 0x0762, 0x3B07, 0x3B06,
2613 0x3B1D, 0x3B1C, 0x3B1F, 0x3B1E, 0x3B19, 0x3B18, 0x3B1B, 0x0038,
2614 0x01DE, 0x00ED, 0x03BF, 0x00EE, 0x003A, 0x0006, 0x0EC0, 0x3B1A,
2615 ], [
2616 0x0000, 0x0002, 0x000F, 0x0006, 0x001C, 0x01D0, 0x0E8C, 0x1D1B,
2617 0x1D1A, 0x0003, 0x0002, 0x00EA, 0x00E9, 0x0E89, 0x0E88, 0x0E8B,
2618 0x0E8A, 0x1D65, 0x1D64, 0x1D67, 0x1D66, 0x1D61, 0x1D60, 0x03AD,
2619 0x1D63, 0x1D62, 0x1D1D, 0x1D1C, 0x003B, 0x01D7, 0x1D1F, 0x1D1E,
2620 ], [
2621 0x0002, 0x000F, 0x001C, 0x000C, 0x003B, 0x01AC, 0x1AD8, 0x35B3,
2622 0x35B2, 0x0001, 0x0000, 0x0069, 0x0068, 0x35BD, 0x35BC, 0x35BF,
2623 0x35BE, 0x35B9, 0x35B8, 0x35BB, 0x35BA, 0x35B5, 0x35B4, 0x01A9,
2624 0x01A8, 0x035A, 0x00D7, 0x00D5, 0x003A, 0x001B, 0x35B7, 0x35B6,
2625 ]
2626];
2627
6543b6f8 2628const VP31_AC_CAT3_BITS: [[u8; 32]; 16] = [
5b24175d
KS		 2629 [
2630 3, 5, 7, 7, 9, 12, 12, 5, 7, 3, 3, 4, 4, 4, 5, 7,
2631 7, 8, 10, 13, 13, 13, 13, 4, 5, 5, 6, 6, 4, 6, 5, 5,
2632 ], [
2633 3, 5, 6, 6, 7, 10, 13, 5, 6, 3, 3, 4, 4, 5, 6, 8,
2634 10, 10, 13, 13, 13, 12, 12, 4, 5, 5, 5, 6, 4, 5, 5, 5,
2635 ], [
2636 3, 4, 6, 5, 7, 9, 13, 6, 6, 3, 3, 4, 4, 5, 8, 10,
2637 13, 13, 13, 13, 13, 13, 13, 4, 5, 5, 6, 6, 4, 4, 6, 6,
2638 ], [
2639 3, 4, 5, 4, 6, 8, 12, 7, 7, 3, 3, 4, 4, 7, 9, 13,
2640 13, 12, 12, 12, 12, 12, 12, 4, 5, 5, 6, 6, 4, 4, 7, 7,
2641 ], [
2642 3, 4, 5, 4, 5, 7, 10, 10, 7, 3, 3, 5, 5, 8, 13, 14,
2643 14, 13, 13, 13, 13, 13, 13, 4, 5, 5, 6, 6, 4, 3, 7, 10,
2644 ], [
2645 3, 4, 3, 3, 4, 6, 11, 13, 8, 3, 3, 6, 6, 13, 13, 13,
2646 13, 13, 13, 13, 14, 14, 14, 3, 6, 8, 9, 8, 6, 5, 12, 14,
2647 ], [
2648 3, 4, 3, 3, 4, 6, 11, 13, 8, 3, 3, 6, 6, 13, 13, 13,
2649 13, 13, 13, 13, 14, 14, 14, 3, 6, 8, 9, 8, 6, 5, 12, 14,
2650 ], [
2651 3, 4, 3, 3, 4, 6, 11, 13, 8, 3, 3, 6, 6, 13, 13, 13,
2652 13, 13, 13, 13, 14, 14, 14, 3, 6, 8, 9, 8, 6, 5, 12, 14,
2653 ], [
2654 3, 5, 6, 7, 9, 12, 12, 5, 7, 3, 3, 4, 4, 5, 6, 7,
2655 9, 9, 10, 13, 13, 13, 13, 4, 4, 5, 5, 6, 4, 5, 5, 6,
2656 ], [
2657 3, 4, 6, 5, 8, 13, 14, 6, 6, 3, 3, 4, 4, 5, 7, 9,
2658 10, 11, 14, 14, 14, 14, 14, 4, 5, 5, 6, 6, 4, 4, 6, 6,
2659 ], [
2660 3, 4, 5, 5, 7, 10, 13, 6, 6, 3, 3, 4, 4, 6, 8, 9,
2661 12, 14, 14, 13, 13, 13, 13, 4, 5, 5, 6, 6, 4, 4, 6, 6,
2662 ], [
2663 3, 4, 5, 4, 6, 9, 13, 7, 7, 3, 3, 4, 4, 6, 10, 12,
2664 13, 13, 13, 14, 14, 14, 14, 4, 5, 5, 6, 6, 4, 4, 7, 8,
2665 ], [
2666 3, 4, 4, 4, 6, 9, 13, 8, 7, 2, 3, 5, 5, 8, 13, 14,
2667 14, 13, 13, 13, 13, 14, 14, 5, 6, 6, 7, 6, 4, 4, 8, 10,
2668 ], [
2669 3, 3, 4, 4, 6, 9, 13, 11, 10, 2, 2, 6, 6, 11, 14, 14,
2670 14, 14, 14, 14, 14, 14, 14, 6, 9, 8, 10, 8, 6, 5, 12, 14,
2671 ], [
2672 2, 3, 5, 4, 6, 10, 13, 14, 14, 2, 2, 9, 9, 13, 13, 13,
2673 13, 14, 14, 14, 14, 14, 14, 11, 14, 14, 14, 14, 7, 10, 14, 14,
2674 ], [
2675 2, 4, 5, 4, 6, 9, 13, 14, 14, 2, 2, 7, 7, 14, 14, 14,
2676 14, 14, 14, 14, 14, 14, 14, 9, 9, 10, 8, 8, 6, 5, 14, 14,
2677 ]
2678];
2679
6543b6f8 2680const VP31_DC_WEIGHTS: [[i16; 5]; 16] = [
5b24175d
KS		 2681 [ 0, 0, 0, 0, 0 ],
2682 [ 1, 0, 0, 0, 1 ],
2683 [ 0, 1, 0, 0, 1 ],
2684 [ 1, 0, 0, 0, 1 ],
2685
2686 [ 0, 0, 1, 0, 1 ],
2687 [ 1, 0, 1, 0, 2 ],
2688 [ 0, 0, 1, 0, 1 ],
2689 [ 29, -26, 29, 0, 32 ],
2690
2691 [ 0, 0, 0, 1, 1 ],
2692 [ 75, 0, 0, 53, 128 ],
2693 [ 0, 1, 0, 1, 2 ],
2694 [ 75, 0, 0, 53, 128 ],
2695
2696 [ 0, 0, 1, 0, 1 ],
2697 [ 75, 0, 0, 53, 128 ],
2698 [ 0, 3, 10, 3, 16 ],
2699 [ 29, -26, 29, 0, 32 ],
2700];
3567fcdb
KS		 2701
2702const VP30_DC_SCALES: [i16; 64] = [
2703 24, 20, 20, 20, 20, 20, 20, 20,
2704 19, 19, 19, 19, 18, 18, 18, 18,
2705 17, 17, 17, 17, 16, 16, 15, 15,
2706 14, 14, 13, 13, 12, 12, 11, 11,
2707 10, 10, 9, 9, 8, 8, 7, 7,
2708 6, 6, 6, 6, 5, 5, 5, 5,
2709 4, 4, 4, 4, 3, 3, 3, 3,
2710 2, 2, 2, 2, 1, 1, 1, 1
2711];
2712
2713const VP30_AC_SCALES: [i16; 64] = [
2714 3000, 2500, 2000, 1500, 1200, 1000, 900, 800,
2715 750, 700, 650, 630, 600, 550, 500, 450,
2716 410, 380, 350, 320, 290, 260, 240, 220,
2717 200, 180, 165, 150, 140, 130, 120, 115,
2718 110, 100, 95, 90, 85, 80, 75, 70,
2719 67, 65, 63, 61, 57, 55, 53, 50,
2720 49, 46, 44, 42, 39, 36, 33, 30,
2721 27, 24, 21, 19, 17, 15, 12, 10
2722];
2723
2724const VP30_DC_CODES: [[u16; 32]; 5] = [
2725 [
2726 0x0005, 0x002D, 0x0004, 0x0009, 0x0088, 0x0225, 0x0224, 0x0005,
2727 0x0011, 0x0007, 0x0006, 0x0009, 0x000A, 0x0007, 0x0017, 0x000C,
2728 0x002C, 0x0005, 0x0008, 0x0003, 0x0012, 0x0010, 0x0113, 0x0003,
2729 0x0010, 0x0000, 0x0013, 0x001A, 0x0023, 0x0045, 0x0001, 0x001B
2730 ], [
2731 0x000B, 0x0012, 0x0029, 0x0010, 0x000D, 0x00A2, 0x0020, 0x0009,
2732 0x0050, 0x0007, 0x0006, 0x0006, 0x0005, 0x0002, 0x0008, 0x0027,
2733 0x0005, 0x0022, 0x0023, 0x0057, 0x00A3, 0x0011, 0x0021, 0x0007,
2734 0x0000, 0x0009, 0x002A, 0x0003, 0x0007, 0x0026, 0x000C, 0x0056
2735 ], [
2736 0x000D, 0x0018, 0x0009, 0x0017, 0x0033, 0x0056, 0x00F7, 0x00F1,
2737 0x007A, 0x0000, 0x0007, 0x0009, 0x0008, 0x0005, 0x000D, 0x002D,
2738 0x0010, 0x001D, 0x001C, 0x0057, 0x00CB, 0x00F6, 0x00F0, 0x0014,
2739 0x000C, 0x002C, 0x0011, 0x001F, 0x002A, 0x0064, 0x00CA, 0x0079
2740 ], [
2741 0x000F, 0x001A, 0x0013, 0x001B, 0x003B, 0x0072, 0x01D3, 0x0707,
2742 0x0E0D, 0x0001, 0x0000, 0x000C, 0x000B, 0x0008, 0x0012, 0x002A,
2743 0x0073, 0x0028, 0x0075, 0x0056, 0x0052, 0x01C0, 0x0E0C, 0x0071,
2744 0x0057, 0x00E1, 0x00A6, 0x00E8, 0x00A7, 0x03A5, 0x03A4, 0x0382
2745 ], [
2746 0x000F, 0x001B, 0x0014, 0x001D, 0x0010, 0x0073, 0x00E2, 0x023C,
2747 0x11C9, 0x0001, 0x0000, 0x000C, 0x000B, 0x0009, 0x0015, 0x0035,
2748 0x0072, 0x0034, 0x0022, 0x0070, 0x0046, 0x011D, 0x11C8, 0x01C7,
2749 0x01C6, 0x0238, 0x047E, 0x023E, 0x0473, 0x08E5, 0x023D, 0x047F
2750 ]
2751];
2752const VP30_DC_BITS: [[u8; 32]; 5] = [
2753 [
2754 4, 6, 6, 6, 8, 10, 10, 6, 7, 3, 3, 4, 4, 4, 5, 5,
2755 6, 5, 5, 5, 6, 7, 9, 4, 5, 5, 6, 6, 6, 7, 5, 6
2756 ], [
2757 4, 5, 6, 5, 6, 8, 9, 7, 7, 3, 3, 4, 4, 4, 5, 6,
2758 6, 6, 6, 7, 8, 8, 9, 4, 4, 5, 6, 5, 5, 6, 6, 7
2759 ], [
2760 4, 5, 5, 5, 6, 7, 9, 9, 8, 2, 3, 4, 4, 4, 5, 6,
2761 6, 6, 6, 7, 8, 9, 9, 5, 5, 6, 6, 6, 6, 7, 8, 8
2762 ], [
2763 4, 5, 5, 5, 6, 7, 9, 11, 12, 2, 2, 4, 4, 4, 5, 6,
2764 7, 6, 7, 7, 7, 9, 12, 7, 7, 8, 8, 8, 8, 10, 10, 10
2765 ], [
2766 4, 5, 5, 5, 5, 7, 8, 10, 13, 2, 2, 4, 4, 4, 5, 6,
2767 7, 6, 6, 7, 7, 9, 13, 9, 9, 10, 11, 10, 11, 12, 10, 11
2768 ]
2769];
2770const VP30_AC_INTRA_CODES: [[u16; 32]; 5] = [
2771 [
2772 0x0008, 0x0033, 0x0008, 0x004B, 0x0089, 0x0221, 0x0220, 0x001F,
2773 0x0045, 0x0000, 0x000E, 0x000B, 0x000A, 0x000D, 0x0006, 0x001E,
2774 0x000A, 0x0018, 0x0013, 0x0005, 0x0009, 0x0046, 0x0111, 0x0007,
2775 0x000B, 0x0032, 0x0010, 0x004A, 0x0024, 0x0047, 0x0003, 0x0009
2776 ], [
2777 0x000E, 0x000E, 0x007B, 0x001E, 0x007E, 0x03EF, 0x07DD, 0x0018,
2778 0x00FA, 0x0002, 0x0000, 0x000A, 0x0008, 0x000B, 0x0003, 0x0012,
2779 0x0033, 0x000C, 0x003C, 0x001A, 0x007F, 0x01F6, 0x07DC, 0x000D,
2780 0x0013, 0x0004, 0x001B, 0x007A, 0x0032, 0x007C, 0x001F, 0x0005
2781 ], [
2782 0x0000, 0x0018, 0x0034, 0x000C, 0x006A, 0x01F9, 0x07EA, 0x0016,
2783 0x0FD7, 0x0002, 0x0001, 0x000A, 0x0009, 0x0007, 0x001B, 0x003E,
2784 0x0020, 0x0021, 0x006B, 0x01FB, 0x03F4, 0x1FAD, 0x1FAC, 0x000E,
2785 0x0019, 0x0011, 0x002F, 0x007F, 0x002E, 0x01F8, 0x001E, 0x000D
2786 ], [
2787 0x000E, 0x0016, 0x002E, 0x0003, 0x006E, 0x008B, 0x0113, 0x0018,
2788 0x0221, 0x0001, 0x0002, 0x000A, 0x0009, 0x0007, 0x001A, 0x0002,
2789 0x001B, 0x0023, 0x006F, 0x008A, 0x0111, 0x0441, 0x0440, 0x000F,
2790 0x0019, 0x0010, 0x0036, 0x001A, 0x002F, 0x0112, 0x0000, 0x000C
2791 ], [
2792 0x000E, 0x000F, 0x001B, 0x0033, 0x005A, 0x00B6, 0x0008, 0x001A,
2793 0x004D, 0x0001, 0x0002, 0x000A, 0x0009, 0x0008, 0x001B, 0x0003,
2794 0x002C, 0x002E, 0x0005, 0x00B7, 0x0027, 0x0099, 0x0098, 0x000F,
2795 0x0018, 0x000E, 0x002F, 0x001A, 0x0032, 0x0012, 0x0000, 0x000C
2796 ]
2797];
2798const VP30_AC_INTRA_BITS: [[u8; 32]; 5] = [
2799 [
2800 4, 6, 6, 7, 9, 11, 11, 5, 8, 3, 4, 4, 4, 4, 4, 5,
2801 5, 5, 5, 5, 6, 8, 10, 4, 5, 6, 6, 7, 6, 8, 4, 5
2802 ], [
2803 4, 5, 7, 6, 8, 11, 12, 5, 9, 3, 3, 4, 4, 4, 4, 5,
2804 6, 5, 6, 6, 8, 10, 12, 4, 5, 5, 6, 7, 6, 8, 5, 5
2805 ], [
2806 3, 5, 6, 5, 7, 9, 11, 5, 12, 3, 3, 4, 4, 4, 5, 6,
2807 6, 6, 7, 9, 10, 13, 13, 4, 5, 5, 6, 7, 6, 9, 5, 5
2808 ], [
2809 4, 5, 6, 5, 7, 8, 9, 5, 10, 3, 3, 4, 4, 4, 5, 5,
2810 6, 6, 7, 8, 9, 11, 11, 4, 5, 5, 6, 6, 6, 9, 4, 5
2811 ], [
2812 4, 5, 6, 6, 7, 8, 7, 5, 10, 3, 3, 4, 4, 4, 5, 5,
2813 6, 6, 6, 8, 9, 11, 11, 4, 5, 5, 6, 6, 6, 8, 4, 5
2814 ]
2815];
2816const VP30_AC_INTER_CODES: [[u16; 32]; 5] = [
2817 [
2818 0x000D, 0x0038, 0x0061, 0x0060, 0x0393, 0x1C95, 0x1C94, 0x0014,
2819 0x0073, 0x0001, 0x0000, 0x000B, 0x0009, 0x001D, 0x000E, 0x0022,
2820 0x0046, 0x0047, 0x00E5, 0x01C8, 0x0724, 0x1C97, 0x1C96, 0x000F,
2821 0x0006, 0x0019, 0x000F, 0x0031, 0x0004, 0x0010, 0x0005, 0x0015
2822 ], [
2823 0x0004, 0x001B, 0x0030, 0x0034, 0x00D5, 0x06B3, 0x3595, 0x0031,
2824 0x001A, 0x0002, 0x0001, 0x001F, 0x001E, 0x000C, 0x001B, 0x00D7,
2825 0x00D4, 0x01AD, 0x0358, 0x0D64, 0x3594, 0x3597, 0x3596, 0x0000,
2826 0x000A, 0x001D, 0x0017, 0x0039, 0x0007, 0x0019, 0x0016, 0x0038
2827 ], [
2828 0x0005, 0x0009, 0x001A, 0x001E, 0x001F, 0x00E2, 0x038E, 0x0070,
2829 0x003B, 0x0001, 0x0000, 0x0019, 0x0018, 0x001E, 0x003A, 0x01C6,
2830 0x071E, 0x0E3E, 0x1C7E, 0x71FD, 0x71FC, 0x71FF, 0x71FE, 0x0002,
2831 0x0008, 0x001D, 0x001B, 0x0039, 0x001F, 0x000D, 0x000C, 0x001C
2832 ], [
2833 0x0003, 0x000B, 0x001C, 0x000D, 0x0004, 0x000A, 0x0076, 0x00E8,
2834 0x01DC, 0x0001, 0x0000, 0x0033, 0x0032, 0x00E9, 0x03BB, 0x0774,
2835 0x1DD5, 0x3BAD, 0x3BAC, 0x3BAF, 0x3BAE, 0x3BA9, 0x3BA8, 0x0004,
2836 0x000A, 0x001F, 0x001E, 0x0030, 0x000B, 0x0075, 0x0031, 0x00EF
2837 ], [
2838 0x0009, 0x001E, 0x000F, 0x000E, 0x000C, 0x0008, 0x0001, 0x00E3,
2839 0x00E2, 0x0002, 0x0000, 0x003A, 0x0039, 0x0070, 0x01DC, 0x0776,
2840 0x0775, 0x0EEF, 0x0EE8, 0x1DD3, 0x1DD2, 0x1DDD, 0x1DDC, 0x0005,
2841 0x001F, 0x001B, 0x0006, 0x006A, 0x0034, 0x0076, 0x006B, 0x00EF
2842 ]
2843];
2844const VP30_AC_INTER_BITS: [[u8; 32]; 5] = [
2845 [
2846 4, 6, 7, 7, 10, 13, 13, 5, 7, 3, 3, 4, 4, 5, 5, 6,
2847 7, 7, 8, 9, 11, 13, 13, 4, 4, 5, 5, 6, 4, 5, 4, 5
2848 ], [
2849 3, 5, 6, 6, 8, 11, 14, 6, 6, 3, 3, 5, 5, 5, 6, 8,
2850 8, 9, 10, 12, 14, 14, 14, 3, 4, 5, 5, 6, 4, 5, 5, 6
2851 ], [
2852 3, 4, 5, 5, 6, 8, 10, 7, 7, 3, 3, 5, 5, 6, 7, 9,
2853 11, 12, 13, 15, 15, 15, 15, 3, 4, 5, 5, 6, 5, 5, 5, 6
2854 ], [
2855 3, 4, 5, 4, 4, 5, 7, 8, 9, 3, 3, 6, 6, 8, 10, 11,
2856 13, 14, 14, 14, 14, 14, 14, 3, 4, 5, 5, 6, 5, 7, 6, 8
2857 ], [
2858 4, 5, 5, 4, 4, 4, 3, 9, 9, 3, 3, 7, 7, 8, 10, 12,
2859 12, 13, 13, 14, 14, 14, 14, 3, 5, 5, 4, 7, 6, 8, 7, 9
2860 ]
2861];
2862const VP30_MBTYPE_CODES: [u8; 7] = [ 0x00, 0x08, 0x0A, 0x03, 0x0B, 0x13, 0x12 ];
2863const VP30_MBTYPE_BITS: [u8; 7] = [ 1, 4, 4, 2, 4, 5, 5 ];
2864const VP30_MBTYPE_SYMS: [VPMBType; 7] = [
2865 VPMBType::InterNoMV, VPMBType::Intra, VPMBType::InterMV, VPMBType::InterNearest,
2866 VPMBType::GoldenNoMV, VPMBType::GoldenMV, VPMBType::InterFourMV
2867];
8e4b2f44
KS		 2868
2869const VP40_DC_CODES: [[u32; 32]; 16] = [
2870 [
2871 0x000C, 0x0070, 0x01CA, 0x01CB, 0x0391, 0x1C9B, 0x3935, 0x0071,
2872 0x3934, 0x000B, 0x000F, 0x0019, 0x0002, 0x0009, 0x0003, 0x001D,
2873 0x0018, 0x0007, 0x000D, 0x0002, 0x0000, 0x000A, 0x0008, 0x001A,
2874 0x0073, 0x006F, 0x0E4C, 0x0727, 0x0392, 0x0390, 0x0036, 0x006E
2875 ], [
2876 0x0011, 0x007A, 0x0083, 0x0040, 0x0105, 0x0413, 0x0410, 0x007B,
2877 0x0822, 0x000E, 0x0002, 0x0002, 0x0006, 0x000A, 0x0007, 0x001F,
2878 0x0017, 0x0009, 0x000D, 0x0000, 0x000C, 0x0003, 0x003C, 0x002C,
2879 0x0021, 0x0169, 0x0412, 0x02D0, 0x02D1, 0x0823, 0x005B, 0x00B5
2880 ], [
2881 0x0017, 0x0010, 0x00B6, 0x0022, 0x016A, 0x02D0, 0x0B48, 0x0077,
2882 0x1692, 0x0000, 0x0003, 0x0003, 0x0009, 0x000C, 0x0005, 0x0002,
2883 0x001C, 0x0008, 0x000D, 0x000F, 0x000A, 0x0009, 0x0023, 0x003A,
2884 0x002C, 0x016B, 0x05A5, 0x02D3, 0x02D1, 0x1693, 0x0076, 0x00B7
2885 ], [
2886 0x001E, 0x0013, 0x00FB, 0x007C, 0x0046, 0x07D6, 0x0FA9, 0x0012,
2887 0x1F50, 0x0001, 0x0004, 0x0005, 0x000A, 0x000E, 0x0007, 0x0000,
2888 0x0017, 0x0006, 0x000D, 0x000C, 0x0001, 0x002C, 0x008F, 0x003F,
2889 0x002D, 0x01F4, 0x07D5, 0x008E, 0x07D7, 0x1F51, 0x0010, 0x0022
2890 ], [
2891 0x0001, 0x002B, 0x0012, 0x0055, 0x0027, 0x03B0, 0x0762, 0x0077,
2892 0x0261, 0x0002, 0x0006, 0x0007, 0x000B, 0x000F, 0x0008, 0x0000,
2893 0x001C, 0x0003, 0x0009, 0x0006, 0x0014, 0x0054, 0x0131, 0x0005,
2894 0x003A, 0x01D9, 0x0099, 0x004D, 0x0763, 0x0260, 0x0008, 0x00ED
2895 ], [
2896 0x0004, 0x0033, 0x0060, 0x0065, 0x00C2, 0x030D, 0x0619, 0x0064,
2897 0x1862, 0x0004, 0x0007, 0x000A, 0x000B, 0x000D, 0x0006, 0x0000,
2898 0x000F, 0x0003, 0x0005, 0x0002, 0x0002, 0x0077, 0x0C30, 0x0003,
2899 0x0031, 0x0187, 0x01D9, 0x00ED, 0x01D8, 0x1863, 0x001C, 0x003A
2900 ], [
2901 0x0008, 0x000A, 0x006A, 0x0016, 0x001E, 0x034E, 0x069F, 0x0068,
2902 0x0D28, 0x0005, 0x0007, 0x0007, 0x000C, 0x0000, 0x0006, 0x001B,
2903 0x0012, 0x0002, 0x0004, 0x0013, 0x000E, 0x034B, 0x1A53, 0x0006,
2904 0x0017, 0x01A6, 0x069E, 0x01A4, 0x0695, 0x1A52, 0x006B, 0x001F
2905 ], [
2906 0x000E, 0x000F, 0x0017, 0x0025, 0x009F, 0x0138, 0x024B, 0x0093,
2907 0x092A, 0x0005, 0x0000, 0x0008, 0x000D, 0x000F, 0x0006, 0x0004,
2908 0x000E, 0x0019, 0x0018, 0x000A, 0x009E, 0x0494, 0x1256, 0x0026,
2909 0x0016, 0x0124, 0x04E5, 0x0273, 0x04E4, 0x1257, 0x0048, 0x009D
2910 ], [
2911 0x0004, 0x002C, 0x0050, 0x001E, 0x0071, 0x00E1, 0x00E0, 0x001D,
2912 0x0006, 0x0007, 0x0006, 0x0007, 0x0005, 0x0006, 0x0015, 0x0000,
2913 0x0029, 0x0002, 0x0006, 0x0001, 0x0023, 0x001F, 0x0039, 0x0009,
2914 0x0002, 0x0010, 0x0007, 0x002D, 0x002F, 0x002E, 0x0022, 0x0051
2915 ], [
2916 0x0008, 0x002F, 0x0051, 0x0050, 0x02ED, 0x05D9, 0x05D8, 0x00BA,
2917 0x005C, 0x0007, 0x0006, 0x0009, 0x0006, 0x0007, 0x0016, 0x0005,
2918 0x002B, 0x0006, 0x000A, 0x0001, 0x000F, 0x001D, 0x0177, 0x0004,
2919 0x0001, 0x0004, 0x0001, 0x002A, 0x000B, 0x0029, 0x0000, 0x001C
2920 ], [
2921 0x000A, 0x003C, 0x0074, 0x004E, 0x026D, 0x04D9, 0x04D8, 0x009A,
2922 0x004C, 0x0000, 0x0006, 0x0008, 0x0007, 0x0006, 0x0016, 0x0008,
2923 0x002E, 0x000A, 0x000B, 0x003D, 0x0024, 0x00EB, 0x0137, 0x001F,
2924 0x001C, 0x003B, 0x0012, 0x0025, 0x002F, 0x0013, 0x004F, 0x00EA
2925 ], [
2926 0x000A, 0x000A, 0x0003, 0x0016, 0x0009, 0x0021, 0x0020, 0x00B3,
2927 0x0058, 0x0007, 0x0006, 0x0007, 0x0006, 0x0004, 0x0013, 0x0002,
2928 0x0025, 0x0000, 0x0003, 0x002D, 0x005D, 0x00B2, 0x0011, 0x0008,
2929 0x0002, 0x0006, 0x0017, 0x002F, 0x0007, 0x0024, 0x005C, 0x0005
2930 ], [
2931 0x000B, 0x0013, 0x001F, 0x0031, 0x0021, 0x0295, 0x0528, 0x00A4,
2932 0x003C, 0x0000, 0x0007, 0x0006, 0x0005, 0x001B, 0x0012, 0x0032,
2933 0x001D, 0x002B, 0x0030, 0x001C, 0x003D, 0x014B, 0x0529, 0x0008,
2934 0x001A, 0x0033, 0x0011, 0x002A, 0x0009, 0x0028, 0x0053, 0x0020
2935 ], [
2936 0x000E, 0x0015, 0x0029, 0x003F, 0x004D, 0x02F1, 0x05E0, 0x0092,
2937 0x0048, 0x0000, 0x0006, 0x0006, 0x0005, 0x0004, 0x000F, 0x002E,
2938 0x001D, 0x0028, 0x0027, 0x005F, 0x00BD, 0x0179, 0x05E1, 0x0008,
2939 0x001E, 0x002D, 0x001C, 0x002C, 0x003E, 0x0025, 0x004C, 0x0093
2940 ], [
2941 0x000C, 0x0017, 0x0035, 0x0013, 0x0021, 0x00AD, 0x06F1, 0x01BD,
2942 0x00D9, 0x0000, 0x0007, 0x0007, 0x0006, 0x0004, 0x0011, 0x002A,
2943 0x006E, 0x0025, 0x0024, 0x0057, 0x00D8, 0x0379, 0x06F0, 0x0005,
2944 0x0016, 0x0029, 0x006D, 0x0028, 0x0034, 0x0020, 0x00DF, 0x00AC
2945 ], [
2946 0x0000, 0x001A, 0x0006, 0x0019, 0x0030, 0x005A, 0x018A, 0x02DD,
2947 0x018B, 0x0001, 0x0007, 0x000A, 0x0009, 0x0002, 0x0010, 0x002E,
2948 0x006E, 0x002C, 0x000E, 0x005E, 0x00C4, 0x05B9, 0x05B8, 0x0011,
2949 0x0036, 0x005F, 0x001E, 0x0063, 0x006F, 0x001F, 0x00B6, 0x016F
2950 ]
2951];
2952const VP40_DC_BITS: [[u8; 32]; 16] = [
2953 [
2954 5, 7, 9, 9, 10, 13, 14, 7, 14, 4, 4, 5, 4, 4, 4, 5,
2955 5, 4, 4, 3, 3, 4, 4, 6, 7, 8, 12, 11, 10, 10, 7, 8
2956 ], [
2957 5, 7, 8, 7, 9, 11, 11, 7, 12, 4, 3, 4, 4, 4, 4, 5,
2958 5, 4, 4, 3, 4, 4, 6, 6, 6, 9, 11, 10, 10, 12, 7, 8
2959 ], [
2960 5, 6, 8, 7, 9, 10, 12, 7, 13, 3, 3, 4, 4, 4, 4, 4,
2961 5, 4, 4, 4, 4, 5, 7, 6, 6, 9, 11, 10, 10, 13, 7, 8
2962 ], [
2963 5, 6, 8, 7, 8, 11, 12, 6, 13, 3, 3, 4, 4, 4, 4, 4,
2964 5, 4, 4, 4, 4, 6, 9, 6, 6, 9, 11, 9, 11, 13, 6, 7
2965 ], [
2966 4, 6, 7, 7, 8, 10, 11, 7, 12, 3, 3, 4, 4, 4, 4, 4,
2967 5, 4, 4, 4, 5, 7, 11, 5, 6, 9, 10, 9, 11, 12, 6, 8
2968 ], [
2969 4, 6, 7, 7, 8, 10, 11, 7, 13, 3, 3, 4, 4, 4, 4, 4,
2970 5, 4, 4, 4, 5, 8, 12, 5, 6, 9, 10, 9, 10, 13, 6, 7
2971 ], [
2972 4, 5, 7, 6, 7, 10, 11, 7, 12, 3, 3, 4, 4, 3, 4, 5,
2973 5, 4, 4, 5, 6, 10, 13, 5, 6, 9, 11, 9, 11, 13, 7, 7
2974 ], [
2975 4, 5, 6, 6, 8, 9, 10, 8, 12, 3, 2, 4, 4, 4, 4, 4,
2976 5, 5, 5, 5, 8, 11, 13, 6, 6, 9, 11, 10, 11, 13, 7, 8
2977 ], [
2978 4, 6, 7, 7, 9, 10, 10, 7, 6, 3, 3, 4, 4, 4, 5, 5,
2979 6, 5, 5, 5, 6, 7, 8, 4, 4, 5, 6, 6, 6, 6, 6, 7
2980 ], [
2981 4, 6, 7, 7, 10, 11, 11, 8, 7, 3, 3, 4, 4, 4, 5, 5,
2982 6, 5, 5, 5, 6, 7, 9, 4, 4, 5, 6, 6, 5, 6, 6, 7
2983 ], [
2984 4, 6, 7, 7, 10, 11, 11, 8, 7, 2, 3, 4, 4, 4, 5, 5,
2985 6, 5, 5, 6, 6, 8, 9, 5, 5, 6, 6, 6, 6, 6, 7, 8
2986 ], [
2987 4, 5, 6, 6, 8, 10, 10, 8, 7, 3, 3, 4, 4, 4, 5, 5,
2988 6, 5, 5, 6, 7, 8, 9, 4, 4, 5, 6, 6, 5, 6, 7, 7
2989 ], [
2990 4, 5, 6, 6, 7, 10, 11, 8, 7, 2, 3, 4, 4, 5, 5, 6,
2991 6, 6, 6, 6, 7, 9, 11, 4, 5, 6, 6, 6, 5, 6, 7, 7
2992 ], [
2993 4, 5, 6, 6, 7, 10, 11, 8, 7, 2, 3, 4, 4, 4, 5, 6,
2994 6, 6, 6, 7, 8, 9, 11, 4, 5, 6, 6, 6, 6, 6, 7, 8
2995 ], [
2996 4, 5, 6, 5, 6, 8, 11, 9, 8, 2, 3, 4, 4, 4, 5, 6,
2997 7, 6, 6, 7, 8, 10, 11, 4, 5, 6, 7, 6, 6, 6, 8, 8
2998 ], [
2999 3, 5, 5, 5, 6, 7, 9, 10, 9, 2, 3, 4, 4, 4, 5, 6,
3000 7, 6, 6, 7, 8, 11, 11, 5, 6, 7, 7, 7, 7, 7, 8, 9
3001 ]
3002];
3003const VP40_AC_CAT0_CODES: [[u32; 32]; 16] = [
3004 [
3005 0x0006, 0x001E, 0x01CC, 0x01CE, 0x0734, 0x1CD5, 0x1CD4, 0x0018,
3006 0x0E6B, 0x0000, 0x000F, 0x0006, 0x0007, 0x000D, 0x0008, 0x0002,
3007 0x0019, 0x0005, 0x000B, 0x000A, 0x001D, 0x0027, 0x01CF, 0x0004,
3008 0x0038, 0x000E, 0x004C, 0x001F, 0x004D, 0x039B, 0x0012, 0x0072
3009 ], [
3010 0x0009, 0x004B, 0x0090, 0x0091, 0x0745, 0x1D11, 0x1D10, 0x0019,
3011 0x0E89, 0x0000, 0x000F, 0x0008, 0x0007, 0x000D, 0x000B, 0x0002,
3012 0x001C, 0x0003, 0x000A, 0x0005, 0x0018, 0x0010, 0x01D0, 0x0006,
3013 0x003B, 0x0011, 0x004A, 0x0049, 0x00E9, 0x03A3, 0x0013, 0x0075
3014 ], [
3015 0x0019, 0x0074, 0x001D, 0x00EA, 0x0073, 0x01CA, 0x0396, 0x001C,
3016 0x00E4, 0x0002, 0x0001, 0x0007, 0x0008, 0x000D, 0x0009, 0x001F,
3017 0x0018, 0x0000, 0x0006, 0x001E, 0x003B, 0x00EB, 0x0397, 0x000A,
3018 0x0002, 0x002C, 0x005B, 0x005A, 0x000F, 0x0038, 0x0017, 0x0006
3019 ], [
3020 0x001E, 0x006F, 0x00AE, 0x00AF, 0x0187, 0x061B, 0x0C35, 0x001A,
3021 0x030C, 0x0002, 0x0001, 0x0007, 0x0008, 0x000E, 0x0009, 0x001F,
3022 0x0014, 0x0000, 0x0001, 0x0019, 0x002A, 0x0060, 0x0C34, 0x000B,
3023 0x000D, 0x0036, 0x006E, 0x0056, 0x0031, 0x00C2, 0x0018, 0x0019
3024 ], [
3025 0x0001, 0x002C, 0x0005, 0x0015, 0x0008, 0x0097, 0x012D, 0x0017,
3026 0x004A, 0x0003, 0x0002, 0x0009, 0x000A, 0x000E, 0x0008, 0x001F,
3027 0x0007, 0x001E, 0x001B, 0x0004, 0x005A, 0x0024, 0x012C, 0x000C,
3028 0x0006, 0x0000, 0x0003, 0x005B, 0x0014, 0x0013, 0x001A, 0x000B
3029 ], [
3030 0x0004, 0x0000, 0x0017, 0x0063, 0x018B, 0x0310, 0x0C44, 0x0019,
3031 0x0623, 0x0004, 0x0003, 0x000A, 0x000B, 0x000D, 0x0003, 0x001C,
3032 0x0003, 0x000A, 0x0004, 0x0003, 0x018A, 0x188B, 0x188A, 0x000F,
3033 0x000B, 0x0002, 0x000A, 0x0002, 0x0016, 0x0189, 0x001D, 0x0030
3034 ], [
3035 0x000D, 0x0003, 0x0077, 0x000D, 0x0082, 0x020D, 0x0830, 0x0019,
3036 0x0419, 0x0003, 0x0002, 0x000A, 0x0009, 0x000B, 0x0002, 0x0011,
3037 0x0039, 0x0002, 0x0021, 0x0040, 0x1063, 0x20C5, 0x20C4, 0x000F,
3038 0x0018, 0x0007, 0x0038, 0x000C, 0x0076, 0x0107, 0x0000, 0x003A
3039 ], [
3040 0x000F, 0x001C, 0x0036, 0x0008, 0x0061, 0x0091, 0x0243, 0x0009,
3041 0x0120, 0x0005, 0x0003, 0x0008, 0x0005, 0x0001, 0x0013, 0x0031,
3042 0x0076, 0x0060, 0x0093, 0x0909, 0x0908, 0x090B, 0x090A, 0x0001,
3043 0x001A, 0x0019, 0x003A, 0x0025, 0x0077, 0x0092, 0x0000, 0x0037
3044 ], [
3045 0x001F, 0x0079, 0x00F1, 0x00F0, 0x011B, 0x0469, 0x0468, 0x003B,
3046 0x0022, 0x0005, 0x0004, 0x0007, 0x0005, 0x0006, 0x001C, 0x0001,
3047 0x0035, 0x003D, 0x003A, 0x0010, 0x0047, 0x008C, 0x0235, 0x0001,
3048 0x0001, 0x0019, 0x0000, 0x0030, 0x0009, 0x0031, 0x001B, 0x0034
3049 ], [
3050 0x0003, 0x001B, 0x00F3, 0x00FD, 0x03C9, 0x0F20, 0x1E42, 0x003D,
3051 0x00FC, 0x0006, 0x0004, 0x0002, 0x0000, 0x0001, 0x0017, 0x003E,
3052 0x001A, 0x0039, 0x002B, 0x0078, 0x01E5, 0x0791, 0x1E43, 0x0002,
3053 0x0007, 0x001D, 0x000C, 0x0038, 0x0014, 0x007F, 0x0016, 0x002A
3054 ], [
3055 0x0007, 0x0039, 0x0051, 0x0078, 0x03CB, 0x0F29, 0x1E51, 0x003D,
3056 0x00F3, 0x0006, 0x0004, 0x0002, 0x0000, 0x0001, 0x0017, 0x003E,
3057 0x007F, 0x002B, 0x007E, 0x0050, 0x01E4, 0x0795, 0x1E50, 0x0002,
3058 0x0006, 0x001D, 0x0006, 0x0038, 0x0007, 0x0029, 0x0016, 0x002A
3059 ], [
3060 0x0008, 0x003B, 0x001D, 0x0072, 0x01CC, 0x0734, 0x1CD5, 0x003A,
3061 0x001C, 0x0006, 0x0005, 0x0002, 0x0001, 0x0000, 0x0012, 0x003E,
3062 0x007F, 0x001E, 0x007E, 0x00E7, 0x039B, 0x0E6B, 0x1CD4, 0x0002,
3063 0x0006, 0x001E, 0x000E, 0x0038, 0x0006, 0x000F, 0x0013, 0x001F
3064 ], [
3065 0x000D, 0x003F, 0x0073, 0x000C, 0x00E4, 0x072B, 0x0E54, 0x003A,
3066 0x001A, 0x0005, 0x0004, 0x0002, 0x0001, 0x0000, 0x0007, 0x0038,
3067 0x0076, 0x0077, 0x001B, 0x01CB, 0x0394, 0x1CAB, 0x1CAA, 0x0002,
3068 0x0006, 0x001E, 0x000E, 0x003E, 0x0019, 0x001F, 0x0018, 0x001E
3069 ], [
3070 0x000E, 0x0007, 0x000C, 0x001C, 0x00BD, 0x02F3, 0x0BC9, 0x001F,
3071 0x00BF, 0x0006, 0x0004, 0x0002, 0x0001, 0x001E, 0x0001, 0x000D,
3072 0x003A, 0x003B, 0x00BE, 0x0178, 0x05E5, 0x1791, 0x1790, 0x0002,
3073 0x0006, 0x001F, 0x0016, 0x0000, 0x0015, 0x002E, 0x0014, 0x001E
3074 ], [
3075 0x0000, 0x001B, 0x0031, 0x003A, 0x0060, 0x006F, 0x01B9, 0x000E,
3076 0x001A, 0x0005, 0x0003, 0x0002, 0x001F, 0x001A, 0x0039, 0x000C,
3077 0x00C3, 0x00C2, 0x0036, 0x00DD, 0x0370, 0x06E3, 0x06E2, 0x0002,
3078 0x0008, 0x001E, 0x0019, 0x003B, 0x0012, 0x000F, 0x0013, 0x0038
3079 ], [
3080 0x0002, 0x0000, 0x0003, 0x001C, 0x0032, 0x001C, 0x0199, 0x0004,
3081 0x00CD, 0x0004, 0x0003, 0x001B, 0x001A, 0x003D, 0x0067, 0x003B,
3082 0x0198, 0x0075, 0x00E9, 0x03A1, 0x03A0, 0x03A3, 0x03A2, 0x0005,
3083 0x0002, 0x001F, 0x001D, 0x003C, 0x0018, 0x000F, 0x0006, 0x0005
3084 ]
3085];
3086const VP40_AC_CAT0_BITS: [[u8; 32]; 16] = [
3087 [
3088 5, 7, 9, 9, 11, 13, 13, 5, 12, 3, 4, 4, 4, 4, 4, 4,
3089 5, 4, 4, 4, 5, 6, 9, 4, 6, 6, 7, 7, 7, 10, 5, 7
3090 ], [
3091 5, 7, 8, 8, 11, 13, 13, 5, 12, 3, 4, 4, 4, 4, 4, 4,
3092 5, 4, 4, 4, 5, 6, 9, 4, 6, 6, 7, 7, 8, 10, 5, 7
3093 ], [
3094 5, 7, 8, 8, 10, 12, 13, 5, 11, 3, 3, 4, 4, 4, 4, 5,
3095 5, 4, 4, 5, 6, 8, 13, 4, 5, 6, 7, 7, 7, 9, 5, 6
3096 ], [
3097 5, 7, 8, 8, 10, 12, 13, 5, 11, 3, 3, 4, 4, 4, 4, 5,
3098 5, 4, 4, 5, 6, 8, 13, 4, 5, 6, 7, 7, 7, 9, 5, 6
3099 ], [
3100 4, 6, 7, 7, 8, 12, 13, 5, 11, 3, 3, 4, 4, 4, 4, 5,
3101 5, 5, 5, 5, 7, 10, 13, 4, 5, 5, 6, 7, 7, 9, 5, 6
3102 ], [
3103 4, 5, 7, 7, 9, 10, 12, 5, 11, 3, 3, 4, 4, 4, 4, 5,
3104 5, 5, 5, 6, 9, 13, 13, 4, 5, 5, 6, 6, 7, 9, 5, 6
3105 ], [
3106 4, 5, 7, 6, 8, 10, 12, 5, 11, 3, 3, 4, 4, 4, 4, 5,
3107 6, 5, 6, 7, 13, 14, 14, 4, 5, 5, 6, 6, 7, 9, 4, 6
3108 ], [
3109 4, 5, 6, 5, 7, 8, 10, 5, 9, 3, 3, 4, 4, 4, 5, 6,
3110 7, 7, 8, 12, 12, 12, 12, 3, 5, 5, 6, 6, 7, 8, 4, 6
3111 ], [
3112 5, 7, 8, 8, 10, 12, 12, 6, 7, 3, 3, 4, 4, 4, 5, 5,
3113 6, 6, 6, 6, 8, 9, 11, 3, 4, 5, 5, 6, 5, 6, 5, 6
3114 ], [
3115 4, 6, 8, 8, 10, 12, 13, 6, 8, 3, 3, 4, 4, 4, 5, 6,
3116 6, 6, 6, 7, 9, 11, 13, 3, 4, 5, 5, 6, 5, 7, 5, 6
3117 ], [
3118 4, 6, 7, 7, 10, 12, 13, 6, 8, 3, 3, 4, 4, 4, 5, 6,
3119 7, 6, 7, 7, 9, 11, 13, 3, 4, 5, 5, 6, 5, 6, 5, 6
3120 ], [
3121 4, 6, 7, 7, 9, 11, 13, 6, 7, 3, 3, 4, 4, 4, 5, 6,
3122 7, 6, 7, 8, 10, 12, 13, 3, 4, 5, 5, 6, 5, 6, 5, 6
3123 ], [
3124 4, 6, 7, 6, 8, 11, 12, 6, 7, 3, 3, 4, 4, 4, 5, 6,
3125 7, 7, 7, 9, 10, 13, 13, 3, 4, 5, 5, 6, 5, 6, 5, 6
3126 ], [
3127 4, 5, 6, 6, 8, 10, 12, 6, 8, 3, 3, 4, 4, 5, 5, 6,
3128 7, 7, 8, 9, 11, 13, 13, 3, 4, 5, 5, 5, 5, 6, 5, 6
3129 ], [
3130 3, 5, 6, 6, 7, 9, 11, 6, 7, 3, 3, 4, 5, 5, 6, 6,
3131 8, 8, 8, 10, 12, 13, 13, 3, 4, 5, 5, 6, 5, 6, 5, 6
3132 ], [
3133 3, 4, 5, 5, 6, 7, 9, 6, 8, 3, 3, 5, 5, 6, 7, 8,
3134 9, 9, 10, 12, 12, 12, 12, 3, 4, 5, 5, 6, 5, 6, 5, 6
3135 ]
3136];
3137const VP40_AC_CAT1_CODES: [[u32; 32]; 16] = [
3138 [
3139 0x0004, 0x00F5, 0x0182, 0x060F, 0x1839, 0x1838, 0x183B, 0x0013,
3140 0x00C0, 0x0003, 0x0002, 0x000B, 0x000A, 0x000E, 0x0008, 0x0001,
3141 0x0012, 0x001F, 0x0000, 0x0006, 0x007B, 0x0306, 0x183A, 0x000D,
3142 0x0007, 0x0031, 0x000A, 0x0061, 0x003C, 0x00F4, 0x0019, 0x000B
3143 ], [
3144 0x000A, 0x001A, 0x01D8, 0x03B3, 0x0ECA, 0x1D96, 0x3B2F, 0x0014,
3145 0x0036, 0x0004, 0x0003, 0x000C, 0x000B, 0x0000, 0x0004, 0x001C,
3146 0x0005, 0x0015, 0x0007, 0x0017, 0x0037, 0x0764, 0x3B2E, 0x000F,
3147 0x001A, 0x003A, 0x000C, 0x0077, 0x0004, 0x00ED, 0x001B, 0x0016
3148 ], [
3149 0x001A, 0x002D, 0x0058, 0x01F4, 0x07D4, 0x1F55, 0x1F54, 0x0014,
3150 0x0059, 0x0004, 0x0003, 0x000B, 0x000C, 0x000E, 0x0004, 0x0015,
3151 0x0005, 0x0007, 0x0004, 0x007C, 0x03EB, 0x1F57, 0x1F56, 0x0000,
3152 0x001B, 0x003F, 0x000D, 0x000C, 0x000A, 0x00FB, 0x001E, 0x0017
3153 ], [
3154 0x0000, 0x0075, 0x004A, 0x0097, 0x025B, 0x0969, 0x0968, 0x000B,
3155 0x00E8, 0x0005, 0x0004, 0x0007, 0x000C, 0x000D, 0x0001, 0x000A,
3156 0x0039, 0x003B, 0x0018, 0x00E9, 0x012C, 0x096B, 0x096A, 0x0001,
3157 0x001F, 0x0008, 0x0019, 0x0013, 0x000D, 0x0024, 0x001E, 0x0038
3158 ], [
3159 0x0004, 0x0014, 0x006E, 0x0057, 0x0159, 0x0562, 0x0AC7, 0x000B,
3160 0x006F, 0x0006, 0x0005, 0x0008, 0x0009, 0x0007, 0x001E, 0x0002,
3161 0x0007, 0x0006, 0x002A, 0x00AD, 0x0AC6, 0x0561, 0x0560, 0x0001,
3162 0x001F, 0x000C, 0x0039, 0x001A, 0x0000, 0x0036, 0x001D, 0x0038
3163 ], [
3164 0x0007, 0x001B, 0x000E, 0x000D, 0x03E1, 0x1F06, 0x3E0F, 0x0002,
3165 0x00F9, 0x0005, 0x0006, 0x0008, 0x0009, 0x0004, 0x000C, 0x001A,
3166 0x000F, 0x000C, 0x01F1, 0x07C0, 0x3E0E, 0x1F05, 0x1F04, 0x0001,
3167 0x0000, 0x001C, 0x003F, 0x003D, 0x0005, 0x007D, 0x001D, 0x003C
3168 ], [
3169 0x000F, 0x000A, 0x0071, 0x0006, 0x01C2, 0x0702, 0x1C0E, 0x0002,
3170 0x000E, 0x0005, 0x0004, 0x0006, 0x0007, 0x001D, 0x0017, 0x000F,
3171 0x01C3, 0x01C1, 0x0380, 0x381F, 0x381E, 0x1C0D, 0x1C0C, 0x0001,
3172 0x0004, 0x0018, 0x0001, 0x0000, 0x000D, 0x0016, 0x0019, 0x0039
3173 ], [
3174 0x0002, 0x001E, 0x003B, 0x000D, 0x0061, 0x01FA, 0x1FB5, 0x0031,
3175 0x00FC, 0x0004, 0x0005, 0x0001, 0x0007, 0x003A, 0x0060, 0x03F7,
3176 0x07EC, 0x1FB7, 0x3F6C, 0x7EDB, 0x7EDA, 0x3F69, 0x3F68, 0x0001,
3177 0x0000, 0x0019, 0x003E, 0x0039, 0x000D, 0x0038, 0x000C, 0x007F
3178 ], [
3179 0x001E, 0x0070, 0x0127, 0x0126, 0x0492, 0x124D, 0x124C, 0x0001,
3180 0x007F, 0x0006, 0x0005, 0x0005, 0x0004, 0x0001, 0x0007, 0x0025,
3181 0x0071, 0x007E, 0x0048, 0x0125, 0x0248, 0x124F, 0x124E, 0x0003,
3182 0x0008, 0x001D, 0x0006, 0x003E, 0x0002, 0x0000, 0x0013, 0x0039
3183 ], [
3184 0x0001, 0x0001, 0x00E7, 0x0091, 0x0240, 0x120D, 0x120C, 0x003C,
3185 0x0000, 0x0006, 0x0005, 0x0005, 0x0004, 0x001F, 0x0004, 0x0025,
3186 0x0072, 0x0049, 0x00E6, 0x0121, 0x0482, 0x120F, 0x120E, 0x0003,
3187 0x0008, 0x001D, 0x0005, 0x003D, 0x0003, 0x0001, 0x0013, 0x0038
3188 ], [
3189 0x0004, 0x000F, 0x00F4, 0x005B, 0x02D3, 0x0B4A, 0x1697, 0x003C,
3190 0x000E, 0x0006, 0x0005, 0x0002, 0x0001, 0x001D, 0x0000, 0x007B,
3191 0x002C, 0x00F5, 0x00B5, 0x0168, 0x1696, 0x0B49, 0x0B48, 0x0003,
3192 0x0009, 0x001F, 0x000A, 0x0001, 0x0008, 0x0006, 0x001C, 0x0017
3193 ], [
3194 0x0008, 0x0039, 0x001A, 0x0003, 0x00DB, 0x06D6, 0x0DAF, 0x003C,
3195 0x000C, 0x0006, 0x0005, 0x0002, 0x0001, 0x001D, 0x003D, 0x0000,
3196 0x0002, 0x0037, 0x006C, 0x01B4, 0x0DAE, 0x06D5, 0x06D4, 0x0002,
3197 0x0007, 0x001F, 0x0007, 0x0001, 0x0009, 0x000D, 0x000C, 0x0038
3198 ], [
3199 0x000F, 0x0004, 0x002F, 0x002E, 0x0054, 0x0555, 0x0554, 0x0016,
3200 0x000E, 0x0006, 0x0005, 0x0001, 0x0000, 0x0009, 0x000B, 0x0014,
3201 0x0057, 0x0056, 0x00AB, 0x0557, 0x0556, 0x02A9, 0x02A8, 0x0003,
3202 0x0008, 0x0013, 0x000A, 0x0008, 0x000E, 0x0012, 0x0006, 0x000F
3203 ], [
3204 0x0001, 0x000E, 0x0006, 0x0004, 0x00DA, 0x0DBE, 0x1B7E, 0x0007,
3205 0x001A, 0x0005, 0x0004, 0x001C, 0x001B, 0x003A, 0x0037, 0x006C,
3206 0x01B6, 0x036E, 0x0DBD, 0x36FF, 0x36FE, 0x1B79, 0x1B78, 0x0002,
3207 0x000C, 0x0000, 0x000F, 0x000C, 0x000F, 0x001A, 0x003B, 0x0005
3208 ], [
3209 0x0005, 0x001E, 0x003A, 0x003E, 0x00FC, 0x0FD7, 0x3F55, 0x0077,
3210 0x0030, 0x0003, 0x0004, 0x001A, 0x0019, 0x007F, 0x01FB, 0x03F4,
3211 0x0FD6, 0x1FA9, 0x3F54, 0x3F57, 0x3F56, 0x3F51, 0x3F50, 0x0001,
3212 0x0004, 0x001C, 0x000B, 0x000A, 0x0000, 0x001B, 0x0031, 0x0076
3213 ], [
3214 0x0005, 0x000C, 0x001B, 0x0008, 0x0038, 0x0015, 0x00A3, 0x00E6,
3215 0x0004, 0x0001, 0x0002, 0x0012, 0x0003, 0x000B, 0x0029, 0x00A0,
3216 0x0142, 0x0287, 0x0286, 0x0289, 0x0288, 0x028B, 0x028A, 0x000F,
3217 0x001D, 0x0013, 0x0001, 0x0000, 0x0003, 0x001A, 0x0072, 0x00E7
3218 ]
3219];
3220const VP40_AC_CAT1_BITS: [[u8; 32]; 16] = [
3221 [
3222 5, 8, 9, 11, 13, 13, 13, 5, 8, 3, 3, 4, 4, 4, 4, 4,
3223 5, 5, 4, 5, 7, 10, 13, 4, 5, 6, 6, 7, 6, 8, 5, 6
3224 ], [
3225 5, 7, 9, 10, 12, 13, 14, 5, 8, 3, 3, 4, 4, 3, 4, 5,
3226 5, 5, 5, 6, 8, 11, 14, 4, 5, 6, 6, 7, 5, 8, 5, 6
3227 ], [
3228 5, 7, 8, 9, 11, 13, 13, 5, 8, 3, 3, 4, 4, 4, 4, 5,
3229 5, 5, 5, 7, 10, 13, 13, 3, 5, 6, 6, 6, 5, 8, 5, 6
3230 ], [
3231 4, 7, 8, 9, 11, 13, 13, 5, 8, 3, 3, 4, 4, 4, 4, 5,
3232 6, 6, 6, 8, 10, 13, 13, 3, 5, 5, 6, 6, 5, 7, 5, 6
3233 ], [
3234 4, 6, 8, 8, 10, 12, 13, 5, 8, 3, 3, 4, 4, 4, 5, 5,
3235 6, 6, 7, 9, 13, 12, 12, 3, 5, 5, 6, 6, 4, 7, 5, 6
3236 ], [
3237 4, 6, 7, 7, 10, 13, 14, 5, 8, 3, 3, 4, 4, 4, 5, 6,
3238 7, 7, 9, 11, 14, 13, 13, 3, 4, 5, 6, 6, 4, 7, 5, 6
3239 ], [
3240 4, 5, 7, 6, 9, 11, 13, 5, 7, 3, 3, 4, 4, 5, 6, 7,
3241 9, 9, 10, 14, 14, 13, 13, 3, 4, 5, 5, 5, 4, 6, 5, 6
3242 ], [
3243 3, 5, 6, 5, 7, 9, 13, 6, 8, 3, 3, 4, 4, 6, 7, 10,
3244 11, 13, 14, 15, 15, 14, 14, 3, 4, 5, 6, 6, 4, 6, 5, 7
3245 ], [
3246 5, 7, 9, 9, 11, 13, 13, 5, 7, 3, 3, 4, 4, 4, 5, 6,
3247 7, 7, 7, 9, 10, 13, 13, 3, 4, 5, 5, 6, 4, 5, 5, 6
3248 ], [
3249 4, 6, 8, 8, 10, 13, 13, 6, 6, 3, 3, 4, 4, 5, 5, 6,
3250 7, 7, 8, 9, 11, 13, 13, 3, 4, 5, 5, 6, 4, 5, 5, 6
3251 ], [
3252 4, 6, 8, 8, 11, 13, 14, 6, 6, 3, 3, 4, 4, 5, 5, 7,
3253 7, 8, 9, 10, 14, 13, 13, 3, 4, 5, 5, 5, 4, 5, 5, 6
3254 ], [
3255 4, 6, 7, 7, 10, 13, 14, 6, 6, 3, 3, 4, 4, 5, 6, 6,
3256 7, 8, 9, 11, 14, 13, 13, 3, 4, 5, 5, 5, 4, 5, 5, 6
3257 ], [
3258 4, 5, 7, 7, 9, 13, 13, 6, 6, 3, 3, 4, 4, 5, 6, 7,
3259 9, 9, 10, 13, 13, 12, 12, 3, 4, 5, 5, 5, 4, 5, 5, 6
3260 ], [
3261 3, 5, 6, 6, 9, 13, 14, 6, 6, 3, 3, 5, 5, 6, 7, 8,
3262 10, 11, 13, 15, 15, 14, 14, 3, 4, 4, 5, 5, 4, 5, 6, 6
3263 ], [
3264 3, 5, 6, 6, 8, 12, 14, 7, 6, 3, 3, 5, 5, 7, 9, 10,
3265 12, 13, 14, 14, 14, 14, 14, 3, 4, 5, 5, 5, 3, 5, 6, 7
3266 ], [
3267 3, 4, 5, 4, 6, 8, 11, 8, 6, 3, 3, 5, 5, 7, 9, 11,
3268 12, 13, 13, 13, 13, 13, 13, 4, 5, 5, 5, 5, 3, 5, 7, 8
3269 ]
3270];
3271const VP40_AC_CAT2_CODES: [[u32; 32]; 16] = [
3272 [
3273 0x0009, 0x0015, 0x0028, 0x0052, 0x029A, 0x0537, 0x0536, 0x000A,
3274 0x0054, 0x0004, 0x0003, 0x000C, 0x000B, 0x000D, 0x0003, 0x0014,
3275 0x003A, 0x0004, 0x0038, 0x0055, 0x00A7, 0x0299, 0x0298, 0x0000,
3276 0x001E, 0x0008, 0x002B, 0x000B, 0x000B, 0x003B, 0x001F, 0x0039
3277 ], [
3278 0x001D, 0x002F, 0x0002, 0x0007, 0x0019, 0x0035, 0x0034, 0x0009,
3279 0x002E, 0x0006, 0x0005, 0x0009, 0x0008, 0x0007, 0x001F, 0x0008,
3280 0x0018, 0x0019, 0x0001, 0x0000, 0x0018, 0x0037, 0x0036, 0x0001,
3281 0x0001, 0x000A, 0x0039, 0x0016, 0x000D, 0x0001, 0x001E, 0x0038
3282 ], [
3283 0x0001, 0x0071, 0x00E0, 0x01C3, 0x0708, 0x1C26, 0x384F, 0x0001,
3284 0x0031, 0x0006, 0x0005, 0x0009, 0x0008, 0x0005, 0x000F, 0x0039,
3285 0x0077, 0x0076, 0x0030, 0x0385, 0x384E, 0x1C25, 0x1C24, 0x0001,
3286 0x0004, 0x000D, 0x0000, 0x0019, 0x001F, 0x000E, 0x001E, 0x003A
3287 ], [
3288 0x0006, 0x000C, 0x00D6, 0x007B, 0x01E8, 0x07A4, 0x0F4B, 0x0036,
3289 0x006A, 0x0007, 0x0005, 0x0008, 0x0009, 0x0001, 0x0007, 0x000D,
3290 0x003C, 0x00D7, 0x00F5, 0x07A7, 0x0F4A, 0x0F4D, 0x0F4C, 0x0002,
3291 0x0002, 0x000E, 0x0037, 0x0034, 0x0000, 0x0019, 0x0018, 0x001F
3292 ], [
3293 0x000A, 0x0027, 0x00BF, 0x00BE, 0x0224, 0x225D, 0x225C, 0x0026,
3294 0x005E, 0x0007, 0x0006, 0x0006, 0x0007, 0x0016, 0x002E, 0x0045,
3295 0x0088, 0x0113, 0x044A, 0x225F, 0x225E, 0x112D, 0x112C, 0x0002,
3296 0x0002, 0x0012, 0x0003, 0x0002, 0x0003, 0x0000, 0x0010, 0x0023
3297 ], [
3298 0x000F, 0x0006, 0x0075, 0x0074, 0x000A, 0x00BF, 0x00B9, 0x0022,
3299 0x0003, 0x0005, 0x0006, 0x0001, 0x0002, 0x0007, 0x0000, 0x0004,
3300 0x0016, 0x005E, 0x00B8, 0x00BB, 0x00BA, 0x017D, 0x017C, 0x0002,
3301 0x0006, 0x001C, 0x0010, 0x003B, 0x0009, 0x0007, 0x0001, 0x0023
3302 ], [
3303 0x0001, 0x001C, 0x0036, 0x003B, 0x00EA, 0x075B, 0x1D65, 0x0019,
3304 0x0074, 0x0004, 0x0005, 0x0000, 0x0001, 0x0037, 0x01D7, 0x075A,
3305 0x1D64, 0x1D67, 0x1D66, 0x1D61, 0x1D60, 0x1D63, 0x1D62, 0x0002,
3306 0x001F, 0x001A, 0x000D, 0x003D, 0x000C, 0x0007, 0x003C, 0x0018
3307 ], [
3308 0x0002, 0x0001, 0x0014, 0x0000, 0x002F, 0x00BB, 0x02E4, 0x007D,
3309 0x00BA, 0x0003, 0x0004, 0x0016, 0x001A, 0x00B8, 0x172E, 0x2E5F,
3310 0x2E5E, 0x1729, 0x1728, 0x172B, 0x172A, 0x172D, 0x172C, 0x0001,
3311 0x001E, 0x0015, 0x001B, 0x003F, 0x000C, 0x000E, 0x007C, 0x0173
3312 ], [
3313 0x0003, 0x007B, 0x0058, 0x01EA, 0x1EB1, 0x1EB0, 0x1EB3, 0x0013,
3314 0x0012, 0x0005, 0x0006, 0x0002, 0x0001, 0x0013, 0x003C, 0x002D,
3315 0x00F4, 0x0059, 0x03D7, 0x0F5B, 0x1EB2, 0x1EB5, 0x1EB4, 0x0003,
3316 0x000E, 0x001F, 0x0012, 0x0008, 0x0008, 0x0000, 0x000A, 0x0017
3317 ], [
3318 0x0008, 0x003C, 0x00F5, 0x00F4, 0x1EF7, 0x3DE9, 0x3DE8, 0x001C,
3319 0x000D, 0x0005, 0x0006, 0x0001, 0x0000, 0x0007, 0x000C, 0x00F6,
3320 0x01EE, 0x03DF, 0x07BC, 0x3DEB, 0x3DEA, 0x3DED, 0x3DEC, 0x0002,
3321 0x0009, 0x001F, 0x000F, 0x0005, 0x000E, 0x0006, 0x0004, 0x001D
3322 ], [
3323 0x0009, 0x0039, 0x0019, 0x0018, 0x0706, 0x383D, 0x383C, 0x000D,
3324 0x000F, 0x0005, 0x0006, 0x0000, 0x001D, 0x0003, 0x0071, 0x00E1,
3325 0x01C0, 0x0382, 0x1C1D, 0x383F, 0x383E, 0x3839, 0x3838, 0x0002,
3326 0x0008, 0x0002, 0x000D, 0x000C, 0x000F, 0x0007, 0x0002, 0x000E
3327 ], [
3328 0x0000, 0x0006, 0x0035, 0x0034, 0x0777, 0x1DD4, 0x3BAB, 0x000E,
3329 0x000F, 0x0005, 0x0004, 0x001C, 0x0019, 0x003A, 0x00EF, 0x01DC,
3330 0x0776, 0x0774, 0x3BAA, 0x3BAD, 0x3BAC, 0x3BAF, 0x3BAE, 0x0002,
3331 0x0007, 0x0002, 0x0018, 0x000C, 0x000F, 0x000D, 0x001B, 0x0076
3332 ], [
3333 0x0002, 0x0011, 0x0006, 0x004F, 0x0130, 0x1319, 0x1318, 0x004E,
3334 0x0007, 0x0006, 0x0005, 0x0010, 0x000D, 0x0005, 0x0099, 0x0262,
3335 0x098E, 0x131B, 0x131A, 0x263D, 0x263C, 0x263F, 0x263E, 0x0001,
3336 0x0007, 0x0000, 0x0012, 0x000C, 0x000E, 0x000F, 0x0004, 0x004D
3337 ], [
3338 0x0003, 0x0000, 0x0002, 0x0037, 0x01B7, 0x0DB5, 0x36DD, 0x006C,
3339 0x0016, 0x0005, 0x0004, 0x0003, 0x000A, 0x002E, 0x036C, 0x0DB4,
3340 0x36DC, 0x36DF, 0x36DE, 0x36D9, 0x36D8, 0x36DB, 0x36DA, 0x000E,
3341 0x0004, 0x001A, 0x0019, 0x0018, 0x000F, 0x0001, 0x002F, 0x00DA
3342 ], [
3343 0x0006, 0x0006, 0x000F, 0x0000, 0x0075, 0x03B8, 0x1DCA, 0x0074,
3344 0x0076, 0x0004, 0x0005, 0x0003, 0x0002, 0x01DE, 0x0EE6, 0x3B97,
3345 0x3B96, 0x3B9D, 0x3B9C, 0x3B9F, 0x3B9E, 0x1DC9, 0x1DC8, 0x0005,
3346 0x001C, 0x0009, 0x000E, 0x0008, 0x000F, 0x0001, 0x01DF, 0x01DD
3347 ], [
3348 0x0004, 0x000B, 0x001D, 0x000C, 0x0014, 0x00E0, 0x3875, 0x0386,
3349 0x01C2, 0x0000, 0x0001, 0x0071, 0x0072, 0x1C3F, 0x3874, 0x3877,
3350 0x3876, 0x3871, 0x3870, 0x3873, 0x3872, 0x3879, 0x3878, 0x003C,
3351 0x0073, 0x002A, 0x003D, 0x002B, 0x001F, 0x000D, 0x1C3E, 0x1C3D
3352 ]
3353];
3354const VP40_AC_CAT2_BITS: [[u8; 32]; 16] = [
3355 [
3356 5, 7, 8, 9, 12, 13, 13, 5, 7, 3, 3, 4, 4, 4, 4, 5,
3357 6, 5, 6, 7, 10, 12, 12, 3, 5, 5, 6, 6, 5, 6, 5, 6
3358 ], [
3359 5, 7, 8, 9, 11, 12, 12, 5, 7, 3, 3, 4, 4, 4, 5, 5,
3360 6, 6, 6, 7, 11, 12, 12, 3, 4, 5, 6, 6, 5, 5, 5, 6
3361 ], [
3362 4, 7, 8, 9, 11, 13, 14, 5, 7, 3, 3, 4, 4, 4, 5, 6,
3363 7, 7, 7, 10, 14, 13, 13, 3, 4, 5, 5, 6, 5, 5, 5, 6
3364 ], [
3365 4, 6, 8, 8, 10, 12, 13, 6, 7, 3, 3, 4, 4, 4, 5, 6,
3366 7, 8, 9, 12, 13, 13, 13, 3, 4, 5, 6, 6, 4, 5, 5, 6
3367 ], [
3368 4, 6, 8, 8, 10, 14, 14, 6, 7, 3, 3, 4, 4, 5, 6, 7,
3369 8, 9, 11, 14, 14, 13, 13, 3, 4, 5, 5, 5, 4, 4, 5, 6
3370 ], [
3371 4, 5, 7, 7, 9, 13, 13, 6, 7, 3, 3, 4, 4, 5, 6, 8,
3372 10, 12, 13, 13, 13, 14, 14, 3, 4, 5, 5, 6, 4, 4, 5, 6
3373 ], [
3374 3, 5, 6, 6, 8, 11, 13, 6, 7, 3, 3, 4, 4, 6, 9, 11,
3375 13, 13, 13, 13, 13, 13, 13, 3, 5, 5, 5, 6, 4, 4, 6, 6
3376 ], [
3377 3, 4, 5, 4, 6, 8, 10, 7, 8, 3, 3, 5, 5, 8, 13, 14,
3378 14, 13, 13, 13, 13, 13, 13, 3, 5, 5, 5, 6, 4, 4, 7, 9
3379 ], [
3380 4, 7, 8, 9, 13, 13, 13, 6, 6, 3, 3, 4, 4, 5, 6, 7,
3381 8, 8, 10, 12, 13, 13, 13, 3, 4, 5, 5, 5, 4, 4, 5, 6
3382 ], [
3383 4, 6, 8, 8, 13, 14, 14, 6, 6, 3, 3, 4, 4, 5, 6, 8,
3384 9, 10, 11, 14, 14, 14, 14, 3, 4, 5, 5, 5, 4, 4, 5, 6
3385 ], [
3386 4, 6, 7, 7, 11, 14, 14, 6, 6, 3, 3, 4, 5, 5, 7, 8,
3387 9, 10, 13, 14, 14, 14, 14, 3, 4, 4, 5, 5, 4, 4, 5, 6
3388 ], [
3389 3, 5, 7, 7, 11, 13, 14, 6, 6, 3, 3, 5, 5, 6, 8, 9,
3390 11, 11, 14, 14, 14, 14, 14, 3, 4, 4, 5, 5, 4, 4, 6, 7
3391 ], [
3392 3, 5, 6, 7, 9, 13, 13, 7, 6, 3, 3, 5, 5, 6, 8, 10,
3393 12, 13, 13, 14, 14, 14, 14, 3, 4, 4, 5, 5, 4, 4, 6, 7
3394 ], [
3395 3, 4, 5, 6, 9, 12, 14, 7, 6, 3, 3, 5, 5, 7, 10, 12,
3396 14, 14, 14, 14, 14, 14, 14, 4, 4, 5, 5, 5, 4, 3, 7, 8
3397 ], [
3398 3, 4, 5, 4, 7, 10, 13, 7, 7, 3, 3, 5, 5, 9, 12, 14,
3399 14, 14, 14, 14, 14, 13, 13, 4, 5, 5, 5, 5, 4, 3, 9, 9
3400 ], [
3401 3, 4, 5, 4, 5, 8, 14, 10, 9, 2, 2, 7, 7, 13, 14, 14,
3402 14, 14, 14, 14, 14, 14, 14, 6, 7, 6, 6, 6, 5, 4, 13, 13
3403 ]
3404];
3405const VP40_AC_CAT3_CODES: [[u32; 32]; 16] = [
3406 [
3407 0x0007, 0x000F, 0x00BB, 0x00BA, 0x05CF, 0x173A, 0x2E77, 0x0029,
3408 0x0172, 0x0007, 0x0006, 0x0009, 0x0008, 0x0001, 0x0005, 0x000D,
3409 0x001D, 0x001C, 0x00B8, 0x02E6, 0x2E76, 0x1739, 0x1738, 0x0002,
3410 0x0006, 0x0016, 0x0004, 0x0028, 0x0015, 0x000C, 0x0000, 0x002F
3411 ], [
3412 0x000B, 0x0002, 0x0054, 0x002F, 0x02AC, 0x156B, 0x1568, 0x0016,
3413 0x0154, 0x0007, 0x0006, 0x0004, 0x0003, 0x0013, 0x0028, 0x002E,
3414 0x0157, 0x0155, 0x055B, 0x2AD3, 0x2AD2, 0x2AD5, 0x2AD4, 0x0003,
3415 0x0008, 0x0000, 0x000A, 0x0003, 0x0002, 0x002B, 0x0012, 0x0029
3416 ], [
3417 0x000F, 0x0007, 0x0001, 0x0000, 0x01C4, 0x0703, 0x0E02, 0x0011,
3418 0x00E1, 0x0005, 0x0006, 0x0002, 0x0001, 0x0009, 0x0010, 0x00E3,
3419 0x01C5, 0x01C1, 0x0702, 0x1C07, 0x1C06, 0x0E01, 0x0E00, 0x0004,
3420 0x0007, 0x001D, 0x000D, 0x0001, 0x0005, 0x0006, 0x000C, 0x0039
3421 ], [
3422 0x0001, 0x001C, 0x0011, 0x0013, 0x0042, 0x0207, 0x0815, 0x0075,
3423 0x0041, 0x0005, 0x0006, 0x0000, 0x001F, 0x003B, 0x0074, 0x0043,
3424 0x0080, 0x0206, 0x0814, 0x0817, 0x0816, 0x0409, 0x0408, 0x0003,
3425 0x0009, 0x001E, 0x0011, 0x0003, 0x0005, 0x0010, 0x0002, 0x0012
3426 ], [
3427 0x0001, 0x001F, 0x0027, 0x0001, 0x004B, 0x0123, 0x0915, 0x0000,
3428 0x0049, 0x0005, 0x0006, 0x001D, 0x001C, 0x0013, 0x004A, 0x0090,
3429 0x0914, 0x0917, 0x0916, 0x0911, 0x0910, 0x0913, 0x0912, 0x0003,
3430 0x0005, 0x0001, 0x0012, 0x0008, 0x0008, 0x001E, 0x0026, 0x0001
3431 ], [
3432 0x0003, 0x0001, 0x003F, 0x000B, 0x004E, 0x0132, 0x099A, 0x004F,
3433 0x0098, 0x0006, 0x0005, 0x001D, 0x001C, 0x007C, 0x0267, 0x1331,
3434 0x1330, 0x1333, 0x1332, 0x266D, 0x266C, 0x266F, 0x266E, 0x0001,
3435 0x0004, 0x001E, 0x0012, 0x000A, 0x0008, 0x0000, 0x007D, 0x004D
3436 ], [
3437 0x0002, 0x0007, 0x0015, 0x0003, 0x0004, 0x00A7, 0x0536, 0x0028,
3438 0x029A, 0x0006, 0x0004, 0x001C, 0x0017, 0x00A4, 0x29BE, 0x537F,
3439 0x537E, 0x29B9, 0x29B8, 0x29BB, 0x29BA, 0x29BD, 0x29BC, 0x000F,
3440 0x0000, 0x0005, 0x0016, 0x001D, 0x0006, 0x0001, 0x00A5, 0x014C
3441 ], [
3442 0x0004, 0x0007, 0x001A, 0x000C, 0x0006, 0x0029, 0x01BD, 0x1BE3,
3443 0x1BE0, 0x0000, 0x0007, 0x006E, 0x01BC, 0x37C3, 0x37C2, 0x37CD,
3444 0x37CC, 0x37CF, 0x37CE, 0x37C9, 0x37C8, 0x37CB, 0x37CA, 0x0015,
3445 0x01BF, 0x037D, 0x0036, 0x0002, 0x000B, 0x0028, 0x37C5, 0x37C4
3446 ], [
3447 0x0001, 0x0009, 0x0003, 0x0002, 0x011F, 0x08E9, 0x08E8, 0x002D,
3448 0x0022, 0x0006, 0x0007, 0x0010, 0x0011, 0x0017, 0x002C, 0x0046,
3449 0x011E, 0x011C, 0x0477, 0x08EB, 0x08EA, 0x08ED, 0x08EC, 0x0003,
3450 0x000B, 0x0001, 0x0014, 0x000A, 0x0009, 0x0015, 0x0000, 0x0010
3451 ], [
3452 0x0001, 0x001D, 0x0022, 0x0013, 0x011E, 0x08FC, 0x23F5, 0x0023,
3453 0x0022, 0x0005, 0x0006, 0x0010, 0x000B, 0x0010, 0x008E, 0x023E,
3454 0x08FF, 0x11FD, 0x23F4, 0x23F7, 0x23F6, 0x23F9, 0x23F8, 0x0003,
3455 0x0009, 0x0000, 0x001C, 0x000A, 0x000F, 0x0001, 0x0012, 0x0046
3456 ], [
3457 0x0003, 0x001F, 0x003C, 0x003D, 0x0086, 0x0877, 0x10E8, 0x0041,
3458 0x0040, 0x0005, 0x0006, 0x0007, 0x0006, 0x0004, 0x010F, 0x021C,
3459 0x0875, 0x21D3, 0x21D2, 0x21D9, 0x21D8, 0x21DB, 0x21DA, 0x0002,
3460 0x0009, 0x0000, 0x0011, 0x0003, 0x000E, 0x0002, 0x0005, 0x0042
3461 ], [
3462 0x0004, 0x0001, 0x003D, 0x0009, 0x00F3, 0x0793, 0x1E45, 0x0000,
3463 0x0002, 0x0005, 0x0006, 0x0008, 0x0001, 0x0003, 0x01E5, 0x0792,
3464 0x1E44, 0x1E47, 0x1E46, 0x1E41, 0x1E40, 0x1E43, 0x1E42, 0x0001,
3465 0x0006, 0x001F, 0x000F, 0x000E, 0x000E, 0x0005, 0x0078, 0x0001
3466 ], [
3467 0x0004, 0x0005, 0x000E, 0x0017, 0x003E, 0x00F0, 0x0F1E, 0x007A,
3468 0x007F, 0x0006, 0x0007, 0x0005, 0x0004, 0x007B, 0x01E2, 0x1E3F,
3469 0x1E3E, 0x0F19, 0x0F18, 0x0F1B, 0x0F1A, 0x0F1D, 0x0F1C, 0x0000,
3470 0x0003, 0x0016, 0x0009, 0x0008, 0x000A, 0x0006, 0x007E, 0x0079
3471 ], [
3472 0x0005, 0x000C, 0x001A, 0x0004, 0x001A, 0x00DE, 0x0DF4, 0x00DD,
3473 0x006D, 0x0000, 0x0007, 0x0025, 0x0024, 0x00DC, 0x0DF7, 0x1BEB,
3474 0x1BEA, 0x0DF1, 0x0DF0, 0x0DF3, 0x0DF2, 0x1BED, 0x1BEC, 0x0008,
3475 0x0013, 0x000C, 0x0037, 0x0036, 0x0005, 0x0007, 0x006C, 0x01BF
3476 ], [
3477 0x0005, 0x000D, 0x001F, 0x000C, 0x003B, 0x0040, 0x041A, 0x0104,
3478 0x0107, 0x0001, 0x0000, 0x0024, 0x0021, 0x020B, 0x106E, 0x20DF,
3479 0x20DE, 0x1055, 0x1054, 0x1057, 0x1056, 0x106D, 0x106C, 0x0011,
3480 0x003A, 0x0025, 0x0038, 0x0039, 0x0013, 0x001E, 0x020C, 0x0414
3481 ], [
3482 0x0000, 0x0007, 0x000D, 0x0005, 0x0009, 0x0022, 0x0CD1, 0x0CD0,
3483 0x0CD3, 0x0003, 0x0002, 0x008D, 0x00CC, 0x066B, 0x0CD2, 0x19B5,
3484 0x19B4, 0x19B7, 0x19B6, 0x19B1, 0x19B0, 0x19B3, 0x19B2, 0x0047,
3485 0x008C, 0x0337, 0x0067, 0x0018, 0x0010, 0x0032, 0x0CD5, 0x0CD4
3486 ]
3487];
3488const VP40_AC_CAT3_BITS: [[u8; 32]; 16] = [
3489 [
3490 4, 6, 8, 8, 11, 13, 14, 6, 9, 3, 3, 4, 4, 4, 5, 6,
3491 7, 7, 8, 10, 14, 13, 13, 3, 4, 5, 5, 6, 5, 6, 4, 6
3492 ], [
3493 4, 5, 7, 7, 10, 13, 13, 6, 9, 3, 3, 4, 4, 5, 6, 7,
3494 9, 9, 11, 14, 14, 14, 14, 3, 4, 4, 5, 5, 4, 6, 5, 6
3495 ], [
3496 4, 5, 6, 6, 9, 11, 12, 6, 8, 3, 3, 4, 4, 5, 6, 8,
3497 9, 9, 11, 13, 13, 12, 12, 3, 4, 5, 5, 5, 4, 5, 5, 6
3498 ], [
3499 3, 5, 6, 6, 8, 11, 13, 7, 8, 3, 3, 4, 5, 6, 7, 8,
3500 9, 11, 13, 13, 13, 12, 12, 3, 4, 5, 5, 5, 4, 5, 5, 6
3501 ], [
3502 3, 5, 6, 5, 8, 10, 13, 6, 8, 3, 3, 5, 5, 6, 8, 9,
3503 13, 13, 13, 13, 13, 13, 13, 3, 4, 4, 5, 5, 4, 5, 6, 6
3504 ], [
3505 3, 4, 6, 5, 7, 9, 12, 7, 8, 3, 3, 5, 5, 7, 10, 13,
3506 13, 13, 13, 14, 14, 14, 14, 3, 4, 5, 5, 5, 4, 4, 7, 7
3507 ], [
3508 3, 4, 5, 4, 5, 8, 11, 6, 10, 3, 3, 5, 5, 8, 14, 15,
3509 15, 14, 14, 14, 14, 14, 14, 4, 4, 5, 5, 5, 4, 4, 8, 9
3510 ], [
3511 3, 4, 5, 4, 4, 6, 9, 13, 13, 2, 3, 7, 9, 14, 14, 14,
3512 14, 14, 14, 14, 14, 14, 14, 5, 9, 10, 6, 3, 4, 6, 14, 14
3513 ], [
3514 3, 5, 6, 6, 10, 13, 13, 7, 7, 3, 3, 5, 5, 6, 7, 8,
3515 10, 10, 12, 13, 13, 13, 13, 3, 4, 4, 5, 5, 4, 5, 5, 6
3516 ], [
3517 3, 5, 6, 6, 9, 12, 14, 7, 7, 3, 3, 5, 5, 6, 8, 10,
3518 12, 13, 14, 14, 14, 14, 14, 3, 4, 4, 5, 5, 4, 4, 6, 7
3519 ], [
3520 3, 5, 6, 6, 8, 12, 13, 7, 7, 3, 3, 5, 5, 6, 9, 10,
3521 12, 14, 14, 14, 14, 14, 14, 3, 4, 4, 5, 5, 4, 4, 6, 7
3522 ], [
3523 3, 4, 6, 5, 8, 11, 13, 7, 7, 3, 3, 5, 5, 7, 9, 11,
3524 13, 13, 13, 13, 13, 13, 13, 3, 4, 5, 5, 5, 4, 4, 7, 7
3525 ], [
3526 3, 4, 5, 5, 7, 9, 13, 8, 8, 3, 3, 5, 5, 8, 10, 14,
3527 14, 13, 13, 13, 13, 13, 13, 3, 4, 5, 5, 5, 4, 4, 8, 8
3528 ], [
3529 3, 4, 5, 4, 6, 9, 13, 9, 8, 2, 3, 6, 6, 9, 13, 14,
3530 14, 13, 13, 13, 13, 14, 14, 4, 5, 5, 6, 6, 4, 4, 8, 10
3531 ], [
3532 3, 4, 5, 4, 6, 7, 11, 9, 9, 2, 2, 6, 6, 10, 13, 14,
3533 14, 13, 13, 13, 13, 13, 13, 5, 6, 6, 6, 6, 5, 5, 10, 11
3534 ], [
3535 2, 4, 5, 4, 5, 7, 13, 13, 13, 2, 2, 9, 9, 12, 13, 14,
3536 14, 14, 14, 14, 14, 14, 14, 8, 9, 11, 8, 6, 6, 7, 13, 13
3537 ]
3538];
3539
3540const VP40_QMAT: &[i16; 64] = &[
3541 16, 17, 18, 20, 22, 24, 26, 28,
3542 17, 18, 20, 22, 24, 26, 28, 32,
3543 18, 20, 22, 24, 26, 28, 32, 36,
3544 20, 22, 24, 26, 28, 32, 36, 40,
3545 22, 24, 26, 28, 32, 36, 40, 44,
3546 24, 26, 28, 32, 36, 40, 44, 48,
3547 26, 28, 32, 36, 40, 44, 48, 52,
3548 28, 32, 36, 40, 44, 48, 52, 56
3549];
3550const VP40_DC_Y_SCALES: [i16; 64] = [
3551 180, 180, 180, 180, 180, 180, 175, 170,
3552 165, 160, 157, 155, 152, 150, 147, 145,
3553 142, 140, 137, 135, 132, 130, 127, 125,
3554 122, 120, 117, 115, 112, 110, 107, 105,
3555 102, 100, 97, 95, 92, 90, 87, 85,
3556 82, 80, 77, 75, 72, 70, 67, 65,
3557 62, 60, 57, 55, 52, 50, 47, 45,
3558 42, 40, 37, 35, 32, 30, 27, 25
3559];
3560const VP40_DC_C_SCALES: [i16; 64] = [
3561 150, 150, 150, 150, 150, 150, 150, 150,
3562 150, 150, 150, 150, 150, 150, 147, 145,
3563 142, 140, 137, 135, 132, 130, 127, 125,
3564 122, 120, 117, 115, 112, 110, 107, 105,
3565 102, 100, 97, 95, 92, 90, 87, 85,
3566 82, 80, 77, 75, 72, 70, 67, 65,
3567 62, 60, 57, 55, 52, 50, 47, 45,
3568 42, 40, 37, 35, 32, 30, 27, 25
3569];
3570const VP40_AC_SCALES: [i16; 64] = [
3571 500, 475, 450, 430, 410, 390, 370, 350,
3572 330, 315, 300, 285, 270, 260, 250, 240,
3573 230, 220, 210, 200, 190, 185, 180, 170,
3574 160, 150, 143, 135, 128, 120, 113, 106,
3575 100, 94, 90, 85, 80, 75, 70, 66,
3576 62, 57, 52, 49, 45, 41, 38, 35,
3577 33, 30, 27, 24, 22, 20, 18, 16,
3578 14, 12, 10, 9, 7, 6, 4, 1
3579];
3580
3581const VP40_MBPAT_CODES: [[u8; 14]; 2] = [
3582 [ 0b000, 0b1111, 0b1001, 0b010, 0b1101, 0b01110, 0b1011, 0b001, 0b01111, 0b1000, 0b0110, 0b1110, 0b1100, 0b1010 ],
3583 [ 0b0111, 0b1010, 0b1001, 0b1100, 0b1000, 0b01101, 0b000, 0b1110, 0b01100, 0b1101, 0b001, 0b1011, 0b1111, 0b010 ]
3584];
3585const VP40_MBPAT_BITS: [[u8; 14]; 2] = [
3586 [ 3, 4, 4, 3, 4, 5, 4, 3, 5, 4, 4, 4, 4, 4 ],
3587 [ 4, 4, 4, 4, 4, 5, 3, 4, 5, 4, 3, 4, 4, 3 ]
3588];
3589const VP40_BP_PREDICTOR: [u8; 15] = [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1 ];
3590const VP40_MV_X_CODES: [[u32; 63]; 7] = [
3591 [
3592 0x06A, 0x11A, 0x18E, 0x237, 0x04A, 0x236, 0x07A, 0x0D6,
3593 0x07E, 0x1FD, 0x08C, 0x0D7, 0x087, 0x183, 0x03C, 0x061,
3594 0x047, 0x069, 0x040, 0x048, 0x049, 0x086, 0x013, 0x0D2,
3595 0x01C, 0x042, 0x025, 0x01B, 0x013, 0x005, 0x000, 0x007,
3596 0x005, 0x01B, 0x019, 0x019, 0x008, 0x045, 0x01D, 0x0C6,
3597 0x068, 0x090, 0x041, 0x04B, 0x031, 0x18F, 0x062, 0x03E,
3598 0x044, 0x068, 0x030, 0x182, 0x0C0, 0x1A7, 0x091, 0x092,
3599 0x07B, 0x0FF, 0x1A6, 0x1FC, 0x06A, 0x093, 0x06B
3600 ], [
3601 0x039, 0x259, 0x01B, 0x1D1, 0x137, 0x1D0, 0x01A, 0x1B5,
3602 0x01D, 0x4BC, 0x06C, 0x038, 0x071, 0x02D, 0x07D, 0x075,
3603 0x019, 0x0E9, 0x037, 0x015, 0x01E, 0x0DB, 0x04C, 0x070,
3604 0x00D, 0x00C, 0x027, 0x004, 0x002, 0x000, 0x005, 0x007,
3605 0x006, 0x002, 0x008, 0x024, 0x00C, 0x03B, 0x01E, 0x09A,
3606 0x00E, 0x069, 0x04A, 0x12D, 0x035, 0x0F9, 0x018, 0x07F,
3607 0x00F, 0x0F8, 0x07E, 0x25F, 0x068, 0x02C, 0x014, 0x258,
3608 0x136, 0x4BD, 0x12E, 0x1B4, 0x017, 0x039, 0x01F
3609 ], [
3610 0x029, 0x3CB, 0x1F5, 0x263, 0x1F4, 0x3DA, 0x050, 0x260,
3611 0x1EC, 0x3D3, 0x109, 0x3D2, 0x051, 0x792, 0x0F3, 0x09A,
3612 0x0F7, 0x132, 0x0C1, 0x1E8, 0x02A, 0x085, 0x061, 0x1F7,
3613 0x078, 0x0C7, 0x023, 0x07C, 0x012, 0x00B, 0x00E, 0x00D,
3614 0x000, 0x005, 0x003, 0x004, 0x019, 0x020, 0x03F, 0x043,
3615 0x062, 0x09F, 0x04E, 0x181, 0x02B, 0x137, 0x0F5, 0x089,
3616 0x0C6, 0x262, 0x088, 0x3C8, 0x1F6, 0x3CA, 0x09E, 0x261,
3617 0x136, 0x108, 0x133, 0x793, 0x180, 0x3DB, 0x045
3618 ], [
3619 0x001, 0x1C7, 0x067, 0x0B5, 0x066, 0x139, 0x099, 0x0B4,
3620 0x0C3, 0x130, 0x000, 0x131, 0x09E, 0x0B7, 0x02C, 0x001,
3621 0x028, 0x138, 0x04B, 0x031, 0x060, 0x091, 0x003, 0x09D,
3622 0x017, 0x04D, 0x031, 0x070, 0x007, 0x03A, 0x007, 0x002,
3623 0x00B, 0x001, 0x00F, 0x008, 0x00D, 0x004, 0x00A, 0x00D,
3624 0x019, 0x002, 0x03B, 0x04A, 0x015, 0x0C2, 0x018, 0x032,
3625 0x072, 0x1C6, 0x029, 0x1C5, 0x049, 0x121, 0x01B, 0x030,
3626 0x01A, 0x1C4, 0x09F, 0x0B6, 0x019, 0x120, 0x073
3627 ], [
3628 0x023, 0x1C8, 0x043, 0x110, 0x00C, 0x153, 0x022, 0x111,
3629 0x00F, 0x042, 0x023, 0x1C9, 0x02A, 0x01B, 0x073, 0x045,
3630 0x06E, 0x089, 0x06C, 0x01A, 0x06F, 0x0B6, 0x00B, 0x0E5,
3631 0x025, 0x020, 0x029, 0x04D, 0x002, 0x014, 0x01A, 0x017,
3632 0x01E, 0x027, 0x018, 0x028, 0x01F, 0x000, 0x006, 0x010,
3633 0x007, 0x00B, 0x003, 0x004, 0x01D, 0x02C, 0x019, 0x02B,
3634 0x009, 0x055, 0x038, 0x00E, 0x024, 0x0A8, 0x00A, 0x099,
3635 0x05A, 0x098, 0x06D, 0x152, 0x02B, 0x0B7, 0x001
3636 ], [
3637 0x03D, 0x0B1, 0x0DD, 0x1F6, 0x0C5, 0x188, 0x037, 0x03F,
3638 0x01E, 0x189, 0x00F, 0x03E, 0x06A, 0x1F7, 0x061, 0x079,
3639 0x018, 0x0B0, 0x00E, 0x0B3, 0x00C, 0x0DF, 0x006, 0x0DC,
3640 0x019, 0x0DE, 0x027, 0x00E, 0x01A, 0x063, 0x00F, 0x00E,
3641 0x014, 0x07C, 0x036, 0x06B, 0x03F, 0x060, 0x008, 0x074,
3642 0x009, 0x078, 0x012, 0x00D, 0x015, 0x02D, 0x002, 0x01C,
3643 0x005, 0x03B, 0x000, 0x034, 0x019, 0x026, 0x010, 0x075,
3644 0x002, 0x036, 0x023, 0x0B2, 0x022, 0x0FA, 0x017
3645 ], [
3646 0x015, 0x0DD, 0x03E, 0x16E, 0x04C, 0x012, 0x05D, 0x0B6,
3647 0x06F, 0x1F1, 0x069, 0x1F0, 0x01D, 0x16F, 0x002, 0x06B,
3648 0x00C, 0x0DC, 0x068, 0x09B, 0x07D, 0x09A, 0x00D, 0x013,
3649 0x008, 0x0F9, 0x02C, 0x012, 0x033, 0x04F, 0x00D, 0x005,
3650 0x012, 0x03F, 0x032, 0x013, 0x03B, 0x005, 0x02F, 0x05A,
3651 0x03F, 0x01C, 0x03A, 0x008, 0x036, 0x05C, 0x010, 0x000,
3652 0x00C, 0x04E, 0x003, 0x06A, 0x00E, 0x003, 0x014, 0x01E,
3653 0x01C, 0x00F, 0x018, 0x023, 0x01E, 0x022, 0x002
3654 ]
3655];
3656const VP40_MV_X_BITS: [[u8; 63]; 7] = [
3657 [
3658 7, 9, 9, 10, 8, 10, 8, 9, 8, 10, 8, 9, 8, 9, 7, 7,
3659 7, 8, 7, 8, 7, 8, 6, 8, 6, 7, 6, 6, 5, 4, 2, 3,
3660 3, 5, 5, 6, 5, 7, 6, 8, 7, 8, 7, 8, 7, 9, 7, 7,
3661 7, 8, 7, 9, 8, 9, 8, 9, 8, 9, 9, 10, 8, 9, 7
3662 ], [
3663 7, 10, 8, 10, 9, 10, 8, 10, 8, 11, 8, 9, 8, 9, 8, 8,
3664 7, 9, 7, 8, 7, 9, 7, 8, 6, 7, 6, 6, 4, 4, 3, 3,
3665 3, 3, 4, 6, 5, 7, 6, 8, 6, 8, 7, 9, 7, 9, 7, 8,
3666 7, 9, 8, 10, 8, 9, 8, 10, 9, 11, 9, 10, 8, 9, 7
3667 ], [
3668 7, 10, 9, 10, 9, 10, 8, 10, 9, 10, 9, 10, 8, 11, 8, 8,
3669 8, 9, 8, 9, 7, 8, 7, 9, 7, 8, 6, 7, 5, 5, 4, 4,
3670 2, 3, 3, 4, 5, 6, 6, 7, 7, 8, 7, 9, 7, 9, 8, 8,
3671 8, 10, 8, 10, 9, 10, 8, 10, 9, 9, 9, 11, 9, 10, 7
3672 ], [
3673 6, 9, 8, 9, 8, 9, 8, 9, 8, 9, 7, 9, 8, 9, 7, 7,
3674 7, 9, 7, 8, 7, 8, 6, 8, 6, 7, 6, 7, 5, 6, 4, 4,
3675 4, 4, 4, 4, 4, 4, 4, 5, 5, 6, 6, 7, 6, 8, 6, 7,
3676 7, 9, 7, 9, 7, 9, 7, 8, 7, 9, 8, 9, 7, 9, 7
3677 ], [
3678 6, 9, 8, 9, 7, 9, 7, 9, 7, 8, 7, 9, 7, 8, 7, 7,
3679 7, 8, 7, 8, 7, 8, 6, 8, 6, 7, 6, 7, 5, 6, 5, 5,
3680 5, 6, 5, 6, 5, 5, 4, 5, 4, 5, 4, 5, 5, 6, 5, 6,
3681 5, 7, 6, 7, 6, 8, 6, 8, 7, 8, 7, 9, 7, 8, 5
3682 ], [
3683 6, 8, 8, 9, 8, 9, 7, 8, 7, 9, 7, 8, 7, 9, 7, 7,
3684 6, 8, 6, 8, 6, 8, 6, 8, 6, 8, 6, 7, 6, 7, 5, 5,
3685 5, 7, 6, 7, 6, 7, 5, 7, 5, 7, 5, 6, 5, 6, 4, 5,
3686 4, 6, 4, 6, 5, 6, 5, 7, 5, 7, 6, 8, 6, 8, 5
3687 ], [
3688 5, 8, 7, 9, 7, 8, 7, 8, 7, 9, 7, 9, 7, 9, 6, 7,
3689 6, 8, 7, 8, 7, 8, 6, 8, 6, 8, 6, 7, 6, 7, 5, 5,
3690 5, 7, 6, 7, 6, 6, 6, 7, 6, 7, 6, 7, 6, 7, 5, 5,
3691 5, 7, 5, 7, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 3
3692 ]
3693];
3694const VP40_MV_Y_CODES: [[u32; 63]; 7] = [
3695 [
3696 0x052, 0x14C, 0x1FA, 0x124, 0x082, 0x29E, 0x08E, 0x24B,
3697 0x09C, 0x3F7, 0x086, 0x114, 0x083, 0x3A5, 0x0FA, 0x04F,
3698 0x0FB, 0x13B, 0x0FC, 0x172, 0x044, 0x173, 0x051, 0x087,
3699 0x05F, 0x0BA, 0x026, 0x05E, 0x016, 0x015, 0x006, 0x001,
3700 0x000, 0x01C, 0x01E, 0x075, 0x03B, 0x0FF, 0x025, 0x0BB,
3701 0x07C, 0x08B, 0x048, 0x171, 0x042, 0x14E, 0x046, 0x0FE,
3702 0x040, 0x13A, 0x093, 0x115, 0x08F, 0x3F6, 0x170, 0x29F,
3703 0x1D1, 0x24A, 0x1D3, 0x3A4, 0x1D0, 0x14D, 0x050
3704 ], [
3705 0x0DE, 0x223, 0x136, 0x7C5, 0x12F, 0x4A1, 0x3D7, 0x7AC,
3706 0x133, 0x7C4, 0x1B8, 0x222, 0x096, 0x251, 0x095, 0x1F0,
3707 0x0DA, 0x110, 0x09A, 0x360, 0x0DD, 0x12E, 0x048, 0x092,
3708 0x078, 0x098, 0x027, 0x045, 0x01A, 0x010, 0x005, 0x000,
3709 0x001, 0x00E, 0x00C, 0x023, 0x03F, 0x0F4, 0x07D, 0x089,
3710 0x07B, 0x1BE, 0x0F9, 0x3E3, 0x0F3, 0x127, 0x0DB, 0x1EA,
3711 0x0D9, 0x6E7, 0x1BF, 0x4A0, 0x1B1, 0x6E6, 0x137, 0x7AD,
3712 0x126, 0x6C2, 0x132, 0x6C3, 0x129, 0x372, 0x0F2
3713 ], [
3714 0x016, 0x09C, 0x13C, 0x09E, 0x12B, 0x0BA, 0x181, 0x317,
3715 0x084, 0x04E, 0x026, 0x316, 0x180, 0x05C, 0x0C1, 0x02F,
3716 0x010, 0x045, 0x012, 0x189, 0x024, 0x13D, 0x066, 0x023,
3717 0x067, 0x0C6, 0x024, 0x04B, 0x011, 0x032, 0x00D, 0x000,
3718 0x007, 0x005, 0x003, 0x003, 0x005, 0x020, 0x008, 0x025,
3719 0x026, 0x04F, 0x061, 0x02B, 0x04E, 0x18A, 0x043, 0x09F,
3720 0x014, 0x254, 0x094, 0x310, 0x085, 0x311, 0x02A, 0x0BB,
3721 0x18F, 0x255, 0x09D, 0x09F, 0x18E, 0x044, 0x026
3722 ], [
3723 0x061, 0x12A, 0x00D, 0x3BD, 0x089, 0x109, 0x18E, 0x210,
3724 0x1D3, 0x211, 0x088, 0x019, 0x085, 0x018, 0x0E8, 0x0CE,
3725 0x040, 0x119, 0x045, 0x1D2, 0x04B, 0x1DD, 0x062, 0x094,
3726 0x075, 0x00C, 0x027, 0x00D, 0x002, 0x026, 0x006, 0x01E,
3727 0x00D, 0x01F, 0x001, 0x00A, 0x002, 0x007, 0x00B, 0x000,
3728 0x01C, 0x076, 0x032, 0x007, 0x024, 0x0C0, 0x007, 0x041,
3729 0x002, 0x18F, 0x047, 0x1DC, 0x043, 0x12B, 0x0CF, 0x118,
3730 0x0C6, 0x3BC, 0x08D, 0x3BF, 0x0C1, 0x3BE, 0x066
3731 ], [
3732 0x007, 0x14D, 0x0A0, 0x09E, 0x0CF, 0x39C, 0x0A1, 0x39D,
3733 0x0AB, 0x1C5, 0x026, 0x14C, 0x025, 0x19C, 0x03F, 0x0E1,
3734 0x066, 0x1CF, 0x03E, 0x1C4, 0x072, 0x04E, 0x006, 0x0AA,
3735 0x01C, 0x0E6, 0x032, 0x051, 0x03B, 0x005, 0x01F, 0x018,
3736 0x002, 0x03A, 0x000, 0x036, 0x005, 0x008, 0x008, 0x016,
3737 0x009, 0x00D, 0x003, 0x02F, 0x01E, 0x02E, 0x01A, 0x02B,
3738 0x00C, 0x024, 0x01E, 0x0E0, 0x004, 0x0A7, 0x054, 0x1C7,
3739 0x052, 0x19D, 0x03A, 0x09F, 0x03B, 0x1C6, 0x037
3740 ], [
3741 0x02A, 0x039, 0x025, 0x115, 0x024, 0x1FA, 0x02F, 0x114,
3742 0x075, 0x038, 0x0FC, 0x036, 0x01E, 0x1FB, 0x07F, 0x068,
3743 0x016, 0x037, 0x01F, 0x05C, 0x013, 0x08B, 0x001, 0x0FB,
3744 0x021, 0x044, 0x02B, 0x06B, 0x03B, 0x00C, 0x01C, 0x019,
3745 0x001, 0x020, 0x016, 0x07C, 0x00C, 0x074, 0x00A, 0x01C,
3746 0x012, 0x069, 0x00F, 0x06A, 0x014, 0x011, 0x01E, 0x017,
3747 0x002, 0x031, 0x01B, 0x030, 0x00D, 0x000, 0x001, 0x01D,
3748 0x023, 0x01A, 0x01D, 0x05D, 0x010, 0x0FA, 0x013
3749 ], [
3750 0x012, 0x026, 0x041, 0x022, 0x01A, 0x0A9, 0x04C, 0x1B2,
3751 0x05C, 0x0A8, 0x058, 0x1B3, 0x040, 0x079, 0x00C, 0x055,
3752 0x01F, 0x0D8, 0x076, 0x023, 0x05F, 0x078, 0x00B, 0x01B,
3753 0x02D, 0x010, 0x037, 0x06D, 0x032, 0x00A, 0x01A, 0x01E,
3754 0x01F, 0x02B, 0x00D, 0x077, 0x031, 0x05D, 0x038, 0x027,
3755 0x00C, 0x0E9, 0x033, 0x05E, 0x030, 0x04D, 0x00A, 0x021,
3756 0x007, 0x03D, 0x039, 0x0E8, 0x00B, 0x059, 0x014, 0x027,
3757 0x011, 0x075, 0x00E, 0x009, 0x008, 0x012, 0x000
3758 ]
3759];
3760const VP40_MV_Y_BITS: [[u8; 63]; 7] = [
3761 [
3762 7, 9, 9, 9, 8, 10, 8, 10, 8, 10, 8, 9, 8, 10, 8, 7,
3763 8, 9, 8, 9, 7, 9, 7, 8, 7, 8, 6, 7, 5, 5, 3, 2,
3764 2, 5, 5, 7, 6, 8, 6, 8, 7, 8, 7, 9, 7, 9, 7, 8,
3765 7, 9, 8, 9, 8, 10, 9, 10, 9, 10, 9, 10, 9, 9, 7
3766 ], [
3767 8, 10, 9, 11, 9, 11, 10, 11, 9, 11, 9, 10, 8, 10, 8, 9,
3768 8, 9, 8, 10, 8, 9, 7, 8, 7, 8, 6, 7, 5, 5, 3, 2,
3769 2, 4, 4, 6, 6, 8, 7, 8, 7, 9, 8, 10, 8, 9, 8, 9,
3770 8, 11, 9, 11, 9, 11, 9, 11, 9, 11, 9, 11, 9, 10, 8
3771 ], [
3772 7, 9, 9, 10, 9, 10, 9, 10, 8, 9, 8, 10, 9, 9, 8, 8,
3773 7, 9, 7, 9, 7, 9, 7, 8, 7, 8, 6, 7, 5, 6, 4, 3,
3774 3, 3, 3, 4, 4, 6, 5, 7, 6, 8, 7, 8, 7, 9, 7, 8,
3775 7, 10, 8, 10, 8, 10, 8, 10, 9, 10, 9, 10, 9, 9, 7
3776 ], [
3777 7, 9, 8, 10, 8, 9, 9, 10, 9, 10, 8, 9, 8, 9, 8, 8,
3778 7, 9, 7, 9, 7, 9, 7, 8, 7, 7, 6, 7, 5, 6, 4, 5,
3779 4, 5, 3, 4, 3, 4, 4, 5, 5, 7, 6, 7, 6, 8, 6, 7,
3780 6, 9, 7, 9, 7, 9, 8, 9, 8, 10, 8, 10, 8, 10, 7
3781 ], [
3782 6, 9, 8, 9, 8, 10, 8, 10, 8, 9, 7, 9, 7, 9, 7, 8,
3783 7, 9, 7, 9, 7, 8, 6, 8, 6, 8, 6, 7, 6, 6, 5, 5,
3784 4, 6, 4, 6, 4, 5, 4, 5, 4, 5, 4, 6, 5, 6, 5, 6,
3785 5, 7, 6, 8, 6, 8, 7, 9, 7, 9, 7, 9, 7, 9, 6
3786 ], [
3787 6, 8, 7, 9, 7, 9, 7, 9, 7, 8, 8, 8, 7, 9, 7, 7,
3788 6, 8, 7, 8, 6, 8, 6, 8, 6, 7, 6, 7, 6, 6, 5, 5,
3789 4, 6, 5, 7, 5, 7, 5, 6, 5, 7, 5, 7, 5, 6, 5, 5,
3790 4, 6, 5, 6, 5, 6, 5, 7, 6, 7, 6, 8, 6, 8, 5
3791 ], [
3792 5, 7, 7, 8, 7, 8, 7, 9, 7, 8, 7, 9, 7, 8, 6, 7,
3793 6, 8, 7, 8, 7, 8, 6, 7, 6, 7, 6, 7, 6, 6, 5, 5,
3794 5, 6, 5, 7, 6, 7, 6, 7, 5, 8, 6, 7, 6, 7, 5, 6,
3795 5, 7, 6, 8, 5, 7, 5, 6, 5, 7, 5, 6, 5, 6, 3
3796 ]
3797];
3798
3799const VP40_LOOP_STRENGTH: [i16; 64] = [
3800 30, 25, 20, 20, 15, 15, 14, 14,
3801 13, 13, 12, 12, 11, 11, 10, 10,
3802 9, 9, 8, 8, 7, 7, 7, 7,
3803 6, 6, 6, 6, 5, 5, 5, 5,
3804 4, 4, 4, 4, 3, 3, 3, 3,
3805 2, 2, 2, 2, 2, 2, 2, 2,
3806 2, 2, 2, 2, 2, 2, 2, 2,
3807 1, 1, 1, 1, 1, 1, 1, 1
3808];
3809const VP40_MV_LUT_INDEX: [usize; 32] = [
3810 0, 1, 2, 2, 3, 3, 3, 3,
3811 4, 4, 4, 4, 4, 4, 4, 4,
3812 5, 5, 5, 5, 5, 5, 5, 5,
3813 6, 6, 6, 6, 6, 6, 6, 6
3814];
NihAV is a research multimedia framework