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