modules/egl/teglImageFormatTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program EGL Module
   3  * ---------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief EGL image tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "teglImageFormatTests.hpp"
  25
  26 #include "deStringUtil.hpp"
  27 #include "deSTLUtil.hpp"
  28
  29 #include "tcuTestLog.hpp"
  30 #include "tcuSurface.hpp"
  31 #include "tcuTexture.hpp"
  32 #include "tcuTextureUtil.hpp"
  33 #include "tcuImageCompare.hpp"
  34 #include "tcuCommandLine.hpp"
  35
  36 #include "egluNativeDisplay.hpp"
  37 #include "egluNativeWindow.hpp"
  38 #include "egluNativePixmap.hpp"
  39 #include "egluConfigFilter.hpp"
  40 #include "egluUnique.hpp"
  41 #include "egluUtil.hpp"
  42
  43 #include "eglwLibrary.hpp"
  44 #include "eglwEnums.hpp"
  45
  46 #include "gluCallLogWrapper.hpp"
  47 #include "gluShaderProgram.hpp"
  48 #include "gluStrUtil.hpp"
  49 #include "gluTexture.hpp"
  50 #include "gluPixelTransfer.hpp"
  51 #include "gluObjectWrapper.hpp"
  52 #include "gluTextureUtil.hpp"
  53
  54 #include "glwEnums.hpp"
  55 #include "glwFunctions.hpp"
  56
  57 #include "teglImageUtil.hpp"
  58 #include "teglAndroidUtil.hpp"
  59
  60 #include <vector>
  61 #include <string>
  62 #include <set>
  63
  64 using std::vector;
  65 using std::set;
  66 using std::string;
  67
  68 using de::MovePtr;
  69 using de::UniquePtr;
  70
  71 using glu::Framebuffer;
  72 using glu::Renderbuffer;
  73 using glu::Texture;
  74
  75 using eglu::UniqueImage;
  76
  77 using tcu::ConstPixelBufferAccess;
  78
  79 using namespace glw;
  80 using namespace eglw;
  81
  82 namespace deqp
  83 {
  84 namespace egl
  85 {
  86
  87 namespace
  88 {
  89
  90 glu::ProgramSources programSources (const string& vertexSource, const string& fragmentSource)
  91 {
  92         glu::ProgramSources sources;
  93
  94         sources << glu::VertexSource(vertexSource) << glu::FragmentSource(fragmentSource);
  95
  96         return sources;
  97 }
  98
  99 class Program : public glu::ShaderProgram
 100 {
 101 public:
 102         Program (const glw::Functions& gl, const char* vertexSource, const char* fragmentSource)
 103                 : glu::ShaderProgram(gl, programSources(vertexSource, fragmentSource)) {}
 104 };
 105
 106 } // anonymous
 107
 108 namespace Image
 109 {
 110
 111 class ImageApi;
 112
 113 class IllegalRendererException : public std::exception
 114 {
 115 };
 116
 117 class Action
 118 {
 119 public:
 120         virtual                 ~Action                                 (void) {}
 121         virtual bool    invoke                                  (ImageApi& api, MovePtr<UniqueImage>& image, tcu::Texture2D& refImg) const = 0;
 122         virtual string  getRequiredExtension    (void) const = 0;
 123 };
 124
 125 struct TestSpec
 126 {
 127         std::string name;
 128         std::string desc;
 129
 130         enum ApiContext
 131         {
 132                 API_GLES2 = 0,
 133                 //API_VG
 134                 //API_GLES1
 135
 136                 API_LAST
 137         };
 138
 139         struct Operation
 140         {
 141                 Operation (int apiIndex_, const Action& action_) : apiIndex(apiIndex_), action(&action_) {}
 142                 int                             apiIndex;
 143                 const Action*   action;
 144         };
 145
 146         vector<ApiContext>      contexts;
 147         vector<Operation>       operations;
 148
 149 };
 150
 151 class ImageApi
 152 {
 153 public:
 154                                         ImageApi                (const Library& egl, int contextId, EGLDisplay display, EGLSurface surface);
 155         virtual                 ~ImageApi               (void) {}
 156
 157 protected:
 158         const Library&  m_egl;
 159         int                             m_contextId;
 160         EGLDisplay              m_display;
 161         EGLSurface              m_surface;
 162 };
 163
 164 ImageApi::ImageApi (const Library& egl, int contextId, EGLDisplay display, EGLSurface surface)
 165         : m_egl                         (egl)
 166         , m_contextId           (contextId)
 167         , m_display                     (display)
 168         , m_surface                     (surface)
 169 {
 170 }
 171
 172 class GLES2ImageApi : public ImageApi, private glu::CallLogWrapper
 173 {
 174 public:
 175         class GLES2Action : public Action
 176         {
 177         public:
 178                 bool                            invoke                                  (ImageApi& api, MovePtr<UniqueImage>& image, tcu::Texture2D& ref) const;
 179                 virtual bool            invokeGLES2                             (GLES2ImageApi& api, MovePtr<UniqueImage>& image, tcu::Texture2D& ref) const = 0;
 180         };
 181
 182         class Create : public GLES2Action
 183         {
 184         public:
 185                                                                 Create                                  (MovePtr<ImageSource> imgSource) : m_imgSource(imgSource) {}
 186                 string                                  getRequiredExtension    (void) const { return m_imgSource->getRequiredExtension(); }
 187                 bool                                    invokeGLES2                             (GLES2ImageApi& api, MovePtr<UniqueImage>& image, tcu::Texture2D& ref) const;
 188                 glw::GLenum                             getEffectiveFormat              (void) const { return m_imgSource->getEffectiveFormat(); }
 189
 190         private:
 191                 UniquePtr<ImageSource>  m_imgSource;
 192         };
 193
 194         class Render : public GLES2Action
 195         {
 196         public:
 197                 string                          getRequiredExtension    (void) const { return "GL_OES_EGL_image"; }
 198         };
 199
 200         class RenderTexture2D                           : public Render { public: bool invokeGLES2 (GLES2ImageApi& api, MovePtr<UniqueImage>& image, tcu::Texture2D& ref) const; };
 201         class RenderTextureCubemap                      : public Render { public: bool invokeGLES2 (GLES2ImageApi& api, MovePtr<UniqueImage>& image, tcu::Texture2D& ref) const; };
 202         class RenderReadPixelsRenderbuffer      : public Render { public: bool invokeGLES2 (GLES2ImageApi& api, MovePtr<UniqueImage>& image, tcu::Texture2D& ref) const; };
 203         class RenderDepthbuffer                         : public Render { public: bool invokeGLES2 (GLES2ImageApi& api, MovePtr<UniqueImage>& image, tcu::Texture2D& ref) const; };
 204         class RenderStencilbuffer                       : public Render { public: bool invokeGLES2 (GLES2ImageApi& api, MovePtr<UniqueImage>& image, tcu::Texture2D& ref) const; };
 205         class RenderTryAll                                      : public Render { public: bool invokeGLES2 (GLES2ImageApi& api, MovePtr<UniqueImage>& image, tcu::Texture2D& ref) const; };
 206
 207         class Modify : public GLES2Action
 208         {
 209         public:
 210                 string                          getRequiredExtension    (void) const { return "GL_OES_EGL_image"; }
 211         };
 212
 213         class ModifyTexSubImage : public Modify
 214         {
 215         public:
 216                                                         ModifyTexSubImage               (GLenum format, GLenum type) : m_format(format), m_type(type) {}
 217                 bool                            invokeGLES2                             (GLES2ImageApi& api, MovePtr<UniqueImage>& image, tcu::Texture2D& ref) const;
 218                 GLenum                          getFormat                               (void) const { return m_format; }
 219                 GLenum                          getType                                 (void) const { return m_type; }
 220
 221         private:
 222                 GLenum                          m_format;
 223                 GLenum                          m_type;
 224         };
 225
 226         class ModifyRenderbuffer : public Modify
 227         {
 228         public:
 229                 bool                            invokeGLES2                             (GLES2ImageApi& api, MovePtr<UniqueImage>& image, tcu::Texture2D& ref) const;
 230
 231         protected:
 232                 virtual void            initializeRbo                   (GLES2ImageApi& api, GLuint rbo, tcu::Texture2D& ref) const = 0;
 233         };
 234
 235         class ModifyRenderbufferClearColor : public ModifyRenderbuffer
 236         {
 237         public:
 238                                         ModifyRenderbufferClearColor    (tcu::Vec4 color) : m_color(color) {}
 239
 240         protected:
 241                 void            initializeRbo                                   (GLES2ImageApi& api, GLuint rbo, tcu::Texture2D& ref) const;
 242
 243                 tcu::Vec4       m_color;
 244         };
 245
 246         class ModifyRenderbufferClearDepth : public ModifyRenderbuffer
 247         {
 248         public:
 249                                         ModifyRenderbufferClearDepth    (GLfloat depth) : m_depth(depth) {}
 250
 251         protected:
 252                 void            initializeRbo                                   (GLES2ImageApi& api, GLuint rbo, tcu::Texture2D& ref) const;
 253
 254                 GLfloat         m_depth;
 255         };
 256
 257         class ModifyRenderbufferClearStencil : public ModifyRenderbuffer
 258         {
 259         public:
 260                                         ModifyRenderbufferClearStencil  (GLint stencil) : m_stencil(stencil) {}
 261
 262         protected:
 263                 void            initializeRbo                                   (GLES2ImageApi& api, GLuint rbo, tcu::Texture2D& ref) const;
 264
 265                 GLint           m_stencil;
 266         };
 267
 268                                         GLES2ImageApi                                   (const Library& egl, const glw::Functions& gl, int contextId, tcu::TestLog& log, EGLDisplay display, EGLSurface surface, EGLConfig config);
 269                                         ~GLES2ImageApi                                  (void);
 270
 271 private:
 272         EGLContext                                      m_context;
 273         const glw::Functions&           m_gl;
 274
 275         MovePtr<UniqueImage>            createImage                     (const ImageSource& source, const ClientBuffer& buffer) const;
 276 };
 277
 278 GLES2ImageApi::GLES2ImageApi (const Library& egl, const glw::Functions& gl, int contextId, tcu::TestLog& log, EGLDisplay display, EGLSurface surface, EGLConfig config)
 279         : ImageApi                              (egl, contextId, display, surface)
 280         , glu::CallLogWrapper   (gl, log)
 281         , m_context                             (DE_NULL)
 282         , m_gl                                  (gl)
 283 {
 284         const EGLint attriblist[] =
 285         {
 286                 EGL_CONTEXT_CLIENT_VERSION, 2,
 287                 EGL_NONE
 288         };
 289
 290         EGLint configId = -1;
 291         EGLU_CHECK_CALL(m_egl, getConfigAttrib(m_display, config, EGL_CONFIG_ID, &configId));
 292         getLog() << tcu::TestLog::Message << "Creating gles2 context with config id: " << configId << " context: " << m_contextId << tcu::TestLog::EndMessage;
 293         egl.bindAPI(EGL_OPENGL_ES_API);
 294         m_context = m_egl.createContext(m_display, config, EGL_NO_CONTEXT, attriblist);
 295         EGLU_CHECK_MSG(m_egl, "Failed to create GLES2 context");
 296
 297         egl.makeCurrent(display, m_surface, m_surface, m_context);
 298         EGLU_CHECK_MSG(m_egl, "Failed to make context current");
 299 }
 300
 301 GLES2ImageApi::~GLES2ImageApi (void)
 302 {
 303         m_egl.makeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
 304         m_egl.destroyContext(m_display, m_context);
 305 }
 306
 307 bool GLES2ImageApi::GLES2Action::invoke (ImageApi& api, MovePtr<UniqueImage>& image, tcu::Texture2D& ref) const
 308 {
 309         GLES2ImageApi& gles2Api = dynamic_cast<GLES2ImageApi&>(api);
 310
 311         gles2Api.m_egl.makeCurrent(gles2Api.m_display, gles2Api.m_surface, gles2Api.m_surface, gles2Api.m_context);
 312         return invokeGLES2(gles2Api, image, ref);
 313 }
 314
 315
 316 bool GLES2ImageApi::Create::invokeGLES2 (GLES2ImageApi& api, MovePtr<UniqueImage>& image, tcu::Texture2D& ref) const
 317 {
 318         de::UniquePtr<ClientBuffer>     buffer  (m_imgSource->createBuffer(api.m_gl, &ref));
 319
 320         GLU_CHECK_GLW_CALL(api.m_gl, finish());
 321
 322         image = api.createImage(*m_imgSource, *buffer);
 323         return true;
 324 }
 325
 326 MovePtr<UniqueImage> GLES2ImageApi::createImage (const ImageSource& source, const ClientBuffer& buffer) const
 327 {
 328         const EGLImageKHR image = source.createImage(m_egl, m_display, m_context, buffer.get());
 329         return MovePtr<UniqueImage>(new UniqueImage(m_egl, m_display, image));
 330 }
 331
 332 static void imageTargetTexture2D (const Library& egl, const glw::Functions& gl, GLeglImageOES img)
 333 {
 334         gl.eglImageTargetTexture2DOES(GL_TEXTURE_2D, img);
 335         {
 336                 const GLenum error = gl.getError();
 337
 338                 if (error == GL_INVALID_OPERATION)
 339                         TCU_THROW(NotSupportedError, "Creating texture2D from EGLImage type not supported");
 340
 341                 GLU_EXPECT_NO_ERROR(error, "glEGLImageTargetTexture2DOES()");
 342                 EGLU_CHECK_MSG(egl, "glEGLImageTargetTexture2DOES()");
 343         }
 344 }
 345
 346 static void imageTargetRenderbuffer (const Library& egl, const glw::Functions& gl, GLeglImageOES img)
 347 {
 348         gl.eglImageTargetRenderbufferStorageOES(GL_RENDERBUFFER, img);
 349         {
 350                 const GLenum error = gl.getError();
 351
 352                 if (error == GL_INVALID_OPERATION)
 353                         TCU_THROW(NotSupportedError, "Creating renderbuffer from EGLImage type not supported");
 354
 355                 GLU_EXPECT_NO_ERROR(error, "glEGLImageTargetRenderbufferStorageOES()");
 356                 EGLU_CHECK_MSG(egl, "glEGLImageTargetRenderbufferStorageOES()");
 357         }
 358 }
 359
 360 static void framebufferRenderbuffer (const glw::Functions& gl, GLenum attachment, GLuint rbo)
 361 {
 362         GLU_CHECK_GLW_CALL(gl, framebufferRenderbuffer(GL_FRAMEBUFFER, attachment, GL_RENDERBUFFER, rbo));
 363         TCU_CHECK_AND_THROW(NotSupportedError,
 364                                                 gl.checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE,
 365                                                 ("EGLImage as " + string(glu::getFramebufferAttachmentName(attachment)) + " not supported").c_str());
 366 }
 367
 368 static const float squareTriangleCoords[] =
 369 {
 370         -1.0, -1.0,
 371         1.0, -1.0,
 372         1.0,  1.0,
 373
 374         1.0,  1.0,
 375         -1.0,  1.0,
 376         -1.0, -1.0
 377 };
 378
 379 bool GLES2ImageApi::RenderTexture2D::invokeGLES2 (GLES2ImageApi& api, MovePtr<UniqueImage>& img, tcu::Texture2D& reference) const
 380 {
 381         const glw::Functions&   gl              = api.m_gl;
 382         tcu::TestLog&                   log             = api.getLog();
 383         Texture                                 srcTex  (gl);
 384
 385         // Branch only taken in TryAll case
 386         if (reference.getFormat().order == tcu::TextureFormat::DS || reference.getFormat().order == tcu::TextureFormat::D)
 387                 throw IllegalRendererException(); // Skip, GLES2 does not support sampling depth textures
 388         if (reference.getFormat().order == tcu::TextureFormat::S)
 389                 throw IllegalRendererException(); // Skip, GLES2 does not support sampling stencil textures
 390
 391         gl.clearColor(0.0, 0.0, 0.0, 0.0);
 392         gl.viewport(0, 0, reference.getWidth(), reference.getHeight());
 393         gl.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
 394         gl.disable(GL_DEPTH_TEST);
 395
 396         log << tcu::TestLog::Message << "Rendering EGLImage as GL_TEXTURE_2D in context: " << api.m_contextId << tcu::TestLog::EndMessage;
 397         TCU_CHECK(**img != EGL_NO_IMAGE_KHR);
 398
 399         GLU_CHECK_GLW_CALL(gl, bindTexture(GL_TEXTURE_2D, *srcTex));
 400         imageTargetTexture2D(api.m_egl, gl, **img);
 401
 402         GLU_CHECK_GLW_CALL(gl, texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST));
 403         GLU_CHECK_GLW_CALL(gl, texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST));
 404         GLU_CHECK_GLW_CALL(gl, texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
 405         GLU_CHECK_GLW_CALL(gl, texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
 406
 407         const char* const vertexShader =
 408                 "attribute highp vec2 a_coord;\n"
 409                 "varying mediump vec2 v_texCoord;\n"
 410                 "void main(void) {\n"
 411                 "\tv_texCoord = vec2((a_coord.x + 1.0) * 0.5, (a_coord.y + 1.0) * 0.5);\n"
 412                 "\tgl_Position = vec4(a_coord, -0.1, 1.0);\n"
 413                 "}\n";
 414
 415         const char* const fragmentShader =
 416                 "varying mediump vec2 v_texCoord;\n"
 417                 "uniform sampler2D u_sampler;\n"
 418                 "void main(void) {\n"
 419                 "\tmediump vec4 texColor = texture2D(u_sampler, v_texCoord);\n"
 420                 "\tgl_FragColor = vec4(texColor);\n"
 421                 "}";
 422
 423         Program program(gl, vertexShader, fragmentShader);
 424         TCU_CHECK(program.isOk());
 425
 426         GLuint glProgram = program.getProgram();
 427         GLU_CHECK_GLW_CALL(gl, useProgram(glProgram));
 428
 429         GLuint coordLoc = gl.getAttribLocation(glProgram, "a_coord");
 430         TCU_CHECK_MSG((int)coordLoc != -1, "Couldn't find attribute a_coord");
 431
 432         GLuint samplerLoc = gl.getUniformLocation(glProgram, "u_sampler");
 433         TCU_CHECK_MSG((int)samplerLoc != (int)-1, "Couldn't find uniform u_sampler");
 434
 435         GLU_CHECK_GLW_CALL(gl, bindTexture(GL_TEXTURE_2D, *srcTex));
 436         GLU_CHECK_GLW_CALL(gl, uniform1i(samplerLoc, 0));
 437         GLU_CHECK_GLW_CALL(gl, enableVertexAttribArray(coordLoc));
 438         GLU_CHECK_GLW_CALL(gl, vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, squareTriangleCoords));
 439
 440         GLU_CHECK_GLW_CALL(gl, drawArrays(GL_TRIANGLES, 0, 6));
 441         GLU_CHECK_GLW_CALL(gl, disableVertexAttribArray(coordLoc));
 442         GLU_CHECK_GLW_CALL(gl, bindTexture(GL_TEXTURE_2D, 0));
 443
 444         tcu::Surface refSurface (reference.getWidth(), reference.getHeight());
 445         tcu::Surface screen             (reference.getWidth(), reference.getHeight());
 446         GLU_CHECK_GLW_CALL(gl, readPixels(0, 0, screen.getWidth(), screen.getHeight(), GL_RGBA, GL_UNSIGNED_BYTE, screen.getAccess().getDataPtr()));
 447
 448         tcu::copy(refSurface.getAccess(), reference.getLevel(0));
 449
 450         float   threshold       = 0.05f;
 451         bool    match           = tcu::fuzzyCompare(log, "ComparisonResult", "Image comparison result", refSurface, screen, threshold, tcu::COMPARE_LOG_RESULT);
 452
 453         return match;
 454 }
 455
 456 bool GLES2ImageApi::RenderDepthbuffer::invokeGLES2 (GLES2ImageApi& api, MovePtr<UniqueImage>& img, tcu::Texture2D& reference) const
 457 {
 458         const glw::Functions&   gl                                      = api.m_gl;
 459         tcu::TestLog&                   log                                     = api.getLog();
 460         Framebuffer                             framebuffer                     (gl);
 461         Renderbuffer                    renderbufferColor       (gl);
 462         Renderbuffer                    renderbufferDepth       (gl);
 463         const tcu::RGBA                 compareThreshold        (32, 32, 32, 32); // layer colors are far apart, large thresholds are ok
 464
 465         // Branch only taken in TryAll case
 466         if (reference.getFormat().order != tcu::TextureFormat::DS && reference.getFormat().order != tcu::TextureFormat::D)
 467                 throw IllegalRendererException(); // Skip, interpreting non-depth data as depth data is not meaningful
 468
 469         log << tcu::TestLog::Message << "Rendering with depth buffer" << tcu::TestLog::EndMessage;
 470
 471         GLU_CHECK_GLW_CALL(gl, bindFramebuffer(GL_FRAMEBUFFER, *framebuffer));
 472
 473         GLU_CHECK_GLW_CALL(gl, bindRenderbuffer(GL_RENDERBUFFER, *renderbufferColor));
 474         GLU_CHECK_GLW_CALL(gl, renderbufferStorage(GL_RENDERBUFFER, GL_RGBA4, reference.getWidth(), reference.getHeight()));
 475         framebufferRenderbuffer(gl, GL_COLOR_ATTACHMENT0, *renderbufferColor);
 476
 477         GLU_CHECK_GLW_CALL(gl, bindRenderbuffer(GL_RENDERBUFFER, *renderbufferDepth));
 478         imageTargetRenderbuffer(api.m_egl, gl, **img);
 479         framebufferRenderbuffer(gl, GL_DEPTH_ATTACHMENT, *renderbufferDepth);
 480         GLU_CHECK_GLW_CALL(gl, bindRenderbuffer(GL_RENDERBUFFER, 0));
 481
 482         GLU_CHECK_GLW_CALL(gl, viewport(0, 0, reference.getWidth(), reference.getHeight()));
 483
 484         // Render
 485         const char* vertexShader =
 486                 "attribute highp vec2 a_coord;\n"
 487                 "uniform highp float u_depth;\n"
 488                 "void main(void) {\n"
 489                 "\tgl_Position = vec4(a_coord, u_depth, 1.0);\n"
 490                 "}\n";
 491
 492         const char* fragmentShader =
 493                 "uniform mediump vec4 u_color;\n"
 494                 "void main(void) {\n"
 495                 "\tgl_FragColor = u_color;\n"
 496                 "}";
 497
 498         Program program(gl, vertexShader, fragmentShader);
 499         TCU_CHECK(program.isOk());
 500
 501         GLuint glProgram = program.getProgram();
 502         GLU_CHECK_GLW_CALL(gl, useProgram(glProgram));
 503
 504         GLuint coordLoc = gl.getAttribLocation(glProgram, "a_coord");
 505         TCU_CHECK_MSG((int)coordLoc != -1, "Couldn't find attribute a_coord");
 506
 507         GLuint colorLoc = gl.getUniformLocation(glProgram, "u_color");
 508         TCU_CHECK_MSG((int)colorLoc != (int)-1, "Couldn't find uniform u_color");
 509
 510         GLuint depthLoc = gl.getUniformLocation(glProgram, "u_depth");
 511         TCU_CHECK_MSG((int)depthLoc != (int)-1, "Couldn't find uniform u_depth");
 512
 513         GLU_CHECK_GLW_CALL(gl, clearColor(0.5f, 1.0f, 0.5f, 1.0f));
 514         GLU_CHECK_GLW_CALL(gl, clear(GL_COLOR_BUFFER_BIT));
 515
 516         tcu::Vec4 depthLevelColors[] = {
 517                 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f),
 518                 tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f),
 519                 tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f),
 520                 tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f),
 521                 tcu::Vec4(1.0f, 0.0f, 1.0f, 1.0f),
 522
 523                 tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f),
 524                 tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f),
 525                 tcu::Vec4(0.5f, 0.0f, 0.0f, 1.0f),
 526                 tcu::Vec4(0.0f, 0.5f, 0.0f, 1.0f),
 527                 tcu::Vec4(0.5f, 0.5f, 0.0f, 1.0f)
 528         };
 529
 530         GLU_CHECK_GLW_CALL(gl, enableVertexAttribArray(coordLoc));
 531         GLU_CHECK_GLW_CALL(gl, vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, squareTriangleCoords));
 532
 533         GLU_CHECK_GLW_CALL(gl, enable(GL_DEPTH_TEST));
 534         GLU_CHECK_GLW_CALL(gl, depthFunc(GL_LESS));
 535         GLU_CHECK_GLW_CALL(gl, depthMask(GL_FALSE));
 536
 537         for (int level = 0; level < DE_LENGTH_OF_ARRAY(depthLevelColors); level++)
 538         {
 539                 const tcu::Vec4 color           = depthLevelColors[level];
 540                 const float             clipDepth       = ((float)(level + 1) * 0.1f) * 2.0f - 1.0f; // depth in clip coords
 541
 542                 GLU_CHECK_GLW_CALL(gl, uniform4f(colorLoc, color.x(), color.y(), color.z(), color.w()));
 543                 GLU_CHECK_GLW_CALL(gl, uniform1f(depthLoc, clipDepth));
 544                 GLU_CHECK_GLW_CALL(gl, drawArrays(GL_TRIANGLES, 0, 6));
 545         }
 546
 547         GLU_CHECK_GLW_CALL(gl, depthMask(GL_TRUE));
 548         GLU_CHECK_GLW_CALL(gl, disable(GL_DEPTH_TEST));
 549         GLU_CHECK_GLW_CALL(gl, disableVertexAttribArray(coordLoc));
 550
 551         const ConstPixelBufferAccess&   refAccess               = reference.getLevel(0);
 552         tcu::Surface                                    screen                  (reference.getWidth(), reference.getHeight());
 553         tcu::Surface                                    referenceScreen (reference.getWidth(), reference.getHeight());
 554
 555         gl.readPixels(0, 0, screen.getWidth(), screen.getHeight(), GL_RGBA, GL_UNSIGNED_BYTE, screen.getAccess().getDataPtr());
 556
 557         for (int y = 0; y < reference.getHeight(); y++)
 558         {
 559                 for (int x = 0; x < reference.getWidth(); x++)
 560                 {
 561                         tcu::Vec4 result = tcu::Vec4(0.5f, 1.0f, 0.5f, 1.0f);
 562
 563                         for (int level = 0; level < DE_LENGTH_OF_ARRAY(depthLevelColors); level++)
 564                         {
 565                                 if ((float)(level + 1) * 0.1f < refAccess.getPixDepth(x, y))
 566                                         result = depthLevelColors[level];
 567                         }
 568
 569                         referenceScreen.getAccess().setPixel(result, x, y);
 570                 }
 571         }
 572
 573         GLU_CHECK_GLW_CALL(gl, bindFramebuffer(GL_FRAMEBUFFER, 0));
 574         GLU_CHECK_GLW_CALL(gl, finish());
 575
 576         return tcu::pixelThresholdCompare(log, "Depth buffer rendering result", "Result from rendering with depth buffer", referenceScreen, screen, compareThreshold, tcu::COMPARE_LOG_RESULT);
 577 }
 578
 579 bool GLES2ImageApi::RenderStencilbuffer::invokeGLES2 (GLES2ImageApi& api, MovePtr<UniqueImage>& img, tcu::Texture2D& reference) const
 580 {
 581         // Branch only taken in TryAll case
 582         if (reference.getFormat().order != tcu::TextureFormat::DS && reference.getFormat().order != tcu::TextureFormat::S)
 583                 throw IllegalRendererException(); // Skip, interpreting non-stencil data as stencil data is not meaningful
 584
 585         const glw::Functions&   gl                                      = api.m_gl;
 586         tcu::TestLog&                   log                                     = api.getLog();
 587         Framebuffer                             framebuffer                     (gl);
 588         Renderbuffer                    renderbufferColor       (gl);
 589         Renderbuffer                    renderbufferStencil (gl);
 590         const tcu::RGBA                 compareThreshold        (32, 32, 32, 32); // layer colors are far apart, large thresholds are ok
 591         const deUint32                  numStencilBits          = tcu::getTextureFormatBitDepth(tcu::getEffectiveDepthStencilTextureFormat(reference.getLevel(0).getFormat(), tcu::Sampler::MODE_STENCIL)).x();
 592         const deUint32                  maxStencil                      = deBitMask32(0, numStencilBits);
 593
 594         log << tcu::TestLog::Message << "Rendering with stencil buffer" << tcu::TestLog::EndMessage;
 595
 596         GLU_CHECK_GLW_CALL(gl, bindFramebuffer(GL_FRAMEBUFFER, *framebuffer));
 597
 598         GLU_CHECK_GLW_CALL(gl, bindRenderbuffer(GL_RENDERBUFFER, *renderbufferColor));
 599         GLU_CHECK_GLW_CALL(gl, renderbufferStorage(GL_RENDERBUFFER, GL_RGBA4, reference.getWidth(), reference.getHeight()));
 600         framebufferRenderbuffer(gl, GL_COLOR_ATTACHMENT0, *renderbufferColor);
 601
 602         GLU_CHECK_GLW_CALL(gl, bindRenderbuffer(GL_RENDERBUFFER, *renderbufferStencil));
 603         imageTargetRenderbuffer(api.m_egl, gl, **img);
 604         framebufferRenderbuffer(gl, GL_STENCIL_ATTACHMENT, *renderbufferStencil);
 605         GLU_CHECK_GLW_CALL(gl, bindRenderbuffer(GL_RENDERBUFFER, 0));
 606
 607         GLU_CHECK_GLW_CALL(gl, viewport(0, 0, reference.getWidth(), reference.getHeight()));
 608
 609         // Render
 610         const char* vertexShader =
 611                 "attribute highp vec2 a_coord;\n"
 612                 "void main(void) {\n"
 613                 "\tgl_Position = vec4(a_coord, 0.0, 1.0);\n"
 614                 "}\n";
 615
 616         const char* fragmentShader =
 617                 "uniform mediump vec4 u_color;\n"
 618                 "void main(void) {\n"
 619                 "\tgl_FragColor = u_color;\n"
 620                 "}";
 621
 622         Program program(gl, vertexShader, fragmentShader);
 623         TCU_CHECK(program.isOk());
 624
 625         GLuint glProgram = program.getProgram();
 626         GLU_CHECK_GLW_CALL(gl, useProgram(glProgram));
 627
 628         GLuint coordLoc = gl.getAttribLocation(glProgram, "a_coord");
 629         TCU_CHECK_MSG((int)coordLoc != -1, "Couldn't find attribute a_coord");
 630
 631         GLuint colorLoc = gl.getUniformLocation(glProgram, "u_color");
 632         TCU_CHECK_MSG((int)colorLoc != (int)-1, "Couldn't find uniform u_color");
 633
 634         GLU_CHECK_GLW_CALL(gl, clearColor(0.5f, 1.0f, 0.5f, 1.0f));
 635         GLU_CHECK_GLW_CALL(gl, clear(GL_COLOR_BUFFER_BIT));
 636
 637         tcu::Vec4 stencilLevelColors[] = {
 638                 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f),
 639                 tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f),
 640                 tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f),
 641                 tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f),
 642                 tcu::Vec4(1.0f, 0.0f, 1.0f, 1.0f),
 643
 644                 tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f),
 645                 tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f),
 646                 tcu::Vec4(0.5f, 0.0f, 0.0f, 1.0f),
 647                 tcu::Vec4(0.0f, 0.5f, 0.0f, 1.0f),
 648                 tcu::Vec4(0.5f, 0.5f, 0.0f, 1.0f)
 649         };
 650
 651         GLU_CHECK_GLW_CALL(gl, enableVertexAttribArray(coordLoc));
 652         GLU_CHECK_GLW_CALL(gl, vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, squareTriangleCoords));
 653
 654         GLU_CHECK_GLW_CALL(gl, enable(GL_STENCIL_TEST));
 655         GLU_CHECK_GLW_CALL(gl, stencilOp(GL_KEEP, GL_KEEP, GL_KEEP));
 656
 657         for (int level = 0; level < DE_LENGTH_OF_ARRAY(stencilLevelColors); level++)
 658         {
 659                 const tcu::Vec4 color   = stencilLevelColors[level];
 660                 const int               stencil = (int)(((float)(level + 1) * 0.1f) * (float)maxStencil);
 661
 662                 GLU_CHECK_GLW_CALL(gl, stencilFunc(GL_LESS, stencil, 0xFFFFFFFFu));
 663                 GLU_CHECK_GLW_CALL(gl, uniform4f(colorLoc, color.x(), color.y(), color.z(), color.w()));
 664                 GLU_CHECK_GLW_CALL(gl, drawArrays(GL_TRIANGLES, 0, 6));
 665         }
 666
 667         GLU_CHECK_GLW_CALL(gl, disable(GL_STENCIL_TEST));
 668         GLU_CHECK_GLW_CALL(gl, disableVertexAttribArray(coordLoc));
 669
 670         const ConstPixelBufferAccess&   refAccess               = reference.getLevel(0);
 671         tcu::Surface                                    screen                  (reference.getWidth(), reference.getHeight());
 672         tcu::Surface                                    referenceScreen (reference.getWidth(), reference.getHeight());
 673
 674         gl.readPixels(0, 0, screen.getWidth(), screen.getHeight(), GL_RGBA, GL_UNSIGNED_BYTE, screen.getAccess().getDataPtr());
 675
 676         for (int y = 0; y < reference.getHeight(); y++)
 677         for (int x = 0; x < reference.getWidth(); x++)
 678         {
 679                 tcu::Vec4 result = tcu::Vec4(0.5f, 1.0f, 0.5f, 1.0f);
 680
 681                 for (int level = 0; level < DE_LENGTH_OF_ARRAY(stencilLevelColors); level++)
 682                 {
 683                         const int levelStencil = (int)(((float)(level + 1) * 0.1f) * (float)maxStencil);
 684                         if (levelStencil < refAccess.getPixStencil(x, y))
 685                                 result = stencilLevelColors[level];
 686                 }
 687
 688                 referenceScreen.getAccess().setPixel(result, x, y);
 689         }
 690
 691         GLU_CHECK_GLW_CALL(gl, bindFramebuffer(GL_FRAMEBUFFER, 0));
 692         GLU_CHECK_GLW_CALL(gl, finish());
 693
 694         return tcu::pixelThresholdCompare(log, "StencilResult", "Result from rendering with stencil buffer", referenceScreen, screen, compareThreshold, tcu::COMPARE_LOG_RESULT);
 695 }
 696
 697 bool GLES2ImageApi::RenderReadPixelsRenderbuffer::invokeGLES2 (GLES2ImageApi& api, MovePtr<UniqueImage>& img, tcu::Texture2D& reference) const
 698 {
 699         const glw::Functions&   gl                              = api.m_gl;
 700         const tcu::IVec4                bitDepth                = tcu::getTextureFormatMantissaBitDepth(reference.getFormat());
 701         const tcu::IVec4                threshold               (2 * (tcu::IVec4(1) << (tcu::IVec4(8) - bitDepth)));
 702         const tcu::RGBA                 threshold8              ((deUint8)(de::clamp(threshold[0], 0, 255)), (deUint8)(de::clamp(threshold[1], 0, 255)), (deUint8)(de::clamp(threshold[2], 0, 255)), (deUint8)(de::clamp(threshold[3], 0, 255)));
 703         tcu::TestLog&                   log                             = api.getLog();
 704         Framebuffer                             framebuffer             (gl);
 705         Renderbuffer                    renderbuffer    (gl);
 706         tcu::Surface                    screen                  (reference.getWidth(), reference.getHeight());
 707         tcu::Surface                    refSurface              (reference.getWidth(), reference.getHeight());
 708
 709         // Branch only taken in TryAll case
 710         if (reference.getFormat().order == tcu::TextureFormat::DS || reference.getFormat().order == tcu::TextureFormat::D)
 711                 throw IllegalRendererException(); // Skip, GLES2 does not support ReadPixels for depth attachments
 712         if (reference.getFormat().order == tcu::TextureFormat::S)
 713                 throw IllegalRendererException(); // Skip, GLES2 does not support ReadPixels for stencil attachments
 714
 715         log << tcu::TestLog::Message << "Reading with ReadPixels from renderbuffer" << tcu::TestLog::EndMessage;
 716
 717         GLU_CHECK_GLW_CALL(gl, bindFramebuffer(GL_FRAMEBUFFER, *framebuffer));
 718         GLU_CHECK_GLW_CALL(gl, bindRenderbuffer(GL_RENDERBUFFER, *renderbuffer));
 719         imageTargetRenderbuffer(api.m_egl, gl, **img);
 720         framebufferRenderbuffer(gl, GL_COLOR_ATTACHMENT0, *renderbuffer);
 721
 722         GLU_CHECK_GLW_CALL(gl, viewport(0, 0, reference.getWidth(), reference.getHeight()));
 723
 724         gl.readPixels(0, 0, screen.getWidth(), screen.getHeight(), GL_RGBA, GL_UNSIGNED_BYTE, screen.getAccess().getDataPtr());
 725
 726         GLU_CHECK_GLW_CALL(gl, bindFramebuffer(GL_FRAMEBUFFER, 0));
 727         GLU_CHECK_GLW_CALL(gl, bindRenderbuffer(GL_RENDERBUFFER, 0));
 728         GLU_CHECK_GLW_CALL(gl, finish());
 729
 730         tcu::copy(refSurface.getAccess(), reference.getLevel(0));
 731
 732         return tcu::pixelThresholdCompare(log, "Renderbuffer read", "Result from reading renderbuffer", refSurface, screen, threshold8, tcu::COMPARE_LOG_RESULT);
 733
 734 }
 735
 736 bool GLES2ImageApi::RenderTryAll::invokeGLES2 (GLES2ImageApi& api, MovePtr<UniqueImage>& img, tcu::Texture2D& reference) const
 737 {
 738         bool                                                                            foundSupported                  = false;
 739         tcu::TestLog&                                                           log                                             = api.getLog();
 740         GLES2ImageApi::RenderTexture2D                          renderTex2D;
 741         GLES2ImageApi::RenderReadPixelsRenderbuffer     renderReadPixels;
 742         GLES2ImageApi::RenderDepthbuffer                        renderDepth;
 743         GLES2ImageApi::RenderStencilbuffer                      renderStencil;
 744         Action*                                                                         actions[]                               = { &renderTex2D, &renderReadPixels, &renderDepth, &renderStencil };
 745
 746         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(actions); ++ndx)
 747         {
 748                 try
 749                 {
 750                         if (!actions[ndx]->invoke(api, img, reference))
 751                                 return false;
 752
 753                         foundSupported = true;
 754                 }
 755                 catch (const tcu::NotSupportedError& error)
 756                 {
 757                         log << tcu::TestLog::Message << error.what() << tcu::TestLog::EndMessage;
 758                 }
 759                 catch (const IllegalRendererException&)
 760                 {
 761                         // not valid renderer
 762                 }
 763         }
 764
 765         if (!foundSupported)
 766                 throw tcu::NotSupportedError("Rendering not supported", "", __FILE__, __LINE__);
 767
 768         return true;
 769 }
 770
 771 bool GLES2ImageApi::ModifyTexSubImage::invokeGLES2 (GLES2ImageApi& api, MovePtr<UniqueImage>& img, tcu::Texture2D& reference) const
 772 {
 773         const glw::Functions&   gl              = api.m_gl;
 774         tcu::TestLog&                   log             = api.getLog();
 775         glu::Texture                    srcTex  (gl);
 776         const int                               xOffset = 8;
 777         const int                               yOffset = 16;
 778         const int                               xSize   = de::clamp(16, 0, reference.getWidth() - xOffset);
 779         const int                               ySize   = de::clamp(16, 0, reference.getHeight() - yOffset);
 780         tcu::Texture2D                  src             (glu::mapGLTransferFormat(m_format, m_type), xSize, ySize);
 781
 782         log << tcu::TestLog::Message << "Modifying EGLImage with gl.texSubImage2D" << tcu::TestLog::EndMessage;
 783
 784         src.allocLevel(0);
 785         tcu::fillWithComponentGradients(src.getLevel(0), tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f));
 786
 787         GLU_CHECK_GLW_CALL(gl, bindTexture(GL_TEXTURE_2D, *srcTex));
 788         imageTargetTexture2D(api.m_egl, gl, **img);
 789         GLU_CHECK_GLW_CALL(gl, texSubImage2D(GL_TEXTURE_2D, 0, xOffset, yOffset, src.getWidth(), src.getHeight(), m_format, m_type, src.getLevel(0).getDataPtr()));
 790         GLU_CHECK_GLW_CALL(gl, bindTexture(GL_TEXTURE_2D, 0));
 791         GLU_CHECK_GLW_CALL(gl, finish());
 792
 793         tcu::copy(tcu::getSubregion(reference.getLevel(0), xOffset, yOffset, 0, xSize, ySize, 1), src.getLevel(0));
 794
 795         return true;
 796 }
 797
 798 bool GLES2ImageApi::ModifyRenderbuffer::invokeGLES2 (GLES2ImageApi& api, MovePtr<UniqueImage>& img, tcu::Texture2D& reference) const
 799 {
 800         const glw::Functions&   gl                              = api.m_gl;
 801         tcu::TestLog&                   log                             = api.getLog();
 802         glu::Framebuffer                framebuffer             (gl);
 803         glu::Renderbuffer               renderbuffer    (gl);
 804
 805         log << tcu::TestLog::Message << "Modifying EGLImage with glClear to renderbuffer" << tcu::TestLog::EndMessage;
 806
 807         GLU_CHECK_GLW_CALL(gl, bindFramebuffer(GL_FRAMEBUFFER, *framebuffer));
 808         GLU_CHECK_GLW_CALL(gl, bindRenderbuffer(GL_RENDERBUFFER, *renderbuffer));
 809
 810         imageTargetRenderbuffer(api.m_egl, gl, **img);
 811
 812         initializeRbo(api, *renderbuffer, reference);
 813
 814         GLU_CHECK_GLW_CALL(gl, bindFramebuffer(GL_FRAMEBUFFER, 0));
 815         GLU_CHECK_GLW_CALL(gl, bindRenderbuffer(GL_RENDERBUFFER, 0));
 816
 817         GLU_CHECK_GLW_CALL(gl, finish());
 818
 819         return true;
 820 }
 821
 822 void GLES2ImageApi::ModifyRenderbufferClearColor::initializeRbo (GLES2ImageApi& api, GLuint renderbuffer, tcu::Texture2D& reference) const
 823 {
 824         const glw::Functions&   gl              = api.m_gl;
 825
 826         framebufferRenderbuffer(gl, GL_COLOR_ATTACHMENT0, renderbuffer);
 827
 828         GLU_CHECK_GLW_CALL(gl, viewport(0, 0, reference.getWidth(), reference.getHeight()));
 829         GLU_CHECK_GLW_CALL(gl, clearColor(m_color.x(), m_color.y(), m_color.z(), m_color.w()));
 830         GLU_CHECK_GLW_CALL(gl, clear(GL_COLOR_BUFFER_BIT));
 831
 832         tcu::clear(reference.getLevel(0), m_color);
 833 }
 834
 835 void GLES2ImageApi::ModifyRenderbufferClearDepth::initializeRbo (GLES2ImageApi& api, GLuint renderbuffer, tcu::Texture2D& reference) const
 836 {
 837         const glw::Functions&   gl              = api.m_gl;
 838
 839         framebufferRenderbuffer(gl, GL_DEPTH_ATTACHMENT, renderbuffer);
 840
 841         GLU_CHECK_GLW_CALL(gl, viewport(0, 0, reference.getWidth(), reference.getHeight()));
 842         GLU_CHECK_GLW_CALL(gl, clearDepthf(m_depth));
 843         GLU_CHECK_GLW_CALL(gl, clear(GL_DEPTH_BUFFER_BIT));
 844
 845         tcu::clearDepth(reference.getLevel(0), m_depth);
 846 }
 847
 848 void GLES2ImageApi::ModifyRenderbufferClearStencil::initializeRbo (GLES2ImageApi& api, GLuint renderbuffer, tcu::Texture2D& reference) const
 849 {
 850         const glw::Functions&   gl              = api.m_gl;
 851
 852         framebufferRenderbuffer(gl, GL_STENCIL_ATTACHMENT, renderbuffer);
 853
 854         GLU_CHECK_GLW_CALL(gl, viewport(0, 0, reference.getWidth(), reference.getHeight()));
 855         GLU_CHECK_GLW_CALL(gl, clearStencil(m_stencil));
 856         GLU_CHECK_GLW_CALL(gl, clear(GL_STENCIL_BUFFER_BIT));
 857
 858         tcu::clearStencil(reference.getLevel(0), m_stencil);
 859 }
 860
 861 class ImageFormatCase : public TestCase, private glu::CallLogWrapper
 862 {
 863 public:
 864                                                 ImageFormatCase         (EglTestContext& eglTestCtx, const TestSpec& spec);
 865                                                 ~ImageFormatCase        (void);
 866
 867         void                            init                            (void);
 868         void                            deinit                          (void);
 869         IterateResult           iterate                         (void);
 870         void                            checkExtensions         (void);
 871
 872 private:
 873         EGLConfig                       getConfig                       (void);
 874
 875         const TestSpec          m_spec;
 876
 877         vector<ImageApi*>       m_apiContexts;
 878
 879         EGLDisplay                      m_display;
 880         eglu::NativeWindow*     m_window;
 881         EGLSurface                      m_surface;
 882         EGLConfig                       m_config;
 883         int                                     m_curIter;
 884         MovePtr<UniqueImage>m_img;
 885         tcu::Texture2D          m_refImg;
 886         glw::Functions          m_gl;
 887 };
 888
 889 EGLConfig ImageFormatCase::getConfig (void)
 890 {
 891         const EGLint attribList[] =
 892         {
 893                 EGL_RENDERABLE_TYPE,    EGL_OPENGL_ES2_BIT,
 894                 EGL_SURFACE_TYPE,               EGL_WINDOW_BIT,
 895                 EGL_RED_SIZE,                   8,
 896                 EGL_BLUE_SIZE,                  8,
 897                 EGL_GREEN_SIZE,                 8,
 898                 EGL_ALPHA_SIZE,                 8,
 899                 EGL_DEPTH_SIZE,                 8,
 900                 EGL_NONE
 901         };
 902
 903         return eglu::chooseSingleConfig(m_eglTestCtx.getLibrary(), m_display, attribList);
 904 }
 905
 906 ImageFormatCase::ImageFormatCase (EglTestContext& eglTestCtx, const TestSpec& spec)
 907         : TestCase                              (eglTestCtx, spec.name.c_str(), spec.desc.c_str())
 908         , glu::CallLogWrapper   (m_gl, eglTestCtx.getTestContext().getLog())
 909         , m_spec                                (spec)
 910         , m_display                             (EGL_NO_DISPLAY)
 911         , m_window                              (DE_NULL)
 912         , m_surface                             (EGL_NO_SURFACE)
 913         , m_config                              (0)
 914         , m_curIter                             (0)
 915         , m_refImg                              (tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), 1, 1)
 916 {
 917 }
 918
 919 ImageFormatCase::~ImageFormatCase (void)
 920 {
 921         deinit();
 922 }
 923
 924 void ImageFormatCase::checkExtensions (void)
 925 {
 926         const Library&                  egl             = m_eglTestCtx.getLibrary();
 927         const EGLDisplay                dpy             = m_display;
 928         set<string>                             exts;
 929         const vector<string>    glExts  = de::splitString((const char*) m_gl.getString(GL_EXTENSIONS));
 930         const vector<string>    eglExts = eglu::getDisplayExtensions(egl, dpy);
 931
 932         exts.insert(glExts.begin(), glExts.end());
 933         exts.insert(eglExts.begin(), eglExts.end());
 934
 935         if (eglu::getVersion(egl, dpy) >= eglu::Version(1, 5))
 936         {
 937                 // EGL 1.5 has built-in support for EGLImage and GL sources
 938                 exts.insert("EGL_KHR_image_base");
 939                 exts.insert("EGL_KHR_gl_texture_2D_image");
 940                 exts.insert("EGL_KHR_gl_texture_cubemap_image");
 941                 exts.insert("EGL_KHR_gl_renderbuffer_image");
 942         }
 943
 944         if (!de::contains(exts, "EGL_KHR_image_base") && !de::contains(exts, "EGL_KHR_image"))
 945         {
 946                 getLog() << tcu::TestLog::Message
 947                                  << "EGL version is under 1.5 and neither EGL_KHR_image nor EGL_KHR_image_base is supported."
 948                                  << "One should be supported."
 949                                  << tcu::TestLog::EndMessage;
 950                 TCU_THROW(NotSupportedError, "Extension not supported: EGL_KHR_image_base");
 951         }
 952
 953         for (int operationNdx = 0; operationNdx < (int)m_spec.operations.size(); operationNdx++)
 954         {
 955                 const TestSpec::Operation&      op      = m_spec.operations[operationNdx];
 956                 const string                            ext     = op.action->getRequiredExtension();
 957
 958                 if (!de::contains(exts, ext))
 959                         TCU_THROW_EXPR(NotSupportedError, "Extension not supported", ext.c_str());
 960         }
 961 }
 962
 963 void ImageFormatCase::init (void)
 964 {
 965         const Library&                                          egl                             = m_eglTestCtx.getLibrary();
 966         const eglu::NativeWindowFactory&        windowFactory   = eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine());
 967
 968         try
 969         {
 970                 m_display       = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
 971                 m_config        = getConfig();
 972                 m_window        = windowFactory.createWindow(&m_eglTestCtx.getNativeDisplay(), m_display, m_config, DE_NULL, eglu::WindowParams(480, 480, eglu::parseWindowVisibility(m_testCtx.getCommandLine())));
 973                 m_surface       = eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *m_window, m_display, m_config, DE_NULL);
 974
 975                 {
 976                         const char* extensions[] = { "GL_OES_EGL_image" };
 977                         m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2, 0), DE_LENGTH_OF_ARRAY(extensions), &extensions[0]);
 978                 }
 979
 980                 for (int contextNdx = 0; contextNdx < (int)m_spec.contexts.size(); contextNdx++)
 981                 {
 982                         ImageApi* api = DE_NULL;
 983                         switch (m_spec.contexts[contextNdx])
 984                         {
 985                                 case TestSpec::API_GLES2:
 986                                 {
 987                                         api = new GLES2ImageApi(egl, m_gl, contextNdx, getLog(), m_display, m_surface, m_config);
 988                                         break;
 989                                 }
 990
 991                                 default:
 992                                         DE_ASSERT(false);
 993                                         break;
 994                         }
 995                         m_apiContexts.push_back(api);
 996                 }
 997                 checkExtensions();
 998         }
 999         catch (...)
