nihav-duck/src/codecs/vp5.rs

   1 use nihav_core::codecs::*;
   2 use nihav_core::io::bitreader::*;
   3 use super::vpcommon::*;
   4 use super::vp56::*;
   5
   6 struct VP5BR {}
   7
   8 impl VP5BR {
   9     fn new() -> Self {
  10         Self {}
  11     }
  12 }
  13
  14 impl VP56Parser for VP5BR {
  15     fn parse_header(&mut self, bc: &mut BoolCoder) -> DecoderResult<VP56Header> {
  16         let mut hdr = VP56Header::default();
  17         hdr.is_intra                            = !bc.read_bool();
  18         hdr.is_golden = hdr.is_intra;
  19                                                   bc.read_bool();
  20         hdr.quant                               = bc.read_bits(6) as u8;
  21         if hdr.is_intra {
  22             hdr.version                         = bc.read_bits(13) as u8;
  23             validate!(hdr.version == 5);
  24             hdr.profile                         = bc.read_bits(2) as u8;
  25             hdr.interlaced                      = bc.read_bool();
  26             validate!(!hdr.interlaced);
  27             hdr.mb_h                            = bc.read_bits(8) as u8;
  28             hdr.mb_w                            = bc.read_bits(8) as u8;
  29             hdr.disp_h                          = bc.read_bits(8) as u8;
  30             hdr.disp_w                          = bc.read_bits(8) as u8;
  31             validate!((hdr.mb_h > 0) && (hdr.mb_w > 0) && (hdr.disp_w > 0) && (hdr.disp_h > 0));
  32             validate!((hdr.disp_w <= hdr.mb_w) && (hdr.disp_h <= hdr.mb_h));
  33             hdr.scale                           = bc.read_bits(2) as u8;
  34         }
  35
  36         Ok(hdr)
  37     }
  38     fn decode_mv(&self, bc: &mut BoolCoder, model: &VP56MVModel) -> i16 {
  39         if bc.read_prob(model.nz_prob) {
  40             let sign                            = bc.read_prob(model.sign_prob);
  41             let b0                              = bc.read_prob(model.raw_probs[0]) as i16;
  42             let b1                              = bc.read_prob(model.raw_probs[1]) as i16;
  43             let top: i16 = vp_tree!(bc, model.tree_probs[0],
  44                                 vp_tree!(bc, model.tree_probs[1],
  45                                     vp_tree!(bc, model.tree_probs[2], 0, 1),
  46                                     vp_tree!(bc, model.tree_probs[3], 2, 3)
  47                                 ),
  48                                 vp_tree!(bc, model.tree_probs[4],
  49                                     vp_tree!(bc, model.tree_probs[5], 4, 5),
  50                                     vp_tree!(bc, model.tree_probs[6], 6, 7)
  51                                 )
  52                            );
  53             let val = (top << 2) | (b1 << 1) | b0;
  54             if !sign {
  55                 val
  56             } else {
  57                 -val
  58             }
  59         } else {
  60             0
  61         }
  62     }
  63     fn reset_models(&self, models: &mut VP56Models) {
  64         for mdl in models.mv_models.iter_mut() {
  65             mdl.nz_prob         = 128;
  66             mdl.sign_prob       = 128;
  67             mdl.raw_probs[0]    = 85;
  68             mdl.raw_probs[1]    = 128;
  69             mdl.tree_probs      = [128; 7];
  70         }
  71     }
  72     fn decode_mv_models(&self, bc: &mut BoolCoder, models: &mut [VP56MVModel; 2]) -> DecoderResult<()> {
  73         const HAS_NZ_PROB:   [u8; 2] = [ 243, 235 ];
  74         const HAS_SIGN_PROB: [u8; 2] = [ 220, 211 ];
  75         const HAS_RAW0_PROB: [u8; 2] = [ 251, 246 ];
  76         const HAS_RAW1_PROB: [u8; 2] = [ 253, 249 ];
  77         const HAS_TREE_PROB: [[u8; 7]; 2] = [
  78             [ 237, 232, 241, 245, 247, 251, 253 ],
  79             [ 234, 231, 248, 249, 252, 252, 254 ]
  80         ];
  81         for comp in 0..2 {
  82             if bc.read_prob(HAS_NZ_PROB[comp]) {
  83                 models[comp].nz_prob            = bc.read_probability();
  84             }
  85             if bc.read_prob(HAS_SIGN_PROB[comp]) {
  86                 models[comp].sign_prob          = bc.read_probability();
  87             }
  88             if bc.read_prob(HAS_RAW0_PROB[comp]) {
  89                 models[comp].raw_probs[0]       = bc.read_probability();
  90             }
  91             if bc.read_prob(HAS_RAW1_PROB[comp]) {
  92                 models[comp].raw_probs[1]       = bc.read_probability();
  93             }
  94         }
  95         for comp in 0..2 {
  96             for i in 0..7 {
  97                 if bc.read_prob(HAS_TREE_PROB[comp][i]) {
  98                     models[comp].tree_probs[i]  = bc.read_probability();
  99                 }
 100             }
 101         }
 102         Ok(())
 103     }
 104     fn decode_coeff_models(&self, bc: &mut BoolCoder, models: &mut VP56Models, is_intra: bool) -> DecoderResult<()> {
 105         const COEF_PROBS: [[u8; 11]; 2] = [
 106             [ 146, 197, 181, 207, 232, 243, 238, 251, 244, 250, 249 ],
 107             [ 179, 219, 214, 240, 250, 254, 244, 254, 254, 254, 254 ]
 108         ];
 109
 110         let mut def_prob = [128u8; 11];
 111         for plane in 0..2 {
 112             for i in 0..11 {
 113                 if bc.read_prob(COEF_PROBS[plane][i]) {
 114                     def_prob[i]                 = bc.read_probability();
 115                     models.coeff_models[plane].dc_value_probs[i] = def_prob[i];
 116                 } else if is_intra {
 117                     models.coeff_models[plane].dc_value_probs[i] = def_prob[i];
 118                 }
 119             }
 120         }
 121         for ctype in 0..3 {
 122             for plane in 0..2 {
 123                 for group in 0..6 {
 124                     for i in 0..11 {
 125                         if bc.read_prob(VP5_AC_PROBS[ctype][plane][group][i]) {
 126                             def_prob[i]         = bc.read_probability();
 127                             models.coeff_models[plane].ac_val_probs[ctype][group][i] = def_prob[i];
 128                         } else if is_intra {
 129                             models.coeff_models[plane].ac_val_probs[ctype][group][i] = def_prob[i];
 130                         }
 131                     }
 132                 }
 133             }
 134         }
 135         for plane in 0..2 {
 136             let mdl = &mut models.coeff_models[plane];
 137             for i in 0..6 {
 138                 for j in 0..6 {
 139                     for k in 0..5 {
 140                         mdl.dc_token_probs[i][j][k] = rescale_prob(mdl.dc_value_probs[k], &VP5_DC_WEIGHTS[k][i][j], 254);
 141                     }
 142                 }
 143             }
 144             for ctype in 0..3 {
 145                 for group in 0..3 {
 146                     for i in 0..6 {
 147                         for j in 0..5 {
 148                             mdl.ac_type_probs[ctype][group][i][j] = rescale_prob(mdl.ac_val_probs[ctype][group][j], &VP5_AC_WEIGHTS[ctype][group][j][i], 254);
 149                         }
 150                     }
 151                 }
 152             }
 153         }
 154         Ok(())
 155     }
 156     fn decode_block(&self, bc: &mut BoolCoder, coeffs: &mut [i16; 64], model: &VP56CoeffModel, _vp6model: &VP6Models, fstate: &mut FrameState) -> DecoderResult<()> {
 157         const COEF_GROUPS: [u8; 64] = [
 158             0, 0, 1, 1, 2, 1, 1, 2,
 159             2, 1, 1, 2, 2, 2, 1, 2,
 160             2, 2, 2, 2, 1, 1, 2, 2,
 161             3, 3, 4, 3, 4, 4, 4, 3,
 162             3, 3, 3, 3, 4, 3, 3, 3,
 163             4, 4, 4, 4, 4, 3, 3, 4,
 164             4, 4, 3, 4, 4, 4, 4, 4,
 165             4, 4, 5, 5, 5, 5, 5, 5
 166         ];
 167
 168         let mut ctype = 1;
 169         let left_ctx = fstate.coeff_cat[fstate.ctx_idx][0] as usize;
 170         let top_ctx = fstate.top_ctx as usize;
 171
 172         let mut val_probs: &[u8; 11] = &model.dc_value_probs;
 173         let mut tok_probs: &[u8] = &model.dc_token_probs[left_ctx][top_ctx];
 174         let mut idx = 0;
 175         loop {
 176             let token = vp_tree!(bc, tok_probs[0],
 177                             if ctype != 0 { vp_tree!(bc, tok_probs[1], break, 0) } else { 0 },
 178                             vp_tree!(bc, tok_probs[2],
 179                                 1,
 180                                 vp_tree!(bc, tok_probs[3],
 181                                     vp_tree!(bc, tok_probs[4], 2,
 182                                              vp_tree!(bc, val_probs[5], 3, 4)),
 183                                     TOKEN_LARGE)));
 184             let val = expand_token_bc(bc, val_probs, token, 5);
 185             ctype = token.min(2) as usize;
 186             if token < TOKEN_LARGE {
 187                 fstate.coeff_cat[fstate.ctx_idx][idx] = token.min(3);
 188             } else {
 189                 fstate.coeff_cat[fstate.ctx_idx][idx] = 4;
 190             }
 191             coeffs[ZIGZAG[idx]] = val;
 192             if idx > 0 {
 193                 coeffs[ZIGZAG[idx]] *= fstate.ac_quant;
 194             }
 195
 196             idx += 1;
 197             if idx >= 64 {
 198                 break;
 199             }
 200             let group = COEF_GROUPS[idx] as usize;
 201             val_probs = &model.ac_val_probs[ctype][group];
 202             tok_probs = if group > 2 { val_probs
 203                         } else {
 204                             let ctx = fstate.coeff_cat[fstate.ctx_idx][idx] as usize;
 205                             &model.ac_type_probs[ctype][group][ctx]
 206                         };
 207         }
 208         let end = fstate.last_idx[fstate.ctx_idx].min(24);
 209         fstate.last_idx[fstate.ctx_idx] = idx;
 210         for i in idx..end {
 211             fstate.coeff_cat[fstate.ctx_idx][i] = 5;
 212         }
 213         fstate.top_ctx = fstate.coeff_cat[fstate.ctx_idx][0];
 214
 215         Ok(())
 216     }
 217     fn decode_block_huff(&self, _br: &mut BitReader, _coeffs: &mut [i16; 64], _vp6model: &VP6Models, _model: &VP6HuffModels, _fstate: &mut FrameState) -> DecoderResult<()> {
 218         unreachable!();
 219     }
 220     fn mc_block(&self, dst: &mut NASimpleVideoFrame<u8>, mc_buf: NAVideoBufferRef<u8>, src: NAVideoBufferRef<u8>, plane: usize, x: usize, y: usize, mv: MV, loop_str: i16) {
 221         let (sx, sy, mx, my) = if (plane != 1) && (plane != 2) {
 222                 (mv.x / 2, mv.y / 2, mv.x & 1, mv.y & 1)
 223             } else {
 224                 (mv.x / 4, mv.y / 4, (mv.x >> 1) & 1, (mv.y >> 1) & 1)
 225             };
 226         let mode = (mx as usize) + (my as usize) * 2;
 227         vp_copy_block(dst, src, plane, x, y, sx, sy, 0, 1, loop_str,
 228                       mode, VP3_INTERP_FUNCS, mc_buf);
 229     }
 230 }
 231
 232 struct VP5Decoder {
 233     dec:        VP56Decoder,
 234     info:       NACodecInfoRef,
 235     br:         VP5BR,
 236 }
 237
 238 impl VP5Decoder {
 239     fn new() -> Self {
 240         Self {
 241             dec:        VP56Decoder::new(5, false, true),
 242             info:       NACodecInfoRef::default(),
 243             br:         VP5BR::new(),
 244         }
 245     }
 246 }
 247
 248 impl NADecoder for VP5Decoder {
 249     fn init(&mut self, supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
 250         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
 251             let myvinfo = NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), false, YUV420_FORMAT);
 252             let myinfo = NACodecTypeInfo::Video(myvinfo.clone());
 253             self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
 254             self.dec.init(supp, myvinfo)?;
 255             Ok(())
 256         } else {
 257             Err(DecoderError::InvalidData)
 258         }
 259     }
 260     fn decode(&mut self, supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
 261         let src = pkt.get_buffer();
 262
 263         let (bufinfo, ftype) = self.dec.decode_frame(supp, src.as_slice(), &mut self.br)?;
 264
 265         let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
 266         frm.set_keyframe(ftype == FrameType::I);
 267         frm.set_frame_type(ftype);
 268         Ok(frm.into_ref())
 269     }
 270     fn flush(&mut self) {
 271         self.dec.flush();
 272     }
 273 }
 274
 275 pub fn get_decoder() -> Box<NADecoder> {
 276     Box::new(VP5Decoder::new())
 277 }
 278
 279 #[cfg(test)]
 280 mod test {
 281     use nihav_core::codecs::RegisteredDecoders;
 282     use nihav_core::demuxers::RegisteredDemuxers;
 283     use nihav_core::test::dec_video::*;
 284     use crate::codecs::duck_register_all_codecs;
 285     use nihav_commonfmt::demuxers::generic_register_all_demuxers;
 286
 287     #[test]
 288     fn test_vp5() {
 289         let mut dmx_reg = RegisteredDemuxers::new();
 290         generic_register_all_demuxers(&mut dmx_reg);
 291         let mut dec_reg = RegisteredDecoders::new();
 292         duck_register_all_codecs(&mut dec_reg);
 293
 294         let file = "assets/Duck/Cell-140.vp5";
 295         //let file = "assets/Duck/Chocolat-500.vp5";
 296         test_file_decoding("avi", file, Some(13), true, false, None/*Some("vp5")*/, &dmx_reg, &dec_reg);
 297 //panic!("end");
 298     }
 299 }
 300
 301 const VP5_AC_PROBS: [[[[u8; 11]; 6]; 2]; 3] = [
 302   [
 303     [
 304       [ 227, 246, 230, 247, 244, 254, 254, 254, 254, 254, 254 ],
 305       [ 202, 254, 209, 231, 231, 249, 249, 253, 254, 254, 254 ],
 306       [ 206, 254, 225, 242, 241, 251, 253, 254, 254, 254, 254 ],
 307       [ 235, 254, 241, 253, 252, 254, 254, 254, 254, 254, 254 ],
 308       [ 234, 254, 248, 254, 254, 254, 254, 254, 254, 254, 254 ],
 309       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ]
 310     ], [
 311       [ 240, 254, 248, 254, 254, 254, 254, 254, 254, 254, 254 ],
 312       [ 238, 254, 240, 253, 254, 254, 254, 254, 254, 254, 254 ],
 313       [ 244, 254, 251, 254, 254, 254, 254, 254, 254, 254, 254 ],
 314       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ],
 315       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ],
 316       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ]
 317     ]
 318   ], [
 319     [
 320       [ 206, 203, 227, 239, 247, 254, 253, 254, 254, 254, 254 ],
 321       [ 207, 199, 220, 236, 243, 252, 252, 254, 254, 254, 254 ],
 322       [ 212, 219, 230, 243, 244, 253, 252, 254, 254, 254, 254 ],
 323       [ 236, 237, 247, 252, 253, 254, 254, 254, 254, 254, 254 ],
 324       [ 240, 240, 248, 254, 254, 254, 254, 254, 254, 254, 254 ],
 325       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ]
 326     ], [
 327       [ 230, 233, 249, 254, 254, 254, 254, 254, 254, 254, 254 ],
 328       [ 238, 238, 250, 254, 254, 254, 254, 254, 254, 254, 254 ],
 329       [ 248, 251, 254, 254, 254, 254, 254, 254, 254, 254, 254 ],
 330       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ],
 331       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ],
 332       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ]
 333     ]
 334   ], [
 335     [
 336       [ 225, 239, 227, 231, 244, 253, 243, 254, 254, 253, 254 ],
 337       [ 232, 234, 224, 228, 242, 249, 242, 252, 251, 251, 254 ],
 338       [ 235, 249, 238, 240, 251, 254, 249, 254, 253, 253, 254 ],
 339       [ 249, 253, 251, 250, 254, 254, 254, 254, 254, 254, 254 ],
 340       [ 251, 250, 249, 254, 254, 254, 254, 254, 254, 254, 254 ],
 341       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ]
 342     ], [
 343       [ 243, 244, 250, 250, 254, 254, 254, 254, 254, 254, 254 ],
 344       [ 249, 248, 250, 253, 254, 254, 254, 254, 254, 254, 254 ],
 345       [ 253, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ],
 346       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ],
 347       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ],
 348       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ]
 349     ]
 350   ]
 351 ];
 352
 353 const VP5_DC_WEIGHTS: [[[[i16; 2]; 6]; 6]; 5] = [
 354   [
 355     [ [154,  61], [141,  54], [ 90,  45], [ 54,  34], [ 54,  13], [128, 109] ],
 356     [ [136,  54], [148,  45], [ 92,  41], [ 54,  33], [ 51,  15], [ 87, 113] ],
 357     [ [ 87,  44], [ 97,  40], [ 67,  36], [ 46,  29], [ 41,  15], [ 64,  80] ],
 358     [ [ 59,  33], [ 61,  31], [ 51,  28], [ 44,  22], [ 33,  12], [ 49,  63] ],
 359     [ [ 69,  12], [ 59,  16], [ 46,  14], [ 31,  13], [ 26,   6], [ 92,  26] ],
 360     [ [128, 108], [ 77, 119], [ 54,  84], [ 26,  71], [ 87,  19], [ 95, 155] ]
 361   ], [
 362     [ [154,   4], [182,   0], [159,  -8], [128,  -5], [143,  -5], [187,  55] ],
 363     [ [182,   0], [228,  -3], [187,  -7], [174,  -9], [189, -11], [169,  79] ],
 364     [ [161,  -9], [192,  -8], [187,  -9], [169, -10], [136,  -9], [184,  40] ],
 365     [ [164, -11], [179, -10], [174, -10], [161, -10], [115,  -7], [197,  20] ],
 366     [ [195, -11], [195, -11], [146, -10], [110,  -6], [ 95,  -4], [195,  39] ],
 367     [ [182,  55], [172,  77], [177,  37], [169,  29], [172,  52], [ 92, 162] ]
 368   ], [
 369     [ [174,  80], [164,  80], [ 95,  80], [ 46,  66], [ 56,  24], [ 36, 193] ],
 370     [ [164,  80], [166,  77], [105,  76], [ 49,  68], [ 46,  31], [ 49, 186] ],
 371     [ [ 97,  78], [110,  74], [ 72,  72], [ 44,  60], [ 33,  30], [ 69, 131] ],
 372     [ [ 61,  61], [ 69,  63], [ 51,  57], [ 31,  48], [ 26,  27], [ 64,  89] ],
 373     [ [ 67,  23], [ 51,  32], [ 36,  33], [ 26,  28], [ 20,  12], [ 44,  68] ],
 374     [ [ 26, 197], [ 41, 189], [ 61, 129], [ 28, 103], [ 49,  52], [-12, 245] ]
 375   ], [
 376     [ [102, 141], [ 79, 166], [ 72, 162], [ 97, 125], [179,   4], [307,   0] ],
 377     [ [ 72, 168], [ 69, 175], [ 84, 160], [105, 127], [148,  34], [310,   0] ],
 378     [ [ 84, 151], [ 82, 161], [ 87, 153], [ 87, 135], [115,  51], [317,   0] ],
 379     [ [ 97, 125], [102, 131], [105, 125], [ 87, 122], [ 84,  64], [ 54, 184] ],
 380     [ [166,  18], [146,  43], [125,  51], [ 90,  64], [ 95,   7], [ 38, 154] ],
 381     [ [294,   0], [ 13, 225], [ 10, 225], [ 67, 168], [  0, 167], [161,  94] ]
 382   ], [
 383     [ [172,  76], [172,  75], [136,  80], [ 64,  98], [ 74,  67], [315,   0] ],
 384     [ [169,  76], [207,  56], [164,  66], [ 97,  80], [ 67,  72], [328,   0] ],
 385     [ [136,  80], [187,  53], [154,  62], [ 72,  85], [ -2, 105], [305,   0] ],
 386     [ [ 74,  91], [128,  64], [113,  64], [ 61,  77], [ 41,  75], [259,   0] ],
 387     [ [ 46,  84], [ 51,  81], [ 28,  89], [ 31,  78], [ 23,  77], [202,   0] ],
 388     [ [323,   0], [323,   0], [300,   0], [236,   0], [195,   0], [328,   0] ]
 389   ]
 390 ];
 391
 392 const VP5_AC_WEIGHTS: [[[[[i16; 2]; 6]; 5]; 3]; 3] = [
 393   [
 394     [
 395       [ [276,  0], [238,  0], [195,  0], [156,  0], [113,  0], [274,  0] ],
 396       [ [  0,  1], [  0,  1], [  0,  1], [  0,  1], [  0,  1], [  0,  1] ],
 397       [ [192, 59], [182, 50], [141, 48], [110, 40], [ 92, 19], [125,128] ],
 398       [ [169, 87], [169, 83], [184, 62], [220, 16], [184,  0], [264,  0] ],
 399       [ [212, 40], [212, 36], [169, 49], [174, 27], [  8,120], [182, 71] ]
 400     ], [
 401       [ [259, 10], [197, 19], [143, 22], [123, 16], [110,  8], [133, 88] ],
 402       [ [  0,  1], [256,  0], [  0,  1], [  0,  1], [  0,  1], [  0,  1] ],
 403       [ [207, 46], [187, 50], [ 97, 83], [ 23,100], [ 41, 56], [ 56,188] ],
 404       [ [166, 90], [146,108], [161, 88], [136, 95], [174,  0], [266,  0] ],
 405       [ [264,  7], [243, 18], [184, 43], [-14,154], [ 20,112], [ 20,199] ]
 406     ], [
 407       [ [230, 26], [197, 22], [159, 20], [146, 12], [136,  4], [ 54,162] ],
 408       [ [  0,  1], [  0,  1], [  0,  1], [  0,  1], [  0,  1], [  0,  1] ],
 409       [ [192, 59], [156, 72], [ 84,101], [ 49,101], [ 79, 47], [ 79,167] ],
 410       [ [138,115], [136,116], [166, 80], [238,  0], [195,  0], [261,  0] ],
 411       [ [225, 33], [205, 42], [159, 61], [ 79, 96], [ 92, 66], [ 28,195] ]
 412     ]
 413   ], [
 414     [
 415       [ [200, 37], [197, 18], [159, 13], [143,  7], [102,  5], [123,126] ],
 416       [ [197,  3], [220, -9], [210,-12], [187, -6], [151, -2], [174, 80] ],
 417       [ [200, 53], [187, 47], [159, 40], [118, 38], [100, 18], [141,111] ],
 418       [ [179, 78], [166, 86], [197, 50], [207, 27], [187,  0], [115,139] ],
 419       [ [218, 34], [220, 29], [174, 46], [128, 61], [ 54, 89], [187, 65] ]
 420     ], [
 421       [ [238, 14], [197, 18], [125, 26], [ 90, 25], [ 82, 13], [161, 86] ],
 422       [ [189,  1], [205, -2], [156, -4], [143, -4], [146, -4], [172, 72] ],
 423       [ [230, 31], [192, 45], [102, 76], [ 38, 85], [ 56, 41], [ 64,173] ],
 424       [ [166, 91], [141,111], [128,116], [118,109], [177,  0], [ 23,222] ],
 425       [ [253, 14], [236, 21], [174, 49], [ 33,118], [ 44, 93], [ 23,187] ]
 426     ], [
 427       [ [218, 28], [179, 28], [118, 35], [ 95, 30], [ 72, 24], [128,108] ],
 428       [ [187,  1], [174, -1], [125, -1], [110, -1], [108, -1], [202, 52] ],
 429       [ [197, 53], [146, 75], [ 46,118], [ 33,103], [ 64, 50], [118,126] ],
 430       [ [138,114], [128,122], [161, 86], [243, -6], [195,  0], [ 38,210] ],
 431       [ [215, 39], [179, 58], [ 97,101], [ 95, 85], [ 87, 70], [ 69,152] ]
 432     ]
 433   ], [
 434     [
 435       [ [236, 24], [205, 18], [172, 12], [154,  6], [125,  1], [169, 75] ],
 436       [ [187,  4], [230, -2], [228, -4], [236, -4], [241, -2], [192, 66] ],
 437       [ [200, 46], [187, 42], [159, 34], [136, 25], [105, 10], [179, 62] ],
 438       [ [207, 55], [192, 63], [192, 54], [195, 36], [177,  1], [143, 98] ],
 439       [ [225, 27], [207, 34], [200, 30], [131, 57], [ 97, 60], [197, 45] ]
 440     ], [
 441       [ [271,  8], [218, 13], [133, 19], [ 90, 19], [ 72,  7], [182, 51] ],
 442       [ [179,  1], [225, -1], [154, -2], [110, -1], [ 92,  0], [195, 41] ],
 443       [ [241, 26], [189, 40], [ 82, 64], [ 33, 60], [ 67, 17], [120, 94] ],
 444       [ [192, 68], [151, 94], [146, 90], [143, 72], [161,  0], [113,128] ],
 445       [ [256, 12], [218, 29], [166, 48], [ 44, 99], [ 31, 87], [148, 78] ]
 446     ], [
 447       [ [238, 20], [184, 22], [113, 27], [ 90, 22], [ 74,  9], [192, 37] ],
 448       [ [184,  0], [215, -1], [141, -1], [ 97,  0], [ 49,  0], [264, 13] ],
 449       [ [182, 51], [138, 61], [ 95, 63], [ 54, 59], [ 64, 25], [200, 45] ],
 450       [ [179, 75], [156, 87], [174, 65], [177, 44], [174,  0], [164, 85] ],
 451       [ [195, 45], [148, 65], [105, 79], [ 95, 72], [ 87, 60], [169, 63] ]
 452     ]
 453   ]
 454 ];