[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..], edata.len() - 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..], src.len() - 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())
    }
}

pub fn get_decoder_video() -> Box<dyn NADecoder> {
    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, src.len(), 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)
        }
    }
}

pub fn get_decoder_audio() -> Box<dyn NADecoder> {
    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::codecs::rad_register_all_codecs;
    use crate::demuxers::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, "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;
	416	let mut br = BitReader::new(&edata[24..], edata.len() - 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));
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 KS	444	if src.len() > PAL_SIZE {
	445	let mut br = BitReader::new(&src[PAL_SIZE..], src.len() - PAL_SIZE, BitReaderMode::LE);
	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 KS	467	}
	468	}
	469
6011e201	470	pub fn get_decoder_video() -> Box<dyn NADecoder> {
606c448e KS	471	Box::new(SmackerVideoDecoder::new())
	472	}
	473
	474	struct SmackerAudioDecoder {
	475	ainfo: NAAudioInfo,
	476	chmap: NAChannelMap,
	477	chans: usize,
	478	bits: u8,
	479	}
	480
	481	impl SmackerAudioDecoder {
	482	fn new() -> Self {
	483	Self {
	484	ainfo: NAAudioInfo::new(0, 1, SND_S16P_FORMAT, 0),
	485	chmap: NAChannelMap::new(),
	486	chans: 0,
	487	bits: 0,
	488	}
	489	}
	490	}
	491
	492	impl NADecoder for SmackerAudioDecoder {
01613464	493	fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
606c448e KS	494	if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
	495	self.bits = ainfo.get_format().get_bits();
	496	let fmt = if self.bits == 8 { SND_U8_FORMAT } else { SND_S16P_FORMAT };
	497	self.chans = ainfo.get_channels() as usize;
	498	self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), ainfo.get_channels(), fmt, 0);
	499	self.chmap = NAChannelMap::from_str(if ainfo.get_channels() == 2 {"L,R"} else {"C"}).unwrap();
	500	Ok(())
	501	} else {
	502	Err(DecoderError::InvalidData)
	503	}
	504	}
