/*
 * Copyright (C) 2021 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.mediapc.cts;

import static android.mediapc.cts.CodecTestBase.SELECT_ALL;
import static android.mediapc.cts.CodecTestBase.SELECT_AUDIO;
import static android.mediapc.cts.CodecTestBase.SELECT_HARDWARE;
import static android.mediapc.cts.CodecTestBase.SELECT_VIDEO;
import static android.mediapc.cts.CodecTestBase.getMimesOfAvailableCodecs;
import static android.mediapc.cts.CodecTestBase.selectCodecs;
import static android.mediapc.cts.CodecTestBase.selectHardwareCodecs;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assume.assumeFalse;
import static org.junit.Assume.assumeTrue;

import android.app.Instrumentation;
import android.content.Context;
import android.content.pm.PackageManager;
import android.media.MediaCodec;
import android.media.MediaCodecInfo;
import android.media.MediaFormat;
import android.media.MediaRecorder;
import android.mediapc.cts.common.PerformanceClassEvaluator;
import android.mediapc.cts.common.Utils;
import android.util.Log;
import android.util.Pair;
import android.view.Surface;

import androidx.test.filters.LargeTest;
import androidx.test.platform.app.InstrumentationRegistry;
import androidx.test.rule.ActivityTestRule;

import com.android.compatibility.common.util.CddTest;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TestName;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * The following test class validates the codec initialization latency (time for codec create +
 * configure) for the audio codecs and hardware video codecs available in the device, under the
 * load condition (Transcode + MediaRecorder session Audio(Microphone) and 1080p Video(Camera)).
 */
@RunWith(Parameterized.class)
public class CodecInitializationLatencyTest {
    private static final String LOG_TAG = CodecInitializationLatencyTest.class.getSimpleName();
    private static final boolean[] boolStates = {false, true};

    private static final String AVC = MediaFormat.MIMETYPE_VIDEO_AVC;
    private static final String HEVC = MediaFormat.MIMETYPE_VIDEO_HEVC;
    private static final String AVC_TRANSCODE_FILE = "bbb_1280x720_3mbps_30fps_avc.mp4";
    private static String AVC_DECODER_NAME;
    private static String AVC_ENCODER_NAME;
    private static final Map<String, String> mTestFiles = new HashMap<>();

    @Rule
    public final TestName mTestName = new TestName();

    static {
        // TODO(b/222006626): Add tests vectors for remaining media types
        // Audio media types
        mTestFiles.put(MediaFormat.MIMETYPE_AUDIO_AAC, "bbb_stereo_48kHz_128kbps_aac.mp4");
        mTestFiles.put(MediaFormat.MIMETYPE_AUDIO_AMR_NB, "bbb_mono_8kHz_12.2kbps_amrnb.3gp");
        mTestFiles.put(MediaFormat.MIMETYPE_AUDIO_AMR_WB, "bbb_1ch_16kHz_23kbps_amrwb.3gp");
        mTestFiles.put(MediaFormat.MIMETYPE_AUDIO_FLAC, "bbb_1ch_12kHz_lvl4_flac.mka");
        mTestFiles.put(MediaFormat.MIMETYPE_AUDIO_G711_ALAW, "bbb_2ch_8kHz_alaw.wav");
        mTestFiles.put(MediaFormat.MIMETYPE_AUDIO_G711_MLAW, "bbb_2ch_8kHz_mulaw.wav");
        mTestFiles.put(MediaFormat.MIMETYPE_AUDIO_MPEG, "bbb_1ch_8kHz_lame_cbr.mp3");
        mTestFiles.put(MediaFormat.MIMETYPE_AUDIO_MSGSM, "bbb_1ch_8kHz_gsm.wav");
        mTestFiles.put(MediaFormat.MIMETYPE_AUDIO_OPUS, "bbb_2ch_48kHz_opus.mka");
        mTestFiles.put(MediaFormat.MIMETYPE_AUDIO_RAW, "bbb_1ch_8kHz.wav");
        mTestFiles.put(MediaFormat.MIMETYPE_AUDIO_VORBIS, "bbb_stereo_48kHz_128kbps_vorbis.ogg");

        // Video media types
        mTestFiles.put(MediaFormat.MIMETYPE_VIDEO_AV1, "bbb_1920x1080_4mbps_30fps_av1.mp4");
        mTestFiles.put(MediaFormat.MIMETYPE_VIDEO_AVC, "bbb_1920x1080_6mbps_30fps_avc.mp4");
        mTestFiles.put(MediaFormat.MIMETYPE_VIDEO_H263, "bbb_cif_768kbps_30fps_h263.mp4");
        mTestFiles.put(MediaFormat.MIMETYPE_VIDEO_HEVC, "bbb_1920x1080_4mbps_30fps_hevc.mp4");
        mTestFiles.put(MediaFormat.MIMETYPE_VIDEO_MPEG2, "bbb_1920x1080_mpeg2_main_high.mp4");
        mTestFiles.put(MediaFormat.MIMETYPE_VIDEO_MPEG4, "bbb_cif_768kbps_30fps_mpeg4.mkv");
        mTestFiles.put(MediaFormat.MIMETYPE_VIDEO_VP8, "bbb_1920x1080_6mbps_30fps_vp8.webm");
        mTestFiles.put(MediaFormat.MIMETYPE_VIDEO_VP9, "bbb_1920x1080_4mbps_30fps_vp9.webm");
    }

