Add CopyTexture gl_tests for level == 0

gpu/command_buffer/tests/gl_copy_texture_CHROMIUM_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES
 #endif
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
@@ skipping 11 matching lines @@
 namespace gpu {
 
 namespace {
 
 enum CopyType { TexImage, TexSubImage };
 const CopyType kCopyTypes[] = {
     TexImage,
     TexSubImage,
 };
 
+struct FormatType {
+  GLenum internal_format;
+  GLenum format;
+  GLenum type;
+};
+
+static const char* kSimpleVertexShaderES2 =
+    "attribute vec2 a_position;\n"
+    "varying vec2 v_texCoord;\n"
+    "void main() {\n"
+    "  gl_Position = vec4(a_position.x, a_position.y, 0.0, 1.0);\n"
+    "  v_texCoord = (a_position + vec2(1.0, 1.0)) * 0.5;\n"
+    "}\n";
+
 static const char* kSimpleVertexShaderES3 =
     "#version 300 es\n"
     "in vec2 a_position;\n"
     "out vec2 v_texCoord;\n"
     "void main() {\n"
     "  gl_Position = vec4(a_position.x, a_position.y, 0.0, 1.0);\n"
     "  v_texCoord = (a_position + vec2(1.0, 1.0)) * 0.5;\n"
     "}\n";
 
-std::string GetFragmentShaderSource(GLenum format) {
+std::string GetFragmentShaderSource(GLenum format, bool is_es3) {
   std::string source;
-  source += std::string(
-      "#version 300 es\n"
-      "precision mediump float;\n");
+  if (is_es3) {
+    source +=
+        "#version 300 es\n"
+        "#define VARYING in\n"
+        "#define FRAGCOLOR frag_color\n"
+        "#define TextureLookup texture\n";
+  } else {
+    source +=
+        "#define VARYING varying\n"
+        "#define FRAGCOLOR gl_FragColor\n"
+        "#define TextureLookup texture2D\n";
+  }
+  source += "precision mediump float;\n";
+
   if (gles2::GLES2Util::IsSignedIntegerFormat(format)) {
     source += std::string("#define SamplerType isampler2D\n");
     source += std::string("#define TextureType ivec4\n");
     source += std::string("#define ScaleValue 255.0\n");
   } else if (gles2::GLES2Util::IsUnsignedIntegerFormat(format)) {
     source += std::string("#define SamplerType usampler2D\n");
     source += std::string("#define TextureType uvec4\n");
     source += std::string("#define ScaleValue 255.0\n");
   } else {
     source += std::string("#define SamplerType sampler2D\n");
     source += std::string("#define TextureType vec4\n");
     source += std::string("#define ScaleValue 1.0\n");
   }
 
+  if (is_es3)
+    source += "out vec4 frag_color;\n";
+
   source += std::string(
       "uniform mediump SamplerType u_texture;\n"
-      "in vec2 v_texCoord;\n"
-      "out vec4 fragData;\n"
+      "VARYING vec2 v_texCoord;\n"
       "void main() {\n"
-      "  TextureType color = texture(u_texture, v_texCoord);\n"
-      "  fragData = vec4(color) / ScaleValue;\n"
+      "  TextureType color = TextureLookup(u_texture, v_texCoord);\n"
+      "  FRAGCOLOR = vec4(color) / ScaleValue;\n"
       "}\n");
   return source;
 }
 
 void setColor(uint8_t r, uint8_t g, uint8_t b, uint8_t a, uint8_t* color) {
   color[0] = r;
   color[1] = g;
   color[2] = b;
   color[3] = a;
 }
@@ skipping 106 matching lines @@
   }
 }
 
 }  // namespace
 
 // A collection of tests that exercise the GL_CHROMIUM_copy_texture extension.
 class GLCopyTextureCHROMIUMTest
     : public testing::Test,
       public ::testing::WithParamInterface<CopyType> {
  protected:
-
   void CreateAndBindDestinationTextureAndFBO(GLenum target) {
     glGenTextures(2, textures_);
     glBindTexture(target, textures_[1]);
 
     // Some drivers (NVidia/SGX) require texture settings to be a certain way or
     // they won't report FRAMEBUFFER_COMPLETE.
     glTexParameterf(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameterf(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 
     glGenFramebuffers(1, &framebuffer_id_);
     glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_id_);
     glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target,
                            textures_[1], 0);
   }
 
   void SetUp() override {
-    gl_.Initialize(GLManager::Options());
+    GLManager::Options options;
+    options.size = gfx::Size(64, 64);
+    gl_.Initialize(options);
+
+    width_ = 8;
+    height_ = 8;
   }
 
   void TearDown() override { gl_.Destroy(); }
 
   void CreateBackingForTexture(GLenum target, GLsizei width, GLsizei height) {
     if (target == GL_TEXTURE_RECTANGLE_ARB) {
       GLuint image_id = glCreateGpuMemoryBufferImageCHROMIUM(
           width, height, GL_RGBA, GL_READ_WRITE_CHROMIUM);
       glBindTexImage2DCHROMIUM(target, image_id);
     } else {
       glTexImage2D(target, 0, GL_RGBA, width, height, 0, GL_RGBA,
                    GL_UNSIGNED_BYTE, nullptr);
     }
   }
 
+  GLuint CreateDrawingTexture(GLenum target, GLsizei width, GLsizei height) {
+    GLuint texture = 0;
+    glGenTextures(1, &texture);
+    glBindTexture(target, texture);
+    glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    CreateBackingForTexture(GL_TEXTURE_2D, width, height);
+    return texture;
+  }
+
+  GLuint CreateDrawingFBO(GLenum target, GLuint texture) {
+    GLuint framebuffer = 0;
+    glGenFramebuffers(1, &framebuffer);
+    glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target,
+                           texture, 0);
+    return framebuffer;
+  }
+
   GLenum ExtractFormatFrom(GLenum internalformat) {
     switch (internalformat) {
       case GL_RGBA8_OES:
         return GL_RGBA;
       case GL_RGB8_OES:
         return GL_RGB;
       case GL_BGRA8_EXT:
         return GL_BGRA_EXT;
       default:
         NOTREACHED();
         return GL_NONE;
     }
   }
 
