modules/egl/teglPartialUpdateTests.cpp

/*-------------------------------------------------------------------------
 * drawElements Quality Program EGL Module
 * ---------------------------------------
 *
 * Copyright 2015 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.
 *
 *//*!
 * \file
 * \brief Test KHR_partial_update
 *//*--------------------------------------------------------------------*/

#include "teglPartialUpdateTests.hpp"

#include "tcuImageCompare.hpp"
#include "tcuTestLog.hpp"
#include "tcuSurface.hpp"
#include "tcuTextureUtil.hpp"

#include "egluNativeWindow.hpp"
#include "egluUtil.hpp"
#include "egluConfigFilter.hpp"

#include "eglwLibrary.hpp"
#include "eglwEnums.hpp"

#include "gluDefs.hpp"
#include "gluRenderContext.hpp"
#include "gluShaderProgram.hpp"

#include "glwDefs.hpp"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"

#include "deRandom.hpp"
#include "deString.h"

#include <string>
#include <vector>
#include <sstream>

using glw::GLubyte;
using std::string;
using std::vector;
using tcu::IVec2;

using namespace eglw;

namespace deqp
{
namespace egl
{
namespace
{

typedef tcu::Vector<GLubyte, 3> Color;

class GLES2Renderer;

class ReferenceRenderer;

class PartialUpdateTest : public TestCase
{
public:
    enum DrawType
    {
        DRAWTYPE_GLES2_CLEAR,
        DRAWTYPE_GLES2_RENDER
    };

    PartialUpdateTest(EglTestContext &eglTestCtx, const vector<DrawType> &oddFrameDrawType,
                      const vector<DrawType> &evenFrameDrawType, const char *name, const char *description);
    ~PartialUpdateTest(void);

    void init(void);
    void deinit(void);
    IterateResult iterate(void);

private:
    eglu::NativeWindow *m_window;
    EGLConfig m_eglConfig;
    EGLContext m_eglContext;

protected:
    void initEGLSurface(EGLConfig config);
    void initEGLContext(EGLConfig config);

    const int m_seed;
    const vector<DrawType> m_oddFrameDrawType;
    const vector<DrawType> m_evenFrameDrawType;

    bool m_supportBufferAge;
    EGLDisplay m_eglDisplay;
    EGLSurface m_eglSurface;
    glw::Functions m_gl;

    GLES2Renderer *m_gles2Renderer;
    ReferenceRenderer *m_refRenderer;
};

struct ColoredRect
{
public:
    ColoredRect(const IVec2 &bottomLeft_, const IVec2 &topRight_, const Color &color_);
    IVec2 bottomLeft;
    IVec2 topRight;
    Color color;
};

ColoredRect::ColoredRect(const IVec2 &bottomLeft_, const IVec2 &topRight_, const Color &color_)
    : bottomLeft(bottomLeft_)
    , topRight(topRight_)
    , color(color_)
{
}

struct DrawCommand
{
    DrawCommand(const PartialUpdateTest::DrawType drawType_, const ColoredRect &rect_);
    PartialUpdateTest::DrawType drawType;
    ColoredRect rect;
};

DrawCommand::DrawCommand(const PartialUpdateTest::DrawType drawType_, const ColoredRect &rect_)
    : drawType(drawType_)
    , rect(rect_)
{
}

struct Frame
{
    Frame(int width_, int height_);
    int width;
    int height;
    vector<DrawCommand> draws;
};

Frame::Frame(int width_, int height_) : width(width_), height(height_)
{
}

// (x1,y1) lie in the lower-left quadrant while (x2,y2) lie in the upper-right.
// the coords are multiplied by 4 to amplify the minimial difference between coords to 4 (if not zero)
// to avoid the situation where two edges are too close to each other which makes the rounding error
// intoleratable by compareToReference()
void generateRandomFrame(Frame &dst, const vector<PartialUpdateTest::DrawType> &drawTypes, de::Random &rnd)
{
    for (size_t ndx = 0; ndx < drawTypes.size(); ndx++)
    {
        const int x1    = rnd.getInt(0, (dst.width - 1) / 8) * 4;
        const int y1    = rnd.getInt(0, (dst.height - 1) / 8) * 4;
        const int x2    = rnd.getInt((dst.width - 1) / 8, (dst.width - 1) / 4) * 4;
        const int y2    = rnd.getInt((dst.height - 1) / 8, (dst.height - 1) / 4) * 4;
        const GLubyte r = rnd.getUint8();
        const GLubyte g = rnd.getUint8();
        const GLubyte b = rnd.getUint8();
        const ColoredRect coloredRect(IVec2(x1, y1), IVec2(x2, y2), Color(r, g, b));
        const DrawCommand drawCommand(drawTypes[ndx], coloredRect);

        dst.draws.push_back(drawCommand);
    }
}

typedef vector<Frame> FrameSequence;

//helper function declaration
EGLConfig getEGLConfig(const Library &egl, EGLDisplay eglDisplay);
void clearColorScreen(const glw::Functions &gl, const tcu::Vec4 &clearColor);
void clearColorReference(tcu::Surface *ref, const tcu::Vec4 &clearColor);
void readPixels(const glw::Functions &gl, tcu::Surface *screen);
float windowToDeviceCoordinates(int x, int length);
bool compareToReference(tcu::TestLog &log, const tcu::Surface &reference, const tcu::Surface &buffer, int frameNdx,
                        int bufferNum);
vector<int> getFramesOnBuffer(const vector<int> &bufferAges, int frameNdx);

class GLES2Renderer
{
public:
    GLES2Renderer(const glw::Functions &gl);
    ~GLES2Renderer(void);
    void render(int width, int height, const Frame &frame) const;

private:
    GLES2Renderer(const GLES2Renderer &);
    GLES2Renderer &operator=(const GLES2Renderer &);

