nihav-duck/src/codecs/truemotion1.rs

   1 use nihav_core::codecs::*;
   2 use nihav_core::io::byteio::*;
   3
   4 struct MaskState<'a> {
   5     is_intra:   bool,
   6     pos:        usize,
   7     row_pos:   usize,
   8     row_size:   usize,
   9     mask:       u8,
  10     src:        &'a [u8],
  11 }
  12
  13 impl<'a> MaskState<'a> {
  14     fn new(is_intra: bool, src: &'a [u8], row_size: usize) -> Self {
  15         Self { is_intra, src, pos: 0, row_pos: 0, row_size, mask: 0x01 }
  16     }
  17     fn get_next(&mut self) -> bool {
  18         if self.is_intra {
  19             true
  20         } else {
  21             let res = (self.src[self.pos] & self.mask) == 0;
  22             self.mask <<= 1;
  23             if self.mask == 0 {
  24                 self.pos += 1;
  25                 self.mask = 0x01;
  26             }
  27             res
  28         }
  29     }
  30     fn reset_row(&mut self) {
  31         self.pos = self.row_pos;
  32         self.mask = 0x01;
  33     }
  34     fn next_row(&mut self) {
  35         self.row_pos += self.row_size;
  36         self.reset_row();
  37     }
  38 }
  39
  40 struct IndexState<'a> {
  41     src:        &'a [u8],
  42     pos:        usize,
  43     vec_idx:    usize,
  44     vec_subidx: usize,
  45 }
  46
  47 impl<'a> IndexState<'a> {
  48     fn new(src: &'a [u8]) -> Self {
  49         Self { src, pos: 0, vec_idx: 0, vec_subidx: 0 }
  50     }
  51     fn get_next(&mut self) -> DecoderResult<()> {
  52         validate!(self.pos < self.src.len());
  53         self.vec_idx = self.src[self.pos] as usize;
  54         self.vec_subidx = 0;
  55         self.pos += 1;
  56         Ok(())
  57     }
  58     fn get_pred(&self, dtab: &[[u32; 4]; 256]) -> u32 { dtab[self.vec_idx][self.vec_subidx] }
  59     fn get_diff16(&mut self, dtab: &[[u32; 4]; 256]) -> DecoderResult<u32> {
  60         let pred1 = self.get_pred(dtab);
  61         let mut pred = pred1 >> 1;
  62         if (pred1 & 1) != 0 {
  63             self.get_next()?;
  64             if self.vec_idx == 0 {
  65                 self.get_next()?;
  66                 let pred2 = self.get_pred(dtab);
  67                 pred = pred.wrapping_add((pred2 >> 1).wrapping_mul(5));
  68                 if (pred2 & 1) != 0 {
  69                     self.get_next()?;
  70                 } else {
  71                     self.vec_subidx += 1;
  72                 }
  73             }
  74         } else {
  75             self.vec_subidx += 1;
  76         }
  77         Ok(pred)
  78     }
  79     fn get_diff16_noesc(&mut self, dtab: &[[u32; 4]; 256]) -> DecoderResult<u32> {
  80         let pred1 = self.get_pred(dtab);
  81         let pred = pred1 >> 1;
  82         if (pred1 & 1) != 0 {
  83             self.get_next()?;
  84         } else {
  85             self.vec_subidx += 1;
  86         }
  87         Ok(pred)
  88     }
  89     fn get_diff24(&mut self, dtab: &[[u32; 4]; 256], esctab: &[[u32; 4]; 256]) -> DecoderResult<u32> {
  90         let pred1 = self.get_pred(dtab);
  91         let mut pred = pred1 >> 1;
  92         if (pred1 & 1) != 0 {
  93             self.get_next()?;
  94             if self.vec_idx == 0 {
  95                 self.get_next()?;
  96                 let pred2 = self.get_pred(esctab);
  97                 pred = pred.wrapping_add(pred2 >> 1);
  98                 if (pred2 & 1) != 0 {
  99                     self.get_next()?;
 100                 } else {
 101                     self.vec_subidx += 1;
 102                 }
 103             }
 104         } else {
 105             self.vec_subidx += 1;
 106         }
 107         Ok(pred)
 108     }
 109 }
 110
 111 struct DeltaTables {
 112     ydt:        [[u32; 4]; 256],
 113     cdt:        [[u32; 4]; 256],
 114     fat_ydt:    [[u32; 4]; 256],
 115     fat_cdt:    [[u32; 4]; 256],
 116     adt:        [[u32; 4]; 256],
 117 }
 118
 119 impl Default for DeltaTables {
 120     fn default() -> Self {
 121         Self {
 122             ydt:        [[0; 4]; 256],
 123             cdt:        [[0; 4]; 256],
 124             fat_ydt:    [[0; 4]; 256],
 125             fat_cdt:    [[0; 4]; 256],
 126             adt:        [[0; 4]; 256],
 127         }
 128     }
 129 }
 130
 131 #[derive(Default)]
 132 struct FrameBuf {
 133     last16: Option<NAVideoBufferRef<u16>>,
 134     last24: Option<NAVideoBufferRef<u8>>,
 135 }
 136
 137 impl FrameBuf {
 138     fn set16(&mut self, buf: NAVideoBufferRef<u16>) { self.last16 = Some(buf); }
 139     fn set24(&mut self, buf: NAVideoBufferRef<u8>)  { self.last24 = Some(buf); }
 140     fn get16(&mut self) -> Option<NAVideoBufferRef<u16>> {
 141         if let Some(ref mut frm) = self.last16 {
 142             let newfrm = frm.copy_buffer();
 143             *frm = newfrm.clone().into_ref();
 144             Some(newfrm.into_ref())
 145         } else {
 146             None
 147         }
 148     }
 149     fn get24(&mut self) -> Option<NAVideoBufferRef<u8>> {
 150         if let Some(ref mut frm) = self.last24 {
 151             let newfrm = frm.copy_buffer();
 152             *frm = newfrm.clone().into_ref();
 153             Some(newfrm.into_ref())
 154         } else {
 155             None
 156         }
 157     }
 158     fn reset(&mut self) {
 159         self.last16 = None;
 160         self.last24 = None;
 161     }
 162 }
 163
 164 #[derive(Default)]
 165 struct TM1Decoder {
 166     info:           NACodecInfoRef,
 167     last_delta_set: usize,
 168     last_table_idx: usize,
 169     delta_tables:   DeltaTables,
 170     blk_w:          usize,
 171     blk_h:          usize,
 172     vert_pred:      Vec<u32>,
 173     lastframe:      FrameBuf,
 174 }
 175
 176 const RGB555_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3,
 177                                         comp_info: [
 178                                             Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: 10, comp_offs: 0, next_elem: 2 }),
 179                                             Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift:  5, comp_offs: 0, next_elem: 2 }),
 180                                             Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift:  0, comp_offs: 0, next_elem: 2 }),
 181                                             None, None],
 182                                         elem_size: 2, be: false, alpha: false, palette: false };
 183 const BGR0_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3,
 184                                         comp_info: [
 185                                             Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 2, next_elem: 4 }),
 186                                             Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 1, next_elem: 4 }),
 187                                             Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 0, next_elem: 4 }),
 188                                             None, None],
 189                                         elem_size: 4, be: false, alpha: false, palette: false };
 190
 191 impl TM1Decoder {
 192     fn new() -> Self { Self::default() }
 193     fn set_delta_tables(&mut self, delta_set: usize, table_idx: usize, is_24bit: bool) {
 194         if (self.last_delta_set == delta_set) && (self.last_table_idx == table_idx) { return; }
 195         let ydt  = &DUCK_Y_DELTAS[delta_set];
 196         let yfdt = DUCK_Y_FAT_DELTAS[delta_set];
 197         let cdt  = &DUCK_C_DELTAS[delta_set];
 198         let cfdt = DUCK_C_FAT_DELTAS[delta_set];
 199         let vec  = DUCK_VECTABLES[table_idx - 1];
 200
 201         let mut vec_iter = vec.iter();
 202         for i in 0..256 {
 203             let len = (*vec_iter.next().unwrap() as usize) >> 1;
 204             for j in 0..len {
 205                 let pair = vec_iter.next().unwrap();
 206                 let lo = (pair >> 4) as usize;
 207                 let hi = (pair & 0xF) as usize;
 208                 if !is_24bit {
 209                     let d_lo = ydt[lo] + (ydt[lo] << 5) + (ydt[lo] << 10);
 210                     let d_hi = ydt[hi] + (ydt[hi] << 5) + (ydt[hi] << 10);
 211                     self.delta_tables.ydt[i][j] = ((d_lo + (d_hi << 16)) << 1) as u32;
 212                     let d_c = cdt[hi] + (cdt[lo] << 10);
 213                     self.delta_tables.cdt[i][j] = ((d_c + (d_c << 16)) << 1) as u32;
 214                     let d_a = lo + hi * 5;
 215                     self.delta_tables.adt[i][j] = ((d_a << 16) << 1) as u32;
 216                 } else {
 217                     self.delta_tables.ydt[i][j]     = ((ydt [lo] + (ydt [hi] << 8) + (ydt [hi] << 16)) << 1) as u32;
 218                     self.delta_tables.fat_ydt[i][j] = ((yfdt[lo] + (yfdt[hi] << 8) + (yfdt[hi] << 16)) << 1) as u32;
 219                     self.delta_tables.cdt[i][j]     = ((cdt [hi] + (cdt [lo] << 16)) << 1) as u32;
 220                     self.delta_tables.fat_cdt[i][j] = ((cfdt[hi] + (cfdt[lo] << 16)) << 1) as u32;
 221                 }
 222             }
 223             self.delta_tables.ydt[i][len - 1] |= 1;
 224             self.delta_tables.cdt[i][len - 1] |= 1;
 225             self.delta_tables.adt[i][len - 1] |= 1;
 226             self.delta_tables.fat_ydt[i][len - 1] |= 1;
 227             self.delta_tables.fat_cdt[i][len - 1] |= 1;
 228         }
 229
 230         self.last_delta_set = delta_set;
 231         self.last_table_idx = table_idx;
 232     }
 233     fn decode_16bit(&mut self, dst: &mut [u16], stride: usize, width: usize, height: usize, mask: &mut MaskState<'_>, index: &mut IndexState<'_>) -> DecoderResult<()> {
 234         let mut off = 0;
 235         index.get_next()?;
 236         for y in 0..height {
 237             let mut hor_pred: u32 = 0;
 238             for x in (0..width).step_by(4) {
 239                 if mask.get_next() {
 240                     match y & 3 {
 241                         0 => {
 242                             let dc0 = index.get_diff16(&self.delta_tables.cdt)?;
 243                             let dy0 = index.get_diff16(&self.delta_tables.ydt)?;
 244                             hor_pred = hor_pred.wrapping_add(dc0);
 245                             hor_pred = hor_pred.wrapping_add(dy0);
 246                             let cur = hor_pred.wrapping_add(self.vert_pred[(x >> 1) + 0]);
 247                             self.vert_pred[(x >> 1) + 0] = cur;
 248                             dst[off + x + 0] = cur as u16;
 249                             dst[off + x + 1] = (cur >> 16) as u16;
 250                             if self.blk_w == 2 {
 251                                 let dc1 = index.get_diff16(&self.delta_tables.cdt)?;
 252                                 hor_pred = hor_pred.wrapping_add(dc1);
 253                             }
 254                             let dy1 = index.get_diff16(&self.delta_tables.ydt)?;
 255                             hor_pred = hor_pred.wrapping_add(dy1);
 256                             let cur = hor_pred.wrapping_add(self.vert_pred[(x >> 1) + 1]);
 257                             self.vert_pred[(x >> 1) + 1] = cur;
 258                             dst[off + x + 2] = cur as u16;
 259                             dst[off + x + 3] = (cur >> 16) as u16;
 260                         },
 261                         1 | 3 => {
 262                             let dy0 = index.get_diff16(&self.delta_tables.ydt)?;
 263                             hor_pred = hor_pred.wrapping_add(dy0);
 264                             let cur = hor_pred.wrapping_add(self.vert_pred[(x >> 1) + 0]);
 265                             self.vert_pred[(x >> 1) + 0] = cur;
 266                             dst[off + x + 0] = cur as u16;
 267                             dst[off + x + 1] = (cur >> 16) as u16;
 268                             let dy1 = index.get_diff16(&self.delta_tables.ydt)?;
 269                             hor_pred = hor_pred.wrapping_add(dy1);
 270                             let cur = hor_pred.wrapping_add(self.vert_pred[(x >> 1) + 1]);
 271                             self.vert_pred[(x >> 1) + 1] = cur;
 272                             dst[off + x + 2] = cur as u16;
 273                             dst[off + x + 3] = (cur >> 16) as u16;
 274                         },
 275                         2 => {
 276                             if self.blk_h == 2 {
 277                                 let dc0 = index.get_diff16(&self.delta_tables.cdt)?;
 278                                 let dy0 = index.get_diff16(&self.delta_tables.ydt)?;
 279                                 hor_pred = hor_pred.wrapping_add(dc0);
 280                                 hor_pred = hor_pred.wrapping_add(dy0);
 281                                 let cur = hor_pred.wrapping_add(self.vert_pred[(x >> 1) + 0]);
 282                                 self.vert_pred[(x >> 1) + 0] = cur;
 283                                 dst[off + x + 0] = cur as u16;
 284                                 dst[off + x + 1] = (cur >> 16) as u16;
 285                                 if self.blk_w == 2 {
 286                                     let dc1 = index.get_diff16(&self.delta_tables.cdt)?;
 287                                     hor_pred = hor_pred.wrapping_add(dc1);
 288                                 }
 289                                 let dy1 = index.get_diff16(&self.delta_tables.ydt)?;
 290                                 hor_pred = hor_pred.wrapping_add(dy1);
 291                                 let cur = hor_pred.wrapping_add(self.vert_pred[(x >> 1) + 1]);
 292                                 self.vert_pred[(x >> 1) + 1] = cur;
 293                                 dst[off + x + 2] = cur as u16;
 294                                 dst[off + x + 3] = (cur >> 16) as u16;
 295                             } else {
 296                                 let dy0 = index.get_diff16(&self.delta_tables.ydt)?;
 297                                 hor_pred = hor_pred.wrapping_add(dy0);
 298                                 let cur = hor_pred.wrapping_add(self.vert_pred[(x >> 1) + 0]);
 299                                 self.vert_pred[(x >> 1) + 0] = cur;
 300                                 dst[off + x + 0] = cur as u16;
 301                                 dst[off + x + 1] = (cur >> 16) as u16;
 302                                 let dy1 = index.get_diff16(&self.delta_tables.ydt)?;
 303                                 hor_pred = hor_pred.wrapping_add(dy1);
 304                                 let cur = hor_pred.wrapping_add(self.vert_pred[(x >> 1) + 1]);
 305                                 self.vert_pred[(x >> 1) + 1] = cur;
 306                                 dst[off + x + 2] = cur as u16;
 307                                 dst[off + x + 3] = (cur >> 16) as u16;
 308                             }
 309                         },
 310                         _ => unreachable!(),
 311                     };
 312                 } else {
 313                     let cur = u32::from(dst[off + x + 0]) | (u32::from(dst[off + x + 1]) << 16);
 314                     self.vert_pred[(x >> 1) + 0] = cur;
 315                     let cur = u32::from(dst[off + x + 2]) | (u32::from(dst[off + x + 3]) << 16);
 316                     hor_pred = cur.wrapping_sub(self.vert_pred[(x >> 1) + 1]);
 317                     self.vert_pred[(x >> 1) + 1] = cur;
 318                 }
 319             }
 320             if (y & 3) != 3 {
 321                 mask.reset_row();
 322             } else {
 323                 mask.next_row();
 324             }
 325             off += stride;
 326         }
 327         Ok(())
 328     }
 329     fn decode_sprite(&mut self, dst: &mut [u16], stride: usize, width: usize, height: usize, mask: &mut MaskState<'_>, index: &mut IndexState<'_>) -> DecoderResult<()> {
 330         let mut off = 0;
 331         let _ = index.get_next();
 332         for y in 0..height {
 333             let mut hor_pred: u32 = 0;
 334             for x in (0..width).step_by(4) {
 335                 let is_tm = !mask.get_next();
 336                 let is_sprite = !mask.get_next();
 337                 if is_tm {
 338                     if (y & 3) == 0 {
 339                         let dc0 = index.get_diff16(&self.delta_tables.cdt)?;
 340                         hor_pred = hor_pred.wrapping_add(dc0);
 341                     }
 342                     let dy0 = index.get_diff16(&self.delta_tables.ydt)?;
 343                     hor_pred = hor_pred.wrapping_add(dy0);
 344                     let cur = hor_pred.wrapping_add(self.vert_pred[(x >> 1) + 0]);
 345                     self.vert_pred[(x >> 1) + 0] = cur;
 346                     dst[off + x + 0] = cur as u16;
 347                     dst[off + x + 1] = (cur >> 16) as u16;
 348                     let dy1 = index.get_diff16(&self.delta_tables.ydt)?;
 349                     hor_pred = hor_pred.wrapping_add(dy1);
 350                     let cur = hor_pred.wrapping_add(self.vert_pred[(x >> 1) + 1]);
 351                     self.vert_pred[(x >> 1) + 1] = cur;
 352                     dst[off + x + 2] = cur as u16;
 353                     dst[off + x + 3] = (cur >> 16) as u16;
 354                 } else if is_sprite {
 355                     if (y & 3) == 0 {
 356                         let dc0 = index.get_diff16(&self.delta_tables.cdt)?;
 357                         hor_pred = hor_pred.wrapping_add(dc0);
 358                     }
 359                     let dy0 = index.get_diff16(&self.delta_tables.ydt)?;
 360                     hor_pred = hor_pred.wrapping_add(dy0);
 361                     let _da0 = index.get_diff16_noesc(&self.delta_tables.adt)?;
 362                     let cur = hor_pred.wrapping_add(self.vert_pred[(x >> 1) + 0]);
 363                     self.vert_pred[(x >> 1) + 0] = cur;
 364                     dst[off + x + 0] = cur as u16;
 365                     dst[off + x + 1] = (cur >> 16) as u16;
 366                     let dy1 = index.get_diff16(&self.delta_tables.ydt)?;
 367                     hor_pred = hor_pred.wrapping_add(dy1);
 368                     let _da1 = index.get_diff16_noesc(&self.delta_tables.adt)?;
 369                     let cur = hor_pred.wrapping_add(self.vert_pred[(x >> 1) + 1]);
 370                     self.vert_pred[(x >> 1) + 1] = cur;
 371                     dst[off + x + 2] = cur as u16;
 372                     dst[off + x + 3] = (cur >> 16) as u16;
 373                 } else {
 374                     hor_pred = 0;
 375                     dst[off + x + 0] = 0;
 376                     dst[off + x + 1] = 0;
 377                     dst[off + x + 2] = 0;
 378                     dst[off + x + 3] = 0;
 379                     self.vert_pred[(x >> 1) + 0] = 0;
 380                     self.vert_pred[(x >> 1) + 1] = 0;
 381                 }
 382             }
 383             if (y & 3) != 3 {
 384                 mask.reset_row();
 385             } else {
 386                 mask.next_row();
 387             }
 388             off += stride;
 389         }
 390         Ok(())
 391     }
 392     fn decode_24bit(&mut self, dst: &mut [u8], stride: usize, width: usize, height: usize, mask: &mut MaskState<'_>, index: &mut IndexState<'_>) -> DecoderResult<()> {
 393         let mut off = 0;
 394         index.get_next()?;
 395         for y in 0..height {
 396             let mut hor_pred: u32 = 0;
 397             for x in (0..width).step_by(2) {
 398                 if mask.get_next() {
 399                     match y & 3 {
 400                         0 => {
 401                             let dc0 = index.get_diff24(&self.delta_tables.cdt, &self.delta_tables.fat_cdt)?;
 402                             let dy0 = index.get_diff24(&self.delta_tables.ydt, &self.delta_tables.fat_ydt)?;
 403                             hor_pred = hor_pred.wrapping_add(dc0);
 404                             hor_pred = hor_pred.wrapping_add(dy0);
 405                             let cur = hor_pred.wrapping_add(self.vert_pred[x + 0]);
 406                             self.vert_pred[x + 0] = cur;
 407                             dst[off + x*4 + 0] = cur as u8;
 408                             dst[off + x*4 + 1] = (cur >> 8) as u8;
 409                             dst[off + x*4 + 2] = (cur >> 16) as u8;
 410                             dst[off + x*4 + 3] = 0;
 411                             if self.blk_w == 2 {
 412                                 let dc1 = index.get_diff24(&self.delta_tables.cdt, &self.delta_tables.fat_cdt)?;
 413                                 hor_pred = hor_pred.wrapping_add(dc1);
 414                             }
 415                             let dy1 = index.get_diff24(&self.delta_tables.ydt, &self.delta_tables.fat_ydt)?;
 416                             hor_pred = hor_pred.wrapping_add(dy1);
 417                             let cur = hor_pred.wrapping_add(self.vert_pred[x + 1]);
 418                             self.vert_pred[x + 1] = cur;
 419                             dst[off + x*4 + 4] = cur as u8;
 420                             dst[off + x*4 + 5] = (cur >> 8) as u8;
 421                             dst[off + x*4 + 6] = (cur >> 16) as u8;
 422                             dst[off + x*4 + 7] = 0;
 423                         },
 424                         1 | 3 => {
 425                             let dy0 = index.get_diff24(&self.delta_tables.ydt, &self.delta_tables.fat_ydt)?;
 426                             hor_pred = hor_pred.wrapping_add(dy0);
 427                             let cur = hor_pred.wrapping_add(self.vert_pred[x + 0]);
 428                             self.vert_pred[x + 0] = cur;
 429                             dst[off + x*4 + 0] = cur as u8;
 430                             dst[off + x*4 + 1] = (cur >> 8) as u8;
 431                             dst[off + x*4 + 2] = (cur >> 16) as u8;
 432                             dst[off + x*4 + 3] = 0;
 433                             let dy1 = index.get_diff24(&self.delta_tables.ydt, &self.delta_tables.fat_ydt)?;
 434                             hor_pred = hor_pred.wrapping_add(dy1);
 435                             let cur = hor_pred.wrapping_add(self.vert_pred[x + 1]);
 436                             self.vert_pred[x + 1] = cur;
 437                             dst[off + x*4 + 4] = cur as u8;
 438                             dst[off + x*4 + 5] = (cur >> 8) as u8;
 439                             dst[off + x*4 + 6] = (cur >> 16) as u8;
 440                             dst[off + x*4 + 7] = 0;
 441                         },
 442                         2 => {
 443                             if self.blk_h == 2 {
 444                                 let dc0 = index.get_diff24(&self.delta_tables.cdt, &self.delta_tables.fat_cdt)?;
 445                                 let dy0 = index.get_diff24(&self.delta_tables.ydt, &self.delta_tables.fat_ydt)?;
 446                                 hor_pred = hor_pred.wrapping_add(dc0);
 447                                 hor_pred = hor_pred.wrapping_add(dy0);
 448                                 let cur = hor_pred.wrapping_add(self.vert_pred[x + 0]);
 449                                 self.vert_pred[x + 0] = cur;
 450                                 dst[off + x*4 + 0] = cur as u8;
 451                                 dst[off + x*4 + 1] = (cur >> 8) as u8;
 452                                 dst[off + x*4 + 2] = (cur >> 16) as u8;
 453                                 dst[off + x*4 + 3] = 0;
 454                                 if self.blk_w == 2 {
 455                                     let dc1 = index.get_diff24(&self.delta_tables.cdt, &self.delta_tables.fat_cdt)?;
 456                                     hor_pred = hor_pred.wrapping_add(dc1);
 457                                 }
 458                                 let dy1 = index.get_diff24(&self.delta_tables.ydt, &self.delta_tables.fat_ydt)?;
 459                                 hor_pred = hor_pred.wrapping_add(dy1);
 460                                 let cur = hor_pred.wrapping_add(self.vert_pred[x + 1]);
 461                                 self.vert_pred[x + 1] = cur;
 462                                 dst[off + x*4 + 4] = cur as u8;
 463                                 dst[off + x*4 + 5] = (cur >> 8) as u8;
 464                                 dst[off + x*4 + 6] = (cur >> 16) as u8;
 465                                 dst[off + x*4 + 7] = 0;
 466                             } else {
 467                                 let dy0 = index.get_diff24(&self.delta_tables.ydt, &self.delta_tables.fat_ydt)?;
 468                                 hor_pred = hor_pred.wrapping_add(dy0);
 469                                 let cur = hor_pred.wrapping_add(self.vert_pred[x + 0]);
 470                                 self.vert_pred[x + 0] = cur;
 471                                 dst[off + x*4 + 0] = cur as u8;
 472                                 dst[off + x*4 + 1] = (cur >> 8) as u8;
 473                                 dst[off + x*4 + 2] = (cur >> 16) as u8;
 474                                 dst[off + x*4 + 3] = 0;
 475                                 let dy1 = index.get_diff24(&self.delta_tables.ydt, &self.delta_tables.fat_ydt)?;
 476                                 hor_pred = hor_pred.wrapping_add(dy1);
 477                                 let cur = hor_pred.wrapping_add(self.vert_pred[x + 1]);
 478                                 self.vert_pred[x + 1] = cur;
 479                                 dst[off + x*4 + 4] = cur as u8;
 480                                 dst[off + x*4 + 5] = (cur >> 8) as u8;
 481                                 dst[off + x*4 + 6] = (cur >> 16) as u8;
 482                                 dst[off + x*4 + 7] = 0;
 483                             }
 484                         },
 485                         _ => unreachable!(),
 486                     };
 487                 } else {
 488                     let cur =   u32::from(dst[off + x*4 + 0])
 489                              | (u32::from(dst[off + x*4 + 1]) << 8)
 490                              | (u32::from(dst[off + x*4 + 2]) << 16)
 491                              | (u32::from(dst[off + x*4 + 3]) << 24);
 492                     self.vert_pred[x + 0] = cur;
 493                     let cur =   u32::from(dst[off + x*4 + 4])
 494                              | (u32::from(dst[off + x*4 + 5]) << 8)
 495                              | (u32::from(dst[off + x*4 + 6]) << 16)
 496                              | (u32::from(dst[off + x*4 + 7]) << 24);
 497                     hor_pred = cur.wrapping_sub(self.vert_pred[x + 1]);
 498                     self.vert_pred[x + 1] = cur;
 499                 }
 500             }
 501             if (y & 3) != 3 {
 502                 mask.reset_row();
 503             } else {
 504                 mask.next_row();
 505             }
 506             off += stride;
 507         }
 508         Ok(())
 509     }
 510 }
 511
 512 impl NADecoder for TM1Decoder {
 513     fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
 514         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
 515             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), false, YUV410_FORMAT));
 516             self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
 517             Ok(())
 518         } else {
 519             Err(DecoderError::InvalidData)
 520         }
 521     }
 522     fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
 523         let src = pkt.get_buffer();
 524         validate!(src.len() > 10);
 525         let hdr_size = (src[0].rotate_left(3) & 0x7F) as usize;
 526         validate!(hdr_size >= 12 && hdr_size < src.len());
 527         let mut hdr: [u8; 127] = [0; 127];
 528         for i in 1..hdr_size {
 529             hdr[i - 1] = src[i] ^ src[i + 1];
 530         }
 531         let mut mr = MemoryReader::new_read(&hdr[0..hdr_size-1]);
 532         let mut br = ByteReader::new(&mut mr);
 533
 534         let tm1type                             = br.read_byte()? as usize;
 535         let delta_set                           = br.read_byte()? as usize;
 536         let table_idx                           = br.read_byte()? as usize;
 537         let height                              = br.read_u16le()? as usize;
 538         let width                               = br.read_u16le()? as usize;
 539         let _frameno                            = br.read_u16le()? as usize;
 540         let version                             = br.read_byte()?;
 541         let meta_type                           = br.read_byte()?;
 542         validate!(width > 0 && height > 0);
 543         let is_intra;
 544         let mut is_sprite = false;
 545         let mut spr_xoff = 0;
 546         let mut spr_yoff = 0;
 547         let mut spr_width = 0;
 548         let mut spr_height = 0;
 549         if version >= 2 {
 550             validate!(meta_type <= 3);
 551             if meta_type >= 2 {
 552                 let frameinfo                   = br.read_byte()?;
 553                 let _control                    = br.read_byte()?;
 554
 555                 is_intra = ((frameinfo & 0x10) != 0) || ((frameinfo & 0x08) == 0);
 556             } else {
 557                 is_intra = true;
 558             }
 559             if meta_type == 3 {
 560                 spr_xoff                        = br.read_u16le()? as usize;
 561                 spr_yoff                        = br.read_u16le()? as usize;
 562                 spr_width                       = br.read_u16le()? as usize;
 563                 spr_height                      = br.read_u16le()? as usize;
 564                 is_sprite = true;
 565             }
 566         } else {
 567             is_intra = true;
 568         }
 569         validate!(tm1type < TM1_COMPR_TYPES.len());
 570         let cinfo = TM1_COMPR_TYPES[tm1type];
 571         if cinfo.is_none() {
 572 //check for missing ref
 573             let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), NABufferType::None);
 574             frm.set_keyframe(false);
 575             frm.set_frame_type(FrameType::Skip);
 576             return Ok(frm.into_ref());
 577         }
 578         let compr_info = cinfo.unwrap();
 579         let is_24bit = !is_sprite && compr_info.is_24bit;
 580
 581         let vec_idx = if ((tm1type & 1) != 0) && (meta_type > 0) { 1 } else { table_idx };
 582         validate!((delta_set < DUCK_Y_DELTAS.len()) && (vec_idx > 0) && (vec_idx <= DUCK_VECTABLES.len()));
 583         self.set_delta_tables(delta_set, vec_idx, is_24bit);
 584
 585         let out_width = if is_24bit { width >> 1 } else { width };
 586         let mask_row_size = if is_sprite {
 587                 ((spr_width >> 2) + 3) >> 2
 588             } else if is_intra {
 589                 0
 590             } else {
 591                 ((width >> 2) + 7) >> 3
 592             };
 593         let mask_size = mask_row_size * (if is_sprite { spr_height >> 2 } else { height >> 2 });
 594         let mask_bits = &src[hdr_size..][..mask_size];
 595         let index_bytes = &src[hdr_size+mask_size..];
 596         validate!(src.len() >= hdr_size + mask_size);
 597         self.vert_pred.clear();
 598         self.vert_pred.resize(out_width, 0);
 599
 600         if is_intra || is_sprite {
 601             let fmt = if is_24bit { BGR0_FORMAT } else { RGB555_FORMAT };
 602             let myinfo = NAVideoInfo::new(out_width, height, false, fmt);
 603             let bufinfo = alloc_video_buffer(myinfo, 2)?;
 604             self.lastframe.reset();
 605             if !is_24bit {
 606                 self.lastframe.set16(bufinfo.get_vbuf16().unwrap());
 607             } else {
 608                 self.lastframe.set24(bufinfo.get_vbuf().unwrap());
 609             }
 610         }
 611
 612         self.blk_w = compr_info.block_w;
 613         self.blk_h = compr_info.block_h;
 614         let mut mask = MaskState::new(is_intra && !is_sprite, mask_bits, mask_row_size);
 615         let mut index = IndexState::new(index_bytes);
 616         let bufinfo;
 617         if !is_24bit {
 618             if let Some(mut buf) = self.lastframe.get16() {
 619                 let stride = buf.get_stride(0);
 620                 {
 621                     let data = buf.get_data_mut().unwrap();
 622                     if !is_sprite {
 623                         self.decode_16bit(data.as_mut_slice(), stride, out_width, height, &mut mask, &mut index)?;
 624                     } else {
 625                         validate!(spr_xoff + spr_width <= out_width);
 626                         validate!(spr_yoff + spr_height <= height);
 627                         for el in data.iter_mut() { *el = 0; }
 628                         let dst = &mut data[spr_xoff + spr_yoff * stride..];
 629                         self.decode_sprite(dst, stride, spr_width, spr_height, &mut mask, &mut index)?;
 630                     }
 631                 }
 632                 bufinfo = NABufferType::Video16(buf);
 633             } else {
 634                 return Err(DecoderError::MissingReference);
 635             }
 636         } else if let Some(mut buf) = self.lastframe.get24() {
 637             let stride = buf.get_stride(0);
 638             {
 639                 let data = buf.get_data_mut().unwrap();
 640                 self.decode_24bit(data.as_mut_slice(), stride, out_width, height, &mut mask, &mut index)?;
 641             }
 642             bufinfo = NABufferType::VideoPacked(buf);
 643         } else {
 644             return Err(DecoderError::MissingReference);
 645         }
 646
 647         let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
 648         frm.set_keyframe(is_intra || is_sprite);
 649         frm.set_frame_type(if is_intra { FrameType::I } else { FrameType::P });
 650         Ok(frm.into_ref())
 651     }
 652     fn flush(&mut self) {
 653         self.lastframe.reset();
 654     }
 655 }
 656
 657 impl NAOptionHandler for TM1Decoder {
 658     fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
 659     fn set_options(&mut self, _options: &[NAOption]) { }
 660     fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
 661 }
 662
 663 pub fn get_decoder() -> Box<dyn NADecoder + Send> {
 664     Box::new(TM1Decoder::new())
 665 }
 666
 667 #[cfg(test)]
 668 mod test {
 669     use nihav_core::codecs::RegisteredDecoders;
 670     use nihav_core::demuxers::RegisteredDemuxers;
 671     use nihav_codec_support::test::dec_video::*;
 672     use crate::duck_register_all_decoders;
 673     use nihav_commonfmt::generic_register_all_demuxers;
 674     #[test]
 675     fn test_tm1() {
 676         let mut dmx_reg = RegisteredDemuxers::new();
 677         generic_register_all_demuxers(&mut dmx_reg);
 678         let mut dec_reg = RegisteredDecoders::new();
 679         duck_register_all_decoders(&mut dec_reg);
 680
 681         // sample: https://samples.mplayerhq.hu/V-codecs/DUCK/phant2-940.duk
 682         test_decoding("avi", "truemotion1", "assets/Duck/phant2-940.duk", Some(12), &dmx_reg, &dec_reg,
 683                       ExpectedTestResult::MD5Frames(vec![
 684                         [0x989e62b8, 0x5d85c23c, 0x1cffba6d, 0xe599f1c4],
 685                         [0xc4231321, 0x25561487, 0x9db11f57, 0x4faeb9a5],
 686                         [0x36e3a831, 0xdbd21f89, 0x0a446071, 0xf6d31ee7],
 687                         [0x0af640af, 0x64bc2bac, 0x0e95dd72, 0x9e55360b],
 688                         [0xbc9c5f8b, 0x6c06f2bc, 0x216f4129, 0x3a421337],
 689                         [0xd8ea7297, 0xce5f79fc, 0x46071f4c, 0xaed7fb7a],
 690                         [0x87617060, 0x72ce8df8, 0xde42eaa6, 0x804a6f45],
 691                         [0xfd8c45b3, 0xf424b683, 0xb4d6a9bd, 0xc622d0b9],
 692                         [0x6c233746, 0xba8ed68e, 0xc0ed0e85, 0xc99e1dc0],
 693                         [0x5842aac0, 0xd3d78242, 0x5da21218, 0xea1ed0ad],
 694                         [0xdea0db20, 0xe2ce3586, 0xf7386649, 0xecc374f9],
 695                         [0xb80ae9cb, 0x04eb938e, 0xd8a337ee, 0x0054b5ed],
 696                         [0xf8b80e1d, 0xd8eb3d6c, 0xa99b23ff, 0x562851a1]]));
 697         test_decoding("avi", "truemotion1", "assets/Duck/SPRITES.AVI", Some(2), &dmx_reg, &dec_reg,
 698                       ExpectedTestResult::MD5([0xb89a4275, 0xf9797f5f, 0xe53c1ccd, 0xfa163e02]));
 699         //let file = "assets/Duck/AVI-DUCK-dk3.duk";
 700         //let file = "assets/Duck/phant2-940.duk";
 701         //let file = "assets/Duck/bugsampler-m01-16bit.avi";
 702         //let file = "assets/Duck/sonic3dblast_intro.avi";
 703         //let file = "assets/Duck/BUTTONS.AVI";
 704         //let file = "assets/Duck/SPRITES.AVI";
 705         //let file = "assets/Duck/TRICORD.AVI";
 706         //test_file_decoding("avi", file, Some(42), true, false, None/*Some("tm1-")*/, &dmx_reg, &dec_reg);
 707     }
 708 }
 709
 710 #[derive(Clone,Copy)]
 711 struct TM1ComprInfo {
 712     is_24bit:   bool,
 713     block_w:    usize,
 714     block_h:    usize,
 715 }
 716
 717 const TM1_COMPR_TYPES: [Option<TM1ComprInfo>; 17] = [
 718     None,
 719     Some(TM1ComprInfo { is_24bit: false, block_w: 4, block_h: 4 }),
 720     Some(TM1ComprInfo { is_24bit: false, block_w: 4, block_h: 4 }),
 721     Some(TM1ComprInfo { is_24bit: false, block_w: 4, block_h: 2 }),
 722     Some(TM1ComprInfo { is_24bit: false, block_w: 4, block_h: 2 }),
 723     Some(TM1ComprInfo { is_24bit: false, block_w: 2, block_h: 4 }),
 724     Some(TM1ComprInfo { is_24bit: false, block_w: 2, block_h: 4 }),
 725     Some(TM1ComprInfo { is_24bit: false, block_w: 2, block_h: 2 }),
 726     Some(TM1ComprInfo { is_24bit: false, block_w: 2, block_h: 2 }),
 727     None,
 728     Some(TM1ComprInfo { is_24bit: true,  block_w: 4, block_h: 4 }),
 729     None,
 730     Some(TM1ComprInfo { is_24bit: true,  block_w: 4, block_h: 2 }),
 731     None,
 732     Some(TM1ComprInfo { is_24bit: true,  block_w: 2, block_h: 4 }),
 733     None,
 734     Some(TM1ComprInfo { is_24bit: true,  block_w: 2, block_h: 2 }),
 735 ];
 736
 737 const DUCK_Y_DELTAS: [[i32; 8]; 4] = [
 738     [ 0, -1,  1,  -3,  3,  -6,  6,  -6 ],
 739     [ 0, -1,  2,  -3,  4,  -6,  6,  -6 ],
 740     [ 2, -3, 10, -10, 23, -23, 47, -47 ],
 741     [ 0, -2,  2,  -8,  8, -18, 18, -40 ]
 742 ];
 743 const DUCK_Y_FAT_DELTA3: [i32; 8] = [ 0, -15, 50, -50, 115, -115, 235, -235 ];
 744 const DUCK_Y_FAT_DELTA4: [i32; 8] = [ 0,  40, 80, -76, 160, -154, 236, -236 ];
 745 const DUCK_Y_FAT_DELTAS: [&[i32]; 4] = [
 746     &DUCK_Y_FAT_DELTA3, &DUCK_Y_FAT_DELTA3, &DUCK_Y_FAT_DELTA3, &DUCK_Y_FAT_DELTA4
 747 ];
 748
 749 const DUCK_C_DELTAS: [[i32; 8]; 4] = [
 750     [ 0, -1, 1,  -2,  3,  -4,  5,  -4 ],
 751     [ 0, -1, 1,  -2,  3,  -4,  5,  -4 ],
 752     [ 0, -4, 3, -16, 20, -32, 36, -32 ],
 753     [ 0, -2, 2,  -8,  8, -18, 18, -40 ]
 754 ];
 755 const DUCK_C_FAT_DELTA3: [i32; 8] = [ 0, -20, 15, -80, 100, -160, 180, -160 ];
 756 const DUCK_C_FAT_DELTAS: [&[i32]; 4] = [
 757     &DUCK_C_FAT_DELTA3, &DUCK_C_FAT_DELTA3, &DUCK_C_FAT_DELTA3, &DUCK_Y_FAT_DELTA4
 758 ];
 759
 760 const DUCK_VECTBL2: &[u8] = &[
 761 0x8,0x00,0x00,0x00,0x00,
 762 0x8,0x00,0x00,0x00,0x00,
 763 0x8,0x10,0x00,0x00,0x00,
 764 0x8,0x01,0x00,0x00,0x00,
 765 0x8,0x00,0x10,0x00,0x00,
 766 0x8,0x00,0x01,0x00,0x00,
 767 0x8,0x00,0x00,0x10,0x00,
 768 0x8,0x00,0x00,0x01,0x00,
 769 0x8,0x00,0x00,0x00,0x10,
 770 0x8,0x00,0x00,0x00,0x01,
 771 0x6,0x00,0x00,0x00,
 772 0x6,0x10,0x00,0x00,
 773 0x6,0x01,0x00,0x00,
 774 0x6,0x00,0x10,0x00,
 775 0x6,0x00,0x01,0x00,
 776 0x6,0x00,0x00,0x01,
 777 0x6,0x00,0x00,0x10,
 778 0x6,0x00,0x00,0x02,
 779 0x6,0x00,0x00,0x20,
 780 0x6,0x20,0x10,0x00,
 781 0x6,0x00,0x02,0x01,
 782 0x6,0x00,0x20,0x10,
 783 0x6,0x02,0x01,0x00,
 784 0x6,0x11,0x00,0x00,
 785 0x6,0x00,0x20,0x00,
 786 0x6,0x00,0x02,0x00,
 787 0x6,0x20,0x00,0x00,
 788 0x6,0x01,0x10,0x00,
 789 0x6,0x02,0x00,0x00,
 790 0x6,0x01,0x00,0x02,
 791 0x6,0x10,0x00,0x20,
 792 0x6,0x00,0x01,0x02,
 793 0x6,0x10,0x01,0x00,
 794 0x6,0x00,0x10,0x20,
 795 0x6,0x10,0x10,0x00,
 796 0x6,0x10,0x00,0x01,
 797 0x6,0x20,0x00,0x10,
 798 0x6,0x02,0x00,0x01,
 799 0x6,0x01,0x01,0x00,
 800 0x6,0x01,0x00,0x10,
 801 0x6,0x00,0x11,0x00,
 802 0x6,0x10,0x00,0x02,
 803 0x6,0x00,0x01,0x10,
 804 0x6,0x00,0x00,0x11,
 805 0x6,0x10,0x00,0x10,
 806 0x6,0x01,0x00,0x01,
 807 0x6,0x00,0x00,0x22,
 808 0x6,0x02,0x01,0x01,
 809 0x6,0x10,0x20,0x10,
 810 0x6,0x01,0x02,0x01,
 811 0x6,0x20,0x10,0x10,
 812 0x6,0x01,0x00,0x20,
 813 0x6,0x00,0x10,0x01,
 814 0x6,0x21,0x10,0x00,
 815 0x6,0x10,0x02,0x01,
 816 0x6,0x12,0x01,0x00,
 817 0x6,0x01,0x20,0x10,
 818 0x6,0x01,0x02,0x00,
 819 0x6,0x10,0x20,0x00,
 820 0x6,0x00,0x10,0x02,
 821 0x6,0x00,0x01,0x20,
 822 0x6,0x00,0x02,0x21,
 823 0x6,0x00,0x02,0x20,
 824 0x6,0x00,0x00,0x12,
 825 0x6,0x00,0x00,0x21,
 826 0x6,0x20,0x11,0x00,
 827 0x6,0x00,0x01,0x01,
 828 0x6,0x11,0x10,0x00,
 829 0x6,0x00,0x20,0x12,
 830 0x6,0x00,0x20,0x11,
 831 0x6,0x20,0x10,0x02,
 832 0x6,0x02,0x01,0x20,
 833 0x6,0x00,0x22,0x11,
 834 0x6,0x00,0x10,0x10,
 835 0x6,0x02,0x11,0x00,
 836 0x6,0x00,0x21,0x10,
 837 0x6,0x00,0x02,0x03,
 838 0x6,0x20,0x10,0x01,
 839 0x6,0x00,0x12,0x01,
 840 0x4,0x11,0x00,
 841 0x4,0x00,0x22,
 842 0x4,0x20,0x00,
 843 0x4,0x01,0x10,
 844 0x4,0x02,0x20,
 845 0x4,0x00,0x20,
 846 0x4,0x02,0x00,
 847 0x4,0x10,0x01,
 848 0x4,0x00,0x11,
 849 0x4,0x02,0x01,
 850 0x4,0x02,0x21,
 851 0x4,0x00,0x02,
 852 0x4,0x20,0x02,
 853 0x4,0x01,0x01,
 854 0x4,0x10,0x10,
 855 0x4,0x10,0x02,
 856 0x4,0x22,0x00,
 857 0x4,0x10,0x00,
 858 0x4,0x01,0x00,
 859 0x4,0x21,0x00,
 860 0x4,0x12,0x00,
 861 0x4,0x00,0x10,
 862 0x4,0x20,0x12,
 863 0x4,0x01,0x11,
 864 0x4,0x00,0x01,
 865 0x4,0x01,0x02,
 866 0x4,0x11,0x02,
 867 0x4,0x11,0x01,
 868 0x4,0x10,0x20,
 869 0x4,0x20,0x01,
 870 0x4,0x22,0x11,
 871 0x4,0x00,0x12,
 872 0x4,0x20,0x10,
 873 0x4,0x22,0x01,
 874 0x4,0x01,0x20,
 875 0x4,0x00,0x21,
 876 0x4,0x10,0x11,
 877 0x4,0x21,0x10,
 878 0x4,0x10,0x22,
 879 0x4,0x02,0x03,
 880 0x4,0x12,0x01,
 881 0x4,0x20,0x11,
 882 0x4,0x11,0x10,
 883 0x4,0x20,0x30,
 884 0x4,0x11,0x20,
 885 0x4,0x02,0x10,
 886 0x4,0x22,0x10,
 887 0x4,0x11,0x11,
 888 0x4,0x30,0x20,
 889 0x4,0x30,0x00,
 890 0x4,0x01,0x22,
 891 0x4,0x01,0x12,
 892 0x4,0x02,0x11,
 893 0x4,0x03,0x02,
 894 0x4,0x03,0x00,
 895 0x4,0x10,0x21,
 896 0x4,0x12,0x20,
 897 0x4,0x00,0x00,
 898 0x4,0x12,0x21,
 899 0x4,0x21,0x11,
 900 0x4,0x02,0x22,
 901 0x4,0x10,0x12,
 902 0x4,0x31,0x00,
 903 0x4,0x20,0x20,
 904 0x4,0x00,0x03,
 905 0x4,0x02,0x02,
 906 0x4,0x22,0x20,
 907 0x4,0x01,0x21,
 908 0x4,0x21,0x02,
 909 0x4,0x21,0x12,
 910 0x4,0x11,0x22,
 911 0x4,0x00,0x30,
 912 0x4,0x12,0x11,
 913 0x4,0x20,0x22,
 914 0x4,0x31,0x20,
 915 0x4,0x21,0x30,
 916 0x4,0x22,0x02,
 917 0x4,0x22,0x22,
 918 0x4,0x20,0x31,
 919 0x4,0x13,0x02,
 920 0x4,0x03,0x10,
 921 0x4,0x11,0x12,
 922 0x4,0x00,0x13,
 923 0x4,0x21,0x01,
 924 0x4,0x12,0x03,
 925 0x4,0x13,0x00,
 926 0x4,0x13,0x10,
 927 0x4,0x02,0x13,
 928 0x4,0x30,0x01,
 929 0x4,0x12,0x10,
 930 0x4,0x22,0x13,
 931 0x4,0x03,0x12,
 932 0x4,0x31,0x01,
 933 0x4,0x30,0x22,
 934 0x4,0x00,0x31,
 935 0x4,0x01,0x31,
 936 0x4,0x02,0x23,
 937 0x4,0x01,0x30,
 938 0x4,0x11,0x21,
 939 0x4,0x22,0x21,
 940 0x4,0x01,0x13,
 941 0x4,0x10,0x03,
 942 0x4,0x22,0x03,
 943 0x4,0x30,0x21,
 944 0x4,0x21,0x31,
 945 0x4,0x33,0x00,
 946 0x4,0x13,0x12,
 947 0x4,0x11,0x31,
 948 0x4,0x30,0x02,
 949 0x4,0x12,0x02,
 950 0x4,0x11,0x13,
 951 0x4,0x12,0x22,
 952 0x4,0x20,0x32,
 953 0x4,0x10,0x13,
 954 0x4,0x22,0x31,
 955 0x4,0x21,0x20,
 956 0x4,0x01,0x33,
 957 0x4,0x33,0x10,
 958 0x4,0x20,0x13,
 959 0x4,0x31,0x22,
 960 0x4,0x13,0x30,
 961 0x4,0x01,0x03,
 962 0x4,0x11,0x33,
 963 0x4,0x20,0x21,
 964 0x4,0x13,0x31,
 965 0x4,0x03,0x22,
 966 0x4,0x31,0x02,
 967 0x4,0x00,0x24,
 968 0x2,0x00,
 969 0x2,0x10,
 970 0x2,0x20,
 971 0x2,0x30,
 972 0x2,0x40,
 973 0x2,0x50,
 974 0x2,0x60,
 975 0x2,0x01,
 976 0x2,0x11,
 977 0x2,0x21,
 978 0x2,0x31,
 979 0x2,0x41,
 980 0x2,0x51,
 981 0x2,0x61,
 982 0x2,0x02,
 983 0x2,0x12,
 984 0x2,0x22,
 985 0x2,0x32,
 986 0x2,0x42,
 987 0x2,0x52,
 988 0x2,0x62,
 989 0x2,0x03,
 990 0x2,0x13,
 991 0x2,0x23,
 992 0x2,0x33,
 993 0x2,0x43,
 994 0x2,0x53,
 995 0x2,0x63,
 996 0x2,0x04,
 997 0x2,0x14,
 998 0x2,0x24,
 999 0x2,0x34,
1000 0x2,0x44,
1001 0x2,0x54,
1002 0x2,0x64,
1003 0x2,0x05,
1004 0x2,0x15,
1005 0x2,0x25,
1006 0x2,0x35,
1007 0x2,0x45,
1008 0x2,0x55,
1009 0x2,0x65,
1010 0x2,0x06,
1011 0x2,0x16,
1012 0x2,0x26,
1013 0x2,0x36,
1014 0x2,0x46,
1015 0x2,0x56,
1016 0x2,0x66
1017 ];
1018
1019 const DUCK_VECTBL3: &[u8] = &[
1020 0x6,0x00,0x00,0x00,
1021 0x6,0x00,0x00,0x00,
1022 0x6,0x00,0x00,0x01,
1023 0x6,0x00,0x00,0x10,
1024 0x6,0x00,0x00,0x11,
1025 0x6,0x00,0x01,0x00,
1026 0x6,0x00,0x01,0x01,
1027 0x6,0x00,0x01,0x10,
1028 0x6,0x00,0x01,0x11,
1029 0x6,0x00,0x10,0x00,
1030 0x6,0x00,0x10,0x01,
1031 0x6,0x00,0x10,0x10,
1032 0x6,0x00,0x10,0x11,
1033 0x6,0x00,0x11,0x00,
1034 0x6,0x00,0x11,0x01,
1035 0x6,0x00,0x11,0x10,
1036 0x6,0x00,0x11,0x11,
1037 0x6,0x01,0x00,0x00,
1038 0x6,0x01,0x00,0x01,
1039 0x6,0x01,0x00,0x10,
1040 0x6,0x01,0x00,0x11,
1041 0x6,0x01,0x01,0x00,
1042 0x6,0x01,0x01,0x01,
1043 0x6,0x01,0x01,0x10,
1044 0x6,0x01,0x01,0x11,
1045 0x6,0x01,0x10,0x00,
1046 0x6,0x01,0x10,0x01,
1047 0x6,0x01,0x10,0x10,
1048 0x6,0x01,0x10,0x11,
1049 0x6,0x01,0x11,0x00,
1050 0x6,0x01,0x11,0x01,
1051 0x6,0x01,0x11,0x10,
1052 0x6,0x01,0x11,0x11,
1053 0x6,0x10,0x00,0x00,
1054 0x6,0x10,0x00,0x01,
1055 0x6,0x10,0x00,0x10,
1056 0x6,0x10,0x00,0x11,
1057 0x6,0x10,0x01,0x00,
1058 0x6,0x10,0x01,0x01,
1059 0x6,0x10,0x01,0x10,
1060 0x6,0x10,0x01,0x11,
1061 0x6,0x10,0x10,0x00,
1062 0x6,0x10,0x10,0x01,
1063 0x6,0x10,0x10,0x10,
1064 0x6,0x10,0x10,0x11,
1065 0x6,0x10,0x11,0x00,
1066 0x6,0x10,0x11,0x01,
1067 0x6,0x10,0x11,0x10,
1068 0x6,0x10,0x11,0x11,
1069 0x6,0x11,0x00,0x00,
1070 0x6,0x11,0x00,0x01,
1071 0x6,0x11,0x00,0x10,
1072 0x6,0x11,0x00,0x11,
1073 0x6,0x11,0x01,0x00,
1074 0x6,0x11,0x01,0x01,
1075 0x6,0x11,0x01,0x10,
1076 0x6,0x11,0x01,0x11,
1077 0x6,0x11,0x10,0x00,
1078 0x6,0x11,0x10,0x01,
1079 0x6,0x11,0x10,0x10,
1080 0x6,0x11,0x10,0x11,
1081 0x6,0x11,0x11,0x00,
1082 0x6,0x11,0x11,0x01,
1083 0x6,0x11,0x11,0x10,
1084 0x4,0x00,0x00,
1085 0x4,0x00,0x01,
1086 0x4,0x00,0x02,
1087 0x4,0x00,0x03,
1088 0x4,0x00,0x10,
1089 0x4,0x00,0x11,
1090 0x4,0x00,0x12,
1091 0x4,0x00,0x13,
1092 0x4,0x00,0x20,
1093 0x4,0x00,0x21,
1094 0x4,0x00,0x22,
1095 0x4,0x00,0x23,
1096 0x4,0x00,0x30,
1097 0x4,0x00,0x31,
1098 0x4,0x00,0x32,
1099 0x4,0x00,0x33,
1100 0x4,0x01,0x00,
1101 0x4,0x01,0x01,
1102 0x4,0x01,0x02,
1103 0x4,0x01,0x03,
1104 0x4,0x01,0x10,
1105 0x4,0x01,0x11,
1106 0x4,0x01,0x12,
1107 0x4,0x01,0x13,
1108 0x4,0x01,0x20,
1109 0x4,0x01,0x21,
1110 0x4,0x01,0x22,
1111 0x4,0x01,0x23,
1112 0x4,0x01,0x30,
1113 0x4,0x01,0x31,
1114 0x4,0x01,0x32,
1115 0x4,0x01,0x33,
1116 0x4,0x02,0x00,
1117 0x4,0x02,0x01,
1118 0x4,0x02,0x02,
1119 0x4,0x02,0x03,
1120 0x4,0x02,0x10,
1121 0x4,0x02,0x11,
1122 0x4,0x02,0x12,
1123 0x4,0x02,0x13,
1124 0x4,0x02,0x20,
1125 0x4,0x02,0x21,
1126 0x4,0x02,0x22,
1127 0x4,0x02,0x23,
1128 0x4,0x02,0x30,
1129 0x4,0x02,0x31,
1130 0x4,0x02,0x32,
1131 0x4,0x02,0x33,
1132 0x4,0x03,0x00,
1133 0x4,0x03,0x01,
1134 0x4,0x03,0x02,
1135 0x4,0x03,0x03,
1136 0x4,0x03,0x10,
1137 0x4,0x03,0x11,
1138 0x4,0x03,0x12,
1139 0x4,0x03,0x13,
1140 0x4,0x03,0x20,
1141 0x4,0x03,0x21,
1142 0x4,0x03,0x22,
1143 0x4,0x03,0x23,
1144 0x4,0x03,0x30,
1145 0x4,0x03,0x31,
1146 0x4,0x03,0x32,
1147 0x4,0x03,0x33,
1148 0x4,0x10,0x00,
1149 0x4,0x10,0x01,
1150 0x4,0x10,0x02,
1151 0x4,0x10,0x03,
1152 0x4,0x10,0x10,
1153 0x4,0x10,0x11,
1154 0x4,0x10,0x12,
1155 0x4,0x10,0x13,
1156 0x4,0x10,0x20,
1157 0x4,0x10,0x21,
1158 0x4,0x10,0x22,
1159 0x4,0x10,0x23,
1160 0x4,0x10,0x30,
1161 0x4,0x10,0x31,
1162 0x4,0x10,0x32,
1163 0x4,0x10,0x33,
1164 0x4,0x11,0x00,
1165 0x4,0x11,0x01,
1166 0x4,0x11,0x02,
1167 0x4,0x11,0x03,
1168 0x4,0x11,0x10,
1169 0x4,0x11,0x11,
1170 0x4,0x11,0x12,
1171 0x4,0x11,0x13,
1172 0x4,0x11,0x20,
1173 0x4,0x11,0x21,
1174 0x4,0x11,0x22,
1175 0x4,0x11,0x23,
1176 0x4,0x11,0x30,
1177 0x4,0x11,0x31,
1178 0x4,0x11,0x32,
1179 0x4,0x11,0x33,
1180 0x4,0x12,0x00,
1181 0x4,0x12,0x01,
1182 0x4,0x12,0x02,
1183 0x4,0x12,0x03,
1184 0x4,0x12,0x10,
1185 0x4,0x12,0x11,
1186 0x4,0x12,0x12,
1187 0x4,0x12,0x13,
1188 0x4,0x12,0x20,
1189 0x4,0x12,0x21,
1190 0x4,0x12,0x22,
1191 0x4,0x12,0x23,
1192 0x4,0x12,0x30,
1193 0x4,0x12,0x31,
1194 0x4,0x12,0x32,
1195 0x4,0x12,0x33,
1196 0x4,0x13,0x00,
1197 0x4,0x13,0x01,
1198 0x4,0x13,0x02,
1199 0x4,0x13,0x03,
1200 0x4,0x13,0x10,
1201 0x4,0x13,0x11,
1202 0x4,0x13,0x12,
1203 0x4,0x13,0x13,
1204 0x4,0x13,0x20,
1205 0x4,0x13,0x21,
1206 0x4,0x13,0x22,
1207 0x4,0x13,0x23,
1208 0x4,0x13,0x30,
1209 0x4,0x13,0x31,
1210 0x4,0x13,0x32,
1211 0x4,0x13,0x33,
1212 0x2,0x00,
1213 0x2,0x10,
1214 0x2,0x20,
1215 0x2,0x30,
1216 0x2,0x40,
1217 0x2,0x50,
1218 0x2,0x60,
1219 0x2,0x70,
1220 0x2,0x01,
1221 0x2,0x11,
1222 0x2,0x21,
1223 0x2,0x31,
1224 0x2,0x41,
1225 0x2,0x51,
1226 0x2,0x61,
1227 0x2,0x71,
1228 0x2,0x02,
1229 0x2,0x12,
1230 0x2,0x22,
1231 0x2,0x32,
1232 0x2,0x42,
1233 0x2,0x52,
1234 0x2,0x62,
1235 0x2,0x72,
1236 0x2,0x03,
1237 0x2,0x13,
1238 0x2,0x23,
1239 0x2,0x33,
1240 0x2,0x43,
1241 0x2,0x53,
1242 0x2,0x63,
1243 0x2,0x73,
1244 0x2,0x04,
1245 0x2,0x14,
1246 0x2,0x24,
1247 0x2,0x34,
1248 0x2,0x44,
1249 0x2,0x54,
1250 0x2,0x64,
1251 0x2,0x74,
1252 0x2,0x05,
1253 0x2,0x15,
1254 0x2,0x25,
1255 0x2,0x35,
1256 0x2,0x45,
1257 0x2,0x55,
1258 0x2,0x65,
1259 0x2,0x75,
1260 0x2,0x06,
1261 0x2,0x16,
1262 0x2,0x26,
1263 0x2,0x36,
1264 0x2,0x46,
1265 0x2,0x56,
1266 0x2,0x66,
1267 0x2,0x76,
1268 0x2,0x07,
1269 0x2,0x17,
1270 0x2,0x27,
1271 0x2,0x37,
1272 0x2,0x47,
1273 0x2,0x57,
1274 0x2,0x67,
1275 0x2,0x77
1276 ];
1277
1278 const DUCK_VECTBL4: &[u8] = &[
1279 0x8,0x00,0x00,0x00,0x00,
1280 0x8,0x00,0x00,0x00,0x00,
1281 0x8,0x20,0x00,0x00,0x00,
1282 0x8,0x00,0x00,0x00,0x01,
1283 0x8,0x10,0x00,0x00,0x00,
1284 0x8,0x00,0x00,0x00,0x02,
1285 0x8,0x01,0x00,0x00,0x00,
1286 0x8,0x00,0x00,0x00,0x10,
1287 0x8,0x02,0x00,0x00,0x00,
1288 0x6,0x00,0x00,0x00,
1289 0x6,0x20,0x00,0x00,
1290 0x6,0x00,0x00,0x01,
1291 0x6,0x10,0x00,0x00,
1292 0x6,0x00,0x00,0x02,
1293 0x6,0x00,0x10,0x00,
1294 0x6,0x00,0x20,0x00,
1295 0x6,0x00,0x02,0x00,
1296 0x6,0x00,0x01,0x00,
1297 0x6,0x01,0x00,0x00,
1298 0x6,0x00,0x00,0x20,
1299 0x6,0x02,0x00,0x00,
1300 0x6,0x00,0x00,0x10,
1301 0x6,0x10,0x00,0x20,
1302 0x6,0x01,0x00,0x02,
1303 0x6,0x20,0x00,0x10,
1304 0x6,0x02,0x00,0x01,
1305 0x6,0x20,0x10,0x00,
1306 0x6,0x00,0x12,0x00,
1307 0x6,0x00,0x02,0x01,
1308 0x6,0x02,0x01,0x00,
1309 0x6,0x00,0x21,0x00,
1310 0x6,0x00,0x01,0x02,
1311 0x6,0x00,0x20,0x10,
1312 0x6,0x00,0x00,0x21,
1313 0x6,0x00,0x00,0x12,
1314 0x6,0x00,0x01,0x20,
1315 0x6,0x12,0x00,0x00,
1316 0x6,0x00,0x10,0x20,
1317 0x6,0x01,0x20,0x00,
1318 0x6,0x02,0x10,0x00,
1319 0x6,0x10,0x20,0x00,
1320 0x6,0x01,0x02,0x00,
1321 0x6,0x21,0x00,0x00,
1322 0x6,0x00,0x02,0x10,
1323 0x6,0x20,0x01,0x00,
1324 0x6,0x00,0x22,0x00,
1325 0x6,0x10,0x02,0x00,
1326 0x6,0x00,0x10,0x02,
1327 0x6,0x11,0x00,0x00,
1328 0x6,0x00,0x11,0x00,
1329 0x6,0x22,0x00,0x00,
1330 0x6,0x20,0x00,0x02,
1331 0x6,0x10,0x00,0x01,
1332 0x6,0x00,0x20,0x01,
1333 0x6,0x02,0x20,0x00,
1334 0x6,0x01,0x10,0x00,
1335 0x6,0x01,0x00,0x20,
1336 0x6,0x00,0x20,0x02,
1337 0x6,0x01,0x20,0x02,
1338 0x6,0x10,0x01,0x00,
1339 0x6,0x02,0x00,0x10,
1340 0x6,0x00,0x10,0x01,
1341 0x6,0x10,0x01,0x20,
1342 0x6,0x20,0x02,0x10,
1343 0x6,0x00,0x00,0x22,
1344 0x6,0x10,0x00,0x02,
1345 0x6,0x00,0x02,0x20,
1346 0x6,0x20,0x02,0x00,
1347 0x6,0x00,0x00,0x11,
1348 0x6,0x02,0x10,0x01,
1349 0x6,0x00,0x01,0x10,
1350 0x6,0x00,0x02,0x11,
1351 0x4,0x01,0x02,
1352 0x4,0x02,0x01,
1353 0x4,0x01,0x00,
1354 0x4,0x10,0x20,
1355 0x4,0x20,0x10,
1356 0x4,0x20,0x00,
1357 0x4,0x11,0x00,
1358 0x4,0x02,0x00,
1359 0x4,0x12,0x00,
1360 0x4,0x00,0x21,
1361 0x4,0x22,0x00,
1362 0x4,0x00,0x12,
1363 0x4,0x21,0x00,
1364 0x4,0x02,0x11,
1365 0x4,0x00,0x01,
1366 0x4,0x10,0x02,
1367 0x4,0x02,0x20,
1368 0x4,0x20,0x11,
1369 0x4,0x01,0x10,
1370 0x4,0x21,0x10,
1371 0x4,0x10,0x00,
1372 0x4,0x10,0x22,
1373 0x4,0x20,0x20,
1374 0x4,0x00,0x22,
1375 0x4,0x01,0x22,
1376 0x4,0x20,0x01,
1377 0x4,0x02,0x02,
1378 0x4,0x00,0x20,
1379 0x4,0x00,0x10,
1380 0x4,0x00,0x11,
1381 0x4,0x22,0x01,
1382 0x4,0x11,0x20,
1383 0x4,0x12,0x01,
1384 0x4,0x12,0x20,
1385 0x4,0x11,0x02,
1386 0x4,0x10,0x10,
1387 0x4,0x01,0x01,
1388 0x4,0x02,0x21,
1389 0x4,0x20,0x12,
1390 0x4,0x01,0x12,
1391 0x4,0x22,0x11,
1392 0x4,0x21,0x12,
1393 0x4,0x22,0x10,
1394 0x4,0x21,0x02,
1395 0x4,0x20,0x02,
1396 0x4,0x10,0x01,
1397 0x4,0x00,0x02,
1398 0x4,0x10,0x21,
1399 0x4,0x01,0x20,
1400 0x4,0x11,0x22,
1401 0x4,0x12,0x21,
1402 0x4,0x22,0x20,
1403 0x4,0x02,0x10,
1404 0x4,0x02,0x22,
1405 0x4,0x11,0x10,
1406 0x4,0x22,0x02,
1407 0x4,0x20,0x21,
1408 0x4,0x01,0x11,
1409 0x4,0x11,0x01,
1410 0x4,0x10,0x12,
1411 0x4,0x02,0x12,
1412 0x4,0x20,0x22,
1413 0x4,0x21,0x20,
1414 0x4,0x01,0x21,
1415 0x4,0x12,0x02,
1416 0x4,0x21,0x11,
1417 0x4,0x12,0x22,
1418 0x4,0x12,0x10,
1419 0x4,0x22,0x21,
1420 0x4,0x10,0x11,
1421 0x4,0x21,0x01,
1422 0x4,0x11,0x12,
1423 0x4,0x12,0x11,
1424 0x4,0x66,0x66,
1425 0x4,0x22,0x22,
1426 0x4,0x11,0x21,
1427 0x4,0x11,0x11,
1428 0x4,0x21,0x22,
1429 0x4,0x00,0x00,
1430 0x4,0x22,0x12,
1431 0x4,0x12,0x12,
1432 0x4,0x21,0x21,
1433 0x4,0x42,0x00,
1434 0x4,0x00,0x04,
1435 0x4,0x40,0x00,
1436 0x4,0x30,0x00,
1437 0x4,0x31,0x00,
1438 0x4,0x00,0x03,
1439 0x4,0x00,0x14,
1440 0x4,0x00,0x13,
1441 0x4,0x01,0x24,
1442 0x4,0x20,0x13,
1443 0x4,0x01,0x42,
1444 0x4,0x14,0x20,
1445 0x4,0x42,0x02,
1446 0x4,0x13,0x00,
1447 0x4,0x00,0x24,
1448 0x4,0x31,0x20,
1449 0x4,0x22,0x13,
1450 0x4,0x11,0x24,
1451 0x4,0x12,0x66,
1452 0x4,0x30,0x01,
1453 0x4,0x02,0x13,
1454 0x4,0x12,0x42,
1455 0x4,0x40,0x10,
1456 0x4,0x40,0x02,
1457 0x4,0x01,0x04,
1458 0x4,0x24,0x00,
1459 0x4,0x42,0x10,
1460 0x4,0x21,0x13,
1461 0x4,0x13,0x12,
1462 0x4,0x31,0x21,
1463 0x4,0x21,0x24,
1464 0x4,0x00,0x40,
1465 0x4,0x10,0x24,
1466 0x4,0x10,0x42,
1467 0x4,0x32,0x01,
1468 0x4,0x11,0x42,
1469 0x4,0x20,0x31,
1470 0x4,0x12,0x40,
1471 0x2,0x00,
1472 0x2,0x10,
1473 0x2,0x20,
1474 0x2,0x30,
1475 0x2,0x40,
1476 0x2,0x50,
1477 0x2,0x60,
1478 0x2,0x70,
1479 0x2,0x01,
1480 0x2,0x11,
1481 0x2,0x21,
1482 0x2,0x31,
1483 0x2,0x41,
1484 0x2,0x51,
1485 0x2,0x61,
1486 0x2,0x71,
1487 0x2,0x02,
1488 0x2,0x12,
1489 0x2,0x22,
1490 0x2,0x32,
1491 0x2,0x42,
1492 0x2,0x52,
1493 0x2,0x62,
1494 0x2,0x72,
1495 0x2,0x03,
1496 0x2,0x13,
1497 0x2,0x23,
1498 0x2,0x33,
1499 0x2,0x43,
1500 0x2,0x53,
1501 0x2,0x63,
1502 0x2,0x73,
1503 0x2,0x04,
1504 0x2,0x14,
1505 0x2,0x24,
1506 0x2,0x34,
1507 0x2,0x44,
1508 0x2,0x54,
1509 0x2,0x64,
1510 0x2,0x74,
1511 0x2,0x05,
1512 0x2,0x15,
1513 0x2,0x25,
1514 0x2,0x35,
1515 0x2,0x45,
1516 0x2,0x55,
1517 0x2,0x65,
1518 0x2,0x75,
1519 0x2,0x06,
1520 0x2,0x16,
1521 0x2,0x26,
1522 0x2,0x36,
1523 0x2,0x46,
1524 0x2,0x56,
1525 0x2,0x66,
1526 0x2,0x76,
1527 0x2,0x07,
1528 0x2,0x17,
1529 0x2,0x27,
1530 0x2,0x37,
1531 0x2,0x47,
1532 0x2,0x57,
1533 0x2,0x67,
1534 0x2,0x77
1535 ];
1536
1537 const DUCK_VECTABLES: [&[u8]; 3] = [ DUCK_VECTBL2, DUCK_VECTBL3, DUCK_VECTBL4 ];