]> git.nihav.org Git - nihav.git/commitdiff
janitorial: fix clippy warnings and update code style for ra14.4 decoder
authorKostya Shishkov <kostya.shishkov@gmail.com>
Fri, 13 Nov 2026 13:54:48 +0000 (14:54 +0100)
committerKostya Shishkov <kostya.shishkov@gmail.com>
Fri, 13 Nov 2026 13:54:48 +0000 (14:54 +0100)
nihav-realmedia/src/codecs/ra144.rs

index ba2bd9e29fa92aeb3d2c5db9357d9d8d3c65476e..3cf3b0d250fa62bb4ceb47de255c9e7ceb17a649 100644 (file)
@@ -42,23 +42,19 @@ impl RA144Decoder {
         let mut tmp: [i32; LPC_ORDER] = [0; LPC_ORDER];
 
         for i in 0..LPC_ORDER {
-            let src;
-            let dst;
-            if (i & 1) == 0 {
-                src = &self.lpc_data[self.frame_no];
-                dst = &mut tmp;
-            } else {
-                src = &tmp;
-                dst = &mut self.lpc_data[self.frame_no];
-            }
+            let (src, dst) = if (i & 1) == 0 {
+                    (&self.lpc_data[self.frame_no], &mut tmp)
+                } else {
+                    (&tmp, &mut self.lpc_data[self.frame_no])
+                };
             dst[i] = lpc_refl[i] << 4;
 
             for j in 0..i {
                 dst[j] = ((lpc_refl[i] * src[i - j - 1]) >> 12) + src[j];
             }
         }
-        for i in 0..LPC_ORDER {
-            self.lpc_data[self.frame_no][i] >>= 4;
+        for el in self.lpc_data[self.frame_no].iter_mut() {
+            *el >>= 4;
         }
     }
     fn interpolate(&mut self, coeffs: &mut [i16; LPC_ORDER], scale1: i32, copyold: bool, energy: u16) -> u32 {
@@ -66,16 +62,16 @@ impl RA144Decoder {
         {
             let src1 = &self.lpc_data[self.frame_no];
             let src2 = &self.lpc_data[self.frame_no ^ 1];
-            for i in 0..LPC_ORDER {
-                coeffs[i] = ((scale1 * src1[i] + scale2 * src2[i]) >> 2) as i16;
+            for (dst, (&s1, &s2)) in coeffs.iter_mut().zip(src1.iter().zip(src2.iter())) {
+                *dst = ((scale1 * s1 + scale2 * s2) >> 2) as i16;
             }
         }
         if let Some(rms) = eval_reflection(coeffs) {
             rescale_rms(rms, energy)
         } else {
             let src = if copyold { &self.lpc_data[self.frame_no ^ 1] } else { &self.lpc_data[self.frame_no] };
-            for i in 0..LPC_ORDER {
-                coeffs[i] = src[i] as i16;
+            for (dst, &c) in coeffs.iter_mut().zip(src.iter()) {
+                *dst = c as i16;
             }
             rescale_rms(self.lpc_refl_rms[if copyold { 1 } else { 0 }], energy)
         }
@@ -102,8 +98,8 @@ impl RA144Decoder {
         }
         m[1] = ((RA144_CODEBOOK1[cb1_idx] as u32) * rms) >> 8;
         m[2] = ((RA144_CODEBOOK2[cb2_idx] as u32) * rms) >> 8;
-        for i in 0..3 {
-            m[i] = (m[i] * (RA144_GAIN_VAL_TAB[gain][i] as u32)) >> RA144_GAIN_EXP_TAB[gain];
+        for (i, coef) in m.iter_mut().enumerate() {
+            *coef = (*coef * u32::from(RA144_GAIN_VAL_TAB[gain][i])) >> RA144_GAIN_EXP_TAB[gain];
         }
 
         for i in 0..(BUFFERSIZE - BLOCKSIZE) {
@@ -190,12 +186,9 @@ fn rescale_rms(rms: u32, energy: u16) -> u32 {
 
 fn eval_reflection(coeffs: &[i16; LPC_ORDER]) -> Option<u32> {
     let mut tmp1: [i32; LPC_ORDER] = [0; LPC_ORDER];
-    let mut tmp2: [i32; LPC_ORDER] = [0; LPC_ORDER];
+    let mut tmp2: [i32; LPC_ORDER] = std::array::from_fn(|i| i32::from(coeffs[i]));
     let mut tmp3: [i32; LPC_ORDER] = [0; LPC_ORDER];
 
-    for i in 0..LPC_ORDER {
-        tmp2[i] = coeffs[i] as i32;
-    }
     tmp3[LPC_ORDER - 1] = tmp2[LPC_ORDER - 1];
 
     if (tmp2[LPC_ORDER - 1] as u32).wrapping_add(0x1000) > 0x1FFF {
@@ -203,24 +196,12 @@ fn eval_reflection(coeffs: &[i16; LPC_ORDER]) -> Option<u32> {
     }
 
     for i in (0..(LPC_ORDER - 1)).rev() {
-        let src;
-        let dst;
-        if (i & 1) == 0 {
-            src = &tmp2;
-            dst = &mut tmp1;
-        } else {
-            src = &tmp1;
-            dst = &mut tmp2;
-        }
+        let (src, dst) = if (i & 1) == 0 { (&tmp2, &mut tmp1) } else { (&tmp1, &mut tmp2) };
         let a = (1 << 12) - ((src[i + 1] * src[i + 1]) >> 12);
         let scale = if a != 0 { (1 << 24) / a } else { 1 << 24 };
         for j in 0..=i {
             let result = (src[j] - ((tmp3[i + 1] * src[i - j]) >> 12)).checked_mul(scale);
-            if let Some(val) = result {
-                dst[j] = val >> 12;
-            } else {
-                return None;
-            }
+            dst[j] = result? >> 12;
         }
         if (dst[i] as u32).wrapping_add(0x1000) > 0x1FFF {
             return None;
@@ -264,8 +245,9 @@ impl NADecoder for RA144Decoder {
             let mut br = BitReader::new(input, BitReaderMode::BE);
 
             let mut lpc_refl: [i32; LPC_ORDER] = [0; LPC_ORDER];
-            for i in 0..LPC_ORDER {
-                lpc_refl[i] = RA144_LPC_REFL_CODEBOOK[i][br.read(RA144_LPC_SIZES[i])? as usize] as i32;
+            for (coef, (cb, &cb_bits)) in lpc_refl.iter_mut()
+                    .zip(RA144_LPC_REFL_CODEBOOK.iter().zip(RA144_LPC_SIZES.iter())) {
+                *coef = i32::from(cb[br.read(cb_bits)? as usize]);
             }
 
             self.evaluate_coeffs(&lpc_refl);
@@ -282,7 +264,9 @@ impl NADecoder for RA144Decoder {
             refl_rms[1] = self.interpolate(&mut block_coeffs[1], 2, energy <= old_energy, interp_energy);
             refl_rms[2] = self.interpolate(&mut block_coeffs[2], 3, false, energy);
             refl_rms[3] = rescale_rms(self.lpc_refl_rms[0], energy);
-            for i in 0..LPC_ORDER { block_coeffs[3][i] = self.lpc_data[self.frame_no][i] as i16; }
+            for (dst, &src) in block_coeffs[3].iter_mut().zip(self.lpc_data[self.frame_no].iter()) {
+                *dst = src as i16;
+            }
 
             for (i, block) in output.chunks_mut(BLOCKSIZE).enumerate() {