Adds support for the GL_ANGLE_texture_usage and GL_EXT_texture_storage

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>
@@ skipping 733 matching lines @@
     const void * data);
 
   // Wrapper for TexImageIOSurface2DCHROMIUM.
   void DoTexImageIOSurface2DCHROMIUM(
     GLenum target,
     GLsizei width,
     GLsizei height,
     GLuint io_surface_id,
     GLuint plane);
 
+  // Wrapper for TexStorage2DEXT.
+  void DoTexStorage2DEXT(
+    GLenum target,
+    GLint levels,
+    GLenum internal_format,
+    GLsizei width,
+    GLsizei height);
+
   // 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 2458 matching lines @@
   if (vertex_attrib_manager_.Enable(index, true)) {
     glEnableVertexAttribArray(index);
   } else {
     SetGLError(GL_INVALID_VALUE,
                "glEnableVertexAttribArray: index out of range");
   }
 }
 
 void GLES2DecoderImpl::DoGenerateMipmap(GLenum target) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
-  if (!info || !texture_manager()->MarkMipmapsGenerated(feature_info_, info)) {
+  if (!info ||
+      !texture_manager()->MarkMipmapsGenerated(feature_info_, info, true)) {
     SetGLError(GL_INVALID_OPERATION,
                "glGenerateMipmaps: Can not generate mips for npot textures");
     return;
   }
   // Workaround for Mac driver bug. In the large scheme of things setting
   // glTexParamter twice for glGenerateMipmap is probably not a lage performance
   // hit so there's probably no need to make this conditional. The bug appears
   // to be that if the filtering mode is set to something that doesn't require
   // mipmaps for rendering, or is never set to something other than the default,
   // then glGenerateMipmap misbehaves.
@@ skipping 2935 matching lines @@
     SetGLError(GL_INVALID_VALUE,
                "glCompressedTexImage2D: dimensions out of range");
     return error::kNoError;
   }
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE,
                "glCompressedTexImage2D: unknown texture target");
     return error::kNoError;
   }
+  if (info->IsImmutable()) {
+    SetGLError(GL_INVALID_OPERATION,
+               "glCompressedTexImage2D: texture is immutable");
+    return error::kNoError;
+  }
   scoped_array<int8> zero;
   if (!data) {
     zero.reset(new int8[image_size]);
     memset(zero.get(), 0, image_size);
     data = zero.get();
   }
   CopyRealGLErrorsToWrapper();
   glCompressedTexImage2D(
       target, level, internal_format, width, height, border, image_size, data);
   GLenum error = PeekGLError();
@@ skipping 155 matching lines @@
     SetGLError(GL_INVALID_VALUE, "glTexImage2D: dimensions out of range");
     return error::kNoError;
   }
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
                "glTexImage2D: unknown texture for target");
     return error::kNoError;
   }
 
+  if (info->IsImmutable()) {
+    SetGLError(GL_INVALID_OPERATION,
+               "glTexImage2D: texture is immutable");
+    return error::kNoError;
+  }
+
   GLsizei tex_width = 0;
   GLsizei tex_height = 0;
   GLenum tex_type = 0;
   GLenum tex_format = 0;
   bool level_is_same =
       info->GetLevelSize(target, level, &tex_width, &tex_height) &&
       info->GetLevelType(target, level, &tex_type, &tex_format) &&
       width == tex_width && height == tex_height &&
       type == tex_type && format == tex_format;
 
@@ skipping 154 matching lines @@
   GLint y,
   GLsizei width,
   GLsizei height,
   GLint border) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
                "glCopyTexImage2D: unknown texture for target");
     return;
   }
+  if (info->IsImmutable()) {
+    SetGLError(GL_INVALID_OPERATION,
+               "glCopyTexImage2D: texture is immutable");
+  }
   if (!texture_manager()->ValidForTarget(
         feature_info_, target, level, width, height, 1) ||
       border != 0) {
     SetGLError(GL_INVALID_VALUE, "glCopyTexImage2D: dimensions out of range");
     return;
   }
 
   // Check we have compatible formats.
   GLenum read_format = GetBoundReadFrameBufferInternalFormat();
   uint32 channels_exist = GLES2Util::GetChannelsForFormat(read_format);
@@ skipping 175 matching lines @@
   }
 
   if (!info->ValidForTexture(
           target, level, xoffset, yoffset, width, height, format, type)) {
     SetGLError(GL_INVALID_VALUE,
                "glTexSubImage2D: bad dimensions.");
     return;
   }
 
   // See if we can call glTexImage2D instead since it appears to be faster.
-  if (teximage2d_faster_than_texsubimage2d_ && xoffset == 0 && yoffset == 0) {
+  if (teximage2d_faster_than_texsubimage2d_ && xoffset == 0 && yoffset == 0 &&
+      !info->IsImmutable()) {
     GLsizei tex_width = 0;
     GLsizei tex_height = 0;
     bool ok = info->GetLevelSize(target, level, &tex_width, &tex_height);
     DCHECK(ok);
     if (width == tex_width && height == tex_height) {
       // NOTE: In OpenGL ES 2.0 border is always zero and format is always the
       // same as internal_foramt. If that changes we'll need to look them up.
       WrappedTexImage2D(
           target, level, format, width, height, 0, format, type, data);
       texture_manager()->SetLevelCleared(info, target, level);
@@ skipping 934 matching lines @@
       feature_info_, info,
       target, 0, GL_RGBA, width, height, 1, 0,
       GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, true);
 
 #else
   SetGLError(GL_INVALID_OPERATION,
              "glTexImageIOSurface2DCHROMIUM: not supported.");
 #endif
 }
 
+static GLenum ExtractFormatFromStorageFormat(GLenum internalformat) {
+  switch (internalformat) {
+    case GL_RGB565:
+      return GL_RGB;
+    case GL_RGBA4:
+      return GL_RGBA;
+    case GL_RGB5_A1:
+      return GL_RGBA;
+    case GL_RGB8_OES:
+      return GL_RGB;
+    case GL_RGBA8_OES:
+      return GL_RGBA;
+    case GL_LUMINANCE8_ALPHA8_EXT:
+      return GL_LUMINANCE_ALPHA;
+    case GL_LUMINANCE8_EXT:
+      return GL_LUMINANCE;
+    case GL_ALPHA8_EXT:
+      return GL_ALPHA;
+    case GL_RGBA32F_EXT:
+      return GL_RGBA;
+    case GL_RGB32F_EXT:
+      return GL_RGB;
+    case GL_ALPHA32F_EXT:
+      return GL_ALPHA;
+    case GL_LUMINANCE32F_EXT:
+      return GL_LUMINANCE;
+    case GL_LUMINANCE_ALPHA32F_EXT:
+      return GL_LUMINANCE_ALPHA;
+    case GL_RGBA16F_EXT:
+      return GL_RGBA;
+    case GL_RGB16F_EXT:
+      return GL_RGB;
+    case GL_ALPHA16F_EXT:
+      return GL_ALPHA;
+    case GL_LUMINANCE16F_EXT:
+      return GL_LUMINANCE;
+    case GL_LUMINANCE_ALPHA16F_EXT:
+      return GL_LUMINANCE_ALPHA;
+    case GL_BGRA8_EXT:
+      return GL_BGRA_EXT;
+    default:
+      return GL_NONE;
+  }
+}
+
+static GLenum ExtractTypeFromStorageFormat(GLenum internalformat) {
+  switch (internalformat) {
+    case GL_RGB565:
+      return GL_UNSIGNED_SHORT_5_6_5;
+    case GL_RGBA4:
+      return GL_UNSIGNED_SHORT_4_4_4_4;
+    case GL_RGB5_A1:
+      return GL_UNSIGNED_SHORT_5_5_5_1;
+    case GL_RGB8_OES:
+      return GL_UNSIGNED_BYTE;
+    case GL_RGBA8_OES:
+      return GL_UNSIGNED_BYTE;
+    case GL_LUMINANCE8_ALPHA8_EXT:
+      return GL_UNSIGNED_BYTE;
+    case GL_LUMINANCE8_EXT:
+      return GL_UNSIGNED_BYTE;
+    case GL_ALPHA8_EXT:
+      return GL_UNSIGNED_BYTE;
+    case GL_RGBA32F_EXT:
+      return GL_FLOAT;
+    case GL_RGB32F_EXT:
+      return GL_FLOAT;
+    case GL_ALPHA32F_EXT:
+      return GL_FLOAT;
+    case GL_LUMINANCE32F_EXT:
+      return GL_FLOAT;
+    case GL_LUMINANCE_ALPHA32F_EXT:
+      return GL_FLOAT;
+    case GL_RGBA16F_EXT:
+      return GL_HALF_FLOAT_OES;
+    case GL_RGB16F_EXT:
+      return GL_HALF_FLOAT_OES;
+    case GL_ALPHA16F_EXT:
+      return GL_HALF_FLOAT_OES;
+    case GL_LUMINANCE16F_EXT:
+      return GL_HALF_FLOAT_OES;
+    case GL_LUMINANCE_ALPHA16F_EXT:
+      return GL_HALF_FLOAT_OES;
+    case GL_BGRA8_EXT:
+      return GL_UNSIGNED_BYTE;
+    default:
+      return GL_NONE;
+  }
+}
+
+void GLES2DecoderImpl::DoTexStorage2DEXT(
+  GLenum target,
+  GLint levels,
+  GLenum internal_format,
+  GLsizei width,
+  GLsizei height) {
+  if (!texture_manager()->ValidForTarget(
+        feature_info_, target, 0, width, height, 1) ||
+      TextureManager::ComputeMipMapCount(width, height, 1) < levels) {
+    SetGLError(GL_INVALID_VALUE, "glTexStorage2DEXT: dimensions out of range");
+    return;
+  }
+  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  if (!info) {
+    SetGLError(GL_INVALID_OPERATION,
+               "glTexStorage2DEXT: unknown texture for target");
+    return;
+  }
+  if (info->IsAttachedToFramebuffer()) {
+    state_dirty_ = true;
+  }
+  if (info->IsImmutable()) {
+    SetGLError(GL_INVALID_OPERATION,
+               "glTexStorage2DEXT: texture is immutable");
+    return;
+  }
+  CopyRealGLErrorsToWrapper();
+  glTexStorage2DEXT(target, levels, internal_format, width, height);
+  GLenum error = PeekGLError();
+  if (error == GL_NO_ERROR) {
+    GLenum format = ExtractFormatFromStorageFormat(internal_format);
+    GLenum type = ExtractTypeFromStorageFormat(internal_format);
+    texture_manager()->SetLevelInfo(
+        feature_info_, info,
+        target, 0, format, width, height, 1, 0, format, type,
+        false);
+    texture_manager()->MarkMipmapsGenerated(feature_info_, info, false);
+    info->SetImmutable(true);
+  }
+
+}
 
 // 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