mirrors/mp4-rust
1
0
Fork 0
mirror of https://github.com/alfg/mp4-rust.git synced 2025-01-03 08:58:40 +00:00
Code Issues Projects Releases Wiki Activity

Feature/mp4reader (#13)

Browse source 
* Add ReadBox trait

* Add boxtype macro

* Remove offset in BoxHeader

* Fix parsing error when box has largesize

* Remove duplicated codes reading version and flags

* Add avc1 box

* Add mp4a box

* Add mp4a box

* Add DecoderSpecificDescriptor in esds box

* Add necessary sub-boxes to stbl box

* Improve ReadBox::read_box()

* Add smhd box

* Refactor BoxHeader

* Refactor BMFF

* Refactor

* Add some functions to get offset and size of sample

* Add Mp4Reader::read_sample() that read media samples

Co-authored-by: Byungwan Jun <unipro.kr@gmail.com>
This commit is contained in:
Ian Jun 2020-08-01 02:12:26 +09:00 committed by GitHub
parent b755db3fa0
commit 0df82aec5f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
31 changed files with 2484 additions and 619 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Cargo.toml
View file

@ -20,4 +20,5 @@ license = "MIT"
[dependencies]
thiserror = "^1.0"
byteorder = "1"
bytes = "0.5"
num-rational = "0.3"

41
examples/mp4copy.rs Normal file
View file

@ -0,0 +1,41 @@
use std::env;
use std::fs::File;
use std::io::prelude::*;
use std::io::{self, BufReader};
use std::path::Path;
use mp4::Result;
fn main() {
let args: Vec<String> = env::args().collect();
if args.len() < 3 {
println!("Usage: mp4copy <source file> <target file>");
std::process::exit(1);
}
if let Err(err) = copy(&args[1], &args[2]) {
let _ = writeln!(io::stderr(), "{}", err);
}
}
fn copy<P: AsRef<Path>>(src_filename: &P, _dst_filename: &P) -> Result<()> {
let src_file = File::open(src_filename)?;
let size = src_file.metadata()?.len();
let reader = BufReader::new(src_file);
let mut mp4 = mp4::Mp4Reader::new(reader);
mp4.read(size)?;
for tix in 0..mp4.track_count()? {
let track_id = tix + 1;
let sample_count = mp4.sample_count(track_id)?;
for six in 0..sample_count {
let sample_id = six + 1;
let sample = mp4.read_sample(track_id, sample_id)?.unwrap();
println!("sample_id: {}, {}", sample_id, sample);
}
}
Ok(())
}

149
examples/mp4info.rs
View file

@ -1,97 +1,98 @@
use mp4;
use std::env;
use std::fs::File;
use std::io::prelude::*;
use std::io::{self, BufReader};
use std::path::Path;
use mp4::{Result, Mp4Reader, TrackType};
fn main() {
let args: Vec<String> = env::args().collect();
match args.len() {
2 => {
let filename = &args[1];
let f = File::open(filename).unwrap();
if args.len() < 2 {
println!("Usage: mp4info <filename>");
std::process::exit(1);
}
let bmff = mp4::read_mp4(f).unwrap();
let moov = bmff.moov.unwrap();
if let Err(err) = info(&args[1]) {
let _ = writeln!(io::stderr(), "{}", err);
}
}
// Print results.
println!("File:");
println!(" file size: {}", bmff.size);
println!(
" brands: {:?} {:?}\n",
bmff.ftyp.major_brand, bmff.ftyp.compatible_brands
);
fn info<P: AsRef<Path>>(filename: &P) -> Result<()> {
let f = File::open(filename)?;
let size = f.metadata()?.len();
let reader = BufReader::new(f);
println!("Movie:");
println!(" version: {:?}", moov.mvhd.version);
println!(
" creation time: {}",
creation_time(moov.mvhd.creation_time)
);
println!(" duration: {:?}", moov.mvhd.duration);
println!(" timescale: {:?}\n", moov.mvhd.timescale);
let mut mp4 = Mp4Reader::new(reader);
mp4.read(size)?;
println!("Found {} Tracks", moov.traks.len());
for trak in moov.traks.iter() {
let tkhd = trak.tkhd.as_ref().unwrap();
println!("Track: {:?}", tkhd.track_id);
println!(" flags: {:?}", tkhd.flags);
println!(" id: {:?}", tkhd.track_id);
println!(" duration: {:?}", tkhd.duration);
if tkhd.width != 0 && tkhd.height != 0 {
println!(" width: {:?}", tkhd.width);
println!(" height: {:?}", tkhd.height);
println!("File:");
println!(" size: {}", mp4.size());
println!(" brands: {:?} {:?}\n",
mp4.ftyp.major_brand, mp4.ftyp.compatible_brands);
if let Some(ref moov) = mp4.moov {
println!("Movie:");
println!(" version: {:?}", moov.mvhd.version);
println!(" creation time: {}",
creation_time(moov.mvhd.creation_time));
println!(" duration: {:?}", moov.mvhd.duration);
println!(" timescale: {:?}\n", moov.mvhd.timescale);
println!("Found {} Tracks", moov.traks.len());
for trak in moov.traks.iter() {
let tkhd = trak.tkhd.as_ref().unwrap();
println!("Track: {:?}", tkhd.track_id);
println!(" flags: {:?}", tkhd.flags);
println!(" id: {:?}", tkhd.track_id);
println!(" duration: {:?}", tkhd.duration);
if tkhd.width != 0 && tkhd.height != 0 {
println!(" width: {:?}", tkhd.width);
println!(" height: {:?}", tkhd.height);
}
if let Some(ref mdia) = trak.mdia {
let hdlr = mdia.hdlr.as_ref().unwrap();
let mdhd = mdia.mdhd.as_ref().unwrap();
let stts = mdia
.minf
.as_ref()
.map(|m| m.stbl.as_ref().map(|s| s.stts.as_ref()).flatten())
.flatten();
println!(" type: {:?}",
get_handler_type(hdlr.handler_type.value.as_ref()));
println!(" language: {:?}", mdhd.language);
println!(" media:");
if let Some(ref s) = stts {
println!(" sample count: {:?}", s.entries[0].sample_count);
}
if let Some(ref mdia) = trak.mdia {
let hdlr = mdia.hdlr.as_ref().unwrap();
let mdhd = mdia.mdhd.as_ref().unwrap();
let stts = mdia
.minf
.as_ref()
.map(|m| m.stbl.as_ref().map(|s| s.stts.as_ref()).flatten())
.flatten();
println!(
" type: {:?}",
get_handler_type(hdlr.handler_type.value.as_ref())
);
println!(" language: {:?}", mdhd.language);
println!(" media:");
println!(" timescale: {:?}", mdhd.timescale);
println!(" duration: {:?} (media timescale units)",
mdhd.duration);
println!(" duration: {:?} (ms)",
get_duration_ms(mdhd.duration, mdhd.timescale));
if get_handler_type(hdlr.handler_type.value.as_ref()) == TrackType::Video {
if let Some(ref s) = stts {
println!(" sample count: {:?}", s.entries[0].sample_count);
}
println!(" timescale: {:?}", mdhd.timescale);
println!(
" duration: {:?} (media timescale units)",
mdhd.duration
);
println!(
" duration: {:?} (ms)",
get_duration_ms(mdhd.duration, mdhd.timescale)
);
if get_handler_type(hdlr.handler_type.value.as_ref()) == mp4::TrackType::Video {
if let Some(ref s) = stts {
println!(
" frame rate: (computed): {:?}",
get_framerate(s.entries[0].sample_count, mdhd.duration, mdhd.timescale)
);
}
println!(" frame rate: (computed): {:?}",
get_framerate(s.entries[0].sample_count,
mdhd.duration, mdhd.timescale));
}
}
}
}
_ => {
println!("Usage: mp4info <filename>");
}
}
Ok(())
}
fn get_handler_type(handler: &str) -> mp4::TrackType {
let mut typ: mp4::TrackType = mp4::TrackType::Unknown;
fn get_handler_type(handler: &str) -> TrackType {
let mut typ: TrackType = TrackType::Unknown;
match handler {
"vide" => typ = mp4::TrackType::Video,
"soun" => typ = mp4::TrackType::Audio,
"meta" => typ = mp4::TrackType::Unknown,
"vide" => typ = TrackType::Video,
"soun" => typ = TrackType::Audio,
"meta" => typ = TrackType::Unknown,
_ => (),
}
return typ;

235
src/atoms/avc.rs Normal file
View file

@ -0,0 +1,235 @@
use std::io::{Seek, Read, Write};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use num_rational::Ratio;
use crate::*;
use crate::atoms::*;
#[derive(Debug, PartialEq)]
pub struct Avc1Box {
pub data_reference_index: u16,
pub width: u16,
pub height: u16,
pub horizresolution: Ratio<u32>,
pub vertresolution: Ratio<u32>,
pub frame_count: u16,
pub depth: u16,
pub avcc: AvcCBox,
}
impl Default for Avc1Box {
fn default() -> Self {
Avc1Box {
data_reference_index: 0,
width: 0,
height: 0,
horizresolution: Ratio::new_raw(0x00480000, 0x10000),
vertresolution: Ratio::new_raw(0x00480000, 0x10000),
frame_count: 1,
depth: 0x0018,
avcc: AvcCBox::default(),
}
}
}
impl Mp4Box for Avc1Box {
fn box_type() -> BoxType {
BoxType::Avc1Box
}
fn box_size(&self) -> u64 {
HEADER_SIZE + 8 + 74 + self.avcc.box_size()
}
}
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
reader.read_u16::<BigEndian>()?; // reserved
let data_reference_index = reader.read_u16::<BigEndian>()?;
reader.read_u32::<BigEndian>()?; // pre-defined, reserved
reader.read_u64::<BigEndian>()?; // pre-defined
reader.read_u32::<BigEndian>()?; // pre-defined
let width = reader.read_u16::<BigEndian>()?;
let height = reader.read_u16::<BigEndian>()?;
let horiznumer = reader.read_u32::<BigEndian>()?;
let horizresolution = Ratio::new_raw(horiznumer, 0x10000);
let vertnumer = reader.read_u32::<BigEndian>()?;
let vertresolution = Ratio::new_raw(vertnumer, 0x10000);
reader.read_u32::<BigEndian>()?; // reserved
let frame_count = reader.read_u16::<BigEndian>()?;
skip_read(reader, 32)?; // compressorname
let depth = reader.read_u16::<BigEndian>()?;
reader.read_i16::<BigEndian>()?; // pre-defined
let header = BoxHeader::read(reader)?;
let BoxHeader{ name, size: s } = header;
if name == BoxType::AvcCBox {
let avcc = AvcCBox::read_box(reader, s)?;
skip_read_to(reader, start + size)?;
Ok(Avc1Box {
data_reference_index,
width,
height,
horizresolution,
vertresolution,
frame_count,
depth,
avcc,
})
} else {
Err(Error::InvalidData("avcc not found"))
}
}
}
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)?;
writer.write_u32::<BigEndian>(0)?; // reserved
writer.write_u16::<BigEndian>(0)?; // reserved
writer.write_u16::<BigEndian>(self.data_reference_index)?;
writer.write_u32::<BigEndian>(0)?; // pre-defined, reserved
writer.write_u64::<BigEndian>(0)?; // pre-defined
writer.write_u32::<BigEndian>(0)?; // pre-defined
writer.write_u16::<BigEndian>(self.width)?;
writer.write_u16::<BigEndian>(self.height)?;
writer.write_u32::<BigEndian>(*self.horizresolution.numer())?;
writer.write_u32::<BigEndian>(*self.vertresolution.numer())?;
writer.write_u32::<BigEndian>(0)?; // reserved
writer.write_u16::<BigEndian>(self.frame_count)?;
// skip compressorname
for _ in 0..4 {
writer.write_u64::<BigEndian>(0)?;
}
writer.write_u16::<BigEndian>(self.depth)?;
writer.write_i16::<BigEndian>(-1)?; // pre-defined
self.avcc.write_box(writer)?;
Ok(size)
}
}
#[derive(Debug, Default, PartialEq)]
pub struct AvcCBox {
pub configuration_version: u8,
pub avc_profile_indication: u8,
pub profile_compatibility: u8,
pub avc_level_indication: u8,
pub length_size_minus_one: u8,
pub sequence_parameter_sets: Vec<NalUnit>,
pub picture_parameter_sets: Vec<NalUnit>,
}
impl Mp4Box for AvcCBox {
fn box_type() -> BoxType {
BoxType::AvcCBox
}
fn box_size(&self) -> u64 {
let mut size = HEADER_SIZE + 7;
for sps in self.sequence_parameter_sets.iter() {
size += sps.size() as u64;
}
for pps in self.picture_parameter_sets.iter() {
size += pps.size() as u64;
}
size
}
}
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()?;
let avc_profile_indication = reader.read_u8()?;
let profile_compatibility = reader.read_u8()?;
let avc_level_indication = reader.read_u8()?;
let length_size_minus_one = reader.read_u8()? & 0x3;
let num_of_spss = reader.read_u8()? & 0x1F;
let mut sequence_parameter_sets = Vec::with_capacity(num_of_spss as usize);
for _ in 0..num_of_spss {
let nal_unit = NalUnit::read(reader)?;
sequence_parameter_sets.push(nal_unit);
}
let num_of_ppss = reader.read_u8()?;
let mut picture_parameter_sets = Vec::with_capacity(num_of_ppss as usize);
for _ in 0..num_of_ppss {
let nal_unit = NalUnit::read(reader)?;
picture_parameter_sets.push(nal_unit);
}
skip_read_to(reader, start + size)?;
Ok(AvcCBox {
configuration_version,
avc_profile_indication,
profile_compatibility,
avc_level_indication,
length_size_minus_one,
sequence_parameter_sets,
picture_parameter_sets,
})
}
}
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)?;
writer.write_u8(self.configuration_version)?;
writer.write_u8(self.avc_profile_indication)?;
writer.write_u8(self.profile_compatibility)?;
writer.write_u8(self.avc_level_indication)?;
writer.write_u8(self.length_size_minus_one | 0xFC)?;
writer.write_u8(self.sequence_parameter_sets.len() as u8 | 0xE0)?;
for sps in self.sequence_parameter_sets.iter() {
sps.write(writer)?;
}
writer.write_u8(self.picture_parameter_sets.len() as u8)?;
for pps in self.picture_parameter_sets.iter() {
pps.write(writer)?;
}
Ok(size)
}
}
#[derive(Debug, Default, PartialEq)]
pub struct NalUnit {
pub bytes: Vec<u8>,
}
impl NalUnit {
pub fn size(&self) -> usize {
2 + self.bytes.len()
}
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)?;
Ok(NalUnit {
bytes,
})
}
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)
}
}

