rv6: fix typo in chroma filtering loop

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

diff --git a/nihav-realmedia/src/codecs/rv60.rs b/nihav-realmedia/src/codecs/rv60.rs
index ecc400a7c821128a599e864d90aa0ca3994cf8b8..ca04fb1f958373575b96711b556f5d92f6f8cd18 100644 (file)
--- a/nihav-realmedia/src/codecs/rv60.rs
+++ b/nihav-realmedia/src/codecs/rv60.rs
@@ -41,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,
@@ -123,7 +124,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);
@@ -305,16 +306,10 @@ 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)
     }
 }
 
@@ -367,22 +362,13 @@ impl MVRef {
         }
     }
     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)
     }
 }
 
@@ -691,7 +677,7 @@ impl RealVideo60Decoder {
         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 {
@@ -728,7 +714,7 @@ println!(" left {} bits", br.left());
 }
         Ok(())
     }
-    #[allow(clippy::cyclomatic_complexity)]
+    #[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(()); }
 
@@ -764,9 +750,9 @@ println!(" left {} bits", br.left());
                             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);
                         }
                     },
                 _ => {
@@ -865,8 +851,8 @@ println!(" left {} bits", br.left());
                                             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);
                                         }
                                     }
                                 }
@@ -879,15 +865,15 @@ println!(" left {} bits", br.left());
                                             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);
                                         }
                                     }
                                 }
@@ -904,10 +890,10 @@ println!(" left {} bits", br.left());
                                 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];
@@ -915,8 +901,7 @@ println!(" left {} bits", br.left());
                                     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 {
@@ -924,16 +909,14 @@ println!(" left {} bits", br.left());
                                 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);
                             }
                         }
                     },
@@ -947,24 +930,21 @@ println!(" left {} bits", br.left());
                                 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);
                             }
                         }
                     },
@@ -989,24 +969,21 @@ println!(" left {} bits", br.left());
                                         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);
                                     }
                                 }
                             }
@@ -1506,7 +1483,7 @@ println!("???");
         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);
@@ -1589,15 +1566,16 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::realmedia_register_all_codecs;
+    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);
 
+        // 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],
@@ -1605,13 +1583,13 @@ mod test {
                             [0x2b1f1807, 0x09edef33, 0x0e6c78c1, 0x3b3c8179],
                             [0xb04e2626, 0x976e16f5, 0xc41a7a78, 0x2d8765da],
                             [0xf4f30d97, 0x7f2876eb, 0x265ffad4, 0x3542a7c4],
-                            [0xa5082524, 0x38a86952, 0x35bf1fee, 0xfc830d3f],
-                            [0x75eab1a2, 0x62e2222f, 0xe96a20d9, 0x652140b4],
-                            [0x7590fa49, 0x78c83490, 0x239eeff9, 0x64282ac7],
-                            [0x70b19e9f, 0x66c1f866, 0xb8d7142a, 0xf3e424b2],
-                            [0xc2934123, 0x3bf72fc4, 0x12d8d123, 0x1f39525b],
-                            [0x13344919, 0xecd01190, 0x2f69079b, 0xbf4d7026],
-                            [0xcefb3284, 0xa9b36d4d, 0xf1aa6752, 0xaae17d44],
-                            [0x57f01275, 0xf8e883ea, 0x4865752e, 0xc760a777]]));
+                            [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]]));
     }
 }