make all codec crates export just register_all functions and document them

[nihav.git] / nihav-realmedia / src / codecs / rv40.rs

diff --git a/nihav-realmedia/src/codecs/rv40.rs b/nihav-realmedia/src/codecs/rv40.rs
index 542b644006be82ff1511e987e8714cca952e9a7d..5f95f0a966fe88ab6c411923d1d7aeef5c00f5e5 100644 (file)
--- a/nihav-realmedia/src/codecs/rv40.rs
+++ b/nihav-realmedia/src/codecs/rv40.rs
@@ -1,5 +1,3 @@
-use std::rc::Rc;
-use std::cell::RefCell;
 use nihav_core::formats;
 use nihav_core::frame::*;
 use nihav_core::io::bitreader::*;
@@ -99,15 +97,15 @@ impl RealVideo40BR {
         RealVideo40BR {
             width:          0,
             height:         0,
-            aic_top_cb:     aic_top_cb,
-            aic_mode1_cb:   aic_mode1_cb,
-            aic_mode2_cb:   aic_mode2_cb,
-            ptype_cb:       ptype_cb,
-            btype_cb:       btype_cb,
+            aic_top_cb,
+            aic_mode1_cb,
+            aic_mode2_cb,
+            ptype_cb,
+            btype_cb,
             had_skip_run:   false,
         }
     }
-    fn predict_b_mv_component(&self, sstate: &SState, mvi: &MVInfo, mbinfo: &Vec<RV34MBInfo>, mbtype: MBType, fwd: bool) -> MV {
+    fn predict_b_mv_component(&self, sstate: &SState, mvi: &MVInfo, mbinfo: &[RV34MBInfo], mbtype: MBType, fwd: bool) -> MV {
         let mut pred_mvs: [MV; 3] = [ZERO_MV; 3];
         let mut mv_count: usize = 0;
         let mb_x = sstate.mb_x;
@@ -194,7 +192,7 @@ impl RV34BitstreamDecoder for RealVideo40BR {
 
         self.had_skip_run = false;
 
-        Ok(RV34SliceHeader{ ftype: ftype, quant: q, deblock: deblock, pts: pts, width: w, height: h, start: start, end: 0, set_idx: set_idx })
+        Ok(RV34SliceHeader{ ftype, quant: q, deblock, pts, width: w, height: h, start, end: 0, set_idx })
     }
     fn decode_intra_pred(&mut self, br: &mut BitReader, types: &mut [i8], mut pos: usize, tstride: usize, has_top: bool) -> DecoderResult<()> {
         let start;
@@ -278,9 +276,9 @@ impl RV34BitstreamDecoder for RealVideo40BR {
             mbtype = if ftype == FrameType::P { br.read_cb(&self.ptype_cb[idx])? }
                      else { br.read_cb(&self.btype_cb[idx])? };
         }
-        Ok(MBInfo { mbtype: mbtype, skip_run: 0, dquant: dquant })
+        Ok(MBInfo { mbtype, skip_run: 0, dquant })
     }
-    fn predict_b_mv(&self, sstate: &SState, mvi: &MVInfo, mbtype: MBType, mvs: &[MV], mbinfo: &Vec<RV34MBInfo>) -> (MV, MV) {
+    fn predict_b_mv(&self, sstate: &SState, mvi: &MVInfo, mbtype: MBType, mvs: &[MV], mbinfo: &[RV34MBInfo]) -> (MV, MV) {
         let mut mv_f = self.predict_b_mv_component(sstate, mvi, mbinfo, mbtype, true);
         let mut mv_b = self.predict_b_mv_component(sstate, mvi, mbinfo, mbtype, false);
 
@@ -301,7 +299,7 @@ impl RV34BitstreamDecoder for RealVideo40BR {
 
 struct RealVideo40Decoder {
     bd:         RealVideo40BR,
-    info:       Rc<NACodecInfo>,
+    info:       NACodecInfoRef,
     dec:        RV34Decoder,
 }
 
@@ -309,60 +307,76 @@ impl RealVideo40Decoder {
     fn new() -> Self {
         RealVideo40Decoder{
             bd:         RealVideo40BR::new(),
-            info:       Rc::new(DUMMY_CODEC_INFO),
+            info:       NACodecInfoRef::default(),
             dec:        RV34Decoder::new(false, Box::new(RV40DSP::new())),
         }
     }
 }
 
 impl NADecoder for RealVideo40Decoder {
-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let fmt = formats::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;
 
 {
 println!("edata:");
-for i in 0..src.len() { print!(" {:02X}", src[i]); } println!("");
+for i in 0..src.len() { print!(" {:02X}", src[i]); } println!();
 }
             if src.len() < 2 { return Err(DecoderError::InvalidData); }
 
             self.bd.width  = vinfo.get_width();
             self.bd.height = vinfo.get_height();
+
+            supp.pool_u8.set_dec_bufs(3);
+            supp.pool_u8.prealloc_video(NAVideoInfo::new(self.bd.width, self.bd.height, false, fmt), 4)?;
+
             Ok(())
         } else {
 println!("???");
             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 (bufinfo, ftype, ts) = self.dec.parse_frame(src.as_slice(), &mut self.bd)?;
+        let (bufinfo, ftype, ts) = self.dec.parse_frame(supp, src.as_slice(), &mut self.bd)?;
 
         let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
         frm.set_keyframe(ftype == FrameType::I);
         frm.set_frame_type(ftype);
         frm.set_pts(Some(ts));
-        Ok(Rc::new(RefCell::new(frm)))
+        Ok(frm.into_ref())
+    }
+    fn flush(&mut self) {
+        self.dec.flush();
     }
 }
 
-pub fn get_decoder() -> Box<NADecoder> {
+pub fn get_decoder() -> Box<dyn NADecoder + Send> {
     Box::new(RealVideo40Decoder::new())
 }
 
 #[cfg(test)]
 mod test {
-    use crate::test::dec_video::test_file_decoding;
+    use nihav_core::codecs::RegisteredDecoders;
+    use nihav_core::demuxers::RegisteredDemuxers;
+    use nihav_core::test::dec_video::*;
+    use crate::realmedia_register_all_codecs;
+    use crate::realmedia_register_all_demuxers;
     #[test]
     fn test_rv40() {
+        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);
+
 //         test_file_decoding("realmedia", "assets/RV/rv40_ralf.rmvb", Some(1000), true, false, /*None*/Some("rv40"));
-         test_file_decoding("realmedia", "assets/RV/rv40_weighted_mc.rmvb", Some(400), true, false, None/*Some("rv40")*/);
+        test_file_decoding("realmedia", "assets/RV/rv40_weighted_mc.rmvb", Some(400), true, false, None/*Some("rv40")*/, &dmx_reg, &dec_reg);
 //         test_file_decoding("realmedia", "assets/RV/rv40_weighted_mc_2.rmvb", Some(1000), true, false, /*None*/Some("rv40"));
 //panic!("end");
     }