]> git.nihav.org Git - nihav.git/commitdiff
janitorial: fix or squash clippy warnings and update code style for na_codec_support
authorKostya Shishkov <kostya.shishkov@gmail.com>
Fri, 13 Nov 2026 15:08:08 +0000 (16:08 +0100)
committerKostya Shishkov <kostya.shishkov@gmail.com>
Fri, 13 Nov 2026 15:08:08 +0000 (16:08 +0100)
nihav-codec-support/src/codecs/blockdsp.rs
nihav-codec-support/src/codecs/h263/code.rs
nihav-codec-support/src/codecs/h263/decoder.rs
nihav-codec-support/src/codecs/h263/mod.rs
nihav-codec-support/src/dsp/dct.rs
nihav-codec-support/src/dsp/fft.rs
nihav-codec-support/src/dsp/mod.rs
nihav-codec-support/src/dsp/window.rs
nihav-codec-support/src/lib.rs

index 9f70582c17a09fbf4db08353e4a70f7bc46b9262..51842a4f7ce52ea36c337a1fd71db02878c7c34d 100644 (file)
@@ -15,41 +15,29 @@ pub fn put_blocks(buf: &mut NAVideoBuffer<u8>, xpos: usize, ypos: usize, blk: &[
 
     for j in 0..8 {
         for k in 0..8 {
-            let mut v = blk[0][k + j * 8];
-            if v < 0 { v = 0; } else if v > 255 { v = 255; }
-            framebuf[idxy + k] = v as u8;
+            framebuf[idxy + k] = blk[0][k + j * 8].clamp(0, 255) as u8;
         }
         for k in 0..8 {
-            let mut v = blk[1][k + j * 8];
-            if v < 0 { v = 0; } else if v > 255 { v = 255; }
-            framebuf[idxy + k + 8] = v as u8;
+            framebuf[idxy + k + 8] = blk[1][k + j * 8].clamp(0, 255) as u8;
         }
         idxy += stridey;
     }
     for j in 0..8 {
         for k in 0..8 {
-            let mut v = blk[2][k + j * 8];
-            if v < 0 { v = 0; } else if v > 255 { v = 255; }
-            framebuf[idxy + k] = v as u8;
+            framebuf[idxy + k] = blk[2][k + j * 8].clamp(0, 255) as u8;
         }
         for k in 0..8 {
-            let mut v = blk[3][k + j * 8];
-            if v < 0 { v = 0; } else if v > 255 { v = 255; }
-            framebuf[idxy + k + 8] = v as u8;
+            framebuf[idxy + k + 8] = blk[3][k + j * 8].clamp(0, 255) as u8;
         }
         idxy += stridey;
     }
 
     for j in 0..8 {
         for k in 0..8 {
-            let mut v = blk[4][k + j * 8];
-            if v < 0 { v = 0; } else if v > 255 { v = 255; }
-            framebuf[idxu + k] = v as u8;
+            framebuf[idxu + k] = blk[4][k + j * 8].clamp(0, 255) as u8;
         }
         for k in 0..8 {
-            let mut v = blk[5][k + j * 8];
-            if v < 0 { v = 0; } else if v > 255 { v = 255; }
-            framebuf[idxv + k] = v as u8;
+            framebuf[idxv + k] = blk[5][k + j * 8].clamp(0, 255) as u8;
         }
         idxu += strideu;
         idxv += stridev;
@@ -70,41 +58,29 @@ pub fn add_blocks(buf: &mut NAVideoBuffer<u8>, xpos: usize, ypos: usize, blk: &[
 
     for j in 0..8 {
         for k in 0..8 {
-            let mut v = blk[0][k + j * 8] + i16::from(framebuf[idxy + k]);
-            if v < 0 { v = 0; } else if v > 255 { v = 255; }
-            framebuf[idxy + k] = v as u8;
+            framebuf[idxy + k] = (blk[0][k + j * 8] + i16::from(framebuf[idxy + k])).clamp(0, 255) as u8;
         }
         for k in 0..8 {
-            let mut v = blk[1][k + j * 8] + i16::from(framebuf[idxy + k + 8]);
-            if v < 0 { v = 0; } else if v > 255 { v = 255; }
-            framebuf[idxy + k + 8] = v as u8;
+            framebuf[idxy + k + 8] = (blk[1][k + j * 8] + i16::from(framebuf[idxy + k + 8])).clamp(0, 255) as u8;
         }
         idxy += stridey;
     }
     for j in 0..8 {
         for k in 0..8 {
-            let mut v = blk[2][k + j * 8] + i16::from(framebuf[idxy + k]);
-            if v < 0 { v = 0; } else if v > 255 { v = 255; }
-            framebuf[idxy + k] = v as u8;
+            framebuf[idxy + k] = (blk[2][k + j * 8] + i16::from(framebuf[idxy + k])).clamp(0, 255) as u8;
         }
         for k in 0..8 {
-            let mut v = blk[3][k + j * 8] + i16::from(framebuf[idxy + k + 8]);
-            if v < 0 { v = 0; } else if v > 255 { v = 255; }
-            framebuf[idxy + k + 8] = v as u8;
+            framebuf[idxy + k + 8] = (blk[3][k + j * 8] + i16::from(framebuf[idxy + k + 8])).clamp(0, 255) as u8;
         }
         idxy += stridey;
     }
 
     for j in 0..8 {
         for k in 0..8 {
-            let mut v = blk[4][k + j * 8] + i16::from(framebuf[idxu + k]);
-            if v < 0 { v = 0; } else if v > 255 { v = 255; }
-            framebuf[idxu + k] = v as u8;
+            framebuf[idxu + k] = (blk[4][k + j * 8] + i16::from(framebuf[idxu + k])).clamp(0, 255) as u8;
         }
         for k in 0..8 {
-            let mut v = blk[5][k + j * 8] + i16::from(framebuf[idxv + k]);
-            if v < 0 { v = 0; } else if v > 255 { v = 255; }
-            framebuf[idxv + k] = v as u8;
+            framebuf[idxv + k] = (blk[5][k + j * 8] + i16::from(framebuf[idxv + k])).clamp(0, 255) as u8;
         }
         idxu += strideu;
         idxv += stridev;
@@ -129,16 +105,10 @@ pub fn edge_emu(src: &NAVideoBuffer<u8>, xpos: isize, ypos: isize, bw: usize, bh
         };
 
     for y in 0..bh {
-        let srcy;
-        if (y as isize) + ypos < 0 { srcy = 0; }
-        else if (y as isize) + ypos >= (h as isize) { srcy = h - 1; }
-        else { srcy = ((y as isize) + ypos) as usize; }
+        let srcy = (y as isize + ypos).clamp(0, h as isize - 1) as usize;
 
         for x in 0..bw {
-            let srcx;
-            if (x as isize) + xpos < 0 { srcx = 0; }
-            else if (x as isize) + xpos >= (w as isize) { srcx = w - 1; }
-            else { srcx = ((x as isize) + xpos) as usize; }
+            let srcx = (x as isize + xpos).clamp(0, w as isize - 1) as usize;
             dst[x + y * dstride] = framebuf[offs + srcx + srcy * stride];
         }
     }
index 6ff42475d962944576184593ecefaa4254470d88..0ea8647387ee07a9c6f1a61a46dddc8fc9fbd077 100644 (file)
@@ -479,8 +479,8 @@ fn deblock_hor(buf: &mut NAVideoBuffer<u8>, comp: usize, strength: u8, off: usiz
             let d2  = ((a - d) / 4).max(-hd1).min(hd1);
 
             buf[off - 2 * stride + x] = (a - d2) as u8;
-            buf[off - 1 * stride + x] = (b + d1).max(0).min(255) as u8;
-            buf[off + 0 * stride + x] = (c - d1).max(0).min(255) as u8;
+            buf[off - 1 * stride + x] = (b + d1).clamp(0, 255) as u8;
+            buf[off + 0 * stride + x] = (c - d1).clamp(0, 255) as u8;
             buf[off + 1 * stride + x] = (d + d2) as u8;
         }
     }
@@ -503,8 +503,8 @@ fn deblock_ver(buf: &mut NAVideoBuffer<u8>, comp: usize, strength: u8, off: usiz
             let d2  = ((a - d) / 4).max(-hd1).min(hd1);
 
             buf[off - 2 + y * stride] = (a - d2) as u8;
-            buf[off - 1 + y * stride] = (b + d1).max(0).min(255) as u8;
-            buf[off     + y * stride] = (c - d1).max(0).min(255) as u8;
+            buf[off - 1 + y * stride] = (b + d1).clamp(0, 255) as u8;
+            buf[off     + y * stride] = (c - d1).clamp(0, 255) as u8;
             buf[off + 1 + y * stride] = (d + d2) as u8;
         }
     }
index a2ba62bf4dcc8787e9d7a33de8a43404fe1c4a3d..7d584d4b62871f81bc7093e62114f96cd819bcdf 100644 (file)
@@ -17,6 +17,7 @@ struct MVInfo {
     mvmode:     MVMode,
 }
 
+#[allow(clippy::identity_op)]
 impl MVInfo {
     fn new() -> Self { MVInfo{ mv: Vec::new(), mb_w: 0, mb_stride: 0, mb_start: 0, top: true, mvmode: MVMode::Old } }
     fn reset(&mut self, mb_w: usize, mb_start: usize, mvmode: MVMode) {
@@ -159,11 +160,7 @@ fn clip_dc(dc: i16) -> i16 {
 }
 
 #[inline]
-fn clip_ac(ac: i16) -> i16 {
-    if ac < -2048 { -2048 }
-    else if ac > 2047 { 2047 }
-    else { ac }
-}
+fn clip_ac(ac: i16) -> i16 { ac.clamp(-2048, 2047) }
 
 #[allow(dead_code)]
 impl H263BaseDecoder {
@@ -215,7 +212,7 @@ impl H263BaseDecoder {
 
     fn decode_intra_mb(&mut self, bd: &mut dyn BlockDecoder, bdsp: &dyn BlockDSP, mb_pos: usize, binfo: &BlockInfo, sstate: &SliceState, apply_acpred: bool) -> DecoderResult<()> {
         for i in 0..6 {
-            bd.decode_block_intra(&binfo, &sstate, binfo.get_q(), i, (binfo.cbp & (1 << (5 - i))) != 0, &mut self.blk[i])?;
+            bd.decode_block_intra(binfo, sstate, binfo.get_q(), i, (binfo.cbp & (1 << (5 - i))) != 0, &mut self.blk[i])?;
             if apply_acpred && (binfo.acpred != ACPredMode::None) {
                 let has_b = (i == 1) || (i == 3) || !sstate.first_mb;
                 let has_a = (i == 2) || (i == 3) || !sstate.first_line;
@@ -239,16 +236,12 @@ impl H263BaseDecoder {
                     } else { (0, 0) };
                 match binfo.acpred {
                     ACPredMode::DC   => {
-                                let dc;
-                                if has_a && has_b {
-                                    dc = (self.pred_coeffs[b_mb].hor[b_blk][0] + self.pred_coeffs[a_mb].ver[a_blk][0]) / 2;
-                                } else if has_a {
-                                    dc = self.pred_coeffs[a_mb].ver[a_blk][0];
-                                } else if has_b {
-                                    dc = self.pred_coeffs[b_mb].hor[b_blk][0];
-                                } else {
-                                    dc = 1024;
-                                }
+                                let dc = match (has_a, has_b) {
+                                        (true, true) => (self.pred_coeffs[b_mb].hor[b_blk][0] + self.pred_coeffs[a_mb].ver[a_blk][0]) / 2,
+                                        (true, _) => self.pred_coeffs[a_mb].ver[a_blk][0],
+                                        (_, true) => self.pred_coeffs[b_mb].hor[b_blk][0],
+                                        _ => 1024
+                                    };
                                 self.blk[i][0] = clip_dc(self.blk[i][0] + dc);
                             },
                     ACPredMode::Hor  => {
@@ -289,7 +282,7 @@ impl H263BaseDecoder {
     #[allow(clippy::comparison_chain)]
     fn decode_intra_mb_pred_quant(&mut self, bd: &mut dyn BlockDecoder, bdsp: &dyn BlockDSP, mb_pos: usize, binfo: &BlockInfo, sstate: &SliceState, apply_acpred: bool) -> DecoderResult<()> {
         for i in 0..6 {
-            bd.decode_block_intra(&binfo, &sstate, binfo.get_q(), i, (binfo.cbp & (1 << (5 - i))) != 0, &mut self.blk[i])?;
+            bd.decode_block_intra(binfo, sstate, binfo.get_q(), i, (binfo.cbp & (1 << (5 - i))) != 0, &mut self.blk[i])?;
             let q = if binfo.get_q() < 8 {
                     8
                 } else {
@@ -393,7 +386,7 @@ impl H263BaseDecoder {
     }
     fn decode_inter_mb(&mut self, bd: &mut dyn BlockDecoder, bdsp: &dyn BlockDSP, binfo: &BlockInfo, sstate: &SliceState) -> DecoderResult<()> {
         for i in 0..6 {
-            bd.decode_block_inter(&binfo, &sstate, binfo.get_q(), i, ((binfo.cbp >> (5 - i)) & 1) != 0, &mut self.blk[i])?;
+            bd.decode_block_inter(binfo, sstate, binfo.get_q(), i, ((binfo.cbp >> (5 - i)) & 1) != 0, &mut self.blk[i])?;
             bdsp.idct(&mut self.blk[i]);
         }
         Ok(())
@@ -712,10 +705,7 @@ impl H263BaseDecoder {
                     let mut b_mb = BMB::new();
                     let cbp = binfo.get_cbp_b();
                     let bq = (((pinfo.get_pbinfo().get_dbquant() + 5) as u16) * (binfo.get_q() as u16)) >> 2;
-                    let bquant;
-                    if bq < 1 { bquant = 1; }
-                    else if bq > 31 { bquant = 31; }
-                    else { bquant = bq as u8; }
+                    let bquant = bq.clamp(1, 31) as u8;
 
                     b_mb.cbp = cbp;
                     for i in 0..6 {
index e357778175a840552b8b794945254a5cd04935f2..479d570e886112198723a2f5852b53150d46ec13 100644 (file)
@@ -3,6 +3,7 @@ use super::{MV, ZERO_MV};
 use nihav_core::frame::{NAVideoBuffer, NAVideoBufferRef};
 
 #[allow(clippy::erasing_op)]
+#[allow(clippy::identity_op)]
 #[allow(clippy::many_single_char_names)]
 pub mod code;
 pub mod data;
@@ -34,12 +35,7 @@ pub enum Type {
 }
 
 impl Type {
-    pub fn is_ref(self) -> bool {
-        match self {
-            Type::I | Type::P | Type::PB => true,
-            _                            => false,
-        }
-    }
+    pub fn is_ref(self) -> bool { matches!(self, Type::I | Type::P | Type::PB) }
 }
 
 #[allow(dead_code)]
index 2206350f50b6fe7ec2f30a7a712bb133f8f7d536..fa8f643cedb779e834c8cc8ef375d63f2e216200 100644 (file)
@@ -90,10 +90,7 @@ impl DCT {
     }
     fn can_do_fast(&mut self) -> bool {
         if !self.is_pow2 { return false; }
-        match self.mode {
-            DCTMode::DCT_I | DCTMode::DST_I | DCTMode::DST_IV => false,
-            _ => true,
-        }
+        !matches!(self.mode, DCTMode::DCT_I | DCTMode::DST_I | DCTMode::DST_IV)
     }
     fn inplace_fast_dct(&mut self, dst: &mut [f32]) {
         match self.mode {
@@ -217,49 +214,49 @@ fn do_ref_dct(mode: DCTMode, src: &[f32], dst: &mut [f32], size: usize) {
 #[allow(non_snake_case)]
 fn dct_I_ref(src: &[f32], dst: &mut [f32], size: usize) {
     let base = consts::PI / ((size - 1) as f32);
-    for k in 0..size {
+    for (k, dst) in dst.iter_mut().enumerate().take(size) {
         let mut sum = (src[0] + (if (k & 1) != 0 { -src[size - 1] } else { src[size - 1] })) * 0.5;
-        for n in 1..size-1 {
-            sum += src[n] * (base * ((n * k) as f32)).cos();
+        for (n, &el) in src.iter().enumerate().take(size - 1).skip(1) {
+            sum += el * (base * ((n * k) as f32)).cos();
         }
-        dst[k] = sum;
+        *dst = sum;
     }
 }
 
 #[allow(non_snake_case)]
 fn dst_I_ref(src: &[f32], dst: &mut [f32], size: usize) {
     let base = consts::PI / ((size + 1) as f32);
-    for k in 0..size {
+    for (k, dst) in dst.iter_mut().enumerate().take(size) {
         let mut sum = 0.0;
-        for n in 0..size {
-            sum += src[n] * (base * (((n + 1) * (k + 1)) as f32)).sin();
+        for (n, &el) in src.iter().enumerate().take(size) {
+            sum += el * (base * (((n + 1) * (k + 1)) as f32)).sin();
         }
-        dst[k] = sum;
+        *dst = sum;
     }
 }
 
 #[allow(non_snake_case)]
 fn dct_II_ref(src: &[f32], dst: &mut [f32], size: usize) {
     let base = consts::PI / (size as f32);
-    for k in 0..size {
+    for (k, dst) in dst.iter_mut().enumerate().take(size) {
         let mut sum = 0.0;
-        for n in 0..size {
-            sum += src[n] * (base * ((n as f32) + 0.5) * (k as f32)).cos();
+        for (n, &el) in src.iter().enumerate().take(size) {
+            sum += el * (base * ((n as f32) + 0.5) * (k as f32)).cos();
         }
-        dst[k] = sum * (if k == 0 { (1.0 / (size as f32)).sqrt() } else { (2.0 / (size as f32)).sqrt() });
+        *dst = sum * (if k == 0 { (1.0 / (size as f32)).sqrt() } else { (2.0 / (size as f32)).sqrt() });
     }
 }
 
 #[allow(non_snake_case)]
 fn dst_II_ref(src: &[f32], dst: &mut [f32], size: usize) {
     let base = consts::PI / (size as f32);
-    for k in 0..size {
+    for (k, dst) in dst.iter_mut().enumerate().take(size) {
         let mut sum = 0.0;
         let kmod = (k + 1) as f32;
-        for n in 0..size {
-            sum += src[n] * (base * ((n as f32) + 0.5) * kmod).sin();
+        for (n, &el) in src.iter().enumerate().take(size) {
+            sum += el * (base * ((n as f32) + 0.5) * kmod).sin();
         }
-        dst[k] = sum * (2.0 / (size as f32)).sqrt();
+        *dst = sum * (2.0 / (size as f32)).sqrt();
     }
     dst[size - 1] /= consts::SQRT_2;
 }
@@ -267,53 +264,53 @@ fn dst_II_ref(src: &[f32], dst: &mut [f32], size: usize) {
 #[allow(non_snake_case)]
 fn dct_III_ref(src: &[f32], dst: &mut [f32], size: usize) {
     let base = consts::PI / (size as f32);
-    for k in 0..size {
+    for (k, dst) in dst.iter_mut().enumerate().take(size) {
         let mut sum = src[0] / consts::SQRT_2;
         let kmod = (k as f32) + 0.5;
-        for n in 1..size {
-            sum += src[n] * (base * (n as f32) * kmod).cos();
+        for (n, &el) in src.iter().enumerate().take(size).skip(1) {
+            sum += el * (base * (n as f32) * kmod).cos();
         }
-        dst[k] = sum * (2.0 / (size as f32)).sqrt();
+        *dst = sum * (2.0 / (size as f32)).sqrt();
     }
 }
 
 #[allow(non_snake_case)]
 fn dst_III_ref(src: &[f32], dst: &mut [f32], size: usize) {
     let base = consts::PI / (size as f32);
-    for k in 0..size {
+    for (k, dst) in dst.iter_mut().enumerate().take(size) {
         let mut sum = 0.0;
         let kmod = (k as f32) + 0.5;
-        for n in 0..size-1 {
-            sum += src[n] * (base * ((n + 1) as f32) * kmod).sin();
+        for (n, &el) in src.iter().enumerate().take(size - 1) {
+            sum += el * (base * ((n + 1) as f32) * kmod).sin();
         }
         sum += src[size - 1] / consts::SQRT_2 * (base * (size as f32) * kmod).sin();
-        dst[k] = sum * (2.0 / (size as f32)).sqrt();
+        *dst = sum * (2.0 / (size as f32)).sqrt();
     }
 }
 
 #[allow(non_snake_case)]
 fn dct_IV_ref(src: &[f32], dst: &mut [f32], size: usize) {
     let base = consts::PI / (size as f32);
-    for k in 0..size {
+    for (k, dst) in dst.iter_mut().enumerate().take(size) {
         let mut sum = 0.0;
         let kmod = (k as f32) + 0.5;
-        for n in 0..size {
-            sum += src[n] * (base * ((n as f32) + 0.5) * kmod).cos();
+        for (n, &el) in src.iter().enumerate().take(size) {
+            sum += el * (base * ((n as f32) + 0.5) * kmod).cos();
         }
-        dst[k] = sum;
+        *dst = sum;
     }
 }
 
 #[allow(non_snake_case)]
 fn dst_IV_ref(src: &[f32], dst: &mut [f32], size: usize) {
     let base = consts::PI / (size as f32);
-    for k in 0..size {
+    for (k, dst) in dst.iter_mut().enumerate().take(size) {
         let mut sum = 0.0;
         let kmod = (k as f32) + 0.5;
-        for n in 0..size {
-            sum += src[n] * (base * ((n as f32) + 0.5) * kmod).sin();
+        for (n, &el) in src.iter().enumerate().take(size) {
+            sum += el * (base * ((n as f32) + 0.5) * kmod).sin();
         }
-        dst[k] = sum;
+        *dst = sum;
     }
 }
 
index 9a80509efa7956f2b290cb54af4c5081ed1bb2c9..f8948d87a04d4213fc37f6931d07e0c2d75f3d92 100644 (file)
@@ -97,6 +97,7 @@ impl MulAssign for FFTComplex {
 
 impl Div for FFTComplex {
     type Output = FFTComplex;
+    #[allow(clippy::suspicious_arithmetic_impl)]
     fn div(self, other: Self) -> Self::Output {
         self * other.reciprocal()
     }
@@ -113,21 +114,14 @@ pub const FFTC_ZERO: FFTComplex = FFTComplex { re: 0.0, im: 0.0 };
 
 /// Calculates forward or inverse FFT in the straightforward way.
 pub fn generic_fft(data: &mut [FFTComplex], forward: bool) {
-    let mut tmp = Vec::with_capacity(data.len());
-    tmp.resize(data.len(), FFTC_ZERO);
+    let mut tmp = vec![FFTC_ZERO; data.len()];
     let base = if forward { -consts::PI * 2.0 / (data.len() as f32) }
                else       {  consts::PI * 2.0 / (data.len() as f32) };
-    for k in 0..data.len() {
-        let mut sum = FFTC_ZERO;
-        for n in 0..data.len() {
-            let w = FFTComplex::exp(base * ((n * k) as f32));
-            sum += data[n] * w;
-        }
-        tmp[k] = sum;
-    }
-    for k in 0..data.len() {
-        data[k] = tmp[k];
+    for (k, el) in tmp.iter_mut().enumerate() {
+        *el = data.iter().enumerate().fold(FFTC_ZERO, |acc, (n, &dta)|
+                acc + dta * FFTComplex::exp(base * ((n * k) as f32)));
     }
+    data.copy_from_slice(&tmp);
 }
 
 struct FFTData {
@@ -156,19 +150,18 @@ fn twiddle5(a: FFTComplex, b: FFTComplex, c: FFTComplex) -> (FFTComplex, FFTComp
 
 impl FFTGeneric {
     fn new_data(size: usize, forward: bool) -> FFTData {
-        let mut table: Vec<FFTComplex> = Vec::with_capacity(size * size);
-        table.resize(size * size, FFTC_ZERO);
+        let mut table = vec![FFTC_ZERO; size * size];
         let base = consts::PI * 2.0 / (size as f32);
         if forward {
-            for n in 0..size {
-                for k in 0..size {
-                    table[n * size + k] = FFTComplex::exp(-base * ((n * k) as f32));
+            for (n, row) in table.chunks_exact_mut(size).enumerate() {
+                for (k, el) in row.iter_mut().enumerate() {
+                    *el = FFTComplex::exp(-base * ((n * k) as f32));
                 }
             }
         } else {
-            for n in 0..size {
-                for k in 0..size {
-                    table[n * size + k] = FFTComplex::exp( base * ((n * k) as f32));
+            for (n, row) in table.chunks_exact_mut(size).enumerate() {
+                for (k, el) in row.iter_mut().enumerate() {
+                    *el = FFTComplex::exp( base * ((n * k) as f32));
                 }
             }
         }
@@ -218,8 +211,8 @@ impl FFTGeneric {
                 tbl.tmp[k] += data[n * step] * tbl.table[k * tbl.size + n];
             }
         }
-        for n in 0..tbl.size {
-            data[n * step] = tbl.tmp[n];
+        for (n, &el) in tbl.tmp[..tbl.size].iter().enumerate() {
+            data[n * step] = el;
         }
     }
     fn ifft(tbl: &mut FFTData, size: usize, data: &mut [FFTComplex], step: usize) {
@@ -497,8 +490,8 @@ impl FFTMode {
                 let div = perms.len() >> bits;
                 gen_sr_perms(perms, 1 << bits);
                 if div > 1 {
-                    for i in 0..(1 << bits) {
-                        perms[i] *= div;
+                    for el in perms.iter_mut().take(1 << bits) {
+                        *el *= div;
                     }
                     for i in 1..div {
                         for j in 0..(1 << bits) {
@@ -672,12 +665,14 @@ fn gen_sr_perms(swaps: &mut [usize], size: usize) {
         evec.push (swaps[k * 4 + 2]);
         ovec2.push(swaps[k * 4 + 3]);
     }
-    for k in 0..size/2 { swaps[k]            = evec[k]; }
-    for k in 0..size/4 { swaps[k +   size/2] = ovec1[k]; }
-    for k in 0..size/4 { swaps[k + 3*size/4] = ovec2[k]; }
-    gen_sr_perms(&mut swaps[0..size/2],        size/2);
-    gen_sr_perms(&mut swaps[size/2..3*size/4], size/4);
-    gen_sr_perms(&mut swaps[3*size/4..],       size/4);
+    let (half0, half1) = swaps[..size].split_at_mut(size / 2);
+    let (quart2, quart3) = half1.split_at_mut(size / 4);
+    half0.copy_from_slice(&evec);
+    quart2.copy_from_slice(&ovec1);
+    quart3.copy_from_slice(&ovec2);
+    gen_sr_perms(half0,  size/2);
+    gen_sr_perms(quart2, size/4);
+    gen_sr_perms(quart3, size/4);
 }
 
 fn gen_swaps_for_perm(swaps: &mut Vec<usize>, perms: &[usize]) {
@@ -819,8 +814,8 @@ impl RDFT {
             buf[0].re = a + b;
             buf[0].im = a - b;
         } else {
-            for n in 0..self.size {
-                buf[n] = FFTComplex{ re: buf[n].im, im: buf[n].re };
+            for el in buf.iter_mut().take(self.size) {
+                *el = FFTComplex{ re: el.im, im: el.re };
             }
         }
     }
index b8c32df34f7a17de5f4a41da104e30d9bde7facc..4a5d2013261a1937c8fa4fac93b300852d8a7e20 100644 (file)
@@ -1,9 +1,7 @@
 //! DSP routines.
 #[cfg(feature="dct")]
-#[allow(clippy::erasing_op)]
 pub mod dct;
 #[cfg(feature="fft")]
-#[allow(clippy::erasing_op)]
 pub mod fft;
 #[cfg(feature="lpc")]
 pub mod lpc;
index eb350e3ecbd319208e8b9312a90cecaad6f31358..b0aed34d7c71323b787a2813413680f221b84c64 100644 (file)
@@ -18,7 +18,7 @@ pub enum WindowType {
 pub fn generate_window(mode: WindowType, scale: f32, size: usize, half: bool, dst: &mut [f32]) {
     match mode {
         WindowType::Square => {
-                for n in 0..size { dst[n] = scale; }
+                for el in dst[..size].iter_mut() { *el = scale; }
             },
         WindowType::Sine => {
                 let param = if half {
@@ -26,8 +26,8 @@ pub fn generate_window(mode: WindowType, scale: f32, size: usize, half: bool, ds
                     } else {
                         consts::PI / (size as f32)
                     };
-                for n in 0..size {
-                    dst[n] = (((n as f32) + 0.5) * param).sin() * scale;
+                for (n, el) in dst[..size].iter_mut().enumerate() {
+                    *el = (((n as f32) + 0.5) * param).sin() * scale;
                 }
             },
         WindowType::KaiserBessel(alpha) => {
@@ -42,8 +42,8 @@ pub fn generate_window(mode: WindowType, scale: f32, size: usize, half: bool, ds
                     kb.push(sum);
                 }
                 sum += 1.0;
-                for n in 0..size {
-                    dst[n] = (kb[n] / sum).sqrt() as f32;
+                for (dst, &kb) in dst.iter_mut().zip(kb.iter()) {
+                    *dst = (kb / sum).sqrt() as f32;
                 }
             },
     };
index 974e4d49f0e5539d50720cbc5c839f317c4c22eb..cd50567b5565e2665b0c53d44ca654d67d38adf4 100644 (file)
@@ -2,6 +2,9 @@
 pub mod codecs;
 
 #[cfg(feature="dsp")]
+#[allow(clippy::erasing_op)]
+#[allow(clippy::excessive_precision)]
+#[allow(clippy::identity_op)]
 pub mod dsp;
 
 pub mod data;