01613464	505	fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
606c448e KS	506	let info = pkt.get_stream().get_info();
	507	if let NACodecTypeInfo::Audio(_) = info.get_properties() {
	508	let src = pkt.get_buffer();
	509	validate!(src.len() > 4);
	510	let mut br = BitReader::new(&src, src.len(), BitReaderMode::LE);
	511	let unp_size = br.read(32)? as usize;
	512	if !br.read_bool()? {
	513	let mut frm = NAFrame::new_from_pkt(pkt, info.clone(), NABufferType::None);
	514	frm.set_frame_type(FrameType::Skip);
171860fc	515	return Ok(frm.into_ref());
606c448e KS	516	}
	517	let stereo = br.read_bool()?;
	518	let bits16 = br.read_bool()?;
	519	validate!(!(stereo ^ (self.chans == 2)));
	520	validate!(!(bits16 ^ (self.bits == 16)));
	521
b70cc006	522	let abuf;
606c448e KS	523	let samples;
	524	let nch = if stereo { 2 } else { 1 };
	525	if bits16 {
	526	samples = unp_size / 2 / nch;
	527	let mask = if stereo { 1 } else { 0 };
	528	let mut trees: [SmackerTree8; 4] = [SmackerTree8::new(), SmackerTree8::new(), SmackerTree8::new(), SmackerTree8::new()];
	529	for i in 0..nch*2 {
	530	trees[i].decode(&mut br)?;
	531	}
	532	let mut pred: [i16; 2] = [0; 2];
	533	for i in 0..nch {
	534	let hi = br.read(8)?;
	535	let lo = br.read(8)?;
	536	pred[nch - i - 1] = (lo \| (hi << 8)) as i16;
	537	}
	538
	539	abuf = alloc_audio_buffer(self.ainfo, samples, self.chmap.clone())?;
	540	let mut adata = abuf.get_abuf_i16().unwrap();
	541	let offs: [usize; 2] = [0, adata.get_offset(1)];
1a967e6b	542	let dst = adata.get_data_mut().unwrap();
606c448e KS	543	for ch in 0..nch {
	544	dst[offs[ch]] = pred[ch];
	545	}
	546	for i in nch..(unp_size >> 1) {
	547	let idx = i & mask;
	548	let lo = br.read_tree8(&trees[idx * 2 + 0])? as u16;
	549	let hi = br.read_tree8(&trees[idx * 2 + 1])? as u16;
	550	let diff = (lo \| (hi << 8)) as i16;
	551	pred[idx] = pred[idx].wrapping_add(diff);
	552	dst[offs[idx] + (i >> 1)] = pred[idx];
	553	}
	554	} else {
	555	samples = unp_size / nch;
	556	abuf = alloc_audio_buffer(self.ainfo, samples, self.chmap.clone())?;
	557	let mut adata = abuf.get_abuf_u8().unwrap();
1a967e6b	558	let dst = adata.get_data_mut().unwrap();
606c448e KS	559	if stereo {
	560	let mut trees: [SmackerTree8; 2] = [SmackerTree8::new(), SmackerTree8::new()];
	561	trees[0].decode(&mut br)?;
	562	trees[1].decode(&mut br)?;
	563	let pred0 = br.read(8)? as u8;
	564	let pred1 = br.read(8)? as u8;
	565	let mut pred: [u8; 2] = [ pred1, pred0 ];
	566	for ch in 0..2 { dst[ch] = pred[ch]; }
	567	for i in 2..unp_size {
	568	let diff = br.read_tree8(&trees[i & 1])? as u8;
	569	pred[i & 1] = pred[i & 1].wrapping_add(diff);
	570	dst[i] = pred[i & 1];
	571	}
	572	} else {
	573	let mut tree = SmackerTree8::new();
	574	tree.decode(&mut br)?;
	575	let mut pred = br.read(8)? as u8;
	576	dst[0] = pred;
	577	for i in 1..unp_size {
	578	let diff = br.read_tree8(&tree)? as u8;
	579	pred = pred.wrapping_add(diff);
	580	dst[i] = pred;
	581	}
	582	}
	583	}
	584	let mut frm = NAFrame::new_from_pkt(pkt, info, abuf);
	585	frm.set_duration(Some(samples as u64));
	586	frm.set_keyframe(false);
171860fc	587	Ok(frm.into_ref())
606c448e KS	588	} else {
	589	Err(DecoderError::InvalidData)
	590	}
	591	}
	592	}
	593
6011e201	594	pub fn get_decoder_audio() -> Box<dyn NADecoder> {
606c448e KS	595	Box::new(SmackerAudioDecoder::new())
	596	}
	597
	598	#[cfg(test)]
	599	mod test {
	600	use nihav_core::codecs::RegisteredDecoders;
	601	use nihav_core::demuxers::RegisteredDemuxers;
	602	use nihav_core::test::dec_video::*;
	603	use crate::codecs::rad_register_all_codecs;
	604	use crate::demuxers::rad_register_all_demuxers;
	605	#[test]
	606	fn test_smkvid() {
	607	let mut dmx_reg = RegisteredDemuxers::new();
	608	rad_register_all_demuxers(&mut dmx_reg);
	609	let mut dec_reg = RegisteredDecoders::new();
	610	rad_register_all_codecs(&mut dec_reg);
	611
	612	//let file = "assets/RAD/20130507_audio-distortion.smk";
	613	//let file = "assets/RAD/ajfstr1.smk";
	614	//let file = "assets/RAD/credits.smk";
	615	let file = "assets/RAD/wetlogo.smk";
	616	test_file_decoding("smacker", file, Some(1000), true, false, None, &dmx_reg, &dec_reg);
	617	}
	618	#[test]
	619	fn test_smkaud() {
	620	let mut dmx_reg = RegisteredDemuxers::new();
	621	rad_register_all_demuxers(&mut dmx_reg);
	622	let mut dec_reg = RegisteredDecoders::new();
	623	rad_register_all_codecs(&mut dec_reg);
	624
	625	//let file = "assets/RAD/20130507_audio-distortion.smk";
	626	let file = "assets/RAD/wetlogo.smk";
	627	test_decode_audio("smacker", file, None, "smk", &dmx_reg, &dec_reg);
	628	}
	629	}