+  void RunCopyTexture(GLenum target,
+                      CopyType copy_type,
+                      FormatType src_format_type,
+                      GLint source_level,
+                      FormatType dest_format_type,
+                      GLint dest_level,
+                      bool is_es3) {
+    const int src_channel_count = gles2::GLES2Util::ElementsPerGroup(
+        src_format_type.format, src_format_type.type);
+    uint8_t color[4] = {1u, 63u, 127u, 255u};
+    std::unique_ptr<uint8_t[]> pixels(new uint8_t[width_ * height_ * 4]);
+    for (int i = 0; i < width_ * height_ * src_channel_count;
+         i += src_channel_count)
+      for (int j = 0; j < src_channel_count; ++j)
+        pixels[i + j] = color[j];
+    uint8_t expected_color[4];
+    uint8_t mask[4];
+    getExpectedColor(src_format_type.internal_format,
+                     dest_format_type.internal_format, color, expected_color,
+                     mask);
+
+    glGenTextures(2, textures_);
+    glBindTexture(target, textures_[0]);
+    glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexImage2D(target, source_level, src_format_type.internal_format, width_,
+                 height_, 0, src_format_type.format, src_format_type.type,
+                 pixels.get());
+    EXPECT_TRUE(glGetError() == GL_NO_ERROR);
+    glBindTexture(target, textures_[1]);
+    glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    EXPECT_TRUE(glGetError() == GL_NO_ERROR);
+
+    if (copy_type == TexImage) {
+      glCopyTextureCHROMIUM(textures_[0], textures_[1],

[Zhenyao Mo, 2017/01/04 18:51:21]

Could you please add a comment here that this function will be upgraded to also
take in tex level information? Otherwise this code doesn't make sense because
you only set up a certain level but it's not reflected in the actual copying.

[qiankun, 2017/01/05 03:07:45]

Done.

+                            dest_format_type.internal_format,
+                            dest_format_type.type, false, false, false);
+    } else {
+      glBindTexture(target, textures_[1]);
+      glTexImage2D(target, dest_level, dest_format_type.internal_format, width_,
+                   height_, 0, dest_format_type.format, dest_format_type.type,
+                   nullptr);
+
+      glCopySubTextureCHROMIUM(textures_[0], textures_[1], 0, 0, 0, 0, width_,

[Zhenyao Mo, 2017/01/04 18:51:21]

Same here.

[qiankun, 2017/01/05 03:07:45]

Done.

+                               height_, false, false, false);
+    }
+    EXPECT_TRUE(glGetError() == GL_NO_ERROR);
+
+    // Draw destination texture to a fbo with a texture attachment in RGBA
+    // format.
+    GLuint texture = CreateDrawingTexture(target, width_, height_);
+    GLuint framebuffer = CreateDrawingFBO(target, texture);
+    EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
+              glCheckFramebufferStatus(GL_FRAMEBUFFER));
+    glViewport(0, 0, width_, height_);
+
+    glBindTexture(target, textures_[1]);
+    std::string fragment_shader_source =
+        GetFragmentShaderSource(dest_format_type.internal_format, is_es3);
+    GLTestHelper::DrawTextureQuad(

[Zhenyao Mo, 2017/01/04 18:51:21]

Again, the tex level information isn't reflected here, so this function also
needs to be upgraded.  Could you add a comment? Otherwise this code is very
confusing.

[qiankun, 2017/01/05 03:07:45]

Done.

+        is_es3 ? kSimpleVertexShaderES3 : kSimpleVertexShaderES2,
+        fragment_shader_source.c_str(), "a_position", "u_texture");
+    EXPECT_TRUE(GL_NO_ERROR == glGetError());
+
+    uint8_t tolerance = dest_format_type.internal_format == GL_RGBA4 ? 20 : 7;
+    EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, width_, height_, tolerance,
+                                          expected_color, mask))
+        << " src_internal_format: "
+        << gles2::GLES2Util::GetStringEnum(src_format_type.internal_format)
+        << " source_level: " << source_level
+        << " dest_internal_format: "
+        << gles2::GLES2Util::GetStringEnum(dest_format_type.internal_format)
+        << " dest_level: " << dest_level;
+
+    glDeleteTextures(1, &texture);
+    glDeleteFramebuffers(1, &framebuffer);
+    glDeleteTextures(2, textures_);
+  }
+
   GLManager gl_;
   GLuint textures_[2];
