Refactor

examples/mp4info.rs

@@ -1,6 +1,7 @@
 use mp4;
 use std::env;
 use std::fs::File;
+use std::io::BufReader;
 
 fn main() {
     let args: Vec<String> = env::args().collect();
@@ -9,15 +10,18 @@ fn main() {
         2 => {
             let filename = &args[1];
             let f = File::open(filename).unwrap();
+            let size = f.metadata().unwrap().len();
+            let reader = BufReader::new(f);
 
-            let bmff = mp4::BMFF::read_from_file(f).unwrap();
-            let moov = bmff.moov.unwrap();
+            let mut mp4 = mp4::Mp4Reader::new(reader);
+            mp4.read(size).unwrap();
 
-            // Print results.
             println!("File:");
-            println!("  size:  {}", bmff.size);
+            println!("  size:  {}", mp4.size());
             println!("  brands:     {:?} {:?}\n",
-                     bmff.ftyp.major_brand, bmff.ftyp.compatible_brands);
+                     mp4.ftyp.major_brand, mp4.ftyp.compatible_brands);
+
+            let moov = mp4.moov.unwrap();
 
             println!("Movie:");
             println!("  version:       {:?}", moov.mvhd.version);

src/atoms/avc.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, Seek, Read, BufWriter, Write};
+use std::io::{Seek, Read, Write};
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 use num_rational::Ratio;
 
@@ -43,8 +43,8 @@ impl Mp4Box for Avc1Box {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for Avc1Box {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for Avc1Box {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         reader.read_u32::<BigEndian>()?; // reserved
@@ -89,8 +89,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for Avc1Box {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for Avc1Box {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for Avc1Box {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 
@@ -149,8 +149,8 @@ impl Mp4Box for AvcCBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for AvcCBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for AvcCBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let configuration_version = reader.read_u8()?;
@@ -185,8 +185,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for AvcCBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for AvcCBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for AvcCBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 
@@ -218,7 +218,7 @@ impl NalUnit {
         2 + self.bytes.len()
     }
 
-    pub fn read<R: Read + Seek>(reader: &mut BufReader<R>) -> Result<Self> {
+    pub fn read<R: Read + Seek>(reader: &mut R) -> Result<Self> {
         let length = reader.read_u16::<BigEndian>()? as usize;
         let mut bytes = vec![0u8; length];
         reader.read(&mut bytes)?;
@@ -227,7 +227,7 @@ impl NalUnit {
         })
     }
 
-    pub fn write<W: Write>(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+    pub fn write<W: Write>(&self, writer: &mut W) -> Result<u64> {
         writer.write_u16::<BigEndian>(self.bytes.len() as u16)?;
         writer.write(&self.bytes)?;
         Ok(self.size() as u64)

src/atoms/co64.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, Seek, Read, BufWriter, Write};
+use std::io::{Seek, Read, Write};
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 
 use crate::*;
@@ -22,8 +22,8 @@ impl Mp4Box for Co64Box {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for Co64Box {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for Co64Box {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let (version, flags) = read_box_header_ext(reader)?;
@@ -45,8 +45,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for Co64Box {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for Co64Box {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for Co64Box {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 
@@ -75,21 +75,15 @@ mod tests {
             entries: vec![267, 1970, 2535, 2803, 11843, 22223, 33584],
         };
         let mut buf = Vec::new();
-        {
-            let mut writer = BufWriter::new(&mut buf);
-            src_box.write_box(&mut writer).unwrap();
-        }
+        src_box.write_box(&mut buf).unwrap();
         assert_eq!(buf.len(), src_box.box_size() as usize);
 
-        {
-            let mut reader = BufReader::new(Cursor::new(&buf));
-            let header = BoxHeader::read(&mut reader).unwrap();
-            assert_eq!(header.name, BoxType::Co64Box);
-            assert_eq!(src_box.box_size(), header.size);
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::Co64Box);
+        assert_eq!(src_box.box_size(), header.size);
 
-            let dst_box = Co64Box::read_box(&mut reader, header.size).unwrap();
-
-            assert_eq!(src_box, dst_box);
-        }
+        let dst_box = Co64Box::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
     }
 }

src/atoms/edts.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, Seek, Read, BufWriter, Write};
+use std::io::{Seek, Read, Write};
 
 use crate::*;
 use crate::atoms::*;
@@ -30,8 +30,8 @@ impl Mp4Box for EdtsBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for EdtsBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for EdtsBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let mut edts = EdtsBox::new();
@@ -53,8 +53,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for EdtsBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for EdtsBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for EdtsBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 

src/atoms/elst.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, Seek, Read, BufWriter, Write};
+use std::io::{Seek, Read, Write};
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 
 use crate::*;
@@ -37,8 +37,8 @@ impl Mp4Box for ElstBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for ElstBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for ElstBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let (version, flags) = read_box_header_ext(reader)?;
@@ -78,8 +78,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for ElstBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for ElstBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for ElstBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 
@@ -121,22 +121,16 @@ mod tests {
             }],
         };
         let mut buf = Vec::new();
-        {
-            let mut writer = BufWriter::new(&mut buf);
-            src_box.write_box(&mut writer).unwrap();
-        }
+        src_box.write_box(&mut buf).unwrap();
         assert_eq!(buf.len(), src_box.box_size() as usize);
 
-        {
-            let mut reader = BufReader::new(Cursor::new(&buf));
-            let header = BoxHeader::read(&mut reader).unwrap();
-            assert_eq!(header.name, BoxType::ElstBox);
-            assert_eq!(src_box.box_size(), header.size);
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::ElstBox);
+        assert_eq!(src_box.box_size(), header.size);
 
-            let dst_box = ElstBox::read_box(&mut reader, header.size).unwrap();
-
-            assert_eq!(src_box, dst_box);
-        }
+        let dst_box = ElstBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
     }
 
     #[test]
@@ -152,21 +146,15 @@ mod tests {
             }],
         };
         let mut buf = Vec::new();
-        {
-            let mut writer = BufWriter::new(&mut buf);
-            src_box.write_box(&mut writer).unwrap();
-        }
+        src_box.write_box(&mut buf).unwrap();
         assert_eq!(buf.len(), src_box.box_size() as usize);
 
-        {
-            let mut reader = BufReader::new(Cursor::new(&buf));
-            let header = BoxHeader::read(&mut reader).unwrap();
-            assert_eq!(header.name, BoxType::ElstBox);
-            assert_eq!(src_box.box_size(), header.size);
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::ElstBox);
+        assert_eq!(src_box.box_size(), header.size);
 
-            let dst_box = ElstBox::read_box(&mut reader, header.size).unwrap();
-
-            assert_eq!(src_box, dst_box);
-        }
+        let dst_box = ElstBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
     }
 }

