Feature/mp4copy

examples/mp4copy.rs

@@ -1,10 +1,10 @@
 use std::env;
 use std::fs::File;
 use std::io::prelude::*;
-use std::io::{self, BufReader};
+use std::io::{self, BufReader, BufWriter};
 use std::path::Path;
 
-use mp4::Result;
+use mp4::{AacConfig, AvcConfig, MediaConfig, MediaType, Mp4Config, Result, TrackConfig};
 
 fn main() {
     let args: Vec<String> = env::args().collect();
@@ -19,23 +19,66 @@ fn main() {
     }
 }
 
-fn copy<P: AsRef<Path>>(src_filename: &P, _dst_filename: &P) -> Result<()> {
+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)?;
+    let dst_file = File::create(dst_filename)?;
+    let writer = BufWriter::new(dst_file);
 
-    for tix in 0..mp4.track_count()? {
-        let track_id = tix + 1;
-        let sample_count = mp4.sample_count(track_id)?;
+    let mut mp4_reader = mp4::Mp4Reader::read_header(reader, size)?;
+    let mut mp4_writer = mp4::Mp4Writer::write_start(
+        writer,
+        &Mp4Config {
+            major_brand: mp4_reader.major_brand().clone(),
+            minor_version: mp4_reader.minor_version(),
+            compatible_brands: mp4_reader.compatible_brands().to_vec(),
+            timescale: mp4_reader.timescale(),
+        },
+    )?;
+
+    // TODO interleaving
+    for track_idx in 0..mp4_reader.tracks().len() {
+        if let Some(ref track) = mp4_reader.tracks().get(track_idx) {
+            let media_conf = match track.media_type()? {
+                MediaType::H264 => MediaConfig::AvcConfig(AvcConfig {
+                    width: track.width(),
+                    height: track.height(),
+                    seq_param_set: track.sequence_parameter_set()?.to_vec(),
+                    pic_param_set: track.picture_parameter_set()?.to_vec(),
+                }),
+                MediaType::AAC => MediaConfig::AacConfig(AacConfig {
+                    bitrate: track.bitrate(),
+                    profile: track.audio_profile()?,
+                    freq_index: track.sample_freq_index()?,
+                    chan_conf: track.channel_config()?,
+                }),
+            };
+
+            let track_conf = TrackConfig {
+                track_type: track.track_type()?,
+                timescale: track.timescale(),
+                language: track.language().to_string(),
+                media_conf,
+            };
+
+            mp4_writer.add_track(&track_conf)?;
+        } else {
+            unreachable!()
+        }
+
+        let track_id = track_idx as u32 + 1;
+        let sample_count = mp4_reader.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);
+            let sample = mp4_reader.read_sample(track_id, sample_id)?.unwrap();
+            mp4_writer.write_sample(track_id, &sample)?;
+            // println!("copy {}:({})", sample_id, sample);
         }
     }
 
+    mp4_writer.write_end()?;
+
     Ok(())
 }

examples/mp4info.rs

@@ -4,7 +4,7 @@ use std::io::prelude::*;
 use std::io::{self, BufReader};
 use std::path::Path;
 
-use mp4::{Result, Mp4Reader, TrackType};
+use mp4::{Mp4Track, Result, TrackType};
 
 fn main() {
     let args: Vec<String> = env::args().collect();
@@ -24,96 +24,61 @@ fn info<P: AsRef<Path>>(filename: &P) -> Result<()> {
     let size = f.metadata()?.len();
     let reader = BufReader::new(f);
 
-    let mut mp4 = Mp4Reader::new(reader);
-    mp4.read(size)?;
+    let mp4 = mp4::Mp4Reader::read_header(reader, size)?;
 
-    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);
-                }
-                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!("    frame rate: (computed): {:?}",
-                                 get_framerate(s.entries[0].sample_count,
-                                               mdhd.duration, mdhd.timescale));
-                    }
-                }
-            }
-        }
+    println!("Metadata:");
+    println!("  size            : {}", mp4.size());
+    println!("  major_brand     : {}", mp4.major_brand());
+    let mut compatible_brands = String::new();
+    for brand in mp4.compatible_brands().iter() {
+        compatible_brands.push_str(&brand.to_string());
+        compatible_brands.push_str(",");
     }
-
-    Ok(())
-}
-
-fn get_handler_type(handler: &str) -> TrackType {
-    let mut typ: TrackType = TrackType::Unknown;
-    match handler {
-        "vide" => typ = TrackType::Video,
-        "soun" => typ = TrackType::Audio,
-        "meta" => typ = TrackType::Unknown,
-        _ => (),
+    println!("  compatible_brands: {}", compatible_brands);
+    println!(
+        "Duration: {}, timescale: {}",
+        mp4.duration(),
+        mp4.timescale()
+    );
+
+    for track in mp4.tracks().iter() {
+        let media_info = match track.track_type()? {
+            TrackType::Video => video_info(track)?,
+            TrackType::Audio => audio_info(track)?,
+        };
+        println!(
+            "  Track: #{}({}) {}: {}",
+            track.track_id(),
+            track.language(),
+            track.track_type()?,
+            media_info
+        );
     }
-    return typ;
-}
 
-fn get_duration_ms(duration: u64, timescale: u32) -> String {
-    let ms = (duration as f64 / timescale as f64) * 1000.0;
-    return format!("{:.2}", ms.floor());
+    Ok(())
 }
 
-fn get_framerate(sample_count: u32, duration: u64, timescale: u32) -> String {
-    let sc = (sample_count as f64) * 1000.0;
-    let ms = (duration as f64 / timescale as f64) * 1000.0;
-    return format!("{:.2}", sc / ms.floor());
+fn video_info(track: &Mp4Track) -> Result<String> {
+    Ok(format!(
+        "{} ({}) ({:?}), {}x{}, {} kb/s, {:.2} fps",
+        track.media_type()?,
+        track.video_profile()?,
+        track.box_type()?,
+        track.width(),
+        track.height(),
+        track.bitrate() / 1000,
+        track.frame_rate_f64()
+    ))
 }
 
-fn creation_time(creation_time: u64) -> u64 {
-    // convert from MP4 epoch (1904-01-01) to Unix epoch (1970-01-01)
-    if creation_time >= 2082844800 {
-        creation_time - 2082844800
-    } else {
-        creation_time
-    }
+fn audio_info(track: &Mp4Track) -> Result<String> {
+    Ok(format!(
+        "{} ({}) ({:?}), {} Hz, {}, {} kb/s",
+        track.media_type()?,
+        track.audio_profile()?,
+        track.box_type()?,
+        track.sample_freq_index()?.freq(),
+        track.channel_config()?,
+        track.bitrate() / 1000
+    ))
 }