use nihav_core::formats::YUV420_FORMAT;
use nihav_core::frame::*;
-use nihav_core::codecs::{NADecoder, NADecoderSupport, 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::*;
const MAX_IMODE: u8 = 34;
#[derive(Clone,Copy,Debug)]
+#[allow(dead_code)]
struct FrameHeader {
profile: u8,
ftype: FrameType,
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);
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
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 has_hor_split(self) -> bool {
- match self {
- PUType::N2Hor | PUType::N4Hor | PUType::N34Hor | PUType::Quarters => true,
- _ => false,
- }
+ 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,
- }
+ matches!(self, PUType::N2Ver | PUType::N4Ver | PUType::N34Ver | PUType::Quarters)
}
}
}
}
fn is_ref0(self) -> bool {
- match self {
- MVRef::Ref0 | MVRef::Ref0AndBRef => true,
- _ => false,
- }
+ matches!(self, MVRef::Ref0 | MVRef::Ref0AndBRef)
}
fn is_fwd(self) -> bool {
- match self {
- MVRef::Ref0 | MVRef::Ref1 | MVRef::Ref0AndBRef => true,
- _ => false,
- }
+ matches!(self, MVRef::Ref0 | MVRef::Ref1 | MVRef::Ref0AndBRef)
}
fn is_bwd(self) -> bool {
- match self {
- MVRef::BRef | MVRef::Ref0AndBRef => true,
- _ => false,
- }
+ matches!(self, MVRef::BRef | MVRef::Ref0AndBRef)
}
}
ipbs: IPBShuffler,
dsp: RV60DSP,
ipred: IntraPredContext,
+ skip_mode: FrameSkipMode,
avg_buf: NAVideoBufferRef<u8>,
cbs: RV60Codebooks::init(),
ipbs: IPBShuffler::new(),
ipred: IntraPredContext::new(),
+ skip_mode: FrameSkipMode::default(),
dsp: RV60DSP::new(),
avg_buf,
y_coeffs: [0; 16 * 16],
}
}
fn decode_cu_line(&mut self, buf: &mut NASimpleVideoFrame<u8>, hdr: &FrameHeader, src: &[u8], cu_y: usize) -> DecoderResult<()> {
- let mut br = BitReader::new(src, src.len(), BitReaderMode::BE);
+ 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 {
}
Ok(())
}
+ #[allow(clippy::cognitive_complexity)]
fn decode_cb_tree(&mut self, buf: &mut NASimpleVideoFrame<u8>, hdr: &FrameHeader, br: &mut BitReader, xpos: usize, ypos: usize, log_size: u8) -> DecoderResult<()> {
if (xpos >= hdr.width) || (ypos >= hdr.height) { return Ok(()); }
let dstride = buf.stride[comp];
let soff = buf.offset[comp];
let off = soff + (xpos >> 1) + (ypos >> 1) * dstride;
- let mut dst = &mut buf.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);
}
},
_ => {
self.dsp.transform4x4(&mut self.y_coeffs[i * 16..][..16]);
let dstride = buf.stride[0];
let off = xpos + x * 4 + (ypos + y * 4) * dstride;
- let mut dst = &mut buf.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.dsp.transform4x4(&mut self.u_coeffs[i * 16..][..16]);
let dstride = buf.stride[1];
let off = buf.offset[1] + xoff + yoff * dstride;
- let mut dst = &mut buf.data;
- self.dsp.add_block(&mut dst, off, dstride, &self.u_coeffs[i * 16..][..16], 4);
+ let dst = &mut buf.data;
+ self.dsp.add_block(dst, off, dstride, &self.u_coeffs[i * 16..][..16], 4);
}
if ((cbp16 >> (20 + i)) & 1) != 0 {
self.dsp.transform4x4(&mut self.v_coeffs[i * 16..][..16]);
let dstride = buf.stride[2];
let off = buf.offset[2] + xoff + yoff * dstride;
- let mut dst = &mut buf.data;
- self.dsp.add_block(&mut dst, off, dstride, &self.v_coeffs[i * 16..][..16], 4);
+ let dst = &mut buf.data;
+ self.dsp.add_block(dst, off, dstride, &self.v_coeffs[i * 16..][..16], 4);
}
}
}
if split_i4x4 {
let dstride = buf.stride[0];
let off = xpos + xoff + (ypos + yoff) * dstride;
- let mut dst = &mut buf.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, false);
}
if ((cbp8 >> i) & 1) != 0 {
let blk = &mut self.y_coeffs[i * 16..][..16];
let dstride = buf.stride[0];
let soff = buf.offset[0];
let off = soff + xpos + xoff + (ypos + yoff) * dstride;
- let mut dst = &mut buf.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 {
let dstride = buf.stride[1];
let soff = buf.offset[1];
let off = soff + (xpos >> 1) + (ypos >> 1) * dstride;
- let mut dst = &mut buf.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.stride[2];
let soff = buf.offset[2];
let off = soff + (xpos >> 1) + (ypos >> 1) * dstride;
- let mut dst = &mut buf.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);
}
}
},
self.dsp.transform8x8(&mut self.y_coeffs);
let dstride = buf.stride[0];
let off = xpos + ypos * dstride;
- let mut dst = &mut buf.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.stride[1];
let soff = buf.offset[1];
let off = soff + (xpos >> 1) + (ypos >> 1) * dstride;
- let mut dst = &mut buf.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.stride[2];
let soff = buf.offset[2];
let off = soff + (xpos >> 1) + (ypos >> 1) * dstride;
- let mut dst = &mut buf.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);
}
}
},
self.dsp.transform16x16(&mut self.y_coeffs);
let dstride = buf.stride[0];
let off = xpos + x * 16 + (ypos + y * 16) * dstride;
- let mut dst = &mut buf.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.stride[1];
let soff = buf.offset[1];
let off = soff + (xpos >> 1) + x * 8 + ((ypos >> 1) + y * 8) * dstride;
- let mut dst = &mut buf.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.stride[2];
let soff = buf.offset[2];
let off = soff + (xpos >> 1) + x * 8 + ((ypos >> 1) + y * 8) * dstride;
- let mut dst = &mut buf.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);
}
}
}
} 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<MVInfo>, size: usize) {
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<usize> = Vec::new();
hdr.parse_slice_sizes(&mut br, &mut slices)?;
match hdr.ftype {
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);
}
}
-pub fn get_decoder() -> Box<dyn NADecoder> {
+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<NAValue> {
+ match name {
+ FRAME_SKIP_OPTION => Some(NAValue::String(self.skip_mode.to_string())),
+ _ => None,
+ }
+ }
+}
+
+pub fn get_decoder() -> Box<dyn NADecoder + Send> {
Box::new(RealVideo60Decoder::new())
}
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],
+ [0xea406850, 0x400802b8, 0xac106fb6, 0xe1e2e766],
+ [0x2b1f1807, 0x09edef33, 0x0e6c78c1, 0x3b3c8179],
+ [0xb04e2626, 0x976e16f5, 0xc41a7a78, 0x2d8765da],
+ [0xf4f30d97, 0x7f2876eb, 0x265ffad4, 0x3542a7c4],
+ [0x7fd46b65, 0x9e56b770, 0xffa13e3b, 0x73d47eb6],
+ [0xa3ec74e1, 0xc33617ab, 0xb49c744b, 0x7d1c8127],
+ [0x830d85c2, 0x1df398c3, 0x40f33a4f, 0x445d95b3],
+ [0xa5471116, 0x9299e39f, 0x98da1680, 0x1aabeed5],
+ [0xd89ef645, 0x66c684fe, 0x6d5e4207, 0x5e480550],
+ [0xdf434d0c, 0xf0018799, 0x935aa650, 0xcfc702fc],
+ [0x9770cae6, 0x8a7caa6a, 0x87b6438d, 0x7b161519],
+ [0x9a2dfade, 0x3ff56dbe, 0x5fbc6999, 0x827770e9]]));
}
}
projects / nihav.git / blobdiff