Remove GSC usage from ExynosVideoDecodeAccelerator.

content/common/gpu/media/rendering_helper.cc

 // Copyright 2013 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 "content/common/gpu/media/rendering_helper.h"
 
 #include "base/bind.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringize_macros.h"
@@ skipping 312 matching lines @@
       uniform bool tex_flip;
       void main() {
         if (tex_flip)
           interp_tc = vec2(in_tc.x, 1.0 - in_tc.y);
         else
           interp_tc = in_tc;
         gl_Position = in_pos;
       });
 
 #if GL_VARIANT_EGL
-  static const char kFragmentShader[] = STRINGIZE(
-      precision mediump float;
-      varying vec2 interp_tc;
-      uniform sampler2D tex;
-      void main() {
-        gl_FragColor = texture2D(tex, interp_tc);
-      });
+  static const char kFragmentShader[] =
+      "#extension GL_OES_EGL_image_external : enable\n"

[Ami GONE FROM CHROMIUM, 2013/11/12 19:36:44]

Sure would be nice if you could use STRINGIZE

[Ami GONE FROM CHROMIUM, 2013/11/12 19:36:44]

This works on windows/angle?

[sheu, 2013/11/12 19:41:45]

Can't, since we have an "#extension" preprocessor bit.  (Not sure if you meant
that in passing or what.)

[sheu, 2013/11/12 19:41:45]

It should.  To the trybot!

+      "precision mediump float;\n"
+      "varying vec2 interp_tc;\n"
+      "uniform sampler2D tex;\n"
+      "#ifdef GL_OES_EGL_image_external\n"
+      "uniform samplerExternalOES tex_external;\n"
+      "#endif\n"
+      "void main() {\n"
+      "  vec4 color = texture2D(tex, interp_tc);\n"
+      "#ifdef GL_OES_EGL_image_external\n"
+      "  color += texture2D(tex_external, interp_tc);\n"
+      "#endif\n"
+      "  gl_FragColor = color;\n"
+      "}\n";
 #else
   static const char kFragmentShader[] = STRINGIZE(
       varying vec2 interp_tc;
       uniform sampler2D tex;
       void main() {
         gl_FragColor = texture2D(tex, interp_tc);
       });
 #endif
   program_ = glCreateProgram();
   CreateShader(
       program_, GL_VERTEX_SHADER, kVertexShader, arraysize(kVertexShader));
   CreateShader(program_,
                GL_FRAGMENT_SHADER,
                kFragmentShader,
                arraysize(kFragmentShader));
   glLinkProgram(program_);
   int result = GL_FALSE;
   glGetProgramiv(program_, GL_LINK_STATUS, &result);
   if (!result) {
     char log[4096];
     glGetShaderInfoLog(program_, arraysize(log), NULL, log);
     LOG(FATAL) << log;
   }
   glUseProgram(program_);
   glDeleteProgram(program_);
 
   glUniform1i(glGetUniformLocation(program_, "tex_flip"), 0);
   glUniform1i(glGetUniformLocation(program_, "tex"), 0);
+  GLint tex_external = glGetUniformLocation(program_, "tex_external");
+  if (tex_external != -1) {
+    glUniform1i(tex_external, 1);
+  }
   int pos_location = glGetAttribLocation(program_, "in_pos");
   glEnableVertexAttribArray(pos_location);
   glVertexAttribPointer(pos_location, 2, GL_FLOAT, GL_FALSE, 0, kVertices);
   int tc_location = glGetAttribLocation(program_, "in_tc");
   glEnableVertexAttribArray(tc_location);
   glVertexAttribPointer(tc_location, 2, GL_FLOAT, GL_FALSE, 0, kTextureCoords);
   done->Signal();
 }
 
 void RenderingHelper::UnInitialize(base::WaitableEvent* done) {
@@ skipping 21 matching lines @@
                                     uint32 texture_target,
                                     uint32* texture_id,
                                     base::WaitableEvent* done) {
   if (base::MessageLoop::current() != message_loop_) {
     message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&RenderingHelper::CreateTexture, base::Unretained(this),
                    window_id, texture_target, texture_id, done));
     return;
   }
-  CHECK_EQ(static_cast<uint32>(GL_TEXTURE_2D), texture_target);
   MakeCurrent(window_id);
   glGenTextures(1, texture_id);
-  glBindTexture(GL_TEXTURE_2D, *texture_id);
+  glBindTexture(texture_target, *texture_id);
   int dimensions_id = window_id % frame_dimensions_.size();
