1 use nihav_core::codecs::*;
2 use nihav_core::io::byteio::*;
3 use nihav_core::io::bitreader::*;
4 use nihav_core::io::codebook::*;
7 const PAL_SIZE: usize = 768;
8 const SMK_FLAG_INTERLACED: u32 = 0x02;
9 const SMK_FLAG_SCALED: u32 = 0x04;
12 cb: Option<Codebook<u8>>,
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<()> {
19 codes[*count] = prefix;
20 syms[*count] = br.read(8)? as u8;
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))?;
30 pub struct FullTableCodebookDescReader<'a> {
36 impl<'a> FullTableCodebookDescReader<'a> {
37 pub fn new(codes: &'a [u32], bits: &'a [u8], syms: &'a [u8]) -> Self {
38 Self { bits, codes, syms }
41 impl<'a> CodebookDescReader<u8> for FullTableCodebookDescReader<'a>
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() }
56 fn decode(&mut self, br: &mut BitReader) -> DecoderResult<()> {
57 if !br.read_bool()? { return Ok(()); }
59 let mut bits: [u8; 256] = [0; 256];
60 let mut codes: [u32; 256] = [0; 256];
61 let mut syms: [u8; 256] = [0; 256];
64 get_tree8(br, &mut bits, &mut codes, &mut syms, &mut count, 0, 0)?;
65 validate!(!br.read_bool()?);
68 let mut cr = FullTableCodebookDescReader::new(&codes[0..count], &bits[0..count], &syms[0..count]);
69 let cb = Codebook::new(&mut cr, CodebookMode::LSB)?;
72 self.defsym = syms[0];
79 struct SmackerTree16 {
84 struct SmackerTree16Builder {
85 tree_lo: SmackerTree8,
86 tree_hi: SmackerTree8,
91 const SMK_BIGTREE_NODE: u32 = 0x80000000;
92 const SMK_LAST_UNINIT: usize = 0xFFFFFFFF;
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);
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();
104 } else if sym == self.esc[1] {
105 tree.last[1] = tree.tree.len();
107 } else if sym == self.esc[2] {
108 tree.last[2] = tree.tree.len();
114 let cur_idx = tree.tree.len();
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)
128 last: [SMK_LAST_UNINIT; 3],
131 fn decode(&mut self, br: &mut BitReader, size: u32) -> DecoderResult<()> {
132 if !br.read_bool()? { return Ok(()); }
134 let mut tree_lo = SmackerTree8::new();
136 let mut tree_hi = SmackerTree8::new();
139 let mut esc: [u32; 3] = [0; 3];
140 for i in 0..esc.len() {
141 esc[i] = br.read(16)? as u32;
144 let nsyms = (((size + 3) >> 2) + 4) as usize;
145 self.tree = Vec::with_capacity(nsyms);
147 let mut tb = SmackerTree16Builder { tree_lo, tree_hi, nsyms, esc };
149 tb.get_tree16(br, self, 0)?;
150 validate!(!br.read_bool()?);
152 for i in 0..self.last.len() {
153 if self.last[i] == SMK_LAST_UNINIT {
154 self.last[i] = self.tree.len();
158 validate!(self.tree.len() <= nsyms);
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;
171 fn read_tree8(&mut self, tree: &SmackerTree8) -> DecoderResult<u8>;
172 fn read_bigtree(&mut self, tree: &mut SmackerTree16) -> DecoderResult<u16>;
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)?)
183 fn read_bigtree(&mut self, tree: &mut SmackerTree16) -> DecoderResult<u16> {
185 while (tree.tree[pos] & SMK_BIGTREE_NODE) != 0 {
186 if self.read_bool()? {
187 pos += (tree.tree[pos] & !SMK_BIGTREE_NODE) as usize;
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;
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
212 struct SmackerVideoDecoder {
213 info: Rc<NACodecInfo>,
214 mmap_tree: SmackerTree16,
215 mclr_tree: SmackerTree16,
216 full_tree: SmackerTree16,
217 type_tree: SmackerTree16,
228 impl SmackerVideoDecoder {
230 let dummy_info = Rc::new(DUMMY_CODEC_INFO);
233 mmap_tree: SmackerTree16::new(),
234 mclr_tree: SmackerTree16::new(),
235 full_tree: SmackerTree16::new(),
236 type_tree: SmackerTree16::new(),
247 fn block_pos(&self, blk_no: usize) -> usize {
248 let bx = blk_no % self.bw;
249 let by = blk_no / self.bw;
250 bx * 4 + by * 4 * self.stride
252 fn decode_frame(&mut self, br: &mut BitReader) -> DecoderResult<bool> {
253 let mut is_intra = true;
254 let blocks = self.bw * self.bh;
256 self.mmap_tree.reset();
257 self.mclr_tree.reset();
258 self.full_tree.reset();
259 self.type_tree.reset();
262 while block < blocks {
263 let btype = br.read_bigtree(&mut self.type_tree)?;
264 let run = SMK_BLOCK_RUNS[((btype as usize) >> 2) & 0x3F];
265 validate!(run <= blocks - block);
267 0 => { // two-colour pattern
269 let clr = br.read_bigtree(&mut self.mclr_tree)?;
270 let mut map = br.read_bigtree(&mut self.mmap_tree)?;
271 let hi = (clr >> 8) as u8;
272 let lo = (clr & 0xFF) as u8;
273 let mut doff = self.block_pos(block + i);
275 self.frame[doff + 0] = if (map & 1) != 0 { hi } else { lo };
276 self.frame[doff + 1] = if (map & 2) != 0 { hi } else { lo };
277 self.frame[doff + 2] = if (map & 4) != 0 { hi } else { lo };
278 self.frame[doff + 3] = if (map & 8) != 0 { hi } else { lo };
286 if !self.is_ver4 || !br.read_bool()? {
289 mode = 1 + br.read(1)?;
292 let mut doff = self.block_pos(block + i);
296 let clr0 = br.read_bigtree(&mut self.full_tree)?;
297 let clr1 = br.read_bigtree(&mut self.full_tree)?;
298 self.frame[doff + 0] = (clr1 & 0xFF) as u8;
299 self.frame[doff + 1] = (clr1 >> 8) as u8;
300 self.frame[doff + 2] = (clr0 & 0xFF) as u8;
301 self.frame[doff + 3] = (clr0 >> 8) as u8;
307 let clr = br.read_bigtree(&mut self.full_tree)?;
308 self.frame[doff + 0] = (clr & 0xFF) as u8;
309 self.frame[doff + 1] = (clr & 0xFF) as u8;
310 self.frame[doff + 2] = (clr >> 8) as u8;
311 self.frame[doff + 3] = (clr >> 8) as u8;
313 self.frame[doff + 0] = (clr & 0xFF) as u8;
314 self.frame[doff + 1] = (clr & 0xFF) as u8;
315 self.frame[doff + 2] = (clr >> 8) as u8;
316 self.frame[doff + 3] = (clr >> 8) as u8;
322 let clr0 = br.read_bigtree(&mut self.full_tree)?;
323 let clr1 = br.read_bigtree(&mut self.full_tree)?;
324 self.frame[doff + 0] = (clr1 & 0xFF) as u8;
325 self.frame[doff + 1] = (clr1 >> 8) as u8;
326 self.frame[doff + 2] = (clr0 & 0xFF) as u8;
327 self.frame[doff + 3] = (clr0 >> 8) as u8;
329 self.frame[doff + 0] = (clr1 & 0xFF) as u8;
330 self.frame[doff + 1] = (clr1 >> 8) as u8;
331 self.frame[doff + 2] = (clr0 & 0xFF) as u8;
332 self.frame[doff + 3] = (clr0 >> 8) as u8;
344 let clr = (btype >> 8) as u8;
346 let mut doff = self.block_pos(block + i);
348 self.frame[doff + 0] = clr;
349 self.frame[doff + 1] = clr;
350 self.frame[doff + 2] = clr;
351 self.frame[doff + 3] = clr;
362 fn output_frame(&self, buf: &mut NAVideoBuffer<u8>) {
363 let stride = buf.get_stride(0);
364 let mut data = buf.get_data_mut();
365 let dst = data.as_mut_slice();
366 let is_scaled = (self.flags & SMK_FLAG_SCALED) != 0;
367 let is_interlaced = (self.flags & SMK_FLAG_INTERLACED) != 0;
371 for x in 0..self.w { dst[didx + x] = self.frame[sidx + x]; }
375 for x in 0..self.w { dst[didx + x] = dst[didx - stride + x]; }
379 for x in 0..self.w { dst[didx + x] = 0; }
382 for x in 0..self.w { dst[didx + x] = 0; }
390 impl NADecoder for SmackerVideoDecoder {
391 fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
392 if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
393 let w = vinfo.get_width();
394 let h = vinfo.get_height();
395 let fmt = PAL8_FORMAT;
401 let edata = info.get_extradata().unwrap();
402 validate!(edata.len() > 24);
405 self.frame.resize(w * h, 0);
407 let mut mr = MemoryReader::new_read(&edata);
408 let mut br = ByteReader::new(&mut mr);
409 let magic = br.read_u32be()?;
410 self.flags = br.read_u32le()?;
411 let mmap_size = br.read_u32le()?;
412 let mclr_size = br.read_u32le()?;
413 let full_size = br.read_u32le()?;
414 let type_size = br.read_u32le()?;
416 self.is_ver4 = (magic & 0xFF) == 0x34;
417 let mut br = BitReader::new(&edata[24..], edata.len() - 24, BitReaderMode::LE);
418 self.mmap_tree.decode(&mut br, mmap_size)?;
419 self.mclr_tree.decode(&mut br, mclr_size)?;
420 self.full_tree.decode(&mut br, full_size)?;
421 self.type_tree.decode(&mut br, type_size)?;
424 if (self.flags & SMK_FLAG_INTERLACED) != 0 {
427 if (self.flags & SMK_FLAG_SCALED) != 0 {
430 let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, out_h, false, fmt));
431 self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
436 Err(DecoderError::InvalidData)
439 fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
440 let src = pkt.get_buffer();
441 validate!(src.len() >= PAL_SIZE);
446 if src.len() > PAL_SIZE {
447 let mut br = BitReader::new(&src[PAL_SIZE..], src.len() - PAL_SIZE, BitReaderMode::LE);
449 let bufret = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 2);
450 if let Err(_) = bufret { return Err(DecoderError::InvalidData); }
451 bufinfo = bufret.unwrap();
452 let mut buf = bufinfo.get_vbuf().unwrap();
453 is_intra = self.decode_frame(&mut br)?;
454 self.output_frame(&mut buf);
455 let paloff = buf.get_offset(1);
456 let mut data = buf.get_data_mut();
457 let dst = data.as_mut_slice();
458 let palout = &mut dst[paloff..][..PAL_SIZE];
459 palout.copy_from_slice(&src[0..PAL_SIZE]);
460 ftype = if is_intra { FrameType::I } else { FrameType::P };
462 bufinfo = NABufferType::None;
463 ftype = FrameType::Skip;
467 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
468 frm.set_keyframe(is_intra);
469 frm.set_frame_type(ftype);
470 Ok(Rc::new(RefCell::new(frm)))
474 pub fn get_decoder_video() -> Box<NADecoder> {
475 Box::new(SmackerVideoDecoder::new())
478 struct SmackerAudioDecoder {
485 impl SmackerAudioDecoder {
488 ainfo: NAAudioInfo::new(0, 1, SND_S16P_FORMAT, 0),
489 chmap: NAChannelMap::new(),
496 impl NADecoder for SmackerAudioDecoder {
497 fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
498 if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
499 self.bits = ainfo.get_format().get_bits();
500 let fmt = if self.bits == 8 { SND_U8_FORMAT } else { SND_S16P_FORMAT };
501 self.chans = ainfo.get_channels() as usize;
502 self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), ainfo.get_channels(), fmt, 0);
503 self.chmap = NAChannelMap::from_str(if ainfo.get_channels() == 2 {"L,R"} else {"C"}).unwrap();
506 Err(DecoderError::InvalidData)
509 fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
510 let info = pkt.get_stream().get_info();
511 if let NACodecTypeInfo::Audio(_) = info.get_properties() {
512 let src = pkt.get_buffer();
513 validate!(src.len() > 4);
514 let mut br = BitReader::new(&src, src.len(), BitReaderMode::LE);
515 let unp_size = br.read(32)? as usize;
516 if !br.read_bool()? {
517 let mut frm = NAFrame::new_from_pkt(pkt, info.clone(), NABufferType::None);
518 frm.set_frame_type(FrameType::Skip);
519 return Ok(Rc::new(RefCell::new(frm)));
521 let stereo = br.read_bool()?;
522 let bits16 = br.read_bool()?;
523 validate!(!(stereo ^ (self.chans == 2)));
524 validate!(!(bits16 ^ (self.bits == 16)));
528 let nch = if stereo { 2 } else { 1 };
530 samples = unp_size / 2 / nch;
531 let mask = if stereo { 1 } else { 0 };
532 let mut trees: [SmackerTree8; 4] = [SmackerTree8::new(), SmackerTree8::new(), SmackerTree8::new(), SmackerTree8::new()];
534 trees[i].decode(&mut br)?;
536 let mut pred: [i16; 2] = [0; 2];
538 let hi = br.read(8)?;
539 let lo = br.read(8)?;
540 pred[nch - i - 1] = (lo | (hi << 8)) as i16;
543 abuf = alloc_audio_buffer(self.ainfo, samples, self.chmap.clone())?;
544 let mut adata = abuf.get_abuf_i16().unwrap();
545 let offs: [usize; 2] = [0, adata.get_offset(1)];
546 let mut dst = adata.get_data_mut();
548 dst[offs[ch]] = pred[ch];
550 for i in nch..(unp_size >> 1) {
552 let lo = br.read_tree8(&trees[idx * 2 + 0])? as u16;
553 let hi = br.read_tree8(&trees[idx * 2 + 1])? as u16;
554 let diff = (lo | (hi << 8)) as i16;
555 pred[idx] = pred[idx].wrapping_add(diff);
556 dst[offs[idx] + (i >> 1)] = pred[idx];
559 samples = unp_size / nch;
560 abuf = alloc_audio_buffer(self.ainfo, samples, self.chmap.clone())?;
561 let mut adata = abuf.get_abuf_u8().unwrap();
562 let mut dst = adata.get_data_mut();
564 let mut trees: [SmackerTree8; 2] = [SmackerTree8::new(), SmackerTree8::new()];
565 trees[0].decode(&mut br)?;
566 trees[1].decode(&mut br)?;
567 let pred0 = br.read(8)? as u8;
568 let pred1 = br.read(8)? as u8;
569 let mut pred: [u8; 2] = [ pred1, pred0 ];
570 for ch in 0..2 { dst[ch] = pred[ch]; }
571 for i in 2..unp_size {
572 let diff = br.read_tree8(&trees[i & 1])? as u8;
573 pred[i & 1] = pred[i & 1].wrapping_add(diff);
574 dst[i] = pred[i & 1];
577 let mut tree = SmackerTree8::new();
578 tree.decode(&mut br)?;
579 let mut pred = br.read(8)? as u8;
581 for i in 1..unp_size {
582 let diff = br.read_tree8(&tree)? as u8;
583 pred = pred.wrapping_add(diff);
588 let mut frm = NAFrame::new_from_pkt(pkt, info, abuf);
589 frm.set_duration(Some(samples as u64));
590 frm.set_keyframe(false);
591 Ok(Rc::new(RefCell::new(frm)))
593 Err(DecoderError::InvalidData)
598 pub fn get_decoder_audio() -> Box<NADecoder> {
599 Box::new(SmackerAudioDecoder::new())
604 use nihav_core::codecs::RegisteredDecoders;
605 use nihav_core::demuxers::RegisteredDemuxers;
606 use nihav_core::test::dec_video::*;
607 use crate::codecs::rad_register_all_codecs;
608 use crate::demuxers::rad_register_all_demuxers;
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);
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);
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);
629 //let file = "assets/RAD/20130507_audio-distortion.smk";
630 let file = "assets/RAD/wetlogo.smk";
631 test_decode_audio("smacker", file, None, "smk", &dmx_reg, &dec_reg);