Added minimal support to command buffer for GL_ARB_texture_rectangle

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2011 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 <stdio.h>
 
 #include <algorithm>
 #include <list>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/at_exit.h"
 #include "base/bind.h"
+#if defined(OS_MACOSX)
+#include "base/mac/scoped_cftyperef.h"
+#endif
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "build/build_config.h"
 #define GLES2_GPU_SERVICE 1
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/common/id_allocator.h"
 #include "gpu/command_buffer/common/trace_event.h"
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/framebuffer_manager.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_validation.h"
 #include "gpu/command_buffer/service/program_manager.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/shader_translator.h"
 #include "gpu/command_buffer/service/stream_texture.h"
 #include "gpu/command_buffer/service/stream_texture_manager.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "gpu/command_buffer/service/vertex_attrib_manager.h"
 #include "ui/gfx/gl/gl_context.h"
 #include "ui/gfx/gl/gl_implementation.h"
 #include "ui/gfx/gl/gl_surface.h"
+#if defined(OS_MACOSX)
+#include "ui/gfx/surface/io_surface_support_mac.h"
+#endif
 
 #if !defined(GL_DEPTH24_STENCIL8)
 #define GL_DEPTH24_STENCIL8 0x88F0
 #endif
 
 namespace gpu {
 namespace gles2 {
 
 namespace {
 static const char kOESDerivativeExtension[] = "GL_OES_standard_derivatives";
@@ skipping 499 matching lines @@
     TextureManager::TextureInfo::Ref bound_texture_2d;
 
     // texture currently bound to this unit's GL_TEXTURE_CUBE_MAP with
     // glBindTexture
     TextureManager::TextureInfo::Ref bound_texture_cube_map;
 
     // texture currently bound to this unit's GL_TEXTURE_EXTERNAL_OES with
     // glBindTexture
     TextureManager::TextureInfo::Ref bound_texture_external_oes;
 
+    // texture currently bound to this unit's GL_TEXTURE_RECTANGLE_ARB with
+    // glBindTexture
+    TextureManager::TextureInfo::Ref bound_texture_rectangle_arb;
+
     TextureManager::TextureInfo::Ref GetInfoForSamplerType(GLenum type) {
       DCHECK(type == GL_SAMPLER_2D || type == GL_SAMPLER_CUBE ||
-             type == GL_SAMPLER_EXTERNAL_OES);
-      return type == GL_SAMPLER_2D ? bound_texture_2d :
-          (type == GL_SAMPLER_EXTERNAL_OES ? bound_texture_external_oes :
-              bound_texture_cube_map);
+             type == GL_SAMPLER_EXTERNAL_OES || type == GL_SAMPLER_2D_RECT_ARB);
+      switch (type) {
+        case GL_SAMPLER_2D:
+          return bound_texture_2d;
+        case GL_SAMPLER_CUBE:
+          return bound_texture_cube_map;
+        case GL_SAMPLER_EXTERNAL_OES:
+          return bound_texture_external_oes;
+        case GL_SAMPLER_2D_RECT_ARB:
+          return bound_texture_rectangle_arb;
+      }
+
+      NOTREACHED();
+      return NULL;
     }
 
     void Unbind(TextureManager::TextureInfo* texture) {
       if (bound_texture_2d == texture) {
         bound_texture_2d = NULL;
       }
       if (bound_texture_cube_map == texture) {
         bound_texture_cube_map = NULL;
       }
       if (bound_texture_external_oes == texture) {
@@ skipping 137 matching lines @@
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLsizei width,
     GLsizei height,
     GLenum format,
     GLenum type,
     const void * data);
 
+  // Wrapper for TexImageIOSurface2DCHROMIUM.
+  void DoTexImageIOSurface2DCHROMIUM(
+    GLenum target,
+    GLsizei width,
+    GLsizei height,
+    GLuint io_surface_id,
+    GLuint plane);
+
   // Creates a ProgramInfo for the given program.
   ProgramManager::ProgramInfo* CreateProgramInfo(
       GLuint client_id, GLuint service_id) {
     return program_manager()->CreateProgramInfo(client_id, service_id);
   }
 
   // Gets the program info for the given program. Returns NULL if none exists.
   ProgramManager::ProgramInfo* GetProgramInfo(GLuint client_id) {
     return program_manager()->GetProgramInfo(client_id);
   }
@@ skipping 438 matching lines @@
       case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
       case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
       case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
         info = unit.bound_texture_cube_map;
         break;
       case GL_TEXTURE_EXTERNAL_OES:
         info = unit.bound_texture_external_oes;
         break;
-      // Note: If we ever support TEXTURE_RECTANGLE as a target, be sure to
-      // track |texture_| with the currently bound TEXTURE_RECTANGLE texture,
-      // because |texture_| is used by the FBO rendering mechanism for readback
-      // to the bits that get sent to the browser.
+      case GL_TEXTURE_RECTANGLE_ARB:
+        info = unit.bound_texture_rectangle_arb;
+        break;
       default:
         NOTREACHED();
         return NULL;
     }
     return info;
   }
 
   GLenum GetBindTargetForSamplerType(GLenum type) {
     DCHECK(type == GL_SAMPLER_2D || type == GL_SAMPLER_CUBE ||
-           type == GL_SAMPLER_EXTERNAL_OES);
-    return type == GL_SAMPLER_2D ? GL_TEXTURE_2D :
-        (type == GL_SAMPLER_EXTERNAL_OES ? GL_TEXTURE_EXTERNAL_OES :
-            GL_TEXTURE_CUBE_MAP);
+           type == GL_SAMPLER_EXTERNAL_OES || type == GL_SAMPLER_2D_RECT_ARB);
+    switch (type) {
+      case GL_SAMPLER_2D:
+        return GL_TEXTURE_2D;
+      case GL_SAMPLER_CUBE:
+        return GL_TEXTURE_CUBE_MAP;
+      case GL_SAMPLER_EXTERNAL_OES:
+        return GL_TEXTURE_EXTERNAL_OES;
+      case GL_SAMPLER_2D_RECT_ARB:
+        return GL_TEXTURE_RECTANGLE_ARB;
+    }
+
+    NOTREACHED();
+    return 0;
   }
 
   // Gets the framebuffer info for a particular target.
   FramebufferManager::FramebufferInfo* GetFramebufferInfoForTarget(
       GLenum target) {
     FramebufferManager::FramebufferInfo* info = NULL;
     switch (target) {
       case GL_FRAMEBUFFER:
       case GL_DRAW_FRAMEBUFFER:
         info = bound_draw_framebuffer_;
@@ skipping 27 matching lines @@
   // should be called.
   bool GetUniformSetup(
       GLuint program, GLint location,
       uint32 shm_id, uint32 shm_offset,
       error::Error* error, GLuint* service_id, void** result,
       GLenum* result_type);
 
   // Returns true if the context was just lost due to e.g. GL_ARB_robustness.
   bool WasContextLost();
 
+#if defined(OS_MACOSX)
+  void ReleaseIOSurfaceForTexture(GLuint texture_id);
+#endif
+
   // Generate a member function prototype for each command in an automated and
   // typesafe way.
   #define GLES2_CMD_OP(name) \
      Error Handle ## name(             \
        uint32 immediate_data_size,          \
        const gles2::name& args);            \
 
   GLES2_COMMAND_LIST(GLES2_CMD_OP)
 
   #undef GLES2_CMD_OP
@@ skipping 157 matching lines @@
   bool needs_glsl_built_in_function_emulation_;
 
   // These flags are used to override the state of the shared feature_info_
   // member.  Because the same FeatureInfo instance may be shared among many
   // contexts, the assumptions on the availablity of extensions in WebGL
   // contexts may be broken.  These flags override the shared state to preserve
   // WebGL semantics.
   bool force_webgl_glsl_validation_;
   bool derivatives_explicitly_enabled_;
 
+#if defined(OS_MACOSX)
+  typedef std::map<GLuint, CFTypeRef> TextureToIOSurfaceMap;
+  TextureToIOSurfaceMap texture_to_io_surface_map_;
+#endif
+
   DISALLOW_COPY_AND_ASSIGN(GLES2DecoderImpl);
 };
 
 ScopedGLErrorSuppressor::ScopedGLErrorSuppressor(GLES2DecoderImpl* decoder)
     : decoder_(decoder) {
   decoder_->CopyRealGLErrorsToWrapper();
 }
 
 ScopedGLErrorSuppressor::~ScopedGLErrorSuppressor() {
   decoder_->ClearRealGLErrors();
@@ skipping 441 matching lines @@
       new TextureUnit[group_->max_texture_units()]);
   for (uint32 tt = 0; tt < group_->max_texture_units(); ++tt) {
     glActiveTexture(GL_TEXTURE0 + tt);
     // We want the last bind to be 2D.
     TextureManager::TextureInfo* info;
     if (feature_info_->feature_flags().oes_egl_image_external) {
       info = texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_EXTERNAL_OES);
       texture_units_[tt].bound_texture_external_oes = info;
       glBindTexture(GL_TEXTURE_EXTERNAL_OES, info->service_id());
     }
