WebGL2 & 16-bit depth capture: Upload video to GL_RED float texture.

media/renderers/skcanvas_video_renderer_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.
 
+#include <GLES3/gl3.h>
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/memory/aligned_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface_stub.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
@@ skipping 571 matching lines @@
                   GLint border,
                   GLenum format,
                   GLenum type,
                   const void* pixels) override {
     if (!teximage2d_callback_.is_null()) {
       teximage2d_callback_.Run(target, level, internalformat, width, height,
                                border, format, type, pixels);
     }
   }
 
+  void TexSubImage2D(GLenum target,
+                     GLint level,
+                     GLint xoffset,
+                     GLint yoffset,
+                     GLsizei width,
+                     GLsizei height,
+                     GLenum format,
+                     GLenum type,
+                     const void* pixels) override {
+    if (!texsubimage2d_callback_.is_null()) {
+      texsubimage2d_callback_.Run(target, level, xoffset, yoffset, width,
+                                  height, format, type, pixels);
+    }
+  }
+
   base::Callback<void(GLenum target,
                       GLint level,
                       GLint internalformat,
                       GLsizei width,
                       GLsizei height,
                       GLint border,
                       GLenum format,
                       GLenum type,
                       const void* pixels)>
       teximage2d_callback_;
+
+  base::Callback<void(GLenum target,
+                      GLint level,
+                      GLint xoffset,
+                      GLint yoffset,
+                      GLsizei width,
+                      GLsizei height,
+                      GLenum format,
+                      GLenum type,
+                      const void* pixels)>
+      texsubimage2d_callback_;
 };
 void MailboxHoldersReleased(const gpu::SyncToken& sync_token) {}
 }  // namespace
 
 // Test that SkCanvasVideoRendererTest::Paint doesn't crash when GrContext is
 // abandoned.
 TEST_F(SkCanvasVideoRendererTest, ContextLost) {
   sk_sp<const GrGLInterface> null_interface(GrGLCreateNullInterface());
   sk_sp<GrContext> gr_context(GrContext::Create(
       kOpenGL_GrBackend,
@@ skipping 51 matching lines @@
 
   gfx::RectF visible_rect(visible_size.width(), visible_size.height());
   SkPaint paint;
   renderer_.Paint(video_frame, canvas, visible_rect, paint, VIDEO_ROTATION_0,
                   context_3d);
 
   EXPECT_EQ(fWidth / 2, renderer_.LastImageDimensionsForTesting().width());
   EXPECT_EQ(fWidth / 2, renderer_.LastImageDimensionsForTesting().height());
 }
 
-TEST_F(SkCanvasVideoRendererTest, TexImageImplY16) {
+TEST_F(SkCanvasVideoRendererTest, TexImage2D_Y16_RGBA32F) {
   // Create test frame.
   // |offset_x| and |offset_y| define visible rect's offset to coded rect.
   const int offset_x = 3;
   const int offset_y = 5;
   const int width = 16;
   const int height = 16;
   const int stride = width + offset_x;
   const size_t byte_size = stride * (height + offset_y) * 2;
   std::unique_ptr<unsigned char, base::AlignedFreeDeleter> memory(
       static_cast<unsigned char*>(base::AlignedAlloc(
@@ skipping 34 matching lines @@
             EXPECT_EQ(expected_value, data[(i + j * width) * 4 + 2]);
             EXPECT_EQ(1.0f, data[(i + j * width) * 4 + 3]);
           }
         }
       });
   SkCanvasVideoRenderer::TexImage2D(GL_TEXTURE_2D, &gles2, video_frame.get(), 0,
                                     GL_RGBA, GL_RGBA, GL_FLOAT, true /*flip_y*/,
                                     true);
 }
 
+TEST_F(SkCanvasVideoRendererTest, TexSubImage2D_Y16_R32F) {
+  // Create test frame.
+  // |offset_x| and |offset_y| define visible rect's offset to coded rect.
+  const int offset_x = 3;
+  const int offset_y = 5;
+  const int width = 16;
+  const int height = 16;
+  const int stride = width + offset_x;
+  const size_t byte_size = stride * (height + offset_y) * 2;
+  std::unique_ptr<unsigned char, base::AlignedFreeDeleter> memory(
+      static_cast<unsigned char*>(base::AlignedAlloc(
+          byte_size, media::VideoFrame::kFrameAddressAlignment)));
+  const gfx::Rect rect(offset_x, offset_y, width, height);
+  scoped_refptr<media::VideoFrame> video_frame =
+      CreateTestY16Frame(gfx::Size(stride, offset_y + height), rect,
+                         memory.get(), cropped_frame()->timestamp());
+
+  // Create GL context.
+  sk_sp<const GrGLInterface> null_interface(GrGLCreateNullInterface());
+  sk_sp<GrContext> gr_context(GrContext::Create(
+      kOpenGL_GrBackend,
+      reinterpret_cast<GrBackendContext>(null_interface.get())));
+  TestGLES2Interface gles2;
+  Context3D context_3d(&gles2, gr_context.get());
+
+  // Bind the texImage2D callback to verify the uint16 to float32 conversion.
+  gles2.texsubimage2d_callback_ = base::Bind([](
+      GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
+      GLsizei height, GLenum format, GLenum type, const void* pixels) {
+    EXPECT_EQ(static_cast<unsigned>(GL_FLOAT), type);
+    EXPECT_EQ(static_cast<unsigned>(GL_RED), format);
+    EXPECT_EQ(2, xoffset);
+    EXPECT_EQ(1, yoffset);
+    EXPECT_EQ(16, width);
+    EXPECT_EQ(16, height);
+    EXPECT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
+    const float* data = static_cast<const float*>(pixels);
+    for (int j = 0; j < height; j++) {
+      for (int i = 0; i < width; i++) {
+        const int value = i + j * width;  // flip_y is false.
+        float expected_value =
+            (((value & 0xFF) << 8) | (~value & 0xFF)) / 65535.f;
+        EXPECT_EQ(expected_value, data[(i + j * width)]);
+      }
+    }
+  });
+  SkCanvasVideoRenderer::TexSubImage2D(GL_TEXTURE_2D, &gles2, video_frame.get(),
+                                       0, GL_RED, GL_FLOAT, 2 /*xoffset*/,
+                                       1 /*yoffset*/, false /*flip_y*/, true);
+}
+
 }  // namespace media