[nihav.git] / nihav-rad / src / codecs / smacker.rs

use nihav_core::codecs::*;
use nihav_core::io::byteio::*;
use nihav_core::io::bitreader::*;
use nihav_core::io::codebook::*;
use std::str::FromStr;

const PAL_SIZE: usize = 768;
const SMK_FLAG_INTERLACED: u32 = 0x02;
const SMK_FLAG_SCALED: u32 = 0x04;

struct SmackerTree8 {
    cb:     Option<Codebook<u8>>,
    defsym: u8,
}

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<()> {
    if !br.read_bool()? {
        bits[*count]  = len;
        codes[*count] = prefix;
        syms[*count]                            = br.read(8)? as u8;
        *count += 1;
    } else {
        validate!((*count <= 256 - 2) && (len <= 31));
        get_tree8(br, bits, codes, syms, count, len + 1, prefix)?;
        get_tree8(br, bits, codes, syms, count, len + 1, prefix | (1 << len))?;
    }
    Ok(())
}

pub struct FullTableCodebookDescReader<'a> {
    bits:       &'a [u8],
    codes:      &'a [u32],
    syms:       &'a [u8],
}

impl<'a> FullTableCodebookDescReader<'a> {
    pub fn new(codes: &'a [u32], bits: &'a [u8], syms: &'a [u8]) -> Self {
        Self { bits, codes, syms }
    }
}
impl<'a> CodebookDescReader<u8> for FullTableCodebookDescReader<'a>
{
    fn bits(&mut self, idx: usize) -> u8  { self.bits[idx] }
    fn code(&mut self, idx: usize) -> u32 { self.codes[idx] }
    fn sym (&mut self, idx: usize) -> u8  { self.syms[idx] }
    fn len(&mut self) -> usize { self.bits.len() }
}

impl SmackerTree8 {
    fn new() -> Self {
        Self {
            cb:     None,
            defsym: 0,
        }
    }
    fn decode(&mut self, br: &mut BitReader) -> DecoderResult<()> {
        if !br.read_bool()? { return Ok(()); }

        let mut bits: [u8; 256] = [0; 256];
        let mut codes: [u32; 256] = [0; 256];
        let mut syms: [u8; 256] = [0; 256];
        let mut count = 0;

        get_tree8(br, &mut bits, &mut codes, &mut syms, &mut count, 0, 0)?;
        validate!(!br.read_bool()?);

        if count > 1 {
            let mut cr = FullTableCodebookDescReader::new(&codes[0..count], &bits[0..count], &syms[0..count]);
            let cb = Codebook::new(&mut cr, CodebookMode::LSB)?;
            self.cb = Some(cb);
        } else {
            self.defsym = syms[0];
        }

        Ok(())
    }
}

struct SmackerTree16 {
    tree:   Vec<u32>,
    last:   [usize; 3],
}

struct SmackerTree16Builder {
    tree_lo:    SmackerTree8,
    tree_hi:    SmackerTree8,
    nsyms:      usize,
    esc:        [u32; 3],
}

const SMK_BIGTREE_NODE: u32 = 0x80000000;
const SMK_LAST_UNINIT: usize = 0xFFFFFFFF;

impl SmackerTree16Builder {
    fn get_tree16(&mut self, br: &mut BitReader, tree: &mut SmackerTree16, depth: usize) -> DecoderResult<u32> {
        validate!(tree.tree.len() < self.nsyms);
        if !br.read_bool()? {
            let lo = br.read_tree8(&self.tree_lo)?;
            let hi = br.read_tree8(&self.tree_hi)?;
            let mut sym = (((hi as u16) << 8) | (lo as u16)) as u32;
            if sym == self.esc[0] {
                tree.last[0] = tree.tree.len();
                sym = 0;
            } else if sym == self.esc[1] {
                tree.last[1] = tree.tree.len();
                sym = 0;
            } else if sym == self.esc[2] {
                tree.last[2] = tree.tree.len();
                sym = 0;
            }
            tree.tree.push(sym);
            Ok(1)
        } else {
            let cur_idx = tree.tree.len();
            tree.tree.push(0);
            let lcount = self.get_tree16(br, tree, depth + 1)?;
            let rcount = self.get_tree16(br, tree, depth + 1)?;
            tree.tree[cur_idx] = SMK_BIGTREE_NODE | lcount;
            Ok(lcount + rcount + 1)
        }
    }
}

