Support HEVC.

Author: alastor0325

mp4parse/src/boxes.rs

@@ -146,6 +146,9 @@ box_database!(
     AVCConfigurationBox               0x6176_6343, // "avcC"
     H263SampleEntry                   0x7332_3633, // "s263"
     H263SpecificBox                   0x6432_3633, // "d263"
+    HEVCSampleEntry                   0x6865_7631, // "hev1"
+    HEVCSampleEntry2                  0x6876_6331, // "hvc1"
+    HEVCConfigurationBox              0x6876_6343, // "hvcC"
     MP4AudioSampleEntry               0x6d70_3461, // "mp4a"
     MP4VideoSampleEntry               0x6d70_3476, // "mp4v"
     #[cfg(feature = "3gpp")]

mp4parse/src/lib.rs

@@ -1161,6 +1161,7 @@ pub enum VideoCodecSpecific {
     AV1Config(AV1ConfigBox),
     ESDSConfig(TryVec<u8>),
     H263Config(TryVec<u8>),
+    HEVCConfig(HEVCConfigBox),
 }
 
 #[derive(Debug)]
@@ -1233,6 +1234,44 @@ impl AV1ConfigBox {
     }
 }
 
+// Spec 8.3.2.1.2 HEVCDecoderConfigurationRecord
+#[derive(Debug)]
+pub struct NALUnit {
+    pub nal_unit_length: u16,
+    pub nal_unit_content: TryVec<u8>,
+}
+
+#[derive(Debug)]
+pub struct HEVCArrayInfo {
+    pub array_completeness: u8,
+    pub nal_unit_type: u8,
+    pub num_nalus: u16,
+    pub nal_units: TryVec<NALUnit>,
+}
+
+#[derive(Debug)]
+pub struct HEVCConfigBox {
+    pub configuration_version: u8,
+    pub general_profile_space: u8,
+    pub general_tier_flag: u8,
+    pub general_profile_idc: u8,
+    pub general_profile_compatibility_flags: u32,
+    pub general_constraint_indicator_flags: u64,
+    pub general_level_idc: u8,
+    pub min_spatial_segmentation_idc: u16,
+    pub parallelism_type: u8,
+    pub chroma_format_idc: u8,
+    pub bit_depth_luma_minus8: u8,
+    pub bit_depth_chroma_minus8: u8,
+    pub avg_frame_rate: u16,
+    pub constant_frame_rate: u8,
+    pub num_temporal_layers: u8,
+    pub temporal_id_nested: u8,
+    pub length_size_minus_one: u8,
+    pub num_of_arrays: u8,
+    pub array_infos: TryVec<HEVCArrayInfo>,
+}
+
 #[derive(Debug)]
 pub struct FLACMetadataBlock {
     pub block_type: u8,
@@ -2060,6 +2099,7 @@ pub enum CodecType {
     LPCM, // QT
     ALAC,
     H263,
+    HEVC,
     #[cfg(feature = "3gpp")]
     AMRNB,
     #[cfg(feature = "3gpp")]
@@ -4927,6 +4967,102 @@ fn read_av1c<T: Read>(src: &mut BMFFBox<T>) -> Result<AV1ConfigBox> {
     })
 }
 
