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