Support glCopyTex[Sub]Image to LUMA formats on the core profile.

gpu/command_buffer/service/texture_manager.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/texture_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 254 matching lines @@
   // are initialized in the constructor, it should never be modified later.
   std::set<FormatType, FormatTypeCompare> supported_combinations_;
 };
 
 static const Texture::CompatibilitySwizzle kSwizzledFormats[] = {
     {GL_ALPHA, GL_RED, GL_ZERO, GL_ZERO, GL_ZERO, GL_RED},
     {GL_LUMINANCE, GL_RED, GL_RED, GL_RED, GL_RED, GL_ONE},
     {GL_LUMINANCE_ALPHA, GL_RG, GL_RED, GL_RED, GL_RED, GL_GREEN},
 };
 
+// static
 const Texture::CompatibilitySwizzle* GetCompatibilitySwizzle(GLenum format) {
   size_t count = arraysize(kSwizzledFormats);
   for (size_t i = 0; i < count; ++i) {
     if (kSwizzledFormats[i].format == format)
       return &kSwizzledFormats[i];
   }
   return nullptr;
 }
 
 GLenum GetSwizzleForChannel(GLenum channel,
@@ skipping 2383 matching lines @@
   if (full_image && !texture_state->texsubimage_faster_than_teximage &&
       !texture->IsImmutable() && !texture->HasImages()) {
     ScopedTextureUploadTimer timer(texture_state);
     GLenum internal_format;
     GLenum tex_type;
     texture->GetLevelType(args.target, args.level, &tex_type, &internal_format);
     // NOTE: In OpenGL ES 2/3 border is always zero. If that changes we'll need
     // to look it up.
     if (args.command_type == DoTexSubImageArguments::kTexSubImage3D) {
       glTexImage3D(args.target, args.level, internal_format, args.width,
-                   args.height, args.depth, 0, AdjustTexFormat(args.format),
-                   args.type, args.pixels);
+                   args.height, args.depth, 0,
+                   AdjustTexFormat(feature_info_.get(), args.format), args.type,
+                   args.pixels);
     } else {
-      glTexImage2D(args.target, args.level,
-                   AdjustTexInternalFormat(internal_format), args.width,
-                   args.height, 0, AdjustTexFormat(args.format), args.type,
-                   args.pixels);
+      glTexImage2D(
+          args.target, args.level,
+          AdjustTexInternalFormat(feature_info_.get(), internal_format),
+          args.width, args.height, 0,
+          AdjustTexFormat(feature_info_.get(), args.format), args.type,
+          args.pixels);
     }
   } else {
     ScopedTextureUploadTimer timer(texture_state);
     if (args.command_type == DoTexSubImageArguments::kTexSubImage3D) {
       glTexSubImage3D(args.target, args.level, args.xoffset, args.yoffset,
                       args.zoffset, args.width, args.height, args.depth,
-                      AdjustTexFormat(args.format), args.type, args.pixels);
+                      AdjustTexFormat(feature_info_.get(), args.format),
+                      args.type, args.pixels);
     } else {
       glTexSubImage2D(args.target, args.level, args.xoffset, args.yoffset,
-                      args.width, args.height, AdjustTexFormat(args.format),
+                      args.width, args.height,
+                      AdjustTexFormat(feature_info_.get(), args.format),
                       args.type, args.pixels);
     }
   }
 }
 
 void TextureManager::DoTexSubImageWithAlignmentWorkaround(
     DecoderTextureState* texture_state,
     ContextState* state,
     const DoTexSubImageArguments& args) {
   DCHECK(state->bound_pixel_unpack_buffer.get());
   DCHECK(args.width > 0 && args.height > 0 && args.depth > 0);
 
   ScopedTextureUploadTimer timer(texture_state);
   uint32_t offset = ToGLuint(args.pixels);
   if (args.command_type == DoTexSubImageArguments::kTexSubImage2D) {
     PixelStoreParams params = state->GetUnpackParams(ContextState::k2D);
     if (args.height > 1) {
       glTexSubImage2D(args.target, args.level, args.xoffset, args.yoffset,
                       args.width, args.height - 1,
-                      AdjustTexFormat(args.format), args.type, args.pixels);
+                      AdjustTexFormat(feature_info_.get(), args.format),
+                      args.type, args.pixels);
       GLint actual_width = state->unpack_row_length > 0 ?
           state->unpack_row_length : args.width;
       uint32_t size;
       uint32_t padding;
       // No need to worry about integer overflow here.
       GLES2Util::ComputeImageDataSizesES3(actual_width, args.height - 1, 1,
                                           args.format, args.type,
                                           params,
                                           &size,
                                           nullptr, nullptr, nullptr,
                                           &padding);
       DCHECK_EQ(args.padding, padding);
       // Last row should be padded, not unpadded.
       offset += size + padding;
     }
     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
     glTexSubImage2D(args.target, args.level, args.xoffset,
-                    args.yoffset + args.height - 1,
-                    args.width, 1, AdjustTexFormat(args.format), args.type,
-                    reinterpret_cast<const void *>(offset));
+                    args.yoffset + args.height - 1, args.width, 1,
+                    AdjustTexFormat(feature_info_.get(), args.format),
+                    args.type, reinterpret_cast<const void*>(offset));
     glPixelStorei(GL_UNPACK_ALIGNMENT, state->unpack_alignment);
     {
       uint32_t size;
       GLES2Util::ComputeImageDataSizesES3(args.width, 1, 1,
                                           args.format, args.type,
                                           params,
                                           &size,
                                           nullptr, nullptr, nullptr, nullptr);
       offset += size;
     }
   } else {  // kTexSubImage3D
     PixelStoreParams params = state->GetUnpackParams(ContextState::k3D);
     GLint actual_width = state->unpack_row_length > 0 ?
         state->unpack_row_length : args.width;
     if (args.depth > 1) {
       glTexSubImage3D(args.target, args.level, args.xoffset, args.yoffset,
                       args.zoffset, args.width, args.height, args.depth - 1,
-                      AdjustTexFormat(args.format), args.type, args.pixels);
+                      AdjustTexFormat(feature_info_.get(), args.format),
+                      args.type, args.pixels);
       GLint actual_height = state->unpack_image_height > 0 ?
           state->unpack_image_height : args.height;
       uint32_t size;
       uint32_t padding;
       // No need to worry about integer overflow here.
       GLES2Util::ComputeImageDataSizesES3(actual_width, actual_height,
                                           args.depth - 1,
                                           args.format, args.type,
                                           params,
                                           &size,
                                           nullptr, nullptr, nullptr,
                                           &padding);
       DCHECK_EQ(args.padding, padding);
       // Last row should be padded, not unpadded.
       offset += size + padding;
     }
     if (args.height > 1) {
       glTexSubImage3D(args.target, args.level, args.xoffset, args.yoffset,
                       args.zoffset + args.depth - 1, args.width,
-                      args.height - 1, 1, AdjustTexFormat(args.format),
+                      args.height - 1, 1,
+                      AdjustTexFormat(feature_info_.get(), args.format),
                       args.type, reinterpret_cast<const void*>(offset));
       uint32_t size;
       uint32_t padding;
       // No need to worry about integer overflow here.
       GLES2Util::ComputeImageDataSizesES3(actual_width, args.height - 1, 1,
                                           args.format, args.type,
                                           params,
                                           &size,
                                           nullptr, nullptr, nullptr,
                                           &padding);
       DCHECK_EQ(args.padding, padding);
       // Last row should be padded, not unpadded.
       offset += size + padding;
     }
     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
     glTexSubImage3D(args.target, args.level, args.xoffset,
                     args.yoffset + args.height - 1,
-                    args.zoffset + args.depth - 1,
-                    args.width, 1, 1, AdjustTexFormat(args.format), args.type,
-                    reinterpret_cast<const void *>(offset));
+                    args.zoffset + args.depth - 1, args.width, 1, 1,
+                    AdjustTexFormat(feature_info_.get(), args.format),
+                    args.type, reinterpret_cast<const void*>(offset));
     glPixelStorei(GL_UNPACK_ALIGNMENT, state->unpack_alignment);
     {
       uint32_t size;
       GLES2Util::ComputeImageDataSizesES3(args.width, 1, 1,
                                           args.format, args.type,
                                           params,
                                           &size,
                                           nullptr, nullptr, nullptr, nullptr);
       offset += size;
     }
   }
   DCHECK_EQ(ToGLuint(args.pixels) + args.pixels_size, offset);
 }
 
 void TextureManager::DoTexSubImageRowByRowWorkaround(
     DecoderTextureState* texture_state,
     ContextState* state,
     const DoTexSubImageArguments& args,
     const PixelStoreParams& unpack_params) {
   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
   glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
   DCHECK_EQ(0, state->unpack_skip_pixels);
   DCHECK_EQ(0, state->unpack_skip_rows);
   DCHECK_EQ(0, state->unpack_skip_images);
 
-  GLenum format = AdjustTexFormat(args.format);
+  GLenum format = AdjustTexFormat(feature_info_.get(), args.format);
 
   GLsizei row_bytes = unpack_params.row_length *
                       GLES2Util::ComputeImageGroupSize(format, args.type);
   GLsizei alignment_diff = row_bytes % unpack_params.alignment;
   if (alignment_diff != 0) {
     row_bytes += unpack_params.alignment - alignment_diff;
   }
   DCHECK_EQ(0, row_bytes % unpack_params.alignment);
   if (args.command_type == DoTexSubImageArguments::kTexSubImage3D) {
     GLsizei image_height = args.height;
@@ skipping 20 matching lines @@
       glTexSubImage2D(args.target, args.level, args.xoffset, row + args.yoffset,
                       args.width, 1, format, args.type, row_pixels);
     }
   }
 
   // Restore unpack state
   glPixelStorei(GL_UNPACK_ALIGNMENT, unpack_params.alignment);
   glPixelStorei(GL_UNPACK_ROW_LENGTH, unpack_params.row_length);
 }
 
