diff options
| author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 09:22:09 +0000 |
|---|---|---|
| committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 09:22:09 +0000 |
| commit | 43a97878ce14b72f0981164f87f2e35e14151312 (patch) | |
| tree | 620249daf56c0258faa40cbdcf9cfba06de2a846 /third_party/rust/mp4parse/tests | |
| parent | Initial commit. (diff) | |
| download | firefox-upstream.tar.xz firefox-upstream.zip | |
Adding upstream version 110.0.1.upstream/110.0.1upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'third_party/rust/mp4parse/tests')
58 files changed, 1455 insertions, 0 deletions
diff --git a/third_party/rust/mp4parse/tests/1x1-black-alpha-50pct-premultiplied.avif b/third_party/rust/mp4parse/tests/1x1-black-alpha-50pct-premultiplied.avif Binary files differnew file mode 100644 index 0000000000..40652dfd49 --- /dev/null +++ b/third_party/rust/mp4parse/tests/1x1-black-alpha-50pct-premultiplied.avif diff --git a/third_party/rust/mp4parse/tests/a1lx.avif b/third_party/rust/mp4parse/tests/a1lx.avif Binary files differnew file mode 100644 index 0000000000..42d77f2336 --- /dev/null +++ b/third_party/rust/mp4parse/tests/a1lx.avif diff --git a/third_party/rust/mp4parse/tests/a1op.avif b/third_party/rust/mp4parse/tests/a1op.avif Binary files differnew file mode 100644 index 0000000000..a98f0ffffd --- /dev/null +++ b/third_party/rust/mp4parse/tests/a1op.avif diff --git a/third_party/rust/mp4parse/tests/alpha_video_avif_major_avis_compatible.avif b/third_party/rust/mp4parse/tests/alpha_video_avif_major_avis_compatible.avif Binary files differnew file mode 100644 index 0000000000..f2782a5206 --- /dev/null +++ b/third_party/rust/mp4parse/tests/alpha_video_avif_major_avis_compatible.avif diff --git a/third_party/rust/mp4parse/tests/alpha_video_fixed.avif b/third_party/rust/mp4parse/tests/alpha_video_fixed.avif Binary files differnew file mode 100644 index 0000000000..a600f849c0 --- /dev/null +++ b/third_party/rust/mp4parse/tests/alpha_video_fixed.avif diff --git a/third_party/rust/mp4parse/tests/alpha_video_no_avis.avif b/third_party/rust/mp4parse/tests/alpha_video_no_avis.avif Binary files differnew file mode 100644 index 0000000000..b1794c9d6e --- /dev/null +++ b/third_party/rust/mp4parse/tests/alpha_video_no_avis.avif diff --git a/third_party/rust/mp4parse/tests/amr_nb_1f.3gp b/third_party/rust/mp4parse/tests/amr_nb_1f.3gp Binary files differnew file mode 100644 index 0000000000..5ef216c636 --- /dev/null +++ b/third_party/rust/mp4parse/tests/amr_nb_1f.3gp diff --git a/third_party/rust/mp4parse/tests/amr_wb_1f.3gp b/third_party/rust/mp4parse/tests/amr_wb_1f.3gp Binary files differnew file mode 100644 index 0000000000..a49f39438d --- /dev/null +++ b/third_party/rust/mp4parse/tests/amr_wb_1f.3gp diff --git a/third_party/rust/mp4parse/tests/av1C-missing-essential.avif b/third_party/rust/mp4parse/tests/av1C-missing-essential.avif Binary files differnew file mode 100644 index 0000000000..c5bf6ee045 --- /dev/null +++ b/third_party/rust/mp4parse/tests/av1C-missing-essential.avif diff --git a/third_party/rust/mp4parse/tests/bad-ipma-flags.avif b/third_party/rust/mp4parse/tests/bad-ipma-flags.avif Binary files differnew file mode 100644 index 0000000000..40012f2114 --- /dev/null +++ b/third_party/rust/mp4parse/tests/bad-ipma-flags.avif diff --git a/third_party/rust/mp4parse/tests/bad-ipma-version.avif b/third_party/rust/mp4parse/tests/bad-ipma-version.avif Binary files differnew file mode 100644 index 0000000000..e8442c166c --- /dev/null +++ b/third_party/rust/mp4parse/tests/bad-ipma-version.avif diff --git a/third_party/rust/mp4parse/tests/bbb_sunflower_QCIF_30fps_h263_noaudio_1f.3gp b/third_party/rust/mp4parse/tests/bbb_sunflower_QCIF_30fps_h263_noaudio_1f.3gp Binary files differnew file mode 100644 index 0000000000..7e8ff7f814 --- /dev/null +++ b/third_party/rust/mp4parse/tests/bbb_sunflower_QCIF_30fps_h263_noaudio_1f.3gp diff --git a/third_party/rust/mp4parse/tests/clap-basic-1_3x3-to-1x1.avif b/third_party/rust/mp4parse/tests/clap-basic-1_3x3-to-1x1.avif Binary files differnew file mode 100644 index 0000000000..2d59986a28 --- /dev/null +++ b/third_party/rust/mp4parse/tests/clap-basic-1_3x3-to-1x1.avif diff --git a/third_party/rust/mp4parse/tests/clap-missing-essential.avif b/third_party/rust/mp4parse/tests/clap-missing-essential.avif Binary files differnew file mode 100644 index 0000000000..4dfcfd2bb9 --- /dev/null +++ b/third_party/rust/mp4parse/tests/clap-missing-essential.avif diff --git a/third_party/rust/mp4parse/tests/clusterfuzz-testcase-minimized-mp4-6093954524250112 b/third_party/rust/mp4parse/tests/clusterfuzz-testcase-minimized-mp4-6093954524250112 Binary files differnew file mode 100644 index 0000000000..fb6335f563 --- /dev/null +++ b/third_party/rust/mp4parse/tests/clusterfuzz-testcase-minimized-mp4-6093954524250112 diff --git a/third_party/rust/mp4parse/tests/corrupt/a1lx-marked-essential.avif b/third_party/rust/mp4parse/tests/corrupt/a1lx-marked-essential.avif Binary files differnew file mode 100644 index 0000000000..c24f2c1c67 --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/a1lx-marked-essential.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/a1op-missing-essential.avif b/third_party/rust/mp4parse/tests/corrupt/a1op-missing-essential.avif Binary files differnew file mode 100644 index 0000000000..828dbbc52c --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/a1op-missing-essential.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/alpha_video_moov_is_moop.avif b/third_party/rust/mp4parse/tests/corrupt/alpha_video_moov_is_moop.avif Binary files differnew file mode 100644 index 0000000000..c6aa254722 --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/alpha_video_moov_is_moop.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/bug-1655846.avif b/third_party/rust/mp4parse/tests/corrupt/bug-1655846.avif Binary files differnew file mode 100644 index 0000000000..31c7e42454 --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/bug-1655846.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/bug-1661347.avif b/third_party/rust/mp4parse/tests/corrupt/bug-1661347.avif Binary files differnew file mode 100644 index 0000000000..11b539230b --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/bug-1661347.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/clusterfuzz-testcase-minimized-avif-4914209301856256.avif b/third_party/rust/mp4parse/tests/corrupt/clusterfuzz-testcase-minimized-avif-4914209301856256.avif Binary files differnew file mode 100644 index 0000000000..e5cb2fe70e --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/clusterfuzz-testcase-minimized-avif-4914209301856256.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/hdlr-not-first.avif b/third_party/rust/mp4parse/tests/corrupt/hdlr-not-first.avif Binary files differnew file mode 100644 index 0000000000..2011e7bb7d --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/hdlr-not-first.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/hdlr-not-pict.avif b/third_party/rust/mp4parse/tests/corrupt/hdlr-not-pict.avif Binary files differnew file mode 100644 index 0000000000..34137ce3c9 --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/hdlr-not-pict.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/imir-before-clap.avif b/third_party/rust/mp4parse/tests/corrupt/imir-before-clap.avif Binary files differnew file mode 100644 index 0000000000..d02ef72424 --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/imir-before-clap.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/invalid-avif-colr-multiple-nclx.avif b/third_party/rust/mp4parse/tests/corrupt/invalid-avif-colr-multiple-nclx.avif Binary files differnew file mode 100644 index 0000000000..7d2ea0dc52 --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/invalid-avif-colr-multiple-nclx.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/invalid-avif-colr-multiple-prof.avif b/third_party/rust/mp4parse/tests/corrupt/invalid-avif-colr-multiple-prof.avif Binary files differnew file mode 100644 index 0000000000..671b8b6585 --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/invalid-avif-colr-multiple-prof.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/invalid-avif-colr-multiple-rICC.avif b/third_party/rust/mp4parse/tests/corrupt/invalid-avif-colr-multiple-rICC.avif Binary files differnew file mode 100644 index 0000000000..e8ced19127 --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/invalid-avif-colr-multiple-rICC.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/invalid-avif-colr-multiple.zip b/third_party/rust/mp4parse/tests/corrupt/invalid-avif-colr-multiple.zip Binary files differnew file mode 100644 index 0000000000..14629882d0 --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/invalid-avif-colr-multiple.zip diff --git a/third_party/rust/mp4parse/tests/corrupt/ipma-duplicate-item_id.avif b/third_party/rust/mp4parse/tests/corrupt/ipma-duplicate-item_id.avif Binary files differnew file mode 100644 index 0000000000..ed47ebfe6f --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/ipma-duplicate-item_id.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/ipma-duplicate-version-and-flags.avif b/third_party/rust/mp4parse/tests/corrupt/ipma-duplicate-version-and-flags.avif Binary files differnew file mode 100644 index 0000000000..9bc5e76309 --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/ipma-duplicate-version-and-flags.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/ipma-invalid-property-index.avif b/third_party/rust/mp4parse/tests/corrupt/ipma-invalid-property-index.avif Binary files differnew file mode 100644 index 0000000000..e5ecbb993b --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/ipma-invalid-property-index.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/lsel-missing-essential.avif b/third_party/rust/mp4parse/tests/corrupt/lsel-missing-essential.avif Binary files differnew file mode 100644 index 0000000000..a83300c6a9 --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/lsel-missing-essential.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/no-alpha-av1C.avif b/third_party/rust/mp4parse/tests/corrupt/no-alpha-av1C.avif Binary files differnew file mode 100644 index 0000000000..6d674ebbbf --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/no-alpha-av1C.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/no-av1C.avif b/third_party/rust/mp4parse/tests/corrupt/no-av1C.avif Binary files differnew file mode 100644 index 0000000000..f46fcb6523 --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/no-av1C.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/no-ftyp.avif b/third_party/rust/mp4parse/tests/corrupt/no-ftyp.avif Binary files differnew file mode 100644 index 0000000000..ff666bb3f8 --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/no-ftyp.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/no-hdlr.avif b/third_party/rust/mp4parse/tests/corrupt/no-hdlr.avif Binary files differnew file mode 100644 index 0000000000..d75e869589 --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/no-hdlr.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/no-ispe.avif b/third_party/rust/mp4parse/tests/corrupt/no-ispe.avif Binary files differnew file mode 100644 index 0000000000..69f97caeae --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/no-ispe.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/no-pitm.avif b/third_party/rust/mp4parse/tests/corrupt/no-pitm.avif Binary files differnew file mode 100644 index 0000000000..074788b398 --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/no-pitm.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/no-pixi-for-alpha.avif b/third_party/rust/mp4parse/tests/corrupt/no-pixi-for-alpha.avif Binary files differnew file mode 100644 index 0000000000..caf1b7fe60 --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/no-pixi-for-alpha.avif diff --git a/third_party/rust/mp4parse/tests/corrupt/no-pixi.avif b/third_party/rust/mp4parse/tests/corrupt/no-pixi.avif Binary files differnew file mode 100644 index 0000000000..9e04a6817a --- /dev/null +++ b/third_party/rust/mp4parse/tests/corrupt/no-pixi.avif diff --git a/third_party/rust/mp4parse/tests/hdlr-nonzero-reserved.avif b/third_party/rust/mp4parse/tests/hdlr-nonzero-reserved.avif Binary files differnew file mode 100644 index 0000000000..e84ba63e2d --- /dev/null +++ b/third_party/rust/mp4parse/tests/hdlr-nonzero-reserved.avif diff --git a/third_party/rust/mp4parse/tests/imir-missing-essential.avif b/third_party/rust/mp4parse/tests/imir-missing-essential.avif Binary files differnew file mode 100644 index 0000000000..6baa293ab6 --- /dev/null +++ b/third_party/rust/mp4parse/tests/imir-missing-essential.avif diff --git a/third_party/rust/mp4parse/tests/invalid-avif-hdlr-name-multiple-nul.avif b/third_party/rust/mp4parse/tests/invalid-avif-hdlr-name-multiple-nul.avif Binary files differnew file mode 100644 index 0000000000..fe7a64ee02 --- /dev/null +++ b/third_party/rust/mp4parse/tests/invalid-avif-hdlr-name-multiple-nul.avif diff --git a/third_party/rust/mp4parse/tests/irot-missing-essential.avif b/third_party/rust/mp4parse/tests/irot-missing-essential.avif Binary files differnew file mode 100644 index 0000000000..8c62e55ecc --- /dev/null +++ b/third_party/rust/mp4parse/tests/irot-missing-essential.avif diff --git a/third_party/rust/mp4parse/tests/lsel.avif b/third_party/rust/mp4parse/tests/lsel.avif Binary files differnew file mode 100644 index 0000000000..ad85f72b84 --- /dev/null +++ b/third_party/rust/mp4parse/tests/lsel.avif diff --git a/third_party/rust/mp4parse/tests/multiple-extents.avif b/third_party/rust/mp4parse/tests/multiple-extents.avif Binary files differnew file mode 100644 index 0000000000..dd306992cb --- /dev/null +++ b/third_party/rust/mp4parse/tests/multiple-extents.avif diff --git a/third_party/rust/mp4parse/tests/no-mif1.avif b/third_party/rust/mp4parse/tests/no-mif1.avif Binary files differnew file mode 100644 index 0000000000..1ccbcc43fc --- /dev/null +++ b/third_party/rust/mp4parse/tests/no-mif1.avif diff --git a/third_party/rust/mp4parse/tests/overflow.rs b/third_party/rust/mp4parse/tests/overflow.rs new file mode 100644 index 0000000000..ce5dc52247 --- /dev/null +++ b/third_party/rust/mp4parse/tests/overflow.rs @@ -0,0 +1,15 @@ +/// Verify we're built with run-time integer overflow detection. + +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at https://mozilla.org/MPL/2.0/. + +#[test] +#[should_panic(expected = "attempt to add with overflow")] +fn overflow_protection() { + let edge = u32::max_value(); + assert_eq!(0u32, edge + 1); + + let edge = u64::max_value(); + assert_eq!(0u64, edge + 1); +} diff --git a/third_party/rust/mp4parse/tests/public.rs b/third_party/rust/mp4parse/tests/public.rs new file mode 100644 index 0000000000..a35cef6666 --- /dev/null +++ b/third_party/rust/mp4parse/tests/public.rs @@ -0,0 +1,1440 @@ +/// Check if needed fields are still public. +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at https://mozilla.org/MPL/2.0/. +extern crate mp4parse as mp4; + +use mp4::{Error, ParseStrictness, Status}; +use std::convert::TryInto; +use std::fs::File; +use std::io::{Cursor, Read, Seek, SeekFrom}; + +static MINI_MP4: &str = "tests/minimal.mp4"; +static MINI_MP4_WITH_METADATA: &str = "tests/metadata.mp4"; +static MINI_MP4_WITH_METADATA_STD_GENRE: &str = "tests/metadata_gnre.mp4"; + +static AUDIO_EME_CENC_MP4: &str = "tests/bipbop-cenc-audioinit.mp4"; +static VIDEO_EME_CENC_MP4: &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: &str = "tests/bipbop_cbcs_audio_init.mp4"; +static VIDEO_EME_CBCS_MP4: &str = "tests/bipbop_cbcs_video_init.mp4"; +static VIDEO_AV1_MP4: &str = "tests/tiny_av1.mp4"; +// This file contains invalid userdata in its copyright userdata. See +// https://bugzilla.mozilla.org/show_bug.cgi?id=1687357 for more information. +static VIDEO_INVALID_USERDATA: &str = "tests/invalid_userdata.mp4"; +static IMAGE_AVIF: &str = "tests/valid.avif"; +static IMAGE_AVIF_EXTENTS: &str = "tests/multiple-extents.avif"; +static IMAGE_AVIF_ALPHA: &str = "tests/valid-alpha.avif"; +static IMAGE_AVIF_ALPHA_PREMULTIPLIED: &str = "tests/1x1-black-alpha-50pct-premultiplied.avif"; +static IMAGE_AVIF_CORRUPT: &str = "tests/corrupt/bug-1655846.avif"; +static IMAGE_AVIF_CORRUPT_2: &str = "tests/corrupt/bug-1661347.avif"; +static IMAGE_AVIF_IPMA_BAD_VERSION: &str = "tests/bad-ipma-version.avif"; +static IMAGE_AVIF_IPMA_BAD_FLAGS: &str = "tests/bad-ipma-flags.avif"; +static IMAGE_AVIF_IPMA_DUPLICATE_VERSION_AND_FLAGS: &str = + "tests/corrupt/ipma-duplicate-version-and-flags.avif"; +static IMAGE_AVIF_IPMA_DUPLICATE_ITEM_ID: &str = "tests/corrupt/ipma-duplicate-item_id.avif"; +static IMAGE_AVIF_IPMA_INVALID_PROPERTY_INDEX: &str = + "tests/corrupt/ipma-invalid-property-index.avif"; +static IMAGE_AVIF_NO_HDLR: &str = "tests/corrupt/hdlr-not-first.avif"; +static IMAGE_AVIF_HDLR_NOT_FIRST: &str = "tests/corrupt/no-hdlr.avif"; +static IMAGE_AVIF_HDLR_NOT_PICT: &str = "tests/corrupt/hdlr-not-pict.avif"; +static IMAGE_AVIF_HDLR_NONZERO_RESERVED: &str = "tests/hdlr-nonzero-reserved.avif"; +static IMAGE_AVIF_HDLR_MULTIPLE_NUL: &str = "tests/invalid-avif-hdlr-name-multiple-nul.avif"; +static IMAGE_AVIF_NO_MIF1: &str = "tests/no-mif1.avif"; +static IMAGE_AVIF_NO_PITM: &str = "tests/corrupt/no-pitm.avif"; +static IMAGE_AVIF_NO_PIXI: &str = "tests/corrupt/no-pixi.avif"; +static IMAGE_AVIF_NO_AV1C: &str = "tests/corrupt/no-av1C.avif"; +static IMAGE_AVIF_NO_ISPE: &str = "tests/corrupt/no-ispe.avif"; +static IMAGE_AVIF_NO_ALPHA_AV1C: &str = "tests/corrupt/no-alpha-av1C.avif"; +static IMAGE_AVIF_NO_ALPHA_PIXI: &str = "tests/corrupt/no-pixi-for-alpha.avif"; +static IMAGE_AVIF_AV1C_MISSING_ESSENTIAL: &str = "tests/av1C-missing-essential.avif"; +static IMAGE_AVIF_A1LX_MARKED_ESSENTIAL: &str = "tests/corrupt/a1lx-marked-essential.avif"; +static IMAGE_AVIF_A1OP_MISSING_ESSENTIAL: &str = "tests/corrupt/a1op-missing-essential.avif"; +static IMAGE_AVIF_IMIR_MISSING_ESSENTIAL: &str = "tests/imir-missing-essential.avif"; +static IMAGE_AVIF_IROT_MISSING_ESSENTIAL: &str = "tests/irot-missing-essential.avif"; +static IMAGE_AVIF_LSEL_MISSING_ESSENTIAL: &str = "tests/corrupt/lsel-missing-essential.avif"; +static IMAGE_AVIF_CLAP_MISSING_ESSENTIAL: &str = "tests/clap-missing-essential.avif"; +static AVIF_TEST_DIRS: &[&str] = &["tests", "av1-avif/testFiles", "link-u-avif-sample-images"]; + +// These files are +// av1-avif/testFiles/Apple/multilayer_examples/animals_00_multilayer_a1op.avif +// av1-avif/testFiles/Apple/multilayer_examples/animals_00_multilayer_a1lx.avif +// av1-avif/testFiles/Apple/multilayer_examples/animals_00_multilayer_lsel.avif +// respectively, but with https://github.com/AOMediaCodec/av1-avif/issues/174 fixed +static AVIF_A1OP: &str = "tests/a1op.avif"; +static AVIF_A1LX: &str = "tests/a1lx.avif"; +static AVIF_LSEL: &str = "tests/lsel.avif"; + +static AVIF_CLAP: &str = "tests/clap-basic-1_3x3-to-1x1.avif"; +static AVIF_GRID: &str = "av1-avif/testFiles/Microsoft/Summer_in_Tomsk_720p_5x4_grid.avif"; +static AVIF_GRID_A1LX: &str = + "av1-avif/testFiles/Apple/multilayer_examples/animals_00_multilayer_grid_a1lx.avif"; +static AVIF_AVIS_MAJOR_NO_PITM: &str = + "av1-avif/testFiles/Netflix/avis/Chimera-AV1-10bit-480x270.avif"; +/// This is av1-avif/testFiles/Netflix/avis/alpha_video.avif +/// but with https://github.com/AOMediaCodec/av1-avif/issues/177 fixed +static AVIF_AVIS_MAJOR_WITH_PITM_AND_ALPHA: &str = "tests/alpha_video_fixed.avif"; +static AVIF_AVIS_MAJOR_NO_MOOV: &str = "tests/corrupt/alpha_video_moov_is_moop.avif"; +static AVIF_NO_PIXI_IMAGES: &[&str] = &[IMAGE_AVIF_NO_PIXI, IMAGE_AVIF_NO_ALPHA_PIXI]; +static AVIF_UNSUPPORTED_IMAGES: &[&str] = &[ + AVIF_A1LX, + AVIF_A1OP, + AVIF_CLAP, + IMAGE_AVIF_CLAP_MISSING_ESSENTIAL, + AVIF_GRID, + AVIF_GRID_A1LX, + AVIF_LSEL, + AVIF_AVIS_MAJOR_NO_PITM, + AVIF_AVIS_MAJOR_WITH_PITM_AND_ALPHA, + "av1-avif/testFiles/Apple/multilayer_examples/animals_00_multilayer_a1lx.avif", + "av1-avif/testFiles/Apple/multilayer_examples/animals_00_multilayer_a1op.avif", + "av1-avif/testFiles/Apple/multilayer_examples/animals_00_multilayer_a1op_lsel.avif", + "av1-avif/testFiles/Apple/multilayer_examples/animals_00_multilayer_lsel.avif", + "av1-avif/testFiles/Apple/multilayer_examples/animals_00_multilayer_grid_lsel.avif", + "av1-avif/testFiles/Link-U/kimono.crop.avif", + "av1-avif/testFiles/Link-U/kimono.mirror-vertical.rotate270.crop.avif", + "av1-avif/testFiles/Microsoft/Chimera_10bit_cropped_to_1920x1008.avif", + "av1-avif/testFiles/Microsoft/Chimera_10bit_cropped_to_1920x1008_with_HDR_metadata.avif", + "av1-avif/testFiles/Microsoft/Chimera_8bit_cropped_480x256.avif", + "av1-avif/testFiles/Netflix/avis/alpha_video.avif", + "av1-avif/testFiles/Xiph/abandoned_filmgrain.avif", + "av1-avif/testFiles/Xiph/fruits_2layer_thumbsize.avif", + "av1-avif/testFiles/Xiph/quebec_3layer_op2.avif", + "av1-avif/testFiles/Xiph/tiger_3layer_1res.avif", + "av1-avif/testFiles/Xiph/tiger_3layer_3res.avif", + "link-u-avif-sample-images/kimono.crop.avif", + "link-u-avif-sample-images/kimono.mirror-vertical.rotate270.crop.avif", + "link-u-avif-sample-images/star-10bpc-with-alpha.avifs", + "link-u-avif-sample-images/star-10bpc.avifs", + "link-u-avif-sample-images/star-12bpc-with-alpha.avifs", + "link-u-avif-sample-images/star-12bpc.avifs", + "link-u-avif-sample-images/star-8bpc-with-alpha.avifs", + "link-u-avif-sample-images/star-8bpc.avifs", +]; +/// See https://github.com/AOMediaCodec/av1-avif/issues/150 +/// https://github.com/AOMediaCodec/av1-avif/issues/174 +/// and https://github.com/AOMediaCodec/av1-avif/issues/177 +// TODO: make this into a map of expected errors? +static AV1_AVIF_CORRUPT_IMAGES: &[&str] = &[ + "link-u-avif-sample-images/plum-blossom-large.profile0.10bpc.yuv420.alpha-full.avif", + "link-u-avif-sample-images/plum-blossom-large.profile0.10bpc.yuv420.alpha-full.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-large.profile0.10bpc.yuv420.alpha-limited.avif", + "link-u-avif-sample-images/plum-blossom-large.profile0.10bpc.yuv420.alpha-limited.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-large.profile0.8bpc.yuv420.alpha-full.avif", + "link-u-avif-sample-images/plum-blossom-large.profile0.8bpc.yuv420.alpha-full.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-large.profile0.8bpc.yuv420.alpha-limited.avif", + "link-u-avif-sample-images/plum-blossom-large.profile0.8bpc.yuv420.alpha-limited.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-large.profile1.10bpc.yuv444.alpha-full.avif", + "link-u-avif-sample-images/plum-blossom-large.profile1.10bpc.yuv444.alpha-limited.avif", + "link-u-avif-sample-images/plum-blossom-large.profile1.8bpc.yuv444.alpha-full.avif", + "link-u-avif-sample-images/plum-blossom-large.profile1.8bpc.yuv444.alpha-limited.avif", + "link-u-avif-sample-images/plum-blossom-large.profile2.10bpc.yuv422.alpha-full.avif", + "link-u-avif-sample-images/plum-blossom-large.profile2.10bpc.yuv422.alpha-full.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-large.profile2.10bpc.yuv422.alpha-limited.avif", + "link-u-avif-sample-images/plum-blossom-large.profile2.10bpc.yuv422.alpha-limited.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-large.profile2.12bpc.yuv420.alpha-full.avif", + "link-u-avif-sample-images/plum-blossom-large.profile2.12bpc.yuv420.alpha-full.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-large.profile2.12bpc.yuv420.alpha-limited.avif", + "link-u-avif-sample-images/plum-blossom-large.profile2.12bpc.yuv420.alpha-limited.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-large.profile2.12bpc.yuv422.alpha-full.avif", + "link-u-avif-sample-images/plum-blossom-large.profile2.12bpc.yuv422.alpha-full.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-large.profile2.12bpc.yuv422.alpha-limited.avif", + "link-u-avif-sample-images/plum-blossom-large.profile2.12bpc.yuv422.alpha-limited.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-large.profile2.12bpc.yuv444.alpha-full.avif", + "link-u-avif-sample-images/plum-blossom-large.profile2.12bpc.yuv444.alpha-full.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-large.profile2.12bpc.yuv444.alpha-limited.avif", + "link-u-avif-sample-images/plum-blossom-large.profile2.12bpc.yuv444.alpha-limited.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-large.profile2.8bpc.yuv422.alpha-full.avif", + "link-u-avif-sample-images/plum-blossom-large.profile2.8bpc.yuv422.alpha-full.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-large.profile2.8bpc.yuv422.alpha-limited.avif", + "link-u-avif-sample-images/plum-blossom-large.profile2.8bpc.yuv422.alpha-limited.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-small.profile0.10bpc.yuv420.alpha-full.avif", + "link-u-avif-sample-images/plum-blossom-small.profile0.10bpc.yuv420.alpha-full.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-small.profile0.10bpc.yuv420.alpha-limited.avif", + "link-u-avif-sample-images/plum-blossom-small.profile0.10bpc.yuv420.alpha-limited.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-small.profile0.8bpc.yuv420.alpha-full.avif", + "link-u-avif-sample-images/plum-blossom-small.profile0.8bpc.yuv420.alpha-full.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-small.profile0.8bpc.yuv420.alpha-limited.avif", + "link-u-avif-sample-images/plum-blossom-small.profile0.8bpc.yuv420.alpha-limited.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-small.profile1.10bpc.yuv444.alpha-full.avif", + "link-u-avif-sample-images/plum-blossom-small.profile1.10bpc.yuv444.alpha-limited.avif", + "link-u-avif-sample-images/plum-blossom-small.profile1.8bpc.yuv444.alpha-full.avif", + "link-u-avif-sample-images/plum-blossom-small.profile1.8bpc.yuv444.alpha-limited.avif", + "link-u-avif-sample-images/plum-blossom-small.profile2.10bpc.yuv422.alpha-full.avif", + "link-u-avif-sample-images/plum-blossom-small.profile2.10bpc.yuv422.alpha-full.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-small.profile2.10bpc.yuv422.alpha-limited.avif", + "link-u-avif-sample-images/plum-blossom-small.profile2.10bpc.yuv422.alpha-limited.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-small.profile2.12bpc.yuv420.alpha-full.avif", + "link-u-avif-sample-images/plum-blossom-small.profile2.12bpc.yuv420.alpha-full.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-small.profile2.12bpc.yuv420.alpha-limited.avif", + "link-u-avif-sample-images/plum-blossom-small.profile2.12bpc.yuv420.alpha-limited.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-small.profile2.12bpc.yuv422.alpha-full.avif", + "link-u-avif-sample-images/plum-blossom-small.profile2.12bpc.yuv422.alpha-full.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-small.profile2.12bpc.yuv422.alpha-limited.avif", + "link-u-avif-sample-images/plum-blossom-small.profile2.12bpc.yuv422.alpha-limited.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-small.profile2.12bpc.yuv444.alpha-full.avif", + "link-u-avif-sample-images/plum-blossom-small.profile2.12bpc.yuv444.alpha-full.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-small.profile2.12bpc.yuv444.alpha-limited.avif", + "link-u-avif-sample-images/plum-blossom-small.profile2.12bpc.yuv444.alpha-limited.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-small.profile2.8bpc.yuv422.alpha-full.avif", + "link-u-avif-sample-images/plum-blossom-small.profile2.8bpc.yuv422.alpha-full.monochrome.avif", + "link-u-avif-sample-images/plum-blossom-small.profile2.8bpc.yuv422.alpha-limited.avif", + "link-u-avif-sample-images/plum-blossom-small.profile2.8bpc.yuv422.alpha-limited.monochrome.avif", +]; +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 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")] +static AUDIO_AMRNB_3GP: &str = "tests/amr_nb_1f.3gp"; +// The 1 frame AMR-WB 3gp file can be generated by ffmpeg with command +// "ffmpeg -i [input file] -f 3gp -acodec amr_wb -ar 16000 -ac 1 -frames:a 1 -vn output.3gp" +#[cfg(feature = "3gpp")] +static AUDIO_AMRWB_3GP: &str = "tests/amr_wb_1f.3gp"; +#[cfg(feature = "mp4v")] +// The 1 frame mp4v mp4 file can be generated by ffmpeg with command +// "ffmpeg -i [input file] -f mp4 -c:v mpeg4 -vf scale=176x144 -frames:v 1 -an output.mp4" +static VIDEO_MP4V_MP4: &str = "tests/bbb_sunflower_QCIF_30fps_mp4v_noaudio_1f.mp4"; + +// Adapted from https://github.com/GuillaumeGomez/audio-video-metadata/blob/9dff40f565af71d5502e03a2e78ae63df95cfd40/src/metadata.rs#L53 +#[test] +fn public_api() { + let mut fd = File::open(MINI_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"); + assert_eq!(context.timescale, Some(mp4::MediaTimeScale(1000))); + for track in context.tracks { + match track.track_type { + mp4::TrackType::Video => { + // track part + assert_eq!(track.duration, Some(mp4::TrackScaledTime(512, 0))); + assert_eq!(track.empty_duration, Some(mp4::MediaScaledTime(0))); + assert_eq!(track.media_time, Some(mp4::TrackScaledTime(0, 0))); + assert_eq!(track.timescale, Some(mp4::TrackTimeScale(12800, 0))); + + // track.tkhd part + let tkhd = track.tkhd.unwrap(); + assert!(!tkhd.disabled); + assert_eq!(tkhd.duration, 40); + assert_eq!(tkhd.width, 20_971_520); + assert_eq!(tkhd.height, 15_728_640); + + // track.stsd part + let stsd = track.stsd.expect("expected an stsd"); + let v = match stsd.descriptions.first().expect("expected a SampleEntry") { + mp4::SampleEntry::Video(v) => v, + _ => panic!("expected a VideoSampleEntry"), + }; + assert_eq!(v.width, 320); + assert_eq!(v.height, 240); + assert_eq!( + match v.codec_specific { + mp4::VideoCodecSpecific::AVCConfig(ref avc) => { + assert!(!avc.is_empty()); + "AVC" + } + mp4::VideoCodecSpecific::VPxConfig(ref vpx) => { + // We don't enter in here, we just check if fields are public. + assert!(vpx.bit_depth > 0); + assert!(vpx.colour_primaries > 0); + assert!(vpx.chroma_subsampling > 0); + assert!(!vpx.codec_init.is_empty()); + "VPx" + } + mp4::VideoCodecSpecific::ESDSConfig(ref mp4v) => { + assert!(!mp4v.is_empty()); + "MP4V" + } + mp4::VideoCodecSpecific::AV1Config(ref _av1c) => { + "AV1" + } + mp4::VideoCodecSpecific::H263Config(ref _h263) => { + "H263" + } + }, + "AVC" + ); + } + mp4::TrackType::Audio => { + // track part + assert_eq!(track.duration, Some(mp4::TrackScaledTime(2944, 1))); + assert_eq!(track.empty_duration, Some(mp4::MediaScaledTime(0))); + assert_eq!(track.media_time, Some(mp4::TrackScaledTime(1024, 1))); + assert_eq!(track.timescale, Some(mp4::TrackTimeScale(48000, 1))); + + // track.tkhd part + let tkhd = track.tkhd.unwrap(); + assert!(!tkhd.disabled); + assert_eq!(tkhd.duration, 62); + assert_eq!(tkhd.width, 0); + assert_eq!(tkhd.height, 0); + + // track.stsd part + let stsd = track.stsd.expect("expected an stsd"); + let a = match stsd.descriptions.first().expect("expected a SampleEntry") { + mp4::SampleEntry::Audio(a) => a, + _ => panic!("expected a AudioSampleEntry"), + }; + assert_eq!( + match a.codec_specific { + mp4::AudioCodecSpecific::ES_Descriptor(ref esds) => { + assert_eq!(esds.audio_codec, mp4::CodecType::AAC); + assert_eq!(esds.audio_sample_rate.unwrap(), 48000); + assert_eq!(esds.audio_object_type.unwrap(), 2); + "ES" + } + mp4::AudioCodecSpecific::FLACSpecificBox(ref flac) => { + // STREAMINFO block must be present and first. + assert!(!flac.blocks.is_empty()); + assert_eq!(flac.blocks[0].block_type, 0); + assert_eq!(flac.blocks[0].data.len(), 34); + "FLAC" + } + mp4::AudioCodecSpecific::OpusSpecificBox(ref opus) => { + // We don't enter in here, we just check if fields are public. + assert!(opus.version > 0); + "Opus" + } + mp4::AudioCodecSpecific::ALACSpecificBox(ref alac) => { + assert!(alac.data.len() == 24 || alac.data.len() == 48); + "ALAC" + } + mp4::AudioCodecSpecific::MP3 => { + "MP3" + } + mp4::AudioCodecSpecific::LPCM => { + "LPCM" + } + #[cfg(feature = "3gpp")] + mp4::AudioCodecSpecific::AMRSpecificBox(_) => { + "AMR" + } + }, + "ES" + ); + assert!(a.samplesize > 0); + assert!(a.samplerate > 0.0); + } + mp4::TrackType::Metadata | mp4::TrackType::Unknown => {} + } + } +} + +#[test] +fn public_metadata() { + let mut fd = File::open(MINI_MP4_WITH_METADATA).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"); + let udta = context + .userdata + .expect("didn't find udta") + .expect("failed to parse udta"); + let meta = udta.meta.expect("didn't find meta"); + assert_eq!(meta.title.unwrap(), "Title"); + assert_eq!(meta.artist.unwrap(), "Artist"); + assert_eq!(meta.album_artist.unwrap(), "Album Artist"); + assert_eq!(meta.comment.unwrap(), "Comments"); + assert_eq!(meta.year.unwrap(), "2019"); + assert_eq!( + meta.genre.unwrap(), + mp4::Genre::CustomGenre("Custom Genre".try_into().unwrap()) + ); + assert_eq!(meta.encoder.unwrap(), "Lavf56.40.101"); + assert_eq!(meta.encoded_by.unwrap(), "Encoded-by"); + assert_eq!(meta.copyright.unwrap(), "Copyright"); + assert_eq!(meta.track_number.unwrap(), 3); + assert_eq!(meta.total_tracks.unwrap(), 6); + assert_eq!(meta.disc_number.unwrap(), 5); + assert_eq!(meta.total_discs.unwrap(), 10); + assert_eq!(meta.beats_per_minute.unwrap(), 128); + assert_eq!(meta.composer.unwrap(), "Composer"); + assert!(meta.compilation.unwrap()); + assert!(!meta.gapless_playback.unwrap()); + assert!(!meta.podcast.unwrap()); + assert_eq!(meta.advisory.unwrap(), mp4::AdvisoryRating::Clean); + assert_eq!(meta.media_type.unwrap(), mp4::MediaType::Normal); + assert_eq!(meta.rating.unwrap(), "50"); + assert_eq!(meta.grouping.unwrap(), "Grouping"); + assert_eq!(meta.category.unwrap(), "Category"); + assert_eq!(meta.keyword.unwrap(), "Keyword"); + assert_eq!(meta.description.unwrap(), "Description"); + assert_eq!(meta.lyrics.unwrap(), "Lyrics"); + assert_eq!(meta.long_description.unwrap(), "Long Description"); + assert_eq!(meta.tv_episode_name.unwrap(), "Episode Name"); + assert_eq!(meta.tv_network_name.unwrap(), "Network Name"); + assert_eq!(meta.tv_episode_number.unwrap(), 15); + assert_eq!(meta.tv_season.unwrap(), 10); + assert_eq!(meta.tv_show_name.unwrap(), "Show Name"); + assert!(meta.hd_video.unwrap()); + assert_eq!(meta.owner.unwrap(), "Owner"); + assert_eq!(meta.sort_name.unwrap(), "Sort Name"); + assert_eq!(meta.sort_album.unwrap(), "Sort Album"); + assert_eq!(meta.sort_artist.unwrap(), "Sort Artist"); + assert_eq!(meta.sort_album_artist.unwrap(), "Sort Album Artist"); + assert_eq!(meta.sort_composer.unwrap(), "Sort Composer"); + + // Check for valid JPEG header + let covers = meta.cover_art.unwrap(); + let cover = &covers[0]; + let mut bytes = [0u8; 4]; + bytes[0] = cover[0]; + bytes[1] = cover[1]; + bytes[2] = cover[2]; + assert_eq!(u32::from_le_bytes(bytes), 0x00ff_d8ff); +} + +#[test] +fn public_metadata_gnre() { + let mut fd = File::open(MINI_MP4_WITH_METADATA_STD_GENRE).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"); + let udta = context + .userdata + .expect("didn't find udta") + .expect("failed to parse udta"); + let meta = udta.meta.expect("didn't find meta"); + assert_eq!(meta.title.unwrap(), "Title"); + assert_eq!(meta.artist.unwrap(), "Artist"); + assert_eq!(meta.album_artist.unwrap(), "Album Artist"); + assert_eq!(meta.comment.unwrap(), "Comments"); + assert_eq!(meta.year.unwrap(), "2019"); + assert_eq!(meta.genre.unwrap(), mp4::Genre::StandardGenre(3)); + assert_eq!(meta.encoder.unwrap(), "Lavf56.40.101"); + assert_eq!(meta.encoded_by.unwrap(), "Encoded-by"); + assert_eq!(meta.copyright.unwrap(), "Copyright"); + assert_eq!(meta.track_number.unwrap(), 3); + assert_eq!(meta.total_tracks.unwrap(), 6); + assert_eq!(meta.disc_number.unwrap(), 5); + assert_eq!(meta.total_discs.unwrap(), 10); + assert_eq!(meta.beats_per_minute.unwrap(), 128); + assert_eq!(meta.composer.unwrap(), "Composer"); + assert!(meta.compilation.unwrap()); + assert!(!meta.gapless_playback.unwrap()); + assert!(!meta.podcast.unwrap()); + assert_eq!(meta.advisory.unwrap(), mp4::AdvisoryRating::Clean); + assert_eq!(meta.media_type.unwrap(), mp4::MediaType::Normal); + assert_eq!(meta.rating.unwrap(), "50"); + assert_eq!(meta.grouping.unwrap(), "Grouping"); + assert_eq!(meta.category.unwrap(), "Category"); + assert_eq!(meta.keyword.unwrap(), "Keyword"); + assert_eq!(meta.description.unwrap(), "Description"); + assert_eq!(meta.lyrics.unwrap(), "Lyrics"); + assert_eq!(meta.long_description.unwrap(), "Long Description"); + assert_eq!(meta.tv_episode_name.unwrap(), "Episode Name"); + assert_eq!(meta.tv_network_name.unwrap(), "Network Name"); + assert_eq!(meta.tv_episode_number.unwrap(), 15); + assert_eq!(meta.tv_season.unwrap(), 10); + assert_eq!(meta.tv_show_name.unwrap(), "Show Name"); + assert!(meta.hd_video.unwrap()); + assert_eq!(meta.owner.unwrap(), "Owner"); + assert_eq!(meta.sort_name.unwrap(), "Sort Name"); + assert_eq!(meta.sort_album.unwrap(), "Sort Album"); + assert_eq!(meta.sort_artist.unwrap(), "Sort Artist"); + assert_eq!(meta.sort_album_artist.unwrap(), "Sort Album Artist"); + assert_eq!(meta.sort_composer.unwrap(), "Sort Composer"); + + // Check for valid JPEG header + let covers = meta.cover_art.unwrap(); + let cover = &covers[0]; + let mut bytes = [0u8; 4]; + bytes[0] = cover[0]; + bytes[1] = cover[1]; + bytes[2] = cover[2]; + assert_eq!(u32::from_le_bytes(bytes), 0x00ff_d8ff); +} + +#[test] +fn public_invalid_metadata() { + // Test that reading userdata containing invalid metadata is not fatal to parsing and that + // expected values are still found. + let mut fd = File::open(VIDEO_INVALID_USERDATA).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"); + // Should have userdata. + assert!(context.userdata.is_some()); + // But it should contain an error. + assert!(context.userdata.unwrap().is_err()); + // Smoke test that other data has been parsed. Don't check everything, just make sure some + // values are as expected. + assert_eq!(context.tracks.len(), 2); + for track in context.tracks { + match track.track_type { + mp4::TrackType::Video => { + // Check some of the values in the video tkhd. + let tkhd = track.tkhd.unwrap(); + assert!(!tkhd.disabled); + assert_eq!(tkhd.duration, 231232); + assert_eq!(tkhd.width, 83_886_080); + assert_eq!(tkhd.height, 47_185_920); + } + mp4::TrackType::Audio => { + // Check some of the values in the audio tkhd. + let tkhd = track.tkhd.unwrap(); + assert!(!tkhd.disabled); + assert_eq!(tkhd.duration, 231338); + assert_eq!(tkhd.width, 0); + assert_eq!(tkhd.height, 0); + } + _ => panic!("File should not contain other tracks."), + } + } +} + +#[test] +fn public_audio_tenc() { + let kid = vec![ + 0x7e, 0x57, 0x1d, 0x04, 0x7e, 0x57, 0x1d, 0x04, 0x7e, 0x57, 0x1d, 0x04, 0x7e, 0x57, 0x1d, + 0x04, + ]; + + 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"); + + 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 a = match stsd.descriptions.first().expect("expected a SampleEntry") { + mp4::SampleEntry::Audio(a) => a, + _ => panic!("expected a AudioSampleEntry"), + }; + assert_eq!(a.codec_type, mp4::CodecType::EncryptedAudio); + match a.protection_info.iter().find(|sinf| sinf.tenc.is_some()) { + Some(p) => { + assert_eq!(p.original_format, b"mp4a"); + if let Some(ref schm) = p.scheme_type { + assert_eq!(schm.scheme_type, b"cenc"); + } else { + panic!("Expected scheme type info"); + } + if let Some(ref tenc) = p.tenc { + assert!(tenc.is_encrypted > 0); + assert_eq!(tenc.iv_size, 16); + assert_eq!(tenc.kid, kid); + assert_eq!(tenc.crypt_byte_block_count, None); + assert_eq!(tenc.skip_byte_block_count, None); + assert_eq!(tenc.constant_iv, None); + } else { + panic!("Invalid test condition"); + } + } + _ => { + panic!("Invalid test condition"); + } + } + } +} + +#[test] +fn public_video_cenc() { + 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, 0x03, 0x7e, 0x57, 0x1d, 0x03, 0x7e, 0x57, 0x1d, 0x03, 0x7e, 0x57, 0x1d, + 0x11, + ]; + + 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, 0x03, 0x7e, 0x57, 0x1d, 0x03, 0x7e, 0x57, 0x1d, 0x03, 0x7e, + 0x57, 0x1d, 0x11, 0x00, 0x00, 0x00, 0x00, + ]; + + 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"); + + 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::EncryptedVideo); + match v.protection_info.iter().find(|sinf| sinf.tenc.is_some()) { + Some(p) => { + assert_eq!(p.original_format, b"avc1"); + if let Some(ref schm) = p.scheme_type { + assert_eq!(schm.scheme_type, b"cenc"); + } else { + panic!("Expected scheme type info"); + } + if let Some(ref tenc) = p.tenc { + assert!(tenc.is_encrypted > 0); + assert_eq!(tenc.iv_size, 16); + assert_eq!(tenc.kid, kid); + assert_eq!(tenc.crypt_byte_block_count, None); + assert_eq!(tenc.skip_byte_block_count, None); + assert_eq!(tenc.constant_iv, None); + } else { + panic!("Invalid test condition"); + } + } + _ => { + panic!("Invalid test condition"); + } + } + } + + 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_audio_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 context = mp4::read_mp4(&mut c).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.original_format, b"mp4a"); + if let Some(ref schm) = p.scheme_type { + assert_eq!(schm.scheme_type, b"cbcs"); + } else { + panic!("Expected scheme type info"); + } + 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().into())); + } else { + panic!("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 context = mp4::read_mp4(&mut c).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.original_format, b"avc1"); + if let Some(ref schm) = p.scheme_type { + assert_eq!(schm.scheme_type, b"cbcs"); + } else { + panic!("Expected scheme type info"); + } + 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().into())); + } else { + panic!("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"); + 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 { + // track part + assert_eq!(track.duration, Some(mp4::TrackScaledTime(512, 0))); + assert_eq!(track.empty_duration, Some(mp4::MediaScaledTime(0))); + assert_eq!(track.media_time, Some(mp4::TrackScaledTime(0, 0))); + assert_eq!(track.timescale, Some(mp4::TrackTimeScale(12288, 0))); + + // track.tkhd part + let tkhd = track.tkhd.unwrap(); + assert!(!tkhd.disabled); + assert_eq!(tkhd.duration, 42); + assert_eq!(tkhd.width, 4_194_304); + assert_eq!(tkhd.height, 4_194_304); + + // track.stsd part + 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::AV1); + assert_eq!(v.width, 64); + assert_eq!(v.height, 64); + + match v.codec_specific { + mp4::VideoCodecSpecific::AV1Config(ref av1c) => { + // TODO: test av1c fields once ffmpeg is updated + assert_eq!(av1c.profile, 0); + assert_eq!(av1c.level, 0); + assert_eq!(av1c.tier, 0); + assert_eq!(av1c.bit_depth, 8); + assert!(!av1c.monochrome); + assert_eq!(av1c.chroma_subsampling_x, 1); + assert_eq!(av1c.chroma_subsampling_y, 1); + assert_eq!(av1c.chroma_sample_position, 0); + assert!(!av1c.initial_presentation_delay_present); + assert_eq!(av1c.initial_presentation_delay_minus_one, 0); + } + _ => panic!("Invalid test condition"), + } + } +} + +#[test] +fn public_mp4_bug_1185230() { + let input = &mut File::open("tests/test_case_1185230.mp4").expect("Unknown file"); + let context = mp4::read_mp4(input).expect("read_mp4 failed"); + let number_video_tracks = context + .tracks + .iter() + .filter(|t| t.track_type == mp4::TrackType::Video) + .count(); + let number_audio_tracks = context + .tracks + .iter() + .filter(|t| t.track_type == mp4::TrackType::Audio) + .count(); + assert_eq!(number_video_tracks, 2); + assert_eq!(number_audio_tracks, 2); +} + +#[test] +fn public_mp4_ctts_overflow() { + let input = &mut File::open("tests/clusterfuzz-testcase-minimized-mp4-6093954524250112") + .expect("Unknown file"); + assert_invalid_data(mp4::read_mp4(input), "insufficient data in 'ctts' box"); +} + +#[test] +fn public_avif_primary_item() { + let input = &mut File::open(IMAGE_AVIF).expect("Unknown file"); + let context = mp4::read_avif(input, ParseStrictness::Normal).expect("read_avif failed"); + assert_eq!( + context.primary_item_coded_data().unwrap(), + [ + 0x12, 0x00, 0x0A, 0x07, 0x38, 0x00, 0x06, 0x90, 0x20, 0x20, 0x69, 0x32, 0x0C, 0x16, + 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x79, 0x4C, 0xD2, 0x02 + ] + ); +} + +#[test] +fn public_avif_primary_item_split_extents() { + let input = &mut File::open(IMAGE_AVIF_EXTENTS).expect("Unknown file"); + let context = mp4::read_avif(input, ParseStrictness::Normal).expect("read_avif failed"); + assert_eq!(context.primary_item_coded_data().unwrap().len(), 52); +} + +#[test] +fn public_avif_alpha_item() { + for_strictness_result(IMAGE_AVIF_ALPHA, |_strictness, result| { + assert!(result.is_ok()); + }); +} + +#[test] +fn public_avif_alpha_non_premultiplied() { + for_strictness_result(IMAGE_AVIF_ALPHA, |_strictness, result| { + let context = result.expect("read_avif failed"); + assert!(context.primary_item_coded_data().is_some()); + assert!(context.alpha_item_coded_data().is_some()); + assert!(!context.premultiplied_alpha); + }); +} + +#[test] +fn public_avif_alpha_premultiplied() { + for_strictness_result(IMAGE_AVIF_ALPHA_PREMULTIPLIED, |_strictness, result| { + let context = result.expect("read_avif failed"); + assert!(context.primary_item_coded_data().is_some()); + assert!(context.alpha_item_coded_data().is_some()); + assert!(context.premultiplied_alpha); + }); +} + +#[test] +fn public_avif_bug_1655846() { + let input = &mut File::open(IMAGE_AVIF_CORRUPT).expect("Unknown file"); + assert!(mp4::read_avif(input, ParseStrictness::Normal).is_err()); +} + +#[test] +fn public_avif_bug_1661347() { + let input = &mut File::open(IMAGE_AVIF_CORRUPT_2).expect("Unknown file"); + assert!(mp4::read_avif(input, ParseStrictness::Normal).is_err()); +} + +fn assert_invalid_data<T: std::fmt::Debug>(result: mp4::Result<T>, expected_msg: &str) { + match result { + Err(Error::InvalidData(msg)) if msg == expected_msg => {} + Err(Error::InvalidData(msg)) if msg != expected_msg => { + panic!( + "Error message mismatch\nExpected: {}\nFound: {}", + expected_msg, msg + ); + } + r => panic!( + "Expected Err(Error::InvalidData({:?}), found {:?}", + expected_msg, r + ), + } +} + +fn for_strictness_result( + path: &str, + check: impl Fn(ParseStrictness, mp4::Result<mp4::AvifContext>), +) { + let input = &mut File::open(path).expect("Unknown file"); + + for strictness in [ + ParseStrictness::Permissive, + ParseStrictness::Normal, + ParseStrictness::Strict, + ] { + input.seek(SeekFrom::Start(0)).expect("rewind failed"); + check(strictness, mp4::read_avif(input, strictness)); + } +} + +/// Check that input generates the expected error only in strict parsing mode +fn assert_avif_should(path: &str, expected_msg: &str) { + let input = &mut File::open(path).expect("Unknown file"); + assert_invalid_data(mp4::read_avif(input, ParseStrictness::Strict), expected_msg); + input.seek(SeekFrom::Start(0)).expect("rewind failed"); + mp4::read_avif(input, ParseStrictness::Normal).expect("ParseStrictness::Normal failed"); + input.seek(SeekFrom::Start(0)).expect("rewind failed"); + mp4::read_avif(input, ParseStrictness::Permissive).expect("ParseStrictness::Permissive failed"); +} + +/// Check that input generates the expected error only in strict parsing mode +// TODO: replace assert_avif_should +fn assert_avif_should2(path: &str, expected: Status) { + for_strictness_result(path, |strictness, result| { + if strictness == ParseStrictness::Strict { + assert_eq!(expected, Status::from(result)); + } else { + assert!(result.is_ok()); + } + }) +} + +/// Check that input generates the expected error unless in permissive parsing mode +fn assert_avif_shall(path: &str, expected_msg: &str) { + let input = &mut File::open(path).expect("Unknown file"); + assert_invalid_data(mp4::read_avif(input, ParseStrictness::Strict), expected_msg); + input.seek(SeekFrom::Start(0)).expect("rewind failed"); + assert_invalid_data(mp4::read_avif(input, ParseStrictness::Normal), expected_msg); + input.seek(SeekFrom::Start(0)).expect("rewind failed"); + mp4::read_avif(input, ParseStrictness::Permissive).expect("ParseStrictness::Permissive failed"); +} + +// TODO: replace assert_avif_shall +fn assert_avif_shall2(path: &str, expected: Status) { + for_strictness_result(path, |strictness, result| { + if strictness == ParseStrictness::Permissive { + assert!(result.is_ok()); + } else { + assert_eq!(expected, Status::from(result)); + } + }) +} + +// Technically all transforms shall be essential, but this appears likely to change +// so we only enforce it in strict parsing +// See https://github.com/mozilla/mp4parse-rust/issues/284 + +#[test] +fn public_avif_av1c_missing_essential() { + assert_avif_should2(IMAGE_AVIF_AV1C_MISSING_ESSENTIAL, Status::TxformNoEssential); +} + +#[test] +fn public_avif_clap_missing_essential() { + for_strictness_result(IMAGE_AVIF_CLAP_MISSING_ESSENTIAL, |strictness, result| { + if strictness == ParseStrictness::Strict { + assert_eq!(Status::TxformNoEssential, Status::from(result)); + } else { + assert_unsupported_nonfatal(&result, mp4::Feature::Clap); + } + }) +} + +#[test] +fn public_avif_imir_missing_essential() { + assert_avif_should2(IMAGE_AVIF_IMIR_MISSING_ESSENTIAL, Status::TxformNoEssential); +} + +#[test] +fn public_avif_irot_missing_essential() { + assert_avif_should2(IMAGE_AVIF_IROT_MISSING_ESSENTIAL, Status::TxformNoEssential); +} + +#[test] +fn public_avif_ipma_bad_version() { + let expected_msg = "The ipma version 0 should be used unless 32-bit \ + item_ID values are needed \ + per ISOBMFF (ISO 14496-12:2020 § 8.11.14.1"; + assert_avif_should(IMAGE_AVIF_IPMA_BAD_VERSION, expected_msg); +} + +#[test] +fn public_avif_ipma_bad_flags() { + let expected_msg = "Unless there are more than 127 properties in the \ + ItemPropertyContainerBox, flags should be equal to 0 \ + per ISOBMFF (ISO 14496-12:2020 § 8.11.14.1"; + assert_avif_should(IMAGE_AVIF_IPMA_BAD_FLAGS, expected_msg); +} + +#[test] +fn public_avif_ipma_duplicate_version_and_flags() { + let expected_msg = "There shall be at most one ItemPropertyAssociationbox \ + with a given pair of values of version and flags \ + per ISOBMFF (ISO 14496-12:2020 § 8.11.14.1"; + assert_avif_shall(IMAGE_AVIF_IPMA_DUPLICATE_VERSION_AND_FLAGS, expected_msg); +} + +#[test] +// TODO: convert this to a `assert_avif_shall` test to cover all `ParseStrictness` modes +// that would require crafting an input that validly uses multiple ipma boxes, +// which is kind of annoying to make pass the "should" requirements on flags and version +// as well as the "shall" requirement on duplicate version and flags +fn public_avif_ipma_duplicate_item_id() { + let expected_msg = "There shall be at most one occurrence of a given item_ID, \ + in the set of ItemPropertyAssociationBox boxes \ + per ISOBMFF (ISO 14496-12:2020) § 8.11.14.1"; + let input = &mut File::open(IMAGE_AVIF_IPMA_DUPLICATE_ITEM_ID).expect("Unknown file"); + assert_invalid_data( + mp4::read_avif(input, ParseStrictness::Permissive), + expected_msg, + ) +} + +#[test] +fn public_avif_ipma_invalid_property_index() { + let expected_msg = "Invalid property index in ipma"; + assert_avif_shall(IMAGE_AVIF_IPMA_INVALID_PROPERTY_INDEX, expected_msg); +} + +#[test] +fn public_avif_hdlr_first_in_meta() { + let expected_msg = "The HandlerBox shall be the first contained box within \ + the MetaBox \ + per MIAF (ISO 23000-22:2019) § 7.2.1.5"; + assert_avif_shall(IMAGE_AVIF_NO_HDLR, expected_msg); + assert_avif_shall(IMAGE_AVIF_HDLR_NOT_FIRST, expected_msg); +} + +#[test] +fn public_avif_hdlr_is_pict() { + let expected_msg = "The HandlerBox handler_type must be 'pict' \ + per MIAF (ISO 23000-22:2019) § 7.2.1.5"; + assert_avif_shall(IMAGE_AVIF_HDLR_NOT_PICT, expected_msg); +} + +#[test] +fn public_avif_hdlr_nonzero_reserved() { + let expected_msg = "The HandlerBox 'reserved' fields shall be 0 \ + per ISOBMFF (ISO 14496-12:2020) § 8.4.3.2"; + // This is a "should" despite the spec indicating a (somewhat ambiguous) + // requirement that this field is set to zero. + // See comments in read_hdlr + assert_avif_should(IMAGE_AVIF_HDLR_NONZERO_RESERVED, expected_msg); +} + +#[test] +fn public_avif_hdlr_multiple_nul() { + let expected_msg = "The HandlerBox 'name' field shall have a NUL byte \ + only in the final position \ + per ISOBMFF (ISO 14496-12:2020) § 8.4.3.2"; + + // This is a "should" despite the spec indicating a (somewhat ambiguous) + // requirement about extra data in boxes + // See comments in read_hdlr + assert_avif_should(IMAGE_AVIF_HDLR_MULTIPLE_NUL, expected_msg); +} + +#[test] +fn public_avif_no_mif1() { + let expected_msg = "The FileTypeBox should contain 'mif1' in the compatible_brands list \ + per MIAF (ISO 23000-22:2019) § 7.2.1.2"; + assert_avif_should(IMAGE_AVIF_NO_MIF1, expected_msg); +} + +#[test] +fn public_avif_no_pitm() { + assert_avif_shall2(IMAGE_AVIF_NO_PITM, Status::NoPrimaryItem); +} + +#[test] +fn public_avif_pixi_present_for_displayable_images() { + let expected_msg = "The pixel information property shall be associated with every image \ + that is displayable (not hidden) \ + per MIAF (ISO/IEC 23000-22:2019) specification § 7.3.6.6"; + let pixi_test = if cfg!(feature = "missing-pixi-permitted") { + assert_avif_should + } else { + assert_avif_shall + }; + + pixi_test(IMAGE_AVIF_NO_PIXI, expected_msg); + pixi_test(IMAGE_AVIF_NO_ALPHA_PIXI, expected_msg); +} + +#[test] +fn public_avif_av1c_present_for_av01() { + let expected_msg = "One AV1 Item Configuration Property (av1C) \ + is mandatory for an image item of type 'av01' \ + per AVIF specification § 2.2.1"; + assert_avif_shall(IMAGE_AVIF_NO_AV1C, expected_msg); + assert_avif_shall(IMAGE_AVIF_NO_ALPHA_AV1C, expected_msg); +} + +#[test] +fn public_avif_ispe_present() { + let expected_msg = "Missing 'ispe' property for primary item, required \ + per HEIF (ISO/IEC 23008-12:2017) § 6.5.3.1"; + assert_avif_shall(IMAGE_AVIF_NO_ISPE, expected_msg); +} + +fn assert_unsupported_nonfatal(result: &mp4::Result<mp4::AvifContext>, feature: mp4::Feature) { + match result { + Ok(context) => { + assert!( + context.unsupported_features.contains(feature), + "context.unsupported_features missing expected {:?}", + feature + ); + } + r => panic!( + "Expected Ok with unsupported_features containing {:?}, found {:?}", + feature, r + ), + } +} + +// Assert that across all strictness levels the given feature is tracked as +// being used, but unsupported. Additionally, if the feature is essential, +// assert that the primary item is not processed unless using permissive mode. +// TODO: Add similar tests for alpha +fn assert_unsupported(path: &str, feature: mp4::Feature, essential: bool) { + for_strictness_result(path, |strictness, result| { + assert_unsupported_nonfatal(&result, feature); + match result { + Ok(context) if essential => assert_eq!( + context.primary_item_coded_data().is_some(), + strictness == ParseStrictness::Permissive + ), + Ok(context) if !essential => assert!(context.primary_item_coded_data().is_some()), + _ => panic!("Expected Ok, got {:?}", result), + } + }); +} + +fn assert_unsupported_nonessential(path: &str, feature: mp4::Feature) { + assert_unsupported(path, feature, false); +} + +fn assert_unsupported_essential(path: &str, feature: mp4::Feature) { + assert_unsupported(path, feature, true); +} + +#[test] +fn public_avif_a1lx() { + assert_unsupported_nonessential(AVIF_A1LX, mp4::Feature::A1lx); +} + +#[test] +fn public_avif_a1lx_marked_essential() { + assert_avif_shall2(IMAGE_AVIF_A1LX_MARKED_ESSENTIAL, Status::A1lxEssential); +} + +#[test] +fn public_avif_a1op() { + assert_unsupported_essential(AVIF_A1OP, mp4::Feature::A1op); +} + +#[test] +fn public_avif_a1op_missing_essential() { + assert_avif_shall2(IMAGE_AVIF_A1OP_MISSING_ESSENTIAL, Status::A1opNoEssential); +} + +#[test] +fn public_avif_lsel() { + assert_unsupported_essential(AVIF_LSEL, mp4::Feature::Lsel); +} + +#[test] +fn public_avif_lsel_missing_essential() { + assert_avif_shall2(IMAGE_AVIF_LSEL_MISSING_ESSENTIAL, Status::LselNoEssential); +} + +#[test] +fn public_avif_clap() { + assert_unsupported_essential(AVIF_CLAP, mp4::Feature::Clap); +} + +#[test] +fn public_avif_grid() { + for file in &[AVIF_GRID, AVIF_GRID_A1LX] { + let input = &mut File::open(file).expect(file); + assert_unsupported_nonfatal( + &mp4::read_avif(input, ParseStrictness::Normal), + mp4::Feature::Grid, + ); + } +} + +#[test] +fn public_avis_major_no_pitm() { + let input = &mut File::open(AVIF_AVIS_MAJOR_NO_PITM).expect("Unknown file"); + match mp4::read_avif(input, ParseStrictness::Normal) { + Ok(context) => { + assert_eq!(context.major_brand, mp4::AVIS_BRAND); + assert!(context.unsupported_features.contains(mp4::Feature::Avis)); + assert!(context.primary_item_coded_data().is_none()); + } + Err(e) => panic!("Expected Ok(_), found {:?}", e), + } +} + +#[test] +fn public_avis_major_with_pitm_and_alpha() { + let input = &mut File::open(AVIF_AVIS_MAJOR_WITH_PITM_AND_ALPHA).expect("Unknown file"); + match mp4::read_avif(input, ParseStrictness::Normal) { + Ok(context) => { + assert_eq!(context.major_brand, mp4::AVIS_BRAND); + assert!(context.unsupported_features.contains(mp4::Feature::Avis)); + assert!(context.primary_item_coded_data().is_some()); + assert!(context.alpha_item_coded_data().is_some()); + } + Err(e) => panic!("Expected Ok(_), found {:?}", e), + } +} + +#[test] +fn public_avif_avis_major_no_moov() { + assert_avif_shall2(AVIF_AVIS_MAJOR_NO_MOOV, Status::NoMoov); +} + +#[test] +fn public_avif_read_samples() { + public_avif_read_samples_impl(ParseStrictness::Normal); +} + +#[test] +#[ignore] // See https://github.com/AOMediaCodec/av1-avif/issues/146 +fn public_avif_read_samples_strict() { + public_avif_read_samples_impl(ParseStrictness::Strict); +} + +fn to_canonical_paths(strs: &[&str]) -> Vec<std::path::PathBuf> { + strs.iter() + .map(std::fs::canonicalize) + .map(Result::unwrap) + .collect() +} + +fn public_avif_read_samples_impl(strictness: ParseStrictness) { + let corrupt_images = to_canonical_paths(AV1_AVIF_CORRUPT_IMAGES); + let unsupported_images = to_canonical_paths(AVIF_UNSUPPORTED_IMAGES); + let legal_no_pixi_images = if cfg!(feature = "missing-pixi-permitted") { + to_canonical_paths(AVIF_NO_PIXI_IMAGES) + } else { + vec![] + }; + for dir in AVIF_TEST_DIRS { + for entry in walkdir::WalkDir::new(dir) { + let entry = entry.expect("AVIF entry"); + let path = entry.path(); + let extension = path.extension().unwrap_or_default(); + if !path.is_file() || (extension != "avif" && extension != "avifs") { + eprintln!("Skipping {:?}", path); + continue; // Skip directories, ReadMe.txt, etc. + } + let corrupt = (path.canonicalize().unwrap().parent().unwrap() + == std::fs::canonicalize(AVIF_CORRUPT_IMAGES_DIR).unwrap() + || corrupt_images.contains(&path.canonicalize().unwrap())) + && !legal_no_pixi_images.contains(&path.canonicalize().unwrap()); + + let unsupported = unsupported_images.contains(&path.canonicalize().unwrap()); + println!( + "parsing {}{}{:?}", + if corrupt { "(corrupt) " } else { "" }, + if unsupported { "(unsupported) " } else { "" }, + path, + ); + let input = &mut File::open(path).expect("Unknow file"); + match mp4::read_avif(input, strictness) { + Ok(c) if unsupported || corrupt => { + if unsupported { + assert!(!c.unsupported_features.is_empty()); + } else { + panic!("Expected error parsing {:?}, found:\n{:?}", path, c) + } + } + Ok(c) => { + assert!( + c.unsupported_features.is_empty(), + "{:?}", + c.unsupported_features + ); + eprintln!("Successfully parsed {:?}", path) + } + Err(e) if corrupt => { + eprintln!("Expected error parsing corrupt input {:?}: {:?}", path, e) + } + Err(e) => panic!("Unexpected error parsing {:?}: {:?}", path, e), + } + } + } +} + +#[test] +fn public_video_h263() { + let mut fd = File::open(VIDEO_H263_3GP).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::H263); + assert_eq!(v.width, 176); + assert_eq!(v.height, 144); + let _codec_specific = match v.codec_specific { + mp4::VideoCodecSpecific::H263Config(_) => true, + _ => { + panic!("expected a H263Config",); + } + }; + } +} + +#[test] +#[cfg(feature = "3gpp")] +fn public_audio_amrnb() { + let mut fd = File::open(AUDIO_AMRNB_3GP).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 a = match stsd.descriptions.first().expect("expected a SampleEntry") { + mp4::SampleEntry::Audio(ref v) => v, + _ => panic!("expected a AudioSampleEntry"), + }; + assert!(a.codec_type == mp4::CodecType::AMRNB); + let _codec_specific = match a.codec_specific { + mp4::AudioCodecSpecific::AMRSpecificBox(_) => true, + _ => { + panic!("expected a AMRSpecificBox",); + } + }; + } +} + +#[test] +#[cfg(feature = "3gpp")] +fn public_audio_amrwb() { + let mut fd = File::open(AUDIO_AMRWB_3GP).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 a = match stsd.descriptions.first().expect("expected a SampleEntry") { + mp4::SampleEntry::Audio(ref v) => v, + _ => panic!("expected a AudioSampleEntry"), + }; + assert!(a.codec_type == mp4::CodecType::AMRWB); + let _codec_specific = match a.codec_specific { + mp4::AudioCodecSpecific::AMRSpecificBox(_) => true, + _ => { + panic!("expected a AMRSpecificBox",); + } + }; + } +} + +#[test] +#[cfg(feature = "mp4v")] +fn public_video_mp4v() { + let mut fd = File::open(VIDEO_MP4V_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::MP4V); + assert_eq!(v.width, 176); + assert_eq!(v.height, 144); + let _codec_specific = match v.codec_specific { + mp4::VideoCodecSpecific::ESDSConfig(_) => true, + _ => { + panic!("expected a ESDSConfig",); + } + }; + } +} diff --git a/third_party/rust/mp4parse/tests/valid-alpha.avif b/third_party/rust/mp4parse/tests/valid-alpha.avif Binary files differnew file mode 100644 index 0000000000..b192607495 --- /dev/null +++ b/third_party/rust/mp4parse/tests/valid-alpha.avif diff --git a/third_party/rust/mp4parse/tests/valid-avif-colr-nclx-and-prof-and-rICC.avif b/third_party/rust/mp4parse/tests/valid-avif-colr-nclx-and-prof-and-rICC.avif Binary files differnew file mode 100644 index 0000000000..b9fe1853ff --- /dev/null +++ b/third_party/rust/mp4parse/tests/valid-avif-colr-nclx-and-prof-and-rICC.avif diff --git a/third_party/rust/mp4parse/tests/valid-avif-colr-nclx-and-prof.avif b/third_party/rust/mp4parse/tests/valid-avif-colr-nclx-and-prof.avif Binary files differnew file mode 100644 index 0000000000..683baa7f54 --- /dev/null +++ b/third_party/rust/mp4parse/tests/valid-avif-colr-nclx-and-prof.avif diff --git a/third_party/rust/mp4parse/tests/valid-avif-colr-nclx-and-rICC.avif b/third_party/rust/mp4parse/tests/valid-avif-colr-nclx-and-rICC.avif Binary files differnew file mode 100644 index 0000000000..eea6c788a7 --- /dev/null +++ b/third_party/rust/mp4parse/tests/valid-avif-colr-nclx-and-rICC.avif diff --git a/third_party/rust/mp4parse/tests/valid-avif-colr-nclx.avif b/third_party/rust/mp4parse/tests/valid-avif-colr-nclx.avif Binary files differnew file mode 100644 index 0000000000..3aa4b8f5bb --- /dev/null +++ b/third_party/rust/mp4parse/tests/valid-avif-colr-nclx.avif diff --git a/third_party/rust/mp4parse/tests/valid-avif-colr-prof-and-rICC.avif b/third_party/rust/mp4parse/tests/valid-avif-colr-prof-and-rICC.avif Binary files differnew file mode 100644 index 0000000000..a4609aa93e --- /dev/null +++ b/third_party/rust/mp4parse/tests/valid-avif-colr-prof-and-rICC.avif diff --git a/third_party/rust/mp4parse/tests/valid-avif-colr-prof.avif b/third_party/rust/mp4parse/tests/valid-avif-colr-prof.avif Binary files differnew file mode 100644 index 0000000000..2ee8fa86b3 --- /dev/null +++ b/third_party/rust/mp4parse/tests/valid-avif-colr-prof.avif diff --git a/third_party/rust/mp4parse/tests/valid-avif-colr-rICC.avif b/third_party/rust/mp4parse/tests/valid-avif-colr-rICC.avif Binary files differnew file mode 100644 index 0000000000..1da111942e --- /dev/null +++ b/third_party/rust/mp4parse/tests/valid-avif-colr-rICC.avif diff --git a/third_party/rust/mp4parse/tests/valid.avif b/third_party/rust/mp4parse/tests/valid.avif Binary files differnew file mode 100644 index 0000000000..d576365b6e --- /dev/null +++ b/third_party/rust/mp4parse/tests/valid.avif |
