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

media/renderers/skcanvas_video_renderer.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 "media/renderers/skcanvas_video_renderer.h"
 
 #include <GLES3/gl3.h>
 #include <limits>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "cc/paint/paint_canvas.h"
 #include "cc/paint/paint_flags.h"
 #include "cc/paint/paint_image.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
+#include "gpu/command_buffer/common/capabilities.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "media/base/data_buffer.h"
 #include "media/base/video_frame.h"
 #include "skia/ext/texture_handle.h"
 #include "third_party/libyuv/include/libyuv.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkImageGenerator.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/gl/GrGLTypes.h"
 #include "ui/gfx/geometry/rect_f.h"
@@ skipping 541 matching lines @@
           *out_row++ = gray_value;
           *out_row++ = gray_value;
           *out_row++ = 1.0f;
         }
         continue;
       } else if (format == GL_RED) {
         while (row < row_end)
           *out_row++ = *row++ / 65535.f;
         continue;
       }
-      // For other formats, hit NOTREACHED bellow.
+      // For other formats, hit NOTREACHED below.
     } else if (type == GL_UNSIGNED_BYTE) {
       // We take the upper 8 bits of 16-bit data and convert it as luminance to
       // ARGB.  We loose the precision here, but it is important not to render
       // Y16 as RG_88.  To get the full precision use float textures with WebGL1
       // and e.g. R16UI or R32F textures with WebGL2.
       DCHECK_EQ(static_cast<unsigned>(GL_RGBA), format);
       uint32_t* rgba = reinterpret_cast<uint32_t*>(out_row_head);
       while (row < row_end) {
         uint32_t gray_value = *row++ >> 8;
         *rgba++ = SkColorSetRGB(gray_value, gray_value, gray_value);
@@ skipping 42 matching lines @@
 
   size_t output_row_bytes =
       frame->visible_rect().width() * output_bytes_per_pixel;
   *temp_buffer =
       new DataBuffer(output_row_bytes * frame->visible_rect().height());
   FlipAndConvertY16(frame, (*temp_buffer)->writable_data(), format, type,
                     flip_y, output_row_bytes);
   return true;
 }
 
+// Upload the |frame| data to temporary texture of |temp_format|,
+// |temp_internalformat| and |temp_type| and then copy intermediate texture
+// subimage to destination |texture|. The destination |texture| is bound to the
+// |target| before the call.
+void TextureSubImageUsingIntermediate(unsigned target,
+                                      unsigned texture,
+                                      gpu::gles2::GLES2Interface* gl,
+                                      VideoFrame* frame,
+                                      int temp_internalformat,
+                                      unsigned temp_format,
+                                      unsigned temp_type,
+                                      int level,
+                                      int xoffset,
+                                      int yoffset,
+                                      bool flip_y,
+                                      bool premultiply_alpha) {
+  unsigned temp_texture = 0;
+  gl->GenTextures(1, &temp_texture);
+  gl->BindTexture(target, temp_texture);
+  gl->TexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  gl->TexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  gl->TexImage2D(target, 0, temp_internalformat, frame->visible_rect().width(),
+                 frame->visible_rect().height(), 0, temp_format, temp_type,
+                 frame->visible_data(0));
+  gl->BindTexture(target, texture);
+  gl->CopySubTextureCHROMIUM(temp_texture, 0, target, texture, level, 0, 0,
+                             xoffset, yoffset, frame->visible_rect().width(),
+                             frame->visible_rect().height(), flip_y,
+                             premultiply_alpha, false);
+  gl->DeleteTextures(1, &temp_texture);
+}
+
 }  // anonymous namespace
 
 // static
 void SkCanvasVideoRenderer::ConvertVideoFrameToRGBPixels(
     const VideoFrame* video_frame,
     void* rgb_pixels,
     size_t row_bytes) {
   if (!video_frame->IsMappable()) {
     NOTREACHED() << "Cannot extract pixels from non-CPU frame formats.";
     return;
@@ skipping 269 matching lines @@
     video_frame->UpdateReleaseSyncToken(&client);
   } else {
     CopyVideoFrameSingleTextureToGLTexture(
         destination_gl, video_frame.get(), SingleFrameForWebGL, texture,
         internal_format, format, type, premultiply_alpha, flip_y);
   }
 
   return true;
 }
 
-bool SkCanvasVideoRenderer::TexImage2D(unsigned target,
-                                       gpu::gles2::GLES2Interface* gl,
-                                       VideoFrame* frame,
-                                       int level,
-                                       int internalformat,
-                                       unsigned format,
-                                       unsigned type,
-                                       bool flip_y,
-                                       bool premultiply_alpha) {
+bool SkCanvasVideoRenderer::TexImage2D(
+    unsigned target,
+    unsigned texture,
+    gpu::gles2::GLES2Interface* gl,
+    const gpu::Capabilities& gpu_capabilities,
+    VideoFrame* frame,
+    int level,
+    int internalformat,
+    unsigned format,
+    unsigned type,
+    bool flip_y,
+    bool premultiply_alpha) {
   DCHECK(frame);
   DCHECK(!frame->HasTextures());
 
+  // Note: CopyTextureCHROMIUM uses mediump for color computation. Don't use
+  // it if the precision would lead to data loss when converting 16-bit
+  // normalized to float. medium_float.precision > 15 means that the approach
+  // below is not used on Android, where the extension EXT_texture_norm16 is
+  // not widely supported. It is used on Windows, Linux and OSX.
+  // Android support is not required for now because Tango depth camera already
+  // provides floating point data (projected point cloud). See crbug.com/674440.
+  if (gpu_capabilities.texture_norm16 &&
+      gpu_capabilities.fragment_shader_precisions.medium_float.precision > 15 &&
+      target == GL_TEXTURE_2D &&
+      (type == GL_FLOAT || type == GL_UNSIGNED_BYTE)) {
+    // TODO(aleksandar.stojiljkovic): Extend the approach to TexSubImage2D
+    // implementation and other types. See https://crbug.com/624436.
+
+    // Allocate the destination texture.
+    gl->TexImage2D(target, level, internalformat, frame->visible_rect().width(),
+                   frame->visible_rect().height(), 0, format, type, nullptr);
+    // We use sized internal format GL_R16_EXT instead of unsized GL_RED.
+    // See angleproject:1952
+    TextureSubImageUsingIntermediate(target, texture, gl, frame, GL_R16_EXT,
+                                     GL_RED, GL_UNSIGNED_SHORT, level, 0, 0,
+                                     flip_y, premultiply_alpha);
+    return true;
+  }
   scoped_refptr<DataBuffer> temp_buffer;
   if (!TexImageHelper(frame, format, type, flip_y, &temp_buffer))
     return false;
 
   gl->TexImage2D(target, level, internalformat, frame->visible_rect().width(),
                  frame->visible_rect().height(), 0, format, type,
                  temp_buffer->data());
   return true;
 }
 
@@ skipping 70 matching lines @@
       last_image_->bounds().contains(visible_rect)) {
     last_image_ = last_image_->makeSubset(visible_rect);
   }
 }
 
 SkISize SkCanvasVideoRenderer::LastImageDimensionsForTesting() {
   return last_image_dimensions_for_testing_;
 }
 
 }  // namespace media