impl SmackerTree16 {
    fn new() -> Self {
        Self {
            tree:   Vec::new(),
            last:   [SMK_LAST_UNINIT; 3],
        }
    }
    fn decode(&mut self, br: &mut BitReader, size: u32) -> DecoderResult<()> {
        if !br.read_bool()? { return Ok(()); }

        let mut tree_lo = SmackerTree8::new();
        tree_lo.decode(br)?;
        let mut tree_hi = SmackerTree8::new();
        tree_hi.decode(br)?;

        let mut esc: [u32; 3] = [0; 3];
        for i in 0..esc.len() {
            esc[i] = br.read(16)? as u32;
        }

        let nsyms = (((size + 3) >> 2) + 4) as usize;
        self.tree = Vec::with_capacity(nsyms);

        let mut tb = SmackerTree16Builder { tree_lo, tree_hi, nsyms, esc };

        tb.get_tree16(br, self, 0)?;
        validate!(!br.read_bool()?);

        for i in 0..self.last.len() {
            if self.last[i] == SMK_LAST_UNINIT {
                self.last[i] = self.tree.len();
                self.tree.push(0);
            }
        }
        validate!(self.tree.len() <= nsyms);
        Ok(())
    }
    fn reset(&mut self) {
        for i in 0..self.last.len() {
            if self.last[i] != SMK_LAST_UNINIT {
                self.tree[self.last[i]] = 0;
            }
        }
    }
}

trait ReadTree {
    fn read_tree8(&mut self, tree: &SmackerTree8) -> DecoderResult<u8>;
    fn read_bigtree(&mut self, tree: &mut SmackerTree16) -> DecoderResult<u16>;
}

impl<'a> ReadTree for BitReader<'a> {
    fn read_tree8(&mut self, tree: &SmackerTree8) -> DecoderResult<u8> {
        if let Some(ref cb) = tree.cb {
            Ok(self.read_cb(cb)?)
        } else {
            Ok(tree.defsym)
        }
    }
    fn read_bigtree(&mut self, tree: &mut SmackerTree16) -> DecoderResult<u16> {
        let mut pos = 0;
        while (tree.tree[pos] & SMK_BIGTREE_NODE) != 0 {
            if self.read_bool()? {
                pos += (tree.tree[pos] & !SMK_BIGTREE_NODE) as usize;
            }
            pos += 1;
        }
        let val = tree.tree[pos];
        if val != tree.tree[tree.last[0]] {
            tree.tree[tree.last[2]] = tree.tree[tree.last[1]];
            tree.tree[tree.last[1]] = tree.tree[tree.last[0]];
            tree.tree[tree.last[0]] = val;
        }
        Ok(val as u16)
    }
}

const SMK_BLOCK_RUNS: [usize; 64] = [
      1,    2,    3,    4,    5,    6,    7,    8,
      9,   10,   11,   12,   13,   14,   15,   16,
     17,   18,   19,   20,   21,   22,   23,   24,
     25,   26,   27,   28,   29,   30,   31,   32,
     33,   34,   35,   36,   37,   38,   39,   40,
     41,   42,   43,   44,   45,   46,   47,   48,
     49,   50,   51,   52,   53,   54,   55,   56,
     57,   58,   59,  128,  256,  512, 1024, 2048
];

struct SmackerVideoDecoder {
    info:       NACodecInfoRef,
    mmap_tree:  SmackerTree16,
    mclr_tree:  SmackerTree16,
    full_tree:  SmackerTree16,
    type_tree:  SmackerTree16,
    w:          usize,
    h:          usize,
    bw:         usize,
    bh:         usize,
    is_ver4:    bool,
    flags:      u32,
    frame:      Vec<u8>,
    stride:     usize,
}