+  GLsizei width_;
+  GLsizei height_;
   GLuint framebuffer_id_;
 };
 
 class GLCopyTextureCHROMIUMES3Test : public GLCopyTextureCHROMIUMTest {
  protected:
   void SetUp() override {
     GLManager::Options options;
     options.context_type = gles2::CONTEXT_TYPE_OPENGLES3;
     options.size = gfx::Size(64, 64);
     gl_.Initialize(options);
+
+    width_ = 8;
+    height_ = 8;
   }
 
   // If a driver isn't capable of supporting ES3 context, creating
   // ContextGroup will fail. Just skip the test.
   bool ShouldSkipTest() const {
     return (!gl_.decoder() || !gl_.decoder()->GetContextGroup());
   }
 
   // RGB9_E5 isn't accepted by glCopyTexImage2D if underlying context is ES.
   // TODO(qiankun.miao@intel.com): we should support RGB9_E5 in ES context.
@@ skipping 74 matching lines @@
 
   GLTestHelper::CheckPixels(0, 0, 1, 1, 0, pixels, nullptr);
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
 TEST_P(GLCopyTextureCHROMIUMES3Test, FormatCombinations) {
   if (ShouldSkipTest())
     return;
   CopyType copy_type = GetParam();
 
-  struct FormatType {
-    GLenum internal_format;
-    GLenum format;
-    GLenum type;
-  };
-
   FormatType src_format_types[] = {
       {GL_LUMINANCE, GL_LUMINANCE, GL_UNSIGNED_BYTE},
       {GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE},
       {GL_RGB, GL_RGB, GL_UNSIGNED_BYTE},
       {GL_RGB8, GL_RGB, GL_UNSIGNED_BYTE},
       {GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE},
       {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE},
       {GL_BGRA_EXT, GL_BGRA_EXT, GL_UNSIGNED_BYTE},
       {GL_BGRA8_EXT, GL_BGRA_EXT, GL_UNSIGNED_BYTE},
   };
@@ skipping 56 matching lines @@
       if (gles2::GLES2Util::IsFloatFormat(dest_format_type.internal_format) &&
           ShouldSkipFloatFormat())
         continue;
       if ((dest_format_type.internal_format == GL_SRGB_EXT ||
            dest_format_type.internal_format == GL_SRGB_ALPHA_EXT) &&
           ShouldSkipSRGBEXT())
         continue;
       if (dest_format_type.internal_format == GL_RGB5_A1 && ShouldSkipRGB5_A1())
         continue;
 
-      const GLsizei kWidth = 8, kHeight = 8;
-      const int src_channel_count = gles2::GLES2Util::ElementsPerGroup(
-          src_format_type.format, src_format_type.type);
-      uint8_t color[4] = {1, 63, 127, 255};
-      uint8_t pixels[8 * 8 * 4];
-      for (int i = 0; i < kWidth * kHeight * src_channel_count;
-           i += src_channel_count)
-        for (int j = 0; j < src_channel_count; ++j)
-          pixels[i + j] = color[j];
-      uint8_t expected_color[4];
-      uint8_t mask[4];
-      getExpectedColor(src_format_type.internal_format,
-                       dest_format_type.internal_format, color, expected_color,
-                       mask);
-
-      CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D);
-      glBindTexture(GL_TEXTURE_2D, textures_[0]);
-      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-      glTexImage2D(GL_TEXTURE_2D, 0, src_format_type.internal_format, kWidth,
-                   kHeight, 0, src_format_type.format, src_format_type.type,
-                   pixels);
-
-      EXPECT_TRUE(glGetError() == GL_NO_ERROR);
-      if (copy_type == TexImage) {
-        glCopyTextureCHROMIUM(textures_[0], textures_[1],
-                              dest_format_type.internal_format,
-                              dest_format_type.type, false, false, false);
-      } else {
-        glBindTexture(GL_TEXTURE_2D, textures_[1]);
-        glTexImage2D(GL_TEXTURE_2D, 0, dest_format_type.internal_format, kWidth,
-                     kHeight, 0, dest_format_type.format, dest_format_type.type,
-                     nullptr);
-
-        glCopySubTextureCHROMIUM(textures_[0], textures_[1], 0, 0, 0, 0, kWidth,
-                                 kHeight, false, false, false);
-      }
-      EXPECT_TRUE(glGetError() == GL_NO_ERROR)
-          << " src_internal_format: "
-          << gles2::GLES2Util::GetStringEnum(src_format_type.internal_format)
-          << " dest_internal_format: "
-          << gles2::GLES2Util::GetStringEnum(dest_format_type.internal_format);
-
-      // Draw destination texture to a fbo with attachment in RGBA format.
-      glBindFramebuffer(GL_FRAMEBUFFER, 0);
-      GLuint framebuffer = 0;
-      glGenFramebuffers(1, &framebuffer);
-      glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
-      GLuint texture = 0;
-      glGenTextures(1, &texture);
-      glBindTexture(GL_TEXTURE_2D, texture);
-      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-      CreateBackingForTexture(GL_TEXTURE_2D, kWidth, kHeight);
-      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
-                             GL_TEXTURE_2D, texture, 0);
-      EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
-                glCheckFramebufferStatus(GL_FRAMEBUFFER));
-      glViewport(0, 0, kWidth, kHeight);
-
-      glBindTexture(GL_TEXTURE_2D, textures_[1]);
-      std::string fragment_shader_source =
-          GetFragmentShaderSource(dest_format_type.internal_format);
-      GLTestHelper::DrawTextureQuad(kSimpleVertexShaderES3,
-                                    fragment_shader_source.c_str(),
-                                    "a_position", "u_texture");
-
-      uint8_t tolerance = dest_format_type.internal_format == GL_RGBA4 ? 20 : 7;
-      EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kWidth, kHeight, tolerance,
-                                            expected_color, mask))
-          << " src_internal_format: "
-          << gles2::GLES2Util::GetStringEnum(src_format_type.internal_format)
-          << " dest_internal_format: "
-          << gles2::GLES2Util::GetStringEnum(dest_format_type.internal_format);
-      EXPECT_TRUE(GL_NO_ERROR == glGetError());
-
-      glDeleteTextures(1, &texture);
-      glDeleteFramebuffers(1, &framebuffer);
-      glDeleteTextures(2, textures_);
-      glDeleteFramebuffers(1, &framebuffer_id_);
+      RunCopyTexture(GL_TEXTURE_2D, copy_type, src_format_type, 0,
+                     dest_format_type, 0, true);
     }
   }
 }
 
 TEST_P(GLCopyTextureCHROMIUMTest, ImmutableTexture) {
   if (!GLTestHelper::HasExtension("GL_EXT_texture_storage")) {
     LOG(INFO) << "GL_EXT_texture_storage not supported. Skipping test...";
     return;
   }
   CopyType copy_type = GetParam();
@@ skipping 133 matching lines @@
     glCopyTextureCHROMIUM(
         textures_[0], textures_[1], unsupported_format_types[dest_index].format,
         unsupported_format_types[dest_index].type, false, false, false);
     EXPECT_TRUE(GL_INVALID_OPERATION == glGetError())
         << "dest_index:" << dest_index;
   }
   glDeleteTextures(2, textures_);
   glDeleteFramebuffers(1, &framebuffer_id_);
 }
 
