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