modules/egl/teglRenderTests.cpp

/*-------------------------------------------------------------------------
 * drawElements Quality Program EGL Module
 * ---------------------------------------
 *
 * Copyright 2014 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 Rendering tests for different config and api combinations.
 * \todo [2013-03-19 pyry] GLES1 and VG support.
 *//*--------------------------------------------------------------------*/

#include "teglRenderTests.hpp"
#include "teglRenderCase.hpp"

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

#include "egluDefs.hpp"
#include "egluUtil.hpp"

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

#include "gluShaderProgram.hpp"

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

#include "deRandom.hpp"
#include "deSharedPtr.hpp"
#include "deSemaphore.hpp"
#include "deThread.hpp"
#include "deString.h"

#include "rrRenderer.hpp"
#include "rrFragmentOperations.hpp"

#include <algorithm>
#include <iterator>
#include <memory>
#include <set>

namespace deqp
{
namespace egl
{

using std::set;
using std::string;
using std::vector;

using tcu::Vec4;

using tcu::TestLog;

using namespace glw;
using namespace eglw;

static const tcu::Vec4 CLEAR_COLOR = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f);
static const float CLEAR_DEPTH     = 1.0f;
static const int CLEAR_STENCIL     = 0;

namespace
{

enum PrimitiveType
{
    PRIMITIVETYPE_TRIANGLE = 0, //!< Triangles, requires 3 coordinates per primitive
    //    PRIMITIVETYPE_POINT, //!< Points, requires 1 coordinate per primitive (w is used as size)
    //    PRIMITIVETYPE_LINE, //!< Lines, requires 2 coordinates per primitive

    PRIMITIVETYPE_LAST
};

enum BlendMode
{
    BLENDMODE_NONE = 0, //!< No blending
    BLENDMODE_ADDITIVE, //!< Blending with ONE, ONE
    BLENDMODE_SRC_OVER, //!< Blending with SRC_ALPHA, ONE_MINUS_SRC_ALPHA

    BLENDMODE_LAST
};

enum DepthMode
{
    DEPTHMODE_NONE = 0, //!< No depth test or depth writes
    DEPTHMODE_LESS,     //!< Depth test with less & depth write

    DEPTHMODE_LAST
};

enum StencilMode
{
    STENCILMODE_NONE = 0,   //!< No stencil test or write
    STENCILMODE_LEQUAL_INC, //!< Stencil test with LEQUAL, increment on pass

    STENCILMODE_LAST
};

struct DrawPrimitiveOp
{
    PrimitiveType type;
    int count;
    vector<Vec4> positions;
    vector<Vec4> colors;
    BlendMode blend;
    DepthMode depth;
    StencilMode stencil;
    int stencilRef;
};

static bool isANarrowScreenSpaceTriangle(const tcu::Vec4 &p0, const tcu::Vec4 &p1, const tcu::Vec4 &p2)
{
    // to clip space
    const tcu::Vec2 csp0 = p0.swizzle(0, 1) / p0.w();
    const tcu::Vec2 csp1 = p1.swizzle(0, 1) / p1.w();
    const tcu::Vec2 csp2 = p2.swizzle(0, 1) / p2.w();

    const tcu::Vec2 e01 = (csp1 - csp0);
    const tcu::Vec2 e02 = (csp2 - csp0);

    const float minimumVisibleArea = 0.4f; // must cover at least 10% of the surface
    const float visibleArea        = de::abs(e01.x() * e02.y() - e02.x() * e01.y()) * 0.5f;

    return visibleArea < minimumVisibleArea;
}

void randomizeDrawOp(de::Random &rnd, DrawPrimitiveOp &drawOp, const bool alphaZeroOrOne)
{
    const int minStencilRef = 0;
    const int maxStencilRef = 8;
    const int minPrimitives = 2;
    const int maxPrimitives = 4;

    const float maxTriOffset = 1.0f;
    const float minDepth     = -1.0f; // \todo [pyry] Reference doesn't support Z clipping yet
    const float maxDepth     = 1.0f;

    const float minRGB   = 0.2f;
    const float maxRGB   = 0.9f;
    const float minAlpha = 0.3f;
    const float maxAlpha = 1.0f;

    drawOp.type       = (PrimitiveType)rnd.getInt(0, PRIMITIVETYPE_LAST - 1);
    drawOp.count      = rnd.getInt(minPrimitives, maxPrimitives);
    drawOp.blend      = (BlendMode)rnd.getInt(0, BLENDMODE_LAST - 1);
    drawOp.depth      = (DepthMode)rnd.getInt(0, DEPTHMODE_LAST - 1);
    drawOp.stencil    = (StencilMode)rnd.getInt(0, STENCILMODE_LAST - 1);
    drawOp.stencilRef = rnd.getInt(minStencilRef, maxStencilRef);

    if (drawOp.type == PRIMITIVETYPE_TRIANGLE)
    {
        drawOp.positions.resize(drawOp.count * 3);
        drawOp.colors.resize(drawOp.count * 3);

        for (int triNdx = 0; triNdx < drawOp.count; triNdx++)
        {
            const float cx        = rnd.getFloat(-1.0f, 1.0f);
            const float cy        = rnd.getFloat(-1.0f, 1.0f);
            const float flatAlpha = (rnd.getFloat(minAlpha, maxAlpha) > 0.5f) ? 1.0f : 0.0f;

            for (int coordNdx = 0; coordNdx < 3; coordNdx++)
            {
                tcu::Vec4 &position = drawOp.positions[triNdx * 3 + coordNdx];
                tcu::Vec4 &color    = drawOp.colors[triNdx * 3 + coordNdx];

                position.x() = cx + rnd.getFloat(-maxTriOffset, maxTriOffset);
                position.y() = cy + rnd.getFloat(-maxTriOffset, maxTriOffset);
                position.z() = rnd.getFloat(minDepth, maxDepth);
                position.w() = 1.0f;

                color.x() = rnd.getFloat(minRGB, maxRGB);
                color.y() = rnd.getFloat(minRGB, maxRGB);
                color.z() = rnd.getFloat(minRGB, maxRGB);
                color.w() = rnd.getFloat(minAlpha, maxAlpha);

                if (alphaZeroOrOne)
                {
                    color.w() = flatAlpha;
                }
            }

            // avoid generating narrow triangles
            {
                const int maxAttempts = 100;
                int numAttempts       = 0;
                tcu::Vec4 &p0         = drawOp.positions[triNdx * 3 + 0];
                tcu::Vec4 &p1         = drawOp.positions[triNdx * 3 + 1];
                tcu::Vec4 &p2         = drawOp.positions[triNdx * 3 + 2];

                while (isANarrowScreenSpaceTriangle(p0, p1, p2))
                {
                    p1.x() = cx + rnd.getFloat(-maxTriOffset, maxTriOffset);
                    p1.y() = cy + rnd.getFloat(-maxTriOffset, maxTriOffset);
                    p1.z() = rnd.getFloat(minDepth, maxDepth);
                    p1.w() = 1.0f;

                    p2.x() = cx + rnd.getFloat(-maxTriOffset, maxTriOffset);
                    p2.y() = cy + rnd.getFloat(-maxTriOffset, maxTriOffset);
                    p2.z() = rnd.getFloat(minDepth, maxDepth);
                    p2.w() = 1.0f;

                    if (++numAttempts > maxAttempts)
                    {
                        DE_ASSERT(false);
                        break;
                    }
                }
            }
        }
    }
    else
        DE_ASSERT(false);
}

// Reference rendering code

class ReferenceShader : public rr::VertexShader, public rr::FragmentShader
{
public:
    enum
    {
        VaryingLoc_Color = 0
    };