89
src/atoms/co64.rs Normal file
View file

@ -0,0 +1,89 @@
use std::io::{Seek, Read, Write};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use crate::*;
use crate::atoms::*;
#[derive(Debug, Default, PartialEq)]
pub struct Co64Box {
pub version: u8,
pub flags: u32,
pub entries: Vec<u64>,
}
impl Mp4Box for Co64Box {
fn box_type() -> BoxType {
BoxType::Co64Box
}
fn box_size(&self) -> u64 {
HEADER_SIZE + HEADER_EXT_SIZE + 4 + (8 * self.entries.len() as u64)
}
}
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)?;
let entry_count = reader.read_u32::<BigEndian>()?;
let mut entries = Vec::with_capacity(entry_count as usize);
for _i in 0..entry_count {
let chunk_offset = reader.read_u64::<BigEndian>()?;
entries.push(chunk_offset);
}
skip_read_to(reader, start + size)?;
Ok(Co64Box {
version,
flags,
entries,
})
}
}
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)?;
write_box_header_ext(writer, self.version, self.flags)?;
writer.write_u32::<BigEndian>(self.entries.len() as u32)?;
for chunk_offset in self.entries.iter() {
writer.write_u64::<BigEndian>(*chunk_offset)?;
}
Ok(size)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::atoms::BoxHeader;
use std::io::Cursor;
#[test]
fn test_co64() {
let src_box = Co64Box {
version: 0,
flags: 0,
entries: vec![267, 1970, 2535, 2803, 11843, 22223, 33584],
};
let mut buf = Vec::new();
src_box.write_box(&mut buf).unwrap();
assert_eq!(buf.len(), src_box.box_size() as usize);
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);
}
}

102
src/atoms/ctts.rs Normal file
View file

