Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

7 files changed, 934 insertions, 0 deletions

diff --git a/third_party/rust/mp4parse_capi/tests/test_avis.rs b/third_party/rust/mp4parse_capi/tests/test_avis.rs
new file mode 100644
index 0000000000..a6e5a1c64e
--- /dev/null
+++ b/third_party/rust/mp4parse_capi/tests/test_avis.rs
@@ -0,0 +1,113 @@
+use mp4parse_capi::*;
+use num_traits::ToPrimitive;
+use std::io::Read;
+
+extern "C" 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 buf = unsafe { std::slice::from_raw_parts_mut(buf, size) };
+    match input.read(buf) {
+        Ok(n) => n as isize,
+        Err(_) => -1,
+    }
+}
+
+unsafe fn parse_file_and_get_info(path: &str) -> (*mut Mp4parseAvifParser, Mp4parseAvifInfo) {
+    let mut file = std::fs::File::open(path).expect("Unknown file");
+    let io = Mp4parseIo {
+        read: Some(buf_read),
+        userdata: &mut file as *mut _ as *mut std::os::raw::c_void,
+    };
+
+    let mut parser = std::ptr::null_mut();
+    let mut rv = mp4parse_avif_new(&io, ParseStrictness::Normal, &mut parser);
+    assert_eq!(rv, Mp4parseStatus::Ok);
+    assert!(!parser.is_null());
+
+    let mut info = Mp4parseAvifInfo {
+        premultiplied_alpha: Default::default(),
+        major_brand: Default::default(),
+        unsupported_features_bitfield: Default::default(),
+        spatial_extents: std::ptr::null(),
+        nclx_colour_information: std::ptr::null(),
+        icc_colour_information: Default::default(),
+        image_rotation: mp4parse::ImageRotation::D0,
+        image_mirror: std::ptr::null(),
+        pixel_aspect_ratio: std::ptr::null(),
+        has_primary_item: Default::default(),
+        primary_item_bit_depth: Default::default(),
+        has_alpha_item: Default::default(),
+        alpha_item_bit_depth: Default::default(),
+        has_sequence: Default::default(),
+        loop_mode: Default::default(),
+        loop_count: Default::default(),
+        color_track_id: Default::default(),
+        color_track_bit_depth: Default::default(),
+        alpha_track_id: Default::default(),
+        alpha_track_bit_depth: Default::default(),
+    };
+    rv = mp4parse_avif_get_info(parser, &mut info);
+    assert_eq!(rv, Mp4parseStatus::Ok);
+    (parser, info)
+}
+
+fn check_loop_count(path: &str, expected_loop_count: i64) {
+    let (parser, info) = unsafe { parse_file_and_get_info(path) };
+    match info.loop_mode {
+        Mp4parseAvifLoopMode::NoEdits => assert_eq!(expected_loop_count, -1),
+        Mp4parseAvifLoopMode::LoopByCount => {
+            assert_eq!(info.loop_count.to_i64(), Some(expected_loop_count))
+        }
+        Mp4parseAvifLoopMode::LoopInfinitely => assert_eq!(expected_loop_count, std::i64::MIN),
+    }
+
+    unsafe { mp4parse_avif_free(parser) };
+}
+
+fn check_timescale(path: &str, expected_timescale: u64) {
+    let (parser, info) = unsafe { parse_file_and_get_info(path) };
+
+    let mut indices: Mp4parseByteData = Mp4parseByteData::default();
+    let mut timescale: u64 = 0;
+    let rv = unsafe {
+        mp4parse_avif_get_indice_table(parser, info.color_track_id, &mut indices, &mut timescale)
+    };
+
+    assert_eq!(rv, Mp4parseStatus::Ok);
+    assert_eq!(timescale, expected_timescale);
+
+    unsafe { mp4parse_avif_free(parser) };
+}
+
+#[test]
+fn loop_once() {
+    check_loop_count("tests/loop_1.avif", 1);
+}
+
+#[test]
+fn loop_twice() {
+    check_loop_count("tests/loop_2.avif", 2);
+}
+
+#[test]
+fn loop_four_times_due_to_ceiling() {
+    check_loop_count("tests/loop_ceiled_4.avif", 4);
+}
+
+#[test]
+fn loop_forever() {
+    check_loop_count("tests/loop_forever.avif", std::i64::MIN);
+}
+
+#[test]
+fn no_edts() {
+    check_loop_count("tests/no_edts.avif", -1);
+}
+
+#[test]
+fn check_timescales() {
+    check_timescale("tests/loop_1.avif", 2);
+    check_timescale("tests/loop_2.avif", 2);
+    check_timescale("tests/loop_ceiled_4.avif", 2);
+    check_timescale("tests/loop_forever.avif", 2);
+    check_timescale("tests/no_edts.avif", 16384);
+}
diff --git a/third_party/rust/mp4parse_capi/tests/test_chunk_out_of_range.rs b/third_party/rust/mp4parse_capi/tests/test_chunk_out_of_range.rs
new file mode 100644
index 0000000000..26c2f506e1
--- /dev/null
+++ b/third_party/rust/mp4parse_capi/tests/test_chunk_out_of_range.rs
@@ -0,0 +1,44 @@
+use mp4parse_capi::*;
+use std::io::Read;
+
+extern "C" 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 buf = unsafe { std::slice::from_raw_parts_mut(buf, size) };
+    match input.read(buf) {
+        Ok(n) => n as isize,
+        Err(_) => -1,
+    }
+}
+
+#[test]
+fn parse_out_of_chunk_range() {
+    let mut file = std::fs::File::open("tests/chunk_out_of_range.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 mut parser = std::ptr::null_mut();
+        let mut rv = mp4parse_new(&io, &mut parser);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert!(!parser.is_null());
+
+        let mut counts: u32 = 0;
+        rv = mp4parse_get_track_count(parser, &mut counts);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(counts, 1);
+
+        // its first chunk is out of range.
+        // <SampleToChunkBox EntryCount="1">
+        //     <BoxInfo Size="28" Type="stsc"/>
+        //     <FullBoxInfo Version="0" Flags="0x0"/>
+        //     <SampleToChunkEntry FirstChunk="16777217" SamplesPerChunk="17" SampleDescriptionIndex="1"/>
+        //
+        let mut indice = Mp4parseByteData::default();
+        let rv = mp4parse_get_indice_table(parser, 1, &mut indice);
+        assert_eq!(rv, Mp4parseStatus::Invalid);
+
+        mp4parse_free(parser);
+    }
+}
diff --git a/third_party/rust/mp4parse_capi/tests/test_encryption.rs b/third_party/rust/mp4parse_capi/tests/test_encryption.rs
new file mode 100644
index 0000000000..03f5963044
--- /dev/null
+++ b/third_party/rust/mp4parse_capi/tests/test_encryption.rs
@@ -0,0 +1,295 @@
+use mp4parse_capi::*;
+use std::io::Read;
+
+extern "C" 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 buf = unsafe { std::slice::from_raw_parts_mut(buf, size) };
+    match input.read(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 mut parser = std::ptr::null_mut();
+        let mut rv = mp4parse_new(&io, &mut parser);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert!(!parser.is_null());
+        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.original_format,
+            OptionalFourCc::Some(*b"avc1")
+        );
+        assert_eq!(
+            protected_data.scheme_type,
+            Mp4ParseEncryptionSchemeType::Cenc
+        );
+        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.add(i)), 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.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);
+        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.add(i)), 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 mut parser = std::ptr::null_mut();
+        let mut rv = mp4parse_new(&io, &mut parser);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert!(!parser.is_null());
+        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.original_format,
+            OptionalFourCc::Some(*b"avc1")
+        );
+        assert_eq!(
+            protected_data.scheme_type,
+            Mp4ParseEncryptionSchemeType::Cbcs
+        );
+        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.add(i)), 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.add(i)), expected_byte);
+        }
+    }
+}
+
+#[test]
+fn parse_unencrypted() {
+    // Ensure the encryption related data is not populated for files without
+    // encryption metadata.
+    let mut file = std::fs::File::open("tests/opus_audioinit.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 mut parser = std::ptr::null_mut();
+        let mut rv = mp4parse_new(&io, &mut parser);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert!(!parser.is_null());
+
+        let mut counts: u32 = 0;
+        rv = mp4parse_get_track_count(parser, &mut counts);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(counts, 1);
+
+        let mut track_info = Mp4parseTrackInfo::default();
+        rv = mp4parse_get_track_info(parser, 0, &mut track_info);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(track_info.track_type, Mp4parseTrackType::Audio);
+
+        let mut audio = Mp4parseTrackAudioInfo::default();
+        rv = mp4parse_get_track_audio_info(parser, 0, &mut audio);
+        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
+        );
+        assert_eq!(protected_data.is_encrypted, 0x00);
+        assert_eq!(protected_data.iv_size, 0);
+        assert_eq!(protected_data.kid.length, 0);
+        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_encrypted_av1() {
+    // For reference, this file was created from the av1.mp4 in mozilla's media tests using
+    // shaka-packager. The following command was used to produce the file:
+    // ```
+    // packager-win.exe in=av1.mp4,stream=video,output=av1-clearkey-cbcs-video.mp4
+    // --protection_scheme cbcs --enable_raw_key_encryption
+    // --keys label=:key_id=00112233445566778899AABBCCDDEEFF:key=00112233445566778899AABBCCDDEEFF
+    // --iv 11223344556677889900112233445566
+    // ```
+    let mut file = std::fs::File::open("tests/av1-clearkey-cbcs-video.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 mut parser = std::ptr::null_mut();
+        let mut rv = mp4parse_new(&io, &mut parser);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert!(!parser.is_null());
+        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::Av1);
+        assert_eq!((*video.sample_info).image_width, 160);
+        assert_eq!((*video.sample_info).image_height, 90);
+
+        // Check that extra data binary blob.
+        let expected_extra_data = [
+            0x81, 0x00, 0x0c, 0x00, 0x0a, 0x0a, 0x00, 0x00, 0x00, 0x03, 0xb4, 0xfd, 0x97, 0xff,
+            0xe6, 0x01,
+        ];
+        let extra_data = &(*video.sample_info).extra_data;
+        assert_eq!(extra_data.length, 16);
+        for (i, expected_byte) in expected_extra_data.iter().enumerate() {
+            assert_eq!(&(*extra_data.data.add(i)), expected_byte);
+        }
+
+        let protected_data = &(*video.sample_info).protected_data;
+        assert_eq!(
+            protected_data.original_format,
+            OptionalFourCc::Some(*b"av01")
+        );
+        assert_eq!(
+            protected_data.scheme_type,
+            Mp4ParseEncryptionSchemeType::Cbcs
+        );
+        assert_eq!(protected_data.is_encrypted, 0x01);
+        assert_eq!(protected_data.iv_size, 0);
+        assert_eq!(protected_data.kid.length, 16);
+        let expected_kid = [
+            0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd,
+            0xee, 0xff,
+        ];
+        for (i, expected_byte) in expected_kid.iter().enumerate() {
+            assert_eq!(&(*protected_data.kid.data.add(i)), 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.add(i)), expected_byte);
+        }
+    }
+}
diff --git a/third_party/rust/mp4parse_capi/tests/test_fragment.rs b/third_party/rust/mp4parse_capi/tests/test_fragment.rs
new file mode 100644
index 0000000000..38bc569fa3
--- /dev/null
+++ b/third_party/rust/mp4parse_capi/tests/test_fragment.rs
@@ -0,0 +1,119 @@
+use mp4parse_capi::*;
+use std::io::Read;
+
+extern "C" 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 buf = unsafe { std::slice::from_raw_parts_mut(buf, size) };
+    match input.read(buf) {
+        Ok(n) => n as isize,
+        Err(_) => -1,
+    }
+}
+
+#[test]
+fn parse_fragment() {
+    let mut file = std::fs::File::open("tests/bipbop_audioinit.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 mut parser = std::ptr::null_mut();
+        let mut rv = mp4parse_new(&io, &mut parser);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert!(!parser.is_null());
+
+        let mut counts: u32 = 0;
+        rv = mp4parse_get_track_count(parser, &mut counts);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(counts, 1);
+
+        let mut track_info = Mp4parseTrackInfo::default();
+        rv = mp4parse_get_track_info(parser, 0, &mut track_info);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(track_info.track_type, Mp4parseTrackType::Audio);
+        assert_eq!(track_info.track_id, 1);
+        assert_eq!(track_info.duration, 0);
+        assert_eq!(track_info.media_time, 0);
+        assert_eq!(track_info.time_scale, 22050);
+
+        let mut audio = Default::default();
+        rv = mp4parse_get_track_audio_info(parser, 0, &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, 22050);
+        assert_eq!((*audio.sample_info).extra_data.length, 27);
+        assert_eq!((*audio.sample_info).codec_specific_config.length, 2);
+
+        let mut is_fragmented_file: u8 = 0;
+        rv = mp4parse_is_fragmented(parser, track_info.track_id, &mut is_fragmented_file);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(is_fragmented_file, 1);
+
+        let mut fragment_info = Mp4parseFragmentInfo::default();
+        rv = mp4parse_get_fragment_info(parser, &mut fragment_info);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(fragment_info.fragment_duration, 10_032);
+        assert_eq!(fragment_info.time_scale, 1000);
+
+        mp4parse_free(parser);
+    }
+}
+
+#[test]
+fn parse_opus_fragment() {
+    let mut file = std::fs::File::open("tests/opus_audioinit.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 mut parser = std::ptr::null_mut();
+        let mut rv = mp4parse_new(&io, &mut parser);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert!(!parser.is_null());
+
+        let mut counts: u32 = 0;
+        rv = mp4parse_get_track_count(parser, &mut counts);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(counts, 1);
+
+        let mut track_info = Mp4parseTrackInfo::default();
+        rv = mp4parse_get_track_info(parser, 0, &mut track_info);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(track_info.track_type, Mp4parseTrackType::Audio);
+        assert_eq!(track_info.track_id, 1);
+        assert_eq!(track_info.duration, 0);
+        assert_eq!(track_info.media_time, 0);
+        assert_eq!(track_info.time_scale, 48000);
+
+        let mut audio = Default::default();
+        rv = mp4parse_get_track_audio_info(parser, 0, &mut audio);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(audio.sample_info_count, 1);
+
+        assert_eq!((*audio.sample_info).codec_type, Mp4parseCodec::Opus);
+        assert_eq!((*audio.sample_info).channels, 1);
+        assert_eq!((*audio.sample_info).bit_depth, 16);
+        assert_eq!((*audio.sample_info).sample_rate, 48000);
+        assert_eq!((*audio.sample_info).extra_data.length, 0);
+        assert_eq!((*audio.sample_info).codec_specific_config.length, 19);
+
+        let mut is_fragmented_file: u8 = 0;
+        rv = mp4parse_is_fragmented(parser, track_info.track_id, &mut is_fragmented_file);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(is_fragmented_file, 1);
+
+        let mut fragment_info = Mp4parseFragmentInfo::default();
+        rv = mp4parse_get_fragment_info(parser, &mut fragment_info);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+
+        mp4parse_free(parser);
+    }
+}
diff --git a/third_party/rust/mp4parse_capi/tests/test_rotation.rs b/third_party/rust/mp4parse_capi/tests/test_rotation.rs
new file mode 100644
index 0000000000..2ea47a5d52
--- /dev/null
+++ b/third_party/rust/mp4parse_capi/tests/test_rotation.rs
@@ -0,0 +1,40 @@
+use mp4parse_capi::*;
+use std::io::Read;
+
+extern "C" 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 buf = unsafe { std::slice::from_raw_parts_mut(buf, size) };
+    match input.read(buf) {
+        Ok(n) => n as isize,
+        Err(_) => -1,
+    }
+}
+
+#[test]
+fn parse_rotation() {
+    let mut file = std::fs::File::open("tests/video_rotation_90.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 mut parser = std::ptr::null_mut();
+        let mut rv = mp4parse_new(&io, &mut parser);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert!(!parser.is_null());
+
+        let mut counts: u32 = 0;
+        rv = mp4parse_get_track_count(parser, &mut counts);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(counts, 1);
+
+        let mut video = Mp4parseTrackVideoInfo::default();
+
+        let rv = mp4parse_get_track_video_info(parser, 0, &mut video);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(video.rotation, 90);
+
+        mp4parse_free(parser);
+    }
+}
diff --git a/third_party/rust/mp4parse_capi/tests/test_sample_table.rs b/third_party/rust/mp4parse_capi/tests/test_sample_table.rs
new file mode 100644
index 0000000000..820eed64f3
--- /dev/null
+++ b/third_party/rust/mp4parse_capi/tests/test_sample_table.rs
@@ -0,0 +1,278 @@
+use mp4parse::unstable::Indice;
+use mp4parse_capi::*;
+use std::io::Read;
+
+extern "C" 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 buf = unsafe { std::slice::from_raw_parts_mut(buf, size) };
+    match input.read(buf) {
+        Ok(n) => n as isize,
+        Err(_) => -1,
+    }
+}
+
+#[test]
+fn parse_sample_table() {
+    let mut file =
+        std::fs::File::open("tests/bipbop_nonfragment_header.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 mut parser = std::ptr::null_mut();
+        let mut rv = mp4parse_new(&io, &mut parser);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert!(!parser.is_null());
+
+        let mut counts: u32 = 0;
+        rv = mp4parse_get_track_count(parser, &mut counts);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(counts, 2);
+
+        let mut track_info = Mp4parseTrackInfo::default();
+        rv = mp4parse_get_track_info(parser, 1, &mut track_info);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(track_info.track_type, Mp4parseTrackType::Audio);
+
+        // Check audio smaple table
+        let mut is_fragmented_file: u8 = 0;
+        rv = mp4parse_is_fragmented(parser, track_info.track_id, &mut is_fragmented_file);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(is_fragmented_file, 0);
+
+        let mut indice = Mp4parseByteData::default();
+        rv = mp4parse_get_indice_table(parser, track_info.track_id, &mut indice);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+
+        // Compare the value from stagefright.
+        let audio_indice_0 = Indice {
+            start_offset: 27_046.into(),
+            end_offset: 27_052.into(),
+            start_composition: 0.into(),
+            end_composition: 1024.into(),
+            start_decode: 0.into(),
+            sync: true,
+        };
+        let audio_indice_215 = Indice {
+            start_offset: 283_550.into(),
+            end_offset: 283_556.into(),
+            start_composition: 220160.into(),
+            end_composition: 221184.into(),
+            start_decode: 220160.into(),
+            sync: true,
+        };
+        assert_eq!(indice.length, 216);
+        assert_eq!(*indice.indices.offset(0), audio_indice_0);
+        assert_eq!(*indice.indices.offset(215), audio_indice_215);
+
+        // Check video smaple table
+        rv = mp4parse_get_track_info(parser, 0, &mut track_info);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(track_info.track_type, Mp4parseTrackType::Video);
+
+        let mut is_fragmented_file: u8 = 0;
+        rv = mp4parse_is_fragmented(parser, track_info.track_id, &mut is_fragmented_file);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(is_fragmented_file, 0);
+
+        let mut indice = Mp4parseByteData::default();
+        rv = mp4parse_get_indice_table(parser, track_info.track_id, &mut indice);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+
+        // Compare the last few data from stagefright.
+        let video_indice_291 = Indice {
+            start_offset: 280_226.into(),
+            end_offset: 280_855.into(),
+            start_composition: 876995.into(),
+            end_composition: 879996.into(),
+            start_decode: 873900.into(),
+            sync: false,
+        };
+        let video_indice_292 = Indice {
+            start_offset: 280_855.into(),
+            end_offset: 281_297.into(),
+            start_composition: 873996.into(),
+            end_composition: 876995.into(),
+            start_decode: 873901.into(),
+            sync: false,
+        };
+        // TODO: start_composition time in stagefright is 9905000, but it is 9904999 in parser, it
+        //       could be rounding error.
+        //let video_indice_293 = Indice { start_offset: 281_297, end_offset: 281_919, start_composition: 9_905_000, end_composition: 9_938_344, start_decode: 9_776_666, sync: false };
+        //let video_indice_294 = Indice { start_offset: 281_919, end_offset: 282_391, start_composition: 9_871_677, end_composition: 9_905_000, start_decode: 9_776_677, sync: false };
+        let video_indice_295 = Indice {
+            start_offset: 282_391.into(),
+            end_offset: 283_032.into(),
+            start_composition: 888995.into(),
+            end_composition: 888996.into(),
+            start_decode: 885900.into(),
+            sync: false,
+        };
+        let video_indice_296 = Indice {
+            start_offset: 283_092.into(),
+            end_offset: 283_526.into(),
+            start_composition: 885996.into(),
+            end_composition: 888995.into(),
+            start_decode: 885901.into(),
+            sync: false,
+        };
+
+        assert_eq!(indice.length, 297);
+        assert_eq!(*indice.indices.offset(291), video_indice_291);
+        assert_eq!(*indice.indices.offset(292), video_indice_292);
+        //assert_eq!(*indice.indices.offset(293), video_indice_293);
+        //assert_eq!(*indice.indices.offset(294), video_indice_294);
+        assert_eq!(*indice.indices.offset(295), video_indice_295);
+        assert_eq!(*indice.indices.offset(296), video_indice_296);
+
+        mp4parse_free(parser);
+    }
+}
+
+#[test]
+fn parse_sample_table_with_elst() {
+    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 mut parser = std::ptr::null_mut();
+        let mut rv = mp4parse_new(&io, &mut parser);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert!(!parser.is_null());
+
+        let mut counts: u32 = 0;
+        rv = mp4parse_get_track_count(parser, &mut counts);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(counts, 2);
+
+        let mut track_info = Mp4parseTrackInfo::default();
+        rv = mp4parse_get_track_info(parser, 1, &mut track_info);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(track_info.track_type, Mp4parseTrackType::Audio);
+
+        // Check audio sample table
+        let mut is_fragmented_file: u8 = std::u8::MAX;
+        rv = mp4parse_is_fragmented(parser, track_info.track_id, &mut is_fragmented_file);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(is_fragmented_file, 0);
+
+        let mut indice = Mp4parseByteData::default();
+        rv = mp4parse_get_indice_table(parser, track_info.track_id, &mut indice);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+
+        // Compare the value from stagefright.
+        // Due to 'elst', the start_composition and end_composition are negative
+        // at first two samples.
+        let audio_indice_0 = Indice {
+            start_offset: 6992.into(),
+            end_offset: 7363.into(),
+            start_composition: (-1600).into(),
+            end_composition: (-576).into(),
+            start_decode: 0.into(),
+            sync: true,
+        };
+        let audio_indice_1 = Indice {
+            start_offset: 7363.into(),
+            end_offset: 7735.into(),
+            start_composition: (-576).into(),
+            end_composition: 448.into(),
+            start_decode: 1024.into(),
+            sync: true,
+        };
+        let audio_indice_2 = Indice {
+            start_offset: 7735.into(),
+            end_offset: 8106.into(),
+            start_composition: 448.into(),
+            end_composition: 1472.into(),
+            start_decode: 2048.into(),
+            sync: true,
+        };
+        assert_eq!(indice.length, 21);
+        assert_eq!(*indice.indices.offset(0), audio_indice_0);
+        assert_eq!(*indice.indices.offset(1), audio_indice_1);
+        assert_eq!(*indice.indices.offset(2), audio_indice_2);
+
+        mp4parse_free(parser);
+    }
+}
+
+#[test]
+fn parse_sample_table_with_negative_ctts() {
+    let mut file = std::fs::File::open("tests/white.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 mut parser = std::ptr::null_mut();
+        let mut rv = mp4parse_new(&io, &mut parser);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert!(!parser.is_null());
+
+        let mut counts: u32 = 0;
+        rv = mp4parse_get_track_count(parser, &mut counts);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(counts, 1);
+
+        let mut track_info = Mp4parseTrackInfo::default();
+        rv = mp4parse_get_track_info(parser, 0, &mut track_info);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(track_info.track_type, Mp4parseTrackType::Video);
+
+        let mut is_fragmented_file: u8 = std::u8::MAX;
+        rv = mp4parse_is_fragmented(parser, track_info.track_id, &mut is_fragmented_file);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(is_fragmented_file, 0);
+
+        let mut indice = Mp4parseByteData::default();
+        rv = mp4parse_get_indice_table(parser, track_info.track_id, &mut indice);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+
+        // There are negative value in 'ctts' table.
+        let video_indice_0 = Indice {
+            start_offset: 48.into(),
+            end_offset: 890.into(),
+            start_composition: 0.into(),
+            end_composition: 100.into(),
+            start_decode: 0.into(),
+            sync: true,
+        };
+        let video_indice_1 = Indice {
+            start_offset: 890.into(),
+            end_offset: 913.into(),
+            start_composition: 400.into(),
+            end_composition: 500.into(),
+            start_decode: 100.into(),
+            sync: false,
+        };
+        let video_indice_2 = Indice {
+            start_offset: 913.into(),
+            end_offset: 934.into(),
+            start_composition: 200.into(),
+            end_composition: 300.into(),
+            start_decode: 200.into(),
+            sync: false,
+        };
+        let video_indice_3 = Indice {
+            start_offset: 934.into(),
+            end_offset: 955.into(),
+            start_composition: 100.into(),
+            end_composition: 200.into(),
+            start_decode: 300.into(),
+            sync: false,
+        };
+        assert_eq!(indice.length, 300);
+        assert_eq!(*indice.indices.offset(0), video_indice_0);
+        assert_eq!(*indice.indices.offset(1), video_indice_1);
+        assert_eq!(*indice.indices.offset(2), video_indice_2);
+        assert_eq!(*indice.indices.offset(3), video_indice_3);
+
+        mp4parse_free(parser);
+    }
+}
diff --git a/third_party/rust/mp4parse_capi/tests/test_workaround_stsc.rs b/third_party/rust/mp4parse_capi/tests/test_workaround_stsc.rs
new file mode 100644
index 0000000000..197024086f
--- /dev/null
+++ b/third_party/rust/mp4parse_capi/tests/test_workaround_stsc.rs
@@ -0,0 +1,45 @@
+use mp4parse_capi::*;
+use std::io::Read;
+
+extern "C" 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 buf = unsafe { std::slice::from_raw_parts_mut(buf, size) };
+    match input.read(buf) {
+        Ok(n) => n as isize,
+        Err(_) => -1,
+    }
+}
+
+#[test]
+fn parse_invalid_stsc_table() {
+    let mut file = std::fs::File::open("tests/zero_empty_stsc.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 mut parser = std::ptr::null_mut();
+        let rv = mp4parse_new(&io, &mut parser);
+
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert!(!parser.is_null());
+
+        let mut counts: u32 = 0;
+        let rv = mp4parse_get_track_count(parser, &mut counts);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(counts, 2);
+
+        let mut indice_video = Mp4parseByteData::default();
+        let rv = mp4parse_get_indice_table(parser, 1, &mut indice_video);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(indice_video.length, 1040);
+
+        let mut indice_audio = Mp4parseByteData::default();
+        let rv = mp4parse_get_indice_table(parser, 2, &mut indice_audio);
+        assert_eq!(rv, Mp4parseStatus::Ok);
+        assert_eq!(indice_audio.length, 1952);
+
+        mp4parse_free(parser);
+    }
+}