impl SmackerVideoDecoder {
    fn new() -> Self {
        Self {
            info:       NACodecInfoRef::default(),
            mmap_tree:  SmackerTree16::new(),
            mclr_tree:  SmackerTree16::new(),
            full_tree:  SmackerTree16::new(),
            type_tree:  SmackerTree16::new(),
            w:          0,
            h:          0,
            bw:         0,
            bh:         0,
            is_ver4:    false,
            flags:      0,
            frame:      Vec::new(),
            stride:     0,
        }
    }
    fn block_pos(&self, blk_no: usize) -> usize {
        let bx = blk_no % self.bw;
        let by = blk_no / self.bw;
        bx * 4 + by * 4 * self.stride
    }
    fn decode_frame(&mut self, br: &mut BitReader) -> DecoderResult<bool> {
        let mut is_intra = true;
        let blocks = self.bw * self.bh;

        self.mmap_tree.reset();
        self.mclr_tree.reset();
        self.full_tree.reset();
        self.type_tree.reset();

        let mut block = 0;
        while block < blocks {
            let btype = br.read_bigtree(&mut self.type_tree)?;
            let run = SMK_BLOCK_RUNS[((btype as usize) >> 2) & 0x3F];
            validate!(run <= blocks - block);
            match btype & 3 {
                0 => { // two-colour pattern
                        for i in 0..run {
                            let clr = br.read_bigtree(&mut self.mclr_tree)?;
                            let mut map = br.read_bigtree(&mut self.mmap_tree)?;
                            let hi = (clr >> 8) as u8;
                            let lo = (clr & 0xFF) as u8;
                            let mut doff = self.block_pos(block + i);
                            for _ in 0..4 {
                                self.frame[doff + 0] = if (map & 1) != 0 { hi } else { lo };
                                self.frame[doff + 1] = if (map & 2) != 0 { hi } else { lo };
                                self.frame[doff + 2] = if (map & 4) != 0 { hi } else { lo };
                                self.frame[doff + 3] = if (map & 8) != 0 { hi } else { lo };
                                map >>= 4;
                                doff += self.stride;
                            }
                        }
                    },
                1 => { // full
                        let mode;
                        if !self.is_ver4 || !br.read_bool()? {
                            mode = 0;
                        } else {
                            mode = 1 + br.read(1)?;
                        }
                        for i in 0..run {
                            let mut doff = self.block_pos(block + i);
                            match mode {
                                0 => {
                                        for _ in 0..4 {
                                            let clr0 = br.read_bigtree(&mut self.full_tree)?;
                                            let clr1 = br.read_bigtree(&mut self.full_tree)?;
                                            self.frame[doff + 0] = (clr1 & 0xFF) as u8;
                                            self.frame[doff + 1] = (clr1 >> 8) as u8;
                                            self.frame[doff + 2] = (clr0 & 0xFF) as u8;
                                            self.frame[doff + 3] = (clr0 >> 8) as u8;
                                            doff += self.stride;
                                        }
                                    },
                                1 => {
                                        for _ in 0..2 {
                                            let clr = br.read_bigtree(&mut self.full_tree)?;
                                            self.frame[doff + 0] = (clr & 0xFF) as u8;
                                            self.frame[doff + 1] = (clr & 0xFF) as u8;
                                            self.frame[doff + 2] = (clr >> 8) as u8;
                                            self.frame[doff + 3] = (clr >> 8) as u8;
                                            doff += self.stride;
                                            self.frame[doff + 0] = (clr & 0xFF) as u8;
                                            self.frame[doff + 1] = (clr & 0xFF) as u8;
                                            self.frame[doff + 2] = (clr >> 8) as u8;
                                            self.frame[doff + 3] = (clr >> 8) as u8;
                                            doff += self.stride;
                                        }
                                    },
                                2 => {
                                        for _ in 0..2 {
                                            let clr0 = br.read_bigtree(&mut self.full_tree)?;
                                            let clr1 = br.read_bigtree(&mut self.full_tree)?;
                                            self.frame[doff + 0] = (clr1 & 0xFF) as u8;
                                            self.frame[doff + 1] = (clr1 >> 8) as u8;
                                            self.frame[doff + 2] = (clr0 & 0xFF) as u8;
                                            self.frame[doff + 3] = (clr0 >> 8) as u8;
                                            doff += self.stride;
                                            self.frame[doff + 0] = (clr1 & 0xFF) as u8;
                                            self.frame[doff + 1] = (clr1 >> 8) as u8;
                                            self.frame[doff + 2] = (clr0 & 0xFF) as u8;
                                            self.frame[doff + 3] = (clr0 >> 8) as u8;
                                            doff += self.stride;
                                        }
                                    },
                                _ => unreachable!(),
                            };
                        }
                    },
                2 => { // skip
                        is_intra = false;
                    },
                3 => { // fill
                        let clr = (btype >> 8) as u8;
                        for i in 0..run {
                            let mut doff = self.block_pos(block + i);
                            for _ in 0..4 {
                                self.frame[doff + 0] = clr;
                                self.frame[doff + 1] = clr;
                                self.frame[doff + 2] = clr;
                                self.frame[doff + 3] = clr;
                                doff += self.stride;
                            }
                        }
                    },
                _ => unreachable!(),
            };
            block += run;
        }
        Ok(is_intra)
    }
    fn output_frame(&self, buf: &mut NAVideoBuffer<u8>) {
        let stride = buf.get_stride(0);
        let data = buf.get_data_mut().unwrap();
        let dst = data.as_mut_slice();
        let is_scaled = (self.flags & SMK_FLAG_SCALED) != 0;
        let is_interlaced = (self.flags & SMK_FLAG_INTERLACED) != 0;
        let mut didx = 0;
        let mut sidx = 0;
        for _ in 0..self.h {
            for x in 0..self.w { dst[didx + x] = self.frame[sidx + x]; }
            sidx += self.stride;
            didx += stride;
            if is_scaled {
                for x in 0..self.w { dst[didx + x] = dst[didx - stride + x]; }
                didx += stride;
            }
            if is_interlaced {
                for x in 0..self.w { dst[didx + x] = 0; }
                didx += stride;
                if is_scaled {
                    for x in 0..self.w { dst[didx + x] = 0; }
                    didx += stride;
                }
            }
        }
    }
}