@ -0,0 +1,102 @@
use std::io::{Seek, Read, Write};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use crate::*;
use crate::atoms::*;
#[derive(Debug, Default, PartialEq)]
pub struct CttsBox {
pub version: u8,
pub flags: u32,
pub entries: Vec<CttsEntry>,
}
#[derive(Debug, Default, PartialEq)]
pub struct CttsEntry {
pub sample_count: u32,
pub sample_offset: i32,
}
impl Mp4Box for CttsBox {
fn box_type() -> BoxType {
BoxType::CttsBox
}
fn box_size(&self) -> u64 {
HEADER_SIZE + HEADER_EXT_SIZE + 4 + (8 * self.entries.len() as u64)
}
}
impl<R: Read + Seek> ReadBox<&mut R> for CttsBox {
fn read_box(reader: &mut R, size: u64) -> Result<Self> {
let start = get_box_start(reader)?;
let (version, flags) = read_box_header_ext(reader)?;
let entry_count = reader.read_u32::<BigEndian>()?;
let mut entries = Vec::with_capacity(entry_count as usize);
for _ in 0..entry_count {
let entry = CttsEntry {
sample_count: reader.read_u32::<BigEndian>()?,
sample_offset: reader.read_i32::<BigEndian>()?,
};
entries.push(entry);
}
skip_read_to(reader, start + size)?;
Ok(CttsBox {
version,
flags,
entries,
})
}
}
impl<W: Write> WriteBox<&mut W> for CttsBox {
fn write_box(&self, writer: &mut W) -> Result<u64> {
let size = self.box_size();
BoxHeader::new(Self::box_type(), size).write(writer)?;
write_box_header_ext(writer, self.version, self.flags)?;
writer.write_u32::<BigEndian>(self.entries.len() as u32)?;
for entry in self.entries.iter() {
writer.write_u32::<BigEndian>(entry.sample_count)?;
writer.write_i32::<BigEndian>(entry.sample_offset)?;
}
Ok(size)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::atoms::BoxHeader;
use std::io::Cursor;
#[test]
fn test_ctts() {
let src_box = CttsBox {
version: 0,
flags: 0,
entries: vec![
CttsEntry {sample_count: 1, sample_offset: 200},
CttsEntry {sample_count: 2, sample_offset: -100},
],
};
let mut buf = Vec::new();
src_box.write_box(&mut buf).unwrap();
assert_eq!(buf.len(), src_box.box_size() as usize);
let mut reader = Cursor::new(&buf);
let header = BoxHeader::read(&mut reader).unwrap();
assert_eq!(header.name, BoxType::CttsBox);
assert_eq!(src_box.box_size(), header.size);
let dst_box = CttsBox::read_box(&mut reader, header.size).unwrap();
assert_eq!(src_box, dst_box);
}
}

43
src/atoms/edts.rs
View file

@ -1,6 +1,7 @@
use std::io::{BufReader, SeekFrom, Seek, Read, BufWriter, Write};
use std::io::{Seek, Read, Write};
use crate::*;
use crate::atoms::*;
use crate::atoms::elst::ElstBox;
@ -16,50 +17,48 @@ impl EdtsBox {
}
impl Mp4Box for EdtsBox {
fn box_type(&self) -> BoxType {
fn box_type() -> BoxType {
BoxType::EdtsBox
}
fn box_size(&self) -> u64 {
let mut size = HEADER_SIZE;
if let Some(elst) = &self.elst {
if let Some(ref elst) = self.elst {
size += elst.box_size();
}
size
}
}
impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for EdtsBox {
fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
let current = reader.seek(SeekFrom::Current(0))?; // Current cursor position.
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();
let start = 0u64;
while start < size {
// Get box header.
let header = read_box_header(reader, start)?;
let BoxHeader{ name, size: s } = header;
let header = BoxHeader::read(reader)?;
let BoxHeader{ name, size: s } = header;
match name {
BoxType::ElstBox => {
let elst = ElstBox::read_box(reader, s)?;
edts.elst = Some(elst);
}
_ => break
match name {
BoxType::ElstBox => {
let elst = ElstBox::read_box(reader, s)?;
edts.elst = Some(elst);
}
_ => {}
}
skip_read(reader, current, size)?;
skip_read_to(reader, start + size)?;
Ok(edts)
}
}
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_box(writer)?;
BoxHeader::new(Self::box_type(), size).write(writer)?;
if let Some(elst) = &self.elst {
if let Some(ref elst) = self.elst {
elst.write_box(writer)?;
}

62
src/atoms/elst.rs
View file

@ -1,7 +1,8 @@
use std::io::{BufReader, SeekFrom, Seek, Read, BufWriter, Write};
use std::io::{Seek, Read, Write};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use crate::*;
use crate::atoms::*;
#[derive(Debug, Default, PartialEq)]
@ -20,7 +21,7 @@ pub struct ElstEntry {
}
impl Mp4Box for ElstBox {
fn box_type(&self) -> BoxType {
fn box_type() -> BoxType {
BoxType::ElstBox
}
@ -36,9 +37,9 @@ 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> {
let current = reader.seek(SeekFrom::Current(0))?; // Current cursor position.
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)?;
@ -66,7 +67,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for ElstBox {
};
entries.push(entry);
}
skip_read(reader, current, size)?;
skip_read_to(reader, start + size)?;
Ok(ElstBox {
version,
@ -76,10 +78,10 @@ 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_box(writer)?;
BoxHeader::new(Self::box_type(), size).write(writer)?;
write_box_header_ext(writer, self.version, self.flags)?;
@ -103,7 +105,7 @@ impl<W: Write> WriteBox<&mut BufWriter<W>> for ElstBox {
#[cfg(test)]
mod tests {
use super::*;
use crate::read_box_header;
use crate::atoms::BoxHeader;
use std::io::Cursor;
#[test]
@ -119,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 = read_box_header(&mut reader, 0).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]
@ -150,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 = read_box_header(&mut reader, 0).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);
}
}

41
src/atoms/ftyp.rs
View file

@ -1,7 +1,8 @@
use std::io::{BufReader, Seek, Read, BufWriter, Write};
use std::io::{Seek, Read, Write};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use crate::*;
use crate::atoms::*;
#[derive(Debug, Default, PartialEq)]
@ -12,7 +13,7 @@ pub struct FtypBox {
}
impl Mp4Box for FtypBox {
fn box_type(&self) -> BoxType {
fn box_type() -> BoxType {
BoxType::FtypBox
}
@ -21,8 +22,10 @@ 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>()?;
let minor = reader.read_u32::<BigEndian>()?;
if size % 4 != 0 {
@ -36,6 +39,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for FtypBox {
brands.push(From::from(b));
}
skip_read_to(reader, start + size)?;
Ok(FtypBox {
major_brand: From::from(major),
minor_version: minor,
@ -44,10 +49,10 @@ 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_box(writer)?;
BoxHeader::new(Self::box_type(), size).write(writer)?;
writer.write_u32::<BigEndian>((&self.major_brand).into())?;
writer.write_u32::<BigEndian>(self.minor_version)?;
@ -61,7 +66,7 @@ impl<W: Write> WriteBox<&mut BufWriter<W>> for FtypBox {
#[cfg(test)]
mod tests {
use super::*;
use crate::read_box_header;
use crate::atoms::BoxHeader;
use std::io::Cursor;
#[test]
@ -77,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 = read_box_header(&mut reader, 0).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);
}
}

45
src/atoms/hdlr.rs
View file

@ -1,7 +1,8 @@
use std::io::{BufReader, SeekFrom, Seek, Read, BufWriter, Write};
use std::io::{Seek, Read, Write};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use crate::*;
use crate::atoms::*;
#[derive(Debug, Default, PartialEq)]
@ -13,7 +14,7 @@ pub struct HdlrBox {
}
impl Mp4Box for HdlrBox {
fn box_type(&self) -> BoxType {
fn box_type() -> BoxType {
BoxType::HdlrBox
}
@ -22,18 +23,18 @@ 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> {
let current = reader.seek(SeekFrom::Current(0))?; // Current cursor position.
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)?;
reader.read_u32::<BigEndian>()?; // pre-defined
let handler = reader.read_u32::<BigEndian>()?;
let n = reader.seek(SeekFrom::Current(12))?; // 12 bytes reserved.
skip_read(reader, 12)?; // reserved
let buf_size = (size - (n - current)) - HEADER_SIZE - 1;
let buf_size = size - HEADER_SIZE - HEADER_EXT_SIZE - 20 - 1;
let mut buf = vec![0u8; buf_size as usize];
reader.read_exact(&mut buf)?;
@ -45,7 +46,7 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for HdlrBox {
_ => String::from("null"),
};
skip_read(reader, current, size)?;
skip_read_to(reader, start + size)?;
Ok(HdlrBox {
version,
@ -56,10 +57,10 @@ 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_box(writer)?;
BoxHeader::new(Self::box_type(), size).write(writer)?;
write_box_header_ext(writer, self.version, self.flags)?;
@ -81,7 +82,7 @@ impl<W: Write> WriteBox<&mut BufWriter<W>> for HdlrBox {
#[cfg(test)]
mod tests {
use super::*;
use crate::read_box_header;
use crate::atoms::BoxHeader;
use std::io::Cursor;
#[test]
@ -93,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 = read_box_header(&mut reader, 0).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);
}
}

62
src/atoms/mdhd.rs
View file

@ -1,8 +1,9 @@
use std::io::{BufReader, SeekFrom, Seek, Read, BufWriter, Write};
use std::io::{Seek, Read, Write};
use std::char::{decode_utf16, REPLACEMENT_CHARACTER};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use crate::*;
use crate::atoms::*;
#[derive(Debug, PartialEq)]
@ -31,7 +32,7 @@ impl Default for MdhdBox {
}
impl Mp4Box for MdhdBox {
fn box_type(&self) -> BoxType {
fn box_type() -> BoxType {
BoxType::MdhdBox
}
@ -49,9 +50,9 @@ 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> {
let current = reader.seek(SeekFrom::Current(0))?; // Current cursor position.
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)?;
@ -74,7 +75,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for MdhdBox {
};
let language_code = reader.read_u16::<BigEndian>()?;
let language = get_language_string(language_code);
skip_read(reader, current, size)?;
skip_read_to(reader, start + size)?;
Ok(MdhdBox {
version,
@ -88,10 +90,10 @@ 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_box(writer)?;
BoxHeader::new(Self::box_type(), size).write(writer)?;
write_box_header_ext(writer, self.version, self.flags)?;
@ -142,7 +144,7 @@ fn get_language_code(language: &str) -> u16 {
#[cfg(test)]
mod tests {
use super::*;
use crate::read_box_header;
use crate::atoms::BoxHeader;
use std::io::Cursor;
fn test_language_code(lang: &str) {
@ -170,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 = read_box_header(&mut reader, 0).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]
@ -200,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 = read_box_header(&mut reader, 0).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);
}
}

47
src/atoms/mdia.rs
View file

@ -1,6 +1,7 @@
use std::io::{BufReader, SeekFrom, Seek, Read, BufWriter, Write};
use std::io::{Seek, SeekFrom, Read, Write};
use crate::*;
use crate::atoms::*;
use crate::atoms::{mdhd::MdhdBox, hdlr::HdlrBox, minf::MinfBox};
@ -18,34 +19,36 @@ impl MdiaBox {
}
impl Mp4Box for MdiaBox {
fn box_type(&self) -> BoxType {
fn box_type() -> BoxType {
BoxType::MdiaBox
}
fn box_size(&self) -> u64 {
let mut size = HEADER_SIZE;
if let Some(mdhd) = &self.mdhd {
if let Some(ref mdhd) = self.mdhd {
size += mdhd.box_size();
}
if let Some(hdlr) = &self.hdlr {
if let Some(ref hdlr) = self.hdlr {
size += hdlr.box_size();
}
if let Some(minf) = &self.minf {
if let Some(ref minf) = self.minf {
size += minf.box_size();
}
size
}
}
impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for MdiaBox {
fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
let current = reader.seek(SeekFrom::Current(0))?; // Current cursor position.
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();
let start = 0u64;
while start < size {
let mut current = reader.seek(SeekFrom::Current(0))?;
let end = start + size;
while current < end {
// Get box header.
let header = read_box_header(reader, start)?;
let header = BoxHeader::read(reader)?;
let BoxHeader{ name, size: s } = header;
match name {
@ -61,27 +64,33 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for MdiaBox {
let minf = MinfBox::read_box(reader, s)?;
mdia.minf = Some(minf);
}
_ => break
_ => {
// XXX warn!()
skip_box(reader, s)?;
}
}
current = reader.seek(SeekFrom::Current(0))?;
}
skip_read(reader, current, size)?;
skip_read_to(reader, start + size)?;
Ok(mdia)
}
}
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_box(writer)?;
BoxHeader::new(Self::box_type(), size).write(writer)?;
if let Some(mdhd) = &self.mdhd {
if let Some(ref mdhd) = self.mdhd {
mdhd.write_box(writer)?;
}
if let Some(hdlr) = &self.hdlr {
if let Some(ref hdlr) = self.hdlr {
hdlr.write_box(writer)?;
}
if let Some(minf) = &self.minf {
if let Some(ref minf) = self.minf {
minf.write_box(writer)?;
}

59
src/atoms/minf.rs
View file

@ -1,12 +1,14 @@
use std::io::{BufReader, SeekFrom, Seek, Read, BufWriter, Write};
use std::io::{Seek, SeekFrom, Read, Write};
use crate::*;
use crate::atoms::{vmhd::VmhdBox, stbl::StblBox};
use crate::atoms::*;
use crate::atoms::{vmhd::VmhdBox, smhd::SmhdBox, stbl::StblBox};
#[derive(Debug, Default)]
pub struct MinfBox {
pub vmhd: Option<VmhdBox>,
pub smhd: Option<SmhdBox>,
pub stbl: Option<StblBox>,
}
@ -17,31 +19,36 @@ impl MinfBox {
}
impl Mp4Box for MinfBox {
fn box_type(&self) -> BoxType {
fn box_type() -> BoxType {
BoxType::MinfBox
}
fn box_size(&self) -> u64 {
let mut size = HEADER_SIZE;
if let Some(vmhd) = &self.vmhd {
if let Some(ref vmhd) = self.vmhd {
size += vmhd.box_size();
}
if let Some(stbl) = &self.stbl {
if let Some(ref smhd) = self.smhd {
size += smhd.box_size();
}
if let Some(ref stbl) = self.stbl {
size += stbl.box_size();
}
size
}
}
impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for MinfBox {
fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
let current = reader.seek(SeekFrom::Current(0))?; // Current cursor position.
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();
let mut start = 0u64;
while start < size {
let mut current = reader.seek(SeekFrom::Current(0))?;
let end = start + size;
while current < end {
// Get box header.
let header = read_box_header(reader, start)?;
let header = BoxHeader::read(reader)?;
let BoxHeader{ name, size: s } = header;
match name {
@ -50,33 +57,43 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for MinfBox {
minf.vmhd = Some(vmhd);
}
BoxType::SmhdBox => {
start = s - HEADER_SIZE;
let smhd = SmhdBox::read_box(reader, s)?;
minf.smhd = Some(smhd);
}
BoxType::DinfBox => {
start = s - HEADER_SIZE;
BoxType::DinfBox => {// XXX warn!()
skip_box(reader, s)?;
}
BoxType::StblBox => {
let stbl = StblBox::read_box(reader, s)?;
minf.stbl = Some(stbl);
}
_ => break
_ => {
// XXX warn!()
skip_box(reader, s)?;
}
}
current = reader.seek(SeekFrom::Current(0))?;
}
skip_read(reader, current, size)?;
skip_read_to(reader, start + size)?;
Ok(minf)
}
}
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_box(writer)?;
BoxHeader::new(Self::box_type(), size).write(writer)?;
if let Some(vmhd) = &self.vmhd {
if let Some(ref vmhd) = self.vmhd {
vmhd.write_box(writer)?;
}
if let Some(stbl) = &self.stbl {
if let Some(ref smhd) = self.smhd {
smhd.write_box(writer)?;
}
if let Some(ref stbl) = self.stbl {
stbl.write_box(writer)?;
}

130
src/atoms/mod.rs
View file

@ -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::*;
@ -16,13 +16,24 @@ mod mdhd;
mod hdlr;
mod minf;
mod vmhd;
mod smhd;
mod stbl;
mod stts;
mod stsd;
mod stts;
mod ctts;
mod stss;
mod stsc;
mod stsz;
mod stco;
mod co64;
mod avc;
mod mp4a;
pub use ftyp::FtypBox;
pub use moov::MoovBox;
const HEADER_SIZE: u64 = 8;
// const HEADER_LARGE_SIZE: u64 = 16;
pub const HEADER_EXT_SIZE: u64 = 4;
macro_rules! boxtype {
@ -71,12 +82,20 @@ boxtype!{
StblBox => 0x7374626c,
StsdBox => 0x73747364,
SttsBox => 0x73747473,
CttsBox => 0x63747473,
StssBox => 0x73747373,
StscBox => 0x73747363,
StszBox => 0x7374737A,
StcoBox => 0x7374636F,
Co64Box => 0x636F3634,
TrakBox => 0x7472616b,
UdtaBox => 0x75647461,
DinfBox => 0x64696e66,
SmhdBox => 0x736d6864,
Avc1Box => 0x61766331,
Mp4aBox => 0x6d703461
AvcCBox => 0x61766343,
Mp4aBox => 0x6d703461,
EsdsBox => 0x65736473
}
impl fmt::Debug for BoxType {
@ -86,6 +105,13 @@ impl fmt::Debug for BoxType {
}
}
impl fmt::Display for BoxType {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let fourcc: FourCC = From::from(self.clone());
write!(f, "{}", fourcc)
}
}
#[derive(Default, PartialEq, Clone)]
pub struct FourCC {
pub value: String
@ -167,7 +193,7 @@ impl fmt::Display for FourCC {
}
pub trait Mp4Box: Sized {
fn box_type(&self) -> BoxType;
fn box_type() -> BoxType;
fn box_size(&self) -> u64;
}
@ -179,23 +205,50 @@ pub trait WriteBox<T>: Sized {
fn write_box(&self, _: T) -> Result<u64>;
}
pub fn read_box_header_ext<R: Read>(reader: &mut BufReader<R>) -> Result<(u8, u32)> {
let version = reader.read_u8()?;
let flags_a = reader.read_u8()?;
let flags_b = reader.read_u8()?;
let flags_c = reader.read_u8()?;
let flags = u32::from(flags_a) << 16 | u32::from(flags_b) << 8 | u32::from(flags_c);
Ok((version, flags))
#[derive(Debug, Clone, Copy)]
pub struct BoxHeader {
pub name: BoxType,
pub size: u64,
}
pub fn write_box_header_ext<W: Write>(w: &mut BufWriter<W>, v: u8, f: u32) -> Result<u64> {
let d = u32::from(v) << 24 | f;
w.write_u32::<BigEndian>(d)?;
Ok(4)
}
impl BoxHeader {
fn new(name: BoxType, size: u64) -> Self {
Self { name, size }
}
impl<W: Write> WriteBox<&mut BufWriter<W>> for BoxHeader {
fn write_box(&self, writer: &mut BufWriter<W>) -> Result<u64> {
// TODO: if size is 0, then this box is the last one in the file
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)?;
// Get size.
let s = buf[0..4].try_into().unwrap();
let size = u32::from_be_bytes(s);
// Get box type string.
let t = buf[4..8].try_into().unwrap();
let typ = u32::from_be_bytes(t);
// Get largesize if size is 1
if size == 1 {
reader.read(&mut buf)?;
let s = buf.try_into().unwrap();
let largesize = u64::from_be_bytes(s);
Ok(BoxHeader {
name: BoxType::from(typ),
size: largesize,
})
} else {
Ok(BoxHeader {
name: BoxType::from(typ),
size: size as 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())?;
@ -209,19 +262,44 @@ impl<W: Write> WriteBox<&mut BufWriter<W>> for BoxHeader {
}
}
pub fn skip_read<R: Read + Seek>(reader: &mut BufReader<R>, current: u64, size: u64) -> Result<i64> {
let after = reader.seek(SeekFrom::Current(0))?;
let remaining_bytes = (size - (after - current)) as i64;
let size = remaining_bytes - HEADER_SIZE as i64;
reader.seek(SeekFrom::Current(size))?;
Ok(size)
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 skip_write<W: Write>(writer: &mut BufWriter<W>, size: u64) -> 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 R) -> Result<u64> {
Ok(reader.seek(SeekFrom::Current(0))? - HEADER_SIZE)
}
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 R, pos: u64) -> Result<()> {
reader.seek(SeekFrom::Start(pos))?;
Ok(())
}
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 W, size: u64) -> Result<()> {
for _ in 0..size {
writer.write_u8(0)?;
}
Ok(size)
Ok(())
}
#[cfg(test)]

41
src/atoms/moov.rs
View file

@ -1,6 +1,7 @@
use std::io::{BufReader, Seek, Read, BufWriter, Write};
use std::io::{Seek, SeekFrom, Read, Write};
use crate::*;
use crate::atoms::*;
use crate::atoms::{mvhd::MvhdBox, trak::TrakBox};
@ -17,7 +18,7 @@ impl MoovBox {
}
impl Mp4Box for MoovBox {
fn box_type(&self) -> BoxType {
fn box_type() -> BoxType {
BoxType::MoovBox
}
@ -30,15 +31,17 @@ 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();
let mut start = 0u64;
while start < size {
let mut current = reader.seek(SeekFrom::Current(0))?;
let end = start + size;
while current < end {
// Get box header.
let header = read_box_header(reader, start)?;
let header = BoxHeader::read(reader)?;
let BoxHeader{ name, size: s } = header;
match name {
@ -46,23 +49,33 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for MoovBox {
moov.mvhd = MvhdBox::read_box(reader, s)?;
}
BoxType::TrakBox => {
let trak = TrakBox::read_box(reader, s)?;
let mut trak = TrakBox::read_box(reader, s)?;
trak.id = moov.traks.len() as u32 + 1;
moov.traks.push(trak);
}
BoxType::UdtaBox => {
start = s - HEADER_SIZE;
// XXX warn!()
skip_box(reader, s)?;
}
_ => {
// XXX warn!()
skip_box(reader, s)?;
}
_ => break
}
current = reader.seek(SeekFrom::Current(0))?;
}
skip_read_to(reader, start + size)?;
Ok(moov)
}
}
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_box(writer)?;
BoxHeader::new(Self::box_type(), size).write(writer)?;
self.mvhd.write_box(writer)?;
for trak in self.traks.iter() {

411
src/atoms/mp4a.rs Normal file
View file

@ -0,0 +1,411 @@
use std::io::{Seek, Read, Write};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use crate::*;
use crate::atoms::*;
#[derive(Debug, PartialEq)]
pub struct Mp4aBox {
pub data_reference_index: u16,
pub channel_count: u16,
pub samplesize: u16,
pub samplerate: u32,
pub esds: EsdsBox,
}
impl Default for Mp4aBox {
fn default() -> Self {
Mp4aBox {
data_reference_index: 0,
channel_count: 2,
samplesize: 16,
samplerate: 0, // XXX
esds: EsdsBox::default(),
}
}
}
impl Mp4Box for Mp4aBox {
fn box_type() -> BoxType {
BoxType::Mp4aBox
}
fn box_size(&self) -> u64 {
HEADER_SIZE + 8 + 74 + self.esds.box_size()
}
}
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
reader.read_u16::<BigEndian>()?; // reserved
let data_reference_index = reader.read_u16::<BigEndian>()?;
reader.read_u64::<BigEndian>()?; // reserved
let channel_count = reader.read_u16::<BigEndian>()?;
let samplesize = reader.read_u16::<BigEndian>()?;
reader.read_u32::<BigEndian>()?; // pre-defined, reserved
let samplerate = reader.read_u32::<BigEndian>()?;
let header = BoxHeader::read(reader)?;
let BoxHeader{ name, size: s } = header;
if name == BoxType::EsdsBox {
let esds = EsdsBox::read_box(reader, s)?;
skip_read_to(reader, start + size)?;
Ok(Mp4aBox {
data_reference_index,
channel_count,
samplesize,
samplerate,
esds,
})
} else {
Err(Error::InvalidData("esds not found"))
}
}
}
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)?;
writer.write_u32::<BigEndian>(0)?; // reserved
writer.write_u16::<BigEndian>(0)?; // reserved
writer.write_u16::<BigEndian>(self.data_reference_index)?;
writer.write_u64::<BigEndian>(0)?; // reserved
writer.write_u16::<BigEndian>(self.channel_count)?;
writer.write_u16::<BigEndian>(self.samplesize)?;
writer.write_u32::<BigEndian>(0)?; // reserved
writer.write_u32::<BigEndian>(self.samplerate)?;
self.esds.write_box(writer)?;
Ok(size)
}
}
#[derive(Debug, Default, PartialEq)]
pub struct EsdsBox {
pub version: u8,
pub flags: u32,
pub es_desc: ESDescriptor,
}
impl Mp4Box for EsdsBox {
fn box_type() -> BoxType {
BoxType::EsdsBox
}
fn box_size(&self) -> u64 {
HEADER_SIZE + HEADER_EXT_SIZE
}
}
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)?;
let es_desc = ESDescriptor::read_desc(reader)?;
skip_read_to(reader, start + size)?;
Ok(EsdsBox {
version,
flags,
es_desc,
})
}
}
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)?;
write_box_header_ext(writer, self.version, self.flags)?;
Ok(size)
}
}
trait Descriptor: Sized {
fn desc_tag() -> u8;
fn desc_size() -> u32;
}
trait ReadDesc<T>: Sized {
fn read_desc(_: T) -> Result<Self>;
}
trait WriteDesc<T>: Sized {
fn write_desc(&self, _: T) -> Result<u32>;
}
fn read_desc<R: Read>(reader: &mut R) -> Result<(u8, u32)> {
let tag = reader.read_u8()?;
let mut size: u32 = 0;
for _ in 0..4 {
let b = reader.read_u8()?;
size = (size << 7) | (b & 0x7F) as u32;
if b & 0x80 == 0 {
break;
}
}
Ok((tag, size))
}
fn write_desc<W: Write>(writer: &mut W, tag: u8, size: u32) -> Result<u64> {
writer.write_u8(tag)?;
if size > 0x0FFFFFFF {
return Err(Error::InvalidData("invalid descriptor length range"));
}
let nbytes = match size {
0x0..=0x7F => 1,
0x80..=0x3FFF => 2,
0x4000..=0x1FFFFF => 3,
_ => 4,
};
for i in 0..nbytes {
let mut b = (size >> ((3 - i) * 7)) as u8 & 0x7F;
if i < nbytes - 1 {
b |= 0x80;
}
writer.write_u8(b)?;
}
Ok(1 + nbytes)
}
#[derive(Debug, Default, PartialEq)]
pub struct ESDescriptor {
pub tag: u8,
pub size: u32,
pub es_id: u16,
pub dec_config: DecoderConfigDescriptor,
pub sl_config: SLConfigDescriptor,
}
impl Descriptor for ESDescriptor {
fn desc_tag() -> u8 {
0x03
}
// XXX size > 0x7F
fn desc_size() -> u32 {
2 + 3
+ DecoderConfigDescriptor::desc_size()
+ SLConfigDescriptor::desc_size()
}
}
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"));
}
let es_id = reader.read_u16::<BigEndian>()?;
reader.read_u8()?; // XXX flags must be 0
let dec_config = DecoderConfigDescriptor::read_desc(reader)?;
let sl_config = SLConfigDescriptor::read_desc(reader)?;
Ok(ESDescriptor {
tag,
size,
es_id,
dec_config,
sl_config,
})
}
}
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)
}
}
#[derive(Debug, Default, PartialEq)]
pub struct DecoderConfigDescriptor {
pub tag: u8,
pub size: u32,
pub object_type_indication: u8,
pub stream_type: u8,
pub up_stream: u8,
pub buffer_size_db: u32,
pub max_bitrate: u32,
pub avg_bitrate: u32,
pub dec_specific: DecoderSpecificDescriptor,
}
impl Descriptor for DecoderConfigDescriptor {
fn desc_tag() -> u8 {
0x04
}
// XXX size > 0x7F
fn desc_size() -> u32 {
2 + 13 + DecoderSpecificDescriptor::desc_size()
}
}
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"));
}
let object_type_indication = reader.read_u8()?;
let byte_a = reader.read_u8()?;
let stream_type = byte_a & 0xFC;
let up_stream = byte_a & 0x02;
let buffer_size_db = reader.read_u24::<BigEndian>()?;
let max_bitrate = reader.read_u32::<BigEndian>()?;
let avg_bitrate = reader.read_u32::<BigEndian>()?;
let dec_specific = DecoderSpecificDescriptor::read_desc(reader)?;
// XXX skip_read
for _ in DecoderConfigDescriptor::desc_size()..size-1 {
reader.read_u8()?;
}
Ok(DecoderConfigDescriptor {
tag,
size,
object_type_indication,
stream_type,
up_stream,
buffer_size_db,
max_bitrate,
avg_bitrate,
dec_specific,
})
}
}
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)
}
}
#[derive(Debug, Default, PartialEq)]
pub struct DecoderSpecificDescriptor {
pub tag: u8,
pub size: u32,
pub profile: u8,
pub freq_index: u8,
pub chan_conf: u8,
}
impl Descriptor for DecoderSpecificDescriptor {
fn desc_tag() -> u8 {
0x05
}
// XXX size > 0x7F
fn desc_size() -> u32 {
2 + 2
}
}
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"));
}
let byte_a = reader.read_u8()?;
let byte_b = reader.read_u8()?;
let profile = byte_a >> 3;
let freq_index = ((byte_a & 0x07) << 1) + (byte_b >> 7);
let chan_conf = (byte_b >> 3) & 0x0F;
Ok(DecoderSpecificDescriptor {
tag,
size,
profile,
freq_index,
chan_conf,
})
}
}
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)
}
}
#[derive(Debug, Default, PartialEq)]
pub struct SLConfigDescriptor {
pub tag: u8,
pub size: u32,
}
impl Descriptor for SLConfigDescriptor {
fn desc_tag() -> u8 {
0x06
}
// XXX size > 0x7F
fn desc_size() -> u32 {
2 + 1
}
}
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"));
}
reader.read_u8()?; // pre-defined
Ok(SLConfigDescriptor {
tag,
size,
})
}
}
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)
}
}

