Support level > 0 for CopyTextureCHROMIUM extension

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 296 matching lines @@
     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);
+#if defined(OS_MACOSX)
+    // TODO(qiankun.miao@intel.com): Remove this workaround for Mac OSX, once
+    // integer texture rendering bug is fixed on Mac OSX: crbug.com/679639.
+    glTexImage2D(target, 0, src_format_type.internal_format,
+                 width_ << source_level, height_ << source_level, 0,
+                 src_format_type.format, src_format_type.type, nullptr);
+#endif
     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);
+    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);
+    // This hack makes dest texture complete in ES2 and ES3 context
+    // respectively. With this, sampling from the dest texture is correct.
+    if (is_es3) {
+      glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+      glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, dest_level);
+#if defined(OS_MACOSX)
+      // TODO(qiankun.miao@intel.com): Remove this workaround for Mac OSX, once
+      // framebuffer complete bug is fixed on Mac OSX: crbug.com/678526.
+      glTexImage2D(target, 0, dest_format_type.internal_format,
+                   width_ << dest_level, height_ << dest_level, 0,
+                   dest_format_type.format, dest_format_type.type, nullptr);
+#endif
+    } else {
+      glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
+      glTexImage2D(target, 0, dest_format_type.internal_format,
+                   width_ << dest_level, height_ << dest_level, 0,
+                   dest_format_type.format, dest_format_type.type, nullptr);
+      glGenerateMipmap(target);
+    }
     EXPECT_TRUE(glGetError() == GL_NO_ERROR);
 
-    // TODO(qiankun.miao@intel.com): Upgrade glCopyTextureCHROMIUM and
-    // glCopySubTextureCHROMIUM to support copying from level > 0 of source
-    // texture to level > 0 of dest texture.
     if (copy_type == TexImage) {
-      glCopyTextureCHROMIUM(textures_[0], 0, textures_[1], 0,
-                            dest_format_type.internal_format,
+      glCopyTextureCHROMIUM(textures_[0], source_level, textures_[1],
+                            dest_level, 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], 0, textures_[1], 0, 0, 0, 0, 0,
-                               width_, height_, false, false, false);
+      glCopySubTextureCHROMIUM(textures_[0], source_level, textures_[1],
+                               dest_level, 0, 0, 0, 0, width_, 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);
-    // TODO(qiankun.miao@intel.com): Support drawing from level > 0 of a
-    // texture.
     GLTestHelper::DrawTextureQuad(
         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)
@@ skipping 57 matching lines @@
   }
 
   bool ShouldSkipSRGBEXT() const {
     DCHECK(!ShouldSkipTest());
     return !gl_.decoder()->GetFeatureInfo()->feature_flags().ext_srgb;
   }
 
   // RGB5_A1 is not color-renderable on NVIDIA Mac, see crbug.com/676209.
   bool ShouldSkipRGB5_A1() const {
     DCHECK(!ShouldSkipTest());
+#if defined(OS_MACOSX)
     return true;
+#else
+    return false;
+#endif
   }
 };
 
 INSTANTIATE_TEST_CASE_P(CopyType,
                         GLCopyTextureCHROMIUMTest,
                         ::testing::ValuesIn(kCopyTypes));
 
 INSTANTIATE_TEST_CASE_P(CopyType,
                         GLCopyTextureCHROMIUMES3Test,
                         ::testing::ValuesIn(kCopyTypes));
@@ skipping 277 matching lines @@
 
   // 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.
   GLint source_level = 0;
 
-  // TODO(qiankun.miao@intel.com): Support level > 0.
-  for (GLint dest_level = 0; dest_level < 1; dest_level++) {
+  for (GLint dest_level = 0; dest_level < 3; 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 (GLint source_level = 0; source_level < 3; source_level++) {
+    for (GLint dest_level = 0; dest_level < 3; dest_level++) {
       for (auto dest_format_type : dest_format_types) {
+#if defined(OS_WIN) || defined(OS_ANDROID)
+        // TODO(qiankun.miao@intel.com): source_level > 0 or dest_level > 0
+        // isn't available due to renderinig bug for non-zero base level in
+        // NVIDIA Windows: crbug.com/679639 and Android: crbug.com/680460.

[Ken Russell (switch to Gerrit), 2017/01/13 05:08:37]

Sorry for going back and forth on this (per my suggestion on crbug.com/679639),
but I'm concerned that we don't explicitly catch the known error cases in the
core code, and are explicitly skipping the tests rather than expecting failure.
It would be better to add a driver bug workaround like
"disable_copy_texture_chromium_souce_and_dest_levels", and turn on that
workaround for Android and Windows/NVIDIA. The "workaround" would be to manually
generate a GL error if the client attempts to pass in source_level > 0 or
dest_level >0 to Copy{Sub}TextureCHROMIUM on the affected platforms, and abort
the command.

If that's feasible then let's please follow this CL soon with something like it.
Since in the tests we know the platform but not the GPU, we could add a test
here just for Android to expect failure of the CopyTextureCHROMIUM command if
source_level > 0 or dest_level > 0, and on Windows, skip the test.

Thanks.

+        if (dest_level > 0)
+          continue;
+#endif
         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) {
@@ skipping 650 matching lines @@
         }
       }
 
       glDeleteTextures(2, textures_);
       glDeleteFramebuffers(1, &framebuffer_id_);
     }
   }
 }
 
 }  // namespace gpu