16 bpp video stream capture, render and WebGL usage - Realsense R200 & SR300 support.

gpu/command_buffer/service/gles2_cmd_decoder.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 "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 10578 matching lines @@
       accepted_formats.push_back(GL_RGBA_INTEGER);
       accepted_types.push_back(GL_INT);
       break;
     case GL_RGB10_A2:
       accepted_formats.push_back(GL_RGBA);
       accepted_types.push_back(GL_UNSIGNED_BYTE);
       // Special case with an extra supported format/type.
       accepted_formats.push_back(GL_RGBA);
       accepted_types.push_back(GL_UNSIGNED_INT_2_10_10_10_REV);
       break;
+    case GL_R32F:
+      if (validators_->read_pixel_format.IsValid(GL_RED)) {
+        accepted_formats.push_back(GL_RED);
+        accepted_types.push_back(GL_FLOAT);

[Ken Russell (switch to Gerrit), 2016/09/30 23:01:29]

Where is it specified that ReadPixels with type GL_RED and type GL_FLOAT is
legal if a GL_R32F color buffer is bound? Reading the ES 3.0.4 spec,
https://www.khronos.org/registry/gles/extensions/EXT/EXT_color_buffer_float.txt
, and https://www.khronos.org/registry/gles/extensions/EXT/EXT_texture_rg.txt, I
don't see what makes this a legal readback format/type combination. I do see
that GL_RGBA/GL_FLOAT would be legal per EXT_color_buffer_float.

+      }
+    // Fall through.
     default:
       accepted_formats.push_back(GL_RGBA);
       {
         GLenum src_type = GetBoundReadFrameBufferTextureType();
         switch (src_type) {
           case GL_HALF_FLOAT:
           case GL_HALF_FLOAT_OES:
           case GL_FLOAT:
           case GL_UNSIGNED_INT_10F_11F_11F_REV:
             accepted_types.push_back(GL_FLOAT);
@@ skipping 4399 matching lines @@
   source_texture->GetLevelType(source_texture->target(), 0, &source_type,
                                &source_internal_format);
 
   // The destination format should be GL_RGB, or GL_RGBA. GL_ALPHA,
   // GL_LUMINANCE, and GL_LUMINANCE_ALPHA are not supported because they are not
   // renderable on some platforms.
   bool valid_dest_format =
       dest_internal_format == GL_RGB || dest_internal_format == GL_RGBA ||
       dest_internal_format == GL_RGB8 || dest_internal_format == GL_RGBA8 ||
       dest_internal_format == GL_BGRA_EXT ||
-      dest_internal_format == GL_BGRA8_EXT;
+      dest_internal_format == GL_BGRA8_EXT ||
+      ((dest_internal_format == GL_R16UI || dest_internal_format == GL_R8 ||
+        dest_internal_format == GL_RG8) &&
+       feature_info_->feature_flags().ext_texture_rg);

[Ken Russell (switch to Gerrit), 2016/09/30 23:01:30]

EXT_texture_rg doesn't provide the GL_R16UI format. That's only supported by
ES3. The logic here which gates the support for these internal formats must be
correct.

   bool valid_source_format =
       source_internal_format == GL_RED || source_internal_format == GL_ALPHA ||
       source_internal_format == GL_RGB || source_internal_format == GL_RGBA ||
       source_internal_format == GL_RGB8 || source_internal_format == GL_RGBA8 ||
       source_internal_format == GL_LUMINANCE ||
       source_internal_format == GL_LUMINANCE_ALPHA ||
       source_internal_format == GL_BGRA_EXT ||
       source_internal_format == GL_BGRA8_EXT ||
       source_internal_format == GL_RGB_YCBCR_420V_CHROMIUM ||
-      source_internal_format == GL_RGB_YCBCR_422_CHROMIUM;
+      source_internal_format == GL_RGB_YCBCR_422_CHROMIUM ||
+      source_internal_format == GL_RG_EXT ||

[Ken Russell (switch to Gerrit), 2016/09/30 23:01:29]

Why is support for GL_RG_EXT here not gated by
feature_info_->feature_flags().ext_texture_rg? Is it because if the source
texture was allocated successfully with that format, it means that feature test
already happened elsewhere?

+      ((source_internal_format == GL_R32F ||
+        source_internal_format == GL_R16F) &&
+       validators_->texture_internal_format.IsValid(source_internal_format));

[Ken Russell (switch to Gerrit), 2016/09/30 23:01:30]

Why does this check of source_internal_format against the validators_ have to be
done? Is it because the texture may have been mailboxed over into our context,
so this context's share group's validators might not support the source internal
format?

+
+  // TODO(astojilj): to check if renderable, check ext_color_buffer_(half)float.
+  // It is, for now, checked in Extensions3DUtil::canUseCopyTextureCHROMIUM.

[Ken Russell (switch to Gerrit), 2016/09/30 23:01:30]

This is a pretty significant TODO. Could you please work on resolving it?

+  if (dest_internal_format == GL_R32F || dest_internal_format == GL_R16F)
+    valid_dest_format =
+        validators_->texture_internal_format.IsValid(dest_internal_format);

[Ken Russell (switch to Gerrit), 2016/09/30 23:01:30]

Why is this logic separate from the computation of valid_dest_format above?
Could you at least move it closer to the other code?

+
   if (!valid_source_format) {
     std::string msg = "invalid source internal format " +
         GLES2Util::GetStringEnum(source_internal_format);
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
                        msg.c_str());
     return false;
   }
   if (!valid_dest_format) {
     std::string msg = "invalid dest internal format " +
         GLES2Util::GetStringEnum(dest_internal_format);
@@ skipping 58 matching lines @@
     GLenum dest_type,
     GLboolean unpack_flip_y,
     GLboolean unpack_premultiply_alpha,
     GLboolean unpack_unmultiply_alpha) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoCopyTextureCHROMIUM");
   static const char kFunctionName[] = "glCopyTextureCHROMIUM";
 
   TextureRef* source_texture_ref = GetTexture(source_id);
   TextureRef* dest_texture_ref = GetTexture(dest_id);
 
+  GLenum format =
+      TextureManager::ExtractFormatFromStorageFormat(internal_format);
   if (!texture_manager()->ValidateTextureParameters(
-          GetErrorState(), kFunctionName, true, internal_format, dest_type,
+          GetErrorState(), kFunctionName, true, format, dest_type,
           internal_format, 0))
     return;
 
   if (!ValidateCopyTextureCHROMIUMTextures(kFunctionName, source_texture_ref,
                                            dest_texture_ref)) {
     return;
   }
 
   if (!ValidateCopyTextureCHROMIUMInternalFormats(
           kFunctionName, source_texture_ref, internal_format)) {
@@ skipping 2624 matching lines @@
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu