/*
 * Copyright (C) 2013 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 com.android.cts.videoperf;

import android.cts.util.MediaUtils;
import android.cts.util.DeviceReportLog;
import android.graphics.ImageFormat;
import android.graphics.Point;
import android.media.cts.CodecImage;
import android.media.cts.CodecUtils;
import android.media.Image;
import android.media.Image.Plane;
import android.media.MediaCodec;
import android.media.MediaCodec.BufferInfo;
import android.media.MediaCodecInfo;
import android.media.MediaCodecInfo.CodecCapabilities;
import android.media.MediaCodecList;
import android.media.MediaFormat;
import android.util.Log;
import android.util.Pair;
import android.util.Range;
import android.util.Size;

import android.cts.util.CtsAndroidTestCase;
import com.android.cts.util.ResultType;
import com.android.cts.util.ResultUnit;
import com.android.cts.util.Stat;
import com.android.cts.util.TimeoutReq;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.lang.System;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Random;
import java.util.Vector;

/**
 * This tries to test video encoder / decoder performance by running encoding / decoding
 * without displaying the raw data. To make things simpler, encoder is used to encode synthetic
 * data and decoder is used to decode the encoded video. This approach does not work where
 * there is only decoder. Performance index is total time taken for encoding and decoding
 * the whole frames.
 * To prevent sacrificing quality for faster encoding / decoding, randomly selected pixels are
 * compared with the original image. As the pixel comparison can slow down the decoding process,
 * only some randomly selected pixels are compared. As there can be only one performance index,
 * error above certain threshold in pixel value will be treated as an error.
 */
public class VideoEncoderDecoderTest extends CtsAndroidTestCase {
    private static final String TAG = "VideoEncoderDecoderTest";
    // this wait time affects fps as too big value will work as a blocker if device fps
    // is not very high.
    private static final long VIDEO_CODEC_WAIT_TIME_US = 5000;
    private static final boolean VERBOSE = false;
    private static final String VIDEO_AVC = MediaFormat.MIMETYPE_VIDEO_AVC;
    private static final String VIDEO_VP8 = MediaFormat.MIMETYPE_VIDEO_VP8;
    private static final String VIDEO_H263 = MediaFormat.MIMETYPE_VIDEO_H263;
    private static final String VIDEO_MPEG4 = MediaFormat.MIMETYPE_VIDEO_MPEG4;
    private int mCurrentTestRound = 0;
    private double[][] mEncoderFrameTimeDiff = null;
    private double[][] mDecoderFrameTimeDiff = null;
    // i frame interval for encoder
    private static final int KEY_I_FRAME_INTERVAL = 5;
    private static final int MOVING_AVERAGE_NUM = 10;

    private static final int Y_CLAMP_MIN = 16;
    private static final int Y_CLAMP_MAX = 235;
    private static final int YUV_PLANE_ADDITIONAL_LENGTH = 200;
    private ByteBuffer mYBuffer, mYDirectBuffer;
    private ByteBuffer mUVBuffer, mUVDirectBuffer;
    private int mSrcColorFormat;
    private int mDstColorFormat;
    private int mBufferWidth;
    private int mBufferHeight;
    private int mVideoWidth;
    private int mVideoHeight;
    private int mFrameRate;

    private MediaFormat mEncInputFormat;
    private MediaFormat mEncOutputFormat;
    private MediaFormat mDecOutputFormat;

    private LinkedList<Pair<ByteBuffer, BufferInfo>> mEncodedOutputBuffer;
    // check this many pixels per each decoded frame
    // checking too many points decreases decoder frame rates a lot.
    private static final int PIXEL_CHECK_PER_FRAME = 1000;
    // RMS error in pixel values above this will be treated as error.
    private static final double PIXEL_RMS_ERROR_MARGAIN = 20.0;
    private double mRmsErrorMargain = PIXEL_RMS_ERROR_MARGAIN;
    private Random mRandom;

    private class TestConfig {
        public boolean mTestPixels = true;
        public boolean mTestResult = false;
        public boolean mReportFrameTime = false;
        public int mTotalFrames = 300;
        public int mMaxTimeMs = 120000;  // 2 minutes
        public int mNumberOfRepeat = 10;
    }

    private TestConfig mTestConfig;

    private DeviceReportLog mReportLog;

    @Override
    protected void setUp() throws Exception {
        mEncodedOutputBuffer = new LinkedList<Pair<ByteBuffer, BufferInfo>>();
        // Use time as a seed, hoping to prevent checking pixels in the same pattern
        long now = System.currentTimeMillis();
        mRandom = new Random(now);
        mTestConfig = new TestConfig();
        mReportLog = new DeviceReportLog();
        super.setUp();
    }

    @Override
    protected void tearDown() throws Exception {
        mEncodedOutputBuffer.clear();
        mEncodedOutputBuffer = null;
        mYBuffer = null;
        mUVBuffer = null;
        mYDirectBuffer = null;
        mUVDirectBuffer = null;
        mRandom = null;
        mTestConfig = null;
        mReportLog.deliverReportToHost(getInstrumentation());
        super.tearDown();
    }

    private String getEncoderName(String mime) {
        return getCodecName(mime, true /* isEncoder */);
    }

    private String getDecoderName(String mime) {
        return getCodecName(mime, false /* isEncoder */);
    }

    private String getCodecName(String mime, boolean isEncoder) {
        MediaCodecList mcl = new MediaCodecList(MediaCodecList.REGULAR_CODECS);
        for (MediaCodecInfo info : mcl.getCodecInfos()) {
            if (info.isEncoder() != isEncoder) {
                continue;
            }
            CodecCapabilities caps = null;
            try {
                caps = info.getCapabilitiesForType(mime);
            } catch (IllegalArgumentException e) {  // mime is not supported
                continue;
            }
            return info.getName();
        }
        return null;
    }

    private String[] getEncoderName(String mime, boolean isGoog) {
        return getCodecName(mime, isGoog, true /* isEncoder */);
    }

    private String[] getDecoderName(String mime, boolean isGoog) {
        return getCodecName(mime, isGoog, false /* isEncoder */);
    }

