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

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 "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "media/base/data_buffer.h"
 #include "media/base/video_frame.h"
 #include "media/base/yuv_convert.h"
 #include "skia/ext/texture_handle.h"
@@ skipping 510 matching lines @@
 // When the |format| is RGBA, the converted value is fed as luminance.
 void FlipAndConvertY16(const VideoFrame* video_frame,
                        uint8_t* out,
                        unsigned format,
                        unsigned type,
                        bool flip_y,
                        size_t output_row_bytes) {
   const uint8_t* row_head = video_frame->visible_data(0);
   const size_t stride = video_frame->stride(0);
   const int height = video_frame->visible_rect().height();
-  for (int i = 0; i < height; ++i) {
+  for (int i = 0; i < height; ++i, row_head += stride) {
     uint8_t* out_row_head = flip_y ? out + output_row_bytes * (height - i - 1)
                                    : out + output_row_bytes * i;
     const uint16_t* row = reinterpret_cast<const uint16_t*>(row_head);
     const uint16_t* row_end = row + video_frame->visible_rect().width();
     if (type == GL_FLOAT) {
-      DCHECK_EQ(static_cast<unsigned>(GL_RGBA), format);
       float* out_row = reinterpret_cast<float*>(out_row_head);
-      while (row < row_end) {
-        float gray_value = *row++ / 65535.f;
-        *out_row++ = gray_value;
-        *out_row++ = gray_value;
-        *out_row++ = gray_value;
-        *out_row++ = 1.0f;
+      if (format == GL_RGBA) {
+        while (row < row_end) {
+          float gray_value = *row++ / 65535.f;
+          *out_row++ = gray_value;
+          *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.
     } 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);
       }
-    } else {
-      NOTREACHED() << "Unsupported Y16 conversion for format: 0x" << std::hex
-                   << format << " and type: 0x" << std::hex << type;
+      continue;
     }
-    row_head += stride;
+    NOTREACHED() << "Unsupported Y16 conversion for format: 0x" << std::hex
+                 << format << " and type: 0x" << std::hex << type;
   }
 }
 
 // Common functionality of SkCanvasVideoRenderer's TexImage2D and TexSubImage2D.
 // Allocates a buffer required for conversion and converts |frame| content to
 // desired |format|.
 // Returns true if calling glTex(Sub)Image is supported for provided |frame|
 // format and parameters.
 bool TexImageHelper(VideoFrame* frame,
                     unsigned format,
                     unsigned type,
                     bool flip_y,
                     scoped_refptr<DataBuffer>* temp_buffer) {
   unsigned output_bytes_per_pixel = 0;
   switch (frame->format()) {
     case PIXEL_FORMAT_Y16:
       // Converting single component unsigned short here to FLOAT luminance.
       switch (format) {
         case GL_RGBA:
           if (type == GL_FLOAT) {
             output_bytes_per_pixel = 4 * sizeof(GLfloat);
             break;
           }
-        // Pass through.
+          return false;
+        case GL_RED:
+          if (type == GL_FLOAT) {
+            output_bytes_per_pixel = sizeof(GLfloat);
+            break;
+          }
+          return false;
         default:
           return false;
       }
       break;
     default:
       return false;
   }
 
   size_t output_row_bytes =
       frame->visible_rect().width() * output_bytes_per_pixel;
@@ skipping 330 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