core: fix most clippy warnings

4 files changed, 95 insertions, 92 deletions

diff --git a/nihav-core/src/io/bitreader.rs b/nihav-core/src/io/bitreader.rs
index ea5f27c..faa1d87 100644
--- a/nihav-core/src/io/bitreader.rs
+++ b/nihav-core/src/io/bitreader.rs
@@ -27,11 +27,12 @@ pub struct BitReader<'a> {
     mode:  BitReaderMode,
 }
 
+#[allow(clippy::identity_op)]
 impl<'a> BitReader<'a> {
 
     pub fn new(src: &'a [u8], size: usize, mode: BitReaderMode) -> Self {
         if src.len() < size { panic!("size is less than needed"); }
-        BitReader{ cache: 0, pos: 0, bits: 0, end: size, src: src, mode: mode }
+        BitReader{ cache: 0, pos: 0, bits: 0, end: size, src, mode }
     }
 
     pub fn tell(&self) -> usize {
@@ -43,30 +44,30 @@ impl<'a> BitReader<'a> {
     }
 
     fn fill32be(&mut self, src: &[u8]) {
-        let nw = (((src[0] as u32) << 24) |
-                  ((src[1] as u32) << 16) |
-                  ((src[2] as u32) <<  8) |
-                  ((src[3] as u32) <<  0)) as u64;
-        self.cache |= nw << (32 - self.bits);
+        let nw = (u32::from(src[0]) << 24) |
+                 (u32::from(src[1]) << 16) |
+                 (u32::from(src[2]) <<  8) |
+                 (u32::from(src[3]) <<  0);
+        self.cache |= u64::from(nw) << (32 - self.bits);
     }
 
     fn fill32le16(&mut self, src: &[u8]) {
-        let nw = (((src[1] as u32) << 24) |
-                  ((src[0] as u32) << 16) |
-                  ((src[3] as u32) <<  8) |
-                  ((src[2] as u32) <<  0)) as u64;
-        self.cache |= nw << (32 - self.bits);
+        let nw = (u32::from(src[1]) << 24) |
+                 (u32::from(src[0]) << 16) |
+                 (u32::from(src[3]) <<  8) |
+                 (u32::from(src[2]) <<  0);
+        self.cache |= u64::from(nw) << (32 - self.bits);
     }
 
     fn fill32le32(&mut self, src: &[u8], lsb: bool) {
-        let nw = (((src[3] as u32) << 24) |
-                  ((src[2] as u32) << 16) |
-                  ((src[1] as u32) <<  8) |
-                  ((src[0] as u32) <<  0)) as u64;
+        let nw = (u32::from(src[3]) << 24) |
+                 (u32::from(src[2]) << 16) |
+                 (u32::from(src[1]) <<  8) |
+                 (u32::from(src[0]) <<  0);
         if lsb {
-            self.cache |= nw << self.bits;
+            self.cache |= u64::from(nw) << self.bits;
         } else {
-            self.cache |= nw << (32 - self.bits);
+            self.cache |= u64::from(nw) << (32 - self.bits);
         }
     }
 
@@ -87,10 +88,10 @@ impl<'a> BitReader<'a> {
             } else {
                 let mut buf: [u8; 4] = [0, 0, 0, 0];
                 let mut newbits: u8 = 0;
-                for i in 0..3 {
+                for out in buf.iter_mut().take(3) {
                     if self.pos < self.end {
-                        buf[i] = self.src[self.pos];
-                        self.pos = self.pos + 1;
+                        *out = self.src[self.pos];
+                        self.pos += 1;
                         newbits += 8;
                     }
                 }
@@ -111,7 +112,7 @@ impl<'a> BitReader<'a> {
     fn read_cache(&mut self, nbits: u8) -> u32 {
         let res = match self.mode {
             BitReaderMode::LE => ((1u64 << nbits) - 1) & self.cache,
-            _                 => (self.cache as u64) >> (64 - nbits),
+            _                 => self.cache >> (64 - nbits),
         };
         res as u32
     }
@@ -183,14 +184,14 @@ impl<'a> BitReader<'a> {
 
     #[inline(always)]
     pub fn skip(&mut self, nbits: u32) -> BitReaderResult<()> {
-        if self.bits as u32 >= nbits {
+        if u32::from(self.bits) >= nbits {
             self.skip_cache(nbits as u8);
             return Ok(());
         }
-        let mut skip_bits = nbits - (self.bits as u32);
+        let mut skip_bits = nbits - u32::from(self.bits);
         self.reset_cache();
         self.pos += ((skip_bits / 32) * 4) as usize;
-        skip_bits = skip_bits & 0x1F;
+        skip_bits &= 0x1F;
         self.refill()?;
         if skip_bits > 0 {
             self.skip_cache(skip_bits as u8);
@@ -223,8 +224,8 @@ pub fn reverse_bits(inval: u32, len: u8) -> u32 {
     let mut ret = 0;
     let mut val = inval;
     for _ in 0..8 {
-        ret = (ret << 4) | (REV_TAB[(val & 0xF) as usize] as u32);
-        val = val >> 4;
+        ret = (ret << 4) | u32::from(REV_TAB[(val & 0xF) as usize]);
+        val >>= 4;
     }
     ret >> (32 - len)
 }
diff --git a/nihav-core/src/io/byteio.rs b/nihav-core/src/io/byteio.rs
index 286a117..545bff5 100644
--- a/nihav-core/src/io/byteio.rs
+++ b/nihav-core/src/io/byteio.rs
@@ -1,6 +1,7 @@
 use std::io::SeekFrom;
 use std::fs::File;
 use std::io::prelude::*;
+use std::ptr;
 
 #[derive(Debug)]
 pub enum ByteIOError {
@@ -24,7 +25,7 @@ pub trait ByteIO {
     fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()>;
     fn tell(&mut self) -> u64;
     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64>;
-    fn is_eof(&mut self) -> bool;
+    fn is_eof(&self) -> bool;
     fn is_seekable(&mut self) -> bool;
     fn size(&mut self) -> i64;
 }
@@ -47,20 +48,20 @@ pub struct FileReader<'a> {
 
 macro_rules! read_int {
     ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
-        let mut buf = [0; $size];
-        $s.read_buf(&mut buf)?;
         unsafe {
-            Ok((*(buf.as_ptr() as *const $inttype)).$which())
+            let mut buf: $inttype = 0;
+            $s.read_buf(&mut *(&mut buf as *mut $inttype as *mut [u8; $size]))?;
+            Ok(buf.$which())
         }
     })
 }
 
 macro_rules! peek_int {
     ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
-        let mut buf = [0; $size];
-        $s.peek_buf(&mut buf)?;
         unsafe {
-            Ok((*(buf.as_ptr() as *const $inttype)).$which())
+            let mut buf: $inttype = 0;
+            $s.peek_buf(&mut *(&mut buf as *mut $inttype as *mut [u8; $size]))?;
+            Ok(buf.$which())
         }
     })
 }
@@ -70,7 +71,9 @@ macro_rules! read_int_func {
         pub fn $s(src: &[u8]) -> ByteIOResult<$inttype> {
             if src.len() < $size { return Err(ByteIOError::ReadError); }
             unsafe {
-                Ok((*(src.as_ptr() as *const $inttype)).$which())
+                let mut buf: $inttype = 0;
+                ptr::copy_nonoverlapping(src.as_ptr(), &mut buf as *mut $inttype as *mut u8, 1);
+                Ok(buf.$which())
             }
         }
     }
@@ -85,15 +88,15 @@ read_int_func!(read_u64le, u64, 8, to_le);
 
 pub fn read_u24be(src: &[u8]) -> ByteIOResult<u32> {
     if src.len() < 3 { return Err(ByteIOError::ReadError); }
-    Ok(((src[0] as u32) << 16) | ((src[1] as u32) << 8) | (src[2] as u32))
+    Ok((u32::from(src[0]) << 16) | (u32::from(src[1]) << 8) | u32::from(src[2]))
 }
 pub fn read_u24le(src: &[u8]) -> ByteIOResult<u32> {
     if src.len() < 3 { return Err(ByteIOError::ReadError); }
-    Ok(((src[2] as u32) << 16) | ((src[1] as u32) << 8) | (src[0] as u32))
+    Ok((u32::from(src[2]) << 16) | (u32::from(src[1]) << 8) | u32::from(src[0]))
 }
 
 impl<'a> ByteReader<'a> {
-    pub fn new(io: &'a mut ByteIO) -> Self { ByteReader { io: io } }
+    pub fn new(io: &'a mut ByteIO) -> Self { ByteReader { io } }
 
     pub fn read_buf(&mut self, buf: &mut [u8])  -> ByteIOResult<usize> {
         self.io.read_buf(buf)
@@ -126,13 +129,13 @@ impl<'a> ByteReader<'a> {
     pub fn read_u24be(&mut self) -> ByteIOResult<u32> {
         let p16 = self.read_u16be()?;
         let p8 = self.read_byte()?;
-        Ok(((p16 as u32) << 8) | (p8 as u32))
+        Ok((u32::from(p16) << 8) | u32::from(p8))
     }
 
     pub fn peek_u24be(&mut self) -> ByteIOResult<u32> {
         let mut src: [u8; 3] = [0; 3];
         self.peek_buf(&mut src)?;
-        Ok(((src[0] as u32) << 16) | ((src[1] as u32) << 8) | (src[2] as u32))
+        Ok((u32::from(src[0]) << 16) | (u32::from(src[1]) << 8) | u32::from(src[2]))
     }
 
     pub fn read_u32be(&mut self) -> ByteIOResult<u32> {
@@ -162,13 +165,13 @@ impl<'a> ByteReader<'a> {
     pub fn read_u24le(&mut self) -> ByteIOResult<u32> {
         let p8 = self.read_byte()?;
         let p16 = self.read_u16le()?;
-        Ok(((p16 as u32) << 8) | (p8 as u32))
+        Ok((u32::from(p16) << 8) | u32::from(p8))
     }
 
     pub fn peek_u24le(&mut self) -> ByteIOResult<u32> {
         let mut src: [u8; 3] = [0; 3];
         self.peek_buf(&mut src)?;
-        Ok((src[0] as u32) | ((src[1] as u32) << 8) | ((src[2] as u32) << 16))
+        Ok(u32::from(src[0]) | (u32::from(src[1]) << 8) | (u32::from(src[2]) << 16))
     }
 
     pub fn read_u32le(&mut self) -> ByteIOResult<u32> {
@@ -200,7 +203,7 @@ impl<'a> ByteReader<'a> {
             }
             while ssize > 0 {
                 self.io.read_byte()?;
-                ssize = ssize - 1;
+                ssize -= 1;
             }
         }
         Ok(())
@@ -214,7 +217,7 @@ impl<'a> ByteReader<'a> {
         self.io.seek(pos)
     }
 
-    pub fn is_eof(&mut self) -> bool {
+    pub fn is_eof(&self) -> bool {
         self.io.is_eof()
     }
 
@@ -225,19 +228,19 @@ impl<'a> ByteReader<'a> {
     pub fn left(&mut self) -> i64 {
         let size = self.io.size();
         if size == -1 { return -1; }
-        return size - (self.io.tell() as i64)
+        size - (self.io.tell() as i64)
     }
 }
 
 impl<'a> MemoryReader<'a> {
 
     pub fn new_read(buf: &'a [u8]) -> Self {
-        MemoryReader { buf: buf, size: buf.len(), pos: 0 }
+        MemoryReader { buf, size: buf.len(), pos: 0 }
     }
 
     fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
         if pos < 0 || (pos as usize) > self.size {
-            return Err(ByteIOError::WrongRange)
+            return Err(ByteIOError::WrongRange);
         }
         self.pos = pos as usize;
         Ok(pos as u64)
@@ -248,7 +251,7 @@ impl<'a> ByteIO for MemoryReader<'a> {
     fn read_byte(&mut self) -> ByteIOResult<u8> {
         if self.is_eof() { return Err(ByteIOError::EOF); }
         let res = self.buf[self.pos];
-        self.pos = self.pos + 1;
+        self.pos += 1;
         Ok(res)
     }
 
@@ -260,9 +263,8 @@ impl<'a> ByteIO for MemoryReader<'a> {
     fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
         let copy_size = if self.size - self.pos < buf.len() { self.size } else { buf.len() };
         if copy_size == 0 { return Err(ByteIOError::EOF); }
-        for i in 0..copy_size {
-            buf[i] = self.buf[self.pos + i];
-        }
+        let dst = &mut buf[0..copy_size];
+        dst.copy_from_slice(&self.buf[self.pos..][..copy_size]);
         Ok(copy_size)
     }
 
@@ -298,7 +300,7 @@ impl<'a> ByteIO for MemoryReader<'a> {
         }
     }
 
-    fn is_eof(&mut self) -> bool {
+    fn is_eof(&self) -> bool {
         self.pos >= self.size
     }
 
@@ -314,16 +316,16 @@ impl<'a> ByteIO for MemoryReader<'a> {
 impl<'a> FileReader<'a> {
 
     pub fn new_read(file: &'a mut File) -> Self {
-        FileReader { file: file, eof : false }
+        FileReader { file, eof : false }
     }
 }
 
 impl<'a> ByteIO for FileReader<'a> {
     fn read_byte(&mut self) -> ByteIOResult<u8> {
         let mut byte : [u8; 1] = [0];
-        let err = self.file.read(&mut byte);
-        if let Err(_) = err { return Err(ByteIOError::ReadError); }
-        let sz = err.unwrap();
+        let ret = self.file.read(&mut byte);
+        if ret.is_err() { return Err(ByteIOError::ReadError); }
+        let sz = ret.unwrap();
         if sz == 0 { self.eof = true; return Err(ByteIOError::EOF); }
         Ok (byte[0])
     }
@@ -335,17 +337,17 @@ impl<'a> ByteIO for FileReader<'a> {
     }
 
     fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
-        let res = self.file.read(buf);
-        if let Err(_) = res { return Err(ByteIOError::ReadError); }
-        let sz = res.unwrap();
+        let ret = self.file.read(buf);
+        if ret.is_err() { return Err(ByteIOError::ReadError); }
+        let sz = ret.unwrap();
         if sz < buf.len() { self.eof = true; return Err(ByteIOError::EOF); }
         Ok(sz)
     }
 
     fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
-        let res = self.file.read(buf);
-        if let Err(_) = res { return Err(ByteIOError::ReadError); }
-        let sz = res.unwrap();
+        let ret = self.file.read(buf);
+        if ret.is_err() { return Err(ByteIOError::ReadError); }
+        let sz = ret.unwrap();
         if sz < buf.len() { self.eof = true; }
         Ok(sz)
     }
@@ -373,7 +375,7 @@ impl<'a> ByteIO for FileReader<'a> {
         }
     }
 
-    fn is_eof(&mut self) -> bool {
+    fn is_eof(&self) -> bool {
         self.eof
     }
 
@@ -402,7 +404,7 @@ pub struct FileWriter {
 }
 
 impl<'a> ByteWriter<'a> {
-    pub fn new(io: &'a mut ByteIO) -> Self { ByteWriter { io: io } }
+    pub fn new(io: &'a mut ByteIO) -> Self { ByteWriter { io } }
 
     pub fn write_buf(&mut self, buf: &[u8])  -> ByteIOResult<()> {
         self.io.write_buf(buf)
@@ -444,13 +446,13 @@ impl<'a> ByteWriter<'a> {
     }
 
     pub fn write_u64be(&mut self, val: u64) -> ByteIOResult<()> {
-        self.write_u32be(((val >> 32) & 0xFFFFFFFF) as u32)?;
-        self.write_u32be((val & 0xFFFFFFFF) as u32)
+        self.write_u32be((val >> 32) as u32)?;
+        self.write_u32be(val as u32)
     }
 
     pub fn write_u64le(&mut self, val: u64) -> ByteIOResult<()> {
-        self.write_u32le((val & 0xFFFFFFFF) as u32)?;
-        self.write_u32le(((val >> 32) & 0xFFFFFFFF) as u32)
+        self.write_u32le(val as u32)?;
+        self.write_u32le((val >> 32) as u32)
     }
 
     pub fn tell(&mut self) -> u64 {
@@ -472,7 +474,7 @@ impl<'a> MemoryWriter<'a> {
 
     pub fn new_write(buf: &'a mut [u8]) -> Self {
         let len = buf.len();
-        MemoryWriter { buf: buf, size: len, pos: 0 }
+        MemoryWriter { buf, size: len, pos: 0 }
     }
 
     fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
@@ -533,7 +535,7 @@ impl<'a> ByteIO for MemoryWriter<'a> {
         }
     }
 
-    fn is_eof(&mut self) -> bool {
+    fn is_eof(&self) -> bool {
         self.pos >= self.size
     }
 
@@ -548,7 +550,7 @@ impl<'a> ByteIO for MemoryWriter<'a> {
 
 impl FileWriter {
     pub fn new_write(file: File) -> Self {
-        FileWriter { file: file }
+        FileWriter { file }
     }
 }
 
@@ -597,7 +599,7 @@ impl ByteIO for FileWriter {
         }
     }
 
-    fn is_eof(&mut self) -> bool {
+    fn is_eof(&self) -> bool {
         false
     }
 
diff --git a/nihav-core/src/io/codebook.rs b/nihav-core/src/io/codebook.rs
index b86d0c1..4f041c6 100644
--- a/nihav-core/src/io/codebook.rs
+++ b/nihav-core/src/io/codebook.rs
@@ -55,14 +55,14 @@ fn fill_lut_msb(table: &mut Vec<u32>, off: usize,
         let fill_len  = lut_bits - bits;
         let fill_size = 1 << fill_len;
         let fill_code = code << (lut_bits - bits);
-        let lut_value = (symidx << 8) | (bits as u32);
+        let lut_value = (symidx << 8) | u32::from(bits);
         for j in 0..fill_size {
             let idx = (fill_code + j) as usize;
             table[idx + off] = lut_value;
         }
     } else {
         let idx = (code as usize) + off;
-        table[idx] = (symidx << 8) | 0x80 | (bits as u32);
+        table[idx] = (symidx << 8) | 0x80 | u32::from(bits);
     }
 }
 
@@ -75,11 +75,11 @@ fn fill_lut_lsb(table: &mut Vec<u32>, off: usize,
         let step = lut_bits - fill_len;
         for j in 0..fill_size {
             let idx = (fill_code + (j << step)) as usize;
-            table[idx + off] = (symidx << 8) | (bits as u32);
+            table[idx + off] = (symidx << 8) | u32::from(bits);
         }
     } else {
         let idx = (code as usize) + off;
-        table[idx] = (symidx << 8) | 0x80 | (bits as u32);
+        table[idx] = (symidx << 8) | 0x80 | u32::from(bits);
     }
 }
 
@@ -143,10 +143,10 @@ impl CodeBucket {
 type EscapeCodes = HashMap<u32, CodeBucket>;
 
 fn add_esc_code(cc: &mut EscapeCodes, key: u32, code: u32, bits: u8, idx: usize) {
-    if !cc.contains_key(&key) { cc.insert(key, CodeBucket::new()); }
+    cc.entry(key).or_insert_with(CodeBucket::new);
     let b = cc.get_mut(&key);
     if let Some(bucket) = b {
-        bucket.add_code(Code {code: code, bits: bits, idx: idx });
+        bucket.add_code(Code {code, bits, idx });
     } else { panic!("no bucket when expected!"); }
 }
 
@@ -178,7 +178,7 @@ fn build_esc_lut(table: &mut Vec<u32>,
         sec_bucket.offset = new_off as usize;
     }
 
-    for (_, sec_bucket) in &escape_list {
+    for sec_bucket in escape_list.values() {
         build_esc_lut(table, mode, sec_bucket)?;
     }
 
@@ -196,7 +196,7 @@ impl<S: Copy> Codebook<S> {
         for i in 0..cb.len() {
             let bits = cb.bits(i);
             if bits > 0 {
-                nnz = nnz + 1;
+                nnz += 1;
                 if cb.code(i) >= (1 << bits) {
                     return Err(CodebookError::InvalidCodebook);
                 }
@@ -208,7 +208,7 @@ impl<S: Copy> Codebook<S> {
                 let cval = extract_esc_part(code, bits, MAX_LUT_BITS, mode);
                 add_esc_code(&mut escape_list, ckey, cval, bits - MAX_LUT_BITS, symidx);
             }
-            if bits > 0 { symidx = symidx + 1; }
+            if bits > 0 { symidx += 1; }
         }
         if maxbits == 0 { return Err(CodebookError::InvalidCodebook); }
 
@@ -240,10 +240,10 @@ impl<S: Copy> Codebook<S> {
                     }
                 }
             }
-            symidx = symidx + 1;
+            symidx += 1;
         }
 
-        for (_, bucket) in &escape_list {
+        for bucket in escape_list.values() {
             build_esc_lut(&mut table, mode, &bucket)?;
         }
 
@@ -253,7 +253,7 @@ impl<S: Copy> Codebook<S> {
             }
         }
 
-        Ok(Codebook { table: table, syms: syms, lut_bits: maxbits })
+        Ok(Codebook { table, syms, lut_bits: maxbits })
     }
 }
 
@@ -272,8 +272,8 @@ impl<'a, S: Copy> CodebookReader<S> for BitReader<'a> {
             if (bits as isize) > self.left() {
                 return Err(CodebookError::InvalidCode);
             }
-            let skip_bits = if esc { lut_bits as u32 } else { bits };
-            if let Err(_) = self.skip(skip_bits as u32) {}
+            let skip_bits = if esc { u32::from(lut_bits) } else { bits };
+            self.skip(skip_bits as u32).unwrap();
             lut_bits = bits as u8;
         }
         Ok(cb.syms[idx])
@@ -286,7 +286,7 @@ pub struct FullCodebookDescReader<S> {
 
 impl<S> FullCodebookDescReader<S> {
     pub fn new(data: Vec<FullCodebookDesc<S>>) -> Self {
-        FullCodebookDescReader { data: data }
+        FullCodebookDescReader { data }
     }
 }
 
@@ -303,7 +303,7 @@ pub struct ShortCodebookDescReader {
 
 impl ShortCodebookDescReader {
     pub fn new(data: Vec<ShortCodebookDesc<>>) -> Self {
-        ShortCodebookDescReader { data: data }
+        ShortCodebookDescReader { data }
     }
 }
 
diff --git a/nihav-core/src/io/intcode.rs b/nihav-core/src/io/intcode.rs
index 8d87920..1c52d81 100644
--- a/nihav-core/src/io/intcode.rs
+++ b/nihav-core/src/io/intcode.rs
@@ -29,7 +29,7 @@ fn read_unary(br: &mut BitReader, terminator: u32) -> BitReaderResult<u32> {
     let mut res: u32 = 0;
     loop {
         if br.read(1)? == terminator { return Ok(res); }
-        res = res + 1;
+        res += 1;
     }
 }
 
@@ -37,7 +37,7 @@ fn read_unary_lim(br: &mut BitReader, len: u32, terminator: u32) -> BitReaderRes
     let mut res: u32 = 0;
     loop {
         if br.read(1)? == terminator { return Ok(res); }
-        res = res + 1;
+        res += 1;
         if res == len { return Ok(res); }
     }
 }
@@ -51,15 +51,15 @@ fn read_golomb(br: &mut BitReader, m: u8) -> BitReaderResult<u32> {
     if m == 0 { return Err(BitReaderError::InvalidValue); }
     let nbits = (8 - m.leading_zeros()) as u8;
     if (m & (m - 1)) == 0 { return read_rice(br, nbits); }
-    let cutoff = ((1 << nbits) - m) as u32;
+    let cutoff = u32::from((1 << nbits) - m);
     let pfx = read_unary(br, 0)?;
     let tail = br.read(nbits - 1)?;
     if tail < cutoff {
-        let res = pfx * (m as u32) + tail;
+        let res = pfx * u32::from(m) + tail;
         Ok (res)
     } else {
         let add = br.read(1)?;
-        let res = pfx * (m as u32) + (tail - cutoff) * 2 + add + cutoff;
+        let res = pfx * u32::from(m) + (tail - cutoff) * 2 + add + cutoff;
         Ok (res)
     }
 }