+TEST_P(GLCopyTextureCHROMIUMTest, CopyTextureLevel) {
+  CopyType copy_type = GetParam();
+
+  // Copy from RGB source texture to dest texture.
+  FormatType src_format_type = {GL_RGB, GL_RGB, GL_UNSIGNED_BYTE};
+  FormatType dest_format_types[] = {
+      {GL_RGB, GL_RGB, GL_UNSIGNED_BYTE},
+      {GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE},
+  };
+  // Source level must be 0 in ES2 context.

[Zhenyao Mo, 2017/01/04 18:51:22]

Even this can be lifted if you sample the source texture through a shader and
write to the dest texture - this path is needed anyway.

[qiankun, 2017/01/05 03:07:45]

We cannot do this if the source texture is not complete. Source texture may only
specify only one level and this level may be greater than 0. We need to set
minification filter to NEAREST_MIPMAP_NEAREST for level > 0 if we want to sample
from that level. In such situation, source texture is not mipmap complete.
Sampling from level > 0 of incomplete source texture will return (0, 0, 0, 1) in
ES2. See page 87, ES2.0 spec in
https://www.khronos.org/registry/gles/specs/2.0/es_full_spec_2.0.25.pdf.
"
Calling a sampler from a fragment shader will return (R, G, B, A) =
(0, 0, 0, 1) if any of the following conditions are true:
• A two-dimensional sampler is called, the minification filter is one that
requires
a mipmap (neither NEAREST nor LINEAR), and the sampler’s associated texture
object is not complete.
"

Similar description in ES 3.0 spec:
"
The minification filter requires a mipmap (is neither NEAREST nor LINEAR),
and the texture is not mipmap complete.
"

But we can do this for ES3. We can set base level to source_level then restore
base level after glCopyTextureCHROMIUM is done.

+  GLint source_level = 0;
+
+  // TODO(qiankun.miao@intel.com): Support level > 0.
+  for (GLint dest_level = 0; dest_level < 1; dest_level++) {
+    for (auto dest_format_type : dest_format_types) {
+      RunCopyTexture(GL_TEXTURE_2D, copy_type, src_format_type, source_level,
+                     dest_format_type, dest_level, false);
+    }
+  }
+}
+
+TEST_P(GLCopyTextureCHROMIUMES3Test, CopyTextureLevel) {
+  if (ShouldSkipTest())
+    return;
+  CopyType copy_type = GetParam();
+
+  // Copy from RGBA source texture to dest texture.
+  FormatType src_format_type = {GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE};
+  FormatType dest_format_types[] = {
+      {GL_RGB8UI, GL_RGB_INTEGER, GL_UNSIGNED_BYTE},
+      {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE},
+      {GL_RGBA8UI, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE},
+  };
+
+  // TODO(qiankun.miao@intel.com): Support level > 0.
+  for (GLint source_level = 0; source_level < 1; source_level++) {
+    for (GLint dest_level = 0; dest_level < 1; dest_level++) {
+      for (auto dest_format_type : dest_format_types) {
+        RunCopyTexture(GL_TEXTURE_2D, copy_type, src_format_type, source_level,
+                       dest_format_type, dest_level, true);
+      }
+    }
+  }
+}
+
 // Test to ensure that the destination texture is redefined if the properties
 // are different.
 TEST_F(GLCopyTextureCHROMIUMTest, RedefineDestinationTexture) {
   uint8_t pixels[4 * 4] = {255u, 0u, 0u, 255u, 255u, 0u, 0u, 255u,
                            255u, 0u, 0u, 255u, 255u, 0u, 0u, 255u};
 
   CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D);
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
@@ skipping 643 matching lines @@
         }
       }
 
       glDeleteTextures(2, textures_);
       glDeleteFramebuffers(1, &framebuffer_id_);
     }
   }
 }
 
 }  // namespace gpu