src/atoms/ftyp.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, Seek, Read, BufWriter, Write};
+use std::io::{Seek, Read, Write};
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 
 use crate::*;
@@ -22,8 +22,8 @@ impl Mp4Box for FtypBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for FtypBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for FtypBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let major = reader.read_u32::<BigEndian>()?;
@@ -49,8 +49,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for FtypBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for FtypBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for FtypBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 
@@ -82,21 +82,15 @@ mod tests {
             ]
         };
         let mut buf = Vec::new();
-        {
-            let mut writer = BufWriter::new(&mut buf);
-            src_box.write_box(&mut writer).unwrap();
-        }
+        src_box.write_box(&mut buf).unwrap();
         assert_eq!(buf.len(), src_box.box_size() as usize);
 
-        {
-            let mut reader = BufReader::new(Cursor::new(&buf));
-            let header = BoxHeader::read(&mut reader).unwrap();
-            assert_eq!(header.name, BoxType::FtypBox);
-            assert_eq!(src_box.box_size(), header.size);
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::FtypBox);
+        assert_eq!(src_box.box_size(), header.size);
 
-            let dst_box = FtypBox::read_box(&mut reader, header.size).unwrap();
-
-            assert_eq!(src_box, dst_box);
-        }
+        let dst_box = FtypBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
     }
 }

src/atoms/hdlr.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, Seek, Read, BufWriter, Write};
+use std::io::{Seek, Read, Write};
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 
 use crate::*;
@@ -23,8 +23,8 @@ impl Mp4Box for HdlrBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for HdlrBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for HdlrBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let (version, flags) = read_box_header_ext(reader)?;
@@ -57,8 +57,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for HdlrBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for HdlrBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for HdlrBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 
@@ -94,21 +94,15 @@ mod tests {
             name: String::from("VideoHandler"),
         };
         let mut buf = Vec::new();
-        {
-            let mut writer = BufWriter::new(&mut buf);
-            src_box.write_box(&mut writer).unwrap();
-        }
+        src_box.write_box(&mut buf).unwrap();
         assert_eq!(buf.len(), src_box.box_size() as usize);
 
-        {
-            let mut reader = BufReader::new(Cursor::new(&buf));
-            let header = BoxHeader::read(&mut reader).unwrap();
-            assert_eq!(header.name, BoxType::HdlrBox);
-            assert_eq!(src_box.box_size(), header.size);
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::HdlrBox);
+        assert_eq!(src_box.box_size(), header.size);
 
-            let dst_box = HdlrBox::read_box(&mut reader, header.size).unwrap();
-
-            assert_eq!(src_box, dst_box);
-        }
+        let dst_box = HdlrBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
     }
 }

src/atoms/mdhd.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, Seek, Read, BufWriter, Write};
+use std::io::{Seek, Read, Write};
 use std::char::{decode_utf16, REPLACEMENT_CHARACTER};
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 
@@ -50,8 +50,8 @@ impl Mp4Box for MdhdBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for MdhdBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for MdhdBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let (version, flags) = read_box_header_ext(reader)?;
@@ -90,8 +90,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for MdhdBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for MdhdBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for MdhdBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 
@@ -172,22 +172,16 @@ mod tests {
             language: String::from("und"),
         };
         let mut buf = Vec::new();
-        {
-            let mut writer = BufWriter::new(&mut buf);
-            src_box.write_box(&mut writer).unwrap();
-        }
+        src_box.write_box(&mut buf).unwrap();
         assert_eq!(buf.len(), src_box.box_size() as usize);
 
-        {
-            let mut reader = BufReader::new(Cursor::new(&buf));
-            let header = BoxHeader::read(&mut reader).unwrap();
-            assert_eq!(header.name, BoxType::MdhdBox);
-            assert_eq!(src_box.box_size(), header.size);
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::MdhdBox);
+        assert_eq!(src_box.box_size(), header.size);
 
-            let dst_box = MdhdBox::read_box(&mut reader, header.size).unwrap();
-
-            assert_eq!(src_box, dst_box);
-        }
+        let dst_box = MdhdBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
     }
 
     #[test]
@@ -202,21 +196,15 @@ mod tests {
             language: String::from("eng"),
         };
         let mut buf = Vec::new();
-        {
-            let mut writer = BufWriter::new(&mut buf);
-            src_box.write_box(&mut writer).unwrap();
-        }
+        src_box.write_box(&mut buf).unwrap();
         assert_eq!(buf.len(), src_box.box_size() as usize);
 
-        {
-            let mut reader = BufReader::new(Cursor::new(&buf));
-            let header = BoxHeader::read(&mut reader).unwrap();
-            assert_eq!(header.name, BoxType::MdhdBox);
-            assert_eq!(src_box.box_size(), header.size);
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::MdhdBox);
+        assert_eq!(src_box.box_size(), header.size);
 
-            let dst_box = MdhdBox::read_box(&mut reader, header.size).unwrap();
-
-            assert_eq!(src_box, dst_box);
-        }
+        let dst_box = MdhdBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
     }
 }

src/atoms/mdia.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, SeekFrom, Seek, Read, BufWriter, Write};
+use std::io::{Seek, SeekFrom, Read, Write};
 
 use crate::*;
 use crate::atoms::*;
@@ -38,8 +38,8 @@ impl Mp4Box for MdiaBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for MdiaBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for MdiaBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let mut mdia = MdiaBox::new();
@@ -79,8 +79,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for MdiaBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for MdiaBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for MdiaBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 

src/atoms/minf.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, SeekFrom, Seek, Read, BufWriter, Write};
+use std::io::{Seek, SeekFrom, Read, Write};
 
 use crate::*;
 use crate::atoms::*;
@@ -38,8 +38,8 @@ impl Mp4Box for MinfBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for MinfBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for MinfBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let mut minf = MinfBox::new();
@@ -82,8 +82,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for MinfBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for MinfBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for MinfBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 

src/atoms/mod.rs

@@ -1,5 +1,5 @@
 use std::fmt;
-use std::io::{BufReader, SeekFrom, Seek, Read, BufWriter, Write};
+use std::io::{Seek, SeekFrom, Read, Write};
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 
 use crate::*;
@@ -208,7 +208,7 @@ impl BoxHeader {
     }
 
     // TODO: if size is 0, then this box is the last one in the file