+    if (feature_info_->feature_flags().arb_texture_rectangle) {
+      info = texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_RECTANGLE_ARB);
+      texture_units_[tt].bound_texture_rectangle_arb = info;
+      glBindTexture(GL_TEXTURE_RECTANGLE_ARB, info->service_id());
+    }
     info = texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_CUBE_MAP);
     texture_units_[tt].bound_texture_cube_map = info;
     glBindTexture(GL_TEXTURE_CUBE_MAP, info->service_id());
     info = texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_2D);
     texture_units_[tt].bound_texture_2d = info;
     glBindTexture(GL_TEXTURE_2D, info->service_id());
   }
   glActiveTexture(GL_TEXTURE0);
   CHECK_GL_ERROR();
 
@@ skipping 200 matching lines @@
   resources.MaxTextureImageUnits = group_->max_texture_image_units();
   resources.MaxFragmentUniformVectors =
       group_->max_fragment_uniform_vectors();
   resources.MaxDrawBuffers = 1;
 
   if (force_webgl_glsl_validation_) {
     resources.OES_standard_derivatives = derivatives_explicitly_enabled_;
   } else {
     resources.OES_standard_derivatives =
         feature_info_->feature_flags().oes_standard_derivatives ? 1 : 0;
+    resources.ARB_texture_rectangle =
+        feature_info_->feature_flags().arb_texture_rectangle ? 1 : 0;
   }
 
   vertex_translator_.reset(new ShaderTranslator);
   ShShaderSpec shader_spec = force_webgl_glsl_validation_ ||
       feature_info_->feature_flags().chromium_webglsl ?
           SH_WEBGL_SPEC : SH_GLES2_SPEC;
   ShaderTranslatorInterface::GlslImplementationType implementation_type =
       gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2 ?
           ShaderTranslatorInterface::kGlslES : ShaderTranslatorInterface::kGlsl;
   ShaderTranslatorInterface::GlslBuiltInFunctionBehavior function_behavior =