impl NADecoder for SmackerVideoDecoder {
    fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
        if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
            let w = vinfo.get_width();
            let h = vinfo.get_height();
            let fmt = PAL8_FORMAT;

            self.w = w;
            self.h = h;
            self.bw = w >> 2;
            self.bh = h >> 2;
            let edata = info.get_extradata().unwrap();
            validate!(edata.len() > 24);

            self.stride = w;
            self.frame.resize(w * h, 0);

            let mut mr = MemoryReader::new_read(&edata);
            let mut br = ByteReader::new(&mut mr);
            let magic                   = br.read_u32be()?;
            self.flags                  = br.read_u32le()?;
            let mmap_size               = br.read_u32le()?;
            let mclr_size               = br.read_u32le()?;
            let full_size               = br.read_u32le()?;
            let type_size               = br.read_u32le()?;

            self.is_ver4 = (magic & 0xFF) == 0x34;
            let mut br = BitReader::new(&edata[24..], BitReaderMode::LE);
            self.mmap_tree.decode(&mut br, mmap_size)?;
            self.mclr_tree.decode(&mut br, mclr_size)?;
            self.full_tree.decode(&mut br, full_size)?;
            self.type_tree.decode(&mut br, type_size)?;

            let mut out_h = h;
            if (self.flags & SMK_FLAG_INTERLACED) != 0 {
                out_h <<= 1;
            }
            if (self.flags & SMK_FLAG_SCALED) != 0 {
                out_h <<= 1;
            }
            let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, out_h, false, fmt));
            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

            Ok(())
        } else {
            Err(DecoderError::InvalidData)
        }
    }
    fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
        let src = pkt.get_buffer();
        validate!(src.len() >= PAL_SIZE);

        let is_intra;
        let ftype;
        let bufinfo;
        if src.len() > PAL_SIZE {
            let mut br = BitReader::new(&src[PAL_SIZE..], BitReaderMode::LE);

            bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 2)?;
            let mut buf = bufinfo.get_vbuf().unwrap();
            is_intra = self.decode_frame(&mut br)?;
            self.output_frame(&mut buf);
            let paloff = buf.get_offset(1);
            let data = buf.get_data_mut().unwrap();
            let dst = data.as_mut_slice();
            let palout = &mut dst[paloff..][..PAL_SIZE];
            palout.copy_from_slice(&src[0..PAL_SIZE]);
            ftype = if is_intra { FrameType::I } else { FrameType::P };
        } else {
            bufinfo  = NABufferType::None;
            ftype    = FrameType::Skip;
            is_intra = false;
        }

        let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
        frm.set_keyframe(is_intra);
        frm.set_frame_type(ftype);
        Ok(frm.into_ref())
    }
    fn flush(&mut self) {
    }
}

pub fn get_decoder_video() -> Box<dyn NADecoder + Send> {
    Box::new(SmackerVideoDecoder::new())
}

struct SmackerAudioDecoder {
    ainfo:      NAAudioInfo,
    chmap:      NAChannelMap,
    chans:      usize,
    bits:       u8,
}

impl SmackerAudioDecoder {
    fn new() -> Self {
        Self {
            ainfo:  NAAudioInfo::new(0, 1, SND_S16P_FORMAT, 0),
            chmap:  NAChannelMap::new(),
            chans:  0,
            bits:   0,
        }
    }
}

impl NADecoder for SmackerAudioDecoder {
    fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
        if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
            self.bits = ainfo.get_format().get_bits();
            let fmt = if self.bits == 8 { SND_U8_FORMAT } else { SND_S16P_FORMAT };
            self.chans = ainfo.get_channels() as usize;
            self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), ainfo.get_channels(), fmt, 0);
            self.chmap = NAChannelMap::from_str(if ainfo.get_channels() == 2 {"L,R"} else {"C"}).unwrap();
            Ok(())
        } else {
            Err(DecoderError::InvalidData)
        }
    }
    fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
        let info = pkt.get_stream().get_info();
        if let NACodecTypeInfo::Audio(_) = info.get_properties() {
            let src = pkt.get_buffer();
            validate!(src.len() > 4);
            let mut br = BitReader::new(&src, BitReaderMode::LE);
            let unp_size                        = br.read(32)? as usize;
            if !br.read_bool()? {
                let mut frm = NAFrame::new_from_pkt(pkt, info.clone(), NABufferType::None);
                frm.set_frame_type(FrameType::Skip);
                return Ok(frm.into_ref());
            }
            let stereo                          = br.read_bool()?;
            let bits16                          = br.read_bool()?;
            validate!(!(stereo ^ (self.chans == 2)));
            validate!(!(bits16 ^ (self.bits == 16)));

            let abuf;
            let samples;
            let nch = if stereo { 2 } else { 1 };
            if bits16 {
                samples = unp_size / 2 / nch;
                let mask = if stereo { 1 } else { 0 };
                let mut trees: [SmackerTree8; 4] = [SmackerTree8::new(), SmackerTree8::new(), SmackerTree8::new(), SmackerTree8::new()];
                for i in 0..nch*2 {
                    trees[i].decode(&mut br)?;
                }
                let mut pred: [i16; 2] = [0; 2];
                for i in 0..nch {
                    let hi                      = br.read(8)?;
                    let lo                      = br.read(8)?;
                    pred[nch - i - 1] = (lo | (hi << 8)) as i16;
                }

                abuf = alloc_audio_buffer(self.ainfo, samples, self.chmap.clone())?;
                let mut adata = abuf.get_abuf_i16().unwrap();
                let offs: [usize; 2] = [0, adata.get_offset(1)];
                let dst = adata.get_data_mut().unwrap();
                for ch in 0..nch {
                    dst[offs[ch]] = pred[ch];
                }
                for i in nch..(unp_size >> 1) {
                    let idx = i & mask;
                    let lo                      = br.read_tree8(&trees[idx * 2 + 0])? as u16;
                    let hi                      = br.read_tree8(&trees[idx * 2 + 1])? as u16;
                    let diff = (lo | (hi << 8)) as i16;
                    pred[idx] = pred[idx].wrapping_add(diff);
                    dst[offs[idx] + (i >> 1)] = pred[idx];
                }
            } else {
                samples = unp_size / nch;
                abuf = alloc_audio_buffer(self.ainfo, samples, self.chmap.clone())?;
                let mut adata = abuf.get_abuf_u8().unwrap();
                let dst = adata.get_data_mut().unwrap();
                if stereo {
                    let mut trees: [SmackerTree8; 2] = [SmackerTree8::new(), SmackerTree8::new()];
                    trees[0].decode(&mut br)?;
                    trees[1].decode(&mut br)?;
                    let pred0                   = br.read(8)? as u8;
                    let pred1                   = br.read(8)? as u8;
                    let mut pred: [u8; 2] = [ pred1, pred0 ];
                    for ch in 0..2 { dst[ch] = pred[ch]; }
                    for i in 2..unp_size {
                        let diff = br.read_tree8(&trees[i & 1])? as u8;
                        pred[i & 1] = pred[i & 1].wrapping_add(diff);
                        dst[i] = pred[i & 1];
                    }
                } else {
                    let mut tree = SmackerTree8::new();
                    tree.decode(&mut br)?;
                    let mut pred                = br.read(8)? as u8;
                    dst[0] = pred;
                    for i in 1..unp_size {
                        let diff = br.read_tree8(&tree)? as u8;
                        pred = pred.wrapping_add(diff);
                        dst[i] = pred;
                    }
                }
            }
            let mut frm = NAFrame::new_from_pkt(pkt, info, abuf);
            frm.set_duration(Some(samples as u64));
            frm.set_keyframe(false);
            Ok(frm.into_ref())
        } else {
            Err(DecoderError::InvalidData)
        }
    }
    fn flush(&mut self) {
    }
}

