diff --git a/src/lib.rs b/src/lib.rs
index 33fce9b..48b1e2a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -111,8 +111,6 @@ mod common_format;
 
 mod parser;
 
-
-mod raw_chunk_reader;
 mod audio_frame_reader;
 mod list_form;
 
diff --git a/src/raw_chunk_reader.rs b/src/raw_chunk_reader.rs
deleted file mode 100644
index 5805475..0000000
--- a/src/raw_chunk_reader.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-use std::cmp::min;
-
-use std::io::SeekFrom;
-use std::io::SeekFrom::{Start, Current, End};
-use std::io::{Seek,Read,Error,ErrorKind};
-
-// I'm not sure this hasn't already been written somewhere in
-// std but I'm just doing this here as an exercise.
-#[derive(Debug)]
-pub struct RawChunkReader<'a, R: Read + Seek> {
-    reader: &'a mut R,
-    pub start: u64,
-    pub length: u64,
-    position: u64
-}
-
-impl<'a,R: Read + Seek> RawChunkReader<'a, R> {
-    pub fn new(reader: &'a mut R, start: u64, length: u64) -> Self {
-        return Self {
-            reader: reader, 
-            start: start, 
-            length: length, 
-            position: 0
-        }
-    }
-}
-
-impl<'a, R:Read + Seek> Read for RawChunkReader<'_, R> {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error> { 
-        if self.position >= self.length {
-            Ok(0)
-        } else {
-            self.reader.seek(Start(self.start + self.position))?;
-            let to_read = min(self.length - self.position, buf.len() as u64);
-            self.reader.take(to_read).read(buf)?;
-            self.position += to_read;
-            Ok(to_read as usize)
-        }
-    }
-}
-
-impl<'a, R:Read + Seek> Seek for RawChunkReader<'_, R> {
-    fn seek(&mut self, seek: SeekFrom) -> Result<u64, std::io::Error> { 
-        match seek {
-            Start(s) => {
-                self.position = s;
-                Ok(self.position)
-            },
-            Current(s) => {
-                let new_position = s + self.position as i64;
-                if new_position < 0 {
-                    Err( Error::new(ErrorKind::Other, "Attempted seek before beginning of chunk") )
-                } else {
-                    self.position = new_position as u64;
-                    Ok(self.position)
-                }
-            },
-            End(s) => {
-                let new_position = s + self.length as i64;
-                if new_position < 0 {
-                    Err( Error::new(ErrorKind::Other, "Attempted seek before beginning of chunk") )
-                } else {
-                    self.position = new_position as u64;
-                    Ok(self.position)
-                }
-            }
-        }
-    }
-}
diff --git a/src/wavereader.rs b/src/wavereader.rs
index f8c5592..eaad8cb 100644
--- a/src/wavereader.rs
+++ b/src/wavereader.rs
@@ -1,10 +1,11 @@
 
+use std::io::SeekFrom;
 use std::fs::File;
 
 use super::parser::Parser;
 use super::fourcc::{FourCC, ReadFourCC, FMT__SIG,DATA_SIG, BEXT_SIG, LIST_SIG, JUNK_SIG, FLLR_SIG, CUE__SIG, ADTL_SIG};
 use super::errors::Error as ParserError;
-use super::raw_chunk_reader::RawChunkReader;
+//use super::raw_chunk_reader::RawChunkReader;
 use super::fmt::{WaveFmt, ChannelDescriptor, ChannelMask};
 use super::bext::Bext;
 use super::audio_frame_reader::AudioFrameReader;
@@ -123,7 +124,9 @@ impl<R: Read + Seek> WaveReader<R> {
     /// Sample and frame format of this wave file.
     ///
     pub fn format(&mut self) -> Result<WaveFmt, ParserError> {
-        self.chunk_reader(FMT__SIG, 0)?.read_wave_fmt()
+        let (start, _) = self.get_chunk_extent_at_index(FMT__SIG, 0)?;
+        self.inner.seek(SeekFrom::Start(start))?;
+        self.inner.read_wave_fmt()
     }
 
     ///
@@ -385,10 +388,10 @@ impl<R:Read+Seek> WaveReader<R> {
     // As time passes thi get smore obnoxious because I haven't implemented recursive chunk 
     // parsing in the raw parser and I'm working around it
 
-    fn chunk_reader(&mut self, signature: FourCC, at_index: u32) -> Result<RawChunkReader<R>, ParserError> {
-        let (start, length) = self.get_chunk_extent_at_index(signature, at_index)?;
-        Ok( RawChunkReader::new(&mut self.inner, start, length) )
-    } 
+    // fn chunk_reader(&mut self, signature: FourCC, at_index: u32) -> Result<RawChunkReader<R>, ParserError> {
+    //     let (start, length) = self.get_chunk_extent_at_index(signature, at_index)?;
+    //     Ok( RawChunkReader::new(&mut self.inner, start, length) )
+    // } 
 
     fn read_list(&mut self, ident: FourCC, buffer: &mut Vec<u8>) -> Result<usize, ParserError> {
         if let Some(index) = self.get_list_form(ident)? {
@@ -398,15 +401,14 @@ impl<R:Read+Seek> WaveReader<R> {
         }
     }
 
-    fn read_chunk(&mut self, ident: FourCC, at: u32, buffer: &mut Vec<u8>) -> Result<usize, ParserError> {
-        let result = self.chunk_reader(ident, at);
 
-        match result {
-            Ok(mut chunk) => {
-                match chunk.read_to_end(buffer) {
-                    Ok(read) => Ok(read),
-                    Err(err) => Err(err.into())
-                }
+    fn read_chunk(&mut self, ident: FourCC, at: u32, mut buffer: &mut Vec<u8>) -> Result<usize, ParserError> {
+
+        match self.get_chunk_extent_at_index(ident, at) {
+            Ok((start, length)) => {
+                buffer.resize(length as usize, 0x0);
+                self.inner.seek(SeekFrom::Start(start))?;
+                self.inner.read(&mut buffer).map_err(|e| ParserError::IOError(e))
             },
             Err(ParserError::ChunkMissing { signature : _} ) => Ok(0),
             Err( any ) => Err(any.into())
@@ -423,9 +425,9 @@ impl<R:Read+Seek> WaveReader<R> {
 
     /// Index of first LIST for with the given FORM fourcc
     fn get_list_form(&mut self, fourcc: FourCC) -> Result<Option<u32>, ParserError> {
-        for (n, (start, length)) in self.get_chunks_extents(LIST_SIG)?.iter().enumerate() {
-            let mut reader = RawChunkReader::new(&mut self.inner, *start, *length);
-            let this_fourcc = reader.read_fourcc()?;
+        for (n, (start, _)) in self.get_chunks_extents(LIST_SIG)?.iter().enumerate() {
+            self.inner.seek(SeekFrom::Start(*start as u64))?;
+            let this_fourcc = self.inner.read_fourcc()?;
             if this_fourcc == fourcc {
                 return Ok( Some( n as u32 ) );
             }