Support level > 0 for CopyTextureCHROMIUM extension

gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.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_copy_texture_chromium.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 494 matching lines @@
 #endif
 }
 
 void DeleteShader(GLuint shader) {
   if (shader)
     glDeleteShader(shader);
 }
 
 bool BindFramebufferTexture2D(GLenum target,
                               GLuint texture_id,
+                              GLint level,
                               GLuint framebuffer) {
   DCHECK(target == GL_TEXTURE_2D || target == GL_TEXTURE_RECTANGLE_ARB);
   glActiveTexture(GL_TEXTURE0);
   glBindTexture(target, texture_id);
   // NVidia drivers require texture settings to be a certain way
   // or they won't report FRAMEBUFFER_COMPLETE.
+  if (level > 0)
+    glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, level);

[Zhenyao Mo, 2017/01/10 20:11:22]

Do we recover this parameter afterwards?

[qiankun, 2017/01/11 10:58:21]

I added the recover in decoder->RestoreTextureState. I wrongly thought it was
there before.

   glTexParameterf(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameterf(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, framebuffer);
   glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target,
-                            texture_id, 0);
+                            texture_id, level);
+  DCHECK(glGetError() == GL_NO_ERROR);

[Zhenyao Mo, 2017/01/10 20:11:22]

This is wrong. It might swallow a GL error from previous command in debug mode.

[qiankun, 2017/01/11 10:58:21]

Remove this DCHECK.

 
 #ifndef NDEBUG
   GLenum fb_status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
   if (GL_FRAMEBUFFER_COMPLETE != fb_status) {
     DLOG(ERROR) << "CopyTextureCHROMIUM: Incomplete framebuffer.";
     return false;
   }
 #endif
   return true;
 }
 
 void DoCopyTexImage2D(const gpu::gles2::GLES2Decoder* decoder,
                       GLenum source_target,
                       GLuint source_id,
+                      GLint source_level,
                       GLenum dest_target,
                       GLuint dest_id,
+                      GLint dest_level,
                       GLenum dest_internal_format,
                       GLsizei width,
                       GLsizei height,
                       GLuint framebuffer) {
   DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), source_target);
   DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), dest_target);