pub fn get_decoder_audio() -> Box<dyn NADecoder + Send> {
    Box::new(SmackerAudioDecoder::new())
}

#[cfg(test)]
mod test {
    use nihav_core::codecs::RegisteredDecoders;
    use nihav_core::demuxers::RegisteredDemuxers;
    use nihav_core::test::dec_video::*;
    use crate::rad_register_all_codecs;
    use crate::rad_register_all_demuxers;
    #[test]
    fn test_smkvid() {
        let mut dmx_reg = RegisteredDemuxers::new();
        rad_register_all_demuxers(&mut dmx_reg);
        let mut dec_reg = RegisteredDecoders::new();
        rad_register_all_codecs(&mut dec_reg);

        //let file = "assets/RAD/20130507_audio-distortion.smk";
        //let file = "assets/RAD/ajfstr1.smk";
        //let file = "assets/RAD/credits.smk";
        let file = "assets/RAD/wetlogo.smk";
        test_file_decoding("smacker", file, Some(1000), true, false, None, &dmx_reg, &dec_reg);
    }
    #[test]
    fn test_smkaud() {
        let mut dmx_reg = RegisteredDemuxers::new();
        rad_register_all_demuxers(&mut dmx_reg);
        let mut dec_reg = RegisteredDecoders::new();
        rad_register_all_codecs(&mut dec_reg);

        //let file = "assets/RAD/20130507_audio-distortion.smk";
        let file = "assets/RAD/wetlogo.smk";
        test_decode_audio("smacker", file, None, None/*Some("smk")*/, &dmx_reg, &dec_reg);
    }
}
Commit	Line	Data
606c448e KS	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() {
af37e28a KS	163	if self.last[i] != SMK_LAST_UNINIT {
	164	self.tree[self.last[i]] = 0;
	165	}
606c448e KS	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 {
2422d969	213	info: NACodecInfoRef,
606c448e KS	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 {
606c448e	230	Self {
2422d969	231	info: NACodecInfoRef::default(),
606c448e KS	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);
1a967e6b	363	let data = buf.get_data_mut().unwrap();
606c448e KS	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 {
01613464	390	fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
606c448e KS	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;
fa90ccfb	416	let mut br = BitReader::new(&edata[24..], BitReaderMode::LE);
606c448e KS	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));
2422d969	430	self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
606c448e KS	431
	432	Ok(())
	433	} else {
	434	Err(DecoderError::InvalidData)
	435	}
	436	}
01613464	437	fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
606c448e KS	438	let src = pkt.get_buffer();
	439	validate!(src.len() >= PAL_SIZE);
	440
	441	let is_intra;
	442	let ftype;