-    pub fn read<R: Read>(reader: &mut BufReader<R>) -> Result<Self> {
+    pub fn read<R: Read>(reader: &mut R) -> Result<Self> {
         // Create and read to buf.
         let mut buf = [0u8;8]; // 8 bytes for box header.
         reader.read(&mut buf)?;
@@ -239,7 +239,7 @@ impl BoxHeader {
         }
     }
 
-    fn write<W: Write>(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+    fn write<W: Write>(&self, writer: &mut W) -> Result<u64> {
         if self.size > u32::MAX as u64 {
             writer.write_u32::<BigEndian>(1)?;
             writer.write_u32::<BigEndian>(self.name.into())?;
@@ -253,40 +253,40 @@ impl BoxHeader {
     }
 }
 
-pub fn read_box_header_ext<R: Read>(reader: &mut BufReader<R>) -> Result<(u8, u32)> {
+pub fn read_box_header_ext<R: Read>(reader: &mut R) -> Result<(u8, u32)> {
     let version = reader.read_u8()?;
     let flags = reader.read_u24::<BigEndian>()?;
     Ok((version, flags))
 }
 
-pub fn write_box_header_ext<W: Write>(w: &mut BufWriter<W>, v: u8, f: u32) -> Result<u64> {
+pub fn write_box_header_ext<W: Write>(w: &mut W, v: u8, f: u32) -> Result<u64> {
     w.write_u8(v)?;
     w.write_u24::<BigEndian>(f)?;
     Ok(4)
 }
 
-pub fn get_box_start<R: Seek>(reader: &mut BufReader<R>) -> Result<u64> {
+pub fn get_box_start<R: Seek>(reader: &mut R) -> Result<u64> {
     Ok(reader.seek(SeekFrom::Current(0))? - HEADER_SIZE)
 }
 
-pub fn skip_read<R: Read + Seek>(reader: &mut BufReader<R>, size: i64) -> Result<()> {
+pub fn skip_read<R: Read + Seek>(reader: &mut R, size: i64) -> Result<()> {
     assert!(size >= 0);
     reader.seek(SeekFrom::Current(size))?;
     Ok(())
 }
 
-pub fn skip_read_to<R: Read + Seek>(reader: &mut BufReader<R>, pos: u64) -> Result<()> {
+pub fn skip_read_to<R: Read + Seek>(reader: &mut R, pos: u64) -> Result<()> {
     reader.seek(SeekFrom::Start(pos))?;
     Ok(())
 }
 
-pub fn skip_box<R: Read + Seek>(reader: &mut BufReader<R>, size: u64) -> Result<()> {
+pub fn skip_box<R: Read + Seek>(reader: &mut R, size: u64) -> Result<()> {
     let start = get_box_start(reader)?;
     skip_read_to(reader, start + size)?;
     Ok(())
 }
 
-pub fn skip_write<W: Write>(writer: &mut BufWriter<W>, size: u64) -> Result<()> {
+pub fn skip_write<W: Write>(writer: &mut W, size: u64) -> Result<()> {
     for _ in 0..size {
         writer.write_u8(0)?;
     }

src/atoms/moov.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, Seek, SeekFrom, Read, BufWriter, Write};
+use std::io::{Seek, SeekFrom, Read, Write};
 
 use crate::*;
 use crate::atoms::*;
@@ -31,8 +31,8 @@ impl Mp4Box for MoovBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for MoovBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for MoovBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let mut moov = MoovBox::new();
@@ -71,8 +71,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for MoovBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for MoovBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for MoovBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 

src/atoms/mp4a.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, Seek, Read, BufWriter, Write};
+use std::io::{Seek, Read, Write};
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 
 use crate::*;
@@ -36,8 +36,8 @@ impl Mp4Box for Mp4aBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for Mp4aBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for Mp4aBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         reader.read_u32::<BigEndian>()?; // reserved
@@ -70,8 +70,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for Mp4aBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for Mp4aBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for Mp4aBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 
@@ -109,8 +109,8 @@ impl Mp4Box for EsdsBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for EsdsBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for EsdsBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let (version, flags) = read_box_header_ext(reader)?;
@@ -127,8 +127,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for EsdsBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for EsdsBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for EsdsBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 
@@ -152,7 +152,7 @@ trait WriteDesc<T>: Sized {
     fn write_desc(&self, _: T) -> Result<u32>;
 }
 
-fn read_desc<R: Read>(reader: &mut BufReader<R>) -> Result<(u8, u32)> {
+fn read_desc<R: Read>(reader: &mut R) -> Result<(u8, u32)> {
     let tag = reader.read_u8()?;
 
     let mut size: u32 = 0;
@@ -167,7 +167,7 @@ fn read_desc<R: Read>(reader: &mut BufReader<R>) -> Result<(u8, u32)> {
     Ok((tag, size))
 }
 
-fn write_desc<W: Write>(writer: &mut BufWriter<W>, tag: u8, size: u32) -> Result<u64> {
+fn write_desc<W: Write>(writer: &mut W, tag: u8, size: u32) -> Result<u64> {
     writer.write_u8(tag)?;
 
     if size > 0x0FFFFFFF {
@@ -217,8 +217,8 @@ impl Descriptor for ESDescriptor {
     }
 }
 
-impl<R: Read + Seek> ReadDesc<&mut BufReader<R>> for ESDescriptor {
-    fn read_desc(reader: &mut BufReader<R>) -> Result<Self> {
+impl<R: Read + Seek> ReadDesc<&mut R> for ESDescriptor {
+    fn read_desc(reader: &mut R) -> Result<Self> {
         let (tag, size) = read_desc(reader)?;
         if tag != Self::desc_tag() {
             return Err(Error::InvalidData("ESDescriptor not found"));
@@ -240,8 +240,8 @@ impl<R: Read + Seek> ReadDesc<&mut BufReader<R>> for ESDescriptor {
     }
 }
 
-impl<W: Write> WriteDesc<&mut BufWriter<W>> for ESDescriptor {
-    fn write_desc(&self, writer: &mut BufWriter<W>) -> Result<u32> {
+impl<W: Write> WriteDesc<&mut W> for ESDescriptor {
+    fn write_desc(&self, writer: &mut W) -> Result<u32> {
         write_desc(writer, self.tag, self.size)?;
 
         Ok(self.size)
@@ -274,8 +274,8 @@ impl Descriptor for DecoderConfigDescriptor {
     }
 }
 
-impl<R: Read + Seek> ReadDesc<&mut BufReader<R>> for DecoderConfigDescriptor {
-    fn read_desc(reader: &mut BufReader<R>) -> Result<Self> {
+impl<R: Read + Seek> ReadDesc<&mut R> for DecoderConfigDescriptor {
+    fn read_desc(reader: &mut R) -> Result<Self> {
         let (tag, size) = read_desc(reader)?;
         if tag != Self::desc_tag() {
             return Err(Error::InvalidData("DecoderConfigDescriptor not found"));
@@ -310,8 +310,8 @@ impl<R: Read + Seek> ReadDesc<&mut BufReader<R>> for DecoderConfigDescriptor {
     }
 }
 
-impl<W: Write> WriteDesc<&mut BufWriter<W>> for DecoderConfigDescriptor {
-    fn write_desc(&self, writer: &mut BufWriter<W>) -> Result<u32> {
+impl<W: Write> WriteDesc<&mut W> for DecoderConfigDescriptor {
+    fn write_desc(&self, writer: &mut W) -> Result<u32> {
         write_desc(writer, self.tag, self.size)?;
 
         Ok(self.size)
@@ -338,8 +338,8 @@ impl Descriptor for DecoderSpecificDescriptor {
     }
 }
 
-impl<R: Read + Seek> ReadDesc<&mut BufReader<R>> for DecoderSpecificDescriptor {
-    fn read_desc(reader: &mut BufReader<R>) -> Result<Self> {
+impl<R: Read + Seek> ReadDesc<&mut R> for DecoderSpecificDescriptor {
+    fn read_desc(reader: &mut R) -> Result<Self> {
         let (tag, size) = read_desc(reader)?;
         if tag != Self::desc_tag() {
             return Err(Error::InvalidData("DecoderSpecificDescriptor not found"));
@@ -361,8 +361,8 @@ impl<R: Read + Seek> ReadDesc<&mut BufReader<R>> for DecoderSpecificDescriptor {
     }
 }
 
-impl<W: Write> WriteDesc<&mut BufWriter<W>> for DecoderSpecificDescriptor {
-    fn write_desc(&self, writer: &mut BufWriter<W>) -> Result<u32> {
+impl<W: Write> WriteDesc<&mut W> for DecoderSpecificDescriptor {
+    fn write_desc(&self, writer: &mut W) -> Result<u32> {
         write_desc(writer, self.tag, self.size)?;
 
         Ok(self.size)
@@ -386,8 +386,8 @@ impl Descriptor for SLConfigDescriptor {
     }
 }
 
-impl<R: Read + Seek> ReadDesc<&mut BufReader<R>> for SLConfigDescriptor {
-    fn read_desc(reader: &mut BufReader<R>) -> Result<Self> {
+impl<R: Read + Seek> ReadDesc<&mut R> for SLConfigDescriptor {
+    fn read_desc(reader: &mut R) -> Result<Self> {
         let (tag, size) = read_desc(reader)?;
         if tag != Self::desc_tag() {
             return Err(Error::InvalidData("SLConfigDescriptor not found"));
@@ -402,8 +402,8 @@ impl<R: Read + Seek> ReadDesc<&mut BufReader<R>> for SLConfigDescriptor {
     }
 }
 
-impl<W: Write> WriteDesc<&mut BufWriter<W>> for SLConfigDescriptor {
-    fn write_desc(&self, writer: &mut BufWriter<W>) -> Result<u32> {
+impl<W: Write> WriteDesc<&mut W> for SLConfigDescriptor {
+    fn write_desc(&self, writer: &mut W) -> Result<u32> {
         write_desc(writer, self.tag, self.size)?;
 
         Ok(self.size)

src/atoms/mvhd.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, Seek, Read, BufWriter, Write};
+use std::io::{Seek, Read, Write};
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 use num_rational::Ratio;
 
@@ -49,8 +49,8 @@ impl Mp4Box for MvhdBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for MvhdBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for MvhdBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let (version, flags) = read_box_header_ext(reader)?;
@@ -89,8 +89,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for MvhdBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for MvhdBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for MvhdBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 
@@ -135,22 +135,16 @@ mod tests {
             rate: Ratio::new_raw(0x00010000, 0x10000),
         };
         let mut buf = Vec::new();
-        {
-            let mut writer = BufWriter::new(&mut buf);
-            src_box.write_box(&mut writer).unwrap();
-        }
+        src_box.write_box(&mut buf).unwrap();
         assert_eq!(buf.len(), src_box.box_size() as usize);
 
-        {
-            let mut reader = BufReader::new(Cursor::new(&buf));
-            let header = BoxHeader::read(&mut reader).unwrap();
-            assert_eq!(header.name, BoxType::MvhdBox);
-            assert_eq!(src_box.box_size(), header.size);
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::MvhdBox);
+        assert_eq!(src_box.box_size(), header.size);
 
-            let dst_box = MvhdBox::read_box(&mut reader, header.size).unwrap();
-
-            assert_eq!(src_box, dst_box);
-        }
+        let dst_box = MvhdBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
     }
 
     #[test]
@@ -165,21 +159,15 @@ mod tests {
             rate: Ratio::new_raw(0x00010000, 0x10000),
         };
         let mut buf = Vec::new();
-        {
-            let mut writer = BufWriter::new(&mut buf);
-            src_box.write_box(&mut writer).unwrap();
-        }
+        src_box.write_box(&mut buf).unwrap();
         assert_eq!(buf.len(), src_box.box_size() as usize);
 
-        {
-            let mut reader = BufReader::new(Cursor::new(&buf));
-            let header = BoxHeader::read(&mut reader).unwrap();
-            assert_eq!(header.name, BoxType::MvhdBox);
-            assert_eq!(src_box.box_size(), header.size);
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::MvhdBox);
+        assert_eq!(src_box.box_size(), header.size);
 
-            let dst_box = MvhdBox::read_box(&mut reader, header.size).unwrap();
-
-            assert_eq!(src_box, dst_box);
-        }
+        let dst_box = MvhdBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
     }
 }

src/atoms/smhd.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, Seek, Read, BufWriter, Write};
+use std::io::{Seek, Read, Write};
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 use num_rational::Ratio;
 
@@ -33,8 +33,8 @@ impl Mp4Box for SmhdBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for SmhdBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for SmhdBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let (version, flags) = read_box_header_ext(reader)?;
@@ -52,8 +52,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for SmhdBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for SmhdBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for SmhdBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 
@@ -81,21 +81,15 @@ mod tests {
             balance: Ratio::new_raw(-0x100, 0x100),
         };
         let mut buf = Vec::new();
-        {
-            let mut writer = BufWriter::new(&mut buf);
-            src_box.write_box(&mut writer).unwrap();
-        }
+        src_box.write_box(&mut buf).unwrap();
         assert_eq!(buf.len(), src_box.box_size() as usize);
 
-        {
-            let mut reader = BufReader::new(Cursor::new(&buf));
-            let header = BoxHeader::read(&mut reader).unwrap();
-            assert_eq!(header.name, BoxType::SmhdBox);
-            assert_eq!(src_box.box_size(), header.size);
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::SmhdBox);
+        assert_eq!(src_box.box_size(), header.size);
 
-            let dst_box = SmhdBox::read_box(&mut reader, header.size).unwrap();
-
-            assert_eq!(src_box, dst_box);
-        }
+        let dst_box = SmhdBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
     }
 }

src/atoms/stbl.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, Seek, SeekFrom, Read, BufWriter, Write};
+use std::io::{Seek, SeekFrom, Read, Write};
 
 use crate::*;
 use crate::atoms::*;
@@ -62,8 +62,8 @@ impl Mp4Box for StblBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for StblBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for StblBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let mut stbl = StblBox::new();
@@ -118,8 +118,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for StblBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for StblBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for StblBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 

src/atoms/stco.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, Seek, Read, BufWriter, Write};
+use std::io::{Seek, Read, Write};
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 
 use crate::*;
@@ -22,8 +22,8 @@ impl Mp4Box for StcoBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for StcoBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for StcoBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let (version, flags) = read_box_header_ext(reader)?;
@@ -45,8 +45,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for StcoBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for StcoBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for StcoBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 
@@ -75,21 +75,15 @@ mod tests {
             entries: vec![267, 1970, 2535, 2803, 11843, 22223, 33584],
         };
         let mut buf = Vec::new();
-        {
-            let mut writer = BufWriter::new(&mut buf);
-            src_box.write_box(&mut writer).unwrap();
-        }
+        src_box.write_box(&mut buf).unwrap();
         assert_eq!(buf.len(), src_box.box_size() as usize);
 
-        {
-            let mut reader = BufReader::new(Cursor::new(&buf));
-            let header = BoxHeader::read(&mut reader).unwrap();
-            assert_eq!(header.name, BoxType::StcoBox);
-            assert_eq!(src_box.box_size(), header.size);
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::StcoBox);
+        assert_eq!(src_box.box_size(), header.size);
 
-            let dst_box = StcoBox::read_box(&mut reader, header.size).unwrap();
-
-            assert_eq!(src_box, dst_box);
-        }
+        let dst_box = StcoBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
     }
 }

src/atoms/stsc.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, Seek, Read, BufWriter, Write};
+use std::io::{Seek, Read, Write};
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 
 use crate::*;
@@ -29,8 +29,8 @@ impl Mp4Box for StscBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for StscBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for StscBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let (version, flags) = read_box_header_ext(reader)?;
@@ -56,8 +56,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for StscBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for StscBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for StscBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 
@@ -99,21 +99,15 @@ mod tests {
             ],
         };
         let mut buf = Vec::new();
-        {
-            let mut writer = BufWriter::new(&mut buf);
-            src_box.write_box(&mut writer).unwrap();
-        }
+        src_box.write_box(&mut buf).unwrap();
         assert_eq!(buf.len(), src_box.box_size() as usize);
 
-        {
-            let mut reader = BufReader::new(Cursor::new(&buf));
-            let header = BoxHeader::read(&mut reader).unwrap();
-            assert_eq!(header.name, BoxType::StscBox);
-            assert_eq!(src_box.box_size(), header.size);
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::StscBox);
+        assert_eq!(src_box.box_size(), header.size);
 
-            let dst_box = StscBox::read_box(&mut reader, header.size).unwrap();
-
-            assert_eq!(src_box, dst_box);
-        }
+        let dst_box = StscBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
     }
 }

src/atoms/stsd.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, Seek, Read, BufWriter, Write};
+use std::io::{Seek, Read, Write};
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 
 use crate::*;
@@ -30,8 +30,8 @@ impl Mp4Box for StsdBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for StsdBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for StsdBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let (version, flags) = read_box_header_ext(reader)?;
@@ -66,8 +66,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for StsdBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for StsdBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for StsdBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 

src/atoms/stss.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, Seek, Read, BufWriter, Write};
+use std::io::{Seek, Read, Write};
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 
 use crate::*;
@@ -22,8 +22,8 @@ impl Mp4Box for StssBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for StssBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for StssBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let (version, flags) = read_box_header_ext(reader)?;
@@ -45,8 +45,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for StssBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for StssBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for StssBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 
@@ -75,21 +75,15 @@ mod tests {
             entries: vec![1, 61, 121, 181, 241, 301, 361, 421, 481],
         };
         let mut buf = Vec::new();
-        {
-            let mut writer = BufWriter::new(&mut buf);
-            src_box.write_box(&mut writer).unwrap();
-        }
+        src_box.write_box(&mut buf).unwrap();
         assert_eq!(buf.len(), src_box.box_size() as usize);
 
-        {
-            let mut reader = BufReader::new(Cursor::new(&buf));
-            let header = BoxHeader::read(&mut reader).unwrap();
-            assert_eq!(header.name, BoxType::StssBox);
-            assert_eq!(src_box.box_size(), header.size);
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::StssBox);
+        assert_eq!(src_box.box_size(), header.size);
 
-            let dst_box = StssBox::read_box(&mut reader, header.size).unwrap();
-
-            assert_eq!(src_box, dst_box);
-        }
+        let dst_box = StssBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
     }
 }

src/atoms/stsz.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, Seek, Read, BufWriter, Write};
+use std::io::{Seek, Read, Write};
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 
 use crate::*;
@@ -23,8 +23,8 @@ impl Mp4Box for StszBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for StszBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for StszBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let (version, flags) = read_box_header_ext(reader)?;
@@ -50,8 +50,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for StszBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for StszBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for StszBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 
@@ -84,22 +84,16 @@ mod tests {
             sample_sizes: vec![],
         };
         let mut buf = Vec::new();
-        {
-            let mut writer = BufWriter::new(&mut buf);
-            src_box.write_box(&mut writer).unwrap();
-        }
+        src_box.write_box(&mut buf).unwrap();
         assert_eq!(buf.len(), src_box.box_size() as usize);
 
-        {
-            let mut reader = BufReader::new(Cursor::new(&buf));
-            let header = BoxHeader::read(&mut reader).unwrap();
-            assert_eq!(header.name, BoxType::StszBox);
-            assert_eq!(src_box.box_size(), header.size);
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::StszBox);
+        assert_eq!(src_box.box_size(), header.size);
 
-            let dst_box = StszBox::read_box(&mut reader, header.size).unwrap();
-
-            assert_eq!(src_box, dst_box);
-        }
+        let dst_box = StszBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
     }
 
     #[test]
@@ -111,21 +105,15 @@ mod tests {
             sample_sizes: vec![1165, 11, 11, 8545, 10126, 10866, 9643, 9351, 7730],
         };
         let mut buf = Vec::new();
-        {
-            let mut writer = BufWriter::new(&mut buf);
-            src_box.write_box(&mut writer).unwrap();
-        }
+        src_box.write_box(&mut buf).unwrap();
         assert_eq!(buf.len(), src_box.box_size() as usize);
 
-        {
-            let mut reader = BufReader::new(Cursor::new(&buf));
-            let header = BoxHeader::read(&mut reader).unwrap();
-            assert_eq!(header.name, BoxType::StszBox);
-            assert_eq!(src_box.box_size(), header.size);
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::StszBox);
+        assert_eq!(src_box.box_size(), header.size);
 
-            let dst_box = StszBox::read_box(&mut reader, header.size).unwrap();
-
-            assert_eq!(src_box, dst_box);
-        }
+        let dst_box = StszBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
     }
 }

src/atoms/stts.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, Seek, Read, BufWriter, Write};
+use std::io::{Seek, Read, Write};
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 
 use crate::*;
@@ -28,8 +28,8 @@ impl Mp4Box for SttsBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for SttsBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for SttsBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let (version, flags) = read_box_header_ext(reader)?;
@@ -54,8 +54,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for SttsBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for SttsBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for SttsBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 
@@ -88,22 +88,16 @@ mod tests {
             ],
         };
         let mut buf = Vec::new();
-        {
-            let mut writer = BufWriter::new(&mut buf);
-            src_box.write_box(&mut writer).unwrap();
-        }
+        src_box.write_box(&mut buf).unwrap();
         assert_eq!(buf.len(), src_box.box_size() as usize);
 
-        {
-            let mut reader = BufReader::new(Cursor::new(&buf));
-            let header = BoxHeader::read(&mut reader).unwrap();
-            assert_eq!(header.name, BoxType::SttsBox);
-            assert_eq!(src_box.box_size(), header.size);
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::SttsBox);
+        assert_eq!(src_box.box_size(), header.size);
 
-            let dst_box = SttsBox::read_box(&mut reader, header.size).unwrap();
-
-            assert_eq!(src_box, dst_box);
-        }
+        let dst_box = SttsBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
     }
 
     #[test]
@@ -117,21 +111,15 @@ mod tests {
             ],
         };
         let mut buf = Vec::new();
-        {
-            let mut writer = BufWriter::new(&mut buf);
-            src_box.write_box(&mut writer).unwrap();
-        }
+        src_box.write_box(&mut buf).unwrap();
         assert_eq!(buf.len(), src_box.box_size() as usize);
 
-        {
-            let mut reader = BufReader::new(Cursor::new(&buf));
-            let header = BoxHeader::read(&mut reader).unwrap();
-            assert_eq!(header.name, BoxType::SttsBox);
-            assert_eq!(src_box.box_size(), header.size);
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::SttsBox);
+        assert_eq!(src_box.box_size(), header.size);
 
-            let dst_box = SttsBox::read_box(&mut reader, header.size).unwrap();
-
-            assert_eq!(src_box, dst_box);
-        }
+        let dst_box = SttsBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
     }
 }

src/atoms/tkhd.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, Seek, Read, BufWriter, Write};
+use std::io::{Seek, Read, Write};
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 use num_rational::Ratio;
 
@@ -72,8 +72,8 @@ impl Mp4Box for TkhdBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for TkhdBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for TkhdBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let (version, flags) = read_box_header_ext(reader)?;
@@ -138,8 +138,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for TkhdBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for TkhdBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for TkhdBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 
@@ -217,22 +217,16 @@ mod tests {
             height: 288,
         };
         let mut buf = Vec::new();
-        {
-            let mut writer = BufWriter::new(&mut buf);
-            src_box.write_box(&mut writer).unwrap();
-        }
+        src_box.write_box(&mut buf).unwrap();
         assert_eq!(buf.len(), src_box.box_size() as usize);
 
-        {
-            let mut reader = BufReader::new(Cursor::new(&buf));
-            let header = BoxHeader::read(&mut reader).unwrap();
-            assert_eq!(header.name, BoxType::TkhdBox);
-            assert_eq!(src_box.box_size(), header.size);
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::TkhdBox);
+        assert_eq!(src_box.box_size(), header.size);
 
-            let dst_box = TkhdBox::read_box(&mut reader, header.size).unwrap();
-
-            assert_eq!(src_box, dst_box);
-        }
+        let dst_box = TkhdBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
     }
 
     #[test]