    const glw::Functions &m_gl;
    glu::ShaderProgram m_glProgram;
    glw::GLuint m_coordLoc;
    glw::GLuint m_colorLoc;
};

// generate sources for vertex and fragment buffer
glu::ProgramSources getSources(void)
{
    const char *const vertexShaderSource = "attribute mediump vec2 a_pos;\n"
                                           "attribute mediump vec4 a_color;\n"
                                           "varying mediump vec4 v_color;\n"
                                           "void main(void)\n"
                                           "{\n"
                                           "\tv_color = a_color;\n"
                                           "\tgl_Position = vec4(a_pos, 0.0, 1.0);\n"
                                           "}";

    const char *const fragmentShaderSource = "varying mediump vec4 v_color;\n"
                                             "void main(void)\n"
                                             "{\n"
                                             "\tgl_FragColor = v_color;\n"
                                             "}";

    return glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource);
}

GLES2Renderer::GLES2Renderer(const glw::Functions &gl)
    : m_gl(gl)
    , m_glProgram(gl, getSources())
    , m_coordLoc((glw::GLuint)-1)
    , m_colorLoc((glw::GLuint)-1)
{
    m_colorLoc = m_gl.getAttribLocation(m_glProgram.getProgram(), "a_color");
    m_coordLoc = m_gl.getAttribLocation(m_glProgram.getProgram(), "a_pos");
    GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to get attribute locations");
}

GLES2Renderer::~GLES2Renderer(void)
{
}

void GLES2Renderer::render(int width, int height, const Frame &frame) const
{
    for (size_t drawNdx = 0; drawNdx < frame.draws.size(); drawNdx++)
    {
        const ColoredRect &coloredRect = frame.draws[drawNdx].rect;

        if (frame.draws[drawNdx].drawType == PartialUpdateTest::DRAWTYPE_GLES2_RENDER)
        {
            const float x1 = windowToDeviceCoordinates(coloredRect.bottomLeft.x(), width);
            const float y1 = windowToDeviceCoordinates(coloredRect.bottomLeft.y(), height);
            const float x2 = windowToDeviceCoordinates(coloredRect.topRight.x(), width);
            const float y2 = windowToDeviceCoordinates(coloredRect.topRight.y(), height);

            const glw::GLfloat coords[] = {
                x1, y1, x1, y2, x2, y2,

                x2, y2, x2, y1, x1, y1,
            };

            const glw::GLubyte colors[] = {
                coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
                coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
                coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,

                coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
                coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
                coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255,
            };

            m_gl.useProgram(m_glProgram.getProgram());
            GLU_EXPECT_NO_ERROR(m_gl.getError(), "glUseProgram() failed");

            m_gl.enableVertexAttribArray(m_coordLoc);
            m_gl.enableVertexAttribArray(m_colorLoc);
            GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to enable attributes");

            m_gl.vertexAttribPointer(m_coordLoc, 2, GL_FLOAT, GL_FALSE, 0, coords);
            m_gl.vertexAttribPointer(m_colorLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, colors);
            GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to set attribute pointers");

            m_gl.drawArrays(GL_TRIANGLES, 0, DE_LENGTH_OF_ARRAY(coords) / 2);
            GLU_EXPECT_NO_ERROR(m_gl.getError(), "glDrawArrays(), failed");

            m_gl.disableVertexAttribArray(m_coordLoc);
            m_gl.disableVertexAttribArray(m_colorLoc);
            GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to disable attributes");

            m_gl.useProgram(0);
            GLU_EXPECT_NO_ERROR(m_gl.getError(), "glUseProgram() failed");
        }
        else if (frame.draws[drawNdx].drawType == PartialUpdateTest::DRAWTYPE_GLES2_CLEAR)
        {
            m_gl.enable(GL_SCISSOR_TEST);
            m_gl.scissor(coloredRect.bottomLeft.x(), coloredRect.bottomLeft.y(),
                         coloredRect.topRight.x() - coloredRect.bottomLeft.x(),
                         coloredRect.topRight.y() - coloredRect.bottomLeft.y());
            m_gl.clearColor(coloredRect.color.x() / 255.0f, coloredRect.color.y() / 255.0f,
                            coloredRect.color.z() / 255.0f, 1.0f);
            m_gl.clear(GL_COLOR_BUFFER_BIT);
            m_gl.disable(GL_SCISSOR_TEST);
        }
        else
            DE_FATAL("Invalid drawtype");
    }
}

class ReferenceRenderer
{
public:
    ReferenceRenderer(void);
    void render(tcu::Surface *target, const Frame &frame) const;

private:
    ReferenceRenderer(const ReferenceRenderer &);
    ReferenceRenderer &operator=(const ReferenceRenderer &);
};

ReferenceRenderer::ReferenceRenderer(void)
{
}

void ReferenceRenderer::render(tcu::Surface *target, const Frame &frame) const
{
    for (size_t drawNdx = 0; drawNdx < frame.draws.size(); drawNdx++)
    {
        const ColoredRect &coloredRect = frame.draws[drawNdx].rect;
        if (frame.draws[drawNdx].drawType == PartialUpdateTest::DRAWTYPE_GLES2_RENDER ||
            frame.draws[drawNdx].drawType == PartialUpdateTest::DRAWTYPE_GLES2_CLEAR)
        {
            // tcu does not support degenerate subregions. Since they correspond to no-op rendering, just skip them.
            if (coloredRect.bottomLeft.x() == coloredRect.topRight.x() ||
                coloredRect.bottomLeft.y() == coloredRect.topRight.y())
                continue;

            const tcu::UVec4 color(coloredRect.color.x(), coloredRect.color.y(), coloredRect.color.z(), 255);
            tcu::clear(tcu::getSubregion(target->getAccess(), coloredRect.bottomLeft.x(), coloredRect.bottomLeft.y(),
                                         coloredRect.topRight.x() - coloredRect.bottomLeft.x(),
                                         coloredRect.topRight.y() - coloredRect.bottomLeft.y()),
                       color);
        }
        else
            DE_FATAL("Invalid drawtype");
    }
}

PartialUpdateTest::PartialUpdateTest(EglTestContext &eglTestCtx, const vector<DrawType> &oddFrameDrawType,
                                     const vector<DrawType> &evenFrameDrawType, const char *name,
                                     const char *description)
    : TestCase(eglTestCtx, name, description)
    , m_window(DE_NULL)
    , m_eglContext(EGL_NO_CONTEXT)
    , m_seed(deStringHash(name))
    , m_oddFrameDrawType(oddFrameDrawType)
    , m_evenFrameDrawType(evenFrameDrawType)
    , m_supportBufferAge(false)
    , m_eglDisplay(EGL_NO_DISPLAY)
    , m_eglSurface(EGL_NO_SURFACE)
    , m_gles2Renderer(DE_NULL)
    , m_refRenderer(DE_NULL)
{
}

PartialUpdateTest::~PartialUpdateTest(void)
{
    deinit();
}

void PartialUpdateTest::init(void)
{
    const Library &egl = m_eglTestCtx.getLibrary();

    m_eglDisplay = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());

