]> git.nihav.org Git - nihav.git/commitdiff
fix clippy warnings for update to rustc 1.46
authorKostya Shishkov <kostya.shishkov@gmail.com>
Sun, 4 Apr 2021 08:06:18 +0000 (10:06 +0200)
committerKostya Shishkov <kostya.shishkov@gmail.com>
Sun, 4 Apr 2021 08:06:18 +0000 (10:06 +0200)
66 files changed:
nihav-codec-support/src/codecs/h263/code.rs
nihav-codec-support/src/codecs/h263/decoder.rs
nihav-codec-support/src/vq/generic_elbg.rs
nihav-commonfmt/src/codecs/aac.rs
nihav-commonfmt/src/codecs/mod.rs
nihav-commonfmt/src/codecs/ts102366.rs
nihav-commonfmt/src/demuxers/mov.rs
nihav-core/src/compr/deflate.rs
nihav-core/src/demuxers/mod.rs
nihav-core/src/formats.rs
nihav-core/src/frame.rs
nihav-core/src/scale/palette/elbg.rs
nihav-core/src/scale/palette/neuquant.rs
nihav-core/src/scale/scale.rs
nihav-duck/src/codecs/mod.rs
nihav-duck/src/codecs/on2avc.rs
nihav-duck/src/codecs/truemotion2x.rs
nihav-duck/src/codecs/vp3.rs
nihav-duck/src/codecs/vp56.rs
nihav-duck/src/codecs/vp6.rs
nihav-duck/src/codecs/vp7.rs
nihav-duck/src/lib.rs
nihav-game/src/codecs/mod.rs
nihav-game/src/codecs/vmd.rs
nihav-indeo/src/codecs/imc.rs
nihav-indeo/src/codecs/indeo3.rs
nihav-indeo/src/codecs/indeo5.rs
nihav-indeo/src/codecs/intel263.rs
nihav-indeo/src/codecs/ivibr.rs
nihav-indeo/src/codecs/mod.rs
nihav-itu/src/codecs/h264/cabac.rs
nihav-itu/src/codecs/h264/cavlc.rs
nihav-itu/src/codecs/h264/mod.rs
nihav-itu/src/codecs/h264/pic_ref.rs
nihav-itu/src/codecs/h264/sets.rs
nihav-itu/src/codecs/h264/slice.rs
nihav-itu/src/codecs/mod.rs
nihav-itu/src/lib.rs
nihav-llaudio/src/codecs/mod.rs
nihav-llaudio/src/codecs/wavpack.rs
nihav-llaudio/src/lib.rs
nihav-ms/src/codecs/mod.rs
nihav-ms/src/codecs/msadpcm.rs
nihav-qt/src/codecs/mod.rs
nihav-qt/src/codecs/qdm2qmf.rs
nihav-qt/src/codecs/smc.rs
nihav-qt/src/codecs/svq3.rs
nihav-qt/src/lib.rs
nihav-rad/src/codecs/bink2.rs
nihav-rad/src/codecs/binkvid.rs
nihav-rad/src/codecs/mod.rs
nihav-rad/src/demuxers/bink.rs
nihav-rad/src/lib.rs
nihav-realmedia/src/codecs/mod.rs
nihav-realmedia/src/codecs/rv20.rs
nihav-realmedia/src/codecs/rv3040.rs
nihav-realmedia/src/codecs/rv30dsp.rs
nihav-realmedia/src/codecs/rv40dsp.rs
nihav-realmedia/src/codecs/rv60.rs
nihav-realmedia/src/codecs/rv60codes.rs
nihav-realmedia/src/codecs/rv60dsp.rs
nihav-realmedia/src/demuxers/realmedia.rs
nihav-realmedia/src/lib.rs
nihav-registry/src/register.rs
nihav-vivo/src/codecs/mod.rs
nihav-vivo/src/codecs/vivo.rs

