nihav-misc/src/codecs/mwv1.rs

   1 use nihav_core::io::byteio::{ByteReader,MemoryReader};
   2 use nihav_core::io::bitreader::*;
   3 use nihav_core::io::codebook::*;
   4 use nihav_core::codecs::*;
   5
   6 #[derive(Clone,Copy)]
   7 struct BandPos {
   8     plane:  usize,
   9     x:      usize,
  10     y:      usize,
  11     w:      usize,
  12     h:      usize,
  13     level:  u8,
  14     ilevel: u8,
  15 }
  16
  17 struct MWV1Decoder {
  18     info:   NACodecInfoRef,
  19     mode:   u32,
  20     flags:  u32,
  21     l_cb:   Codebook<u8>,
  22     h_cb:   Codebook<u8>,
  23     bands:  Vec<BandPos>,
  24     tmp:    Vec<f32>,
  25     plane:  [Vec<f32>; 3],
  26     stride: [usize; 3],
  27 }
  28
  29 #[allow(clippy::too_many_arguments)]
  30 fn decode_band(br: &mut BitReader, cb: &Codebook<u8>, dst: &mut [f32], w: usize, h: usize, stride: usize, scale: f32, round: bool, zero_skip: bool) -> DecoderResult<()> {
  31     let mut ival = 0;
  32     let mut zero_run = 0;
  33
  34     for (y, row) in dst.chunks_mut(stride).take(h).enumerate() {
  35         for i in 0..w {
  36             let idx = if (y & 1) == 0 { i } else { w - 1 - i };
  37             if zero_run > 0 {
  38                 if !zero_skip {
  39                     row[idx] = (ival as f32) * scale;
  40                 }
  41                 zero_run -= 1;
  42                 continue;
  43             }
  44             let val                         = br.read_cb(cb)?;
  45             let diff = match val {
  46                     0 => {
  47                         let esc             = br.read(8)? as i16 - 0x80;
  48                         if esc < 0 {
  49                             esc - 0x7B
  50                         } else {
  51                             esc + 0x7C
  52                         }
  53                     },
  54                     1 => {
  55                         let esc             = br.read(12)? as i16 - 0x800;
  56                         if esc < 0 {
  57                             esc - 0xFB
  58                         } else {
  59                             esc + 0xFC
  60                         }
  61                     },
  62                     2 => {
  63                         zero_run            = br.read(4)? + 4;
  64                         if zero_skip {
  65                             continue;
  66                         }
  67                         0
  68                     },
  69                     3 => {
  70                         zero_run            = br.read(8)? + 20;
  71                         if zero_skip {
  72                             continue;
  73                         }
  74                         0
  75                     },
  76                     4 => {
  77                         zero_run            = br.read(12)? + 276;
  78                         if zero_skip {
  79                             continue;
  80                         }
  81                         0
  82                     },
  83                     0x80 => {
  84                         let esc             = (br.read(16)? ^ 0x8000) as i16;
  85                         if esc < 0 {
  86                             esc - 0x8FB
  87                         } else {
  88                             esc + 0x8FC
  89                         }
  90                     },
  91                     0xFC | 0xFD | 0xFE | 0xFF => {
  92                         zero_run = u32::from(val - 0xFC);
  93                         if zero_skip {
  94                             continue;
  95                         }
  96                         0
  97                     },
  98                     _ => {
  99                         i16::from(val) - 0x80
 100                     },
 101                 };
 102             if !zero_skip {
 103                 ival += diff;
 104                 row[idx] = (ival as f32) * scale;
 105             } else {
 106                 let bias = if !round { 0.0 } else if diff > 0 { 0.5 } else { -0.5 };
 107                 row[idx] = ((diff as f32) + bias) * scale;
 108             }
 109         }
 110     }
 111     validate!(zero_run == 0);
 112
 113     Ok(())
 114 }
 115
 116 #[allow(clippy::too_many_arguments)]
 117 fn decode_band2(br: &mut BitReader, cb: &Codebook<u8>, dst: &mut [f32], w: usize, h: usize, stride: usize, scale: f32, round: bool) -> DecoderResult<()> {
 118     const ZERO_RUN_BITS: [u8; 12] = [ 16, 14, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ];
 119     const ZERO_RUN_ADD: [u32; 12] = [
 120         0x4839, 0x839, 0x439, 0x239, 0x139, 0xB9, 0x79, 0x59, 0x49, 0x41, 0x3D, 0x3B
 121     ];
 122
 123     let mut zero_run = 0;
 124
 125     for (y, row) in dst.chunks_mut(stride).take(h).enumerate() {
 126         for i in 0..w {
 127             let idx = if (y & 1) == 0 { i } else { w - 1 - i };
 128
 129             if zero_run > 0 {
 130                 zero_run -= 1;
 131                 continue;
 132             }
 133             let val                         = br.read_cb(cb)?;
 134             let ival = match val {
 135                     0x00..=0x40 => i16::from(val) - 32,
 136                     0x41..=0x7B => {
 137                         zero_run = u32::from(val) - 0x41;
 138                         continue;
 139                     },
 140                     0xEF..=0xFA => {
 141                         let idx = (val - 0xEF) as usize;
 142                         zero_run            = br.read(ZERO_RUN_BITS[idx])? + ZERO_RUN_ADD[idx];
 143                         continue;
 144                     },
 145                     0xFE => {
 146                         let esc             = br.read(14)? as i16 - 0x2000;
 147                         if esc < 0 {
 148                             esc - 0x220
 149                         } else {
 150                             esc + 0x221
 151                         }
 152                     },
 153                     0xFF => {
 154                         let esc             = br.read(10)? as i16 - 0x200;
 155                         if esc < 0 {
 156                             esc - 0x20
 157                         } else {
 158                             esc + 0x21
 159                         }
 160                     },
 161                     _ => return Err(DecoderError::InvalidData),
 162                 };
 163             let bias = if !round { 0.0 } else if ival > 0 { 0.5 } else { -0.5 };
 164             row[idx] = ((ival as f32) + bias) * scale;
 165         }
 166     }
 167     validate!(zero_run == 0);
 168
 169     Ok(())
 170 }
 171
 172 fn combine_bands(lo: &[f32], hi: &[f32], dst: &mut [f32], step: usize, len: usize) {
 173     dst[0] = (lo[0] - lo[step]) / 128.0 + (hi[0] + lo[0]) / 16.0;
 174     dst[1] = (lo[step] - lo[0]) / 128.0 + (lo[0] - hi[0]) / 16.0;
 175     let mut didx  = 2;
 176     let mut loidx = 0;
 177     let mut hiidx = step;
 178     for _i in 0..(((len + 1) >> 1) - 2) {
 179         let tmp = (lo[loidx] - lo[loidx + 2 * step]) / 128.0;
 180         dst[didx]     = (lo[loidx + step] + hi[hiidx]) / 16.0 + tmp;
 181         dst[didx + 1] = (lo[loidx + step] - hi[hiidx]) / 16.0 - tmp;
 182         didx  += 2;
 183         loidx += step;
 184         hiidx += step;
 185     }
 186     if (len & 1) == 0 {
 187         let tmp = (lo[loidx] - lo[loidx + step]) / 128.0;
 188         dst[didx]     = (lo[loidx + step] + hi[hiidx]) / 16.0 + tmp;
 189         dst[didx + 1] = (lo[loidx + step] - hi[hiidx]) / 16.0 - tmp;
 190     } else {
 191         dst[didx] = lo[loidx + step] / 16.0;
 192     }
 193 }
 194
 195 fn map_index(idx: usize) -> u8 { idx as u8 }
 196
 197 impl MWV1Decoder {
 198     fn new() -> Self {
 199         let mut cbr = TableCodebookDescReader::new(&L_CODE_BITS, &L_CODE_LENS, map_index);
 200         let l_cb = Codebook::new(&mut cbr, CodebookMode::MSB).unwrap();
 201         let mut cbr = TableCodebookDescReader::new(&H_CODE_BITS, &H_CODE_LENS, map_index);
 202         let h_cb = Codebook::new(&mut cbr, CodebookMode::MSB).unwrap();
 203         MWV1Decoder {
 204             info:   NACodecInfo::new_dummy(),
 205             l_cb, h_cb,
 206             mode:   0,
 207             flags:  0,
 208             bands:  Vec::new(),
 209             plane:  [Vec::new(), Vec::new(), Vec::new()],
 210             stride: [0; 3],
 211             tmp:    Vec::new(),
 212         }
 213     }
 214     fn reconstruct(&mut self, frm: &mut NASimpleVideoFrame<u8>) {
 215         for band in self.bands.iter() {
 216             if band.x == 0 || band.y == 0 {
 217                 continue;
 218             }
 219
 220             let stride = self.stride[band.plane] << band.ilevel;
 221             let dst_yy = [0, 1 << band.ilevel >> 1];
 222             for &dst_y in dst_yy.iter() {
 223                 let dst = &mut self.plane[band.plane][dst_y * self.stride[band.plane]..];
 224                 for row in dst.chunks_mut(stride).take(band.h) {
 225                     let (lo, hi) = row.split_at(band.x);
 226                     let size = band.x + band.w;
 227                     combine_bands(lo, hi, &mut self.tmp, 1, size);
 228                     row[..size].copy_from_slice(&self.tmp[..size]);
 229                 }
 230             }
 231             let size = band.y + band.h;
 232             for x in 0..band.x + band.w {
 233                 let col = &self.plane[band.plane][x..];
 234                 combine_bands(col, &col[stride/2..], &mut self.tmp, stride, size);
 235                 for y in 0..size {
 236                     self.plane[band.plane][x + y * (stride/2)] = self.tmp[y] * 128.0;
 237                 }
 238             }
 239         }
 240
 241         for plane in 0..3 {
 242             let dst = &mut frm.data[frm.offset[plane]..];
 243             for (drow, srow) in dst.chunks_mut(frm.stride[plane]).zip(self.plane[plane].chunks(self.stride[plane])) {
 244                 for (dst, &src) in drow.iter_mut().zip(srow.iter()) {
 245                     *dst = (src + 128.0).max(0.0).min(255.0) as u8;
 246                 }
 247             }
 248         }
 249     }
 250 }
 251
 252 impl NADecoder for MWV1Decoder {
 253     fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
 254         if let NACodecTypeInfo::Video(_vinfo) = info.get_properties() {
 255             if let Some(edata) = info.get_extradata() {
 256                 validate!(edata.len() >= 64);
 257                 let mut mr = MemoryReader::new_read(edata.as_slice());
 258                 let mut br = ByteReader::new(&mut mr);
 259                 let len                 = br.read_u32be()? as usize;
 260                 validate!(edata.len() == len);
 261                 let _                   = br.read_u32be()?; //always 7?
 262                 self.mode               = br.read_u32be()?; //pic_fmt
 263                 let width               = br.read_u32be()? as usize;
 264                 let height              = br.read_u32be()? as usize;
 265                 let _smth               = br.read_u16be()?;
 266                 let _bpp                = br.read_u16be()?;
 267                 let _fmt                = br.read_u32le()?;
 268                 let _unp_size           = br.read_u32be()? as usize;
 269                                           br.read_u32be()?; // always zero?
 270                                           br.read_u32be()?; // always zero?
 271                                           br.read_u32be()?; // always zero?
 272                                           br.read_u32be()?; // always zero?
 273                 self.flags              = br.read_u32be()?; // 0x100 - interlaced?
 274                 let mut levels = [[0; 2]; 3];
 275                 for plane_lev in levels.iter_mut() {
 276                     for level in plane_lev.iter_mut() {
 277                         let lev         = br.read_u16be()?;
 278                         validate!(lev < 32);
 279                         *level = lev as u8;
 280                     }
 281                 }
 282                 validate!(width > 1 && height > 1);
 283                 for plane_lev in levels.iter() {
 284                     if plane_lev[0] != plane_lev[1] {
 285                         return Err(DecoderError::NotImplemented);
 286                     }
 287                 }
 288                 let max_levels = levels[0][0].max(levels[1][0]).max(levels[2][0]);
 289                 validate!(max_levels < 8);
 290                 self.bands = Vec::with_capacity((max_levels as usize) * 9 + 1);
 291                 self.tmp = vec![0.0; width.max(height)];
 292                 let mut dim = [[width, height], [width >> 1, height >> 1], [width >> 1, height >> 1]];
 293
 294                 for level in (0..max_levels).rev() {
 295                     for plane in (0..3).rev() {
 296                         if level < levels[plane][0] {
 297                             let bp = BandPos {
 298                                     plane,
 299                                     level,
 300                                     ilevel: levels[plane][0] - level,
 301                                     x: (dim[plane][0] + 1) >> 1,
 302                                     y: (dim[plane][1] + 1) >> 1,
 303                                     w:  dim[plane][0]      >> 1,
 304                                     h:  dim[plane][1]      >> 1,
 305                                 };
 306                             self.bands.push(bp);
 307                         }
 308                     }
 309                     for plane in (0..3).rev() {
 310                         if level < levels[plane][0] {
 311                             let bp = BandPos {
 312                                     plane,
 313                                     level,
 314                                     ilevel: levels[plane][0] - level,
 315                                     x: 0,
 316                                     y: (dim[plane][1] + 1) >> 1,
 317                                     w: (dim[plane][0] + 1) >> 1,
 318                                     h:  dim[plane][1]      >> 1,
 319                                 };
 320                             self.bands.push(bp);
 321                         }
 322                     }
 323                     for plane in (0..3).rev() {
 324                         if level < levels[plane][0] {
 325                             let bp = BandPos {
 326                                     plane,
 327                                     level,
 328                                     ilevel: levels[plane][0] - level,
 329                                     x: (dim[plane][0] + 1) >> 1,
 330                                     y: 0,
 331                                     w:  dim[plane][0]      >> 1,
 332                                     h: (dim[plane][1] + 1) >> 1,
 333                                 };
 334                             self.bands.push(bp);
 335                         }
 336                     }
 337
 338                     if level != 0 {
 339                         for plane in 0..3 {
 340                             if level < levels[plane][0] {
 341                                 dim[plane][0] = (dim[plane][0] + 1) >> 1;
 342                                 dim[plane][1] = (dim[plane][1] + 1) >> 1;
 343                             }
 344                         }
 345                     }
 346                 }
 347                 for plane in (0..3).rev() {
 348                     let bp = BandPos {
 349                             plane,
 350                             level: 0,
 351                             ilevel: levels[plane][0],
 352                             x: 0,
 353                             y: 0,
 354                             w: (dim[plane][0] + 1) >> 1,
 355                             h: (dim[plane][1] + 1) >> 1,
 356                         };
 357                     self.bands.push(bp);
 358                 }
 359                 self.bands.reverse();
 360
 361                 self.plane = [vec![0.0; width * height], vec![0.0; width * height / 4], vec![0.0; width * height / 4]];
 362                 self.stride = [width, width >> 1, width >> 1];
 363
 364                 let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(width, height, false, YUV420_FORMAT));
 365                 self.info = NACodecInfo::new_ref(info.get_name(), myinfo, None).into_ref();
 366                 Ok(())
 367             } else {
 368                 Err(DecoderError::InvalidData)
 369             }
 370         } else {
 371             Err(DecoderError::InvalidData)
 372         }
 373     }
 374     fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
 375         let src = pkt.get_buffer();
 376         if src.len() <= 26 { return Err(DecoderError::ShortData); }
 377
 378         let mut br = BitReader::new(&src, BitReaderMode::BE);
 379
 380         for plane in self.plane.iter_mut() {
 381             for el in plane.iter_mut() {
 382                 *el = 0.0;
 383             }
 384         }
 385
 386         let mut has_hdr = false;
 387         let mut band_iter = self.bands.iter_mut();
 388
 389         while br.left() > 5 {
 390             let ff                      = br.read(32)?;
 391             validate!(ff == 0xFFFFFFFF);
 392             let tag_id                  = br.read(8)?;
 393             match tag_id {
 394                 0xAA => {
 395                     validate!(!has_hdr);
 396                     let size            = br.read(32)?;
 397                     validate!(size >= 6);
 398                     let end = br.tell() + (size as usize) * 8 - 32;
 399                                           br.read(16)?;
 400                     if (self.flags & 0x100) == 0 {
 401                                           br.read(16)?;
 402                                           br.read(16)?;
 403                     }
 404                     if self.mode > 1 {
 405                                           br.read(8)?;
 406                     }
 407                     if self.mode > 4 {
 408                         let _size       = br.read(32)?;
 409                     }
 410
 411                     validate!(br.tell() <= end);
 412                     let tail = end - br.tell();
 413                                           br.skip(tail as u32)?;
 414                     has_hdr = true;
 415                 },
 416                 0xAB => {
 417                     /*validate!(!has_hdr);
 418                     let size            = br.read(32)?;
 419                     validate!(size >= 6);
 420                                           br.read(16)?;
 421                     if self.levels == 2 || self.levels == 3 {
 422                                           br.read(16)?;
 423                                           br.read(16)?;
 424                     }
 425                     if components > 1 {
 426                                           br.read(8)?;
 427                     }
 428                                           br.skip((size - 6) * 8)?;
 429                     has_hdr = true;*/
 430                     return Err(DecoderError::NotImplemented);
 431                 },
 432                 0xD1 => {
 433                     let next_band = band_iter.next();
 434                     validate!(next_band.is_some());
 435                     let band = *next_band.unwrap();
 436
 437                     let scale;
 438                     let band_mode;
 439                     let lscale = (1 << band.level) as f32;
 440                     if self.mode < 3 {
 441                         /*let _           = br.read(32)?;
 442                         let _           = br.read(32)?;
 443                         scale           = (br.read(32)? as f32) / 32768.0;*/
 444                         return Err(DecoderError::NotImplemented);
 445                     } else {
 446                         band_mode       = br.read(8)? as u8;
 447                         if band_mode == 0 {
 448                             scale = 0.0;
 449                         } else {
 450                             scale       = (br.read(32)? as f32) * lscale / 32768.0;
 451                         }
 452                     }
 453
 454                     let dst_y = if band.y != 0 { 1 << band.ilevel >> 1 } else { 0 };
 455
 456                     let dst = &mut self.plane[band.plane][band.x + dst_y * self.stride[band.plane]..];
 457                     let stride = self.stride[band.plane] << band.ilevel;
 458                     let round = (band_mode & 8) != 0;
 459                     match band_mode {
 460                         0 => {}, // empty band
 461                         1 | 9 => {
 462                             decode_band(&mut br, &self.l_cb, dst, band.w, band.h, stride, scale, round, true)?;
 463                         },
 464                         2 | 10 => {
 465                             decode_band2(&mut br, &self.h_cb, dst, band.w, band.h, stride, scale, round)?;
 466                         },
 467                         5 => {
 468                             decode_band(&mut br, &self.l_cb, dst, band.w, band.h, stride, scale, false, false)?;
 469                         },
 470                         _ => return Err(DecoderError::InvalidData),
 471                     };
 472                                           br.align();
 473                 },
 474                 0xD2 | 0xDA => {
 475                     let size            = br.read(32)?;
 476                     validate!(size >= 4);
 477                                           br.skip((size - 4) * 8)?;
 478                 },
 479                 0xD7 => {
 480                     let size            = br.read(32)?;
 481                     validate!(size == 13);
 482                                           br.read(16)?;
 483                     for _ in 0..3 {
 484                                           br.read(16)?;
 485                     }
 486                                           br.read(8)?;
 487                 },
 488                 0xDD => {
 489                     return Err(DecoderError::NotImplemented);
 490                 },
 491                 _ => {
 492                     return Err(DecoderError::NotImplemented);
 493                 },
 494             };
 495             if tag_id == 0 { break; }
 496         }
 497
 498         let vinfo = self.info.get_properties().get_video_info().unwrap();
 499         let bufinfo = alloc_video_buffer(vinfo, 2)?;
 500         let mut buf = bufinfo.get_vbuf().unwrap();
 501         let mut frm = NASimpleVideoFrame::from_video_buf(&mut buf).unwrap();
 502
 503         self.reconstruct(&mut frm);
 504
 505         let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), NABufferType::Video(buf));
 506         frm.set_keyframe(true);
 507         frm.set_frame_type(FrameType::I);
 508         Ok(frm.into_ref())
 509     }
 510     fn flush(&mut self) {
 511     }
 512 }
 513
 514 impl NAOptionHandler for MWV1Decoder {
 515     fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
 516     fn set_options(&mut self, _options: &[NAOption]) { }
 517     fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
 518 }
 519
 520 pub fn get_decoder() -> Box<dyn NADecoder + Send> {
 521     Box::new(MWV1Decoder::new())
 522 }
 523
 524 #[cfg(test)]
 525 mod test {
 526     use nihav_core::codecs::RegisteredDecoders;
 527     use nihav_core::demuxers::RegisteredDemuxers;
 528     use nihav_codec_support::test::dec_video::*;
 529     use crate::misc_register_all_decoders;
 530     use nihav_commonfmt::generic_register_all_demuxers;
 531     #[test]
 532     fn test_mwv1() {
 533         let mut dmx_reg = RegisteredDemuxers::new();
 534         generic_register_all_demuxers(&mut dmx_reg);
 535         let mut dec_reg = RegisteredDecoders::new();
 536         misc_register_all_decoders(&mut dec_reg);
 537         // sample: https://samples.mplayerhq.hu/V-codecs/MWV1/test.avi
 538         test_decoding("avi", "mwv1", "assets/Misc/mwv1.avi", Some(2), &dmx_reg,
 539                      &dec_reg, ExpectedTestResult::MD5Frames(vec![
 540                         [0x9f2e0e5b, 0xa767c1ae, 0x8c009dca, 0x7159d0cd],
 541                         [0xfc00be21, 0x899736d0, 0x6b18dd40, 0x5261af2c],
 542                         [0xf113305d, 0xffac919f, 0x0b64890e, 0x18c60420]]));
 543     }
 544 }
 545
 546 const L_CODE_BITS: [u16; 256] = [
 547     0xFF6B, 0xFF76, 0x0014, 0x00F0, 0xFF77, 0xFF78, 0xFF79, 0xFF7A,
 548     0xFF7B, 0xFF7C, 0xFF7D, 0xFF7E, 0xFF7F, 0xFF80, 0xFF81, 0xFF82,
 549     0xFF83, 0xFF84, 0xFF85, 0xFF86, 0xFF87, 0xFF88, 0xFF89, 0xFF8A,
 550     0xFF8B, 0xFF8C, 0xFF8D, 0xFF8E, 0xFF8F, 0xFF90, 0xFF91, 0xFF92,
 551     0xFF93, 0xFF94, 0xFF95, 0xFF96, 0xFF97, 0xFF98, 0xFF99, 0xFF9A,
 552     0xFF9B, 0xFF9C, 0xFF9D, 0xFF9E, 0xFF9F, 0xFFA0, 0xFFA1, 0xFFA2,
 553     0xFFA3, 0xFFA4, 0xFFA5, 0xFFA6, 0xFFA7, 0xFFA8, 0xFFA9, 0xFFAA,
 554     0xFFAB, 0xFFAC, 0xFFAD, 0xFFAE, 0xFFAF, 0xFFB0, 0xFFB1, 0xFFB2,
 555     0xFFB3, 0xFFB4, 0xFF6C, 0xFFB5, 0xFFB6, 0xFF6D, 0xFFB7, 0xFF6E,
 556     0xFFB8, 0xFFB9, 0xFFBA, 0xFFBB, 0xFF6F, 0xFF5B, 0xFFBC, 0xFF4F,
 557     0xFFBD, 0xFF5C, 0xFFBE, 0xFFBF, 0xFF5D, 0xFF50, 0xFF5E, 0xFF70,
 558     0xFF5F, 0xFF60, 0xFF61, 0x1FDC, 0xFF51, 0x1FDD, 0x1FDE, 0x1FDF,
 559     0x1FE0, 0x1FE1, 0x1FE2, 0x1FE3, 0x0FE4, 0x0FE5, 0x07E8, 0x0FE6,
 560     0x0FE7, 0x07E9, 0x07EA, 0x07EB, 0x07EC, 0x07ED, 0x07EE, 0x03EA,
 561     0x03EB, 0x03EC, 0x01F0, 0x01F1, 0x01F2, 0x00F1, 0x00F2, 0x00F3,
 562     0x0074, 0x0075, 0x0034, 0x0035, 0x0015, 0x0016, 0x0008, 0x0000,
 563     0xFFC0, 0x0002, 0x0009, 0x0017, 0x0018, 0x0036, 0x0037, 0x0076,
 564     0x0077, 0x00F4, 0x00F5, 0x00F6, 0x00F7, 0x01F3, 0x01F4, 0x03ED,
 565     0x03EE, 0x03EF, 0x03F0, 0x03F1, 0x03F2, 0x07EF, 0x07F0, 0x07F1,
 566     0x03F3, 0x0FE8, 0x0FE9, 0x0FEA, 0x0FEB, 0x0FEC, 0x0FED, 0x1FE4,
 567     0x1FE5, 0x1FE6, 0x1FE7, 0xFF52, 0x1FE8, 0x3FD2, 0xFF53, 0x7FA6,
 568     0xFF62, 0xFF63, 0xFF54, 0xFF55, 0xFF64, 0xFF65, 0xFF71, 0xFF72,
 569     0xFF56, 0xFF57, 0xFF58, 0xFF66, 0xFF67, 0xFF68, 0xFF69, 0xFF73,
 570     0xFFC1, 0xFF74, 0xFFC2, 0xFF6A, 0xFF75, 0xFF59, 0xFF4E, 0xFF5A,
 571     0xFFC3, 0xFFC4, 0xFFC5, 0xFFC6, 0xFFC7, 0xFFC8, 0xFFC9, 0xFFCA,
 572     0xFFCB, 0xFFCC, 0xFFCD, 0xFFCE, 0xFFCF, 0xFFD0, 0xFFD1, 0xFFD2,
 573     0xFFD3, 0xFFD4, 0xFFD5, 0xFFD6, 0xFFD7, 0xFFD8, 0xFFD9, 0xFFDA,
 574     0xFFDB, 0xFFDC, 0xFFDD, 0xFFDE, 0xFFDF, 0xFFE0, 0xFFE1, 0xFFE2,
 575     0xFFE3, 0xFFE4, 0xFFE5, 0xFFE6, 0xFFE7, 0xFFE8, 0xFFE9, 0xFFEA,
 576     0xFFEB, 0xFFEC, 0xFFED, 0xFFEE, 0xFFEF, 0xFFF0, 0xFFF1, 0xFFF2,
 577     0xFFF3, 0xFFF4, 0xFFF5, 0xFFF6, 0xFFF7, 0xFFF8, 0xFFF9, 0xFFFA,
 578     0xFFFB, 0xFFFC, 0xFFFD, 0xFFFE, 0x0003, 0x0019, 0x0038, 0x0039
 579 ];
 580 const L_CODE_LENS: [u8; 256] = [
 581     16, 16,  5,  8, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
 582     16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
 583     16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
 584     16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
 585     16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
 586     16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 13, 16, 13, 13, 13,
 587     13, 13, 13, 13, 12, 12, 11, 12, 12, 11, 11, 11, 11, 11, 11, 10,
 588     10, 10,  9,  9,  9,  8,  8,  8,  7,  7,  6,  6,  5,  5,  4,  2,
 589     16,  3,  4,  5,  5,  6,  6,  7,  7,  8,  8,  8,  8,  9,  9, 10,
 590     10, 10, 10, 10, 10, 11, 11, 11, 10, 12, 12, 12, 12, 12, 12, 13,
 591     13, 13, 13, 16, 13, 14, 16, 15, 16, 16, 16, 16, 16, 16, 16, 16,
 592     16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
 593     16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
 594     16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
 595     16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
 596     16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,  3,  5,  6,  6
 597 ];
 598 const H_CODE_BITS: [u16; 256] = [
 599     0xFFFF, 0xFFE5, 0xFFE6, 0xFFE7, 0xFFE8, 0xFFE9, 0xFFEA, 0xFFEB,
 600     0xFFEC, 0xFFED, 0xFFEE, 0xFFEF, 0xFFF0, 0xFFE0, 0xFFDB, 0xFFDC,
 601     0xFFDA, 0xFFD5, 0xFFD6, 0x1FF6, 0x1FF7, 0x0FEE, 0x0FEF, 0x07E0,
 602     0x07E1, 0x03E4, 0x01E4, 0x00E8, 0x006E, 0x0032, 0x0016, 0x0000,
 603     0x0000, 0x0001, 0x0017, 0x0033, 0x006F, 0x00E9, 0x01E5, 0x03E5,
 604     0x07E2, 0x07E3, 0x07E4, 0x0FF0, 0x1FF8, 0xFFD7, 0xFFD8, 0xFFD9,
 605     0xFFDD, 0xFFDE, 0xFFE1, 0xFFE2, 0xFFF1, 0xFFF2, 0xFFE3, 0xFFF3,
 606     0xFFF4, 0xFFF5, 0xFFF6, 0xFFF7, 0xFFF8, 0xFFF9, 0xFFFA, 0xFFFB,
 607     0xFFFC, 0x0004, 0x000A, 0x0018, 0x0034, 0x0035, 0x0036, 0x0070,
 608     0x0071, 0x0072, 0x0073, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE,
 609     0x00EF, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC,
 610     0x01ED, 0x01EE, 0x03E6, 0x03E7, 0x03E8, 0x03E9, 0x03EA, 0x03EB,
 611     0x03EC, 0x03ED, 0x03EE, 0x07E5, 0x07E6, 0x07E7, 0x07E8, 0x07E9,
 612     0x07EA, 0x07EB, 0x07EC, 0x07ED, 0x07EE, 0x07EF, 0x07F0, 0x07F1,
 613     0x07F2, 0x07F3, 0x07F4, 0x0FF1, 0x0FF2, 0x0FF3, 0x0FF4, 0x0FF5,
 614     0x0FF6, 0x0FF7, 0x0FF8, 0x0FF9, 0x0000, 0x0000, 0x0000, 0x0000,
 615     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 616     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 617     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 618     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 619     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 620     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 621     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 622     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 623     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 624     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 625     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 626     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 627     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 628     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFDF,
 629     0x1FF9, 0x3FF4, 0x0FFA, 0x07F5, 0x00F0, 0x00F1, 0x01EF, 0x01F0,
 630     0x01F1, 0x03EF, 0x07F6, 0x0000, 0x0000, 0xFFD4, 0xFFFD, 0xFFFE
 631 ];
 632 const H_CODE_LENS: [u8; 256] = [
 633     16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
 634     16, 16, 16, 13, 13, 12, 12, 11, 11, 10,  9,  8,  7,  6,  5,  2,
 635      0,  2,  5,  6,  7,  8,  9, 10, 11, 11, 11, 12, 13, 16, 16, 16,
 636     16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
 637     16,  3,  4,  5,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  8,  8,
 638      8,  9,  9,  9,  9,  9,  9,  9,  9,  9, 10, 10, 10, 10, 10, 10,
 639     10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
 640     11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12,  0,  0,  0,  0,
 641      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 642      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 643      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 644      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 645      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 646      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 647      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 16,
 648     13, 14, 12, 11,  8,  8,  9,  9,  9, 10, 11,  0,  0, 16, 16, 16
 649 ];