nihav-rad/src/codecs/smacker.rs

   1 use nihav_core::codecs::*;
   2 use nihav_core::io::byteio::*;
   3 use nihav_core::io::bitreader::*;
   4 use nihav_core::io::codebook::*;
   5 use std::str::FromStr;
   6
   7 const PAL_SIZE: usize = 768;
   8 const SMK_FLAG_INTERLACED: u32 = 0x02;
   9 const SMK_FLAG_SCALED: u32 = 0x04;
  10
  11 struct SmackerTree8 {
  12     cb:     Option<Codebook<u8>>,
  13     defsym: u8,
  14 }
  15
  16 fn get_tree8(br: &mut BitReader, bits: &mut [u8; 256], codes: &mut [u32; 256], syms: &mut [u8; 256], count: &mut usize, len: u8, prefix: u32) -> DecoderResult<()> {
  17     if !br.read_bool()? {
  18         bits[*count]  = len;
  19         codes[*count] = prefix;
  20         syms[*count]                            = br.read(8)? as u8;
  21         *count += 1;
  22     } else {
  23         validate!((*count <= 256 - 2) && (len <= 31));
  24         get_tree8(br, bits, codes, syms, count, len + 1, prefix)?;
  25         get_tree8(br, bits, codes, syms, count, len + 1, prefix | (1 << len))?;
  26     }
  27     Ok(())
  28 }
  29
  30 pub struct FullTableCodebookDescReader<'a> {
  31     bits:       &'a [u8],
  32     codes:      &'a [u32],
  33     syms:       &'a [u8],
  34 }
  35
  36 impl<'a> FullTableCodebookDescReader<'a> {
  37     pub fn new(codes: &'a [u32], bits: &'a [u8], syms: &'a [u8]) -> Self {
  38         Self { bits, codes, syms }
  39     }
  40 }
  41 impl<'a> CodebookDescReader<u8> for FullTableCodebookDescReader<'a>
  42 {
  43     fn bits(&mut self, idx: usize) -> u8  { self.bits[idx] }
  44     fn code(&mut self, idx: usize) -> u32 { self.codes[idx] }
  45     fn sym (&mut self, idx: usize) -> u8  { self.syms[idx] }
  46     fn len(&mut self) -> usize { self.bits.len() }
  47 }
  48
  49 impl SmackerTree8 {
  50     fn new() -> Self {
  51         Self {
  52             cb:     None,
  53             defsym: 0,
  54         }
  55     }
  56     fn decode(&mut self, br: &mut BitReader) -> DecoderResult<()> {
  57         if !br.read_bool()? { return Ok(()); }
  58
  59         let mut bits: [u8; 256] = [0; 256];
  60         let mut codes: [u32; 256] = [0; 256];
  61         let mut syms: [u8; 256] = [0; 256];
  62         let mut count = 0;
  63
  64         get_tree8(br, &mut bits, &mut codes, &mut syms, &mut count, 0, 0)?;
  65         validate!(!br.read_bool()?);
  66
  67         if count > 1 {
  68             let mut cr = FullTableCodebookDescReader::new(&codes[0..count], &bits[0..count], &syms[0..count]);
  69             let cb = Codebook::new(&mut cr, CodebookMode::LSB)?;
  70             self.cb = Some(cb);
  71         } else {
  72             self.defsym = syms[0];
  73         }
  74
  75         Ok(())
  76     }
  77 }
  78
  79 struct SmackerTree16 {
  80     tree:   Vec<u32>,
  81     last:   [usize; 3],
  82 }
  83
  84 struct SmackerTree16Builder {
  85     tree_lo:    SmackerTree8,
  86     tree_hi:    SmackerTree8,
  87     nsyms:      usize,
  88     esc:        [u32; 3],
  89 }
  90
  91 const SMK_BIGTREE_NODE: u32 = 0x80000000;
  92 const SMK_LAST_UNINIT: usize = 0xFFFFFFFF;
  93
  94 impl SmackerTree16Builder {
  95     fn get_tree16(&mut self, br: &mut BitReader, tree: &mut SmackerTree16, depth: usize) -> DecoderResult<u32> {
  96         validate!(tree.tree.len() < self.nsyms);
  97         if !br.read_bool()? {
  98             let lo = br.read_tree8(&self.tree_lo)?;
  99             let hi = br.read_tree8(&self.tree_hi)?;
 100             let mut sym = (((hi as u16) << 8) | (lo as u16)) as u32;
 101             if sym == self.esc[0] {
 102                 tree.last[0] = tree.tree.len();
 103                 sym = 0;
 104             } else if sym == self.esc[1] {
 105                 tree.last[1] = tree.tree.len();
 106                 sym = 0;
 107             } else if sym == self.esc[2] {
 108                 tree.last[2] = tree.tree.len();
 109                 sym = 0;
 110             }
 111             tree.tree.push(sym);
 112             Ok(1)
 113         } else {
 114             let cur_idx = tree.tree.len();
 115             tree.tree.push(0);
 116             let lcount = self.get_tree16(br, tree, depth + 1)?;
 117             let rcount = self.get_tree16(br, tree, depth + 1)?;
 118             tree.tree[cur_idx] = SMK_BIGTREE_NODE | lcount;
 119             Ok(lcount + rcount + 1)
 120         }
 121     }
 122 }
 123
 124 impl SmackerTree16 {
 125     fn new() -> Self {
 126         Self {
 127             tree:   Vec::new(),
 128             last:   [SMK_LAST_UNINIT; 3],
 129         }
 130     }
 131     fn decode(&mut self, br: &mut BitReader, size: u32) -> DecoderResult<()> {
 132         if !br.read_bool()? { return Ok(()); }
 133
 134         let mut tree_lo = SmackerTree8::new();
 135         tree_lo.decode(br)?;
 136         let mut tree_hi = SmackerTree8::new();
 137         tree_hi.decode(br)?;
 138
 139         let mut esc: [u32; 3] = [0; 3];
 140         for i in 0..esc.len() {
 141             esc[i] = br.read(16)? as u32;
 142         }
 143
 144         let nsyms = (((size + 3) >> 2) + 4) as usize;
 145         self.tree = Vec::with_capacity(nsyms);
 146
 147         let mut tb = SmackerTree16Builder { tree_lo, tree_hi, nsyms, esc };
 148
 149         tb.get_tree16(br, self, 0)?;
 150         validate!(!br.read_bool()?);
 151
 152         for i in 0..self.last.len() {
 153             if self.last[i] == SMK_LAST_UNINIT {
 154                 self.last[i] = self.tree.len();
 155                 self.tree.push(0);
 156             }
 157         }
 158         validate!(self.tree.len() <= nsyms);
 159         Ok(())
 160     }
 161     fn reset(&mut self) {
 162         for i in 0..self.last.len() {
 163             if self.last[i] != SMK_LAST_UNINIT {
 164                 self.tree[self.last[i]] = 0;
 165             }
 166         }
 167     }
 168 }
 169
 170 trait ReadTree {
 171     fn read_tree8(&mut self, tree: &SmackerTree8) -> DecoderResult<u8>;
 172     fn read_bigtree(&mut self, tree: &mut SmackerTree16) -> DecoderResult<u16>;
 173 }
 174
 175 impl<'a> ReadTree for BitReader<'a> {
 176     fn read_tree8(&mut self, tree: &SmackerTree8) -> DecoderResult<u8> {
 177         if let Some(ref cb) = tree.cb {
 178             Ok(self.read_cb(cb)?)
 179         } else {
 180             Ok(tree.defsym)
 181         }
 182     }
 183     fn read_bigtree(&mut self, tree: &mut SmackerTree16) -> DecoderResult<u16> {
 184         let mut pos = 0;
 185         while (tree.tree[pos] & SMK_BIGTREE_NODE) != 0 {
 186             if self.read_bool()? {
 187                 pos += (tree.tree[pos] & !SMK_BIGTREE_NODE) as usize;
 188             }
 189             pos += 1;
 190         }
 191         let val = tree.tree[pos];
 192         if val != tree.tree[tree.last[0]] {
 193             tree.tree[tree.last[2]] = tree.tree[tree.last[1]];
 194             tree.tree[tree.last[1]] = tree.tree[tree.last[0]];
 195             tree.tree[tree.last[0]] = val;
 196         }
 197         Ok(val as u16)
 198     }
 199 }
 200
 201 const SMK_BLOCK_RUNS: [usize; 64] = [
 202       1,    2,    3,    4,    5,    6,    7,    8,
 203       9,   10,   11,   12,   13,   14,   15,   16,
 204      17,   18,   19,   20,   21,   22,   23,   24,
 205      25,   26,   27,   28,   29,   30,   31,   32,
 206      33,   34,   35,   36,   37,   38,   39,   40,
 207      41,   42,   43,   44,   45,   46,   47,   48,
 208      49,   50,   51,   52,   53,   54,   55,   56,
 209      57,   58,   59,  128,  256,  512, 1024, 2048
 210 ];
 211
 212 struct SmackerVideoDecoder {
 213     info:       NACodecInfoRef,
 214     mmap_tree:  SmackerTree16,
 215     mclr_tree:  SmackerTree16,
 216     full_tree:  SmackerTree16,
 217     type_tree:  SmackerTree16,
 218     w:          usize,
 219     h:          usize,
 220     bw:         usize,
 221     bh:         usize,
 222     is_ver4:    bool,
 223     flags:      u32,
 224     frame:      Vec<u8>,
 225     stride:     usize,
 226 }
 227
 228 impl SmackerVideoDecoder {
 229     fn new() -> Self {
 230         Self {
 231             info:       NACodecInfoRef::default(),
 232             mmap_tree:  SmackerTree16::new(),
 233             mclr_tree:  SmackerTree16::new(),
 234             full_tree:  SmackerTree16::new(),
 235             type_tree:  SmackerTree16::new(),
 236             w:          0,
 237             h:          0,
 238             bw:         0,
 239             bh:         0,
 240             is_ver4:    false,
 241             flags:      0,
 242             frame:      Vec::new(),
 243             stride:     0,
 244         }
 245     }
 246     fn block_pos(&self, blk_no: usize) -> usize {
 247         let bx = blk_no % self.bw;
 248         let by = blk_no / self.bw;
 249         bx * 4 + by * 4 * self.stride
 250     }
 251     fn decode_frame(&mut self, br: &mut BitReader) -> DecoderResult<bool> {
 252         let mut is_intra = true;
 253         let blocks = self.bw * self.bh;
 254
 255         self.mmap_tree.reset();
 256         self.mclr_tree.reset();
 257         self.full_tree.reset();
 258         self.type_tree.reset();
 259
 260         let mut block = 0;
 261         while block < blocks {
 262             let btype = br.read_bigtree(&mut self.type_tree)?;
 263             let run = SMK_BLOCK_RUNS[((btype as usize) >> 2) & 0x3F];
 264             validate!(run <= blocks - block);
 265             match btype & 3 {
 266                 0 => { // two-colour pattern
 267                         for i in 0..run {
 268                             let clr = br.read_bigtree(&mut self.mclr_tree)?;
 269                             let mut map = br.read_bigtree(&mut self.mmap_tree)?;
 270                             let hi = (clr >> 8) as u8;
 271                             let lo = (clr & 0xFF) as u8;
 272                             let mut doff = self.block_pos(block + i);
 273                             for _ in 0..4 {
 274                                 self.frame[doff + 0] = if (map & 1) != 0 { hi } else { lo };
 275                                 self.frame[doff + 1] = if (map & 2) != 0 { hi } else { lo };
 276                                 self.frame[doff + 2] = if (map & 4) != 0 { hi } else { lo };
 277                                 self.frame[doff + 3] = if (map & 8) != 0 { hi } else { lo };
 278                                 map >>= 4;
 279                                 doff += self.stride;
 280                             }
 281                         }
 282                     },
 283                 1 => { // full
 284                         let mode;
 285                         if !self.is_ver4 || !br.read_bool()? {
 286                             mode = 0;
 287                         } else {
 288                             mode = 1 + br.read(1)?;
 289                         }
 290                         for i in 0..run {
 291                             let mut doff = self.block_pos(block + i);
 292                             match mode {
 293                                 0 => {
 294                                         for _ in 0..4 {
 295                                             let clr0 = br.read_bigtree(&mut self.full_tree)?;
 296                                             let clr1 = br.read_bigtree(&mut self.full_tree)?;
 297                                             self.frame[doff + 0] = (clr1 & 0xFF) as u8;
 298                                             self.frame[doff + 1] = (clr1 >> 8) as u8;
 299                                             self.frame[doff + 2] = (clr0 & 0xFF) as u8;
 300                                             self.frame[doff + 3] = (clr0 >> 8) as u8;
 301                                             doff += self.stride;
 302                                         }
 303                                     },
 304                                 1 => {
 305                                         for _ in 0..2 {
 306                                             let clr = br.read_bigtree(&mut self.full_tree)?;
 307                                             self.frame[doff + 0] = (clr & 0xFF) as u8;
 308                                             self.frame[doff + 1] = (clr & 0xFF) as u8;
 309                                             self.frame[doff + 2] = (clr >> 8) as u8;
 310                                             self.frame[doff + 3] = (clr >> 8) as u8;
 311                                             doff += self.stride;
 312                                             self.frame[doff + 0] = (clr & 0xFF) as u8;
 313                                             self.frame[doff + 1] = (clr & 0xFF) as u8;
 314                                             self.frame[doff + 2] = (clr >> 8) as u8;
 315                                             self.frame[doff + 3] = (clr >> 8) as u8;
 316                                             doff += self.stride;
 317                                         }
 318                                     },
 319                                 2 => {
 320                                         for _ in 0..2 {
 321                                             let clr0 = br.read_bigtree(&mut self.full_tree)?;
 322                                             let clr1 = br.read_bigtree(&mut self.full_tree)?;
 323                                             self.frame[doff + 0] = (clr1 & 0xFF) as u8;
 324                                             self.frame[doff + 1] = (clr1 >> 8) as u8;
 325                                             self.frame[doff + 2] = (clr0 & 0xFF) as u8;
 326                                             self.frame[doff + 3] = (clr0 >> 8) as u8;
 327                                             doff += self.stride;
 328                                             self.frame[doff + 0] = (clr1 & 0xFF) as u8;
 329                                             self.frame[doff + 1] = (clr1 >> 8) as u8;
 330                                             self.frame[doff + 2] = (clr0 & 0xFF) as u8;
 331                                             self.frame[doff + 3] = (clr0 >> 8) as u8;
 332                                             doff += self.stride;
 333                                         }
 334                                     },
 335                                 _ => unreachable!(),
 336                             };
 337                         }
 338                     },
 339                 2 => { // skip
 340                         is_intra = false;
 341                     },
 342                 3 => { // fill
 343                         let clr = (btype >> 8) as u8;
 344                         for i in 0..run {
 345                             let mut doff = self.block_pos(block + i);
 346                             for _ in 0..4 {
 347                                 self.frame[doff + 0] = clr;
 348                                 self.frame[doff + 1] = clr;
 349                                 self.frame[doff + 2] = clr;
 350                                 self.frame[doff + 3] = clr;
 351                                 doff += self.stride;
 352                             }
 353                         }
 354                     },
 355                 _ => unreachable!(),
 356             };
 357             block += run;
 358         }
 359         Ok(is_intra)
 360     }
 361     fn output_frame(&self, buf: &mut NAVideoBuffer<u8>) {
 362         let stride = buf.get_stride(0);
 363         let data = buf.get_data_mut().unwrap();
 364         let dst = data.as_mut_slice();
 365         let is_scaled = (self.flags & SMK_FLAG_SCALED) != 0;
 366         let is_interlaced = (self.flags & SMK_FLAG_INTERLACED) != 0;
 367         let mut didx = 0;
 368         let mut sidx = 0;
 369         for _ in 0..self.h {
 370             for x in 0..self.w { dst[didx + x] = self.frame[sidx + x]; }
 371             sidx += self.stride;
 372             didx += stride;
 373             if is_scaled {
 374                 for x in 0..self.w { dst[didx + x] = dst[didx - stride + x]; }
 375                 didx += stride;
 376             }
 377             if is_interlaced {
 378                 for x in 0..self.w { dst[didx + x] = 0; }
 379                 didx += stride;
 380                 if is_scaled {
 381                     for x in 0..self.w { dst[didx + x] = 0; }
 382                     didx += stride;
 383                 }
 384             }
 385         }
 386     }
 387 }
 388
 389 impl NADecoder for SmackerVideoDecoder {
 390     fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
 391         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
 392             let w = vinfo.get_width();
 393             let h = vinfo.get_height();
 394             let fmt = PAL8_FORMAT;
 395
 396             self.w = w;
 397             self.h = h;
 398             self.bw = w >> 2;
 399             self.bh = h >> 2;
 400             let edata = info.get_extradata().unwrap();
 401             validate!(edata.len() > 24);
 402
 403             self.stride = w;
 404             self.frame.resize(w * h, 0);
 405
 406             let mut mr = MemoryReader::new_read(&edata);
 407             let mut br = ByteReader::new(&mut mr);
 408             let magic                   = br.read_u32be()?;
 409             self.flags                  = br.read_u32le()?;
 410             let mmap_size               = br.read_u32le()?;
 411             let mclr_size               = br.read_u32le()?;
 412             let full_size               = br.read_u32le()?;
 413             let type_size               = br.read_u32le()?;
 414
 415             self.is_ver4 = (magic & 0xFF) == 0x34;
 416             let mut br = BitReader::new(&edata[24..], BitReaderMode::LE);
 417             self.mmap_tree.decode(&mut br, mmap_size)?;
 418             self.mclr_tree.decode(&mut br, mclr_size)?;
 419             self.full_tree.decode(&mut br, full_size)?;
 420             self.type_tree.decode(&mut br, type_size)?;
 421
 422             let mut out_h = h;
 423             if (self.flags & SMK_FLAG_INTERLACED) != 0 {
 424                 out_h <<= 1;
 425             }
 426             if (self.flags & SMK_FLAG_SCALED) != 0 {
 427                 out_h <<= 1;
 428             }
 429             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, out_h, false, fmt));
 430             self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
 431
 432             Ok(())
 433         } else {
 434             Err(DecoderError::InvalidData)
 435         }
 436     }
 437     fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
 438         let src = pkt.get_buffer();
 439         validate!(src.len() >= PAL_SIZE);
 440
 441         let is_intra;
 442         let ftype;
 443         let bufinfo;
 444         if src.len() > PAL_SIZE {
 445             let mut br = BitReader::new(&src[PAL_SIZE..], BitReaderMode::LE);
 446
 447             bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 2)?;
 448             let mut buf = bufinfo.get_vbuf().unwrap();
 449             is_intra = self.decode_frame(&mut br)?;
 450             self.output_frame(&mut buf);
 451             let paloff = buf.get_offset(1);
 452             let data = buf.get_data_mut().unwrap();
 453             let dst = data.as_mut_slice();
 454             let palout = &mut dst[paloff..][..PAL_SIZE];
 455             palout.copy_from_slice(&src[0..PAL_SIZE]);
 456             ftype = if is_intra { FrameType::I } else { FrameType::P };
 457         } else {
 458             bufinfo  = NABufferType::None;
 459             ftype    = FrameType::Skip;
 460             is_intra = false;
 461         }
 462
 463         let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
 464         frm.set_keyframe(is_intra);
 465         frm.set_frame_type(ftype);
 466         Ok(frm.into_ref())
 467     }
 468     fn flush(&mut self) {
 469     }
 470 }
 471
 472 pub fn get_decoder_video() -> Box<dyn NADecoder + Send> {
 473     Box::new(SmackerVideoDecoder::new())
 474 }
 475
 476 struct SmackerAudioDecoder {
 477     ainfo:      NAAudioInfo,
 478     chmap:      NAChannelMap,
 479     chans:      usize,
 480     bits:       u8,
 481 }
 482
 483 impl SmackerAudioDecoder {
 484     fn new() -> Self {
 485         Self {
 486             ainfo:  NAAudioInfo::new(0, 1, SND_S16P_FORMAT, 0),
 487             chmap:  NAChannelMap::new(),
 488             chans:  0,
 489             bits:   0,
 490         }
 491     }
 492 }
 493
 494 impl NADecoder for SmackerAudioDecoder {
 495     fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
 496         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
 497             self.bits = ainfo.get_format().get_bits();
 498             let fmt = if self.bits == 8 { SND_U8_FORMAT } else { SND_S16_FORMAT };
 499             self.chans = ainfo.get_channels() as usize;
 500             self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), ainfo.get_channels(), fmt, 0);
 501             self.chmap = NAChannelMap::from_str(if ainfo.get_channels() == 2 {"L,R"} else {"C"}).unwrap();
 502             Ok(())
 503         } else {
 504             Err(DecoderError::InvalidData)
 505         }
 506     }
 507     fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
 508         let info = pkt.get_stream().get_info();
 509         if let NACodecTypeInfo::Audio(_) = info.get_properties() {
 510             let src = pkt.get_buffer();
 511             validate!(src.len() > 4);
 512             let mut br = BitReader::new(&src, BitReaderMode::LE);
 513             let unp_size                        = br.read(32)? as usize;
 514             if !br.read_bool()? {
 515                 let mut frm = NAFrame::new_from_pkt(pkt, info.clone(), NABufferType::None);
 516                 frm.set_frame_type(FrameType::Skip);
 517                 return Ok(frm.into_ref());
 518             }
 519             let stereo                          = br.read_bool()?;
 520             let bits16                          = br.read_bool()?;
 521             validate!(!(stereo ^ (self.chans == 2)));
 522             validate!(!(bits16 ^ (self.bits == 16)));
 523
 524             let abuf;
 525             let samples;
 526             let nch = if stereo { 2 } else { 1 };
 527             if bits16 {
 528                 samples = unp_size / 2 / nch;
 529                 let mask = if stereo { 1 } else { 0 };
 530                 let mut trees: [SmackerTree8; 4] = [SmackerTree8::new(), SmackerTree8::new(), SmackerTree8::new(), SmackerTree8::new()];
 531                 for i in 0..nch*2 {
 532                     trees[i].decode(&mut br)?;
 533                 }
 534                 let mut pred: [i16; 2] = [0; 2];
 535                 for i in 0..nch {
 536                     let hi                      = br.read(8)?;
 537                     let lo                      = br.read(8)?;
 538                     pred[nch - i - 1] = (lo | (hi << 8)) as i16;
 539                 }
 540
 541                 abuf = alloc_audio_buffer(self.ainfo, samples, self.chmap.clone())?;
 542                 let mut adata = abuf.get_abuf_i16().unwrap();
 543                 let dst = adata.get_data_mut().unwrap();
 544                 for ch in 0..nch {
 545                     dst[ch] = pred[ch];
 546                 }
 547                 for i in nch..(unp_size >> 1) {
 548                     let idx = i & mask;
 549                     let lo                      = br.read_tree8(&trees[idx * 2 + 0])? as u16;
 550                     let hi                      = br.read_tree8(&trees[idx * 2 + 1])? as u16;
 551                     let diff = (lo | (hi << 8)) as i16;
 552                     pred[idx] = pred[idx].wrapping_add(diff);
 553                     dst[i] = pred[idx];
 554                 }
 555             } else {
 556                 samples = unp_size / nch;
 557                 abuf = alloc_audio_buffer(self.ainfo, samples, self.chmap.clone())?;
 558                 let mut adata = abuf.get_abuf_u8().unwrap();
 559                 let dst = adata.get_data_mut().unwrap();
 560                 if stereo {
 561                     let mut trees: [SmackerTree8; 2] = [SmackerTree8::new(), SmackerTree8::new()];
 562                     trees[0].decode(&mut br)?;
 563                     trees[1].decode(&mut br)?;
 564                     let pred0                   = br.read(8)? as u8;
 565                     let pred1                   = br.read(8)? as u8;
 566                     let mut pred: [u8; 2] = [ pred1, pred0 ];
 567                     for ch in 0..2 { dst[ch] = pred[ch]; }
 568                     for i in 2..unp_size {
 569                         let diff = br.read_tree8(&trees[i & 1])? as u8;
 570                         pred[i & 1] = pred[i & 1].wrapping_add(diff);
 571                         dst[i] = pred[i & 1];
 572                     }
 573                 } else {
 574                     let mut tree = SmackerTree8::new();
 575                     tree.decode(&mut br)?;
 576                     let mut pred                = br.read(8)? as u8;
 577                     dst[0] = pred;
 578                     for i in 1..unp_size {
 579                         let diff = br.read_tree8(&tree)? as u8;
 580                         pred = pred.wrapping_add(diff);
 581                         dst[i] = pred;
 582                     }
 583                 }
 584             }
 585             let mut frm = NAFrame::new_from_pkt(pkt, info, abuf);
 586             frm.set_duration(Some(samples as u64));
 587             frm.set_keyframe(false);
 588             Ok(frm.into_ref())
 589         } else {
 590             Err(DecoderError::InvalidData)
 591         }
 592     }
 593     fn flush(&mut self) {
 594     }
 595 }
 596
 597 pub fn get_decoder_audio() -> Box<dyn NADecoder + Send> {
 598     Box::new(SmackerAudioDecoder::new())
 599 }
 600
 601 #[cfg(test)]
 602 mod test {
 603     use nihav_core::codecs::RegisteredDecoders;
 604     use nihav_core::demuxers::RegisteredDemuxers;
 605     use nihav_codec_support::test::dec_video::*;
 606     use crate::rad_register_all_codecs;
 607     use crate::rad_register_all_demuxers;
 608     #[test]
 609     fn test_smkvid() {
 610         let mut dmx_reg = RegisteredDemuxers::new();
 611         rad_register_all_demuxers(&mut dmx_reg);
 612         let mut dec_reg = RegisteredDecoders::new();
 613         rad_register_all_codecs(&mut dec_reg);
 614
 615         //let file = "assets/RAD/20130507_audio-distortion.smk";
 616         //let file = "assets/RAD/ajfstr1.smk";
 617         //let file = "assets/RAD/credits.smk";
 618         let file = "assets/RAD/wetlogo.smk";
 619         test_file_decoding("smacker", file, Some(1000), true, false, None, &dmx_reg, &dec_reg);
 620     }
 621     #[test]
 622     fn test_smkaud() {
 623         let mut dmx_reg = RegisteredDemuxers::new();
 624         rad_register_all_demuxers(&mut dmx_reg);
 625         let mut dec_reg = RegisteredDecoders::new();
 626         rad_register_all_codecs(&mut dec_reg);
 627
 628         //let file = "assets/RAD/20130507_audio-distortion.smk";
 629         let file = "assets/RAD/wetlogo.smk";
 630         test_decode_audio("smacker", file, None, None/*Some("smk")*/, &dmx_reg, &dec_reg);
 631     }
 632 }