fix clippy warnings

19 files changed, 65 insertions, 104 deletions

diff --git a/nihav-duck/src/codecs/on2avc.rs b/nihav-duck/src/codecs/on2avc.rs
index 8a34655..9a0e0cd 100644
--- a/nihav-duck/src/codecs/on2avc.rs
+++ b/nihav-duck/src/codecs/on2avc.rs
@@ -355,7 +355,7 @@ impl AVCDecoder {
             0 | 1 => {
                 self.imdct_long.imdct_half(coeffs, &mut self.tmp);
                 overlap_half(dst, &self.tmp, delay, self.win_long);
-                (&mut delay[0..COEFFS/2]).copy_from_slice(&self.tmp[COEFFS/2..COEFFS]);
+                delay[0..COEFFS/2].copy_from_slice(&self.tmp[COEFFS/2..COEFFS]);
                 for i in COEFFS/2..COEFFS {
                     delay[i] = delay[COEFFS - 1 - i];
                 }
@@ -657,12 +657,12 @@ fn synth_recursive(dst: &mut [f32], tmp: &mut [f32], size: usize, order: &[u8],
         let idx = if !dir { i } else { bands - 1 - i };
         synth_filter(src, tmp, size, step, bands, idx);
     }
-    (&mut dst[..size]).copy_from_slice(&tmp[..size]);
+    dst[..size].copy_from_slice(&tmp[..size]);
 }
 
 fn synth_generic(src: &[f32], dst: &mut [f32], tmpbuf: &mut [f32; COEFFS * 2], is_40khz: bool, size: usize) {
     let order = if is_40khz { MERGE_ORDER_40K } else { MERGE_ORDER_44K };
-    (&mut dst[..size]).copy_from_slice(&src[..size]);
+    dst[..size].copy_from_slice(&src[..size]);
     let mut order_idx = 0;
     synth_recursive(dst, tmpbuf, size, order, &mut order_idx, false);
     for el in dst.iter_mut().take(COEFFS) { *el *= 0.125; }
@@ -908,7 +908,7 @@ fn dequant(val: i16, qtab: &[f32; QTAB_SIZE], scale: f32) -> f32 {
     if val >= 0 {
         qtab[val as usize] * scale
     } else {
-        -qtab[val.abs() as usize] * scale
+        -qtab[val.unsigned_abs() as usize] * scale
     }
 }
 
diff --git a/nihav-duck/src/codecs/truemotion1enc.rs b/nihav-duck/src/codecs/truemotion1enc.rs
index 72553b5..d582d1e 100644
--- a/nihav-duck/src/codecs/truemotion1enc.rs
+++ b/nihav-duck/src/codecs/truemotion1enc.rs
@@ -3,20 +3,15 @@ use nihav_core::codecs::*;
 use nihav_core::io::byteio::*;
 use super::truemotion1data::*;
 
-#[derive(Clone,Copy,PartialEq)]
+#[derive(Clone,Copy,PartialEq,Default)]
 enum BlockMode {
     FourByFour,
+    #[default]
     TwoByTwo,
     FourByTwo,
     TwoByFour,
 }
 
-impl Default for BlockMode {
-    fn default() -> Self {
-        BlockMode::TwoByTwo
-    }
-}
-
 impl FromStr for BlockMode {
     type Err = ();
     fn from_str(s: &str) -> Result<BlockMode, Self::Err> {
@@ -41,19 +36,14 @@ impl ToString for BlockMode {
     }
 }
 
-#[derive(Clone,Copy,PartialEq)]
+#[derive(Clone,Copy,PartialEq,Default)]
 enum OptionMode {
     Off,
     On,
+    #[default]
     Auto,
 }
 
-impl Default for OptionMode {
-    fn default() -> Self {
-        OptionMode::Auto
-    }
-}
-
 impl FromStr for OptionMode {
     type Err = ();
     fn from_str(s: &str) -> Result<OptionMode, Self::Err> {
@@ -518,7 +508,7 @@ impl TM1Encoder {
                     pair[1] = self.prev_frame[x * 2 + 1 + y * self.width];
                     hpred[0] = pair[0] - vpred[0];
                     hpred[1] = pair[1] - vpred[1];
-                    vpred.copy_from_slice(&pair);
+                    vpred.copy_from_slice(pair);
                     continue;
                 }
                 let pval = [vpred[0] + hpred[0], vpred[1] + hpred[1]];
diff --git a/nihav-duck/src/codecs/vp3.rs b/nihav-duck/src/codecs/vp3.rs
index cf59b14..08bfd1a 100644
--- a/nihav-duck/src/codecs/vp3.rs
+++ b/nihav-duck/src/codecs/vp3.rs
@@ -1141,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;
@@ -1167,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)?);
@@ -1185,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)?);
@@ -1466,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]);
@@ -1501,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;
diff --git a/nihav-duck/src/codecs/vp56.rs b/nihav-duck/src/codecs/vp56.rs
index 2ab474b..5abea84 100644
--- a/nihav-duck/src/codecs/vp56.rs
+++ b/nihav-duck/src/codecs/vp56.rs
@@ -531,9 +531,7 @@ impl VP56Decoder {
             std::mem::swap(&mut self.models, &mut self.amodels);
             let ret = self.decode_planes(br, &mut dframe, &mut bc, &ahdr, asrc, true);
             std::mem::swap(&mut self.models, &mut self.amodels);
-            if let Err(err) = ret {
-                return Err(err);
-            }
+            ret?;
             match (hdr.is_golden, ahdr.is_golden) {
                 (true, true) => { self.shuf.add_golden_frame(buf.clone()); },
                 (true, false) => {
@@ -699,16 +697,16 @@ impl VP56Decoder {
                 let sum = u32::from(prob_xmitted[mode * 2]) + u32::from(prob_xmitted[mode * 2 + 1]);
                 mdl.probs[9] = 255 - rescale_mb_mode_prob(u32::from(prob_xmitted[mode * 2 + 1]), sum);
 
-                let inter_mv0_weight = (cnt[0] as u32) + (cnt[2] as u32);
-                let inter_mv1_weight = (cnt[3] as u32) + (cnt[4] as u32);
-                let gold_mv0_weight = (cnt[5] as u32) + (cnt[6] as u32);
-                let gold_mv1_weight = (cnt[8] as u32) + (cnt[9] as u32);
-                let mix_weight = (cnt[1] as u32) + (cnt[7] as u32);
+                let inter_mv0_weight = cnt[0] + cnt[2];
+                let inter_mv1_weight = cnt[3] + cnt[4];
+                let gold_mv0_weight = cnt[5] + cnt[6];
+                let gold_mv1_weight = cnt[8] + cnt[9];
+                let mix_weight = cnt[1] + cnt[7];
                 mdl.probs[0] = 1 + rescale_mb_mode_prob(inter_mv0_weight + inter_mv1_weight, total);
                 mdl.probs[1] = 1 + rescale_mb_mode_prob(inter_mv0_weight, inter_mv0_weight + inter_mv1_weight);
                 mdl.probs[2] = 1 + rescale_mb_mode_prob(mix_weight, mix_weight + gold_mv0_weight + gold_mv1_weight);
-                mdl.probs[3] = 1 + rescale_mb_mode_prob(cnt[0] as u32, inter_mv0_weight);
-                mdl.probs[4] = 1 + rescale_mb_mode_prob(cnt[3] as u32, inter_mv1_weight);
+                mdl.probs[3] = 1 + rescale_mb_mode_prob(cnt[0], inter_mv0_weight);
+                mdl.probs[4] = 1 + rescale_mb_mode_prob(cnt[3], inter_mv1_weight);
                 mdl.probs[5] = 1 + rescale_mb_mode_prob(cnt[1], mix_weight);
                 mdl.probs[6] = 1 + rescale_mb_mode_prob(gold_mv0_weight, gold_mv0_weight + gold_mv1_weight);
                 mdl.probs[7] = 1 + rescale_mb_mode_prob(cnt[5], gold_mv0_weight);
diff --git a/nihav-duck/src/codecs/vp6.rs b/nihav-duck/src/codecs/vp6.rs
index 4bbf4c9..916711c 100644
--- a/nihav-duck/src/codecs/vp6.rs
+++ b/nihav-duck/src/codecs/vp6.rs
@@ -54,7 +54,6 @@ impl VP56Parser for VP6BR {
             hdr.multistream = true;
         }
         let bytes = br.tell() >> 3;
-        std::mem::drop(br);
         bc.skip_bytes(bytes);
         self.loop_mode = 0;
         if hdr.is_intra {
diff --git a/nihav-duck/src/codecs/vp6enc/coder.rs b/nihav-duck/src/codecs/vp6enc/coder.rs
index cb0904f..a88b0e2 100644
--- a/nihav-duck/src/codecs/vp6enc/coder.rs
+++ b/nihav-duck/src/codecs/vp6enc/coder.rs
@@ -199,16 +199,16 @@ fn calc_mb_model_probs(prob_xmitted: &[u8; 20], mbtype_models: &mut [VP56MBTypeM
         let sum = u32::from(prob_xmitted[mode * 2]) + u32::from(prob_xmitted[mode * 2 + 1]);
         mdl.probs[9] = 255 - rescale_mb_mode_prob(u32::from(prob_xmitted[mode * 2 + 1]), sum);
 
-        let inter_mv0_weight = (cnt[0] as u32) + (cnt[2] as u32);
-        let inter_mv1_weight = (cnt[3] as u32) + (cnt[4] as u32);
-        let gold_mv0_weight = (cnt[5] as u32) + (cnt[6] as u32);
-        let gold_mv1_weight = (cnt[8] as u32) + (cnt[9] as u32);
-        let mix_weight = (cnt[1] as u32) + (cnt[7] as u32);
+        let inter_mv0_weight = cnt[0] + cnt[2];
+        let inter_mv1_weight = cnt[3] + cnt[4];
+        let gold_mv0_weight = cnt[5] + cnt[6];
+        let gold_mv1_weight = cnt[8] + cnt[9];
+        let mix_weight = cnt[1] + cnt[7];
         mdl.probs[0] = 1 + rescale_mb_mode_prob(inter_mv0_weight + inter_mv1_weight, total);
         mdl.probs[1] = 1 + rescale_mb_mode_prob(inter_mv0_weight, inter_mv0_weight + inter_mv1_weight);
         mdl.probs[2] = 1 + rescale_mb_mode_prob(mix_weight, mix_weight + gold_mv0_weight + gold_mv1_weight);
-        mdl.probs[3] = 1 + rescale_mb_mode_prob(cnt[0] as u32, inter_mv0_weight);
-        mdl.probs[4] = 1 + rescale_mb_mode_prob(cnt[3] as u32, inter_mv1_weight);
+        mdl.probs[3] = 1 + rescale_mb_mode_prob(cnt[0], inter_mv0_weight);
+        mdl.probs[4] = 1 + rescale_mb_mode_prob(cnt[3], inter_mv1_weight);
         mdl.probs[5] = 1 + rescale_mb_mode_prob(cnt[1], mix_weight);
         mdl.probs[6] = 1 + rescale_mb_mode_prob(gold_mv0_weight, gold_mv0_weight + gold_mv1_weight);
         mdl.probs[7] = 1 + rescale_mb_mode_prob(cnt[5], gold_mv0_weight);
@@ -341,7 +341,7 @@ pub fn encode_mode_prob_models(bc: &mut BoolEncoder, models: &mut VP56Models, pm
                                 bc.put_bool(diff < 0, 128)?;
                                 bc.write_el(d0, MODE_TREE_DIFF, MODE_TREE_DIFF_PROBS)?;
                                 if d0 == 7 {
-                                    bc.put_bits(diff.abs() as u32, 7)?;
+                                    bc.put_bits(u32::from(diff.unsigned_abs()), 7)?;
                                 }
                                 tprob[i ^ 1] = (i16::from(tprob[i ^ 1]) + deltas[i ^ 1]) as u8;
                             }
diff --git a/nihav-duck/src/codecs/vp6enc/dsp.rs b/nihav-duck/src/codecs/vp6enc/dsp.rs
index 2651458..90c76b9 100644
--- a/nihav-duck/src/codecs/vp6enc/dsp.rs
+++ b/nihav-duck/src/codecs/vp6enc/dsp.rs
@@ -326,7 +326,7 @@ impl MVEstimator {
 fn sad(src1: &[u8; 64], src2: &[u8; 64]) -> u32 {
     let mut sum = 0;
     for (&p1, &p2) in src1.iter().zip(src2.iter()) {
-        sum += (i32::from(p1) - i32::from(p2)).abs() as u32;
+        sum += (i32::from(p1) - i32::from(p2)).unsigned_abs();
     }
     sum
 }
@@ -341,7 +341,7 @@ pub fn calc_mb_dist(mb1: &ResidueMB, mb2: &ResidueMB) -> u32 {
     let mut sum = 0;
     for (blk1, blk2) in mb1.coeffs.iter().zip(mb2.coeffs.iter()) {
         for (&c1, &c2) in blk1.iter().zip(blk2.iter()) {
-            sum += (i32::from(c1) - i32::from(c2)).abs() as u32;
+            sum += (i32::from(c1) - i32::from(c2)).unsigned_abs();
         }
     }
     sum
diff --git a/nihav-duck/src/codecs/vp6enc/mb.rs b/nihav-duck/src/codecs/vp6enc/mb.rs
index cd33f12..cece9d1 100644
--- a/nihav-duck/src/codecs/vp6enc/mb.rs
+++ b/nihav-duck/src/codecs/vp6enc/mb.rs
@@ -341,7 +341,7 @@ impl FrameEncoder {
         }
     }
     pub fn estimate_mvs(&mut self, ref_frame: NAVideoBufferRef<u8>, mc_buf: NAVideoBufferRef<u8>, golden: bool) {
-        let loop_thr = i16::from(VP56_FILTER_LIMITS[self.quant as usize]);
+        let loop_thr = i16::from(VP56_FILTER_LIMITS[self.quant]);
 
         let inter_mbs = if !golden { &mut self.inter_mbs } else { &mut self.golden_mbs };
 
@@ -384,7 +384,7 @@ impl FrameEncoder {
         }
     }
     fn estimate_fourmv(&mut self, ref_frame: NAVideoBufferRef<u8>, mc_buf: NAVideoBufferRef<u8>, mb_x: usize, mb_y: usize) -> bool {
-        let loop_thr = i16::from(VP56_FILTER_LIMITS[self.quant as usize]);
+        let loop_thr = i16::from(VP56_FILTER_LIMITS[self.quant]);
 
         if self.fourmv_mbs.is_empty() {
             for _ in 0..self.mb_w * self.mb_h {
@@ -526,7 +526,7 @@ impl FrameEncoder {
         }
     }
     pub fn select_inter_blocks_fast(&mut self, ref_frame: NAVideoBufferRef<u8>, gold_frame: Option<NAVideoBufferRef<u8>>, mc_buf: NAVideoBufferRef<u8>, lambda: f32) {
-        let loop_thr = i16::from(VP56_FILTER_LIMITS[self.quant as usize]);
+        let loop_thr = i16::from(VP56_FILTER_LIMITS[self.quant]);
 
         if self.inter_mbs.is_empty() {
             for _ in 0..self.mb_w * self.mb_h {
diff --git a/nihav-duck/src/codecs/vp7.rs b/nihav-duck/src/codecs/vp7.rs
index 5ca88c0..3b2d854 100644
--- a/nihav-duck/src/codecs/vp7.rs
+++ b/nihav-duck/src/codecs/vp7.rs
@@ -204,6 +204,7 @@ impl VP7Decoder {
 
         self.pcache.resize(self.mb_w);
     }
+    #[allow(clippy::field_reassign_with_default)]
     fn read_features(&mut self, bc: &mut BoolCoder) -> DecoderResult<()> {
         for (i, feat) in self.dstate.features.iter_mut().enumerate() {
             if bc.read_bool() {
diff --git a/nihav-duck/src/codecs/vp78.rs b/nihav-duck/src/codecs/vp78.rs
index b0b7672..4ec79d1 100644
--- a/nihav-duck/src/codecs/vp78.rs
+++ b/nihav-duck/src/codecs/vp78.rs
@@ -25,8 +25,9 @@ impl<'a> VPTreeReader for BoolCoder<'a> {
 }
 
 #[repr(u8)]
-#[derive(Clone,Copy,PartialEq,Debug)]
+#[derive(Clone,Copy,PartialEq,Debug,Default)]
 pub enum PredMode {
+    #[default]
     DCPred,
     HPred,
     VPred,
@@ -44,10 +45,6 @@ pub enum PredMode {
     Inter,
 }
 
-impl Default for PredMode {
-    fn default() -> Self { PredMode::DCPred }
-}
-
 impl PredMode {
     pub fn to_b_mode(self) -> Self {
         if self == PredMode::DCPred {
diff --git a/nihav-duck/src/codecs/vp78dsp.rs b/nihav-duck/src/codecs/vp78dsp.rs
index e69a5ab..9d68616 100644
--- a/nihav-duck/src/codecs/vp78dsp.rs
+++ b/nihav-duck/src/codecs/vp78dsp.rs
@@ -396,7 +396,7 @@ fn mc_block_common(dst: &mut [u8], mut doff: usize, dstride: usize, src: &[u8],
         let dst = &mut dst[doff..];
         let src = &src[EDGE_PRE + EDGE_PRE * sstride..];
         for (out, src) in dst.chunks_mut(dstride).take(size).zip(src.chunks(sstride)) {
-            (&mut out[0..size]).copy_from_slice(&src[0..size]);
+            out[..size].copy_from_slice(&src[..size]);
         }
     } else if my == 0 {
         let src = &src[EDGE_PRE * sstride..];
@@ -439,7 +439,7 @@ fn mc_block(dst: &mut [u8], doff: usize, dstride: usize, xpos: usize, ypos: usiz
         let src = &reffrm.get_data();
         let src = &src[srcoff..];
         for (out, src) in dst.chunks_mut(dstride).take(size).zip(src.chunks(sstride)) {
-            (&mut out[0..size]).copy_from_slice(&src[0..size]);
+            out[..size].copy_from_slice(&src[..size]);
         }
         return;
     }
@@ -512,7 +512,7 @@ pub fn mc_block_special(dst: &mut [u8], doff: usize, dstride: usize, xpos: usize
             (&data[off + (start_x as usize) + (start_y as usize) * stride..],
              ((stride as isize) + xstep) as usize)
         } else {
-            let add = (size + EDGE_PRE + EDGE_POST) * (xstep.abs() as usize);
+            let add = (size + EDGE_PRE + EDGE_POST) * xstep.unsigned_abs();
             let bw = size + EDGE_PRE + EDGE_POST + add;
             let bh = (end_y - start_y) as usize;
             let bo = if xstep >= 0 { 0 } else { add };
diff --git a/nihav-duck/src/codecs/vp7dsp.rs b/nihav-duck/src/codecs/vp7dsp.rs
index d4c06c6..090eada 100644
--- a/nihav-duck/src/codecs/vp7dsp.rs
+++ b/nihav-duck/src/codecs/vp7dsp.rs
@@ -172,7 +172,7 @@ pub fn fade_frame(srcfrm: NAVideoBufferRef<u8>, dstfrm: &mut NASimpleVideoFrame<
         let dstride = dstfrm.stride[plane];
         let dst = &mut dstfrm.data[dstfrm.offset[plane]..];
         for (src, dst) in src.chunks(sstride).zip(dst.chunks_mut(dstride)).take(ha) {
-            (&mut dst[0..wa]).copy_from_slice(&src[0..wa]);
+            dst[..wa].copy_from_slice(&src[..wa]);
         }
     }
 }
diff --git a/nihav-duck/src/codecs/vp7enc/blocks.rs b/nihav-duck/src/codecs/vp7enc/blocks.rs
index 2276382..7a18d48 100644
--- a/nihav-duck/src/codecs/vp7enc/blocks.rs
+++ b/nihav-duck/src/codecs/vp7enc/blocks.rs
@@ -270,7 +270,7 @@ impl SrcBlock {
     }
     pub fn apply_ipred_luma(&self, mode: PredMode, ipred: &IPredContext, dst: &mut Residue) {
         let mut tmp = [0; 256];
-        (&mut tmp).ipred16(16, mode, ipred);
+        tmp.ipred16(16, mode, ipred);
         dst.set_luma_from_diff(&self.luma, &tmp);
     }
     pub fn fill_ipred_luma(&mut self, mode: PredMode, ipred: &IPredContext) {
diff --git a/nihav-duck/src/codecs/vp7enc/rdo.rs b/nihav-duck/src/codecs/vp7enc/rdo.rs
index 88f7456..d91cee4 100644
--- a/nihav-duck/src/codecs/vp7enc/rdo.rs
+++ b/nihav-duck/src/codecs/vp7enc/rdo.rs
@@ -136,7 +136,7 @@ impl BitRateControl {
     }
     pub fn get_frame_quant(&self, is_intra: bool) -> usize {
         if let Some(q) = self.force_q {
-            q as usize
+            q
         } else {
             let expected_size = self.get_target_size(is_intra);
             let nits_per_mb = ((expected_size * 8) as f32) / (self.num_mb as f32);
diff --git a/nihav-duck/src/codecs/vp8.rs b/nihav-duck/src/codecs/vp8.rs
index 791788a..6e34f59 100644
--- 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()
diff --git a/nihav-duck/src/codecs/vp8dsp.rs b/nihav-duck/src/codecs/vp8dsp.rs
index c097a3c..fa7aa09 100644
--- a/nihav-duck/src/codecs/vp8dsp.rs
+++ b/nihav-duck/src/codecs/vp8dsp.rs
@@ -177,7 +177,7 @@ fn mc_block_common(dst: &mut [u8], mut doff: usize, dstride: usize, src: &[u8],
     if (mx == 0) && (my == 0) {
         let dst = &mut dst[doff..];
         for (out, src) in dst.chunks_mut(dstride).take(size).zip(src.chunks(sstride)) {
-            (&mut out[0..size]).copy_from_slice(&src[0..size]);
+            out[..size].copy_from_slice(&src[..size]);
         }
     } else if my == 0 {
         for src in src.chunks(sstride).take(size) {
@@ -218,7 +218,7 @@ fn mc_block(dst: &mut [u8], doff: usize, dstride: usize, xpos: usize, ypos: usiz
         let src = &reffrm.get_data();
         let src = &src[srcoff..];
         for (out, src) in dst.chunks_mut(dstride).take(size).zip(src.chunks(sstride)) {
-            (&mut out[0..size]).copy_from_slice(&src[0..size]);
+            out[..size].copy_from_slice(&src[..size]);
         }
         return;
     }
diff --git a/nihav-duck/src/codecs/vpcommon.rs b/nihav-duck/src/codecs/vpcommon.rs
index 8474dc6..eb84f4e 100644
--- a/nihav-duck/src/codecs/vpcommon.rs
+++ b/nihav-duck/src/codecs/vpcommon.rs
@@ -17,9 +17,10 @@ pub const VP_YUVA420_FORMAT: NAPixelFormaton = NAPixelFormaton{
         palette:    false
     };
 
-#[derive(Clone,Copy,Debug,PartialEq)]
+#[derive(Clone,Copy,Debug,PartialEq,Default)]
 #[allow(dead_code)]
 pub enum VPMBType {
+    #[default]
     Intra,
     InterNoMV,
     InterMV,
@@ -51,10 +52,6 @@ impl VPMBType {
     }
 }
 
-impl Default for VPMBType {
-    fn default() -> Self { VPMBType::Intra }
-}
-
 #[derive(Default)]
 pub struct VPShuffler {
     lastframe: Option<NAVideoBufferRef<u8>>,
@@ -71,18 +68,10 @@ impl VPShuffler {
         self.goldframe = 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 has_refs(&self) -> bool {
         self.lastframe.is_some()
diff --git a/nihav-duck/src/codecs/vpenc/motion_est.rs b/nihav-duck/src/codecs/vpenc/motion_est.rs
index 005780c..31d2989 100644
--- a/nihav-duck/src/codecs/vpenc/motion_est.rs
+++ b/nihav-duck/src/codecs/vpenc/motion_est.rs
@@ -2,20 +2,17 @@ use nihav_codec_support::codecs::{MV, ZERO_MV};
 
 use std::str::FromStr;
 
-#[derive(Debug,Clone,Copy,PartialEq)]
+#[derive(Debug,Clone,Copy,PartialEq,Default)]
 #[allow(dead_code)]
 pub enum MVSearchMode {
     Full,
     SEA,
     Diamond,
+    #[default]
     Hexagon,
     EPZS,
 }
 
-impl Default for MVSearchMode {
-    fn default() -> Self { MVSearchMode::Hexagon }
-}
-
 pub struct ParseError{}
 
 impl FromStr for MVSearchMode {
diff --git a/nihav-duck/src/lib.rs b/nihav-duck/src/lib.rs
index bb290cd..76dfbf4 100644
--- a/nihav-duck/src/lib.rs
+++ b/nihav-duck/src/lib.rs
@@ -3,11 +3,16 @@ extern crate nihav_core;
 extern crate nihav_codec_support;
 
 #[allow(clippy::collapsible_if)]
+#[allow(clippy::collapsible_else_if)]
 #[allow(clippy::comparison_chain)]
 #[allow(clippy::excessive_precision)]
 #[allow(clippy::identity_op)]
+#[allow(clippy::needless_late_init)]
 #[allow(clippy::unreadable_literal)]
+#[allow(clippy::upper_case_acronyms)]
 #[allow(clippy::verbose_bit_mask)]
+#[allow(clippy::manual_range_contains)]
+#[allow(clippy::wrong_self_convention)]
 mod codecs;
 
 mod demuxers;