1 use nihav_core::formats;
2 use nihav_core::codecs::*;
3 use nihav_core::io::byteio::*;
6 const BMV_INTRA: u8 = 0x03;
7 const BMV_SCROLL: u8 = 0x04;
8 const BMV_PAL: u8 = 0x08;
9 const BMV_COMMAND: u8 = 0x10;
10 const BMV_PRINT: u8 = 0x80;
12 const BMV_MAX_WIDTH: usize = 640;
13 const BMV_MAX_HEIGHT: usize = 432;
14 const BMV_MAX_SIZE: usize = BMV_MAX_WIDTH * (BMV_MAX_HEIGHT + 1);
34 Self { nib: 0, has_nib: false }
36 fn get_nib(&mut self, br: &mut ByteReader) -> DecoderResult<u8> {
41 let b = br.read_byte()?;
47 fn get_length(&mut self, br: &mut ByteReader, mut len: usize, mut shift: u8) -> DecoderResult<usize> {
49 let nib = self.get_nib(br)? as usize;
57 fn push(&mut self, val: u8) {
59 panic!("nibble already in cache");
71 struct BMV3VideoDecoder {
78 pixbuf: [[u16; 256]; 7],
86 impl BMV3VideoDecoder {
88 let mut pixels = [0u16; 256];
89 for (i, el) in pixels.iter_mut().enumerate() {
92 let mut pixbuf = [[0u16; 256]; 7];
95 pixbuf[i][j] = ((i << 8) + j + 0xF8) as u16;
100 info: NACodecInfoRef::default(),
103 frame: vec![0; BMV_MAX_SIZE],
104 prev_frame: vec![0; BMV_MAX_SIZE],
106 mode: BMV3Mode::Normal,
109 nr: NibbleReader::new(),
113 fn decode_frame(&mut self, br: &mut ByteReader) -> DecoderResult<()> {
116 let op = br.read_byte()?;
120 let op2 = br.read_u16le()?;
121 skip = ((op2 >> 12) as usize) | ((op as usize) << 4);
122 len = (op2 & 0xFFF) as usize;
124 len = ((op & 7) + 1) as usize;
125 skip = ((op >> 3) - 0x11) as usize;
127 while (idx < 0xF8) && (len > 0) {
128 self.pixels[idx] = br.read_u16le()?;
132 while (idx < 0x7F8) && (len > 0) {
133 let nidx = idx - 0xF8;
134 self.pixbuf[nidx >> 8][nidx & 0xFF] = br.read_u16le()?;
139 if skip == 0 { break; }
143 self.mode = BMV3Mode::Normal;
144 while br.left() > 0 && self.pos < self.end {
146 BMV3Mode::Normal => {
147 let op = br.read_byte()?;
148 self.decode_normal(br, op)?;
151 let op = br.read_byte()?;
153 self.decode_normal(br, op + 1)?;
155 self.decode_copy(br, op)?;
158 BMV3Mode::Pixfunc => {
159 let op = br.read_byte()?;
161 self.decode_copy(br, op + 1)?;
163 self.decode_normal(br, op - 1)?;
166 BMV3Mode::After0 => {
167 let cur_op = self.nr.get_nib(br)?;
169 let op = self.nr.get_nib(br)?;
171 0 => self.decode_mode5c(br, op | 0x10)?,
172 1 => self.decode_mode4 (br, op | 0x10)?,
173 2 => self.decode_mode5c(br, op | 0x30)?,
174 _ => self.decode_mode4 (br, op | 0x30)?,
177 let len = (cur_op >> 1) - 1;
178 if (cur_op & 1) == 0 {
179 self.pixfunc(br, len as usize)?;
181 self.repeat(len as usize)?;
185 BMV3Mode::After1 => {
186 let cur_op = self.nr.get_nib(br)?;
188 let op = self.nr.get_nib(br)?;
190 0 => self.decode_mode4 (br, op | 0x10)?,
191 1 => self.decode_mode5c(br, op | 0x00)?,
192 2 => self.decode_mode4 (br, op | 0x30)?,
193 _ => self.decode_mode5c(br, op | 0x20)?,
196 let len = (cur_op >> 1) - 1;
197 if (cur_op & 1) == 0 {
198 self.repeat(len as usize)?;
200 self.copy(len as usize)?;
204 BMV3Mode::After1C => {
205 let cur_op = self.nr.get_nib(br)?;
207 let cur_op1 = self.nr.get_nib(br)?;
208 let m5_op = cur_op1 | (cur_op << 4);
209 self.decode_mode5c(br, m5_op)?;
210 } else if (cur_op & 1) == 0 {
211 let len = (cur_op >> 1) - 1;
212 self.copy(len as usize)?;
214 let len = (cur_op >> 1) - 1;
215 self.pixfunc(br, len as usize)?;
218 BMV3Mode::After4 => {
219 let cur_op0 = self.nr.get_nib(br)?;
220 let cur_op1 = self.nr.get_nib(br)?;
221 let cur_op = (cur_op0 << 4) | cur_op1;
222 if (cur_op & 0x10) == 0 {
223 self.decode_mode5c(br, cur_op | 0x10)?;
225 self.decode_mode4(br, cur_op)?;
228 BMV3Mode::After5 => {
229 let cur_op0 = self.nr.get_nib(br)?;
230 let cur_op1 = self.nr.get_nib(br)?;
231 let cur_op = (cur_op0 << 4) | cur_op1;
232 if (cur_op & 0x10) == 0 {
233 self.decode_mode4(br, cur_op | 0x10)?;
235 self.decode_mode5c(br, cur_op ^ 0x10)?;
239 if self.pos >= self.end { break; }
244 fn copy(&mut self, len: usize) -> DecoderResult<()> {
245 validate!(len <= self.end - self.pos);
248 self.frame[self.pos] = self.frame[self.pos - self.stride];
253 self.frame[self.pos] = self.prev_frame[self.pos];
257 self.mode = BMV3Mode::Copy;
260 fn pixfunc(&mut self, br: &mut ByteReader, len: usize) -> DecoderResult<()> {
261 validate!(len <= self.end - self.pos);
263 let op = BMV_PIXFUNCS_MAP[br.read_byte()? as usize];
266 val = br.read_u16le()?;
267 } else if op >= 0xF8 {
268 let tab_idx = (op - 0xF8) as usize;
269 let sub_idx = br.read_byte()? as usize;
270 val = self.pixbuf[tab_idx][sub_idx];
272 val = self.pixels[op as usize];
274 self.frame[self.pos] = val;
277 self.mode = BMV3Mode::Pixfunc;
280 fn repeat(&mut self, len: usize) -> DecoderResult<()> {
281 validate!(self.pos > 0);
282 validate!(len <= self.end - self.pos);
283 let pix = self.frame[self.pos - 1];
285 self.frame[self.pos] = pix;
288 self.mode = BMV3Mode::Normal;
292 fn decode_normal(&mut self, br: &mut ByteReader, op: u8) -> DecoderResult<()> {
295 let len = ((op >> 1) & 0x7) as usize;
297 let mut len = (op >> 3) as usize;
301 len = self.nr.get_length(br, len, 3)?;
305 self.mode = BMV3Mode::After0;
308 self.pixfunc(br, len)?;
310 self.mode = BMV3Mode::After1;
313 } else if mode == 0 {
315 self.nr.push(op >> 4);
316 self.mode = BMV3Mode::After4;
318 self.pixfunc(br, len - 1)?;
319 self.nr.push(op >> 4);
320 self.mode = BMV3Mode::After5;
324 let x_op = (op >> 4) as usize;
325 let y_op = ((op >> 1) & 7) as usize;
326 let flag = (op & 1) as usize;
327 if y_op == 0 || y_op == 1 {
328 let len = x_op * 2 - 1 + y_op;
332 self.pixfunc(br, len)?;
336 let len2 = (x_op >> 1) - 1;
340 self.pixfunc(br, len1)?;
342 match (x_op & 1) * 2 + flag {
343 0 => self.pixfunc(br, len2)?,
344 1 => self.repeat(len2)?,
345 2 => self.repeat(len2)?,
346 _ => self.copy(len2)?,
351 fn decode_copy(&mut self, br: &mut ByteReader, op: u8) -> DecoderResult<()> {
353 let len = ((op >> 1) & 0x7) as usize;
355 let mut len = (op >> 3) as usize;
359 len = self.nr.get_length(br, len, 3)?;
362 self.mode = BMV3Mode::After1C;
365 self.repeat(len - 1)?;
366 if br.left() == 0 { return Ok(()); }
367 let op2 = self.nr.get_nib(br)?;
368 let cur_op = (op & 0xF0) | op2;
369 self.decode_mode5c(br, cur_op)?;
373 let x_op = (op >> 4) as usize;
374 let y_op = ((op >> 1) & 7) as usize;
375 if y_op == 0 || y_op == 1 {
376 self.repeat(x_op * 2 - 1 + y_op)?;
378 self.repeat(y_op - 1)?;
379 let len = (x_op >> 1) - 1;
383 self.pixfunc(br, len)?;
388 fn decode_mode4(&mut self, br: &mut ByteReader, op: u8) -> DecoderResult<()> {
390 let mut len = ((op & 3) * 2) as usize;
391 if (op & 0xF0) >= 0x20 {
394 len = self.nr.get_length(br, len, 3)?;
397 self.mode = BMV3Mode::After1C;
400 let len = ((op & 0xF) * 2 - 1 + (op >> 5)) as usize;
402 self.mode = BMV3Mode::After1C;
406 fn decode_mode5c(&mut self, br: &mut ByteReader, op: u8) -> DecoderResult<()> {
408 let mut len = ((op & 3) * 2) as usize;
409 if (op & 0xF0) >= 0x20 {
412 len = self.nr.get_length(br, len, 3)?;
413 if (op & 0x10) == 0 {
416 self.mode = BMV3Mode::After0;
419 self.pixfunc(br, len)?;
421 self.mode = BMV3Mode::After1;
425 let len = ((op & 0xF) * 2 - 1 + (op >> 5)) as usize;
426 if (op & 0x10) == 0 {
428 self.mode = BMV3Mode::After0;
430 self.pixfunc(br, len)?;
431 self.mode = BMV3Mode::After1;
438 impl NADecoder for BMV3VideoDecoder {
439 fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
440 if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
441 let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), false, RGB565_FORMAT));
442 self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
444 self.stride = vinfo.get_width();
445 self.height = vinfo.get_height();
446 self.end = self.stride * (self.height + 1);
448 validate!((self.stride <= 640) && (self.height <= 432));
452 Err(DecoderError::InvalidData)
455 fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
456 let src = pkt.get_buffer();
457 validate!(src.len() > 1);
459 let mut mr = MemoryReader::new_read(&src);
460 let mut br = ByteReader::new(&mut mr);
461 let flags = br.read_byte()?;
463 if (flags & BMV_COMMAND) != 0 {
464 let size = if (flags & BMV_PRINT) != 0 { 8 } else { 10 };
467 if (flags & BMV_PAL) != 0 {
468 return Err(DecoderError::InvalidData);
471 if ((flags & 1) == 0) && ((flags & BMV_SCROLL) != 0) {
472 off = br.read_u16le()? as usize;
476 self.pos = off + self.stride;
477 self.is_intra = (flags & BMV_INTRA) == BMV_INTRA;
479 let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0)?;
481 self.decode_frame(&mut br)?;
484 let mut buf = bufinfo.get_vbuf16().unwrap();
485 let stride = buf.get_stride(0);
486 let data = buf.get_data_mut().unwrap();
487 let dst = data.as_mut_slice();
489 let refbuf = &self.frame[self.stride..];
490 for (dst, src) in dst.chunks_mut(stride).zip(refbuf.chunks(self.stride)).take(self.height) {
491 let out = &mut dst[0..self.stride];
492 out.copy_from_slice(src);
495 std::mem::swap(&mut self.frame, &mut self.prev_frame);
497 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
498 frm.set_keyframe(self.is_intra);
499 frm.set_frame_type(if self.is_intra { FrameType::I } else { FrameType::P });
505 pub fn get_decoder_video() -> Box<dyn NADecoder> {
506 Box::new(BMV3VideoDecoder::new())
509 struct BMV3AudioDecoder {
516 impl BMV3AudioDecoder {
519 ainfo: NAAudioInfo::new(0, 1, formats::SND_S16P_FORMAT, 0),
520 chmap: NAChannelMap::new(),
527 fn decode_block(mode: u8, src: &[u8], dst: &mut [i16], mut pred: i16) -> i16 {
528 let steps = &BMV_AUDIO_STEPS[mode as usize];
531 let val = (src[i * 2 + 0] as usize) + (src[i * 2 + 1] as usize) * 256;
532 pred = pred.wrapping_add(steps[(val >> 10) & 0x1F]);
533 dst[i * 3 + 0] = pred;
534 pred = pred.wrapping_add(steps[(val >> 5) & 0x1F]);
535 dst[i * 3 + 1] = pred;
536 pred = pred.wrapping_add(steps[(val >> 0) & 0x1F]);
537 dst[i * 3 + 2] = pred;
538 val2 = (val2 << 1) | (val >> 15);
540 pred = pred.wrapping_add(steps[(val2 >> 5) & 0x1F]);
541 dst[3 * 10 + 0] = pred;
542 pred = pred.wrapping_add(steps[(val2 >> 0) & 0x1F]);
543 dst[3 * 10 + 1] = pred;
547 impl NADecoder for BMV3AudioDecoder {
548 fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
549 if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
550 self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), ainfo.get_channels(), formats::SND_S16P_FORMAT, 32);
551 self.chmap = NAChannelMap::from_str("L,R").unwrap();
554 Err(DecoderError::InvalidData)
557 fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
558 let info = pkt.get_stream().get_info();
559 if let NACodecTypeInfo::Audio(_) = info.get_properties() {
560 let pktbuf = pkt.get_buffer();
561 validate!(pktbuf.len() > 1);
562 let samples = (pktbuf.len() / 41) * 32;
563 let abuf = alloc_audio_buffer(self.ainfo, samples, self.chmap.clone())?;
564 let mut adata = abuf.get_abuf_i16().unwrap();
565 let off1 = adata.get_offset(1);
566 let dst = adata.get_data_mut().unwrap();
567 let mut first = pktbuf[0] == 0;
568 let psrc = &pktbuf[1..];
569 for (n, src) in psrc.chunks_exact(41).enumerate() {
571 let aoff1 = aoff0 + off1;
574 self.pred[0] = decode_block(mode >> 4, &src[0..], &mut dst[aoff0..], self.pred[0]);
575 self.pred[1] = decode_block(mode & 0xF, &src[20..], &mut dst[aoff1..], self.pred[1]);
578 self.pred[0] = decode_block(mode >> 4, &src[1..], &mut dst[aoff0..], self.pred[0]);
579 self.pred[1] = decode_block(mode & 0xF, &src[21..], &mut dst[aoff1..], self.pred[1]);
584 let mut frm = NAFrame::new_from_pkt(pkt, info, abuf);
585 frm.set_duration(Some(samples as u64));
586 frm.set_keyframe(false);
589 Err(DecoderError::InvalidData)
594 pub fn get_decoder_audio() -> Box<dyn NADecoder> {
595 Box::new(BMV3AudioDecoder::new())
600 use nihav_core::codecs::RegisteredDecoders;
601 use nihav_core::demuxers::RegisteredDemuxers;
602 use nihav_core::test::dec_video::*;
603 use crate::codecs::game_register_all_codecs;
604 use crate::demuxers::game_register_all_demuxers;
606 fn test_bmv_video() {
607 let mut dmx_reg = RegisteredDemuxers::new();
608 game_register_all_demuxers(&mut dmx_reg);
609 let mut dec_reg = RegisteredDecoders::new();
610 game_register_all_codecs(&mut dec_reg);
612 let file = "assets/Game/DW3-Loffnote.bmv";
613 test_file_decoding("bmv3", file, None, true, false, None, &dmx_reg, &dec_reg);
616 fn test_bmv_audio() {
617 let mut dmx_reg = RegisteredDemuxers::new();
618 game_register_all_demuxers(&mut dmx_reg);
619 let mut dec_reg = RegisteredDecoders::new();
620 game_register_all_codecs(&mut dec_reg);
622 let file = "assets/Game/DW3-Loffnote.bmv";
623 test_decode_audio("bmv3", file, None, "bmv3", &dmx_reg, &dec_reg);
627 const BMV_PIXFUNCS_MAP: [u8; 256] = [
628 0x38, 0x78, 0xB8, 0xF9,
629 0x39, 0x79, 0xB9, 0xFA,
630 0x3A, 0x7A, 0xBA, 0xFB,
631 0x3B, 0x7B, 0xBB, 0xFC,
632 0x3C, 0x7C, 0xBC, 0xFD,
633 0x3D, 0x7D, 0xBD, 0xFE,
634 0x3E, 0x7E, 0xBE, 0xFF,
635 0x3F, 0x7F, 0xBF, 0x00,
636 0x40, 0x80, 0xC0, 0x01,
637 0x41, 0x81, 0xC1, 0x02,
638 0x42, 0x82, 0xC2, 0x03,
639 0x43, 0x83, 0xC3, 0x04,
640 0x44, 0x84, 0xC4, 0x05,
641 0x45, 0x85, 0xC5, 0x06,
642 0x46, 0x86, 0xC6, 0x07,
643 0x47, 0x87, 0xC7, 0x08,
644 0x48, 0x88, 0xC8, 0x09,
645 0x49, 0x89, 0xC9, 0x0A,
646 0x4A, 0x8A, 0xCA, 0x0B,
647 0x4B, 0x8B, 0xCB, 0x0C,
648 0x4C, 0x8C, 0xCC, 0x0D,
649 0x4D, 0x8D, 0xCD, 0x0E,
650 0x4E, 0x8E, 0xCE, 0x0F,
651 0x4F, 0x8F, 0xCF, 0x10,
652 0x50, 0x90, 0xD0, 0x11,
653 0x51, 0x91, 0xD1, 0x12,
654 0x52, 0x92, 0xD2, 0x13,
655 0x53, 0x93, 0xD3, 0x14,
656 0x54, 0x94, 0xD4, 0x15,
657 0x55, 0x95, 0xD5, 0x16,
658 0x56, 0x96, 0xD6, 0x17,
659 0x57, 0x97, 0xD7, 0x18,
660 0x58, 0x98, 0xD8, 0x19,
661 0x59, 0x99, 0xD9, 0x1A,
662 0x5A, 0x9A, 0xDA, 0x1B,
663 0x5B, 0x9B, 0xDB, 0x1C,
664 0x5C, 0x9C, 0xDC, 0x1D,
665 0x5D, 0x9D, 0xDD, 0x1E,
666 0x5E, 0x9E, 0xDE, 0x1F,
667 0x5F, 0x9F, 0xDF, 0x20,
668 0x60, 0xA0, 0xE0, 0x21,
669 0x61, 0xA1, 0xE1, 0x22,
670 0x62, 0xA2, 0xE2, 0x23,
671 0x63, 0xA3, 0xE3, 0x24,
672 0x64, 0xA4, 0xE4, 0x25,
673 0x65, 0xA5, 0xE5, 0x26,
674 0x66, 0xA6, 0xE6, 0x27,
675 0x67, 0xA7, 0xE7, 0x28,
676 0x68, 0xA8, 0xE8, 0x29,
677 0x69, 0xA9, 0xE9, 0x2A,
678 0x6A, 0xAA, 0xEA, 0x2B,
679 0x6B, 0xAB, 0xEB, 0x2C,
680 0x6C, 0xAC, 0xEC, 0x2D,
681 0x6D, 0xAD, 0xED, 0x2E,
682 0x6E, 0xAE, 0xEE, 0x2F,
683 0x6F, 0xAF, 0xEF, 0x30,
684 0x70, 0xB0, 0xF0, 0x31,
685 0x71, 0xB1, 0xF1, 0x32,
686 0x72, 0xB2, 0xF2, 0x33,
687 0x73, 0xB3, 0xF3, 0x34,
688 0x74, 0xB4, 0xF4, 0x35,
689 0x75, 0xB5, 0xF5, 0x36,
690 0x76, 0xB6, 0xF6, 0x37,
691 0x77, 0xB7, 0xF7, 0xF8
694 const BMV_AUDIO_STEPS: [[i16; 32]; 16] = [
696 0x0000, 0x0400, 0x0800, 0x0C00, 0x1000, 0x1400, 0x1800, 0x1C00,
697 0x2000, 0x2400, 0x2800, 0x2C00, 0x3000, 0x3400, 0x3800, 0x3C00,
698 -0x4000, -0x3C00, -0x3800, -0x3400, -0x3000, -0x2C00, -0x2800, -0x2400,
699 -0x2000, -0x1C00, -0x1800, -0x1400, -0x1000, -0x0C00, -0x0800, -0x0400
701 0x0000, 0x0200, 0x0400, 0x0600, 0x0800, 0x0A00, 0x0C00, 0x0E00,
702 0x1000, 0x1200, 0x1400, 0x1600, 0x1800, 0x1A00, 0x1C00, 0x1E00,
703 -0x2000, -0x1E00, -0x1C00, -0x1A00, -0x1800, -0x1600, -0x1400, -0x1200,
704 -0x1000, -0x0E00, -0x0C00, -0x0A00, -0x0800, -0x0600, -0x0400, -0x0200
706 0x0000, 0x0100, 0x0200, 0x0300, 0x0400, 0x0500, 0x0600, 0x0700,
707 0x0800, 0x0900, 0x0A00, 0x0B00, 0x0C00, 0x0D00, 0x0E00, 0x0F00,
708 -0x1000, -0x0F00, -0x0E00, -0x0D00, -0x0C00, -0x0B00, -0x0A00, -0x0900,
709 -0x0800, -0x0700, -0x0600, -0x0500, -0x0400, -0x0300, -0x0200, -0x0100
711 0x000, 0x080, 0x100, 0x180, 0x200, 0x280, 0x300, 0x380,
712 0x400, 0x480, 0x500, 0x580, 0x600, 0x680, 0x700, 0x780,
713 -0x800, -0x780, -0x700, -0x680, -0x600, -0x580, -0x500, -0x480,
714 -0x400, -0x380, -0x300, -0x280, -0x200, -0x180, -0x100, -0x080
716 0x000, 0x048, 0x090, 0x0D8, 0x120, 0x168, 0x1B0, 0x1F8,
717 0x240, 0x288, 0x2D0, 0x318, 0x360, 0x3A8, 0x3F0, 0x438,
718 -0x480, -0x438, -0x3F0, -0x3A8, -0x360, -0x318, -0x2D0, -0x288,
719 -0x240, -0x1F8, -0x1B0, -0x168, -0x120, -0x0D8, -0x090, -0x048
721 0x000, 0x030, 0x060, 0x090, 0x0C0, 0x0F0, 0x120, 0x150,
722 0x180, 0x1B0, 0x1E0, 0x210, 0x240, 0x270, 0x2A0, 0x2D0,
723 -0x300, -0x2D0, -0x2A0, -0x270, -0x240, -0x210, -0x1E0, -0x1B0,
724 -0x180, -0x150, -0x120, -0x0F0, -0x0C0, -0x090, -0x060, -0x030
726 0x000, 0x020, 0x040, 0x060, 0x080, 0x0A0, 0x0C0, 0x0E0,
727 0x100, 0x120, 0x140, 0x160, 0x180, 0x1A0, 0x1C0, 0x1E0,
728 -0x200, -0x1E0, -0x1C0, -0x1A0, -0x180, -0x160, -0x140, -0x120,
729 -0x100, -0x0E0, -0x0C0, -0x0A0, -0x080, -0x060, -0x040, -0x020
731 0x000, 0x016, 0x02C, 0x042, 0x058, 0x06E, 0x084, 0x09A,
732 0x0B0, 0x0C6, 0x0DC, 0x0F2, 0x108, 0x11E, 0x134, 0x14A,
733 -0x160, -0x14A, -0x134, -0x11E, -0x108, -0x0F2, -0x0DC, -0x0C6,
734 -0x0B0, -0x09A, -0x084, -0x06E, -0x058, -0x042, -0x02C, -0x016
736 0x000, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070,
737 0x080, 0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0,
738 -0x100, -0x0F0, -0x0E0, -0x0D0, -0x0C0, -0x0B0, -0x0A0, -0x090,
739 -0x080, -0x070, -0x060, -0x050, -0x040, -0x030, -0x020, -0x010
741 0x00, 0x0B, 0x16, 0x21, 0x2C, 0x37, 0x42, 0x4D,
742 0x58, 0x63, 0x6E, 0x79, 0x84, 0x8F, 0x9A, 0xA5,
743 -0xB0, -0xA5, -0x9A, -0x8F, -0x84, -0x79, -0x6E, -0x63,
744 -0x58, -0x4D, -0x42, -0x37, -0x2C, -0x21, -0x16, -0x0B
746 0x00, 0x08, 0x10, 0x18, 0x20, 0x28, 0x30, 0x38,
747 0x40, 0x48, 0x50, 0x58, 0x60, 0x68, 0x70, 0x78,
748 -0x80, -0x78, -0x70, -0x68, -0x60, -0x58, -0x50, -0x48,
749 -0x40, -0x38, -0x30, -0x28, -0x20, -0x18, -0x10, -0x08
751 0x00, 0x06, 0x0C, 0x12, 0x18, 0x1E, 0x24, 0x2A,
752 0x30, 0x36, 0x3C, 0x42, 0x48, 0x4E, 0x54, 0x5A,
753 -0x60, -0x5A, -0x54, -0x4E, -0x48, -0x42, -0x3C, -0x36,
754 -0x30, -0x2A, -0x24, -0x1E, -0x18, -0x12, -0x0C, -0x06
756 0x00, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C,
757 0x20, 0x24, 0x28, 0x2C, 0x30, 0x34, 0x38, 0x3C,
758 -0x40, -0x3C, -0x38, -0x34, -0x30, -0x2C, -0x28, -0x24,
759 -0x20, -0x1C, -0x18, -0x14, -0x10, -0x0C, -0x08, -0x04
761 0x00, 0x02, 0x05, 0x08, 0x0B, 0x0D, 0x10, 0x13,
762 0x16, 0x18, 0x1B, 0x1E, 0x21, 0x23, 0x26, 0x29,
763 -0x2C, -0x2A, -0x27, -0x24, -0x21, -0x1F, -0x1C, -0x19,
764 -0x16, -0x14, -0x11, -0x0E, -0x0B, -0x09, -0x06, -0x03
766 0x00, 0x01, 0x03, 0x05, 0x07, 0x08, 0x0A, 0x0C,
767 0x0E, 0x0F, 0x11, 0x13, 0x15, 0x16, 0x18, 0x1A,
768 -0x1C, -0x1B, -0x19, -0x17, -0x15, -0x14, -0x12, -0x10,
769 -0x0E, -0x0D, -0x0B, -0x09, -0x07, -0x06, -0x04, -0x02
771 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
772 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
773 -0x10, -0x0F, -0x0E, -0x0D, -0x0C, -0x0B, -0x0A, -0x09,
774 -0x08, -0x07, -0x06, -0x05, -0x04, -0x03, -0x02, -0x01