Formatted with rustfmt and added to to pre-commit hooks

.pre-commit-config.yaml

@@ -15,4 +15,11 @@ repos:
         language: system
         args: ["--", "-D", "warnings"]
         types: [rust]
-        pass_filenames: false
+        pass_filenames: false
+    -   id: fmt
+        name: fmt
+        description: Check files formating with cargo fmt.
+        entry: cargo fmt
+        language: system
+        types: [rust]
+        args: ["--", "--check"]

README.md

@@ -49,7 +49,9 @@ apt-get install libsndfile1-dev
 ```
 
 # Installation
-TBD
+```
+cargo install audeye
+```
 
 # Build
 1. [Install Rust](https://www.rust-lang.org/tools/install)
@@ -59,6 +61,13 @@ TBD
 ## Development
 Please consider audeye is still in early development, feedbacks are very welcome
 
+### Requirements
+ - [cargo](https://doc.rust-lang.org/cargo/getting-started/installation.html)
+ - [libsndfile](#dependencies)
+ - [precommit](https://pre-commit.com/#install)
+ - [clippy](https://github.com/rust-lang/rust-clippy)
+ - [rustfmt](https://github.com/rust-lang/rustfmt)
+
 ### Contributing
 If you wanna contribute, either make a PR (for small changes/adds) or contact me
 on twitter / discord if you wanna get involved more deeply

src/dsp/data.rs

@@ -1,7 +1,7 @@
 use core::fmt;
 use std::marker::PhantomData;
-use std::sync::mpsc::{Receiver, self};
-use std::thread::{JoinHandle, self};
+use std::sync::mpsc::{self, Receiver};
+use std::thread::{self, JoinHandle};
 
 extern crate sndfile;
 use crate::sndfile::SndFile;
@@ -10,13 +10,13 @@ use super::normalization::compute_norm;
 
 #[derive(Debug)]
 pub struct DspErr {
-    msg: String
+    msg: String,
 }
 
 impl DspErr {
     pub fn new(msg: &str) -> Self {
-        Self{
-            msg: msg.to_string()
+        Self {
+            msg: msg.to_string(),
         }
     }
 }
@@ -28,28 +28,29 @@ impl fmt::Display for DspErr {
 }
 
 pub trait DspData<P> {
-    fn new(file: SndFile, parameter: P, normalize: Option<f64>) -> Result<Self, DspErr> where Self: Sized;
+    fn new(file: SndFile, parameter: P, normalize: Option<f64>) -> Result<Self, DspErr>
+    where
+        Self: Sized;
 }
 
-
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum AsyncDspDataState {
     Created,
     Normalizing,
     Processing,
     Failed,
-    Finished
+    Finished,
 }
 
-pub struct AsyncDspData<T : DspData<P> + Send + 'static, P : Send + 'static> {
+pub struct AsyncDspData<T: DspData<P> + Send + 'static, P: Send + 'static> {
     state: AsyncDspDataState,
     pub data: Option<T>,
     rendered_rx: Receiver<AsyncDspDataState>,
     process_handle: Option<JoinHandle<T>>,
-    phantom : PhantomData<P>
+    phantom: PhantomData<P>,
 }
 
-impl<T : DspData<P> + Send + 'static, P : Send + 'static> AsyncDspData<T, P> {
+impl<T: DspData<P> + Send + 'static, P: Send + 'static> AsyncDspData<T, P> {
     pub fn update_status(&mut self) -> bool {
         let mut update_needed = false;
 
@@ -61,27 +62,27 @@ impl<T : DspData<P> + Send + 'static, P : Send + 'static> AsyncDspData<T, P> {
                     self.state = AsyncDspDataState::Finished;
                     update_needed = true;
                     break;
-                },
+                }
                 Ok(AsyncDspDataState::Failed) => {
                     // Failed to render, try to join to catch error
                     let opt_handle = self.process_handle.take();
                     match opt_handle {
-                        Some(handle) => {
-                            match handle.join() {
-                                Ok(_) => panic!("Async rendering sent failed signal but succeeded"),
-                                Err(err) => panic!("{:?}", err)
-                            }
+                        Some(handle) => match handle.join() {
+                            Ok(_) => panic!("Async rendering sent failed signal but succeeded"),
+                            Err(err) => panic!("{:?}", err),
                         },
-                        None => panic!("Async rendering handle is None")
+                        None => panic!("Async rendering handle is None"),
                     }
-                },
+                }
                 Ok(new_state) => {
                     self.state = new_state;
                     update_needed = true;
                 }
-                _ => { break; }
+                _ => {
+                    break;
+                }
             }
-        };
+        }
 
         update_needed
     }
@@ -99,14 +100,15 @@ impl<T : DspData<P> + Send + 'static, P : Send + 'static> AsyncDspData<T, P> {
         match opt_handle {
             Some(handle) => {
                 self.data = Some(handle.join().expect("Async rendering failed"));
-            },
-            None => panic!("Async rendering handle is None")
+            }
+            None => panic!("Async rendering handle is None"),
         }
     }
 
     pub fn new(path: &std::path::PathBuf, parameters: P, normalize: bool) -> Self {
         let mut snd = sndfile::OpenOptions::ReadOnly(sndfile::ReadOptions::Auto)
-            .from_path(path).expect("Could not open wave file");
+            .from_path(path)
+            .expect("Could not open wave file");
         if !snd.is_seekable() {
             panic!("Input file is not seekable");
         }
@@ -131,7 +133,7 @@ impl<T : DspData<P> + Send + 'static, P : Send + 'static> AsyncDspData<T, P> {
                     // Success, we update the state and return the data
                     let _ = rendered_tx.send(AsyncDspDataState::Finished);
                     data
-                },
+                }
                 Err(dsp_err) => {
                     // Failure, we stop the program and display the error
                     let _ = rendered_tx.send(AsyncDspDataState::Failed);
@@ -145,7 +147,7 @@ impl<T : DspData<P> + Send + 'static, P : Send + 'static> AsyncDspData<T, P> {
             data: None,
             rendered_rx,
             process_handle: Some(join_handle),
-            phantom: PhantomData::default()
+            phantom: PhantomData::default(),
         }
     }
 }

src/dsp/mod.rs

@@ -1,10 +1,12 @@
+mod data;
+mod normalization;
 mod spectrogram;
 mod time_window;
 mod waveform;
-mod data;
-mod normalization;
 
+pub use data::{AsyncDspData, AsyncDspDataState, DspData, DspErr};
 pub use spectrogram::{Spectrogram, SpectrogramParameters};
+pub use time_window::{
+    SidePaddingType, SidePaddingTypeParseError, WindowType, WindowTypeParseError, PADDING_HELP_TEXT,
+};
 pub use waveform::{Waveform, WaveformParameters, WaveformPoint};
-pub use data::{DspData, DspErr, AsyncDspData, AsyncDspDataState};
-pub use time_window::{WindowType, WindowTypeParseError, SidePaddingType, SidePaddingTypeParseError, PADDING_HELP_TEXT};

src/dsp/normalization.rs

@@ -14,10 +14,10 @@ fn clamp(val: &i32) -> i32 {
 pub fn compute_norm(sndfile: &mut SndFile) -> f64 {
     let data: Vec<i32> = sndfile.read_all_to_vec().unwrap();
 
-    let max = data.par_iter().map(|val| { clamp(val).abs()}).max().unwrap();
+    let max = data.par_iter().map(|val| clamp(val).abs()).max().unwrap();
 
     if max <= 0i32 {
         return f64::EPSILON;
     }
     max as f64 / i32::MAX as f64
-}
+}