/*
 * 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.mediav2.cts;

import static android.media.MediaCodecInfo.CodecCapabilities.COLOR_Format32bitABGR2101010;
import static android.media.MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface;
import static android.media.MediaCodecInfo.CodecCapabilities.COLOR_FormatYUVP010;
import static android.mediav2.common.cts.CodecEncoderTestBase.colorFormatToString;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assume.assumeTrue;

import android.media.MediaCodec;
import android.media.MediaFormat;
import android.mediav2.common.cts.CodecAsyncHandler;
import android.mediav2.common.cts.CodecDecoderTestBase;
import android.mediav2.common.cts.CodecTestBase;
import android.mediav2.common.cts.EncoderConfigParams;
import android.mediav2.common.cts.OutputManager;
import android.opengl.GLES20;
import android.opengl.GLES30;
import android.util.Log;
import android.util.Pair;
import android.view.Surface;

import androidx.test.filters.LargeTest;

import com.android.compatibility.common.util.ApiTest;
import com.android.compatibility.common.util.MediaUtils;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import javax.microedition.khronos.opengles.GL10;

/**
 * Color Primaries, Color Standard and Color Transfer are essential information to display the
 * decoded YUV on an RGB display accurately. Tests
 * {@link EncoderColorAspectsTest#testColorAspects()} and
 * {@link DecoderColorAspectsTest#testColorAspects()} checks if the encoder and decoder
 * components are signalling the configured color aspects correctly.
 * This test verifies if the device decoder/display is using this color aspects correctly
 * <p>
 * Test pipeline:
 * <pre> [[ Input RGB frames -> encoder -> muxer -> decoder -> display -> Output RGB frames ]]
 * </pre>
 * Assuming no quantization losses, the test verifies if the input rgb pixel values and output
 * rgb pixel values are within tolerance limits.
 */
@RunWith(Parameterized.class)
public class EncodeDecodeAccuracyTest extends CodecDecoderTestBase {
    private final String LOG_TAG = EncodeDecodeAccuracyTest.class.getSimpleName();
    // The bitrates are configured to large values. The content has zero motion, so in-time the
    // qp of the encoded clips shall drop down to < 10. Further the color bands are aligned to 2,
    // so from downsampling rgb24 to yuv420p, even if bilinear filters are used as opposed to
    // skipping samples, we may not see large color loss. Hence allowable tolerance is kept to 5.
    // until QP stabilizes, the tolerance is set at 7. For devices upgrading to T, thresholds are
    // relaxed to 8 and 10.
    private static final int TRANSIENT_STATE_COLOR_DELTA = FIRST_SDK_IS_AT_LEAST_T ? 7 : 10;
    private static final int STEADY_STATE_COLOR_DELTA = FIRST_SDK_IS_AT_LEAST_T ? 5 : 8;
    private final int[][] mColorBars = new int[][]{
            {66, 133, 244},
            {219, 68, 55},
            {244, 180, 0},
            {15, 157, 88},
            {186, 85, 211},
            {119, 136, 153},
            {225, 179, 120},
            {224, 204, 151},
            {236, 121, 154},
            {159, 2, 81},
            {120, 194, 87}
    };
    private final int FRAMES_TO_ENCODE = 30;
    private final int STEADY_STATE_FRAME_INDEX = 20;

    private final String mCompName;
    private final EncoderConfigParams mEncCfgParams;

    private final CodecAsyncHandler mAsyncHandleEncoder;
    private MediaCodec mEncoder;
    private Surface mInpSurface;
    private EGLWindowSurface mEGLWindowInpSurface;
    private OutputSurface mEGLWindowOutSurface;
    private boolean mSawInputEOSEnc;
    private boolean mSawOutputEOSEnc;
    private int mLatency;
    private boolean mReviseLatency;
    private int mInputCountEnc;
    private int mOutputCountEnc;
    private boolean mSaveToMemEnc;
    private OutputManager mOutputBuffEnc;
    ArrayList<MediaCodec.BufferInfo> mInfoListEnc;

    private final int mColorBarWidth;
    private final int xOffset;
    private final int yOffset = 64;
    private int mLargestColorDelta;
    private int mBadFrames;

    @After
    public void tearDown() {
        if (mEGLWindowInpSurface != null) {
            mEGLWindowInpSurface.release();
            mEGLWindowInpSurface = null;
        }
        if (mInpSurface != null) {
            mInpSurface.release();
            mInpSurface = null;
        }
        if (mEncoder != null) {
            mEncoder.release();
            mEncoder = null;
        }
        mSurface = null;
        if (mEGLWindowOutSurface != null) {
            mEGLWindowOutSurface.release();
            mEGLWindowOutSurface = null;
        }
    }