1000         {
1001                 deinit();
1002                 throw;
1003         }
1004 }
1005
1006 void ImageFormatCase::deinit (void)
1007 {
1008         const Library& egl = m_eglTestCtx.getLibrary();
1009
1010         for (int contexNdx = 0 ; contexNdx < (int)m_apiContexts.size(); contexNdx++)
1011                 delete m_apiContexts[contexNdx];
1012
1013         m_apiContexts.clear();
1014
1015         if (m_surface != EGL_NO_SURFACE)
1016         {
1017                 egl.destroySurface(m_display, m_surface);
1018                 m_surface = EGL_NO_SURFACE;
1019         }
1020
1021         delete m_window;
1022         m_window = DE_NULL;
1023
1024         if (m_display != EGL_NO_DISPLAY)
1025         {
1026                 egl.terminate(m_display);
1027                 m_display = EGL_NO_DISPLAY;
1028         }
1029 }
1030
1031 TestCase::IterateResult ImageFormatCase::iterate (void)
1032 {
1033         const TestSpec::Operation&      op              = m_spec.operations[m_curIter++];
1034         ImageApi&                                       api             = *m_apiContexts[op.apiIndex];
1035         const bool                                      isOk    = op.action->invoke(api, m_img, m_refImg);
1036
1037         if (isOk && m_curIter < (int)m_spec.operations.size())
1038                 return CONTINUE;
1039         else if (isOk)
1040                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1041         else
1042                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1043
1044         return STOP;
1045 }
1046
1047 struct LabeledAction
1048 {
1049         string                  label;
1050         MovePtr<Action> action;
1051 };
1052
1053 // A simple vector mockup that we need because MovePtr isn't copy-constructible.
1054 struct LabeledActions
1055 {
1056                                         LabeledActions  (void) : m_numActions(0){}
1057         LabeledAction&  operator[]              (int ndx)                               { DE_ASSERT(0 <= ndx && ndx < m_numActions); return m_actions[ndx]; }
1058         void                    add                             (const string& label, MovePtr<Action> action);
1059         int                             size                    (void) const                    { return m_numActions; }
1060 private:
1061         LabeledAction   m_actions[32];
1062         int                             m_numActions;
1063 };
1064
1065 void LabeledActions::add (const string& label, MovePtr<Action> action)
1066 {
1067         DE_ASSERT(m_numActions < DE_LENGTH_OF_ARRAY(m_actions));
1068         m_actions[m_numActions].label = label;
1069         m_actions[m_numActions].action = action;
1070         ++m_numActions;
1071 }
1072
1073 class ImageTests : public TestCaseGroup
1074 {
1075 protected:
1076                                         ImageTests                                              (EglTestContext& eglTestCtx, const string& name, const string& desc)
1077                                                 : TestCaseGroup(eglTestCtx, name.c_str(), desc.c_str()) {}
1078
1079         void                    addCreateTexture                                (const string& name, EGLenum source, GLenum internalFormat, GLenum format, GLenum type);
1080         void                    addCreateRenderbuffer                   (const string& name, GLenum format);
1081         void                    addCreateAndroidNative                  (const string& name, GLenum format);
1082         void                    addCreateTexture2DActions               (const string& prefix);
1083         void                    addCreateTextureCubemapActions  (const string& suffix, GLenum internalFormat, GLenum format, GLenum type);
1084         void                    addCreateRenderbufferActions    (void);
1085         void                    addCreateAndroidNativeActions   (void);
1086
1087         LabeledActions  m_createActions;
1088 };
1089
1090 void ImageTests::addCreateTexture (const string& name, EGLenum source, GLenum internalFormat, GLenum format, GLenum type)
1091 {
1092         m_createActions.add(name, MovePtr<Action>(new GLES2ImageApi::Create(createTextureImageSource(source, internalFormat, format, type))));
1093 }
1094
1095 void ImageTests::addCreateRenderbuffer (const string& name, GLenum format)
1096 {
1097         m_createActions.add(name, MovePtr<Action>(new GLES2ImageApi::Create(createRenderbufferImageSource(format))));
1098 }
1099
1100 void ImageTests::addCreateAndroidNative (const string& name, GLenum format)
1101 {
1102         m_createActions.add(name, MovePtr<Action>(new GLES2ImageApi::Create(createAndroidNativeImageSource(format))));
1103 }
1104
1105 void ImageTests::addCreateTexture2DActions (const string& prefix)
1106 {
1107         addCreateTexture(prefix + "rgb8",               EGL_GL_TEXTURE_2D_KHR,  GL_RGB,         GL_RGB,         GL_UNSIGNED_BYTE);
1108         addCreateTexture(prefix + "rgb565",             EGL_GL_TEXTURE_2D_KHR,  GL_RGB,         GL_RGB,         GL_UNSIGNED_SHORT_5_6_5);
1109         addCreateTexture(prefix + "rgba8",              EGL_GL_TEXTURE_2D_KHR,  GL_RGBA,        GL_RGBA,        GL_UNSIGNED_BYTE);
1110         addCreateTexture(prefix + "rgb5_a1",    EGL_GL_TEXTURE_2D_KHR,  GL_RGBA,        GL_RGBA,        GL_UNSIGNED_SHORT_5_5_5_1);
1111         addCreateTexture(prefix + "rgba4",              EGL_GL_TEXTURE_2D_KHR,  GL_RGBA,        GL_RGBA,        GL_UNSIGNED_SHORT_4_4_4_4);
1112 }
1113
1114 void ImageTests::addCreateTextureCubemapActions (const string& suffix, GLenum internalFormat, GLenum format, GLenum type)
1115 {
1116         addCreateTexture("cubemap_positive_x" + suffix, EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR, internalFormat, format, type);
1117         addCreateTexture("cubemap_positive_y" + suffix, EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR, internalFormat, format, type);
1118         addCreateTexture("cubemap_positive_z" + suffix, EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR, internalFormat, format, type);
1119         addCreateTexture("cubemap_negative_x" + suffix, EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR, internalFormat, format, type);
1120         addCreateTexture("cubemap_negative_y" + suffix, EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR, internalFormat, format, type);
1121         addCreateTexture("cubemap_negative_z" + suffix, EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR, internalFormat, format, type);
1122 }
1123
1124 void ImageTests::addCreateRenderbufferActions (void)
1125 {
1126         addCreateRenderbuffer("renderbuffer_rgba4",             GL_RGBA4);
1127         addCreateRenderbuffer("renderbuffer_rgb5_a1",   GL_RGB5_A1);
1128         addCreateRenderbuffer("renderbuffer_rgb565",    GL_RGB565);
1129         addCreateRenderbuffer("renderbuffer_depth16",   GL_DEPTH_COMPONENT16);
1130         addCreateRenderbuffer("renderbuffer_stencil",   GL_STENCIL_INDEX8);
1131 }
1132
1133 void ImageTests::addCreateAndroidNativeActions (void)
1134 {
1135         addCreateAndroidNative("android_native_rgb565",         GL_RGB565);
1136         addCreateAndroidNative("android_native_rgb8",           GL_RGB8);
1137         addCreateAndroidNative("android_native_rgba4",          GL_RGBA4);
1138         addCreateAndroidNative("android_native_rgb5_a1",        GL_RGB5_A1);
1139         addCreateAndroidNative("android_native_rgba8",          GL_RGBA8);
1140 }
1141
1142 class RenderTests : public ImageTests
1143 {
1144 protected:
1145                                                                                         RenderTests                             (EglTestContext& eglTestCtx, const string& name, const string& desc)
1146                                                                                                 : ImageTests                    (eglTestCtx, name, desc) {}
1147
1148         void                                                                    addRenderActions                (void);
1149         LabeledActions                                                  m_renderActions;
1150 };
1151
1152 void RenderTests::addRenderActions (void)
1153 {
1154         m_renderActions.add("texture",                  MovePtr<Action>(new GLES2ImageApi::RenderTexture2D()));
1155         m_renderActions.add("read_pixels",              MovePtr<Action>(new GLES2ImageApi::RenderReadPixelsRenderbuffer()));
1156         m_renderActions.add("depth_buffer",             MovePtr<Action>(new GLES2ImageApi::RenderDepthbuffer()));
1157         m_renderActions.add("stencil_buffer",   MovePtr<Action>(new GLES2ImageApi::RenderStencilbuffer()));
1158 }
1159
1160 class SimpleCreationTests : public RenderTests
1161 {
1162 public:
1163                         SimpleCreationTests             (EglTestContext& eglTestCtx, const string& name, const string& desc) : RenderTests(eglTestCtx, name, desc) {}
1164         void    init                                    (void);
1165 };
1166
1167 bool isDepthFormat (GLenum format)
1168 {
1169         switch (format)
1170         {
1171                 case GL_RGB:
1172                 case GL_RGB8:
1173                 case GL_RGB565:
1174                 case GL_RGBA:
1175                 case GL_RGBA4:
1176                 case GL_RGBA8:
1177                 case GL_RGB5_A1:
1178                         return false;
1179
1180                 case GL_DEPTH_COMPONENT16:
1181                         return true;
1182
1183                 case GL_STENCIL_INDEX8:
1184                         return false;
1185
1186                 default:
1187                         DE_ASSERT(false);
1188                         return false;
1189         }
1190 }
1191
1192 bool isStencilFormat (GLenum format)
1193 {
1194         switch (format)
1195         {
1196                 case GL_RGB:
1197                 case GL_RGB8:
1198                 case GL_RGB565:
1199                 case GL_RGBA:
1200                 case GL_RGBA4:
1201                 case GL_RGBA8:
1202                 case GL_RGB5_A1:
1203                         return false;
1204
1205                 case GL_DEPTH_COMPONENT16:
1206                         return false;
1207
1208                 case GL_STENCIL_INDEX8:
1209                         return true;
1210
1211                 default:
1212                         DE_ASSERT(false);
1213                         return false;
1214         }
1215 }
1216
1217 bool isCompatibleCreateAndRenderActions (const Action& create, const Action& render)
1218 {
1219         if (const GLES2ImageApi::Create* gles2Create = dynamic_cast<const GLES2ImageApi::Create*>(&create))
1220         {
1221                 const GLenum createFormat = gles2Create->getEffectiveFormat();
1222
1223                 if (dynamic_cast<const GLES2ImageApi::RenderTexture2D*>(&render))
1224                 {
1225                         // GLES2 does not have depth or stencil textures
1226                         if (isDepthFormat(createFormat) || isStencilFormat(createFormat))
1227                                 return false;
1228                 }
1229
1230                 if (dynamic_cast<const GLES2ImageApi::RenderReadPixelsRenderbuffer*>(&render))
1231                 {
1232                         // GLES2 does not support readPixels for depth or stencil
1233                         if (isDepthFormat(createFormat) || isStencilFormat(createFormat))
1234                                 return false;
1235                 }
1236
1237                 if (dynamic_cast<const GLES2ImageApi::RenderDepthbuffer*>(&render))
1238                 {
1239                         // Copying non-depth data to depth renderbuffer and expecting meaningful
1240                         // results just doesn't make any sense.
1241                         if (!isDepthFormat(createFormat))
1242                                 return false;
1243                 }
1244
1245                 if (dynamic_cast<const GLES2ImageApi::RenderStencilbuffer*>(&render))
1246                 {
1247                         // Copying non-stencil data to stencil renderbuffer and expecting meaningful
1248                         // results just doesn't make any sense.
1249                         if (!isStencilFormat(createFormat))
1250                                 return false;
1251                 }
1252
1253                 return true;
1254         }
1255         else
1256                 DE_ASSERT(false);
1257
1258         return false;
1259 }
1260
1261 void SimpleCreationTests::init (void)
1262 {
1263         addCreateTexture2DActions("texture_");
1264         addCreateTextureCubemapActions("_rgba", GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE);
1265         addCreateTextureCubemapActions("_rgb", GL_RGB, GL_RGB, GL_UNSIGNED_BYTE);
1266         addCreateRenderbufferActions();
1267         addCreateAndroidNativeActions();
1268         addRenderActions();
1269
1270         for (int createNdx = 0; createNdx < m_createActions.size(); createNdx++)
1271         {
1272                 const LabeledAction& createAction = m_createActions[createNdx];
1273
1274                 for (int renderNdx = 0; renderNdx < m_renderActions.size(); renderNdx++)
1275                 {
1276                         const LabeledAction&    renderAction    = m_renderActions[renderNdx];
1277                         TestSpec                                spec;
1278
1279                         if (!isCompatibleCreateAndRenderActions(*createAction.action, *renderAction.action))
1280                                 continue;
1281
1282                         spec.name = std::string("gles2_") + createAction.label + "_" + renderAction.label;
1283                         spec.desc = spec.name;
1284                         spec.contexts.push_back(TestSpec::API_GLES2);
1285                         spec.operations.push_back(TestSpec::Operation(0, *createAction.action));
1286                         spec.operations.push_back(TestSpec::Operation(0, *renderAction.action));
1287
1288                         addChild(new ImageFormatCase(m_eglTestCtx, spec));
1289                 }
1290         }
1291 }
1292
1293 TestCaseGroup* createSimpleCreationTests (EglTestContext& eglTestCtx, const string& name, const string& desc)
1294 {
1295         return new SimpleCreationTests(eglTestCtx, name, desc);
1296 }
1297
1298 bool isCompatibleFormats (GLenum createFormat, GLenum modifyFormat, GLenum modifyType)
1299 {
1300         switch (modifyFormat)
1301         {
1302                 case GL_RGB:
1303                         switch (modifyType)
1304                         {
1305                                 case GL_UNSIGNED_BYTE:
1306                                         return createFormat == GL_RGB
1307                                                         || createFormat == GL_RGB8
1308                                                         || createFormat == GL_RGB565
1309                                                         || createFormat == GL_SRGB8;
1310
1311                                 case GL_BYTE:
1312                                         return createFormat == GL_RGB8_SNORM;
1313
1314                                 case GL_UNSIGNED_SHORT_5_6_5:
1315                                         return createFormat == GL_RGB
1316                                                         || createFormat == GL_RGB565;
1317
1318                                 case GL_UNSIGNED_INT_10F_11F_11F_REV:
1319                                         return createFormat == GL_R11F_G11F_B10F;
1320
1321                                 case GL_UNSIGNED_INT_5_9_9_9_REV:
1322                                         return createFormat == GL_RGB9_E5;
1323
1324                                 case GL_HALF_FLOAT:
1325                                         return createFormat == GL_RGB16F
1326                                                         || createFormat == GL_R11F_G11F_B10F
1327                                                         || createFormat == GL_RGB9_E5;
1328
1329                                 case GL_FLOAT:
1330                                         return createFormat == GL_RGB16F
1331                                                         || createFormat == GL_RGB32F
1332                                                         || createFormat == GL_R11F_G11F_B10F
1333                                                         || createFormat == GL_RGB9_E5;
1334
1335                                 default:
1336                                         DE_FATAL("Unknown modify type");
1337                                         return false;
1338                         }
1339
1340                 case GL_RGBA:
1341                         switch (modifyType)
1342                         {
1343                                 case GL_UNSIGNED_BYTE:
1344                                         return createFormat == GL_RGBA8
1345                                                 || createFormat == GL_RGB5_A1
1346                                                 || createFormat == GL_RGBA4
1347                                                 || createFormat == GL_SRGB8_ALPHA8
1348                                                 || createFormat == GL_RGBA;
1349
1350                                 case GL_UNSIGNED_SHORT_4_4_4_4:
1351                                         return createFormat == GL_RGBA4
1352                                                 || createFormat == GL_RGBA;
1353
1354                                 case GL_UNSIGNED_SHORT_5_5_5_1:
1355                                         return createFormat == GL_RGB5_A1
1356                                                 || createFormat == GL_RGBA;
1357
1358                                 case GL_UNSIGNED_INT_2_10_10_10_REV:
1359                                         return createFormat == GL_RGB10_A2
1360                                                 || createFormat == GL_RGB5_A1;
1361
1362                                 case GL_HALF_FLOAT:
1363                                         return createFormat == GL_RGBA16F;
1364
1365                                 case GL_FLOAT:
1366                                         return createFormat == GL_RGBA16F
1367                                                 || createFormat == GL_RGBA32F;
1368
1369                                 default:
1370                                         DE_FATAL("Unknown modify type");
1371                                         return false;
1372                         };
1373
1374                 default:
1375                         DE_FATAL("Unknown modify format");
1376                         return false;
1377         }
1378 }
1379
1380 bool isCompatibleCreateAndModifyActions (const Action& create, const Action& modify)
1381 {
1382         if (const GLES2ImageApi::Create* gles2Create = dynamic_cast<const GLES2ImageApi::Create*>(&create))
1383         {
1384                 const GLenum createFormat = gles2Create->getEffectiveFormat();
1385
1386                 if (const GLES2ImageApi::ModifyTexSubImage* gles2TexSubImageModify = dynamic_cast<const GLES2ImageApi::ModifyTexSubImage*>(&modify))
1387                 {
1388                         const GLenum modifyFormat       = gles2TexSubImageModify->getFormat();
1389                         const GLenum modifyType         = gles2TexSubImageModify->getType();
1390
1391                         return isCompatibleFormats(createFormat, modifyFormat, modifyType);
1392                 }
1393
1394                 if (dynamic_cast<const GLES2ImageApi::ModifyRenderbufferClearColor*>(&modify))
1395                 {
1396                         // reintepreting color as non-color is not meaningful
1397                         if (isDepthFormat(createFormat) || isStencilFormat(createFormat))
1398                                 return false;
1399                 }
1400
1401                 if (dynamic_cast<const GLES2ImageApi::ModifyRenderbufferClearDepth*>(&modify))
1402                 {
1403                         // reintepreting depth as non-depth is not meaningful
1404                         if (!isDepthFormat(createFormat))
1405                                 return false;
1406                 }
1407
1408                 if (dynamic_cast<const GLES2ImageApi::ModifyRenderbufferClearStencil*>(&modify))
1409                 {
1410                         // reintepreting stencil as non-stencil is not meaningful
1411                         if (!isStencilFormat(createFormat))
1412                                 return false;
1413                 }
1414
1415                 return true;
1416         }
1417         else
1418                 DE_ASSERT(false);
1419
1420         return false;
1421 }
1422
1423 class MultiContextRenderTests : public RenderTests
1424 {
1425 public:
1426                                         MultiContextRenderTests         (EglTestContext& eglTestCtx, const string& name, const string& desc);
1427         void                    init                                            (void);
1428         void                    addClearActions                         (void);
1429 private:
1430         LabeledActions  m_clearActions;
1431 };
1432
1433 MultiContextRenderTests::MultiContextRenderTests (EglTestContext& eglTestCtx, const string& name, const string& desc)
1434         : RenderTests   (eglTestCtx, name, desc)
1435 {
1436 }
1437
1438 void MultiContextRenderTests::addClearActions (void)
1439 {
1440         m_clearActions.add("renderbuffer_clear_color",          MovePtr<Action>(new GLES2ImageApi::ModifyRenderbufferClearColor(tcu::Vec4(0.8f, 0.2f, 0.9f, 1.0f))));
1441         m_clearActions.add("renderbuffer_clear_depth",          MovePtr<Action>(new GLES2ImageApi::ModifyRenderbufferClearDepth(0.75f)));
1442         m_clearActions.add("renderbuffer_clear_stencil",        MovePtr<Action>(new GLES2ImageApi::ModifyRenderbufferClearStencil(97)));
1443 }
1444
1445 void MultiContextRenderTests::init (void)
1446 {
1447         addCreateTexture2DActions("texture_");
1448         addCreateTextureCubemapActions("_rgba8", GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE);
1449         addCreateTextureCubemapActions("_rgb8", GL_RGB, GL_RGB, GL_UNSIGNED_BYTE);
1450         addCreateRenderbufferActions();
1451         addCreateAndroidNativeActions();
1452         addRenderActions();
1453         addClearActions();
1454
1455         for (int createNdx = 0; createNdx < m_createActions.size(); createNdx++)
1456         for (int renderNdx = 0; renderNdx < m_renderActions.size(); renderNdx++)
1457         for (int clearNdx = 0; clearNdx < m_clearActions.size(); clearNdx++)
1458         {
1459                 const LabeledAction&    createAction    = m_createActions[createNdx];
1460                 const LabeledAction&    renderAction    = m_renderActions[renderNdx];
1461                 const LabeledAction&    clearAction             = m_clearActions[clearNdx];
1462                 TestSpec                                spec;
1463
1464                 if (!isCompatibleCreateAndRenderActions(*createAction.action, *renderAction.action))
1465                         continue;
1466                 if (!isCompatibleCreateAndModifyActions(*createAction.action, *clearAction.action))
1467                         continue;
1468
1469                 spec.name = std::string("gles2_") + createAction.label + "_" + renderAction.label;
1470                 spec.desc = spec.name;
1471
1472                 spec.contexts.push_back(TestSpec::API_GLES2);
1473                 spec.contexts.push_back(TestSpec::API_GLES2);
1474
1475                 spec.operations.push_back(TestSpec::Operation(0, *createAction.action));
1476                 spec.operations.push_back(TestSpec::Operation(0, *renderAction.action));
1477                 spec.operations.push_back(TestSpec::Operation(0, *clearAction.action));
1478                 spec.operations.push_back(TestSpec::Operation(1, *createAction.action));
1479                 spec.operations.push_back(TestSpec::Operation(0, *renderAction.action));
1480                 spec.operations.push_back(TestSpec::Operation(1, *renderAction.action));
1481
1482                 addChild(new ImageFormatCase(m_eglTestCtx, spec));
1483         }
1484 }
1485
1486 TestCaseGroup* createMultiContextRenderTests (EglTestContext& eglTestCtx, const string& name, const string& desc)
1487 {
1488         return new MultiContextRenderTests(eglTestCtx, name, desc);
1489 }
1490
1491 class ModifyTests : public ImageTests
1492 {
1493 public:
1494                                                                 ModifyTests             (EglTestContext& eglTestCtx, const string& name, const string& desc)
1495                                                                         : ImageTests(eglTestCtx, name, desc) {}
1496
1497         void                                            init                    (void);
1498
1499 protected:
1500         void                                            addModifyActions(void);
1501
1502         LabeledActions                          m_modifyActions;
1503         GLES2ImageApi::RenderTryAll     m_renderAction;
1504 };
1505
1506 void ModifyTests::addModifyActions (void)
1507 {
1508         m_modifyActions.add("tex_subimage_rgb8",                        MovePtr<Action>(new GLES2ImageApi::ModifyTexSubImage(GL_RGB,    GL_UNSIGNED_BYTE)));
1509         m_modifyActions.add("tex_subimage_rgb565",                      MovePtr<Action>(new GLES2ImageApi::ModifyTexSubImage(GL_RGB,    GL_UNSIGNED_SHORT_5_6_5)));
1510         m_modifyActions.add("tex_subimage_rgba8",                       MovePtr<Action>(new GLES2ImageApi::ModifyTexSubImage(GL_RGBA,   GL_UNSIGNED_BYTE)));
1511         m_modifyActions.add("tex_subimage_rgb5_a1",                     MovePtr<Action>(new GLES2ImageApi::ModifyTexSubImage(GL_RGBA,   GL_UNSIGNED_SHORT_5_5_5_1)));
1512         m_modifyActions.add("tex_subimage_rgba4",                       MovePtr<Action>(new GLES2ImageApi::ModifyTexSubImage(GL_RGBA,   GL_UNSIGNED_SHORT_4_4_4_4)));
1513
1514         m_modifyActions.add("renderbuffer_clear_color",         MovePtr<Action>(new GLES2ImageApi::ModifyRenderbufferClearColor(tcu::Vec4(0.3f, 0.5f, 0.3f, 1.0f))));
1515         m_modifyActions.add("renderbuffer_clear_depth",         MovePtr<Action>(new GLES2ImageApi::ModifyRenderbufferClearDepth(0.7f)));
1516         m_modifyActions.add("renderbuffer_clear_stencil",       MovePtr<Action>(new GLES2ImageApi::ModifyRenderbufferClearStencil(78)));
1517 }
1518
1519 void ModifyTests::init (void)
1520 {
1521         addCreateTexture2DActions("tex_");
1522         addCreateRenderbufferActions();
1523         addCreateAndroidNativeActions();
1524         addModifyActions();
1525
1526         for (int createNdx = 0; createNdx < m_createActions.size(); createNdx++)
1527         {
1528                 LabeledAction& createAction = m_createActions[createNdx];
1529
1530                 for (int modifyNdx = 0; modifyNdx < m_modifyActions.size(); modifyNdx++)
1531                 {
1532                         LabeledAction& modifyAction = m_modifyActions[modifyNdx];
1533
1534                         if (!isCompatibleCreateAndModifyActions(*createAction.action, *modifyAction.action))
1535                                 continue;
1536
1537                         TestSpec spec;
1538                         spec.name = createAction.label + "_" + modifyAction.label;
1539                         spec.desc = "gles2_tex_sub_image";
1540
1541                         spec.contexts.push_back(TestSpec::API_GLES2);
1542
1543                         spec.operations.push_back(TestSpec::Operation(0, *createAction.action));
1544                         spec.operations.push_back(TestSpec::Operation(0, m_renderAction));
1545                         spec.operations.push_back(TestSpec::Operation(0, *modifyAction.action));
1546                         spec.operations.push_back(TestSpec::Operation(0, m_renderAction));
1547
1548                         addChild(new ImageFormatCase(m_eglTestCtx, spec));
1549                 }
1550         }
1551 }
1552
1553 TestCaseGroup* createModifyTests (EglTestContext& eglTestCtx, const string& name, const string& desc)
1554 {
1555         return new ModifyTests(eglTestCtx, name, desc);
1556 }
1557
1558 } // Image
1559 } // egl
1560 } // deqp