    if (!eglu::hasExtension(egl, m_eglDisplay, "EGL_KHR_partial_update"))
    {
        egl.terminate(m_eglDisplay);
        m_eglDisplay = EGL_NO_DISPLAY;
        TCU_THROW(NotSupportedError, "EGL_KHR_partial_update is not supported");
    }

    m_eglConfig = getEGLConfig(m_eglTestCtx.getLibrary(), m_eglDisplay);

    //create surface and context and make them current
    initEGLSurface(m_eglConfig);
    initEGLContext(m_eglConfig);

    m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2, 0));

    m_supportBufferAge = eglu::hasExtension(egl, m_eglDisplay, "EGL_EXT_buffer_age");

    m_gles2Renderer = new GLES2Renderer(m_gl);
    m_refRenderer   = new ReferenceRenderer();
}

void PartialUpdateTest::deinit(void)
{
    const Library &egl = m_eglTestCtx.getLibrary();

    delete m_refRenderer;
    m_refRenderer = DE_NULL;

    delete m_gles2Renderer;
    m_gles2Renderer = DE_NULL;

    if (m_eglContext != EGL_NO_CONTEXT)
    {
        egl.makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
        egl.destroyContext(m_eglDisplay, m_eglContext);
        m_eglContext = EGL_NO_CONTEXT;
    }

    if (m_eglSurface != EGL_NO_SURFACE)
    {
        egl.destroySurface(m_eglDisplay, m_eglSurface);
        m_eglSurface = EGL_NO_SURFACE;
    }

    if (m_eglDisplay != EGL_NO_DISPLAY)
    {
        egl.terminate(m_eglDisplay);
        m_eglDisplay = EGL_NO_DISPLAY;
    }

    delete m_window;
    m_window = DE_NULL;
}

