Add tests to verify cbcs parsing.

Add tests to both mp4parse and mprparse_capi to verify parsing of
encrypted mp4s. These primarily focus on cbcs encryption, but some new
cenc tests have also been added to the c-api to provide further
coverage.

Author: SingingTree

mp4parse/tests/bipbop_cbcs_audio_init.mp4

@@ -10,8 +10,19 @@ use std::io::{Cursor, Read};
 use std::fs::File;
 
 static MINI_MP4: &'static str = "tests/minimal.mp4";
-static AUDIO_EME_MP4: &'static str = "tests/bipbop-cenc-audioinit.mp4";
-static VIDEO_EME_MP4: &'static str = "tests/bipbop_480wp_1001kbps-cenc-video-key1-init.mp4";
+static AUDIO_EME_CENC_MP4: &'static str = "tests/bipbop-cenc-audioinit.mp4";
+static VIDEO_EME_CENC_MP4: &'static str = "tests/bipbop_480wp_1001kbps-cenc-video-key1-init.mp4";
+// The cbcs files were created via shaka-packager from Firefox's test suite's bipbop.mp4 using:
+// packager-win.exe
+// in=bipbop.mp4,stream=audio,init_segment=bipbop_cbcs_audio_init.mp4,segment_template=bipbop_cbcs_audio_$Number$.m4s
+// in=bipbop.mp4,stream=video,init_segment=bipbop_cbcs_video_init.mp4,segment_template=bipbop_cbcs_video_$Number$.m4s
+// --protection_scheme cbcs --enable_raw_key_encryption
+// --keys label=:key_id=7e571d047e571d047e571d047e571d21:key=7e5744447e5744447e5744447e574421
+// --iv 11223344556677889900112233445566
+// --generate_static_mpd --mpd_output bipbop_cbcs.mpd
+// note: only the init files are needed for these tests
+static AUDIO_EME_CBCS_MP4: &'static str = "tests/bipbop_cbcs_audio_init.mp4";
+static VIDEO_EME_CBCS_MP4: &'static str = "tests/bipbop_cbcs_video_init.mp4";
 static VIDEO_AV1_MP4: &'static str = "tests/tiny_av1.mp4";
 
 // Adapted from https://github.com/GuillaumeGomez/audio-video-metadata/blob/9dff40f565af71d5502e03a2e78ae63df95cfd40/src/metadata.rs#L53
@@ -135,7 +146,7 @@ fn public_audio_tenc() {
         vec![0x7e, 0x57, 0x1d, 0x04, 0x7e, 0x57, 0x1d, 0x04,
              0x7e, 0x57, 0x1d, 0x04, 0x7e, 0x57, 0x1d, 0x04];
 
-    let mut fd = File::open(AUDIO_EME_MP4).expect("Unknown file");
+    let mut fd = File::open(AUDIO_EME_CENC_MP4).expect("Unknown file");
     let mut buf = Vec::new();
     fd.read_to_end(&mut buf).expect("File error");
 
@@ -189,7 +200,7 @@ fn public_video_cenc() {
              0x7e, 0x57, 0x1d, 0x03, 0x7e, 0x57, 0x1d, 0x11,
              0x00, 0x00, 0x00, 0x00];
 
-    let mut fd = File::open(VIDEO_EME_MP4).expect("Unknown file");
+    let mut fd = File::open(VIDEO_EME_CENC_MP4).expect("Unknown file");
     let mut buf = Vec::new();
     fd.read_to_end(&mut buf).expect("File error");
 
@@ -233,6 +244,153 @@ fn public_video_cenc() {
     }
 }
 