@@ -262,21 +256,15 @@ mod tests {
             height: 288,
         };
         let mut buf = Vec::new();
-        {
-            let mut writer = BufWriter::new(&mut buf);
-            src_box.write_box(&mut writer).unwrap();
-        }
+        src_box.write_box(&mut buf).unwrap();
         assert_eq!(buf.len(), src_box.box_size() as usize);
 
-        {
-            let mut reader = BufReader::new(Cursor::new(&buf));
-            let header = BoxHeader::read(&mut reader).unwrap();
-            assert_eq!(header.name, BoxType::TkhdBox);
-            assert_eq!(src_box.box_size(), header.size);
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::TkhdBox);
+        assert_eq!(src_box.box_size(), header.size);
 
-            let dst_box = TkhdBox::read_box(&mut reader, header.size).unwrap();
-
-            assert_eq!(src_box, dst_box);
-        }
+        let dst_box = TkhdBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
     }
 }

src/atoms/trak.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, SeekFrom, Seek, Read, BufWriter, Write};
+use std::io::{Seek, SeekFrom, Read, Write};
 
 use crate::*;
 use crate::atoms::*;
@@ -38,8 +38,8 @@ impl Mp4Box for TrakBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for TrakBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for TrakBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let mut trak = TrakBox::new();
@@ -79,8 +79,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for TrakBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for TrakBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for TrakBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 

