Fixed warnings

src/amdemod.rs

@@ -1,9 +1,12 @@
 pub struct SquaringAMDemodulator<'a> {
-    iterator: Box<Iterator<Item=f32> + 'a>,
+    iterator: Box<dyn Iterator<Item = f32> + 'a>,
 }
 
 impl<'a> SquaringAMDemodulator<'a> {
-    pub fn from<I>(iterator1: I) -> SquaringAMDemodulator<'a> where I: Iterator<Item=f32> + 'a {
+    pub fn from<I>(iterator1: I) -> SquaringAMDemodulator<'a>
+    where
+        I: Iterator<Item = f32> + 'a,
+    {
         SquaringAMDemodulator {
             iterator: Box::new(iterator1),
         }
@@ -16,7 +19,7 @@ impl<'a> Iterator for SquaringAMDemodulator<'a> {
     fn next(&mut self) -> Option<Self::Item> {
         match self.iterator.next() {
             Some(x) => Some((x * x).sqrt()),
-            None => None
+            None => None,
         }
     }
 }

src/aptsyncer.rs

@@ -1,51 +1,49 @@
-const SYNC_LENGHT : usize = 40;
-const SYNCA_SEQ : [bool; 40] = [false, false, false, false,
-                                true, true, false, false,   // Pulse 1
-                                true, true, false, false,   // Pulse 2
-                                true, true, false, false,   // Pulse 3
-                                true, true, false, false,   // Pulse 4
-                                true, true, false, false,   // Pulse 5
-                                true, true, false, false,   // Pulse 6
-                                true, true, false, false,   // Pulse 7
-                                false, false, false, false,
-                                false, false, false, false,];
-
-const SYNCB_SEQ : [bool; 40] = [false, false, false, false,
-                                true, true, true, false, false,
-                                true, true, true, false, false,
-                                true, true, true, false, false,
-                                true, true, true, false, false,
-                                true, true, true, false, false,
-                                true, true, true, false, false,
-                                true, true, true, false, false,
-                                false];
+const SYNC_LENGHT: usize = 40;
+const SYNCA_SEQ: [bool; 40] = [
+    false, false, false, false, true, true, false, false, // Pulse 1
+    true, true, false, false, // Pulse 2
+    true, true, false, false, // Pulse 3
+    true, true, false, false, // Pulse 4
+    true, true, false, false, // Pulse 5
+    true, true, false, false, // Pulse 6
+    true, true, false, false, // Pulse 7
+    false, false, false, false, false, false, false, false,
+];
 
+const SYNCB_SEQ: [bool; 40] = [
+    false, false, false, false, true, true, true, false, false, true, true, true, false, false,
+    true, true, true, false, false, true, true, true, false, false, true, true, true, false, false,
+    true, true, true, false, false, true, true, true, false, false, false,
+];
 
 pub enum SyncedSample {
     Sample(f32),
     SyncA(f32),
-    SyncB(f32)
+    SyncB(f32),
 }
 
 pub struct APTSyncer<'a> {
     state: [f32; SYNC_LENGHT],
-    pos : usize,
+    pos: usize,
     nones_read: usize,
-    avg_level : f32,
-    iterator: Box<Iterator<Item=f32> + 'a>
+    avg_level: f32,
+    iterator: Box<dyn Iterator<Item = f32> + 'a>,
 }
 
 impl<'a> APTSyncer<'a> {
-    pub fn from<I>(mut iterator: I) -> APTSyncer<'a> where I: Iterator<Item=f32> + 'a {
+    pub fn from<I>(mut iterator: I) -> APTSyncer<'a>
+    where
+        I: Iterator<Item = f32> + 'a,
+    {
         let mut state = [0.0; SYNC_LENGHT];
         let mut avg_level = 0.5;
         for i in 0..SYNC_LENGHT {
             match iterator.next() {
                 Some(x) => {
-                                state[i] = x;
-                                avg_level = 0.25 * x + avg_level * 0.75;
-                            },
-                None => panic!("Could not retrieve enough samples to prime syncer")
+                    state[i] = x;
+                    avg_level = 0.25 * x + avg_level * 0.75;
+                }
+                None => panic!("Could not retrieve enough samples to prime syncer"),
             }
         }
 
@@ -54,7 +52,7 @@ impl<'a> APTSyncer<'a> {
             pos: 0,
             nones_read: 0,
             avg_level: avg_level,
-            iterator: Box::new(iterator)
+            iterator: Box::new(iterator),
         }
     }
 
@@ -87,16 +85,15 @@ impl<'a> Iterator for APTSyncer<'a> {
     type Item = SyncedSample;
 
     fn next(&mut self) -> Option<Self::Item> {
-
         let (is_a, is_b) = self.is_marker();
 
         let sample = self.state[self.pos];
         match self.iterator.next() {
             Some(x) => {
-                            self.state[self.pos] = x;
-                            self.avg_level = 0.25 * x + self.avg_level * 0.75;
-                        },
-            None => self.nones_read += 1
+                self.state[self.pos] = x;
+                self.avg_level = 0.25 * x + self.avg_level * 0.75;
+            }
+            None => self.nones_read += 1,
         };
 
         if self.nones_read >= SYNC_LENGHT {
@@ -107,11 +104,9 @@ impl<'a> Iterator for APTSyncer<'a> {
 
         if is_a {
             return Some(SyncedSample::SyncA(sample));
-        }
-        else if is_b {
+        } else if is_b {
             return Some(SyncedSample::SyncB(sample));
-        }
-        else {
+        } else {
             return Some(SyncedSample::Sample(sample));
         }
     }

src/errors.rs

@@ -12,7 +12,4 @@ pub enum DecoderError {
 
     #[error("Unable to write output file: {0}")]
     OutputFileError(#[from] image::ImageError),
-
-    #[error("FIXME: Unknown decoder error")]
-    Unknown,
 }

src/firfilter.rs

@@ -2,11 +2,14 @@ pub struct FIRFilter<'a> {
     coeffs: &'a [f32],
     state: Vec<f32>,
     pos: usize,
-    iterator: Box<Iterator<Item=f32> + 'a>
+    iterator: Box<dyn Iterator<Item = f32> + 'a>,
 }
 
 impl<'a> FIRFilter<'a> {
-    pub fn from<I>(iterator: I, coeffs: &'a [f32]) -> FIRFilter<'a> where I: Iterator<Item=f32> + 'a {
+    pub fn from<I>(iterator: I, coeffs: &'a [f32]) -> FIRFilter<'a>
+    where
+        I: Iterator<Item = f32> + 'a,
+    {
         let mut state = Vec::new();
         for _ in 0..coeffs.len() {
             state.push(0.0);
@@ -16,7 +19,7 @@ impl<'a> FIRFilter<'a> {
             coeffs: coeffs,
             state: state,
             pos: 0,
-            iterator: Box::new(iterator)
+            iterator: Box::new(iterator),
         }
     }
 }
@@ -27,7 +30,7 @@ impl<'a> Iterator for FIRFilter<'a> {
     fn next(&mut self) -> Option<Self::Item> {
         let cur = match self.iterator.next() {
             Some(x) => x,
-            None => return None
+            None => return None,
         };
 
         self.pos = (self.pos + 1) % self.coeffs.len();
@@ -37,7 +40,7 @@ impl<'a> Iterator for FIRFilter<'a> {
         for i in 0..self.coeffs.len() {
             let pos = (self.pos + self.coeffs.len() - i) % self.coeffs.len();
             result += self.state[pos] * self.coeffs[i];
-        };
+        }
 
         Some(result)
     }

src/resamplers.rs

@@ -1,15 +1,18 @@
 pub struct Upsampler<'a> {
     factor: u16,
     state: u16,
-    iterator: Box<Iterator<Item=f32> + 'a>
+    iterator: Box<dyn Iterator<Item = f32> + 'a>,
 }
 
 impl<'a> Upsampler<'a> {
-    pub fn from<I>(iterator: I, factor: u16) -> Upsampler<'a> where I: Iterator<Item=f32> + 'a {
+    pub fn from<I>(iterator: I, factor: u16) -> Upsampler<'a>
+    where
+        I: Iterator<Item = f32> + 'a,
+    {
         Upsampler {
             factor: factor,
             state: 0,
-            iterator: Box::new(iterator)
+            iterator: Box::new(iterator),
         }
     }
 }
@@ -20,8 +23,7 @@ impl<'a> Iterator for Upsampler<'a> {
     fn next(&mut self) -> Option<Self::Item> {
         let result = if self.state == 0 {
             self.iterator.next()
-        }
-        else {
+        } else {
             Some(0.0)
         };
         self.state = (self.state + 1) % self.factor;
@@ -30,18 +32,19 @@ impl<'a> Iterator for Upsampler<'a> {
     }
 }
 
-
-
 pub struct Downsampler<'a> {
-        factor: u16,
-        iterator: Box<Iterator<Item=f32> + 'a>
+    factor: u16,
+    iterator: Box<dyn Iterator<Item = f32> + 'a>,
 }
 
 impl<'a> Downsampler<'a> {
-    pub fn from<I>(iterator: I, factor: u16) -> Downsampler<'a> where I: Iterator<Item=f32> + 'a {
+    pub fn from<I>(iterator: I, factor: u16) -> Downsampler<'a>
+    where
+        I: Iterator<Item = f32> + 'a,
+    {
         Downsampler {
             factor: factor,
-            iterator: Box::new(iterator)
+            iterator: Box::new(iterator),
         }
     }
 }
@@ -54,7 +57,7 @@ impl<'a> Iterator for Downsampler<'a> {
         for _ in 0..self.factor {
             match self.iterator.next() {
                 Some(x) => result += x,
-                None => return None
+                None => return None,
             }
         }
         result /= self.factor as f32;

src/utils.rs

@@ -6,7 +6,7 @@ type FileReader = std::io::BufReader<std::fs::File>;
 
 pub fn float_sample_iterator<'a>(
     reader: &'a mut hound::WavReader<FileReader>,
-) -> Box<Iterator<Item = f32> + 'a> {
+) -> Box<dyn Iterator<Item = f32> + 'a> {
     match reader.spec().sample_format {
         hound::SampleFormat::Float => Box::new(reader.samples::<f32>().map(|x| x.unwrap())),
         hound::SampleFormat::Int => match reader.spec().bits_per_sample {