]> git.nihav.org Git - nihav.git/commitdiff
fix clippy warnings
authorKostya Shishkov <kostya.shishkov@gmail.com>
Wed, 26 Jul 2023 17:03:18 +0000 (19:03 +0200)
committerKostya Shishkov <kostya.shishkov@gmail.com>
Wed, 26 Jul 2023 17:03:18 +0000 (19:03 +0200)
114 files changed:
nihav-codec-support/src/codecs/mod.rs
nihav-codec-support/src/test/dec_video.rs
nihav-codec-support/src/test/wavwriter.rs
nihav-commonfmt/src/codecs/clearvideo.rs
nihav-commonfmt/src/codecs/jpeg.rs
nihav-commonfmt/src/codecs/mod.rs
nihav-commonfmt/src/codecs/pcm.rs
nihav-commonfmt/src/demuxers/mov.rs
nihav-commonfmt/src/demuxers/y4m.rs
nihav-commonfmt/src/lib.rs
nihav-core/src/codecs/mod.rs
nihav-core/src/compr/deflate.rs
nihav-core/src/compr/mod.rs
nihav-core/src/demuxers/mod.rs
nihav-core/src/formats.rs
nihav-core/src/frame.rs
nihav-core/src/io/bitreader.rs
nihav-core/src/io/bitwriter.rs
nihav-core/src/io/byteio.rs
nihav-core/src/io/codebook.rs
nihav-core/src/lib.rs
nihav-core/src/muxers/mod.rs
nihav-core/src/reorder.rs
nihav-core/src/scale/mod.rs
nihav-core/src/scale/palette/mediancut.rs
nihav-core/src/scale/palette/mod.rs
nihav-core/src/scale/scale/mod.rs
nihav-duck/src/codecs/on2avc.rs
nihav-duck/src/codecs/truemotion1enc.rs
nihav-duck/src/codecs/vp3.rs
nihav-duck/src/codecs/vp56.rs
nihav-duck/src/codecs/vp6.rs
nihav-duck/src/codecs/vp6enc/coder.rs
nihav-duck/src/codecs/vp6enc/dsp.rs
nihav-duck/src/codecs/vp6enc/mb.rs
nihav-duck/src/codecs/vp7.rs
nihav-duck/src/codecs/vp78.rs
nihav-duck/src/codecs/vp78dsp.rs
nihav-duck/src/codecs/vp7dsp.rs
nihav-duck/src/codecs/vp7enc/blocks.rs
nihav-duck/src/codecs/vp7enc/rdo.rs
nihav-duck/src/codecs/vp8.rs
nihav-duck/src/codecs/vp8dsp.rs
nihav-duck/src/codecs/vpcommon.rs
nihav-duck/src/codecs/vpenc/motion_est.rs
nihav-duck/src/lib.rs
nihav-flash/src/codecs/flashsv.rs
nihav-game/src/codecs/gremlinvideo.rs
nihav-game/src/codecs/lhst500f22.rs
nihav-game/src/codecs/midivid3.rs
nihav-game/src/codecs/q.rs
nihav-game/src/codecs/smush/v1.rs
nihav-game/src/codecs/vmd.rs
nihav-game/src/demuxers/q.rs
nihav-game/src/demuxers/smush.rs
nihav-game/src/lib.rs
nihav-indeo/src/codecs/imc.rs
nihav-indeo/src/codecs/indeo2.rs
nihav-indeo/src/codecs/indeo3enc/cell.rs
nihav-indeo/src/codecs/indeo3enc/mod.rs
nihav-indeo/src/codecs/indeo5.rs
nihav-indeo/src/codecs/ivibr.rs
nihav-indeo/src/demuxers/ivf.rs
nihav-indeo/src/lib.rs
nihav-itu/src/codecs/h264/cabac.rs
nihav-itu/src/codecs/h264/cavlc.rs
nihav-itu/src/codecs/h264/decoder_mt.rs
nihav-itu/src/codecs/h264/decoder_st.rs
nihav-itu/src/codecs/h264/pic_ref.rs
nihav-itu/src/codecs/h264/types.rs
nihav-itu/src/codecs/mod.rs
nihav-llaudio/src/codecs/ape.rs
nihav-llaudio/src/codecs/flac.rs
nihav-llaudio/src/codecs/wavpack.rs
nihav-llaudio/src/demuxers/flac.rs
nihav-llaudio/src/demuxers/flacraw.rs
nihav-llaudio/src/demuxers/wavpack.rs
nihav-mpeg/src/codecs/aac/coeff_read.rs
nihav-mpeg/src/codecs/aac/mod.rs
nihav-mpeg/src/codecs/aac/sbr/bs.rs
nihav-mpeg/src/codecs/aac/sbr/synth.rs
nihav-mpeg/src/codecs/mpegaudio/mod.rs
nihav-mpeg/src/lib.rs
nihav-ms/src/codecs/imaadpcmenc.rs
nihav-ms/src/codecs/mod.rs
nihav-ms/src/codecs/msadpcm.rs
nihav-ms/src/codecs/msvideo1enc.rs
nihav-ms/src/lib.rs
nihav-qt/src/codecs/qdm2qmf.rs
nihav-qt/src/codecs/qdmcommon.rs
nihav-qt/src/codecs/rpza.rs
nihav-qt/src/codecs/smc.rs
nihav-qt/src/codecs/svq3.rs
nihav-qt/src/lib.rs
nihav-rad/src/codecs/binkaud.rs
nihav-rad/src/codecs/binkvid.rs
nihav-rad/src/codecs/smacker.rs
nihav-rad/src/demuxers/smacker.rs
nihav-rad/src/lib.rs
nihav-realmedia/src/codecs/cook.rs
nihav-realmedia/src/codecs/rv20.rs
nihav-realmedia/src/codecs/rv40enc/bitstream.rs
nihav-realmedia/src/codecs/rv40enc/mod.rs
nihav-realmedia/src/codecs/rv40enc/motion_est.rs
nihav-realmedia/src/codecs/rv60.rs
nihav-realmedia/src/codecs/rv60codes.rs
nihav-realmedia/src/demuxers/realmedia.rs
nihav-realmedia/src/lib.rs
nihav-realmedia/src/muxers/rmvb/audiostream.rs
nihav-realmedia/src/muxers/rmvb/mod.rs
nihav-realmedia/src/muxers/rmvb/videostream.rs
nihav-registry/src/register.rs
nihav-vivo/src/codecs/g723_1.rs
nihav-vivo/src/lib.rs

index 2bac7e27fa5b84313ab1c49ad3f19ade869dfd13..63810adca15bdcca5f70e871628ddcf5cebf0c84 100644 (file)
@@ -56,10 +56,7 @@ impl<T: Copy> HAMShuffler<T> {
     /// Returns the original saved reference frame or `None` if it is not present.
     #[allow(dead_code)]
     pub fn get_output_frame(&mut self) -> Option<NAVideoBufferRef<T>> {
-        match self.lastframe {
-            Some(ref frm) => Some(frm.clone()),
-            None => None,
-        }
+        self.lastframe.as_ref().cloned()
     }
 }
 
@@ -102,11 +99,7 @@ impl IPShuffler {
     /// Returns the original saved reference frame or `None` if it is not present.
     #[allow(dead_code)]
     pub fn get_ref(&mut self) -> Option<NAVideoBufferRef<u8>> {
-        if let Some(ref frm) = self.lastframe {
-            Some(frm.clone())
-        } else {
-            None
-        }
+        self.lastframe.as_ref().cloned()
     }
 }
 
@@ -162,38 +155,22 @@ impl IPBShuffler {
     /// Returns the previous reference frame or `None` if it is not present.
     #[allow(dead_code)]
     pub fn get_lastref(&mut self) -> Option<NAVideoBufferRef<u8>> {
-        if let Some(ref frm) = self.lastframe {
-            Some(frm.clone())
-        } else {
-            None
-        }
+        self.lastframe.as_ref().cloned()
     }
     /// Returns second last reference frame or `None` if it is not present.
     #[allow(dead_code)]
     pub fn get_nextref(&mut self) -> Option<NAVideoBufferRef<u8>> {
-        if let Some(ref frm) = self.nextframe {
-            Some(frm.clone())
-        } else {
-            None
-        }
+        self.nextframe.as_ref().cloned()
     }
     /// Returns the temporally following reference for B-frame or `None` if it is not present.
     #[allow(dead_code)]
     pub fn get_b_fwdref(&mut self) -> Option<NAVideoBufferRef<u8>> {
-        if let Some(ref frm) = self.nextframe {
-            Some(frm.clone())
-        } else {
-            None
-        }
+        self.nextframe.as_ref().cloned()
     }
     /// Returns the temporally preceeding reference for B-frame or `None` if it is not present.
     #[allow(dead_code)]
     pub fn get_b_bwdref(&mut self) -> Option<NAVideoBufferRef<u8>> {
-        if let Some(ref frm) = self.lastframe {
-            Some(frm.clone())
-        } else {
-            None
-        }
+        self.lastframe.as_ref().cloned()
     }
 }
 
@@ -219,6 +196,7 @@ pub struct MV {
 
 #[allow(clippy::many_single_char_names)]
 #[allow(clippy::collapsible_if)]
+#[allow(clippy::collapsible_else_if)]
 impl MV {
     /// Creates a new motion vector instance.
     pub fn new(x: i16, y: i16) -> Self { MV{ x, y } }
index 035e89df5dc3ddb73c4ba0d32163775a49b5bf4c..8915a73d4ee7311229ce8b60f3fe4f2be4c442d9 100644 (file)
@@ -486,8 +486,7 @@ println!("stream {} codec {} / {}", i, info.get_name(), dec_name);
 
         }
     }
-    'tail_loop: for dentry in decs.iter_mut() {
-        if let Some((_, ref mut dec)) = dentry {
+    'tail_loop: for (_, ref mut dec) in decs.iter_mut().flatten() {
             loop {
                 match dec.get_frame() {
                     (Ok(frm), id) => {
@@ -507,7 +506,6 @@ println!("stream {} codec {} / {}", i, info.get_name(), dec_name);
                     break;
                 }
             }
-        }
     }
     if let ExpectedTestResult::MD5(ref ref_hash) = test {
         md5.finish();
index 061abfa9dbd2e0d557af3d7407bc972367e05dff..3d4110828c84702590a72183d9450b2a09cf2c02 100644 (file)
@@ -124,7 +124,7 @@ impl<'a> Drop for WavWriter<'a> {
             let res = self.io.seek(SeekFrom::Start(4));
             let res = self.io.write_u32le((size - 8) as u32);
             let res = self.io.seek(SeekFrom::Start(self.data_pos - 4));
-            let res = self.io.write_u32le(((size as u64) - self.data_pos) as u32);
+            let res = self.io.write_u32le((size - self.data_pos) as u32);
         }
     }
 }
index 52bfe2bab7efc4cb0ca652616765a3cae13b43c4..50794aba7ab783b4cd2711bd219b0d671e92ec1a 100644 (file)
@@ -572,7 +572,7 @@ fn decode_dct_block(br: &mut BitReader, blk: &mut [i32; 64], ac_quant: i32, has_
             } else {
                 eob = br.read_bool()?;
                 let run = br.read(6)? as usize;
-                let lev = br.read_s(8)? as i32;
+                let lev = br.read_s(8)?;
                 (lev, run)
             };
         idx += skip;
