use std::mem;
-use std::rc::Rc;
-pub use std::cell::{Ref,RefCell};
use nihav_core::io::bitreader::*;
//use io::intcode::*;
use nihav_core::codecs::*;
+use nihav_core::frame::NABufferRef;
use super::ivi::*;
use super::ividsp::*;
for i in 0..cb.len {
cb.bits[i] = br.read(4)? as u8;
}
+ cb = cb.init();
br.align();
let tile_start = br.tell();
Ok(())
}
-fn decode_block8x8(br: &mut BitReader, blk_cb: &IVICodebook, rvmap: &RVMap, tables: &TxParams8x8, is_intra: bool, is_2d: bool, prev_dc: &mut i32, quant: u8, coeffs: &mut [i32; 64], transform: &TrFunc) -> DecoderResult<()> {
+#[allow(clippy::cast_lossless)]
+fn decode_block8x8(br: &mut BitReader, blk_cb: &IVICodebook, rvmap: &RVMap, tables: &TxParams8x8, is_intra: bool, is_2d: bool, prev_dc: &mut i32, quant: u8, coeffs: &mut [i32; 64], transform: TrFunc) -> DecoderResult<()> {
let mut idx: isize = -1;
let quant_mat = if is_intra { tables.quant_intra } else { tables.quant_inter };
while idx <= 64 {
(transform)(coeffs);
Ok(())
}
-fn decode_block4x4(br: &mut BitReader, blk_cb: &IVICodebook, rvmap: &RVMap, tables: &TxParams4x4, is_intra: bool, is_2d: bool, prev_dc: &mut i32, quant: u8, coeffs: &mut [i32; 64], transform: &TrFunc) -> DecoderResult<()> {
+#[allow(clippy::cast_lossless)]
+fn decode_block4x4(br: &mut BitReader, blk_cb: &IVICodebook, rvmap: &RVMap, tables: &TxParams4x4, is_intra: bool, is_2d: bool, prev_dc: &mut i32, quant: u8, coeffs: &mut [i32; 64], transform: TrFunc) -> DecoderResult<()> {
let mut idx: isize = -1;
let quant_mat = if is_intra { tables.quant_intra } else { tables.quant_inter };
while idx <= 64 {
}
impl FrameData {
- fn new() -> Rc<RefCell<Self>> {
- Rc::new(RefCell::new(FrameData {
+ fn new() -> NABufferRef<Self> {
+ NABufferRef::new(FrameData {
plane_buf: [Vec::new(), Vec::new(), Vec::new(), Vec::new()],
plane_stride: [0, 0, 0, 0],
pic_hdr: PictureHeader::new_null(IVIFrameType::Intra),
- }))
+ })
}
fn realloc(&mut self, pic_hdr: &PictureHeader) -> DecoderResult<()> {
let width = align(pic_hdr.width, 6);
pub trait IndeoXParser {
fn decode_picture_header(&mut self, br: &mut BitReader) -> DecoderResult<PictureHeader>;
fn decode_band_header(&mut self, br: &mut BitReader, pic_hdr: &PictureHeader, plane: usize, band: usize) -> DecoderResult<BandHeader>;
- fn decode_mb_info(&mut self, br: &mut BitReader, pic_hdr: &PictureHeader, band_hdr: &BandHeader, tile: &mut IVITile, ref_tile: Option<Ref<IVITile>>, mv_scale: u8) -> DecoderResult<()>;
+ fn decode_mb_info(&mut self, br: &mut BitReader, pic_hdr: &PictureHeader, band_hdr: &BandHeader, tile: &mut IVITile, ref_tile: Option<&IVITile>, mv_scale: u8) -> DecoderResult<()>;
fn recombine_plane(&mut self, src: &[i16], sstride: usize, dst: &mut [u8], dstride: usize, w: usize, h: usize);
}
pub struct IVIDecoder {
ftype: IVIFrameType,
- frames: [Rc<RefCell<FrameData>>; 4],
+ frames: [NABufferRef<FrameData>; 4],
cur_frame: usize,
prev_frame: usize,
next_frame: usize,
bref: Option<NABufferType>,
bands: Vec<BandHeader>,
- tiles: Vec<Rc<RefCell<IVITile>>>,
+ tiles: Vec<IVITile>,
num_tiles: [[usize; 4]; 4],
tile_start: [[usize; 4]; 4],
}
fn realloc(&mut self, pic_hdr: &PictureHeader) -> DecoderResult<()> {
let planes = if pic_hdr.transparent { 4 } else { 3 };
- //self.bands.truncate(0);
- self.tiles.truncate(0);
+ //self.bands.clear();
+ self.tiles.clear();
self.num_tiles = [[0; 4]; 4];
self.tile_start = [[0; 4]; 4];
let mut tstart: usize = 0;
while x < band_w {
let cur_w = if x + tile_w <= band_w { tile_w } else { band_w - x };
let tile = IVITile::new(band_xoff + x, band_yoff + y, cur_w, cur_h);
- self.tiles.push(Rc::new(RefCell::new(tile)));
+ self.tiles.push(tile);
self.num_tiles[plane][band] += 1;
tstart += 1;
x += tile_w;
}
Ok(())
}
- fn decode_band(&mut self, pic_hdr: &PictureHeader, dec: &mut IndeoXParser, br: &mut BitReader, plane_no: usize, band_no: usize) -> DecoderResult<()> {
+ fn decode_band(&mut self, pic_hdr: &PictureHeader, dec: &mut dyn IndeoXParser, br: &mut BitReader, plane_no: usize, band_no: usize) -> DecoderResult<()> {
let bidx = match plane_no {
0 => { band_no },
_ => { pic_hdr.luma_bands + plane_no - 1 },
};
for tile_no in tstart..tend {
{
- let mut tile = self.tiles[tile_no].borrow_mut();
+ let tile = &mut self.tiles[tile_no];
let mb_w = (tile.w + mb_size - 1) / mb_size;
let mb_h = (tile.h + mb_size - 1) / mb_size;
tile.mb_w = mb_w;
tile.mb_h = mb_h;
- tile.mb.truncate(0);
+ tile.mb.clear();
tile.mb.resize(mb_w * mb_h, MB::new(0, 0));
}
validate!(tile_end > br.tell());
validate!(tile_end <= br.tell() + (br.left() as usize));
{
- let mut tile = self.tiles[tile_no].borrow_mut();
- let ref_tile: Option<Ref<IVITile>>;
+ let ref_tile: Option<&IVITile>;
let mv_scale;
if (plane_no == 0) && (band_no == 0) {
mv_scale = 0;
} else {
mv_scale = (((self.bands[0].mb_size >> 3) as i8) - ((band.mb_size >> 3) as i8)) as u8;
}
+ let (ref_tiles, cur_tiles) = self.tiles.split_at_mut(tile_no);
+ let tile = &mut cur_tiles[0];
if plane_no != 0 || band_no != 0 {
- let rtile = self.tiles[0].borrow();
+ let rtile = &ref_tiles[0];
if (tile.mb_w != rtile.mb_w) || (tile.mb_h != rtile.mb_h) {
ref_tile = None;
} else {
} else {
ref_tile = None;
}
- dec.decode_mb_info(br, pic_hdr, &band, &mut tile, ref_tile, mv_scale)?;
+ dec.decode_mb_info(br, pic_hdr, &band, tile, ref_tile, mv_scale)?;
}
- self.decode_tile(br, &band, tile_no, &tr, &tr_dc)?;
+ self.decode_tile(br, &band, tile_no, tr, tr_dc)?;
let skip_part = tile_end - br.tell();
br.skip(skip_part as u32)?;
} else {
{
- let mut tile = self.tiles[tile_no].borrow_mut();
- let ref_tile: Option<Ref<IVITile>>;
+ let ref_tile: Option<&IVITile>;
let mv_scale;
if (plane_no == 0) && (band_no == 0) {
mv_scale = 0;
} else {
mv_scale = (((self.bands[0].mb_size >> 3) as i8) - ((band.mb_size >> 3) as i8)) as u8;
}
+ let (ref_tiles, cur_tiles) = self.tiles.split_at_mut(tile_no);
+ let tile = &mut cur_tiles[0];
if plane_no != 0 || band_no != 0 {
- let rtile = self.tiles[0].borrow();
+ let rtile = &ref_tiles[0];
if (tile.mb_w != rtile.mb_w) || (tile.mb_h != rtile.mb_h) {
ref_tile = None;
} else {
}
}
}
- self.decode_tile(br, &band, tile_no, &tr, &tr_dc)?;
+ self.decode_tile(br, &band, tile_no, tr, tr_dc)?;
}
}
self.bands[bidx] = band;
br.align();
Ok(())
}
- fn decode_tile(&mut self, br: &mut BitReader, band: &BandHeader, tile_no: usize, tr: &TrFunc, transform_dc: &TrFuncDC) -> DecoderResult<()> {
+ fn decode_tile(&mut self, br: &mut BitReader, band: &BandHeader, tile_no: usize, tr: TrFunc, transform_dc: TrFuncDC) -> DecoderResult<()> {
let mut mb_idx = 0;
let mut prev_dc: i32 = 0;
- let mut tile = self.tiles[tile_no].borrow_mut();
- let mut frame = self.frames[self.cur_frame].borrow_mut();
+ let tile = &mut self.tiles[tile_no];
+ let mut frame = self.frames[self.cur_frame].clone();
let stride = frame.plane_stride[band.plane_no];
let mut dstidx = tile.pos_x + tile.pos_y * stride;
} else {
idx = self.next_frame;
}
- let pf = self.frames[idx].borrow();
+ let pf = &self.frames[idx];
do_mc(&mut dst[dstidx + boff..], stride,
&pf.plane_buf[band.plane_no], pf.plane_stride[band.plane_no],
pos_x + mb_x * band.mb_size + (blk_no & 1) * band.blk_size,
pos_x, pos_x + tile_w, pos_y, pos_y + tile_h,
mb.mv_x, mb.mv_y, band.halfpel, band.blk_size);
} else {
- let pf = self.frames[self.prev_frame].borrow();
- let nf = self.frames[self.next_frame].borrow();
+ let pf = &self.frames[self.prev_frame];
+ let nf = &self.frames[self.next_frame];
do_mc_b(&mut dst[dstidx + boff..], stride,
&pf.plane_buf[band.plane_no], pf.plane_stride[band.plane_no],
&nf.plane_buf[band.plane_no], nf.plane_stride[band.plane_no],
} else {
idx = self.next_frame;
}
- let pf = self.frames[idx].borrow();
+ let pf = &self.frames[idx];
do_mc(&mut dst[dstidx + mb_x * band.blk_size..], stride,
&pf.plane_buf[band.plane_no], pf.plane_stride[band.plane_no],
pos_x + mb_x * band.mb_size,
pos_x, pos_x + tile_w, pos_y, pos_y + tile_h,
mb.mv_x, mb.mv_y, band.halfpel, band.blk_size);
} else {
- let pf = self.frames[self.prev_frame].borrow();
- let nf = self.frames[self.next_frame].borrow();
+ let pf = &self.frames[self.prev_frame];
+ let nf = &self.frames[self.next_frame];
do_mc_b(&mut dst[dstidx + mb_x * band.blk_size..], stride,
&pf.plane_buf[band.plane_no], pf.plane_stride[band.plane_no],
&nf.plane_buf[band.plane_no], nf.plane_stride[band.plane_no],
unreachable!();
}
- fn decode_single_frame<'a>(&mut self, dec: &mut IndeoXParser, br: &mut BitReader<'a>) -> DecoderResult<NABufferType> {
+ fn decode_single_frame<'a>(&mut self, dec: &mut dyn IndeoXParser, br: &mut BitReader<'a>) -> DecoderResult<NABufferType> {
let pic_hdr = dec.decode_picture_header(br)?;
self.ftype = pic_hdr.ftype;
if pic_hdr.ftype.is_null() {
vinfo.set_height(pic_hdr.height);
let mut buftype = alloc_video_buffer(vinfo, 0)?;
self.realloc(&pic_hdr)?;
- self.frames[self.cur_frame].borrow_mut().realloc(&pic_hdr)?;
+ self.frames[self.cur_frame].realloc(&pic_hdr)?;
for plane in 0..3 {
let num_bands = if plane == 0 { pic_hdr.luma_bands } else { pic_hdr.chroma_bands };
self.decode_band(&pic_hdr, dec, br, plane, band)?;
}
if let NABufferType::Video(ref mut vb) = buftype {
- let mut frame = self.frames[self.cur_frame].borrow_mut();
+ let mut frame = self.frames[self.cur_frame].clone();
if num_bands == 1 {
frame.fill_plane(vb, plane);
} else {
}
}
if pic_hdr.transparent {
- let mut frame = self.frames[self.cur_frame].borrow_mut();
+ let mut frame = self.frames[self.cur_frame].clone();
let stride = frame.plane_stride[3];
read_trans_band_header(br, pic_hdr.width, pic_hdr.height, &mut frame.plane_buf[3], stride)?;
if let NABufferType::Video(ref mut vb) = buftype {
}
match self.ftype {
- IVIFrameType::Intra | IVIFrameType::Inter => {
+ IVIFrameType::Intra | IVIFrameType::Intra1 | IVIFrameType::Inter => {
self.iref_1 = self.iref_0;
self.iref_0 = self.cur_frame;
self.scal_ref = self.cur_frame;
Ok(buftype)
}
- pub fn decode_frame<'a>(&mut self, dec: &mut IndeoXParser, br: &mut BitReader<'a>) -> DecoderResult<NABufferType> {
+ pub fn decode_frame<'a>(&mut self, dec: &mut dyn IndeoXParser, br: &mut BitReader<'a>) -> DecoderResult<NABufferType> {
let res = self.decode_single_frame(dec, br);
if res.is_err() { return res; }
if (self.ftype == IVIFrameType::Intra) && (br.left() > 16) {
let seq = br.peek(21);
if seq == 0xBFFF8 {
let res2 = self.decode_single_frame(dec, br);
- if res2.is_ok() {
- self.bref = Some(res2.unwrap());
+ if let Ok(res) = res2 {
+ self.bref = Some(res);
}
}
self.ftype = IVIFrameType::Intra;
projects / nihav.git / blobdiff