+fn read_hvcc<T: Read>(src: &mut BMFFBox<T>) -> Result<HEVCConfigBox> {
+    let configuration_version = src.read_u8()?;
+    let (general_profile_space, general_tier_flag, general_profile_idc) = {
+        let byte = src.read_u8()?;
+        ((byte >> 6) & 0x03, (byte >> 5) & 0x01, byte & 0x1F)
+    };
+    let general_profile_compatibility_flags = src.read_u32::<byteorder::BigEndian>()?;
+    let general_constraint_indicator_flags = {
+        let flag_high = src.read_u32::<byteorder::BigEndian>()?;
+        let flag_low: u16 = src.read_u16::<byteorder::BigEndian>()?;
+        (flag_high as u64) << 16 | flag_low as u64
+    };
+    let general_level_idc = src.read_u8()?;
+    let (min_spatial_segmentation_idc, parallelism_type, chroma_format_idc) = {
+        let byte = src.read_u32::<byteorder::BigEndian>()?;
+        (
+            ((byte >> 16) & 0x0FFF) as u16,
+            ((byte >> 8) & 0x03) as u8,
+            (byte & 0x03) as u8,
+        )
+    };
+    let (bit_depth_luma_minus8, bit_depth_chroma_minus8) = {
+        let byte = src.read_u16::<byteorder::BigEndian>()?;
+        (((byte >> 8) & 0x07) as u8, (byte & 0x07) as u8)
+    };
+    let avg_frame_rate = src.read_u16::<byteorder::BigEndian>()?;
+    let (constant_frame_rate, num_temporal_layers, temporal_id_nested, length_size_minus_one) = {
+        let byte = src.read_u8()?;
+        (
+            (byte >> 6) & 0x03,
+            (byte >> 3) & 0x07,
+            (byte >> 2) & 0x01,
+            byte & 0x03,
+        )
+    };
+    let num_of_arrays = src.read_u8()?;
+    let mut array_infos = TryVec::new();
+    for _i in 0..num_of_arrays {
+        let array_info = read_hevc_arry_info(src)?;
+        array_infos.push(array_info)?;
+    }
+    Ok(HEVCConfigBox {
+        configuration_version,
+        general_profile_space,
+        general_tier_flag,
+        general_profile_idc,
+        general_profile_compatibility_flags,
+        general_constraint_indicator_flags,
+        general_level_idc,
+        min_spatial_segmentation_idc,
+        parallelism_type,
+        chroma_format_idc,
+        bit_depth_luma_minus8,
+        bit_depth_chroma_minus8,
+        avg_frame_rate,
+        constant_frame_rate,
+        num_temporal_layers,
+        temporal_id_nested,
+        length_size_minus_one,
+        num_of_arrays,
+        array_infos,
+    })
+}
+
+fn read_hevc_arry_info<T: Read>(src: &mut BMFFBox<T>) -> Result<HEVCArrayInfo> {
+    let (array_completeness, nal_unit_type) = {
+        let byte = src.read_u8()?;
+        ((byte >> 7) & 0x01, byte & 0x3F)
+    };
+    let num_nalus = src.read_u16::<byteorder::BigEndian>()?;
+    let mut nal_units = TryVec::new();
+    for _i in 0..num_nalus {
+        let nal = read_nal_unit(src)?;
+        nal_units.push(nal)?;
+    }
+    Ok(HEVCArrayInfo {
+        array_completeness,
+        nal_unit_type,
+        num_nalus,
+        nal_units,
+    })
+}
+
+fn read_nal_unit<T: Read>(src: &mut BMFFBox<T>) -> Result<NALUnit> {
+    let nal_unit_length = src.read_u16::<byteorder::BigEndian>()?;
+    let mut nal_unit_content = TryVec::new();
+    for _i in 0..nal_unit_length {
+        let byte = src.read_u8()?;
+        nal_unit_content.push(byte)?;
+    }
+    Ok(NALUnit {
+        nal_unit_length,
+        nal_unit_content,
+    })
+}
+
 fn read_flac_metadata<T: Read>(src: &mut BMFFBox<T>) -> Result<FLACMetadataBlock> {
     let temp = src.read_u8()?;
     let block_type = temp & 0x7f;
@@ -5456,6 +5592,8 @@ fn read_video_sample_entry<T: Read>(src: &mut BMFFBox<T>) -> Result<SampleEntry>
         BoxType::AV1SampleEntry => CodecType::AV1,
         BoxType::ProtectedVisualSampleEntry => CodecType::EncryptedVideo,
         BoxType::H263SampleEntry => CodecType::H263,
+        BoxType::HEVCSampleEntry => CodecType::HEVC,
+        BoxType::HEVCSampleEntry2 => CodecType::HEVC,
         _ => {
             debug!("Unsupported video codec, box {:?} found", name);
             CodecType::Unknown
@@ -5567,6 +5705,13 @@ fn read_video_sample_entry<T: Read>(src: &mut BMFFBox<T>) -> Result<SampleEntry>
                 debug!("{:?} (sinf)", sinf);
                 protection_info.push(sinf)?;
             }
+            BoxType::HEVCConfigurationBox => {
+                if name != BoxType::HEVCSampleEntry && name != BoxType::HEVCSampleEntry2 {
+                    return Status::StsdBadVideoSampleEntry.into();
+                }
+                let hvcc = read_hvcc(&mut b)?;
+                codec_specific = Some(VideoCodecSpecific::HEVCConfig(hvcc));
+            }
             _ => {
                 debug!("Unsupported video codec, box {:?} found", b.head.name);
                 skip_box_content(&mut b)?;

mp4parse/tests/hevc_white_frame.mp4

@@ -215,6 +215,9 @@ static AVIF_CORRUPT_IMAGES_DIR: &str = "tests/corrupt";
 // The 1 frame h263 3gp file can be generated by ffmpeg with command
 // "ffmpeg -i [input file] -f 3gp -vcodec h263 -vf scale=176x144 -frames:v 1 -an output.3gp"
 static VIDEO_H263_3GP: &str = "tests/bbb_sunflower_QCIF_30fps_h263_noaudio_1f.3gp";
+// The 1 frame hevc mp4 file generated by ffmpeg with command
+// "ffmpeg -f lavfi -i color=c=white:s=640x480 -c:v libx265 -frames:v 1 -pix_fmt yuv420p hevc_white_frame.mp4"
+static VIDEO_HEVC_MP4: &str = "tests/hevc_white_frame.mp4";
 // The 1 frame AMR-NB 3gp file can be generated by ffmpeg with command
 // "ffmpeg -i [input file] -f 3gp -acodec amr_nb -ar 8000 -ac 1 -frames:a 1 -vn output.3gp"
 #[cfg(feature = "3gpp")]
@@ -286,6 +289,9 @@ fn public_api() {
                         mp4::VideoCodecSpecific::H263Config(ref _h263) => {
                             "H263"
                         }
+                        mp4::VideoCodecSpecific::HEVCConfig(ref _hevc) => {
+                            "HEVC"
+                        }
                     },
                     "AVC"
                 );
@@ -1435,6 +1441,51 @@ fn public_video_h263() {
     }
 }
 