index 957104c8967b1ef413a1abc5e20e981979481e4e..08f30a784be3d2a7460c5c42903b250ce46f6a27 100644 (file)
@@ -637,9 +637,7 @@ impl NADecoder for JPEGDecoder {
                                 std::mem::swap(&mut self.buf, &mut data);
                                 let ret = self.decode_scan(&data, buf, &ci[..ns], ss, se);
                                 std::mem::swap(&mut self.buf, &mut data);
-                                if let Err(err) = ret {
-                                    return Err(err);
-                                }
+                                ret?;
                             } else { unreachable!(); }
                         },
                         JPEGType::Progressive => {
index 4c6569ecef66845c484ee6b0669ce6e8b613d22a..ad8a8c6604b40cd9ab3fa2e9305a25b3703b004e 100644 (file)
@@ -30,6 +30,7 @@ mod atrac3;
 mod pcm;
 #[cfg(feature="decoder_sipro")]
 #[allow(clippy::collapsible_if)]
+#[allow(clippy::collapsible_else_if)]
 #[allow(clippy::identity_op)]
 #[allow(clippy::manual_memcpy)]
 mod sipro;
index b2dd8174879e75bc9f518fb5cca2e1255d5f8291..c0ef5d3bc1a2ab284aaa694a5557718c53831f7c 100644 (file)
@@ -79,12 +79,12 @@ fn get_default_chmap(nch: u8) -> NAChannelMap {
 
 #[cfg(feature="decoder_pcm")]
 fn get_duration(ainfo: &NAAudioInfo, duration: Option<u64>, data_size: usize) -> u64 {
-    if duration == None {
+    if let Some(dur) = duration {
+        dur
+    } else {
         let size_bits = (data_size as u64) * 8;
         let blk_size = u64::from(ainfo.get_channels()) * u64::from(ainfo.get_format().get_bits());
         size_bits / blk_size
-    } else {
-        duration.unwrap()
     }
 }
 
index 54a6c522d2f1a9c86cd90a9e70894248e9c6562a..87eb2f17a9ff366b9082a683480f08aecf8c3bcf 100644 (file)
@@ -573,6 +573,7 @@ fn parse_audio_edata(br: &mut ByteReader, start_pos: u64, size: u64) -> DemuxerR
     }
 }
 
+#[allow(clippy::neg_cmp_op_on_partial_ord)]
 fn read_stsd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
     const KNOWN_STSD_SIZE: u64 = 24;
     validate!(size >= KNOWN_STSD_SIZE);
@@ -625,12 +626,12 @@ fn read_stsd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult
                 match depth & 0x1F {
                     2 => {
                         let mut pal = [0; 1024];
-                        (&mut pal[..4 * 4]).copy_from_slice(&MOV_DEFAULT_PAL_2BIT);
+                        pal[..4 * 4].copy_from_slice(&MOV_DEFAULT_PAL_2BIT);
                         track.pal = Some(Arc::new(pal));
                     },
                     4 => {
                         let mut pal = [0; 1024];
-                        (&mut pal[..16 * 4]).copy_from_slice(&MOV_DEFAULT_PAL_4BIT);
+                        pal[..16 * 4].copy_from_slice(&MOV_DEFAULT_PAL_4BIT);
                         track.pal = Some(Arc::new(pal));
                     },
                     8 => {
@@ -1276,7 +1277,7 @@ impl Track {
         for kf_time in self.keyframes.iter() {
             let pts = tsearch.map_time(*kf_time - 1, &self.time_to_sample);
             let time = NATimeInfo::ts_to_time(pts, 1000, self.tb_num, self.tb_den);
-            seek_index.add_entry(self.track_no as u32, SeekEntry { time, pts: u64::from(*kf_time - 1), pos: 0 });
+            seek_index.add_entry(self.track_no, SeekEntry { time, pts: u64::from(*kf_time - 1), pos: 0 });
         }
     }
     fn calculate_chunk_size(&self, nsamp: usize) -> usize {
@@ -1409,6 +1410,7 @@ impl Track {
         }
     }
     #[allow(clippy::collapsible_if)]
+    #[allow(clippy::collapsible_else_if)]
     fn seek(&mut self, pts: u64, tpoint: NATimePoint) -> DemuxerResult<u64> {
         self.cur_sample = pts as usize;
         self.samples_left = 0;
index 89bf933025c49996d1fe7236ca594b8f00d03a8e..3571ea97aeb4944d47c4f5b58b1cb657906082d9 100644 (file)
@@ -151,10 +151,8 @@ impl<'a> Y4MDemuxer<'a> {
         }
         validate!(self.width > 0 && self.height > 0);
         self.frame_size = 0;
-        for chromaton in format.comp_info.iter() {
-            if let Some(ref chr) = chromaton {
-                self.frame_size += chr.get_data_size(self.width, self.height);
-            }
+        for chr in format.comp_info.iter().flatten() {
+            self.frame_size += chr.get_data_size(self.width, self.height);
         }
         validate!(self.frame_size > 0);
 
index 528b8b724a46e8d528b23fa2dc657636f6a264bd..cdd2cd9ffd3df810a5c5ba29ef57c561f929b680 100644 (file)
@@ -9,6 +9,9 @@ extern crate nihav_registry;
 #[allow(clippy::unreadable_literal)]
 #[allow(clippy::too_many_arguments)]
 #[allow(clippy::excessive_precision)]
+#[allow(clippy::upper_case_acronyms)]
+#[allow(clippy::manual_range_contains)]
+#[allow(clippy::collapsible_else_if)]
 mod codecs;
 
 #[cfg(feature="decoders")]
index 04d480a81db0d02766ebed9014ff503bb67f6c85..37857d98d1f3cc7d4779bc628171b2c8ec68747a 100644 (file)
@@ -203,9 +203,10 @@ impl RegisteredMTDecoders {
 }
 
 /// Frame skipping mode for decoders.
-#[derive(Clone,Copy,PartialEq,Debug)]
+#[derive(Clone,Copy,PartialEq,Debug,Default)]
 pub enum FrameSkipMode {
     /// Decode all frames.
+    #[default]
     None,
     /// Decode all key frames.
     KeyframesOnly,
@@ -213,12 +214,6 @@ pub enum FrameSkipMode {
     IntraOnly,
 }
 
-impl Default for FrameSkipMode {
-    fn default() -> Self {
-        FrameSkipMode::None
-    }
-}
-
 impl FromStr for FrameSkipMode {
     type Err = DecoderError;
 
index 09e9d8ffb560f2c8dbe504889b5a17f405e10558..9277731d2301b02fc212137b637f4c53aa095441 100644 (file)
@@ -210,7 +210,7 @@ impl<'a, S: Copy> CodebookReader<S> for CurrentSource<'a> {
         let mut lut_bits = cb.lut_bits;
         let orig_br = self.br;
         while esc {
-            let lut_idx = (self.peek(lut_bits) as usize) + (idx as usize);
+            let lut_idx = (self.peek(lut_bits) as usize) + idx;
             if cb.table[lut_idx] == TABLE_FILL_VALUE { return Err(CodebookError::InvalidCode); }
             let bits = cb.table[lut_idx] & 0x7F;
             esc  = (cb.table[lut_idx] & 0x80) != 0;
@@ -221,7 +221,7 @@ impl<'a, S: Copy> CodebookReader<S> for CurrentSource<'a> {
                 self.refill();
                 return Err(CodebookError::MemoryError);
             }
-            self.skip(skip_bits as u32).unwrap();
+            self.skip(skip_bits).unwrap();
             lut_bits = bits as u8;
         }
         Ok(cb.syms[idx])
@@ -1918,22 +1918,19 @@ impl LZParse for OptimalParser {
 }
 
 ///! Deflate compression mode.
-#[derive(Clone,Copy,Debug,PartialEq)]
+#[derive(Clone,Copy,Debug,PartialEq,Default)]
 pub enum DeflateMode {
     ///! No compression.
     NoCompr,
     ///! Fast compression.
     Fast,
     ///! Still fast but better compression.
+    #[default]
     Better,
     ///! Slow but the best compression.
     Best,
 }
 
-impl Default for DeflateMode {
-    fn default() -> Self { DeflateMode::Better }
-}
-
 pub const DEFLATE_MODE_DESCRIPTION: &str = "Deflate compression level.";
 ///! Deflate option for no compression.
 pub const DEFLATE_MODE_NONE: &str = "none";
index c8069b5cc194325e75050f591d8e8671fa52f6cc..106b03adc24a6f92235424b229607de8c69cebbd 100644 (file)
@@ -1,5 +1,6 @@
 //! Various compression formats support.
 #[cfg(feature="deflate")]
+#[allow(clippy::manual_range_contains)]
 pub mod deflate;
 
 use crate::io::byteio::ByteIOError;
@@ -64,7 +65,7 @@ pub fn lz_copy(buf: &mut [u8], dst_pos: usize, offset: usize, len: usize) {
     let buf = &mut buf[ipos..];
     if ipos + len <= dst_pos {
         let (src, dst) = buf.split_at_mut(offset);
-        (&mut dst[..len]).copy_from_slice(&src[..len]);
+        dst[..len].copy_from_slice(&src[..len]);
     } else {
         for i in 0..len {
             buf[offset + i] = buf[i];
index 300b6af8f5dbca2b661e4e51dbccb115ddb01de3..08bf8f7353a9eaff9a5a98ae93eade6193f7ffdf 100644 (file)
@@ -181,9 +181,10 @@ impl<'a> Iterator for StreamIter<'a> {
 }
 
 /// Seeking modes.
-#[derive(Clone,Copy,PartialEq)]
+#[derive(Clone,Copy,PartialEq,Default)]
 pub enum SeekIndexMode {
     /// No seeking index present.
+    #[default]
     None,
     /// Seeking index is present.
     Present,
@@ -191,10 +192,6 @@ pub enum SeekIndexMode {
     Automatic,
 }
 
-impl Default for SeekIndexMode {
-    fn default() -> Self { SeekIndexMode::None }
-}
-
 /// A structure holding seeking information.
 #[derive(Clone,Copy,Default)]
 pub struct SeekEntry {
@@ -309,12 +306,7 @@ impl SeekIndex {
     }
     /// Returns stream reference for provided stream ID.
     pub fn get_stream_index(&mut self, id: u32) -> Option<&mut StreamSeekInfo> {
-        for stream in self.seek_info.iter_mut() {
-            if stream.id == id {
-                return Some(stream);
-            }
-        }
-        None
+        self.seek_info.iter_mut().find(|stream| stream.id == id)
     }
     /// Adds seeking information to the index.
     pub fn add_entry(&mut self, id: u32, entry: SeekEntry) {
@@ -498,12 +490,7 @@ impl RegisteredDemuxers {
     }
     /// Searches for a demuxer that supports requested container format.
     pub fn find_demuxer(&self, name: &str) -> Option<&dyn DemuxerCreator> {
-        for &dmx in self.dmxs.iter() {
-            if dmx.get_name() == name {
-                return Some(dmx);
-            }
-        }
-        None
+        self.dmxs.iter().find(|&&dmx| dmx.get_name() == name).copied()
     }
     /// Provides an iterator over currently registered demuxers.
     pub fn iter(&self) -> std::slice::Iter<&dyn DemuxerCreator> {
@@ -674,12 +661,7 @@ impl RegisteredRawDemuxers {
     }
     /// Searches for a demuxer that supports requested container format.
     pub fn find_demuxer(&self, name: &str) -> Option<&dyn RawDemuxerCreator> {
-        for &dmx in self.dmxs.iter() {
-            if dmx.get_name() == name {
-                return Some(dmx);
-            }
-        }
-        None
+        self.dmxs.iter().find(|&&dmx| dmx.get_name() == name).copied()
     }
     /// Provides an iterator over currently registered demuxers.
     pub fn iter(&self) -> std::slice::Iter<&dyn RawDemuxerCreator> {
index 810fff25ddc1a0de03896ac659df1fbf6737e6a9..fdb7a1b7640a303d17a7552970ec3ad2fc2d151f 100644 (file)
@@ -315,7 +315,7 @@ impl fmt::Display for NAChannelMap {
         let mut map = String::new();
         for el in self.ids.iter() {
             if !map.is_empty() { map.push(','); }
-            map.push_str(&*el.to_string());
+            map.push_str(&el.to_string());
         }
         write!(f, "{}", map)
     }
@@ -660,41 +660,33 @@ impl NAPixelFormaton {
     /// Reports whether the format is not packed.
     pub fn is_unpacked(&self) -> bool {
         if self.palette { return false; }
-        for chr in self.comp_info.iter() {
-            if let Some(ref chromaton) = chr {
-                if chromaton.is_packed() { return false; }
-            }
+        for chromaton in self.comp_info.iter().flatten() {
+            if chromaton.is_packed() { return false; }
         }
         true
     }
     /// Returns the maximum component bit depth.
     pub fn get_max_depth(&self) -> u8 {
         let mut mdepth = 0;
-        for chr in self.comp_info.iter() {
-            if let Some(ref chromaton) = chr {
-                mdepth = mdepth.max(chromaton.depth);
-            }
+        for chromaton in self.comp_info.iter().flatten() {
+            mdepth = mdepth.max(chromaton.depth);
         }
         mdepth
     }
     /// Returns the total amount of bits needed for components.
     pub fn get_total_depth(&self) -> u8 {
         let mut depth = 0;
-        for chr in self.comp_info.iter() {
-            if let Some(ref chromaton) = chr {
-                depth += chromaton.depth;
-            }
+        for chromaton in self.comp_info.iter().flatten() {
+            depth += chromaton.depth;
         }
         depth
     }
     /// Returns the maximum component subsampling.
     pub fn get_max_subsampling(&self) -> u8 {
         let mut ssamp = 0;
-        for chr in self.comp_info.iter() {
-            if let Some(ref chromaton) = chr {
-                let (ss_v, ss_h) = chromaton.get_subsampling();
-                ssamp = ssamp.max(ss_v).max(ss_h);
-            }
+        for chromaton in self.comp_info.iter().flatten() {
+            let (ss_v, ss_h) = chromaton.get_subsampling();
+            ssamp = ssamp.max(ss_v).max(ss_h);
         }
         ssamp
     }
@@ -716,12 +708,10 @@ impl NAPixelFormaton {
                 let mut start_off = 0;
                 let mut start_shift = 0;
                 let mut use_shift = true;
-                for comp in self.comp_info.iter() {
-                    if let Some(comp) = comp {
-                        start_off = start_off.min(comp.comp_offs);
-                        start_shift = start_shift.min(comp.shift);
-                        if comp.comp_offs != 0 { use_shift = false; }
-                    }
+                for comp in self.comp_info.iter().flatten() {
+                    start_off = start_off.min(comp.comp_offs);
+                    start_shift = start_shift.min(comp.shift);
+                    if comp.comp_offs != 0 { use_shift = false; }
                 }
                 for component in 0..(self.components as usize) {
                     for (comp, cname) in self.comp_info.iter().zip(b"rgba".iter()) {
@@ -1017,7 +1007,7 @@ fn parse_yuv_format(s: &str) -> Result<NAPixelFormaton, FormatParseError> {
     let mut parse_end = components as usize;
     for ch in s.chars().skip(components as usize) {
         parse_end += 1;
-        if ('0'..='9').contains(&ch) {
+        if ch.is_ascii_digit() {
             format = format * 10 + u32::from((ch as u8) - b'0');
             if format > 444 { return Err(FormatParseError {}); }
         } else {
@@ -1029,7 +1019,7 @@ fn parse_yuv_format(s: &str) -> Result<NAPixelFormaton, FormatParseError> {
     let depth = if s.len() == parse_end { 8 } else {
             let mut val = 0;
             for ch in s.chars().skip(parse_end) {
-                if ('0'..='9').contains(&ch) {
+                if ch.is_ascii_digit() {
                     val = val * 10 + ((ch as u8) - b'0');
                     if val > 16 { return Err(FormatParseError {}); }
                 } else {
index 10db18de0d15ccf7be8a9d4dc50123e4a7f5c4fc..1bf5dec96cfcaec1ad2c5814e82321f308acef18 100644 (file)
@@ -65,9 +65,9 @@ impl NAVideoInfo {
         NAVideoInfo { width: w, height: h, flipped: flip, format: fmt, bits }
     }
     /// Returns picture width.
-    pub fn get_width(&self)  -> usize { self.width as usize }
+    pub fn get_width(&self)  -> usize { self.width }
     /// Returns picture height.
-    pub fn get_height(&self) -> usize { self.height as usize }
+    pub fn get_height(&self) -> usize { self.height }
     /// Returns picture orientation.
     pub fn is_flipped(&self) -> bool { self.flipped }
     /// Returns picture pixel format.
@@ -535,12 +535,12 @@ pub fn alloc_video_buffer(vinfo: NAVideoInfo, align: u8) -> Result<NABufferType,
     let mut strides: Vec<usize> = Vec::new();
 
     for i in 0..fmt.get_num_comp() {
-        if fmt.get_chromaton(i) == None { return Err(AllocatorError::FormatError); }
+        if fmt.get_chromaton(i).is_none() { return Err(AllocatorError::FormatError); }
     }
 
     let align_mod = ((1 << align) as usize) - 1;
-    let width  = ((vinfo.width  as usize) + align_mod) & !align_mod;
-    let height = ((vinfo.height as usize) + align_mod) & !align_mod;
+    let width  = (vinfo.width  + align_mod) & !align_mod;
+    let height = (vinfo.height + align_mod) & !align_mod;
     let mut max_depth = 0;
     let mut all_packed = true;
     let mut all_bytealigned = true;
@@ -562,10 +562,10 @@ pub fn alloc_video_buffer(vinfo: NAVideoInfo, align: u8) -> Result<NABufferType,
 //todo various-sized palettes?
         let stride = vinfo.get_format().get_chromaton(0).unwrap().get_linesize(width);
         let pic_sz = stride.checked_mul(height);
-        if pic_sz == None { return Err(AllocatorError::TooLargeDimensions); }
+        if pic_sz.is_none() { return Err(AllocatorError::TooLargeDimensions); }
         let pal_size = 256 * (fmt.get_elem_size() as usize);
         let new_size = pic_sz.unwrap().checked_add(pal_size);
-        if new_size == None { return Err(AllocatorError::TooLargeDimensions); }
+        if new_size.is_none() { return Err(AllocatorError::TooLargeDimensions); }
         offs.push(0);
         offs.push(stride * height);
         strides.push(stride);
@@ -577,13 +577,13 @@ pub fn alloc_video_buffer(vinfo: NAVideoInfo, align: u8) -> Result<NABufferType,
             let ochr = fmt.get_chromaton(i);
             if ochr.is_none() { continue; }
             let chr = ochr.unwrap();
-            offs.push(new_size as usize);
+            offs.push(new_size);
             let stride = chr.get_linesize(width);
             let cur_h = chr.get_height(height);
             let cur_sz = stride.checked_mul(cur_h);
-            if cur_sz == None { return Err(AllocatorError::TooLargeDimensions); }
+            if cur_sz.is_none() { return Err(AllocatorError::TooLargeDimensions); }
             let new_sz = new_size.checked_add(cur_sz.unwrap());
-            if new_sz == None { return Err(AllocatorError::TooLargeDimensions); }
+            if new_sz.is_none() { return Err(AllocatorError::TooLargeDimensions); }
             new_size = new_sz.unwrap();
             strides.push(stride);
         }
@@ -603,9 +603,9 @@ pub fn alloc_video_buffer(vinfo: NAVideoInfo, align: u8) -> Result<NABufferType,
     } else if all_bytealigned || unfit_elem_size {
         let elem_sz = fmt.get_elem_size();
         let line_sz = width.checked_mul(elem_sz as usize);
-        if line_sz == None { return Err(AllocatorError::TooLargeDimensions); }
+        if line_sz.is_none() { return Err(AllocatorError::TooLargeDimensions); }
         let new_sz = line_sz.unwrap().checked_mul(height);
-        if new_sz == None { return Err(AllocatorError::TooLargeDimensions); }
+        if new_sz.is_none() { return Err(AllocatorError::TooLargeDimensions); }
         new_size = new_sz.unwrap();
         let data: Vec<u8> = vec![0; new_size];
         strides.push(line_sz.unwrap());
@@ -614,7 +614,7 @@ pub fn alloc_video_buffer(vinfo: NAVideoInfo, align: u8) -> Result<NABufferType,
     } else {
         let elem_sz = fmt.get_elem_size();
         let new_sz = width.checked_mul(height);
-        if new_sz == None { return Err(AllocatorError::TooLargeDimensions); }
+        if new_sz.is_none() { return Err(AllocatorError::TooLargeDimensions); }
         new_size = new_sz.unwrap();
         match elem_sz {
             2 => {
@@ -636,11 +636,12 @@ pub fn alloc_video_buffer(vinfo: NAVideoInfo, align: u8) -> Result<NABufferType,
 
 /// Constructs a new audio buffer for the requested format and length.
 #[allow(clippy::collapsible_if)]
+#[allow(clippy::collapsible_else_if)]
 pub fn alloc_audio_buffer(ainfo: NAAudioInfo, nsamples: usize, chmap: NAChannelMap) -> Result<NABufferType, AllocatorError> {
     let mut offs: Vec<usize> = Vec::new();
     if ainfo.format.is_planar() || ((ainfo.format.get_bits() % 8) == 0) {
         let len = nsamples.checked_mul(ainfo.channels as usize);
-        if len == None { return Err(AllocatorError::TooLargeDimensions); }
+        if len.is_none() { return Err(AllocatorError::TooLargeDimensions); }
         let length = len.unwrap();
         let stride;
         let step;
@@ -684,7 +685,7 @@ pub fn alloc_audio_buffer(ainfo: NAAudioInfo, nsamples: usize, chmap: NAChannelM
         }
     } else {
         let len = nsamples.checked_mul(ainfo.channels as usize);
-        if len == None { return Err(AllocatorError::TooLargeDimensions); }
+        if len.is_none() { return Err(AllocatorError::TooLargeDimensions); }
         let length = ainfo.format.get_audio_size(len.unwrap() as u64);
         let data: Vec<u8> = vec![0; length];
         let buf: NAAudioBuffer<u8> = NAAudioBuffer { data: NABufferRef::new(data), info: ainfo, offs, chmap, len: nsamples, stride: 0, step: 0 };
@@ -957,6 +958,7 @@ impl NATimeInfo {
 
     /// Converts time in given scale into timestamp in given base.
     #[allow(clippy::collapsible_if)]
+    #[allow(clippy::collapsible_else_if)]
     pub fn time_to_ts(time: u64, base: u64, tb_num: u32, tb_den: u32) -> u64 {
         let tb_num = u64::from(tb_num);
         let tb_den = u64::from(tb_den);
@@ -1032,22 +1034,17 @@ impl NATimeInfo {
 }
 
 /// Time information for specifying durations or seek positions.
-#[derive(Clone,Copy,Debug,PartialEq)]
+#[derive(Clone,Copy,Debug,PartialEq,Default)]
 pub enum NATimePoint {
     /// Time in milliseconds.
     Milliseconds(u64),
     /// Stream timestamp.
     PTS(u64),
     /// No time information present.
+    #[default]
     None,
 }
 
-impl Default for NATimePoint {
-    fn default() -> Self {
-        NATimePoint::None
-    }
-}
-
 impl fmt::Display for NATimePoint {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
@@ -1149,7 +1146,7 @@ impl FromStr for NATimePoint {
                             let mut mval = 0;
                             let mut base = 0;
                             for ch in val.chars() {
-                                if ('0'..='9').contains(&ch) {
+                                if ch.is_ascii_digit() {
                                     mval = mval * 10 + u64::from((ch as u8) - b'0');
                                     base += 1;
                                     if base > 3 { break; }
index c4f9f6c8a3490edeccb1ed4385e495f15ee940a7..b5f8de61cb8db863c0f2b09c00327b93e40507b6 100644 (file)
@@ -227,7 +227,7 @@ impl<'a> BitReader<'a> {
         if nbits == 0 { return Ok(0) }
         if nbits > 32 { return Err(TooManyBitsRequested) }
         if self.bits < nbits {
-            if let Err(err) = self.refill() { return Err(err) }
+            self.refill()?;
             if self.bits < nbits { return Err(BitstreamEnd) }
         }
         let res = self.read_cache(nbits);
@@ -243,7 +243,7 @@ impl<'a> BitReader<'a> {
     pub fn read_s(&mut self, nbits: u8) -> BitReaderResult<i32> {
         if nbits == 0 || nbits > 32 { return Err(TooManyBitsRequested) }
         if self.bits < nbits {
-            if let Err(err) = self.refill() { return Err(err) }
+            self.refill()?;
             if self.bits < nbits { return Err(BitstreamEnd) }
         }
         let res = self.read_cache_s(nbits);
@@ -255,7 +255,7 @@ impl<'a> BitReader<'a> {
     #[inline(always)]
     pub fn read_bool(&mut self) -> BitReaderResult<bool> {
         if self.bits < 1 {
-            if let Err(err) = self.refill() { return Err(err) }
+            self.refill()?;
             if self.bits < 1 { return Err(BitstreamEnd) }
         }
         let res = self.read_cache(1);
index 444756744ed143a72d07e8f4f1117aa81a98ed58..4f3c39c25d5e618dbc41c54a3a25f703044507e7 100644 (file)
@@ -77,6 +77,7 @@ impl BitWriter {
     }
     /// Writes `bits` bits of `val` value to the output.
     #[allow(clippy::collapsible_if)]
+    #[allow(clippy::collapsible_else_if)]
     pub fn write(&mut self, val: u32, bits: u8) {
         if bits == 0 {
             return;
index 0ff54cb13ed9321e31f794dbea03e8365d53dc39..61b8816f2dd78ae2d7bc0db5f1f2bcad3fa244e8 100644 (file)
@@ -624,7 +624,7 @@ impl<T: Read+Seek> ByteIO for FileReader<T> {
     }
 
     fn tell(&mut self) -> u64 {
-        self.file.seek(SeekFrom::Current(0)).unwrap()
+        self.file.stream_position().unwrap()
     }
 
     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
@@ -681,7 +681,7 @@ impl<T: Read+Seek> BoundedFileReader<T> {
     /// Destroys the reader and releases the reader resource for a further use.
     pub fn finish(self) -> Box<T> { self.file }
     fn real_tell(&mut self) -> u64 {
-        self.file.seek(SeekFrom::Current(0)).unwrap()
+        self.file.stream_position().unwrap()
     }
     fn max_read_len(&mut self, len: usize) -> usize {
         if let Some(epos) = self.end {
@@ -779,7 +779,7 @@ impl<T: Read+Seek> ByteIO for BoundedFileReader<T> {
     }
 
     fn tell(&mut self) -> u64 {
-        self.file.seek(SeekFrom::Current(0)).unwrap() - self.start
+        self.file.stream_position().unwrap() - self.start
     }
 
     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
@@ -1188,7 +1188,7 @@ impl<T: Write+Seek> ByteIO for FileWriter<T> {
     }
 
     fn tell(&mut self) -> u64 {
-        self.file.seek(SeekFrom::Current(0)).unwrap()
+        self.file.stream_position().unwrap()
     }
 
     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
index 6ea3b1ee5ea4ff65df5700d02368a2d021d0f786..f533cb263abe8abf76dfe67143f4100b979470b4 100644 (file)
@@ -271,7 +271,7 @@ fn build_esc_lut(table: &mut Vec<u32>,
 
     let cur_offset = bucket.offset;
     for (ckey, sec_bucket) in &mut escape_list {
-        let key = *ckey as u32;
+        let key = *ckey;
         let maxlen = min(sec_bucket.maxlen, MAX_LUT_BITS);
         let new_off = resize_table(table, maxlen)?;
         fill_lut(table, mode, cur_offset, key, maxlen,
@@ -366,7 +366,7 @@ impl<'a, S: Copy> CodebookReader<S> for BitReader<'a> {
         let mut idx = 0;
         let mut lut_bits = cb.lut_bits;
         while esc {
-            let lut_idx = (self.peek(lut_bits) as usize) + (idx as usize);
+            let lut_idx = (self.peek(lut_bits) as usize) + idx;
             if cb.table[lut_idx] == TABLE_FILL_VALUE { return Err(CodebookError::InvalidCode); }
             let bits = cb.table[lut_idx] & 0x7F;
             esc  = (cb.table[lut_idx] & 0x80) != 0;
@@ -375,7 +375,7 @@ impl<'a, S: Copy> CodebookReader<S> for BitReader<'a> {
             if (skip_bits as isize) > self.left() {
                 return Err(CodebookError::InvalidCode);
             }
-            self.skip(skip_bits as u32).unwrap();
+            self.skip(skip_bits).unwrap();
             lut_bits = bits as u8;
         }
         Ok(cb.syms[idx])
index d9eab81e107c95fda31eb27e8cdd7339b607a7bc..b6e1690370e82c975f0e049ffec4f7ed088050e7 100644 (file)
@@ -1,5 +1,6 @@
 //! Core functionality of NihAV intended to be used by both crates implementing format support and users.
 #[cfg(feature="decoders")]
+#[allow(clippy::upper_case_acronyms)]
 #[allow(clippy::cast_lossless)]
 #[allow(clippy::identity_op)]
 #[allow(clippy::too_many_arguments)]
@@ -26,6 +27,7 @@ pub mod io;
 pub mod options;
 pub mod refs;
 pub mod reorder;
+#[allow(clippy::upper_case_acronyms)]
 #[allow(clippy::collapsible_if)]
 #[allow(clippy::many_single_char_names)]
 #[allow(clippy::needless_range_loop)]
index e8334e52a83a459ab08f4bbeff0b1d57caae77a8..eb71df5ec36b2f7e57ee10f013ed5470bc2b112c 100644 (file)
@@ -157,12 +157,7 @@ impl RegisteredMuxers {
     }
     /// Searches for a muxer that supports requested container format.
     pub fn find_muxer(&self, name: &str) -> Option<&dyn MuxerCreator> {
-        for &mux in self.muxes.iter() {
-            if mux.get_name() == name {
-                return Some(mux);
-            }
-        }
-        None
+        self.muxes.iter().find(|&&mux| mux.get_name() == name).copied()
     }
     /// Provides an iterator over currently registered muxers.
     pub fn iter(&self) -> std::slice::Iter<&dyn MuxerCreator> {
index 8f02afd05d06d01be9a5533e818a9900248a538a..9337b9a7f232c78962aae93066e4439ecab92f41 100644 (file)
@@ -226,6 +226,7 @@ impl MTFrameReorderer {
     }
     /// Gets the next frame to be displayed (or `None` if that is not possible).
     #[allow(clippy::collapsible_if)]
+    #[allow(clippy::collapsible_else_if)]
     pub fn get_frame(&mut self) -> Option<NAFrameRef> {
         // check if we have consequent timestamps that we can output
         if !self.frames.is_empty() {
@@ -255,7 +256,7 @@ impl MTFrameReorderer {
                         }
                         let end = self.ids.iter().position(|&id| id == kf_id).unwrap();
                         for ref_id in self.ids[..end].iter() {
-                            if self.frames.iter().position(|(id, _)| id == ref_id).is_none() {
+                            if !self.frames.iter().any(|(id, _)| id == ref_id) {
                                 return None;
                             }
                         }
index a79232d3e96136d34bfcd2d62f9d6bb7c215cb94..4fbf3e696c42f4140be848999824d7daf4e42037 100644 (file)
@@ -187,7 +187,7 @@ fn copy(pic_in: &NABufferType, pic_out: &mut NABufferType)
                 let dst = &mut ddata[doff..];
                 let copy_size = sstride.min(dstride);
                 for (dline, sline) in dst.chunks_exact_mut(dstride).take(h).zip(src.chunks_exact(sstride)) {
-                    (&mut dline[..copy_size]).copy_from_slice(&sline[..copy_size]);
+                    dline[..copy_size].copy_from_slice(&sline[..copy_size]);
                 }
             }
         }
@@ -220,7 +220,7 @@ fn copy(pic_in: &NABufferType, pic_out: &mut NABufferType)
                 let dst = &mut ddata[doff..];
                 let copy_size = sstride.min(dstride);
                 for (dline, sline) in dst.chunks_exact_mut(dstride).take(h).zip(src.chunks_exact(sstride)) {
-                    (&mut dline[..copy_size]).copy_from_slice(&sline[..copy_size]);
+                    dline[..copy_size].copy_from_slice(&sline[..copy_size]);
                 }
             }
         }
@@ -363,8 +363,8 @@ fn swap_plane<T:Copy>(data: &mut [T], stride: usize, h: usize, line0: &mut [T],
     for _ in 0..h/2 {
         line0.copy_from_slice(&data[doff0..][..stride]);
         line1.copy_from_slice(&data[doff1..][..stride]);
-        (&mut data[doff1..][..stride]).copy_from_slice(line0);
-        (&mut data[doff0..][..stride]).copy_from_slice(line1);
+        data[doff1..][..stride].copy_from_slice(line0);
+        data[doff0..][..stride].copy_from_slice(line1);
         doff0 += stride;
         doff1 -= stride;
     }
index 64281ef23bfa7bef86bca19c3e52aaa89471481f..b8fb7d65296f6d27a02cd222270df187d8d5cbc0 100644 (file)
@@ -47,7 +47,7 @@ impl<'a> VQBox<'a> {
                 pivot = start + end;
                 cand1 = start;
             }
-            (&mut arr[start..][..end]).copy_from_slice(bucket.as_slice());
+            arr[start..][..end].copy_from_slice(bucket.as_slice());
             start += end;
         }
         for bucket in buckets.iter() {
index f70300fb8666f810ff68e23a911d51cc15345270..12c2947483b76bbaded90befab6f623aa36c46dd 100644 (file)
@@ -45,12 +45,13 @@ mod palettise;
 //use mediancut::quantise_median_cut;
 //use neuquant::NeuQuantQuantiser;
 
-#[derive(Clone,Copy,Debug,PartialEq)]
+#[derive(Clone,Copy,Debug,PartialEq,Default)]
 /// Palette quantisation algorithms.
 pub enum QuantisationMode {
     /// Median cut approach proposed by Paul Heckbert.
     ///
     /// This is moderately fast and moderately good.
+    #[default]
     MedianCut,
     /// Enhanced LBG algorithm proposed by Giuseppe Patane and Marco Russo.
     ///
@@ -63,25 +64,18 @@ pub enum QuantisationMode {
     NeuQuant(u8),
 }
 
-impl Default for QuantisationMode {
-    fn default() -> Self { QuantisationMode::MedianCut }
-}
-
-#[derive(Clone,Copy,Debug,PartialEq)]
+#[derive(Clone,Copy,Debug,PartialEq,Default)]
 /// Algorithms for seaching an appropriate palette entry for a given pixel.
 pub enum PaletteSearchMode {
     /// Full search (slowest).
     Full,
     /// Local search (faster but may be not so good).
+    #[default]
     Local,
     /// k-d tree based one (the fastest but not so accurate).
     KDTree,
 }
 
-impl Default for PaletteSearchMode {
-    fn default() -> Self { PaletteSearchMode::Local }
-}
-
 use crate::scale::palette::elbg::ELBG;
 use crate::scale::palette::mediancut::quantise_median_cut;
 use crate::scale::palette::neuquant::NeuQuantQuantiser;
@@ -146,7 +140,7 @@ fn palettise_frame_internal(pic_in: &NABufferType, pic_out: &mut NABufferType, q
         };
         let esize = ofmt.elem_size as usize;
         let coffs = [ofmt.comp_info[0].unwrap().comp_offs as usize, ofmt.comp_info[1].unwrap().comp_offs as usize, ofmt.comp_info[2].unwrap().comp_offs as usize];
-        for (dpal, spal) in (&mut dst[paloff..]).chunks_mut(esize).zip(pal.iter()) {
+        for (dpal, spal) in dst[paloff..].chunks_mut(esize).zip(pal.iter()) {
             dpal[coffs[0]] = spal[0];
             dpal[coffs[1]] = spal[1];
             dpal[coffs[2]] = spal[2];
index ae39ef33de2f1efb6bfadacb8d92fac0da5f0a13..5d0776d0ed3caf44851044315816ab6681818ce1 100644 (file)
@@ -221,8 +221,8 @@ impl LanczosResize {
         let a = order as f32;
         for i in 0..(order * 2) {
             let x = frac - ((i as f32) + 1.0 - a);
-            let fp = std::f32::consts::PI * (x as f32);
-            coeffs[i] = a * fp.sin() * (fp / a).sin() / (norm * (x as f32) * (x as f32));
+            let fp = std::f32::consts::PI * x;
+            coeffs[i] = a * fp.sin() * (fp / a).sin() / (norm * x * x);
         }
     }
     fn create_cache(order: usize, den: usize) -> Vec<Vec<f32>> {
index 8a346553e5f396b9857b0241d25ef4cf89d2f021..9a0e0cd64e74d55c48c5370ebeff5f6f30bdcf23 100644 (file)
@@ -355,7 +355,7 @@ impl AVCDecoder {
             0 | 1 => {
                 self.imdct_long.imdct_half(coeffs, &mut self.tmp);
                 overlap_half(dst, &self.tmp, delay, self.win_long);
-                (&mut delay[0..COEFFS/2]).copy_from_slice(&self.tmp[COEFFS/2..COEFFS]);
+                delay[0..COEFFS/2].copy_from_slice(&self.tmp[COEFFS/2..COEFFS]);
                 for i in COEFFS/2..COEFFS {
                     delay[i] = delay[COEFFS - 1 - i];
                 }
@@ -657,12 +657,12 @@ fn synth_recursive(dst: &mut [f32], tmp: &mut [f32], size: usize, order: &[u8],
         let idx = if !dir { i } else { bands - 1 - i };
         synth_filter(src, tmp, size, step, bands, idx);
     }
-    (&mut dst[..size]).copy_from_slice(&tmp[..size]);
+    dst[..size].copy_from_slice(&tmp[..size]);
 }
 
 fn synth_generic(src: &[f32], dst: &mut [f32], tmpbuf: &mut [f32; COEFFS * 2], is_40khz: bool, size: usize) {
     let order = if is_40khz { MERGE_ORDER_40K } else { MERGE_ORDER_44K };
-    (&mut dst[..size]).copy_from_slice(&src[..size]);
+    dst[..size].copy_from_slice(&src[..size]);
     let mut order_idx = 0;
     synth_recursive(dst, tmpbuf, size, order, &mut order_idx, false);
     for el in dst.iter_mut().take(COEFFS) { *el *= 0.125; }
@@ -908,7 +908,7 @@ fn dequant(val: i16, qtab: &[f32; QTAB_SIZE], scale: f32) -> f32 {
     if val >= 0 {
         qtab[val as usize] * scale
     } else {
-        -qtab[val.abs() as usize] * scale
+        -qtab[val.unsigned_abs() as usize] * scale
     }
 }
 
index 72553b5f5b3f698da38509e5d3ca0c6f914c1832..d582d1e06f2891335bbdf939c40f93884b9ab130 100644 (file)
@@ -3,20 +3,15 @@ use nihav_core::codecs::*;
 use nihav_core::io::byteio::*;
 use super::truemotion1data::*;
 
-#[derive(Clone,Copy,PartialEq)]
+#[derive(Clone,Copy,PartialEq,Default)]
 enum BlockMode {
     FourByFour,
+    #[default]
     TwoByTwo,
     FourByTwo,
     TwoByFour,
 }
 
-impl Default for BlockMode {
-    fn default() -> Self {
-        BlockMode::TwoByTwo
-    }
-}
-
 impl FromStr for BlockMode {
     type Err = ();
     fn from_str(s: &str) -> Result<BlockMode, Self::Err> {
@@ -41,19 +36,14 @@ impl ToString for BlockMode {
     }
 }
 
-#[derive(Clone,Copy,PartialEq)]
+#[derive(Clone,Copy,PartialEq,Default)]
 enum OptionMode {
     Off,
     On,
+    #[default]
     Auto,
 }
 
-impl Default for OptionMode {
-    fn default() -> Self {
-        OptionMode::Auto
-    }
-}
-
 impl FromStr for OptionMode {
     type Err = ();
     fn from_str(s: &str) -> Result<OptionMode, Self::Err> {
@@ -518,7 +508,7 @@ impl TM1Encoder {
                     pair[1] = self.prev_frame[x * 2 + 1 + y * self.width];
                     hpred[0] = pair[0] - vpred[0];
                     hpred[1] = pair[1] - vpred[1];
-                    vpred.copy_from_slice(&pair);
+                    vpred.copy_from_slice(pair);
                     continue;
                 }
                 let pval = [vpred[0] + hpred[0], vpred[1] + hpred[1]];
index cf59b14340f57e21e6f840424c67ffe8d7a4e74c..08bfd1a97f58de69693c930025f6d7ac0ca307e6 100644 (file)
@@ -1141,8 +1141,8 @@ impl VP34Decoder {
         if let Some(ref codes) = self.aux_codes {
             for _ in 0..self.y_blocks/4 {
                 if self.blocks[self.blk_addr[cur_blk] >> 2].btype == VPMBType::InterFourMV {
-                    let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv.x.abs() as usize]];
-                    let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv.y.abs() as usize]];
+                    let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv.x.unsigned_abs() as usize]];
+                    let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv.y.unsigned_abs() as usize]];
                     let x_sign = last_mv.x < 0;
                     let y_sign = last_mv.y < 0;
                     last2_mv = last_mv;
@@ -1167,8 +1167,8 @@ impl VP34Decoder {
                             cur_mv = ZERO_MV;
                         },
                         VPMBType::InterMV => {
-                            let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv.x.abs() as usize]];
-                            let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv.y.abs() as usize]];
+                            let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv.x.unsigned_abs() as usize]];
+                            let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv.y.unsigned_abs() as usize]];
                             let x_sign = last_mv.x < 0;
                             let y_sign = last_mv.y < 0;
                             let x               = i16::from(br.read_cb(x_cb)?);
@@ -1185,8 +1185,8 @@ impl VP34Decoder {
                             std::mem::swap(&mut last_mv, &mut last2_mv);
                         },
                         _ => { // GoldenMV
-                            let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv_g.x.abs() as usize]];
-                            let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv_g.y.abs() as usize]];
+                            let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv_g.x.unsigned_abs() as usize]];
+                            let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv_g.y.unsigned_abs() as usize]];
                             let x_sign = last_mv_g.x < 0;
                             let y_sign = last_mv_g.y < 0;
                             let x               = i16::from(br.read_cb(x_cb)?);
@@ -1466,7 +1466,7 @@ impl VP34Decoder {
         let mut pred = 0i32;
         for i in 0..4 {
             if (pp & (1 << i)) != 0 {
-                pred += (preds[i] as i32) * i32::from(VP31_DC_WEIGHTS[pp][i]);
+                pred += preds[i] * i32::from(VP31_DC_WEIGHTS[pp][i]);
             }
         }
         pred /= i32::from(VP31_DC_WEIGHTS[pp][4]);
@@ -1501,7 +1501,7 @@ impl VP34Decoder {
         let mut npred = 0;
         for i in 0..4 {
             if (pp & (1 << i)) != 0 {
-                pred += preds[i] as i32;
+                pred += preds[i];
                 npred += 1;
                 if npred == 2 {
                     return (pred / 2) as i16;
index 2ab474bbb336df23a4b89b80a80630e0edfcff35..5abea84f07a22fcc62567db91db0f09d2bb50a35 100644 (file)
@@ -531,9 +531,7 @@ impl VP56Decoder {
             std::mem::swap(&mut self.models, &mut self.amodels);
             let ret = self.decode_planes(br, &mut dframe, &mut bc, &ahdr, asrc, true);
             std::mem::swap(&mut self.models, &mut self.amodels);
-            if let Err(err) = ret {
-                return Err(err);
-            }
+            ret?;
             match (hdr.is_golden, ahdr.is_golden) {
                 (true, true) => { self.shuf.add_golden_frame(buf.clone()); },
                 (true, false) => {
@@ -699,16 +697,16 @@ impl VP56Decoder {
                 let sum = u32::from(prob_xmitted[mode * 2]) + u32::from(prob_xmitted[mode * 2 + 1]);
                 mdl.probs[9] = 255 - rescale_mb_mode_prob(u32::from(prob_xmitted[mode * 2 + 1]), sum);
 
-                let inter_mv0_weight = (cnt[0] as u32) + (cnt[2] as u32);
-                let inter_mv1_weight = (cnt[3] as u32) + (cnt[4] as u32);
-                let gold_mv0_weight = (cnt[5] as u32) + (cnt[6] as u32);
-                let gold_mv1_weight = (cnt[8] as u32) + (cnt[9] as u32);
-                let mix_weight = (cnt[1] as u32) + (cnt[7] as u32);
+                let inter_mv0_weight = cnt[0] + cnt[2];
+                let inter_mv1_weight = cnt[3] + cnt[4];
+                let gold_mv0_weight = cnt[5] + cnt[6];
+                let gold_mv1_weight = cnt[8] + cnt[9];
+                let mix_weight = cnt[1] + cnt[7];
                 mdl.probs[0] = 1 + rescale_mb_mode_prob(inter_mv0_weight + inter_mv1_weight, total);
                 mdl.probs[1] = 1 + rescale_mb_mode_prob(inter_mv0_weight, inter_mv0_weight + inter_mv1_weight);
                 mdl.probs[2] = 1 + rescale_mb_mode_prob(mix_weight, mix_weight + gold_mv0_weight + gold_mv1_weight);
-                mdl.probs[3] = 1 + rescale_mb_mode_prob(cnt[0] as u32, inter_mv0_weight);
-                mdl.probs[4] = 1 + rescale_mb_mode_prob(cnt[3] as u32, inter_mv1_weight);
+                mdl.probs[3] = 1 + rescale_mb_mode_prob(cnt[0], inter_mv0_weight);
+                mdl.probs[4] = 1 + rescale_mb_mode_prob(cnt[3], inter_mv1_weight);
                 mdl.probs[5] = 1 + rescale_mb_mode_prob(cnt[1], mix_weight);
                 mdl.probs[6] = 1 + rescale_mb_mode_prob(gold_mv0_weight, gold_mv0_weight + gold_mv1_weight);
                 mdl.probs[7] = 1 + rescale_mb_mode_prob(cnt[5], gold_mv0_weight);
index 4bbf4c91cee35bddb6e0c34eb97b010b055d2f5d..916711cddbc00b5392b75c4f1c7f6b28ba257f7e 100644 (file)
@@ -54,7 +54,6 @@ impl VP56Parser for VP6BR {
             hdr.multistream = true;
         }
         let bytes = br.tell() >> 3;
-        std::mem::drop(br);
         bc.skip_bytes(bytes);
         self.loop_mode = 0;
         if hdr.is_intra {
index cb0904f7b797f59b7f399f767542cbdf20ddabb0..a88b0e2e4ec69d5b5ba58143c41a9d7a341b4396 100644 (file)
@@ -199,16 +199,16 @@ fn calc_mb_model_probs(prob_xmitted: &[u8; 20], mbtype_models: &mut [VP56MBTypeM
         let sum = u32::from(prob_xmitted[mode * 2]) + u32::from(prob_xmitted[mode * 2 + 1]);
         mdl.probs[9] = 255 - rescale_mb_mode_prob(u32::from(prob_xmitted[mode * 2 + 1]), sum);
 
-        let inter_mv0_weight = (cnt[0] as u32) + (cnt[2] as u32);
-        let inter_mv1_weight = (cnt[3] as u32) + (cnt[4] as u32);
-        let gold_mv0_weight = (cnt[5] as u32) + (cnt[6] as u32);
-        let gold_mv1_weight = (cnt[8] as u32) + (cnt[9] as u32);
-        let mix_weight = (cnt[1] as u32) + (cnt[7] as u32);
+        let inter_mv0_weight = cnt[0] + cnt[2];
+        let inter_mv1_weight = cnt[3] + cnt[4];
+        let gold_mv0_weight = cnt[5] + cnt[6];
+        let gold_mv1_weight = cnt[8] + cnt[9];
+        let mix_weight = cnt[1] + cnt[7];
         mdl.probs[0] = 1 + rescale_mb_mode_prob(inter_mv0_weight + inter_mv1_weight, total);
         mdl.probs[1] = 1 + rescale_mb_mode_prob(inter_mv0_weight, inter_mv0_weight + inter_mv1_weight);
         mdl.probs[2] = 1 + rescale_mb_mode_prob(mix_weight, mix_weight + gold_mv0_weight + gold_mv1_weight);
-        mdl.probs[3] = 1 + rescale_mb_mode_prob(cnt[0] as u32, inter_mv0_weight);
-        mdl.probs[4] = 1 + rescale_mb_mode_prob(cnt[3] as u32, inter_mv1_weight);
+        mdl.probs[3] = 1 + rescale_mb_mode_prob(cnt[0], inter_mv0_weight);
+        mdl.probs[4] = 1 + rescale_mb_mode_prob(cnt[3], inter_mv1_weight);
         mdl.probs[5] = 1 + rescale_mb_mode_prob(cnt[1], mix_weight);
         mdl.probs[6] = 1 + rescale_mb_mode_prob(gold_mv0_weight, gold_mv0_weight + gold_mv1_weight);
         mdl.probs[7] = 1 + rescale_mb_mode_prob(cnt[5], gold_mv0_weight);
@@ -341,7 +341,7 @@ pub fn encode_mode_prob_models(bc: &mut BoolEncoder, models: &mut VP56Models, pm
                                 bc.put_bool(diff < 0, 128)?;
                                 bc.write_el(d0, MODE_TREE_DIFF, MODE_TREE_DIFF_PROBS)?;
                                 if d0 == 7 {
-                                    bc.put_bits(diff.abs() as u32, 7)?;
+                                    bc.put_bits(u32::from(diff.unsigned_abs()), 7)?;
                                 }
                                 tprob[i ^ 1] = (i16::from(tprob[i ^ 1]) + deltas[i ^ 1]) as u8;
                             }
index 2651458f59fbcdb09704d6655ae922a2fd85c941..90c76b99c7244cecd8a1a6c56425d4e07ada7d55 100644 (file)
@@ -326,7 +326,7 @@ impl MVEstimator {
 fn sad(src1: &[u8; 64], src2: &[u8; 64]) -> u32 {
     let mut sum = 0;
     for (&p1, &p2) in src1.iter().zip(src2.iter()) {
-        sum += (i32::from(p1) - i32::from(p2)).abs() as u32;
+        sum += (i32::from(p1) - i32::from(p2)).unsigned_abs();
     }
     sum
 }
@@ -341,7 +341,7 @@ pub fn calc_mb_dist(mb1: &ResidueMB, mb2: &ResidueMB) -> u32 {
     let mut sum = 0;
     for (blk1, blk2) in mb1.coeffs.iter().zip(mb2.coeffs.iter()) {
         for (&c1, &c2) in blk1.iter().zip(blk2.iter()) {
-            sum += (i32::from(c1) - i32::from(c2)).abs() as u32;
+            sum += (i32::from(c1) - i32::from(c2)).unsigned_abs();
         }
     }
     sum
index cd33f126c53a25fb5dff8aecdfa08fe81304eb8c..cece9d10067cdd0c2a384cefbd582cca12258d01 100644 (file)
@@ -341,7 +341,7 @@ impl FrameEncoder {
         }
     }
     pub fn estimate_mvs(&mut self, ref_frame: NAVideoBufferRef<u8>, mc_buf: NAVideoBufferRef<u8>, golden: bool) {
-        let loop_thr = i16::from(VP56_FILTER_LIMITS[self.quant as usize]);
+        let loop_thr = i16::from(VP56_FILTER_LIMITS[self.quant]);
 
         let inter_mbs = if !golden { &mut self.inter_mbs } else { &mut self.golden_mbs };
 
@@ -384,7 +384,7 @@ impl FrameEncoder {
         }
     }
     fn estimate_fourmv(&mut self, ref_frame: NAVideoBufferRef<u8>, mc_buf: NAVideoBufferRef<u8>, mb_x: usize, mb_y: usize) -> bool {
-        let loop_thr = i16::from(VP56_FILTER_LIMITS[self.quant as usize]);
+        let loop_thr = i16::from(VP56_FILTER_LIMITS[self.quant]);
 
         if self.fourmv_mbs.is_empty() {
             for _ in 0..self.mb_w * self.mb_h {
@@ -526,7 +526,7 @@ impl FrameEncoder {
         }
     }
     pub fn select_inter_blocks_fast(&mut self, ref_frame: NAVideoBufferRef<u8>, gold_frame: Option<NAVideoBufferRef<u8>>, mc_buf: NAVideoBufferRef<u8>, lambda: f32) {
-        let loop_thr = i16::from(VP56_FILTER_LIMITS[self.quant as usize]);
+        let loop_thr = i16::from(VP56_FILTER_LIMITS[self.quant]);
 
         if self.inter_mbs.is_empty() {
             for _ in 0..self.mb_w * self.mb_h {
index 5ca88c07dca991cee079e56a5018e0c38b0871c1..3b2d854588df8f2321cd7f0d475684a8015c2678 100644 (file)
@@ -204,6 +204,7 @@ impl VP7Decoder {
 
         self.pcache.resize(self.mb_w);
     }
+    #[allow(clippy::field_reassign_with_default)]
     fn read_features(&mut self, bc: &mut BoolCoder) -> DecoderResult<()> {
         for (i, feat) in self.dstate.features.iter_mut().enumerate() {
             if bc.read_bool() {
index b0b7672b52ce001e6903d5e5eb1e8f96d0509772..4ec79d13f85345073248d6d08cfb960b4da91025 100644 (file)
@@ -25,8 +25,9 @@ impl<'a> VPTreeReader for BoolCoder<'a> {
 }
 
 #[repr(u8)]
-#[derive(Clone,Copy,PartialEq,Debug)]
+#[derive(Clone,Copy,PartialEq,Debug,Default)]
 pub enum PredMode {
+    #[default]
     DCPred,
     HPred,
     VPred,
@@ -44,10 +45,6 @@ pub enum PredMode {
     Inter,
 }
 
-impl Default for PredMode {
-    fn default() -> Self { PredMode::DCPred }
-}
-
 impl PredMode {
     pub fn to_b_mode(self) -> Self {
         if self == PredMode::DCPred {
index e69a5abedd8700fcb6f72632f990888039c5f470..9d68616aac029da7d28b581ee234593de1d10b1b 100644 (file)
@@ -396,7 +396,7 @@ fn mc_block_common(dst: &mut [u8], mut doff: usize, dstride: usize, src: &[u8],
         let dst = &mut dst[doff..];
         let src = &src[EDGE_PRE + EDGE_PRE * sstride..];
         for (out, src) in dst.chunks_mut(dstride).take(size).zip(src.chunks(sstride)) {
-            (&mut out[0..size]).copy_from_slice(&src[0..size]);
+            out[..size].copy_from_slice(&src[..size]);
         }
     } else if my == 0 {
         let src = &src[EDGE_PRE * sstride..];
@@ -439,7 +439,7 @@ fn mc_block(dst: &mut [u8], doff: usize, dstride: usize, xpos: usize, ypos: usiz
         let src = &reffrm.get_data();
         let src = &src[srcoff..];
         for (out, src) in dst.chunks_mut(dstride).take(size).zip(src.chunks(sstride)) {
-            (&mut out[0..size]).copy_from_slice(&src[0..size]);
+            out[..size].copy_from_slice(&src[..size]);
         }
         return;
     }
@@ -512,7 +512,7 @@ pub fn mc_block_special(dst: &mut [u8], doff: usize, dstride: usize, xpos: usize
             (&data[off + (start_x as usize) + (start_y as usize) * stride..],
              ((stride as isize) + xstep) as usize)
         } else {
-            let add = (size + EDGE_PRE + EDGE_POST) * (xstep.abs() as usize);
+            let add = (size + EDGE_PRE + EDGE_POST) * xstep.unsigned_abs();
             let bw = size + EDGE_PRE + EDGE_POST + add;
             let bh = (end_y - start_y) as usize;
             let bo = if xstep >= 0 { 0 } else { add };
index d4c06c68614b2c11aa79770d942d361c18b49d30..090eadad799c3c48d1ac7b9055c661949a5a867f 100644 (file)
@@ -172,7 +172,7 @@ pub fn fade_frame(srcfrm: NAVideoBufferRef<u8>, dstfrm: &mut NASimpleVideoFrame<
         let dstride = dstfrm.stride[plane];
         let dst = &mut dstfrm.data[dstfrm.offset[plane]..];
         for (src, dst) in src.chunks(sstride).zip(dst.chunks_mut(dstride)).take(ha) {
-            (&mut dst[0..wa]).copy_from_slice(&src[0..wa]);
+            dst[..wa].copy_from_slice(&src[..wa]);
         }
     }
 }
index 227638264cdd8676389664abae7f907a4ea5dd28..7a18d48a316ef23c227fd1d40f8b4b3400cf8122 100644 (file)
@@ -270,7 +270,7 @@ impl SrcBlock {
     }
     pub fn apply_ipred_luma(&self, mode: PredMode, ipred: &IPredContext, dst: &mut Residue) {
         let mut tmp = [0; 256];
-        (&mut tmp).ipred16(16, mode, ipred);
+        tmp.ipred16(16, mode, ipred);
         dst.set_luma_from_diff(&self.luma, &tmp);
     }
     pub fn fill_ipred_luma(&mut self, mode: PredMode, ipred: &IPredContext) {
index 88f74566bec0a5b9e1058adb1dd1b1e38f3d4d3c..d91cee433bb597bbaaa515efee4f0cee46c9de76 100644 (file)
@@ -136,7 +136,7 @@ impl BitRateControl {
     }
     pub fn get_frame_quant(&self, is_intra: bool) -> usize {
         if let Some(q) = self.force_q {
-            q as usize
+            q
         } else {
             let expected_size = self.get_target_size(is_intra);
             let nits_per_mb = ((expected_size * 8) as f32) / (self.num_mb as f32);
index 791788afd4863506adb17d4a42f44771eed97ce1..6e34f591fb839b52c1f0d0be8a0f67ae0e8a6ae1 100644 (file)
@@ -7,18 +7,15 @@ use super::vp78data::*;
 use super::vp78dsp::*;
 use super::vp8dsp::*;
 
-#[derive(Clone,Copy,PartialEq,Debug)]
+#[derive(Clone,Copy,PartialEq,Debug,Default)]
 enum VP8Ref {
+    #[default]
     Intra,
     Last,
     Golden,
     AltRef,
 }
 
-impl Default for VP8Ref {
-    fn default() -> Self { VP8Ref::Intra }
-}
-
 #[derive(Default)]
 pub struct VP8Shuffler {
     lastframe: Option<NAVideoBufferRef<u8>>,
@@ -43,25 +40,13 @@ impl VP8Shuffler {
         self.altframe = Some(buf);
     }
     pub fn get_last(&mut self) -> Option<NAVideoBufferRef<u8>> {
-        if let Some(ref frm) = self.lastframe {
-            Some(frm.clone())
-        } else {
-            None
-        }
+        self.lastframe.as_ref().cloned()
     }
     pub fn get_golden(&mut self) -> Option<NAVideoBufferRef<u8>> {
-        if let Some(ref frm) = self.goldframe {
-            Some(frm.clone())
-        } else {
-            None
-        }
+        self.goldframe.as_ref().cloned()
     }
     pub fn get_altref(&mut self) -> Option<NAVideoBufferRef<u8>> {
-        if let Some(ref frm) = self.altframe {
-            Some(frm.clone())
-        } else {
-            None
-        }
+        self.altframe.as_ref().cloned()
     }
     pub fn has_refs(&self) -> bool {
         self.lastframe.is_some()
index c097a3cd563db3afec0063faa085f83d14284bb7..fa7aa0928b21c42c60715344854b0cf39e1a60df 100644 (file)
@@ -177,7 +177,7 @@ fn mc_block_common(dst: &mut [u8], mut doff: usize, dstride: usize, src: &[u8],
     if (mx == 0) && (my == 0) {
         let dst = &mut dst[doff..];
         for (out, src) in dst.chunks_mut(dstride).take(size).zip(src.chunks(sstride)) {
-            (&mut out[0..size]).copy_from_slice(&src[0..size]);
+            out[..size].copy_from_slice(&src[..size]);
         }
     } else if my == 0 {
         for src in src.chunks(sstride).take(size) {
@@ -218,7 +218,7 @@ fn mc_block(dst: &mut [u8], doff: usize, dstride: usize, xpos: usize, ypos: usiz
         let src = &reffrm.get_data();
         let src = &src[srcoff..];
         for (out, src) in dst.chunks_mut(dstride).take(size).zip(src.chunks(sstride)) {
-            (&mut out[0..size]).copy_from_slice(&src[0..size]);
+            out[..size].copy_from_slice(&src[..size]);
         }
         return;
     }
index 8474dc6a211561ecf347535a80352bbd3e736bc9..eb84f4ef19582f295d679460e314882730f48cdf 100644 (file)
@@ -17,9 +17,10 @@ pub const VP_YUVA420_FORMAT: NAPixelFormaton = NAPixelFormaton{
         palette:    false
     };
 
-#[derive(Clone,Copy,Debug,PartialEq)]
+#[derive(Clone,Copy,Debug,PartialEq,Default)]
 #[allow(dead_code)]
 pub enum VPMBType {
+    #[default]
     Intra,
     InterNoMV,
     InterMV,
@@ -51,10 +52,6 @@ impl VPMBType {
     }
 }
 
-impl Default for VPMBType {
-    fn default() -> Self { VPMBType::Intra }
-}
-
 #[derive(Default)]
 pub struct VPShuffler {
     lastframe: Option<NAVideoBufferRef<u8>>,
@@ -71,18 +68,10 @@ impl VPShuffler {
         self.goldframe = Some(buf);
     }
     pub fn get_last(&mut self) -> Option<NAVideoBufferRef<u8>> {
-        if let Some(ref frm) = self.lastframe {
-            Some(frm.clone())
-        } else {
-            None
-        }
+        self.lastframe.as_ref().cloned()
     }
     pub fn get_golden(&mut self) -> Option<NAVideoBufferRef<u8>> {
-        if let Some(ref frm) = self.goldframe {
-            Some(frm.clone())
-        } else {
-            None
-        }
+        self.goldframe.as_ref().cloned()
     }
     pub fn has_refs(&self) -> bool {
         self.lastframe.is_some()
index 005780c530ce78bc0f2eaaf9705ab2c724424a4e..31d298944da978ec8c54f86deba4b1010e653d7e 100644 (file)
@@ -2,20 +2,17 @@ use nihav_codec_support::codecs::{MV, ZERO_MV};
 
 use std::str::FromStr;
 
-#[derive(Debug,Clone,Copy,PartialEq)]
+#[derive(Debug,Clone,Copy,PartialEq,Default)]
 #[allow(dead_code)]
 pub enum MVSearchMode {
     Full,
     SEA,
     Diamond,
+    #[default]
     Hexagon,
     EPZS,
 }
 
-impl Default for MVSearchMode {
-    fn default() -> Self { MVSearchMode::Hexagon }
-}
-
 pub struct ParseError{}
 
 impl FromStr for MVSearchMode {
index bb290cd0b490faccdee19f549a05669bd5464b33..76dfbf47009a0d44a15276cc6273878d38d3d2d0 100644 (file)
@@ -3,11 +3,16 @@ extern crate nihav_core;
 extern crate nihav_codec_support;
 
 #[allow(clippy::collapsible_if)]
+#[allow(clippy::collapsible_else_if)]
 #[allow(clippy::comparison_chain)]
 #[allow(clippy::excessive_precision)]
 #[allow(clippy::identity_op)]
+#[allow(clippy::needless_late_init)]
 #[allow(clippy::unreadable_literal)]
+#[allow(clippy::upper_case_acronyms)]
 #[allow(clippy::verbose_bit_mask)]
+#[allow(clippy::manual_range_contains)]
+#[allow(clippy::wrong_self_convention)]
 mod codecs;
 
 mod demuxers;
index 91d5825a4b692439ff5e6383cd5e9d5c9a5fbcd3..47f660f8425a9d3f863d928ee1fb3bc53c5a9490 100644 (file)
@@ -33,16 +33,10 @@ impl FSVShuffler {
     }
     fn has_last_frame(&self) -> bool { self.lastframe.is_some() }
     fn get_key_frame(&mut self) -> Option<NAVideoBufferRef<u8>> {
-        match self.keyframe {
-            Some(ref frm) => Some(frm.clone()),
-            None => None,
-        }
+        self.keyframe.as_ref().cloned()
     }
     fn get_last_frame(&mut self) -> Option<NAVideoBufferRef<u8>> {
-        match self.lastframe {
-            Some(ref frm) => Some(frm.clone()),
-            None => None,
-        }
+        self.lastframe.as_ref().cloned()
     }
 }
 
index 624f51335db4c4610615102ed0aa4f3461b90178..ad637968abda653b9aa6771ef5534e9e2c539b32 100644 (file)
@@ -453,7 +453,7 @@ impl GremlinVideoDecoder {
                     let top = (bits.read_bits(br, 4)? as usize) << 8;
                     let offs = top + (br.read_byte()? as usize);
                     if (subtag != 0) || (offs <= 0xF80) {
-                        let len = (subtag as usize) + 3;
+                        let len = subtag + 3;
                         self.lz_copy(idx, (offs as isize) - 4096, len)?;
                         idx += len;
                     } else {
index 8129b5ea87247b4cc8aa1198c64dc67f63e537a8..859049243f552f9f98e4b24bf3a8c07642d6d397 100644 (file)
@@ -191,7 +191,7 @@ impl NADecoder for LHDecoder {
             let abuf = alloc_audio_buffer(self.ainfo, daudio.len(), self.chmap.clone())?;
             let mut adata = abuf.get_abuf_f32().unwrap();
             let buf = adata.get_data_mut().unwrap();
-            (&mut buf[..daudio.len()]).copy_from_slice(daudio.as_slice());
+            buf[..daudio.len()].copy_from_slice(daudio.as_slice());
 
             let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), abuf);
             frm.set_duration(Some(CODEC_SAMPLES as u64));
index 7878f2bc01caf26ae6f8093c34154032f494063f..aebd11814ecfa364a4bd5d98614f890179f3c47e 100644 (file)
@@ -211,7 +211,7 @@ impl Midivid3Decoder {
                     let src = &ref_frm.get_data()[ref_frm.get_offset(0) + (src_x as usize) + (src_y as usize) * sstride..];
                     let dst = &mut frm.data[ydst + x..];
                     for (dst, src) in dst.chunks_mut(frm.stride[0]).zip(src.chunks(sstride)).take(16) {
-                        (&mut dst[..16]).copy_from_slice(&src[..16]);
+                        dst[..16].copy_from_slice(&src[..16]);
                     }
                     let xoff = (src_x as usize) >> 1;
                     let yoff = (src_y as usize) >> 1;
@@ -220,7 +220,7 @@ impl Midivid3Decoder {
                         let src = &ref_frm.get_data()[ref_frm.get_offset(plane) + xoff + yoff * sstride..];
                         let dst = &mut frm.data[if plane == 1 { udst } else { vdst } + x / 2..];
                         for (dst, src) in dst.chunks_mut(frm.stride[plane]).zip(src.chunks(sstride)).take(8) {
-                            (&mut dst[..8]).copy_from_slice(&src[..8]);
+                            dst[..8].copy_from_slice(&src[..8]);
                         }
                     }
                     if has_residue {
index 9e51832a22900da57addf83d4127199dca9ff57c..b282a47fb3ff7ac6e5cae6d25681b1b29ddad68f 100644 (file)
@@ -161,8 +161,8 @@ impl QVideoDecoder {
                         const MV_PART: [i8; 16] = [ 0, 4, 8, 12, 16, 20, 24, 28, -32, -4, -8, -12, -16, -20, -24, -28 ];
 
                         let idx         = br.read_byte()? as usize;
-                        let x = MV_PART[(idx & 0xF) as usize] as isize;
-                        let y = MV_PART[(idx >>  4) as usize] as isize;
+                        let x = MV_PART[idx & 0xF] as isize;
+                        let y = MV_PART[idx >>  4] as isize;
                         let src_off = (tile_off as isize) + x + y * (self.w as isize);
                         validate!(src_off >= 0);
                         validate!((src_off as usize) + self.tile_w + (self.tile_h - 1) * self.w <= self.w * self.h);
index 6731a29b7048165af3afea76fb33600793f81452..40e600842966af033988dca7f19e0e762c44d382 100644 (file)
@@ -1051,7 +1051,7 @@ impl NADecoder for Smush1Decoder {
                                 self.pic.fpal[i] = self.pic.fpal[i].wrapping_add(self.pic.pdelta[i]);
                                 self.pic.pal[i] = (self.pic.fpal[i] >> 7) as u8;
                             }
-                                          br.read_skip((size as usize) - 4)?;
+                                          br.read_skip(size - 4)?;
                         },
                         2 => {
                             validate!(size == 0x904);
index f3a1d8740c81b245ddcc3642f71e641e83f73b7e..9492c62fb6a171f51c390a0ea94b822974a62888 100644 (file)
@@ -308,10 +308,10 @@ impl NADecoder for VMDVideoDecoder {
             let paloff = buf.get_offset(1);
             let data = buf.get_data_mut().unwrap();
             for (inrow, outrow) in self.framebuf.chunks(self.width).zip(data.chunks_mut(stride)) {
-                (&mut outrow[..self.width]).copy_from_slice(inrow);
+                outrow[..self.width].copy_from_slice(inrow);
             }
             if !self.is_24bit {
-                (&mut data[paloff..][..768]).copy_from_slice(&self.pal);
+                data[paloff..][..768].copy_from_slice(&self.pal);
             }
             videobuf = if !self.is_24bit { NABufferType::Video(buf) } else { NABufferType::VideoPacked(buf) };
         } else {
index 071f00f17f288a054b9e654af75a74a8af7620e6..ebd93b2137b567fc934a9abcb32a40da812f328f 100644 (file)
@@ -61,7 +61,7 @@ impl<'a> DemuxCore<'a> for QDemuxer<'a> {
                     validate!(abits == 8 || abits == 16);
                     self.bps = (channels as usize) * abits / 8;
                     let bsize    = read_u16le(&buf[32..])? as usize;
-                    let ahdr = NAAudioInfo::new(arate, channels as u8, if abits == 16 { SND_S16_FORMAT } else { SND_U8_FORMAT }, bsize);
+                    let ahdr = NAAudioInfo::new(arate, channels, if abits == 16 { SND_S16_FORMAT } else { SND_U8_FORMAT }, bsize);
                     let ainfo = NACodecInfo::new("pcm", NACodecTypeInfo::Audio(ahdr), None);
                     self.a_id = strmgr.add_stream(NAStream::new(StreamType::Audio, 1, ainfo, 1, arate, 2));
                 }
index 6132d9ce37756abf9b23da34a7161e917a567df2..3cc5fbc5410a591172605ffee6c98832abe14512 100644 (file)
@@ -531,7 +531,7 @@ impl<'a> DemuxCore<'a> for MCMPDemuxer<'a> {
         let hdr_size                    = self.src.read_u32be()?;
         validate!(cmp == 0 && size1 == hdr_size);
 
-        let size = (nframes - 1) as usize;
+        let size = nframes - 1;
         self.offsets = Vec::with_capacity(size);
         self.sizes   = Vec::with_capacity(size);
         self.samples = Vec::with_capacity(size);
index 5682ef04bb7b5a0cc0db3cb1e58b677e70d86810..e0187aeb0ffc2a97979264e7ee0a5657c40f94bf 100644 (file)
@@ -3,14 +3,20 @@ extern crate nihav_core;
 extern crate nihav_codec_support;
 
 #[allow(clippy::collapsible_if)]
+#[allow(clippy::collapsible_else_if)]
 #[allow(clippy::excessive_precision)]
 #[allow(clippy::needless_range_loop)]
+#[allow(clippy::manual_range_contains)]
 #[allow(clippy::unreadable_literal)]
 #[allow(clippy::useless_let_if_seq)]
+#[allow(clippy::upper_case_acronyms)]
+#[allow(clippy::needless_late_init)]
 mod codecs;
 pub use crate::codecs::game_register_all_decoders;
 #[allow(clippy::collapsible_if)]
 #[allow(clippy::needless_range_loop)]
 #[allow(clippy::unreadable_literal)]
+#[allow(clippy::manual_range_contains)]
+#[allow(clippy::upper_case_acronyms)]
 mod demuxers;
 pub use crate::demuxers::game_register_all_demuxers;
index 98f97ebb0608409ecadcd4516d9b26b3b70cb4fb..ea4d0b02d700c12eeb2375ebd1658b92aee655e3 100644 (file)
@@ -161,7 +161,7 @@ impl BitAlloc {
                 if len < 0 { len = 0; }
                 if len > 6 { len = 6; }
                 self.band_bits[band] = len as u8;
-                cur_bits += (self.band_width[band] as i32) * (len as i32);
+                cur_bits += (self.band_width[band] as i32) * len;
                 if len > 0 {
                     acc += self.band_width[band] as i32;
                 }
@@ -643,7 +643,7 @@ impl IMCDecoder {
             }
             if self.ba.band_present[band] {
                 let band_w = IMC_BANDS[band + 1] - IMC_BANDS[band];
-                let bitsum = self.ba.band_bitsum[band] as usize;
+                let bitsum = self.ba.band_bitsum[band];
                 if (bitsum > 0) && (((band_w * 3) >> 1) > bitsum) {
                     self.ba.band_skip[band] = true;
                 }
@@ -903,8 +903,8 @@ impl NADecoder for IMCDecoder {
         let channels = self.ainfo.get_channels() as usize;
         for chunk in pktbuf.chunks(BLOCK_SIZE * channels) {
             for ch in 0..channels {
-                let off = abuf.get_offset(ch as usize) + start;
-                self.decode_block(chunk, ch as usize, &mut dst[off..off+COEFFS])?;
+                let off = abuf.get_offset(ch) + start;
+                self.decode_block(chunk, ch, &mut dst[off..off+COEFFS])?;
             }
             if (channels == 2) && ((chunk[1] & 0x20) != 0) {
                 let off1 = abuf.get_offset(0) + start;
index 321338821fd662baea35ea3eb18d320c09ce5321..a07904effb60d80c943466fc67838d333e08380e 100644 (file)
@@ -223,8 +223,8 @@ impl Indeo2Decoder {
                 }
                 x += run;
             } else {
-                framebuf[base + x + 0] = table[(idx * 2 + 0) as usize];
-                framebuf[base + x + 1] = table[(idx * 2 + 1) as usize];
+                framebuf[base + x + 0] = table[idx * 2];
+                framebuf[base + x + 1] = table[idx * 2 + 1];
                 x += 2;
             }
         }
index 582293b92a349ea968de5198673e345811070d97..b4e30f912080442baff9b44a169bef2b23648226 100644 (file)
@@ -132,7 +132,7 @@ impl CodebookSuggester {
             if delta == 0 {
                 continue;
             }
-            let delta = delta.abs() as u8;
+            let delta = delta.unsigned_abs();
             self.add_delta(delta);
         }
     }
@@ -141,7 +141,7 @@ impl CodebookSuggester {
             if delta == 0 {
                 continue;
             }
-            let delta = delta.abs() as u8;
+            let delta = delta.unsigned_abs();
             self.add_delta(delta);
         }
     }
@@ -253,9 +253,9 @@ impl CellEncoder {
     fn determine_mode(&self, intra: bool, mut mode_hint: u8) -> (u8, [u8; 2]) {
         if let Some(qmode) = self.quant {
             if intra {
-                return (mode_hint, [qmode as u8, qmode as u8]);
+                return (mode_hint, [qmode, qmode]);
             } else {
-                let qmode = (qmode & 7) as u8;
+                let qmode = qmode & 7;
                 return (mode_hint, [qmode, qmode]);
             }
         }
@@ -646,7 +646,7 @@ fn compress_intra_cell(iwriter: &mut IndexWriter, cell4: &mut [u8; 20], cbs: &[&
         let (prev, cur) = cell4.split_at_mut(pivot);
         let prev = &prev[prev.len() - 4..];
         let cur = &mut cur[..4];
-        let (idx0, idx1) = find_quad(&cb.data, prev, cur);
+        let (idx0, idx1) = find_quad(cb.data, prev, cur);
 
         cur[0] = ((prev[0] as i8) + cb.data[usize::from(idx1) * 2]) as u8;
         cur[1] = ((prev[1] as i8) + cb.data[usize::from(idx1) * 2 + 1]) as u8;
@@ -665,7 +665,7 @@ fn compress_inter_cell(iwriter: &mut IndexWriter, ccell4: &mut [u8; 20], pcell:
         let cb = cbs[y];
         let esc_val = esc_vals[y];
 
-        let (idx0, idx1) = find_quad(&cb.data, prev, cur);
+        let (idx0, idx1) = find_quad(cb.data, prev, cur);
 
         cur[0] = ((prev[0] as i8) + cb.data[usize::from(idx1) * 2]) as u8;
         cur[1] = ((prev[1] as i8) + cb.data[usize::from(idx1) * 2 + 1]) as u8;
@@ -780,8 +780,8 @@ fn compress_inter_cell_mode11(iwriter: &mut IndexWriter, cell: &mut [u8; 32], di
 }
 
 fn pair_dist(src: &[i8], pair: &[i8]) -> u32 {
-    let d0 = (i32::from(src[0]) - i32::from(pair[0])).abs() as u32;
-    let d1 = (i32::from(src[1]) - i32::from(pair[1])).abs() as u32;
+    let d0 = (i32::from(src[0]) - i32::from(pair[0])).unsigned_abs();
+    let d1 = (i32::from(src[1]) - i32::from(pair[1])).unsigned_abs();
     d0 * d0 + d1 * d1
 }
 
index eefa3d7b94bcb95fb6aae470bb3eb79e6886b651..762f8a2764bf1c71a572788f3dbd577fa706754b 100644 (file)
@@ -148,7 +148,7 @@ impl Indeo3Encoder {
             }
 
             let mut iw = Indeo3Writer::new(dbuf);
-            self.cframe.plane[planeno].encode_tree(&mut iw, &tree, &mut self.cenc, ref_plane);
+            self.cframe.plane[planeno].encode_tree(&mut iw, tree, &mut self.cenc, ref_plane);
             drop(iw);
             while (dbuf.len() & 3) != 0 {
                 dbuf.push(0);
index b5030deb9c3eb79dc41c369c5cdc01d737faf869..e4863d37d853f72cc3bdd12bbc503983b23b023c 100644 (file)
@@ -7,7 +7,7 @@ use super::ivi::*;
 use super::ivibr::*;
 
 fn calc_quant(glob_q: u32, qd: i16) -> usize {
-    let qq = (glob_q as i16) + (qd as i16);
+    let qq = (glob_q as i16) + qd;
     if qq < 0 {
         0
     } else if qq > 23 {
index d544085f350fa54d68cb950a1ba9b438a700a225..1383f7409dec3f1b72f88fbcc41b5bd13fbe7072 100644 (file)
@@ -836,7 +836,7 @@ br.skip(skip_part as u32)?;
         unreachable!();
     }
 
-    fn decode_single_frame<'a>(&mut self, dec: &mut dyn IndeoXParser, br: &mut BitReader<'a>) -> DecoderResult<NABufferType> {
+    fn decode_single_frame(&mut self, dec: &mut dyn IndeoXParser, br: &mut BitReader) -> DecoderResult<NABufferType> {
         let pic_hdr = dec.decode_picture_header(br)?;
         self.ftype = pic_hdr.ftype;
         if pic_hdr.ftype.is_null() {
@@ -978,9 +978,8 @@ br.skip(skip_part as u32)?;
         Ok(buftype)
     }
 
-    pub fn decode_frame<'a>(&mut self, dec: &mut dyn IndeoXParser, br: &mut BitReader<'a>) -> DecoderResult<NABufferType> {
-        let res = self.decode_single_frame(dec, br);
-        if res.is_err() { return res; }
+    pub fn decode_frame(&mut self, dec: &mut dyn IndeoXParser, br: &mut BitReader) -> DecoderResult<NABufferType> {
+        let res = self.decode_single_frame(dec, br)?;
         if (self.ftype == IVIFrameType::Intra) && (br.left() > 16) {
             loop {
                 if br.left() < 8 { break; }
@@ -1003,11 +1002,11 @@ br.skip(skip_part as u32)?;
             }
         }
         if self.bref.is_some() && self.ftype == IVIFrameType::Inter {
-            let mut bref: Option<NABufferType> = Some(res.unwrap());
+            let mut bref: Option<NABufferType> = Some(res);
             mem::swap(&mut bref, &mut self.bref);
             return Ok(bref.unwrap());
         }
-        if let Ok(NABufferType::None) = res {
+        if let NABufferType::None = res {
             if self.bref.is_some() {
                 let mut bref: Option<NABufferType> = None;
                 mem::swap(&mut bref, &mut self.bref);
@@ -1015,7 +1014,7 @@ br.skip(skip_part as u32)?;
                 return Ok(bref.unwrap());
             }
         }
-        res
+        Ok(res)
     }
 
     pub fn flush(&mut self) {
index cccb5ab71dfea36a7a1410ce68ecb06851fbec78..4e55d914f21d1966b65453a559ecc21b95503cc2 100644 (file)
@@ -40,9 +40,9 @@ impl<'a> DemuxCore<'a> for IVFDemuxer<'a> {
     fn open(&mut self, strmgr: &mut StreamManager, _seek_index: &mut SeekIndex) -> DemuxerResult<()> {
         let mut guid = [0; 16];
                                           self.src.read_buf(&mut guid)?;
-        let version = match &guid {
-            &IVF_GUID_0 => 0,
-            &IVF_GUID_1 => 1,
+        let version = match guid {
+            IVF_GUID_0 => 0,
+            IVF_GUID_1 => 1,
             _ => return Err(DemuxerError::InvalidData),
         };
         let flags                       = self.src.read_u32le()?;
@@ -85,7 +85,7 @@ impl<'a> DemuxCore<'a> for IVFDemuxer<'a> {
         let fcc                         = self.src.read_tag()?;
                                           self.src.read_skip(20)?;
 
-        let mut vhdr = NAVideoInfo::new(width, height.abs() as usize, height < 0, YUV420_FORMAT);
+        let mut vhdr = NAVideoInfo::new(width, height.unsigned_abs() as usize, height < 0, YUV420_FORMAT);
         vhdr.bits = (planes as u8) * (bitcount as u8);
         let cname = match &fcc {
                 b"IV31" | b"IV32" => "indeo3",
@@ -243,6 +243,7 @@ const DEMUXER_OPTS: &[NAOptionDefinition] = &[
 
 impl<'a> NAOptionHandler for IVFDemuxer<'a> {
     fn get_supported_options(&self) -> &[NAOptionDefinition] { DEMUXER_OPTS }
+    #[allow(clippy::single_match)]
     fn set_options(&mut self, options: &[NAOption]) {
        for option in options.iter() {
             for opt_def in DEMUXER_OPTS.iter() {
@@ -259,6 +260,7 @@ impl<'a> NAOptionHandler for IVFDemuxer<'a> {
             }
         }
     }
+    #[allow(clippy::single_match)]
     fn query_option_value(&self, name: &str) -> Option<NAValue> {
         match name {
             PASSES => Some(NAValue::Int(i64::from(self.passes))),
index 22ef878a5e58032d4b683e7dee51bfc5eefbd6bf..a89bd260638f957868ba83a74b14cb7983c7e8bb 100644 (file)
@@ -3,11 +3,15 @@ extern crate nihav_core;
 extern crate nihav_codec_support;
 
 #[allow(clippy::collapsible_if)]
+#[allow(clippy::collapsible_else_if)]
 #[allow(clippy::identity_op)]
 #[allow(clippy::needless_range_loop)]
+#[allow(clippy::needless_late_init)]
 #[allow(clippy::too_many_arguments)]
 #[allow(clippy::useless_let_if_seq)]
 #[allow(clippy::verbose_bit_mask)]
+#[allow(clippy::upper_case_acronyms)]
+#[allow(clippy::manual_range_contains)]
 mod codecs;
 
 pub use crate::codecs::indeo_register_all_decoders;
index 01d46af5f96fec03be656c4cd0ff8ea421dab409..ae0d435d3145c4f35bdfd8f5b4b59730c51c7c92 100644 (file)
@@ -287,7 +287,7 @@ pub fn decode_mb_pred_cabac(cabac: &mut CABAC, slice_hdr: &SliceHeader, mb_type:
                         } else { new_mode };
                 }
                 mb_info.ipred[x + y * 4] = pred_mode.into();
-                sstate.get_cur_blk4(x + y * 4).ipred = (pred_mode as u8).into();
+                sstate.get_cur_blk4(x + y * 4).ipred = pred_mode.into();
             }
             let mut ctx = 0;
             if sstate.get_left_mb().cmode != 0 {
@@ -329,10 +329,10 @@ pub fn decode_mb_pred_cabac(cabac: &mut CABAC, slice_hdr: &SliceHeader, mb_type:
                 mb_info.ipred[blk4 + 1] = pred_mode.into();
                 mb_info.ipred[blk4 + 4] = pred_mode.into();
                 mb_info.ipred[blk4 + 5] = pred_mode.into();
-                sstate.get_cur_blk4(blk4).ipred = (pred_mode as u8).into();
-                sstate.get_cur_blk4(blk4 + 1).ipred = (pred_mode as u8).into();
-                sstate.get_cur_blk4(blk4 + 4).ipred = (pred_mode as u8).into();
-                sstate.get_cur_blk4(blk4 + 5).ipred = (pred_mode as u8).into();
+                sstate.get_cur_blk4(blk4).ipred = pred_mode.into();
+                sstate.get_cur_blk4(blk4 + 1).ipred = pred_mode.into();
+                sstate.get_cur_blk4(blk4 + 4).ipred = pred_mode.into();
+                sstate.get_cur_blk4(blk4 + 5).ipred = pred_mode.into();
             }
             let mut ctx = 0;
             if sstate.get_left_mb().cmode != 0 {
@@ -589,9 +589,9 @@ pub fn decode_mb_qp_delta_cabac(cabac: &mut CABAC, ctx: usize) -> i32 {
             val += 1;
         }
         if (val & 1) != 0 {
-            ((val >> 1) as i32) + 2
+            (val >> 1) + 2
         } else {
-            -((val >> 1) as i32) - 1
+            -(val >> 1) - 1
         }
     }
 }
index adc28aba96084f076695b450c8a3e3b3f65ed2be..af98aa5a1cac61450c6a8da25df76ed2db2a893b 100644 (file)
@@ -130,7 +130,7 @@ pub fn decode_mb_pred_cavlc(br: &mut BitReader, slice_hdr: &SliceHeader, mb_type
                         } else { new_mode };
                 }
                 mb_info.ipred[x + y * 4] = pred_mode.into();
-                sstate.get_cur_blk4(x + y * 4).ipred = (pred_mode as u8).into();
+                sstate.get_cur_blk4(x + y * 4).ipred = pred_mode.into();
             }
             mb_info.chroma_ipred                    = br.read_ue_lim(3)? as u8;
         },
@@ -154,10 +154,10 @@ pub fn decode_mb_pred_cavlc(br: &mut BitReader, slice_hdr: &SliceHeader, mb_type
                 mb_info.ipred[blk4 + 1] = pred_mode.into();
                 mb_info.ipred[blk4 + 4] = pred_mode.into();
                 mb_info.ipred[blk4 + 5] = pred_mode.into();
-                sstate.get_cur_blk4(blk4).ipred = (pred_mode as u8).into();
-                sstate.get_cur_blk4(blk4 + 1).ipred = (pred_mode as u8).into();
-                sstate.get_cur_blk4(blk4 + 4).ipred = (pred_mode as u8).into();
-                sstate.get_cur_blk4(blk4 + 5).ipred = (pred_mode as u8).into();
+                sstate.get_cur_blk4(blk4).ipred = pred_mode.into();
+                sstate.get_cur_blk4(blk4 + 1).ipred = pred_mode.into();
+                sstate.get_cur_blk4(blk4 + 4).ipred = pred_mode.into();
+                sstate.get_cur_blk4(blk4 + 5).ipred = pred_mode.into();
             }
             mb_info.chroma_ipred                    = br.read_ue_lim(3)? as u8;
         },
index 27570e511d20b0616703c429628d17ca0bcef60e..a69cf336d39fdf1b956fa34ae3b1decdb5387bcd 100644 (file)
@@ -61,7 +61,7 @@ impl FrameDecoder {
             17, 18, 20, 24, 19, 21, 26, 28, 23, 27, 29, 30, 22, 25, 38, 41
         ];
 
-        let mut mb_idx = slice_hdr.first_mb_in_slice as usize;
+        let mut mb_idx = slice_hdr.first_mb_in_slice;
         let mut mb_info = CurrentMBInfo { qp_y: slice_hdr.slice_qp, ..Default::default() };
         let skip_type = if slice_hdr.slice_type.is_p() { MBType::PSkip } else { MBType::BSkip };
         while br.tell() < full_size && mb_idx < self.num_mbs {
@@ -155,7 +155,7 @@ impl FrameDecoder {
         Ok(mb_idx)
     }
     fn decode_slice_cabac(&mut self, cabac: &mut CABAC, slice_hdr: &SliceHeader, refs: &SliceRefs) -> DecoderResult<usize> {
-        let mut mb_idx = slice_hdr.first_mb_in_slice as usize;
+        let mut mb_idx = slice_hdr.first_mb_in_slice;
         let mut prev_mb_skipped = false;
         let skip_type = if slice_hdr.slice_type.is_p() { MBType::PSkip } else { MBType::BSkip };
         let mut last_qp_diff = false;
@@ -777,7 +777,7 @@ impl NADecoderMT for H264MTDecoder {
             }
 
             let num_bufs = if !self.sps.is_empty() {
-                    self.sps[0].num_ref_frames as usize + 1
+                    self.sps[0].num_ref_frames + 1
                 } else {
                     3
                 }.max(16 + 1);
index 85deab9ed0fea8f9a613cff39d6f9616152991e0..13fe1bd82f33abac4b1f29f8ac005616ce0a41b2 100644 (file)
@@ -222,7 +222,7 @@ println!("PAFF?");
                     self.has_pic = self.decode_slice_cavlc(&mut br, &slice_hdr, full_size)?;
                 } else {
                     br.align();
-                    let start = (br.tell() / 8) as usize;
+                    let start = br.tell() / 8;
                     let csrc = &src[start..];
                     validate!(csrc.len() >= 2);
                     let mut cabac = CABAC::new(csrc, slice_hdr.slice_type, slice_hdr.slice_qp, slice_hdr.cabac_init_idc as usize)?;
@@ -482,7 +482,7 @@ _ => {},
             17, 18, 20, 24, 19, 21, 26, 28, 23, 27, 29, 30, 22, 25, 38, 41
         ];
 
-        let mut mb_idx = slice_hdr.first_mb_in_slice as usize;
+        let mut mb_idx = slice_hdr.first_mb_in_slice;
         let mut mb_info = CurrentMBInfo { qp_y: slice_hdr.slice_qp, ..Default::default() };
         let skip_type = if slice_hdr.slice_type.is_p() { MBType::PSkip } else { MBType::BSkip };
         while br.tell() < full_size && mb_idx < self.num_mbs {
@@ -576,7 +576,7 @@ _ => {},
         Ok(mb_idx == self.num_mbs)
     }
     fn decode_slice_cabac(&mut self, cabac: &mut CABAC, slice_hdr: &SliceHeader) -> DecoderResult<bool> {
-        let mut mb_idx = slice_hdr.first_mb_in_slice as usize;
+        let mut mb_idx = slice_hdr.first_mb_in_slice;
         let mut prev_mb_skipped = false;
         let skip_type = if slice_hdr.slice_type.is_p() { MBType::PSkip } else { MBType::BSkip };
         let mut last_qp_diff = false;
@@ -763,7 +763,7 @@ impl NADecoder for H264Decoder {
             }
 
             let num_bufs = if !self.sps.is_empty() {
-                    self.sps[0].num_ref_frames as usize + 1
+                    self.sps[0].num_ref_frames + 1
                 } else {
                     3
                 }.max(16 + 1);
index a0472163c949bab1579aa06563dd7372a16ca0a5..a24e9d0e0a4fb582b4cb9806501c891819673bea 100644 (file)
@@ -188,11 +188,9 @@ impl FrameRefs {
                 dst.push(pic.full_id);
             }
         }
-        for ltpic in self.long_term.iter() {
-            if let Some(ref pic) = ltpic {
-                if !dst.contains(&pic.full_id) {
-                    dst.push(pic.full_id);
-                }
+        for pic in self.long_term.iter().flatten() {
+            if !dst.contains(&pic.full_id) {
+                dst.push(pic.full_id);
             }
         }
     }
index 9df866e829348526c92e92f7f1d6d91903560354..6fe5aea9f00f40f4612e38dece654d24ccb4a029 100644 (file)
@@ -12,8 +12,9 @@ pub enum BMode {
     Bi,
 }
 
-#[derive(Clone,Copy,Debug,PartialEq)]
+#[derive(Clone,Copy,Debug,PartialEq,Default)]
 pub enum MBType {
+    #[default]
     Intra4x4,
     Intra8x8,
     Intra16x16(u8, u8, u8),
@@ -106,16 +107,13 @@ impl MBType {
     }
 }
 
-impl Default for MBType {
-    fn default() -> Self { MBType::Intra4x4 }
-}
-
-#[derive(Clone,Copy,Debug,PartialEq)]
+#[derive(Clone,Copy,Debug,PartialEq,Default)]
 pub enum SubMBType {
     P8x8,
     P8x4,
     P4x8,
     P4x4,
+    #[default]
     Direct8x8,
     B8x8(BMode),
     B8x4(BMode),
@@ -159,12 +157,8 @@ impl SubMBType {
     }
 }
 
-impl Default for SubMBType {
-    fn default() -> Self { SubMBType::Direct8x8 }
-}
-
 #[repr(u8)]
-#[derive(Clone,Copy,Debug,PartialEq)]
+#[derive(Clone,Copy,Debug,PartialEq,Default)]
 pub enum CompactMBType {
     Intra4x4,
     Intra8x8,
@@ -185,6 +179,7 @@ pub enum CompactMBType {
     B8x8,
     BSkip,
 
+    #[default]
     None,
 }
 
@@ -215,10 +210,6 @@ impl CompactMBType {
     }
 }
 
-impl Default for CompactMBType {
-    fn default() -> Self { CompactMBType::None }
-}
-
 impl From<MBType> for CompactMBType {
     fn from(mbtype: MBType) -> Self {
         match mbtype {
@@ -243,7 +234,7 @@ impl From<MBType> for CompactMBType {
 }
 
 #[repr(u8)]
-#[derive(Clone,Copy,Debug,PartialEq)]
+#[derive(Clone,Copy,Debug,PartialEq,Default)]
 pub enum IntraPredMode {
     Vertical,
     Horizontal,
@@ -254,6 +245,7 @@ pub enum IntraPredMode {
     HorDown,
     VerLeft,
     HorUp,
+    #[default]
     None,
 }
 
@@ -268,10 +260,6 @@ impl IntraPredMode {
     }
 }
 
-impl Default for IntraPredMode {
-    fn default() -> Self { IntraPredMode::None }
-}
-
 impl From<u8> for IntraPredMode {
     fn from(val: u8) -> Self {
         match val {
index a3873bf5c34f65222ac6b8e7a72f7702941f71a3..2014f0af26ea8e2183c9f22cc58a53203f9d1aa5 100644 (file)
@@ -10,6 +10,7 @@ macro_rules! validate {
 }
 
 #[allow(clippy::collapsible_else_if)]
+#[allow(clippy::manual_range_contains)]
 #[allow(clippy::too_many_arguments)]
 #[allow(clippy::upper_case_acronyms)]
 #[cfg(feature="decoder_h264")]
index 1bcd62e2a200dca4b4b75f62fcda473c0e3f9ebf..7b02c94d033e21ac25848bbbcc0651cda91851f9 100644 (file)
@@ -107,7 +107,7 @@ impl NADecoder for APEDecoder {
                     } else {
                         return Err(DecoderError::NotImplemented);
                     };
-                self.ainfo = NAAudioInfo::new(srate, channels as u8, SND_S16P_FORMAT, 4602);
+                self.ainfo = NAAudioInfo::new(srate, channels, SND_S16P_FORMAT, 4602);
                 Ok(())
             } else {
                 Err(DecoderError::InvalidData)
index e0b407d68c32fa36e7c90246339d6bd532546783..6d7198120a2820ce05e71b23877cdd87b6d60bba 100644 (file)
@@ -263,7 +263,7 @@ impl NADecoder for FlacDecoder {
                         _ => return Err(DecoderError::NotImplemented),
                     };
 
-                self.ainfo = NAAudioInfo::new(self.srate, self.channels as u8, fmt, self.max_blk_size.max(1));
+                self.ainfo = NAAudioInfo::new(self.srate, self.channels, fmt, self.max_blk_size.max(1));
                 Ok(())
             } else {
                 Err(DecoderError::InvalidData)
index 31629e7f29fec7081347bef240d4219cad1c5f93..d8f2302600a127e320dbc61135e566caa411b51d 100644 (file)
@@ -38,6 +38,7 @@ struct WVHeader {
 const WV_HEADER_SIZE: usize = 32;
 
 impl WVHeader {
+    #[allow(clippy::field_reassign_with_default)]
     fn parse(src: &[u8]) -> DecoderResult<Self> {
         let mut mr = MemoryReader::new_read(src);
         let mut br = ByteReader::new(&mut mr);
index 215a1e9527c00508b48802ef71466d9f31953278..4fb6c4c144b45b4125fb4ca004e3d1d8bec8f328 100644 (file)
@@ -212,7 +212,7 @@ impl<'a> DemuxCore<'a> for FLACDemuxer<'a> {
         self.srate = srate;
 
         let base = if self.blk_samples != 0 { u32::from(self.blk_samples) } else { 1 };
-        let ahdr = NAAudioInfo::new(srate, channels as u8, SND_S16P_FORMAT, base as usize);
+        let ahdr = NAAudioInfo::new(srate, channels, SND_S16P_FORMAT, base as usize);
         let ainfo = NACodecInfo::new("flac", NACodecTypeInfo::Audio(ahdr), Some(streaminfo));
         strmgr.add_stream(NAStream::new(StreamType::Audio, 0, ainfo, base, srate, 0)).unwrap();
 
index c04f1f00461aeecdddd025370004df97fdfc4375..dcdd5a5b9be9082cf4a7a971eaa0bc3f543ea00d 100644 (file)
@@ -90,7 +90,7 @@ impl<'a> RawDemuxCore<'a> for FLACDemuxer<'a> {
         self.srate = srate;
 
         let base = if self.blk_samples != 0 { u32::from(self.blk_samples) } else { 1 };
-        let ahdr = NAAudioInfo::new(srate, channels as u8, SND_S16P_FORMAT, base as usize);
+        let ahdr = NAAudioInfo::new(srate, channels, SND_S16P_FORMAT, base as usize);
         let ainfo = NACodecInfo::new("flac", NACodecTypeInfo::Audio(ahdr), Some(streaminfo));
         strmgr.add_stream(NAStream::new(StreamType::Audio, 0, ainfo, base, srate, 0)).unwrap();
 
index 2d92e7b7f1fe3041bd33c0d2d12a5642b1e73cef..6c5f8dd392b51d155abebc000ac519dc11439e36 100644 (file)
@@ -36,6 +36,7 @@ struct WVHeader {
 const WV_HEADER_SIZE: usize = 32;
 
 impl WVHeader {
+    #[allow(clippy::field_reassign_with_default)]
     fn parse(src: &[u8]) -> DemuxerResult<Self> {
         let mut mr = MemoryReader::new_read(src);
         let mut br = ByteReader::new(&mut mr);
index 63a86aaebe33f601a056de99741c65b352df2a91..81a1d367a1c3cd76d105df986db01d706a32d660 100644 (file)
@@ -43,7 +43,7 @@ pub fn get_scale(scale: u8) -> f32 {
     2.0f32.powf(0.25 * (f32::from(scale) - 100.0 - 56.0))
 }
 fn iquant(val: i16) -> f32 {
-    let idx = val.abs() as usize;
+    let idx = val.unsigned_abs() as usize;
     if idx < CBRT_TAB.len() {
         if val < 0 {
             -CBRT_TAB[idx]
@@ -83,9 +83,9 @@ fn decode_quads(br: &mut BitReader, cb: &Codebook<u16>, unsigned: bool, scale: f
             for i in 0..4 {
                 let val = AAC_QUADS[cw][i] - 1;
                 if val < 0 {
-                    out[i] = -CBRT_TAB[val.abs() as usize] * scale;
+                    out[i] = -CBRT_TAB[val.unsigned_abs() as usize] * scale;
                 } else {
-                    out[i] =  CBRT_TAB[val.abs() as usize] * scale;
+                    out[i] =  CBRT_TAB[val.unsigned_abs() as usize] * scale;
                 }
             }
         }
@@ -118,8 +118,8 @@ fn decode_pairs(br: &mut BitReader, cb: &Codebook<u16>, unsigned: bool, escape:
             out[0] = iquant(x) * scale;
             out[1] = iquant(y) * scale;
         } else {
-            out[0] = scale * if x < 0 { -CBRT_TAB[x.abs() as usize] } else { CBRT_TAB[x as usize] };
-            out[1] = scale * if y < 0 { -CBRT_TAB[y.abs() as usize] } else { CBRT_TAB[y as usize] };
+            out[0] = scale * if x < 0 { -CBRT_TAB[x.unsigned_abs() as usize] } else { CBRT_TAB[x as usize] };
+            out[1] = scale * if y < 0 { -CBRT_TAB[y.unsigned_abs() as usize] } else { CBRT_TAB[y as usize] };
         }
     }
     Ok(())
index ea262b9dfe330ab5e2190831421fb609fcda4018..179134ccdd2fafa55f7dabf3e87115822f74c660 100644 (file)
@@ -628,8 +628,8 @@ impl AACDecoder {
                 4 => { // ID_DSE
                         let _id                         = br.read(4)?;
                         let align                       = br.read_bool()?;
-                        let mut count                   = br.read(8)? as u32;
-                        if count == 255 { count        += br.read(8)? as u32; }
+                        let mut count                   = br.read(8)?;
+                        if count == 255 { count        += br.read(8)?; }
                         if align {                        br.align(); }
                                                           br.skip(count * 8)?; // no SBR payload or such
                     },
index f12e9d9dc0a9a4d7fda6c1409fde2ae76d5f32a0..dbce7276c553aabf6c8de221087ec9fe03215b45 100644 (file)
@@ -159,7 +159,7 @@ fn read_grid(br: &mut BitReader, chan: &mut SBRChannel) -> DecoderResult<()> {
             let var_bord_1          = br.read(2)? as u8;
             let num_rel_0           = br.read(2)? as usize;
             let num_rel_1           = br.read(2)? as usize;
-            chan.num_env = (num_rel_0 as usize) + (num_rel_1 as usize) + 1;
+            chan.num_env = num_rel_0 + num_rel_1 + 1;
             let mut rel_bord_0 = [0u8; NUM_ENVELOPES];
             let mut rel_bord_1 = [0u8; NUM_ENVELOPES];
             for el in rel_bord_0[..num_rel_0].iter_mut() {
index 75c808eed2bfc0d7d23b1e14c7988ca7f2f81a80..42a5ba04f4d671eca6d0aeb48a00d5155d31988e 100644 (file)
@@ -447,15 +447,15 @@ impl SBRChannel {
                 let mut e_o_sum = EPS0;
                 let mut e_c_sum = EPS0;
                 for k in start..end {
-                    e_o_sum += e_orig_mapped[env][k] as f32;
+                    e_o_sum += e_orig_mapped[env][k];
                     e_c_sum += e_curr[env][k];
                 }
                 *dst = (e_o_sum / e_c_sum).sqrt() * LIM_GAIN[hdr.limiter_gains as usize];
                 start = end;
             }
             for k in kx..km {
-                let e_orig = e_orig_mapped[env][k] as f32;
-                let q_orig = q_mapped[env][k] as f32;
+                let e_orig = e_orig_mapped[env][k];
+                let q_orig = q_mapped[env][k];
                 let e_curr = e_curr[env][k];
 
                 q_m[k] = (e_orig * q_orig / (1.0 + q_orig)).sqrt();
@@ -485,7 +485,7 @@ impl SBRChannel {
                 let mut nsum = EPS0;
                 let mut dsum = EPS0;
                 for k in start..end {
-                    nsum += e_orig_mapped[env][k] as f32;
+                    nsum += e_orig_mapped[env][k];
                     dsum += e_curr[env][k] * g_lim[k] * g_lim[k];
                     if s_m[k] != 0.0 || (env as i8) == l_a || (env as i8) == la_prev {
                         dsum += s_m[k] * s_m[k];
index 99b57720127296ca210430b86146581b3952e538..677e81b55049594d428d3066bc12f9587032c68d 100644 (file)
@@ -81,7 +81,7 @@ impl MPADecoder {
             ctx.mpeg1 = self.sf_idx < 3;
             ctx.sf_idx = self.sf_idx;
             ctx.read_mp3_side_data(br, channels)?;
-            let hdr_size = (br.tell() / 8) as usize;
+            let hdr_size = br.tell() / 8;
             let add_len = src.len() - hdr_size;
             if self.bytebuf.len() + add_len > BYTEBUF_SIZE {
                 self.bytebuf.drain(..self.bytebuf.len() + add_len - BYTEBUF_SIZE);
index a40decfa96bef58243825923d5b5ab284a967f22..5e161257870397bcabac056b91819c27bf8fcdfd 100644 (file)
@@ -4,7 +4,11 @@ extern crate nihav_codec_support;
 
 #[cfg(feature="decoders")]
 #[allow(clippy::collapsible_if)]
+#[allow(clippy::collapsible_else_if)]
 #[allow(clippy::needless_range_loop)]
+#[allow(clippy::needless_late_init)]
+#[allow(clippy::manual_range_contains)]
+#[allow(clippy::upper_case_acronyms)]
 mod codecs;
 
 #[cfg(feature="decoders")]
index a113d5d3e0e47be3be0a6364c190d6613df68ede..f2a222325914e4f9d84ef2b80ec50117c7a312eb 100644 (file)
@@ -96,7 +96,6 @@ impl IMAADPCMEncoder {
                     nw.write(nib)?;
                 }
             }
-            drop(nw);
         } else {
             self.nodes.reserve(self.block_len);
             self.nibs.resize(self.channels, Vec::new());
@@ -164,7 +163,6 @@ impl IMAADPCMEncoder {
                     nw.write(self.nibs[ch][i])?;
                 }
             }
-            drop(nw);
         }
 
         self.samples.drain(..self.block_len * self.channels);
index 739315b07105101eb634796c86291b2efd876859..736884bcecf443bebb616c055b10ed54f6132dcc 100644 (file)
@@ -43,6 +43,7 @@ pub fn ms_register_all_decoders(rd: &mut RegisteredDecoders) {
 }
 
 #[cfg(feature="encoder_msvideo1")]
+#[allow(clippy::collapsible_else_if)]
 pub mod msvideo1enc;
 
 const MS_ENCODERS: &[EncoderInfo] = &[
index 179b097515f95ffa27a05edc78647928fb6f8725..23769de9e30d6126a37c80b207f93433ebdeab7a 100644 (file)
@@ -267,7 +267,6 @@ impl MSADPCMEncoder {
             }
         }
         self.samples.drain(..len * self.channels);
-        drop(bw);
         let ts = NATimeInfo::new(None, None, Some(1), 1, self.srate);
         Ok(NAPacket::new(self.stream.clone().unwrap(), ts, true, dbuf))
     }
index 4507e08ec7bfff1f7d3251d4d059b29c494a2bc1..f457dfcf78ed6f81daf6f444d53bc38dd12486bf 100644 (file)
@@ -316,7 +316,7 @@ impl BlockState {
                 self.clr2.swap(0, 1);
             }
         } else {
-            let (clrs, mask, dist) = quant2_16pix(&buf);
+            let (clrs, mask, dist) = quant2_16pix(buf);
             self.clr2 = clrs;
             self.clr2_flags = mask;
             self.clr2_dist = dist;
@@ -581,7 +581,7 @@ impl MSVideo1Encoder {
         let dst = cur_frm.get_data_mut().unwrap();
         let mut skip_run = 0;
         let bpainter = BlockPainter15::new();
-        for ((sstrip, rstrip), dstrip) in (&src[soff..]).chunks(sstride * 4).take(h / 4).zip((&rsrc[roff..]).chunks(rstride * 4)).zip((&mut dst[doff..]).chunks_mut(dstride * 4)) {
+        for ((sstrip, rstrip), dstrip) in src[soff..].chunks(sstride * 4).take(h / 4).zip(rsrc[roff..].chunks(rstride * 4)).zip(dst[doff..].chunks_mut(dstride * 4)) {
             for x in (0..w).step_by(4) {
                 let mut buf = [UnpackedPixel::default(); 16];
                 let mut refbuf = [UnpackedPixel::default(); 16];
@@ -662,7 +662,7 @@ impl MSVideo1Encoder {
         let doff = cur_frm.get_offset(0);
         let dst = cur_frm.get_data_mut().unwrap();
         let bpainter = BlockPainter15::new();
-        for (sstrip, dstrip) in (&src[soff..]).chunks(sstride * 4).take(h / 4).zip((&mut dst[doff..]).chunks_mut(dstride * 4)) {
+        for (sstrip, dstrip) in src[soff..].chunks(sstride * 4).take(h / 4).zip(dst[doff..].chunks_mut(dstride * 4)) {
             for x in (0..w).step_by(4) {
                 let mut buf = [UnpackedPixel::default(); 16];
                 Self::get_block(&sstrip[x..], sstride, &mut buf);
@@ -701,7 +701,7 @@ impl MSVideo1Encoder {
         let dst = cur_frm.get_data_mut().unwrap();
         let mut skip_run = 0;
         let bpainter = BlockPainterPal::new(ls);
-        for ((sstrip, rstrip), dstrip) in (&src[soff..]).chunks(sstride * 4).take(h / 4).zip((&rsrc[roff..]).chunks(rstride * 4)).zip((&mut dst[doff..]).chunks_mut(dstride * 4)) {
+        for ((sstrip, rstrip), dstrip) in src[soff..].chunks(sstride * 4).take(h / 4).zip(rsrc[roff..].chunks(rstride * 4)).zip(dst[doff..].chunks_mut(dstride * 4)) {
             for x in (0..w).step_by(4) {
                 let mut buf = [UnpackedPixel::default(); 16];
                 let mut refbuf = [UnpackedPixel::default(); 16];
@@ -782,7 +782,7 @@ impl MSVideo1Encoder {
         let doff = cur_frm.get_offset(0);
         let dst = cur_frm.get_data_mut().unwrap();
         let bpainter = BlockPainterPal::new(ls);
-        for (sstrip, dstrip) in (&src[soff..]).chunks(sstride * 4).take(h / 4).zip((&mut dst[doff..]).chunks_mut(dstride * 4)) {
+        for (sstrip, dstrip) in src[soff..].chunks(sstride * 4).take(h / 4).zip(dst[doff..].chunks_mut(dstride * 4)) {
             for x in (0..w).step_by(4) {
                 let mut buf = [UnpackedPixel::default(); 16];
                 Self::get_block8(&sstrip[x..], sstride, &mut buf, pal);
@@ -932,7 +932,7 @@ impl NAEncoder for MSVideo1Encoder {
             for (cur_pal, new_pal) in self.pal.iter_mut().zip(pal.chunks_exact(3)) {
                 let (cur_clr, luma) = cur_pal.split_at_mut(3);
                 let new_clr = [u16::from(new_pal[0]), u16::from(new_pal[1]), u16::from(new_pal[2])];
-                if cur_clr != &new_clr {
+                if cur_clr != new_clr {
                     pal_changed = true;
                     cur_clr.copy_from_slice(&new_clr);
                     luma[0] = rgb2y(cur_clr[0], cur_clr[1], cur_clr[2]);
index 2274a208b10b209403041f668b8f882a5f5d723a..7eec3c25fce9df7fc9277afaab0d1852b2f32468 100644 (file)
@@ -3,6 +3,7 @@ extern crate nihav_core;
 extern crate nihav_codec_support;
 
 #[allow(clippy::needless_range_loop)]
+#[allow(clippy::needless_late_init)]
 #[allow(clippy::single_match)]
 #[allow(clippy::verbose_bit_mask)]
 mod codecs;
index 214f7af697ae737012e2643f9c34e30c2d9f3750..d8cafa24910221c03e10c26da740e41403c3a83d 100644 (file)
@@ -359,7 +359,7 @@ unimplemented!();
                             }
                             q = q.wrapping_sub(self.grid_3_quant[ch][band - 4]);
                         }
-                        self.tone_idx[ch][band][i] = q as i8;
+                        self.tone_idx[ch][band][i] = q;
                         if q > 0 || (self.is_intra && q == 0) {
                             self.tone_scale[ch][band][i] = TONE_SCALES[0][(q & 0x3F) as usize];
                         } else {
index 601114091e47c39ca986aa7f8346760846d49d94..17ce03fb3a3d195498a284e9433f6ef2ce5406e5 100644 (file)
@@ -93,13 +93,13 @@ impl<'a, S: Copy> CodebookReader<S> for QdmBitReader<'a> {
         let mut idx = 0;
         let mut lut_bits = cb.lut_bits;
         while esc {
-            let lut_idx = (self.peek(lut_bits) as usize) + (idx as usize);
+            let lut_idx = (self.peek(lut_bits) as usize) + idx;
             if cb.table[lut_idx] == TABLE_FILL_VALUE { return Err(CodebookError::InvalidCode); }
             let bits = cb.table[lut_idx] & 0x7F;
             esc  = (cb.table[lut_idx] & 0x80) != 0;
             idx  = (cb.table[lut_idx] >> 8) as usize;
             let skip_bits = if esc { u32::from(lut_bits) } else { bits };
-            self.skip(skip_bits as u32);
+            self.skip(skip_bits);
             lut_bits = bits as u8;
         }
         Ok(cb.syms[idx])
index e0efd2614080a3db96ae5d654448fc931410a100..7eb1d8bc61e8dd41590dc56818297336ea151047 100644 (file)
@@ -25,7 +25,7 @@ impl RpzaDecoder {
     }
     fn put_block(dst: &mut [u16], dstride: usize, block: &[u16; 16]) {
         for (line, src) in dst.chunks_mut(dstride).take(4).zip(block.chunks(4)) {
-            (&mut line[..4]).copy_from_slice(src);
+            line[..4].copy_from_slice(src);
         }
     }
 }
index b53ca5cff3ec638769299196096251e1f636c809..7b01097fc931aa05379eac74eb4ed0c029b73aef 100644 (file)
@@ -26,7 +26,7 @@ impl SmcDecoder {
     }
     fn put_block(dst: &mut [u8], dstride: usize, block: &[u8; 16]) {
         for (line, src) in dst.chunks_mut(dstride).take(4).zip(block.chunks(4)) {
-            (&mut line[..4]).copy_from_slice(src);
+            line[..4].copy_from_slice(src);
         }
     }
     fn put_blocks(&self, dst: &mut [u8], stride: usize, doff: &mut usize, x: &mut usize, len: usize, block: &[u8; 16]) {
index 3852d6d5c22c95c79a36049dbfba6c972dd88c8d..1a87ca62200fd76958a8f8ba898789ef0f38a2c2 100644 (file)
@@ -261,7 +261,7 @@ fn decode_alt_slice(br: &mut BitReader, blk: &mut [i16; 16], mut idx: usize, end
                 SVQ3_RUNLEVEL_ALT[val as usize]
             } else {
                 let run = (val & 0x7) as usize;
-                (run, ((val >> 3) as i16) + RUN_ADD_ALT[(run as usize).min(RUN_ADD_ALT.len() - 1)])
+                (run, ((val >> 3) as i16) + RUN_ADD_ALT[run.min(RUN_ADD_ALT.len() - 1)])
             };
         idx += run;
         validate!(idx < end);
@@ -289,7 +289,7 @@ fn decode_block(br: &mut BitReader, blk: &mut [i16; 16], start: usize, alt: bool
                     SVQ3_RUNLEVEL[val as usize]
                 } else {
                     let run = (val & 0xF) as usize;
-                    (run, ((val >> 4) as i16) + RUN_ADD[(run as usize).min(RUN_ADD.len() - 1)])
+                    (run, ((val >> 4) as i16) + RUN_ADD[run.min(RUN_ADD.len() - 1)])
                 };
             idx += run;
             validate!(idx < blk.len());
@@ -674,7 +674,7 @@ unimplemented!();
             } else {
                 MCMode::Pixel
             };
-        let (bw, bh) = SVQ3_PART_SIZES[mb_type as usize];
+        let (bw, bh) = SVQ3_PART_SIZES[mb_type];
         let bw = (bw >> 2) as usize;
         let bh = (bh >> 2) as usize;
 
@@ -1167,9 +1167,7 @@ impl NADecoder for SVQ3Decoder {
             }
             let ret = self.decode_slice(&mut br, &hdr, &mut dframe);
             std::mem::swap(&mut sbuf, &mut self.slice_buf);
-            if let Err(err) = ret {
-                return Err(err);
-            }
+            ret?;
             slice_prepared = false;
             off += slice_len;
         }
index 2c2e792793713a7ff62caedb4f949b9999fa5956..59c415c3394ad83ee776ad46f028bcf301ed6b6e 100644 (file)
@@ -4,5 +4,8 @@ extern crate nihav_codec_support;
 
 #[allow(clippy::comparison_chain)]
 #[allow(clippy::single_match)]
+#[allow(clippy::field_reassign_with_default)]
+#[allow(clippy::upper_case_acronyms)]
+#[allow(clippy::collapsible_else_if)]
 mod codecs;
 pub use crate::codecs::qt_register_all_decoders;
index 039e4411830d5d07257ab7db99bec0f74cf4842a..7848e7e461035b685f42f8db1f0f91b318e3a201 100644 (file)
@@ -45,8 +45,8 @@ fn read_bink_float(br: &mut BitReader) -> DecoderResult<f32> {
         Ok(v)
     }*/
     let exp                                     = br.read(5)? as u8;
-    let mant                                    = br.read(23)? as u32;
-    let sign                                    = br.read(1)? as u32;
+    let mant                                    = br.read(23)?;
+    let sign                                    = br.read(1)?;
     let nexp = exp.wrapping_add(0x7E) as u32;
     let nmant = (mant << 1) & ((1 << 23) - 1);
     Ok(f32::from_bits((sign << 31) | (nexp << 23) | nmant))
index 65ab3cf0770e136ff6fe129495d4a5bb3e9d7d54..7a31486038674c6f40adba6bd43bbdf41a4142e4 100644 (file)
@@ -227,7 +227,7 @@ impl Bundle<u8> {
             last = col_hi[last as usize].read_sym(br, trees)?;
             let lo = self.tree.read_sym(br, trees)?;
             let val = Self::cvt_color(lo, last, new_bink);
-            for i in 0..len { self.data[self.dec_pos + i] = val as u8; }
+            for i in 0..len { self.data[self.dec_pos + i] = val; }
             self.dec_pos += len;
         } else {
             while self.dec_pos < end {
index c1b9fd6cae3270c49165960d10482f6c1573dc68..d834c7eea40ff17457f2c1dda64e1e26d3282824 100644 (file)
@@ -138,7 +138,7 @@ impl SmackerTree16 {
 
         let mut esc: [u32; 3] = [0; 3];
         for i in 0..esc.len() {
-            esc[i] = br.read(16)? as u32;
+            esc[i] = br.read(16)?;
         }
 
         let nsyms = (((size + 3) >> 2) + 4) as usize;
@@ -573,7 +573,7 @@ impl NADecoder for SmackerAudioDecoder {
                     let mut pred: [u8; 2] = [ pred1, pred0 ];
                     for ch in 0..2 { dst[ch] = pred[ch]; }
                     for i in 2..unp_size {
-                        let diff = br.read_tree8(&trees[i & 1])? as u8;
+                        let diff = br.read_tree8(&trees[i & 1])?;
                         pred[i & 1] = pred[i & 1].wrapping_add(diff);
                         dst[i] = pred[i & 1];
                     }
@@ -583,7 +583,7 @@ impl NADecoder for SmackerAudioDecoder {
                     let mut pred                = br.read(8)? as u8;
                     dst[0] = pred;
                     for i in 1..unp_size {
-                        let diff = br.read_tree8(&tree)? as u8;
+                        let diff = br.read_tree8(&tree)?;
                         pred = pred.wrapping_add(diff);
                         dst[i] = pred;
                     }
index fe64191399b5de6e33508b419a8c96fad26192b0..00724cf5b0c7be3b0a2d9ccaeebcc9e9ed396167 100644 (file)
@@ -252,11 +252,7 @@ impl<'a> DemuxCore<'a> for SmackerVideoDemuxer<'a> {
         Ok(pkt)
     }
     fn seek(&mut self, time: NATimePoint, _seek_idx: &SeekIndex) -> DemuxerResult<()> {
-        let seek_to_start = match time {
-                NATimePoint::Milliseconds(0) => true,
-                NATimePoint::PTS(0) => true,
-                _ => false,
-            };
+        let seek_to_start = matches!(time, NATimePoint::Milliseconds(0) | NATimePoint::PTS(0));
         if seek_to_start {
             let start = self.start;
             self.src.seek(SeekFrom::Start(start))?;
index d407fa7ae5894cc0ecedecc0e9bd8ce482ba12f1..f7bce33a9fee072d5824da2e4e245d7631778770 100644 (file)
@@ -5,12 +5,15 @@ extern crate nihav_codec_support;
 #[cfg(feature="decoders")]
 #[allow(clippy::cast_lossless)]
 #[allow(clippy::collapsible_if)]
+#[allow(clippy::collapsible_else_if)]
 #[allow(clippy::excessive_precision)]
 #[allow(clippy::identity_op)]
 #[allow(clippy::needless_range_loop)]
+#[allow(clippy::needless_late_init)]
 #[allow(clippy::too_many_arguments)]
 #[allow(clippy::unreadable_literal)]
 #[allow(clippy::useless_let_if_seq)]
+#[allow(clippy::upper_case_acronyms)]
 mod codecs;
 #[cfg(feature="decoders")]
 pub use crate::codecs::rad_register_all_decoders;
index 48bdb0a80cafd799ed7842180c1d83cb1cfac511..1afe246793f1a8c54450fd9013c98cb3aa7d7dbe 100644 (file)
@@ -292,7 +292,7 @@ impl CookChannelPair {
         for _ in 0..num_vectors {
             let idx = tcat[tcat_idx2];
             tcat_idx2 += 1;
-            self.category[idx] = (self.category[idx] + 1).min((NUM_CATEGORIES - 1) as u8) as u8;
+            self.category[idx] = (self.category[idx] + 1).min((NUM_CATEGORIES - 1) as u8);
         }
     }
     fn decode_channel_data(&mut self, dsp: &mut CookDSP, rnd: &mut RND, codebooks: &Codebooks, src: &[u8], buf: &mut [u8], channel: usize) -> DecoderResult<()> {
index f25df6beeb00f23790be5fbc953d8d0a3d77dc2e..333e91a08df53e81885425bd091eb12bf8b39173 100644 (file)
@@ -257,7 +257,7 @@ impl<'a> RealVideo20BR<'a> {
 
         let rl_cb = if sstate.is_iframe { &self.tables.aic_rl_cb } else { &self.tables.rl_cb };
         let q = if plane_no == 0 { (quant * 2) as i16 } else { (H263_CHROMA_QUANT[quant as usize] * 2) as i16 };
-        let q_add = if q == 0 || sstate.is_iframe { 0i16 } else { (((q >> 1) - 1) | 1) as i16 };
+        let q_add = if q == 0 || sstate.is_iframe { 0i16 } else { ((q >> 1) - 1) | 1 };
         while idx < 64 {
             let code = br.read_cb(rl_cb)?;
             let run;
@@ -593,7 +593,7 @@ impl RealVideo20Decoder {
             h:              0,
             minor_ver:      0,
             rpr:            RPRInfo { present: false, bits: 0, widths: [0; 8], heights: [0; 8] },
-            bdsp:           Box::new(RV20BlockDSP::default()),
+            bdsp:           Box::<RV20BlockDSP>::default(),
             base_ts:        0,
             last_ts:        0,
             next_ts:        0,
@@ -626,7 +626,7 @@ impl NADecoder for RealVideo20Decoder {
                 self.rpr.present = false;
             } else {
                 self.rpr.present = true;
-                self.rpr.bits    = ((rprb >> 1) + 1).min(3) as u8;
+                self.rpr.bits    = ((rprb >> 1) + 1).min(3);
                 let num_dim = ((src.len() - 8) / 2).min(self.rpr.widths.len() - 1);
                 for i in 0..num_dim {
                     self.rpr.widths [i] = (src[i * 2 + 8] as usize) * 4;
index bd0bacc926d3d214c72e012960751e619668f009..892b7ffad110fe67fe34f3eef946f86df8d92483 100644 (file)
@@ -432,7 +432,7 @@ impl CodeSets {
         }
     }
     pub fn init(&mut self, quant: usize, subset: usize) {
-        let mut idx = quant as usize;
+        let mut idx = quant;
         if (subset == 2) && (idx < 19) {
             idx += 10;
         } else if (subset != 0) && (idx < 26) {
index 9adecfb87933b3a99c3457531db8b2af7e652afd..071a7aecdf6fb7e668d5f854c78b3ec1d1572622 100644 (file)
@@ -631,7 +631,7 @@ impl RV40Encoder {
             }
 
             if self.debug_log.is_set(DEBUG_BIT_PSNR) {
-                let psnr = calc_psnr(&vbuf, &rvbuf);
+                let psnr = calc_psnr(vbuf, &rvbuf);
                 println!("  encoded frame PSNR {} size {}", psnr, dvec.len());
             }
 
@@ -675,7 +675,7 @@ fn calc_psnr(pic1: &NAVideoBuffer<u8>, pic2: &NAVideoBuffer<u8>) -> f64 {
         for (line1, line2) in data1[pic1.get_offset(comp)..].chunks(pic1.get_stride(comp)).zip(
                 data2[pic2.get_offset(comp)..].chunks(pic2.get_stride(comp))).take(h) {
             for (&pix1, &pix2) in line1[..w].iter().zip(line2.iter()) {
-                let diff = (i32::from(pix1) - i32::from(pix2)).abs() as u32;
+                let diff = (i32::from(pix1) - i32::from(pix2)).unsigned_abs();
                 sum += u64::from(diff * diff);
             }
         }
index 63d466391e0c9871be6534b79e86a74935098cd1..9fa18e9edc51343727d47e0095fc96ae698d4cf8 100644 (file)
@@ -3,10 +3,11 @@ use nihav_codec_support::codecs::{MV, ZERO_MV};
 use std::str::FromStr;
 use super::dsp::{RefMBData, luma_mc, chroma_mc};
 
-#[derive(Clone,Copy,PartialEq)]
+#[derive(Clone,Copy,PartialEq,Default)]
 pub enum MVSearchMode {
     Dummy,
     Diamond,
+    #[default]
     Hexagon,
     UMH,
 }
@@ -25,10 +26,6 @@ impl MVSearchMode {
     }
 }
 
-impl Default for MVSearchMode {
-    fn default() -> Self { MVSearchMode::Hexagon }
-}
-
 impl std::fmt::Display for MVSearchMode {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match *self {
@@ -878,7 +875,7 @@ impl FrameComplexityEstimate {
             hadamard!(diffs[i], diffs[i + 4], diffs[i + 8], diffs[i + 12],
                       diffs[i], diffs[i + 4], diffs[i + 8], diffs[i + 12]);
         }
-        diffs.iter().fold(0u32, |acc, x| acc + (x.abs() as u32))
+        diffs.iter().fold(0u32, |acc, x| acc + (x.unsigned_abs() as u32))
     }
     fn satd(src0: &[u8], src1: &[u8], stride: usize) -> u32 {
         let mut diffs = [0; 16];
@@ -894,7 +891,7 @@ impl FrameComplexityEstimate {
             hadamard!(diffs[i], diffs[i + 4], diffs[i + 8], diffs[i + 12],
                       diffs[i], diffs[i + 4], diffs[i + 8], diffs[i + 12]);
         }
-        diffs.iter().fold(0u32, |acc, x| acc + (x.abs() as u32))
+        diffs.iter().fold(0u32, |acc, x| acc + (x.unsigned_abs() as u32))
     }
     fn downscale(dst: &mut NAVideoBuffer<u8>, src: &NAVideoBuffer<u8>) {
         let dst = NASimpleVideoFrame::from_video_buf(dst).unwrap();
index 844e1abf611dcff59d8f1a84398c198300c7b37a..befe7a651cd4784e30242ca41054663406201f92 100644 (file)
@@ -233,22 +233,20 @@ const RV60_AVAIL_MASK: [u8; 64] = [
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 ];
 
-#[derive(Clone,Copy,PartialEq,Debug)]
+#[derive(Clone,Copy,PartialEq,Debug,Default)]
 enum CUType {
+    #[default]
     Intra,
     InterMV,
     Skip,
     InterNoMV,
 }
 
-impl Default for CUType {
-    fn default() -> Self { CUType::Intra }
-}
-
 const RV60_CU_TYPES: [CUType; 4] = [ CUType::Intra, CUType::InterMV, CUType::Skip, CUType::InterNoMV ];
 
-#[derive(Clone,Copy,PartialEq,Debug)]
+#[derive(Clone,Copy,PartialEq,Debug,Default)]
 enum PUType {
+    #[default]
     Full,
     N2Hor,
     N2Ver,
@@ -317,10 +315,6 @@ impl PUType {
     }
 }
 
-impl Default for PUType {
-    fn default() -> Self { PUType::Full }
-}
-
 #[derive(Clone,Copy,Debug)]
 enum IntraMode {
     Index(u8),
@@ -329,18 +323,15 @@ enum IntraMode {
     Plane64,
 }
 
-#[derive(Clone,Copy,PartialEq,Debug)]
+#[derive(Clone,Copy,PartialEq,Debug,Default)]
 enum TransformType {
+    #[default]
     None,
     T4X4,
     T8X8,
     T16X16,
 }
 
-impl Default for TransformType {
-    fn default() -> Self { TransformType::None }
-}
-
 #[derive(Clone,Copy,PartialEq,Debug)]
 enum MVRef {
     None,
@@ -1502,7 +1493,7 @@ impl NADecoder for RealVideo60Decoder {
         if hdr.deblock {
             self.dblk.reinit(hdr.awidth, hdr.aheight);
         }
-        let mut off = hsize + ((br.tell() >> 3) as usize);
+        let mut off = hsize + (br.tell() >> 3);
         let mut dframe = NASimpleVideoFrame::from_video_buf(&mut buf).unwrap();
         for (cu_y, size) in slices.into_iter().enumerate() {
             self.decode_cu_line(&mut dframe, &hdr, &src[off..][..size], cu_y)?;
index 8effbb57daf8af616324a2c277fca799c38238fc..390458c1174d36608e2300edd5087ba2ec5b82ac 100644 (file)
@@ -169,7 +169,7 @@ fn quant(val: i16, q: i16) -> i16 { (val * q + 8) >> 4 }
 
 fn decode_2x2_dc(br: &mut BitReader, cb: &Codebook<u16>, coeffs: &mut [i16], stride: usize, block2: bool, dsc: usize, q_dc: i16, q_ac: i16) -> DecoderResult<()> {
     if dsc == 0 { return Ok(()); }
-    let lx = RV60_DSC_TO_LX[dsc as usize];
+    let lx = RV60_DSC_TO_LX[dsc];
     let l0 = ((lx >>  0) & 0xFF) as i16;
     let l1 = ((lx >>  8) & 0xFF) as i16;
     let l2 = ((lx >> 16) & 0xFF) as i16;
@@ -187,7 +187,7 @@ fn decode_2x2_dc(br: &mut BitReader, cb: &Codebook<u16>, coeffs: &mut [i16], str
 }
 fn decode_2x2(br: &mut BitReader, cb: &Codebook<u16>, coeffs: &mut [i16], stride: usize, block2: bool, dsc: usize, q_ac: i16) -> DecoderResult<()> {
     if dsc == 0 { return Ok(()); }
-    let lx = RV60_DSC_TO_LX[dsc as usize];
+    let lx = RV60_DSC_TO_LX[dsc];
     let l0 = ((lx >>  0) & 0xFF) as i16;
     let l1 = ((lx >>  8) & 0xFF) as i16;
     let l2 = ((lx >> 16) & 0xFF) as i16;
index 6335c6d9b426730ef7c84d6e20621ad3b5c0faad..7f94cdcf25fa520484160bffb8f292bebc0316b8 100644 (file)
@@ -398,7 +398,7 @@ fn read_14or30(src: &mut ByteReader) -> DemuxerResult<(bool, u32)> {
 }
 
 fn read_video_buf(src: &mut ByteReader, stream: NAStreamRef, ts: u32, keyframe: bool, frame_size: usize) -> DemuxerResult<NAPacket> {
-    let size = (frame_size as usize) + 9;
+    let size = frame_size + 9;
     let mut vec: Vec<u8> = vec![0; size];
     //v[0] = 0; // 1 slice
     vec[4] = 1;
@@ -444,7 +444,7 @@ impl RMDemuxCommon {
             let soniton = NASoniton::new(samp_size as u8, SONITON_FLAG_SIGNED);
             let ahdr = NAAudioInfo::new(sample_rate, channels as u8, soniton, 1);
             let nainfo = NACodecInfo::new("ralf", NACodecTypeInfo::Audio(ahdr), extradata);
-            let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, nainfo, 1, 1000, u64::from(duration)));
+            let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no, nainfo, 1, 1000, u64::from(duration)));
             if res.is_none() { return Err(MemoryError); }
             let astr = RMAudioStream::new(None);
             str_data.streams.push(RMStreamType::Audio(astr));
@@ -530,7 +530,7 @@ println!("unknown MLTI substream {:08X} / {:08X}", tag, tag2);
             };
         let duration = if duration == 0 { ainfo.get_duration(1000) } else { u64::from(duration) };
         let nainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), extradata);
-        let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, nainfo, 1, 1000, duration));
+        let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no, nainfo, 1, 1000, duration));
         if res.is_none() { return Err(MemoryError); }
 
         let astr = RMAudioStream::new(ainfo.ileave_info);
@@ -563,7 +563,7 @@ println!("unknown MLTI substream {:08X} / {:08X}", tag, tag2);
 
         let vhdr = NAVideoInfo::new(width, height, false, RGB24_FORMAT);
         let vinfo = NACodecInfo::new(cname, NACodecTypeInfo::Video(vhdr), extradata);
-        let res = strmgr.add_stream(NAStream::new(StreamType::Video, stream_no as u32, vinfo, 1, 1000, u64::from(duration)));
+        let res = strmgr.add_stream(NAStream::new(StreamType::Video, stream_no, vinfo, 1, 1000, u64::from(duration)));
         if res.is_none() { return Err(DemuxerError::MemoryError); }
 
         let vstr = RMVideoStream::new();
@@ -571,6 +571,7 @@ println!("unknown MLTI substream {:08X} / {:08X}", tag, tag2);
         Ok(())
     }
 #[allow(unused_variables)]
+    #[allow(clippy::question_mark)]
     fn parse_packet_payload(src: &mut ByteReader, rmstream: &mut RMStreamType, stream: NAStreamRef, slice_buf: &mut Vec<u8>, queued_pkts: &mut Vec<NAPacket>, keyframe: bool, ts: u32, payload_size: usize) -> DemuxerResult<NAPacket> {
         match rmstream {
             RMStreamType::Video(ref mut vstr) => {
@@ -588,7 +589,7 @@ println!("unknown MLTI substream {:08X} / {:08X}", tag, tag2);
                                 let seq_no = src.read_byte()?;
                                 let hdr_skip = (src.tell() - pos) as usize;
 
-                                let slice_size = (payload_size - hdr_skip) as usize;
+                                let slice_size = payload_size - hdr_skip;
                                 slice_buf.resize(slice_size, 0);
                                 src.read_buf(slice_buf.as_mut_slice())?;
                                 if packet_num == 1 {
@@ -714,7 +715,7 @@ impl<'a> DemuxCore<'a> for RealMediaDemuxer<'a> {
 
             let payload_size = len - (hdr_size as usize);
 
-            let stream_id = self.str_data.get_stream_id(str_no as u32, pkt_grp);
+            let stream_id = self.str_data.get_stream_id(str_no, pkt_grp);
             let sr = self.str_data.find_stream(stream_id);
             if sr.is_none() {
                 self.src.read_skip(payload_size)?;
@@ -1502,7 +1503,7 @@ impl RecordDemuxer {
                         validate!(sr.is_some());
                         let str_no = self.start_str + (sr.unwrap() as u32);
                         let pkt_grp = ((flags >> 8) & 0xFF) as u16;
-                        let stream_id = str_data.get_stream_id(str_no as u32, pkt_grp);
+                        let stream_id = str_data.get_stream_id(str_no, pkt_grp);
                         let sr = str_data.find_stream(stream_id);
                         if sr.is_none() {
                             src.read_skip(payload_size)?;
index 9cacc2846ba00e4eb8acde3c41be0f8beacaf33b..a5083c0215970cd721deddf83b6058fa5cfe8810 100644 (file)
@@ -5,6 +5,7 @@ extern crate nihav_codec_support;
 #[cfg(any(feature="decoders", feature="encoders"))]
 #[allow(clippy::cast_lossless)]
 #[allow(clippy::collapsible_if)]
+#[allow(clippy::collapsible_else_if)]
 #[allow(clippy::comparison_chain)]
 #[allow(clippy::excessive_precision)]
 #[allow(clippy::identity_op)]
@@ -13,6 +14,10 @@ extern crate nihav_codec_support;
 #[allow(clippy::too_many_arguments)]
 #[allow(clippy::unreadable_literal)]
 #[allow(clippy::useless_let_if_seq)]
+#[allow(clippy::needless_late_init)]
+#[allow(clippy::upper_case_acronyms)]
+#[allow(clippy::manual_range_contains)]
+#[allow(clippy::wrong_self_convention)]
 mod codecs;
 #[cfg(feature="decoders")]
 pub use crate::codecs::realmedia_register_all_decoders;
@@ -24,6 +29,8 @@ pub use crate::codecs::realmedia_register_all_encoders;
 #[allow(clippy::too_many_arguments)]
 #[allow(clippy::unreadable_literal)]
 #[allow(clippy::useless_let_if_seq)]
+#[allow(clippy::needless_late_init)]
+#[allow(clippy::upper_case_acronyms)]
 mod demuxers;
 #[cfg(feature="demuxers")]
 pub use crate::demuxers::realmedia_register_all_demuxers;
index 0e174a2729099524613bfbedf210cb69e78aa012..bd8d34e4faea2e1db8c609281955189a4d327439 100644 (file)
@@ -57,11 +57,7 @@ impl Interleaver for NoInterleaver {
     fn get_packet(&mut self) -> Option<(Vec<u8>, bool)> {
         let mut ret = None;
         std::mem::swap(&mut self.pkt, &mut ret);
-        if let Some(pkt) = ret {
-            Some((pkt, true))
-        } else {
-            None
-        }
+        ret.map(|pkt| (pkt, true))
     }
     fn flush(&mut self) {}
 }
@@ -117,7 +113,7 @@ impl Interleaver for Int4Interleaver {
             return false;
         }
         let pos = self.map[self.cur_frame];
-        self.buf[pos * self.frame_size..][..self.frame_size].copy_from_slice(&src);
+        self.buf[pos * self.frame_size..][..self.frame_size].copy_from_slice(src);
         self.cur_frame += 1;
         true
     }
@@ -217,7 +213,7 @@ impl Interleaver for GenericInterleaver {
             return false;
         }
         let pos = self.map[self.cur_frame];
-        self.buf[pos * self.frame_size..][..self.frame_size].copy_from_slice(&src);
+        self.buf[pos * self.frame_size..][..self.frame_size].copy_from_slice(src);
         self.cur_frame += 1;
         true
     }
index 661e59a00ff9731761b837882c03e8750f59c4ef..1d08f4d0b83854f3562b3d53bd261d6b623a95c4 100644 (file)
@@ -89,7 +89,7 @@ impl RMStream {
         self.mdpr_pos = bw.tell();
 
         bw.write_chunk(b"MDPR", 0, 0)?;
-        bw.write_u16be(self.stream_id as u16)?;
+        bw.write_u16be(self.stream_id)?;
         bw.write_u32be(0)?; //max br
         bw.write_u32be(0)?; //avg br
         bw.write_u32be(0)?; //max ps
@@ -453,7 +453,7 @@ impl<'a> MuxCore<'a> for RAMuxer<'a> {
     }
     fn end(&mut self) -> MuxerResult<()> {
         if let Some(ref mut sw) = self.sw {
-            sw.finish(&mut self.bw)?;
+            sw.finish(self.bw)?;
         }
         Ok(())
     }
index b6ed1a794ef071b049a68084840360489447bae5..2d561e65063ae702b30f74349725708a6dc7abe2 100644 (file)
@@ -249,7 +249,7 @@ fn write_16_or_32(dst: &mut Vec<u8>, val: u32) {
 fn write_multiple_frame(dst: &mut Vec<u8>, frm: &VideoData) {
     dst.push(0xC0); // 0x3 = multiple frame
     write_16_or_32(dst, frm.data.len() as u32);
-    write_16_or_32(dst, frm.pts as u32);
+    write_16_or_32(dst, frm.pts);
     dst.push(frm.seq_no);
     dst.extend_from_slice(&frm.data);
 }
index c8d3b60ba26435b338e7a3955d3fc306b17d6b6c..7bfd172196294f5969dac6e0005cc4fcb0a36aee 100644 (file)
@@ -147,12 +147,7 @@ macro_rules! desc {
 
 /// Returns codec description for the provided codec short name if it is found.
 pub fn get_codec_description(name: &str) -> Option<&'static CodecDescription> {
-    for reg in CODEC_REGISTER {
-        if reg.name == name {
-            return Some(reg);
-        }
-    }
-    None
+    CODEC_REGISTER.iter().find(|&reg| reg.name == name)
 }
 
 static CODEC_REGISTER: &[CodecDescription] = &[
index da000426fe973007cc9f6beb043c3645326bfe6d..89d694d15df2e979888a998a7b4005cb055c0d29 100644 (file)
@@ -396,7 +396,7 @@ impl G7231Decoder {
         Self::inverse_quant(&self.prev_lsp, &mut cur_lsp, &self.lsp_index, bad_frame);
         Self::interpolate_lsp(&mut self.lpc, &cur_lsp, &self.prev_lsp);
         self.prev_lsp.copy_from_slice(&cur_lsp);
-        (&mut self.excitation[..MAX_PITCH]).copy_from_slice(&self.prev_excitation);
+        self.excitation[..MAX_PITCH].copy_from_slice(&self.prev_excitation);
         if self.erased_frames == 0 {
             let mut acb_vector = [0; SUBFRAME_LEN];
             self.interp_gain = FIXED_CB_GAIN[(self.subframe[2].amp_index + self.subframe[3].amp_index) >> 1];
@@ -562,15 +562,15 @@ impl G7231Decoder {
             }
         }
 
-        (&mut self.synth_buf[LPC_ORDER..][..MAX_PITCH]).copy_from_slice(&self.prev_excitation);
+        self.synth_buf[LPC_ORDER..][..MAX_PITCH].copy_from_slice(&self.prev_excitation);
         let mut acb_vec = [0; SUBFRAME_LEN];
         let mut tmp = [0; SUBFRAME_LEN * 2];
         for i in (0..SUBFRAMES).step_by(2) {
             let buf = &mut self.synth_buf[LPC_ORDER + SUBFRAME_LEN * i..];
             self.subframe[i].gen_acb_excitation(&mut acb_vec, buf, self.is_6300);
-            (&mut buf[..SUBFRAME_LEN]).copy_from_slice(&acb_vec);
+            buf[..SUBFRAME_LEN].copy_from_slice(&acb_vec);
             self.subframe[i + 1].gen_acb_excitation(&mut acb_vec, &buf[SUBFRAME_LEN..], self.is_6300);
-            (&mut buf[SUBFRAME_LEN..][..SUBFRAME_LEN]).copy_from_slice(&acb_vec);
+            buf[SUBFRAME_LEN..][..SUBFRAME_LEN].copy_from_slice(&acb_vec);
 
             let mut max = 0;
             for j in 0..SUBFRAME_LEN*2 {
@@ -783,9 +783,9 @@ impl G7231Decoder {
         }
     }
     fn formant_postfilter(&mut self, dst: &mut [i16]) {
-        (&mut self.synth_buf[..LPC_ORDER]).copy_from_slice(&self.fir_mem);
+        self.synth_buf[..LPC_ORDER].copy_from_slice(&self.fir_mem);
         let mut filter_data = [0; LPC_ORDER + SAMPLES];
-        (&mut filter_data[..LPC_ORDER]).copy_from_slice(&self.iir_mem);
+        filter_data[..LPC_ORDER].copy_from_slice(&self.iir_mem);
 
         let mut filter_coef = [[0; LPC_ORDER]; 2];
         for i in 0..SUBFRAMES {
@@ -945,7 +945,7 @@ impl NADecoder for G7231Decoder {
             self.synth_frame_other();
         }
         self.prev_ftype = self.cur_ftype;
-        (&mut self.synth_buf[..LPC_ORDER]).copy_from_slice(&self.filt_mem);
+        self.synth_buf[..LPC_ORDER].copy_from_slice(&self.filt_mem);
         for i in 0..SUBFRAMES {
             Self::do_lpc(&mut self.synth_buf, LPC_ORDER + i * SUBFRAME_LEN, &self.lpc[i]);
         }
index b5fdfad67f80091af4f6cd4ddede8d242f9dc2a4..469babee5ef06467aa251454ae9d0ce6aecca6d0 100644 (file)
@@ -2,6 +2,8 @@
 extern crate nihav_core;
 extern crate nihav_codec_support;
 
+#[allow(clippy::upper_case_acronyms)]
+#[allow(clippy::needless_late_init)]
 mod codecs;
 mod demuxers;