Merge pull request #219 from SingingTree/expose_encrypted_original_format

Bryce Van Dyk · web-flow · commit 309b9b8acdaf · 2020-05-26T10:05:12.000-07:00
Expose encrypted original format via C API
diff --git a/mp4parse/src/boxes.rs b/mp4parse/src/boxes.rs
@@ -94,6 +94,12 @@ impl fmt::Display for FourCC {
     }
 }
 
+impl PartialEq<&[u8; 4]> for FourCC {
+    fn eq(&self, other: &&[u8; 4]) -> bool {
+        self.value.eq(*other)
+    }
+}
+
 box_database!(
     FileTypeBox                       0x6674_7970, // "ftyp"
     MediaDataBox                      0x6d64_6174, // "mdat"
diff --git a/mp4parse/src/lib.rs b/mp4parse/src/lib.rs
@@ -538,7 +538,7 @@ pub struct TrackEncryptionBox {
 
 #[derive(Debug, Default)]
 pub struct ProtectionSchemeInfoBox {
-    pub code_name: TryString,
+    pub original_format: FourCC,
     pub scheme_type: Option<SchemeTypeBox>,
     pub tenc: Option<TrackEncryptionBox>,
 }
@@ -3163,8 +3163,7 @@ fn read_sinf<T: Read>(src: &mut BMFFBox<T>) -> Result<ProtectionSchemeInfoBox> {
     while let Some(mut b) = iter.next_box()? {
         match b.head.name {
             BoxType::OriginalFormatBox => {
-                let frma = read_frma(&mut b)?;
-                sinf.code_name = frma;
+                sinf.original_format = FourCC::from(be_u32(&mut b)?);
             }
             BoxType::SchemeTypeBox => {
                 sinf.scheme_type = Some(read_schm(&mut b)?);
@@ -3241,10 +3240,6 @@ fn read_tenc<T: Read>(src: &mut BMFFBox<T>) -> Result<TrackEncryptionBox> {
     })
 }
 
-fn read_frma<T: Read>(src: &mut BMFFBox<T>) -> Result<TryString> {
-    read_buf(src, 4)
-}
-
 fn read_schm<T: Read>(src: &mut BMFFBox<T>) -> Result<SchemeTypeBox> {
     // Flags can be used to signal presence of URI in the box, but we don't
     // use the URI so don't bother storing the flags.
diff --git a/mp4parse/src/tests.rs b/mp4parse/src/tests.rs
@@ -17,7 +17,7 @@ use std::io::Read as _;
 extern crate test_assembler;
 use self::test_assembler::*;
 
-use boxes::{BoxType, FourCC};
+use boxes::BoxType;
 
 enum BoxSize {
     Short(u32),
@@ -181,11 +181,11 @@ fn read_ftyp() {
     assert_eq!(stream.head.name, BoxType::FileTypeBox);
     assert_eq!(stream.head.size, 24);
     let parsed = super::read_ftyp(&mut stream).unwrap();
-    assert_eq!(parsed.major_brand, FourCC::from(*b"mp42")); // mp42
+    assert_eq!(parsed.major_brand, b"mp42"); // mp42
     assert_eq!(parsed.minor_version, 0);
     assert_eq!(parsed.compatible_brands.len(), 2);
-    assert_eq!(parsed.compatible_brands[0], FourCC::from(*b"isom")); // isom
-    assert_eq!(parsed.compatible_brands[1], FourCC::from(*b"mp42")); // mp42
+    assert_eq!(parsed.compatible_brands[0], b"isom"); // isom
+    assert_eq!(parsed.compatible_brands[1], b"mp42"); // mp42
 }
 
 #[test]
@@ -223,11 +223,11 @@ fn read_ftyp_case() {
     assert_eq!(stream.head.name, BoxType::FileTypeBox);
     assert_eq!(stream.head.size, 24);
     let parsed = super::read_ftyp(&mut stream).unwrap();
-    assert_eq!(parsed.major_brand, FourCC::from(*b"MP42"));
+    assert_eq!(parsed.major_brand, b"MP42");
     assert_eq!(parsed.minor_version, 0);
     assert_eq!(parsed.compatible_brands.len(), 2);
-    assert_eq!(parsed.compatible_brands[0], FourCC::from(*b"ISOM")); // ISOM
-    assert_eq!(parsed.compatible_brands[1], FourCC::from(*b"MP42")); // MP42
+    assert_eq!(parsed.compatible_brands[0], b"ISOM"); // ISOM
+    assert_eq!(parsed.compatible_brands[1], b"MP42"); // MP42
 }
 
 #[test]
@@ -474,7 +474,7 @@ fn read_hdlr() {
     assert_eq!(stream.head.name, BoxType::HandlerBox);
     assert_eq!(stream.head.size, 45);
     let parsed = super::read_hdlr(&mut stream).unwrap();
-    assert_eq!(parsed.handler_type, FourCC::from(*b"vide"));
+    assert_eq!(parsed.handler_type, b"vide");
 }
 
 #[test]
@@ -487,7 +487,7 @@ fn read_hdlr_short_name() {
     assert_eq!(stream.head.name, BoxType::HandlerBox);
     assert_eq!(stream.head.size, 33);
     let parsed = super::read_hdlr(&mut stream).unwrap();
-    assert_eq!(parsed.handler_type, FourCC::from(*b"vide"));
+    assert_eq!(parsed.handler_type, b"vide");
 }
 
 #[test]
@@ -500,7 +500,7 @@ fn read_hdlr_zero_length_name() {
     assert_eq!(stream.head.name, BoxType::HandlerBox);
     assert_eq!(stream.head.size, 32);
     let parsed = super::read_hdlr(&mut stream).unwrap();
-    assert_eq!(parsed.handler_type, FourCC::from(*b"vide"));
+    assert_eq!(parsed.handler_type, b"vide");
 }
 
 fn flac_streaminfo() -> Vec<u8> {
diff --git a/mp4parse/tests/public.rs b/mp4parse/tests/public.rs
@@ -309,9 +309,9 @@ fn public_audio_tenc() {
         assert_eq!(a.codec_type, mp4::CodecType::EncryptedAudio);
         match a.protection_info.iter().find(|sinf| sinf.tenc.is_some()) {
             Some(ref p) => {
-                assert_eq!(p.code_name, "mp4a");
+                assert_eq!(p.original_format, b"mp4a");
                 if let Some(ref schm) = p.scheme_type {
-                    assert_eq!(schm.scheme_type.value, *b"cenc");
+                    assert_eq!(schm.scheme_type, b"cenc");
                 } else {
                     panic!("Expected scheme type info");
                 }
@@ -368,9 +368,9 @@ fn public_video_cenc() {
         assert_eq!(v.codec_type, mp4::CodecType::EncryptedVideo);
         match v.protection_info.iter().find(|sinf| sinf.tenc.is_some()) {
             Some(ref p) => {
-                assert_eq!(p.code_name, "avc1");
+                assert_eq!(p.original_format, b"avc1");
                 if let Some(ref schm) = p.scheme_type {
-                    assert_eq!(schm.scheme_type.value, *b"cenc");
+                    assert_eq!(schm.scheme_type, b"cenc");
                 } else {
                     panic!("Expected scheme type info");
                 }
@@ -441,9 +441,9 @@ fn public_audio_cbcs() {
                 mp4::SampleEntry::Audio(ref a) => {
                     if let Some(p) = a.protection_info.iter().find(|sinf| sinf.tenc.is_some()) {
                         found_encrypted_sample_description = true;
-                        assert_eq!(p.code_name, "mp4a");
+                        assert_eq!(p.original_format, b"mp4a");
                         if let Some(ref schm) = p.scheme_type {
-                            assert_eq!(schm.scheme_type.value, *b"cbcs");
+                            assert_eq!(schm.scheme_type, b"cbcs");
                         } else {
                             panic!("Expected scheme type info");
                         }
@@ -526,9 +526,9 @@ fn public_video_cbcs() {
                     assert_eq!(v.height, 300);
                     if let Some(p) = v.protection_info.iter().find(|sinf| sinf.tenc.is_some()) {
                         found_encrypted_sample_description = true;
-                        assert_eq!(p.code_name, "avc1");
+                        assert_eq!(p.original_format, b"avc1");
                         if let Some(ref schm) = p.scheme_type {
-                            assert_eq!(schm.scheme_type.value, *b"cbcs");
+                            assert_eq!(schm.scheme_type, b"cbcs");
                         } else {
                             panic!("Expected scheme type info");
                         }
diff --git a/mp4parse_capi/src/lib.rs b/mp4parse_capi/src/lib.rs
@@ -217,9 +217,23 @@ pub struct Mp4parsePsshInfo {
     pub data: Mp4parseByteData,
 }
 
+#[repr(u8)]
+#[derive(Debug, PartialEq)]
+pub enum OptionalFourCC {
+    None,
+    Some([u8; 4]),
+}
+
+impl Default for OptionalFourCC {
+    fn default() -> Self {
+        Self::None
+    }
+}
+
 #[repr(C)]
 #[derive(Default, Debug)]
 pub struct Mp4parseSinfInfo {
+    pub original_format: OptionalFourCC,
     pub scheme_type: Mp4ParseEncryptionSchemeType,
     pub is_encrypted: u8,
     pub iv_size: u8,
@@ -827,6 +841,8 @@ fn get_track_audio_info(
             .iter()
             .find(|sinf| sinf.tenc.is_some())
         {
+            sample_info.protected_data.original_format =
+                OptionalFourCC::Some(p.original_format.value);
             sample_info.protected_data.scheme_type = match p.scheme_type {
                 Some(ref scheme_type_box) => {
                     match scheme_type_box.scheme_type.value.as_ref() {
@@ -987,6 +1003,8 @@ fn mp4parse_get_track_video_info_safe(
             .iter()
             .find(|sinf| sinf.tenc.is_some())
         {
+            sample_info.protected_data.original_format =
+                OptionalFourCC::Some(p.original_format.value);
             sample_info.protected_data.scheme_type = match p.scheme_type {
                 Some(ref scheme_type_box) => {
                     match scheme_type_box.scheme_type.value.as_ref() {
diff --git a/mp4parse_capi/tests/test_encryption.rs b/mp4parse_capi/tests/test_encryption.rs
@@ -51,6 +51,10 @@ fn parse_cenc() {
         assert_eq!((*video.sample_info).image_width, 320);
         assert_eq!((*video.sample_info).image_height, 240);
         let protected_data = &(*video.sample_info).protected_data;
+        assert_eq!(
+            protected_data.original_format,
+            OptionalFourCC::Some(*b"avc1")
+        );
         assert_eq!(
             protected_data.scheme_type,
             Mp4ParseEncryptionSchemeType::Cenc
@@ -79,6 +83,10 @@ fn parse_cenc() {
         assert_eq!((*audio.sample_info).bit_depth, 16);
         assert_eq!((*audio.sample_info).sample_rate, 44100);
         let protected_data = &(*audio.sample_info).protected_data;
+        assert_eq!(
+            protected_data.original_format,
+            OptionalFourCC::Some(*b"mp4a")
+        );
         assert_eq!(protected_data.is_encrypted, 0x01);
         assert_eq!(protected_data.iv_size, 16);
         assert_eq!(protected_data.kid.length, 16);
@@ -128,6 +136,10 @@ fn parse_cbcs() {
         assert_eq!((*video.sample_info).image_width, 400);
         assert_eq!((*video.sample_info).image_height, 300);
         let protected_data = &(*video.sample_info).protected_data;
+        assert_eq!(
+            protected_data.original_format,
+            OptionalFourCC::Some(*b"avc1")
+        );
         assert_eq!(
             protected_data.scheme_type,
             Mp4ParseEncryptionSchemeType::Cbcs
@@ -186,6 +198,7 @@ fn parse_unencrypted() {
         assert_eq!(rv, Mp4parseStatus::Ok);
         assert_eq!(audio.sample_info_count, 1);
         let protected_data = &(*audio.sample_info).protected_data;
+        assert_eq!(protected_data.original_format, OptionalFourCC::None);
         assert_eq!(
             protected_data.scheme_type,
             Mp4ParseEncryptionSchemeType::None

Original file line number	Diff line number	Diff line change
`@@ -94,6 +94,12 @@ impl fmt::Display for FourCC {`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`
	`97`	`+impl PartialEq<&[u8; 4]> for FourCC {`
	`98`	`+ fn eq(&self, other: &&[u8; 4]) -> bool {`
	`99`	`+ self.value.eq(*other)`
	`100`	`+ }`
	`101`	`+}`
	`102`	`+`
`97`	`103`	`box_database!(`
`98`	`104`	`FileTypeBox 0x6674_7970, // "ftyp"`
`99`	`105`	`MediaDataBox 0x6d64_6174, // "mdat"`