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 frame1 = Vec::with_capacity(BMV_MAX_SIZE);
89 frame1.resize(BMV_MAX_SIZE, 0);
90 let mut frame2 = Vec::with_capacity(BMV_MAX_SIZE);
91 frame2.resize(BMV_MAX_SIZE, 0);
93 let mut pixels = [0u16; 256];
94 for (i, el) in pixels.iter_mut().enumerate() {
97 let mut pixbuf = [[0u16; 256]; 7];
100 pixbuf[i][j] = ((i << 8) + j + 0xF8) as u16;
105 info: NACodecInfoRef::default(),
111 mode: BMV3Mode::Normal,
114 nr: NibbleReader::new(),
118 fn decode_frame(&mut self, br: &mut ByteReader) -> DecoderResult<()> {
121 let op = br.read_byte()?;
125 let op2 = br.read_u16le()?;
126 skip = ((op2 >> 12) as usize) | ((op as usize) << 4);
127 len = (op2 & 0xFFF) as usize;
129 len = ((op & 7) + 1) as usize;
130 skip = ((op >> 3) - 0x11) as usize;
132 while (idx < 0xF8) && (len > 0) {
133 self.pixels[idx] = br.read_u16le()?;
137 while (idx < 0x7F8) && (len > 0) {
138 let nidx = idx - 0xF8;
139 self.pixbuf[nidx >> 8][nidx & 0xFF] = br.read_u16le()?;
144 if skip == 0 { break; }
148 self.mode = BMV3Mode::Normal;
149 while br.left() > 0 && self.pos < self.end {
151 BMV3Mode::Normal => {
152 let op = br.read_byte()?;
153 self.decode_normal(br, op)?;
156 let op = br.read_byte()?;
158 self.decode_normal(br, op + 1)?;
160 self.decode_copy(br, op)?;
163 BMV3Mode::Pixfunc => {
164 let op = br.read_byte()?;
166 self.decode_copy(br, op + 1)?;
168 self.decode_normal(br, op - 1)?;
171 BMV3Mode::After0 => {
172 let cur_op = self.nr.get_nib(br)?;
174 let op = self.nr.get_nib(br)?;
176 0 => self.decode_mode5c(br, op | 0x10)?,
177 1 => self.decode_mode4 (br, op | 0x10)?,
178 2 => self.decode_mode5c(br, op | 0x30)?,
179 _ => self.decode_mode4 (br, op | 0x30)?,
182 let len = (cur_op >> 1) - 1;
183 if (cur_op & 1) == 0 {
184 self.pixfunc(br, len as usize)?;
186 self.repeat(len as usize)?;
190 BMV3Mode::After1 => {
191 let cur_op = self.nr.get_nib(br)?;
193 let op = self.nr.get_nib(br)?;
195 0 => self.decode_mode4 (br, op | 0x10)?,
196 1 => self.decode_mode5c(br, op | 0x00)?,
197 2 => self.decode_mode4 (br, op | 0x30)?,
198 _ => self.decode_mode5c(br, op | 0x20)?,
201 let len = (cur_op >> 1) - 1;
202 if (cur_op & 1) == 0 {
203 self.repeat(len as usize)?;
205 self.copy(len as usize)?;
209 BMV3Mode::After1C => {
210 let cur_op = self.nr.get_nib(br)?;
212 let cur_op1 = self.nr.get_nib(br)?;
213 let m5_op = cur_op1 | (cur_op << 4);
214 self.decode_mode5c(br, m5_op)?;
215 } else if (cur_op & 1) == 0 {
216 let len = (cur_op >> 1) - 1;
217 self.copy(len as usize)?;
219 let len = (cur_op >> 1) - 1;
220 self.pixfunc(br, len as usize)?;
223 BMV3Mode::After4 => {
224 let cur_op0 = self.nr.get_nib(br)?;
225 let cur_op1 = self.nr.get_nib(br)?;
226 let cur_op = (cur_op0 << 4) | cur_op1;
227 if (cur_op & 0x10) == 0 {
228 self.decode_mode5c(br, cur_op | 0x10)?;
230 self.decode_mode4(br, cur_op)?;
233 BMV3Mode::After5 => {
234 let cur_op0 = self.nr.get_nib(br)?;
235 let cur_op1 = self.nr.get_nib(br)?;
236 let cur_op = (cur_op0 << 4) | cur_op1;
237 if (cur_op & 0x10) == 0 {
238 self.decode_mode4(br, cur_op | 0x10)?;
240 self.decode_mode5c(br, cur_op ^ 0x10)?;
244 if self.pos >= self.end { break; }
249 fn copy(&mut self, len: usize) -> DecoderResult<()> {
250 validate!(len <= self.end - self.pos);
253 self.frame[self.pos] = self.frame[self.pos - self.stride];
258 self.frame[self.pos] = self.prev_frame[self.pos];
262 self.mode = BMV3Mode::Copy;
265 fn pixfunc(&mut self, br: &mut ByteReader, len: usize) -> DecoderResult<()> {
266 validate!(len <= self.end - self.pos);
268 let op = BMV_PIXFUNCS_MAP[br.read_byte()? as usize];
271 val = br.read_u16le()?;
272 } else if op >= 0xF8 {
273 let tab_idx = (op - 0xF8) as usize;
274 let sub_idx = br.read_byte()? as usize;
275 val = self.pixbuf[tab_idx][sub_idx];
277 val = self.pixels[op as usize];
279 self.frame[self.pos] = val;
282 self.mode = BMV3Mode::Pixfunc;
285 fn repeat(&mut self, len: usize) -> DecoderResult<()> {
286 validate!(self.pos > 0);
287 validate!(len <= self.end - self.pos);
288 let pix = self.frame[self.pos - 1];
290 self.frame[self.pos] = pix;
293 self.mode = BMV3Mode::Normal;
297 fn decode_normal(&mut self, br: &mut ByteReader, op: u8) -> DecoderResult<()> {
300 let len = ((op >> 1) & 0x7) as usize;
302 let mut len = (op >> 3) as usize;
306 len = self.nr.get_length(br, len, 3)?;
310 self.mode = BMV3Mode::After0;
313 self.pixfunc(br, len)?;
315 self.mode = BMV3Mode::After1;
318 } else if mode == 0 {
320 self.nr.push(op >> 4);
321 self.mode = BMV3Mode::After4;
323 self.pixfunc(br, len - 1)?;
324 self.nr.push(op >> 4);
325 self.mode = BMV3Mode::After5;
329 let x_op = (op >> 4) as usize;
330 let y_op = ((op >> 1) & 7) as usize;
331 let flag = (op & 1) as usize;
332 if y_op == 0 || y_op == 1 {
333 let len = x_op * 2 - 1 + y_op;
337 self.pixfunc(br, len)?;
341 let len2 = (x_op >> 1) - 1;
345 self.pixfunc(br, len1)?;
347 match (x_op & 1) * 2 + flag {
348 0 => self.pixfunc(br, len2)?,
349 1 => self.repeat(len2)?,
350 2 => self.repeat(len2)?,
351 _ => self.copy(len2)?,
356 fn decode_copy(&mut self, br: &mut ByteReader, op: u8) -> DecoderResult<()> {
358 let len = ((op >> 1) & 0x7) as usize;
360 let mut len = (op >> 3) as usize;
364 len = self.nr.get_length(br, len, 3)?;
367 self.mode = BMV3Mode::After1C;
370 self.repeat(len - 1)?;
371 if br.left() == 0 { return Ok(()); }
372 let op2 = self.nr.get_nib(br)?;
373 let cur_op = (op & 0xF0) | op2;
374 self.decode_mode5c(br, cur_op)?;
378 let x_op = (op >> 4) as usize;
379 let y_op = ((op >> 1) & 7) as usize;
380 if y_op == 0 || y_op == 1 {
381 self.repeat(x_op * 2 - 1 + y_op)?;
383 self.repeat(y_op - 1)?;
384 let len = (x_op >> 1) - 1;
388 self.pixfunc(br, len)?;
393 fn decode_mode4(&mut self, br: &mut ByteReader, op: u8) -> DecoderResult<()> {
395 let mut len = ((op & 3) * 2) as usize;
396 if (op & 0xF0) >= 0x20 {
399 len = self.nr.get_length(br, len, 3)?;
402 self.mode = BMV3Mode::After1C;
405 let len = ((op & 0xF) * 2 - 1 + (op >> 5)) as usize;
407 self.mode = BMV3Mode::After1C;
411 fn decode_mode5c(&mut self, br: &mut ByteReader, op: u8) -> DecoderResult<()> {
413 let mut len = ((op & 3) * 2) as usize;
414 if (op & 0xF0) >= 0x20 {
417 len = self.nr.get_length(br, len, 3)?;
418 if (op & 0x10) == 0 {
421 self.mode = BMV3Mode::After0;
424 self.pixfunc(br, len)?;
426 self.mode = BMV3Mode::After1;
430 let len = ((op & 0xF) * 2 - 1 + (op >> 5)) as usize;
431 if (op & 0x10) == 0 {
433 self.mode = BMV3Mode::After0;
435 self.pixfunc(br, len)?;
436 self.mode = BMV3Mode::After1;
443 impl NADecoder for BMV3VideoDecoder {
444 fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {
445 if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
446 let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), false, RGB565_FORMAT));
447 self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
449 self.stride = vinfo.get_width();
450 self.height = vinfo.get_height();
451 self.end = self.stride * (self.height + 1);
453 validate!((self.stride <= 640) && (self.height <= 432));
457 Err(DecoderError::InvalidData)
460 fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
461 let src = pkt.get_buffer();
462 validate!(src.len() > 1);
464 let mut mr = MemoryReader::new_read(&src);
465 let mut br = ByteReader::new(&mut mr);
466 let flags = br.read_byte()?;
468 if (flags & BMV_COMMAND) != 0 {
469 let size = if (flags & BMV_PRINT) != 0 { 8 } else { 10 };
472 if (flags & BMV_PAL) != 0 {
473 return Err(DecoderError::InvalidData);
476 if ((flags & 1) == 0) && ((flags & BMV_SCROLL) != 0) {
477 off = br.read_u16le()? as usize;
481 self.pos = off + self.stride;
482 self.is_intra = (flags & BMV_INTRA) == BMV_INTRA;
484 let bufret = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0);
485 if let Err(_) = bufret { return Err(DecoderError::InvalidData); }
486 let bufinfo = bufret.unwrap();
488 self.decode_frame(&mut br)?;
491 let mut buf = bufinfo.get_vbuf16().unwrap();
492 let stride = buf.get_stride(0);
493 let data = buf.get_data_mut().unwrap();
494 let dst = data.as_mut_slice();
496 let refbuf = &self.frame[self.stride..];
497 for (dst, src) in dst.chunks_mut(stride).zip(refbuf.chunks(self.stride)).take(self.height) {
498 let out = &mut dst[0..self.stride];
499 out.copy_from_slice(src);
502 std::mem::swap(&mut self.frame, &mut self.prev_frame);
504 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
505 frm.set_keyframe(self.is_intra);
506 frm.set_frame_type(if self.is_intra { FrameType::I } else { FrameType::P });
512 pub fn get_decoder_video() -> Box<NADecoder> {
513 Box::new(BMV3VideoDecoder::new())
516 struct BMV3AudioDecoder {
523 impl BMV3AudioDecoder {
526 ainfo: NAAudioInfo::new(0, 1, formats::SND_S16P_FORMAT, 0),
527 chmap: NAChannelMap::new(),
534 fn decode_block(mode: u8, src: &[u8], dst: &mut [i16], mut pred: i16) -> i16 {
535 let steps = &BMV_AUDIO_STEPS[mode as usize];
538 let val = (src[i * 2 + 0] as usize) + (src[i * 2 + 1] as usize) * 256;
539 pred = pred.wrapping_add(steps[(val >> 10) & 0x1F]);
540 dst[i * 3 + 0] = pred;
541 pred = pred.wrapping_add(steps[(val >> 5) & 0x1F]);
542 dst[i * 3 + 1] = pred;
543 pred = pred.wrapping_add(steps[(val >> 0) & 0x1F]);
544 dst[i * 3 + 2] = pred;
545 val2 = (val2 << 1) | (val >> 15);
547 pred = pred.wrapping_add(steps[(val2 >> 5) & 0x1F]);
548 dst[3 * 10 + 0] = pred;
549 pred = pred.wrapping_add(steps[(val2 >> 0) & 0x1F]);
550 dst[3 * 10 + 1] = pred;
554 impl NADecoder for BMV3AudioDecoder {
555 fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {
556 if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
557 self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), ainfo.get_channels(), formats::SND_S16P_FORMAT, 32);
558 self.chmap = NAChannelMap::from_str("L,R").unwrap();
561 Err(DecoderError::InvalidData)
564 fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
565 let info = pkt.get_stream().get_info();
566 if let NACodecTypeInfo::Audio(_) = info.get_properties() {
567 let pktbuf = pkt.get_buffer();
568 validate!(pktbuf.len() > 1);
569 let samples = (pktbuf.len() / 41) * 32;
570 let abuf = alloc_audio_buffer(self.ainfo, samples, self.chmap.clone())?;
571 let mut adata = abuf.get_abuf_i16().unwrap();
572 let off1 = adata.get_offset(1);
573 let dst = adata.get_data_mut().unwrap();
574 let mut first = pktbuf[0] == 0;
575 let psrc = &pktbuf[1..];
576 for (n, src) in psrc.chunks_exact(41).enumerate() {
578 let aoff1 = aoff0 + off1;
581 self.pred[0] = decode_block(mode >> 4, &src[0..], &mut dst[aoff0..], self.pred[0]);
582 self.pred[1] = decode_block(mode & 0xF, &src[20..], &mut dst[aoff1..], self.pred[1]);
585 self.pred[0] = decode_block(mode >> 4, &src[1..], &mut dst[aoff0..], self.pred[0]);
586 self.pred[1] = decode_block(mode & 0xF, &src[21..], &mut dst[aoff1..], self.pred[1]);
591 let mut frm = NAFrame::new_from_pkt(pkt, info, abuf);
592 frm.set_duration(Some(samples as u64));
593 frm.set_keyframe(false);
596 Err(DecoderError::InvalidData)
601 pub fn get_decoder_audio() -> Box<NADecoder> {
602 Box::new(BMV3AudioDecoder::new())
607 use nihav_core::codecs::RegisteredDecoders;
608 use nihav_core::demuxers::RegisteredDemuxers;
609 use nihav_core::test::dec_video::*;
610 use crate::codecs::game_register_all_codecs;
611 use crate::demuxers::game_register_all_demuxers;
613 fn test_bmv_video() {
614 let mut dmx_reg = RegisteredDemuxers::new();
615 game_register_all_demuxers(&mut dmx_reg);
616 let mut dec_reg = RegisteredDecoders::new();
617 game_register_all_codecs(&mut dec_reg);
619 let file = "assets/Game/DW3-Loffnote.bmv";
620 test_file_decoding("bmv3", file, None, true, false, None, &dmx_reg, &dec_reg);
623 fn test_bmv_audio() {
624 let mut dmx_reg = RegisteredDemuxers::new();
625 game_register_all_demuxers(&mut dmx_reg);
626 let mut dec_reg = RegisteredDecoders::new();
627 game_register_all_codecs(&mut dec_reg);
629 let file = "assets/Game/DW3-Loffnote.bmv";
630 test_decode_audio("bmv3", file, None, "bmv3", &dmx_reg, &dec_reg);
634 const BMV_PIXFUNCS_MAP: [u8; 256] = [
635 0x38, 0x78, 0xB8, 0xF9,
636 0x39, 0x79, 0xB9, 0xFA,
637 0x3A, 0x7A, 0xBA, 0xFB,
638 0x3B, 0x7B, 0xBB, 0xFC,
639 0x3C, 0x7C, 0xBC, 0xFD,
640 0x3D, 0x7D, 0xBD, 0xFE,
641 0x3E, 0x7E, 0xBE, 0xFF,
642 0x3F, 0x7F, 0xBF, 0x00,
643 0x40, 0x80, 0xC0, 0x01,
644 0x41, 0x81, 0xC1, 0x02,
645 0x42, 0x82, 0xC2, 0x03,
646 0x43, 0x83, 0xC3, 0x04,
647 0x44, 0x84, 0xC4, 0x05,
648 0x45, 0x85, 0xC5, 0x06,
649 0x46, 0x86, 0xC6, 0x07,
650 0x47, 0x87, 0xC7, 0x08,
651 0x48, 0x88, 0xC8, 0x09,
652 0x49, 0x89, 0xC9, 0x0A,
653 0x4A, 0x8A, 0xCA, 0x0B,
654 0x4B, 0x8B, 0xCB, 0x0C,
655 0x4C, 0x8C, 0xCC, 0x0D,
656 0x4D, 0x8D, 0xCD, 0x0E,
657 0x4E, 0x8E, 0xCE, 0x0F,
658 0x4F, 0x8F, 0xCF, 0x10,
659 0x50, 0x90, 0xD0, 0x11,
660 0x51, 0x91, 0xD1, 0x12,
661 0x52, 0x92, 0xD2, 0x13,
662 0x53, 0x93, 0xD3, 0x14,
663 0x54, 0x94, 0xD4, 0x15,
664 0x55, 0x95, 0xD5, 0x16,
665 0x56, 0x96, 0xD6, 0x17,
666 0x57, 0x97, 0xD7, 0x18,
667 0x58, 0x98, 0xD8, 0x19,
668 0x59, 0x99, 0xD9, 0x1A,
669 0x5A, 0x9A, 0xDA, 0x1B,
670 0x5B, 0x9B, 0xDB, 0x1C,
671 0x5C, 0x9C, 0xDC, 0x1D,
672 0x5D, 0x9D, 0xDD, 0x1E,
673 0x5E, 0x9E, 0xDE, 0x1F,
674 0x5F, 0x9F, 0xDF, 0x20,
675 0x60, 0xA0, 0xE0, 0x21,
676 0x61, 0xA1, 0xE1, 0x22,
677 0x62, 0xA2, 0xE2, 0x23,
678 0x63, 0xA3, 0xE3, 0x24,
679 0x64, 0xA4, 0xE4, 0x25,
680 0x65, 0xA5, 0xE5, 0x26,
681 0x66, 0xA6, 0xE6, 0x27,
682 0x67, 0xA7, 0xE7, 0x28,
683 0x68, 0xA8, 0xE8, 0x29,
684 0x69, 0xA9, 0xE9, 0x2A,
685 0x6A, 0xAA, 0xEA, 0x2B,
686 0x6B, 0xAB, 0xEB, 0x2C,
687 0x6C, 0xAC, 0xEC, 0x2D,
688 0x6D, 0xAD, 0xED, 0x2E,
689 0x6E, 0xAE, 0xEE, 0x2F,
690 0x6F, 0xAF, 0xEF, 0x30,
691 0x70, 0xB0, 0xF0, 0x31,
692 0x71, 0xB1, 0xF1, 0x32,
693 0x72, 0xB2, 0xF2, 0x33,
694 0x73, 0xB3, 0xF3, 0x34,
695 0x74, 0xB4, 0xF4, 0x35,
696 0x75, 0xB5, 0xF5, 0x36,
697 0x76, 0xB6, 0xF6, 0x37,
698 0x77, 0xB7, 0xF7, 0xF8
701 const BMV_AUDIO_STEPS: [[i16; 32]; 16] = [
703 0x0000, 0x0400, 0x0800, 0x0C00, 0x1000, 0x1400, 0x1800, 0x1C00,
704 0x2000, 0x2400, 0x2800, 0x2C00, 0x3000, 0x3400, 0x3800, 0x3C00,
705 -0x4000, -0x3C00, -0x3800, -0x3400, -0x3000, -0x2C00, -0x2800, -0x2400,
706 -0x2000, -0x1C00, -0x1800, -0x1400, -0x1000, -0x0C00, -0x0800, -0x0400
708 0x0000, 0x0200, 0x0400, 0x0600, 0x0800, 0x0A00, 0x0C00, 0x0E00,
709 0x1000, 0x1200, 0x1400, 0x1600, 0x1800, 0x1A00, 0x1C00, 0x1E00,
710 -0x2000, -0x1E00, -0x1C00, -0x1A00, -0x1800, -0x1600, -0x1400, -0x1200,
711 -0x1000, -0x0E00, -0x0C00, -0x0A00, -0x0800, -0x0600, -0x0400, -0x0200
713 0x0000, 0x0100, 0x0200, 0x0300, 0x0400, 0x0500, 0x0600, 0x0700,
714 0x0800, 0x0900, 0x0A00, 0x0B00, 0x0C00, 0x0D00, 0x0E00, 0x0F00,
715 -0x1000, -0x0F00, -0x0E00, -0x0D00, -0x0C00, -0x0B00, -0x0A00, -0x0900,
716 -0x0800, -0x0700, -0x0600, -0x0500, -0x0400, -0x0300, -0x0200, -0x0100
718 0x000, 0x080, 0x100, 0x180, 0x200, 0x280, 0x300, 0x380,
719 0x400, 0x480, 0x500, 0x580, 0x600, 0x680, 0x700, 0x780,
720 -0x800, -0x780, -0x700, -0x680, -0x600, -0x580, -0x500, -0x480,
721 -0x400, -0x380, -0x300, -0x280, -0x200, -0x180, -0x100, -0x080
723 0x000, 0x048, 0x090, 0x0D8, 0x120, 0x168, 0x1B0, 0x1F8,
724 0x240, 0x288, 0x2D0, 0x318, 0x360, 0x3A8, 0x3F0, 0x438,
725 -0x480, -0x438, -0x3F0, -0x3A8, -0x360, -0x318, -0x2D0, -0x288,
726 -0x240, -0x1F8, -0x1B0, -0x168, -0x120, -0x0D8, -0x090, -0x048
728 0x000, 0x030, 0x060, 0x090, 0x0C0, 0x0F0, 0x120, 0x150,
729 0x180, 0x1B0, 0x1E0, 0x210, 0x240, 0x270, 0x2A0, 0x2D0,
730 -0x300, -0x2D0, -0x2A0, -0x270, -0x240, -0x210, -0x1E0, -0x1B0,
731 -0x180, -0x150, -0x120, -0x0F0, -0x0C0, -0x090, -0x060, -0x030
733 0x000, 0x020, 0x040, 0x060, 0x080, 0x0A0, 0x0C0, 0x0E0,
734 0x100, 0x120, 0x140, 0x160, 0x180, 0x1A0, 0x1C0, 0x1E0,
735 -0x200, -0x1E0, -0x1C0, -0x1A0, -0x180, -0x160, -0x140, -0x120,
736 -0x100, -0x0E0, -0x0C0, -0x0A0, -0x080, -0x060, -0x040, -0x020
738 0x000, 0x016, 0x02C, 0x042, 0x058, 0x06E, 0x084, 0x09A,
739 0x0B0, 0x0C6, 0x0DC, 0x0F2, 0x108, 0x11E, 0x134, 0x14A,
740 -0x160, -0x14A, -0x134, -0x11E, -0x108, -0x0F2, -0x0DC, -0x0C6,
741 -0x0B0, -0x09A, -0x084, -0x06E, -0x058, -0x042, -0x02C, -0x016
743 0x000, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070,
744 0x080, 0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0,
745 -0x100, -0x0F0, -0x0E0, -0x0D0, -0x0C0, -0x0B0, -0x0A0, -0x090,
746 -0x080, -0x070, -0x060, -0x050, -0x040, -0x030, -0x020, -0x010
748 0x00, 0x0B, 0x16, 0x21, 0x2C, 0x37, 0x42, 0x4D,
749 0x58, 0x63, 0x6E, 0x79, 0x84, 0x8F, 0x9A, 0xA5,
750 -0xB0, -0xA5, -0x9A, -0x8F, -0x84, -0x79, -0x6E, -0x63,
751 -0x58, -0x4D, -0x42, -0x37, -0x2C, -0x21, -0x16, -0x0B
753 0x00, 0x08, 0x10, 0x18, 0x20, 0x28, 0x30, 0x38,
754 0x40, 0x48, 0x50, 0x58, 0x60, 0x68, 0x70, 0x78,
755 -0x80, -0x78, -0x70, -0x68, -0x60, -0x58, -0x50, -0x48,
756 -0x40, -0x38, -0x30, -0x28, -0x20, -0x18, -0x10, -0x08
758 0x00, 0x06, 0x0C, 0x12, 0x18, 0x1E, 0x24, 0x2A,
759 0x30, 0x36, 0x3C, 0x42, 0x48, 0x4E, 0x54, 0x5A,
760 -0x60, -0x5A, -0x54, -0x4E, -0x48, -0x42, -0x3C, -0x36,
761 -0x30, -0x2A, -0x24, -0x1E, -0x18, -0x12, -0x0C, -0x06
763 0x00, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C,
764 0x20, 0x24, 0x28, 0x2C, 0x30, 0x34, 0x38, 0x3C,
765 -0x40, -0x3C, -0x38, -0x34, -0x30, -0x2C, -0x28, -0x24,
766 -0x20, -0x1C, -0x18, -0x14, -0x10, -0x0C, -0x08, -0x04
768 0x00, 0x02, 0x05, 0x08, 0x0B, 0x0D, 0x10, 0x13,
769 0x16, 0x18, 0x1B, 0x1E, 0x21, 0x23, 0x26, 0x29,
770 -0x2C, -0x2A, -0x27, -0x24, -0x21, -0x1F, -0x1C, -0x19,
771 -0x16, -0x14, -0x11, -0x0E, -0x0B, -0x09, -0x06, -0x03
773 0x00, 0x01, 0x03, 0x05, 0x07, 0x08, 0x0A, 0x0C,
774 0x0E, 0x0F, 0x11, 0x13, 0x15, 0x16, 0x18, 0x1A,
775 -0x1C, -0x1B, -0x19, -0x17, -0x15, -0x14, -0x12, -0x10,
776 -0x0E, -0x0D, -0x0B, -0x09, -0x07, -0x06, -0x04, -0x02
778 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
779 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
780 -0x10, -0x0F, -0x0E, -0x0D, -0x0C, -0x0B, -0x0A, -0x09,
781 -0x08, -0x07, -0x06, -0x05, -0x04, -0x03, -0x02, -0x01