    private String[] getCodecName(String mime, boolean isGoog, boolean isEncoder) {
        MediaCodecList mcl = new MediaCodecList(MediaCodecList.REGULAR_CODECS);
        ArrayList<String> result = new ArrayList<String>();
        for (MediaCodecInfo info : mcl.getCodecInfos()) {
            if (info.isEncoder() != isEncoder
                    || info.getName().toLowerCase().startsWith("omx.google.") != isGoog) {
                continue;
            }
            CodecCapabilities caps = null;
            try {
                caps = info.getCapabilitiesForType(mime);
            } catch (IllegalArgumentException e) {  // mime is not supported
                continue;
            }
            result.add(info.getName());
        }
        return result.toArray(new String[result.size()]);
    }

    public void testAvc0176x0144() throws Exception {
        doTestDefault(VIDEO_AVC, 176, 144);
    }

    public void testAvc0352x0288() throws Exception {
        doTestDefault(VIDEO_AVC, 352, 288);
    }

    public void testAvc0720x0480() throws Exception {
        doTestDefault(VIDEO_AVC, 720, 480);
    }

    public void testAvc1280x0720() throws Exception {
        doTestDefault(VIDEO_AVC, 1280, 720);
    }

    /**
     * resolution intentionally set to 1072 not 1080
     * as 1080 is not multiple of 16, and it requires additional setting like stride
     * which is not specified in API documentation.
     */
    public void testAvc1920x1072() throws Exception {
        doTestDefault(VIDEO_AVC, 1920, 1072);
    }

    // Avc tests
    public void testAvc0320x0240Other() throws Exception {
        doTestOther(VIDEO_AVC, 320, 240);
    }

    public void testAvc0320x0240Goog() throws Exception {
        doTestGoog(VIDEO_AVC, 320, 240);
    }

    public void testAvc0720x0480Other() throws Exception {
        doTestOther(VIDEO_AVC, 720, 480);
    }

    public void testAvc0720x0480Goog() throws Exception {
        doTestGoog(VIDEO_AVC, 720, 480);
    }

    @TimeoutReq(minutes = 10)
    public void testAvc1280x0720Other() throws Exception {
        doTestOther(VIDEO_AVC, 1280, 720);
    }

    @TimeoutReq(minutes = 10)
    public void testAvc1280x0720Goog() throws Exception {
        doTestGoog(VIDEO_AVC, 1280, 720);
    }

    @TimeoutReq(minutes = 10)
    public void testAvc1920x1080Other() throws Exception {
        doTestOther(VIDEO_AVC, 1920, 1080);
    }

    @TimeoutReq(minutes = 10)
    public void testAvc1920x1080Goog() throws Exception {
        doTestGoog(VIDEO_AVC, 1920, 1080);
    }

    // Vp8 tests
    public void testVp80320x0180Other() throws Exception {
        doTestOther(VIDEO_VP8, 320, 180);
    }

    public void testVp80320x0180Goog() throws Exception {
        doTestGoog(VIDEO_VP8, 320, 180);
    }

    public void testVp80640x0360Other() throws Exception {
        doTestOther(VIDEO_VP8, 640, 360);
    }

    public void testVp80640x0360Goog() throws Exception {
        doTestGoog(VIDEO_VP8, 640, 360);
    }

    @TimeoutReq(minutes = 10)
    public void testVp81280x0720Other() throws Exception {
        doTestOther(VIDEO_VP8, 1280, 720);
    }

    @TimeoutReq(minutes = 10)
    public void testVp81280x0720Goog() throws Exception {
        doTestGoog(VIDEO_VP8, 1280, 720);
    }

    @TimeoutReq(minutes = 10)
    public void testVp81920x1080Other() throws Exception {
        doTestOther(VIDEO_VP8, 1920, 1080);
    }

    @TimeoutReq(minutes = 10)
    public void testVp81920x1080Goog() throws Exception {
        doTestGoog(VIDEO_VP8, 1920, 1080);
    }

    // H263 tests
    public void testH2630176x0144Other() throws Exception {
        doTestOther(VIDEO_H263, 176, 144);
    }

    public void testH2630176x0144Goog() throws Exception {
        doTestGoog(VIDEO_H263, 176, 144);
    }

    public void testH2630352x0288Other() throws Exception {
        doTestOther(VIDEO_H263, 352, 288);
    }

    public void testH2630352x0288Goog() throws Exception {
        doTestGoog(VIDEO_H263, 352, 288);
    }

    // Mpeg4 tests
    public void testMpeg40176x0144Other() throws Exception {
        doTestOther(VIDEO_MPEG4, 176, 144);
    }

    public void testMpeg40176x0144Goog() throws Exception {
        doTestGoog(VIDEO_MPEG4, 176, 144);
    }

    public void testMpeg40352x0288Other() throws Exception {
        doTestOther(VIDEO_MPEG4, 352, 288);
    }

    public void testMpeg40352x0288Goog() throws Exception {
        doTestGoog(VIDEO_MPEG4, 352, 288);
    }

    public void testMpeg40640x0480Other() throws Exception {
        doTestOther(VIDEO_MPEG4, 640, 480);
    }

    public void testMpeg40640x0480Goog() throws Exception {
        doTestGoog(VIDEO_MPEG4, 640, 480);
    }

    @TimeoutReq(minutes = 10)
    public void testMpeg41280x0720Other() throws Exception {
        doTestOther(VIDEO_MPEG4, 1280, 720);
    }

    @TimeoutReq(minutes = 10)
    public void testMpeg41280x0720Goog() throws Exception {
        doTestGoog(VIDEO_MPEG4, 1280, 720);
    }

    private boolean isSrcSemiPlanar() {
        return mSrcColorFormat == CodecCapabilities.COLOR_FormatYUV420SemiPlanar;
    }

    private boolean isSrcFlexYUV() {
        return mSrcColorFormat == CodecCapabilities.COLOR_FormatYUV420Flexible;
    }

    private boolean isDstSemiPlanar() {
        return mDstColorFormat == CodecCapabilities.COLOR_FormatYUV420SemiPlanar;
    }

    private boolean isDstFlexYUV() {
        return mDstColorFormat == CodecCapabilities.COLOR_FormatYUV420Flexible;
    }

    private static int getColorFormat(CodecInfo info) {
        if (info.mSupportSemiPlanar) {
            return CodecCapabilities.COLOR_FormatYUV420SemiPlanar;
        } else if (info.mSupportPlanar) {
            return CodecCapabilities.COLOR_FormatYUV420Planar;
        } else {
            // FlexYUV must be supported
            return CodecCapabilities.COLOR_FormatYUV420Flexible;
        }
    }

    private void doTestGoog(String mimeType, int w, int h) throws Exception {
        mTestConfig.mTestPixels = false;
        mTestConfig.mTestResult = true;
        mTestConfig.mTotalFrames = 3000;
        mTestConfig.mNumberOfRepeat = 2;
        doTest(true /* isGoog */, mimeType, w, h);
    }

    private void doTestOther(String mimeType, int w, int h) throws Exception {
        mTestConfig.mTestPixels = false;
        mTestConfig.mTestResult = true;
        mTestConfig.mTotalFrames = 3000;
        mTestConfig.mNumberOfRepeat = 2;
        doTest(false /* isGoog */, mimeType, w, h);
    }

    private void doTestDefault(String mimeType, int w, int h) throws Exception {
        String encoderName = getEncoderName(mimeType);
        if (encoderName == null) {
            Log.i(TAG, "Encoder for " + mimeType + " not found");
            return;
        }

        String decoderName = getDecoderName(mimeType);
        if (decoderName == null) {
            Log.i(TAG, "Encoder for " + mimeType + " not found");
            return;
        }

        doTestByName(encoderName, decoderName, mimeType, w, h);
    }

    /**
     * Run encoding / decoding test for given mimeType of codec
     * @param isGoog test google or non-google codec.
     * @param mimeType like video/avc
     * @param w video width
     * @param h video height
     */
    private void doTest(boolean isGoog, String mimeType, int w, int h)
            throws Exception {
        String[] encoderNames = getEncoderName(mimeType, isGoog);
        if (encoderNames.length == 0) {
            Log.i(TAG, isGoog ? "Google " : "Non-google "
                    + "encoder for " + mimeType + " not found");
            return;
        }

        String[] decoderNames = getDecoderName(mimeType, isGoog);
        if (decoderNames.length == 0) {
            Log.i(TAG, isGoog ? "Google " : "Non-google "
                    + "decoder for " + mimeType + " not found");
            return;
        }

        for (String encoderName: encoderNames) {
            for (String decoderName: decoderNames) {
                doTestByName(encoderName, decoderName, mimeType, w, h);
            }
        }
    }

    private void doTestByName(
            String encoderName, String decoderName, String mimeType, int w, int h)
            throws Exception {
        CodecInfo infoEnc = CodecInfo.getSupportedFormatInfo(encoderName, mimeType, w, h);
        if (infoEnc == null) {
            Log.i(TAG, "Encoder " + mimeType + " with " + w + "," + h + " not supported");
            return;
        }
        CodecInfo infoDec = CodecInfo.getSupportedFormatInfo(decoderName, mimeType, w, h);
        assertNotNull(infoDec);
        mVideoWidth = w;
        mVideoHeight = h;

        mSrcColorFormat = getColorFormat(infoEnc);
        mDstColorFormat = getColorFormat(infoDec);
        Log.i(TAG, "Testing video resolution " + w + "x" + h +
                   ": enc format " + mSrcColorFormat +
                   ", dec format " + mDstColorFormat);

        initYUVPlane(w + YUV_PLANE_ADDITIONAL_LENGTH, h + YUV_PLANE_ADDITIONAL_LENGTH);
        mEncoderFrameTimeDiff =
                new double[mTestConfig.mNumberOfRepeat][mTestConfig.mTotalFrames - 1];
        mDecoderFrameTimeDiff =
                new double[mTestConfig.mNumberOfRepeat][mTestConfig.mTotalFrames - 1];
        double[] encoderFpsResults = new double[mTestConfig.mNumberOfRepeat];
        double[] decoderFpsResults = new double[mTestConfig.mNumberOfRepeat];
        double[] totalFpsResults = new double[mTestConfig.mNumberOfRepeat];
        double[] decoderRmsErrorResults = new double[mTestConfig.mNumberOfRepeat];
        boolean success = true;
        for (int i = 0; i < mTestConfig.mNumberOfRepeat && success; i++) {
            mCurrentTestRound = i;
            MediaFormat format = new MediaFormat();
            format.setString(MediaFormat.KEY_MIME, mimeType);
            format.setInteger(MediaFormat.KEY_BIT_RATE, infoEnc.mBitRate);
            format.setInteger(MediaFormat.KEY_WIDTH, w);
            format.setInteger(MediaFormat.KEY_HEIGHT, h);
            format.setInteger(MediaFormat.KEY_COLOR_FORMAT, mSrcColorFormat);
            format.setInteger(MediaFormat.KEY_FRAME_RATE, infoEnc.mFps);
            mFrameRate = infoEnc.mFps;
            format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, KEY_I_FRAME_INTERVAL);

            double encodingTime = runEncoder(encoderName, format, mTestConfig.mTotalFrames);
            // re-initialize format for decoder
            format = new MediaFormat();
            format.setString(MediaFormat.KEY_MIME, mimeType);
            format.setInteger(MediaFormat.KEY_WIDTH, w);
            format.setInteger(MediaFormat.KEY_HEIGHT, h);
            format.setInteger(MediaFormat.KEY_COLOR_FORMAT, mDstColorFormat);
            double[] decoderResult = runDecoder(decoderName, format);
            if (decoderResult == null) {
                success = false;
            } else {
                double decodingTime = decoderResult[0];
                decoderRmsErrorResults[i] = decoderResult[1];
                encoderFpsResults[i] = (double)mTestConfig.mTotalFrames / encodingTime * 1000.0;
                decoderFpsResults[i] = (double)mTestConfig.mTotalFrames / decodingTime * 1000.0;
                totalFpsResults[i] =
                        (double)mTestConfig.mTotalFrames / (encodingTime + decodingTime) * 1000.0;
            }

            // clear things for re-start
            mEncodedOutputBuffer.clear();
            // it will be good to clean everything to make every run the same.
            System.gc();
        }
        mReportLog.printArray("encoder", encoderFpsResults, ResultType.HIGHER_BETTER,
                ResultUnit.FPS);
        mReportLog.printArray("rms error", decoderRmsErrorResults, ResultType.LOWER_BETTER,
                ResultUnit.NONE);
        mReportLog.printArray("decoder", decoderFpsResults, ResultType.HIGHER_BETTER,
                ResultUnit.FPS);
        mReportLog.printArray("encoder decoder", totalFpsResults, ResultType.HIGHER_BETTER,
                ResultUnit.FPS);
        mReportLog.printValue(mimeType + " encoder average fps for " + w + "x" + h,
                Stat.getAverage(encoderFpsResults), ResultType.HIGHER_BETTER, ResultUnit.FPS);
        mReportLog.printValue(mimeType + " decoder average fps for " + w + "x" + h,
                Stat.getAverage(decoderFpsResults), ResultType.HIGHER_BETTER, ResultUnit.FPS);
        mReportLog.printSummary("encoder decoder", Stat.getAverage(totalFpsResults),
                ResultType.HIGHER_BETTER, ResultUnit.FPS);