62
src/atoms/mvhd.rs
View file

@ -1,8 +1,9 @@
use std::io::{BufReader, SeekFrom, Seek, Read, BufWriter, Write};
use std::io::{Seek, Read, Write};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use num_rational::Ratio;
use crate::*;
use crate::atoms::*;
#[derive(Debug, PartialEq)]
@ -31,7 +32,7 @@ impl Default for MvhdBox {
}
impl Mp4Box for MvhdBox {
fn box_type(&self) -> BoxType {
fn box_type() -> BoxType {
BoxType::MvhdBox
}
@ -48,9 +49,9 @@ 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> {
let current = reader.seek(SeekFrom::Current(0))?; // Current cursor position.
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)?;
@ -73,7 +74,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for MvhdBox {
};
let numer = reader.read_u32::<BigEndian>()?;
let rate = Ratio::new_raw(numer, 0x10000);
skip_read(reader, current, size)?;
skip_read_to(reader, start + size)?;
Ok(MvhdBox{
version,
@ -87,10 +89,10 @@ 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_box(writer)?;
BoxHeader::new(Self::box_type(), size).write(writer)?;
write_box_header_ext(writer, self.version, self.flags)?;
@ -118,7 +120,7 @@ impl<W: Write> WriteBox<&mut BufWriter<W>> for MvhdBox {
#[cfg(test)]
mod tests {
use super::*;
use crate::read_box_header;
use crate::atoms::BoxHeader;
use std::io::Cursor;
#[test]
@ -133,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 = read_box_header(&mut reader, 0).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]
@ -163,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 = read_box_header(&mut reader, 0).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);
}
}

95
src/atoms/smhd.rs Normal file
View file

@ -0,0 +1,95 @@
use std::io::{Seek, Read, Write};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use num_rational::Ratio;
use crate::*;
use crate::atoms::*;
#[derive(Debug, PartialEq)]
pub struct SmhdBox {
pub version: u8,
pub flags: u32,
pub balance: Ratio<i16>,
}
impl Default for SmhdBox {
fn default() -> Self {
SmhdBox {
version: 0,
flags: 0,
balance: Ratio::new_raw(0, 0x100),
}
}
}
impl Mp4Box for SmhdBox {
fn box_type() -> BoxType {
BoxType::SmhdBox
}
fn box_size(&self) -> u64 {
HEADER_SIZE + HEADER_EXT_SIZE + 4
}
}
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)?;
let balance_numer = reader.read_i16::<BigEndian>()?;
let balance = Ratio::new_raw(balance_numer, 0x100);
skip_read_to(reader, start + size)?;
Ok(SmhdBox {
version,
flags,
balance,
})
}
}
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)?;
write_box_header_ext(writer, self.version, self.flags)?;
writer.write_i16::<BigEndian>(*self.balance.numer())?;
writer.write_u16::<BigEndian>(0)?; // reserved
Ok(size)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::atoms::BoxHeader;
use std::io::Cursor;
#[test]
fn test_smhd() {
let src_box = SmhdBox {
version: 0,
flags: 0,
balance: Ratio::new_raw(-0x100, 0x100),
};
let mut buf = Vec::new();
src_box.write_box(&mut buf).unwrap();
assert_eq!(buf.len(), src_box.box_size() as usize);
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);
}
}

