aac: clear M/S flags

[nihav.git] / nihav-duck / src / codecs / vp8.rs

diff --git a/nihav-duck/src/codecs/vp8.rs b/nihav-duck/src/codecs/vp8.rs
index 9a9c4ccb8902155b027dcc3c23ccd136f0544d52..6e34f591fb839b52c1f0d0be8a0f67ae0e8a6ae1 100644 (file)
--- a/nihav-duck/src/codecs/vp8.rs
+++ b/nihav-duck/src/codecs/vp8.rs
@@ -7,18 +7,15 @@ use super::vp78data::*;
 use super::vp78dsp::*;
 use super::vp8dsp::*;
 
-#[derive(Clone,Copy,PartialEq,Debug)]
+#[derive(Clone,Copy,PartialEq,Debug,Default)]
 enum VP8Ref {
+    #[default]
     Intra,
     Last,
     Golden,
     AltRef,
 }
 
-impl Default for VP8Ref {
-    fn default() -> Self { VP8Ref::Intra }
-}
-
 #[derive(Default)]
 pub struct VP8Shuffler {
     lastframe: Option<NAVideoBufferRef<u8>>,
@@ -43,25 +40,13 @@ impl VP8Shuffler {
         self.altframe = Some(buf);
     }
     pub fn get_last(&mut self) -> Option<NAVideoBufferRef<u8>> {
-        if let Some(ref frm) = self.lastframe {
-            Some(frm.clone())
-        } else {
-            None
-        }
+        self.lastframe.as_ref().cloned()
     }
     pub fn get_golden(&mut self) -> Option<NAVideoBufferRef<u8>> {
-        if let Some(ref frm) = self.goldframe {
-            Some(frm.clone())
-        } else {
-            None
-        }
+        self.goldframe.as_ref().cloned()
     }
     pub fn get_altref(&mut self) -> Option<NAVideoBufferRef<u8>> {
-        if let Some(ref frm) = self.altframe {
-            Some(frm.clone())
-        } else {
-            None
-        }
+        self.altframe.as_ref().cloned()
     }
     pub fn has_refs(&self) -> bool {
         self.lastframe.is_some()
@@ -975,7 +960,7 @@ impl VP8Decoder {
             }.unwrap();
         let single_mv = self.mb_info[mb_x + mb_y * self.mb_w].mb_type != VPMBType::InterFourMV;
         let mut iidx = mb_x * 4 + mb_y * 4 * self.mv_stride;
-        let mut mc_buf = self.mc_buf.get_data_mut().unwrap();
+        let mc_buf = self.mc_buf.get_data_mut().unwrap();
 
         let dst = &mut dframe.data[0..];
         let ystride = dframe.stride[0];
@@ -983,20 +968,20 @@ impl VP8Decoder {
         if single_mv {
             if self.dstate.version == 0 {
                 mc_block16x16(dst, yoff, ystride, mb_x * 16, mb_y * 16,
-                              self.mvs[iidx].x * 2, self.mvs[iidx].y * 2, refframe.clone(), 0, &mut mc_buf);
+                              self.mvs[iidx].x * 2, self.mvs[iidx].y * 2, refframe.clone(), 0, mc_buf);
             } else {
                 mc_block16x16_bilin(dst, yoff, ystride, mb_x * 16, mb_y * 16,
-                              self.mvs[iidx].x * 2, self.mvs[iidx].y * 2, refframe.clone(), 0, &mut mc_buf);
+                              self.mvs[iidx].x * 2, self.mvs[iidx].y * 2, refframe.clone(), 0, mc_buf);
             }
         } else {
             for y in 0..4 {
                 for x in 0..4 {
                     if self.dstate.version == 0 {
                         mc_block4x4(dst, yoff + x * 4, ystride, mb_x * 16 + x * 4, mb_y * 16 + y * 4,
-                                    self.mvs[iidx + x].x * 2, self.mvs[iidx + x].y * 2, refframe.clone(), 0, &mut mc_buf);
+                                    self.mvs[iidx + x].x * 2, self.mvs[iidx + x].y * 2, refframe.clone(), 0, mc_buf);
                     } else {
                         mc_block4x4_bilin(dst, yoff + x * 4, ystride, mb_x * 16 + x * 4, mb_y * 16 + y * 4,
-                                          self.mvs[iidx + x].x * 2, self.mvs[iidx + x].y * 2, refframe.clone(), 0, &mut mc_buf);
+                                          self.mvs[iidx + x].x * 2, self.mvs[iidx + x].y * 2, refframe.clone(), 0, mc_buf);
                     }
                 }
                 yoff += 4 * ystride;
@@ -1013,15 +998,15 @@ impl VP8Decoder {
             let mut chroma_mv = self.mvs[iidx];
 
             if self.dstate.version == 0 {
-                mc_block8x8(dst, uoff, ustride, mb_x * 8, mb_y * 8, chroma_mv.x, chroma_mv.y, refframe.clone(), 1, &mut mc_buf);
-                mc_block8x8(dst, voff, vstride, mb_x * 8, mb_y * 8, chroma_mv.x, chroma_mv.y, refframe,         2, &mut mc_buf);
+                mc_block8x8(dst, uoff, ustride, mb_x * 8, mb_y * 8, chroma_mv.x, chroma_mv.y, refframe.clone(), 1, mc_buf);
+                mc_block8x8(dst, voff, vstride, mb_x * 8, mb_y * 8, chroma_mv.x, chroma_mv.y, refframe,         2, mc_buf);
             } else {
                 if self.dstate.version == 3 {
                     chroma_mv.x &= !7;
                     chroma_mv.y &= !7;
                 }
-                mc_block8x8_bilin(dst, uoff, ustride, mb_x * 8, mb_y * 8, chroma_mv.x, chroma_mv.y, refframe.clone(), 1, &mut mc_buf);
-                mc_block8x8_bilin(dst, voff, vstride, mb_x * 8, mb_y * 8, chroma_mv.x, chroma_mv.y, refframe,         2, &mut mc_buf);
+                mc_block8x8_bilin(dst, uoff, ustride, mb_x * 8, mb_y * 8, chroma_mv.x, chroma_mv.y, refframe.clone(), 1, mc_buf);
+                mc_block8x8_bilin(dst, voff, vstride, mb_x * 8, mb_y * 8, chroma_mv.x, chroma_mv.y, refframe,         2, mc_buf);
             }
         } else {
             for y in 0..2 {
@@ -1049,14 +1034,14 @@ impl VP8Decoder {
 
                     if self.dstate.version == 0 {
                         mc_block4x4(dst, uoff + x * 4, ustride, mb_x * 8 + x * 4, mb_y * 8 + y * 4,
-                                    chroma_mv.x, chroma_mv.y, refframe.clone(), 1, &mut mc_buf);
+                                    chroma_mv.x, chroma_mv.y, refframe.clone(), 1, mc_buf);
                         mc_block4x4(dst, voff + x * 4, vstride, mb_x * 8 + x * 4, mb_y * 8 + y * 4,
-                                    chroma_mv.x, chroma_mv.y, refframe.clone(), 2, &mut mc_buf);
+                                    chroma_mv.x, chroma_mv.y, refframe.clone(), 2, mc_buf);
                     } else {
                         mc_block4x4_bilin(dst, uoff + x * 4, ustride, mb_x * 8 + x * 4, mb_y * 8 + y * 4,
-                                          chroma_mv.x, chroma_mv.y, refframe.clone(), 1, &mut mc_buf);
+                                          chroma_mv.x, chroma_mv.y, refframe.clone(), 1,  mc_buf);
                         mc_block4x4_bilin(dst, voff + x * 4, vstride, mb_x * 8 + x * 4, mb_y * 8 + y * 4,
-                                          chroma_mv.x, chroma_mv.y, refframe.clone(), 2, &mut mc_buf);
+                                          chroma_mv.x, chroma_mv.y, refframe.clone(), 2, mc_buf);
                     }
                 }
                 uoff += ustride * 4;
@@ -1281,13 +1266,10 @@ impl NADecoder for VP8Decoder {
         for start in part_offs[num_partitions..].iter_mut() {
             *start = data_start;
         }
-        let mut bc_src = unsafe {
-                let mut arr: [BoolCoder; 8] = std::mem::MaybeUninit::uninit().assume_init();
-                for (bc, &off) in arr.iter_mut().zip(part_offs.iter()) {
-                    std::ptr::write(bc, BoolCoder::new(&src[off..]).unwrap());
-                }
-                arr
-            };
+        let mut bc_src = Vec::new();
+        for &off in part_offs.iter() {
+            bc_src.push(BoolCoder::new(&src[off..]).unwrap());
+        }
 
         let vinfo = NAVideoInfo::new(self.width, self.height, false, YUV420_FORMAT);
         let ret = supp.pool_u8.get_free();
@@ -1554,7 +1536,7 @@ mod test {
         let mut dec_reg = RegisteredDecoders::new();
         duck_register_all_decoders(&mut dec_reg);
 
-        test_decoding("ivf", "vp8", name, None, &dmx_reg,
+        test_decoding("dkivf", "vp8", name, None, &dmx_reg,
                       &dec_reg, ExpectedTestResult::MD5(hash));
     }