    ReferenceShader()
        : rr::VertexShader(2, 1)   // color and pos in => color out
        , rr::FragmentShader(1, 1) // color in => color out
    {
        this->rr::VertexShader::m_inputs[0].type = rr::GENERICVECTYPE_FLOAT;
        this->rr::VertexShader::m_inputs[1].type = rr::GENERICVECTYPE_FLOAT;

        this->rr::VertexShader::m_outputs[0].type      = rr::GENERICVECTYPE_FLOAT;
        this->rr::VertexShader::m_outputs[0].flatshade = false;

        this->rr::FragmentShader::m_inputs[0].type      = rr::GENERICVECTYPE_FLOAT;
        this->rr::FragmentShader::m_inputs[0].flatshade = false;

        this->rr::FragmentShader::m_outputs[0].type = rr::GENERICVECTYPE_FLOAT;
    }

    void shadeVertices(const rr::VertexAttrib *inputs, rr::VertexPacket *const *packets, const int numPackets) const
    {
        for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
        {
            const int positionAttrLoc = 0;
            const int colorAttrLoc    = 1;

            rr::VertexPacket &packet = *packets[packetNdx];

            // Transform to position
            packet.position = rr::readVertexAttribFloat(inputs[positionAttrLoc], packet.instanceNdx, packet.vertexNdx);

            // Pass color to FS
            packet.outputs[VaryingLoc_Color] =
                rr::readVertexAttribFloat(inputs[colorAttrLoc], packet.instanceNdx, packet.vertexNdx);
        }
    }

    void shadeFragments(rr::FragmentPacket *packets, const int numPackets,
                        const rr::FragmentShadingContext &context) const
    {
        for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
        {
            rr::FragmentPacket &packet = packets[packetNdx];

            for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
                rr::writeFragmentOutput(context, packetNdx, fragNdx, 0,
                                        rr::readVarying<float>(packet, context, VaryingLoc_Color, fragNdx));
        }
    }
};

void toReferenceRenderState(rr::RenderState &state, const DrawPrimitiveOp &drawOp)
{
    state.cullMode = rr::CULLMODE_NONE;

    if (drawOp.blend != BLENDMODE_NONE)
    {
        state.fragOps.blendMode = rr::BLENDMODE_STANDARD;

        switch (drawOp.blend)
        {
        case BLENDMODE_ADDITIVE:
            state.fragOps.blendRGBState.srcFunc  = rr::BLENDFUNC_ONE;
            state.fragOps.blendRGBState.dstFunc  = rr::BLENDFUNC_ONE;
            state.fragOps.blendRGBState.equation = rr::BLENDEQUATION_ADD;
            state.fragOps.blendAState            = state.fragOps.blendRGBState;
            break;

        case BLENDMODE_SRC_OVER:
            state.fragOps.blendRGBState.srcFunc  = rr::BLENDFUNC_SRC_ALPHA;
            state.fragOps.blendRGBState.dstFunc  = rr::BLENDFUNC_ONE_MINUS_SRC_ALPHA;
            state.fragOps.blendRGBState.equation = rr::BLENDEQUATION_ADD;
            state.fragOps.blendAState            = state.fragOps.blendRGBState;
            break;

        default:
            DE_ASSERT(false);
        }
    }

    if (drawOp.depth != DEPTHMODE_NONE)
    {
        state.fragOps.depthTestEnabled = true;

        DE_ASSERT(drawOp.depth == DEPTHMODE_LESS);
        state.fragOps.depthFunc = rr::TESTFUNC_LESS;
    }

    if (drawOp.stencil != STENCILMODE_NONE)
    {
        state.fragOps.stencilTestEnabled = true;

        DE_ASSERT(drawOp.stencil == STENCILMODE_LEQUAL_INC);
        state.fragOps.stencilStates[0].func   = rr::TESTFUNC_LEQUAL;
        state.fragOps.stencilStates[0].sFail  = rr::STENCILOP_KEEP;
        state.fragOps.stencilStates[0].dpFail = rr::STENCILOP_INCR;
        state.fragOps.stencilStates[0].dpPass = rr::STENCILOP_INCR;
        state.fragOps.stencilStates[0].ref    = drawOp.stencilRef;
        state.fragOps.stencilStates[1]        = state.fragOps.stencilStates[0];
    }
}

tcu::TextureFormat getColorFormat(const tcu::PixelFormat &colorBits)
{
    using tcu::TextureFormat;

    DE_ASSERT(de::inBounds(colorBits.redBits, 0, 0xff) && de::inBounds(colorBits.greenBits, 0, 0xff) &&
              de::inBounds(colorBits.blueBits, 0, 0xff) && de::inBounds(colorBits.alphaBits, 0, 0xff));

#define PACK_FMT(R, G, B, A) (((R) << 24) | ((G) << 16) | ((B) << 8) | (A))

    // \note [pyry] This may not hold true on some implementations - best effort guess only.
    switch (PACK_FMT(colorBits.redBits, colorBits.greenBits, colorBits.blueBits, colorBits.alphaBits))
    {
    case PACK_FMT(8, 8, 8, 8):
        return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8);
    case PACK_FMT(8, 8, 8, 0):
        return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8);
    case PACK_FMT(4, 4, 4, 4):
        return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_4444);
    case PACK_FMT(5, 5, 5, 1):
        return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_5551);
    case PACK_FMT(5, 6, 5, 0):
        return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_SHORT_565);
    case PACK_FMT(10, 10, 10, 2):
        return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT_1010102_REV);
    case PACK_FMT(10, 10, 10, 0):
        return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT_101010);
    // \note Defaults to RGBA8
    default:
        return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8);
    }

