From c83013a1f409bc5f83e343cf1b2293aa736e6c93 Mon Sep 17 00:00:00 2001 From: Kostya Shishkov Date: Wed, 15 May 2019 11:17:24 +0200 Subject: [PATCH] commonfmt: fix some clippy warnings --- nihav-commonfmt/src/codecs/aac.rs | 66 ++++++------- nihav-commonfmt/src/codecs/atrac3.rs | 30 +++--- nihav-commonfmt/src/codecs/clearvideo.rs | 120 ++++++----------------- nihav-commonfmt/src/codecs/mod.rs | 2 +- nihav-commonfmt/src/codecs/pcm.rs | 4 +- nihav-commonfmt/src/codecs/sipro.rs | 23 ++--- nihav-commonfmt/src/codecs/ts102366.rs | 94 +++++++++--------- nihav-commonfmt/src/demuxers/avi.rs | 41 ++++---- nihav-commonfmt/src/demuxers/mod.rs | 5 +- nihav-commonfmt/src/lib.rs | 3 + 10 files changed, 161 insertions(+), 227 deletions(-) diff --git a/nihav-commonfmt/src/codecs/aac.rs b/nihav-commonfmt/src/codecs/aac.rs index df5fda3..04fff33 100644 --- a/nihav-commonfmt/src/codecs/aac.rs +++ b/nihav-commonfmt/src/codecs/aac.rs @@ -462,14 +462,14 @@ impl TNSCoeffs { let iqfac = (fac_base - 0.5) / (consts::PI / 2.0); let iqfac_m = (fac_base + 0.5) / (consts::PI / 2.0); let mut tmp: [f32; TNS_MAX_ORDER] = [0.0; TNS_MAX_ORDER]; - for i in 0..self.order { + for el in tmp.iter_mut().take(self.order) { let val = br.read(coef_bits)? as i8; - let c = if (val & sign_mask) != 0 { val | neg_mask } else { val } as f32; - tmp[i] = (if c >= 0.0 { c / iqfac } else { c / iqfac_m }).sin(); + let c = f32::from(if (val & sign_mask) != 0 { val | neg_mask } else { val }); + *el = (if c >= 0.0 { c / iqfac } else { c / iqfac_m }).sin(); } // convert to LPC coefficients let mut b: [f32; TNS_MAX_ORDER + 1] = [0.0; TNS_MAX_ORDER + 1]; - for m in 1..(self.order + 1) { + for m in 1..=self.order { for i in 1..m { b[i] = self.coef[i - 1] + tmp[m - 1] * self.coef[m - i - 1]; } @@ -638,32 +638,30 @@ impl ICS { } fn decode_scale_factor_data(&mut self, br: &mut BitReader, codebooks: &Codebooks) -> DecoderResult<()> { let mut noise_pcm_flag = true; - let mut scf_normal = self.global_gain as i16; + let mut scf_normal = i16::from(self.global_gain); let mut scf_intensity = 0i16; let mut scf_noise = 0i16; for g in 0..self.info.window_groups { for sfb in 0..self.info.max_sfb { if self.sfb_cb[g][sfb] != ZERO_HCB { if self.is_intensity(g, sfb) { - let diff = br.read_cb(&codebooks.scale_cb)? as i16; + let diff = i16::from(br.read_cb(&codebooks.scale_cb)?); scf_intensity += diff; validate!((scf_intensity >= INTENSITY_SCALE_MIN) && (scf_intensity < INTENSITY_SCALE_MIN + 256)); self.scales[g][sfb] = (scf_intensity - INTENSITY_SCALE_MIN) as u8; - } else { - if self.sfb_cb[g][sfb] == NOISE_HCB { - if noise_pcm_flag { - noise_pcm_flag = false; - scf_noise = (br.read(9)? as i16) - 256 + (self.global_gain as i16) - 90; - } else { - scf_noise += br.read_cb(&codebooks.scale_cb)? as i16; - } - validate!((scf_noise >= NOISE_SCALE_MIN) && (scf_noise < NOISE_SCALE_MIN + 256)); - self.scales[g][sfb] = (scf_noise - NOISE_SCALE_MIN) as u8; + } else if self.sfb_cb[g][sfb] == NOISE_HCB { + if noise_pcm_flag { + noise_pcm_flag = false; + scf_noise = (br.read(9)? as i16) - 256 + i16::from(self.global_gain) - 90; } else { - scf_normal += br.read_cb(&codebooks.scale_cb)? as i16; - validate!((scf_normal >= 0) && (scf_normal < 255)); - self.scales[g][sfb] = scf_normal as u8; + scf_noise += i16::from(br.read_cb(&codebooks.scale_cb)?); } + validate!((scf_noise >= NOISE_SCALE_MIN) && (scf_noise < NOISE_SCALE_MIN + 256)); + self.scales[g][sfb] = (scf_noise - NOISE_SCALE_MIN) as u8; + } else { + scf_normal += i16::from(br.read_cb(&codebooks.scale_cb)?); + validate!((scf_normal >= 0) && (scf_normal < 255)); + self.scales[g][sfb] = scf_normal as u8; } } } @@ -731,9 +729,9 @@ impl ICS { base = requant(self.coeffs[k], scale); } if base > 0.0 { - base += pdata.pulse_amp[pno] as f32; + base += f32::from(pdata.pulse_amp[pno]); } else { - base -= pdata.pulse_amp[pno] as f32; + base -= f32::from(pdata.pulse_amp[pno]); } self.coeffs[k] = iquant(base) * scale; } @@ -805,7 +803,7 @@ impl ICS { } fn get_scale(scale: u8) -> f32 { - 2.0f32.powf(0.25 * ((scale as f32) - 100.0 - 56.0)) + 2.0f32.powf(0.25 * (f32::from(scale) - 100.0 - 56.0)) } fn iquant(val: f32) -> f32 { if val < 0.0 { @@ -831,15 +829,15 @@ fn decode_quads(br: &mut BitReader, cb: &Codebook, unsigned: bool, scale: f let val = AAC_QUADS[cw][i]; if val != 0 { if br.read_bool()? { - out[i] = iquant(-val as f32) * scale; + out[i] = iquant(-f32::from(val)) * scale; } else { - out[i] = iquant( val as f32) * scale; + out[i] = iquant( f32::from(val)) * scale; } } } } else { for i in 0..4 { - out[i] = iquant((AAC_QUADS[cw][i] - 1) as f32) * scale; + out[i] = iquant(f32::from(AAC_QUADS[cw][i] - 1)) * scale; } } } @@ -869,8 +867,8 @@ fn decode_pairs(br: &mut BitReader, cb: &Codebook, unsigned: bool, escape: y += read_escape(br, y > 0)?; } } - out[0] = iquant(x as f32) * scale; - out[1] = iquant(y as f32) * scale; + out[0] = iquant(f32::from(x)) * scale; + out[1] = iquant(f32::from(y)) * scale; } Ok(()) } @@ -939,7 +937,7 @@ impl ChannelPair { if self.ics[0].is_intensity(g, sfb) { let invert = (self.ms_mask_present == 1) && self.ms_used[g][sfb]; let dir = self.ics[0].get_intensity_dir(g, sfb) ^ invert; - let scale = 0.5f32.powf(0.25 * ((self.ics[0].scales[g][sfb] as f32) + (INTENSITY_SCALE_MIN as f32))); + let scale = 0.5f32.powf(0.25 * (f32::from(self.ics[0].scales[g][sfb]) + f32::from(INTENSITY_SCALE_MIN))); if !dir { for i in start..end { self.ics[1].coeffs[i] = scale * self.ics[0].coeffs[i]; @@ -1224,7 +1222,7 @@ impl NADecoder for AACDecoder { return Err(DecoderError::NotImplemented); } let chmap_str = DEFAULT_CHANNEL_MAP[self.m4ainfo.channels]; - if chmap_str.len() == 0 { return Err(DecoderError::NotImplemented); } + if chmap_str.is_empty() { return Err(DecoderError::NotImplemented); } self.chmap = NAChannelMap::from_str(chmap_str).unwrap(); Ok(()) @@ -1743,16 +1741,16 @@ struct GASubbandInfo { impl GASubbandInfo { fn find(srate: u32) -> GASubbandInfo { - for i in 0..AAC_SUBBAND_INFO.len() { - if srate >= AAC_SUBBAND_INFO[i].min_srate { - return AAC_SUBBAND_INFO[i]; + for sbi in AAC_SUBBAND_INFO.iter() { + if srate >= sbi.min_srate { + return *sbi; } } unreachable!("") } fn find_idx(srate: u32) -> usize { - for i in 0..AAC_SUBBAND_INFO.len() { - if srate >= AAC_SUBBAND_INFO[i].min_srate { + for (i, sbi) in AAC_SUBBAND_INFO.iter().enumerate() { + if srate >= sbi.min_srate { return i; } } diff --git a/nihav-commonfmt/src/codecs/atrac3.rs b/nihav-commonfmt/src/codecs/atrac3.rs index 0d12cf3..c80bd36 100644 --- a/nihav-commonfmt/src/codecs/atrac3.rs +++ b/nihav-commonfmt/src/codecs/atrac3.rs @@ -156,8 +156,7 @@ impl Channel { } fn synth(&mut self, dsp: &mut DSP) { let mut flag = 0; - let mut band = 0; - for (data, delay) in self.data.chunks_mut(256).zip(self.delay.chunks_mut(256)) { + for (band, (data, delay)) in self.data.chunks_mut(256).zip(self.delay.chunks_mut(256)).enumerate() { if (flag & 1) != 0 { for i in 0..128 { let t0 = data[i]; @@ -170,7 +169,6 @@ impl Channel { dsp.apply_gains(data, delay, &mut self.gain_data, self.block_no, band); delay.copy_from_slice(&dsp.tmp[256..512]); flag ^= 1; - band += 1; } self.block_no ^= 1; } @@ -209,15 +207,15 @@ const ATRAC3_MODE0_BITS: [u8; 8] = [ 0, 4, 3, 3, 4, 4, 5, 6 ]; fn read_coeffs_mode0(br: &mut BitReader, dst: &mut [f32], quant: usize, scale: f32) -> DecoderResult<()> { let bits = ATRAC3_MODE0_BITS[quant]; if bits > 0 { - for i in 0..dst.len() { + for el in dst.iter_mut() { let val = br.read_s(bits)? as f32; - dst[i] = val * scale; + *el = val * scale; } } else { - for i in (0..dst.len()).step_by(2) { + for out in dst.chunks_mut(2) { let val = br.read(4)? as usize; - dst[i + 0] = ATRAC3_MODE0_CB[val >> 2] * scale; - dst[i + 1] = ATRAC3_MODE0_CB[val & 3] * scale; + out[0] = ATRAC3_MODE0_CB[val >> 2] * scale; + out[1] = ATRAC3_MODE0_CB[val & 3] * scale; } } Ok(()) @@ -236,20 +234,20 @@ const ATRAC3_MODE1_CB: [f32; 9 * 2] = [ ]; fn read_coeffs_mode1(br: &mut BitReader, cb: &Codebook, dst: &mut [f32], scale: f32) -> DecoderResult<()> { - for i in (0..dst.len()).step_by(2) { + for out in dst.chunks_mut(2) { let val = br.read_cb(cb)? as usize; - dst[i + 0] = ATRAC3_MODE1_CB[val * 2 + 0] * scale; - dst[i + 1] = ATRAC3_MODE1_CB[val * 2 + 1] * scale; + out[0] = ATRAC3_MODE1_CB[val * 2 + 0] * scale; + out[1] = ATRAC3_MODE1_CB[val * 2 + 1] * scale; } Ok(()) } fn read_coeffs_other(br: &mut BitReader, cb: &Codebook, dst: &mut [f32], scale: f32) -> DecoderResult<()> { - for i in 0..dst.len() { + for el in dst.iter_mut() { let val = (br.read_cb(cb)? as i8) + 1; let sign = (val & 1) != 0; - let coef = (if sign { -(val >> 1) } else { val >> 1 }) as f32; - dst[i] = coef * scale; + let coef = f32::from(if sign { -(val >> 1) } else { val >> 1 }); + *el = coef * scale; } Ok(()) } @@ -512,7 +510,7 @@ impl Atrac3Decoder { if self.weighting_delay[1] == 7 { pw = [1.0; 2]; } else { - let w = (self.weighting_delay[1] as f32) / 7.0; + let w = f32::from(self.weighting_delay[1]) / 7.0; let iw = (2.0 - w * w).sqrt(); if self.weighting_delay[0] == 0 { pw = [w, iw]; @@ -524,7 +522,7 @@ impl Atrac3Decoder { if self.weighting_delay[3] == 7 { cw = [1.0; 2]; } else { - let w = (self.weighting_delay[3] as f32) / 7.0; + let w = f32::from(self.weighting_delay[3]) / 7.0; let iw = (2.0 - w * w).sqrt(); if self.weighting_delay[2] == 0 { cw = [w, iw]; diff --git a/nihav-commonfmt/src/codecs/clearvideo.rs b/nihav-commonfmt/src/codecs/clearvideo.rs index 4aee1fe..46cbb54 100644 --- a/nihav-commonfmt/src/codecs/clearvideo.rs +++ b/nihav-commonfmt/src/codecs/clearvideo.rs @@ -3,8 +3,6 @@ use nihav_core::io::bitreader::*; use nihav_core::io::codebook::*; use nihav_core::formats; use nihav_core::codecs::*; -use std::fmt; -use std::ops::{Add, Sub}; struct CLVDCCodeReader { } struct CLVACCodeReader { } @@ -13,28 +11,28 @@ struct CLVSym16CodeReader { codes: &'static [u16], bits: &'static [u8], syms: &' impl CodebookDescReader for CLVDCCodeReader { fn bits(&mut self, idx: usize) -> u8 { CLV_DC_BITS[idx] } - fn code(&mut self, idx: usize) -> u32 { CLV_DC_CODES[idx] as u32 } + fn code(&mut self, idx: usize) -> u32 { u32::from(CLV_DC_CODES[idx]) } fn sym (&mut self, idx: usize) -> i8 { (idx as i8) - 63 } fn len(&mut self) -> usize { CLV_DC_BITS.len() } } impl CodebookDescReader for CLVACCodeReader { fn bits(&mut self, idx: usize) -> u8 { CLV_AC_BITS[idx] } - fn code(&mut self, idx: usize) -> u32 { CLV_AC_CODES[idx] as u32 } + fn code(&mut self, idx: usize) -> u32 { u32::from(CLV_AC_CODES[idx]) } fn sym (&mut self, idx: usize) -> u16 { CLV_AC_SYMS[idx] } fn len(&mut self) -> usize { CLV_AC_BITS.len() } } impl CodebookDescReader for CLVFlagsCodeReader { fn bits(&mut self, idx: usize) -> u8 { self.bits[idx] } - fn code(&mut self, idx: usize) -> u32 { self.codes[idx] as u32 } + fn code(&mut self, idx: usize) -> u32 { u32::from(self.codes[idx]) } fn sym (&mut self, idx: usize) -> u8 { idx as u8 } fn len(&mut self) -> usize { self.bits.len() } } impl CodebookDescReader for CLVSym16CodeReader { fn bits(&mut self, idx: usize) -> u8 { self.bits[idx] } - fn code(&mut self, idx: usize) -> u32 { self.codes[idx] as u32 } + fn code(&mut self, idx: usize) -> u32 { u32::from(self.codes[idx]) } fn sym (&mut self, idx: usize) -> u16 { self.syms[idx] } fn len(&mut self) -> usize { self.bits.len() } } @@ -53,83 +51,24 @@ impl LevelCodes { mvd: Option<(&'static [u8], &'static [u16], &'static [u16])>, mv_esc: u16, bias: Option<(&'static [u8], &'static [u16], &'static [u16])>, bias_esc: u16) -> Self { let flags_cb = if let Some((bits, codes)) = flgd { - let mut coderead = CLVFlagsCodeReader { bits: bits, codes: codes }; + let mut coderead = CLVFlagsCodeReader { bits, codes }; Some(Codebook::new(&mut coderead, CodebookMode::MSB).unwrap()) } else { None }; let mv_cb = if let Some((bits, codes, syms)) = mvd { - let mut coderead = CLVSym16CodeReader { bits: bits, codes: codes, syms: syms }; + let mut coderead = CLVSym16CodeReader { bits, codes, syms }; Some(Codebook::new(&mut coderead, CodebookMode::MSB).unwrap()) } else { None }; let bias_cb = if let Some((bits, codes, syms)) = bias { - let mut coderead = CLVSym16CodeReader { bits: bits, codes: codes, syms: syms }; + let mut coderead = CLVSym16CodeReader { bits, codes, syms }; Some(Codebook::new(&mut coderead, CodebookMode::MSB).unwrap()) } else { None }; - LevelCodes { flags_cb: flags_cb, mv_cb: mv_cb, mv_esc: mv_esc, bias_cb: bias_cb, bias_esc: bias_esc } - } -} - -#[derive(Debug,Clone,Copy)] -pub struct MV { - x: i16, - y: i16, -} - -impl MV { - pub fn new(x: i16, y: i16) -> Self { MV{ x: x, y: y } } - pub fn pred(a: MV, b: MV, c: MV) -> Self { - let x; - if a.x < b.x { - if b.x < c.x { - x = b.x; - } else { - if a.x < c.x { x = c.x; } else { x = a.x; } - } - } else { - if b.x < c.x { - if a.x < c.x { x = a.x; } else { x = c.x; } - } else { - x = b.x; - } - } - let y; - if a.y < b.y { - if b.y < c.y { - y = b.y; - } else { - if a.y < c.y { y = c.y; } else { y = a.y; } - } - } else { - if b.y < c.y { - if a.y < c.y { y = a.y; } else { y = c.y; } - } else { - y = b.y; - } - } - MV { x: x, y: y } - } -} - -pub const ZERO_MV: MV = MV { x: 0, y: 0 }; - -impl Add for MV { - type Output = MV; - fn add(self, other: MV) -> MV { MV { x: self.x + other.x, y: self.y + other.y } } -} - -impl Sub for MV { - type Output = MV; - fn sub(self, other: MV) -> MV { MV { x: self.x - other.x, y: self.y - other.y } } -} - -impl fmt::Display for MV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{},{}", self.x, self.y) + LevelCodes { flags_cb, mv_cb, mv_esc, bias_cb, bias_esc } } } @@ -208,8 +147,8 @@ fn dct_row(blk: &mut [i32]) { let t7 = ((blk[0] - blk[4]) << dshift) + (1 << (shift - 1)); let t8 = t0 + t2; let t9 = t0 - t2; - let tA = 181 * (t9 + (t1 - t3)) + 0x80 >> 8; - let tB = 181 * (t9 - (t1 - t3)) + 0x80 >> 8; + let tA = (181 * (t9 + (t1 - t3)) + 0x80) >> 8; + let tB = (181 * (t9 - (t1 - t3)) + 0x80) >> 8; let tC = t1 + t3; blk[0] = (t6 + t5 + t8) >> shift; @@ -224,6 +163,7 @@ fn dct_row(blk: &mut [i32]) { #[allow(non_snake_case)] #[allow(clippy::erasing_op)] +#[allow(clippy::identity_op)] fn dct_col(blk: &mut [i32; 64], col: usize) { let dshift = 8; let shift = 14; @@ -237,8 +177,8 @@ fn dct_col(blk: &mut [i32; 64], col: usize) { let t7 = ((blk[0*8 + col] - blk[4*8 + col]) << dshift) + (1 << (shift - 1)); let t8 = t0 + t2; let t9 = t0 - t2; - let tA = 181 * (t9 + (t1 - t3)) + 0x80 >> 8; - let tB = 181 * (t9 - (t1 - t3)) + 0x80 >> 8; + let tA = (181 * (t9 + (t1 - t3)) + 0x80) >> 8; + let tB = (181 * (t9 - (t1 - t3)) + 0x80) >> 8; let tC = t1 + t3; blk[0*8 + col] = (t6 + t5 + t8) >> shift; @@ -258,7 +198,7 @@ fn clv_dct(blk: &mut [i32; 64]) { fn clv_dct_dc(blk: &mut [i32; 64]) { let dval = blk[0] >> 3; - for i in 0..64 { blk[i] = dval; } + for el in blk.iter_mut() { *el = dval; } } fn put_blocks(buf: &mut NAVideoBuffer, xpos: usize, ypos: usize, blk: &[[i32;64]; 6]) { @@ -275,12 +215,12 @@ fn put_blocks(buf: &mut NAVideoBuffer, xpos: usize, ypos: usize, blk: &[[i32 for j in 0..8 { for k in 0..8 { let mut v = blk[0][k + j * 8] + 128; - if v < 0 { v = 0; } if v > 255 { v = 255; } + if v < 0 { v = 0; } else if v > 255 { v = 255; } framebuf[idxy + k] = v as u8; } for k in 0..8 { let mut v = blk[1][k + j * 8] + 128; - if v < 0 { v = 0; } if v > 255 { v = 255; } + if v < 0 { v = 0; } else if v > 255 { v = 255; } framebuf[idxy + k + 8] = v as u8; } idxy += stridey; @@ -288,12 +228,12 @@ fn put_blocks(buf: &mut NAVideoBuffer, xpos: usize, ypos: usize, blk: &[[i32 for j in 0..8 { for k in 0..8 { let mut v = blk[2][k + j * 8] + 128; - if v < 0 { v = 0; } if v > 255 { v = 255; } + if v < 0 { v = 0; } else if v > 255 { v = 255; } framebuf[idxy + k] = v as u8; } for k in 0..8 { let mut v = blk[3][k + j * 8] + 128; - if v < 0 { v = 0; } if v > 255 { v = 255; } + if v < 0 { v = 0; } else if v > 255 { v = 255; } framebuf[idxy + k + 8] = v as u8; } idxy += stridey; @@ -302,12 +242,12 @@ fn put_blocks(buf: &mut NAVideoBuffer, xpos: usize, ypos: usize, blk: &[[i32 for j in 0..8 { for k in 0..8 { let mut v = blk[4][k + j * 8] + 128; - if v < 0 { v = 0; } if v > 255 { v = 255; } + if v < 0 { v = 0; } else if v > 255 { v = 255; } framebuf[idxu + k] = v as u8; } for k in 0..8 { let mut v = blk[5][k + j * 8] + 128; - if v < 0 { v = 0; } if v > 255 { v = 255; } + if v < 0 { v = 0; } else if v > 255 { v = 255; } framebuf[idxv + k] = v as u8; } idxu += strideu; @@ -356,7 +296,7 @@ fn copyadd_block(dst: &mut NAVideoBuffer, src: &NAVideoBuffer, let dst = &mut dbuf[doff..][..size]; let src = &sbuf[soff..][..size]; for i in 0..size { - let val = (src[i] as i16) + bias; + let val = i16::from(src[i]) + bias; if val < 0x00 { dst[i] = 0x00; } else if val > 0xFF { dst[i] = 0xFF; } else { dst[i] = val as u8; } @@ -445,7 +385,7 @@ fn decode_dct_block(br: &mut BitReader, blk: &mut [i32; 64], ac_quant: i32, has_ let mut idx = 1; let mut eob = false; - blk[0] = br.read_cb(dc_cb)? as i32; + blk[0] = i32::from(br.read_cb(dc_cb)?); if !has_ac { return Ok(()); } @@ -454,7 +394,7 @@ fn decode_dct_block(br: &mut BitReader, blk: &mut [i32; 64], ac_quant: i32, has_ let (level, skip) = if val != CLV_AC_ESCAPE { eob = ((val >> 12) & 1) != 0; let run = ((val >> 4) & 0xFF) as usize; - let lev = (val & 0xF) as i32; + let lev = i32::from(val & 0xF); if br.read_bool()? { (-lev, run) } else { @@ -496,7 +436,7 @@ fn decode_tile_info(br: &mut BitReader, lc: &[LevelCodes], level: usize) -> Deco let mv = if let Some(ref cb) = lc[level].mv_cb { let mv_code = br.read_cb(cb)?; if mv_code != lc[level].mv_esc { - MV::new(((mv_code & 0xFF) as i8) as i16, (mv_code as i16) >> 8) + MV::new(i16::from((mv_code & 0xFF) as i8), (mv_code as i16) >> 8) } else { let x = br.read_s(8)? as i16; let y = br.read_s(8)? as i16; @@ -515,7 +455,7 @@ fn decode_tile_info(br: &mut BitReader, lc: &[LevelCodes], level: usize) -> Deco } else { 0 }; - let mut ti = TileInfo { flags: flags, mv: mv, bias: bias, child: [None, None, None, None] }; + let mut ti = TileInfo { flags, mv, bias, child: [None, None, None, None] }; if ti.flags != 0 { for i in 0..4 { if (ti.flags & (1 << i)) != 0 { @@ -537,9 +477,9 @@ impl ClearVideoDecoder { ClearVideoDecoder { info: dummy_info, - dc_cb: dc_cb, ac_cb: ac_cb, + dc_cb, ac_cb, frmmgr: HAMShuffler::new(), - is_rm: is_rm, + is_rm, ylev: [ LevelCodes::new(Some((CLV_FLAGSY_0_BITS, CLV_FLAGSY_0_CODES)), Some((CLV_MVY_0_BITS, CLV_MVY_0_CODES, CLV_MVY_0_SYMS)), CLV_MVY_0_ESCAPE, @@ -594,7 +534,7 @@ impl ClearVideoDecoder { let mut blks: [[i32; 64]; 6] = [[0; 64]; 6]; let mut has_ac: [bool; 6] = [false; 6]; - for i in 0..6 { has_ac[i] = br.read_bool()? } + for flag in has_ac.iter_mut() { *flag = br.read_bool()?; } for i in 0..4 { decode_dct_block(br, &mut blks[i], ac_quant, has_ac[i], &self.dc_cb, &self.ac_cb)?; @@ -734,9 +674,7 @@ impl NADecoder for ClearVideoDecoder { let mut br = BitReader::new(&src[(off + 1)..], src.len() - (off + 1), BitReaderMode::BE); let vinfo = self.info.get_properties().get_video_info().unwrap(); - let bufret = alloc_video_buffer(vinfo, self.tsize); - if let Err(_) = bufret { return Err(DecoderError::InvalidData); } - let bufinfo = bufret.unwrap(); + let bufinfo = alloc_video_buffer(vinfo, self.tsize)?; let mut buf = bufinfo.get_vbuf().unwrap(); if is_intra { diff --git a/nihav-commonfmt/src/codecs/mod.rs b/nihav-commonfmt/src/codecs/mod.rs index 886b807..fa7b2f1 100644 --- a/nihav-commonfmt/src/codecs/mod.rs +++ b/nihav-commonfmt/src/codecs/mod.rs @@ -37,7 +37,7 @@ const DECODERS: &[DecoderInfo] = &[ ]; pub fn generic_register_all_codecs(rd: &mut RegisteredDecoders) { - for decoder in DECODERS.into_iter() { + for decoder in DECODERS.iter() { rd.add_decoder(decoder.clone()); } } diff --git a/nihav-commonfmt/src/codecs/pcm.rs b/nihav-commonfmt/src/codecs/pcm.rs index 7967b34..49e9dad 100644 --- a/nihav-commonfmt/src/codecs/pcm.rs +++ b/nihav-commonfmt/src/codecs/pcm.rs @@ -25,10 +25,10 @@ fn get_default_chmap(nch: u8) -> NAChannelMap { fn get_duration(ainfo: &NAAudioInfo, duration: Option, data_size: usize) -> u64 { if duration == None { let size_bits = (data_size as u64) * 8; - let blk_size = (ainfo.get_channels() as u64) * (ainfo.get_format().get_bits() as u64); + let blk_size = u64::from(ainfo.get_channels()) * u64::from(ainfo.get_format().get_bits()); size_bits / blk_size } else { - duration.unwrap() as u64 + duration.unwrap() } } diff --git a/nihav-commonfmt/src/codecs/sipro.rs b/nihav-commonfmt/src/codecs/sipro.rs index e617c9e..fd035c6 100644 --- a/nihav-commonfmt/src/codecs/sipro.rs +++ b/nihav-commonfmt/src/codecs/sipro.rs @@ -6,6 +6,7 @@ use nihav_core::io::bitreader::*; use std::f32::consts::PI; #[derive(Clone,Copy,PartialEq)] +#[allow(clippy::enum_variant_names)] enum SiproMode { Mode16k, Mode8_5k, @@ -14,7 +15,7 @@ enum SiproMode { } impl SiproMode { - fn is16k(&self) -> bool { *self == SiproMode::Mode16k } + fn is16k(self) -> bool { self == SiproMode::Mode16k } } const SIPRO_MODE_FROM_IDX: [SiproMode; 4] = [ @@ -391,9 +392,9 @@ impl SiproDecoder { fn update_gain_16k(&mut self, sf: usize) { let mut energy: f64 = 0.0; for i in 0..80 { - energy += (self.fix_vec[i] as f64) * (self.fix_vec[i] as f64); + energy += f64::from(self.fix_vec[i]) * f64::from(self.fix_vec[i]); } - let ehist = ((0.8 * self.energy_hist[0] + 0.6 * self.energy_hist[1]) as f64) - 71.30899869919435856603; + let ehist = f64::from(0.8 * self.energy_hist[0] + 0.6 * self.energy_hist[1]) - 71.30899869919435856603; let rms = 8.94427190999915878559 * (10.0f64.ln() / 20.0 * ehist).exp() / (0.01 + energy).sqrt(); let gain = SIPRO_GAIN_CB_16K[self.gc_index[sf]] * (rms as f32); @@ -425,7 +426,7 @@ impl SiproDecoder { } self.energy_hist[3] = 20.0 * gain1.log10(); - let gain = ((gain1 as f64) * ((sum as f64) * (10.0f64).ln() * 0.05).exp() / (self.avg_energy as f64).sqrt()) as f32; + let gain = (f64::from(gain1) * (f64::from(sum) * (10.0f64).ln() * 0.05).exp() / f64::from(self.avg_energy).sqrt()) as f32; let exc = &mut self.excitation[EXCITATION_OFFSET + sf * 48..][..48]; for i in 0..48 { exc[i] = exc[i] * gain0 + self.fix_vec[i] * gain; @@ -586,13 +587,13 @@ impl SiproDecoder { fn lsp2poly(lsp: &[f32], poly: &mut [f64], order: usize) { poly[0] = 1.0; - poly[1] = -2.0 * (lsp[0] as f64); + poly[1] = -2.0 * f64::from(lsp[0]); for i in 1..order { - poly[i + 1] = -2.0 * (lsp[2 * i] as f64) * poly[i] + 2.0 * poly[i - 1]; + poly[i + 1] = -2.0 * f64::from(lsp[2 * i]) * poly[i] + 2.0 * poly[i - 1]; for j in (2..i+1).rev() { - poly[j] += -2.0 * (lsp[2 * i] as f64) * poly[j - 1] + poly[j - 2]; + poly[j] += -2.0 * f64::from(lsp[2 * i]) * poly[j - 1] + poly[j - 2]; } - poly[1] += -2.0 * (lsp[2 * i] as f64); + poly[1] += -2.0 * f64::from(lsp[2 * i]); } } @@ -614,8 +615,8 @@ fn lsp2lpc_lbr(lpc: &mut [f32], lsp: &[f32]) { lsp2poly(&lsp[0..], &mut a[0..], 5); lsp2poly(&lsp[1..], &mut b[1..], 4); - let ascale = (1.0 + lsp[9]) as f64; - let bscale = (1.0 - lsp[9]) as f64; + let ascale = f64::from(1.0 + lsp[9]); + let bscale = f64::from(1.0 - lsp[9]); for i in 1..5 { let ta = ascale * a[i]; let tb = bscale * (b[i + 1] - b[i - 1]); @@ -662,7 +663,7 @@ impl NADecoder for SiproDecoder { self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), 1, SND_F32P_FORMAT, 0); - self.info = info.replace_info(NACodecTypeInfo::Audio(self.ainfo.clone())); + self.info = info.replace_info(NACodecTypeInfo::Audio(self.ainfo)); Ok(()) } else { Err(DecoderError::InvalidData) diff --git a/nihav-commonfmt/src/codecs/ts102366.rs b/nihav-commonfmt/src/codecs/ts102366.rs index f30652c..65b1b9e 100644 --- a/nihav-commonfmt/src/codecs/ts102366.rs +++ b/nihav-commonfmt/src/codecs/ts102366.rs @@ -43,7 +43,7 @@ impl IMDCTContext { xsincos[k].im = -factor.sin(); } let fft = FFTBuilder::new_fft(size/4, false); - IMDCTContext { xsincos: xsincos, size: size, fft: fft } + IMDCTContext { xsincos, size, fft } } #[allow(non_snake_case)] fn do_imdct(&mut self, coeffs: &[i32; BLOCK_LEN], tmp: &mut IMDCTWorkspace) { @@ -181,11 +181,11 @@ struct Syncinfo { impl Syncinfo { fn read(br: &mut BitReader) -> DecoderResult { let syncword = br.read(16)?; - validate!(syncword == ((MAGIC_BYTE0 as u32) * 256) + (MAGIC_BYTE1 as u32)); + validate!(syncword == (u32::from(MAGIC_BYTE0) * 256) + u32::from(MAGIC_BYTE1)); let crc1 = br.read(16)? as u16; let fscod = br.read(2)? as usize; let frmsizecod = br.read(6)? as usize; - Ok(Syncinfo { crc1: crc1, fscod: fscod as u8, frmsizecod: frmsizecod as u8, + Ok(Syncinfo { crc1, fscod: fscod as u8, frmsizecod: frmsizecod as u8, samplerate: SAMPLE_RATES[fscod], frame_size: FRAME_SIZES[fscod][frmsizecod] * 2 }) } fn is_valid(&self) -> bool { @@ -228,8 +228,8 @@ enum ACMode { } impl ACMode { - fn get_num_channels(&self) -> usize { - match *self { + fn get_num_channels(self) -> usize { + match self { ACMode::DualMono => 2, ACMode::Mono => 1, ACMode::Stereo => 2, @@ -240,8 +240,8 @@ impl ACMode { ACMode::Mode3_2 => 5, } } - fn get_channel_map_str(&self) -> &'static str { - match *self { + fn get_channel_map_str(self) -> &'static str { + match self { ACMode::DualMono => "C,C", ACMode::Mono => "C", ACMode::Stereo => "L,R", @@ -252,23 +252,23 @@ impl ACMode { ACMode::Mode3_2 => "L,C,R,Ls,Rs", } } - fn get_channel_map(&self, has_lfe: bool) -> NAChannelMap { + fn get_channel_map(self, has_lfe: bool) -> NAChannelMap { let mut chmap = NAChannelMap::from_str(self.get_channel_map_str()).unwrap(); if has_lfe { chmap.add_channel(NAChannelType::LFE); } chmap } - fn is_3_x(&self) -> bool { - match *self { + fn is_3_x(self) -> bool { + match self { ACMode::Mode3_0 | ACMode::Mode3_1 | ACMode::Mode3_2 => true, _ => false, } } - fn is_surround(&self) -> bool { - match *self { + fn is_surround(self) -> bool { + match self { ACMode::Mode2_1 | ACMode::Mode3_1 | ACMode::Mode2_2 | @@ -369,7 +369,7 @@ impl BSI { Ok(BSI{ bsid, shift, bsmod, acmod, lfeon, cmixlev, surmixlev, dsurmod, - mixinfo: mixinfo, mixinfo2: mixinfo2, + mixinfo, mixinfo2, copysmth, origbs, timecod1, timecod2, has_addb, }) } @@ -557,7 +557,7 @@ impl ChannelData { let bndpsd = &mut self.bndpsd; for bin in start..end { - psd[bin] = 3072 - ((exps[bin] as i16) << 7); + psd[bin] = 3072 - (i16::from(exps[bin]) << 7); } let mut bin = start; @@ -565,10 +565,10 @@ impl ChannelData { let mut lastbin; loop { lastbin = ((TS102366_BAND_START[band] as usize) + (TS102366_BAND_SIZE[band] as usize)).min(end); - bndpsd[band] = psd[bin] as i32; + bndpsd[band] = i32::from(psd[bin]); bin += 1; while bin < lastbin { - bndpsd[band] = logadd(bndpsd[band], psd[bin] as i32); + bndpsd[band] = logadd(bndpsd[band], i32::from(psd[bin])); bin += 1; } band += 1; @@ -577,7 +577,7 @@ impl ChannelData { } fn compute_mask(&mut self, mask: &mut [i32; MAX_BANDS], fscod: usize, sgain: u16, fdecay: u8, sdecay: u8, dbknee: u16, cplfleak: u16, cplsleak: u16, shift: u8) { - let fgain = TS102366_FAST_GAIN[self.fgaincod] as i32; + let fgain = i32::from(TS102366_FAST_GAIN[self.fgaincod]); let bndstart = TS102366_BIN_TO_BAND[self.startmant] as usize; let bndend = (TS102366_BIN_TO_BAND[self.endmant - 1] as usize) + 1; @@ -602,39 +602,37 @@ impl ChannelData { lowcomp = calc_lowcomp(lowcomp, self.bndpsd[band], self.bndpsd[band + 1], band); } fast_leak = self.bndpsd[band] - fgain; - slow_leak = self.bndpsd[band] - (sgain as i32); + slow_leak = self.bndpsd[band] - i32::from(sgain); excite[band] = fast_leak - lowcomp; - if not_lfe_case { - if self.bndpsd[band] <= self.bndpsd[band + 1] { - sband = band + 1; - break; - } + if not_lfe_case && (self.bndpsd[band] <= self.bndpsd[band + 1]) { + sband = band + 1; + break; } } for band in sband..bndend.min(22) { if (bndend != 7) || (band != 6) { lowcomp = calc_lowcomp(lowcomp, self.bndpsd[band], self.bndpsd[band + 1], band); } - fast_leak = (fast_leak - (fdecay as i32)).max(self.bndpsd[band] - (fgain as i32)); - slow_leak = (slow_leak - (sdecay as i32)).max(self.bndpsd[band] - (sgain as i32)); + fast_leak = (fast_leak - i32::from(fdecay)).max(self.bndpsd[band] - fgain); + slow_leak = (slow_leak - i32::from(sdecay)).max(self.bndpsd[band] - i32::from(sgain)); excite[band] = slow_leak.max(fast_leak - lowcomp); } begin = 22; } else { begin = bndstart; - fast_leak = cplfleak as i32; - slow_leak = cplsleak as i32; + fast_leak = i32::from(cplfleak); + slow_leak = i32::from(cplsleak); } for band in begin..bndend { - fast_leak = (fast_leak - (fdecay as i32)).max(self.bndpsd[band] - (fgain as i32)); - slow_leak = (slow_leak - (sdecay as i32)).max(self.bndpsd[band] - (sgain as i32)); + fast_leak = (fast_leak - i32::from(fdecay)).max(self.bndpsd[band] - fgain); + slow_leak = (slow_leak - i32::from(sdecay)).max(self.bndpsd[band] - i32::from(sgain)); excite[band] = fast_leak.max(slow_leak); } for band in bndstart..bndend { - if self.bndpsd[band] < (dbknee as i32) { - excite[band] += ((dbknee as i32) - self.bndpsd[band]) >> 2; + if self.bndpsd[band] < i32::from(dbknee) { + excite[band] += (i32::from(dbknee) - self.bndpsd[band]) >> 2; } - mask[band] = excite[band].max(TS102366_HTH[fscod][band >> shift] as i32); + mask[band] = excite[band].max(i32::from(TS102366_HTH[fscod][band >> shift])); } } fn apply_delta_info(&mut self, mask: &mut [i32; MAX_BANDS]) { @@ -643,9 +641,9 @@ impl ChannelData { for seg in 0..self.deltnseg { band += self.deltoffst[seg] as usize; let delta = if self.deltba[seg] >= 4 { - ((self.deltba[seg] as i32) - 3) << 7 + (i32::from(self.deltba[seg]) - 3) << 7 } else { - ((self.deltba[seg] as i32) - 4) << 7 + (i32::from(self.deltba[seg]) - 4) << 7 }; if band + self.deltlen[seg] > MAX_BANDS { break; } for _ in 0..self.deltlen[seg] { @@ -656,7 +654,7 @@ impl ChannelData { } } fn calc_snr_offset(&mut self, csnroffst: u8) { - self.snroffset = ((((csnroffst as i32) - 15) << 4) + (self.fsnroffst as i32)) << 2; + self.snroffset = (((i32::from(csnroffst) - 15) << 4) + i32::from(self.fsnroffst)) << 2; } fn compute_bap(&mut self, mask: &mut [i32; MAX_BANDS], floor: u16) { let end = self.endmant; @@ -665,10 +663,10 @@ impl ChannelData { let mut lastbin; loop { lastbin = ((TS102366_BAND_START[band] as usize) + (TS102366_BAND_SIZE[band] as usize)).min(end); - mask[band] = (mask[band] - self.snroffset - (floor as i32)).max(0) & 0x1FE0; - mask[band] += floor as i32; + mask[band] = (mask[band] - self.snroffset - i32::from(floor)).max(0) & 0x1FE0; + mask[band] += i32::from(floor); while bin < lastbin { - let addr = (((self.psd[bin] as i32) - mask[band]) >> 5).min(63).max(0) as usize; + let addr = ((i32::from(self.psd[bin]) - mask[band]) >> 5).min(63).max(0) as usize; self.bap[bin] = TS102366_BAPTAB[addr]; bin += 1; } @@ -696,7 +694,7 @@ impl ChannelData { validate!(self.bap[bin] < 15); let nbits = TS102366_BAP_BITS[(self.bap[bin] as usize) - 6]; let val = br.read(nbits)? as i16; - ((val << (16 - nbits)) as i32) << 9 + i32::from(val << (16 - nbits)) << 9 }, }; self.mant[bin] >>= self.exps[bin]; @@ -718,9 +716,9 @@ fn logadd(acc: i32, add: i32) -> i32 { let c = acc - add; let addr = (c.abs() >> 1).min(255); if c >= 0 { - acc + (TS102366_LATAB[addr as usize] as i32) + acc + i32::from(TS102366_LATAB[addr as usize]) } else { - add + (TS102366_LATAB[addr as usize] as i32) + add + i32::from(TS102366_LATAB[addr as usize]) } } @@ -749,7 +747,7 @@ fn calc_lowcomp(a: i32, b0: i32, b1: i32, band: usize) -> i32 { fn overlap(delay: &mut [f32; BLOCK_LEN], src: &[f32; BLOCK_LEN * 2], out: &mut [f32]) { { let dly = &delay; - for ((d, s), o) in dly.into_iter().zip(src.into_iter()).zip(out.iter_mut()) { + for ((d, s), o) in dly.iter().zip(src.iter()).zip(out.iter_mut()) { *o = (*d + *s) * 2.0; } } @@ -1063,7 +1061,7 @@ impl AudioBlock { if self.cplinu { self.chdata[CPL_CHANNEL].compute_bndpsd(); self.chdata[CPL_CHANNEL].compute_mask(&mut mask, fscod, sgain, fdecay, sdecay, dbknee, - ((self.cplfleak as u16) << 8) + 768, ((self.cplsleak as u16) << 8) + 768, bsi.shift); + (u16::from(self.cplfleak) << 8) + 768, (u16::from(self.cplsleak) << 8) + 768, bsi.shift); self.chdata[CPL_CHANNEL].apply_delta_info(&mut mask); self.chdata[CPL_CHANNEL].calc_snr_offset(self.csnroffst); self.chdata[CPL_CHANNEL].compute_bap(&mut mask, floor); @@ -1093,7 +1091,7 @@ impl AudioBlock { for band in self.cplbegf..self.cplendf { let cband = band - self.cplbegf; let comant = self.chdata[ch].cplcomant[cband]; - let mut cotemp = (if self.chdata[ch].cplcoexp[cband] == 15 { comant << 1 } else { comant + 16 }) as i32; + let mut cotemp = i32::from(if self.chdata[ch].cplcoexp[cband] == 15 { comant << 1 } else { comant + 16 }); if (acmod == ACMode::Stereo) && (ch == 1) && self.phsflginu && self.phsflg[pband] { cotemp = -cotemp; } @@ -1103,7 +1101,7 @@ impl AudioBlock { let exp = self.chdata[ch].cplcoexp[cband] + 3 * self.chdata[ch].mstrcplco + 5 - 3; let start = band * 12 + 37; for bin in 0..12 { - self.chdata[ch].mant[start + bin] = self.chdata[CPL_CHANNEL].mant[start + bin] * cotemp >> exp; + self.chdata[ch].mant[start + bin] = (self.chdata[CPL_CHANNEL].mant[start + bin] * cotemp) >> exp; } //todo dither } @@ -1185,7 +1183,7 @@ impl NADecoder for AudioDecoder { let bsi = BSI::read(&mut br)?; if bsi.has_addb { - let len = br.read(6)? as u32; + let len = br.read(6)?; br.skip((len + 1) * 8)?; } @@ -1216,7 +1214,7 @@ impl NADecoder for AudioDecoder { self.ablk.synth_audio_block(&mut self.imdct512, &mut self.imdct256, &mut self.tmp, ch, &mut self.delay[ch], dst); } else { self.delay[ch] = [0.0; BLOCK_LEN]; - for i in 0..BLOCK_LEN { dst[i] = 0.0; } + for el in dst.iter_mut().take(BLOCK_LEN) { *el = 0.0; } } } if bsi.lfeon { @@ -1226,7 +1224,7 @@ impl NADecoder for AudioDecoder { self.ablk.synth_audio_block(&mut self.imdct512, &mut self.imdct256, &mut self.tmp, LFE_CHANNEL, &mut self.delay[LFE_CHANNEL], dst); } else { self.delay[LFE_CHANNEL] = [0.0; BLOCK_LEN]; - for i in 0..BLOCK_LEN { dst[i] = 0.0; } + for el in dst.iter_mut().take(BLOCK_LEN) { *el = 0.0; } } } } diff --git a/nihav-commonfmt/src/demuxers/avi.rs b/nihav-commonfmt/src/demuxers/avi.rs index 511a22f..c8e7071 100644 --- a/nihav-commonfmt/src/demuxers/avi.rs +++ b/nihav-commonfmt/src/demuxers/avi.rs @@ -92,7 +92,7 @@ impl<'a> DemuxCore<'a> for AVIDemuxer<'a> { } let stream_no = (tag[0] - b'0') * 10 + (tag[1] - b'0'); let str = strmgr.get_stream(stream_no as usize); - if let None = str { return Err(InvalidData); } + if str.is_none() { return Err(InvalidData); } let stream = str.unwrap(); if size == 0 { self.movi_size -= 8; @@ -145,26 +145,24 @@ impl<'a> AVIDemuxer<'a> { return Ok((size, true)); } - for i in 0..CHUNKS.len() { - if RIFFTag::Chunk(tag) == CHUNKS[i].tag { - let psize = (CHUNKS[i].parse)(self, strmgr, size)?; + for chunk in CHUNKS.iter() { + if RIFFTag::Chunk(tag) == chunk.tag { + let psize = (chunk.parse)(self, strmgr, size)?; if psize != size { return Err(InvalidData); } if (psize & 1) == 1 { self.src.read_skip(1)?; } return Ok((size + 8, false)); } - if RIFFTag::List(tag, ltag) == CHUNKS[i].tag { + if RIFFTag::List(tag, ltag) == chunk.tag { let mut rest_size = size - 4; - let psize = (CHUNKS[i].parse)(self, strmgr, rest_size)?; + let psize = (chunk.parse)(self, strmgr, rest_size)?; if psize > rest_size { return Err(InvalidData); } rest_size -= psize; while rest_size > 0 { let (psize, _) = self.parse_chunk(strmgr, end_tag, rest_size, depth+1)?; if psize > rest_size { return Err(InvalidData); } rest_size -= psize; - if (psize & 1) == 1 { - if rest_size > 0 { - rest_size -= 1; - } + if ((psize & 1) == 1) && (rest_size > 0) { + rest_size -= 1; } } @@ -178,7 +176,7 @@ impl<'a> AVIDemuxer<'a> { self.src.read_skip(size - 4)?; } if (size & 1) == 1 { self.src.read_skip(1)?; } - return Ok((size + 8, false)); + Ok((size + 8, false)) } fn read_header(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> { @@ -203,8 +201,7 @@ impl<'a> AVIDemuxer<'a> { fn read_extradata(&mut self, size: usize) -> DemuxerResult>> { if size == 0 { return Ok(None); } - let mut edvec: Vec = Vec::with_capacity(size); - edvec.resize(size, 0); + let mut edvec: Vec = vec![0; size]; self.src.read_buf(&mut edvec)?; Ok(Some(edvec)) } @@ -220,8 +217,8 @@ const CHUNKS: [RIFFParser; 6] = [ ]; fn is_list_tag(tag: u32) -> bool { - for i in 0..CHUNKS.len() { - if let RIFFTag::List(ltag, _) = CHUNKS[i].tag { + for chunk in CHUNKS.iter() { + if let RIFFTag::List(ltag, _) = chunk.tag { if tag == ltag { return true; } @@ -279,7 +276,7 @@ fn parse_strh(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> } fn parse_strf(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult { - if let None = dmx.sstate.strm_type { return Err(InvalidData); } + if dmx.sstate.strm_type.is_none() { return Err(InvalidData); } match dmx.sstate.strm_type.unwrap() { StreamType::Video => parse_strf_vids(dmx, strmgr, size), StreamType::Audio => parse_strf_auds(dmx, strmgr, size), @@ -314,8 +311,8 @@ fn parse_strf_vids(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize Some(name) => name, }; let vinfo = NACodecInfo::new(cname, vci, edata); - let res = strmgr.add_stream(NAStream::new(StreamType::Video, dmx.sstate.strm_no as u32, vinfo, dmx.tb_num, dmx.tb_den)); - if let None = res { return Err(MemoryError); } + let res = strmgr.add_stream(NAStream::new(StreamType::Video, u32::from(dmx.sstate.strm_no), vinfo, dmx.tb_num, dmx.tb_den)); + if res.is_none() { return Err(MemoryError); } dmx.sstate.reset(); Ok(size) } @@ -338,8 +335,8 @@ fn parse_strf_auds(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize Some(name) => name, }; let ainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), edata); - let res = strmgr.add_stream(NAStream::new(StreamType::Audio, dmx.sstate.strm_no as u32, ainfo, dmx.tb_num, dmx.tb_den)); - if let None = res { return Err(MemoryError); } + let res = strmgr.add_stream(NAStream::new(StreamType::Audio, u32::from(dmx.sstate.strm_no), ainfo, dmx.tb_num, dmx.tb_den)); + if res.is_none() { return Err(MemoryError); } dmx.sstate.reset(); Ok(size) } @@ -347,8 +344,8 @@ fn parse_strf_auds(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize fn parse_strf_xxxx(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult { let edata = dmx.read_extradata(size)?; let info = NACodecInfo::new("unknown", NACodecTypeInfo::None, edata); - let res = strmgr.add_stream(NAStream::new(StreamType::Data, dmx.sstate.strm_no as u32, info, dmx.tb_num, dmx.tb_den)); - if let None = res { return Err(MemoryError); } + let res = strmgr.add_stream(NAStream::new(StreamType::Data, u32::from(dmx.sstate.strm_no), info, dmx.tb_num, dmx.tb_den)); + if res.is_none() { return Err(MemoryError); } dmx.sstate.reset(); Ok(size) } diff --git a/nihav-commonfmt/src/demuxers/mod.rs b/nihav-commonfmt/src/demuxers/mod.rs index 84d21f0..9c05c18 100644 --- a/nihav-commonfmt/src/demuxers/mod.rs +++ b/nihav-commonfmt/src/demuxers/mod.rs @@ -7,15 +7,16 @@ macro_rules! validate { } #[cfg(feature="demuxer_avi")] +#[allow(clippy::cast_lossless)] mod avi; -const DEMUXERS: &[&'static DemuxerCreator] = &[ +const DEMUXERS: &[&DemuxerCreator] = &[ #[cfg(feature="demuxer_avi")] &avi::AVIDemuxerCreator {}, ]; pub fn generic_register_all_demuxers(rd: &mut RegisteredDemuxers) { - for demuxer in DEMUXERS.into_iter() { + for demuxer in DEMUXERS.iter() { rd.add_demuxer(*demuxer); } } diff --git a/nihav-commonfmt/src/lib.rs b/nihav-commonfmt/src/lib.rs index 01db994..bcb20ed 100644 --- a/nihav-commonfmt/src/lib.rs +++ b/nihav-commonfmt/src/lib.rs @@ -1,6 +1,9 @@ extern crate nihav_core; #[cfg(feature="decoders")] +#[allow(clippy::unreadable_literal)] +#[allow(clippy::too_many_arguments)] +#[allow(clippy::excessive_precision)] pub mod codecs; #[cfg(feature="demuxers")] -- 2.30.2