void PartialUpdateTest::initEGLSurface(EGLConfig config)
{
    const eglu::NativeWindowFactory &factory =
        eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine());
    m_window =
        factory.createWindow(&m_eglTestCtx.getNativeDisplay(), m_eglDisplay, config, DE_NULL,
                             eglu::WindowParams(480, 480, eglu::parseWindowVisibility(m_testCtx.getCommandLine())));
    m_eglSurface = eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *m_window, m_eglDisplay, config, DE_NULL);
}

void PartialUpdateTest::initEGLContext(EGLConfig config)
{
    const Library &egl        = m_eglTestCtx.getLibrary();
    const EGLint attribList[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};

    egl.bindAPI(EGL_OPENGL_ES_API);
    m_eglContext = egl.createContext(m_eglDisplay, config, EGL_NO_CONTEXT, attribList);
    EGLU_CHECK_MSG(egl, "eglCreateContext");
    TCU_CHECK(m_eglSurface != EGL_NO_SURFACE);
    egl.makeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext);
    EGLU_CHECK_MSG(egl, "eglMakeCurrent");
}

// return indices of frames that have been written to the given buffer
vector<int> getFramesOnBuffer(const vector<int> &bufferAges, int frameNdx)
{
    DE_ASSERT(frameNdx < (int)bufferAges.size());
    vector<int> frameOnBuffer;
    int age = bufferAges[frameNdx];
    while (age != 0)
    {
        frameNdx = frameNdx - age;
        DE_ASSERT(frameNdx >= 0);
        frameOnBuffer.push_back(frameNdx);
        age = bufferAges[frameNdx];
    }

    reverse(frameOnBuffer.begin(), frameOnBuffer.end());
    return frameOnBuffer;
}