+#[test]
+fn public_video_hevc() {
+    let mut fd = File::open(VIDEO_HEVC_MP4).expect("Unknown file");
+    let mut buf = Vec::new();
+    fd.read_to_end(&mut buf).expect("File error");
+
+    let mut c = Cursor::new(&buf);
+    let context = mp4::read_mp4(&mut c).expect("read_mp4 failed");
+    for track in context.tracks {
+        let stsd = track.stsd.expect("expected an stsd");
+        let v = match stsd.descriptions.first().expect("expected a SampleEntry") {
+            mp4::SampleEntry::Video(ref v) => v,
+            _ => panic!("expected a VideoSampleEntry"),
+        };
+        assert_eq!(v.codec_type, mp4::CodecType::HEVC);
+        assert_eq!(v.width, 640);
+        assert_eq!(v.height, 480);
+        let _codec_specific = match &v.codec_specific {
+            mp4::VideoCodecSpecific::HEVCConfig(config) => {
+                assert_eq!(config.configuration_version, 1);
+                assert_eq!(config.general_profile_space, 0);
+                assert_eq!(config.general_tier_flag, 0);
+                assert_eq!(config.general_profile_idc, 1);
+                assert_eq!(config.general_profile_compatibility_flags, 1610612736);
+                assert_eq!(config.general_constraint_indicator_flags, 158329674399744);
+                assert_eq!(config.general_level_idc, 90);
+                assert_eq!(config.min_spatial_segmentation_idc, 0);
+                assert_eq!(config.parallelism_type, 0);
+                assert_eq!(config.chroma_format_idc, 1);
+                assert_eq!(config.bit_depth_luma_minus8, 0);
+                assert_eq!(config.bit_depth_chroma_minus8, 0);
+                assert_eq!(config.avg_frame_rate, 0);
+                assert_eq!(config.constant_frame_rate, 0);
+                assert_eq!(config.num_temporal_layers, 1);
+                assert_eq!(config.temporal_id_nested, 1);
+                assert_eq!(config.length_size_minus_one, 3);
+                assert_eq!(config.num_of_arrays, 4);
+            }
+            _ => {
+                panic!("expected a HEVCConfig",);
+            }
+        };
+    }
+}
+
 #[test]
 #[cfg(feature = "3gpp")]
 fn public_audio_amrnb() {

mp4parse/tests/public.rs

@@ -100,6 +100,7 @@ pub enum Mp4parseCodec {
     Ec3,
     Alac,
     H263,
+    HEVC,
     #[cfg(feature = "3gpp")]
     AMRNB,
     #[cfg(feature = "3gpp")]
@@ -962,6 +963,7 @@ fn mp4parse_get_track_video_info_safe(
             VideoCodecSpecific::AV1Config(_) => Mp4parseCodec::Av1,
             VideoCodecSpecific::AVCConfig(_) => Mp4parseCodec::Avc,
             VideoCodecSpecific::H263Config(_) => Mp4parseCodec::H263,
+            VideoCodecSpecific::HEVCConfig(_) => Mp4parseCodec::HEVC,
             #[cfg(feature = "mp4v")]
             VideoCodecSpecific::ESDSConfig(_) => Mp4parseCodec::Mp4v,
             #[cfg(not(feature = "mp4v"))]