modules/egl/teglImageTests.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 "teglImageTests.hpp"
  25
  26 #include "teglImageUtil.hpp"
  27 #include "teglAndroidUtil.hpp"
  28 #include "teglImageFormatTests.hpp"
  29
  30 #include "egluNativeDisplay.hpp"
  31 #include "egluNativeWindow.hpp"
  32 #include "egluNativePixmap.hpp"
  33 #include "egluStrUtil.hpp"
  34 #include "egluUnique.hpp"
  35 #include "egluUtil.hpp"
  36 #include "egluGLUtil.hpp"
  37
  38 #include "eglwLibrary.hpp"
  39 #include "eglwEnums.hpp"
  40
  41 #include "gluDefs.hpp"
  42 #include "gluCallLogWrapper.hpp"
  43 #include "gluObjectWrapper.hpp"
  44 #include "gluStrUtil.hpp"
  45
  46 #include "glwDefs.hpp"
  47 #include "glwEnums.hpp"
  48
  49 #include "tcuTestLog.hpp"
  50 #include "tcuCommandLine.hpp"
  51
  52 #include "deUniquePtr.hpp"
  53
  54 #include <algorithm>
  55 #include <sstream>
  56 #include <string>
  57 #include <vector>
  58 #include <set>
  59
  60 using tcu::TestLog;
  61
  62 using std::string;
  63 using std::vector;
  64 using std::set;
  65 using std::ostringstream;
  66
  67 using de::MovePtr;
  68 using de::UniquePtr;
  69 using glu::ApiType;
  70 using glu::ContextType;
  71 using glu::Texture;
  72 using eglu::AttribMap;
  73 using eglu::NativeWindow;
  74 using eglu::NativePixmap;
  75 using eglu::UniqueImage;
  76 using eglu::UniqueSurface;
  77 using eglu::ScopedCurrentContext;
  78
  79 using namespace glw;
  80 using namespace eglw;
  81
  82 namespace deqp
  83 {
  84 namespace egl
  85 {
  86
  87 namespace Image
  88 {
  89
  90 #define CHECK_EXTENSION(DPY, EXTNAME) \
  91         TCU_CHECK_AND_THROW(NotSupportedError, eglu::hasExtension(m_eglTestCtx.getLibrary(), DPY, EXTNAME), (string("Unsupported extension: ") + (EXTNAME)).c_str())
  92
  93 template <typename RetVal>
  94 RetVal checkCallError (EglTestContext& eglTestCtx, const char* call, RetVal returnValue, EGLint expectError)
  95 {
  96         tcu::TestContext&       testCtx         = eglTestCtx.getTestContext();
  97         TestLog&                        log                     = testCtx.getLog();
  98         EGLint                          error;
  99
 100         log << TestLog::Message << call << TestLog::EndMessage;
 101
 102         error = eglTestCtx.getLibrary().getError();
 103
 104         if (error != expectError)
 105         {
 106                 log << TestLog::Message << "  Fail: Error code mismatch! Expected " << eglu::getErrorStr(expectError) << ", got " << eglu::getErrorStr(error) << TestLog::EndMessage;
 107                 log << TestLog::Message << "  " << returnValue << " was returned" << TestLog::EndMessage;
 108
 109                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 110                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid error code");
 111         }
 112
 113         return returnValue;
 114 }
 115
 116 template <typename RetVal>
 117 void checkCallReturn (EglTestContext& eglTestCtx, const char* call, RetVal returnValue, RetVal expectReturnValue, EGLint expectError)
 118 {
 119         tcu::TestContext&       testCtx         = eglTestCtx.getTestContext();
 120         TestLog&                        log                     = testCtx.getLog();
 121         EGLint                          error;
 122
 123         log << TestLog::Message << call << TestLog::EndMessage;
 124
 125         error = eglTestCtx.getLibrary().getError();
 126
 127         if (returnValue != expectReturnValue)
 128         {
 129                 log << TestLog::Message << "  Fail: Return value mismatch! Expected " << expectReturnValue << ", got " << returnValue << TestLog::EndMessage;
 130
 131                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 132                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid return value");
 133         }
 134
 135         if (error != expectError)
 136         {
 137                 log << TestLog::Message << "  Fail: Error code mismatch! Expected " << eglu::getErrorStr(expectError) << ", got " << eglu::getErrorStr(error) << TestLog::EndMessage;
 138
 139                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 140                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid error code");
 141         }
 142 }
 143
 144 // \note These macros expect "EglTestContext m_eglTestCtx" to be defined.
 145 #define CHECK_EXT_CALL_RET(CALL, EXPECT_RETURN_VALUE, EXPECT_ERROR)     checkCallReturn(m_eglTestCtx, #CALL, CALL, (EXPECT_RETURN_VALUE), (EXPECT_ERROR))
 146 #define CHECK_EXT_CALL_ERR(CALL, EXPECT_ERROR)                                          checkCallError(m_eglTestCtx, #CALL, CALL, (EXPECT_ERROR))
 147
 148 class ImageTestCase : public TestCase, public glu::CallLogWrapper
 149 {
 150 public:
 151                                 ImageTestCase           (EglTestContext& eglTestCtx, ApiType api, const string& name, const string& desc)
 152                                         : TestCase                              (eglTestCtx, name.c_str(), desc.c_str())
 153                                         , glu::CallLogWrapper   (m_gl, m_testCtx.getLog())
 154                                         , m_api                                 (api)
 155                                         , m_display                             (EGL_NO_DISPLAY)
 156         {
 157         }
 158
 159         void            init                            (void)
 160         {
 161                 DE_ASSERT(m_display == EGL_NO_DISPLAY);
 162                 m_display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
 163
 164                 const char* extensions[] = { "GL_OES_EGL_image" };
 165                 m_eglTestCtx.initGLFunctions(&m_gl, m_api, DE_LENGTH_OF_ARRAY(extensions), &extensions[0]);
 166         }
 167
 168         void            deinit                          (void)
 169         {
 170                 m_eglTestCtx.getLibrary().terminate(m_display);
 171                 m_display = EGL_NO_DISPLAY;
 172         }
 173
 174         bool            isGLRedSupported        (void)
 175         {
 176                 return m_api.getMajorVersion() >= 3 || glu::hasExtension(m_gl, m_api, "GL_EXT_texture_rg");
 177         }
 178
 179 protected:
 180         glw::Functions  m_gl;
 181         ApiType                 m_api;
 182         EGLDisplay              m_display;
 183 };
 184
 185 class InvalidCreateImage : public ImageTestCase
 186 {
 187 public:
 188         InvalidCreateImage (EglTestContext& eglTestCtx)
 189                 : ImageTestCase(eglTestCtx, ApiType::es(2, 0), "invalid_create_image", "eglCreateImageKHR() with invalid arguments")
 190         {
 191         }
 192
 193         void checkCreate (const char* desc, EGLDisplay dpy, const char* dpyStr, EGLContext context, const char* ctxStr, EGLenum source, const char* srcStr, EGLint expectError);
 194
 195         IterateResult iterate (void)
 196         {
 197 #define CHECK_CREATE(MSG, DPY, CONTEXT, SOURCE, ERR) checkCreate(MSG, DPY, #DPY, CONTEXT, #CONTEXT, SOURCE, #SOURCE, ERR)
 198                 CHECK_CREATE("Testing bad display (-1)...", (EGLDisplay)-1, EGL_NO_CONTEXT, EGL_NONE, EGL_BAD_DISPLAY);
 199                 CHECK_CREATE("Testing bad context (-1)...", m_display, (EGLContext)-1, EGL_NONE, EGL_BAD_CONTEXT);
 200                 CHECK_CREATE("Testing bad source (-1)...", m_display, EGL_NO_CONTEXT, (EGLenum)-1, EGL_BAD_PARAMETER);
 201 #undef CHECK_CREATE
 202
 203                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 204                 return STOP;
 205         }
 206
 207 };
 208
 209 void InvalidCreateImage::checkCreate (const char* msg, EGLDisplay dpy, const char* dpyStr, EGLContext context, const char* ctxStr, EGLenum source, const char* srcStr, EGLint expectError)
 210 {
 211         m_testCtx.getLog() << TestLog::Message << msg << TestLog::EndMessage;
 212         {
 213                 const Library&          egl             = m_eglTestCtx.getLibrary();
 214                 const EGLImageKHR       image   = egl.createImageKHR(dpy, context, source, 0, DE_NULL);
 215                 ostringstream           call;
 216
 217                 call << "eglCreateImage(" << dpyStr << ", " << ctxStr << ", " << srcStr << ", 0, DE_NULL)";
 218                 checkCallReturn(m_eglTestCtx, call.str().c_str(), image, EGL_NO_IMAGE_KHR, expectError);
 219         }
 220 }
 221
 222 EGLConfig chooseConfig (const Library& egl, EGLDisplay display, ApiType apiType)
 223 {
 224         AttribMap                               attribs;
 225         vector<EGLConfig>               configs;
 226         // Prefer configs in order: pbuffer, window, pixmap
 227         static const EGLenum    s_surfaceTypes[] = { EGL_PBUFFER_BIT, EGL_WINDOW_BIT, EGL_PIXMAP_BIT };
 228
 229         attribs[EGL_RENDERABLE_TYPE] = eglu::apiRenderableType(apiType);
 230
 231         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_surfaceTypes); ++ndx)
 232         {
 233                 attribs[EGL_SURFACE_TYPE] = s_surfaceTypes[ndx];
 234                 configs = eglu::chooseConfigs(egl, display, attribs);
 235
 236                 if (!configs.empty())
 237                         return configs.front();
 238         }
 239
 240         TCU_THROW(NotSupportedError, "No compatible EGL configs found");
 241         return (EGLConfig)0;
 242 }
 243
 244 class Context
 245 {
 246 public:
 247                                                                 Context                 (EglTestContext& eglTestCtx, EGLDisplay display, ContextType ctxType, int width, int height)
 248                                                                         : m_eglTestCtx  (eglTestCtx)
 249                                                                         , m_display             (display)
 250                                                                         , m_config              (chooseConfig(eglTestCtx.getLibrary(), display, ctxType.getAPI()))
 251                                                                         , m_context             (m_eglTestCtx.getLibrary(), m_display, eglu::createGLContext(eglTestCtx.getLibrary(), m_display, m_config, ctxType))
 252                                                                         , m_surface             (createSurface(eglTestCtx, m_display, m_config, width, height))
 253                                                                         , m_current             (eglTestCtx.getLibrary(), m_display, m_surface->get(), m_surface->get(), *m_context)
 254         {
 255                 m_eglTestCtx.initGLFunctions(&m_gl, ctxType.getAPI());
 256         }
 257
 258         EGLConfig                                       getConfig               (void) const { return m_config; }
 259         EGLDisplay                                      getEglDisplay   (void) const { return m_display; }
 260         EGLContext                                      getEglContext   (void) const { return *m_context; }
 261         const glw::Functions&           gl                              (void) const { return m_gl; }
 262
 263 private:
 264         EglTestContext&                         m_eglTestCtx;
 265         EGLDisplay                                      m_display;
 266         EGLConfig                                       m_config;
 267         eglu::UniqueContext                     m_context;
 268         UniquePtr<ManagedSurface>       m_surface;
 269         ScopedCurrentContext            m_current;
 270         glw::Functions                          m_gl;
 271
 272                                                                 Context                 (const Context&);
 273         Context&                                        operator=               (const Context&);
 274 };
 275
 276 class CreateImageGLES2 : public ImageTestCase
 277 {
 278 public:
 279         static const char* getTargetName (EGLint target)
 280         {
 281                 switch (target)
 282                 {
 283                         case EGL_GL_TEXTURE_2D_KHR:                                             return "tex2d";
 284                         case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR:    return "cubemap_pos_x";
 285                         case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR:    return "cubemap_neg_x";
 286                         case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR:    return "cubemap_pos_y";
 287                         case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR:    return "cubemap_neg_y";
 288                         case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR:    return "cubemap_pos_z";
 289                         case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR:    return "cubemap_neg_z";
 290                         case EGL_GL_RENDERBUFFER_KHR:                                   return "renderbuffer";
 291                         case EGL_NATIVE_BUFFER_ANDROID:                                 return "android_native";
 292                         default:                DE_ASSERT(DE_FALSE);                    return "";
 293                 }
 294         }
 295
 296         static const char* getStorageName (GLenum storage)
 297         {
 298                 switch (storage)
 299                 {
 300                         case GL_RED:                            return "red";
 301                         case GL_RG:                                     return "rg";
 302                         case GL_LUMINANCE:                      return "luminance";
 303                         case GL_LUMINANCE_ALPHA:        return "luminance_alpha";
 304                         case GL_RGB:                            return "rgb";
 305                         case GL_RGBA:                           return "rgba";
 306                         case GL_DEPTH_COMPONENT16:      return "depth_component_16";
 307                         case GL_RGBA4:                          return "rgba4";
 308                         case GL_RGB5_A1:                        return "rgb5_a1";
 309                         case GL_RGB565:                         return "rgb565";
 310                         case GL_RGB8:                           return "rgb8";
 311                         case GL_RGBA8:                          return "rgba8";
 312                         case GL_STENCIL_INDEX8:         return "stencil_index8";
 313                         default:
 314                                 DE_ASSERT(DE_FALSE);
 315                                 return "";
 316                 }
 317         }
 318
 319         MovePtr<ImageSource> getImageSource (EGLint target, GLenum internalFormat, GLenum format, GLenum type, bool useTexLevel0)
 320         {
 321                 switch (target)
 322                 {
 323                         case EGL_GL_TEXTURE_2D_KHR:
 324                         case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR:
 325                         case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR:
 326                         case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR:
 327                         case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR:
 328                         case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR:
 329                         case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR:
 330                                 DE_ASSERT(format != 0u && type != 0u);
 331                                 return createTextureImageSource(target, internalFormat, format, type, useTexLevel0);
 332
 333                         case EGL_GL_RENDERBUFFER_KHR:
 334                                 DE_ASSERT(format == 0u && type == 0u);
 335                                 return createRenderbufferImageSource(internalFormat);
 336
 337                         case EGL_NATIVE_BUFFER_ANDROID:
 338                                 DE_ASSERT(format == 0u && type == 0u);
 339                                 return createAndroidNativeImageSource(internalFormat);
 340
 341                         default:
 342                                 DE_FATAL("Impossible");
 343                                 return MovePtr<ImageSource>();
 344                 }
 345         }
 346
 347         CreateImageGLES2 (EglTestContext& eglTestCtx, EGLint target, GLenum internalFormat, GLenum format, GLenum type, bool useTexLevel0 = false)
 348                 : ImageTestCase         (eglTestCtx, ApiType::es(2, 0), string("create_image_gles2_") + getTargetName(target) + "_" + getStorageName(internalFormat) + (useTexLevel0 ? "_level0_only" : ""), "Create EGLImage from GLES2 object")
 349                 , m_source                      (getImageSource(target, internalFormat, format, type, useTexLevel0))
 350                 , m_internalFormat      (internalFormat)
 351         {
 352         }
 353
 354         IterateResult iterate (void)
 355         {
 356                 const Library&                  egl                             = m_eglTestCtx.getLibrary();
 357                 const EGLDisplay                dpy                             = m_display;
 358
 359                 if (eglu::getVersion(egl, dpy) < eglu::Version(1, 5))
 360                         CHECK_EXTENSION(dpy, m_source->getRequiredExtension());
 361
 362                 // Initialize result.
 363                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 364
 365                 // Create GLES2 context
 366                 TestLog&                                log                             = m_testCtx.getLog();
 367                 const ContextType               contextType             (ApiType::es(2, 0));
 368                 Context                                 context                 (m_eglTestCtx, dpy, contextType, 64, 64);
 369                 const EGLContext                eglContext              = context.getEglContext();
 370
 371                 if ((m_internalFormat == GL_RED || m_internalFormat == GL_RG) && !isGLRedSupported())
 372                         TCU_THROW(NotSupportedError, "Unsupported extension: GL_EXT_texture_rg");
 373
 374                 log << TestLog::Message << "Using EGL config " << eglu::getConfigID(egl, dpy, context.getConfig()) << TestLog::EndMessage;
 375
 376                 UniquePtr<ClientBuffer> clientBuffer    (m_source->createBuffer(context.gl()));
 377                 const EGLImageKHR               image                   = m_source->createImage(egl, dpy, eglContext, clientBuffer->get());
 378
 379                 if (image == EGL_NO_IMAGE_KHR)
 380                 {
 381                         log << TestLog::Message << "  Fail: Got EGL_NO_IMAGE_KHR!" << TestLog::EndMessage;
 382
 383                         if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 384                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got EGL_NO_IMAGE_KHR");
 385                 }
 386
 387                 // Destroy image
 388                 CHECK_EXT_CALL_RET(egl.destroyImageKHR(context.getEglDisplay(), image), (EGLBoolean)EGL_TRUE, EGL_SUCCESS);
 389
 390                 return STOP;
 391         }
 392
 393 private:
 394         const UniquePtr<ImageSource>    m_source;
 395         const GLenum                                    m_internalFormat;
 396 };
 397
 398 class ImageTargetGLES2 : public ImageTestCase
 399 {
 400 public:
 401         static const char* getTargetName (GLenum target)
 402         {
 403                 switch (target)
 404                 {
 405                         case GL_TEXTURE_2D:             return "tex2d";
 406                         case GL_RENDERBUFFER:   return "renderbuffer";
 407                         default:
 408                                 DE_ASSERT(DE_FALSE);
 409                                 return "";
 410                 }
 411         }
 412
 413         ImageTargetGLES2 (EglTestContext& eglTestCtx, GLenum target)
 414                 : ImageTestCase (eglTestCtx, ApiType::es(2, 0), string("image_target_gles2_") + getTargetName(target), "Use EGLImage as GLES2 object")
 415                 , m_target              (target)
 416         {
 417         }
 418
 419         IterateResult iterate (void)
 420         {
 421                 const Library&  egl     = m_eglTestCtx.getLibrary();
 422                 TestLog&                log     = m_testCtx.getLog();
 423
 424                 // \todo [2011-07-21 pyry] Try all possible EGLImage sources
 425                 CHECK_EXTENSION(m_display, "EGL_KHR_gl_texture_2D_image");
 426
 427                 // Initialize result.
 428                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 429
 430                 // Create GLES2 context
 431
 432                 Context context(m_eglTestCtx, m_display, ContextType(ApiType::es(2, 0)), 64, 64);
 433                 log << TestLog::Message << "Using EGL config " << eglu::getConfigID(m_eglTestCtx.getLibrary(), context.getEglDisplay(), context.getConfig()) << TestLog::EndMessage;
 434
 435                 // Check for OES_EGL_image
 436                 {
 437                         const char* glExt = (const char*)glGetString(GL_EXTENSIONS);
 438
 439                         if (string(glExt).find("GL_OES_EGL_image") == string::npos)
 440                                 throw tcu::NotSupportedError("Extension not supported", "GL_OES_EGL_image", __FILE__, __LINE__);
 441
 442                         TCU_CHECK(m_gl.eglImageTargetTexture2DOES);
 443                         TCU_CHECK(m_gl.eglImageTargetRenderbufferStorageOES);
 444                 }
 445
 446                 // Create GL_TEXTURE_2D and EGLImage from it.
 447                 log << TestLog::Message << "Creating EGLImage using GL_TEXTURE_2D with GL_RGBA storage" << TestLog::EndMessage;
 448
 449                 deUint32 srcTex = 1;
 450                 GLU_CHECK_CALL(glBindTexture(GL_TEXTURE_2D, srcTex));
 451                 GLU_CHECK_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL));
 452                 GLU_CHECK_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
 453
 454                 // Create EGL image
 455                 EGLint          attribs[]       = { EGL_GL_TEXTURE_LEVEL_KHR, 0, EGL_NONE };
 456                 EGLImageKHR     image           = CHECK_EXT_CALL_ERR(egl.createImageKHR(context.getEglDisplay(), context.getEglContext(), EGL_GL_TEXTURE_2D_KHR, (EGLClientBuffer)(deUintptr)srcTex, attribs), EGL_SUCCESS);
 457                 if (image == EGL_NO_IMAGE_KHR)
 458                 {
 459                         log << TestLog::Message << "  Fail: Got EGL_NO_IMAGE_KHR!" << TestLog::EndMessage;
 460
 461                         if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 462                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got EGL_NO_IMAGE_KHR");
 463                 }
 464
 465                 // Create texture or renderbuffer
 466                 if (m_target == GL_TEXTURE_2D)
 467                 {
 468                         log << TestLog::Message << "Creating GL_TEXTURE_2D from EGLimage" << TestLog::EndMessage;
 469
 470                         deUint32 dstTex = 2;
 471                         GLU_CHECK_CALL(glBindTexture(GL_TEXTURE_2D, dstTex));
 472                         GLU_CHECK_CALL(glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image));
 473                         GLU_CHECK_CALL(glDeleteTextures(1, &dstTex));
 474                 }
 475                 else
 476                 {
 477                         DE_ASSERT(m_target == GL_RENDERBUFFER);
 478
 479                         log << TestLog::Message << "Creating GL_RENDERBUFFER from EGLimage" << TestLog::EndMessage;
 480
 481                         deUint32 dstRbo = 2;
 482                         GLU_CHECK_CALL(glBindRenderbuffer(GL_RENDERBUFFER, dstRbo));
 483                         GLU_CHECK_CALL(glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER, (GLeglImageOES)image));
 484                         GLU_CHECK_CALL(glDeleteRenderbuffers(1, &dstRbo));
 485                 }
 486
 487                 // Destroy image
 488                 CHECK_EXT_CALL_RET(egl.destroyImageKHR(context.getEglDisplay(), image), (EGLBoolean)EGL_TRUE, EGL_SUCCESS);
 489
 490                 // Destroy source texture object
 491                 GLU_CHECK_CALL(glDeleteTextures(1, &srcTex));
 492
 493                 return STOP;
 494         }
 495
 496 private:
 497         GLenum  m_target;
 498 };
 499
 500 class ApiTests : public TestCaseGroup
 501 {
 502 public:
 503         ApiTests (EglTestContext& eglTestCtx, const string& name, const string& desc) : TestCaseGroup(eglTestCtx, name.c_str(), desc.c_str()) {}
 504
 505         void init (void)
 506         {
 507                 addChild(new Image::InvalidCreateImage(m_eglTestCtx));
 508
 509                 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_2D_KHR, GL_RED, GL_RED, GL_UNSIGNED_BYTE, false));
 510                 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_2D_KHR, GL_RG, GL_RG, GL_UNSIGNED_BYTE, false));
 511
 512                 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_2D_KHR, GL_LUMINANCE, GL_LUMINANCE, GL_UNSIGNED_BYTE));
 513                 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_2D_KHR, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE));
 514
 515                 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_2D_KHR, GL_RGB, GL_RGB, GL_UNSIGNED_BYTE));
 516                 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_2D_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE));
 517                 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_2D_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, true));
 518
 519                 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR, GL_RGB, GL_RGB, GL_UNSIGNED_BYTE));
 520                 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE));
 521                 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, true));
 522
 523                 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE));
 524                 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE));
 525                 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE));
 526                 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE));
 527                 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE));
 528
 529                 static const GLenum rboStorages[] =
 530                 {
 531                         GL_DEPTH_COMPONENT16,
 532                         GL_RGBA4,
 533                         GL_RGB5_A1,
 534                         GL_RGB565,
 535                         GL_STENCIL_INDEX8
 536                 };
 537                 for (int storageNdx = 0; storageNdx < DE_LENGTH_OF_ARRAY(rboStorages); storageNdx++)
 538                         addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_RENDERBUFFER_KHR, rboStorages[storageNdx], (GLenum)0, (GLenum)0));
 539
 540                 static const GLenum androidFormats[] =
 541                 {
 542                         GL_RGB565,
 543                         GL_RGB8,
 544                         GL_RGBA4,
 545                         GL_RGB5_A1,
 546                         GL_RGBA8,
 547                 };
 548
 549                 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(androidFormats); ++formatNdx)
 550                         addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_NATIVE_BUFFER_ANDROID, androidFormats[formatNdx], (GLenum)0, (GLenum)0));
 551
 552                 addChild(new Image::ImageTargetGLES2(m_eglTestCtx, GL_TEXTURE_2D));
 553                 addChild(new Image::ImageTargetGLES2(m_eglTestCtx, GL_RENDERBUFFER));
 554         }
 555 };
 556
 557 } // Image
 558
 559 ImageTests::ImageTests (EglTestContext& eglTestCtx)
 560         : TestCaseGroup(eglTestCtx, "image", "EGLImage Tests")
 561 {
 562 }
 563
 564 ImageTests::~ImageTests (void)
 565 {
 566 }
 567
 568 void ImageTests::init (void)
 569 {
 570         addChild(new Image::ApiTests(m_eglTestCtx, "api", "EGLImage API tests"));
 571         addChild(Image::createSimpleCreationTests(m_eglTestCtx, "create", "EGLImage creation tests"));
 572         addChild(Image::createModifyTests(m_eglTestCtx, "modify", "EGLImage modifying tests"));
 573         addChild(Image::createMultiContextRenderTests(m_eglTestCtx, "render_multiple_contexts", "EGLImage render tests on multiple contexts"));
 574 }
 575
 576 } // egl
 577 } // deqp