    private final String mMime;
    private final String mCodecName;

    private LoadStatus mTranscodeLoadStatus = null;
    private Thread mTranscodeLoadThread = null;
    private MediaRecorder mMediaRecorderLoad = null;
    private File mTempRecordedFile = null;
    private Surface mSurface = null;
    private Exception mException = null;

    @Before
    public void setUp() throws Exception {
        Utils.assumeDeviceMeetsPerformanceClassPreconditions();

        ArrayList<String> listOfAvcHwDecoders = selectHardwareCodecs(AVC, null, null, false);
        assumeFalse("Test requires h/w avc decoder", listOfAvcHwDecoders.isEmpty());
        AVC_DECODER_NAME = listOfAvcHwDecoders.get(0);

        ArrayList<String> listOfAvcHwEncoders = selectHardwareCodecs(AVC, null, null, true);
        assumeFalse("Test requires h/w avc encoder", listOfAvcHwEncoders.isEmpty());
        AVC_ENCODER_NAME = listOfAvcHwEncoders.get(0);

        Instrumentation instrumentation = InstrumentationRegistry.getInstrumentation();
        Context context = instrumentation.getTargetContext();
        PackageManager packageManager = context.getPackageManager();
        assertNotNull(packageManager.getSystemAvailableFeatures());
        assumeTrue("The device doesn't have a camera",
                packageManager.hasSystemFeature(PackageManager.FEATURE_CAMERA_ANY));
        assumeTrue("The device doesn't have a microphone",
                packageManager.hasSystemFeature(PackageManager.FEATURE_MICROPHONE));
        createSurface();
        startLoad();
    }

    @After
    public void tearDown() throws Exception {
        stopLoad();
        releaseSurface();
    }

    public CodecInitializationLatencyTest(String mimeType, String codecName) {
        mMime = mimeType;
        mCodecName = codecName;
    }

    @Rule
    public ActivityTestRule<TestActivity> mActivityRule =
            new ActivityTestRule<>(TestActivity.class);

