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 {
{
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)
}
}
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) {
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 {
}
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;
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);
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() {