#undef PACK_FMT
}

/*
The getColorThreshold function is used to obtain a
threshold usable for the fuzzyCompare function.

For 8bit color depths a value of 0.02 should provide
a good metric for rejecting images above this level.
For other bit depths other thresholds should be selected.
Ideally this function would take advantage of the
getColorThreshold function provided by the PixelFormat class
as this would also allow setting per channel thresholds.
However using the PixelFormat provided function can result
in too strict thresholds for 8bit bit depths (compared to
the current default of 0.02) or too relaxed for lower bit
depths if scaled proportionally to the 8bit default.
*/

float getColorThreshold(const tcu::PixelFormat &colorBits)
{
    if ((colorBits.redBits > 0 && colorBits.redBits < 8) || (colorBits.greenBits > 0 && colorBits.greenBits < 8) ||
        (colorBits.blueBits > 0 && colorBits.blueBits < 8) || (colorBits.alphaBits > 0 && colorBits.alphaBits < 8))
    {
        return 0.05f;
    }
    else
    {
        return 0.02f;
    }
}

tcu::TextureFormat getDepthFormat(const int depthBits)
{
    switch (depthBits)
    {
    case 0:
        return tcu::TextureFormat();
    case 8:
        return tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::UNORM_INT8);
    case 16:
        return tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::UNORM_INT16);
    case 24:
        return tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::UNORM_INT24);
    case 32:
    default:
        return tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::FLOAT);
    }
}

tcu::TextureFormat getStencilFormat(int stencilBits)
{
    switch (stencilBits)
    {
    case 0:
        return tcu::TextureFormat();
    case 8:
    default:
        return tcu::TextureFormat(tcu::TextureFormat::S, tcu::TextureFormat::UNSIGNED_INT8);
    }
}

void renderReference(const tcu::PixelBufferAccess &dst, const vector<DrawPrimitiveOp> &drawOps,
                     const tcu::PixelFormat &colorBits, const int depthBits, const int stencilBits,
                     const int numSamples, const int subpixelBits)
{
    const int width  = dst.getWidth();
    const int height = dst.getHeight();

    tcu::TextureLevel colorBuffer;
    tcu::TextureLevel depthBuffer;
    tcu::TextureLevel stencilBuffer;

    rr::Renderer referenceRenderer;
    rr::VertexAttrib attributes[2];
    const ReferenceShader shader;

    attributes[0].type            = rr::VERTEXATTRIBTYPE_FLOAT;
    attributes[0].size            = 4;
    attributes[0].stride          = 0;
    attributes[0].instanceDivisor = 0;

    attributes[1].type            = rr::VERTEXATTRIBTYPE_FLOAT;
    attributes[1].size            = 4;
    attributes[1].stride          = 0;
    attributes[1].instanceDivisor = 0;

    // Initialize buffers.
    colorBuffer.setStorage(getColorFormat(colorBits), numSamples, width, height);
    rr::clearMultisampleColorBuffer(colorBuffer, CLEAR_COLOR, rr::WindowRectangle(0, 0, width, height));

    if (depthBits > 0)
    {
        depthBuffer.setStorage(getDepthFormat(depthBits), numSamples, width, height);
        rr::clearMultisampleDepthBuffer(depthBuffer, CLEAR_DEPTH, rr::WindowRectangle(0, 0, width, height));
    }

    if (stencilBits > 0)
    {
        stencilBuffer.setStorage(getStencilFormat(stencilBits), numSamples, width, height);
        rr::clearMultisampleStencilBuffer(stencilBuffer, CLEAR_STENCIL, rr::WindowRectangle(0, 0, width, height));
    }

    const rr::RenderTarget renderTarget(
        rr::MultisamplePixelBufferAccess::fromMultisampleAccess(colorBuffer.getAccess()),
        rr::MultisamplePixelBufferAccess::fromMultisampleAccess(depthBuffer.getAccess()),
        rr::MultisamplePixelBufferAccess::fromMultisampleAccess(stencilBuffer.getAccess()));

    for (vector<DrawPrimitiveOp>::const_iterator drawOp = drawOps.begin(); drawOp != drawOps.end(); drawOp++)
    {
        // Translate state
        rr::RenderState renderState(
            (rr::ViewportState)(rr::MultisamplePixelBufferAccess::fromMultisampleAccess(colorBuffer.getAccess())),
            subpixelBits);
        toReferenceRenderState(renderState, *drawOp);

        DE_ASSERT(drawOp->type == PRIMITIVETYPE_TRIANGLE);

        attributes[0].pointer = &drawOp->positions[0];
        attributes[1].pointer = &drawOp->colors[0];

        referenceRenderer.draw(rr::DrawCommand(renderState, renderTarget,
                                               rr::Program(static_cast<const rr::VertexShader *>(&shader),
                                                           static_cast<const rr::FragmentShader *>(&shader)),
                                               2, attributes,
                                               rr::PrimitiveList(rr::PRIMITIVETYPE_TRIANGLES, drawOp->count * 3, 0)));
    }

    rr::resolveMultisampleColorBuffer(dst,
                                      rr::MultisamplePixelBufferAccess::fromMultisampleAccess(colorBuffer.getAccess()));
}