b70cc006	443	let bufinfo;
606c448e	444	if src.len() > PAL_SIZE {
fa90ccfb	445	let mut br = BitReader::new(&src[PAL_SIZE..], BitReaderMode::LE);
606c448e	446
7e6086e5	447	bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 2)?;
606c448e KS	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);
1a967e6b	452	let data = buf.get_data_mut().unwrap();
606c448e KS	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);
171860fc	466	Ok(frm.into_ref())
606c448e	467	}
f9be4e75 KS	468	fn flush(&mut self) {
f9be4e75 KS	469	}
606c448e KS	470	}
606c448e KS	471
08a1fab7	472	pub fn get_decoder_video() -> Box<dyn NADecoder + Send> {
606c448e KS	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 {
01613464	495	fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
606c448e KS	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_S16P_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	}
01613464	507	fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
606c448e KS	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);
fa90ccfb	512	let mut br = BitReader::new(&src, BitReaderMode::LE);
606c448e KS	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);
171860fc	517	return Ok(frm.into_ref());
606c448e KS	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
b70cc006	524	let abuf;
606c448e KS	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 offs: [usize; 2] = [0, adata.get_offset(1)];
1a967e6b	544	let dst = adata.get_data_mut().unwrap();
606c448e KS	545	for ch in 0..nch {
	546	dst[offs[ch]] = pred[ch];
	547	}
	548	for i in nch..(unp_size >> 1) {
	549	let idx = i & mask;
	550	let lo = br.read_tree8(&trees[idx * 2 + 0])? as u16;
	551	let hi = br.read_tree8(&trees[idx * 2 + 1])? as u16;
	552	let diff = (lo \| (hi << 8)) as i16;
	553	pred[idx] = pred[idx].wrapping_add(diff);
	554	dst[offs[idx] + (i >> 1)] = pred[idx];
	555	}
	556	} else {
	557	samples = unp_size / nch;
	558	abuf = alloc_audio_buffer(self.ainfo, samples, self.chmap.clone())?;
	559	let mut adata = abuf.get_abuf_u8().unwrap();
1a967e6b	560	let dst = adata.get_data_mut().unwrap();
606c448e KS	561	if stereo {
	562	let mut trees: [SmackerTree8; 2] = [SmackerTree8::new(), SmackerTree8::new()];
	563	trees[0].decode(&mut br)?;
	564	trees[1].decode(&mut br)?;
	565	let pred0 = br.read(8)? as u8;
	566	let pred1 = br.read(8)? as u8;
	567	let mut pred: [u8; 2] = [ pred1, pred0 ];
	568	for ch in 0..2 { dst[ch] = pred[ch]; }
	569	for i in 2..unp_size {
	570	let diff = br.read_tree8(&trees[i & 1])? as u8;
	571	pred[i & 1] = pred[i & 1].wrapping_add(diff);
	572	dst[i] = pred[i & 1];
	573	}
	574	} else {
	575	let mut tree = SmackerTree8::new();
	576	tree.decode(&mut br)?;
	577	let mut pred = br.read(8)? as u8;
	578	dst[0] = pred;
	579	for i in 1..unp_size {
	580	let diff = br.read_tree8(&tree)? as u8;
	581	pred = pred.wrapping_add(diff);
	582	dst[i] = pred;
	583	}
	584	}
	585	}
	586	let mut frm = NAFrame::new_from_pkt(pkt, info, abuf);
	587	frm.set_duration(Some(samples as u64));
	588	frm.set_keyframe(false);
171860fc	589	Ok(frm.into_ref())
606c448e KS	590	} else {
	591	Err(DecoderError::InvalidData)
	592	}
	593	}
f9be4e75 KS	594	fn flush(&mut self) {
f9be4e75 KS	595	}
606c448e KS	596	}
606c448e KS	597
08a1fab7	598	pub fn get_decoder_audio() -> Box<dyn NADecoder + Send> {
606c448e KS	599	Box::new(SmackerAudioDecoder::new())
	600	}
	601
	602	#[cfg(test)]
	603	mod test {
	604	use nihav_core::codecs::RegisteredDecoders;
	605	use nihav_core::demuxers::RegisteredDemuxers;
	606	use nihav_core::test::dec_video::*;
e64739f8 KS	607	use crate::rad_register_all_codecs;
e64739f8 KS	608	use crate::rad_register_all_demuxers;
606c448e KS	609	#[test]
	610	fn test_smkvid() {
	611	let mut dmx_reg = RegisteredDemuxers::new();
	612	rad_register_all_demuxers(&mut dmx_reg);
	613	let mut dec_reg = RegisteredDecoders::new();
	614	rad_register_all_codecs(&mut dec_reg);
	615
	616	//let file = "assets/RAD/20130507_audio-distortion.smk";
	617	//let file = "assets/RAD/ajfstr1.smk";
	618	//let file = "assets/RAD/credits.smk";
	619	let file = "assets/RAD/wetlogo.smk";
	620	test_file_decoding("smacker", file, Some(1000), true, false, None, &dmx_reg, &dec_reg);
	621	}
	622	#[test]
	623	fn test_smkaud() {
	624	let mut dmx_reg = RegisteredDemuxers::new();
	625	rad_register_all_demuxers(&mut dmx_reg);
	626	let mut dec_reg = RegisteredDecoders::new();
	627	rad_register_all_codecs(&mut dec_reg);
	628
	629	//let file = "assets/RAD/20130507_audio-distortion.smk";
	630	let file = "assets/RAD/wetlogo.smk";
5580b11b	631	test_decode_audio("smacker", file, None, None/Some("smk")/, &dmx_reg, &dec_reg);
606c448e KS	632	}
606c448e KS	633	}