MediaParserTest.java (revision b7c941bb3fa97aba169d73cee0bed2de8ac964bf) - OpenGrok cross reference for /aosp_15_r20/cts/tests/tests/mediaparser/src/android/media/mediaparser/cts/MediaParserTest.java

/*
 * Copyright 2020 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.media.mediaparser.cts;

import static com.google.common.truth.Truth.assertThat;

import static org.junit.Assert.fail;
import static org.junit.Assume.assumeTrue;

import android.media.MediaCodec;
import android.media.MediaFormat;
import android.media.MediaParser;
import android.media.metrics.LogSessionId;
import android.media.metrics.MediaMetricsManager;
import android.media.metrics.PlaybackSession;
import android.os.Build;

import androidx.test.ext.junit.runners.AndroidJUnit4;
import androidx.test.platform.app.InstrumentationRegistry;

import com.android.compatibility.common.util.ModuleSpecificTest;

import com.google.android.exoplayer2.testutil.FakeExtractorInput;
import com.google.android.exoplayer2.testutil.TestUtil;
import com.google.android.exoplayer2.util.Util;

import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;

import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.Map;

@RunWith(AndroidJUnit4.class)
@ModuleSpecificTest
public class MediaParserTest {

    private static final String PARAMETER_IN_BAND_CRYPTO_INFO =
            "android.media.mediaparser.inBandCryptoInfo";

    @Before
    public void setUp() {
        assumeTrue(Build.VERSION.SDK_INT >= Build.VERSION_CODES.R);
    }

    @Test
    public void testDefaultLogSessionId() {
        assumeTrue(Build.VERSION.SDK_INT >= Build.VERSION_CODES.S);
        MediaParser mediaParser = MediaParser.create(new MockMediaParserOutputConsumer());
        assertThat(mediaParser.getLogSessionId())
                .isSameInstanceAs(LogSessionId.LOG_SESSION_ID_NONE);
        mediaParser.release();
    }

    @Test
    public void testSetLogSessionId() {
        assumeTrue(Build.VERSION.SDK_INT >= Build.VERSION_CODES.S);
        MediaParser mediaParser = MediaParser.create(new MockMediaParserOutputConsumer());
        MediaMetricsManager mediaMetricsManager =
                InstrumentationRegistry.getInstrumentation()
                        .getTargetContext()
                        .getSystemService(MediaMetricsManager.class);
        PlaybackSession playbackSession = mediaMetricsManager.createPlaybackSession();
        LogSessionId logSessionId = playbackSession.getSessionId();
        mediaParser.setLogSessionId(logSessionId);
        assertThat(mediaParser.getLogSessionId()).isSameInstanceAs(logSessionId);
        mediaParser.release();
    }

    @Test
    public void testGetAllParserNames() {
        MediaFormat format = new MediaFormat();
        // By not providing a mime type, MediaParser should return all parser names.
        format.setString(MediaFormat.KEY_MIME, null);
        assertThat(MediaParser.getParserNames(format))
                .containsExactly(
                        MediaParser.PARSER_NAME_MATROSKA,
                        MediaParser.PARSER_NAME_FMP4,
                        MediaParser.PARSER_NAME_MP4,
                        MediaParser.PARSER_NAME_MP3,
                        MediaParser.PARSER_NAME_ADTS,
                        MediaParser.PARSER_NAME_AC3,
                        MediaParser.PARSER_NAME_TS,
                        MediaParser.PARSER_NAME_FLV,
                        MediaParser.PARSER_NAME_OGG,
                        MediaParser.PARSER_NAME_PS,
                        MediaParser.PARSER_NAME_WAV,
                        MediaParser.PARSER_NAME_AMR,
                        MediaParser.PARSER_NAME_AC4,
                        MediaParser.PARSER_NAME_FLAC);
    }

    @Test
    public void testGetParserNamesByMimeType() {
        // MimeTypes obtained from the W3C.
        assertParsers(MediaParser.PARSER_NAME_MATROSKA)
                .supportMimeTypes(
                        "video/x-matroska", "audio/x-matroska", "video/x-webm", "audio/x-webm");
        assertParsers(MediaParser.PARSER_NAME_MP4, MediaParser.PARSER_NAME_FMP4)
                .supportMimeTypes("video/mp4", "audio/mp4", "application/mp4");
        assertParsers(MediaParser.PARSER_NAME_MP3).supportMimeTypes("audio/mpeg");
        assertParsers(MediaParser.PARSER_NAME_ADTS).supportMimeTypes("audio/aac");
        assertParsers(MediaParser.PARSER_NAME_AC3).supportMimeTypes("audio/ac3");
        assertParsers(MediaParser.PARSER_NAME_TS).supportMimeTypes("video/mp2t", "audio/mp2t");
        assertParsers(MediaParser.PARSER_NAME_FLV).supportMimeTypes("video/x-flv");
        assertParsers(MediaParser.PARSER_NAME_OGG)
                .supportMimeTypes("video/ogg", "audio/ogg", "application/ogg");
        assertParsers(MediaParser.PARSER_NAME_PS).supportMimeTypes("video/mp2p", "video/mp1s");
        assertParsers(MediaParser.PARSER_NAME_WAV)
                .supportMimeTypes("audio/vnd.wave", "audio/wav", "audio/wave", "audio/x-wav");
        assertParsers(MediaParser.PARSER_NAME_AMR).supportMimeTypes("audio/amr");
        assertParsers(MediaParser.PARSER_NAME_AC4).supportMimeTypes("audio/ac4");
        assertParsers(MediaParser.PARSER_NAME_FLAC).supportMimeTypes("audio/flac", "audio/x-flac");
    }

    @Test
    public void testGetParserNamesForUnsupportedMimeType() {
        MediaFormat format = new MediaFormat();
        // None of the parser supports WebVTT.
        format.setString(MediaFormat.KEY_MIME, "text/vtt");
        assertThat(MediaParser.getParserNames(format)).isEmpty();
    }

    @Test
    public void testCreationByName() {
        testCreationByName(MediaParser.PARSER_NAME_MATROSKA);
        testCreationByName(MediaParser.PARSER_NAME_FMP4);
        testCreationByName(MediaParser.PARSER_NAME_MP4);
        testCreationByName(MediaParser.PARSER_NAME_MP3);
        testCreationByName(MediaParser.PARSER_NAME_ADTS);
        testCreationByName(MediaParser.PARSER_NAME_AC3);
        testCreationByName(MediaParser.PARSER_NAME_TS);
        testCreationByName(MediaParser.PARSER_NAME_FLV);
        testCreationByName(MediaParser.PARSER_NAME_OGG);
        testCreationByName(MediaParser.PARSER_NAME_PS);
        testCreationByName(MediaParser.PARSER_NAME_WAV);
        testCreationByName(MediaParser.PARSER_NAME_AMR);
        testCreationByName(MediaParser.PARSER_NAME_AC4);
        testCreationByName(MediaParser.PARSER_NAME_FLAC);
        try {
            testCreationByName("android.media.mediaparser.ExtractorThatDoesNotExist");
            fail();
        } catch (IllegalArgumentException e) {
            // Expected.
        }
    }

    @Test
    public void testSupportsParameter() {
        assertSupportFor(MediaParser.PARAMETER_ADTS_ENABLE_CBR_SEEKING);
        assertSupportFor(MediaParser.PARAMETER_AMR_ENABLE_CBR_SEEKING);
        assertSupportFor(MediaParser.PARAMETER_FLAC_DISABLE_ID3);
        assertSupportFor(MediaParser.PARAMETER_MP4_IGNORE_EDIT_LISTS);
        assertSupportFor(MediaParser.PARAMETER_MP4_IGNORE_TFDT_BOX);
        assertSupportFor(MediaParser.PARAMETER_MP4_TREAT_VIDEO_FRAMES_AS_KEYFRAMES);
        assertSupportFor(MediaParser.PARAMETER_MATROSKA_DISABLE_CUES_SEEKING);
        assertSupportFor(MediaParser.PARAMETER_MP3_DISABLE_ID3);
        assertSupportFor(MediaParser.PARAMETER_MP3_ENABLE_CBR_SEEKING);
        assertSupportFor(MediaParser.PARAMETER_MP3_ENABLE_INDEX_SEEKING);
        assertSupportFor(MediaParser.PARAMETER_TS_MODE);
        assertSupportFor(MediaParser.PARAMETER_TS_ALLOW_NON_IDR_AVC_KEYFRAMES);
        assertSupportFor(MediaParser.PARAMETER_TS_IGNORE_AAC_STREAM);
        assertSupportFor(MediaParser.PARAMETER_TS_IGNORE_AVC_STREAM);
        assertSupportFor(MediaParser.PARAMETER_TS_IGNORE_SPLICE_INFO_STREAM);
        assertSupportFor(MediaParser.PARAMETER_TS_DETECT_ACCESS_UNITS);
        assertSupportFor(MediaParser.PARAMETER_TS_ENABLE_HDMV_DTS_AUDIO_STREAMS);
    }

    @Test
    public void testSetKnownParameters() {
        testValidAndInvalidValueForBooleanParameter(MediaParser.PARAMETER_ADTS_ENABLE_CBR_SEEKING);
        testValidAndInvalidValueForBooleanParameter(MediaParser.PARAMETER_AMR_ENABLE_CBR_SEEKING);
        testValidAndInvalidValueForBooleanParameter(MediaParser.PARAMETER_FLAC_DISABLE_ID3);
        testValidAndInvalidValueForBooleanParameter(MediaParser.PARAMETER_MP4_IGNORE_EDIT_LISTS);
        testValidAndInvalidValueForBooleanParameter(MediaParser.PARAMETER_MP4_IGNORE_TFDT_BOX);
        testValidAndInvalidValueForBooleanParameter(
                MediaParser.PARAMETER_MP4_TREAT_VIDEO_FRAMES_AS_KEYFRAMES);
        testValidAndInvalidValueForBooleanParameter(
                MediaParser.PARAMETER_MATROSKA_DISABLE_CUES_SEEKING);
        testValidAndInvalidValueForBooleanParameter(MediaParser.PARAMETER_MP3_DISABLE_ID3);
        testValidAndInvalidValueForBooleanParameter(MediaParser.PARAMETER_MP3_ENABLE_CBR_SEEKING);
        testValidAndInvalidValueForBooleanParameter(MediaParser.PARAMETER_MP3_ENABLE_INDEX_SEEKING);
        testValidAndInvalidValueForBooleanParameter(
                MediaParser.PARAMETER_TS_ALLOW_NON_IDR_AVC_KEYFRAMES);
        testValidAndInvalidValueForBooleanParameter(MediaParser.PARAMETER_TS_IGNORE_AAC_STREAM);
        testValidAndInvalidValueForBooleanParameter(MediaParser.PARAMETER_TS_IGNORE_AVC_STREAM);
        testValidAndInvalidValueForBooleanParameter(
                MediaParser.PARAMETER_TS_IGNORE_SPLICE_INFO_STREAM);
        testValidAndInvalidValueForBooleanParameter(MediaParser.PARAMETER_TS_DETECT_ACCESS_UNITS);
        testValidAndInvalidValueForBooleanParameter(
                MediaParser.PARAMETER_TS_ENABLE_HDMV_DTS_AUDIO_STREAMS);
        testParameterSetting(
                MediaParser.PARAMETER_TS_MODE, /* value= */ 1, /* valueIsIllegal= */ true);
        testParameterSetting(
                MediaParser.PARAMETER_TS_MODE,
                /* value= */ "invalid_mode",
                /* valueIsIllegal= */ true);
        testParameterSetting(
                MediaParser.PARAMETER_TS_MODE,
                /* value= */ "single_pmt",
                /* valueIsIllegal= */ false);
        testParameterSetting(
                MediaParser.PARAMETER_TS_MODE, /* value= */ "hls", /* valueIsIllegal= */ false);
        testParameterSetting(
                MediaParser.PARAMETER_TS_MODE,
                /* value= */ "multi_pmt",
                /* valueIsIllegal= */ false);
    }

    @Test
    public void testSetUnknownParameter() {
        String parameterName = "android.media.mediaparser.unsupportedParameterName";
        // All of the following should be ignored.
        testParameterSetting(parameterName, /* value= */ 1, /* valueIsIllegal= */ false);
        testParameterSetting(parameterName, /* value= */ "string", /* valueIsIllegal= */ false);
        testParameterSetting(parameterName, /* value= */ true, /* valueIsIllegal= */ false);
    }

    @Test
    public void testLackOfSupportForUnsupportedParameter() {
        MediaParser mediaParser = MediaParser.create(new MockMediaParserOutputConsumer());
        assertThat(mediaParser.supportsParameter("android.media.mediaparser.UNSUPPORTED_PARAMETER"))
                .isFalse();
        mediaParser.release();
    }

    // OGG.

    @Test
    public void testOggBearVorbis() throws IOException {
        testAssetExtraction("media/ogg/bear_vorbis.ogg");
    }

    @Test
    public void testOggBear() throws IOException {
        testAssetExtraction("media/ogg/bear.opus");
    }

    @Test
    public void testOggBearFlac() throws IOException {
        testAssetExtraction("media/ogg/bear_flac.ogg");
    }

    @Test
    public void testOggNoFlacSeekTable() throws IOException {
        testAssetExtraction("media/ogg/bear_flac_noseektable.ogg");
    }

    @Test
    public void testOggFlacHeaderSniff() throws IOException {
        testSniffAsset(
                "media/ogg/flac_header", /* expectedExtractorName= */ MediaParser.PARSER_NAME_OGG);
    }

    @Test
    public void testOggOpusHeaderSniff() throws IOException {
        try {
            testSniffAsset(
                    "media/ogg/opus_header",
                    /* expectedExtractorName= */ MediaParser.PARSER_NAME_OGG);
            fail();
        } catch (MediaParser.UnrecognizedInputFormatException e) {
            // Expected.
        }
    }

    @Test
    public void testOggInvalidHeaderSniff() throws IOException {
        try {
            testSniffAsset(
                    "media/ogg/invalid_ogg_header",
                    /* expectedExtractorName= */ MediaParser.PARSER_NAME_OGG);
            fail();
        } catch (MediaParser.UnrecognizedInputFormatException e) {
            // Expected.
        }
        try {
            testSniffAsset(
                    "media/ogg/invalid_header",
                    /* expectedExtractorName= */ MediaParser.PARSER_NAME_OGG);
            fail();
        } catch (MediaParser.UnrecognizedInputFormatException e) {
            // Expected.
        }
    }

    // FLAC.

    @Test
    public void testFlacUncommonSampleRateFlac() throws IOException {
        testAssetExtraction("media/flac/bear_uncommon_sample_rate.flac");
    }

    @Test
    public void testFlacNoSeekTableAndNoNumSamples() throws IOException {
        testAssetExtraction("media/flac/bear_no_seek_table_no_num_samples.flac");
    }

    @Test
    public void testFlacWithPicture() throws IOException {
        testAssetExtraction("media/flac/bear_with_picture.flac");
    }

    @Test
    public void testFlacWithVorbisComments() throws IOException {
        testAssetExtraction("media/flac/bear_with_vorbis_comments.flac");
    }

    @Test
    public void testFlacOneMetadataBlock() throws IOException {
        testAssetExtraction("media/flac/bear_one_metadata_block.flac");
    }

    @Test
    public void testFlacNoMinMaxFrameSize() throws IOException {
        testAssetExtraction("media/flac/bear_no_min_max_frame_size.flac");
    }

    @Test
    public void testFlacNoNumSamples() throws IOException {
        testAssetExtraction("media/flac/bear_no_num_samples.flac");
    }

    @Test
    public void testFlacWithId3() throws IOException {
        testAssetExtraction("media/flac/bear_with_id3.flac");
    }

    @Test
    public void testFlacSample() throws IOException {
        testAssetExtraction("media/flac/bear.flac");
    }

    // MP3.

    @Test
    public void testMp3WithNoSeekTableVariableFrameSize() throws IOException {
        testAssetExtraction("media/mp3/bear-cbr-variable-frame-size-no-seek-table.mp3");
    }

    @Test
    public void testMp3WithVariableBitrateAndXingHeader() throws IOException {
        testAssetExtraction("media/mp3/bear-vbr-xing-header.mp3");
    }

    @Test
    public void testMp3WithNoSeekTableVariableBitrate() throws IOException {
        testAssetExtraction("media/mp3/bear-vbr-no-seek-table.mp3");
    }

    @Test
    public void testMp3WithTrimmedSample() throws IOException {
        testAssetExtraction("media/mp3/play-trimmed.mp3");
    }

    @Test
    public void testMp3WithId3() throws IOException {
        testAssetExtraction("media/mp3/bear-id3.mp3");
    }

    // WAV.

    @Test
    public void testWavWithImaAdpcm() throws IOException {
        testAssetExtraction("media/wav/sample_ima_adpcm.wav");
    }

    @Test
    public void testWav() throws IOException {
        testAssetExtraction("media/wav/sample.wav");
    }

    // AMR.

    @Test
    public void testAmrNarrowBandSamplesWithConstantBitrateSeeking() throws IOException {
        testAssetExtraction("media/amr/sample_nb_cbr.amr");
    }

    @Test
    public void testAmrNarrowBandSamples() throws IOException {
        testAssetExtraction("media/amr/sample_nb.amr");
    }

    @Test
    public void testAmrWideBandSamples() throws IOException {
        testAssetExtraction("media/amr/sample_wb.amr");
    }

    @Test
    public void testAmrWideBandSamplesWithConstantBitrateSeeking() throws IOException {
        testAssetExtraction("media/amr/sample_wb_cbr.amr");
    }

    // FLV.

    @Test
    public void testFlv() throws IOException {
        testAssetExtraction("media/flv/sample.flv");
    }

    // PS.

    // TODO: Enable once the timeout is fixed.
    @Test
    @Ignore
    public void testPsElphantsDream() throws IOException {
        testAssetExtraction("media/ts/elephants_dream.mpg");
    }

    @Test
    public void testPsWithAc3() throws IOException {
        testAssetExtraction("media/ts/sample_ac3.ps");
    }

    @Test
    public void testPsWithH262MpegAudio() throws IOException {
        testAssetExtraction("media/ts/sample_h262_mpeg_audio.ps");
    }

    // ADTS.

    @Test
    public void testAdtsTruncatedWithConstantBitrateSeeking() throws IOException {
        testAssetExtraction(
                "media/ts/sample_cbs_truncated.adts",
                Collections.singletonMap(MediaParser.PARAMETER_ADTS_ENABLE_CBR_SEEKING, true));
    }

    @Test
    public void testAdts() throws IOException {
        testAssetExtraction("media/ts/sample.adts");
    }

    // AC-3.

    @Test
    public void testAc3() throws IOException {
        testAssetExtraction("media/ts/sample.ac3");
    }

    // AC-4.

    @Test
    public void testAc4() throws IOException {
        testAssetExtraction("media/ts/sample.ac4");
    }

    // EAC-3.

    @Test
    public void testEac3() throws IOException {
        testAssetExtraction("media/ts/sample.eac3");
    }

    // TS.

    @Test
    public void testTsBigBuckBunny() throws IOException {
        // This file is too big to run a full extraction with multiple seeks like other tests do.
        MockMediaParserOutputConsumer outputConsumer = new MockMediaParserOutputConsumer();
        MockMediaParserInputReader inputReader = getInputReader("media/ts/bbb_2500ms.ts");
        MediaParser mediaParser = MediaParser.create(outputConsumer);
        advanceUntilSample(outputConsumer, inputReader, mediaParser, /* sampleNumber= */ 100);
        assertThat(outputConsumer.getSeekMap().getDurationMicros()).isEqualTo(2_500_000);
        mediaParser.seek(MediaParser.SeekPoint.START);
        inputReader.setPosition(0);
        advanceUntilSample(outputConsumer, inputReader, mediaParser, /* sampleNumber= */ 101);
    }

    @Test
    public void testTsWithH262MpegAudio() throws IOException {
        testAssetExtraction("media/ts/sample_h262_mpeg_audio.ts");
    }

    @Test
    public void testTsWithH264MpegAudio() throws IOException {
        testAssetExtraction("media/ts/sample_h264_mpeg_audio.ts");
    }

    @Test
    public void testTsWithH264DetectAccessUnits() throws IOException {
        testAssetExtraction(
                "media/ts/sample_h264_no_access_unit_delimiters.ts",
                Collections.singletonMap(MediaParser.PARAMETER_TS_DETECT_ACCESS_UNITS, true));
    }

    @Test
    public void testTsWithH264DtsAudio() throws IOException {
        testAssetExtraction(
                "media/ts/sample_h264_dts_audio.ts",
                Collections.singletonMap(
                        MediaParser.PARAMETER_TS_ENABLE_HDMV_DTS_AUDIO_STREAMS, true));
    }

    @Test
    public void testTsWithLatm() throws IOException {
        testAssetExtraction("media/ts/sample_latm.ts");
    }

    @Test
    public void testTsWithSdt() throws IOException {
        testAssetExtraction("media/ts/sample_with_sdt.ts");
    }

    @Test
    public void testTsWithH265() throws IOException {
        testAssetExtraction("media/ts/sample_h265.ts");
    }

    // MKV.

    @Test
    public void testMatroskaSubsampleEncryptedNoAltref() throws IOException {
        testAssetExtraction("media/mkv/subsample_encrypted_noaltref.webm");
    }

    @Test
    public void testMatroskaFile() throws IOException {
        testAssetExtraction("media/mkv/sample.mkv");
    }

    @Test
    public void testMatroskaFullBlocks() throws IOException {
        testAssetExtraction("media/mkv/full_blocks.mkv");
    }

    @Test
    public void testMatroskaSubsampleEncryptedAltref() throws IOException {
        testAssetExtraction("media/mkv/subsample_encrypted_altref.webm");
    }

    @Test
    public void testMatroskaOutOfBandCrypto() throws IOException {
        MockMediaParserOutputConsumer outputConsumer = new MockMediaParserOutputConsumer();
        MockMediaParserInputReader inputReader =
                getInputReader("media/mkv/subsample_encrypted_noaltref.webm");
        MediaParser mediaParser = MediaParser.create(outputConsumer);
        // Initialization vectors are 16 bytes in size, as per CryptoInfo documentation.
        MediaCodec.CryptoInfo expectedCryptoInfo = new MediaCodec.CryptoInfo();
        expectedCryptoInfo.set(
                /* newNumSubsamples=*/ 1,
                /* newNumBytesOfClearData= */ new int[] {2},
                /* newNumBytesOfEncryptedData= */ new int[] {5},
                /* newKey= */ Arrays.copyOf(
                        Util.getBytesFromHexString("01020304050607080910111213141516"), 16),
                /* newIv= */ Arrays.copyOf(Util.getBytesFromHexString("0101010101010101"), 16),
                MediaCodec.CRYPTO_MODE_AES_CTR);
        advanceUntilSample(outputConsumer, inputReader, mediaParser, /* sampleNumber= */ 1);
        assertEqual(outputConsumer.getLastOutputCryptoInfo(), expectedCryptoInfo);
        mediaParser.release();
    }

    // MP4.

    @Test
    public void testMp4Ac4Fragmented() throws IOException {
        testAssetExtraction("media/mp4/sample_ac4_fragmented.mp4");
    }

    @Test
    public void testMp4AndroidSlowMotion() throws IOException {
        testAssetExtraction("media/mp4/sample_android_slow_motion.mp4");
    }

    @Test
    public void testMp4FragmentedSei() throws IOException {
        testAssetExtraction("media/mp4/sample_fragmented_sei.mp4");
    }

    @Test
    public void testMp4WithAc4() throws IOException {
        testAssetExtraction("media/mp4/sample_ac4.mp4");
    }

    @Test
    public void testMp4FragmentedSeekable() throws IOException {
        testAssetExtraction("media/mp4/sample_fragmented_seekable.mp4");
    }

    @Test
    public void testMp4WithProtectedAc4() throws IOException {
        testAssetExtraction("media/mp4/sample_ac4_protected.mp4");
    }

    @Test
    public void testMp4() throws IOException {
        testAssetExtraction("media/mp4/sample.mp4");
    }

    @Test
    public void testMp4MdatTooLong() throws IOException {
        testAssetExtraction("media/mp4/sample_mdat_too_long.mp4");
    }

    @Test
    public void testMp4Fragmented() throws IOException {
        testAssetExtraction("media/mp4/sample_fragmented.mp4");
    }

    @Test
    public void testMp4FragmentedOutOfBandCrypto() throws IOException {
        MockMediaParserOutputConsumer outputConsumer = new MockMediaParserOutputConsumer();
        MockMediaParserInputReader inputReader =
                getInputReader("media/mp4/sample_ac4_protected.mp4");
        MediaParser mediaParser = MediaParser.create(outputConsumer);
        // Initialization vectors are 16 bytes in size, as per CryptoInfo documentation.
        MediaCodec.CryptoInfo expectedCryptoInfo = new MediaCodec.CryptoInfo();
        expectedCryptoInfo.set(
                /* newNumSubsamples=*/ 1,
                /* newNumBytesOfClearData= */ new int[] {7},
                /* newNumBytesOfEncryptedData= */ new int[] {360},
                /* newKey= */ Arrays.copyOf(
                        Util.getBytesFromHexString("91341951696b5e1ba232439ecec1f12a"), 16),
                /* newIv= */ Arrays.copyOf(Util.getBytesFromHexString("aab4ed0108dd5267"), 16),
                MediaCodec.CRYPTO_MODE_AES_CTR);
        advanceUntilSample(outputConsumer, inputReader, mediaParser, /* sampleNumber= */ 1);
        assertEqual(outputConsumer.getLastOutputCryptoInfo(), expectedCryptoInfo);

        expectedCryptoInfo.iv = Arrays.copyOf(Util.getBytesFromHexString("aab4ed0108dd5272"), 16);
        expectedCryptoInfo.numBytesOfEncryptedData = new int[] {488};
        advanceUntilSample(outputConsumer, inputReader, mediaParser, /* sampleNumber= */ 12);
        assertEqual(outputConsumer.getLastOutputCryptoInfo(), expectedCryptoInfo);

        mediaParser.release();
    }

    // Internal methods.

    private static void testCreationByName(String name) {
        MediaParser.createByName(name, new MockMediaParserOutputConsumer()).release();
    }

    private static void assertSupportFor(String parameterName) {
        MediaParser mediaParser = MediaParser.create(new MockMediaParserOutputConsumer());
        assertThat(mediaParser.supportsParameter(parameterName)).isTrue();
        mediaParser.release();
    }

    private static void testValidAndInvalidValueForBooleanParameter(String parameterName) {
        testParameterSetting(parameterName, /* value= */ "string", /* valueIsIllegal= */ true);
        testParameterSetting(parameterName, /* value= */ true, /* valueIsIllegal= */ false);
    }

    private static void testParameterSetting(
            String parameterName, Object value, boolean valueIsIllegal) {
        MediaParser mediaParser = MediaParser.create(new MockMediaParserOutputConsumer());
        boolean illegalArgument = false;
        try {
            mediaParser.setParameter(parameterName, value);
        } catch (IllegalArgumentException e) {
            illegalArgument = true;
        }
        if (valueIsIllegal != illegalArgument) {
            fail();
        }
    }

    private static void testSniffAsset(String assetPath, String expectedParserName)
            throws IOException {
        testAssetExtraction(assetPath, Collections.emptyMap(), expectedParserName);
    }

    private static void testAssetExtraction(String assetPath) throws IOException {
        testAssetExtraction(assetPath, Collections.emptyMap());
    }

    private static void testAssetExtraction(String assetPath, Map<String, Object> parameters)
            throws IOException {
        testAssetExtraction(assetPath, parameters, /* expectedParserName= */ null);
    }

    private static void testAssetExtraction(
            String assetPath, Map<String, Object> parameters, String expectedParserName)
            throws IOException {
        MockMediaParserInputReader inputReader = getInputReader(assetPath);
        boolean usingInBandCryptoInfo =
                (boolean) parameters.getOrDefault(PARAMETER_IN_BAND_CRYPTO_INFO, false);
        MockMediaParserOutputConsumer outputConsumer =
                new MockMediaParserOutputConsumer(usingInBandCryptoInfo);
        MediaParser mediaParser = MediaParser.create(outputConsumer);
        for (Map.Entry<String, Object> entry : parameters.entrySet()) {
            mediaParser.setParameter(entry.getKey(), entry.getValue());
        }

        try {
            mediaParser.advance(inputReader);
            if (expectedParserName != null) {
                assertThat(expectedParserName).isEqualTo(mediaParser.getParserName());
                // We are only checking that the extractor is the right one.
                return;
            }

            while (mediaParser.advance(inputReader)) {
                // Do nothing.
            }

            // If the SeekMap is seekable, test seeking in the stream.
            MediaParser.SeekMap seekMap = outputConsumer.getSeekMap();
            assertThat(seekMap).isNotNull();
            if (seekMap.isSeekable()) {
                long durationUs = seekMap.getDurationMicros();
                for (int j = 0; j < 4; j++) {
                    outputConsumer.clearTrackOutputs();
                    long timeUs =
                            durationUs == MediaParser.SeekMap.UNKNOWN_DURATION
                                    ? 0
                                    : (durationUs * j) / 3;
                    MediaParser.SeekPoint seekPoint = seekMap.getSeekPoints(timeUs).first;
                    inputReader.reset();
                    inputReader.setPosition((int) seekPoint.position);
                    mediaParser.seek(seekPoint);
                    while (mediaParser.advance(inputReader)) {
                        // Do nothing.
                    }
                    if (durationUs == MediaParser.SeekMap.UNKNOWN_DURATION) {
                        break;
                    }
                }
            }
        } finally {
            mediaParser.release();
        }
    }

    private static MockMediaParserInputReader getInputReader(String assetPath) throws IOException {
        byte[] assetBytes =
                TestUtil.getByteArray(
                        InstrumentationRegistry.getInstrumentation().getContext(), assetPath);
        return new MockMediaParserInputReader(
                new FakeExtractorInput.Builder().setData(assetBytes).build());
    }

    private static void advanceUntilSample(
            MockMediaParserOutputConsumer outputConsumer,
            MockMediaParserInputReader inputReader,
            MediaParser mediaParser,
            int sampleNumber)
            throws IOException {
        while (outputConsumer.getCompletedSampleCount() != sampleNumber) {
            assertThat(mediaParser.advance(inputReader)).isTrue();
        }
    }

    private static void assertEqual(
            MediaCodec.CryptoInfo actualCryptoInfo, MediaCodec.CryptoInfo expectedCryptoInfo) {
        assertThat(actualCryptoInfo.mode).isEqualTo(expectedCryptoInfo.mode);
        assertThat(actualCryptoInfo.key).isEqualTo(expectedCryptoInfo.key);
        assertThat(actualCryptoInfo.iv).isEqualTo(expectedCryptoInfo.iv);
        assertThat(actualCryptoInfo.numSubSamples).isEqualTo(expectedCryptoInfo.numSubSamples);
        for (int i = 0; i < actualCryptoInfo.numSubSamples; i++) {
            assertThat(actualCryptoInfo.numBytesOfClearData[i])
                    .isEqualTo(expectedCryptoInfo.numBytesOfClearData[i]);
            assertThat(actualCryptoInfo.numBytesOfEncryptedData[i])
                    .isEqualTo(expectedCryptoInfo.numBytesOfEncryptedData[i]);
        }
    }

    // Internal classes.

    private static FluentMediaParserSubject assertParsers(String... names) {
        return new FluentMediaParserSubject(names);
    }

    private static final class FluentMediaParserSubject {

        private final String[] mediaParserNames;

        private FluentMediaParserSubject(String[] mediaParserNames) {
            this.mediaParserNames = mediaParserNames;
        }

        public void supportMimeTypes(String... mimeTypes) {
            for (String mimeType : mimeTypes) {
                MediaFormat format = new MediaFormat();
                format.setString(MediaFormat.KEY_MIME, mimeType);
                assertThat(MediaParser.getParserNames(format))
                        .containsExactlyElementsIn(mediaParserNames);
            }
        }
    }
}