index 4d24ec36f5e1199bee2c37ffbafc0422b9213b9f..cbeb12042fad4946a79d04ce14f238ec6da0de1c 100644 (file)
@@ -600,7 +600,7 @@ impl BlockDSP for H263BlockDSP {
 
         blockdsp::copy_block(&mut dst, src.clone(), 0, xpos, ypos, mv.x >> 1, mv.y >> 1, 16, 16, 0, 1, mode, H263_INTERP_FUNCS);
         blockdsp::copy_block(&mut dst, src.clone(), 1, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_FUNCS);
-        blockdsp::copy_block(&mut dst, src.clone(), 2, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_FUNCS);
+        blockdsp::copy_block(&mut dst, src,         2, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_FUNCS);
     }
     fn copy_blocks8x8(&self, dst: &mut NAVideoBuffer<u8>, src: NAVideoBufferRef<u8>, xpos: usize, ypos: usize, mvs: &[MV; 4]) {
         let mut dst = NASimpleVideoFrame::from_video_buf(dst).unwrap();
@@ -629,7 +629,7 @@ impl BlockDSP for H263BlockDSP {
 
         blockdsp::copy_block(&mut dst, src.clone(), 0, xpos, ypos, mv.x >> 1, mv.y >> 1, 16, 16, 0, 1, mode, H263_INTERP_AVG_FUNCS);
         blockdsp::copy_block(&mut dst, src.clone(), 1, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_AVG_FUNCS);
-        blockdsp::copy_block(&mut dst, src.clone(), 2, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_AVG_FUNCS);
+        blockdsp::copy_block(&mut dst, src,         2, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_AVG_FUNCS);
     }
     fn avg_blocks8x8(&self, dst: &mut NAVideoBuffer<u8>, src: NAVideoBufferRef<u8>, xpos: usize, ypos: usize, mvs: &[MV; 4]) {
         let mut dst = NASimpleVideoFrame::from_video_buf(dst).unwrap();
index 6be437bd084e17906fcf238ee0f5018285251540..e1af173bca458a8d052f4b1479c121c070d492e7 100644 (file)
@@ -287,6 +287,7 @@ impl H263BaseDecoder {
         }
         Ok(())
     }
+    #[allow(clippy::comparison_chain)]
     fn decode_intra_mb_pred_quant(&mut self, bd: &mut dyn BlockDecoder, bdsp: &dyn BlockDSP, mb_pos: usize, binfo: &BlockInfo, sstate: &SliceState, apply_acpred: bool) -> DecoderResult<()> {
         for i in 0..6 {
             bd.decode_block_intra(&binfo, &sstate, binfo.get_q(), i, (binfo.cbp & (1 << (5 - i))) != 0, &mut self.blk[i])?;
@@ -410,7 +411,7 @@ impl H263BaseDecoder {
             bi.mv_f[blk_no]
         }
     }
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     fn reconstruct_obmc(&mut self, buf: &mut NAVideoBuffer<u8>, slice_start: usize, start: usize, end: usize, slice_end: bool) -> usize {
         let mut mb_x = start % self.mb_w;
         let mut mb_y = start / self.mb_w;
@@ -514,7 +515,7 @@ impl H263BaseDecoder {
         }
         mb_pos
     }
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     pub fn parse_frame(&mut self, bd: &mut dyn BlockDecoder, bdsp: &dyn BlockDSP) -> DecoderResult<NABufferType> {
         let pinfo = bd.decode_pichdr()?;
         let mut mvi = MVInfo::new();
index 87ea16e90560935816658f9ac5d9c29ddf770886..32cbb82c790ab9a29ba003f29603a3392622fe46 100644 (file)
@@ -148,7 +148,7 @@ impl<T: VQElement+Default, TS: VQElementSum<T>> ELBG<T, TS> {
         clu1.calc_dist();
         clu0.dist + clu1.dist
     }
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     pub fn quantise(&mut self, src: &[T], dst: &mut [T]) -> usize {
         if src.is_empty() || dst.len() != self.clusters.len() {
             return 0;
index 09a5b6b1dd582e90600e1b6ae16715ccfbf7f9f3..59cda6290b8166b219e32fc26fd52a30c83f2247 100644 (file)
@@ -558,7 +558,7 @@ impl Codebooks {
         let scale_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
         let mut spec_cb: [Codebook<u16>; 11];
         unsafe {
-            spec_cb = mem::uninitialized();
+            spec_cb = mem::MaybeUninit::uninit().assume_init();
             for i in 0..AAC_SPEC_CODES.len() {
                 let mut coderead = TableCodebookDescReader::new(AAC_SPEC_CODES[i], AAC_SPEC_BITS[i], cb_map);
                 ptr::write(&mut spec_cb[i], Codebook::new(&mut coderead, CodebookMode::MSB).unwrap());
@@ -1015,7 +1015,7 @@ impl DSP {
             tmp: [0.0; 2048], ew_buf: [0.0; 1152],
         }
     }
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     fn synth(&mut self, coeffs: &[f32; 1024], delay: &mut [f32; 1024], seq: u8, window_shape: bool, prev_window_shape: bool, dst: &mut [f32]) {
         let long_win  = if window_shape { &self.kbd_long_win  } else { &self.sine_long_win };
         let short_win = if window_shape { &self.kbd_short_win } else { &self.sine_short_win };
index 643e73caaaa8f39be1ec7157d8c535f887df267b..054836e99ee6ab20c6a4bb0520bde6fbdc0138eb 100644 (file)
@@ -54,7 +54,7 @@ const DECODERS: &[DecoderInfo] = &[
 /// Registers all available codecs provided by this crate.
 pub fn generic_register_all_decoders(rd: &mut RegisteredDecoders) {
     for decoder in DECODERS.iter() {
-        rd.add_decoder(decoder.clone());
+        rd.add_decoder(*decoder);
     }
 }
 
@@ -72,7 +72,7 @@ const ENCODERS: &[EncoderInfo] = &[
 /// Registers all available encoders provided by this crate.
 pub fn generic_register_all_encoders(re: &mut RegisteredEncoders) {
     for encoder in ENCODERS.iter() {
-        re.add_encoder(encoder.clone());
+        re.add_encoder(*encoder);
     }
 }
 
index c4b18004169c0827f8a6c9828471d60d9ac378b6..de6a5adb391c0446d745280cfa29f30c4e7bbfa5 100644 (file)
@@ -831,7 +831,7 @@ impl AudioBlock {
             bap_buf_fill:   [0; 3],
         }
     }
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     fn read(&mut self, br: &mut BitReader, bsi: &BSI, fscod: usize, blk_no: usize) -> DecoderResult<bool> {
         let channels = bsi.acmod.get_num_channels();
         let is_stereo = bsi.acmod == ACMode::Stereo;
index 9a77496fc2717e70ba563b2756adacd18ae65ba6..8b9526fa828e6337c2803e858199a1fe4539ddac 100644 (file)
@@ -1077,7 +1077,7 @@ impl TimeSearcher {
     fn reset(&mut self) {
         *self = Self::default();
     }
-    fn map_time(&mut self, sample: u32, tts: &Vec<(u32, u32)>) -> u64 {
+    fn map_time(&mut self, sample: u32, tts: &[(u32, u32)]) -> u64 {
         if tts.is_empty() {
             u64::from(sample)
         } else if sample >= self.sbase {
@@ -1363,6 +1363,7 @@ impl Track {
             self.bsize
         }
     }
+    #[allow(clippy::collapsible_if)]
     fn seek(&mut self, pts: u64, tpoint: NATimePoint) -> DemuxerResult<()> {
         self.cur_sample = pts as usize;
         self.samples_left = 0;
@@ -1604,6 +1605,7 @@ const DEMUXER_OPTIONS: &[NAOptionDefinition] = &[
 
 impl<'a> NAOptionHandler for MOVDemuxer<'a> {
     fn get_supported_options(&self) -> &[NAOptionDefinition] { DEMUXER_OPTIONS }
+    #[allow(clippy::single_match)]
     fn set_options(&mut self, options: &[NAOption]) {
         for option in options.iter() {
             for opt_def in DEMUXER_OPTIONS.iter() {
index d16230675bfb96de3aa40e4027a665e7099843f2..3462a4034996445255b9ad0f93f79671fae12e9e 100644 (file)
@@ -359,6 +359,7 @@ impl Inflate {
     ///!
     ///! [`DecompressError::ShortData`]: ../enum.DecompressError.html#variant.ShortData
     ///! [`DecompressError::OutputFull`]: ../enum.DecompressError.html#variant.OutputFull
+    #[allow(clippy::comparison_chain)]
     pub fn decompress_data(&mut self, src: &[u8], dst: &mut [u8], continue_block: bool) -> DecompressResult<usize> {
         if src.is_empty() || dst.is_empty() {
             return Err(DecompressError::InvalidArgument);
index dfcd11836e0e7d6dcba1c396ec254ab5a150a5f9..9c7e46e1f8cdc99db2c411acfe6614382092fd56 100644 (file)
@@ -291,11 +291,11 @@ impl SeekIndex {
     pub fn new() -> Self { Self::default() }
     pub fn add_stream(&mut self, id: u32) -> usize {
         let ret = self.stream_id_to_index(id);
-        if ret.is_none() {
+        if let Some(res) = ret {
+            res
+        } else {
             self.seek_info.push(StreamSeekInfo::new(id));
             self.seek_info.len() - 1
-        } else {
-            ret.unwrap()
         }
     }
     /// Adds a new stream to the index.
index 3501cb065ae8b8f85afd104c0598bffc1c55129c..713a3e5662b3e30fb342569a2f5e047ee3f59eac 100644 (file)
@@ -428,8 +428,8 @@ impl ColorModel {
 impl fmt::Display for ColorModel {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let name = match *self {
-            ColorModel::RGB(fmt) => format!("RGB({})", fmt).to_string(),
-            ColorModel::YUV(fmt) => format!("YUV({})", fmt).to_string(),
+            ColorModel::RGB(fmt) => format!("RGB({})", fmt),
+            ColorModel::YUV(fmt) => format!("YUV({})", fmt),
             ColorModel::CMYK     => "CMYK".to_string(),
             ColorModel::HSV      => "HSV".to_string(),
             ColorModel::LAB      => "LAB".to_string(),
@@ -710,7 +710,7 @@ impl NAPixelFormaton {
         }
         ssamp
     }
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     /// Returns a short string description of the format if possible.
     pub fn to_short_string(&self) -> Option<String> {
         match self.model {
@@ -1078,6 +1078,7 @@ fn parse_yuv_format(s: &str) -> Result<NAPixelFormaton, FormatParseError> {
 impl FromStr for NAPixelFormaton {
     type Err = FormatParseError;
 
+    #[allow(clippy::single_match)]
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
             "pal8" => return Ok(PAL8_FORMAT),
index 5ddec1adbba0d247c323df82ce8e5e20c34a4e1b..0fcdbcaa7526845f74ced9303431f7872d50e1c5 100644 (file)
@@ -693,7 +693,7 @@ pub fn alloc_data_buffer(size: usize) -> Result<NABufferType, AllocatorError> {
 }
 
 /// Creates a clone of current buffer.
-pub fn copy_buffer(buf: NABufferType) -> NABufferType {
+pub fn copy_buffer(buf: &NABufferType) -> NABufferType {
     buf.clone()
 }
 
@@ -937,6 +937,7 @@ impl NATimeInfo {
     pub fn set_duration(&mut self, dur: Option<u64>) { self.duration = dur; }
 
     /// Converts time in given scale into timestamp in given base.
+    #[allow(clippy::collapsible_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);
@@ -1300,6 +1301,7 @@ pub struct NAStream {
 pub type NAStreamRef = Arc<NAStream>;
 
 /// Downscales the timebase by its greatest common denominator.
+#[allow(clippy::comparison_chain)]
 pub fn reduce_timebase(tb_num: u32, tb_den: u32) -> (u32, u32) {
     if tb_num == 0 { return (tb_num, tb_den); }
     if (tb_den % tb_num) == 0 { return (1, tb_den / tb_num); }
index 8b67a513fdc84797b33aa103d6a57f9d7bde4a04..a9704f9cb165987fbedcf7f1421c8f9bd9a6f1c9 100644 (file)
@@ -195,7 +195,7 @@ impl ELBG {
         clu1.calc_dist();
         clu0.dist + clu1.dist
     }
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     pub fn quantise(&mut self, src: &[Pixel], dst: &mut [[u8; 3]; 256]) {
         if src.len() < 3 {
             return;
index 73d2a3acbd58134bdd4de9e20d83c6cad2bdee40..09745000150c19c2c2a20e65cbdd365040f9e7f8 100644 (file)
@@ -52,6 +52,7 @@ impl NeuQuantQuantiser {
             }
         }
     }
+    #[allow(clippy::float_cmp)]
     fn find_node(&mut self, clr: &[f64; 3]) -> usize {
         for i in 0..SPECIAL_NODES {
             if &self.weights[i] == clr {
index eb8ff6cc2cf6f75dc0203ae5730f0a3c29175155..fc97bd78e97230926f69255b034c60a597031c07 100644 (file)
@@ -7,6 +7,7 @@ impl NNResampler {
     fn new() -> Self { Self{} }
 }
 
+#[allow(clippy::comparison_chain)]
 fn scale_line<T:Copy>(src: &[T], dst: &mut [T], src_w: usize, dst_w: usize) {
     if src_w == dst_w {
         (&mut dst[..dst_w]).copy_from_slice(&src[..dst_w]);
index bfdd44ed705f34a50a57d6875acc2b897a15140a..da702b4649d327e3185d89a6e1428b496bfb8593 100644 (file)
@@ -93,6 +93,6 @@ const DUCK_CODECS: &[DecoderInfo] = &[
 /// Registers all available codecs provided by this crate.
 pub fn duck_register_all_decoders(rd: &mut RegisteredDecoders) {
     for decoder in DUCK_CODECS.iter() {
-        rd.add_decoder(decoder.clone());
+        rd.add_decoder(*decoder);
     }
 }
index 17f2d5ec75e760e1649628df9047fcefdbaff36b..1e3a1220f72e8be914d78dd20873708a5da85b52 100644 (file)
@@ -346,7 +346,7 @@ impl AVCDecoder {
         }
         Ok(())
     }
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     fn synth_channel(&mut self, chno: usize, dst: &mut [f32]) {
         let coeffs = &mut self.coeffs[chno];
         let delay  = &mut self.delay[chno];
index 7f4ac524062903d4129f13ea9405faeaeb66437c..652b5b06147b9741240f2661d429660bae08a13e 100644 (file)
@@ -277,7 +277,7 @@ impl TM2XDecoder {
 
     #[allow(clippy::int_plus_one)]
     #[allow(clippy::manual_memcpy)]
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     fn decode_frame(&mut self, src: &[u8]) -> DecoderResult<()> {
         let mut mr = MemoryReader::new_read(src);
         let mut br = ByteReader::new(&mut mr);
index 9d5693622ac95304c5ab9787c613da1499fd6b1d..3507fdb67d767c5f1928865ffb510b5d9c458af8 100644 (file)
@@ -38,9 +38,9 @@ impl VP30Codes {
         let mut cr = TableCodebookDescReader::new(&VP30_MBTYPE_CODES, &VP30_MBTYPE_BITS, map_mbt);
         let mbtype_cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
         unsafe {
-            dc_cb = mem::uninitialized();
-            ac_i_cb = mem::uninitialized();
-            ac_p_cb = mem::uninitialized();
+            dc_cb = mem::MaybeUninit::uninit().assume_init();
+            ac_i_cb = mem::MaybeUninit::uninit().assume_init();
+            ac_p_cb = mem::MaybeUninit::uninit().assume_init();
             for i in 0..5 {
                 let mut cr = TableCodebookDescReader::new(&VP30_DC_CODES[i], &VP30_DC_BITS[i], map_idx);
                 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
@@ -73,11 +73,11 @@ impl VP31Codes {
         let mut ac2_cb: [Codebook<u8>; 16];
         let mut ac3_cb: [Codebook<u8>; 16];
         unsafe {
-            dc_cb = mem::uninitialized();
-            ac0_cb = mem::uninitialized();
-            ac1_cb = mem::uninitialized();
-            ac2_cb = mem::uninitialized();
-            ac3_cb = mem::uninitialized();
+            dc_cb = mem::MaybeUninit::uninit().assume_init();
+            ac0_cb = mem::MaybeUninit::uninit().assume_init();
+            ac1_cb = mem::MaybeUninit::uninit().assume_init();
+            ac2_cb = mem::MaybeUninit::uninit().assume_init();
+            ac3_cb = mem::MaybeUninit::uninit().assume_init();
             for i in 0..16 {
                 let mut cr = TableCodebookDescReader::new(&VP31_DC_CODES[i], &VP31_DC_BITS[i], map_idx);
                 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
@@ -106,11 +106,11 @@ impl VP31Codes {
         let mut ac2_cb: [Codebook<u8>; 16];
         let mut ac3_cb: [Codebook<u8>; 16];
         unsafe {
-            dc_cb = mem::uninitialized();
-            ac0_cb = mem::uninitialized();
-            ac1_cb = mem::uninitialized();
-            ac2_cb = mem::uninitialized();
-            ac3_cb = mem::uninitialized();
+            dc_cb = mem::MaybeUninit::uninit().assume_init();
+            ac0_cb = mem::MaybeUninit::uninit().assume_init();
+            ac1_cb = mem::MaybeUninit::uninit().assume_init();
+            ac2_cb = mem::MaybeUninit::uninit().assume_init();
+            ac3_cb = mem::MaybeUninit::uninit().assume_init();
             for i in 0..16 {
                 let mut cr = TableCodebookDescReader::new(&VP40_DC_CODES[i], &VP40_DC_BITS[i], map_idx);
                 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
@@ -149,8 +149,8 @@ impl VP40AuxCodes {
         let mut mv_x_cb: [Codebook<i8>; 7];
         let mut mv_y_cb: [Codebook<i8>; 7];
         unsafe {
-            mv_x_cb = mem::uninitialized();
-            mv_y_cb = mem::uninitialized();
+            mv_x_cb = mem::MaybeUninit::uninit().assume_init();
+            mv_y_cb = mem::MaybeUninit::uninit().assume_init();
             for i in 0..7 {
                 let mut cr = TableCodebookDescReader::new(&VP40_MV_X_CODES[i], &VP40_MV_X_BITS[i], map_mv);
                 let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
@@ -1553,7 +1553,7 @@ impl VP34Decoder {
             }
         }
     }
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     fn output_blocks_inter(&mut self, frm: &mut NASimpleVideoFrame<u8>) {
         let mut blk_idx = 0;
         let bstride = self.mb_w * 2;
index b8cad1722aea16590e2f51791568df1d9689d27a..797ff910a9c84780841de05027743fffca521b8a 100644 (file)
@@ -751,7 +751,7 @@ impl VP56Decoder {
         }
         Ok(self.last_mbt)
     }
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     fn decode_mb(&mut self, frm: &mut NASimpleVideoFrame<u8>, bc: &mut BoolCoder, cr: &mut CoeffReader, br: &mut dyn VP56Parser, hdr: &VP56Header, alpha: bool) -> DecoderResult<()> {
         const FOURMV_SUB_TYPE: [VPMBType; 4] = [ VPMBType::InterNoMV, VPMBType::InterMV, VPMBType::InterNearest, VPMBType::InterNear ];
 
@@ -946,7 +946,7 @@ impl VP56Decoder {
             let x = self.fstate.mb_x * 8;
             let y = self.fstate.mb_y * 8;
             br.mc_block(frm, self.mc_buf.clone(), src.clone(), 1, x, y, mv, self.loop_thr);
-            br.mc_block(frm, self.mc_buf.clone(), src.clone(), 2, x, y, mv, self.loop_thr);
+            br.mc_block(frm, self.mc_buf.clone(), src,         2, x, y, mv, self.loop_thr);
         }
     }
     fn do_fourmv(&mut self, br: &dyn VP56Parser, frm: &mut NASimpleVideoFrame<u8>, mvs: &[MV; 4], alpha: bool) {
@@ -965,7 +965,7 @@ impl VP56Decoder {
             let sum = mvs[0] + mvs[1] + mvs[2] + mvs[3];
             let mv = MV { x: sum.x / 4, y: sum.y / 4 };
             br.mc_block(frm, self.mc_buf.clone(), src.clone(), 1, x, y, mv, self.loop_thr);
-            br.mc_block(frm, self.mc_buf.clone(), src.clone(), 2, x, y, mv, self.loop_thr);
+            br.mc_block(frm, self.mc_buf.clone(), src,         2, x, y, mv, self.loop_thr);
         }
     }
     fn predict_dc(&mut self, mb_type: VPMBType, _mb_pos: usize, blk_no: usize, _alpha: bool) {
index 3dda67be9ea8f9b7171654d498c538ad510127cf..ca8946f5ad4d7032259c499c05dd875d3305b547 100644 (file)
@@ -361,7 +361,7 @@ impl VP56Parser for VP6BR {
                 (mv.x >> 3, mv.y >> 3, mv.x & 7, mv.y & 7, mv.x / 8, mv.y / 8)
             };
         let tmp_blk = mc_buf.get_data_mut().unwrap();
-        get_block(tmp_blk, 16, src.clone(), plane, x, y, sx, sy);
+        get_block(tmp_blk, 16, src, plane, x, y, sx, sy);
         if (msx & 7) != 0 {
             let foff = (8 - (sx & 7)) as usize;
             let off = 2 + foff;
index 9243f93456de6512340f781e4391c0235c74fee6..b46cbad31c0264b32dc410f12b8ec97e5a7b7f36 100644 (file)
@@ -1010,12 +1010,12 @@ impl VP7Decoder {
 
             if pitch_smode == 0 {
                 mc_block8x8(dst, uoff, ustride, mb_x * 8, mb_y * 8, chroma_mv.x, chroma_mv.y, refframe.clone(), 1, &mut mc_buf);
-                mc_block8x8(dst, voff, vstride, mb_x * 8, mb_y * 8, chroma_mv.x, chroma_mv.y, refframe.clone(), 2, &mut mc_buf);
+                mc_block8x8(dst, voff, vstride, mb_x * 8, mb_y * 8, chroma_mv.x, chroma_mv.y, refframe,         2, &mut mc_buf);
             } else {
                 mc_block_special(dst, uoff, ustride, mb_x * 8, mb_y * 8, chroma_mv.x, chroma_mv.y,
                                  refframe.clone(), 1, &mut mc_buf, 8, pitch_smode);
                 mc_block_special(dst, voff, vstride, mb_x * 8, mb_y * 8, chroma_mv.x, chroma_mv.y,
-                                 refframe.clone(), 2, &mut mc_buf, 8, pitch_smode);
+                                 refframe,         2, &mut mc_buf, 8, pitch_smode);
             }
         } else {
             for y in 0..2 {
@@ -1137,7 +1137,7 @@ impl NADecoder for VP7Decoder {
             Err(DecoderError::InvalidData)
         }
     }
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     fn decode(&mut self, supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
         let src = pkt.get_buffer();
 
index b0dae19c227bd857bbf47ad97b26cd552921a683..366a2dbf1e2b101deb492d42e76d524986e235b0 100644 (file)
@@ -2,6 +2,7 @@ extern crate nihav_core;
 extern crate nihav_codec_support;
 
 #[allow(clippy::collapsible_if)]
+#[allow(clippy::comparison_chain)]
 #[allow(clippy::excessive_precision)]
 #[allow(clippy::identity_op)]
 #[allow(clippy::unreadable_literal)]
index fb30a05fd8eadb5b5cf1d5e1b65fcf0aac114fbe..3caa51c1ba232db68c5923e71c85e6b8c00ef49b 100644 (file)
@@ -65,6 +65,6 @@ const GAME_CODECS: &[DecoderInfo] = &[
 /// Registers all available codecs provided by this crate.
 pub fn game_register_all_decoders(rd: &mut RegisteredDecoders) {
     for decoder in GAME_CODECS.iter() {
-        rd.add_decoder(decoder.clone());
+        rd.add_decoder(*decoder);
     }
 }
index 40d8c5e9b8413ac37eecaafb9c9c12aa4aecb4e4..e05899de67f2e4fe93feadcfa7825538e3021cb3 100644 (file)
@@ -488,7 +488,7 @@ impl NADecoder for VMDAudioDecoder {
         }
     }
     #[allow(clippy::identity_op)]
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
         let info = pkt.get_stream().get_info();
         if let NACodecTypeInfo::Audio(_) = info.get_properties() {
index ea84d0ab01977f91285045264d60488f5df197d7..cb89b8ee403d198460080715a0f5c204aa411679 100644 (file)
@@ -103,7 +103,7 @@ impl BitAlloc {
             self.skip_flag[i]       = false;
         }
     }
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     fn calculate_bit_allocation(&mut self, ch_data: &mut IMCChannel, bits: usize, fixed_head: bool, adj_idx: usize) -> DecoderResult<()> {
 
         let mut peak = 0.0;
@@ -360,7 +360,7 @@ impl IMCDecoder {
             weights2.copy_from_slice(&IMC_WEIGHTS2);
         }
         unsafe {
-            codes = mem::uninitialized();
+            codes = mem::MaybeUninit::uninit().assume_init();
             for i in 0..4 {
                 for j in 0..4 {
                     let mut cr = IMCCodeReader::new(i, j);
index cc3bed877c9cf6dd6863960bb0f3fdad7e0edb53..4048385a50df2e45febce3ee0ac08f58757e11f6 100644 (file)
@@ -325,7 +325,7 @@ impl Indeo3Decoder {
         Ok((self.bbuf >> self.bpos) & 0x3)
     }
 
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     fn decode_cell_data(&mut self, br: &mut ByteReader, cell: IV3Cell,
                         off: usize, stride: usize, params: CellDecParams, vq_idx: u8) -> DecoderResult<()> {
         let blk_w = cell.w * 4 / params.bw;
index 3527906e2839fc0c643cbb87f82a47f633f2ee48..eb0b40c577217baa2dc0a4a245c2bfe28a32ad36 100644 (file)
@@ -265,7 +265,7 @@ impl IndeoXParser for Indeo5Parser {
         Ok(BandHeader::new(plane_no, band_no, self.mb_size[band_id], self.blk_size[band_id], self.is_hpel[band_id], inherit_mv, has_qdelta, inherit_qd, band_q, rvmap_idx, num_corr, corr_map, blk_cb, tr, txtype))
     }
 
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     fn decode_mb_info(&mut self, br: &mut BitReader, pic_hdr: &PictureHeader, band: &BandHeader, tile: &mut IVITile, ref_tile: Option<&IVITile>, mv_scale: u8) -> DecoderResult<()> {
         let mut mv_x = 0;
         let mut mv_y = 0;
index ff55e65ce8e07f0909a734ca118b9cc1c920d210..7237adf7f90ce21dfc08cb3e64accf66e240cec7 100644 (file)
@@ -205,7 +205,7 @@ impl BlockDSP for I263BlockDSP {
 
         blockdsp::copy_block(&mut dst, src.clone(), 0, xpos, ypos, mv.x >> 1, mv.y >> 1, 16, 16, 0, 1, mode, H263_INTERP_FUNCS);
         blockdsp::copy_block(&mut dst, src.clone(), 1, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_FUNCS);
-        blockdsp::copy_block(&mut dst, src.clone(), 2, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_FUNCS);
+        blockdsp::copy_block(&mut dst, src,         2, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_FUNCS);
     }
     fn copy_blocks8x8(&self, dst: &mut NAVideoBuffer<u8>, src: NAVideoBufferRef<u8>, xpos: usize, ypos: usize, mvs: &[MV; 4]) {
         let mut dst = NASimpleVideoFrame::from_video_buf(dst).unwrap();
@@ -234,7 +234,7 @@ impl BlockDSP for I263BlockDSP {
 
         blockdsp::copy_block(&mut dst, src.clone(), 0, xpos, ypos, mv.x >> 1, mv.y >> 1, 16, 16, 0, 1, mode, H263_INTERP_AVG_FUNCS);
         blockdsp::copy_block(&mut dst, src.clone(), 1, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_AVG_FUNCS);
-        blockdsp::copy_block(&mut dst, src.clone(), 2, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_AVG_FUNCS);
+        blockdsp::copy_block(&mut dst, src,         2, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_AVG_FUNCS);
     }
     fn avg_blocks8x8(&self, dst: &mut NAVideoBuffer<u8>, src: NAVideoBufferRef<u8>, xpos: usize, ypos: usize, mvs: &[MV; 4]) {
         let mut dst = NASimpleVideoFrame::from_video_buf(dst).unwrap();
index c6609ccaf15c62a97cf76778566ec5b58629e711..141200c447ee5baa9063854529ae89207e2523ba 100644 (file)
@@ -931,8 +931,8 @@ br.skip(skip_part as u32)?;
                 let seq = br.peek(21);
                 if seq == 0xBFFF8 {
                     let res2 = self.decode_single_frame(dec, br);
-                    if res2.is_ok() {
-                        self.bref = Some(res2.unwrap());
+                    if let Ok(res) = res2 {
+                        self.bref = Some(res);
                     }
                 }
                 self.ftype = IVIFrameType::Intra;
index 321fe3844ff794e657f5dbcb60008de86eab4d58..a5a8ec3bbd3ec67eb9a2e4ab82a8dc74eba6bbbe 100644 (file)
@@ -49,6 +49,6 @@ const INDEO_CODECS: &[DecoderInfo] = &[
 /// Registers all available codecs provided by this crate.
 pub fn indeo_register_all_decoders(rd: &mut RegisteredDecoders) {
     for decoder in INDEO_CODECS.iter() {
-        rd.add_decoder(decoder.clone());
+        rd.add_decoder(*decoder);
     }
 }
index 4be9a0dcbc263e97c34fcf5205602838adf03387..01d46af5f96fec03be656c4cd0ff8ea421dab409 100644 (file)
@@ -258,7 +258,7 @@ fn decode_mv(cabac: &mut CABAC, ctx0: usize, ctx1: usize) -> MV {
     MV{ x, y }
 }
 
-#[allow(clippy::cyclomatic_complexity)]
+#[allow(clippy::cognitive_complexity)]
 pub fn decode_mb_pred_cabac(cabac: &mut CABAC, slice_hdr: &SliceHeader, mb_type: MBType, sstate: &mut SliceState, mb_info: &mut CurrentMBInfo) {
     mb_info.mb_type = mb_type;
     let num_l0 = slice_hdr.num_ref_idx_l0_active;
index 73d9c6bff36621d58e3f80a60b024e690c3b5c81..adc28aba96084f076695b450c8a3e3b3f65ed2be 100644 (file)
@@ -106,7 +106,7 @@ fn read_mvs(br: &mut BitReader, mvs: &mut [MV]) -> DecoderResult<()> {
     Ok(())
 }
 
-#[allow(clippy::cyclomatic_complexity)]
+#[allow(clippy::cognitive_complexity)]
 pub fn decode_mb_pred_cavlc(br: &mut BitReader, slice_hdr: &SliceHeader, mb_type: MBType, sstate: &mut SliceState, mb_info: &mut CurrentMBInfo) -> DecoderResult<()> {
     mb_info.mb_type = mb_type;
     let num_l0 = slice_hdr.num_ref_idx_l0_active;
index 976b8b575a47178af71eb5095132ef5fff33fa3c..803087cdc4540c9bcb05cb26386ad0d5fe53ac42 100644 (file)
@@ -657,7 +657,7 @@ println!("PAFF?");
             }
         }
     }
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     fn handle_macroblock(&mut self, mb_info: &mut CurrentMBInfo) {
         let pps = &self.pps[self.cur_pps];
 
index 81889a2cf3ad79591bb85110393ca519346440ec..d75d8893dd19249838757a14b8bbb4a3d2cf5bd3 100644 (file)
@@ -215,7 +215,7 @@ impl FrameRefs {
         self.ref_pics.truncate(0);
         self.long_term.truncate(0);
     }
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     pub fn select_refs(&mut self, sps: &SeqParameterSet, slice_hdr: &SliceHeader, cur_id: u32) {
         self.ref_list0.truncate(0);
         self.ref_list1.truncate(0);
index 5bd51a955e395abb3c96405203901648779fff0d..b02faf121df592c21f90bccfb1cb8da0fa56384b 100644 (file)
@@ -50,7 +50,7 @@ pub fn is_high_profile(profile: u8) -> bool {
     }
 }
 
-#[allow(clippy::cyclomatic_complexity)]
+#[allow(clippy::cognitive_complexity)]
 pub fn parse_sps(src: &[u8]) -> DecoderResult<SeqParameterSet> {
     let mut br = BitReader::new(src, BitReaderMode::BE);
     let mut sps: SeqParameterSet = unsafe { std::mem::zeroed() };
index 7250fafad4ae25bbed365075e83526a92f5b69fb..864eec7829ada5c272795b156f5d45efa54e4afa 100644 (file)
@@ -124,7 +124,7 @@ pub fn parse_slice_header_minimal(br: &mut BitReader) -> DecoderResult<(usize, S
     Ok((first_mb_in_slice, slice_type))
 }
 
-#[allow(clippy::cyclomatic_complexity)]
+#[allow(clippy::cognitive_complexity)]
 pub fn parse_slice_header(br: &mut BitReader, sps_arr: &[SeqParameterSet], pps_arr: &[PicParameterSet], is_idr: bool, nal_ref_idc: u8) -> DecoderResult<SliceHeader> {
     let mut hdr: SliceHeader = unsafe { std::mem::zeroed() };
 
index ec35801c8286491e3c09b069d6b2691b0256341b..efb24bc2b99e81d578fc33121be391846a2acade 100644 (file)
@@ -16,6 +16,6 @@ const ITU_CODECS: &[DecoderInfo] = &[
 /// Registers all available codecs provided by this crate.
 pub fn itu_register_all_decoders(rd: &mut RegisteredDecoders) {
     for decoder in ITU_CODECS.iter() {
-        rd.add_decoder(decoder.clone());
+        rd.add_decoder(*decoder);
     }
 }
index 234a472027fd11ff137f9ae6f9b02024767fd327..2cd300ff5922b6532d2e900487d169f71726769e 100644 (file)
@@ -2,6 +2,7 @@ extern crate nihav_core;
 extern crate nihav_codec_support;
 
 #[allow(clippy::collapsible_if)]
+#[allow(clippy::comparison_chain)]
 #[allow(clippy::needless_range_loop)]
 #[allow(clippy::useless_let_if_seq)]
 mod codecs;
index 5cc1769e9f43703036c01f76a5beebb7c2c1727c..87b524de7a6b4ca756ca7505b2273876b07fe716 100644 (file)
@@ -34,6 +34,6 @@ const LL_AUDIO_CODECS: &[DecoderInfo] = &[
 /// Registers all available codecs provided by this crate.
 pub fn llaudio_register_all_decoders(rd: &mut RegisteredDecoders) {
     for decoder in LL_AUDIO_CODECS.iter() {
-        rd.add_decoder(decoder.clone());
+        rd.add_decoder(*decoder);
     }
 }
index 3d1f4117f7cd87b0567e8ca727b69aad72ece700..0f561acca150392b5f703e6dfceb00e440937f39 100644 (file)
@@ -654,7 +654,7 @@ impl WavPackDecoder {
             dstate:     DecorrState::new(),
         }
     }
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     fn decode_block(&mut self, hdr: &WVHeader, src: &[u8], start_ch: usize, abuf: &mut NABufferType) -> DecoderResult<()> {
         let mut mr = MemoryReader::new_read(src);
         let mut br = ByteReader::new(&mut mr);
index abe46948439f3e25e2de4ee6c99dc4bd7f4a7e93..78b8ab9501cb6bbb0d3f573034ea24e1b63bc9e3 100644 (file)
@@ -1,6 +1,7 @@
 extern crate nihav_core;
 extern crate nihav_codec_support;
 
+#[allow(clippy::comparison_chain)]
 #[allow(clippy::unreadable_literal)]
 #[allow(clippy::verbose_bit_mask)]
 mod codecs;
index e01a6bb946ae01c74f707ee7e23e1f6878026d4c..752f5e81e1577b5c9b217d15158d39e2f861504f 100644 (file)
@@ -30,7 +30,7 @@ const MS_CODECS: &[DecoderInfo] = &[
 /// Registers all available codecs provided by this crate.
 pub fn ms_register_all_decoders(rd: &mut RegisteredDecoders) {
     for decoder in MS_CODECS.iter() {
-        rd.add_decoder(decoder.clone());
+        rd.add_decoder(*decoder);
     }
 }
 
@@ -47,6 +47,6 @@ const MS_ENCODERS: &[EncoderInfo] = &[
 /// Registers all available encoders provided by this crate.
 pub fn ms_register_all_encoders(re: &mut RegisteredEncoders) {
     for encoder in MS_ENCODERS.iter() {
-        re.add_encoder(encoder.clone());
+        re.add_encoder(*encoder);
     }
 }
index 19e8146b00cc21d18f4ac7c7f7ec57f7c7ca0fca..5010c03dc330457ef6e8de7a5b8d56af9be5c1bc 100644 (file)
@@ -347,7 +347,7 @@ impl NAEncoder for MSADPCMEncoder {
                 let soniton = NASoniton::new(4, 0);
                 let out_ainfo = NAAudioInfo::new(ainfo.sample_rate, ainfo.channels, soniton, Self::calc_block_size(self.block_len, self.channels));
                 let info = NACodecInfo::new("ms-adpcm", NACodecTypeInfo::Audio(out_ainfo), None);
-                let mut stream = NAStream::new(StreamType::Audio, stream_id, info.clone(), self.block_len as u32, ainfo.sample_rate, 0);
+                let mut stream = NAStream::new(StreamType::Audio, stream_id, info, self.block_len as u32, ainfo.sample_rate, 0);
                 stream.set_num(stream_id as usize);
                 let stream = stream.into_ref();
 
index 0e91176095346a5ef145daf840277729221c95c1..02de48ee78a654dd61e06b51d36550898a042bd1 100644 (file)
@@ -88,6 +88,6 @@ const QT_CODECS: &[DecoderInfo] = &[
 /// Registers all available codecs provided by this crate.
 pub fn qt_register_all_decoders(rd: &mut RegisteredDecoders) {
     for decoder in QT_CODECS.iter() {
-        rd.add_decoder(decoder.clone());
+        rd.add_decoder(*decoder);
     }
 }
index bd018aa7717e24675670bada16de0f91f3f09224..214f7af697ae737012e2643f9c34e30c2d9f3750 100644 (file)
@@ -370,7 +370,7 @@ unimplemented!();
             }
         }
     }
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     fn read_noise_band(&mut self, br: &mut QdmBitReader, ch: usize, band: usize, samples: &mut [f32; 10], signs: &[bool; 16], jstereo: bool) -> DecoderResult<()> {
         let mut type34_first = true;
         let mut type34_pred = 0.0;
index b78c46ba325dd0bcb8ab808e2fbe4646512d9dcf..16f13b4548d624cf63933ce874ee03c55ec979e3 100644 (file)
@@ -55,7 +55,7 @@ impl NADecoder for SmcDecoder {
             Err(DecoderError::InvalidData)
         }
     }
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
         let src = pkt.get_buffer();
         validate!(src.len() >= 2);
index c900d3ca5386379a5cbb3eadaa23b32bd3c4bcc3..46480f57d5b14266a5f1992895cdb78e0bd7ec99 100644 (file)
@@ -434,7 +434,7 @@ fn mc_part(dframe: &mut NASimpleVideoFrame<u8>, src: NAVideoBufferRef<u8>, ebuf:
 
     copy_block(dframe, src.clone(), ebuf, 0, xoff,     yoff,     mx,  my,  bw * 4, bh * 4, 0, post, mode, ifuncs);
     copy_block(dframe, src.clone(), ebuf, 1, xoff / 2, yoff / 2, cmx, cmy, bw * 2, bh * 2, 0, post, mode, ifuncs);
-    copy_block(dframe, src.clone(), ebuf, 2, xoff / 2, yoff / 2, cmx, cmy, bw * 2, bh * 2, 0, post, mode, ifuncs);
+    copy_block(dframe, src,         ebuf, 2, xoff / 2, yoff / 2, cmx, cmy, bw * 2, bh * 2, 0, post, mode, ifuncs);
 }
 
 impl SVQ3Decoder {
@@ -813,7 +813,7 @@ println!("slice offset {}", _offset);
         if let (Some(bwd_ref), true, true) = (self.ipbs.get_b_bwdref(), has_fwd, has_bwd) {
             let mut aframe = NASimpleVideoFrame::from_video_buf(&mut self.avg_buf).unwrap();
             let amv = MV { x: bmv.x + (self.mb_x as i16) * 16 * 6, y: bmv.y + (self.mb_y as i16) * 16 * 6 };
-            mc_part(&mut aframe, bwd_ref.clone(), &mut self.ebuf, 0, 0, 4, 4, amv, bmode, ifuncs);
+            mc_part(&mut aframe, bwd_ref, &mut self.ebuf, 0, 0, 4, 4, amv, bmode, ifuncs);
 
             let dstride = dframe.stride[0];
             let dst = &mut dframe.data[dframe.offset[0] + self.mb_x * 16 + self.mb_y * 16 * dstride..];
index 29180f0e48e47c263669306cb3cb998e06c4c3cf..c434016d669ba37930dd4ceafbfb949af219884e 100644 (file)
@@ -1,6 +1,7 @@
 extern crate nihav_core;
 extern crate nihav_codec_support;
 
+#[allow(clippy::comparison_chain)]
 #[allow(clippy::single_match)]
 mod codecs;
 pub use crate::codecs::qt_register_all_decoders;
index 9ae02a710468ddaa349d0f004dc1e2d526557424..21b48eb5c5602d5ea921069daec5053bf5c75397 100644 (file)
@@ -1027,7 +1027,7 @@ impl Bink2Decoder {
         Self::default()
     }
 
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     fn decode_frame_new(&mut self, br: &mut BitReader, buf: &mut NAVideoBuffer<u8>, is_intra: bool) -> DecoderResult<()> {
         let (stride_y, stride_u, stride_v, stride_a) = (buf.get_stride(0), buf.get_stride(1), buf.get_stride(2), buf.get_stride(3));
         let (mut off_y, mut off_u, mut off_v, mut off_a) = (buf.get_offset(0), buf.get_offset(1), buf.get_offset(2), buf.get_offset(3));
index 5f5bb566aa528603e7b3515f5f813f4bdd468e2f..b0643b0e9655ae3a25a9d7c1d4b1441b56ec08cb 100644 (file)
@@ -387,7 +387,7 @@ impl Default for BinkTrees {
     fn default() -> Self {
         let mut cb: [Codebook<u8>; 16];
         unsafe {
-            cb = std::mem::uninitialized();
+            cb = std::mem::MaybeUninit::uninit().assume_init();
             for i in 0..16 {
                 let mut cr = TableCodebookDescReader::new(&BINK_TREE_CODES[i], &BINK_TREE_BITS[i], map_u8);
                 std::ptr::write(&mut cb[i], Codebook::new(&mut cr, CodebookMode::LSB).unwrap());
index a11f5c536563b4c04e8c76fdc9258159bcaea809..6680c0f2712044b0ed0adc85b88e8c82143706f9 100644 (file)
@@ -31,6 +31,6 @@ const RAD_CODECS: &[DecoderInfo] = &[
 /// Registers all available codecs provided by this crate.
 pub fn rad_register_all_decoders(rd: &mut RegisteredDecoders) {
     for decoder in RAD_CODECS.iter() {
-        rd.add_decoder(decoder.clone());
+        rd.add_decoder(*decoder);
     }
 }
index 83da6acaebcb95643070ae21d027b969dc2ded1b..dbf401f837436510e4b13723b072a3a89763b1fd 100644 (file)
@@ -146,7 +146,7 @@ impl<'a> DemuxCore<'a> for BinkDemuxer<'a> {
         let stream = strres.unwrap();
         let keyframe = (self.frame_pos[self.cur_frame] & 1) != 0;
         let ts = NATimeInfo::new(Some(self.cur_frame as u64), None, None, self.tb_num, self.tb_den);
-        let pkt = self.src.read_packet(stream.clone(), ts, keyframe, payload_size)?;
+        let pkt = self.src.read_packet(stream, ts, keyframe, payload_size)?;
 
         self.cur_frame += 1;
 
index 6ce3702ecd55d4a4d6217c942780bf9d725675a2..16a622c3ee341ad8966832bfdfbccbce58279d64 100644 (file)
@@ -15,6 +15,7 @@ mod codecs;
 pub use crate::codecs::rad_register_all_decoders;
 
 #[cfg(feature="demuxers")]
+#[allow(clippy::comparison_chain)]
 #[allow(clippy::cast_lossless)]
 mod demuxers;
 #[cfg(feature="demuxers")]
index d8a36d4b75ed514b0d748e87a7ebb9b849c963aa..aea7a9e912749f840c4ccc42f2a0fc20a8be3b6a 100644 (file)
@@ -75,6 +75,6 @@ const RM_CODECS: &[DecoderInfo] = &[
 /// Registers all available codecs provided by this crate.
 pub fn realmedia_register_all_decoders(rd: &mut RegisteredDecoders) {
     for decoder in RM_CODECS.iter() {
-        rd.add_decoder(decoder.clone());
+        rd.add_decoder(*decoder);
     }
 }
index 88b1a600a265cb348d8f0264317ece12703acb6a..078198731844d7874e829d8ba2b4ce89ca112b62 100644 (file)
@@ -140,7 +140,7 @@ impl BlockDSP for RV20BlockDSP {
 
         blockdsp::copy_block(&mut dst, src.clone(), 0, xpos, ypos, mv.x >> 1, mv.y >> 1, 16, 16, 0, 1, mode, H263_INTERP_FUNCS);
         blockdsp::copy_block(&mut dst, src.clone(), 1, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_FUNCS);
-        blockdsp::copy_block(&mut dst, src.clone(), 2, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_FUNCS);
+        blockdsp::copy_block(&mut dst, src,         2, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_FUNCS);
     }
     fn copy_blocks8x8(&self, dst: &mut NAVideoBuffer<u8>, src: NAVideoBufferRef<u8>, xpos: usize, ypos: usize, mvs: &[MV; 4]) {
         let mut dst = NASimpleVideoFrame::from_video_buf(dst).unwrap();
@@ -169,7 +169,7 @@ impl BlockDSP for RV20BlockDSP {
 
         blockdsp::copy_block(&mut dst, src.clone(), 0, xpos, ypos, mv.x >> 1, mv.y >> 1, 16, 16, 0, 1, mode, H263_INTERP_AVG_FUNCS);
         blockdsp::copy_block(&mut dst, src.clone(), 1, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_AVG_FUNCS);
-        blockdsp::copy_block(&mut dst, src.clone(), 2, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_AVG_FUNCS);
+        blockdsp::copy_block(&mut dst, src,         2, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_AVG_FUNCS);
     }
     fn avg_blocks8x8(&self, dst: &mut NAVideoBuffer<u8>, src: NAVideoBufferRef<u8>, xpos: usize, ypos: usize, mvs: &[MV; 4]) {
         let mut dst = NASimpleVideoFrame::from_video_buf(dst).unwrap();
index e4d8420bb3b51c6922e764c329b440c8c4a79a78..9e8c68a34792144a8dfd43210a1b941c1b2560b1 100644 (file)
@@ -1095,7 +1095,7 @@ impl RV34Decoder {
         }
     }
 
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     pub fn parse_frame(&mut self, supp: &mut NADecoderSupport, src: &[u8], bd: &mut dyn RV34BitstreamDecoder) -> DecoderResult<(NABufferType, FrameType, u64)> {
         let mut slice_offs: Vec<usize> = Vec::new();
         parse_slice_offsets(src, &mut slice_offs)?;
index ebdd1f32329eba4046caeea04f4269e27a89f55b..36ae629d530468c8f325baee4350c68b450ed994 100644 (file)
@@ -239,7 +239,7 @@ const RV30_EDGE1: [isize; 3] = [ 0, 1, 1 ];
 const RV30_EDGE2: [isize; 3] = [ 0, 2, 2 ];
 
 impl RV34DSP for RV30DSP {
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     fn loop_filter(&self, frame: &mut NAVideoBuffer<u8>, _ftype: FrameType, mbinfo: &[RV34MBInfo], mb_w: usize, _mb_h: usize, row: usize) {
         let mut offs:   [usize; 3] = [0; 3];
         let mut stride: [usize; 3] = [0; 3];
index 299c39505b1dc78106e2d7adab74e5d648b1de53..a883b0b9e0e84e7943302e6fbf89341baaf9b2da 100644 (file)
@@ -591,7 +591,7 @@ const C_LEFT_COL_MASK:  u32 = 0x5;
 const C_RIGHT_COL_MASK: u32 = 0xA;
 
 impl RV34DSP for RV40DSP {
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     fn loop_filter(&self, frame: &mut NAVideoBuffer<u8>, _ftype: FrameType, mbinfo: &[RV34MBInfo], mb_w: usize, mb_h: usize, row: usize) {
         // todo proper B-frame filtering?
         let mut offs:   [usize; 3] = [0; 3];
index d1e7c53dada77d102a882dfa013cf532ae36f270..5574cb43d4bcd539c406c5c37e1fae672ec1d819 100644 (file)
@@ -728,7 +728,7 @@ println!(" left {} bits", br.left());
 }
         Ok(())
     }
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     fn decode_cb_tree(&mut self, buf: &mut NASimpleVideoFrame<u8>, hdr: &FrameHeader, br: &mut BitReader, xpos: usize, ypos: usize, log_size: u8) -> DecoderResult<()> {
         if (xpos >= hdr.width) || (ypos >= hdr.height) { return Ok(()); }
 
index 43bdce7442757baef3db63d296f9155a72eb5df5..a8301813fd09a9ae519c47bcbd8d6cee8f9e1f9e 100644 (file)
@@ -101,8 +101,8 @@ impl RV60Codebooks {
         let mut cbp8_cb:  [[Codebook<u16>; 4];  NUM_INTER_SETS];
         let mut cbp16_cb: [[Codebook<u16>; 12]; NUM_INTER_SETS];
         unsafe {
-            cbp8_cb = mem::uninitialized();
-            cbp16_cb = mem::uninitialized();
+            cbp8_cb = mem::MaybeUninit::uninit().assume_init();
+            cbp16_cb = mem::MaybeUninit::uninit().assume_init();
             for set_no in 0..NUM_INTER_SETS {
                 for i in 0..4 {
                     let mut cbr = RV60CodebookDescReader::new(&RV60_CBP8_TABS[set_no][i], NUM_CBP_ENTRIES, false);
@@ -117,11 +117,11 @@ impl RV60Codebooks {
         let mut intra_coeff_cb: [CoeffCodebooks; NUM_INTRA_SETS];
         let mut inter_coeff_cb: [CoeffCodebooks; NUM_INTER_SETS];
         unsafe {
-            intra_coeff_cb = mem::uninitialized();
+            intra_coeff_cb = mem::MaybeUninit::uninit().assume_init();
             for set_no in 0..NUM_INTRA_SETS {
                 ptr::write(&mut intra_coeff_cb[set_no], CoeffCodebooks::init(set_no, true));
             }
-            inter_coeff_cb = mem::uninitialized();
+            inter_coeff_cb = mem::MaybeUninit::uninit().assume_init();
             for set_no in 0..NUM_INTER_SETS {
                 ptr::write(&mut inter_coeff_cb[set_no], CoeffCodebooks::init(set_no, false));
             }
index 760777a4e31d0a8178897abc8d5495b5649b3662..7fa893397f2f9c354bc9b70aa7e73d2d0b179dd1 100644 (file)
@@ -58,7 +58,7 @@ macro_rules! filter_row {
         });
 }
 
-#[allow(clippy::cyclomatic_complexity)]
+#[allow(clippy::cognitive_complexity)]
 fn luma_mc(dst: &mut [u8], mut didx: usize, dstride: usize, src: &[u8], mut sidx: usize, sstride: usize, w: usize, h: usize, cx: usize, cy: usize) {
     if (cx == 0) && (cy == 0) {
         for _ in 0..h {
@@ -784,7 +784,7 @@ impl IntraPredContext {
             sum += diff;
         }
     }
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     pub fn pred_angle(&self, dst: &mut [u8], mut doff: usize, dstride: usize, size: usize, angle: usize, filter: bool) {
         let mut filtered1: [u8; 96] = [0; 96];
         let mut filtered2: [u8; 96] = [0; 96];
index 74581d934c93774385b144637e03009753d9e6b7..248fa6c6f4c8677c594824fbe706cf0afc8a9518 100644 (file)
@@ -1185,8 +1185,8 @@ fn read_string_size(src: &mut ByteReader, size: usize) -> DemuxerResult<String>
         vec.push(c);
     }
     let str = String::from_utf8(vec);
-    if str.is_ok() {
-        Ok(str.unwrap())
+    if let Ok(res) = str {
+        Ok(res)
     } else {
         Ok(String::new())
     }
@@ -1653,7 +1653,7 @@ impl<'a> RealIVRDemuxer<'a> {
     }
 }
 
-static RM_VIDEO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
+static RM_VIDEO_CODEC_REGISTER: &[(&[u8;4], &str)] = &[
     (b"RV10", "realvideo1"),
     (b"RV20", "realvideo2"),
     (b"RVTR", "realvideo2"),
@@ -1663,7 +1663,7 @@ static RM_VIDEO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
     (b"CLV1", "clearvideo_rm"),
 ];
 
-static RM_AUDIO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
+static RM_AUDIO_CODEC_REGISTER: &[(&[u8;4], &str)] = &[
     (b"lpcJ", "ra14.4"),
     (b"28_8", "ra28.8"),
     (b"cook", "cook"),
index 0155eac4a912ab20de3e191b92bb5f83a56c3037..06efd963d944ae305fcbe4b8310e9775a4d10bff 100644 (file)
@@ -4,6 +4,7 @@ extern crate nihav_codec_support;
 #[cfg(feature="decoders")]
 #[allow(clippy::cast_lossless)]
 #[allow(clippy::collapsible_if)]
+#[allow(clippy::comparison_chain)]
 #[allow(clippy::excessive_precision)]
 #[allow(clippy::identity_op)]
 #[allow(clippy::needless_range_loop)]
index 75a13d91e9424896e21fa590f417a302c14b6b7f..bf5255cc557338cee6901ea9f3bb8e6ca991ad62 100644 (file)
@@ -155,7 +155,7 @@ pub fn get_codec_description(name: &str) -> Option<&'static CodecDescription> {
     None
 }
 
-static CODEC_REGISTER: &'static [CodecDescription] = &[
+static CODEC_REGISTER: &[CodecDescription] = &[
     desc!(audio-ll; "pcm", "PCM"),
     desc!(audio;    "alaw", "A-law PCM"),
     desc!(audio;    "ulaw", "mu-law PCM"),
@@ -263,7 +263,7 @@ static CODEC_REGISTER: &'static [CodecDescription] = &[
     desc!(video;    "h264",          "ITU H.264", CODEC_CAP_COMPLEX_REORDER | CODEC_CAP_HYBRID),
 ];
 
-static AVI_VIDEO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
+static AVI_VIDEO_CODEC_REGISTER: &[(&[u8;4], &str)] = &[
     (&[1, 0, 0, 0], "msrle"),
     (&[2, 0, 0, 0], "msrle"),
 
@@ -302,7 +302,7 @@ static AVI_VIDEO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
     (b"VP70", "vp7"),
 ];
 
-static WAV_CODEC_REGISTER: &'static [(u16, &str)] = &[
+static WAV_CODEC_REGISTER: &[(u16, &str)] = &[
     (0x0000, "unknown"),
     (0x0001, "pcm"),
     (0x0002, "ms-adpcm"),
@@ -316,7 +316,7 @@ static WAV_CODEC_REGISTER: &'static [(u16, &str)] = &[
     (0x0501, "on2avc-501"),
 ];
 
-static MOV_VIDEO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
+static MOV_VIDEO_CODEC_REGISTER: &[(&[u8;4], &str)] = &[
     (b"cvid", "cinepak"),
     (b"jpeg", "jpeg"),
     //(b"raw ", "raw"),
@@ -344,7 +344,7 @@ static MOV_VIDEO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
     (b"avc1", "h264"),
 ];
 
-static MOV_AUDIO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
+static MOV_AUDIO_CODEC_REGISTER: &[(&[u8;4], &str)] = &[
     (b"NONE", "pcm"),
     (b"raw ", "pcm"),
     (b"twos", "pcm"),
index 354f585f65c22fcb56d22bc2c633f94c9f4a9326..ea95f239ce4e1017ff93a87d6ee6c91d23a4166e 100644 (file)
@@ -32,6 +32,6 @@ const VIVO_CODECS: &[DecoderInfo] = &[
 /// Registers all available codecs provided by this crate.
 pub fn vivo_register_all_decoders(rd: &mut RegisteredDecoders) {
     for decoder in VIVO_CODECS.iter() {
-        rd.add_decoder(decoder.clone());
+        rd.add_decoder(*decoder);
     }
 }
index c6620b426a553211a4049c9223102804f382cd11..7f99a525d9dbc25627f7f78cc4e245a9b5fcf96e 100644 (file)
@@ -124,17 +124,17 @@ impl BlockDSP for VivoBlockDSP {
 
         blockdsp::copy_block(&mut dst, src.clone(), 0, xpos, ypos, mv.x >> 1, mv.y >> 1, 16, 16, 0, 1, mode, H263_INTERP_FUNCS);
         blockdsp::copy_block(&mut dst, src.clone(), 1, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_FUNCS);
-        blockdsp::copy_block(&mut dst, src.clone(), 2, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_FUNCS);
+        blockdsp::copy_block(&mut dst, src,         2, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_FUNCS);
     }
     fn copy_blocks8x8(&self, dst: &mut NAVideoBuffer<u8>, src: NAVideoBufferRef<u8>, xpos: usize, ypos: usize, mvs: &[MV; 4]) {
         let mut dst = NASimpleVideoFrame::from_video_buf(dst).unwrap();
 
-        for i in 0..4 {
+        for (i, mv) in mvs.iter().enumerate() {
             let xadd = (i & 1) * 8;
             let yadd = (i & 2) * 4;
-            let mode = ((mvs[i].x & 1) + (mvs[i].y & 1) * 2) as usize;
+            let mode = ((mv.x & 1) + (mv.y & 1) * 2) as usize;
 
-            blockdsp::copy_block(&mut dst, src.clone(), 0, xpos + xadd, ypos + yadd, mvs[i].x >> 1, mvs[i].y >> 1, 8, 8, 0, 1, mode, H263_INTERP_FUNCS);
+            blockdsp::copy_block(&mut dst, src.clone(), 0, xpos + xadd, ypos + yadd, mv.x >> 1, mv.y >> 1, 8, 8, 0, 1, mode, H263_INTERP_FUNCS);
         }
 
         let sum_mv = mvs[0] + mvs[1] + mvs[2] + mvs[3];
@@ -153,17 +153,17 @@ impl BlockDSP for VivoBlockDSP {
 
         blockdsp::copy_block(&mut dst, src.clone(), 0, xpos, ypos, mv.x >> 1, mv.y >> 1, 16, 16, 0, 1, mode, H263_INTERP_AVG_FUNCS);
         blockdsp::copy_block(&mut dst, src.clone(), 1, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_AVG_FUNCS);
-        blockdsp::copy_block(&mut dst, src.clone(), 2, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_AVG_FUNCS);
+        blockdsp::copy_block(&mut dst, src,         2, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_AVG_FUNCS);
     }
     fn avg_blocks8x8(&self, dst: &mut NAVideoBuffer<u8>, src: NAVideoBufferRef<u8>, xpos: usize, ypos: usize, mvs: &[MV; 4]) {
         let mut dst = NASimpleVideoFrame::from_video_buf(dst).unwrap();
 
-        for i in 0..4 {
+        for (i, mv) in mvs.iter().enumerate() {
             let xadd = (i & 1) * 8;
             let yadd = (i & 2) * 4;
-            let mode = ((mvs[i].x & 1) + (mvs[i].y & 1) * 2) as usize;
+            let mode = ((mv.x & 1) + (mv.y & 1) * 2) as usize;
 
-            blockdsp::copy_block(&mut dst, src.clone(), 0, xpos + xadd, ypos + yadd, mvs[i].x >> 1, mvs[i].y >> 1, 8, 8, 0, 1, mode, H263_INTERP_AVG_FUNCS);
+            blockdsp::copy_block(&mut dst, src.clone(), 0, xpos + xadd, ypos + yadd, mv.x >> 1, mv.y >> 1, 8, 8, 0, 1, mode, H263_INTERP_AVG_FUNCS);
         }
 
         let sum_mv = mvs[0] + mvs[1] + mvs[2] + mvs[3];