132
src/atoms/stbl.rs
View file

@ -1,13 +1,29 @@
use std::io::{BufReader, Seek, Read, BufWriter, Write};
use std::io::{Seek, SeekFrom, Read, Write};
use crate::*;
use crate::atoms::{stts::SttsBox, stsd::StsdBox};
use crate::atoms::*;
use crate::atoms::{
stsd::StsdBox,
stts::SttsBox,
ctts::CttsBox,
stss::StssBox,
stsc::StscBox,
stsz::StszBox,
stco::StcoBox,
co64::Co64Box,
};
#[derive(Debug, Default)]
pub struct StblBox {
pub stts: Option<SttsBox>,
pub stsd: Option<StsdBox>,
pub stts: Option<SttsBox>,
pub ctts: Option<CttsBox>,
pub stss: Option<StssBox>,
pub stsc: Option<StscBox>,
pub stsz: Option<StszBox>,
pub stco: Option<StcoBox>,
pub co64: Option<Co64Box>,
}
impl StblBox {
@ -17,58 +33,128 @@ impl StblBox {
}
impl Mp4Box for StblBox {
fn box_type(&self) -> BoxType {
fn box_type() -> BoxType {
BoxType::StblBox
}
fn box_size(&self) -> u64 {
let mut size = HEADER_SIZE;
if let Some(stts) = &self.stts {
if let Some(ref stsd) = self.stsd {
size += stsd.box_size();
}
if let Some(ref stts) = self.stts {
size += stts.box_size();
}
if let Some(stsd) = &self.stsd {
size += stsd.box_size();
if let Some(ref ctts) = self.ctts {
size += ctts.box_size();
}
if let Some(ref stss) = self.stss {
size += stss.box_size();
}
if let Some(ref stsc) = self.stsc {
size += stsc.box_size();
}
if let Some(ref stsz) = self.stsz {
size += stsz.box_size();
}
if let Some(ref stco) = self.stco {
size += stco.box_size();
}
if let Some(ref co64) = self.co64 {
size += co64.box_size();
}
size
}
}
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();
let start = 0u64;
while start < size {
let mut current = reader.seek(SeekFrom::Current(0))?;
let end = start + size;
while current < end {
// Get box header.
let header = read_box_header(reader, start)?;
let header = BoxHeader::read(reader)?;
let BoxHeader{ name, size: s } = header;
match name {
BoxType::SttsBox => {
let stts = SttsBox::read_box(reader, s)?;
stbl.stts = Some(stts);
}
BoxType::StsdBox => {
let stsd = StsdBox::read_box(reader, s)?;
stbl.stsd = Some(stsd);
}
_ => break
BoxType::SttsBox => {
let stts = SttsBox::read_box(reader, s)?;
stbl.stts = Some(stts);
}
BoxType::CttsBox => {
let ctts = CttsBox::read_box(reader, s)?;
stbl.ctts = Some(ctts);
}
BoxType::StssBox => {
let stss = StssBox::read_box(reader, s)?;
stbl.stss = Some(stss);
}
BoxType::StscBox => {
let stsc = StscBox::read_box(reader, s)?;
stbl.stsc = Some(stsc);
}
BoxType::StszBox => {
let stsz = StszBox::read_box(reader, s)?;
stbl.stsz = Some(stsz);
}
BoxType::StcoBox => {
let stco = StcoBox::read_box(reader, s)?;
stbl.stco = Some(stco);
}
BoxType::Co64Box => {
let co64 = Co64Box::read_box(reader, s)?;
stbl.co64 = Some(co64);
}
_ => {
// XXX warn!()
skip_box(reader, s)?;
}
}
current = reader.seek(SeekFrom::Current(0))?;
}
skip_read_to(reader, start + size)?;
Ok(stbl)
}
}
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_box(writer)?;
BoxHeader::new(Self::box_type(), size).write(writer)?;
if let Some(stts) = &self.stts {
if let Some(ref stsd) = self.stsd {
stsd.write_box(writer)?;
}
if let Some(ref stts) = self.stts {
stts.write_box(writer)?;
}
if let Some(stsd) = &self.stsd {
stsd.write_box(writer)?;
if let Some(ref ctts) = self.ctts {
ctts.write_box(writer)?;
}
if let Some(ref stss) = self.stss {
stss.write_box(writer)?;
}
if let Some(ref stsc) = self.stsc {
stsc.write_box(writer)?;
}
if let Some(ref stsz) = self.stsz {
stsz.write_box(writer)?;
}
if let Some(ref stco) = self.stco {
stco.write_box(writer)?;
}
if let Some(ref co64) = self.co64 {
co64.write_box(writer)?;
}
Ok(size)

89
src/atoms/stco.rs Normal file
View file

@ -0,0 +1,89 @@
use std::io::{Seek, Read, Write};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use crate::*;
use crate::atoms::*;
#[derive(Debug, Default, PartialEq)]
pub struct StcoBox {
pub version: u8,
pub flags: u32,
pub entries: Vec<u32>,
}
impl Mp4Box for StcoBox {
fn box_type() -> BoxType {
BoxType::StcoBox
}
fn box_size(&self) -> u64 {
HEADER_SIZE + HEADER_EXT_SIZE + 4 + (4 * self.entries.len() as u64)
}
}
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)?;
let entry_count = reader.read_u32::<BigEndian>()?;
let mut entries = Vec::with_capacity(entry_count as usize);
for _i in 0..entry_count {
let chunk_offset = reader.read_u32::<BigEndian>()?;
entries.push(chunk_offset);
}
skip_read_to(reader, start + size)?;
Ok(StcoBox {
version,
flags,
entries,
})
}
}
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)?;
write_box_header_ext(writer, self.version, self.flags)?;
writer.write_u32::<BigEndian>(self.entries.len() as u32)?;
for chunk_offset in self.entries.iter() {
writer.write_u32::<BigEndian>(*chunk_offset)?;
}
Ok(size)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::atoms::BoxHeader;
use std::io::Cursor;
#[test]
fn test_stco() {
let src_box = StcoBox {
version: 0,
flags: 0,
entries: vec![267, 1970, 2535, 2803, 11843, 22223, 33584],
};
let mut buf = Vec::new();
src_box.write_box(&mut buf).unwrap();
assert_eq!(buf.len(), src_box.box_size() as usize);
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);
}
}