// API rendering code

class Program
{
public:
    Program(void)
    {
    }
    virtual ~Program(void)
    {
    }

    virtual void setup(void) const = DE_NULL;
};

typedef de::SharedPtr<Program> ProgramSp;

static glu::ProgramSources getProgramSourcesES2(void)
{
    static const char *s_vertexSrc = "attribute highp vec4 a_position;\n"
                                     "attribute mediump vec4 a_color;\n"
                                     "varying mediump vec4 v_color;\n"
                                     "void main (void)\n"
                                     "{\n"
                                     "    gl_Position = a_position;\n"
                                     "    v_color = a_color;\n"
                                     "}\n";

    static const char *s_fragmentSrc = "varying mediump vec4 v_color;\n"
                                       "void main (void)\n"
                                       "{\n"
                                       "    gl_FragColor = v_color;\n"
                                       "}\n";

    return glu::ProgramSources() << glu::VertexSource(s_vertexSrc) << glu::FragmentSource(s_fragmentSrc);
}

class GLES2Program : public Program
{
public:
    GLES2Program(const glw::Functions &gl)
        : m_gl(gl)
        , m_program(gl, getProgramSourcesES2())
        , m_positionLoc(0)
        , m_colorLoc(0)
    {

        m_positionLoc = m_gl.getAttribLocation(m_program.getProgram(), "a_position");
        m_colorLoc    = m_gl.getAttribLocation(m_program.getProgram(), "a_color");
    }

    ~GLES2Program(void)
    {
    }

    void setup(void) const
    {
        m_gl.useProgram(m_program.getProgram());
        m_gl.enableVertexAttribArray(m_positionLoc);
        m_gl.enableVertexAttribArray(m_colorLoc);
        GLU_CHECK_GLW_MSG(m_gl, "Program setup failed");
    }

    int getPositionLoc(void) const
    {
        return m_positionLoc;
    }
    int getColorLoc(void) const
    {
        return m_colorLoc;
    }

private:
    const glw::Functions &m_gl;
    glu::ShaderProgram m_program;
    int m_positionLoc;
    int m_colorLoc;
};

void clearGLES2(const glw::Functions &gl, const tcu::Vec4 &color, const float depth, const int stencil)
{
    gl.clearColor(color.x(), color.y(), color.z(), color.w());
    gl.clearDepthf(depth);
    gl.clearStencil(stencil);
    gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
}

void drawGLES2(const glw::Functions &gl, const Program &program, const DrawPrimitiveOp &drawOp)
{
    const GLES2Program &gles2Program = dynamic_cast<const GLES2Program &>(program);

    switch (drawOp.blend)
    {
    case BLENDMODE_NONE:
        gl.disable(GL_BLEND);
        break;

    case BLENDMODE_ADDITIVE:
        gl.enable(GL_BLEND);
        gl.blendFunc(GL_ONE, GL_ONE);
        break;

    case BLENDMODE_SRC_OVER:
        gl.enable(GL_BLEND);
        gl.blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        break;

    default:
        DE_ASSERT(false);
    }

    switch (drawOp.depth)
    {
    case DEPTHMODE_NONE:
        gl.disable(GL_DEPTH_TEST);
        break;

    case DEPTHMODE_LESS:
        gl.enable(GL_DEPTH_TEST);
        break;

    default:
        DE_ASSERT(false);
    }

    switch (drawOp.stencil)
    {
    case STENCILMODE_NONE:
        gl.disable(GL_STENCIL_TEST);
        break;

    case STENCILMODE_LEQUAL_INC:
        gl.enable(GL_STENCIL_TEST);
        gl.stencilFunc(GL_LEQUAL, drawOp.stencilRef, ~0u);
        gl.stencilOp(GL_KEEP, GL_INCR, GL_INCR);
        break;

    default:
        DE_ASSERT(false);
    }

    gl.disable(GL_DITHER);

    gl.vertexAttribPointer(gles2Program.getPositionLoc(), 4, GL_FLOAT, GL_FALSE, 0, &drawOp.positions[0]);
    gl.vertexAttribPointer(gles2Program.getColorLoc(), 4, GL_FLOAT, GL_FALSE, 0, &drawOp.colors[0]);

    DE_ASSERT(drawOp.type == PRIMITIVETYPE_TRIANGLE);
    gl.drawArrays(GL_TRIANGLES, 0, drawOp.count * 3);
}

static void readPixelsGLES2(const glw::Functions &gl, tcu::Surface &dst)
{
    gl.readPixels(0, 0, dst.getWidth(), dst.getHeight(), GL_RGBA, GL_UNSIGNED_BYTE, dst.getAccess().getDataPtr());
}

Program *createProgram(const glw::Functions &gl, EGLint api)
{
    switch (api)
    {
    case EGL_OPENGL_ES2_BIT:
        return new GLES2Program(gl);
    case EGL_OPENGL_ES3_BIT_KHR:
        return new GLES2Program(gl);
    default:
        throw tcu::NotSupportedError("Unsupported API");
    }
}

void draw(const glw::Functions &gl, EGLint api, const Program &program, const DrawPrimitiveOp &drawOp)
{
    switch (api)
    {
    case EGL_OPENGL_ES2_BIT:
        drawGLES2(gl, program, drawOp);
        break;
    case EGL_OPENGL_ES3_BIT_KHR:
        drawGLES2(gl, program, drawOp);
        break;
    default:
        throw tcu::NotSupportedError("Unsupported API");
    }
}