-  if (BindFramebufferTexture2D(source_target, source_id, framebuffer)) {
+  DCHECK(source_level == 0 || decoder->GetFeatureInfo()->IsES3Capable());
+  if (BindFramebufferTexture2D(source_target, source_id, source_level,
+                               framebuffer)) {
     glBindTexture(dest_target, dest_id);
     glTexParameterf(dest_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameterf(dest_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexParameteri(dest_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(dest_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    glCopyTexImage2D(dest_target, 0 /* level */, dest_internal_format,
-                     0 /* x */, 0 /* y */, width, height, 0 /* border */);
+    glCopyTexImage2D(dest_target, dest_level, dest_internal_format, 0 /* x */,
+                     0 /* y */, width, height, 0 /* border */);
   }
 
   decoder->RestoreTextureState(source_id);
   decoder->RestoreTextureState(dest_id);
   decoder->RestoreTextureUnitBindings(0);
   decoder->RestoreActiveTexture();
   decoder->RestoreFramebufferBindings();
 }
 
 void DoCopyTexSubImage2D(const gpu::gles2::GLES2Decoder* decoder,
                          GLenum source_target,
                          GLuint source_id,
+                         GLint source_level,
                          GLenum dest_target,
                          GLuint dest_id,
+                         GLint dest_level,
                          GLint xoffset,
                          GLint yoffset,
                          GLint source_x,
                          GLint source_y,
                          GLsizei source_width,
                          GLsizei source_height,
                          GLuint framebuffer) {
   DCHECK(source_target == GL_TEXTURE_2D ||
          source_target == GL_TEXTURE_RECTANGLE_ARB);
   DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), dest_target);
-  if (BindFramebufferTexture2D(source_target, source_id, framebuffer)) {
+  DCHECK(source_level == 0 || decoder->GetFeatureInfo()->IsES3Capable());
+  if (BindFramebufferTexture2D(source_target, source_id, source_level,
+                               framebuffer)) {
     glBindTexture(dest_target, dest_id);
     glTexParameterf(dest_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameterf(dest_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexParameteri(dest_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(dest_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    glCopyTexSubImage2D(dest_target, 0 /* level */, xoffset, yoffset,
-                        source_x, source_y, source_width, source_height);
+    glCopyTexSubImage2D(dest_target, dest_level, xoffset, yoffset, source_x,
+                        source_y, source_width, source_height);
   }
 
   decoder->RestoreTextureState(source_id);
   decoder->RestoreTextureState(dest_id);
   decoder->RestoreTextureUnitBindings(0);
   decoder->RestoreActiveTexture();
   decoder->RestoreFramebufferBindings();
 }
 
 }  // namespace
@@ skipping 82 matching lines @@
   }
 
   glDeleteBuffersARB(1, &buffer_id_);
   buffer_id_ = 0;
 }
 
 void CopyTextureCHROMIUMResourceManager::DoCopyTexture(
     const gles2::GLES2Decoder* decoder,
     GLenum source_target,
     GLuint source_id,
+    GLint source_level,
     GLenum source_internal_format,
     GLenum dest_target,
     GLuint dest_id,
+    GLint dest_level,
     GLenum dest_internal_format,
     GLsizei width,
     GLsizei height,
     bool flip_y,
     bool premultiply_alpha,
     bool unpremultiply_alpha,
     CopyTextureMethod method) {
   bool premultiply_alpha_change = premultiply_alpha ^ unpremultiply_alpha;
 
   // GL_TEXTURE_RECTANGLE_ARB on FBO is supported by OpenGL, not GLES2,
   // so restrict this to GL_TEXTURE_2D.
   if (source_target == GL_TEXTURE_2D && dest_target == GL_TEXTURE_2D &&
       !flip_y && !premultiply_alpha_change && method == DIRECT_COPY) {
-    DoCopyTexImage2D(decoder,
-                     source_target,
-                     source_id,
-                     dest_target,
-                     dest_id,
-                     dest_internal_format,
-                     width,
-                     height,
-                     framebuffer_);
+    DoCopyTexImage2D(decoder, source_target, source_id, source_level,
+                     dest_target, dest_id, dest_level, dest_internal_format,
+                     width, height, framebuffer_);
     return;
   }
 
   GLuint dest_texture = dest_id;
   GLuint intermediate_texture = 0;
+  GLint original_dest_level = dest_level;
   if (method == DRAW_AND_COPY) {
     GLenum adjusted_internal_format =
         getIntermediateFormat(dest_internal_format);
     glGenTextures(1, &intermediate_texture);
     glBindTexture(dest_target, intermediate_texture);
     GLenum format = TextureManager::ExtractFormatFromStorageFormat(
         adjusted_internal_format);
     GLenum type =
         TextureManager::ExtractTypeFromStorageFormat(adjusted_internal_format);
 
     glTexImage2D(dest_target, 0, adjusted_internal_format, width, height, 0,
                  format, type, nullptr);
     dest_texture = intermediate_texture;
+    dest_level = 0;
     dest_internal_format = adjusted_internal_format;
   }
   // Use kIdentityMatrix if no transform passed in.
   DoCopyTextureWithTransform(
-      decoder, source_target, source_id, source_internal_format, dest_target,
-      dest_texture, dest_internal_format, width, height, flip_y,
-      premultiply_alpha, unpremultiply_alpha, kIdentityMatrix);
+      decoder, source_target, source_id, source_level, source_internal_format,
+      dest_target, dest_texture, dest_level, dest_internal_format, width,
+      height, flip_y, premultiply_alpha, unpremultiply_alpha, kIdentityMatrix);
 
   if (method == DRAW_AND_COPY) {
-    DoCopyTexImage2D(decoder, dest_target, intermediate_texture, dest_target,
-                     dest_id, dest_internal_format, width, height,
-                     framebuffer_);
+    source_level = 0;
+    dest_level = original_dest_level;
+    DoCopyTexImage2D(decoder, dest_target, intermediate_texture, source_level,
+                     dest_target, dest_id, dest_level, dest_internal_format,
+                     width, height, framebuffer_);
     glDeleteTextures(1, &intermediate_texture);
   }
 }
 
 void CopyTextureCHROMIUMResourceManager::DoCopySubTexture(
     const gles2::GLES2Decoder* decoder,
     GLenum source_target,
     GLuint source_id,
+    GLint source_level,
     GLenum source_internal_format,
     GLenum dest_target,
     GLuint dest_id,
+    GLint dest_level,
     GLenum dest_internal_format,
     GLint xoffset,
     GLint yoffset,
     GLint x,
     GLint y,
     GLsizei width,
     GLsizei height,
     GLsizei dest_width,
     GLsizei dest_height,
     GLsizei source_width,
@@ skipping 10 matching lines @@
   // https://bugs.freedesktop.org/show_bug.cgi?id=98478 crbug.com/535198
   use_gl_copy_tex_sub_image_2d = false;
 #endif
   bool premultiply_alpha_change = premultiply_alpha ^ unpremultiply_alpha;
 
   // GL_TEXTURE_RECTANGLE_ARB on FBO is supported by OpenGL, not GLES2,
   // so restrict this to GL_TEXTURE_2D.
   if (use_gl_copy_tex_sub_image_2d && source_target == GL_TEXTURE_2D &&
       dest_target == GL_TEXTURE_2D && !flip_y && !premultiply_alpha_change &&
       method == DIRECT_COPY) {
-    DoCopyTexSubImage2D(decoder, source_target, source_id, dest_target, dest_id,
-                        xoffset, yoffset, x, y, width, height, framebuffer_);
+    DoCopyTexSubImage2D(decoder, source_target, source_id, source_level,
+                        dest_target, dest_id, dest_level, xoffset, yoffset, x,
+                        y, width, height, framebuffer_);
     return;
   }
 
   GLint dest_xoffset = xoffset;
   GLint dest_yoffset = yoffset;
   GLuint dest_texture = dest_id;
+  GLint original_dest_level = dest_level;
   GLuint intermediate_texture = 0;
   if (method == DRAW_AND_COPY) {
     GLenum adjusted_internal_format =
         getIntermediateFormat(dest_internal_format);
     glGenTextures(1, &intermediate_texture);
     glBindTexture(dest_target, intermediate_texture);
     GLenum format = TextureManager::ExtractFormatFromStorageFormat(
         adjusted_internal_format);
     GLenum type =
         TextureManager::ExtractTypeFromStorageFormat(adjusted_internal_format);
 
     glTexImage2D(dest_target, 0, adjusted_internal_format, width, height, 0,
                  format, type, nullptr);
     dest_texture = intermediate_texture;
+    dest_level = 0;
     dest_internal_format = adjusted_internal_format;
     dest_xoffset = 0;
     dest_yoffset = 0;
     dest_width = width;
     dest_height = height;
   }
 
   DoCopySubTextureWithTransform(
-      decoder, source_target, source_id, source_internal_format, dest_target,
-      dest_texture, dest_internal_format, dest_xoffset, dest_yoffset, x, y,
-      width, height, dest_width, dest_height, source_width, source_height,
-      flip_y, premultiply_alpha, unpremultiply_alpha, kIdentityMatrix);
+      decoder, source_target, source_id, source_level, source_internal_format,
+      dest_target, dest_texture, dest_level, dest_internal_format, dest_xoffset,
+      dest_yoffset, x, y, width, height, dest_width, dest_height, source_width,
+      source_height, flip_y, premultiply_alpha, unpremultiply_alpha,
+      kIdentityMatrix);
 
   if (method == DRAW_AND_COPY) {
-    DoCopyTexSubImage2D(decoder, dest_target, intermediate_texture, dest_target,
-                        dest_id, xoffset, yoffset, 0, 0, width, height,
-                        framebuffer_);
+    source_level = 0;
+    dest_level = original_dest_level;
+    DoCopyTexSubImage2D(decoder, dest_target, intermediate_texture,
+                        source_level, dest_target, dest_id, dest_level, xoffset,
+                        yoffset, 0, 0, width, height, framebuffer_);
     glDeleteTextures(1, &intermediate_texture);
   }
 }
 
 void CopyTextureCHROMIUMResourceManager::DoCopySubTextureWithTransform(
     const gles2::GLES2Decoder* decoder,
     GLenum source_target,
     GLuint source_id,
+    GLint source_level,
     GLenum source_internal_format,
     GLenum dest_target,
     GLuint dest_id,
+    GLint dest_level,
     GLenum dest_internal_format,
     GLint xoffset,
     GLint yoffset,
     GLint x,
     GLint y,
     GLsizei width,
     GLsizei height,
     GLsizei dest_width,
     GLsizei dest_height,
     GLsizei source_width,
     GLsizei source_height,
     bool flip_y,
     bool premultiply_alpha,
     bool unpremultiply_alpha,
     const GLfloat transform_matrix[16]) {
   DoCopyTextureInternal(
-      decoder, source_target, source_id, source_internal_format, dest_target,
-      dest_id, dest_internal_format, xoffset, yoffset, x, y, width, height,
-      dest_width, dest_height, source_width, source_height, flip_y,
-      premultiply_alpha, unpremultiply_alpha, transform_matrix);
+      decoder, source_target, source_id, source_level, source_internal_format,
+      dest_target, dest_id, dest_level, dest_internal_format, xoffset, yoffset,
+      x, y, width, height, dest_width, dest_height, source_width, source_height,
+      flip_y, premultiply_alpha, unpremultiply_alpha, transform_matrix);
 }
 
 void CopyTextureCHROMIUMResourceManager::DoCopyTextureWithTransform(
     const gles2::GLES2Decoder* decoder,
     GLenum source_target,
     GLuint source_id,
+    GLint source_level,
     GLenum source_format,
     GLenum dest_target,
     GLuint dest_id,
+    GLint dest_level,
     GLenum dest_format,
     GLsizei width,
     GLsizei height,
     bool flip_y,
     bool premultiply_alpha,
     bool unpremultiply_alpha,
     const GLfloat transform_matrix[16]) {
   GLsizei dest_width = width;
   GLsizei dest_height = height;
-  DoCopyTextureInternal(
-      decoder, source_target, source_id, source_format, dest_target, dest_id,
-      dest_format, 0, 0, 0, 0, width, height, dest_width, dest_height, width,
-      height, flip_y, premultiply_alpha, unpremultiply_alpha, transform_matrix);
+  DoCopyTextureInternal(decoder, source_target, source_id, source_level,
+                        source_format, dest_target, dest_id, dest_level,
+                        dest_format, 0, 0, 0, 0, width, height, dest_width,
+                        dest_height, width, height, flip_y, premultiply_alpha,
+                        unpremultiply_alpha, transform_matrix);
 }
 
 void CopyTextureCHROMIUMResourceManager::DoCopyTextureInternal(
     const gles2::GLES2Decoder* decoder,
     GLenum source_target,
     GLuint source_id,
+    GLint source_level,
     GLenum source_format,
     GLenum dest_target,
     GLuint dest_id,
+    GLint dest_level,
     GLenum dest_format,
     GLint xoffset,
     GLint yoffset,
     GLint x,
     GLint y,
     GLsizei width,
     GLsizei height,
     GLsizei dest_width,
     GLsizei dest_height,
     GLsizei source_width,
     GLsizei source_height,
     bool flip_y,
     bool premultiply_alpha,
     bool unpremultiply_alpha,
     const GLfloat transform_matrix[16]) {
   DCHECK(source_target == GL_TEXTURE_2D ||
          source_target == GL_TEXTURE_RECTANGLE_ARB ||
          source_target == GL_TEXTURE_EXTERNAL_OES);
   DCHECK(dest_target == GL_TEXTURE_2D ||
          dest_target == GL_TEXTURE_RECTANGLE_ARB);
+  DCHECK_GE(source_level, 0);
+  DCHECK_GE(dest_level, 0);
   DCHECK_GE(xoffset, 0);
   DCHECK_LE(xoffset + width, dest_width);
   DCHECK_GE(yoffset, 0);
   DCHECK_LE(yoffset + height, dest_height);
   if (dest_width == 0 || dest_height == 0 || source_width == 0 ||
       source_height == 0) {
     return;
   }
 
   if (!initialized_) {
@@ skipping 131 matching lines @@
   // So everything is the same but the sign of A is flipped.
   GLfloat m_x = source_target == GL_TEXTURE_RECTANGLE_ARB ? source_width : 1;
   GLfloat m_y = source_target == GL_TEXTURE_RECTANGLE_ARB ? source_height : 1;
   GLfloat sign_a = flip_y ? -1 : 1;
   glUniform2f(info->vertex_source_mult_handle, width / 2.f * m_x / source_width,
               height / 2.f * m_y / source_height * sign_a);
   glUniform2f(info->vertex_source_add_handle,
               (x + width / 2.f) * m_x / source_width,
               (y + height / 2.f) * m_y / source_height);
 
-  if (BindFramebufferTexture2D(dest_target, dest_id, framebuffer_)) {
+  DCHECK(dest_level == 0 || decoder->GetFeatureInfo()->IsES3Capable());
+  if (BindFramebufferTexture2D(dest_target, dest_id, dest_level,
+                               framebuffer_)) {
 #ifndef NDEBUG
     // glValidateProgram of MACOSX validates FBO unlike other platforms, so
     // glValidateProgram must be called after FBO binding. crbug.com/463439
     glValidateProgram(info->program);
     GLint validation_status;
     glGetProgramiv(info->program, GL_VALIDATE_STATUS, &validation_status);
     if (GL_TRUE != validation_status) {
       DLOG(ERROR) << "CopyTextureCHROMIUM: Invalid shader.";
       return;
     }
 #endif
 
     glUniform1i(info->sampler_handle, 0);
 
     glBindTexture(source_target, source_id);
+    DCHECK(source_level == 0 || decoder->GetFeatureInfo()->IsES3Capable());
+    if (source_level > 0)
+      glTexParameteri(source_target, GL_TEXTURE_BASE_LEVEL, source_level);
     glTexParameterf(source_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameterf(source_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexParameteri(source_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(source_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 
     glDisable(GL_DEPTH_TEST);
     glDisable(GL_STENCIL_TEST);
     glDisable(GL_CULL_FACE);
     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
     glDepthMask(GL_FALSE);
@@ skipping 17 matching lines @@
   decoder->RestoreTextureUnitBindings(0);
   decoder->RestoreActiveTexture();
   decoder->RestoreProgramBindings();
   decoder->RestoreBufferBindings();
   decoder->RestoreFramebufferBindings();
   decoder->RestoreGlobalState();
 }
 
 }  // namespace gles2
 }  // namespace gpu