src/atoms/vmhd.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, Seek, Read, BufWriter, Write};
+use std::io::{Seek, Read, Write};
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 
 use crate::*;
@@ -30,8 +30,8 @@ impl Mp4Box for VmhdBox {
     }
 }
 
-impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for VmhdBox {
-    fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
+impl<R: Read + Seek> ReadBox<&mut R> for VmhdBox {
+    fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = get_box_start(reader)?;
 
         let (version, flags) = read_box_header_ext(reader)?;
@@ -54,8 +54,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for VmhdBox {
     }
 }
 
-impl<W: Write> WriteBox<&mut BufWriter<W>> for VmhdBox {
-    fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
+impl<W: Write> WriteBox<&mut W> for VmhdBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
         let size = self.box_size();
         BoxHeader::new(Self::box_type(), size).write(writer)?;
 
@@ -86,21 +86,15 @@ mod tests {
             op_color: RgbColor { red: 0, green: 0, blue: 0},
         };
         let mut buf = Vec::new();
-        {
-            let mut writer = BufWriter::new(&mut buf);
-            src_box.write_box(&mut writer).unwrap();
-        }
+        src_box.write_box(&mut buf).unwrap();
         assert_eq!(buf.len(), src_box.box_size() as usize);
 
-        {
-            let mut reader = BufReader::new(Cursor::new(&buf));
-            let header = BoxHeader::read(&mut reader).unwrap();
-            assert_eq!(header.name, BoxType::VmhdBox);
-            assert_eq!(src_box.box_size(), header.size);
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::VmhdBox);
+        assert_eq!(src_box.box_size(), header.size);
 
-            let dst_box = VmhdBox::read_box(&mut reader, header.size).unwrap();
-
-            assert_eq!(src_box, dst_box);
-        }
+        let dst_box = VmhdBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
     }
 }