    /**
     * Returns the list of parameters with mimetype and their codecs(for audio - all codecs,
     * video - hardware codecs).
     *
     * @return Collection of Parameters {0}_{1} -- MIME_CodecName
     */
    @Parameterized.Parameters(name = "{index}({0}_{1})")
    public static Collection<Object[]> inputParams() {
        // Prepares the params list with the required Hardware video codecs and all available
        // audio codecs present in the device.
        final List<Object[]> argsList = new ArrayList<>();
        Set<String> mimeSet = getMimesOfAvailableCodecs(SELECT_VIDEO, SELECT_HARDWARE);
        mimeSet.addAll(getMimesOfAvailableCodecs(SELECT_AUDIO, SELECT_ALL));
        for (String mime : mimeSet) {
            ArrayList<String> listOfCodecs;
            if (mime.startsWith("audio/")) {
                listOfCodecs = selectCodecs(mime, null, null, true);
                listOfCodecs.addAll(selectCodecs(mime, null, null, false));
            } else {
                listOfCodecs = selectHardwareCodecs(mime, null, null, true);
                listOfCodecs.addAll(selectHardwareCodecs(mime, null, null, false));
            }
            for (String codec : listOfCodecs) {
                argsList.add(new Object[]{mime, codec});
            }
        }
        return argsList;
    }