    public EncodeDecodeAccuracyTest(String encoder, String mediaType,
            EncoderConfigParams encCfgParams, @SuppressWarnings("unused") String testLabel,
            String allTestParams) {
        super(null, mediaType, null, allTestParams);
        mCompName = encoder;
        mEncCfgParams = encCfgParams;
        mAsyncHandleEncoder = new CodecAsyncHandler();
        mLatency = 0;
        mReviseLatency = false;
        mInfoListEnc = new ArrayList<>();
        int barWidth = (mEncCfgParams.mWidth + mColorBars.length - 1) / mColorBars.length;
        // aligning color bands to 2 is done because, during chroma subsampling of rgb24 to yuv420p,
        // simple skipping alternate samples or bilinear filter would have same effect.
        mColorBarWidth = (barWidth % 2 == 0) ? barWidth : barWidth + 1;
        assertTrue(mColorBarWidth >= 16);
        xOffset = mColorBarWidth >> 2;
    }

    @Before
    public void setUp() throws IOException {
        // Few cuttlefish specific color conversion issues were fixed after Android T.
        if (MediaUtils.onCuttlefish()) {
            assumeTrue("Color conversion related tests are not valid on cuttlefish releases "
                    + "through android T", IS_AT_LEAST_U);
        }
        if (mEncCfgParams.mInputBitDepth == 10) {
            assumeTrue("Codec doesn't support ABGR2101010",
                    hasSupportForColorFormat(mCompName, mMime, COLOR_Format32bitABGR2101010));
            assumeTrue("Codec doesn't support high bit depth profile encoding",
                    doesCodecSupportHDRProfile(mCompName, mMime));
        }
    }

    private static EncoderConfigParams getVideoEncoderCfgParams(String mediaType, int width,
            int height, int frameRate, int bitRate, int range, int standard, int transfer,
            int colorFormat, int bitDepth) {
        return new EncoderConfigParams.Builder(mediaType)
                .setWidth(width)
                .setHeight(height)
                .setBitRate(bitRate)
                .setFrameRate(frameRate)
                .setRange(range)
                .setStandard(standard)
                .setTransfer(transfer)
                .setColorFormat(colorFormat)
                .setInputBitDepth(bitDepth)
                .build();
    }

