Addition of unpremultiply setting to GL_CHROMIUM_copy_texture.

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 "base/basictypes.h"
 #include "gpu/command_buffer/common/types.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 
 #define SHADER0(Src) \
     "#ifdef GL_ES\n"\
     "precision mediump float;\n"\
     "#endif\n"\
     #Src
 #define SHADER(Src) SHADER0(Src)
 
 namespace {
 
 const GLfloat kQuadVertices[] = { -1.0f, -1.0f, 0.0f, 1.0f,
                                    1.0f, -1.0f, 0.0f, 1.0f,
                                    1.0f,  1.0f, 0.0f, 1.0f,
                                   -1.0f,  1.0f, 0.0f, 1.0f };
 
 const GLfloat kTextureCoords[] = { 0.0f, 0.0f,
                                    1.0f, 0.0f,
                                    1.0f, 1.0f,
                                    0.0f, 1.0f };
 
-const int kNumShaders = 5;
+const int kNumShaders = 7;
 enum ShaderId {
   VERTEX_SHADER_POS_TEX,
   FRAGMENT_SHADER_TEX,
   FRAGMENT_SHADER_TEX_FLIP_Y,
   FRAGMENT_SHADER_TEX_PREMULTIPLY_ALPHA,
-  FRAGMENT_SHADER_TEX_PREMULTIPLY_ALPHA_FLIP_Y
+  FRAGMENT_SHADER_TEX_UNPREMULTIPLY_ALPHA,
+  FRAGMENT_SHADER_TEX_PREMULTIPLY_ALPHA_FLIP_Y,
+  FRAGMENT_SHADER_TEX_UNPREMULTIPLY_ALPHA_FLIP_Y
 };
 
 enum ProgramId {
   PROGRAM_COPY_TEXTURE,
   PROGRAM_COPY_TEXTURE_FLIP_Y,
   PROGRAM_COPY_TEXTURE_PREMULTIPLY_ALPHA,
-  PROGRAM_COPY_TEXTURE_PREMULTIPLY_ALPHA_FLIPY
+  PROGRAM_COPY_TEXTURE_UNPREMULTIPLY_ALPHA,
+  PROGRAM_COPY_TEXTURE_PREMULTIPLY_ALPHA_FLIPY,
+  PROGRAM_COPY_TEXTURE_UNPREMULTIPLY_ALPHA_FLIPY
 };
 
 // Returns the correct program to evaluate the copy operation for
 // the CHROMIUM_flipy and premultiply alpha pixel store settings.
-ProgramId GetProgram(bool flip_y, bool premultiply_alpha) {
+ProgramId GetProgram(bool flip_y, bool premultiply_alpha,
+                     bool unpremultiply_alpha) {
+  // If both pre-multiply and unpremultiply are requested, then perform no
+  // alpha manipulation.
+  if (premultiply_alpha && unpremultiply_alpha) {
+    premultiply_alpha = false;
+    unpremultiply_alpha = false;
+  }
+
   if (flip_y && premultiply_alpha)
     return PROGRAM_COPY_TEXTURE_PREMULTIPLY_ALPHA_FLIPY;
 
+  if (flip_y && unpremultiply_alpha)
+    return PROGRAM_COPY_TEXTURE_UNPREMULTIPLY_ALPHA_FLIPY;
+
   if (flip_y)
     return PROGRAM_COPY_TEXTURE_FLIP_Y;
 
   if (premultiply_alpha)
     return PROGRAM_COPY_TEXTURE_PREMULTIPLY_ALPHA;
 
+  if (unpremultiply_alpha)
+    return PROGRAM_COPY_TEXTURE_UNPREMULTIPLY_ALPHA;
+
   return PROGRAM_COPY_TEXTURE;
 }
 
 const char* GetShaderSource(ShaderId shader) {
   switch (shader) {
     case VERTEX_SHADER_POS_TEX:
       return SHADER(
         attribute vec4 a_position;
         attribute vec2 a_texCoord;
         varying vec2 v_uv;
@@ skipping 16 matching lines @@
           gl_FragColor = texture2D(u_texSampler, vec2(v_uv.s, 1.0 - v_uv.t));
         });
     case FRAGMENT_SHADER_TEX_PREMULTIPLY_ALPHA:
       return SHADER(
         uniform sampler2D u_texSampler;
         varying vec2 v_uv;
         void main(void) {
           gl_FragColor = texture2D(u_texSampler, v_uv.st);
           gl_FragColor.rgb *= gl_FragColor.a;
         });
+    case FRAGMENT_SHADER_TEX_UNPREMULTIPLY_ALPHA:
+      return SHADER(
+        uniform sampler2D u_texSampler;
+        varying vec2 v_uv;
+        void main(void) {
+          gl_FragColor = texture2D(u_texSampler, v_uv.st);
+          if (gl_FragColor.a > 0.0)
+            gl_FragColor.rgb /= gl_FragColor.a;
+        });
     case FRAGMENT_SHADER_TEX_PREMULTIPLY_ALPHA_FLIP_Y:
       return SHADER(
         uniform sampler2D u_texSampler;
         varying vec2 v_uv;
         void main(void) {
           gl_FragColor = texture2D(u_texSampler, vec2(v_uv.s, 1.0 - v_uv.t));
           gl_FragColor.rgb *= gl_FragColor.a;
         });
+    case FRAGMENT_SHADER_TEX_UNPREMULTIPLY_ALPHA_FLIP_Y:
+      return SHADER(
+        uniform sampler2D u_texSampler;
+        varying vec2 v_uv;
+        void main(void) {
+          gl_FragColor = texture2D(u_texSampler, vec2(v_uv.s, 1.0 - v_uv.t));
+          if (gl_FragColor.a > 0.0)
+            gl_FragColor.rgb /= gl_FragColor.a;
+        });
     default:
       return 0;
   }
 }
 
 }  // namespace
 
 void CopyTextureCHROMIUMResourceManager::Initialize() {
   COMPILE_ASSERT(
       kVertexPositionAttrib == 0u || kVertexTextureAttrib == 0u,
@@ skipping 65 matching lines @@
 
   glDeleteBuffersARB(2, buffer_ids_);
 }
 
 void CopyTextureCHROMIUMResourceManager::DoCopyTexture(
     GLenum target,
     GLuint source_id,
     GLuint dest_id,
     GLint level,
     bool flip_y,
-    bool premultiply_alpha) {
+    bool premultiply_alpha,
+    bool unpremultiply_alpha) {
   if (!initialized_) {
     DLOG(ERROR) << "CopyTextureCHROMIUM: Uninitialized manager.";
     return;
   }
 
-  GLuint program = GetProgram(flip_y, premultiply_alpha);
+  GLuint program = GetProgram(flip_y, premultiply_alpha, unpremultiply_alpha);
   glUseProgram(programs_[program]);
 
 #ifndef NDEBUG
   glValidateProgram(programs_[program]);
   GLint validation_status;
   glGetProgramiv(programs_[program], GL_VALIDATE_STATUS, &validation_status);
   if (GL_TRUE != validation_status) {
     DLOG(ERROR) << "CopyTextureCHROMIUM: Invalid shader.";
     return;
   }
@@ skipping 35 matching lines @@
   glDisable(GL_SCISSOR_TEST);
   glDisable(GL_STENCIL_TEST);
   glDisable(GL_CULL_FACE);
   glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
   glDepthMask(GL_FALSE);
   glDisable(GL_BLEND);
 
   glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 }