More tests for EGLImage

tests/EGLImageTest.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Test.h"
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
@@ skipping 19 matching lines @@
         }
         glctx1->unref();
     }
 
     glctx0->makeCurrent();
     if (texID0) {
         GR_GL_CALL(glctx0->gl(), DeleteTextures(1, &texID0));
     }
 }
 
+static void test_read_pixels(skiatest::Reporter* reporter, GrContext* context,
+                             GrTexture* externalTexture, uint32_t expectedPixelValues[]) {
+    int pixelCnt = externalTexture->width() * externalTexture->height();
+    SkAutoTMalloc<uint32_t> pixels(pixelCnt);
+    memset(pixels.get(), 0, sizeof(uint32_t)*pixelCnt);
+    bool read = externalTexture->readPixels(0, 0, externalTexture->width(),
+                                            externalTexture->height(), kRGBA_8888_GrPixelConfig,
+                                            pixels.get());
+    if (!read) {
+        ERRORF(reporter, "Error reading external texture.");
+    }
+    for (int i = 0; i < pixelCnt; ++i) {
+        if (pixels.get()[i] != expectedPixelValues[i]) {
+            ERRORF(reporter, "Error, external texture pixel value %d should be 0x%08x,"
+                             " got 0x%08x.", i, expectedPixelValues[i], pixels.get()[i]);
+            break;
+        }
+    }
+}
+
+static void test_write_pixels(skiatest::Reporter* reporter, GrContext* context,
+                              GrTexture* externalTexture) {
+    int pixelCnt = externalTexture->width() * externalTexture->height();
+    SkAutoTMalloc<uint32_t> pixels(pixelCnt);
+    memset(pixels.get(), 0, sizeof(uint32_t)*pixelCnt);
+    bool write = externalTexture->writePixels(0, 0, 0, 0, kRGBA_8888_GrPixelConfig, pixels.get());
+    REPORTER_ASSERT_MESSAGE(reporter, !write, "Should not be able to write to a EXTERNAL"
+                                              " texture.");
+}
+
+static void test_copy_surface(skiatest::Reporter* reporter, GrContext* context,
+                              GrTexture* externalTexture, uint32_t expectedPixelValues[]) {
+    GrSurfaceDesc copyDesc;
+    copyDesc.fConfig = kRGBA_8888_GrPixelConfig;
+    copyDesc.fWidth = externalTexture->width();
+    copyDesc.fHeight = externalTexture->height();
+    copyDesc.fFlags = kRenderTarget_GrSurfaceFlag;
+    SkAutoTUnref<GrTexture> copy(context->textureProvider()->createTexture(copyDesc, true));
+    context->copySurface(copy, externalTexture);
+    test_read_pixels(reporter, context, copy, expectedPixelValues);
+}
+
 DEF_GPUTEST(EGLImageTest, reporter, factory) {
     for (int glCtxType = 0; glCtxType < GrContextFactory::kGLContextTypeCnt; ++glCtxType) {
         GrContextFactory::GLContextType type = (GrContextFactory::GLContextType)glCtxType;
         if (!GrContextFactory::IsRenderingGLContext(type)) {
             continue;
         }
         
         // Try to create a second GL context and then check if the contexts have necessary
         // extensions to run this test.
 
@@ skipping 83 matching lines @@
         externalDesc.fHeight = kSize;
         externalDesc.fTextureHandle = reinterpret_cast<GrBackendObject>(&externalTexture);
         SkAutoTUnref<GrTexture> externalTextureObj(
             context0->textureProvider()->wrapBackendTexture(externalDesc));
         if (!externalTextureObj) {
             ERRORF(reporter, "Error wrapping external texture in GrTexture.");
             cleanup(glCtx0, externalTexture.fID, glCtx1, context1, backendTexture1, image);
             continue;
         }
 
-        // Read the pixels and see if we get the values set in GL context 1
-        memset(pixels.get(), 0, sizeof(uint32_t)*kSize*kSize);
-        bool read = externalTextureObj->readPixels(0, 0, kSize, kSize, kRGBA_8888_GrPixelConfig,
-                                                   pixels.get());
-        if (!read) {
-            ERRORF(reporter, "Error reading external texture.");
-            cleanup(glCtx0, externalTexture.fID, glCtx1, context1, backendTexture1, image);
-            continue;
+        // Should not be able to wrap as a RT
+        externalDesc.fFlags = kRenderTarget_GrBackendTextureFlag;
+        SkAutoTUnref<GrTexture> externalTextureRTObj(
+            context0->textureProvider()->wrapBackendTexture(externalDesc));
+        if (externalTextureRTObj) {
+            ERRORF(reporter, "Should not be able to wrap an EXTERNAL texture as a RT.");
         }
-        for (int i = 0; i < kSize*kSize; ++i) {
-            if (pixels.get()[i] != 0xDDAABBCC) {
-                ERRORF(reporter, "Error, external texture pixel value %d should be 0xDDAABBCC,"
-                                 " got 0x%08x.", pixels.get()[i]);
-                break;
-            }
+        externalDesc.fFlags = kNone_GrBackendTextureFlag;
+
+        // Should not be able to wrap with a sample count
+        externalDesc.fSampleCnt = 4;
+        SkAutoTUnref<GrTexture> externalTextureMSAAObj(
+            context0->textureProvider()->wrapBackendTexture(externalDesc));
+        if (externalTextureMSAAObj) {
+            ERRORF(reporter, "Should not be able to wrap an EXTERNAL texture with MSAA.");
         }
+        externalDesc.fSampleCnt = 0;

[joshualitt, 2015/11/20 22:57:04]

is there a reason you set this to 0?

[bsalomon, 2015/11/23 15:05:14]

Just in case someone added a third wrap test.

+
+        test_read_pixels(reporter, context0, externalTextureObj, pixels.get());
+
+        test_write_pixels(reporter, context0, externalTextureObj);
+
+        test_copy_surface(reporter, context0, externalTextureObj, pixels.get());
+
         cleanup(glCtx0, externalTexture.fID, glCtx1, context1, backendTexture1, image);
     }
 }
 
 #endif