]> git.nihav.org Git - nihav.git/commitdiff
commonfmt: fix some clippy warnings
authorKostya Shishkov <kostya.shishkov@gmail.com>
Wed, 15 May 2019 09:17:24 +0000 (11:17 +0200)
committerKostya Shishkov <kostya.shishkov@gmail.com>
Wed, 15 May 2019 09:17:24 +0000 (11:17 +0200)
nihav-commonfmt/src/codecs/aac.rs
nihav-commonfmt/src/codecs/atrac3.rs
nihav-commonfmt/src/codecs/clearvideo.rs
nihav-commonfmt/src/codecs/mod.rs
nihav-commonfmt/src/codecs/pcm.rs
nihav-commonfmt/src/codecs/sipro.rs
nihav-commonfmt/src/codecs/ts102366.rs
nihav-commonfmt/src/demuxers/avi.rs
nihav-commonfmt/src/demuxers/mod.rs
nihav-commonfmt/src/lib.rs

index df5fda36ad82993f6a076ce5f5fd3b8ea39dc074..04fff33ec212058c872718bb992de914449d8c25 100644 (file)
@@ -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<u16>, 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<u16>, 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;
             }
         }
index 0d12cf3868de5effdd3d3f40d12068ed032d4c57..c80bd360ff676ac8c7067025c717914cbced9658 100644 (file)
@@ -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<u8>, 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<u8>, 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];
index 4aee1fed704d0386ef505f26e3cd7c844e6ee2f1..46cbb5435c406752b789fe231111a68a4c186feb 100644 (file)
@@ -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<i8> 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<u16> 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<u8> 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<u16> 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<u8>, xpos: usize, ypos: usize, blk: &[[i32;64]; 6]) {
@@ -275,12 +215,12 @@ fn put_blocks(buf: &mut NAVideoBuffer<u8>, 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<u8>, 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<u8>, 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<u8>, src: &NAVideoBuffer<u8>,
         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 {
index 886b8076c2aa126cf2761a1b043701024032d67a..fa7b2f1cffb795edc181977f159a9158308a4de6 100644 (file)
@@ -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());
     }
 }
index 7967b34fca800376104e3380d53faae62cd81f45..49e9dadcb760d548bde7d229edc63b9c4dd1c929 100644 (file)
@@ -25,10 +25,10 @@ fn get_default_chmap(nch: u8) -> NAChannelMap {
 fn get_duration(ainfo: &NAAudioInfo, duration: Option<u64>, 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()
     }
 }
 
index e617c9eb050a2281fb4dd6371560ea399009619a..fd035c624ecb8b7125e9f2cf1c8bb86a8381c062 100644 (file)
@@ -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)
index f30652c4afb4159241158b2eb25a047bc061f4bb..65b1b9e28eec85640721db607e68421dd1c6a3f1 100644 (file)
@@ -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<Self> {
         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; }
                 }
             }
         }
index 511a22f7284fbc18a5ca6eb7a1750bc06d2989c6..c8e707153a77a4b391659a0354654dbd2b5e7ba7 100644 (file)
@@ -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<Option<Vec<u8>>> {
         if size == 0 { return Ok(None); }
-        let mut edvec: Vec<u8> = Vec::with_capacity(size);
-        edvec.resize(size, 0);
+        let mut edvec: Vec<u8> = 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<usize> {
-    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<usize> {
     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)
 }
index 84d21f049f0839b72ea548f3d0e0204845901901..9c05c1859b051a1a947e44815b426d53d93e6ef7 100644 (file)
@@ -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);
     }
 }
index 01db9940692f198a98739a3aec743101438a886d..bcb20ed71b24160bac4252d2b0557be6d5a503b7 100644 (file)
@@ -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")]