130
src/atoms/stsc.rs Normal file
View file

@ -0,0 +1,130 @@
use std::io::{Seek, Read, Write};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use crate::*;
use crate::atoms::*;
#[derive(Debug, Default, PartialEq)]
pub struct StscBox {
pub version: u8,
pub flags: u32,
pub entries: Vec<StscEntry>,
}
#[derive(Debug, Default, PartialEq)]
pub struct StscEntry {
pub first_chunk: u32,
pub samples_per_chunk: u32,
pub sample_description_index: u32,
pub first_sample: u32,
}
impl Mp4Box for StscBox {
fn box_type() -> BoxType {
BoxType::StscBox
}
fn box_size(&self) -> u64 {
HEADER_SIZE + HEADER_EXT_SIZE + 4 + (12 * self.entries.len() as u64)
}
}
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)?;
let entry_count = reader.read_u32::<BigEndian>()?;
let mut entries = Vec::with_capacity(entry_count as usize);
for _ in 0..entry_count {
let entry = StscEntry {
first_chunk: reader.read_u32::<BigEndian>()?,
samples_per_chunk: reader.read_u32::<BigEndian>()?,
sample_description_index: reader.read_u32::<BigEndian>()?,
first_sample: 0,
};
entries.push(entry);
}
let mut sample_id = 1;
for i in 0..entry_count {
let (first_chunk, samples_per_chunk) = {
let mut entry = entries.get_mut(i as usize).unwrap();
entry.first_sample = sample_id;
(entry.first_chunk, entry.samples_per_chunk)
};
if i < entry_count - 1 {
let next_entry = entries.get(i as usize + 1).unwrap();
sample_id += (next_entry.first_chunk - first_chunk) * samples_per_chunk;
}
}
skip_read_to(reader, start + size)?;
Ok(StscBox {
version,
flags,
entries,
})
}
}
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)?;
write_box_header_ext(writer, self.version, self.flags)?;
writer.write_u32::<BigEndian>(self.entries.len() as u32)?;
for entry in self.entries.iter() {
writer.write_u32::<BigEndian>(entry.first_chunk)?;
writer.write_u32::<BigEndian>(entry.samples_per_chunk)?;
writer.write_u32::<BigEndian>(entry.sample_description_index)?;
}
Ok(size)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::atoms::BoxHeader;
use std::io::Cursor;
#[test]
fn test_stsc() {
let src_box = StscBox {
version: 0,
flags: 0,
entries: vec![
StscEntry {
first_chunk: 1,
samples_per_chunk: 1,
sample_description_index: 1,
first_sample: 1,
},
StscEntry {
first_chunk: 19026,
samples_per_chunk: 14,
sample_description_index: 1,
first_sample: 19026,
},
],
};
let mut buf = Vec::new();
src_box.write_box(&mut buf).unwrap();
assert_eq!(buf.len(), src_box.box_size() as usize);
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);
}
}

75
src/atoms/stsd.rs
View file

@ -1,59 +1,86 @@
use std::io::{BufReader, SeekFrom, Seek, Read, BufWriter, Write};
use byteorder::{BigEndian, ReadBytesExt};
use std::io::{Seek, Read, Write};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use crate::*;
use crate::atoms::*;
use crate::atoms::{avc::Avc1Box, mp4a::Mp4aBox};
#[derive(Debug)]
pub struct StsdBox {
pub version: u8,
pub flags: u32,
pub avc1: Option<Avc1Box>,
pub mp4a: Option<Mp4aBox>,
}
impl Mp4Box for StsdBox {
fn box_type(&self) -> BoxType {
fn box_type() -> BoxType {
BoxType::StsdBox
}
fn box_size(&self) -> u64 {
// TODO
0
let mut size = HEADER_SIZE + HEADER_EXT_SIZE;
if let Some(ref avc1) = self.avc1 {
size += avc1.box_size();
} else if let Some(ref mp4a) = self.mp4a {
size += mp4a.box_size();
}
size
}
}
impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for StsdBox {
fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
let current = reader.seek(SeekFrom::Current(0))?; // Current cursor position.
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)?;
let _entry_count = reader.read_u32::<BigEndian>()?;
reader.read_u32::<BigEndian>()?; // XXX entry_count
let mut start = 0u64;
while start < size {
// Get box header.
let header = read_box_header(reader, start)?;
let BoxHeader{ name, size: s } = header;
let mut avc1 = None;
let mut mp4a = None;
match name {
BoxType::Avc1Box => {}
BoxType::Mp4aBox => {}
_ => break
// Get box header.
let header = BoxHeader::read(reader)?;
let BoxHeader{ name, size: s } = header;
match name {
BoxType::Avc1Box => {
avc1 = Some(Avc1Box::read_box(reader, s)?);
}
start += s - HEADER_SIZE;
BoxType::Mp4aBox => {
mp4a = Some(Mp4aBox::read_box(reader, s)?);
}
_ => {}
}
skip_read(reader, current, size)?;
skip_read_to(reader, start + size)?;
Ok(StsdBox {
version,
flags,
avc1,
mp4a,
})
}
}
impl<W: Write> WriteBox<&mut BufWriter<W>> for StsdBox {
fn write_box(&self, _writer: &mut BufWriter<W>) -> Result<u64> {
// TODO
Ok(0)
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)?;
write_box_header_ext(writer, self.version, self.flags)?;
writer.write_u32::<BigEndian>(1)?; // entry_count
if let Some(ref avc1) = self.avc1 {
avc1.write_box(writer)?;
} else if let Some(ref mp4a) = self.mp4a {
mp4a.write_box(writer)?;
}
Ok(size)
}
}

89
src/atoms/stss.rs Normal file
View file

@ -0,0 +1,89 @@
use std::io::{Seek, Read, Write};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use crate::*;
use crate::atoms::*;
#[derive(Debug, Default, PartialEq)]
pub struct StssBox {
pub version: u8,
pub flags: u32,
pub entries: Vec<u32>,
}
impl Mp4Box for StssBox {
fn box_type() -> BoxType {
BoxType::StssBox
}
fn box_size(&self) -> u64 {
HEADER_SIZE + HEADER_EXT_SIZE + 4 + (4 * self.entries.len() as u64)
}
}
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)?;
let entry_count = reader.read_u32::<BigEndian>()?;
let mut entries = Vec::with_capacity(entry_count as usize);
for _i in 0..entry_count {
let sample_number = reader.read_u32::<BigEndian>()?;
entries.push(sample_number);
}
skip_read_to(reader, start + size)?;
Ok(StssBox {
version,
flags,
entries,
})
}
}
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)?;
write_box_header_ext(writer, self.version, self.flags)?;
writer.write_u32::<BigEndian>(self.entries.len() as u32)?;
for sample_number in self.entries.iter() {
writer.write_u32::<BigEndian>(*sample_number)?;
}
Ok(size)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::atoms::BoxHeader;
use std::io::Cursor;
#[test]
fn test_stss() {
let src_box = StssBox {
version: 0,
flags: 0,
entries: vec![1, 61, 121, 181, 241, 301, 361, 421, 481],
};
let mut buf = Vec::new();
src_box.write_box(&mut buf).unwrap();
assert_eq!(buf.len(), src_box.box_size() as usize);
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);
}
}

119
src/atoms/stsz.rs Normal file
View file

@ -0,0 +1,119 @@
use std::io::{Seek, Read, Write};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use crate::*;
use crate::atoms::*;
#[derive(Debug, Default, PartialEq)]
pub struct StszBox {
pub version: u8,
pub flags: u32,
pub sample_size: u32,
pub sample_sizes: Vec<u32>,
}
impl Mp4Box for StszBox {
fn box_type() -> BoxType {
BoxType::StszBox
}
fn box_size(&self) -> u64 {
HEADER_SIZE + HEADER_EXT_SIZE + 8 + (4 * self.sample_sizes.len() as u64)
}
}
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)?;
let sample_size = reader.read_u32::<BigEndian>()?;
let sample_count = reader.read_u32::<BigEndian>()?;
let mut sample_sizes = Vec::with_capacity(sample_count as usize);
if sample_size == 0 {
for _i in 0..sample_count {
let sample_number = reader.read_u32::<BigEndian>()?;
sample_sizes.push(sample_number);
}
}
skip_read_to(reader, start + size)?;
Ok(StszBox {
version,
flags,
sample_size,
sample_sizes,
})
}
}
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)?;
write_box_header_ext(writer, self.version, self.flags)?;
writer.write_u32::<BigEndian>(self.sample_size)?;
writer.write_u32::<BigEndian>(self.sample_sizes.len() as u32)?;
if self.sample_size == 0 {
for sample_number in self.sample_sizes.iter() {
writer.write_u32::<BigEndian>(*sample_number)?;
}
}
Ok(size)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::atoms::BoxHeader;
use std::io::Cursor;
#[test]
fn test_stsz_same_size() {
let src_box = StszBox {
version: 0,
flags: 0,
sample_size: 1165,
sample_sizes: vec![],
};
let mut buf = Vec::new();
src_box.write_box(&mut buf).unwrap();
assert_eq!(buf.len(), src_box.box_size() as usize);
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);
}
#[test]
fn test_stsz_many_sizes() {
let src_box = StszBox {
version: 0,
flags: 0,
sample_size: 0,
sample_sizes: vec![1165, 11, 11, 8545, 10126, 10866, 9643, 9351, 7730],
};
let mut buf = Vec::new();
src_box.write_box(&mut buf).unwrap();
assert_eq!(buf.len(), src_box.box_size() as usize);
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);
}
}

73
src/atoms/stts.rs
View file

