16-bit video upload to float: intermediate R16_EXT and copy to float.

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 148 matching lines @@
                       GLenum dest_internal_format,
                       uint8_t* color,
                       uint8_t* expected_color,
                       uint8_t* mask) {
   uint8_t adjusted_color[4];
   switch (src_internal_format) {
     case GL_ALPHA:
       setColor(0, 0, 0, color[0], adjusted_color);
       break;
     case GL_R8:
+    case GL_R16_EXT:
       setColor(color[0], 0, 0, 255, adjusted_color);
       break;
     case GL_LUMINANCE:
       setColor(color[0], color[0], color[0], 255, adjusted_color);
       break;
     case GL_LUMINANCE_ALPHA:
       setColor(color[0], color[0], color[0], color[1], adjusted_color);
       break;
     case GL_RGB:
     case GL_RGB8:
@@ skipping 77 matching lines @@
       // This should be wrong. Skip the alpha channel check and revisit this in
       // future.
       setColor(1, 1, 1, 0, mask);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
+std::unique_ptr<uint8_t[]> getTextureDataAndExpectedRGBA(
+    FormatType src_format_type,
+    FormatType dest_format_type,
+    GLsizei width,
+    GLsizei height,
+    uint8_t* expected_color,
+    uint8_t* expected_mask) {
+  const int src_channel_count = gles2::GLES2Util::ElementsPerGroup(
+      src_format_type.format, src_format_type.type);
+  uint8_t color[4] = {1u, 63u, 127u, 255u};
+  getExpectedColor(src_format_type.internal_format,
+                   dest_format_type.internal_format, color, expected_color,
+                   expected_mask);
+  if (src_format_type.type == GL_UNSIGNED_BYTE) {
+    std::unique_ptr<uint8_t[]> pixels(
+        new uint8_t[width * height * src_channel_count]);
+    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];
+    }
+    return pixels;
+  } else if (src_format_type.type == GL_UNSIGNED_SHORT) {
+    uint16_t color_16bit[4] = {1u << 8, 63u << 8, 127u << 8, 255u << 8};
+    std::unique_ptr<uint8_t[]> data(
+        new uint8_t[width * height * src_channel_count * sizeof(uint16_t)]);
+    uint16_t* pixels = reinterpret_cast<uint16_t*>(data.get());
+    int16_t flip_sign = -1;
+    for (int i = 0; i < width * height * src_channel_count;
+         i += src_channel_count) {
+      for (int j = 0; j < src_channel_count; ++j) {
+        // Introduce an offset to the value to check. Expected value should be
+        // the same as without the offset.
+        flip_sign *= -1;
+        pixels[i + j] =
+            color_16bit[j] + flip_sign * (0x7F * (i + j)) / (width * height);
+      }
+    }
+    return data;
+  }
+  NOTREACHED();
+  return nullptr;
+}
+
 }  // 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]);
@@ skipping 68 matching lines @@
     }
   }
 
   void RunCopyTexture(GLenum dest_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);
-
+    std::unique_ptr<uint8_t[]> pixels =
+        getTextureDataAndExpectedRGBA(src_format_type, dest_format_type, width_,
+                                      height_, expected_color, mask);
     GLenum source_target = GL_TEXTURE_2D;
     glGenTextures(2, textures_);
     glBindTexture(source_target, textures_[0]);
     glTexParameteri(source_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameteri(source_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(source_target, 0, src_format_type.internal_format,
                  width_ << source_level, height_ << source_level, 0,
@@ skipping 142 matching lines @@
     return !gl_.decoder()
                 ->GetFeatureInfo()
                 ->feature_flags()
                 .ext_texture_format_bgra8888;
   }
 
   bool ShouldSkipSRGBEXT() const {
     DCHECK(!ShouldSkipTest());
     return !gl_.decoder()->GetFeatureInfo()->feature_flags().ext_srgb;
   }
+
+  bool ShouldSkipNorm16() const {
+    DCHECK(!ShouldSkipTest());
+#if (defined(OS_MACOSX) || defined(OS_WIN) || defined(OS_LINUX)) && \
+    (defined(ARCH_CPU_X86) || defined(ARCH_CPU_X86_64))
+    // Make sure it's tested on desktop; it is safe to assume that the
+    // functionality is supported on desktop.
+    return false;

[hubbe, 2017/04/26 18:09:31]

Why can't we just always use the feature flag?
Maybe add a EXPECT_EQ() to make sure that the feature flag is always true on
desktop?

[aleksandar.stojiljkovic, 2017/04/26 19:04:50]

Done.

+#else
+    return !gl_.decoder()->GetFeatureInfo()->feature_flags().ext_texture_norm16;
+#endif
+  }
 };
 
 INSTANTIATE_TEST_CASE_P(CopyType,
                         GLCopyTextureCHROMIUMTest,
                         ::testing::ValuesIn(kCopyTypes));
 
 INSTANTIATE_TEST_CASE_P(CopyType,
                         GLCopyTextureCHROMIUMES3Test,
                         ::testing::ValuesIn(kCopyTypes));
 
@@ skipping 41 matching lines @@
 
   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},
+      {GL_R16_EXT, GL_RED, GL_UNSIGNED_SHORT},
   };
 
   FormatType dest_format_types[] = {
       // TODO(qiankun.miao@intel.com): ALPHA and LUMINANCE formats have bug on
       // GL core profile. See crbug.com/577144. Enable these formats after
       // using workaround in gles2_cmd_copy_tex_image.cc.
       // {GL_ALPHA, GL_ALPHA, GL_UNSIGNED_BYTE},
       // {GL_LUMINANCE, GL_LUMINANCE, GL_UNSIGNED_BYTE},
       // {GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE},
 
@@ skipping 42 matching lines @@
           ShouldSkipBGRA()) {
         continue;
       }
       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 (src_format_type.internal_format == GL_R16_EXT && ShouldSkipNorm16())
+        continue;
 
       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...";
@@ skipping 949 matching lines @@
         }
       }
 
       glDeleteTextures(2, textures_);
       glDeleteFramebuffers(1, &framebuffer_id_);
     }
   }
 }
 
 }  // namespace gpu