rv20: calculate proper frame timestamps

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

diff --git a/nihav-realmedia/src/codecs/rv20.rs b/nihav-realmedia/src/codecs/rv20.rs
index 44386f6967b4c0a90cc8e11d77920ea9ce8fc2eb..804758eb0fda1ac331246d0db43ac56d714d7404 100644 (file)
--- a/nihav-realmedia/src/codecs/rv20.rs
+++ b/nihav-realmedia/src/codecs/rv20.rs
@@ -3,10 +3,11 @@ use nihav_core::io::codebook::*;
 use nihav_core::formats;
 use nihav_core::frame::*;
 use nihav_core::codecs::*;
-use nihav_core::codecs::h263::*;
-use nihav_core::codecs::h263::code::H263BlockDSP;
-use nihav_core::codecs::h263::decoder::*;
-use nihav_core::codecs::h263::data::*;
+use nihav_codec_support::codecs::{MV, ZIGZAG};
+use nihav_codec_support::codecs::h263::*;
+use nihav_codec_support::codecs::h263::code::H263BlockDSP;
+use nihav_codec_support::codecs::h263::decoder::*;
+use nihav_codec_support::codecs::h263::data::*;
 
 
 #[allow(dead_code)]
@@ -38,6 +39,9 @@ struct RealVideo20Decoder {
     minor_ver:  u8,
     rpr:        RPRInfo,
     bdsp:       H263BlockDSP,
+    base_ts:    u64,
+    last_ts:    u16,
+    next_ts:    u16,
 }
 
 struct RealVideo20BR<'a> {
@@ -53,6 +57,7 @@ struct RealVideo20BR<'a> {
     mb_pos_bits: u8,
     minor_ver:  u8,
     rpr:        RPRInfo,
+    pts:        u16,
 }
 
 struct RV20SliceInfo {
@@ -68,7 +73,7 @@ struct RV20SliceInfo {
 
 impl RV20SliceInfo {
     fn new(ftype: Type, seq: u32, qscale: u8, mb_x: usize, mb_y: usize, mb_pos: usize, w: usize, h: usize) -> Self {
-        RV20SliceInfo { ftype: ftype, seq: seq, qscale: qscale, mb_x: mb_x, mb_y: mb_y, mb_pos: mb_pos, w: w, h: h }
+        RV20SliceInfo { ftype, seq, qscale, mb_x, mb_y, mb_pos, w, h }
     }
 }
 
@@ -78,7 +83,7 @@ impl<'a> RealVideo20BR<'a> {
         let mut slice_offs = Vec::with_capacity(nslices);
         {
             let offs = &src[1..][..nslices * 8];
-            let mut br = BitReader::new(offs, offs.len(), BitReaderMode::BE);
+            let mut br = BitReader::new(offs, BitReaderMode::BE);
             for _ in 0..nslices {
                 br.skip(32).unwrap();
                 let off = br.read(32).unwrap();
@@ -97,18 +102,19 @@ impl<'a> RealVideo20BR<'a> {
             }
         }
         RealVideo20BR {
-            br:         BitReader::new(&src[soff..], src.len() - soff, BitReaderMode::BE),
-            tables:     tables,
+            br:         BitReader::new(&src[soff..], BitReaderMode::BE),
+            tables,
             num_slices: nslices,
             slice_no:   0,
             slice_off:  slice_offs,
             w:          width,
             h:          height,
-            mb_w:       mb_w,
-            mb_h:       mb_h,
+            mb_w,
+            mb_h,
             mb_pos_bits: mbpb,
-            minor_ver:  minor_ver,
-            rpr:        rpr,
+            minor_ver,
+            rpr,
+            pts:        0,
         }
     }
 
@@ -126,7 +132,7 @@ impl<'a> RealVideo20BR<'a> {
         let scan = match acpred {
                     ACPredMode::Hor => H263_SCAN_V,
                     ACPredMode::Ver => H263_SCAN_H,
-                    _               => H263_ZIGZAG,
+                    _               => &ZIGZAG,
                 };
 
         let rl_cb = if sstate.is_iframe { &self.tables.aic_rl_cb } else { &self.tables.rl_cb };
@@ -381,6 +387,7 @@ impl<'a> RealVideo20BR<'a> {
             } else {
                 br.read(13)? << 3
             };
+        self.pts = seq as u16;
         let w;
         let h;
         if self.rpr.present {
@@ -432,32 +439,35 @@ impl RealVideo20Decoder {
         let mv_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 
         let tables = Tables {
-            intra_mcbpc_cb: intra_mcbpc_cb,
-            inter_mcbpc_cb: inter_mcbpc_cb,
-            mbtype_b_cb:    mbtype_b_cb,
-            cbpy_cb:        cbpy_cb,
-            cbpc_b_cb:      cbpc_b_cb,
-            rl_cb:          rl_cb,
-            aic_rl_cb:      aic_rl_cb,
-            mv_cb:          mv_cb,
+            intra_mcbpc_cb,
+            inter_mcbpc_cb,
+            mbtype_b_cb,
+            cbpy_cb,
+            cbpc_b_cb,
+            rl_cb,
+            aic_rl_cb,
+            mv_cb,
         };
 
         RealVideo20Decoder{
             info:           NACodecInfoRef::default(),
             dec:            H263BaseDecoder::new_b_frames(false),
-            tables:         tables,
+            tables,
             w:              0,
             h:              0,
             minor_ver:      0,
             rpr:            RPRInfo { present: false, bits: 0, widths: [0; 8], heights: [0; 8] },
             bdsp:           H263BlockDSP::new(),
+            base_ts:        0,
+            last_ts:        0,
+            next_ts:        0,
         }
     }
 }
 
 impl NADecoder for RealVideo20Decoder {
 #[allow(unused_variables)]
-    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();
@@ -491,7 +501,7 @@ impl NADecoder for RealVideo20Decoder {
             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 ibr = RealVideo20BR::new(&src, &self.tables, self.w, self.h, self.minor_ver, self.rpr);
@@ -499,10 +509,25 @@ impl NADecoder for RealVideo20Decoder {
         let bufinfo = self.dec.parse_frame(&mut ibr, &self.bdsp)?;
 
         let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
+        let ftype = self.dec.get_frame_type();
+        let pts = ibr.pts;
+        if ftype != FrameType::B {
+            self.last_ts = self.next_ts;
+            self.next_ts = pts;
+            if self.last_ts > self.next_ts {
+                self.base_ts += 1 << 16;
+            }
+        }
+        let ts_diff = self.next_ts.wrapping_sub(pts);
+        let ts = self.base_ts + (self.next_ts as u64) - (ts_diff as u64);
         frm.set_keyframe(self.dec.is_intra());
-        frm.set_frame_type(self.dec.get_frame_type());
+        frm.set_frame_type(ftype);
+        frm.set_pts(Some(ts >> 3));
         Ok(frm.into_ref())
     }
+    fn flush(&mut self) {
+        self.dec.flush();
+    }
 }
 
 struct MBB { blocks: usize, bits: u8 }
@@ -516,7 +541,7 @@ const H263_MBB: &[MBB; 7] = &[
     MBB{ blocks: 65536, bits: 14 },
 ];
 
-pub fn get_decoder() -> Box<NADecoder> {
+pub fn get_decoder() -> Box<dyn NADecoder + Send> {
     Box::new(RealVideo20Decoder::new())
 }
 
@@ -524,9 +549,9 @@ pub fn get_decoder() -> Box<NADecoder> {
 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_codecs;
+    use crate::realmedia_register_all_demuxers;
     #[test]
     fn test_rv20() {
         let mut dmx_reg = RegisteredDemuxers::new();