-GLenum TextureManager::AdjustTexInternalFormat(GLenum format) const {
-  if (feature_info_->gl_version_info().is_desktop_core_profile) {
+// static
+GLenum TextureManager::AdjustTexInternalFormat(
+    const gles2::FeatureInfo* feature_info,
+    GLenum format) {
+  if (feature_info->gl_version_info().is_desktop_core_profile) {
     const Texture::CompatibilitySwizzle* swizzle =
         GetCompatibilitySwizzle(format);
     if (swizzle)
       return swizzle->dest_format;
   }
   return format;
 }
 
-GLenum TextureManager::AdjustTexFormat(GLenum format) const {
+// static
+GLenum TextureManager::AdjustTexFormat(const gles2::FeatureInfo* feature_info,
+                                       GLenum format) {
   // TODO(bajones): GLES 3 allows for internal format and format to differ.
   // This logic may need to change as a result.
-  if (gl::GetGLImplementation() == gl::kGLImplementationDesktopGL) {
+  if (!feature_info->gl_version_info().is_es) {
     if (format == GL_SRGB_EXT)
       return GL_RGB;
     if (format == GL_SRGB_ALPHA_EXT)
       return GL_RGBA;
   }
-  if (feature_info_->gl_version_info().is_desktop_core_profile) {
+  if (feature_info->gl_version_info().is_desktop_core_profile) {
     const Texture::CompatibilitySwizzle* swizzle =
         GetCompatibilitySwizzle(format);
     if (swizzle)
       return swizzle->dest_format;
   }
   return format;
 }
 
 void TextureManager::DoTexImage(
     DecoderTextureState* texture_state,
@@ skipping 38 matching lines @@
   if (texture_state->texsubimage_faster_than_teximage &&
       level_is_same && args.pixels && !unpack_buffer_bound) {
     {
       ScopedTextureUploadTimer timer(texture_state);
       if (args.command_type == DoTexImageArguments::kTexImage3D) {
         glTexSubImage3D(args.target, args.level, 0, 0, 0,
                         args.width, args.height, args.depth,
                         args.format, args.type, args.pixels);
       } else {
         glTexSubImage2D(args.target, args.level, 0, 0, args.width, args.height,
-                        AdjustTexFormat(args.format), args.type, args.pixels);
+                        AdjustTexFormat(feature_info_.get(), args.format),
+                        args.type, args.pixels);
       }
     }
     SetLevelInfo(texture_ref, args.target, args.level, args.internal_format,
                  args.width, args.height, args.depth, args.border, args.format,
                  args.type, gfx::Rect(args.width, args.height));
     texture_state->tex_image_failed = false;
     return;
   }
 
   ERRORSTATE_COPY_REAL_GL_ERRORS_TO_WRAPPER(error_state, function_name);
   {
     ScopedTextureUploadTimer timer(texture_state);
     if (args.command_type == DoTexImageArguments::kTexImage3D) {
       glTexImage3D(args.target, args.level, args.internal_format, args.width,
                    args.height, args.depth, args.border, args.format,
                    args.type, args.pixels);
     } else {
-      glTexImage2D(args.target, args.level,
-                   AdjustTexInternalFormat(args.internal_format), args.width,
-                   args.height, args.border, AdjustTexFormat(args.format),
-                   args.type, args.pixels);
+      glTexImage2D(
+          args.target, args.level,
+          AdjustTexInternalFormat(feature_info_.get(), args.internal_format),
+          args.width, args.height, args.border,
+          AdjustTexFormat(feature_info_.get(), args.format), args.type,
+          args.pixels);
     }
   }
   GLenum error = ERRORSTATE_PEEK_GL_ERROR(error_state, function_name);
   if (args.command_type == DoTexImageArguments::kTexImage3D) {
     UMA_HISTOGRAM_CUSTOM_ENUMERATION("GPU.Error.TexImage3D", error,
         GetAllGLErrors());
   } else {
     UMA_HISTOGRAM_CUSTOM_ENUMERATION("GPU.Error.TexImage2D", error,
         GetAllGLErrors());
   }
@@ skipping 366 matching lines @@
 uint32_t TextureManager::GetServiceIdGeneration() const {
   return current_service_id_generation_;
 }
 
 void TextureManager::IncrementServiceIdGeneration() {
   current_service_id_generation_++;
 }
 
 }  // namespace gles2
 }  // namespace gpu