vector<EGLint> getDamageRegion(const Frame &frame, int marginLeft, int marginBottom, int marginRight, int marginTop)
{
    vector<EGLint> damageRegion;
    for (size_t drawNdx = 0; drawNdx < frame.draws.size(); drawNdx++)
    {
        const ColoredRect &rect = frame.draws[drawNdx].rect;
        damageRegion.push_back(rect.bottomLeft.x() - marginLeft);
        damageRegion.push_back(rect.bottomLeft.y() - marginBottom);
        damageRegion.push_back(rect.topRight.x() - rect.bottomLeft.x() + marginLeft + marginRight);
        damageRegion.push_back(rect.topRight.y() - rect.bottomLeft.y() + marginBottom + marginTop);
    }

    DE_ASSERT(damageRegion.size() % 4 == 0);
    return damageRegion;
}

TestCase::IterateResult PartialUpdateTest::iterate(void)
{
    de::Random rnd(m_seed);
    const Library &egl     = m_eglTestCtx.getLibrary();
    tcu::TestLog &log      = m_testCtx.getLog();
    const int width        = eglu::querySurfaceInt(egl, m_eglDisplay, m_eglSurface, EGL_WIDTH);
    const int height       = eglu::querySurfaceInt(egl, m_eglDisplay, m_eglSurface, EGL_HEIGHT);
    const float clearRed   = rnd.getFloat();
    const float clearGreen = rnd.getFloat();
    const float clearBlue  = rnd.getFloat();
    const tcu::Vec4 clearColor(clearRed, clearGreen, clearBlue, 1.0f);
    const int numFrames = 20;
    FrameSequence frameSequence;
    vector<int> bufferAges;
    bool hasPositiveAge = false;

    EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED));

    for (int frameNdx = 0; frameNdx < numFrames; frameNdx++)
    {
        tcu::Surface currentBuffer(width, height);
        tcu::Surface refBuffer(width, height);
        Frame newFrame(width, height);
        EGLint currentBufferAge = -1;

        if (frameNdx % 2 == 0)
            generateRandomFrame(newFrame, m_evenFrameDrawType, rnd);
        else
            generateRandomFrame(newFrame, m_oddFrameDrawType, rnd);

        frameSequence.push_back(newFrame);

        EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_KHR, &currentBufferAge));

        if (currentBufferAge > frameNdx || currentBufferAge < 0) // invalid buffer age
        {
            std::ostringstream stream;
            stream << "Fail, the age is invalid. Age: " << currentBufferAge << ", frameNdx: " << frameNdx;
            m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, stream.str().c_str());
            return STOP;
        }

        bufferAges.push_back(currentBufferAge);
        DE_ASSERT((int)bufferAges.size() == frameNdx + 1);

        if (currentBufferAge > 0)
        {
            vector<EGLint> damageRegion;

            hasPositiveAge = true;

            if (m_supportBufferAge)
            {
                damageRegion = getDamageRegion(newFrame, 10, 10, 10, 10);
            }
            else
            {
                damageRegion = getDamageRegion(newFrame, 0, 0, 0, 0);
            }

            // Set empty damage region to avoid invalidating the framebuffer. The damage area is invalidated
            // if the buffer age extension is not supported.
            if (damageRegion.size() == 0)
                damageRegion = vector<EGLint>(4, 0);

            EGLU_CHECK_CALL(
                egl, setDamageRegionKHR(m_eglDisplay, m_eglSurface, &damageRegion[0], (EGLint)damageRegion.size() / 4));
        }
        else
        {
            EGLU_CHECK_CALL(egl, setDamageRegionKHR(m_eglDisplay, m_eglSurface, NULL, 0));
            clearColorScreen(m_gl, clearColor);
        }

        // during first half, just keep rendering without reading pixel back to mimic ordinary use case
        if (frameNdx < numFrames / 2)
            m_gles2Renderer->render(width, height, newFrame);
        else // do verification in the second half
        {
            const vector<int> framesOnBuffer = getFramesOnBuffer(bufferAges, frameNdx);

            clearColorReference(&refBuffer, clearColor);

            for (vector<int>::const_iterator it = framesOnBuffer.begin(); it != framesOnBuffer.end(); it++)
                m_refRenderer->render(&refBuffer, frameSequence[*it]);

            m_gles2Renderer->render(width, height, newFrame);
            m_refRenderer->render(&refBuffer, newFrame);

            readPixels(m_gl, &currentBuffer);

            if (!compareToReference(log, refBuffer, currentBuffer, frameNdx, frameNdx))
            {
                string errorMessage("Fail, render result is wrong. Buffer age is ");
                errorMessage += (m_supportBufferAge ? "supported" : "not supported");
                m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, errorMessage.c_str());
                return STOP;
            }
        }
        EGLU_CHECK_CALL(egl, swapBuffers(m_eglDisplay, m_eglSurface));
    }

    if (!hasPositiveAge) // fraud behavior, pretend to support partial_update
    {
        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL,
                                "Fail, claim to support partial_update but buffer age is always 0");
        return STOP;
    }

    m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
    return STOP;
}

string generateDrawTypeName(const vector<PartialUpdateTest::DrawType> &drawTypes)
{
    std::ostringstream stream;
    if (drawTypes.size() == 0)
        return string("_none");

    for (size_t ndx = 0; ndx < drawTypes.size(); ndx++)
    {
        if (drawTypes[ndx] == PartialUpdateTest::DRAWTYPE_GLES2_RENDER)
            stream << "_render";
        else if (drawTypes[ndx] == PartialUpdateTest::DRAWTYPE_GLES2_CLEAR)
            stream << "_clear";
        else
            DE_ASSERT(false);
    }
    return stream.str();
}

string generateTestName(const vector<PartialUpdateTest::DrawType> &oddFrameDrawType,
                        const vector<PartialUpdateTest::DrawType> &evenFrameDrawType)
{
    return "odd" + generateDrawTypeName(oddFrameDrawType) + "_even" + generateDrawTypeName(evenFrameDrawType);
}

bool isWindow(const eglu::CandidateConfig &c)
{
    return (c.surfaceType() & EGL_WINDOW_BIT) == EGL_WINDOW_BIT;
}

bool isES2Renderable(const eglu::CandidateConfig &c)
{
    return (c.get(EGL_RENDERABLE_TYPE) & EGL_OPENGL_ES2_BIT) == EGL_OPENGL_ES2_BIT;
}

EGLConfig getEGLConfig(const Library &egl, EGLDisplay eglDisplay)
{
    eglu::FilterList filters;
    filters << isWindow << isES2Renderable;
    return eglu::chooseSingleConfig(egl, eglDisplay, filters);
}

void clearColorScreen(const glw::Functions &gl, const tcu::Vec4 &clearColor)
{
    gl.clearColor(clearColor.x(), clearColor.y(), clearColor.z(), clearColor.w());
    gl.clear(GL_COLOR_BUFFER_BIT);
}

void clearColorReference(tcu::Surface *ref, const tcu::Vec4 &clearColor)
{
    tcu::clear(ref->getAccess(), clearColor);
}

void readPixels(const glw::Functions &gl, tcu::Surface *screen)
{
    gl.readPixels(0, 0, screen->getWidth(), screen->getHeight(), GL_RGBA, GL_UNSIGNED_BYTE,
                  screen->getAccess().getDataPtr());
}

float windowToDeviceCoordinates(int x, int length)
{
    return (2.0f * float(x) / float(length)) - 1.0f;
}

bool compareToReference(tcu::TestLog &log, const tcu::Surface &reference, const tcu::Surface &buffer, int frameNdx,
                        int bufferNum)
{
    std::ostringstream stream;
    stream << "FrameNdx = " << frameNdx << ", compare current buffer (numbered: " << bufferNum << ") to reference";
    return tcu::intThresholdPositionDeviationCompare(log, "partial update test", stream.str().c_str(),
                                                     reference.getAccess(), buffer.getAccess(), tcu::UVec4(8, 8, 8, 0),
                                                     tcu::IVec3(2, 2, 0), true, tcu::COMPARE_LOG_RESULT);
}

class RenderOutsideDamageRegion : public PartialUpdateTest
{
public:
    RenderOutsideDamageRegion(EglTestContext &eglTestCtx);
    TestCase::IterateResult iterate(void);
};

RenderOutsideDamageRegion::RenderOutsideDamageRegion(EglTestContext &eglTestCtx)
    : PartialUpdateTest(eglTestCtx, vector<DrawType>(1, DRAWTYPE_GLES2_RENDER),
                        vector<DrawType>(1, DRAWTYPE_GLES2_RENDER), "render_outside_damage_region", "")
{
}

TestCase::IterateResult RenderOutsideDamageRegion::iterate(void)
{
    de::Random rnd(m_seed);
    const Library &egl     = m_eglTestCtx.getLibrary();
    tcu::TestLog &log      = m_testCtx.getLog();
    const int width        = eglu::querySurfaceInt(egl, m_eglDisplay, m_eglSurface, EGL_WIDTH);
    const int height       = eglu::querySurfaceInt(egl, m_eglDisplay, m_eglSurface, EGL_HEIGHT);
    const float clearRed   = rnd.getFloat();
    const float clearGreen = rnd.getFloat();
    const float clearBlue  = rnd.getFloat();
    const tcu::Vec4 clearColor(clearRed, clearGreen, clearBlue, 1.0f);
    tcu::Surface currentBuffer(width, height);
    tcu::Surface refBuffer(width, height);
    Frame frame(width, height);

    EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED));

    generateRandomFrame(frame, m_evenFrameDrawType, rnd);

    {
        // render outside the region
        EGLint bufferAge            = -1;
        vector<EGLint> damageRegion = getDamageRegion(frame, 0, 0, 0, 0);

        EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_KHR, &bufferAge));
        EGLU_CHECK_CALL(
            egl, setDamageRegionKHR(m_eglDisplay, m_eglSurface, &damageRegion[0], (EGLint)damageRegion.size() / 4));
        clearColorScreen(m_gl, clearColor);
        m_gles2Renderer->render(width, height, frame);

        // next line will make the bug on Nexus 6 disappear
        // readPixels(m_gl, &currentBuffer);
    }

    EGLU_CHECK_CALL(egl, swapBuffers(m_eglDisplay, m_eglSurface));

    // render a new frame
    clearColorScreen(m_gl, clearColor);
    m_gles2Renderer->render(width, height, frame);
    clearColorReference(&refBuffer, clearColor);
    m_refRenderer->render(&refBuffer, frame);
    readPixels(m_gl, &currentBuffer);

    if (!compareToReference(log, refBuffer, currentBuffer, 0, 0))
        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail, fail to recover after rendering outside damageRegion");
    else
        m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");

    return STOP;
}

class RenderBeforeSetDamageRegion : public PartialUpdateTest
{
public:
    RenderBeforeSetDamageRegion(EglTestContext &eglTestCtx);
    TestCase::IterateResult iterate(void);
};

RenderBeforeSetDamageRegion::RenderBeforeSetDamageRegion(EglTestContext &eglTestCtx)
    : PartialUpdateTest(eglTestCtx, vector<DrawType>(1, DRAWTYPE_GLES2_RENDER),
                        vector<DrawType>(1, DRAWTYPE_GLES2_RENDER), "render_before_set_damage_region", "")
{
}

TestCase::IterateResult RenderBeforeSetDamageRegion::iterate(void)
{
    de::Random rnd(m_seed);
    const Library &egl     = m_eglTestCtx.getLibrary();
    tcu::TestLog &log      = m_testCtx.getLog();
    const int width        = eglu::querySurfaceInt(egl, m_eglDisplay, m_eglSurface, EGL_WIDTH);
    const int height       = eglu::querySurfaceInt(egl, m_eglDisplay, m_eglSurface, EGL_HEIGHT);
    const float clearRed   = rnd.getFloat();
    const float clearGreen = rnd.getFloat();
    const float clearBlue  = rnd.getFloat();
    const tcu::Vec4 clearColor(clearRed, clearGreen, clearBlue, 1.0f);
    tcu::Surface currentBuffer(width, height);
    tcu::Surface refBuffer(width, height);
    Frame frame(width, height);

    EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED));

    generateRandomFrame(frame, m_evenFrameDrawType, rnd);

    {
        // render before setDamageRegion
        EGLint bufferAge            = -1;
        vector<EGLint> damageRegion = getDamageRegion(frame, 0, 0, 0, 0);

        m_gles2Renderer->render(width, height, frame);
        EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_KHR, &bufferAge));
        EGLU_CHECK_CALL(
            egl, setDamageRegionKHR(m_eglDisplay, m_eglSurface, &damageRegion[0], (EGLint)damageRegion.size() / 4));

        // next line will make the bug on Nexus 6 disappear
        // readPixels(m_gl, &currentBuffer);
    }

    EGLU_CHECK_CALL(egl, swapBuffers(m_eglDisplay, m_eglSurface));

    // render a new frame
    clearColorScreen(m_gl, clearColor);
    m_gles2Renderer->render(width, height, frame);
    clearColorReference(&refBuffer, clearColor);
    m_refRenderer->render(&refBuffer, frame);
    readPixels(m_gl, &currentBuffer);

    if (!compareToReference(log, refBuffer, currentBuffer, 0, 0))
        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
    else
        m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");

    return STOP;
}

} // namespace

PartialUpdateTests::PartialUpdateTests(EglTestContext &eglTestCtx)
    : TestCaseGroup(eglTestCtx, "partial_update", "Partial update tests")
{
}

void PartialUpdateTests::init(void)
{
    const PartialUpdateTest::DrawType clearRender[2] = {PartialUpdateTest::DRAWTYPE_GLES2_CLEAR,
                                                        PartialUpdateTest::DRAWTYPE_GLES2_RENDER};

    const PartialUpdateTest::DrawType renderClear[2] = {PartialUpdateTest::DRAWTYPE_GLES2_RENDER,
                                                        PartialUpdateTest::DRAWTYPE_GLES2_CLEAR};

    vector<vector<PartialUpdateTest::DrawType>> frameDrawTypes;
    frameDrawTypes.push_back(vector<PartialUpdateTest::DrawType>());
    frameDrawTypes.push_back(vector<PartialUpdateTest::DrawType>(1, PartialUpdateTest::DRAWTYPE_GLES2_CLEAR));
    frameDrawTypes.push_back(vector<PartialUpdateTest::DrawType>(1, PartialUpdateTest::DRAWTYPE_GLES2_RENDER));
    frameDrawTypes.push_back(vector<PartialUpdateTest::DrawType>(2, PartialUpdateTest::DRAWTYPE_GLES2_CLEAR));
    frameDrawTypes.push_back(vector<PartialUpdateTest::DrawType>(2, PartialUpdateTest::DRAWTYPE_GLES2_RENDER));
    frameDrawTypes.push_back(
        vector<PartialUpdateTest::DrawType>(DE_ARRAY_BEGIN(clearRender), DE_ARRAY_END(clearRender)));
    frameDrawTypes.push_back(
        vector<PartialUpdateTest::DrawType>(DE_ARRAY_BEGIN(renderClear), DE_ARRAY_END(renderClear)));

    for (size_t evenNdx = 0; evenNdx < frameDrawTypes.size(); evenNdx++)
    {
        const vector<PartialUpdateTest::DrawType> &evenFrameDrawType = frameDrawTypes[evenNdx];

        for (size_t oddNdx = evenNdx; oddNdx < frameDrawTypes.size(); oddNdx++)
        {
            const vector<PartialUpdateTest::DrawType> &oddFrameDrawType = frameDrawTypes[oddNdx];
            const std::string name = generateTestName(oddFrameDrawType, evenFrameDrawType);
            if (oddFrameDrawType.size() == 0 && evenFrameDrawType.size() == 0)
                continue;

            addChild(new PartialUpdateTest(m_eglTestCtx, oddFrameDrawType, evenFrameDrawType, name.c_str(), ""));
        }
    }
    addChild(new RenderOutsideDamageRegion(m_eglTestCtx));
    addChild(new RenderBeforeSetDamageRegion(m_eglTestCtx));
}

} // namespace egl
} // namespace deqp