intel263: fix quantisation

[nihav.git] / nihav-indeo / src / codecs / intel263.rs

diff --git a/nihav-indeo/src/codecs/intel263.rs b/nihav-indeo/src/codecs/intel263.rs
index b42b5d2617e8ba1659468c7b5f128b0e3d5839b4..b2e58cbfdadf75df3eba76b091ae6a0584fe97e9 100644 (file)
--- a/nihav-indeo/src/codecs/intel263.rs
+++ b/nihav-indeo/src/codecs/intel263.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::decoder::*;
-use nihav_core::codecs::h263::data::*;
-use nihav_core::codecs::h263::code::H263BlockDSP;
+use nihav_codec_support::codecs::{MV, ZIGZAG};
+use nihav_codec_support::codecs::h263::*;
+use nihav_codec_support::codecs::h263::decoder::*;
+use nihav_codec_support::codecs::h263::data::*;
+use nihav_codec_support::codecs::h263::code::H263BlockDSP;
 
 #[allow(dead_code)]
 struct Tables {
@@ -23,6 +24,8 @@ struct Intel263Decoder {
     dec:     H263BaseDecoder,
     tables:  Tables,
     bdsp:    H263BlockDSP,
+    lastframe:  Option<NABufferType>,
+    lastpts:    Option<u64>,
 }
 
 struct Intel263BR<'a> {
@@ -43,7 +46,7 @@ fn check_marker<'a>(br: &mut BitReader<'a>) -> DecoderResult<()> {
 impl<'a> Intel263BR<'a> {
     fn new(src: &'a [u8], tables: &'a Tables) -> Self {
         Intel263BR {
-            br:     BitReader::new(src, src.len(), BitReaderMode::BE),
+            br:     BitReader::new(src, BitReaderMode::BE),
             tables,
             gob_no: 0,
             mb_w:   0,
@@ -76,7 +79,11 @@ impl<'a> Intel263BR<'a> {
                 level = code.get_level();
                 last  = code.is_last();
                 if br.read_bool()? { level = -level; }
-                level = (level * q) + q_add;
+                if level > 0 {
+                    level = (level * q) + q_add;
+                } else {
+                    level = (level * q) - q_add;
+                }
             } else {
                 last  = br.read_bool()?;
                 run   = br.read(6)? as u8;
@@ -86,7 +93,11 @@ impl<'a> Intel263BR<'a> {
                     let top = br.read_s(6)? as i16;
                     level = (top << 5) | low;
                 }
-                level = (level * q) + q_add;
+                if level > 0 {
+                    level = (level * q) + q_add;
+                } else {
+                    level = (level * q) - q_add;
+                }
                 if level < -2048 { level = -2048; }
                 if level >  2047 { level =  2047; }
             }
@@ -359,6 +370,8 @@ impl Intel263Decoder {
             dec:            H263BaseDecoder::new(true),
             tables,
             bdsp:           H263BlockDSP::new(),
+            lastframe:      None,
+            lastpts:        None,
         }
     }
 }
@@ -380,28 +393,46 @@ impl NADecoder for Intel263Decoder {
         let src = pkt.get_buffer();
 
         if src.len() == 8 {
-            let bret = self.dec.get_bframe(&self.bdsp);
             let buftype;
-            let is_skip;
-            if let Ok(btype) = bret {
-                buftype = btype;
-                is_skip = false;
-            } else {
+            let ftype;
+            if self.lastframe.is_none() {
                 buftype = NABufferType::None;
-                is_skip = true;
+                ftype = FrameType::Skip;
+            } else {
+                let mut buf = None;
+                std::mem::swap(&mut self.lastframe, &mut buf);
+                buftype = buf.unwrap();
+                ftype = FrameType::B;
             }
             let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), buftype);
             frm.set_keyframe(false);
-            frm.set_frame_type(if is_skip { FrameType::Skip } else { FrameType::B });
+            frm.set_frame_type(ftype);
+            if self.lastpts.is_some() {
+                frm.set_pts(self.lastpts);
+                self.lastpts = None;
+            }
             return Ok(frm.into_ref());
         }
         let mut ibr = Intel263BR::new(&src, &self.tables);
 
         let bufinfo = self.dec.parse_frame(&mut ibr, &self.bdsp)?;
 
+        let mut cur_pts = pkt.get_pts();
+        if !self.dec.is_intra() {
+            let bret = self.dec.get_bframe(&self.bdsp);
+            if let Ok(b_buf) = bret {
+                self.lastframe = Some(b_buf);
+                self.lastpts = pkt.get_pts();
+                if let Some(pts) = pkt.get_pts() {
+                    cur_pts = Some(pts + 1);
+                }
+            }
+        }
+
         let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
         frm.set_keyframe(self.dec.is_intra());
         frm.set_frame_type(if self.dec.is_intra() { FrameType::I } else { FrameType::P });
+        frm.set_pts(cur_pts);
         Ok(frm.into_ref())
     }
     fn flush(&mut self) {
@@ -418,9 +449,9 @@ pub fn get_decoder() -> Box<dyn NADecoder + Send> {
 mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
-    use nihav_core::test::dec_video::*;
-    use crate::codecs::indeo_register_all_codecs;
-    use nihav_commonfmt::demuxers::generic_register_all_demuxers;
+    use nihav_codec_support::test::dec_video::*;
+    use crate::indeo_register_all_codecs;
+    use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_intel263() {
         let mut dmx_reg = RegisteredDemuxers::new();