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