projects / nihav.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
duck/vp56: select proper format for VP6 alpha
[nihav.git] / nihav-duck / src / codecs / vp56.rs
1 use nihav_core::codecs::*;
2 use nihav_core::io::bitreader::*;
3 use super::vpcommon::*;
4
5 pub const TOKEN_LARGE: u8 = 5;
6 pub const TOKEN_EOB: u8 = 42;
7
8 #[derive(Clone,Copy,Debug,Default)]
9 #[allow(dead_code)]
10 pub struct VP56Header {
11 pub is_intra: bool,
12 pub is_golden: bool,
13 pub quant: u8,
14 pub multistream: bool,
15 pub use_huffman: bool,
16 pub version: u8,
17 pub profile: u8,
18 pub interlaced: bool,
19 pub offset: u16,
20 pub mb_w: u8,
21 pub mb_h: u8,
22 pub disp_w: u8,
23 pub disp_h: u8,
24 pub scale: u8,
25 }
26
27 #[derive(Clone,Copy,Default)]
28 pub struct VP56MVModel {
29 pub nz_prob: u8,
30 pub sign_prob: u8,
31 pub raw_probs: [u8; 8],
32 pub tree_probs: [u8; 7],
33 }
34
35 #[derive(Clone,Copy,Default)]
36 pub struct VP56MBTypeModel {
37 pub probs: [u8; 10],
38 }
39
40 #[derive(Clone,Copy,Default)]
41 pub struct VP56CoeffModel {
42 pub dc_token_probs: [[[u8; 5]; 6]; 6],
43 pub dc_value_probs: [u8; 11],
44 pub ac_ctype_probs: [[[[u8; 5]; 5]; 6]; 3],
45 pub ac_type_probs: [[[[u8; 5]; 6]; 3]; 3],
46 pub ac_val_probs: [[[u8; 11]; 6]; 3],
47 }
48
49 pub struct VP6Models {
50 pub scan_order: [usize; 64],
51 pub scan: [usize; 64],
52 pub zigzag: [usize; 64],
53 pub zero_run_probs: [[u8; 14]; 2],
54 }
55
56 const MAX_HUFF_ELEMS: usize = 12;
57 #[derive(Clone,Copy,Default)]
58 pub struct VP6Huff {
59 pub codes: [u16; MAX_HUFF_ELEMS],
60 pub bits: [u8; MAX_HUFF_ELEMS],
61 }
62
63 #[derive(Clone,Copy,Default)]
64 struct Node {
65 weight: u16,
66 sym: i8,
67 ch0: usize,
68 ch1: usize,
69 }
70
71 fn prob2weight(a: u8, b: u8) -> u8 {
72 let w = (((a as u16) * (b as u16)) >> 8) as u8;
73 if w == 0 {
74 1
75 } else {
76 w
77 }
78 }
79
80 impl VP6Huff {
81 fn build_codes(&mut self, probs: &[u8; 11]) {
82 let mut weights = [0u8; 12];
83
84 weights[11] = prob2weight( probs[0], probs[ 1]);
85 weights[ 0] = prob2weight( probs[0], !probs[ 1]);
86 weights[ 1] = prob2weight(!probs[0], probs[ 2]);
87 let lvroot = prob2weight(!probs[0], !probs[ 2]);
88 let tworoot = prob2weight( lvroot, probs[ 3]);
89 let hlroot = prob2weight( lvroot, !probs[ 3]);
90 weights[ 2] = prob2weight( tworoot, probs[ 4]);
91 let root34 = prob2weight( tworoot, !probs[ 4]);
92 weights[ 3] = prob2weight( root34, probs[ 5]);
93 weights[ 4] = prob2weight( root34, !probs[ 5]);
94 let c1root = prob2weight( hlroot, probs[ 6]);
95 let c34root = prob2weight( hlroot, !probs[ 6]);
96 weights[ 5] = prob2weight( c1root, probs[ 7]);
97 weights[ 6] = prob2weight( c1root, !probs[ 7]);
98 let c3root = prob2weight( c34root, probs[ 8]);
99 let c4root = prob2weight( c34root, !probs[ 8]);
100 weights[ 7] = prob2weight( c3root, probs[ 9]);
101 weights[ 8] = prob2weight( c3root, !probs[ 9]);
102 weights[ 9] = prob2weight( c4root, probs[10]);
103 weights[10] = prob2weight( c4root, !probs[10]);
104
105 self.build(&weights);
106 }
107 fn build_codes_zero_run(&mut self, probs: &[u8; 14]) {
108 let mut weights = [0u8; 9];
109
110 let root = prob2weight( probs[0], probs[1]);
111 weights[0] = prob2weight( root, probs[2]);
112 weights[1] = prob2weight( root, !probs[2]);
113
114 let root = prob2weight( probs[0], !probs[1]);
115 weights[2] = prob2weight( root, probs[3]);
116 weights[3] = prob2weight( root, !probs[3]);
117
118 let root = prob2weight(!probs[0], probs[4]);
119 weights[8] = prob2weight(!probs[0], !probs[4]);
120 let root1 = prob2weight( root, probs[5]);
121 let root2 = prob2weight( root, !probs[5]);
122 weights[4] = prob2weight( root1, probs[6]);
123 weights[5] = prob2weight( root1, !probs[6]);
124 weights[6] = prob2weight( root2, probs[7]);
125 weights[7] = prob2weight( root2, !probs[7]);
126
127 self.build(&weights);
128 }
129 fn build(&mut self, weights: &[u8]) {
130 let mut nodes = [Node::default(); MAX_HUFF_ELEMS * 2];
131 let mut nlen = 0;
132
133 for w in weights.iter().rev() {
134 let weight = *w as u16;
135 let mut pos = nlen;
136 for i in 0..nlen {
137 if nodes[i].weight > weight {
138 pos = i;
139 break;
140 }
141 }
142 for j in (pos..nlen).rev() {
143 nodes[j + 1] = nodes[j];
144 }
145 nodes[pos].weight = weight;
146 nodes[pos].sym = (weights.len() - nlen - 1) as i8;
147 nlen += 1;
148 }
149
150 let mut low = 0;
151 for _ in 0..nlen-1 {
152 let nnode = Node {
153 weight: nodes[low + 0].weight + nodes[low + 1].weight,
154 sym: -1,
155 ch0: low + 0,
156 ch1: low + 1,
157 };
158 low += 2;
159 let mut pos = low;
160 while (pos < nlen) && (nodes[pos].weight < nnode.weight) {
161 pos += 1;
162 }
163 for j in (pos..nlen).rev() {
164 nodes[j + 1] = nodes[j];
165 }
166 nodes[pos] = nnode;
167 nlen += 1;
168 }
169 self.get_codes(&nodes, nlen - 1, 0, 0);
170 for i in nlen..self.codes.len() {
171 self.codes[i] = self.codes[0];
172 self.bits[i] = self.bits[0];
173 }
174 }
175 fn get_codes(&mut self, nodes: &[Node], pos: usize, code: u16, len: u8) {
176 if nodes[pos].sym >= 0 {
177 self.codes[nodes[pos].sym as usize] = code;
178 self.bits [nodes[pos].sym as usize] = len;
179 } else {
180 self.get_codes(nodes, nodes[pos].ch0, (code << 1) | 0, len + 1);
181 self.get_codes(nodes, nodes[pos].ch1, (code << 1) | 1, len + 1);
182 }
183 }
184 }
185
186 pub trait ReadHuff {
187 fn read_huff(&mut self, huff: &VP6Huff) -> DecoderResult<u8>;
188 }
189
190 impl<'a> ReadHuff for BitReader<'a> {
191 fn read_huff(&mut self, huff: &VP6Huff) -> DecoderResult<u8> {
192 let peekval = self.peek(16);
193 for (i, (code, bit)) in huff.codes.iter().zip(huff.bits.iter()).enumerate() {
194 if (peekval >> (16 - *bit)) == (*code as u32) {
195 self.skip(*bit as u32)?;
196 return Ok(i as u8);
197 }
198 }
199 Err(DecoderError::InvalidData)
200 }
201 }
202
203 #[derive(Clone,Copy,Default)]
204 pub struct VP6HuffModels {
205 pub dc_token_tree: [VP6Huff; 2],
206 pub ac_token_tree: [[[VP6Huff; 6]; 3]; 2],
207 pub zero_run_tree: [VP6Huff; 2],
208 }
209
210 impl VP6Models {
211 fn new() -> Self {
212 Self {
213 scan_order: [0; 64],
214 scan: [0; 64],
215 zigzag: [0; 64],
216 zero_run_probs: [[0; 14]; 2],
217 }
218 }
219 }
220
221 pub struct VP56Models {
222 pub mv_models: [VP56MVModel; 2],
223 pub mbtype_models: [[VP56MBTypeModel; 10]; 3],
224 pub coeff_models: [VP56CoeffModel; 2],
225 pub prob_xmitted: [[u8; 20]; 3],
226 pub vp6models: VP6Models,
227 pub vp6huff: VP6HuffModels,
228 }
229
230 impl VP56Models {
231 fn new() -> Self {
232 Self {
233 mv_models: [VP56MVModel::default(); 2],
234 mbtype_models: [[VP56MBTypeModel::default(); 10]; 3],
235 coeff_models: [VP56CoeffModel::default(); 2],
236 prob_xmitted: [[0; 20]; 3],
237 vp6models: VP6Models::new(),
238 vp6huff: VP6HuffModels::default(),
239 }
240 }
241 }
242
243 pub trait VP56Parser {
244 fn parse_header(&mut self, bc: &mut BoolCoder) -> DecoderResult<VP56Header>;
245 fn reset_models(&self, models: &mut VP56Models);
246 fn decode_mv(&self, bc: &mut BoolCoder, model: &VP56MVModel) -> i16;
247 fn decode_mv_models(&self, bc: &mut BoolCoder, models: &mut [VP56MVModel; 2]) -> DecoderResult<()>;
248 fn decode_coeff_models(&self, bc: &mut BoolCoder, models: &mut VP56Models, is_intra: bool) -> DecoderResult<()>;
249 fn decode_block(&self, bc: &mut BoolCoder, coeffs: &mut [i16; 64], model: &VP56CoeffModel, vp6model: &VP6Models, fstate: &mut FrameState) -> DecoderResult<()>;
250 fn decode_block_huff(&self, br: &mut BitReader, coeffs: &mut [i16; 64], vp6model: &VP6Models, model: &VP6HuffModels, fstate: &mut FrameState) -> DecoderResult<()>;
251 fn mc_block(&self, dst: &mut NASimpleVideoFrame<u8>, mc_buf: NAVideoBufferRef<u8>, src: NAVideoBufferRef<u8>, plane: usize, x: usize, y: usize, mv: MV, loop_thr: i16);
252 }
253
254 enum CoeffReader<'a> {
255 None,
256 Bool(BoolCoder<'a>),
257 Huff(BitReader<'a>),
258 }
259
260 #[derive(Clone,Copy,Default)]
261 struct MBInfo {
262 mb_type: VPMBType,
263 mv: MV,
264 }
265
266 pub struct FrameState {
267 pub mb_x: usize,
268 pub mb_y: usize,
269 pub plane: usize,
270 pub coeff_cat: [[u8; 64]; 4],
271 pub last_idx: [usize; 4],
272 pub top_ctx: u8,
273 pub ctx_idx: usize,
274 pub dc_quant: i16,
275 pub ac_quant: i16,
276 pub dc_zero_run: [usize; 2],
277 pub ac_zero_run: [usize; 2],
278 }
279
280 impl FrameState {
281 fn new() -> Self {
282 Self {
283 mb_x: 0,
284 mb_y: 0,
285 plane: 0,
286 coeff_cat: [[0; 64]; 4],
287 last_idx: [0; 4],
288 top_ctx: 0,
289 ctx_idx: 0,
290 dc_quant: 0,
291 ac_quant: 0,
292 dc_zero_run: [0; 2],
293 ac_zero_run: [0; 2],
294 }
295 }
296 }
297
298 #[derive(Default)]
299 pub struct VP56DCPred {
300 dc_y: Vec<i16>,
301 dc_u: Vec<i16>,
302 dc_v: Vec<i16>,
303 ldc_y: [i16; 2],
304 ldc_u: i16,
305 ldc_v: i16,
306 ref_y: Vec<u8>,
307 ref_c: Vec<u8>,
308 ref_left: u8,
309 y_idx: usize,
310 c_idx: usize,
311 }
312
313 const INVALID_REF: u8 = 42;
314
315 impl VP56DCPred {
316 fn new() -> Self { Self::default() }
317 fn resize(&mut self, mb_w: usize) {
318 self.dc_y.resize(mb_w * 2 + 2, 0);
319 self.dc_u.resize(mb_w + 2, 0);
320 self.dc_v.resize(mb_w + 2, 0);
321 self.ref_y.resize(mb_w * 2 + 2, INVALID_REF);
322 self.ref_c.resize(mb_w + 2, INVALID_REF);
323 self.ref_c[0] = 0;
324 }
325 fn reset(&mut self) {
326 self.update_row();
327 for el in self.ref_y.iter_mut().skip(1) { *el = INVALID_REF; }
328 for el in self.ref_c.iter_mut().skip(1) { *el = INVALID_REF; }
329 }
330 fn update_row(&mut self) {
331 self.y_idx = 1;
332 self.c_idx = 1;
333 self.ldc_y = [0; 2];
334 self.ldc_u = 0;
335 self.ldc_v = 0;
336 self.ref_left = INVALID_REF;
337 }
338 fn next_mb(&mut self) {
339 self.y_idx += 2;
340 self.c_idx += 1;
341 }
342 }
343
344 pub struct VP56Decoder {
345 version: u8,
346 has_alpha: bool,
347 flip: bool,
348 shuf: VPShuffler,
349 width: usize,
350 height: usize,
351 mb_w: usize,
352 mb_h: usize,
353 models: VP56Models,
354 coeffs: [[i16; 64]; 6],
355 last_mbt: VPMBType,
356
357 loop_thr: i16,
358 ilace_prob: u8,
359 ilace_mb: bool,
360
361 mb_info: Vec<MBInfo>,
362 fstate: FrameState,
363 dc_pred: VP56DCPred,
364 last_dc: [[i16; 4]; 3],
365 top_ctx: [Vec<u8>; 4],
366
367 mc_buf: NAVideoBufferRef<u8>,
368 }
369
370 fn rescale_mb_mode_prob(prob: u32, total: u32) -> u8 {
371 (255 * prob / (1 + total)) as u8
372 }
373
374 fn map_mb_type(mbtype: VPMBType) -> usize {
375 match mbtype {
376 VPMBType::InterNoMV => 0,
377 VPMBType::Intra => 1,
378 VPMBType::InterMV => 2,
379 VPMBType::InterNearest => 3,
380 VPMBType::InterNear => 4,
381 VPMBType::GoldenNoMV => 5,
382 VPMBType::GoldenMV => 6,
383 VPMBType::InterFourMV => 7,
384 VPMBType::GoldenNearest => 8,
385 VPMBType::GoldenNear => 9,
386 }
387 }
388
389 pub fn expand_token_bc(bc: &mut BoolCoder, val_probs: &[u8; 11], token: u8, version: u8) -> i16 {
390 let mut sign = false;
391 let level;
392 if token < TOKEN_LARGE {
393 if token != 0 {
394 sign = bc.read_bool();
395 }
396 level = token as i16;
397 } else {
398 let cat: usize = vp_tree!(bc, val_probs[6],
399 vp_tree!(bc, val_probs[7], 0, 1),
400 vp_tree!(bc, val_probs[8],
401 vp_tree!(bc, val_probs[9], 2, 3),
402 vp_tree!(bc, val_probs[10], 4, 5)));
403 if version == 5 {
404 sign = bc.read_bool();
405 }
406 let mut add = 0i16;
407 let add_probs = &VP56_COEF_ADD_PROBS[cat];
408 for prob in add_probs.iter() {
409 if *prob == 128 { break; }
410 add = (add << 1) | (bc.read_prob(*prob) as i16);
411 }
412 if version != 5 {
413 sign = bc.read_bool();
414 }
415 level = VP56_COEF_BASE[cat] + add;
416 }
417 if !sign {
418 level
419 } else {
420 -level
421 }
422 }
423
424 impl VP56Decoder {
425 pub fn new(version: u8, has_alpha: bool, flip: bool) -> Self {
426 let vt = alloc_video_buffer(NAVideoInfo::new(24, 24, false, VP_YUVA420_FORMAT), 4).unwrap();
427 let mc_buf = vt.get_vbuf().unwrap();
428 Self {
429 version, has_alpha, flip,
430 shuf: VPShuffler::new(),
431 width: 0,
432 height: 0,
433 mb_w: 0,
434 mb_h: 0,
435 models: VP56Models::new(),
436 coeffs: [[0; 64]; 6],
437 last_mbt: VPMBType::InterNoMV,
438
439 loop_thr: 0,
440 ilace_prob: 0,
441 ilace_mb: false,
442
443 mb_info: Vec::new(),
444 fstate: FrameState::new(),
445 dc_pred: VP56DCPred::new(),
446 last_dc: [[0; 4]; 3],
447 top_ctx: [Vec::new(), Vec::new(), Vec::new(), Vec::new()],
448
449 mc_buf,
450 }
451 }
452 fn set_dimensions(&mut self, width: usize, height: usize) {
453 self.width = width;
454 self.height = height;
455 self.mb_w = (self.width + 15) >> 4;
456 self.mb_h = (self.height + 15) >> 4;
457 self.mb_info.resize(self.mb_w * self.mb_h, MBInfo::default());
458 self.top_ctx = [vec![0; self.mb_w * 2], vec![0; self.mb_w], vec![0; self.mb_w], vec![0; self.mb_w * 2]];
459 }
460 pub fn init(&mut self, supp: &mut NADecoderSupport, vinfo: NAVideoInfo) -> DecoderResult<()> {
461 supp.pool_u8.set_dec_bufs(3);
462 supp.pool_u8.prealloc_video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), false, vinfo.get_format()), 4)?;
463 self.set_dimensions(vinfo.get_width(), vinfo.get_height());
464 self.dc_pred.resize(self.mb_w);
465 Ok(())
466 }
467 pub fn flush(&mut self) {
468 self.shuf.clear();
469 }
470 pub fn decode_frame(&mut self, supp: &mut NADecoderSupport, src: &[u8], br: &mut dyn VP56Parser) -> DecoderResult<(NABufferType, FrameType)> {
471 let aoffset;
472 let mut bc;
473 if self.has_alpha {
474 validate!(src.len() >= 7);
475 aoffset = ((src[0] as usize) << 16) | ((src[1] as usize) << 8) | (src[2] as usize);
476 validate!((aoffset > 0) && (aoffset < src.len() - 3));
477 bc = BoolCoder::new(&src[3..])?;
478 } else {
479 validate!(src.len() >= 4);
480 aoffset = src.len();
481 bc = BoolCoder::new(src)?;
482 }
483 let hdr = br.parse_header(&mut bc)?;
484 validate!((hdr.offset as usize) < aoffset); //XXX: take alpha 3 byte offset into account?
485
486 if hdr.mb_w != 0 {
487 self.set_dimensions((hdr.mb_w as usize) * 16, (hdr.mb_h as usize) * 16);
488 }
489 let fmt = if !self.has_alpha {
490 YUV420_FORMAT
491 } else {
492 VP_YUVA420_FORMAT
493 };
494 let vinfo = NAVideoInfo::new(self.width, self.height, self.flip, fmt);
495 let ret = supp.pool_u8.get_free();
496 if ret.is_none() {
497 return Err(DecoderError::AllocError);
498 }
499 let mut buf = ret.unwrap();
500 if buf.get_info() != vinfo {
501 self.shuf.clear();
502 supp.pool_u8.reset();
503 supp.pool_u8.prealloc_video(vinfo, 4)?;
504 let ret = supp.pool_u8.get_free();
505 if ret.is_none() {
506 return Err(DecoderError::AllocError);
507 }
508 buf = ret.unwrap();
509 }
510 let mut dframe = NASimpleVideoFrame::from_video_buf(&mut buf).unwrap();
511
512 if hdr.is_intra {
513 self.shuf.clear();
514 } else {
515 if !self.shuf.has_refs() {
516 return Err(DecoderError::MissingReference);
517 }
518 }
519
520 let mut cr;
521 if hdr.multistream {
522 let off = (if self.has_alpha { 3 } else { 0 }) + (hdr.offset as usize);
523 if !hdr.use_huffman {
524 let bc2 = BoolCoder::new(&src[off..])?;
525 cr = CoeffReader::Bool(bc2);
526 } else {
527 let br = BitReader::new(&src[off..], aoffset - off, BitReaderMode::BE);
528 cr = CoeffReader::Huff(br);
529 }
530 } else {
531 cr = CoeffReader::None;
532 }
533
534 if hdr.is_intra {
535 br.reset_models(&mut self.models);
536 self.reset_mbtype_models();
537 } else {
538 self.decode_mode_prob_models(&mut bc)?;
539 br.decode_mv_models(&mut bc, &mut self.models.mv_models)?;
540 }
541 br.decode_coeff_models(&mut bc, &mut self.models, hdr.is_intra)?;
542 if hdr.use_huffman {
543 for i in 0..2 {
544 self.models.vp6huff.dc_token_tree[i].build_codes(&self.models.coeff_models[i].dc_value_probs);
545 }
546 for i in 0..2 {
547 for mode in 0..3 {
548 for band in 0..6 {
549 self.models.vp6huff.ac_token_tree[i][mode][band].build_codes(&self.models.coeff_models[i].ac_val_probs[mode][band]);
550 }
551 }
552 }
553 for i in 0..2 {
554 self.models.vp6huff.zero_run_tree[i].build_codes_zero_run(&self.models.vp6models.zero_run_probs[i]);
555 }
556 }
557
558 if hdr.interlaced {
559 self.ilace_prob = bc.read_bits(8) as u8;
560 }
561
562 self.fstate = FrameState::new();
563 self.fstate.dc_quant = VP56_DC_QUANTS[hdr.quant as usize] * 4;
564 self.fstate.ac_quant = VP56_AC_QUANTS[hdr.quant as usize] * 4;
565 self.loop_thr = VP56_FILTER_LIMITS[hdr.quant as usize] as i16;
566
567 self.last_mbt = VPMBType::InterNoMV;
568 for vec in self.top_ctx.iter_mut() {
569 for el in vec.iter_mut() {
570 *el = 0;
571 }
572 }
573 self.last_dc = [[0; 4]; 3];
574 self.last_dc[0][1] = 0x80;
575 self.last_dc[0][2] = 0x80;
576 self.dc_pred.reset();
577
578 self.ilace_mb = false;
579 for mb_y in 0..self.mb_h {
580 self.fstate.mb_y = mb_y;
581 self.fstate.coeff_cat = [[0; 64]; 4];
582 self.fstate.last_idx = [24; 4];
583 for mb_x in 0..self.mb_w {
584 self.fstate.mb_x = mb_x;
585 self.decode_mb(&mut dframe, &mut bc, &mut cr, br, &hdr, false)?;
586 self.dc_pred.next_mb();
587 }
588 self.dc_pred.update_row();
589 }
590
591 if self.has_alpha {
592 let asrc = &src[aoffset + 3..];
593 let mut bc = BoolCoder::new(asrc)?;
594 let ahdr = br.parse_header(&mut bc)?;
595 validate!(ahdr.mb_w == hdr.mb_w && ahdr.mb_h == hdr.mb_h);
596 }
597
598 if hdr.is_golden {
599 self.shuf.add_golden_frame(buf.clone());
600 }
601 self.shuf.add_frame(buf.clone());
602
603 Ok((NABufferType::Video(buf), if hdr.is_intra { FrameType::I } else { FrameType::P }))
604 }
605 fn reset_mbtype_models(&mut self) {
606 const DEFAULT_XMITTED_PROBS: [[u8; 20]; 3] = [
607 [ 42, 69, 2, 1, 7, 1, 42, 44, 22, 6, 3, 1, 2, 0, 5, 1, 1, 0, 0, 0 ],
608 [ 8, 229, 1, 1, 8, 0, 0, 0, 0, 0, 2, 1, 1, 0, 0, 0, 1, 1, 0, 0 ],
609 [ 35, 122, 1, 1, 6, 1, 34, 46, 0, 0, 2, 1, 1, 0, 1, 0, 1, 1, 0, 0 ]
610 ];
611 self.models.prob_xmitted.copy_from_slice(&DEFAULT_XMITTED_PROBS);
612 }
613 fn decode_mode_prob_models(&mut self, bc: &mut BoolCoder) -> DecoderResult<()> {
614 for ctx in 0..3 {
615 if bc.read_prob(174) {
616 let idx = bc.read_bits(4) as usize;
617 for i in 0..20 {
618 self.models.prob_xmitted[ctx][i ^ 1] = VP56_MODE_VQ[ctx][idx][i];
619 }
620 }
621 if bc.read_prob(254) {
622 for set in 0..20 {
623 if bc.read_prob(205) {
624 let sign = bc.read_bool();
625 let diff = vp_tree!(bc, 171,
626 vp_tree!(bc, 83, 2, 1),
627 vp_tree!(bc, 199,
628 vp_tree!(bc, 140,
629 vp_tree!(bc, 125,
630 vp_tree!(bc, 104, 6, 5),
631 4
632 ),
633 3
634 ),
635 bc.read_bits(7)
636 )) * 4;
637 validate!(diff < 256);
638 let diff = diff as u8;
639 if !sign {
640 validate!(self.models.prob_xmitted[ctx][set ^ 1] <= 255 - diff);
641 self.models.prob_xmitted[ctx][set ^ 1] += diff;
642 } else {
643 validate!(self.models.prob_xmitted[ctx][set ^ 1] >= diff);
644 self.models.prob_xmitted[ctx][set ^ 1] -= diff;
645 }
646 }
647 }
648 }
649 }
650 for ctx in 0..3 {
651 let prob_xmitted = &self.models.prob_xmitted[ctx];
652 for mode in 0..10 {
653 let mdl = &mut self.models.mbtype_models[ctx][mode];
654 let mut cnt = [0u32; 10];
655 let mut total = 0;
656 for i in 0..10 {
657 if i == mode { continue; }
658 cnt[i] = 100 * (prob_xmitted[i * 2] as u32);
659 total += cnt[i];
660 }
661 let sum = (prob_xmitted[mode * 2] as u32) + (prob_xmitted[mode * 2 + 1] as u32);
662 mdl.probs[9] = 255 - rescale_mb_mode_prob(prob_xmitted[mode * 2 + 1] as u32, sum);
663
664 let inter_mv0_weight = (cnt[0] as u32) + (cnt[2] as u32);
665 let inter_mv1_weight = (cnt[3] as u32) + (cnt[4] as u32);
666 let gold_mv0_weight = (cnt[5] as u32) + (cnt[6] as u32);
667 let gold_mv1_weight = (cnt[8] as u32) + (cnt[9] as u32);
668 let mix_weight = (cnt[1] as u32) + (cnt[7] as u32);
669 mdl.probs[0] = 1 + rescale_mb_mode_prob(inter_mv0_weight + inter_mv1_weight, total);
670 mdl.probs[1] = 1 + rescale_mb_mode_prob(inter_mv0_weight, inter_mv0_weight + inter_mv1_weight);
671 mdl.probs[2] = 1 + rescale_mb_mode_prob(mix_weight, mix_weight + gold_mv0_weight + gold_mv1_weight);
672 mdl.probs[3] = 1 + rescale_mb_mode_prob(cnt[0] as u32, inter_mv0_weight);
673 mdl.probs[4] = 1 + rescale_mb_mode_prob(cnt[3] as u32, inter_mv1_weight);
674 mdl.probs[5] = 1 + rescale_mb_mode_prob(cnt[1], mix_weight);
675 mdl.probs[6] = 1 + rescale_mb_mode_prob(gold_mv0_weight, gold_mv0_weight + gold_mv1_weight);
676 mdl.probs[7] = 1 + rescale_mb_mode_prob(cnt[5], gold_mv0_weight);
677 mdl.probs[8] = 1 + rescale_mb_mode_prob(cnt[8], gold_mv1_weight);
678 }
679 }
680 Ok(())
681 }
682 fn find_mv_pred(&self, ref_id: u8) -> (usize, MV, MV, MV) {
683 const CAND_POS: [(i8, i8); 12] = [
684 (-1, 0), ( 0, -1),
685 (-1, -1), (-1, 1),
686 (-2, 0), ( 0, -2),
687 (-1, -2), (-2, -1),
688 (-2, 1), (-1, 2),
689 (-2, -2), (-2, 2)
690 ];
691
692 let mut nearest_mv = ZERO_MV;
693 let mut near_mv = ZERO_MV;
694 let mut pred_mv = ZERO_MV;
695 let mut num_mv: usize = 0;
696
697 for (i, (yoff, xoff)) in CAND_POS.iter().enumerate() {
698 let cx = (self.fstate.mb_x as isize) + (*xoff as isize);
699 let cy = (self.fstate.mb_y as isize) + (*yoff as isize);
700 if (cx < 0) || (cy < 0) {
701 continue;
702 }
703 let cx = cx as usize;
704 let cy = cy as usize;
705 if (cx >= self.mb_w) || (cy >= self.mb_h) {
706 continue;
707 }
708 let mb_pos = cx + cy * self.mb_w;
709 let mv = self.mb_info[mb_pos].mv;
710 if (self.mb_info[mb_pos].mb_type.get_ref_id() != ref_id) || (mv == ZERO_MV) {
711 continue;
712 }
713 if num_mv == 0 {
714 nearest_mv = mv;
715 num_mv += 1;
716 if (self.version > 5) && (i < 2) {
717 pred_mv = mv;
718 }
719 } else if mv != nearest_mv {
720 near_mv = mv;
721 num_mv += 1;
722 break;
723 }
724 }
725
726 (num_mv, nearest_mv, near_mv, pred_mv)
727 }
728 fn decode_mv(&self, bc: &mut BoolCoder, br: &mut dyn VP56Parser) -> MV {
729 let x = br.decode_mv(bc, &self.models.mv_models[0]);
730 let y = br.decode_mv(bc, &self.models.mv_models[1]);
731 MV{ x, y }
732 }
733 fn decode_mb_type(&mut self, bc: &mut BoolCoder, ctx: usize) -> DecoderResult<VPMBType> {
734 let probs = &self.models.mbtype_models[ctx][map_mb_type(self.last_mbt)].probs;
735 if !bc.read_prob(probs[9]) {
736 self.last_mbt = vp_tree!(
737 bc, probs[0],
738 vp_tree!(bc, probs[1],
739 vp_tree!(bc, probs[3], VPMBType::InterNoMV, VPMBType::InterMV),
740 vp_tree!(bc, probs[4], VPMBType::InterNearest, VPMBType::InterNear)
741 ),
742 vp_tree!(bc, probs[2],
743 vp_tree!(bc, probs[5], VPMBType::Intra, VPMBType::InterFourMV),
744 vp_tree!(bc, probs[6],
745 vp_tree!(bc, probs[7], VPMBType::GoldenNoMV, VPMBType::GoldenMV),
746 vp_tree!(bc, probs[8], VPMBType::GoldenNearest, VPMBType::GoldenNear)
747 )
748 )
749 );
750 }
751 Ok(self.last_mbt)
752 }
753 fn decode_mb(&mut self, frm: &mut NASimpleVideoFrame<u8>, bc: &mut BoolCoder, cr: &mut CoeffReader, br: &mut dyn VP56Parser, hdr: &VP56Header, alpha: bool) -> DecoderResult<()> {
754 const FOURMV_SUB_TYPE: [VPMBType; 4] = [ VPMBType::InterNoMV, VPMBType::InterMV, VPMBType::InterNearest, VPMBType::InterNear ];
755
756 let mb_x = self.fstate.mb_x;
757 let mb_y = self.fstate.mb_y;
758 self.coeffs = [[0; 64]; 6];
759 let mb_pos = mb_x + mb_y * self.mb_w;
760 let mut four_mv = [ZERO_MV; 4];
761 let mut four_mbt = [VPMBType::Intra; 4];
762
763 if hdr.interlaced {
764 let iprob = self.ilace_prob;
765 let prob = if mb_x == 0 {
766 iprob
767 } else if !self.ilace_mb {
768 iprob + (((256 - (iprob as u16)) >> 1) as u8)
769 } else {
770 iprob - (iprob >> 1)
771 };
772 self.ilace_mb = bc.read_prob(prob);
773 }
774
775 let (num_mv, nearest_mv, near_mv, pred_mv) = if hdr.is_intra {
776 (0, ZERO_MV, ZERO_MV, ZERO_MV)
777 } else { self.find_mv_pred(VP_REF_INTER) };
778 let mb_type = if hdr.is_intra {
779 VPMBType::Intra
780 } else {
781 self.decode_mb_type(bc, (num_mv + 1) % 3)?
782 };
783 self.mb_info[mb_pos].mb_type = mb_type;
784 if mb_type.get_ref_id() != VP_REF_GOLDEN {
785 match mb_type {
786 VPMBType::Intra |
787 VPMBType::InterNoMV => {
788 self.mb_info[mb_pos].mv = ZERO_MV;
789 },
790 VPMBType::InterMV => {
791 let diff_mv = self.decode_mv(bc, br);
792 self.mb_info[mb_pos].mv = pred_mv + diff_mv;
793 },
794 VPMBType::InterNearest => {
795 self.mb_info[mb_pos].mv = nearest_mv;
796 },
797 VPMBType::InterNear => {
798 self.mb_info[mb_pos].mv = near_mv;
799 },
800 VPMBType::InterFourMV => {
801 for i in 0..4 {
802 four_mbt[i] = FOURMV_SUB_TYPE[bc.read_bits(2) as usize];
803 }
804 for i in 0..4 {
805 match four_mbt[i] {
806 VPMBType::InterNoMV => {},
807 VPMBType::InterMV => {
808 let diff_mv = self.decode_mv(bc, br);
809 four_mv[i] = pred_mv + diff_mv;
810 },
811 VPMBType::InterNearest => {
812 four_mv[i] = nearest_mv;
813 },
814 VPMBType::InterNear => {
815 four_mv[i] = near_mv;
816 },
817 _ => unreachable!(),
818 };
819 }
820 self.mb_info[mb_pos].mv = four_mv[3];
821 },
822 _ => unreachable!(),
823 };
824 } else {
825 let (_num_mv, nearest_mv, near_mv, pred_mv) = self.find_mv_pred(VP_REF_GOLDEN);
826 match mb_type {
827 VPMBType::GoldenNoMV => {
828 self.mb_info[mb_pos].mv = ZERO_MV;
829 },
830 VPMBType::GoldenMV => {
831 let diff_mv = self.decode_mv(bc, br);
832 self.mb_info[mb_pos].mv = pred_mv + diff_mv;
833 },
834 VPMBType::GoldenNearest => {
835 self.mb_info[mb_pos].mv = nearest_mv;
836 },
837 VPMBType::GoldenNear => {
838 self.mb_info[mb_pos].mv = near_mv;
839 },
840 _ => unreachable!(),
841 };
842 }
843 if !mb_type.is_intra() && (mb_type != VPMBType::InterFourMV) {
844 self.do_mc(br, frm, mb_type, self.mb_info[mb_pos].mv, alpha);
845 } else if mb_type == VPMBType::InterFourMV {
846 self.do_fourmv(br, frm, &four_mv, alpha);
847 }
848
849 for blk_no in 0..4 {
850 self.fstate.plane = if !alpha { 0 } else { 3 };
851 self.fstate.ctx_idx = blk_no >> 1;
852 self.fstate.top_ctx = self.top_ctx[self.fstate.plane][mb_x * 2 + (blk_no & 1)];
853 match cr {
854 CoeffReader::None => {
855 br.decode_block(bc, &mut self.coeffs[blk_no], &self.models.coeff_models[0], &self.models.vp6models, &mut self.fstate)?;
856 },
857 CoeffReader::Bool(ref mut bcc) => {
858 br.decode_block(bcc, &mut self.coeffs[blk_no], &self.models.coeff_models[0], &self.models.vp6models, &mut self.fstate)?;
859 },
860 CoeffReader::Huff(ref mut brc) => {
861 br.decode_block_huff(brc, &mut self.coeffs[blk_no], &self.models.vp6models, &self.models.vp6huff, &mut self.fstate)?;
862 },
863 };
864 self.top_ctx[self.fstate.plane][mb_x * 2 + (blk_no & 1)] = self.fstate.top_ctx;
865 self.predict_dc(mb_type, mb_pos, blk_no, alpha);
866
867 let bx = mb_x * 2 + (blk_no & 1);
868 let by = mb_y * 2 + (blk_no >> 1);
869 let has_ac = self.fstate.last_idx[self.fstate.ctx_idx] > 0;
870 if mb_type.is_intra() {
871 if !self.ilace_mb {
872 if has_ac {
873 vp_put_block(&mut self.coeffs[blk_no], bx, by, self.fstate.plane, frm);
874 } else {
875 vp_put_block_dc(&mut self.coeffs[blk_no], bx, by, self.fstate.plane, frm);
876 }
877 } else {
878 vp_put_block_ilace(&mut self.coeffs[blk_no], bx, by, self.fstate.plane, frm);
879 }
880 } else {
881 if !self.ilace_mb {
882 if has_ac {
883 vp_add_block(&mut self.coeffs[blk_no], bx, by, self.fstate.plane, frm);
884 } else {
885 vp_add_block_dc(&mut self.coeffs[blk_no], bx, by, self.fstate.plane, frm);
886 }
887 } else {
888 vp_add_block_ilace(&mut self.coeffs[blk_no], bx, by, self.fstate.plane, frm);
889 }
890 }
891 }
892 if !alpha {
893 for blk_no in 4..6 {
894 self.fstate.plane = blk_no - 3;
895 self.fstate.ctx_idx = blk_no - 2;
896 self.fstate.top_ctx = self.top_ctx[self.fstate.plane][mb_x];
897 match cr {
898 CoeffReader::None => {
899 br.decode_block(bc, &mut self.coeffs[blk_no], &self.models.coeff_models[1], &self.models.vp6models, &mut self.fstate)?;
900 },
901 CoeffReader::Bool(ref mut bcc) => {
902 br.decode_block(bcc, &mut self.coeffs[blk_no], &self.models.coeff_models[1], &self.models.vp6models, &mut self.fstate)?;
903 },
904 CoeffReader::Huff(ref mut brc) => {
905 br.decode_block_huff(brc, &mut self.coeffs[blk_no], &self.models.vp6models, &self.models.vp6huff, &mut self.fstate)?;
906 },
907 };
908 self.top_ctx[self.fstate.plane][mb_x] = self.fstate.top_ctx;
909 self.predict_dc(mb_type, mb_pos, blk_no, alpha);
910
911 let has_ac = self.fstate.last_idx[self.fstate.ctx_idx] > 0;
912 if mb_type.is_intra() {
913 if has_ac {
914 vp_put_block(&mut self.coeffs[blk_no], mb_x, mb_y, self.fstate.plane, frm);
915 } else {
916 vp_put_block_dc(&mut self.coeffs[blk_no], mb_x, mb_y, self.fstate.plane, frm);
917 }
918 } else {
919 if has_ac {
920 vp_add_block(&mut self.coeffs[blk_no], mb_x, mb_y, self.fstate.plane, frm);
921 } else {
922 vp_add_block_dc(&mut self.coeffs[blk_no], mb_x, mb_y, self.fstate.plane, frm);
923 }
924 }
925 }
926 }
927 Ok(())
928 }
929 fn do_mc(&mut self, br: &dyn VP56Parser, frm: &mut NASimpleVideoFrame<u8>, mb_type: VPMBType, mv: MV, alpha: bool) {
930 let x = self.fstate.mb_x * 16;
931 let y = self.fstate.mb_y * 16;
932 let plane = if !alpha { 0 } else { 3 };
933 let src = if mb_type.get_ref_id() == VP_REF_INTER {
934 self.shuf.get_last().unwrap()
935 } else {
936 self.shuf.get_golden().unwrap()
937 };
938
939 br.mc_block(frm, self.mc_buf.clone(), src.clone(), plane, x + 0, y + 0, mv, self.loop_thr);
940 br.mc_block(frm, self.mc_buf.clone(), src.clone(), plane, x + 8, y + 0, mv, self.loop_thr);
941 br.mc_block(frm, self.mc_buf.clone(), src.clone(), plane, x + 0, y + 8, mv, self.loop_thr);
942 br.mc_block(frm, self.mc_buf.clone(), src.clone(), plane, x + 8, y + 8, mv, self.loop_thr);
943 if !alpha {
944 let x = self.fstate.mb_x * 8;
945 let y = self.fstate.mb_y * 8;
946 br.mc_block(frm, self.mc_buf.clone(), src.clone(), 1, x, y, mv, self.loop_thr);
947 br.mc_block(frm, self.mc_buf.clone(), src.clone(), 2, x, y, mv, self.loop_thr);
948 }
949 }
950 fn do_fourmv(&mut self, br: &dyn VP56Parser, frm: &mut NASimpleVideoFrame<u8>, mvs: &[MV; 4], alpha: bool) {
951 let x = self.fstate.mb_x * 16;
952 let y = self.fstate.mb_y * 16;
953 let plane = if !alpha { 0 } else { 3 };
954 let src = self.shuf.get_last().unwrap();
955 for blk_no in 0..4 {
956 br.mc_block(frm, self.mc_buf.clone(), src.clone(),
957 plane, x + (blk_no & 1) * 8, y + (blk_no & 2) * 4,
958 mvs[blk_no], self.loop_thr);
959 }
960 if !alpha {
961 let x = self.fstate.mb_x * 8;
962 let y = self.fstate.mb_y * 8;
963 let sum = mvs[0] + mvs[1] + mvs[2] + mvs[3];
964 let mv = MV { x: sum.x / 4, y: sum.y / 4 };
965 br.mc_block(frm, self.mc_buf.clone(), src.clone(), 1, x, y, mv, self.loop_thr);
966 br.mc_block(frm, self.mc_buf.clone(), src.clone(), 2, x, y, mv, self.loop_thr);
967 }
968 }
969 fn predict_dc(&mut self, mb_type: VPMBType, _mb_pos: usize, blk_no: usize, _alpha: bool) {
970 let is_luma = blk_no < 4;
971 let (plane, dcs) = match blk_no {
972 4 => (1, &mut self.dc_pred.dc_u),
973 5 => (2, &mut self.dc_pred.dc_v),
974 _ => (0, &mut self.dc_pred.dc_y),
975 };
976 let (dc_ref, dc_idx) = if is_luma {
977 (&mut self.dc_pred.ref_y, self.dc_pred.y_idx + (blk_no & 1))
978 } else {
979 (&mut self.dc_pred.ref_c, self.dc_pred.c_idx)
980 };
981 let ref_id = mb_type.get_ref_id();
982 let mut dc_pred = 0;
983 let mut count = 0;
984 let has_left_blk = is_luma && ((blk_no & 1) == 1);
985 if has_left_blk || self.dc_pred.ref_left == ref_id {
986 dc_pred += match blk_no {
987 0 | 1 => self.dc_pred.ldc_y[0],
988 2 | 3 => self.dc_pred.ldc_y[1],
989 4 => self.dc_pred.ldc_u,
990 _ => self.dc_pred.ldc_v,
991 };
992 count += 1;
993 }
994 if dc_ref[dc_idx] == ref_id {
995 dc_pred += dcs[dc_idx];
996 count += 1;
997 }
998 if self.version == 5 {
999 if (count < 2) && (dc_ref[dc_idx - 1] == ref_id) {
1000 dc_pred += dcs[dc_idx - 1];
1001 count += 1;
1002 }
1003 if (count < 2) && (dc_ref[dc_idx + 1] == ref_id) {
1004 dc_pred += dcs[dc_idx + 1];
1005 count += 1;
1006 }
1007 }
1008 if count == 0 {
1009 dc_pred = self.last_dc[ref_id as usize][plane];
1010 } else if count == 2 {
1011 dc_pred /= 2;
1012 }
1013 self.coeffs[blk_no][0] += dc_pred;
1014
1015 let dc = self.coeffs[blk_no][0];
1016 if blk_no != 4 { // update top block reference only for the second chroma component
1017 dc_ref[dc_idx] = ref_id;
1018 }
1019 match blk_no {
1020 0 | 1 => {
1021 self.dc_pred.ldc_y[0] = dc;
1022 },
1023 2 | 3 => {
1024 self.dc_pred.ldc_y[1] = dc;
1025 },
1026 4 => {
1027 self.dc_pred.ldc_u = dc;
1028 },
1029 _ => {
1030 self.dc_pred.ldc_v = dc;
1031 self.dc_pred.ref_left = ref_id;
1032 },
1033 };
1034 dcs[dc_idx] = dc;
1035
1036 self.last_dc[ref_id as usize][plane] = dc;
1037 self.coeffs[blk_no][0] = self.coeffs[blk_no][0].wrapping_mul(self.fstate.dc_quant);
1038 }
1039 }
1040
1041 const VP56_DC_QUANTS: [i16; 64] = [
1042 47, 47, 47, 47, 45, 43, 43, 43,
1043 43, 43, 42, 41, 41, 40, 40, 40,
1044 40, 35, 35, 35, 35, 33, 33, 33,
1045 33, 32, 32, 32, 27, 27, 26, 26,
1046 25, 25, 24, 24, 23, 23, 19, 19,
1047 19, 19, 18, 18, 17, 16, 16, 16,
1048 16, 16, 15, 11, 11, 11, 10, 10,
1049 9, 8, 7, 5, 3, 3, 2, 2
1050 ];
1051 const VP56_AC_QUANTS: [i16; 64] = [
1052 94, 92, 90, 88, 86, 82, 78, 74,
1053 70, 66, 62, 58, 54, 53, 52, 51,
1054 50, 49, 48, 47, 46, 45, 44, 43,
1055 42, 40, 39, 37, 36, 35, 34, 33,
1056 32, 31, 30, 29, 28, 27, 26, 25,
1057 24, 23, 22, 21, 20, 19, 18, 17,
1058 16, 15, 14, 13, 12, 11, 10, 9,
1059 8, 7, 6, 5, 4, 3, 2, 1
1060 ];
1061
1062 const VP56_FILTER_LIMITS: [u8; 64] = [
1063 14, 14, 13, 13, 12, 12, 10, 10,
1064 10, 10, 8, 8, 8, 8, 8, 8,
1065 8, 8, 8, 8, 8, 8, 8, 8,
1066 8, 8, 8, 8, 8, 8, 8, 8,
1067 8, 8, 8, 8, 7, 7, 7, 7,
1068 7, 7, 6, 6, 6, 6, 6, 6,
1069 5, 5, 5, 5, 4, 4, 4, 4,
1070 4, 4, 4, 3, 3, 3, 3, 2
1071 ];
1072
1073 const VP56_MODE_VQ: [[[u8; 20]; 16]; 3] = [
1074 [
1075 [ 9, 15, 32, 25, 7, 19, 9, 21, 1, 12, 14, 12, 3, 18, 14, 23, 3, 10, 0, 4 ],
1076 [ 48, 39, 1, 2, 11, 27, 29, 44, 7, 27, 1, 4, 0, 3, 1, 6, 1, 2, 0, 0 ],
1077 [ 21, 32, 1, 2, 4, 10, 32, 43, 6, 23, 2, 3, 1, 19, 1, 6, 12, 21, 0, 7 ],
1078 [ 69, 83, 0, 0, 0, 2, 10, 29, 3, 12, 0, 1, 0, 3, 0, 3, 2, 2, 0, 0 ],
1079 [ 11, 20, 1, 4, 18, 36, 43, 48, 13, 35, 0, 2, 0, 5, 3, 12, 1, 2, 0, 0 ],
1080 [ 70, 44, 0, 1, 2, 10, 37, 46, 8, 26, 0, 2, 0, 2, 0, 2, 0, 1, 0, 0 ],
1081 [ 8, 15, 0, 1, 8, 21, 74, 53, 22, 42, 0, 1, 0, 2, 0, 3, 1, 2, 0, 0 ],
1082 [ 141, 42, 0, 0, 1, 4, 11, 24, 1, 11, 0, 1, 0, 1, 0, 2, 0, 0, 0, 0 ],
1083 [ 8, 19, 4, 10, 24, 45, 21, 37, 9, 29, 0, 3, 1, 7, 11, 25, 0, 2, 0, 1 ],
1084 [ 46, 42, 0, 1, 2, 10, 54, 51, 10, 30, 0, 2, 0, 2, 0, 1, 0, 1, 0, 0 ],
1085 [ 28, 32, 0, 0, 3, 10, 75, 51, 14, 33, 0, 1, 0, 2, 0, 1, 1, 2, 0, 0 ],
1086 [ 100, 46, 0, 1, 3, 9, 21, 37, 5, 20, 0, 1, 0, 2, 1, 2, 0, 1, 0, 0 ],
1087 [ 27, 29, 0, 1, 9, 25, 53, 51, 12, 34, 0, 1, 0, 3, 1, 5, 0, 2, 0, 0 ],
1088 [ 80, 38, 0, 0, 1, 4, 69, 33, 5, 16, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0 ],
1089 [ 16, 20, 0, 0, 2, 8, 104, 49, 15, 33, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0 ],
1090 [ 194, 16, 0, 0, 1, 1, 1, 9, 1, 3, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0 ],
1091 ], [
1092 [ 41, 22, 1, 0, 1, 31, 0, 0, 0, 0, 0, 1, 1, 7, 0, 1, 98, 25, 4, 10 ],
1093 [ 123, 37, 6, 4, 1, 27, 0, 0, 0, 0, 5, 8, 1, 7, 0, 1, 12, 10, 0, 2 ],
1094 [ 26, 14, 14, 12, 0, 24, 0, 0, 0, 0, 55, 17, 1, 9, 0, 36, 5, 7, 1, 3 ],
1095 [ 209, 5, 0, 0, 0, 27, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0 ],
1096 [ 2, 5, 4, 5, 0, 121, 0, 0, 0, 0, 0, 3, 2, 4, 1, 4, 2, 2, 0, 1 ],
1097 [ 175, 5, 0, 1, 0, 48, 0, 0, 0, 0, 0, 2, 0, 1, 0, 2, 0, 1, 0, 0 ],
1098 [ 83, 5, 2, 3, 0, 102, 0, 0, 0, 0, 1, 3, 0, 2, 0, 1, 0, 0, 0, 0 ],
1099 [ 233, 6, 0, 0, 0, 8, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0 ],
1100 [ 34, 16, 112, 21, 1, 28, 0, 0, 0, 0, 6, 8, 1, 7, 0, 3, 2, 5, 0, 2 ],
1101 [ 159, 35, 2, 2, 0, 25, 0, 0, 0, 0, 3, 6, 0, 5, 0, 1, 4, 4, 0, 1 ],
1102 [ 75, 39, 5, 7, 2, 48, 0, 0, 0, 0, 3, 11, 2, 16, 1, 4, 7, 10, 0, 2 ],
1103 [ 212, 21, 0, 1, 0, 9, 0, 0, 0, 0, 1, 2, 0, 2, 0, 0, 2, 2, 0, 0 ],
1104 [ 4, 2, 0, 0, 0, 172, 0, 0, 0, 0, 0, 1, 0, 2, 0, 0, 2, 0, 0, 0 ],
1105 [ 187, 22, 1, 1, 0, 17, 0, 0, 0, 0, 3, 6, 0, 4, 0, 1, 4, 4, 0, 1 ],
1106 [ 133, 6, 1, 2, 1, 70, 0, 0, 0, 0, 0, 2, 0, 4, 0, 3, 1, 1, 0, 0 ],
1107 [ 251, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
1108 ], [
1109 [ 2, 3, 2, 3, 0, 2, 0, 2, 0, 0, 11, 4, 1, 4, 0, 2, 3, 2, 0, 4 ],
1110 [ 49, 46, 3, 4, 7, 31, 42, 41, 0, 0, 2, 6, 1, 7, 1, 4, 2, 4, 0, 1 ],
1111 [ 26, 25, 1, 1, 2, 10, 67, 39, 0, 0, 1, 1, 0, 14, 0, 2, 31, 26, 1, 6 ],
1112 [ 103, 46, 1, 2, 2, 10, 33, 42, 0, 0, 1, 4, 0, 3, 0, 1, 1, 3, 0, 0 ],
1113 [ 14, 31, 9, 13, 14, 54, 22, 29, 0, 0, 2, 6, 4, 18, 6, 13, 1, 5, 0, 1 ],
1114 [ 85, 39, 0, 0, 1, 9, 69, 40, 0, 0, 0, 1, 0, 3, 0, 1, 2, 3, 0, 0 ],
1115 [ 31, 28, 0, 0, 3, 14, 130, 34, 0, 0, 0, 1, 0, 3, 0, 1, 3, 3, 0, 1 ],
1116 [ 171, 25, 0, 0, 1, 5, 25, 21, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0 ],
1117 [ 17, 21, 68, 29, 6, 15, 13, 22, 0, 0, 6, 12, 3, 14, 4, 10, 1, 7, 0, 3 ],
1118 [ 51, 39, 0, 1, 2, 12, 91, 44, 0, 0, 0, 2, 0, 3, 0, 1, 2, 3, 0, 1 ],
1119 [ 81, 25, 0, 0, 2, 9, 106, 26, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0 ],
1120 [ 140, 37, 0, 1, 1, 8, 24, 33, 0, 0, 1, 2, 0, 2, 0, 1, 1, 2, 0, 0 ],
1121 [ 14, 23, 1, 3, 11, 53, 90, 31, 0, 0, 0, 3, 1, 5, 2, 6, 1, 2, 0, 0 ],
1122 [ 123, 29, 0, 0, 1, 7, 57, 30, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0 ],
1123 [ 13, 14, 0, 0, 4, 20, 175, 20, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0 ],
1124 [ 202, 23, 0, 0, 1, 3, 2, 9, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0 ],
1125 ]
1126 ];
1127
NihAV is a research multimedia framework