cargo fmt --all

Author: Yoric

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "range-encoding"
-version = "0.2.0"
+version = "0.2.1"
 authors = ["David Teller <[email protected]>"]
 description = "An implementation of range encoding (entropy coding), extracted from Opus."
 readme = "README.md"

src/lib.rs

@@ -4,11 +4,11 @@ pub mod opus {
     mod imported_decode;
     mod imported_encode;
 
-    mod encode;
     mod decode;
+    mod encode;
 
-    pub use self::encode::Writer;
     pub use self::decode::Reader;
+    pub use self::encode::Writer;
 }
 
 #[derive(Clone)]
@@ -21,10 +21,7 @@ pub struct Segment {
 }
 impl Segment {
     pub fn new(low: u32, next: u32) -> Segment {
-        Segment {
-            low,
-            next,
-        }
+        Segment { low, next }
     }
     pub fn width(&self) -> u32 {
         self.next - self.low
@@ -53,8 +50,7 @@ impl CumulativeDistributionFrequency {
             start = next;
         }
         Self {
-            segments: segments
-                .into_boxed_slice(),
+            segments: segments.into_boxed_slice(),
             width: start,
         }
     }
@@ -66,28 +62,30 @@ impl CumulativeDistributionFrequency {
 
     /// Iterate through the widths of the symbols.
     pub fn widths<'a>(&'a self) -> impl Iterator<Item = u32> + 'a {
-        self.segments.iter()
-            .map(Segment::width)
+        self.segments.iter().map(Segment::width)
     }
 
     /// Find a value from its frequency.
     pub fn find(&self, probability: u32) -> Option<IndexedSegment> {
         if probability >= self.width {
-            return None
+            return None;
         }
-        let index = self.segments.binary_search_by(|segment| {
-            use std::cmp::Ordering;
-            if segment.low > probability {
-                return Ordering::Greater
-            }
-            if segment.next <= probability {
-                return Ordering::Less
-            }
-            Ordering::Equal
-        }).ok()?;
+        let index = self
+            .segments
+            .binary_search_by(|segment| {
+                use std::cmp::Ordering;
+                if segment.low > probability {
+                    return Ordering::Greater;
+                }
+                if segment.next <= probability {
+                    return Ordering::Less;
+                }
+                Ordering::Equal
+            })
+            .ok()?;
         Some(IndexedSegment {
             index,
-            segment: self.segments[index].clone()
+            segment: self.segments[index].clone(),
         })
     }
 

src/opus/decode.rs

@@ -1,28 +1,33 @@
-
-use ::CumulativeDistributionFrequency;
+use CumulativeDistributionFrequency;
 
 use opus::imported_decode;
 
 use std;
 
-pub struct Reader<R> where R: std::io::Read {
+pub struct Reader<R>
+where
+    R: std::io::Read,
+{
     state: imported_decode::ec_dec<R>,
 }
 
-impl<R> Reader<R> where R: std::io::Read {
-/*
-    pub fn from_boxed_slice(mut source: Box<[u8]>) -> Self {
-        let state = unsafe {
-            let mut state : imported_decode::ec_dec = std::mem::uninitialized();
-            imported_decode::ec_dec_init(&mut state, source.as_mut_ptr(), source.len() as u32);
-            state
-        };
-        Reader {
-            source,
-            state
+impl<R> Reader<R>
+where
+    R: std::io::Read,
+{
+    /*
+        pub fn from_boxed_slice(mut source: Box<[u8]>) -> Self {
+            let state = unsafe {
+                let mut state : imported_decode::ec_dec = std::mem::uninitialized();
+                imported_decode::ec_dec_init(&mut state, source.as_mut_ptr(), source.len() as u32);
+                state
+            };
+            Reader {
+                source,
+                state
+            }
         }
-    }
-*/
+    */
     pub fn new(input: R) -> Result<Self, std::io::Error> {
         let mut state = imported_decode::ec_dec {
             inp: input,
@@ -35,39 +40,48 @@ impl<R> Reader<R> where R: std::io::Read {
             val: 0,
             ext: 0,
         };
-        unsafe { imported_decode::ec_dec_init(&mut state)?; }
-        Ok(Reader {
-            state
-        })
+        unsafe {
+            imported_decode::ec_dec_init(&mut state)?;
+        }
+        Ok(Reader { state })
     }
 
     /// Decode the next symbol in line.
-    pub fn symbol(&mut self, icdf: &CumulativeDistributionFrequency) -> Result<u32, std::io::Error> {
+    pub fn symbol(
+        &mut self,
+        icdf: &CumulativeDistributionFrequency,
+    ) -> Result<u32, std::io::Error> {
         let index = unsafe {
             let frequency = imported_decode::ec_decode(&mut self.state, icdf.width());
-            let indexed= icdf.find(frequency)
-                .ok_or_else(|| std::io::Error::new(std::io::ErrorKind::InvalidInput, "Invalid probability"))?;
-            imported_decode::ec_dec_update(&mut self.state, indexed.segment.low, indexed.segment.next, icdf.width())?;
+            let indexed = icdf.find(frequency).ok_or_else(|| {
+                std::io::Error::new(std::io::ErrorKind::InvalidInput, "Invalid probability")
+            })?;
+            imported_decode::ec_dec_update(
+                &mut self.state,
+                indexed.segment.low,
+                indexed.segment.next,
+                icdf.width(),
+            )?;
             indexed.index
         };
         Ok(index as u32)
     }
 
-/*
-// FIXME: I actually don't understand `bits()` well enough
-// to publish it.    /// Encode a sequence of raw bits, without any frequency information.
-    pub fn bits(&mut self, size: usize) -> Result<u16, std::io::Error> {
-        let result = unsafe {
-            let result = imported_decode::ec_dec_bits(&mut self.state,
-                size as u32);
-            self.check_status()?;
-            result as u16
-        };
-        Ok(result)
-    }
-*/
+    /*
+    // FIXME: I actually don't understand `bits()` well enough
+    // to publish it.    /// Encode a sequence of raw bits, without any frequency information.
+        pub fn bits(&mut self, size: usize) -> Result<u16, std::io::Error> {
+            let result = unsafe {
+                let result = imported_decode::ec_dec_bits(&mut self.state,
+                    size as u32);
+                self.check_status()?;
+                result as u16
+            };
+            Ok(result)
+        }
+    */
 
     pub fn done(self) {
         // FIXME: Nothing to do?
     }
-}
+}

src/opus/encode.rs

@@ -30,8 +30,9 @@ impl<W> Writer<W> where W: std::io::Write {
     /// Encode the next symbol in line.
     pub fn symbol(&mut self, index: usize, icdf: &CumulativeDistributionFrequency) -> Result<(), std::io::Error> {
         let width = icdf.width();
-        let segment = icdf.at_index(index)
-          .ok_or_else(|| std::io::Error::new(std::io::ErrorKind::InvalidInput, "Invalid symbol"))?;
+        let segment = icdf.at_index(index).ok_or_else(|| {
+            std::io::Error::new(std::io::ErrorKind::InvalidInput, "Invalid symbol")
+        })?;
         unsafe {
             imported_encode::ec_encode(&mut self.state, segment.low, segment.next, width)?;
         };