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

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 "cc/paint/paint_flags.h"
 #include "cc/paint/skia_paint_canvas.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface_stub.h"
+#include "gpu/command_buffer/common/capabilities.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/renderers/skcanvas_video_renderer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/libyuv/include/libyuv/convert.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
@@ skipping 688 matching lines @@
   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.teximage2d_callback_ =
       base::Bind([](GLenum target, GLint level, GLint internalformat,
                     GLsizei width, GLsizei height, GLint border, GLenum format,
                     GLenum type, const void* pixels) {
         EXPECT_EQ(static_cast<unsigned>(GL_FLOAT), type);
         EXPECT_EQ(static_cast<unsigned>(GL_RGBA), format);
         EXPECT_EQ(GL_RGBA, internalformat);
         EXPECT_EQ(0, border);
         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 + (height - j - 1) * width;  // flip_y is true.
             float expected_value =
                 (((value & 0xFF) << 8) | (~value & 0xFF)) / 65535.f;
             EXPECT_EQ(expected_value, data[(i + j * width) * 4]);
             EXPECT_EQ(expected_value, data[(i + j * width) * 4 + 1]);
             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);
+  SkCanvasVideoRenderer::TexImage2D(
+      GL_TEXTURE_2D, 0, &gles2, gpu::Capabilities(), 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