void clear(const glw::Functions &gl, EGLint api, const tcu::Vec4 &color, const float depth, const int stencil)
{
    switch (api)
    {
    case EGL_OPENGL_ES2_BIT:
        clearGLES2(gl, color, depth, stencil);
        break;
    case EGL_OPENGL_ES3_BIT_KHR:
        clearGLES2(gl, color, depth, stencil);
        break;
    default:
        throw tcu::NotSupportedError("Unsupported API");
    }
}

static void readPixels(const glw::Functions &gl, EGLint api, tcu::Surface &dst)
{
    switch (api)
    {
    case EGL_OPENGL_ES2_BIT:
        readPixelsGLES2(gl, dst);
        break;
    case EGL_OPENGL_ES3_BIT_KHR:
        readPixelsGLES2(gl, dst);
        break;
    default:
        throw tcu::NotSupportedError("Unsupported API");
    }
}

static void finish(const glw::Functions &gl, EGLint api)
{
    switch (api)
    {
    case EGL_OPENGL_ES2_BIT:
    case EGL_OPENGL_ES3_BIT_KHR:
        gl.finish();
        break;

    default:
        throw tcu::NotSupportedError("Unsupported API");
    }
}

tcu::PixelFormat getPixelFormat(const Library &egl, EGLDisplay display, EGLConfig config)
{
    tcu::PixelFormat fmt;
    fmt.redBits   = eglu::getConfigAttribInt(egl, display, config, EGL_RED_SIZE);
    fmt.greenBits = eglu::getConfigAttribInt(egl, display, config, EGL_GREEN_SIZE);
    fmt.blueBits  = eglu::getConfigAttribInt(egl, display, config, EGL_BLUE_SIZE);
    fmt.alphaBits = eglu::getConfigAttribInt(egl, display, config, EGL_ALPHA_SIZE);
    return fmt;
}

} // namespace

// SingleThreadRenderCase

class SingleThreadRenderCase : public MultiContextRenderCase
{
public:
    SingleThreadRenderCase(EglTestContext &eglTestCtx, const char *name, const char *description, EGLint api,
                           EGLint surfaceType, const eglu::FilterList &filters, int numContextsPerApi);

    void init(void);

private:
    virtual void executeForContexts(EGLDisplay display, EGLSurface surface, const Config &config,
                                    const std::vector<std::pair<EGLint, EGLContext>> &contexts);

    glw::Functions m_gl;
};

// SingleThreadColorClearCase

SingleThreadRenderCase::SingleThreadRenderCase(EglTestContext &eglTestCtx, const char *name, const char *description,
                                               EGLint api, EGLint surfaceType, const eglu::FilterList &filters,
                                               int numContextsPerApi)
    : MultiContextRenderCase(eglTestCtx, name, description, api, surfaceType, filters, numContextsPerApi)
{
}

void SingleThreadRenderCase::init(void)
{
    MultiContextRenderCase::init();
    m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2, 0));
}

void SingleThreadRenderCase::executeForContexts(EGLDisplay display, EGLSurface surface, const Config &config,
                                                const std::vector<std::pair<EGLint, EGLContext>> &contexts)
{
    const Library &egl              = m_eglTestCtx.getLibrary();
    const int width                 = eglu::querySurfaceInt(egl, display, surface, EGL_WIDTH);
    const int height                = eglu::querySurfaceInt(egl, display, surface, EGL_HEIGHT);
    const int numContexts           = (int)contexts.size();
    const int drawsPerCtx           = 2;
    const int numIters              = 2;
    const tcu::PixelFormat pixelFmt = getPixelFormat(egl, display, config.config);
    const float threshold           = getColorThreshold(pixelFmt);

    const int depthBits   = eglu::getConfigAttribInt(egl, display, config.config, EGL_DEPTH_SIZE);
    const int stencilBits = eglu::getConfigAttribInt(egl, display, config.config, EGL_STENCIL_SIZE);
    const int numSamples  = eglu::getConfigAttribInt(egl, display, config.config, EGL_SAMPLES);

    TestLog &log = m_testCtx.getLog();

    tcu::Surface refFrame(width, height);
    tcu::Surface frame(width, height);

    de::Random rnd(deStringHash(getName()) ^ deInt32Hash(numContexts));
    vector<ProgramSp> programs(contexts.size());
    vector<DrawPrimitiveOp> drawOps;

    // Log basic information about config.
    log << TestLog::Message << "EGL_RED_SIZE = " << pixelFmt.redBits << TestLog::EndMessage;
    log << TestLog::Message << "EGL_GREEN_SIZE = " << pixelFmt.greenBits << TestLog::EndMessage;
    log << TestLog::Message << "EGL_BLUE_SIZE = " << pixelFmt.blueBits << TestLog::EndMessage;
    log << TestLog::Message << "EGL_ALPHA_SIZE = " << pixelFmt.alphaBits << TestLog::EndMessage;
    log << TestLog::Message << "EGL_DEPTH_SIZE = " << depthBits << TestLog::EndMessage;
    log << TestLog::Message << "EGL_STENCIL_SIZE = " << stencilBits << TestLog::EndMessage;
    log << TestLog::Message << "EGL_SAMPLES = " << numSamples << TestLog::EndMessage;

    // Generate draw ops.
    drawOps.resize(numContexts * drawsPerCtx * numIters);
    for (vector<DrawPrimitiveOp>::iterator drawOp = drawOps.begin(); drawOp != drawOps.end(); ++drawOp)
    {
        // The randomized draws force us to use the fuzzyCompare algorithm to check for possible rasterization differences between
        // our rasterizer and the one used by the implementation. However, fuzzyCompare only takes a single float as the error
        // threshold. As per the comments in the code, that threshold doesn't have a direct equivalent to a difference in color
        // values. Instead, it's related to an accumulated quadratic error. Also according to these comments, this works well for
        // rgba8 (the only case it was originally designed for), and it can also be made to work for other formats in which all
        // used channels have a roughly similar number of bits.
        //
        // However, in some of these tests we will run this code using formats such as rgb10a2, in which the alpha can only have
        // values of 0, 0.33, 0.66 and 1.0 while other channels have much more precission. Any small difference in the rounding
        // applied by CTS and the implementation could result in wildly different alpha values that make using the single floating
        // point threshold risky, because we can't separate the alpha errors from the rgb errors. If we increase the threshold to
        // a point which is acceptable for alpha errors, the kind of errors we allow in the colors would be huge.
        //
        // For this reason, with 2 bits for alpha we restrict ourselves to alpha values of 1.0 and 0.0, as if alphabits was 1.
        randomizeDrawOp(rnd, *drawOp, (pixelFmt.alphaBits <= 2));
    }

    // Create and setup programs per context
    for (int ctxNdx = 0; ctxNdx < numContexts; ctxNdx++)
    {
        EGLint api         = contexts[ctxNdx].first;
        EGLContext context = contexts[ctxNdx].second;

        EGLU_CHECK_CALL(egl, makeCurrent(display, surface, surface, context));

        programs[ctxNdx] = ProgramSp(createProgram(m_gl, api));
        programs[ctxNdx]->setup();
    }

    // Clear to black using first context.
    {
        EGLint api         = contexts[0].first;
        EGLContext context = contexts[0].second;

        EGLU_CHECK_CALL(egl, makeCurrent(display, surface, surface, context));

        clear(m_gl, api, CLEAR_COLOR, CLEAR_DEPTH, CLEAR_STENCIL);
        finish(m_gl, api);
    }

    // Render.
    for (int iterNdx = 0; iterNdx < numIters; iterNdx++)
    {
        for (int ctxNdx = 0; ctxNdx < numContexts; ctxNdx++)
        {
            EGLint api         = contexts[ctxNdx].first;
            EGLContext context = contexts[ctxNdx].second;

            EGLU_CHECK_CALL(egl, makeCurrent(display, surface, surface, context));

            for (int drawNdx = 0; drawNdx < drawsPerCtx; drawNdx++)
            {
                const DrawPrimitiveOp &drawOp =
                    drawOps[iterNdx * numContexts * drawsPerCtx + ctxNdx * drawsPerCtx + drawNdx];
                draw(m_gl, api, *programs[ctxNdx], drawOp);
            }

            finish(m_gl, api);
        }
    }

    // Read pixels using first context. \todo [pyry] Randomize?
    {
        EGLint api         = contexts[0].first;
        EGLContext context = contexts[0].second;

        EGLU_CHECK_CALL(egl, makeCurrent(display, surface, surface, context));

        readPixels(m_gl, api, frame);
    }

    int subpixelBits = 0;
    m_gl.getIntegerv(GL_SUBPIXEL_BITS, &subpixelBits);

    EGLU_CHECK_CALL(egl, makeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));

    // Render reference.
    // \note Reference image is always generated using single-sampling.
    renderReference(refFrame.getAccess(), drawOps, pixelFmt, depthBits, stencilBits, 1, subpixelBits);

    // Compare images
    {
        bool imagesOk = tcu::fuzzyCompare(log, "ComparisonResult", "Image comparison result", refFrame, frame,
                                          threshold, tcu::COMPARE_LOG_RESULT);

        if (!imagesOk)
            m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
    }
}

// MultiThreadRenderCase

class MultiThreadRenderCase : public MultiContextRenderCase
{
public:
    MultiThreadRenderCase(EglTestContext &eglTestCtx, const char *name, const char *description, EGLint api,
                          EGLint surfaceType, const eglu::FilterList &filters, int numContextsPerApi);

    void init(void);

private:
    virtual void executeForContexts(EGLDisplay display, EGLSurface surface, const Config &config,
                                    const std::vector<std::pair<EGLint, EGLContext>> &contexts);

    glw::Functions m_gl;
};

class RenderTestThread;

typedef de::SharedPtr<RenderTestThread> RenderTestThreadSp;
typedef de::SharedPtr<de::Semaphore> SemaphoreSp;

struct DrawOpPacket
{
    DrawOpPacket(void) : drawOps(DE_NULL), numOps(0)
    {
    }

    const DrawPrimitiveOp *drawOps;
    int numOps;
    SemaphoreSp wait;
    SemaphoreSp signal;
};

class RenderTestThread : public de::Thread
{
public:
    RenderTestThread(const Library &egl, EGLDisplay display, EGLSurface surface, EGLContext context, EGLint api,
                     const glw::Functions &gl, const Program &program, const std::vector<DrawOpPacket> &packets)
        : m_egl(egl)
        , m_display(display)
        , m_surface(surface)
        , m_context(context)
        , m_api(api)
        , m_gl(gl)
        , m_program(program)
        , m_packets(packets)
    {
    }

    void run(void)
    {
        for (std::vector<DrawOpPacket>::const_iterator packetIter = m_packets.begin(); packetIter != m_packets.end();
             packetIter++)
        {
            // Wait until it is our turn.
            packetIter->wait->decrement();

            // Acquire context.
            EGLU_CHECK_CALL(m_egl, makeCurrent(m_display, m_surface, m_surface, m_context));

            // Execute rendering.
            for (int ndx = 0; ndx < packetIter->numOps; ndx++)
                draw(m_gl, m_api, m_program, packetIter->drawOps[ndx]);

            finish(m_gl, m_api);

            // Release context.
            EGLU_CHECK_CALL(m_egl, makeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));

            // Signal completion.
            packetIter->signal->increment();
        }
        m_egl.releaseThread();
    }

private:
    const Library &m_egl;
    EGLDisplay m_display;
    EGLSurface m_surface;
    EGLContext m_context;
    EGLint m_api;
    const glw::Functions &m_gl;
    const Program &m_program;
    const std::vector<DrawOpPacket> &m_packets;
};