    @Parameterized.Parameters(name = "{index}({0}_{1}_{3})")
    public static Collection<Object[]> input() {
        final boolean isEncoder = true;
        final boolean needAudio = false;
        final boolean needVideo = true;
        final Object[][] baseArgsList = new Object[][]{
                // "video/*", width, height, framerate, bitrate, range, standard, transfer,
                // useHighBitDepth
                {720, 480, 30, 3000000, MediaFormat.COLOR_RANGE_LIMITED,
                        MediaFormat.COLOR_STANDARD_BT601_NTSC,
                        MediaFormat.COLOR_TRANSFER_SDR_VIDEO, false},
                {720, 576, 30, 3000000, MediaFormat.COLOR_RANGE_LIMITED,
                        MediaFormat.COLOR_STANDARD_BT601_PAL, MediaFormat.COLOR_TRANSFER_SDR_VIDEO,
                        false},
                {720, 480, 30, 3000000, MediaFormat.COLOR_RANGE_FULL,
                        MediaFormat.COLOR_STANDARD_BT2020,
                        MediaFormat.COLOR_TRANSFER_ST2084, true},

                {720, 480, 30, 3000000, MediaFormat.COLOR_RANGE_LIMITED,
                    MediaFormat.COLOR_STANDARD_BT2020, MediaFormat.COLOR_TRANSFER_ST2084, true},
                {720, 480, 30, 3000000, MediaFormat.COLOR_RANGE_LIMITED,
                    MediaFormat.COLOR_STANDARD_BT709, MediaFormat.COLOR_TRANSFER_SDR_VIDEO, true},
                // TODO (b/186511593)
                /*
                {1280, 720, 30, 3000000, MediaFormat.COLOR_RANGE_LIMITED,
                        MediaFormat.COLOR_STANDARD_BT709, MediaFormat.COLOR_TRANSFER_SDR_VIDEO},
                {720, 480, 30, 3000000, MediaFormat.COLOR_RANGE_FULL,
                        MediaFormat.COLOR_STANDARD_BT601_NTSC,
                        MediaFormat.COLOR_TRANSFER_SDR_VIDEO},
                {720, 576, 30, 3000000, MediaFormat.COLOR_RANGE_FULL,
                        MediaFormat.COLOR_STANDARD_BT601_PAL, MediaFormat.COLOR_TRANSFER_SDR_VIDEO},
                {1280, 720, 30, 3000000, MediaFormat.COLOR_RANGE_FULL,
                        MediaFormat.COLOR_STANDARD_BT709, MediaFormat.COLOR_TRANSFER_SDR_VIDEO},

                {720, 480, 30, 3000000, MediaFormat.COLOR_RANGE_LIMITED,
                        MediaFormat.COLOR_STANDARD_BT709,
                        MediaFormat.COLOR_TRANSFER_SDR_VIDEO},
                {720, 576, 30, 3000000, MediaFormat.COLOR_RANGE_LIMITED,
                        MediaFormat.COLOR_STANDARD_BT709, MediaFormat.COLOR_TRANSFER_SDR_VIDEO},
                {1280, 720, 30, 3000000, MediaFormat.COLOR_RANGE_LIMITED,
                        MediaFormat.COLOR_STANDARD_BT601_PAL, MediaFormat.COLOR_TRANSFER_SDR_VIDEO},
                {720, 480, 30, 3000000, MediaFormat.COLOR_RANGE_FULL,
                        MediaFormat.COLOR_STANDARD_BT709,
                        MediaFormat.COLOR_TRANSFER_SDR_VIDEO},
                {720, 576, 30, 3000000, MediaFormat.COLOR_RANGE_FULL,
                        MediaFormat.COLOR_STANDARD_BT709, MediaFormat.COLOR_TRANSFER_SDR_VIDEO},
                {1280, 720, 30, 3000000, MediaFormat.COLOR_RANGE_FULL,
                        MediaFormat.COLOR_STANDARD_BT601_PAL, MediaFormat.COLOR_TRANSFER_SDR_VIDEO},
                 */
        };
        // Note: although vp8 and vp9 donot contain fields to signal color aspects properly, this
        // information can be muxed in to containers of mkv and mp4. So even those clips
        // should pass these tests
        final String[] mediaTypes =
                {MediaFormat.MIMETYPE_VIDEO_AVC, MediaFormat.MIMETYPE_VIDEO_HEVC,
                        MediaFormat.MIMETYPE_VIDEO_VP8, MediaFormat.MIMETYPE_VIDEO_VP9,
                        MediaFormat.MIMETYPE_VIDEO_AV1};
        final List<Object[]> exhaustiveArgsList = new ArrayList<>();
        for (String mediaType : mediaTypes) {
            for (Object[] obj : baseArgsList) {
                final int width = (int) obj[0];
                final int height = (int) obj[1];
                final int fps = (int) obj[2];
                final int br = (int) obj[3];
                final int range = (int) obj[4];
                final int std = (int) obj[5];
                final int tfr = (int) obj[6];
                final int bd = (boolean) obj[7] ? 10 : 8;

                Object[] testArgs = new Object[3];
                testArgs[0] = mediaType;
                testArgs[1] = getVideoEncoderCfgParams(mediaType, width, height, fps, br, range,
                        std, tfr, COLOR_FormatSurface, bd);
                testArgs[2] = String.format("%d_%d_%dkbps_%dfps_%d_%d_%d_%s", width, height,
                        br / 1000, fps, range, std, tfr,
                        colorFormatToString(COLOR_FormatSurface, bd));
                exhaustiveArgsList.add(testArgs);
            }
        }
        return CodecTestBase.prepareParamList(exhaustiveArgsList, isEncoder, needAudio, needVideo,
                false);
    }

    private void resetContext(boolean isAsync) {
        super.resetContext(isAsync, false);
        mAsyncHandleEncoder.resetContext();
        mSawInputEOSEnc = false;
        mSawOutputEOSEnc = false;
        mLatency = 0;
        mReviseLatency = false;
        mInputCountEnc = 0;
        mOutputCountEnc = 0;
        mInfoListEnc.clear();
        mLargestColorDelta = 0;
        mBadFrames = 0;
    }

