X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=nihav-realmedia%2Fsrc%2Fcodecs%2Frv60.rs;h=254cc372dce744ad1d8b2626c1d64f555264841c;hb=aa5efa8a68f625b21180a53c17c2cfaa79eb3500;hp=a076d870147a35fa134d935fb180f493111edd5c;hpb=3167c45c8087a692192021e08a8063dff680001c;p=nihav.git diff --git a/nihav-realmedia/src/codecs/rv60.rs b/nihav-realmedia/src/codecs/rv60.rs index a076d87..254cc37 100644 --- a/nihav-realmedia/src/codecs/rv60.rs +++ b/nihav-realmedia/src/codecs/rv60.rs @@ -1,11 +1,12 @@ -use std::rc::Rc; -use std::cell::RefCell; use nihav_core::formats::YUV420_FORMAT; use nihav_core::frame::*; -use nihav_core::codecs::{NADecoder, MV, ZERO_MV, DecoderError, DecoderResult, IPBShuffler}; +use nihav_core::codecs::{NADecoder, NADecoderSupport, DecoderError, DecoderResult, FrameSkipMode}; +use nihav_core::options::*; +use nihav_codec_support::codecs::{MV, ZERO_MV, IPBShuffler}; use nihav_core::io::byteio::{MemoryReader,ByteReader}; use nihav_core::io::bitreader::{BitReader,BitReaderMode}; use nihav_core::io::intcode::*; +use std::str::FromStr; use super::rv60codes::*; use super::rv60dsp::*; @@ -23,7 +24,7 @@ impl UniqueList { fn add(&mut self, cand: A) { if self.fill == self.max_size { return; } let mut unique = true; - for el in self.list.into_iter().take(self.fill) { + for el in self.list.iter().take(self.fill) { if *el == cand { unique = false; break; @@ -40,6 +41,7 @@ const RV60_FRAME_TYPES: [FrameType; 4] = [ FrameType::I, FrameType::P, FrameType const MAX_IMODE: u8 = 34; #[derive(Clone,Copy,Debug)] +#[allow(dead_code)] struct FrameHeader { profile: u8, ftype: FrameType, @@ -47,7 +49,9 @@ struct FrameHeader { osvquant: u8, ts: u32, width: usize, + awidth: usize, height: usize, + aheight: usize, two_f_refs: bool, qp_off_type: u8, deblock: bool, @@ -76,6 +80,8 @@ impl FrameHeader { let width = ((br.read(11)? as usize) + 1) * 4; let height = ((br.read(11)? as usize) + 0) * 4; validate!(height > 0); + let awidth = (width + 15) & !15; + let aheight = (height + 15) & !15; let _some_flag = br.read_bool()?; let two_f_refs; if ftype == FrameType::I { @@ -108,8 +114,8 @@ impl FrameHeader { } Ok(FrameHeader { - profile, ftype, qp, osvquant, ts, width, height, two_f_refs, qp_off_type, - deblock, deblock_chroma, + profile, ftype, qp, osvquant, ts, width, height, awidth, aheight, + two_f_refs, qp_off_type, deblock, deblock_chroma, }) } fn parse_slice_sizes(&self, br: &mut BitReader, sizes: &mut Vec) -> DecoderResult<()> { @@ -122,7 +128,7 @@ impl FrameHeader { signs.push(sign); } validate!(signs[0]); - sizes.truncate(0); + sizes.clear(); let mut sum = 0; let first_size = br.read(nbits)? as usize; validate!(first_size > 0); @@ -186,13 +192,13 @@ println!(" left {} / {}", br.left() >> 3, sum); fn has_top_block(&self, xpos: usize, ypos: usize, dx: usize, dy: usize, size: usize) -> bool { if (ypos + dy) == 0 { return false; } let xpos2 = xpos + dx; - if (xpos2 + size) > self.width { return false; } + if (xpos2 + size) > self.awidth { return false; } true } fn has_top_right_block(&self, xpos: usize, ypos: usize, dx: usize, dy: usize, size: usize) -> bool { if (ypos + dy) == 0 { return false; } let xpos2 = xpos + dx; - if (xpos2 + size * 2) > self.width { return false; } + if (xpos2 + size * 2) > self.awidth { return false; } let cxpos = ((xpos + dx) & 63) >> RV60_BLOCK_LOG2[size]; let cypos = ((ypos + dy) & 63) >> RV60_BLOCK_LOG2[size]; ((cypos as u8) & RV60_AVAIL_MASK[cxpos]) == 0 @@ -200,13 +206,13 @@ println!(" left {} / {}", br.left() >> 3, sum); fn has_left_block(&self, xpos: usize, ypos: usize, dx: usize, dy: usize, size: usize) -> bool { if (xpos + dx) == 0 { return false; } let ypos2 = ypos + dy; - if (ypos2 + size) > self.height { return false; } + if (ypos2 + size) > self.aheight { return false; } true } fn has_left_down_block(&self, xpos: usize, ypos: usize, dx: usize, dy: usize, size: usize) -> bool { if (xpos + dx) == 0 { return false; } let ypos2 = ypos + dy; - if (ypos2 + size * 2) > self.height { return false; } + if (ypos2 + size * 2) > self.aheight { return false; } let cxpos = (!(xpos + dx) & 63) >> RV60_BLOCK_LOG2[size]; let cypos = (!(ypos + dy) & 63) >> RV60_BLOCK_LOG2[size]; ((cypos as u8) & RV60_AVAIL_MASK[cxpos]) >= 1 @@ -221,7 +227,7 @@ const RV60_BLOCK_LOG2: [u8; 65] = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6 ]; const RV60_AVAIL_MASK: [u8; 64] = [ - 0, 1, 0, 3, 0, 1, 0, 7, 0, 1, 0, 3, 0, 1, 0, 0, + 0, 1, 0, 3, 0, 1, 0, 7, 0, 1, 0, 3, 0, 1, 0, 0xF, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 @@ -255,65 +261,59 @@ enum PUType { const RV60_PU_TYPES: [PUType; 8] = [ PUType::Full, PUType::N2Hor, PUType::N2Ver, PUType::Quarters, - PUType::N4Hor, PUType::N34Hor, PUType::N4Ver, PUType::N34Ver, + PUType::N4Hor, PUType::N34Hor, PUType::N4Ver, PUType::N34Ver, ]; impl PUType { - fn get_num_mvs(&self) -> usize { - match *self { + fn get_num_mvs(self) -> usize { + match self { PUType::Full => 1, PUType::Quarters => 4, _ => 2, } } - fn get_mv_size(&self, part_no: usize, size: usize) -> (usize, usize) { + fn get_mv_size(self, part_no: usize, size: usize) -> (usize, usize) { let mv_size = size >> 2; - match *self { + match self { PUType::Full => (mv_size, mv_size), PUType::N2Hor => (mv_size, mv_size >> 1), PUType::N2Ver => (mv_size >> 1, mv_size), PUType::Quarters => (mv_size >> 1, mv_size >> 1), PUType::N4Hor => { if part_no == 0 { - (mv_size, mv_size >> 2) + (mv_size, mv_size >> 2) } else { - (mv_size, 3 * mv_size >> 2) + (mv_size, (3 * mv_size) >> 2) } }, PUType::N34Hor => { if part_no == 0 { - (mv_size, 3 * mv_size >> 2) + (mv_size, (3 * mv_size) >> 2) } else { - (mv_size, mv_size >> 2) + (mv_size, mv_size >> 2) } }, PUType::N4Ver => { if part_no == 0 { - ( mv_size >> 2, mv_size) + ( mv_size >> 2, mv_size) } else { - (3 * mv_size >> 2, mv_size) + ((3 * mv_size) >> 2, mv_size) } }, PUType::N34Ver => { if part_no == 0 { - (3 * mv_size >> 2, mv_size) + ((3 * mv_size) >> 2, mv_size) } else { - ( mv_size >> 2, mv_size) + ( mv_size >> 2, mv_size) } }, } } - fn has_hor_split(&self) -> bool { - match *self { - PUType::N2Hor | PUType::N4Hor | PUType::N34Hor | PUType::Quarters => true, - _ => false, - } + fn has_hor_split(self) -> bool { + matches!(self, PUType::N2Hor | PUType::N4Hor | PUType::N34Hor | PUType::Quarters) } - fn has_ver_split(&self) -> bool { - match *self { - PUType::N2Ver | PUType::N4Ver | PUType::N34Ver | PUType::Quarters => true, - _ => false, - } + fn has_ver_split(self) -> bool { + matches!(self, PUType::N2Ver | PUType::N4Ver | PUType::N34Ver | PUType::Quarters) } } @@ -357,31 +357,22 @@ enum MVRef { const SKIP_MV_REF: [MVRef; 4] = [ MVRef::Skip0, MVRef::Skip1, MVRef::Skip2, MVRef::Skip3 ]; impl MVRef { - fn get_skip_mv_num(&self) -> usize { - match *self { + fn get_skip_mv_num(self) -> usize { + match self { MVRef::Skip1 => 1, MVRef::Skip2 => 2, MVRef::Skip3 => 3, _ => 0, } } - fn is_ref0(&self) -> bool { - match *self { - MVRef::Ref0 | MVRef::Ref0AndBRef => true, - _ => false, - } + fn is_ref0(self) -> bool { + matches!(self, MVRef::Ref0 | MVRef::Ref0AndBRef) } - fn is_fwd(&self) -> bool { - match *self { - MVRef::Ref0 | MVRef::Ref1 | MVRef::Ref0AndBRef => true, - _ => false, - } + fn is_fwd(self) -> bool { + matches!(self, MVRef::Ref0 | MVRef::Ref1 | MVRef::Ref0AndBRef) } - fn is_bwd(&self) -> bool { - match *self { - MVRef::BRef | MVRef::Ref0AndBRef => true, - _ => false, - } + fn is_bwd(self) -> bool { + matches!(self, MVRef::BRef | MVRef::Ref0AndBRef) } } @@ -549,10 +540,11 @@ impl CBHeader { struct PUInfo { cu_type: CUType, ttype: TransformType, + pu_type: PUType, } impl PUInfo { - fn is_intra(&self) -> bool { self.cu_type == CUType::Intra } + fn is_intra(self) -> bool { self.cu_type == CUType::Intra } } const RV60_CANDIDATE_INTRA_ANGLES: [u8; 6] = [ 0, 1, 10, 26, 18, 2 ]; @@ -587,9 +579,11 @@ impl DeblockInfo { let dval = (q << 2) | strength; for x in 0..dsize { self.top_str[pos + x] = dval; + self.top_str[pos + (dsize - 1) * self.stride + x] = dval; } for y in 0..dsize { self.left_str[pos + y * self.stride] = dval; + self.left_str[pos + y * self.stride + dsize - 1] = dval; } } fn get_pos(&self, xpos: usize, ypos: usize) -> usize { @@ -610,13 +604,14 @@ impl DeblockInfo { } struct RealVideo60Decoder { - info: Rc, + info: NACodecInfoRef, cbs: RV60Codebooks, ipbs: IPBShuffler, dsp: RV60DSP, ipred: IntraPredContext, + skip_mode: FrameSkipMode, - avg_buf: NAVideoBuffer, + avg_buf: NAVideoBufferRef, y_coeffs: [i16; 16 * 16], u_coeffs: [i16; 8 * 8], @@ -638,21 +633,28 @@ struct RealVideo60Decoder { xpos: usize, ypos: usize, + + ts_scale: u64, + ref0_pts: u64, + ref1_pts: u64, + ref0_ts: u64, + ref1_ts: u64, } impl RealVideo60Decoder { fn new() -> Self { let tmp_vinfo = NAVideoInfo::new(64, 64, false, YUV420_FORMAT); - let mut vt = alloc_video_buffer(tmp_vinfo, 4).unwrap(); + let vt = alloc_video_buffer(tmp_vinfo, 4).unwrap(); let vb = vt.get_vbuf(); let avg_buf = vb.unwrap(); RealVideo60Decoder{ - info: Rc::new(DUMMY_CODEC_INFO), + info: NACodecInfoRef::default(), cbs: RV60Codebooks::init(), ipbs: IPBShuffler::new(), ipred: IntraPredContext::new(), + skip_mode: FrameSkipMode::default(), dsp: RV60DSP::new(), - avg_buf: avg_buf, + avg_buf, y_coeffs: [0; 16 * 16], u_coeffs: [0; 8 * 8], v_coeffs: [0; 8 * 8], @@ -669,14 +671,20 @@ impl RealVideo60Decoder { blk_pos: 0, xpos: 0, ypos: 0, + + ts_scale: 1, + ref0_pts: 0, + ref1_pts: 0, + ref0_ts: 0, + ref1_ts: 0, } } - fn decode_cu_line(&mut self, buf: &mut NAVideoBuffer, hdr: &FrameHeader, src: &[u8], cu_y: usize) -> DecoderResult<()> { - let mut br = BitReader::new(src, src.len(), BitReaderMode::BE); + fn decode_cu_line(&mut self, buf: &mut NASimpleVideoFrame, hdr: &FrameHeader, src: &[u8], cu_y: usize) -> DecoderResult<()> { + let mut br = BitReader::new(src, BitReaderMode::BE); let cu_w = hdr.get_width_cu(); let dqp = hdr.read_line_qp_offset(&mut br)?; let qps = (hdr.qp as i8) + dqp; - validate!((qps >= 0) && (qps < 32)); + validate!((0..32).contains(&qps)); let qp = qps as u8; self.qp = qp; self.sel_qp = match hdr.osvquant { @@ -713,11 +721,12 @@ println!(" left {} bits", br.left()); } Ok(()) } - fn decode_cb_tree(&mut self, buf: &mut NAVideoBuffer, hdr: &FrameHeader, br: &mut BitReader, xpos: usize, ypos: usize, log_size: u8) -> DecoderResult<()> { - if (xpos >= hdr.width) || (ypos >= hdr.height) { return Ok(()); } + #[allow(clippy::cognitive_complexity)] + fn decode_cb_tree(&mut self, buf: &mut NASimpleVideoFrame, hdr: &FrameHeader, br: &mut BitReader, xpos: usize, ypos: usize, log_size: u8) -> DecoderResult<()> { + if (xpos >= hdr.awidth) || (ypos >= hdr.aheight) { return Ok(()); } let size = 1 << log_size; - let split = (xpos + size > hdr.width) || (ypos + size > hdr.height) || (size > 8 && br.read_bool()?); + let split = (xpos + size > hdr.awidth) || (ypos + size > hdr.aheight) || (size > 8 && br.read_bool()?); self.cu_splits.push(split); if split { let hsize = size >> 1; @@ -738,21 +747,19 @@ println!(" left {} bits", br.left()); CUType::Intra => { let itype = self.blk_info[self.blk_pos].imode; if !split_i4x4 { - let dstride = buf.get_stride(0); + let dstride = buf.stride[0]; let off = xpos + ypos * dstride; - let mut data = buf.get_data_mut(); - let dst = &mut data; + let dst = &mut buf.data; self.populate_ipred(hdr, dst, 0, dstride, 0, 0, size, true); self.ipred.pred_angle(dst, off, dstride, size, itype as usize, true); } for comp in 1..3 { - let dstride = buf.get_stride(comp); - let soff = buf.get_offset(comp); + let dstride = buf.stride[comp]; + let soff = buf.offset[comp]; let off = soff + (xpos >> 1) + (ypos >> 1) * dstride; - let mut data = buf.get_data_mut(); - let mut dst = &mut data; + let dst = &mut buf.data; self.populate_ipred(hdr, dst, soff, dstride, 0, 0, size >> 1, false); - self.ipred.pred_angle(&mut dst, off, dstride, size >> 1, itype as usize, false); + self.ipred.pred_angle(dst, off, dstride, size >> 1, itype as usize, false); } }, _ => { @@ -793,7 +800,10 @@ println!(" left {} bits", br.left()); validate!(hdr.ftype == FrameType::B); if let (Some(ref prevbuf), Some(ref nextbuf)) = (self.ipbs.get_b_fwdref(), self.ipbs.get_b_bwdref()) { self.dsp.do_mc(buf, prevbuf, bx, by, bw, bh, mv.f_mv, false); - self.dsp.do_mc(&mut self.avg_buf, nextbuf, bx, by, bw, bh, mv.b_mv, true); + { + let mut avg_buf = NASimpleVideoFrame::from_video_buf(&mut self.avg_buf).unwrap(); + self.dsp.do_mc(&mut avg_buf, nextbuf, bx, by, bw, bh, mv.b_mv, true); + } self.dsp.do_avg(buf, &self.avg_buf, bx, by, bw, bh); } }, @@ -836,21 +846,17 @@ println!(" left {} bits", br.left()); cbp16 = 0; } if cbp16 != 0 { - self.coded_blk[cb_pos + 0] = true; - self.coded_blk[cb_pos + 1] = true; - self.coded_blk[cb_pos + 8] = true; - self.coded_blk[cb_pos + 9] = true; rv6_decode_cu_4x4in16x16(br, &self.cbs, is_intra, self.qp, self.sel_qp, &mut self.y_coeffs, &mut self.u_coeffs, &mut self.v_coeffs, cbp16)?; for y in 0..4 { for x in 0..4 { let i = x + y * 4; if ((cbp16 >> i) & 1) != 0 { self.dsp.transform4x4(&mut self.y_coeffs[i * 16..][..16]); - let dstride = buf.get_stride(0); + let dstride = buf.stride[0]; let off = xpos + x * 4 + (ypos + y * 4) * dstride; - let mut data = buf.get_data_mut(); - let mut dst = &mut data; - self.dsp.add_block(&mut dst, off, dstride, &self.y_coeffs[i*16..][..16], 4); + let dst = &mut buf.data; + self.dsp.add_block(dst, off, dstride, &self.y_coeffs[i*16..][..16], 4); + self.coded_blk[cb_pos + (y / 2) * 8 + (x / 2)] = true; } } } @@ -861,19 +867,19 @@ println!(" left {} bits", br.left()); let yoff = (ypos >> 1) + y * 4; if ((cbp16 >> (16 + i)) & 1) != 0 { self.dsp.transform4x4(&mut self.u_coeffs[i * 16..][..16]); - let dstride = buf.get_stride(1); - let off = buf.get_offset(1) + xoff + yoff * dstride; - let mut data = buf.get_data_mut(); - let mut dst = &mut data; - self.dsp.add_block(&mut dst, off, dstride, &self.u_coeffs[i * 16..][..16], 4); + let dstride = buf.stride[1]; + let off = buf.offset[1] + xoff + yoff * dstride; + let dst = &mut buf.data; + self.dsp.add_block(dst, off, dstride, &self.u_coeffs[i * 16..][..16], 4); + self.coded_blk[cb_pos + y * 8 + x] = true; } if ((cbp16 >> (20 + i)) & 1) != 0 { self.dsp.transform4x4(&mut self.v_coeffs[i * 16..][..16]); - let dstride = buf.get_stride(2); - let off = buf.get_offset(2) + xoff + yoff * dstride; - let mut data = buf.get_data_mut(); - let mut dst = &mut data; - self.dsp.add_block(&mut dst, off, dstride, &self.v_coeffs[i * 16..][..16], 4); + let dstride = buf.stride[2]; + let off = buf.offset[2] + xoff + yoff * dstride; + let dst = &mut buf.data; + self.dsp.add_block(dst, off, dstride, &self.v_coeffs[i * 16..][..16], 4); + self.coded_blk[cb_pos + y * 8 + x] = true; } } } @@ -888,42 +894,35 @@ println!(" left {} bits", br.left()); let xoff = (i & 1) * 4; let yoff = (i & 2) * 2; if split_i4x4 { - let dstride = buf.get_stride(0); + let dstride = buf.stride[0]; let off = xpos + xoff + (ypos + yoff) * dstride; - let mut data = buf.get_data_mut(); - let mut dst = &mut data; + let dst = &mut buf.data; self.populate_ipred(hdr, dst, 0, dstride, xoff, yoff, 4, true); let itype = self.blk_info[self.blk_pos + (i & 1) + (i >> 1) * self.blk_stride].imode; - self.ipred.pred_angle(&mut dst, off, dstride, 4, itype as usize, false); + self.ipred.pred_angle(dst, off, dstride, 4, itype as usize, true); } if ((cbp8 >> i) & 1) != 0 { let blk = &mut self.y_coeffs[i * 16..][..16]; self.dsp.transform4x4(blk); - let dstride = buf.get_stride(0); - let soff = buf.get_offset(0); + let dstride = buf.stride[0]; + let soff = buf.offset[0]; let off = soff + xpos + xoff + (ypos + yoff) * dstride; - let mut data = buf.get_data_mut(); - let mut dst = &mut data; - self.dsp.add_block(&mut dst, off, dstride, blk, 4); + self.dsp.add_block(buf.data, off, dstride, blk, 4); } } if ((cbp8 >> 4) & 1) != 0 { self.dsp.transform4x4(&mut self.u_coeffs); - let dstride = buf.get_stride(1); - let soff = buf.get_offset(1); + let dstride = buf.stride[1]; + let soff = buf.offset[1]; let off = soff + (xpos >> 1) + (ypos >> 1) * dstride; - let mut data = buf.get_data_mut(); - let mut dst = &mut data; - self.dsp.add_block(&mut dst, off, dstride, &self.u_coeffs, 4); + self.dsp.add_block(buf.data, off, dstride, &self.u_coeffs, 4); } if ((cbp8 >> 5) & 1) != 0 { self.dsp.transform4x4(&mut self.v_coeffs); - let dstride = buf.get_stride(2); - let soff = buf.get_offset(2); + let dstride = buf.stride[2]; + let soff = buf.offset[2]; let off = soff + (xpos >> 1) + (ypos >> 1) * dstride; - let mut data = buf.get_data_mut(); - let mut dst = &mut data; - self.dsp.add_block(&mut dst, off, dstride, &self.v_coeffs, 4); + self.dsp.add_block(buf.data, off, dstride, &self.v_coeffs, 4); } } }, @@ -935,29 +934,23 @@ println!(" left {} bits", br.left()); rv6_decode_cu_8x8(br, &self.cbs, is_intra, self.qp, self.sel_qp, &mut self.y_coeffs, &mut self.u_coeffs, &mut self.v_coeffs, cbp8, false)?; if (cbp8 & 0xF) != 0 { self.dsp.transform8x8(&mut self.y_coeffs); - let dstride = buf.get_stride(0); + let dstride = buf.stride[0]; let off = xpos + ypos * dstride; - let mut data = buf.get_data_mut(); - let mut dst = &mut data; - self.dsp.add_block(&mut dst, off, dstride, &self.y_coeffs, 8); + self.dsp.add_block(buf.data, off, dstride, &self.y_coeffs, 8); } if ((cbp8 >> 4) & 1) != 0 { self.dsp.transform4x4(&mut self.u_coeffs); - let dstride = buf.get_stride(1); - let soff = buf.get_offset(1); + let dstride = buf.stride[1]; + let soff = buf.offset[1]; let off = soff + (xpos >> 1) + (ypos >> 1) * dstride; - let mut data = buf.get_data_mut(); - let mut dst = &mut data; - self.dsp.add_block(&mut dst, off, dstride, &self.u_coeffs, 4); + self.dsp.add_block(buf.data, off, dstride, &self.u_coeffs, 4); } if ((cbp8 >> 5) & 1) != 0 { self.dsp.transform4x4(&mut self.v_coeffs); - let dstride = buf.get_stride(2); - let soff = buf.get_offset(2); + let dstride = buf.stride[2]; + let soff = buf.offset[2]; let off = soff + (xpos >> 1) + (ypos >> 1) * dstride; - let mut data = buf.get_data_mut(); - let mut dst = &mut data; - self.dsp.add_block(&mut dst, off, dstride, &self.v_coeffs, 4); + self.dsp.add_block(buf.data, off, dstride, &self.v_coeffs, 4); } } }, @@ -980,29 +973,23 @@ println!(" left {} bits", br.left()); rv6_decode_cu_16x16(br, &self.cbs, is_intra, self.qp, self.sel_qp, &mut self.y_coeffs, &mut self.u_coeffs, &mut self.v_coeffs, super_cbp)?; if (super_cbp & 0xFFFF) != 0 { self.dsp.transform16x16(&mut self.y_coeffs); - let dstride = buf.get_stride(0); + let dstride = buf.stride[0]; let off = xpos + x * 16 + (ypos + y * 16) * dstride; - let mut data = buf.get_data_mut(); - let mut dst = &mut data; - self.dsp.add_block(&mut dst, off, dstride, &self.y_coeffs, 16); + self.dsp.add_block(buf.data, off, dstride, &self.y_coeffs, 16); } if ((super_cbp >> 16) & 0xF) != 0 { self.dsp.transform8x8(&mut self.u_coeffs); - let dstride = buf.get_stride(1); - let soff = buf.get_offset(1); + let dstride = buf.stride[1]; + let soff = buf.offset[1]; let off = soff + (xpos >> 1) + x * 8 + ((ypos >> 1) + y * 8) * dstride; - let mut data = buf.get_data_mut(); - let mut dst = &mut data; - self.dsp.add_block(&mut dst, off, dstride, &self.u_coeffs, 8); + self.dsp.add_block(buf.data, off, dstride, &self.u_coeffs, 8); } if ((super_cbp >> 20) & 0xF) != 0 { self.dsp.transform8x8(&mut self.v_coeffs); - let dstride = buf.get_stride(2); - let soff = buf.get_offset(2); + let dstride = buf.stride[2]; + let soff = buf.offset[2]; let off = soff + (xpos >> 1) + x * 8 + ((ypos >> 1) + y * 8) * dstride; - let mut data = buf.get_data_mut(); - let mut dst = &mut data; - self.dsp.add_block(&mut dst, off, dstride, &self.v_coeffs, 8); + self.dsp.add_block(buf.data, off, dstride, &self.v_coeffs, 8); } } } @@ -1018,6 +1005,7 @@ println!(" left {} bits", br.left()); let pu_size = size >> 3; pui.cu_type = cbh.cu_type; pui.ttype = cbh.ttype; + pui.pu_type = cbh.pu_type; if (cbh.cu_type == CUType::Intra) && (cbh.pu_type == PUType::Quarters) { // very special case self.pu_info[self.pu_pos] = pui; for y in 0..2 { @@ -1131,7 +1119,7 @@ println!(" left {} bits", br.left()); } } } - for el in RV60_CANDIDATE_INTRA_ANGLES.into_iter() { + for el in RV60_CANDIDATE_INTRA_ANGLES.iter() { ipm_cand.add(*el); } // actually decode prediction mode @@ -1143,7 +1131,7 @@ println!(" left {} bits", br.left()); let mut imode = mode; let mut ipm_cs: [u8; 3] = [ipm_cand.list[0], ipm_cand.list[1], ipm_cand.list[2]]; ipm_cs.sort(); - for ic in ipm_cs.into_iter() { + for ic in ipm_cs.iter() { if imode >= *ic { imode += 1; } @@ -1285,7 +1273,7 @@ println!(" left {} bits", br.left()); } else { b_mv = ZERO_MV; } - + MVInfo { f_mv: mvi.f_mv + f_mv, b_mv: mvi.b_mv + b_mv, mvref: mvi.mvref } } fn fill_skip_cand(&mut self, hdr: &FrameHeader, skip_cand: &mut UniqueList, size: usize) { @@ -1337,9 +1325,17 @@ println!(" left {} bits", br.left()); skip_cand.list[i] = MVInfo { f_mv: ZERO_MV, b_mv: ZERO_MV, mvref: MVRef::Ref0 }; } } - fn deblock_cb_tree(&mut self, buf: &mut NAVideoBuffer, hdr: &FrameHeader, xpos: usize, ypos: usize, log_size: u8) { - if (xpos >= hdr.width) || (ypos >= hdr.height) { return; } - let split = (log_size > 3) && self.cu_splits.pop().unwrap(); + fn calc_tile_size(&self, pu_pos: usize, cu_type: CUType, log_size: u8) -> u8 { + match log_size { + 3 => 3, + 4 if (cu_type != CUType::Intra) && (self.pu_info[pu_pos].pu_type != PUType::Full) => 3, + 4 | 5 | 6 => 4, + _ => unreachable!(), + } + } + fn deblock_cb_tree(&mut self, buf: &mut NASimpleVideoFrame, hdr: &FrameHeader, xpos: usize, ypos: usize, log_size: u8) { + if (xpos >= hdr.awidth) || (ypos >= hdr.aheight) { return; } + let split = self.cu_splits.pop().unwrap(); if split { let hsize = 1 << (log_size - 1); self.deblock_cb_tree(buf, hdr, xpos, ypos, log_size - 1); @@ -1349,12 +1345,12 @@ println!(" left {} bits", br.left()); } else { let pu_pos = (xpos >> 3) + (ypos >> 3) * self.pu_stride; let cu_type = self.pu_info[pu_pos].cu_type; - let tsize = if self.pu_info[pu_pos].ttype == TransformType::T16X16 { 4 } else { 3 }; + let tsize = self.calc_tile_size(pu_pos, cu_type, log_size); let ntiles = 1 << (log_size - tsize); let dparams = RV60DeblockParams { deblock_chroma: hdr.deblock_chroma, - width: hdr.width, - height: hdr.height, + width: hdr.awidth, + height: hdr.aheight, dblkstride: self.dblk.stride, }; for ty in 0..ntiles { @@ -1384,7 +1380,7 @@ println!(" left {} bits", br.left()); if ypos > 0 { let top_blk_pos = blk_pos - self.blk_stride; for i in 0..size4 { - if self.dblk.get_top_strength(dblk_pos + i) == 0 { + if self.dblk.get_top_strength(dblk_pos - self.dblk.stride + i) == 0 { if self.blk_info[blk_pos + i].mv.is_deblock_cand(&self.blk_info[top_blk_pos + i].mv) { self.dblk.set_top_strength(dblk_pos + i, 1); } @@ -1393,8 +1389,8 @@ println!(" left {} bits", br.left()); } if xpos > 0 { for i in 0..size4 { - if self.dblk.get_left_strength(dblk_pos) == 0 { - if self.blk_info[blk_pos + i].mv.is_deblock_cand(&self.blk_info[blk_pos + i - 1].mv) { + if self.dblk.get_left_strength(dblk_pos - 1) == 0 { + if self.blk_info[blk_pos + i * self.blk_stride].mv.is_deblock_cand(&self.blk_info[blk_pos + i * self.blk_stride - 1].mv) { self.dblk.set_left_strength(dblk_pos, 1); } } @@ -1405,11 +1401,11 @@ println!(" left {} bits", br.left()); } impl NADecoder for RealVideo60Decoder { - fn init(&mut self, info: Rc) -> DecoderResult<()> { - if let NACodecTypeInfo::Video(_vinfo) = info.get_properties() { + fn init(&mut self, supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> { + if let NACodecTypeInfo::Video(vinfo) = info.get_properties() { let fmt = YUV420_FORMAT; let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, fmt)); - self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata())); + self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref(); let edata = info.get_extradata().unwrap(); let src: &[u8] = &edata; @@ -1426,56 +1422,157 @@ impl NADecoder for RealVideo60Decoder { //self.bd.width = vinfo.get_width(); //self.bd.height = vinfo.get_height(); //self.frmmgr.clear(); + + supp.pool_u8.set_dec_bufs(3); + supp.pool_u8.prealloc_video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), false, fmt), 6)?; + Ok(()) } else { println!("???"); Err(DecoderError::InvalidData) } } - fn decode(&mut self, pkt: &NAPacket) -> DecoderResult { + fn decode(&mut self, supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult { let src = pkt.get_buffer(); validate!(src.len() > 9); let hsize = (src[0] as usize) * 8 + 9; - let mut br = BitReader::new(&src[hsize..], src.len() - hsize, BitReaderMode::BE); + let mut br = BitReader::new(&src[hsize..], BitReaderMode::BE); let hdr = FrameHeader::read(&mut br)?; + match self.skip_mode { + FrameSkipMode::None => {}, + FrameSkipMode::KeyframesOnly => { + if hdr.ftype == FrameType::B { + let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), NABufferType::None); + frm.set_frame_type(FrameType::Skip); + return Ok(frm.into_ref()); + } + }, + FrameSkipMode::IntraOnly => { + if hdr.ftype != FrameType::I { + let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), NABufferType::None); + frm.set_frame_type(FrameType::Skip); + return Ok(frm.into_ref()); + } + }, + }; + let mut slices: Vec = Vec::new(); hdr.parse_slice_sizes(&mut br, &mut slices)?; + match hdr.ftype { + FrameType::P => { + if self.ipbs.get_lastref().is_none() { + return Err(DecoderError::MissingReference); + } + }, + FrameType::B => { + if self.ipbs.get_lastref().is_none() { + return Err(DecoderError::MissingReference); + } + if self.ipbs.get_nextref().is_none() { + return Err(DecoderError::MissingReference); + } + }, + _ => {}, + }; let tmp_vinfo = NAVideoInfo::new(hdr.width, hdr.height, false, YUV420_FORMAT); - let res = alloc_video_buffer(tmp_vinfo, 6); - if !res.is_ok() { return Err(DecoderError::InvalidData); } - let mut bufinfo = res.unwrap(); - let mut buf = bufinfo.get_vbuf().unwrap(); + let ret = supp.pool_u8.get_free(); + if ret.is_none() { + return Err(DecoderError::AllocError); + } + let mut buf = ret.unwrap(); + if buf.get_info() != tmp_vinfo { + self.ipbs.clear(); + supp.pool_u8.reset(); + supp.pool_u8.prealloc_video(tmp_vinfo, 6)?; + let ret = supp.pool_u8.get_free(); + if ret.is_none() { + return Err(DecoderError::AllocError); + } + buf = ret.unwrap(); + } let cu_w = hdr.get_width_cu(); let cu_h = hdr.get_height_cu(); self.pu_stride = cu_w << 3; self.pu_info.resize(self.pu_stride * (cu_h << 3), PUInfo::default()); self.blk_stride = cu_w << 4; - self.blk_info.truncate(0); + self.blk_info.clear(); self.blk_info.resize(self.blk_stride * (cu_h << 4), BlockInfo::default()); if hdr.deblock { - self.dblk.reinit(hdr.width, hdr.height); + self.dblk.reinit(hdr.awidth, hdr.aheight); } let mut off = hsize + ((br.tell() >> 3) as usize); + let mut dframe = NASimpleVideoFrame::from_video_buf(&mut buf).unwrap(); for (cu_y, size) in slices.into_iter().enumerate() { - self.decode_cu_line(&mut buf, &hdr, &src[off..][..size], cu_y)?; + self.decode_cu_line(&mut dframe, &hdr, &src[off..][..size], cu_y)?; off += size; } if (hdr.ftype == FrameType::I) || (hdr.ftype == FrameType::P) { - self.ipbs.add_frame(buf); + self.ipbs.add_frame(buf.clone()); } - let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo); + if hdr.ftype != FrameType::B { + self.ref0_pts = self.ref1_pts; + self.ref1_pts = pkt.get_pts().unwrap_or(0); + self.ref0_ts = self.ref1_ts; + self.ref1_ts = hdr.ts as u64; + if (self.ref1_pts > self.ref0_pts) && (self.ref1_ts > self.ref0_ts) { + self.ts_scale = (self.ref1_pts - self.ref0_pts) / (self.ref1_ts - self.ref0_ts); + } + } + let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), NABufferType::Video(buf)); frm.set_keyframe(hdr.ftype == FrameType::I); - frm.set_pts(Some(hdr.ts as u64)); + if hdr.ftype == FrameType::B { + let pts = self.ref0_pts + ((hdr.ts as u64) - self.ref0_ts) * self.ts_scale; + frm.set_pts(Some(pts)); + } frm.set_frame_type(hdr.ftype); - Ok(Rc::new(RefCell::new(frm))) + Ok(frm.into_ref()) + } + fn flush(&mut self) { + self.ipbs.clear(); + } +} + +const DECODER_OPTIONS: &[NAOptionDefinition] = &[ + NAOptionDefinition { + name: FRAME_SKIP_OPTION, description: FRAME_SKIP_OPTION_DESC, + opt_type: NAOptionDefinitionType::String(Some(&[ + FRAME_SKIP_OPTION_VAL_NONE, + FRAME_SKIP_OPTION_VAL_KEYFRAME, + FRAME_SKIP_OPTION_VAL_INTRA + ])) }, +]; + +impl NAOptionHandler for RealVideo60Decoder { + fn get_supported_options(&self) -> &[NAOptionDefinition] { DECODER_OPTIONS } + fn set_options(&mut self, options: &[NAOption]) { + for option in options.iter() { + for opt_def in DECODER_OPTIONS.iter() { + if opt_def.check(option).is_ok() { + match (option.name, &option.value) { + (FRAME_SKIP_OPTION, NAValue::String(ref str)) => { + if let Ok(smode) = FrameSkipMode::from_str(str) { + self.skip_mode = smode; + } + }, + _ => {}, + } + } + } + } + } + fn query_option_value(&self, name: &str) -> Option { + match name { + FRAME_SKIP_OPTION => Some(NAValue::String(self.skip_mode.to_string())), + _ => None, + } } } -pub fn get_decoder() -> Box { +pub fn get_decoder() -> Box { Box::new(RealVideo60Decoder::new()) } @@ -1483,17 +1580,31 @@ pub fn get_decoder() -> Box { mod test { use nihav_core::codecs::RegisteredDecoders; use nihav_core::demuxers::RegisteredDemuxers; - use nihav_core::test::dec_video::*; - use crate::codecs::realmedia_register_all_codecs; - use crate::demuxers::realmedia_register_all_demuxers; + use nihav_codec_support::test::dec_video::*; + use crate::realmedia_register_all_decoders; + use crate::realmedia_register_all_demuxers; #[test] fn test_rv60() { let mut dmx_reg = RegisteredDemuxers::new(); realmedia_register_all_demuxers(&mut dmx_reg); let mut dec_reg = RegisteredDecoders::new(); - realmedia_register_all_codecs(&mut dec_reg); + realmedia_register_all_decoders(&mut dec_reg); - test_file_decoding("realmedia", "assets/RV/RV60.rmhd", Some(4000), true, false, None/*Some("rv60")*/, &dmx_reg, &dec_reg); -//panic!("end"); + // sample from a private collection + test_decoding("realmedia", "realvideo6", "assets/RV/RV60.rmhd", Some(1000), &dmx_reg, &dec_reg, + ExpectedTestResult::MD5Frames(vec![ + [0x2b1f1807, 0x09edef33, 0x0e6c78c1, 0x3b3c8179], + [0x76743a3b, 0x7dd4f196, 0x0193fe5a, 0x4f78c7cb], + [0x2b1f1807, 0x09edef33, 0x0e6c78c1, 0x3b3c8179], + [0xfee70206, 0x626f3bea, 0x7677ad4b, 0x1228f3b6], + [0x7156cbc2, 0xf381bcb6, 0xe86531f2, 0xb311c3ea], + [0x1742b5a1, 0x66252580, 0x242753de, 0x5215d732], + [0xd357ebda, 0x6460dba6, 0xa93eb616, 0x63ee6d60], + [0x4cd72275, 0x28e1e439, 0xad17dfca, 0x3fd7253f], + [0xe389ce4f, 0x8f0891b3, 0x88639b23, 0x21ed114f], + [0x5b2b2f1b, 0x17a7518b, 0x53806e6a, 0x4538bb00], + [0xdca03c9a, 0x1a45d80c, 0x86141211, 0x79912ed4], + [0x0bf66bf4, 0x46385620, 0xc6fa4796, 0xd8e16d56], + [0x4671a7f0, 0x46f50649, 0x268df27b, 0x70b71ab3]])); } }