Hvcc support

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mp4"
-version = "0.14.0"
+version = "0.15.0"
 authors = ["Alf <alf.g.jr@gmail.com>"]
 edition = "2018"
 description = "MP4 reader and writer library in Rust."

examples/mp4copy.rs

@@ -5,8 +5,7 @@ use std::io::{self, BufReader, BufWriter};
 use std::path::Path;
 
 use mp4::{
-    AacConfig, AvcConfig, HevcConfig, MediaConfig, MediaType, Mp4Config, Result, TrackConfig,
-    TtxtConfig, Vp9Config,
+    AacConfig, AvcConfig, HevcBoxType, HevcConfig, MediaConfig, MediaType, Mp4Config, OpusConfig, Result, TrackConfig, TtxtConfig, Vp9Config
 };
 
 fn main() {
@@ -51,18 +50,59 @@ fn copy<P: AsRef<Path>>(src_filename: &P, dst_filename: &P) -> Result<()> {
                 pic_param_set: track.picture_parameter_set()?.to_vec(),
             }),
             MediaType::H265 => MediaConfig::HevcConfig(HevcConfig {
-                width: track.width(),
-                height: track.height(),
+                width: Some(track.width()),
+                height: Some(track.height()),
+                configuration_version: Some(1),
+                general_profile_space: Some(0),
+                general_tier_flag: Some(false),
+                general_profile_idc: Some(1),
+                general_profile_compatibility_flags: Some(0),
+                general_constraint_indicator_flag: Some(0),
+                general_level_idc: Some(93),
+                min_spatial_segmentation_idc: Some(0),
+                parallelism_type: Some(0),
+                chroma_format_idc: Some(1),
+                bit_depth_luma_minus8: Some(0),
+                bit_depth_chroma_minus8: Some(0),
+                avg_frame_rate: Some(0),
+                constant_frame_rate: Some(0),
+                num_temporal_layers: Some(1),
+                temporal_id_nested: Some(false),
+                length_size_minus_one: Some(3),
+                arrays: Some(vec![]),
+                use_hvc1: true,
             }),
             MediaType::VP9 => MediaConfig::Vp9Config(Vp9Config {
                 width: track.width(),
                 height: track.height(),
             }),