+#[test]
+fn publicaudio_cbcs() {
+    let system_id =
+        vec![0x10, 0x77, 0xef, 0xec, 0xc0, 0xb2, 0x4d, 0x02,
+             0xac, 0xe3, 0x3c, 0x1e, 0x52, 0xe2, 0xfb, 0x4b];
+
+    let kid =
+        vec![0x7e, 0x57, 0x1d, 0x04, 0x7e, 0x57, 0x1d, 0x04,
+             0x7e, 0x57, 0x1d, 0x04, 0x7e, 0x57, 0x1d, 0x21];
+
+    let default_iv =
+        vec![0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
+             0x99, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66];
+
+    let pssh_box =
+        vec![0x00, 0x00, 0x00, 0x34, 0x70, 0x73, 0x73, 0x68,
+             0x01, 0x00, 0x00, 0x00, 0x10, 0x77, 0xef, 0xec,
+             0xc0, 0xb2, 0x4d, 0x02, 0xac, 0xe3, 0x3c, 0x1e,
+             0x52, 0xe2, 0xfb, 0x4b, 0x00, 0x00, 0x00, 0x01,
+             0x7e, 0x57, 0x1d, 0x04, 0x7e, 0x57, 0x1d, 0x04,
+             0x7e, 0x57, 0x1d, 0x04, 0x7e, 0x57, 0x1d, 0x21,
+             0x00, 0x00, 0x00, 0x00];
+
+    let mut fd = File::open(AUDIO_EME_CBCS_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 mut context = mp4::MediaContext::new();
+    mp4::read_mp4(&mut c, &mut context).expect("read_mp4 failed");
+    for track in context.tracks {
+        let stsd = track.stsd.expect("expected an stsd");
+        assert_eq!(stsd.descriptions.len(), 2);
+        let mut found_encrypted_sample_description = false;
+        for description in stsd.descriptions {
+            match description {
+                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");
+                        if let Some(ref tenc) = p.tenc {
+                            assert!(tenc.is_encrypted > 0);
+                            assert_eq!(tenc.iv_size, 0);
+                            assert_eq!(tenc.kid, kid);
+                            // Note: 0 for both crypt and skip seems odd but
+                            // that's what shaka-packager produced. It appears
+                            // to indicate full encryption.
+                            assert_eq!(tenc.crypt_byte_block_count, Some(0));
+                            assert_eq!(tenc.skip_byte_block_count, Some(0));
+                            assert_eq!(tenc.constant_iv, Some(default_iv.clone()));
+                        } else {
+                            assert!(false, "Invalid test condition");
+                        }
+                    }
+                },
+                _ => {
+                    panic!("expected a VideoSampleEntry");
+                },
+            }
+        }
+        assert!(found_encrypted_sample_description,
+                "Should have found an encrypted sample description");
+    }
+
+    for pssh in context.psshs {
+        assert_eq!(pssh.system_id, system_id);
+        for kid_id in pssh.kid {
+            assert_eq!(kid_id, kid);
+        }
+        assert!(pssh.data.is_empty());
+        assert_eq!(pssh.box_content, pssh_box);
+    }
+}
+
+#[test]
+fn public_video_cbcs() {
+    let system_id =
+        vec![0x10, 0x77, 0xef, 0xec, 0xc0, 0xb2, 0x4d, 0x02,
+             0xac, 0xe3, 0x3c, 0x1e, 0x52, 0xe2, 0xfb, 0x4b];
+
+    let kid =
+        vec![0x7e, 0x57, 0x1d, 0x04, 0x7e, 0x57, 0x1d, 0x04,
+             0x7e, 0x57, 0x1d, 0x04, 0x7e, 0x57, 0x1d, 0x21];
+
+    let default_iv =
+        vec![0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
+             0x99, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66];
+
+    let pssh_box =
+        vec![0x00, 0x00, 0x00, 0x34, 0x70, 0x73, 0x73, 0x68,
+             0x01, 0x00, 0x00, 0x00, 0x10, 0x77, 0xef, 0xec,
+             0xc0, 0xb2, 0x4d, 0x02, 0xac, 0xe3, 0x3c, 0x1e,
+             0x52, 0xe2, 0xfb, 0x4b, 0x00, 0x00, 0x00, 0x01,
+             0x7e, 0x57, 0x1d, 0x04, 0x7e, 0x57, 0x1d, 0x04,
+             0x7e, 0x57, 0x1d, 0x04, 0x7e, 0x57, 0x1d, 0x21,
+             0x00, 0x00, 0x00, 0x00];
+
+    let mut fd = File::open(VIDEO_EME_CBCS_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 mut context = mp4::MediaContext::new();
+    mp4::read_mp4(&mut c, &mut context).expect("read_mp4 failed");
+    for track in context.tracks {
+        let stsd = track.stsd.expect("expected an stsd");
+        assert_eq!(stsd.descriptions.len(), 2);
+        let mut found_encrypted_sample_description = false;
+        for description in stsd.descriptions {
+            match description {
+                mp4::SampleEntry::Video(ref v) => {
+                    assert_eq!(v.width, 400);
+                    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");
+                        if let Some(ref tenc) = p.tenc {
+                            assert!(tenc.is_encrypted > 0);
+                            assert_eq!(tenc.iv_size, 0);
+                            assert_eq!(tenc.kid, kid);
+                            assert_eq!(tenc.crypt_byte_block_count, Some(1));
+                            assert_eq!(tenc.skip_byte_block_count, Some(9));
+                            assert_eq!(tenc.constant_iv, Some(default_iv.clone()));
+                        } else {
+                            assert!(false, "Invalid test condition");
+                        }
+                    }
+                },
+                _ => {
+                    panic!("expected a VideoSampleEntry");
+                },
+            }
+        }
+        assert!(found_encrypted_sample_description,
+                "Should have found an encrypted sample description");
+    }
+
+    for pssh in context.psshs {
+        assert_eq!(pssh.system_id, system_id);
+        for kid_id in pssh.kid {
+            assert_eq!(kid_id, kid);
+        }
+        assert!(pssh.data.is_empty());
+        assert_eq!(pssh.box_content, pssh_box);
+    }
+}
+
 #[test]
 fn public_video_av1() {
     let mut fd = File::open(VIDEO_AV1_MP4).expect("Unknown file");

mp4parse/tests/bipbop_cbcs_video_init.mp4

@@ -0,0 +1,139 @@
+extern crate mp4parse_capi;
+use std::io::Read;
+use mp4parse_capi::*;
+
+extern fn buf_read(buf: *mut u8, size: usize, userdata: *mut std::os::raw::c_void) -> isize {
+    let input: &mut std::fs::File = unsafe { &mut *(userdata as *mut _) };
+    let mut buf = unsafe { std::slice::from_raw_parts_mut(buf, size) };
+    match input.read(&mut buf) {
+        Ok(n) => n as isize,
+        Err(_) => -1,
+    }
+}
+
+#[test]
+fn parse_cenc() {
+    let mut file = std::fs::File::open("tests/short-cenc.mp4").expect("Unknown file");
+    let io = Mp4parseIo {
+        read: Some(buf_read),
+        userdata: &mut file as *mut _ as *mut std::os::raw::c_void
+    };
+
+    unsafe {
+        let parser = mp4parse_new(&io);
+
+        let mut rv = mp4parse_read(parser);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        let mut counts: u32 = 0;
+        rv = mp4parse_get_track_count(parser, &mut counts);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(counts, 2);
+
+        // Make sure we have a video track and it's at index 0
+        let mut video_track_info = Mp4parseTrackInfo::default();
+        rv = mp4parse_get_track_info(parser, 0, &mut video_track_info);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(video_track_info.track_type, Mp4parseTrackType::Video);
+
+        // Make sure we have a audio track and it's at index 1
+        let mut audio_track_info = Mp4parseTrackInfo::default();
+        rv = mp4parse_get_track_info(parser, 1, &mut audio_track_info);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(audio_track_info.track_type, Mp4parseTrackType::Audio);
+
+        // Verify video track and crypto information
+        let mut video = Mp4parseTrackVideoInfo::default();
+        rv = mp4parse_get_track_video_info(parser, 0, &mut video);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(video.sample_info_count, 1);
+        assert_eq!((*video.sample_info).codec_type, Mp4parseCodec::Avc);
+        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.is_encrypted, 0x01);
+        assert_eq!(protected_data.iv_size, 16);
+        assert_eq!(protected_data.kid.length, 16);
+        let expected_kid = [0x7e, 0x57, 0x1d, 0x01, 0x7e, 0x57, 0x1d, 0x01,
+                            0x7e, 0x57, 0x1d, 0x01, 0x7e, 0x57, 0x1d, 0x01];
+        for (i, expected_byte) in expected_kid.iter().enumerate() {
+            assert_eq!(&(*protected_data.kid.data.offset(i as isize)), expected_byte);
+        }
+        assert_eq!(protected_data.crypt_byte_block, 0);
+        assert_eq!(protected_data.skip_byte_block, 0);
+        assert_eq!(protected_data.constant_iv.length, 0);
+
+        // Verify audio track and crypto information
+        let mut audio = Mp4parseTrackAudioInfo::default();
+        rv = mp4parse_get_track_audio_info(parser, 1, &mut audio);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(audio.sample_info_count, 1);
+        assert_eq!((*audio.sample_info).codec_type, Mp4parseCodec::Aac);
+        assert_eq!((*audio.sample_info).channels, 2);
+        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.is_encrypted, 0x01);
+        assert_eq!(protected_data.iv_size, 16);
+        assert_eq!(protected_data.kid.length, 16);
+        let expected_kid = [0x7e, 0x57, 0x1d, 0x02, 0x7e, 0x57, 0x1d, 0x02,
+                            0x7e, 0x57, 0x1d, 0x02, 0x7e, 0x57, 0x1d, 0x02];
+        for (i, expected_byte) in expected_kid.iter().enumerate() {
+            assert_eq!(&(*protected_data.kid.data.offset(i as isize)), expected_byte);
+        }
+        assert_eq!(protected_data.crypt_byte_block, 0);
+        assert_eq!(protected_data.skip_byte_block, 0);
+        assert_eq!(protected_data.constant_iv.length, 0);
+    }
+}
+
+#[test]
+fn parse_cbcs() {
+    let mut file = std::fs::File::open("tests/bipbop_cbcs_video_init.mp4").expect("Unknown file");
+    let io = Mp4parseIo {
+        read: Some(buf_read),
+        userdata: &mut file as *mut _ as *mut std::os::raw::c_void
+    };
+
+    unsafe {
+        let parser = mp4parse_new(&io);
+
+        let mut rv = mp4parse_read(parser);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        let mut counts: u32 = 0;
+        rv = mp4parse_get_track_count(parser, &mut counts);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(counts, 1);
+
+        // Make sure we have a video track
+        let mut video_track_info = Mp4parseTrackInfo::default();
+        rv = mp4parse_get_track_info(parser, 0, &mut video_track_info);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(video_track_info.track_type, Mp4parseTrackType::Video);
+
+        // Verify video track and crypto information
+        let mut video = Mp4parseTrackVideoInfo::default();
+        rv = mp4parse_get_track_video_info(parser, 0, &mut video);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(video.sample_info_count, 2);
+        assert_eq!((*video.sample_info).codec_type, Mp4parseCodec::Avc);
+        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.is_encrypted, 0x01);
+        assert_eq!(protected_data.iv_size, 0);
+        assert_eq!(protected_data.kid.length, 16);
+        let expected_kid = [0x7e, 0x57, 0x1d, 0x04, 0x7e, 0x57, 0x1d, 0x04,
+                            0x7e, 0x57, 0x1d, 0x04, 0x7e, 0x57, 0x1d, 0x21];
+        for (i, expected_byte) in expected_kid.iter().enumerate() {
+            assert_eq!(&(*protected_data.kid.data.offset(i as isize)), expected_byte);
+        }
+        assert_eq!(protected_data.crypt_byte_block, 1);
+        assert_eq!(protected_data.skip_byte_block, 9);
+        assert_eq!(protected_data.constant_iv.length, 16);
+        let expected_iv = [0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
+                           0x99, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66];
+        for (i, expected_byte) in expected_iv.iter().enumerate() {
+            assert_eq!(&(*protected_data.constant_iv.data.offset(i as isize)), expected_byte);
+        }
+    }
+}