@ -1,7 +1,8 @@
use std::io::{BufReader, SeekFrom, Seek, Read, BufWriter, Write};
use std::io::{Seek, Read, Write};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use crate::*;
use crate::atoms::*;
#[derive(Debug, Default, PartialEq)]
@ -18,7 +19,7 @@ pub struct SttsEntry {
}
impl Mp4Box for SttsBox {
fn box_type(&self) -> BoxType {
fn box_type() -> BoxType {
BoxType::SttsBox
}
@ -27,9 +28,9 @@ 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> {
let current = reader.seek(SeekFrom::Current(0))?; // Current cursor position.
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)?;
@ -42,7 +43,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for SttsBox {
};
entries.push(entry);
}
skip_read(reader, current, size)?;
skip_read_to(reader, start + size)?;
Ok(SttsBox {
version,
@ -52,10 +54,10 @@ 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_box(writer)?;
BoxHeader::new(Self::box_type(), size).write(writer)?;
write_box_header_ext(writer, self.version, self.flags)?;
@ -72,11 +74,11 @@ impl<W: Write> WriteBox<&mut BufWriter<W>> for SttsBox {
#[cfg(test)]
mod tests {
use super::*;
use crate::read_box_header;
use crate::atoms::BoxHeader;
use std::io::Cursor;
#[test]
fn test_stts32() {
fn test_stts() {
let src_box = SttsBox {
version: 0,
flags: 0,
@ -86,50 +88,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 = read_box_header(&mut reader, 0).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);
}
}
#[test]
fn test_stts64() {
let src_box = SttsBox {
version: 1,
flags: 0,
entries: vec![
SttsEntry {sample_count: 29726, sample_delta: 1024},
SttsEntry {sample_count: 1, sample_delta: 512},
],
};
let mut buf = Vec::new();
{
let mut writer = BufWriter::new(&mut buf);
src_box.write_box(&mut writer).unwrap();
}
assert_eq!(buf.len(), src_box.box_size() as usize);
{
let mut reader = BufReader::new(Cursor::new(&buf));
let header = read_box_header(&mut reader, 0).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);
}
}

61
src/atoms/tkhd.rs
View file

@ -1,8 +1,9 @@
use std::io::{BufReader, Seek, SeekFrom, Read, BufWriter, Write};
use std::io::{Seek, Read, Write};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use num_rational::Ratio;
use crate::*;
use crate::atoms::*;
#[derive(Debug, PartialEq)]
@ -54,7 +55,7 @@ pub struct Matrix {
}
impl Mp4Box for TkhdBox {
fn box_type(&self) -> BoxType {
fn box_type() -> BoxType {
BoxType::TkhdBox
}
@ -71,9 +72,9 @@ 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> {
let current = reader.seek(SeekFrom::Current(0))?; // Current cursor position.
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)?;
@ -118,7 +119,7 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for TkhdBox {
let width = reader.read_u32::<BigEndian>()? >> 16;
let height = reader.read_u32::<BigEndian>()? >> 16;
skip_read(reader, current, size)?;
skip_read_to(reader, start + size)?;
Ok(TkhdBox {
version,
@ -137,10 +138,10 @@ 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_box(writer)?;
BoxHeader::new(Self::box_type(), size).write(writer)?;
write_box_header_ext(writer, self.version, self.flags)?;
@ -186,7 +187,7 @@ impl<W: Write> WriteBox<&mut BufWriter<W>> for TkhdBox {
#[cfg(test)]
mod tests {
use super::*;
use crate::read_box_header;
use crate::atoms::BoxHeader;
use std::io::Cursor;
#[test]
@ -216,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 = read_box_header(&mut reader, 0).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]
@ -261,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 = read_box_header(&mut reader, 0).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);
}
}

280
src/atoms/trak.rs
View file

@ -1,11 +1,22 @@
use std::io::{BufReader, SeekFrom, Seek, Read, BufWriter, Write};
use std::io::{Seek, SeekFrom, Read, Write};
use crate::*;
use crate::atoms::{tkhd::TkhdBox, edts::EdtsBox, mdia::MdiaBox};
use crate::atoms::*;
use crate::atoms::{
tkhd::TkhdBox,
edts::EdtsBox,
mdia::MdiaBox,
stbl::StblBox,
stts::SttsBox,
stsc::StscBox,
stsz::StszBox,
};
#[derive(Debug, Default)]
pub struct TrakBox {
pub id: u32,
pub tkhd: Option<TkhdBox>,
pub edts: Option<EdtsBox>,
pub mdia: Option<MdiaBox>,
@ -15,37 +26,260 @@ impl TrakBox {
pub(crate) fn new() -> TrakBox {
Default::default()
}
fn stbl(&self) -> Result<&StblBox> {
if let Some(ref mdia) = self.mdia {
if let Some(ref minf) = mdia.minf {
if let Some(ref stbl) = minf.stbl {
Ok(stbl)
} else {
Err(Error::BoxInTrakNotFound(self.id, BoxType::StblBox))
}
} else {
Err(Error::BoxInTrakNotFound(self.id, BoxType::MinfBox))
}
} else {
Err(Error::BoxInTrakNotFound(self.id, BoxType::MdiaBox))
}
}
fn stts(&self) -> Result<&SttsBox> {
let stbl = self.stbl()?;
if let Some(ref stts) = stbl.stts {
Ok(stts)
} else {
Err(Error::BoxInStblNotFound(self.id, BoxType::SttsBox))
}
}
fn stsc(&self) -> Result<&StscBox> {
let stbl = self.stbl()?;
if let Some(ref stsc) = stbl.stsc {
Ok(stsc)
} else {
Err(Error::BoxInStblNotFound(self.id, BoxType::StscBox))
}
}
fn stsz(&self) -> Result<&StszBox> {
let stbl = self.stbl()?;
if let Some(ref stsz) = stbl.stsz {
Ok(stsz)
} else {
Err(Error::BoxInStblNotFound(self.id, BoxType::StszBox))
}
}
fn stsc_index(&self, sample_id: u32) -> Result<usize> {
let stsc = self.stsc()?;
for (i, entry) in stsc.entries.iter().enumerate() {
if sample_id < entry.first_sample {
assert_ne!(i, 0);
return Ok(i - 1);
}
}
assert_ne!(stsc.entries.len(), 0);
Ok(stsc.entries.len() - 1)
}
fn chunk_offset(&self, chunk_id: u32) -> Result<u64> {
let stbl = self.stbl()?;
if let Some(ref stco) = stbl.stco {
if let Some(offset) = stco.entries.get(chunk_id as usize - 1) {
return Ok(*offset as u64);
} else {
return Err(Error::EntryInStblNotFound(self.id, BoxType::StcoBox,
chunk_id));
}
} else {
if let Some(ref co64) = stbl.co64 {
if let Some(offset) = co64.entries.get(chunk_id as usize - 1) {
return Ok(*offset);
} else {
return Err(Error::EntryInStblNotFound(self.id, BoxType::Co64Box,
chunk_id));
}
} else {
// XXX BoxType::StcoBox & BoxType::Co64Box
Err(Error::BoxInStblNotFound(self.id, BoxType::Co64Box))
}
}
}
fn ctts_index(&self, sample_id: u32) -> Result<(usize, u32)> {
let stbl = self.stbl()?;
let ctts = if let Some(ref ctts) = stbl.ctts {
ctts
} else {
return Err(Error::BoxInStblNotFound(self.id, BoxType::CttsBox));
};
let mut sample_count = 1;
for (i, entry) in ctts.entries.iter().enumerate() {
if sample_id <= sample_count + entry.sample_count -1 {
return Ok((i, sample_count))
}
sample_count += entry.sample_count;
}
return Err(Error::EntryInStblNotFound(self.id, BoxType::CttsBox, sample_id));
}
pub fn sample_count(&self) -> Result<u32> {
let stsz = self.stsz()?;
Ok(stsz.sample_sizes.len() as u32)
}
pub fn sample_size(&self, sample_id: u32) -> Result<u32> {
let stsz = self.stsz()?;
if stsz.sample_size > 0 {
return Ok(stsz.sample_size);
}
if let Some(size) = stsz.sample_sizes.get(sample_id as usize - 1) {
Ok(*size)
} else {
return Err(Error::EntryInStblNotFound(self.id, BoxType::StszBox, sample_id));
}
}
pub fn sample_offset(&self, sample_id: u32) -> Result<u64> {
let stsc_index = self.stsc_index(sample_id)?;
let stsc = self.stsc()?;
let stsc_entry = stsc.entries.get(stsc_index).unwrap();
let first_chunk = stsc_entry.first_chunk;
let first_sample = stsc_entry.first_sample;
let samples_per_chunk = stsc_entry.samples_per_chunk;
let chunk_id = first_chunk + (sample_id - first_sample) / samples_per_chunk;
let chunk_offset = self.chunk_offset(chunk_id)?;
let first_sample_in_chunk = sample_id - (sample_id - first_sample)
% samples_per_chunk;
let mut sample_offset = 0;
for i in first_sample_in_chunk..sample_id {
sample_offset += self.sample_size(i)?;
}
Ok(chunk_offset + sample_offset as u64)
}
pub fn sample_time(&self, sample_id: u32) -> Result<(u64, u32)> {
let stts = self.stts()?;
let mut sample_count = 1;
let mut elapsed = 0;
for entry in stts.entries.iter() {
if sample_id <= sample_count + entry.sample_count - 1 {
let start_time = (sample_id - sample_count) as u64
* entry.sample_delta as u64 + elapsed;
return Ok((start_time, entry.sample_delta));
}
sample_count += entry.sample_count;
elapsed += entry.sample_count as u64 * entry.sample_delta as u64;
}
return Err(Error::EntryInStblNotFound(self.id, BoxType::SttsBox, sample_id));
}
pub fn sample_rendering_offset(&self, sample_id: u32) -> Result<i32> {
let stbl = self.stbl()?;
if let Some(ref ctts) = stbl.ctts {
let (ctts_index, _) = self.ctts_index(sample_id)?;
let ctts_entry = ctts.entries.get(ctts_index).unwrap();
Ok(ctts_entry.sample_offset)
} else {
Ok(0)
}
}
pub fn is_sync_sample(&self, sample_id: u32) -> Result<bool> {
let stbl = self.stbl()?;
if let Some(ref stss) = stbl.stss {
match stss.entries.binary_search(&sample_id) {
Ok(_) => Ok(true),
Err(_) => Ok(false)
}
} else {
Ok(true)
}
}
pub fn read_sample<R: Read + Seek>(
&self,
reader: &mut R,
sample_id: u32,
) -> Result<Option<Mp4Sample>> {
let sample_offset = match self.sample_offset(sample_id) {
Ok(offset) => offset,
Err(Error::EntryInStblNotFound(_,_,_)) => return Ok(None),
Err(err) => return Err(err)
};
let sample_size = self.sample_size(sample_id)?;
let mut buffer = vec![0x0u8; sample_size as usize];
reader.seek(SeekFrom::Start(sample_offset))?;
reader.read_exact(&mut buffer)?;
let (start_time, duration) = self.sample_time(sample_id)?;
let rendering_offset = self.sample_rendering_offset(sample_id)?;
let is_sync = self.is_sync_sample(sample_id)?;
Ok(Some(Mp4Sample {
start_time,
duration,
rendering_offset,
is_sync,
bytes: Bytes::from(buffer),
}))
}
}
impl Mp4Box for TrakBox {
fn box_type(&self) -> BoxType {
fn box_type() -> BoxType {
BoxType::TrakBox
}
fn box_size(&self) -> u64 {
let mut size = HEADER_SIZE;
if let Some(tkhd) = &self.tkhd {
if let Some(ref tkhd) = self.tkhd {
size += tkhd.box_size();
}
if let Some(edts) = &self.edts {
if let Some(ref edts) = self.edts {
size += edts.box_size();
}
if let Some(mdia) = &self.mdia {
if let Some(ref mdia) = self.mdia {
size += mdia.box_size();
}
size
}
}
impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for TrakBox {
fn read_box(reader: &mut BufReader<R>, size: u64) -> Result<Self> {
let current = reader.seek(SeekFrom::Current(0))?; // Current cursor position.
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();
let start = 0u64;
while start < size {
let mut current = reader.seek(SeekFrom::Current(0))?;
let end = start + size;
while current < end {
// Get box header.
let header = read_box_header(reader, start)?;
let header = BoxHeader::read(reader)?;
let BoxHeader{ name, size: s } = header;
match name {
@ -61,27 +295,33 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for TrakBox {
let mdia = MdiaBox::read_box(reader, s)?;
trak.mdia = Some(mdia);
}
_ => break
_ => {
// XXX warn!()
skip_box(reader, s)?;
}
}
current = reader.seek(SeekFrom::Current(0))?;
}
skip_read(reader, current, size)?;
skip_read_to(reader, start + size)?;
Ok(trak)
}
}
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_box(writer)?;
BoxHeader::new(Self::box_type(), size).write(writer)?;
if let Some(tkhd) = &self.tkhd {
if let Some(ref tkhd) = self.tkhd {
tkhd.write_box(writer)?;
}
if let Some(edts) = &self.edts {
if let Some(ref edts) = self.edts {
edts.write_box(writer)?;
}
if let Some(mdia) = &self.mdia {
if let Some(ref mdia) = self.mdia {
mdia.write_box(writer)?;
}

42
src/atoms/vmhd.rs
View file

@ -1,7 +1,8 @@
use std::io::{BufReader, SeekFrom, Seek, Read, BufWriter, Write};
use std::io::{Seek, Read, Write};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use crate::*;
use crate::atoms::*;
#[derive(Debug, Default, PartialEq)]
@ -20,7 +21,7 @@ pub struct RgbColor {
}
impl Mp4Box for VmhdBox {
fn box_type(&self) -> BoxType {
fn box_type() -> BoxType {
BoxType::VmhdBox
}
@ -29,9 +30,9 @@ 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> {
let current = reader.seek(SeekFrom::Current(0))?; // Current cursor position.
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)?;
@ -41,7 +42,8 @@ impl<R: Read + Seek> ReadBox<&mut BufReader<R>> for VmhdBox {
green: reader.read_u16::<BigEndian>()?,
blue: reader.read_u16::<BigEndian>()?,
};
skip_read(reader, current, size)?;
skip_read_to(reader, start + size)?;
Ok(VmhdBox {
version,
@ -52,10 +54,10 @@ 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_box(writer)?;
BoxHeader::new(Self::box_type(), size).write(writer)?;
write_box_header_ext(writer, self.version, self.flags)?;
@ -72,7 +74,7 @@ impl<W: Write> WriteBox<&mut BufWriter<W>> for VmhdBox {
#[cfg(test)]
mod tests {
use super::*;
use crate::read_box_header;
use crate::atoms::BoxHeader;
use std::io::Cursor;
#[test]
@ -84,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 = read_box_header(&mut reader, 0).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);
}
}

12
src/error.rs
View file

@ -1,9 +1,21 @@
use thiserror::Error;
use crate::atoms::BoxType;
#[derive(Error, Debug)]
pub enum Error {
#[error("{0}")]
IoError(#[from] std::io::Error),
#[error("{0}")]
InvalidData(&'static str),
#[error("{0} not found")]
BoxNotFound(BoxType),
#[error("trak[{0}] not found")]
TrakNotFound(u32),
#[error("trak[{0}].{1} not found")]
BoxInTrakNotFound(u32, BoxType),
#[error("trak[{0}].stbl.{1} not found")]
BoxInStblNotFound(u32, BoxType),
#[error("trak[{0}].stbl.{1}.entry[{2}] not found")]
EntryInStblNotFound(u32, BoxType, u32),
}

220
src/lib.rs
View file

@ -1,7 +1,9 @@
use std::io::{BufReader, Read, SeekFrom, Seek};
use std::fs::File;
use std::fmt;
use std::io::{Seek, SeekFrom, Read};
use std::convert::TryInto;
pub use bytes::Bytes;
mod atoms;
use crate::atoms::*;
@ -10,9 +12,6 @@ pub use error::Error;
pub type Result<T> = std::result::Result<T, Error>;
// XXX if box has largesize
const HEADER_SIZE: u64 = 8;
#[derive(Debug, PartialEq)]
pub enum TrackType {
Audio,
@ -21,118 +20,143 @@ pub enum TrackType {
Unknown,
}
#[derive(Debug, Default)]
pub struct BMFF {
pub ftyp: FtypBox,
pub moov: Option<MoovBox>,
pub size: u64,
#[derive(Debug)]
pub struct Mp4Sample {
pub start_time: u64,
pub duration: u32,
pub rendering_offset: i32,
pub is_sync: bool,
pub bytes: Bytes,
}
impl BMFF {
fn new() -> BMFF {
Default::default()
impl PartialEq for Mp4Sample {
fn eq(&self, other: &Self) -> bool {
self.start_time == other.start_time
&& self.duration == other.duration
&& self.rendering_offset == other.rendering_offset
&& self.is_sync == other.is_sync
&& self.bytes.len() == other.bytes.len() // XXX for easy check
}
}
#[derive(Debug, Clone, Copy)]
struct BoxHeader {
name: BoxType,
impl fmt::Display for Mp4Sample {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f,
"start_time {}, duration {}, rendering_offset {}, is_sync {}, length {}",
self.start_time, self.duration, self.rendering_offset, self.is_sync,
self.bytes.len())
}
}
#[derive(Debug)]
pub struct Mp4Reader<R> {
reader: R,
pub ftyp: FtypBox,
pub moov: Option<MoovBox>,
size: u64,
}
impl BoxHeader {
fn new(name: BoxType, size: u64) -> Self {
Self { name, size }
impl<R: Read + Seek> Mp4Reader<R> {
pub fn new(reader: R) -> Self {
Mp4Reader {
reader,
ftyp: FtypBox::default(),
moov: None,
size: 0,
}
}
}
pub fn read_mp4(f: File) -> Result<BMFF> {
pub fn size(&self) -> u64 {
self.size
}
// Open file and read boxes.
let bmff = read_boxes(f)?;
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(&mut self.reader)?;
let BoxHeader{ name, size: s } = header;
Ok(bmff)
}
fn read_boxes(f: File) -> Result<BMFF> {
let filesize = f.metadata()?.len();
let mut reader = BufReader::new(f);
let mut bmff = BMFF::new();
bmff.size = filesize;
let mut start = 0u64;
while start < filesize {
// Get box header.
let header = read_box_header(&mut reader, start)?;
let BoxHeader{ name, size } = header;
// Match and parse the atom boxes.
match name {
BoxType::FtypBox => {
let ftyp = FtypBox::read_box(&mut reader, size)?;
bmff.ftyp = ftyp;
}
BoxType::FreeBox => {
start = 0;
}
BoxType::MdatBox => {
start = size - HEADER_SIZE;
}
BoxType::MoovBox => {
let moov = MoovBox::read_box(&mut reader, size)?;
bmff.moov = Some(moov);
}
BoxType::MoofBox => {
start = size - HEADER_SIZE;
}
_ => {
// Skip over unsupported boxes, but stop if the size is zero,
// meaning the last box has been reached.
if size == 0 {
break;
} else {
start = size - HEADER_SIZE;
// Match and parse the atom boxes.
match name {
BoxType::FtypBox => {
let ftyp = FtypBox::read_box(&mut self.reader, s)?;
self.ftyp = ftyp;
}
BoxType::FreeBox => {
skip_box(&mut self.reader, s)?;
}
BoxType::MdatBox => {
skip_box(&mut self.reader, s)?;
}
BoxType::MoovBox => {
let moov = MoovBox::read_box(&mut self.reader, s)?;
self.moov = Some(moov);
}
BoxType::MoofBox => {
skip_box(&mut self.reader, s)?;
}
_ => {
// XXX warn!()
skip_box(&mut self.reader, s)?;
}
}
current = self.reader.seek(SeekFrom::Current(0))?;
}
self.size = current - start;
Ok(())
}
pub fn track_count(&self) -> Result<u32> {
if let Some(ref moov) = self.moov {
Ok(moov.traks.len() as u32)
} else {
Err(Error::BoxNotFound(MoovBox::box_type()))
}
}
pub fn sample_count(&self, track_id: u32) -> Result<u32> {
if track_id == 0 {
return Err(Error::TrakNotFound(track_id));
}
let moov = if let Some(ref moov) = self.moov {
moov
} else {
return Err(Error::BoxNotFound(MoovBox::box_type()));
};
let trak = if let Some(trak) = moov.traks.get(track_id as usize - 1) {
trak
} else {
return Err(Error::TrakNotFound(track_id));
};
trak.sample_count()
}
Ok(bmff)
}
// TODO: if size is 0, then this box is the last one in the file
fn read_box_header<R: Read + Seek>(reader: &mut BufReader<R>, start: u64) -> Result<BoxHeader> {
// Seek to offset.
let _r = reader.seek(SeekFrom::Current(start as i64));
pub fn read_sample(
&mut self,
track_id: u32,
sample_id: u32,
) -> Result<Option<Mp4Sample>> {
if track_id == 0 {
return Err(Error::TrakNotFound(track_id));
}
// Create and read to buf.
let mut buf = [0u8;8]; // 8 bytes for box header.
reader.read(&mut buf)?;
let moov = if let Some(ref moov) = self.moov {
moov
} else {
return Err(Error::BoxNotFound(MoovBox::box_type()));
};
// Get size.
let s = buf[0..4].try_into().unwrap();
let size = u32::from_be_bytes(s);
let trak = if let Some(trak) = moov.traks.get(track_id as usize - 1) {
trak
} else {
return Err(Error::TrakNotFound(track_id));
};
// Get box type string.
let t = buf[4..8].try_into().unwrap();
let typ = u32::from_be_bytes(t);
// Get largesize if size is 1
if size == 1 {
reader.read(&mut buf)?;
let s = buf.try_into().unwrap();
let largesize = u64::from_be_bytes(s);
Ok(BoxHeader {
name: BoxType::from(typ),
size: largesize,
})
} else {
Ok(BoxHeader {
name: BoxType::from(typ),
size: size as u64,
})
trak.read_sample(&mut self.reader, sample_id)
}
}

64
tests/lib.rs
View file

@ -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::read_mp4(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,16 +28,53 @@ 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();
assert_eq!(moov.mvhd.version, 0);
assert_eq!(moov.mvhd.creation_time, 0);
assert_eq!(moov.mvhd.duration, 62);
assert_eq!(moov.mvhd.timescale, 1000);
assert_eq!(moov.traks.len(), 2);
assert!(mp4.moov.is_some());
if let Some(ref moov) = mp4.moov {
assert_eq!(moov.mvhd.version, 0);
assert_eq!(moov.mvhd.creation_time, 0);
assert_eq!(moov.mvhd.duration, 62);
assert_eq!(moov.mvhd.timescale, 1000);
assert_eq!(moov.traks.len(), 2);
}
let sample_count = mp4.sample_count(1).unwrap();
assert_eq!(sample_count, 0);
let sample_count = mp4.sample_count(2).unwrap();
assert_eq!(sample_count, 3);
let sample1 = mp4.read_sample(2, 1).unwrap().unwrap();
assert_eq!(sample1.bytes.len(), 179);
assert_eq!(sample1, mp4::Mp4Sample {
start_time: 0,
duration: 1024,
rendering_offset: 0,
is_sync: true,
bytes: mp4::Bytes::from(vec![0x0u8; 179]),
});
let sample2 = mp4.read_sample(2, 2).unwrap().unwrap();
assert_eq!(sample2, mp4::Mp4Sample {
start_time: 1024,
duration: 1024,
rendering_offset: 0,
is_sync: true,
bytes: mp4::Bytes::from(vec![0x0u8; 180]),
});
let sample3 = mp4.read_sample(2, 3).unwrap().unwrap();
assert_eq!(sample3, mp4::Mp4Sample {
start_time: 2048,
duration: 896,
rendering_offset: 0,
is_sync: true,
bytes: mp4::Bytes::from(vec![0x0u8; 160]),
});
let eos = mp4.read_sample(2, 4).unwrap();
assert!(eos.is_none());
}