-  glTexImage2D(GL_TEXTURE_2D,
-               0,
-               GL_RGBA,
-               frame_dimensions_[dimensions_id].width(),
-               frame_dimensions_[dimensions_id].height(),
-               0,
-               GL_RGBA,
-               GL_UNSIGNED_BYTE,
-               NULL);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  if (texture_target == GL_TEXTURE_2D) {
+    glTexImage2D(GL_TEXTURE_2D,
+                 0,
+                 GL_RGBA,
+                 frame_dimensions_[dimensions_id].width(),
+                 frame_dimensions_[dimensions_id].height(),
+                 0,
+                 GL_RGBA,
+                 GL_UNSIGNED_BYTE,
+                 NULL);
+  }
+  glTexParameteri(texture_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  glTexParameteri(texture_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
   // OpenGLES2.0.25 section 3.8.2 requires CLAMP_TO_EDGE for NPOT textures.
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+  glTexParameteri(texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  glTexParameteri(texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
   CHECK(texture_id_to_surface_index_.insert(
       std::make_pair(*texture_id, window_id)).second);
   done->Signal();
 }
 
-void RenderingHelper::RenderTexture(uint32 texture_id) {
+void RenderingHelper::RenderTexture(uint32 texture_target, uint32 texture_id) {
   CHECK_EQ(base::MessageLoop::current(), message_loop_);
   size_t window_id = texture_id_to_surface_index_[texture_id];
   MakeCurrent(window_id);
 
   int dimensions_id = window_id % window_dimensions_.size();
   int width = window_dimensions_[dimensions_id].width();
   int height = window_dimensions_[dimensions_id].height();
 
   if (render_as_thumbnails_) {
     glBindFramebufferEXT(GL_FRAMEBUFFER, thumbnails_fbo_id_);
     const int thumbnails_in_row =
         thumbnails_fbo_size_.width() / thumbnail_size_.width();
     const int thumbnails_in_column =
         thumbnails_fbo_size_.height() / thumbnail_size_.height();
     const int row = (frame_count_ / thumbnails_in_row) % thumbnails_in_column;
     const int col = frame_count_ % thumbnails_in_row;
     const int x = col * thumbnail_size_.width();
     const int y = row * thumbnail_size_.height();
 
     glViewport(x, y, thumbnail_size_.width(), thumbnail_size_.height());
     glScissor(x, y, thumbnail_size_.width(), thumbnail_size_.height());
     glUniform1i(glGetUniformLocation(program_, "tex_flip"), 0);
   } else {
     glViewport(0, 0, width, height);
     glScissor(0, 0, width, height);
     glUniform1i(glGetUniformLocation(program_, "tex_flip"), 1);
   }
 
-  glActiveTexture(GL_TEXTURE0);
-  glBindTexture(GL_TEXTURE_2D, texture_id);
+  // Unbound texture samplers default to (0, 0, 0, 1).  Use this fact to switch
+  // between GL_TEXTURE_2D and GL_TEXTURE_EXTERNAL_OES as appopriate.
+  if (texture_target == GL_TEXTURE_2D) {
+    glActiveTexture(GL_TEXTURE0 + 0);
+    glBindTexture(GL_TEXTURE_2D, texture_id);
+    glActiveTexture(GL_TEXTURE0 + 1);
+    glBindTexture(texture_target, 0);
+  } else if (texture_target == GL_TEXTURE_EXTERNAL_OES) {
+    glActiveTexture(GL_TEXTURE0 + 0);
+    glBindTexture(GL_TEXTURE_2D, 0);
+    glActiveTexture(GL_TEXTURE0 + 1);
+    glBindTexture(texture_target, texture_id);
+  }
   glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
   CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
 
   ++frame_count_;
 
   if (render_as_thumbnails_) {
     // Copy from FBO to screen
     glUniform1i(glGetUniformLocation(program_, "tex_flip"), 1);
     glBindFramebufferEXT(GL_FRAMEBUFFER, 0);
     glViewport(0, 0, width, height);
     glScissor(0, 0, width, height);
+    glActiveTexture(GL_TEXTURE0 + 0);
     glBindTexture(GL_TEXTURE_2D, thumbnails_texture_id_);
+    glActiveTexture(GL_TEXTURE0 + 1);
+    glBindTexture(texture_target, 0);
     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
   }
 
 #if GL_VARIANT_GLX
   glXSwapBuffers(x_display_, x_windows_[window_id]);
 #else  // EGL
   eglSwapBuffers(gl_display_, gl_surfaces_[window_id]);
   CHECK_EQ(static_cast<int>(eglGetError()), EGL_SUCCESS);
 #endif
 }
@@ skipping 58 matching lines @@
   glBindFramebufferEXT(GL_FRAMEBUFFER, thumbnails_fbo_id_);
   glPixelStorei(GL_PACK_ALIGNMENT, 1);
   // We can only count on GL_RGBA/GL_UNSIGNED_BYTE support.
   glReadPixels(0,
                0,
                thumbnails_fbo_size_.width(),
                thumbnails_fbo_size_.height(),
                GL_RGBA,
                GL_UNSIGNED_BYTE,
                &rgba[0]);
+  glBindFramebufferEXT(GL_FRAMEBUFFER, 0);
   rgb->resize(num_pixels * 3);
   // Drop the alpha channel, but check as we go that it is all 0xff.
   bool solid = true;
   unsigned char* rgb_ptr = &((*rgb)[0]);
   unsigned char* rgba_ptr = &rgba[0];
   for (size_t i = 0; i < num_pixels; ++i) {
     *rgb_ptr++ = *rgba_ptr++;
     *rgb_ptr++ = *rgba_ptr++;
     *rgb_ptr++ = *rgba_ptr++;
     solid = solid && (*rgba_ptr == 0xff);
     rgba_ptr++;
   }
   *alpha_solid = solid;
 
   done->Signal();
 }
 
 }  // namespace content