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 }
 271
 272 pub fn get_decoder() -> Box<NADecoder> {
 273     Box::new(VP5Decoder::new())
 274 }
 275
 276 #[cfg(test)]
 277 mod test {
 278     use nihav_core::codecs::RegisteredDecoders;
 279     use nihav_core::demuxers::RegisteredDemuxers;
 280     use nihav_core::test::dec_video::*;
 281     use crate::codecs::duck_register_all_codecs;
 282     use nihav_commonfmt::demuxers::generic_register_all_demuxers;
 283
 284     #[test]
 285     fn test_vp5() {
 286         let mut dmx_reg = RegisteredDemuxers::new();
 287         generic_register_all_demuxers(&mut dmx_reg);
 288         let mut dec_reg = RegisteredDecoders::new();
 289         duck_register_all_codecs(&mut dec_reg);
 290
 291         let file = "assets/Duck/Cell-140.vp5";
 292         //let file = "assets/Duck/Chocolat-500.vp5";
 293         test_file_decoding("avi", file, Some(13), true, false, None/*Some("vp5")*/, &dmx_reg, &dec_reg);
 294 //panic!("end");
 295     }
 296 }
 297
 298 const VP5_AC_PROBS: [[[[u8; 11]; 6]; 2]; 3] = [
 299   [
 300     [
 301       [ 227, 246, 230, 247, 244, 254, 254, 254, 254, 254, 254 ],
 302       [ 202, 254, 209, 231, 231, 249, 249, 253, 254, 254, 254 ],
 303       [ 206, 254, 225, 242, 241, 251, 253, 254, 254, 254, 254 ],
 304       [ 235, 254, 241, 253, 252, 254, 254, 254, 254, 254, 254 ],
 305       [ 234, 254, 248, 254, 254, 254, 254, 254, 254, 254, 254 ],
 306       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ]
 307     ], [
 308       [ 240, 254, 248, 254, 254, 254, 254, 254, 254, 254, 254 ],
 309       [ 238, 254, 240, 253, 254, 254, 254, 254, 254, 254, 254 ],
 310       [ 244, 254, 251, 254, 254, 254, 254, 254, 254, 254, 254 ],
 311       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ],
 312       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ],
 313       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ]
 314     ]
 315   ], [
 316     [
 317       [ 206, 203, 227, 239, 247, 254, 253, 254, 254, 254, 254 ],
 318       [ 207, 199, 220, 236, 243, 252, 252, 254, 254, 254, 254 ],
 319       [ 212, 219, 230, 243, 244, 253, 252, 254, 254, 254, 254 ],
 320       [ 236, 237, 247, 252, 253, 254, 254, 254, 254, 254, 254 ],
 321       [ 240, 240, 248, 254, 254, 254, 254, 254, 254, 254, 254 ],
 322       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ]
 323     ], [
 324       [ 230, 233, 249, 254, 254, 254, 254, 254, 254, 254, 254 ],
 325       [ 238, 238, 250, 254, 254, 254, 254, 254, 254, 254, 254 ],
 326       [ 248, 251, 254, 254, 254, 254, 254, 254, 254, 254, 254 ],
 327       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ],
 328       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ],
 329       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ]
 330     ]
 331   ], [
 332     [
 333       [ 225, 239, 227, 231, 244, 253, 243, 254, 254, 253, 254 ],
 334       [ 232, 234, 224, 228, 242, 249, 242, 252, 251, 251, 254 ],
 335       [ 235, 249, 238, 240, 251, 254, 249, 254, 253, 253, 254 ],
 336       [ 249, 253, 251, 250, 254, 254, 254, 254, 254, 254, 254 ],
 337       [ 251, 250, 249, 254, 254, 254, 254, 254, 254, 254, 254 ],
 338       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ]
 339     ], [
 340       [ 243, 244, 250, 250, 254, 254, 254, 254, 254, 254, 254 ],
 341       [ 249, 248, 250, 253, 254, 254, 254, 254, 254, 254, 254 ],
 342       [ 253, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ],
 343       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ],
 344       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ],
 345       [ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 ]
 346     ]
 347   ]
 348 ];
 349
 350 const VP5_DC_WEIGHTS: [[[[i16; 2]; 6]; 6]; 5] = [
 351   [
 352     [ [154,  61], [141,  54], [ 90,  45], [ 54,  34], [ 54,  13], [128, 109] ],
 353     [ [136,  54], [148,  45], [ 92,  41], [ 54,  33], [ 51,  15], [ 87, 113] ],
 354     [ [ 87,  44], [ 97,  40], [ 67,  36], [ 46,  29], [ 41,  15], [ 64,  80] ],
 355     [ [ 59,  33], [ 61,  31], [ 51,  28], [ 44,  22], [ 33,  12], [ 49,  63] ],
 356     [ [ 69,  12], [ 59,  16], [ 46,  14], [ 31,  13], [ 26,   6], [ 92,  26] ],
 357     [ [128, 108], [ 77, 119], [ 54,  84], [ 26,  71], [ 87,  19], [ 95, 155] ]
 358   ], [
 359     [ [154,   4], [182,   0], [159,  -8], [128,  -5], [143,  -5], [187,  55] ],
 360     [ [182,   0], [228,  -3], [187,  -7], [174,  -9], [189, -11], [169,  79] ],
 361     [ [161,  -9], [192,  -8], [187,  -9], [169, -10], [136,  -9], [184,  40] ],
 362     [ [164, -11], [179, -10], [174, -10], [161, -10], [115,  -7], [197,  20] ],
 363     [ [195, -11], [195, -11], [146, -10], [110,  -6], [ 95,  -4], [195,  39] ],
 364     [ [182,  55], [172,  77], [177,  37], [169,  29], [172,  52], [ 92, 162] ]
 365   ], [
 366     [ [174,  80], [164,  80], [ 95,  80], [ 46,  66], [ 56,  24], [ 36, 193] ],
 367     [ [164,  80], [166,  77], [105,  76], [ 49,  68], [ 46,  31], [ 49, 186] ],
 368     [ [ 97,  78], [110,  74], [ 72,  72], [ 44,  60], [ 33,  30], [ 69, 131] ],
 369     [ [ 61,  61], [ 69,  63], [ 51,  57], [ 31,  48], [ 26,  27], [ 64,  89] ],
 370     [ [ 67,  23], [ 51,  32], [ 36,  33], [ 26,  28], [ 20,  12], [ 44,  68] ],
 371     [ [ 26, 197], [ 41, 189], [ 61, 129], [ 28, 103], [ 49,  52], [-12, 245] ]
 372   ], [
 373     [ [102, 141], [ 79, 166], [ 72, 162], [ 97, 125], [179,   4], [307,   0] ],
 374     [ [ 72, 168], [ 69, 175], [ 84, 160], [105, 127], [148,  34], [310,   0] ],
 375     [ [ 84, 151], [ 82, 161], [ 87, 153], [ 87, 135], [115,  51], [317,   0] ],
 376     [ [ 97, 125], [102, 131], [105, 125], [ 87, 122], [ 84,  64], [ 54, 184] ],
 377     [ [166,  18], [146,  43], [125,  51], [ 90,  64], [ 95,   7], [ 38, 154] ],
 378     [ [294,   0], [ 13, 225], [ 10, 225], [ 67, 168], [  0, 167], [161,  94] ]
 379   ], [
 380     [ [172,  76], [172,  75], [136,  80], [ 64,  98], [ 74,  67], [315,   0] ],
 381     [ [169,  76], [207,  56], [164,  66], [ 97,  80], [ 67,  72], [328,   0] ],
 382     [ [136,  80], [187,  53], [154,  62], [ 72,  85], [ -2, 105], [305,   0] ],
 383     [ [ 74,  91], [128,  64], [113,  64], [ 61,  77], [ 41,  75], [259,   0] ],
 384     [ [ 46,  84], [ 51,  81], [ 28,  89], [ 31,  78], [ 23,  77], [202,   0] ],
 385     [ [323,   0], [323,   0], [300,   0], [236,   0], [195,   0], [328,   0] ]
 386   ]
 387 ];
 388
 389 const VP5_AC_WEIGHTS: [[[[[i16; 2]; 6]; 5]; 3]; 3] = [
 390   [
 391     [
 392       [ [276,  0], [238,  0], [195,  0], [156,  0], [113,  0], [274,  0] ],
 393       [ [  0,  1], [  0,  1], [  0,  1], [  0,  1], [  0,  1], [  0,  1] ],
 394       [ [192, 59], [182, 50], [141, 48], [110, 40], [ 92, 19], [125,128] ],
 395       [ [169, 87], [169, 83], [184, 62], [220, 16], [184,  0], [264,  0] ],
 396       [ [212, 40], [212, 36], [169, 49], [174, 27], [  8,120], [182, 71] ]
 397     ], [
 398       [ [259, 10], [197, 19], [143, 22], [123, 16], [110,  8], [133, 88] ],
 399       [ [  0,  1], [256,  0], [  0,  1], [  0,  1], [  0,  1], [  0,  1] ],
 400       [ [207, 46], [187, 50], [ 97, 83], [ 23,100], [ 41, 56], [ 56,188] ],
 401       [ [166, 90], [146,108], [161, 88], [136, 95], [174,  0], [266,  0] ],
 402       [ [264,  7], [243, 18], [184, 43], [-14,154], [ 20,112], [ 20,199] ]
 403     ], [
 404       [ [230, 26], [197, 22], [159, 20], [146, 12], [136,  4], [ 54,162] ],
 405       [ [  0,  1], [  0,  1], [  0,  1], [  0,  1], [  0,  1], [  0,  1] ],
 406       [ [192, 59], [156, 72], [ 84,101], [ 49,101], [ 79, 47], [ 79,167] ],
 407       [ [138,115], [136,116], [166, 80], [238,  0], [195,  0], [261,  0] ],
 408       [ [225, 33], [205, 42], [159, 61], [ 79, 96], [ 92, 66], [ 28,195] ]
 409     ]
 410   ], [
 411     [
 412       [ [200, 37], [197, 18], [159, 13], [143,  7], [102,  5], [123,126] ],
 413       [ [197,  3], [220, -9], [210,-12], [187, -6], [151, -2], [174, 80] ],
 414       [ [200, 53], [187, 47], [159, 40], [118, 38], [100, 18], [141,111] ],
 415       [ [179, 78], [166, 86], [197, 50], [207, 27], [187,  0], [115,139] ],
 416       [ [218, 34], [220, 29], [174, 46], [128, 61], [ 54, 89], [187, 65] ]
 417     ], [
 418       [ [238, 14], [197, 18], [125, 26], [ 90, 25], [ 82, 13], [161, 86] ],
 419       [ [189,  1], [205, -2], [156, -4], [143, -4], [146, -4], [172, 72] ],
 420       [ [230, 31], [192, 45], [102, 76], [ 38, 85], [ 56, 41], [ 64,173] ],
 421       [ [166, 91], [141,111], [128,116], [118,109], [177,  0], [ 23,222] ],
 422       [ [253, 14], [236, 21], [174, 49], [ 33,118], [ 44, 93], [ 23,187] ]
 423     ], [
 424       [ [218, 28], [179, 28], [118, 35], [ 95, 30], [ 72, 24], [128,108] ],
 425       [ [187,  1], [174, -1], [125, -1], [110, -1], [108, -1], [202, 52] ],
 426       [ [197, 53], [146, 75], [ 46,118], [ 33,103], [ 64, 50], [118,126] ],
 427       [ [138,114], [128,122], [161, 86], [243, -6], [195,  0], [ 38,210] ],
 428       [ [215, 39], [179, 58], [ 97,101], [ 95, 85], [ 87, 70], [ 69,152] ]
 429     ]
 430   ], [
 431     [
 432       [ [236, 24], [205, 18], [172, 12], [154,  6], [125,  1], [169, 75] ],
 433       [ [187,  4], [230, -2], [228, -4], [236, -4], [241, -2], [192, 66] ],
 434       [ [200, 46], [187, 42], [159, 34], [136, 25], [105, 10], [179, 62] ],
 435       [ [207, 55], [192, 63], [192, 54], [195, 36], [177,  1], [143, 98] ],
 436       [ [225, 27], [207, 34], [200, 30], [131, 57], [ 97, 60], [197, 45] ]
 437     ], [
 438       [ [271,  8], [218, 13], [133, 19], [ 90, 19], [ 72,  7], [182, 51] ],
 439       [ [179,  1], [225, -1], [154, -2], [110, -1], [ 92,  0], [195, 41] ],
 440       [ [241, 26], [189, 40], [ 82, 64], [ 33, 60], [ 67, 17], [120, 94] ],
 441       [ [192, 68], [151, 94], [146, 90], [143, 72], [161,  0], [113,128] ],
 442       [ [256, 12], [218, 29], [166, 48], [ 44, 99], [ 31, 87], [148, 78] ]
 443     ], [
 444       [ [238, 20], [184, 22], [113, 27], [ 90, 22], [ 74,  9], [192, 37] ],
 445       [ [184,  0], [215, -1], [141, -1], [ 97,  0], [ 49,  0], [264, 13] ],
 446       [ [182, 51], [138, 61], [ 95, 63], [ 54, 59], [ 64, 25], [200, 45] ],
 447       [ [179, 75], [156, 87], [174, 65], [177, 44], [174,  0], [164, 85] ],
 448       [ [195, 45], [148, 65], [105, 79], [ 95, 72], [ 87, 60], [169, 63] ]
 449     ]
 450   ]
 451 ];