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::*;
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<()> {
34 for (y, row) in dst.chunks_mut(stride).take(h).enumerate() {
36 let idx = if (y & 1) == 0 { i } else { w - 1 - i };
39 row[idx] = (ival as f32) * scale;
44 let val = br.read_cb(cb)?;
45 let diff = match val {
47 let esc = br.read(8)? as i16 - 0x80;
55 let esc = br.read(12)? as i16 - 0x800;
63 zero_run = br.read(4)? + 4;
70 zero_run = br.read(8)? + 20;
77 zero_run = br.read(12)? + 276;
84 let esc = (br.read(16)? ^ 0x8000) as i16;
91 0xFC | 0xFD | 0xFE | 0xFF => {
92 zero_run = u32::from(val - 0xFC);
104 row[idx] = (ival as f32) * scale;
106 let bias = if !round { 0.0 } else if diff > 0 { 0.5 } else { -0.5 };
107 row[idx] = ((diff as f32) + bias) * scale;
111 validate!(zero_run == 0);
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
123 let mut zero_run = 0;
125 for (y, row) in dst.chunks_mut(stride).take(h).enumerate() {
127 let idx = if (y & 1) == 0 { i } else { w - 1 - i };
133 let val = br.read_cb(cb)?;
134 let ival = match val {
135 0x00..=0x40 => i16::from(val) - 32,
137 zero_run = u32::from(val) - 0x41;
141 let idx = (val - 0xEF) as usize;
142 zero_run = br.read(ZERO_RUN_BITS[idx])? + ZERO_RUN_ADD[idx];
146 let esc = br.read(14)? as i16 - 0x2000;
154 let esc = br.read(10)? as i16 - 0x200;
161 _ => return Err(DecoderError::InvalidData),
163 let bias = if !round { 0.0 } else if ival > 0 { 0.5 } else { -0.5 };
164 row[idx] = ((ival as f32) + bias) * scale;
167 validate!(zero_run == 0);
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;
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;
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;
191 dst[didx] = lo[loidx + step] / 16.0;
195 fn map_index(idx: usize) -> u8 { idx as u8 }
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();
204 info: NACodecInfo::new_dummy(),
209 plane: [Vec::new(), Vec::new(), Vec::new()],
214 fn reconstruct(&mut self, frm: &mut NASimpleVideoFrame<u8>) {
215 for band in self.bands.iter() {
216 if band.x == 0 || band.y == 0 {
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]);
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);
236 self.plane[band.plane][x + y * (stride/2)] = self.tmp[y] * 128.0;
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;
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()?;
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);
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]];
294 for level in (0..max_levels).rev() {
295 for plane in (0..3).rev() {
296 if level < levels[plane][0] {
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,
309 for plane in (0..3).rev() {
310 if level < levels[plane][0] {
314 ilevel: levels[plane][0] - level,
316 y: (dim[plane][1] + 1) >> 1,
317 w: (dim[plane][0] + 1) >> 1,
318 h: dim[plane][1] >> 1,
323 for plane in (0..3).rev() {
324 if level < levels[plane][0] {
328 ilevel: levels[plane][0] - level,
329 x: (dim[plane][0] + 1) >> 1,
331 w: dim[plane][0] >> 1,
332 h: (dim[plane][1] + 1) >> 1,
340 if level < levels[plane][0] {
341 dim[plane][0] = (dim[plane][0] + 1) >> 1;
342 dim[plane][1] = (dim[plane][1] + 1) >> 1;
347 for plane in (0..3).rev() {
351 ilevel: levels[plane][0],
354 w: (dim[plane][0] + 1) >> 1,
355 h: (dim[plane][1] + 1) >> 1,
359 self.bands.reverse();
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];
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();
368 Err(DecoderError::InvalidData)
371 Err(DecoderError::InvalidData)
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); }
378 let mut br = BitReader::new(&src, BitReaderMode::BE);
380 for plane in self.plane.iter_mut() {
381 for el in plane.iter_mut() {
386 let mut has_hdr = false;
387 let mut band_iter = self.bands.iter_mut();
389 while br.left() > 5 {
390 let ff = br.read(32)?;
391 validate!(ff == 0xFFFFFFFF);
392 let tag_id = br.read(8)?;
396 let size = br.read(32)?;
397 validate!(size >= 6);
398 let end = br.tell() + (size as usize) * 8 - 32;
400 if (self.flags & 0x100) == 0 {
408 let _size = br.read(32)?;
411 validate!(br.tell() <= end);
412 let tail = end - br.tell();
413 br.skip(tail as u32)?;
417 /*validate!(!has_hdr);
418 let size = br.read(32)?;
419 validate!(size >= 6);
421 if self.levels == 2 || self.levels == 3 {
428 br.skip((size - 6) * 8)?;
430 return Err(DecoderError::NotImplemented);
433 let next_band = band_iter.next();
434 validate!(next_band.is_some());
435 let band = *next_band.unwrap();
439 let lscale = (1 << band.level) as f32;
441 /*let _ = br.read(32)?;
442 let _ = br.read(32)?;
443 scale = (br.read(32)? as f32) / 32768.0;*/
444 return Err(DecoderError::NotImplemented);
446 band_mode = br.read(8)? as u8;
450 scale = (br.read(32)? as f32) * lscale / 32768.0;
454 let dst_y = if band.y != 0 { 1 << band.ilevel >> 1 } else { 0 };
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;
460 0 => {}, // empty band
462 decode_band(&mut br, &self.l_cb, dst, band.w, band.h, stride, scale, round, true)?;
465 decode_band2(&mut br, &self.h_cb, dst, band.w, band.h, stride, scale, round)?;
468 decode_band(&mut br, &self.l_cb, dst, band.w, band.h, stride, scale, false, false)?;
470 _ => return Err(DecoderError::InvalidData),
475 let size = br.read(32)?;
476 validate!(size >= 4);
477 br.skip((size - 4) * 8)?;
480 let size = br.read(32)?;
481 validate!(size == 13);
489 return Err(DecoderError::NotImplemented);
492 return Err(DecoderError::NotImplemented);
495 if tag_id == 0 { break; }
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();
503 self.reconstruct(&mut frm);
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);
510 fn flush(&mut self) {
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 }
520 pub fn get_decoder() -> Box<dyn NADecoder + Send> {
521 Box::new(MWV1Decoder::new())
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;
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]]));
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
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
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
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