Merge pull request #67 from instaclustr/wavcleanup

Code cleanup

brro-compressor/src/main.rs

@@ -36,6 +36,7 @@ fn process_directory(arguments: &Args) -> Result<(), Box<dyn Error>> {
     for entry in std::fs::read_dir(arguments.input.clone())? {
         let path = entry?.path();
         if path.is_file() {
+            // We need to make sure we skip anything but BRO and WBRO, this can be done on single file processors
             process_single_file(path, arguments)?;
         }
     }

brro-compressor/src/optimizer/mod.rs

@@ -2,6 +2,8 @@ use log::debug;
 use types::metric_tag::MetricTag;
 use crate::{types, utils::{prev_power_of_two, f64_to_u64}, compressor::Compressor};
 
+pub mod utils;
+
 /// Max Frame size, this can aprox. 36h of data at 1point/sec rate, a little more than 1 week at 1point/5sec
 /// and 1 month (30 days) at 1 point/20sec. 
 /// This would be aprox. 1MB of Raw data (131072 * 64bits).

brro-compressor/src/utils/writers/wav_writer.rs → brro-compressor/src/optimizer/utils.rs

@@ -1,25 +1,5 @@
-use std::path::PathBuf;
-use hound::{WavSpec, WavWriter};
-use log::info;
+use log::debug;
 
-// Function to create a streaming writer for a file
-pub fn write_optimal_wav(mut path: PathBuf, data: Vec<f64>, channels: i32) {
-    let (bitdepth, dc, _fractional) = analyze_data(&data);
-    // Make DC a float for operations
-    let fdc = dc as f64;
-    let header: WavSpec = generate_wav_header(Some(channels), bitdepth as u16, 8000);
-    path.set_extension("wav");
-    let file = std::fs::OpenOptions::new().write(true).create(true).read(true).open(path).unwrap();
-    let mut wav_writer = WavWriter::new(file, header).unwrap();
-    for sample in data {
-        let _ = match bitdepth {
-            8 =>  wav_writer.write_sample(as_i8(sample-fdc)),
-            16 => wav_writer.write_sample(as_i16(sample-fdc)),
-            _ => wav_writer.write_sample(as_i32(sample-fdc))
-        };
-    }
-    let _ = wav_writer.finalize();
-}
 fn as_i8(value: f64) -> i8 {
     split_n(value).0 as i8
 }
@@ -71,25 +51,6 @@ fn split_n(x: f64) -> (i64, f64) {
     }
 }
 
-fn join_u16_into_f64(bits: [u16; 4]) -> f64 {
-    let u64_bits = (bits[0] as u64) |
-        ((bits[1] as u64) << 16) |
-        ((bits[2] as u64) << 32) |
-        ((bits[3] as u64) << 48);
-
-
-    f64::from_bits(u64_bits)
-}
-fn generate_wav_header(channels: Option<i32>, bitdepth: u16, samplerate: u32) -> WavSpec {
-
-    hound::WavSpec {
-        channels: channels.unwrap_or(4) as u16,
-        // TODO: Sample rate adaptations
-        sample_rate: samplerate,
-        bits_per_sample: bitdepth,
-        sample_format: hound::SampleFormat::Int
-    }
-}
 fn analyze_data(data: &Vec<f64>) -> (i32, i64, bool) {
     let mut min: f64 = 0.0;
     let mut max: f64 = 0.0;
@@ -112,9 +73,9 @@ fn analyze_data(data: &Vec<f64>) -> (i32, i64, bool) {
     // Finding the bitdepth without the DC component
     let recommended_bitdepth = find_bitdepth(max_int-min_int, min_int);
     if !fractional {
-        info!(" Recommended Bitdepth: {} ", recommended_bitdepth);
+        debug!(" Recommended Bitdepth: {} ", recommended_bitdepth);
     } else {
-        info!(" Fractional, Recommended Bitdepth: {}, Fractions max: {}", recommended_bitdepth, max_frac);
+        debug!(" Fractional, Recommended Bitdepth: {}, Fractions max: {}", recommended_bitdepth, max_frac);
     }
     (recommended_bitdepth, min_int, fractional)
 }
@@ -135,6 +96,5 @@ fn find_bitdepth(max_int: i64, min_int: i64) -> i32 {
         _ => 64
     };
 
-
     bitdepth.max(bitdepth_signed)
 }

brro-compressor/src/utils/mod.rs

@@ -1,9 +1,6 @@
 pub mod error;
 pub mod writers;
 pub mod readers;
-
-mod file_type_detector;
-
 // Is this the right place?
 pub fn prev_power_of_two(n: usize) -> usize {
     // n = 0 gives highest_bit_set_idx = 0.

brro-compressor/src/utils/readers/mod.rs

@@ -1,2 +1 @@
-pub mod bro_reader;
-pub mod wav_reader;
+pub mod bro_reader;

brro-compressor/src/utils/writers/mod.rs

@@ -1 +0,0 @@
-pub mod wav_writer;

wavbrro/src/wavbrro.rs

@@ -58,11 +58,13 @@ impl WavBrro {
     }
 
     // Receives a slice of f64 and writes in it's internal structure
-    fn load_slice(&mut self, data: &[f64]) {
-        let size = data.len();
-        let inner = data.chunks(MAX_CHUNK_SIZE).map(|s| s.into()).collect();
-        self.chunks = inner;
-        self.sample_count = size as u32;
+    fn from_slice(data: &[f64]) -> Self {
+        let sample_count = data.len();
+        WavBrro {
+                sample_count: sample_count as u32,
+                bitdepth: 5,
+                chunks: data.chunks(MAX_CHUNK_SIZE).map(|s| s.into()).collect()
+            }
     }
 
     pub fn add_sample(&mut self, sample: f64) {
@@ -91,8 +93,7 @@ impl WavBrro {
 
     // TODO: This will panic left and right, make it right
     pub fn to_file_with_data(file_path: &Path, data: &[f64]) {
-        let mut wb = WavBrro::new();
-        wb.load_slice(data);
+        let wb = WavBrro::from_slice(data);
         let bytes = wb.to_bytes();
         write_wavbrro_file(file_path, &bytes);
     }