Added buffered IO

And updated tests to reflect this

src/wavereader.rs

@@ -13,7 +13,7 @@ use super::chunks::ReadBWaveChunks;
 use super::cue::Cue;
 
 use std::io::Cursor;
-use std::io::{Read, Seek};
+use std::io::{Read, Seek, BufReader};
 
 
 
@@ -68,13 +68,22 @@ pub struct WaveReader<R: Read + Seek> {
     pub inner: R,
 }
 
+impl WaveReader<BufReader<File>> {
+
+    pub fn open(path: &str) -> Result<Self, ParserError> {
+        let f = File::open(path)?;
+        let inner = BufReader::new(f);
+        Ok( Self::new(inner)? )
+    }
+}
+
 impl WaveReader<File> {
     
-     /// Open a file for reading.
+     /// Open a file for reading with unbuffered IO.
      ///
      /// A convenience that opens `path` and calls `Self::new()`
      
-    pub fn open(path: &str) -> Result<Self, ParserError> {
+    pub fn open_unbuffered(path: &str) -> Result<Self, ParserError> {
         let inner = File::open(path)?;
         return Ok( Self::new(inner)? )
     }

src/wavewriter.rs

@@ -1,5 +1,5 @@
 use std::fs::File;
-use std::io::{Write,Seek,SeekFrom,Cursor};
+use std::io::{Write,Seek,SeekFrom,Cursor,BufWriter};
 
 use super::Error;
 use super::fourcc::{FourCC, WriteFourCC, RIFF_SIG, RF64_SIG, DS64_SIG,
@@ -209,10 +209,19 @@ pub struct WaveWriter<W> where W: Write + Seek {
 
 const DS64_RESERVATION_LENGTH : u32 = 96;
 
-impl WaveWriter<File> {
+impl WaveWriter<BufWriter<File>> {
 
     /// Create a new Wave file at `path`.
     pub fn create(path : &str, format : WaveFmt) -> Result<Self, Error> {
+        let f = File::create(path)?;
+        let b = BufWriter::new(f);
+        Ok( Self::new(b, format)? )
+    }
+}
+
+impl WaveWriter<File> {
+    /// Creare a new Wave file with unbuffered IO at `path`
+    pub fn create_unbuffered(path : &str, format : WaveFmt) -> Result<Self, Error> {
         let f = File::create(path)?;
         Ok( Self::new(f, format)? )
     }

tests/ffprobe_media_tests.rs

@@ -30,7 +30,7 @@ fn assert_match_stream<T>(stream_key: &str,
             .for_each(|value| {
                 let filen : &str = value["format"]["filename"].as_str().unwrap();
                 let json_value : &Value = &value["streams"][0][stream_key];
-                let mut wavfile = WaveReader::open(filen).unwrap();
+                let mut wavfile = WaveReader::open_unbuffered(filen).unwrap();
                 let wavfile_value: T = other(&mut wavfile);
                 println!("asserting {} for {}",stream_key, filen);
                 assert_eq!(Into::<Value>::into(wavfile_value), *json_value);

tests/integration_test.rs

@@ -165,7 +165,7 @@ fn test_frame_reader_consumes_reader() {
     use bwavfile::WaveFmt;
     use bwavfile::AudioFrameReader;
     use std::fs::File;
-    fn from_wav_filename(wav_filename: &str) -> Result<(WaveFmt, AudioFrameReader<File>), ()> {
+    fn from_wav_filename(wav_filename: &str) -> Result<(WaveFmt, AudioFrameReader<std::io::BufReader<File>>), ()> {
         if let Ok(mut r) = WaveReader::open(&wav_filename) {
             let format = r.format().unwrap();
             let frame_reader = r.audio_frame_reader().unwrap();