@@ skipping 183 matching lines @@
         }
       } else {
         if (bound_draw_framebuffer_) {
           bound_draw_framebuffer_->UnbindTexture(GL_FRAMEBUFFER, texture);
         }
       }
       GLuint service_id = texture->service_id();
       if (texture->IsStreamTexture() && stream_texture_manager_) {
         stream_texture_manager_->DestroyStreamTexture(service_id);
       }
+#if defined(OS_MACOSX)
+      if (texture->target() == GL_TEXTURE_RECTANGLE_ARB) {
+        ReleaseIOSurfaceForTexture(service_id);
+      }
+#endif
       glDeleteTextures(1, &service_id);
       RemoveTextureInfo(client_ids[ii]);
     }
   }
 }
 
 // }  // anonymous namespace
 
 bool GLES2DecoderImpl::MakeCurrent() {
   bool result = context_.get() ? context_->MakeCurrent(surface_.get()) : false;
@@ skipping 292 matching lines @@
 
   offscreen_target_frame_buffer_.reset();
   offscreen_target_color_texture_.reset();
   offscreen_target_color_render_buffer_.reset();
   offscreen_target_depth_render_buffer_.reset();
   offscreen_target_stencil_render_buffer_.reset();
   offscreen_saved_frame_buffer_.reset();
   offscreen_saved_color_texture_.reset();
   offscreen_resolved_frame_buffer_.reset();
   offscreen_resolved_color_texture_.reset();
+
+#if defined(OS_MACOSX)
+  for (TextureToIOSurfaceMap::iterator it = texture_to_io_surface_map_.begin();
+       it != texture_to_io_surface_map_.end(); ++it) {
+    CFRelease(it->second);
+  }
+  texture_to_io_surface_map_.clear();
+#endif
 }
 
 bool GLES2DecoderImpl::SetParent(GLES2Decoder* new_parent,
                                  uint32 new_parent_texture_id) {
   if (!offscreen_saved_color_texture_.get())
     return false;
 
   // Remove the saved frame buffer mapping from the parent decoder. The
   // parent pointer is a weak pointer so it will be null if the parent has
   // already been destroyed.
@@ skipping 493 matching lines @@
     case GL_TEXTURE_EXTERNAL_OES:
       unit.bound_texture_external_oes = info;
       if (info->IsStreamTexture()) {
         DCHECK(stream_texture_manager_);
         StreamTexture* stream_tex =
             stream_texture_manager_->LookupStreamTexture(info->service_id());
         if (stream_tex)
           stream_tex->Update();
       }
       break;
+    case GL_TEXTURE_RECTANGLE_ARB:
+      unit.bound_texture_rectangle_arb = info;
+      break;
     default:
       NOTREACHED();  // Validation should prevent us getting here.
       break;
   }
 }
 
 void GLES2DecoderImpl::DoDisableVertexAttribArray(GLuint index) {
   if (vertex_attrib_manager_.Enable(index, false)) {
     if (index != 0 ||
         gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2) {
@@ skipping 322 matching lines @@
         if (unit.bound_texture_external_oes) {
           GLuint client_id = 0;
           texture_manager()->GetClientId(
               unit.bound_texture_external_oes->service_id(), &client_id);
           *params = client_id;
         } else {
           *params = 0;
         }
       }
       return true;
+    case GL_TEXTURE_BINDING_RECTANGLE_ARB:
+      *num_written = 1;
+      if (params) {
+        TextureUnit& unit = texture_units_[active_texture_unit_];
+        if (unit.bound_texture_rectangle_arb) {
+          GLuint client_id = 0;
+          texture_manager()->GetClientId(
+              unit.bound_texture_rectangle_arb->service_id(), &client_id);
+          *params = client_id;
+        } else {
+          *params = 0;
+        }
+      }
+      return true;
     default:
       *num_written = util_.GLGetNumValuesReturned(pname);
       return false;
   }
 }
 
 bool GLES2DecoderImpl::GetNumValuesReturnedForGLGet(
     GLenum pname, GLsizei* num_values) {
   return GetHelper(pname, NULL, num_values);
 }