src/lib.rs

@@ -1,5 +1,4 @@
-use std::io::{BufReader, Read, Seek, SeekFrom};
-use std::fs::File;
+use std::io::{Seek, SeekFrom, Read};
 use std::convert::TryInto;
 
 mod atoms;
@@ -18,66 +17,63 @@ pub enum TrackType {
     Unknown,
 }
 
-#[derive(Debug, Default)]
-pub struct BMFF {
+#[derive(Debug)]
+pub struct Mp4Reader<R> {
+    reader: R,
     pub ftyp: FtypBox,
     pub moov: Option<MoovBox>,
-    pub size: u64,
+    size: u64,
 }
 
-impl BMFF {
-    pub fn new() -> BMFF {
-        Default::default()
+impl<R: Read + Seek> Mp4Reader<R> {
+    pub fn new(reader: R) -> Self {
+        Mp4Reader {
+            reader,
+            ftyp: FtypBox::default(),
+            moov: None,
+            size: 0,
+        }
     }
 
-    pub fn read_from_file(f: File) -> Result<BMFF> {
-        let size = f.metadata()?.len();
-        let mut reader = BufReader::new(f);
-
-        let mut bmff = BMFF::new();
-        bmff.size = bmff.read(&mut reader, size)?;
-
-        Ok(bmff)
+    pub fn size(&self) -> u64 {
+        self.size
     }
 
-    pub fn read<R: Read + Seek>(
-        &mut self,
-        reader: &mut BufReader<R>,
-        size: u64
-    ) -> Result<u64> {
-        let start = reader.seek(SeekFrom::Current(0))?;
+    pub fn read(&mut self, size: u64) -> Result<()> {
+        let start = self.reader.seek(SeekFrom::Current(0))?;
         let mut current = start;
         while current < size {
             // Get box header.
-            let header = BoxHeader::read(reader)?;
+            let header = BoxHeader::read(&mut self.reader)?;
             let BoxHeader{ name, size: s } = header;
 
             // Match and parse the atom boxes.
             match name {
                 BoxType::FtypBox => {
-                    let ftyp = FtypBox::read_box(reader, s)?;
+                    let ftyp = FtypBox::read_box(&mut self.reader, s)?;
                     self.ftyp = ftyp;
                 }
                 BoxType::FreeBox => {
-                    skip_box(reader, s)?;
+                    skip_box(&mut self.reader, s)?;
                 }
                 BoxType::MdatBox => {
-                    skip_box(reader, s)?;
+                    skip_box(&mut self.reader, s)?;
                 }
                 BoxType::MoovBox => {
-                    let moov = MoovBox::read_box(reader, s)?;
+                    let moov = MoovBox::read_box(&mut self.reader, s)?;
                     self.moov = Some(moov);
                 }
                 BoxType::MoofBox => {
-                    skip_box(reader, s)?;
+                    skip_box(&mut self.reader, s)?;
                 }
                 _ => {
                     // XXX warn!()
-                    skip_box(reader, s)?;
+                    skip_box(&mut self.reader, s)?;
                 }
             }
-            current = reader.seek(SeekFrom::Current(0))?;
+            current = self.reader.seek(SeekFrom::Current(0))?;
         }
-        Ok(current - start)
+        self.size = current - start;
+        Ok(())
     }
 }

tests/lib.rs

@@ -1,18 +1,23 @@
 use mp4;
 use std::fs::File;
+use std::io::BufReader;
 
 
 #[test]
 fn test_read_mp4() {
     let filename = "tests/samples/minimal.mp4";
     let f = File::open(filename).unwrap();
-    let bmff = mp4::BMFF::read_from_file(f).unwrap();
+    let size = f.metadata().unwrap().len();
+    let reader = BufReader::new(f);
 
-    assert_eq!(2591, bmff.size);
+    let mut mp4 = mp4::Mp4Reader::new(reader);
+    mp4.read(size).unwrap();
+
+    assert_eq!(2591, mp4.size());
 
     // ftyp.
-    println!("{:?}", bmff.ftyp.compatible_brands);
-    assert_eq!(4, bmff.ftyp.compatible_brands.len());
+    println!("{:?}", mp4.ftyp.compatible_brands);
+    assert_eq!(4, mp4.ftyp.compatible_brands.len());
 
     // Check compatible_brands.
     let brands = vec![
@@ -23,12 +28,12 @@ fn test_read_mp4() {
     ];
 
     for b in brands {
-        let t = bmff.ftyp.compatible_brands.iter().any(|x| x.to_string() == b);
+        let t = mp4.ftyp.compatible_brands.iter().any(|x| x.to_string() == b);
         assert_eq!(t, true);
     }
 
     // moov.
-    let moov = bmff.moov.unwrap();
+    let moov = mp4.moov.unwrap();
     assert_eq!(moov.mvhd.version, 0);
     assert_eq!(moov.mvhd.creation_time, 0);
     assert_eq!(moov.mvhd.duration, 62);