    private void configureCodec(MediaFormat encFormat, boolean isAsync) {
        resetContext(isAsync);
        mAsyncHandleEncoder.setCallBack(mEncoder, isAsync);
        mEncoder.configure(encFormat, null, MediaCodec.CONFIGURE_FLAG_ENCODE, null);
        if (mEncoder.getInputFormat().containsKey(MediaFormat.KEY_LATENCY)) {
            mReviseLatency = true;
            mLatency = mEncoder.getInputFormat().getInteger(MediaFormat.KEY_LATENCY);
        }
        mInpSurface = mEncoder.createInputSurface();
        assertTrue("Surface is not valid \n" + mTestConfig + mTestEnv, mInpSurface.isValid());
        mEGLWindowInpSurface =
                new EGLWindowSurface(mInpSurface, mEncCfgParams.mInputBitDepth == 10);
        if (ENABLE_LOGS) {
            Log.v(LOG_TAG, "codec configured");
        }
    }

    private void dequeueEncoderOutput(int bufferIndex, MediaCodec.BufferInfo info) {
        if (ENABLE_LOGS) {
            Log.v(LOG_TAG, "encoder output: id: " + bufferIndex + " flags: " + info.flags +
                    " size: " + info.size + " timestamp: " + info.presentationTimeUs);
        }
        if ((info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
            mSawOutputEOSEnc = true;
        }
        if (info.size > 0) {
            if (mSaveToMemEnc) {
                ByteBuffer buf = mEncoder.getOutputBuffer(bufferIndex);
                MediaCodec.BufferInfo copy = new MediaCodec.BufferInfo();
                copy.set(mOutputBuffEnc.getOutStreamSize(), info.size, info.presentationTimeUs,
                        info.flags);
                mInfoListEnc.add(copy);
                mOutputBuffEnc.saveToMemory(buf, info);
            }
            if ((info.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) == 0) {
                mOutputBuffEnc.saveOutPTS(info.presentationTimeUs);
                mOutputCountEnc++;
            }
        }
        mEncoder.releaseOutputBuffer(bufferIndex, false);
    }

    private void tryEncoderOutput(long timeOutUs) throws InterruptedException {
        if (mIsCodecInAsyncMode) {
            if (!mAsyncHandleEncoder.hasSeenError() && !mSawOutputEOSEnc) {
                int retry = 0;
                while (mReviseLatency) {
                    if (mAsyncHandleEncoder.hasOutputFormatChanged()) {
                        mReviseLatency = false;
                        int actualLatency = mAsyncHandleEncoder.getOutputFormat()
                                .getInteger(MediaFormat.KEY_LATENCY, mLatency);
                        if (mLatency < actualLatency) {
                            mLatency = actualLatency;
                            return;
                        }
                    } else {
                        if (retry > CodecTestBase.RETRY_LIMIT) {
                            throw new InterruptedException("did not receive output format " +
                                    "changed for encoder after " + CodecTestBase.Q_DEQ_TIMEOUT_US *
                                    CodecTestBase.RETRY_LIMIT + " us");
                        }
                        Thread.sleep(CodecTestBase.Q_DEQ_TIMEOUT_US / 1000);
                        retry++;
                    }
                }
                Pair<Integer, MediaCodec.BufferInfo> element = mAsyncHandleEncoder.getOutput();
                if (element != null) {
                    dequeueEncoderOutput(element.first, element.second);
                }
            }
        } else {
            MediaCodec.BufferInfo outInfo = new MediaCodec.BufferInfo();
            if (!mSawOutputEOSEnc) {
                int outputBufferId = mEncoder.dequeueOutputBuffer(outInfo, timeOutUs);
                if (outputBufferId >= 0) {
                    dequeueEncoderOutput(outputBufferId, outInfo);
                } else if (outputBufferId == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
                    mLatency = mEncoder.getOutputFormat()
                            .getInteger(MediaFormat.KEY_LATENCY, mLatency);
                }
            }
        }
    }

    private void waitForAllEncoderOutputs() throws InterruptedException {
        if (mIsCodecInAsyncMode) {
            while (!mAsyncHandleEncoder.hasSeenError() && !mSawOutputEOSEnc) {
                tryEncoderOutput(CodecTestBase.Q_DEQ_TIMEOUT_US);
            }
        } else {
            while (!mSawOutputEOSEnc) {
                tryEncoderOutput(CodecTestBase.Q_DEQ_TIMEOUT_US);
            }
        }
    }

    private void queueEOSEnc() {
        if (!mAsyncHandleEncoder.hasSeenError() && !mSawInputEOSEnc) {
            mEncoder.signalEndOfInputStream();
            mSawInputEOSEnc = true;
            if (ENABLE_LOGS) Log.d(LOG_TAG, "signalled end of stream");
        }
    }

    private void doWorkEnc(int frameLimit) throws InterruptedException {
        while (!mAsyncHandleEncoder.hasSeenError() && !mSawInputEOSEnc &&
                mInputCountEnc < frameLimit) {
            if (mInputCountEnc - mOutputCountEnc > mLatency) {
                tryEncoderOutput(CodecTestBase.Q_DEQ_TIMEOUT_US);
            }
            mEGLWindowInpSurface.makeCurrent();
            generateSurfaceFrame();
            mEGLWindowInpSurface
                    .setPresentationTime(computePresentationTime(mInputCountEnc) * 1000);
            if (ENABLE_LOGS) Log.d(LOG_TAG, "inputSurface swapBuffers");
            mEGLWindowInpSurface.swapBuffers();
            mInputCountEnc++;
        }
    }

    private long computePresentationTime(int frameIndex) {
        return frameIndex * 1000000L / mEncCfgParams.mFrameRate;
    }

    private void generateSurfaceFrame() {
        GLES20.glViewport(0, 0, mEncCfgParams.mWidth, mEncCfgParams.mHeight);
        GLES20.glEnable(GLES20.GL_SCISSOR_TEST);
        for (int i = 0; i < mColorBars.length; i++) {
            int startX = i * mColorBarWidth;
            int endX = Math.min(startX + mColorBarWidth, mEncCfgParams.mWidth);
            GLES20.glScissor(startX, 0, endX, mEncCfgParams.mHeight);
            GLES20.glClearColor(mColorBars[i][0] / 255.0f, mColorBars[i][1] / 255.0f,
                    mColorBars[i][2] / 255.0f, 1.0f);
            GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
        }
    }

    boolean isColorClose(int actual, int expected) {
        int delta = Math.abs(actual - expected);
        if (delta > mLargestColorDelta) mLargestColorDelta = delta;
        int maxAllowedDelta = (mOutputCount >= STEADY_STATE_FRAME_INDEX ? STEADY_STATE_COLOR_DELTA :
                TRANSIENT_STATE_COLOR_DELTA);
        return (delta <= maxAllowedDelta);
    }

    private boolean checkSurfaceFrame(int frameIndex) {
        ByteBuffer pixelBuf = ByteBuffer.allocateDirect(4);
        boolean frameFailed = false;
        for (int i = 0; i < mColorBars.length; i++) {
            int x = mColorBarWidth * i + xOffset;
            int y = yOffset;
            int r, g, b;
            if (mEncCfgParams.mInputBitDepth == 10) {
                GLES30.glReadPixels(x, y, 1, 1, GL10.GL_RGBA, GLES30.GL_UNSIGNED_INT_2_10_10_10_REV,
                        pixelBuf);
                r = (pixelBuf.get(1) & 0x03) << 8 | (pixelBuf.get(0) & 0xFF);
                g = (pixelBuf.get(2) & 0x0F) << 6 | ((pixelBuf.get(1) >> 2) & 0x3F);
                b = (pixelBuf.get(3) & 0x3F) << 4 | ((pixelBuf.get(2) >> 4) & 0x0F);
                // Convert the values to 8 bit as comparisons later are with 8 bit RGB values
                r = (r + 2) >> 2;
                g = (g + 2) >> 2;
                b = (b + 2) >> 2;
            } else {
                GLES20.glReadPixels(x, y, 1, 1, GL10.GL_RGBA, GL10.GL_UNSIGNED_BYTE, pixelBuf);
                r = pixelBuf.get(0) & 0xFF;
                g = pixelBuf.get(1) & 0xFF;
                b = pixelBuf.get(2) & 0xFF;
            }
            if (!(isColorClose(r, mColorBars[i][0]) && isColorClose(g, mColorBars[i][1]) &&
                    isColorClose(b, mColorBars[i][2]))) {
                Log.w(LOG_TAG, "Bad frame " + frameIndex + " (rect={" + x + " " + y + "} :rgb=" +
                        r + "," + g + "," + b + " vs. expected " + mColorBars[i][0] +
                        "," + mColorBars[i][1] + "," + mColorBars[i][2] + ")");
                frameFailed = true;
            }
        }
        return frameFailed;
    }

    protected void dequeueOutput(int bufferIndex, MediaCodec.BufferInfo info) {
        if ((info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
            mSawOutputEOS = true;
        }
        if (ENABLE_LOGS) {
            Log.v(LOG_TAG, "output: id: " + bufferIndex + " flags: " + info.flags + " size: " +
                    info.size + " timestamp: " + info.presentationTimeUs);
        }
        if (info.size > 0 && (info.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) == 0) {
            mOutputBuff.saveOutPTS(info.presentationTimeUs);
            mOutputCount++;
        }
        mCodec.releaseOutputBuffer(bufferIndex, mSurface != null);
        if (info.size > 0) {
            mEGLWindowOutSurface.awaitNewImage();
            mEGLWindowOutSurface.drawImage();
            if (checkSurfaceFrame(mOutputCount - 1)) mBadFrames++;
        }
    }

    private void decodeElementaryStream(MediaFormat format)
            throws IOException, InterruptedException {
        mEGLWindowOutSurface = new OutputSurface(mEncCfgParams.mWidth, mEncCfgParams.mHeight,
                mEncCfgParams.mInputBitDepth == 10);
        mSurface = mEGLWindowOutSurface.getSurface();
        ArrayList<MediaFormat> formats = new ArrayList<>();
        formats.add(format);
        ArrayList<String> listOfDecoders =
                CodecDecoderTestBase.selectCodecs(mMime, formats, null, false);
        assertFalse("no suitable codecs found for : " + format + "\n" + mTestConfig + mTestEnv,
                listOfDecoders.isEmpty());
        for (String decoder : listOfDecoders) {
            if (mEncCfgParams.mInputBitDepth == 10
                    && !hasSupportForColorFormat(decoder, mMime, COLOR_FormatYUVP010)
                    && !hasSupportForColorFormat(decoder, mMime, COLOR_Format32bitABGR2101010)) {
                continue;
            }
            mCodec = MediaCodec.createByCodecName(decoder);
            configureCodec(format, true, true, false);
            mOutputBuff = new OutputManager();
            mCodec.start();
            doWork(mOutputBuffEnc.getBuffer(), mInfoListEnc);
            queueEOS();
            waitForAllOutputs();
            mCodec.stop();
            mCodec.release();
        }
        mSurface = null;
        mEGLWindowOutSurface.release();
        mEGLWindowOutSurface = null;
    }

    /**
     * Check description of class {@link EncodeDecodeAccuracyTest}
     */
    @ApiTest(apis = {"android.media.MediaFormat#KEY_COLOR_RANGE",
            "android.media.MediaFormat#KEY_COLOR_STANDARD",
            "android.media.MediaFormat#KEY_COLOR_TRANSFER"})
    @LargeTest
    @Test(timeout = CodecTestBase.PER_TEST_TIMEOUT_LARGE_TEST_MS)
    public void testEncodeDecodeAccuracyRGB() throws IOException, InterruptedException {
        MediaFormat format = mEncCfgParams.getFormat();
        final boolean isAsync = true;
        mSaveToMemEnc = true;
        mOutputBuffEnc = new OutputManager();
        {
            mEncoder = MediaCodec.createByCodecName(mCompName);
            mOutputBuffEnc.reset();
            mInfoListEnc.clear();
            configureCodec(format, isAsync);
            mEncoder.start();
            doWorkEnc(FRAMES_TO_ENCODE);
            queueEOSEnc();
            waitForAllEncoderOutputs();
            MediaFormat outputFormat = mEncoder.getOutputFormat();
            assertTrue(outputFormat.containsKey(MediaFormat.KEY_COLOR_RANGE));
            assertTrue(outputFormat.containsKey(MediaFormat.KEY_COLOR_STANDARD));
            assertTrue(outputFormat.containsKey(MediaFormat.KEY_COLOR_TRANSFER));
            if (mMime.equals(MediaFormat.MIMETYPE_VIDEO_AVC) ||
                    mMime.equals(MediaFormat.MIMETYPE_VIDEO_HEVC)) {
                outputFormat.removeKey(MediaFormat.KEY_COLOR_RANGE);
                outputFormat.removeKey(MediaFormat.KEY_COLOR_STANDARD);
                outputFormat.removeKey(MediaFormat.KEY_COLOR_TRANSFER);
            }
            mEGLWindowInpSurface.release();
            mEGLWindowInpSurface = null;
            mInpSurface.release();
            mInpSurface = null;
            mEncoder.reset();
            mEncoder.release();
            decodeElementaryStream(outputFormat);
            assertEquals("color difference exceeds allowed tolerance in " + mBadFrames + " out of "
                    + FRAMES_TO_ENCODE + " frames \n" + mTestConfig + mTestEnv, 0, mBadFrames);
        }
    }
}