@@ skipping 3993 matching lines @@
     info->SetStreamTexture(false);
     texture_manager()->SetInfoTarget(feature_info_, info, 0);
   } else {
     SetGLError(GL_INVALID_VALUE,
                "glDestroyStreamTextureCHROMIUM: bad texture id.");
   }
 
   return error::kNoError;
 }
 
+#if defined(OS_MACOSX)
+void GLES2DecoderImpl::ReleaseIOSurfaceForTexture(GLuint texture_id) {
+  TextureToIOSurfaceMap::iterator it = texture_to_io_surface_map_.find(
+      texture_id);
+  if (it != texture_to_io_surface_map_.end()) {

[greggman, 2011/11/28 22:58:11]

I don't know the use case but is there any issue with texture_to_io_surface_map
being in GLES2DecoderImpl instead of ContextGroup or TextureManager or
IOSurfaceManager? If you have a shared resource then you can delete the texture
in another context and this map will be invalid.

I know that you probably aren't using in in that way but it seems wrong to make
the decoder brittle and at the mercy of the clients not using it correctly.

+    // Found a previous IOSurface bound to this texture; release it.
+    CFTypeRef surface = it->second;
+    CFRelease(surface);
+    texture_to_io_surface_map_.erase(it);
+  }
+}
+#endif
+
+void GLES2DecoderImpl::DoTexImageIOSurface2DCHROMIUM(
+    GLenum target, GLsizei width, GLsizei height,
+    GLuint io_surface_id, GLuint plane) {
+#if defined(OS_MACOSX)
+  if (gfx::GetGLImplementation() != gfx::kGLImplementationDesktopGL) {
+    SetGLError(GL_INVALID_OPERATION,
+               "glTexImageIOSurface2DCHROMIUM: only supported on desktop GL.");
+    return;
+  }
+
+  IOSurfaceSupport* surface_support = IOSurfaceSupport::Initialize();
+  if (!surface_support) {
+    SetGLError(GL_INVALID_OPERATION,
+               "glTexImageIOSurface2DCHROMIUM: only supported on 10.6.");
+    return;
+  }
+
+  if (target != GL_TEXTURE_RECTANGLE_ARB) {
+    // This might be supported in the future, and if we could require
+    // support for binding an IOSurface to a NPOT TEXTURE_2D texture, we
+    // could delete a lot of code. For now, perform strict validation so we
+    // know what's going on.
+    SetGLError(
+        GL_INVALID_OPERATION,
+        "glTexImageIOSurface2DCHROMIUM: requires TEXTURE_RECTANGLE_ARB target");
+    return;
+  }
+
+  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  if (!info) {
+    SetGLError(GL_INVALID_OPERATION,
+               "glTexImageIOSurface2DCHROMIUM: no rectangle texture bound");
+    return;
+  }
+  if (info == texture_manager()->GetDefaultTextureInfo(target)) {

[greggman, 2011/11/28 22:58:11]

This check is not needed. GetTextureInfoForTarget will never return an info for
the default texture.

+    // Maybe this is conceptually valid, but disallow it to avoid accidents.
+    SetGLError(GL_INVALID_OPERATION,
+               "glTexImageIOSurface2DCHROMIUM: can't bind default texture");
+    return;
+  }
+
+  // Look up the new IOSurface. Note that because of asynchrony
+  // between processes this might fail; during live resizing the
+  // plugin process might allocate and release an IOSurface before
+  // this process gets a chance to look it up. Hold on to any old
+  // IOSurface in this case.
+  CFTypeRef surface = surface_support->IOSurfaceLookup(io_surface_id);
+  if (!surface) {
+    SetGLError(GL_INVALID_OPERATION,
+               "glTexImageIOSurface2DCHROMIUM: no IOSurface with the given ID");
+    return;
+  }
+
+  // Release any IOSurface previously bound to this texture.
+  ReleaseIOSurfaceForTexture(info->service_id());
+
+  // Make sure we release the IOSurface even if CGLTexImageIOSurface2D fails.
+  texture_to_io_surface_map_.insert(
+      std::make_pair(info->service_id(), surface));
+
+  CGLContextObj context =
+      static_cast<CGLContextObj>(context_->GetHandle());
+
+  CGLError err = surface_support->CGLTexImageIOSurface2D(
+      context,
+      target,
+      GL_RGBA,
+      width,
+      height,
+      GL_BGRA,
+      GL_UNSIGNED_INT_8_8_8_8_REV,
+      surface,
+      plane);
+
+  if (err != kCGLNoError) {
+    SetGLError(
+        GL_INVALID_OPERATION,
+        "glTexImageIOSurface2DCHROMIUM: error in CGLTexImageIOSurface2D");
+    return;
+  }
+
+  texture_manager()->SetLevelInfo(
+      feature_info_, info,
+      target, 0, GL_RGBA, width, height, 1, 0,
+      GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, true);

[greggman, 2011/11/28 22:58:11]

Do you need to check in feature_info that GL_BGRA support exists before turning
on this feature? Otherwise, passing in GL_BGRA here will mean you can get enums
from glGetIntergerv that won't validate later

Same with GL_UNSIGNED_INT_8_8_8_8_REV, it's not been added to the validators.

+
+#else
+  SetGLError(GL_INVALID_OPERATION,
+             "glTexImageIOSurface2DCHROMIUM: not supported.");
+#endif
+}
+
+
 // 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 "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu