aac: clear M/S flags
[nihav.git] / nihav-duck / src / codecs / vp3.rs
index 9d5693622ac95304c5ab9787c613da1499fd6b1d..08bfd1a97f58de69693c930025f6d7ac0ca307e6 100644 (file)
@@ -32,26 +32,29 @@ fn map_mbt(idx: usize) -> VPMBType {
 
 impl VP30Codes {
     fn new() -> Self {
-        let mut dc_cb:   [Codebook<u8>; 5];
-        let mut ac_i_cb: [Codebook<u8>; 5];
-        let mut ac_p_cb: [Codebook<u8>; 5];
+        let dc_cb;
+        let ac_i_cb;
+        let ac_p_cb;
         let mut cr = TableCodebookDescReader::new(&VP30_MBTYPE_CODES, &VP30_MBTYPE_BITS, map_mbt);
         let mbtype_cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
         unsafe {
-            dc_cb = mem::uninitialized();
-            ac_i_cb = mem::uninitialized();
-            ac_p_cb = mem::uninitialized();
+            let mut udc_cb: mem::MaybeUninit::<[Codebook<u8>; 5]> = mem::MaybeUninit::uninit();
+            let mut uac_i_cb: mem::MaybeUninit::<[Codebook<u8>; 5]> = mem::MaybeUninit::uninit();
+            let mut uac_p_cb: mem::MaybeUninit::<[Codebook<u8>; 5]> = mem::MaybeUninit::uninit();
             for i in 0..5 {
                 let mut cr = TableCodebookDescReader::new(&VP30_DC_CODES[i], &VP30_DC_BITS[i], map_idx);
                 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
-                ptr::write(&mut dc_cb[i], cb);
+                ptr::write(&mut (*udc_cb.as_mut_ptr())[i], cb);
                 let mut cr = TableCodebookDescReader::new(&VP30_AC_INTRA_CODES[i], &VP30_AC_INTRA_BITS[i], map_idx);
                 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
-                ptr::write(&mut ac_i_cb[i], cb);
+                ptr::write(&mut (*uac_i_cb.as_mut_ptr())[i], cb);
                 let mut cr = TableCodebookDescReader::new(&VP30_AC_INTER_CODES[i], &VP30_AC_INTER_BITS[i], map_idx);
                 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
-                ptr::write(&mut ac_p_cb[i], cb);
+                ptr::write(&mut (*uac_p_cb.as_mut_ptr())[i], cb);
             }
+            dc_cb   = udc_cb.assume_init();
+            ac_i_cb = uac_i_cb.assume_init();
+            ac_p_cb = uac_p_cb.assume_init();
         }
         Self { dc_cb, ac_i_cb, ac_p_cb, mbtype_cb }
     }
@@ -67,68 +70,78 @@ struct VP31Codes {
 
 impl VP31Codes {
     fn new() -> Self {
-        let mut dc_cb: [Codebook<u8>; 16];
-        let mut ac0_cb: [Codebook<u8>; 16];
-        let mut ac1_cb: [Codebook<u8>; 16];
-        let mut ac2_cb: [Codebook<u8>; 16];
-        let mut ac3_cb: [Codebook<u8>; 16];
+        let dc_cb;
+        let ac0_cb;
+        let ac1_cb;
+        let ac2_cb;
+        let ac3_cb;
         unsafe {
-            dc_cb = mem::uninitialized();
-            ac0_cb = mem::uninitialized();
-            ac1_cb = mem::uninitialized();
-            ac2_cb = mem::uninitialized();
-            ac3_cb = mem::uninitialized();
+            let mut udc_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
+            let mut uac0_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
+            let mut uac1_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
+            let mut uac2_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
+            let mut uac3_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
             for i in 0..16 {
                 let mut cr = TableCodebookDescReader::new(&VP31_DC_CODES[i], &VP31_DC_BITS[i], map_idx);
                 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
-                ptr::write(&mut dc_cb[i], cb);
+                ptr::write(&mut (*udc_cb.as_mut_ptr())[i], cb);
 
                 let mut cr = TableCodebookDescReader::new(&VP31_AC_CAT0_CODES[i], &VP31_AC_CAT0_BITS[i], map_idx);
                 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
-                ptr::write(&mut ac0_cb[i], cb);
+                ptr::write(&mut (*uac0_cb.as_mut_ptr())[i], cb);
                 let mut cr = TableCodebookDescReader::new(&VP31_AC_CAT1_CODES[i], &VP31_AC_CAT1_BITS[i], map_idx);
                 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
-                ptr::write(&mut ac1_cb[i], cb);
+                ptr::write(&mut (*uac1_cb.as_mut_ptr())[i], cb);
                 let mut cr = TableCodebookDescReader::new(&VP31_AC_CAT2_CODES[i], &VP31_AC_CAT2_BITS[i], map_idx);
                 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
-                ptr::write(&mut ac2_cb[i], cb);
+                ptr::write(&mut (*uac2_cb.as_mut_ptr())[i], cb);
                 let mut cr = TableCodebookDescReader::new(&VP31_AC_CAT3_CODES[i], &VP31_AC_CAT3_BITS[i], map_idx);
                 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
-                ptr::write(&mut ac3_cb[i], cb);
+                ptr::write(&mut (*uac3_cb.as_mut_ptr())[i], cb);
             }
+            dc_cb = udc_cb.assume_init();
+            ac0_cb = uac0_cb.assume_init();
+            ac1_cb = uac1_cb.assume_init();
+            ac2_cb = uac2_cb.assume_init();
+            ac3_cb = uac3_cb.assume_init();
         }
         Self { dc_cb, ac0_cb, ac1_cb, ac2_cb, ac3_cb }
     }
     fn new_vp4() -> VP31Codes {
-        let mut dc_cb: [Codebook<u8>; 16];
-        let mut ac0_cb: [Codebook<u8>; 16];
-        let mut ac1_cb: [Codebook<u8>; 16];
-        let mut ac2_cb: [Codebook<u8>; 16];
-        let mut ac3_cb: [Codebook<u8>; 16];
+        let dc_cb;
+        let ac0_cb;
+        let ac1_cb;
+        let ac2_cb;
+        let ac3_cb;
         unsafe {
-            dc_cb = mem::uninitialized();
-            ac0_cb = mem::uninitialized();
-            ac1_cb = mem::uninitialized();
-            ac2_cb = mem::uninitialized();
-            ac3_cb = mem::uninitialized();
+            let mut udc_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
+            let mut uac0_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
+            let mut uac1_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
+            let mut uac2_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
+            let mut uac3_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
             for i in 0..16 {
                 let mut cr = TableCodebookDescReader::new(&VP40_DC_CODES[i], &VP40_DC_BITS[i], map_idx);
                 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
-                ptr::write(&mut dc_cb[i], cb);
+                ptr::write(&mut (*udc_cb.as_mut_ptr())[i], cb);
 
                 let mut cr = TableCodebookDescReader::new(&VP40_AC_CAT0_CODES[i], &VP40_AC_CAT0_BITS[i], map_idx);
                 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
-                ptr::write(&mut ac0_cb[i], cb);
+                ptr::write(&mut (*uac0_cb.as_mut_ptr())[i], cb);
                 let mut cr = TableCodebookDescReader::new(&VP40_AC_CAT1_CODES[i], &VP40_AC_CAT1_BITS[i], map_idx);
                 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
-                ptr::write(&mut ac1_cb[i], cb);
+                ptr::write(&mut (*uac1_cb.as_mut_ptr())[i], cb);
                 let mut cr = TableCodebookDescReader::new(&VP40_AC_CAT2_CODES[i], &VP40_AC_CAT2_BITS[i], map_idx);
                 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
-                ptr::write(&mut ac2_cb[i], cb);
+                ptr::write(&mut (*uac2_cb.as_mut_ptr())[i], cb);
                 let mut cr = TableCodebookDescReader::new(&VP40_AC_CAT3_CODES[i], &VP40_AC_CAT3_BITS[i], map_idx);
                 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
-                ptr::write(&mut ac3_cb[i], cb);
+                ptr::write(&mut (*uac3_cb.as_mut_ptr())[i], cb);
             }
+            dc_cb = udc_cb.assume_init();
+            ac0_cb = uac0_cb.assume_init();
+            ac1_cb = uac1_cb.assume_init();
+            ac2_cb = uac2_cb.assume_init();
+            ac3_cb = uac3_cb.assume_init();
         }
         VP31Codes { dc_cb, ac0_cb, ac1_cb, ac2_cb, ac3_cb }
     }
@@ -146,19 +159,21 @@ fn map_mv(idx: usize) -> i8 {
 
 impl VP40AuxCodes {
     fn new() -> Self {
-        let mut mv_x_cb: [Codebook<i8>; 7];
-        let mut mv_y_cb: [Codebook<i8>; 7];
+        let mv_x_cb;
+        let mv_y_cb;
         unsafe {
-            mv_x_cb = mem::uninitialized();
-            mv_y_cb = mem::uninitialized();
+            let mut umv_x_cb: mem::MaybeUninit::<[Codebook<i8>; 7]> = mem::MaybeUninit::uninit();
+            let mut umv_y_cb: mem::MaybeUninit::<[Codebook<i8>; 7]> = mem::MaybeUninit::uninit();
             for i in 0..7 {
                 let mut cr = TableCodebookDescReader::new(&VP40_MV_X_CODES[i], &VP40_MV_X_BITS[i], map_mv);
                 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
-                ptr::write(&mut mv_x_cb[i], cb);
+                ptr::write(&mut (*umv_x_cb.as_mut_ptr())[i], cb);
                 let mut cr = TableCodebookDescReader::new(&VP40_MV_Y_CODES[i], &VP40_MV_Y_BITS[i], map_mv);
                 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
-                ptr::write(&mut mv_y_cb[i], cb);
+                ptr::write(&mut (*umv_y_cb.as_mut_ptr())[i], cb);
             }
+            mv_x_cb = umv_x_cb.assume_init();
+            mv_y_cb = umv_y_cb.assume_init();
         }
         let mut cr0 = TableCodebookDescReader::new(&VP40_MBPAT_CODES[0], &VP40_MBPAT_BITS[0], map_idx);
         let mut cr1 = TableCodebookDescReader::new(&VP40_MBPAT_CODES[1], &VP40_MBPAT_BITS[1], map_idx);
@@ -1126,8 +1141,8 @@ impl VP34Decoder {
         if let Some(ref codes) = self.aux_codes {
             for _ in 0..self.y_blocks/4 {
                 if self.blocks[self.blk_addr[cur_blk] >> 2].btype == VPMBType::InterFourMV {
-                    let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv.x.abs() as usize]];
-                    let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv.y.abs() as usize]];
+                    let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv.x.unsigned_abs() as usize]];
+                    let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv.y.unsigned_abs() as usize]];
                     let x_sign = last_mv.x < 0;
                     let y_sign = last_mv.y < 0;
                     last2_mv = last_mv;
@@ -1152,8 +1167,8 @@ impl VP34Decoder {
                             cur_mv = ZERO_MV;
                         },
                         VPMBType::InterMV => {
-                            let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv.x.abs() as usize]];
-                            let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv.y.abs() as usize]];
+                            let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv.x.unsigned_abs() as usize]];
+                            let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv.y.unsigned_abs() as usize]];
                             let x_sign = last_mv.x < 0;
                             let y_sign = last_mv.y < 0;
                             let x               = i16::from(br.read_cb(x_cb)?);
