fix some clippy warnings

11 files changed, 46 insertions, 55 deletions

diff --git a/nihav-duck/src/codecs/on2avc.rs b/nihav-duck/src/codecs/on2avc.rs
index 69505cf..8a34655 100644
--- a/nihav-duck/src/codecs/on2avc.rs
+++ b/nihav-duck/src/codecs/on2avc.rs
@@ -237,7 +237,7 @@ impl AVCDecoder {
                         first = false;
                     } else {
                         scale                   += i16::from(br.read_cb(&self.codebooks.scale_cb)?);
-                        validate!((scale >= 0) && (scale < 128));
+                        validate!((0..128).contains(&scale));
                     }
                     self.scales[cur_band] = scale as u8;
                     cur_band += 1;
diff --git a/nihav-duck/src/codecs/truemotion1.rs b/nihav-duck/src/codecs/truemotion1.rs
index c64c2ec..717a32b 100644
--- a/nihav-duck/src/codecs/truemotion1.rs
+++ b/nihav-duck/src/codecs/truemotion1.rs
@@ -128,6 +128,7 @@ impl Default for DeltaTables {
     }
 }
 
+#[derive(Default)]
 struct FrameBuf {
     last16: Option<NAVideoBufferRef<u16>>,
     last24: Option<NAVideoBufferRef<u8>>,
@@ -160,12 +161,6 @@ impl FrameBuf {
     }
 }
 
