use nihav_core::io::byteio::*;
use nihav_core::io::bitreader::*;
use nihav_core::io::codebook::*;
+use nihav_codec_support::codecs::{IPShuffler, HAMShuffler};
const SKIP_BLOCK: u8 = 0;
const SCALED_BLOCK: u8 = 1;
if br.read_bool()? {
let len = br.read(3)? as usize;
let mut present: [bool; 16] = [false; 16];
- for i in 0..len+1 {
+ for i in 0..=len {
self.syms[i] = br.read(4)? as u8;
present[self.syms[i] as usize] = true;
}
let len = br.read(2)? as usize;
let mut syms: [u8; 16] = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
let mut tmp: [u8; 16] = [0; 16];
- for bits in 0..len+1 {
+ for bits in 0..=len {
let size = 1 << bits;
for arr in syms.chunks_mut(size * 2) {
let mut ptr0 = 0;
self.dec_pos = self.data.len();
self.read_pos = self.data.len() - 1;
}
-println!(" read {} of {} bits", len, self.bits);
Ok(len)
}
fn get_val(&mut self) -> DecoderResult<T> {
self.run.data.resize(size, 0);
}
fn init_bundle_lengths(&mut self, w: usize, bw: usize) {
+ let w = (w + 7) & !7;
self.btype.bits = calc_len(w >> 3);
self.sbtype.bits = calc_len(w >> 4);
self.colors.bits = calc_len(bw * 64);
}
fn read_bundles_binkb(&mut self, br: &mut BitReader) -> DecoderResult<()> {
self.btype.read_binkb(br)?;
-println!(" @ {}", br.tell());
self.colors.read_binkb(br)?;
-println!(" @ {}", br.tell());
self.pattern.read_binkb(br)?;
-println!(" @ {}", br.tell());
self.xoff.read_binkb(br)?;
-println!(" @ {}", br.tell());
self.yoff.read_binkb(br)?;
-println!(" @ {}", br.tell());
self.intradc.read_binkb(br)?;
-println!(" @ {}", br.tell());
self.interdc.read_binkb(br)?;
-println!(" @ {}", br.tell());
self.intraq.read_binkb(br)?;
-println!(" @ {}", br.tell());
self.interq.read_binkb(br)?;
-println!(" @ {}", br.tell());
self.nresidues.read_binkb(br)?;
-println!(" @ {}", br.tell());
Ok(())
}
fn read_bundles(&mut self, br: &mut BitReader) -> DecoderResult<()> {
let ybias = if self.key_frame { -15 } else { 0 };
let yoff = yoff1 + ybias;
-println!(" copy from {}.{} + {},{}({})", bx*8, by*8, xoff, yoff, ybias);
let xpos = ((bx * 8) as isize) + (xoff as isize);
let ypos = ((by * 8) as isize) + (yoff as isize);
validate!((xpos >= 0) && (xpos + 8 <= (self.cur_w as isize)));
self.cur_h = (height + 7) & !7;
self.cur_plane = plane_no;
self.init_bundle_lengths_binkb();
-println!(" plane {}", plane_no);
for by in 0..bh {
self.read_bundles_binkb(br)?;
-println!(" bline {} @ {}", by, br.tell());
for bx in 0..bw {
let mut coeffs: [i32; 64] = [0; 64];
let btype = self.btype.get_val()?;
-println!(" blk {}.{} type {}", bx,by,btype);
match btype {
0 => { // skip
},
let q_index = if let Some(qidx) = q { qidx } else { br.read(4)? as usize };
let qmat = &quant_matrices[q_index];
block[0] = block[0].wrapping_mul(qmat[0]) >> 11;
- for idx in coef_idx.into_iter().take(coef_count) {
+ for idx in coef_idx.iter().take(coef_count) {
block[scan[*idx]] = block[scan[*idx]].wrapping_mul(qmat[*idx]) >> 11;
}
}
mask >>= 1;
}
-
+
Ok(())
}
const BINK_FLAG_GRAY: u32 = 0x00020000;
impl NADecoder for BinkDecoder {
- fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {
+ 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();
Err(DecoderError::InvalidData)
}
}
- fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
+ fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
let src = pkt.get_buffer();
- let mut br = BitReader::new(&src, src.len(), BitReaderMode::LE);
+ let mut br = BitReader::new(&src, BitReaderMode::LE);
let mut buf;
self.key_frame = pkt.is_keyframe();
if let Some(bbuf) = bufret {
buf = bbuf;
} else {
- let bufret = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 4);
- if let Err(_) = bufret { return Err(DecoderError::InvalidData); }
- let bufinfo = bufret.unwrap();
+ let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 4)?;
buf = bufinfo.get_vbuf().unwrap();
self.key_frame = true;
self.hams.add_frame(buf);
buf = self.hams.get_output_frame().unwrap();
}
} else {
- let bufret = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 4);
- if let Err(_) = bufret { return Err(DecoderError::InvalidData); }
- let bufinfo = bufret.unwrap();
+ let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 4)?;
buf = bufinfo.get_vbuf().unwrap();
}
-println!("decode frame {} b={} i={}", pkt.get_pts().unwrap(), self.is_ver_b, self.is_ver_i);
let nplanes = if self.is_gray { 1 } else { 3 };
if self.has_alpha {
validate!(!self.is_ver_b);
frm.set_frame_type(FrameType::P);
Ok(frm.into_ref())
}
+ fn flush(&mut self) {
+ self.ips.clear();
+ }
}
-pub fn get_decoder() -> Box<NADecoder> {
+pub fn get_decoder() -> Box<dyn NADecoder + Send> {
Box::new(BinkDecoder::new())
}
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;
+ use nihav_codec_support::test::dec_video::*;
+ use crate::rad_register_all_codecs;
+ use crate::rad_register_all_demuxers;
#[test]
fn test_binkvid() {
let mut dmx_reg = RegisteredDemuxers::new();
projects / nihav.git / blobdiff