        boolean encTestPassed = false;
        boolean decTestPassed = false;
        for (int i = 0; i < mTestConfig.mNumberOfRepeat; i++) {
            // make sure that rms error is not too big.
            if (decoderRmsErrorResults[i] >= mRmsErrorMargain) {
                fail("rms error is bigger than the limit "
                        + decoderRmsErrorResults[i] + " vs " + mRmsErrorMargain);
            }

            if (mTestConfig.mReportFrameTime) {
                mReportLog.printValue(
                        "encodertest#" + i + ": " + Arrays.toString(mEncoderFrameTimeDiff[i]),
                        0, ResultType.NEUTRAL, ResultUnit.NONE);
                mReportLog.printValue(
                        "decodertest#" + i + ": " + Arrays.toString(mDecoderFrameTimeDiff[i]),
                        0, ResultType.NEUTRAL, ResultUnit.NONE);
            }

            if (mTestConfig.mTestResult) {
                double[] avgs = MediaUtils.calculateMovingAverage(
                        mEncoderFrameTimeDiff[i], MOVING_AVERAGE_NUM);
                double encMin = Stat.getMin(avgs);
                double encMax = Stat.getMax(avgs);
                double encAvg = MediaUtils.getAverage(mEncoderFrameTimeDiff[i]);
                double encStdev = MediaUtils.getStdev(avgs);
                String prefix = "codec=" + encoderName + " round=" + i +
                        " EncInputFormat=" + mEncInputFormat +
                        " EncOutputFormat=" + mEncOutputFormat;
                MediaUtils.logResults(mReportLog, prefix, encMin, encMax, encAvg, encStdev);
                double measuredEncFps = 1000000000 / encMin;
                if (!encTestPassed) {
                    encTestPassed = MediaUtils.verifyResults(
                            encoderName, mimeType, w, h, measuredEncFps);
                }

                avgs = MediaUtils.calculateMovingAverage(
                        mDecoderFrameTimeDiff[i], MOVING_AVERAGE_NUM);
                double decMin = Stat.getMin(avgs);
                double decMax = Stat.getMax(avgs);
                double decAvg = MediaUtils.getAverage(mDecoderFrameTimeDiff[i]);
                double decStdev = MediaUtils.getStdev(avgs);
                prefix = "codec=" + decoderName + " size=" + w + "x" + h + " round=" + i +
                        " DecOutputFormat=" + mDecOutputFormat;
                MediaUtils.logResults(mReportLog, prefix, decMin, decMax, decAvg, decStdev);
                double measuredDecFps = 1000000000 / decMin;
                if (!decTestPassed) {
                    decTestPassed = MediaUtils.verifyResults(
                            decoderName, mimeType, w, h, measuredDecFps);
                }
            }
        }
        if (mTestConfig.mTestResult) {
            if (!encTestPassed) {
                fail("Measured fps for " + encoderName +
                        " doesn't match with reported achievable frame rates.");
            }
            // Decoder result will be verified in VideoDecoderPerfTest
            // if (!decTestPassed) {
            //     fail("Measured fps for " + decoderName +
            //             " doesn't match with reported achievable frame rates.");
            // }
        }
    }

    /**
     * run encoder benchmarking
     * @param encoderName encoder name
     * @param format format of media to encode
     * @param totalFrames total number of frames to encode
     * @return time taken in ms to encode the frames. This does not include initialization time.
     */
    private double runEncoder(String encoderName, MediaFormat format, int totalFrames) {
        MediaCodec codec = null;
        try {
            codec = MediaCodec.createByCodecName(encoderName);
            codec.configure(
                    format,
                    null /* surface */,
                    null /* crypto */,
                    MediaCodec.CONFIGURE_FLAG_ENCODE);
        } catch (IllegalStateException e) {
            Log.e(TAG, "codec '" + encoderName + "' failed configuration.");
            codec.release();
            assertTrue("codec '" + encoderName + "' failed configuration.", false);
        } catch (IOException | NullPointerException e) {
            Log.i(TAG, "could not find codec for " + format);
            return Double.NaN;
        }
        codec.start();
        mEncInputFormat = codec.getInputFormat();
        ByteBuffer[] codecOutputBuffers = codec.getOutputBuffers();

        int numBytesSubmitted = 0;
        int numBytesDequeued = 0;
        int inFramesCount = 0;
        long lastOutputTimeNs = 0;
        long start = System.currentTimeMillis();
        while (true) {
            int index;

            if (inFramesCount < totalFrames) {
                index = codec.dequeueInputBuffer(VIDEO_CODEC_WAIT_TIME_US /* timeoutUs */);
                if (index != MediaCodec.INFO_TRY_AGAIN_LATER) {
                    int size;
                    boolean eos = (inFramesCount == (totalFrames - 1));
                    if (!eos && ((System.currentTimeMillis() - start) > mTestConfig.mMaxTimeMs)) {
                        eos = true;
                    }
                    // when encoder only supports flexYUV, use Image only; otherwise,
                    // use ByteBuffer & Image each on half of the frames to test both
                    if (isSrcFlexYUV() || inFramesCount % 2 == 0) {
                        Image image = codec.getInputImage(index);
                        // image should always be available
                        assertTrue(image != null);
                        size = queueInputImageEncoder(
                                codec, image, index, inFramesCount,
                                eos ? MediaCodec.BUFFER_FLAG_END_OF_STREAM : 0);
                    } else {
                        ByteBuffer buffer = codec.getInputBuffer(index);
                        size = queueInputBufferEncoder(
                                codec, buffer, index, inFramesCount,
                                eos ? MediaCodec.BUFFER_FLAG_END_OF_STREAM : 0);
                    }
                    inFramesCount++;
                    numBytesSubmitted += size;
                    if (VERBOSE) {
                        Log.d(TAG, "queued " + size + " bytes of input data, frame " +
                                (inFramesCount - 1));
                    }

                }
            }
            MediaCodec.BufferInfo info = new MediaCodec.BufferInfo();
            index = codec.dequeueOutputBuffer(info, VIDEO_CODEC_WAIT_TIME_US /* timeoutUs */);
            if (index == MediaCodec.INFO_TRY_AGAIN_LATER) {
            } else if (index == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
                mEncOutputFormat = codec.getOutputFormat();
            } else if (index == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
                codecOutputBuffers = codec.getOutputBuffers();
            } else if (index >= 0) {
                if (lastOutputTimeNs > 0) {
                    int pos = mEncodedOutputBuffer.size() - 1;
                    if (pos < mEncoderFrameTimeDiff[mCurrentTestRound].length) {
                        long diff = System.nanoTime() - lastOutputTimeNs;
                        mEncoderFrameTimeDiff[mCurrentTestRound][pos] = diff;
                    }
                }
                lastOutputTimeNs = System.nanoTime();

                dequeueOutputBufferEncoder(codec, codecOutputBuffers, index, info);
                numBytesDequeued += info.size;
                if ((info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
                    if (VERBOSE) {
                        Log.d(TAG, "dequeued output EOS.");
                    }
                    break;
                }
                if (VERBOSE) {
                    Log.d(TAG, "dequeued " + info.size + " bytes of output data.");
                }
            }
        }
        long finish = System.currentTimeMillis();
        int validDataNum = Math.min(mEncodedOutputBuffer.size() - 1,
                mEncoderFrameTimeDiff[mCurrentTestRound].length);
        mEncoderFrameTimeDiff[mCurrentTestRound] =
                Arrays.copyOf(mEncoderFrameTimeDiff[mCurrentTestRound], validDataNum);
        if (VERBOSE) {
            Log.d(TAG, "queued a total of " + numBytesSubmitted + "bytes, "
                    + "dequeued " + numBytesDequeued + " bytes.");
        }
        codec.stop();
        codec.release();
        codec = null;
        return (double)(finish - start);
    }

    /**
     * Fills input buffer for encoder from YUV buffers.
     * @return size of enqueued data.
     */
    private int queueInputBufferEncoder(
            MediaCodec codec, ByteBuffer buffer, int index, int frameCount, int flags) {
        buffer.clear();

        Point origin = getOrigin(frameCount);
        // Y color first
        int srcOffsetY = origin.x + origin.y * mBufferWidth;
        final byte[] yBuffer = mYBuffer.array();
        for (int i = 0; i < mVideoHeight; i++) {
            buffer.put(yBuffer, srcOffsetY, mVideoWidth);
            srcOffsetY += mBufferWidth;
        }
        if (isSrcSemiPlanar()) {
            int srcOffsetU = origin.y / 2 * mBufferWidth + origin.x / 2 * 2;
            final byte[] uvBuffer = mUVBuffer.array();
            for (int i = 0; i < mVideoHeight / 2; i++) {
                buffer.put(uvBuffer, srcOffsetU, mVideoWidth);
                srcOffsetU += mBufferWidth;
            }
        } else {
            int srcOffsetU = origin.y / 2 * mBufferWidth / 2 + origin.x / 2;
            int srcOffsetV = srcOffsetU + mBufferWidth / 2 * mBufferHeight / 2;
            final byte[] uvBuffer = mUVBuffer.array();
            for (int i = 0; i < mVideoHeight / 2; i++) { //U only
                buffer.put(uvBuffer, srcOffsetU, mVideoWidth / 2);
                srcOffsetU += mBufferWidth / 2;
            }
            for (int i = 0; i < mVideoHeight / 2; i++) { //V only
                buffer.put(uvBuffer, srcOffsetV, mVideoWidth / 2);
                srcOffsetV += mBufferWidth / 2;
            }
        }
        int size = mVideoHeight * mVideoWidth * 3 / 2;
        long ptsUsec = computePresentationTime(frameCount);

        codec.queueInputBuffer(index, 0 /* offset */, size, ptsUsec /* timeUs */, flags);
        if (VERBOSE && (frameCount == 0)) {
            printByteArray("Y ", mYBuffer.array(), 0, 20);
            printByteArray("UV ", mUVBuffer.array(), 0, 20);
            printByteArray("UV ", mUVBuffer.array(), mBufferWidth * 60, 20);
        }
        return size;
    }

    class YUVImage extends CodecImage {
        private final int mImageWidth;
        private final int mImageHeight;
        private final Plane[] mPlanes;

        YUVImage(
                Point origin,
                int imageWidth, int imageHeight,
                int arrayWidth, int arrayHeight,
                boolean semiPlanar,
                ByteBuffer bufferY, ByteBuffer bufferUV) {
            mImageWidth = imageWidth;
            mImageHeight = imageHeight;
            ByteBuffer dupY = bufferY.duplicate();
            ByteBuffer dupUV = bufferUV.duplicate();
            mPlanes = new Plane[3];

            int srcOffsetY = origin.x + origin.y * arrayWidth;

            mPlanes[0] = new YUVPlane(
                        mImageWidth, mImageHeight, arrayWidth, 1,
                        dupY, srcOffsetY);

            if (semiPlanar) {
                int srcOffsetUV = origin.y / 2 * arrayWidth + origin.x / 2 * 2;

                mPlanes[1] = new YUVPlane(
                        mImageWidth / 2, mImageHeight / 2, arrayWidth, 2,
                        dupUV, srcOffsetUV);
                mPlanes[2] = new YUVPlane(
                        mImageWidth / 2, mImageHeight / 2, arrayWidth, 2,
                        dupUV, srcOffsetUV + 1);
            } else {
                int srcOffsetU = origin.y / 2 * arrayWidth / 2 + origin.x / 2;
                int srcOffsetV = srcOffsetU + arrayWidth / 2 * arrayHeight / 2;

                mPlanes[1] = new YUVPlane(
                        mImageWidth / 2, mImageHeight / 2, arrayWidth / 2, 1,
                        dupUV, srcOffsetU);
                mPlanes[2] = new YUVPlane(
                        mImageWidth / 2, mImageHeight / 2, arrayWidth / 2, 1,
                        dupUV, srcOffsetV);
            }
        }

        @Override
        public int getFormat() {
            return ImageFormat.YUV_420_888;
        }

        @Override
        public int getWidth() {
            return mImageWidth;
        }

        @Override
        public int getHeight() {
            return mImageHeight;
        }

        @Override
        public long getTimestamp() {
            return 0;
        }

        @Override
        public Plane[] getPlanes() {
            return mPlanes;
        }

        @Override
        public void close() {
            mPlanes[0] = null;
            mPlanes[1] = null;
            mPlanes[2] = null;
        }

        class YUVPlane extends CodecImage.Plane {
            private final int mRowStride;
            private final int mPixelStride;
            private final ByteBuffer mByteBuffer;

            YUVPlane(int w, int h, int rowStride, int pixelStride,
                    ByteBuffer buffer, int offset) {
                mRowStride = rowStride;
                mPixelStride = pixelStride;

                // only safe to access length bytes starting from buffer[offset]
                int length = (h - 1) * rowStride + (w - 1) * pixelStride + 1;

                buffer.position(offset);
                mByteBuffer = buffer.slice();
                mByteBuffer.limit(length);
            }

            @Override
            public int getRowStride() {
                return mRowStride;
            }

            @Override
            public int getPixelStride() {
                return mPixelStride;
            }

            @Override
            public ByteBuffer getBuffer() {
                return mByteBuffer;
            }
        }
    }

    /**
     * Fills input image for encoder from YUV buffers.
     * @return size of enqueued data.
     */
    private int queueInputImageEncoder(
            MediaCodec codec, Image image, int index, int frameCount, int flags) {
        assertTrue(image.getFormat() == ImageFormat.YUV_420_888);


        Point origin = getOrigin(frameCount);

        // Y color first
        CodecImage srcImage = new YUVImage(
                origin,
                mVideoWidth, mVideoHeight,
                mBufferWidth, mBufferHeight,
                isSrcSemiPlanar(),
                mYDirectBuffer, mUVDirectBuffer);

        CodecUtils.copyFlexYUVImage(image, srcImage);

        int size = mVideoHeight * mVideoWidth * 3 / 2;
        long ptsUsec = computePresentationTime(frameCount);

        codec.queueInputBuffer(index, 0 /* offset */, size, ptsUsec /* timeUs */, flags);
        if (VERBOSE && (frameCount == 0)) {
            printByteArray("Y ", mYBuffer.array(), 0, 20);
            printByteArray("UV ", mUVBuffer.array(), 0, 20);
            printByteArray("UV ", mUVBuffer.array(), mBufferWidth * 60, 20);
        }
        return size;
    }

    /**
     * Dequeue encoded data from output buffer and store for later usage.
     */
    private void dequeueOutputBufferEncoder(
            MediaCodec codec, ByteBuffer[] outputBuffers,
            int index, MediaCodec.BufferInfo info) {
        ByteBuffer output = outputBuffers[index];
        int l = info.size;
        ByteBuffer copied = ByteBuffer.allocate(l);
        output.get(copied.array(), 0, l);
        BufferInfo savedInfo = new BufferInfo();
        savedInfo.set(0, l, info.presentationTimeUs, info.flags);
        mEncodedOutputBuffer.addLast(Pair.create(copied, savedInfo));
        codec.releaseOutputBuffer(index, false /* render */);
    }

    /**
     * run encoder benchmarking with encoded stream stored from encoding phase
     * @param decoderName decoder name
     * @param format format of media to decode
     * @return returns length-2 array with 0: time for decoding, 1 : rms error of pixels
     */
    private double[] runDecoder(String decoderName, MediaFormat format) {
        MediaCodec codec = null;
        try {
            codec = MediaCodec.createByCodecName(decoderName);
        } catch (IOException | NullPointerException e) {
            Log.i(TAG, "could not find decoder for " + format);
            return null;
        }
        codec.configure(format, null /* surface */, null /* crypto */, 0 /* flags */);
        codec.start();
        ByteBuffer[] codecInputBuffers = codec.getInputBuffers();

        double totalErrorSquared = 0;

        MediaCodec.BufferInfo info = new MediaCodec.BufferInfo();
        boolean sawOutputEOS = false;
        int inputLeft = mEncodedOutputBuffer.size();
        int inputBufferCount = 0;
        int outFrameCount = 0;
        YUVValue expected = new YUVValue();
        YUVValue decoded = new YUVValue();
        long lastOutputTimeNs = 0;
        long start = System.currentTimeMillis();
        while (!sawOutputEOS) {
            if (inputLeft > 0) {
                int inputBufIndex = codec.dequeueInputBuffer(VIDEO_CODEC_WAIT_TIME_US);

                if (inputBufIndex >= 0) {
                    ByteBuffer dstBuf = codecInputBuffers[inputBufIndex];
                    dstBuf.clear();
                    ByteBuffer src = mEncodedOutputBuffer.get(inputBufferCount).first;
                    BufferInfo srcInfo = mEncodedOutputBuffer.get(inputBufferCount).second;
                    int writeSize = src.capacity();
                    dstBuf.put(src.array(), 0, writeSize);

                    int flags = srcInfo.flags;
                    if ((System.currentTimeMillis() - start) > mTestConfig.mMaxTimeMs) {
                        flags |= MediaCodec.BUFFER_FLAG_END_OF_STREAM;
                    }

                    codec.queueInputBuffer(
                            inputBufIndex,
                            0 /* offset */,
                            writeSize,
                            srcInfo.presentationTimeUs,
                            flags);
                    inputLeft --;
                    inputBufferCount ++;
                }
            }

            int res = codec.dequeueOutputBuffer(info, VIDEO_CODEC_WAIT_TIME_US);
            if (res >= 0) {
                int outputBufIndex = res;

                // only do YUV compare on EOS frame if the buffer size is none-zero
                if (info.size > 0) {
                    if (lastOutputTimeNs > 0) {
                        int pos = outFrameCount - 1;
                        if (pos < mDecoderFrameTimeDiff[mCurrentTestRound].length) {
                            long diff = System.nanoTime() - lastOutputTimeNs;
                            mDecoderFrameTimeDiff[mCurrentTestRound][pos] = diff;
                        }
                    }
                    lastOutputTimeNs = System.nanoTime();

                    if (mTestConfig.mTestPixels) {
                        Point origin = getOrigin(outFrameCount);
                        int i;

                        // if decoder supports planar or semiplanar, check output with
                        // ByteBuffer & Image each on half of the points
                        int pixelCheckPerFrame = PIXEL_CHECK_PER_FRAME;
                        if (!isDstFlexYUV()) {
                            pixelCheckPerFrame /= 2;
                            ByteBuffer buf = codec.getOutputBuffer(outputBufIndex);
                            if (VERBOSE && (outFrameCount == 0)) {
                                printByteBuffer("Y ", buf, 0, 20);
                                printByteBuffer("UV ", buf, mVideoWidth * mVideoHeight, 20);
                                printByteBuffer("UV ", buf,
                                        mVideoWidth * mVideoHeight + mVideoWidth * 60, 20);
                            }
                            for (i = 0; i < pixelCheckPerFrame; i++) {
                                int w = mRandom.nextInt(mVideoWidth);
                                int h = mRandom.nextInt(mVideoHeight);
                                getPixelValuesFromYUVBuffers(origin.x, origin.y, w, h, expected);
                                getPixelValuesFromOutputBuffer(buf, w, h, decoded);
                                if (VERBOSE) {
                                    Log.i(TAG, outFrameCount + "-" + i + "- th round: ByteBuffer:"
                                            + " expected "
                                            + expected.mY + "," + expected.mU + "," + expected.mV
                                            + " decoded "
                                            + decoded.mY + "," + decoded.mU + "," + decoded.mV);
                                }
                                totalErrorSquared += expected.calcErrorSquared(decoded);
                            }
                        }

                        Image image = codec.getOutputImage(outputBufIndex);
                        assertTrue(image != null);
                        for (i = 0; i < pixelCheckPerFrame; i++) {
                            int w = mRandom.nextInt(mVideoWidth);
                            int h = mRandom.nextInt(mVideoHeight);
                            getPixelValuesFromYUVBuffers(origin.x, origin.y, w, h, expected);
                            getPixelValuesFromImage(image, w, h, decoded);
                            if (VERBOSE) {
                                Log.i(TAG, outFrameCount + "-" + i + "- th round: FlexYUV:"
                                        + " expcted "
                                        + expected.mY + "," + expected.mU + "," + expected.mV
                                        + " decoded "
                                        + decoded.mY + "," + decoded.mU + "," + decoded.mV);
                            }
                            totalErrorSquared += expected.calcErrorSquared(decoded);
                        }
                    }
                    outFrameCount++;
                }
                codec.releaseOutputBuffer(outputBufIndex, false /* render */);
                if ((info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
                    Log.d(TAG, "saw output EOS.");
                    sawOutputEOS = true;
                }
            } else if (res == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
                mDecOutputFormat = codec.getOutputFormat();
                Log.d(TAG, "output format has changed to " + mDecOutputFormat);
                int colorFormat = mDecOutputFormat.getInteger(MediaFormat.KEY_COLOR_FORMAT);
                if (colorFormat == CodecCapabilities.COLOR_FormatYUV420SemiPlanar
                        || colorFormat == CodecCapabilities.COLOR_FormatYUV420Planar) {
                    mDstColorFormat = colorFormat;
                } else {
                    mDstColorFormat = CodecCapabilities.COLOR_FormatYUV420Flexible;
                    Log.w(TAG, "output format changed to unsupported one " +
                            Integer.toHexString(colorFormat) + ", using FlexYUV");
                }
            }
        }
        long finish = System.currentTimeMillis();
        int validDataNum = Math.min(outFrameCount - 1,
                mDecoderFrameTimeDiff[mCurrentTestRound].length);
        mDecoderFrameTimeDiff[mCurrentTestRound] =
                Arrays.copyOf(mDecoderFrameTimeDiff[mCurrentTestRound], validDataNum);
        codec.stop();
        codec.release();
        codec = null;

        // divide by 3 as sum is done for Y, U, V.
        double errorRms = Math.sqrt(totalErrorSquared / PIXEL_CHECK_PER_FRAME / outFrameCount / 3);
        double[] result = { (double) finish - start, errorRms };
        return result;
    }

    /**
     *  returns origin in the absolute frame for given frame count.
     *  The video scene is moving by moving origin per each frame.
     */
    private Point getOrigin(int frameCount) {
        if (frameCount < 100) {
            return new Point(2 * frameCount, 0);
        } else if (frameCount < 200) {
            return new Point(200, (frameCount - 100) * 2);
        } else {
            if (frameCount > 300) { // for safety
                frameCount = 300;
            }
            return new Point(600 - frameCount * 2, 600 - frameCount * 2);
        }
    }

    /**
     * initialize reference YUV plane
     * @param w This should be YUV_PLANE_ADDITIONAL_LENGTH pixels bigger than video resolution
     *          to allow movements
     * @param h This should be YUV_PLANE_ADDITIONAL_LENGTH pixels bigger than video resolution
     *          to allow movements
     * @param semiPlanarEnc
     * @param semiPlanarDec
     */
    private void initYUVPlane(int w, int h) {
        int bufferSizeY = w * h;
        mYBuffer = ByteBuffer.allocate(bufferSizeY);
        mUVBuffer = ByteBuffer.allocate(bufferSizeY / 2);
        mYDirectBuffer = ByteBuffer.allocateDirect(bufferSizeY);
        mUVDirectBuffer = ByteBuffer.allocateDirect(bufferSizeY / 2);
        mBufferWidth = w;
        mBufferHeight = h;
        final byte[] yArray = mYBuffer.array();
        final byte[] uvArray = mUVBuffer.array();
        for (int i = 0; i < h; i++) {
            for (int j = 0; j < w; j++) {
                yArray[i * w + j]  = clampY((i + j) & 0xff);
            }
        }
        if (isSrcSemiPlanar()) {
            for (int i = 0; i < h/2; i++) {
                for (int j = 0; j < w/2; j++) {
                    uvArray[i * w + 2 * j]  = (byte) (i & 0xff);
                    uvArray[i * w + 2 * j + 1]  = (byte) (j & 0xff);
                }
            }
        } else { // planar, U first, then V
            int vOffset = bufferSizeY / 4;
            for (int i = 0; i < h/2; i++) {
                for (int j = 0; j < w/2; j++) {
                    uvArray[i * w/2 + j]  = (byte) (i & 0xff);
                    uvArray[i * w/2 + vOffset + j]  = (byte) (j & 0xff);
                }
            }
        }
        mYDirectBuffer.put(yArray);
        mUVDirectBuffer.put(uvArray);
        mYDirectBuffer.rewind();
        mUVDirectBuffer.rewind();
    }

    /**
     * class to store pixel values in YUV
     *
     */
    public class YUVValue {
        public byte mY;
        public byte mU;
        public byte mV;
        public YUVValue() {
        }

        public boolean equalTo(YUVValue other) {
            return (mY == other.mY) && (mU == other.mU) && (mV == other.mV);
        }

        public double calcErrorSquared(YUVValue other) {
            double yDelta = mY - other.mY;
            double uDelta = mU - other.mU;
            double vDelta = mV - other.mV;
            return yDelta * yDelta + uDelta * uDelta + vDelta * vDelta;
        }
    }

    /**
     * Read YUV values from given position (x,y) for given origin (originX, originY)
     * The whole data is already available from YBuffer and UVBuffer.
     * @param result pass the result via this. This is for avoiding creating / destroying too many
     *               instances
     */
    private void getPixelValuesFromYUVBuffers(int originX, int originY, int x, int y,
            YUVValue result) {
        result.mY = mYBuffer.get((originY + y) * mBufferWidth + (originX + x));
        if (isSrcSemiPlanar()) {
            int index = (originY + y) / 2 * mBufferWidth + (originX + x) / 2 * 2;
            //Log.d(TAG, "YUV " + originX + "," + originY + "," + x + "," + y + "," + index);
            result.mU = mUVBuffer.get(index);
            result.mV = mUVBuffer.get(index + 1);
        } else {
            int vOffset = mBufferWidth * mBufferHeight / 4;
            int index = (originY + y) / 2 * mBufferWidth / 2 + (originX + x) / 2;
            result.mU = mUVBuffer.get(index);
            result.mV = mUVBuffer.get(vOffset + index);
        }
    }

    /**
     * Read YUV pixels from decoded output buffer for give (x, y) position
     * Output buffer is composed of Y parts followed by U/V
     * @param result pass the result via this. This is for avoiding creating / destroying too many
     *               instances
     */
    private void getPixelValuesFromOutputBuffer(ByteBuffer buffer, int x, int y, YUVValue result) {
        result.mY = buffer.get(y * mVideoWidth + x);
        if (isDstSemiPlanar()) {
            int index = mVideoWidth * mVideoHeight + y / 2 * mVideoWidth + x / 2 * 2;
            //Log.d(TAG, "Decoded " + x + "," + y + "," + index);
            result.mU = buffer.get(index);
            result.mV = buffer.get(index + 1);
        } else {
            int vOffset = mVideoWidth * mVideoHeight / 4;
            int index = mVideoWidth * mVideoHeight + y / 2 * mVideoWidth / 2 + x / 2;
            result.mU = buffer.get(index);
            result.mV = buffer.get(index + vOffset);
        }
    }

    private void getPixelValuesFromImage(Image image, int x, int y, YUVValue result) {
        assertTrue(image.getFormat() == ImageFormat.YUV_420_888);

        Plane[] planes = image.getPlanes();
        assertTrue(planes.length == 3);

        result.mY = getPixelFromPlane(planes[0], x, y);
        result.mU = getPixelFromPlane(planes[1], x / 2, y / 2);
        result.mV = getPixelFromPlane(planes[2], x / 2, y / 2);
    }

    private byte getPixelFromPlane(Plane plane, int x, int y) {
        ByteBuffer buf = plane.getBuffer();
        return buf.get(y * plane.getRowStride() + x * plane.getPixelStride());
    }

    /**
     * Y cannot have full range. clamp it to prevent invalid value.
     */
    private byte clampY(int y) {
        if (y < Y_CLAMP_MIN) {
            y = Y_CLAMP_MIN;
        } else if (y > Y_CLAMP_MAX) {
            y = Y_CLAMP_MAX;
        }
        return (byte) (y & 0xff);
    }

    // for debugging
    private void printByteArray(String msg, byte[] data, int offset, int len) {
        StringBuilder builder = new StringBuilder();
        builder.append(msg);
        builder.append(":");
        for (int i = offset; i < offset + len; i++) {
            builder.append(Integer.toHexString(data[i]));
            builder.append(",");
        }
        builder.deleteCharAt(builder.length() - 1);
        Log.i(TAG, builder.toString());
    }

    // for debugging
    private void printByteBuffer(String msg, ByteBuffer data, int offset, int len) {
        StringBuilder builder = new StringBuilder();
        builder.append(msg);
        builder.append(":");
        for (int i = offset; i < offset + len; i++) {
            builder.append(Integer.toHexString(data.get(i)));
            builder.append(",");
        }
        builder.deleteCharAt(builder.length() - 1);
        Log.i(TAG, builder.toString());
    }

    /**
     * Generates the presentation time for frame N, in microseconds.
     */
    private long computePresentationTime(int frameIndex) {
        return 132 + frameIndex * 1000000L / mFrameRate;
    }
}