@@ -1170,8 +1185,8 @@ impl VP34Decoder {
                             std::mem::swap(&mut last_mv, &mut last2_mv);
                         },
                         _ => { // GoldenMV
-                            let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv_g.x.abs() as usize]];
-                            let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv_g.y.abs() as usize]];
+                            let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv_g.x.unsigned_abs() as usize]];
+                            let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv_g.y.unsigned_abs() as usize]];
                             let x_sign = last_mv_g.x < 0;
                             let y_sign = last_mv_g.y < 0;
                             let x               = i16::from(br.read_cb(x_cb)?);
@@ -1451,7 +1466,7 @@ impl VP34Decoder {
         let mut pred = 0i32;
         for i in 0..4 {
             if (pp & (1 << i)) != 0 {
-                pred += (preds[i] as i32) * i32::from(VP31_DC_WEIGHTS[pp][i]);
+                pred += preds[i] * i32::from(VP31_DC_WEIGHTS[pp][i]);
             }
         }
         pred /= i32::from(VP31_DC_WEIGHTS[pp][4]);
@@ -1486,7 +1501,7 @@ impl VP34Decoder {
         let mut npred = 0;
         for i in 0..4 {
             if (pp & (1 << i)) != 0 {
-                pred += preds[i] as i32;
+                pred += preds[i];
                 npred += 1;
                 if npred == 2 {
                     return (pred / 2) as i16;
@@ -1553,7 +1568,7 @@ impl VP34Decoder {
             }
         }
     }
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     fn output_blocks_inter(&mut self, frm: &mut NASimpleVideoFrame<u8>) {
         let mut blk_idx = 0;
         let bstride = self.mb_w * 2;
@@ -1895,6 +1910,7 @@ mod test {
         let mut dec_reg = RegisteredDecoders::new();
         duck_register_all_decoders(&mut dec_reg);
 
+        // sample: https://samples.mplayerhq.hu/V-codecs/VP3/vp30-logo.avi
         test_decoding("avi", "vp3", "assets/Duck/vp30-logo.avi", Some(23), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0x51aba7df, 0x6e42534d, 0xef6c5b13, 0x26c38d1f]));
     }
@@ -1911,6 +1927,7 @@ mod test {
 //        let file = "assets/Duck/01-vp31-0500.avi";
 //        test_file_decoding("avi", file, Some(3), true, false, None/*Some("vp31")*/, &dmx_reg, &dec_reg);
 //panic!("end");
+        // sample: https://samples.mplayerhq.hu/V-codecs/VP3/01-vp31-0500.avi
         test_decoding("avi", "vp3", "assets/Duck/01-vp31-0500.avi", Some(16), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0x65112f7e, 0x2914f29b, 0x2908ed2f, 0xce5fc8c5]));
     }
@@ -1922,6 +1939,7 @@ mod test {
         let mut dec_reg = RegisteredDecoders::new();
         duck_register_all_decoders(&mut dec_reg);
 
+        // sample: https://samples.mplayerhq.hu/V-codecs/VP4/ot171_vp40.avi
         test_decoding("avi", "vp3", "assets/Duck/ot171_vp40.avi", Some(86), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0xd41d8cd9, 0x8f00b204, 0xe9800998, 0xecf8427e]));
     }