    private MediaRecorder createMediaRecorderLoad(Surface surface) throws Exception {
        MediaRecorder mediaRecorder = new MediaRecorder(InstrumentationRegistry.getInstrumentation()
                .getContext());
        mediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
        mediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
        mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.DEFAULT);
        mediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);
        mediaRecorder.setVideoEncoder(mMime.equalsIgnoreCase(HEVC) ?
                MediaRecorder.VideoEncoder.HEVC : MediaRecorder.VideoEncoder.H264);
        mediaRecorder.setOutputFile(mTempRecordedFile);
        mediaRecorder.setVideoSize(1920, 1080);
        mediaRecorder.setOrientationHint(0);
        mediaRecorder.setPreviewDisplay(surface);
        mediaRecorder.prepare();
        return mediaRecorder;
    }

    private void startLoad() throws Exception {
        // TODO: b/183671436
        // Create Transcode load (AVC Decoder(720p) + AVC Encoder(720p))
        mTranscodeLoadStatus = new LoadStatus();
        mTranscodeLoadThread = new Thread(() -> {
            try {
                TranscodeLoad transcodeLoad = new TranscodeLoad(AVC, AVC_TRANSCODE_FILE,
                        AVC_DECODER_NAME, AVC_ENCODER_NAME, mTranscodeLoadStatus);
                transcodeLoad.doTranscode();
            } catch (Exception e) {
                mException = e;
            }
        });
        // Create MediaRecorder Session - Audio (Microphone) + 1080p Video (Camera)
        // Create a temp file to dump the MediaRecorder output. Later it will be deleted.
        mTempRecordedFile = new File(WorkDir.getMediaDirString() + "tempOut.mp4");
        mTempRecordedFile.createNewFile();
        mMediaRecorderLoad = createMediaRecorderLoad(mSurface);
        // Start the Loads
        mTranscodeLoadThread.start();
        mMediaRecorderLoad.start();
    }

    private void stopLoad() throws Exception {
        if (mTranscodeLoadStatus != null) {
            mTranscodeLoadStatus.setLoadFinished();
            mTranscodeLoadStatus = null;
        }
        if (mTranscodeLoadThread != null) {
            mTranscodeLoadThread.join();
            mTranscodeLoadThread = null;
        }
        if (mMediaRecorderLoad != null) {
            // Note that a RuntimeException is intentionally thrown to the application, if no valid
            // audio/video data has been received when stop() is called. This happens if stop() is
            // called immediately after start(). So sleep for 1000ms inorder to make sure some
            // data has been received between start() and stop().
            Thread.sleep(1000);
            mMediaRecorderLoad.stop();
            mMediaRecorderLoad.release();
            mMediaRecorderLoad = null;
            if (mTempRecordedFile != null && mTempRecordedFile.exists()) {
                mTempRecordedFile.delete();
                mTempRecordedFile = null;
            }
        }
        if (mException != null) throw mException;
    }

    private void createSurface() throws InterruptedException {
        mActivityRule.getActivity().waitTillSurfaceIsCreated();
        mSurface = mActivityRule.getActivity().getSurface();
        assertNotNull("Surface created is null.", mSurface);
        assertTrue("Surface created is invalid.", mSurface.isValid());
        mActivityRule.getActivity().setScreenParams(1920, 1080, true);
    }

    private void releaseSurface() {
        if (mSurface != null) {
            mSurface.release();
            mSurface = null;
        }
    }

    /**
     * This test validates the initialization latency (time for codec create + configure) for
     * audio and hw video codecs.
     *
     * <p>Measurements are taken 5 * 2(sync/async) * [1 or 2]
     * (surface/non-surface for video) times. This also logs the stats: min, max, avg of the codec
     * initialization latencies.
     */
    @LargeTest
    @Test(timeout = CodecTestBase.PER_TEST_TIMEOUT_LARGE_TEST_MS)
    @CddTest(requirements = {
        "2.2.7.1/5.1/H-1-7",
        "2.2.7.1/5.1/H-1-8",
        "2.2.7.1/5.1/H-1-12",
        "2.2.7.1/5.1/H-1-13",})
    public void testInitializationLatency() throws Exception {
        MediaCodec codec = MediaCodec.createByCodecName(mCodecName);
        boolean isEncoder = codec.getCodecInfo().isEncoder();
        boolean isAudio = mMime.startsWith("audio/");
        codec.release();
        final int NUM_MEASUREMENTS = 5;
        // Test gathers initialization latency for a number of iterations and
        // percentile is a variable used to control how many of these iterations
        // need to meet the pass criteria. For eg. if NUM_MEASUREMENTS = 5, audio, sync and Async
        // modes which is a total of 10 iterations, this translates to index 7.
        final int percentile = 70;
        long sumOfCodecInitializationLatencyMs = 0;
        int count = 0;
        int numOfActualMeasurements =
                NUM_MEASUREMENTS * boolStates.length * ((!isEncoder && !isAudio) ? 2 : 1);
        long[] codecInitializationLatencyMs = new long[numOfActualMeasurements];
        for (int i = 0; i < NUM_MEASUREMENTS; i++) {
            for (boolean isAsync : boolStates) {
                long latency;
                if (isEncoder) {
                    EncoderInitializationLatency encoderInitializationLatency =
                            new EncoderInitializationLatency(mMime, mCodecName, isAsync);
                    latency = encoderInitializationLatency.calculateInitLatency();
                    codecInitializationLatencyMs[count] = latency;
                    sumOfCodecInitializationLatencyMs += latency;
                    count++;
                } else {
                    String testFile = mTestFiles.get(mMime);
                    assumeTrue("Add test vector for media type: " + mMime, testFile != null);
                    if (isAudio) {
                        DecoderInitializationLatency decoderInitializationLatency =
                                new DecoderInitializationLatency(mMime, mCodecName, testFile,
                                        isAsync, false);
                        latency = decoderInitializationLatency.calculateInitLatency();
                        codecInitializationLatencyMs[count] = latency;
                        sumOfCodecInitializationLatencyMs += latency;
                        count++;
                    } else {
                        for (boolean surfaceMode : boolStates) {
                            DecoderInitializationLatency decoderInitializationLatency =
                                    new DecoderInitializationLatency(mMime, mCodecName,
                                            testFile,
                                            isAsync, surfaceMode);
                            latency = decoderInitializationLatency.calculateInitLatency();
                            codecInitializationLatencyMs[count] = latency;
                            sumOfCodecInitializationLatencyMs += latency;
                            count++;
                        }
                    }
                }
            }
        }
        Arrays.sort(codecInitializationLatencyMs);

        String statsLog = String.format("CodecInitialization latency for mime: %s, " +
                "Codec: %s, in Ms :: ", mMime, mCodecName);
        Log.i(LOG_TAG, "Min " + statsLog + codecInitializationLatencyMs[0]);
        Log.i(LOG_TAG, "Max " + statsLog + codecInitializationLatencyMs[count - 1]);
        Log.i(LOG_TAG, "Avg " + statsLog + (sumOfCodecInitializationLatencyMs / count));
        long initializationLatency = codecInitializationLatencyMs[percentile * count / 100];

        PerformanceClassEvaluator pce = new PerformanceClassEvaluator(this.mTestName);
        PerformanceClassEvaluator.CodecInitLatencyRequirement r5_1__H_1_Latency =
            isEncoder ? isAudio ? pce.addR5_1__H_1_8() : pce.addR5_1__H_1_7()
                : isAudio ? pce.addR5_1__H_1_13() : pce.addR5_1__H_1_12();

        r5_1__H_1_Latency.setCodecInitLatencyMs(initializationLatency);

        pce.submitAndCheck();
    }

    /**
     * The following class calculates the encoder initialization latency (time for codec create +
     * configure).
     *
     * <p>And also logs the time taken by the encoder for:
     * (create + configure + start),
     * (create + configure + start + first frame to enqueue),
     * (create + configure + start + first frame to dequeue).
     */
    static class EncoderInitializationLatency extends CodecEncoderTestBase {
        private static final String LOG_TAG = EncoderInitializationLatency.class.getSimpleName();

        private final String mEncoderName;
        private final boolean mIsAsync;

        EncoderInitializationLatency(String mime, String encoderName, boolean isAsync) {
            super(mime);
            mEncoderName = encoderName;
            mIsAsync = isAsync;
            mSampleRate = 8000;
            mFrameRate = 60;
        }

        private MediaFormat setUpFormat() throws IOException {
            MediaFormat format = new MediaFormat();
            format.setString(MediaFormat.KEY_MIME, mMime);
            if (mIsAudio) {
                if (mMime.equals(MediaFormat.MIMETYPE_AUDIO_FLAC)) {
                    format.setInteger(MediaFormat.KEY_FLAC_COMPRESSION_LEVEL, 10000);
                } else {
                    format.setInteger(MediaFormat.KEY_BIT_RATE, 128000);
                }
                format.setInteger(MediaFormat.KEY_SAMPLE_RATE, mSampleRate);
                format.setInteger(MediaFormat.KEY_CHANNEL_COUNT, 1);
            } else {
                MediaCodec codec = MediaCodec.createByCodecName(mEncoderName);
                MediaCodecInfo.CodecCapabilities codecCapabilities =
                        codec.getCodecInfo().getCapabilitiesForType(mMime);
                if (codecCapabilities.getVideoCapabilities().isSizeSupported(1920, 1080)) {
                    format.setInteger(MediaFormat.KEY_WIDTH, 1920);
                    format.setInteger(MediaFormat.KEY_HEIGHT, 1080);
                    format.setInteger(MediaFormat.KEY_BIT_RATE, 8000000);
                } else if (codecCapabilities.getVideoCapabilities().isSizeSupported(1280, 720)) {
                    format.setInteger(MediaFormat.KEY_WIDTH, 1280);
                    format.setInteger(MediaFormat.KEY_HEIGHT, 720);
                    format.setInteger(MediaFormat.KEY_BIT_RATE, 5000000);
                } else if (codecCapabilities.getVideoCapabilities().isSizeSupported(640, 480)) {
                    format.setInteger(MediaFormat.KEY_WIDTH, 640);
                    format.setInteger(MediaFormat.KEY_HEIGHT, 480);
                    format.setInteger(MediaFormat.KEY_BIT_RATE, 2000000);
                } else if (codecCapabilities.getVideoCapabilities().isSizeSupported(352, 288)) {
                    format.setInteger(MediaFormat.KEY_WIDTH, 352);
                    format.setInteger(MediaFormat.KEY_HEIGHT, 288);
                    format.setInteger(MediaFormat.KEY_BIT_RATE, 512000);
                } else {
                    format.setInteger(MediaFormat.KEY_WIDTH, 176);
                    format.setInteger(MediaFormat.KEY_HEIGHT, 144);
                    format.setInteger(MediaFormat.KEY_BIT_RATE, 128000);
                }
                codec.release();
                format.setInteger(MediaFormat.KEY_FRAME_RATE, mFrameRate);
                format.setFloat(MediaFormat.KEY_I_FRAME_INTERVAL, 1.0f);
                format.setInteger(MediaFormat.KEY_COLOR_FORMAT,
                        MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Flexible);
            }
            return format;
        }

        public long calculateInitLatency() throws Exception {
            MediaFormat format = setUpFormat();
            if (mIsAudio) {
                mSampleRate = format.getInteger(MediaFormat.KEY_SAMPLE_RATE);
                mChannels = format.getInteger(MediaFormat.KEY_CHANNEL_COUNT);
            } else {
                mWidth = format.getInteger(MediaFormat.KEY_WIDTH);
                mHeight = format.getInteger(MediaFormat.KEY_HEIGHT);
            }
            setUpSource(mInputFile);
            MediaCodec.BufferInfo outInfo = new MediaCodec.BufferInfo();
            long enqueueTimeStamp = 0;
            long dequeueTimeStamp = 0;
            long baseTimeStamp = System.nanoTime();
            mCodec = MediaCodec.createByCodecName(mEncoderName);
            resetContext(mIsAsync, false);
            mAsyncHandle.setCallBack(mCodec, mIsAsync);
            mCodec.configure(format, null, MediaCodec.CONFIGURE_FLAG_ENCODE, null);
            long configureTimeStamp = System.nanoTime();
            mCodec.start();
            long startTimeStamp = System.nanoTime();
            if (mIsAsync) {
                // We will keep on feeding the input to encoder until we see the first dequeued
                // frame.
                while (!mAsyncHandle.hasSeenError() && !mSawInputEOS) {
                    Pair<Integer, MediaCodec.BufferInfo> element = mAsyncHandle.getWork();
                    if (element != null) {
                        int bufferID = element.first;
                        MediaCodec.BufferInfo info = element.second;
                        if (info != null) {
                            dequeueTimeStamp = System.nanoTime();
                            dequeueOutput(bufferID, info);
                            break;
                        } else {
                            if (enqueueTimeStamp == 0) {
                                enqueueTimeStamp = System.nanoTime();
                            }
                            enqueueInput(bufferID);
                        }
                    }
                }
            } else {
                while (!mSawOutputEOS) {
                    if (!mSawInputEOS) {
                        int inputBufferId = mCodec.dequeueInputBuffer(Q_DEQ_TIMEOUT_US);
                        if (inputBufferId > 0) {
                            if (enqueueTimeStamp == 0) {
                                enqueueTimeStamp = System.nanoTime();
                            }
                            enqueueInput(inputBufferId);
                        }
                    }
                    int outputBufferId = mCodec.dequeueOutputBuffer(outInfo, Q_DEQ_TIMEOUT_US);
                    if (outputBufferId >= 0) {
                        dequeueTimeStamp = System.nanoTime();
                        dequeueOutput(outputBufferId, outInfo);
                        break;
                    }
                }
            }
            queueEOS();
            waitForAllOutputs();
            mCodec.stop();
            mCodec.release();
            Log.d(LOG_TAG, "Encode Mime: " + mMime + " Encoder: " + mEncoderName +
                    " Time for (create + configure) in ns: " +
                    (configureTimeStamp - baseTimeStamp));
            Log.d(LOG_TAG, "Encode Mime: " + mMime + " Encoder: " + mEncoderName +
                    " Time for (create + configure + start) in ns: " +
                    (startTimeStamp - baseTimeStamp));
            Log.d(LOG_TAG, "Encode Mime: " + mMime + " Encoder: " + mEncoderName +
                    " Time for (create + configure + start + first frame to enqueue) in ns: " +
                    (enqueueTimeStamp - baseTimeStamp));
            Log.d(LOG_TAG, "Encode Mime: " + mMime + " Encoder: " + mEncoderName +
                    " Time for (create + configure + start + first frame to dequeue) in ns: " +
                    (dequeueTimeStamp - baseTimeStamp));
            long timeToConfigureMs = (configureTimeStamp - baseTimeStamp) / 1000000;
            return timeToConfigureMs;
        }
    }

    /**
     * The following class calculates the decoder initialization latency (time for codec create +
     * configure).
     * And also logs the time taken by the decoder for:
     * (create + configure + start),
     * (create + configure + start + first frame to enqueue),
     * (create + configure + start + first frame to dequeue).
     */
    static class DecoderInitializationLatency extends CodecDecoderTestBase {
        private static final String LOG_TAG = DecoderInitializationLatency.class.getSimpleName();

        private final String mDecoderName;
        private final boolean mIsAsync;

        DecoderInitializationLatency(String mediaType, String decoderName, String testFile,
                boolean isAsync, boolean surfaceMode) {
            super(mediaType, testFile);
            mDecoderName = decoderName;
            mIsAsync = isAsync;
            mSurface = mIsAudio ? null :
                    surfaceMode ? MediaCodec.createPersistentInputSurface() : null;
        }

        public long calculateInitLatency() throws Exception {
            MediaCodec.BufferInfo outInfo = new MediaCodec.BufferInfo();
            MediaFormat format = setUpSource(mTestFile);
            long enqueueTimeStamp = 0;
            long dequeueTimeStamp = 0;
            long baseTimeStamp = System.nanoTime();
            mCodec = MediaCodec.createByCodecName(mDecoderName);
            resetContext(mIsAsync, false);
            mAsyncHandle.setCallBack(mCodec, mIsAsync);
            mCodec.configure(format, mSurface, 0, null);
            long configureTimeStamp = System.nanoTime();
            mCodec.start();
            long startTimeStamp = System.nanoTime();
            if (mIsAsync) {
                // We will keep on feeding the input to decoder until we see the first dequeued
                // frame.
                while (!mAsyncHandle.hasSeenError() && !mSawInputEOS) {
                    Pair<Integer, MediaCodec.BufferInfo> element = mAsyncHandle.getWork();
                    if (element != null) {
                        int bufferID = element.first;
                        MediaCodec.BufferInfo info = element.second;
                        if (info != null) {
                            dequeueTimeStamp = System.nanoTime();
                            dequeueOutput(bufferID, info);
                            break;
                        } else {
                            if (enqueueTimeStamp == 0) {
                                enqueueTimeStamp = System.nanoTime();
                            }
                            enqueueInput(bufferID);
                        }
                    }
                }
            } else {
                while (!mSawOutputEOS) {
                    if (!mSawInputEOS) {
                        int inputBufferId = mCodec.dequeueInputBuffer(Q_DEQ_TIMEOUT_US);
                        if (inputBufferId >= 0) {
                            if (enqueueTimeStamp == 0) {
                                enqueueTimeStamp = System.nanoTime();
                            }
                            enqueueInput(inputBufferId);
                        }
                    }
                    int outputBufferId = mCodec.dequeueOutputBuffer(outInfo, Q_DEQ_TIMEOUT_US);
                    if (outputBufferId >= 0) {
                        dequeueTimeStamp = System.nanoTime();
                        dequeueOutput(outputBufferId, outInfo);
                        break;
                    }
                }
            }
            queueEOS();
            waitForAllOutputs();
            mCodec.stop();
            mCodec.release();
            if (mSurface != null) {
                mSurface.release();
            }
            Log.d(LOG_TAG, "Decode Mime: " + mMime + " Decoder: " + mDecoderName +
                    " Time for (create + configure) in ns: " +
                    (configureTimeStamp - baseTimeStamp));
            Log.d(LOG_TAG, "Decode Mime: " + mMime + " Decoder: " + mDecoderName +
                    " Time for (create + configure + start) in ns: " +
                    (startTimeStamp - baseTimeStamp));
            Log.d(LOG_TAG, "Decode Mime: " + mMime + " Decoder: " + mDecoderName +
                    " Time for (create + configure + start + first frame to enqueue) in ns: " +
                    (enqueueTimeStamp - baseTimeStamp));
            Log.d(LOG_TAG, "Decode Mime: " + mMime + " Decoder: " + mDecoderName +
                    " Time for (create + configure + start + first frame to dequeue) in ns: " +
                    (dequeueTimeStamp - baseTimeStamp));
            long timeToConfigureMs = (configureTimeStamp - baseTimeStamp) / 1000000;
            return timeToConfigureMs;
        }
    }
}