-            MediaType::AAC => MediaConfig::AacConfig(AacConfig {
+            MediaType::AAC => {
+                let default_aac_config = AacConfig::default();
+                MediaConfig::AacConfig(AacConfig {
+                    bitrate: track.bitrate(),
+                    profile: track.audio_profile()?,
+                    freq_index: track.sample_freq_index()?,
+                    chan_conf: track.channel_config()?,
+                    samplesize: 16,
+                    data_reference_index: 1,
+                    sound_version: 0,
+                    esds_version: default_aac_config.esds_version,
+                    esds_flags: default_aac_config.esds_flags,
+                    es_id: default_aac_config.es_id,
+                    object_type_indication: default_aac_config.object_type_indication,
+                    stream_type: default_aac_config.stream_type,
+                    up_stream: default_aac_config.up_stream,
+                    buffer_size_db: default_aac_config.buffer_size_db,
+                    max_bitrate: default_aac_config.max_bitrate,
+                    avg_bitrate: default_aac_config.avg_bitrate,
+                    qt_bytes: default_aac_config.qt_bytes,
+                })
+            }
+            MediaType::OPUS => MediaConfig::OpusConfig(OpusConfig {
                 bitrate: track.bitrate(),
-                profile: track.audio_profile()?,
                 freq_index: track.sample_freq_index()?,
                 chan_conf: track.channel_config()?,
+                pre_skip: 0,
             }),
             MediaType::TTXT => MediaConfig::TtxtConfig(TtxtConfig {}),
         };

examples/mp4dump.rs

@@ -96,6 +96,9 @@ fn get_boxes(file: File) -> Result<Vec<Box>> {
         if let Some(ref hev1) = &stbl.stsd.hev1 {
             boxes.push(build_box(hev1));
         }
+        if let Some(ref hvc1) = &stbl.stsd.hvc1 {
+            boxes.push(build_box(hvc1));
+        }
         if let Some(ref mp4a) = &stbl.stsd.mp4a {
             boxes.push(build_box(mp4a));
         }

src/error.rs

@@ -18,8 +18,8 @@ pub enum Error {
     BoxInTrakNotFound(u32, BoxType),
     #[error("traf[{0}].{1} not found")]
     BoxInTrafNotFound(u32, BoxType),
-    #[error("trak[{0}].stbl.{1} not found")]
-    BoxInStblNotFound(u32, BoxType),
+    #[error("trak[{0}].stbl.{1:?} not found")]
+    BoxInStblNotFound(u32, Vec<BoxType>),
     #[error("trak[{0}].stbl.{1}.entry[{2}] not found")]
     EntryInStblNotFound(u32, BoxType, u32),
     #[error("traf[{0}].trun.{1}.entry[{2}] not found")]

src/mp4box/hev1.rs

@@ -37,15 +37,34 @@ impl Default for Hev1Box {
 
 impl Hev1Box {
     pub fn new(config: &HevcConfig) -> Self {
-        Hev1Box {
+        Self {
             data_reference_index: 1,
-            width: config.width,
-            height: config.height,
+            width: config.width.unwrap_or(0),
+            height: config.height.unwrap_or(0),
             horizresolution: FixedPointU16::new(0x48),
             vertresolution: FixedPointU16::new(0x48),
             frame_count: 1,
             depth: 0x0018,
-            hvcc: HvcCBox::new(),
+            hvcc: HvcCBox {
+                configuration_version: config.configuration_version.unwrap_or(1),
+                general_profile_space: config.general_profile_space.unwrap_or(0),
+                general_tier_flag: config.general_tier_flag.unwrap_or(false),
+                general_profile_idc: config.general_profile_idc.unwrap_or(1),
+                general_profile_compatibility_flags: config.general_profile_compatibility_flags.unwrap_or(0),
+                general_constraint_indicator_flag: config.general_constraint_indicator_flag.unwrap_or(0),
+                general_level_idc: config.general_level_idc.unwrap_or(93),
+                min_spatial_segmentation_idc: config.min_spatial_segmentation_idc.unwrap_or(0),
+                parallelism_type: config.parallelism_type.unwrap_or(0),
+                chroma_format_idc: config.chroma_format_idc.unwrap_or(1),
+                bit_depth_luma_minus8: config.bit_depth_luma_minus8.unwrap_or(0),
+                bit_depth_chroma_minus8: config.bit_depth_chroma_minus8.unwrap_or(0),
+                avg_frame_rate: config.avg_frame_rate.unwrap_or(0),
+                constant_frame_rate: config.constant_frame_rate.unwrap_or(0),
+                num_temporal_layers: config.num_temporal_layers.unwrap_or(1),
+                temporal_id_nested: config.temporal_id_nested.unwrap_or(false),
+                length_size_minus_one: config.length_size_minus_one.unwrap_or(3),
+                arrays: config.arrays.clone().unwrap_or_default(),
+            },
         }
     }
 
@@ -180,13 +199,38 @@ pub struct HvcCBox {
     pub arrays: Vec<HvcCArray>,
 }
 
+const VPS: u8 = 32;
+const SPS: u8 = 33;
+const PPS: u8 = 34;
+
 impl HvcCBox {
     pub fn new() -> Self {
         Self {
             configuration_version: 1,
             ..Default::default()
         }
     }
+
+    fn parameter_set(&self, track_id: u32, nal_type: u8) -> Result<&[u8]> {
+        for array in &self.arrays {
+            if array.nal_unit_type == nal_type {
+                return Ok(&array.nalus[0].data);
+            }
+        }
+        Err(Error::EntryInStblNotFound(track_id, BoxType::HvcCBox, 0))
+    }
+
+    pub fn sequence_parameter_set(&self, track_id: u32) -> Result<&[u8]> {
+        self.parameter_set(track_id, SPS)
+    }
+
+    pub fn picture_parameter_set(&self, track_id: u32) -> Result<&[u8]> {
+        self.parameter_set(track_id, PPS)
+    }
+
+    pub fn video_parameter_set(&self, track_id: u32) -> Result<&[u8]> {
+        self.parameter_set(track_id, VPS)
+    }
 }
 
 impl Mp4Box for HvcCBox {