-impl Default for FrameBuf {
-    fn default() -> Self {
-        Self { last16: None, last24: None }
-    }
-}
-
 #[derive(Default)]
 struct TM1Decoder {
     info:           NACodecInfoRef,
@@ -616,8 +611,8 @@ impl NADecoder for TM1Decoder {
 
         self.blk_w = compr_info.block_w;
         self.blk_h = compr_info.block_h;
-        let mut mask = MaskState::new(is_intra && !is_sprite, &mask_bits, mask_row_size);
-        let mut index = IndexState::new(&index_bytes);
+        let mut mask = MaskState::new(is_intra && !is_sprite, mask_bits, mask_row_size);
+        let mut index = IndexState::new(index_bytes);
         let bufinfo;
         if !is_24bit {
             if let Some(mut buf) = self.lastframe.get16() {
diff --git a/nihav-duck/src/codecs/vp56.rs b/nihav-duck/src/codecs/vp56.rs
index 01e8171..2ab474b 100644
--- a/nihav-duck/src/codecs/vp56.rs
+++ b/nihav-duck/src/codecs/vp56.rs
@@ -633,7 +633,7 @@ impl VP56Decoder {
             self.fstate.last_idx = [24; 4];
             for mb_x in 0..self.mb_w {
                 self.fstate.mb_x = mb_x;
-                self.decode_mb(dframe, bc, &mut cr, br, &hdr, alpha)?;
+                self.decode_mb(dframe, bc, &mut cr, br, hdr, alpha)?;
                 self.dc_pred.next_mb();
             }
             self.dc_pred.update_row();
diff --git a/nihav-duck/src/codecs/vp6enc/mb.rs b/nihav-duck/src/codecs/vp6enc/mb.rs
index 2d460f1..cd33f12 100644
--- a/nihav-duck/src/codecs/vp6enc/mb.rs
+++ b/nihav-duck/src/codecs/vp6enc/mb.rs
@@ -507,7 +507,7 @@ impl FrameEncoder {
     }
     fn motion_est_mb(src_mb: &ResidueMB, cur_blk: &mut [[u8; 64]; 6], mb: &mut InterMB, mv_search: &mut Box<dyn MVSearch+Send>, mv_est: &mut MVEstimator, mb_x: usize, mb_y: usize) {
         src_mb.fill(cur_blk);
-        let (best_mv, _best_dist) = mv_search.search_mb(mv_est, &cur_blk, mb_x, mb_y);
+        let (best_mv, _best_dist) = mv_search.search_mb(mv_est, cur_blk, mb_x, mb_y);
         mb.mv[3] = best_mv;
 
         for i in 0..4 {
diff --git a/nihav-duck/src/codecs/vp6enc/mod.rs b/nihav-duck/src/codecs/vp6enc/mod.rs
index b6ce632..d706fe7 100644
--- a/nihav-duck/src/codecs/vp6enc/mod.rs
+++ b/nihav-duck/src/codecs/vp6enc/mod.rs
@@ -666,9 +666,10 @@ impl NAEncoder for VP6Encoder {
     fn negotiate_format(&self, encinfo: &EncodeParameters) -> EncoderResult<EncodeParameters> {
         match encinfo.format {
             NACodecTypeInfo::None => {
-                let mut ofmt = EncodeParameters::default();
-                ofmt.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, self.flipped, YUV420_FORMAT));
-                Ok(ofmt)
+                Ok(EncodeParameters {
+                    format: NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, self.flipped, YUV420_FORMAT)),
+                    ..Default::default()
+                })
             },
             NACodecTypeInfo::Audio(_) => Err(EncoderError::FormatError),
             NACodecTypeInfo::Video(vinfo) => {
diff --git a/nihav-duck/src/codecs/vp7.rs b/nihav-duck/src/codecs/vp7.rs
index 2252e0d..5ca88c0 100644
--- a/nihav-duck/src/codecs/vp7.rs
+++ b/nihav-duck/src/codecs/vp7.rs
@@ -768,7 +768,7 @@ impl VP7Decoder {
         let refframe = (if use_last { self.shuf.get_last() } else { self.shuf.get_golden() }).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];
@@ -776,12 +776,12 @@ impl VP7Decoder {
         if pitch_smode == 0 {
             if single_mv {
                 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 {
                 for y in 0..4 {
                     for x in 0..4 {
                         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);
                     }
                     yoff += 4 * ystride;
                     iidx += self.mv_stride;
@@ -791,14 +791,14 @@ impl VP7Decoder {
             if single_mv {
                 mc_block_special(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, 16, pitch_smode);
+                                 refframe.clone(), 0, mc_buf, 16, pitch_smode);
             } else {
                 for y in 0..4 {
                     for x in 0..4 {
                         mc_block_special(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, 4, pitch_smode);
+                                         refframe.clone(), 0, mc_buf, 4, pitch_smode);
                     }
                     yoff += 4 * ystride;
                     iidx += self.mv_stride;
@@ -815,13 +815,13 @@ impl VP7Decoder {
             let chroma_mv = self.mvs[iidx];
 
             if pitch_smode == 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 {
                 mc_block_special(dst, uoff, ustride, mb_x * 8, mb_y * 8, chroma_mv.x, chroma_mv.y,
-                                 refframe.clone(), 1, &mut mc_buf, 8, pitch_smode);
+                                 refframe.clone(), 1, mc_buf, 8, pitch_smode);
                 mc_block_special(dst, voff, vstride, mb_x * 8, mb_y * 8, chroma_mv.x, chroma_mv.y,
-                                 refframe,         2, &mut mc_buf, 8, pitch_smode);
+                                 refframe,         2, mc_buf, 8, pitch_smode);
             }
         } else {
             for y in 0..2 {
@@ -844,15 +844,15 @@ impl VP7Decoder {
 
                     if pitch_smode == 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_block_special(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,
                                          4, pitch_smode);
                         mc_block_special(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,
                                          4, pitch_smode);
                     }
                 }
@@ -1185,13 +1185,13 @@ impl NADecoder for VP7Decoder {
             let mut new_gf = supp.pool_u8.get_copy(&gf).unwrap();
             let dframe = NASimpleVideoFrame::from_video_buf(&mut new_gf).unwrap();
             let mut mb_idx = 0;
-            let mut mc_buf = self.mc_buf.get_data_mut().unwrap();
+            let mc_buf = self.mc_buf.get_data_mut().unwrap();
             for mb_y in 0..self.mb_h {
                 for mb_x in 0..self.mb_w {
                     if self.mb_info[mb_idx].upd_gf {
-                        mc_block16x16(dframe.data, dframe.offset[0] + mb_x * 16 + mb_y * 16 * dframe.stride[0], dframe.stride[0], mb_x * 16, mb_y * 16, 0, 0, buf.clone(), 0, &mut mc_buf);
-                        mc_block8x8(dframe.data, dframe.offset[1] + mb_x * 8 + mb_y * 8 * dframe.stride[1], dframe.stride[1], mb_x * 8, mb_y * 8, 0, 0, buf.clone(), 1, &mut mc_buf);
-                        mc_block8x8(dframe.data, dframe.offset[2] + mb_x * 8 + mb_y * 8 * dframe.stride[2], dframe.stride[2], mb_x * 8, mb_y * 8, 0, 0, buf.clone(), 2, &mut mc_buf);
+                        mc_block16x16(dframe.data, dframe.offset[0] + mb_x * 16 + mb_y * 16 * dframe.stride[0], dframe.stride[0], mb_x * 16, mb_y * 16, 0, 0, buf.clone(), 0, mc_buf);
+                        mc_block8x8(dframe.data, dframe.offset[1] + mb_x * 8 + mb_y * 8 * dframe.stride[1], dframe.stride[1], mb_x * 8, mb_y * 8, 0, 0, buf.clone(), 1, mc_buf);
+                        mc_block8x8(dframe.data, dframe.offset[2] + mb_x * 8 + mb_y * 8 * dframe.stride[2], dframe.stride[2], mb_x * 8, mb_y * 8, 0, 0, buf.clone(), 2, mc_buf);
                     }
                     mb_idx += 1;
                 }
diff --git a/nihav-duck/src/codecs/vp78dsp.rs b/nihav-duck/src/codecs/vp78dsp.rs
index bc0bbb3..e69a5ab 100644
--- a/nihav-duck/src/codecs/vp78dsp.rs
+++ b/nihav-duck/src/codecs/vp78dsp.rs
@@ -230,7 +230,6 @@ macro_rules! load_pred4 {
 pub struct IPred4x4 {}
 impl IPred4x4 {
     pub fn ipred_dc(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
-        let dc;
         let mut dcsum = 0;
         for el in ipred.left.iter().take(4) {
             dcsum += u16::from(*el);
@@ -238,7 +237,7 @@ impl IPred4x4 {
         for el in ipred.top.iter().take(4) {
             dcsum += u16::from(*el);
         }
-        dc = ((dcsum + (1 << 2)) >> 3) as u8;
+        let dc = ((dcsum + (1 << 2)) >> 3) as u8;
         for _ in 0..4 {
             let out = &mut dst[off..][..4];
             for el in out.iter_mut() {
diff --git a/nihav-duck/src/codecs/vp7enc/blocks.rs b/nihav-duck/src/codecs/vp7enc/blocks.rs
index bfb8fbd..2276382 100644
--- a/nihav-duck/src/codecs/vp7enc/blocks.rs
+++ b/nihav-duck/src/codecs/vp7enc/blocks.rs
@@ -20,11 +20,7 @@ pub enum MBType {
 
 impl MBType {
     pub fn is_intra(&self) -> bool {
-        match *self {
-            MBType::Intra(_, _) |
-            MBType::Intra4x4(_, _, _) => true,
-            _ => false,
-        }
+        matches!(*self, MBType::Intra(_, _) | MBType::Intra4x4(_, _, _))
     }
     pub fn get_last(&self) -> bool {
         match *self {
diff --git a/nihav-duck/src/codecs/vp7enc/mb_coding.rs b/nihav-duck/src/codecs/vp7enc/mb_coding.rs
index cf73d2d..8fc79ff 100644
--- a/nihav-duck/src/codecs/vp7enc/mb_coding.rs
+++ b/nihav-duck/src/codecs/vp7enc/mb_coding.rs
@@ -187,7 +187,7 @@ pub fn select_intra_mode(sblk: &SrcBlock, newblk: &mut SrcBlock, res: &mut Resid
 
         if y_best_dist > SMALL_DIST {
             res.reset();
-            let dist4 = try_i4x4_pred(sblk.luma_blocks(), &mut i4_modes, res, &mut newblk.luma, &imctx, y_best_dist);
+            let dist4 = try_i4x4_pred(sblk.luma_blocks(), &mut i4_modes, res, &mut newblk.luma, imctx, y_best_dist);
             use_i4 = dist4 < y_best_dist;
             y_best_dist = y_best_dist.min(dist4);
         }
diff --git a/nihav-duck/src/codecs/vp7enc/mod.rs b/nihav-duck/src/codecs/vp7enc/mod.rs
index 67d4bed..8a31f10 100644
--- a/nihav-duck/src/codecs/vp7enc/mod.rs
+++ b/nihav-duck/src/codecs/vp7enc/mod.rs
@@ -267,9 +267,9 @@ impl NAEncoder for VP7Encoder {
     fn negotiate_format(&self, encinfo: &EncodeParameters) -> EncoderResult<EncodeParameters> {
         match encinfo.format {
             NACodecTypeInfo::None => {
-                let mut ofmt = EncodeParameters::default();
-                ofmt.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
-                Ok(ofmt)
+                Ok(EncodeParameters {
+                    format: NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT)),
+                    ..Default::default() })
             },
             NACodecTypeInfo::Audio(_) => Err(EncoderError::FormatError),
             NACodecTypeInfo::Video(vinfo) => {
diff --git a/nihav-duck/src/codecs/vp8.rs b/nihav-duck/src/codecs/vp8.rs
index de5d32a..cc2b175 100644
--- a/nihav-duck/src/codecs/vp8.rs
+++ b/nihav-duck/src/codecs/vp8.rs
@@ -975,7 +975,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 +983,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 +1013,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 +1049,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;