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;
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;
};
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];
}
}
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;
}
}
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;
}
}
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) {
}
#[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 {
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;
} 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 => {
#[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 {
}
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(())
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 {
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;
}
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)]
}
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 {
#[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;
}
#[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;
}
}
impl Div for FFTComplex {
type Output = FFTComplex;
+ #[allow(clippy::suspicious_arithmetic_impl)]
fn div(self, other: Self) -> Self::Output {
self * other.reciprocal()
}
/// 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 {
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));
}
}
}
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) {
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) {
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]) {
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 };
}
}
}
//! 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;
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 {
} 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) => {
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;
}
},
};
pub mod codecs;
#[cfg(feature="dsp")]
+#[allow(clippy::erasing_op)]
+#[allow(clippy::excessive_precision)]
+#[allow(clippy::identity_op)]
pub mod dsp;
pub mod data;