MultiThreadRenderCase::MultiThreadRenderCase(EglTestContext &eglTestCtx, const char *name, const char *description,
                                             EGLint api, EGLint surfaceType, const eglu::FilterList &filters,
                                             int numContextsPerApi)
    : MultiContextRenderCase(eglTestCtx, name, description, api, surfaceType, filters, numContextsPerApi)
{
}

void MultiThreadRenderCase::init(void)
{
    MultiContextRenderCase::init();
    m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2, 0));
}

void MultiThreadRenderCase::executeForContexts(EGLDisplay display, EGLSurface surface, const Config &config,
                                               const std::vector<std::pair<EGLint, EGLContext>> &contexts)
{
    const Library &egl              = m_eglTestCtx.getLibrary();
    const int width                 = eglu::querySurfaceInt(egl, display, surface, EGL_WIDTH);
    const int height                = eglu::querySurfaceInt(egl, display, surface, EGL_HEIGHT);
    const int numContexts           = (int)contexts.size();
    const int opsPerPacket          = 2;
    const int packetsPerThread      = 2;
    const int numThreads            = numContexts;
    const int numPackets            = numThreads * packetsPerThread;
    const tcu::PixelFormat pixelFmt = getPixelFormat(egl, display, config.config);
    const float threshold           = getColorThreshold(pixelFmt);

    const int depthBits   = eglu::getConfigAttribInt(egl, display, config.config, EGL_DEPTH_SIZE);
    const int stencilBits = eglu::getConfigAttribInt(egl, display, config.config, EGL_STENCIL_SIZE);
    const int numSamples  = eglu::getConfigAttribInt(egl, display, config.config, EGL_SAMPLES);

    TestLog &log = m_testCtx.getLog();

    tcu::Surface refFrame(width, height);
    tcu::Surface frame(width, height);

    de::Random rnd(deStringHash(getName()) ^ deInt32Hash(numContexts));

    // Resources that need cleanup
    vector<ProgramSp> programs(numContexts);
    vector<SemaphoreSp> semaphores(numPackets + 1);
    vector<DrawPrimitiveOp> drawOps(numPackets * opsPerPacket);
    vector<vector<DrawOpPacket>> packets(numThreads);
    vector<RenderTestThreadSp> threads(numThreads);

    // Log basic information about config.
    log << TestLog::Message << "EGL_RED_SIZE = " << pixelFmt.redBits << TestLog::EndMessage;
    log << TestLog::Message << "EGL_GREEN_SIZE = " << pixelFmt.greenBits << TestLog::EndMessage;
    log << TestLog::Message << "EGL_BLUE_SIZE = " << pixelFmt.blueBits << TestLog::EndMessage;
    log << TestLog::Message << "EGL_ALPHA_SIZE = " << pixelFmt.alphaBits << TestLog::EndMessage;
    log << TestLog::Message << "EGL_DEPTH_SIZE = " << depthBits << TestLog::EndMessage;
    log << TestLog::Message << "EGL_STENCIL_SIZE = " << stencilBits << TestLog::EndMessage;
    log << TestLog::Message << "EGL_SAMPLES = " << numSamples << TestLog::EndMessage;

    // Initialize semaphores.
    for (vector<SemaphoreSp>::iterator sem = semaphores.begin(); sem != semaphores.end(); ++sem)
        *sem = SemaphoreSp(new de::Semaphore(0));

    // Create draw ops.
    for (vector<DrawPrimitiveOp>::iterator drawOp = drawOps.begin(); drawOp != drawOps.end(); ++drawOp)
    {
        // The randomized draws force us to use the fuzzyCompare algorithm to check for possible rasterization differences between
        // our rasterizer and the one used by the implementation. However, fuzzyCompare only takes a single float as the error
        // threshold. As per the comments in the code, that threshold doesn't have a direct equivalent to a difference in color
        // values. Instead, it's related to an accumulated quadratic error. Also according to these comments, this works well for
        // rgba8 (the only case it was originally designed for), and it can also be made to work for other formats in which all
        // used channels have a roughly similar number of bits.
        //
        // However, in some of these tests we will run this code using formats such as rgb10a2, in which the alpha can only have
        // values of 0, 0.33, 0.66 and 1.0 while other channels have much more precission. Any small difference in the rounding
        // applied by CTS and the implementation could result in wildly different alpha values that make using the single floating
        // point threshold risky, because we can't separate the alpha errors from the rgb errors. If we increase the threshold to
        // a point which is acceptable for alpha errors, the kind of errors we allow in the colors would be huge.
        //
        // For this reason, with 2 bits for alpha we restrict ourselves to alpha values of 1.0 and 0.0, as if alphabits was 1.
        randomizeDrawOp(rnd, *drawOp, (pixelFmt.alphaBits <= 2));
    }

    // Create packets.
    for (int threadNdx = 0; threadNdx < numThreads; threadNdx++)
    {
        packets[threadNdx].resize(packetsPerThread);

        for (int packetNdx = 0; packetNdx < packetsPerThread; packetNdx++)
        {
            DrawOpPacket &packet = packets[threadNdx][packetNdx];

            // Threads take turns with packets.
            packet.wait    = semaphores[packetNdx * numThreads + threadNdx];
            packet.signal  = semaphores[packetNdx * numThreads + threadNdx + 1];
            packet.numOps  = opsPerPacket;
            packet.drawOps = &drawOps[(packetNdx * numThreads + threadNdx) * opsPerPacket];
        }
    }

    // Create and setup programs per context
    for (int ctxNdx = 0; ctxNdx < numContexts; ctxNdx++)
    {
        EGLint api         = contexts[ctxNdx].first;
        EGLContext context = contexts[ctxNdx].second;

        EGLU_CHECK_CALL(egl, makeCurrent(display, surface, surface, context));

        programs[ctxNdx] = ProgramSp(createProgram(m_gl, api));
        programs[ctxNdx]->setup();

        // Release context
        EGLU_CHECK_CALL(egl, makeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
    }

    // Clear to black using first context.
    {
        EGLint api         = contexts[0].first;
        EGLContext context = contexts[0].second;

        EGLU_CHECK_CALL(egl, makeCurrent(display, surface, surface, context));

        clear(m_gl, api, CLEAR_COLOR, CLEAR_DEPTH, CLEAR_STENCIL);
        finish(m_gl, api);

        // Release context
        EGLU_CHECK_CALL(egl, makeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
    }

    // Create and launch threads (actual rendering starts once first semaphore is signaled).
    for (int threadNdx = 0; threadNdx < numThreads; threadNdx++)
    {
        threads[threadNdx] = RenderTestThreadSp(new RenderTestThread(egl, display, surface, contexts[threadNdx].second,
                                                                     contexts[threadNdx].first, m_gl,
                                                                     *programs[threadNdx], packets[threadNdx]));
        threads[threadNdx]->start();
    }

    // Signal start and wait until complete.
    semaphores.front()->increment();
    semaphores.back()->decrement();

    // Read pixels using first context. \todo [pyry] Randomize?
    {
        EGLint api         = contexts[0].first;
        EGLContext context = contexts[0].second;

        EGLU_CHECK_CALL(egl, makeCurrent(display, surface, surface, context));

        readPixels(m_gl, api, frame);
    }

    int subpixelBits = 0;
    m_gl.getIntegerv(GL_SUBPIXEL_BITS, &subpixelBits);

    EGLU_CHECK_CALL(egl, makeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));

    // Join threads.
    for (int threadNdx = 0; threadNdx < numThreads; threadNdx++)
        threads[threadNdx]->join();

    // Render reference.
    renderReference(refFrame.getAccess(), drawOps, pixelFmt, depthBits, stencilBits, 1, subpixelBits);

    // Compare images
    {
        bool imagesOk = tcu::fuzzyCompare(log, "ComparisonResult", "Image comparison result", refFrame, frame,
                                          threshold, tcu::COMPARE_LOG_RESULT);

        if (!imagesOk)
            m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
    }
}

RenderTests::RenderTests(EglTestContext &eglTestCtx)
    : TestCaseGroup(eglTestCtx, "render", "Basic rendering with different client APIs")
{
}

RenderTests::~RenderTests(void)
{
}

struct RenderGroupSpec
{
    const char *name;
    const char *desc;
    EGLint apiBits;
    eglu::ConfigFilter baseFilter;
    int numContextsPerApi;
};

template <uint32_t Bits>
static bool renderable(const eglu::CandidateConfig &c)
{
    return (c.renderableType() & Bits) == Bits;
}

template <class RenderClass>
static void createRenderGroups(EglTestContext &eglTestCtx, tcu::TestCaseGroup *group, const RenderGroupSpec *first,
                               const RenderGroupSpec *last)
{
    for (const RenderGroupSpec *groupIter = first; groupIter != last; groupIter++)
    {
        tcu::TestCaseGroup *configGroup =
            new tcu::TestCaseGroup(eglTestCtx.getTestContext(), groupIter->name, groupIter->desc);
        group->addChild(configGroup);

        vector<RenderFilterList> filterLists;
        eglu::FilterList baseFilters;
        baseFilters << groupIter->baseFilter;
        getDefaultRenderFilterLists(filterLists, baseFilters);

        for (vector<RenderFilterList>::const_iterator listIter = filterLists.begin(); listIter != filterLists.end();
             listIter++)
            configGroup->addChild(new RenderClass(eglTestCtx, listIter->getName(), "", groupIter->apiBits,
                                                  listIter->getSurfaceTypeMask(), *listIter,
                                                  groupIter->numContextsPerApi));
    }
}

void RenderTests::init(void)
{
    static const RenderGroupSpec singleContextCases[] = {
        {"gles2", "Primitive rendering using GLES2", EGL_OPENGL_ES2_BIT, renderable<EGL_OPENGL_ES2_BIT>, 1},
        {"gles3", "Primitive rendering using GLES3", EGL_OPENGL_ES3_BIT, renderable<EGL_OPENGL_ES3_BIT>, 1},
    };

    static const RenderGroupSpec multiContextCases[] = {
        {"gles2", "Primitive rendering using multiple GLES2 contexts to shared surface", EGL_OPENGL_ES2_BIT,
         renderable<EGL_OPENGL_ES2_BIT>, 3},
        {"gles3", "Primitive rendering using multiple GLES3 contexts to shared surface", EGL_OPENGL_ES3_BIT,
         renderable<EGL_OPENGL_ES3_BIT>, 3},
        {"gles2_gles3", "Primitive rendering using multiple APIs to shared surface",
         EGL_OPENGL_ES2_BIT | EGL_OPENGL_ES3_BIT, renderable<EGL_OPENGL_ES2_BIT | EGL_OPENGL_ES3_BIT>, 1},
    };

    tcu::TestCaseGroup *singleContextGroup =
        new tcu::TestCaseGroup(m_testCtx, "single_context", "Single-context rendering");
    addChild(singleContextGroup);
    createRenderGroups<SingleThreadRenderCase>(m_eglTestCtx, singleContextGroup, &singleContextCases[0],
                                               &singleContextCases[DE_LENGTH_OF_ARRAY(singleContextCases)]);

    tcu::TestCaseGroup *multiContextGroup =
        new tcu::TestCaseGroup(m_testCtx, "multi_context", "Multi-context rendering with shared surface");
    addChild(multiContextGroup);
    createRenderGroups<SingleThreadRenderCase>(m_eglTestCtx, multiContextGroup, &multiContextCases[0],
                                               &multiContextCases[DE_LENGTH_OF_ARRAY(multiContextCases)]);

    tcu::TestCaseGroup *multiThreadGroup =
        new tcu::TestCaseGroup(m_testCtx, "multi_thread", "Multi-thread rendering with shared surface");
    addChild(multiThreadGroup);
    createRenderGroups<MultiThreadRenderCase>(m_eglTestCtx, multiThreadGroup, &multiContextCases[0],
                                              &multiContextCases[DE_LENGTH_OF_ARRAY(multiContextCases)]);
}

} // namespace egl
} // namespace deqp