Parse tenc members related to pattern encryption.

Parse the tenc members for:
- crypt_byte_block: number of encrypted bytes in the pattern if pattern
encryption is used
- skip_byte_block: number of clear bytes in the pattern if pattern
encryption is used
- constant_iv: the iv that is used for a track by certain pattern based
encryption schemes, such as cbcs

Update the data structures used to contain new data. Note, the
is_encrypted member of the tenc structure has been changed from a u32 to
a u8 to reflect changes in the spec. This changes our interface.

Author: SingingTree

mp4parse/src/lib.rs

@@ -426,9 +426,14 @@ pub struct ProtectionSystemSpecificHeaderBox {
 
 #[derive(Debug, Default, Clone)]
 pub struct TrackEncryptionBox {
-    pub is_encrypted: u32,
+    pub is_encrypted: u8,
     pub iv_size: u8,
     pub kid: Vec<u8>,
+    // Members for pattern encryption schemes
+    pub crypt_byte_block_count: Option<u8>,
+    pub skip_byte_block_count: Option<u8>,
+    pub constant_iv: Option<Vec<u8>>,
+    // End pattern encryption scheme members
 }
 
 #[derive(Debug, Default, Clone)]
@@ -2154,16 +2159,42 @@ fn read_schi<T: Read>(src: &mut BMFFBox<T>) -> Result<Option<TrackEncryptionBox>
 }
 
 fn read_tenc<T: Read>(src: &mut BMFFBox<T>) -> Result<TrackEncryptionBox> {
-    let (_, _) = read_fullbox_extra(src)?;
+    let (version, _) = read_fullbox_extra(src)?;
 
-    let default_is_encrypted = be_u24(src)?;
+    // reserved byte
+    skip(src, 1)?;
+    // the next byte is used to signal the default pattern in version >= 1
+    let (default_crypt_byte_block, default_skip_byte_block) = match version {
+        0 => {
+            skip(src, 1)?;
+            (None, None)
+        },
+        _ => {
+            let pattern_byte = src.read_u8()?;
+            let crypt_bytes = pattern_byte >> 4;
+            let skip_bytes = pattern_byte & 0x0f;
+            (Some(crypt_bytes), Some(skip_bytes))
+        }
+    };
+    let default_is_encrypted = src.read_u8()?;
     let default_iv_size = src.read_u8()?;
     let default_kid = read_buf(src, 16)?;
+    // If default_is_encrypted == 1 && default_iv_size == 0 we expect a default_constant_iv
+    let default_constant_iv = match (default_is_encrypted, default_iv_size) {
+        (1, 0) => {
+            let default_constant_iv_size = src.read_u8()?;
+            Some(read_buf(src, default_constant_iv_size as usize)?)
+        },
+        _ => None,
+    };
 
     Ok(TrackEncryptionBox {
         is_encrypted: default_is_encrypted,
         iv_size: default_iv_size,
         kid: default_kid,
+        crypt_byte_block_count: default_crypt_byte_block,
+        skip_byte_block_count: default_skip_byte_block,
+        constant_iv: default_constant_iv
     })
 }
 

mp4parse_capi/src/lib.rs

@@ -168,9 +168,15 @@ pub struct Mp4parsePsshInfo {
 #[repr(C)]
 #[derive(Default, Debug)]
 pub struct Mp4parseSinfInfo {
-    pub is_encrypted: u32,
+    pub is_encrypted: u8,
     pub iv_size: u8,
     pub kid: Mp4parseByteData,
+    // Members for pattern encryption schemes, may be 0 (u8) or empty
+    // (Mp4parseByteData) if pattern encryption is not in use
+    pub crypt_byte_block: u8,
+    pub skip_byte_block: u8,
+    pub constant_iv: Mp4parseByteData,
+    // End pattern encryption scheme members
 }
 
 #[repr(C)]
@@ -617,6 +623,23 @@ pub unsafe extern fn mp4parse_get_track_audio_info(parser: *mut Mp4parseParser,
                 sample_info.protected_data.is_encrypted = tenc.is_encrypted;
                 sample_info.protected_data.iv_size = tenc.iv_size;
                 sample_info.protected_data.kid.set_data(&(tenc.kid));
+                sample_info.protected_data.crypt_byte_block = match tenc.crypt_byte_block_count {
+                    Some(n) => n,
+                    None => 0,
+                };
+                sample_info.protected_data.skip_byte_block = match tenc.skip_byte_block_count {
+                    Some(n) => n,
+                    None => 0,
+                };
+                match tenc.constant_iv {
+                    Some(ref iv_vec) => {
+                        if iv_vec.len() > std::u32::MAX as usize {
+                            return Mp4parseStatus::Invalid;
+                        }
+                        sample_info.protected_data.constant_iv.set_data(iv_vec);
+                    },
+                    None => {}, // Don't need to do anything, defaults are correct
+                };
             }
         }
         audio_sample_infos.push(sample_info);
@@ -721,6 +744,23 @@ pub unsafe extern fn mp4parse_get_track_video_info(parser: *mut Mp4parseParser,
                 sample_info.protected_data.is_encrypted = tenc.is_encrypted;
                 sample_info.protected_data.iv_size = tenc.iv_size;
                 sample_info.protected_data.kid.set_data(&(tenc.kid));
+                sample_info.protected_data.crypt_byte_block = match tenc.crypt_byte_block_count {
+                    Some(n) => n,
+                    None => 0,
+                };
+                sample_info.protected_data.skip_byte_block = match tenc.skip_byte_block_count {
+                    Some(n) => n,
+                    None => 0,
+                };
+                match tenc.constant_iv {
+                    Some(ref iv_vec) => {
+                        if iv_vec.len() > std::u32::MAX as usize {
+                            return Mp4parseStatus::Invalid;
+                        }
+                        sample_info.protected_data.constant_iv.set_data(iv_vec);
+                    },
+                    None => {}, // Don't need to do anything, defaults are correct
+                };
             }
         }
         video_sample_infos.push(sample_info);