command_buffer: Implement EXT_blend_func_extended

gpu/command_buffer/service/program_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/program_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 10 matching lines @@
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/program_cache.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "third_party/re2/re2/re2.h"
+#include "ui/gl/gl_version_info.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace gpu {
 namespace gles2 {
 
 namespace {
 
 int ShaderTypeToIndex(GLenum shader_type) {
@@ skipping 201 matching lines @@
   }
   DCHECK_LT(0, size);
   DCHECK(is_array || size == 1);
 
   size_t num_texture_units = IsSampler() ? static_cast<size_t>(size) : 0u;
   texture_units.clear();
   texture_units.resize(num_texture_units, 0);
 }
 Program::UniformInfo::~UniformInfo() {}
 
-bool ProgramManager::IsInvalidPrefix(const char* name, size_t length) {
-  static const char kInvalidPrefix[] = { 'g', 'l', '_' };
-  return (length >= sizeof(kInvalidPrefix) &&
-      memcmp(name, kInvalidPrefix, sizeof(kInvalidPrefix)) == 0);
+bool ProgramManager::HasBuiltInPrefix(const std::string& name) {
+  return name.length() >= 3 && name[0] == 'g' && name[1] == 'l' &&
+         name[2] == '_';
 }
 
 Program::Program(ProgramManager* manager, GLuint service_id)
     : manager_(manager),
       use_count_(0),
       max_attrib_name_length_(0),
       max_uniform_name_length_(0),
       service_id_(service_id),
       deleted_(false),
       valid_(false),
       link_status_(false),
       uniforms_cleared_(false),
       transform_feedback_buffer_mode_(GL_NONE) {
   manager_->StartTracking(this);
 }
 
 void Program::Reset() {
   valid_ = false;
   link_status_ = false;
   max_uniform_name_length_ = 0;
   max_attrib_name_length_ = 0;
   attrib_infos_.clear();
   uniform_infos_.clear();
   uniform_locations_.clear();
   fragment_input_infos_.clear();
   fragment_input_locations_.clear();
+  program_output_infos_.clear();
   sampler_indices_.clear();
   attrib_location_to_index_map_.clear();
 }
 
 std::string Program::ProcessLogInfo(
     const std::string& log) {
   std::string output;
   re2::StringPiece input(log);
   std::string prior_log;
   std::string hashed_name;
@@ skipping 220 matching lines @@
     for (const UniformInfo& info : uniform_infos_) {
       DVLOG(1) << ii++ << ": loc = " << info.element_locations[0]
                << ", size = " << info.size
                << ", type = " << GLES2Util::GetStringEnum(info.type)
                << ", name = " << info.name;
     }
   }
 #endif
 
   UpdateFragmentInputs();
+  UpdateProgramOutputs();
 
   valid_ = true;
 }
 
 void Program::UpdateUniforms() {
   // Reserve each client-bound uniform location. This way unbound uniforms will
   // not be allocated to locations that user expects bound uniforms to be, even
   // if the expected uniforms are optimized away by the driver.
   for (const auto& binding : bind_uniform_location_map_) {
     if (binding.second < 0)
@@ skipping 24 matching lines @@
     GLsizei size = 0;
     GLenum type = GL_NONE;
     glGetActiveUniform(service_id_, uniform_index, name_buffer_length,
                        &name_length, &size, &type, name_buffer.get());
     DCHECK(name_length < name_buffer_length);
     DCHECK(name_length == 0 || name_buffer[name_length] == '\0');
     std::string service_name(name_buffer.get(), name_length);
 
     GLint service_location = -1;
     // Force builtin uniforms (gl_DepthRange) to have invalid location.
-    if (!ProgramManager::IsInvalidPrefix(service_name.c_str(),
-                                         service_name.size())) {
+    if (!ProgramManager::HasBuiltInPrefix(service_name)) {
       service_location =
           glGetUniformLocation(service_id_, service_name.c_str());
     }
 
     // Determine the client name of the uniform and whether it is an array
     // or not.
     bool is_array = false;
     std::string client_name;
     for (size_t i = 0; i < kMaxAttachedShaders && client_name.empty(); ++i) {
       const auto& shader = attached_shaders_[i];
@@ skipping 116 matching lines @@
   std::vector<size_t> client_location_indices;
   for (GLint ii = 0; ii < num_fragment_inputs; ++ii) {
     GLsizei name_length = 0;
     glGetProgramResourceName(service_id_, GL_FRAGMENT_INPUT_NV, ii, max_len,
                              &name_length, name_buffer.get());
     DCHECK(name_length < max_len);
     DCHECK(name_length == 0 || name_buffer[name_length] == '\0');
     // A fragment shader can have gl_FragCoord, gl_FrontFacing or gl_PointCoord
     // built-ins as its input, as well as custom varyings. We are interested in
     // custom varyings, client is allowed to bind only them.
-    if (ProgramManager::IsInvalidPrefix(name_buffer.get(), name_length))
+    std::string service_name(name_buffer.get(), name_length);
+    if (ProgramManager::HasBuiltInPrefix(service_name))
       continue;
-    std::string service_name(name_buffer.get(), name_length);
     // Unlike when binding uniforms, we expect the driver to give correct
     // names: "name" for simple variable, "name[0]" for an array.
     GLsizei query_length = 0;
     GLint query_results[arraysize(kQueryProperties)] = {
         0,
     };
     glGetProgramResourceiv(service_id_, GL_FRAGMENT_INPUT_NV, ii,
                            arraysize(kQueryProperties), kQueryProperties,
                            arraysize(query_results), &query_length,
                            query_results);
@@ skipping 64 matching lines @@
   for (size_t i = 0; i < client_location_indices.size(); ++i) {
     size_t client_location = client_location_indices[i];
     // Before linking, we already validated that no two statically used fragment
     // inputs are bound to the same location.
     DCHECK(!fragment_input_locations_[client_location].IsActive());
     fragment_input_locations_[client_location].SetActive(
         &fragment_input_infos_[i]);
   }
 }
 
+void Program::UpdateProgramOutputs() {
+  if (!feature_info().gl_version_info().IsES3Capable() ||
+      feature_info().disable_shader_translator())
+    return;
+
+  Shader* fragment_shader =
+      attached_shaders_[ShaderTypeToIndex(GL_FRAGMENT_SHADER)].get();
+
+  for (auto const& output_var : fragment_shader->output_variable_list()) {
+    const std::string& service_name = output_var.mappedName;
+    // A fragment shader can have gl_FragColor, gl_SecondaryFragColor, etc
+    // built-ins as its output, as well as custom varyings. We are interested
+    // only in custom varyings, client is allowed to bind only them.
+    if (ProgramManager::HasBuiltInPrefix(service_name))
+      continue;
+
+    std::string client_name = output_var.name;
+    if (output_var.arraySize == 0) {
+      GLint color_name =
+          glGetFragDataLocation(service_id_, service_name.c_str());
+      if (color_name < 0)
+        continue;
+      GLint index = 0;
+      if (feature_info().feature_flags().ext_blend_func_extended)
+        index = glGetFragDataIndex(service_id_, service_name.c_str());
+      if (index < 0)
+        continue;
+      program_output_infos_.push_back(
+          ProgramOutputInfo(color_name, index, client_name));
+    } else {
+      for (size_t ii = 0; ii < output_var.arraySize; ++ii) {
+        std::string array_spec(std::string("[") + base::IntToString(ii) + "]");
+        std::string service_element_name(service_name + array_spec);
+        GLint color_name =
+            glGetFragDataLocation(service_id_, service_element_name.c_str());
+        if (color_name < 0)
+          continue;
+        GLint index = 0;
+        if (feature_info().feature_flags().ext_blend_func_extended)
+          index = glGetFragDataIndex(service_id_, service_element_name.c_str());
+        if (index < 0)
+          continue;
+        program_output_infos_.push_back(
+            ProgramOutputInfo(color_name, index, client_name + array_spec));
+      }
+    }
+  }
+}
+
 void Program::ExecuteBindAttribLocationCalls() {
   for (const auto& key_value : bind_attrib_location_map_) {
     const std::string* mapped_name = GetAttribMappedName(key_value.first);
     if (mapped_name)
       glBindAttribLocation(service_id_, key_value.second, mapped_name->c_str());
   }
 }
 
 bool Program::ExecuteTransformFeedbackVaryingsCall() {
   if (!transform_feedback_varyings_.empty()) {
@@ skipping 19 matching lines @@
     }
     glTransformFeedbackVaryings(service_id_,
                                 mapped_names.size(),
                                 &mapped_names.front(),
                                 transform_feedback_buffer_mode_);
   }
 
   return true;
 }
 
+void Program::ExecuteProgramOutputBindCalls() {
+  if (feature_info().disable_shader_translator()) {
+    return;
+  }
+
+  Shader* fragment_shader =
+      attached_shaders_[ShaderTypeToIndex(GL_FRAGMENT_SHADER)].get();
+  DCHECK(fragment_shader && fragment_shader->valid());
+
+  if (fragment_shader->shader_version() != 100) {
+    // ES SL 1.00 does not have mechanism for introducing variables that could
+    // be bound. This means that ES SL 1.00 binding calls would be to
+    // non-existing variable names.  Binding calls are only executed with ES SL
+    // 3.00 and higher.
+    for (auto const& output_var : fragment_shader->output_variable_list()) {
+      size_t count = std::max(output_var.arraySize, 1u);
+      bool is_array = output_var.arraySize > 0;
+
+      for (size_t jj = 0; jj < count; ++jj) {
+        std::string name = output_var.name;
+        std::string array_spec;
+        if (is_array) {
+          array_spec = std::string("[") + base::IntToString(jj) + "]";
+          name += array_spec;
+        }
+        auto it = bind_program_output_location_index_map_.find(name);
+        if (it == bind_program_output_location_index_map_.end())
+          continue;
+
+        std::string mapped_name = output_var.mappedName;
+        if (is_array) {
+          mapped_name += array_spec;
+        }
+        const auto& binding = it->second;
+        if (binding.second == 0) {
+          // Handles the cases where client called glBindFragDataLocation as
+          // well as glBindFragDataLocationIndexed with index == 0.
+          glBindFragDataLocation(service_id_, binding.first,
+                                 mapped_name.c_str());
+        } else {
+          DCHECK(feature_info().feature_flags().ext_blend_func_extended);
+          glBindFragDataLocationIndexed(service_id_, binding.first,
+                                        binding.second, mapped_name.c_str());
+        }
+      }
+    }
+    return;
+  }
+
+  // Support for EXT_blend_func_extended when used with ES SL 1.00 client
+  // shader.
+
+  if (feature_info().gl_version_info().is_es ||
+      !feature_info().feature_flags().ext_blend_func_extended)
+    return;
+
+  // The underlying context does not support EXT_blend_func_extended
+  // natively, need to emulate it.
+
+  // ES SL 1.00 is the only language which contains GLSL built-ins
+  // that need to be bound to color indices. If clients use other
+  // languages, they also bind the output variables themselves.
+  // Map gl_SecondaryFragColorEXT / gl_SecondaryFragDataEXT of
+  // EXT_blend_func_extended to real color indexes.
+  for (auto const& output_var : fragment_shader->output_variable_list()) {
+    const std::string& name = output_var.mappedName;
+    if (name == "gl_FragColor") {
+      DCHECK_EQ(-1, output_var.location);
+      DCHECK_EQ(0u, output_var.arraySize);
+      // We leave these unbound by not giving a binding name. The driver will
+      // bind this.
+    } else if (name == "gl_FragData") {
+      DCHECK_EQ(-1, output_var.location);
+      DCHECK_NE(0u, output_var.arraySize);
+      // We leave these unbound by not giving a binding name. The driver will
+      // bind this.
+    } else if (name == "gl_SecondaryFragColorEXT") {
+      DCHECK_EQ(-1, output_var.location);
+      DCHECK_EQ(0u, output_var.arraySize);
+      glBindFragDataLocationIndexed(service_id_, 0, 1,
+                                    "angle_SecondaryFragColor");
+    } else if (name == "gl_SecondaryFragDataEXT") {
+      DCHECK_EQ(-1, output_var.location);
+      DCHECK_NE(0u, output_var.arraySize);
+      glBindFragDataLocationIndexed(service_id_, 0, 1,
+                                    "angle_SecondaryFragData");
+    }
+  }
+}
+
 bool Program::Link(ShaderManager* manager,
                    Program::VaryingsPackingOption varyings_packing_option,
                    const ShaderCacheCallback& shader_callback) {
   ClearLinkStatus();
 
   if (!AttachedShadersExist()) {
     set_log_info("missing shaders");
     return false;
   }
 
@@ skipping 58 matching lines @@
                              "or statically used varyings in fragment shader "
                              "are not declared in vertex shader: " +
                              conflicting_name;
       set_log_info(ProcessLogInfo(info_log).c_str());
       return false;
     }
     if (DetectFragmentInputLocationBindingConflicts()) {
       set_log_info("glBindFragmentInputLocationCHROMIUM() conflicts");
       return false;
     }
+    if (DetectProgramOutputLocationBindingConflicts()) {
+      set_log_info("glBindFragDataLocation() conflicts");
+      return false;
+    }
     if (DetectBuiltInInvariantConflicts()) {
       set_log_info("Invariant settings for certain built-in varyings "
                    "have to match");
       return false;
     }
     if (DetectGlobalNameConflicts(&conflicting_name)) {
       std::string info_log = "Name conflicts between an uniform and an "
                              "attribute: " + conflicting_name;
       set_log_info(ProcessLogInfo(info_log).c_str());
       return false;
     }
     if (!CheckVaryingsPacking(varyings_packing_option)) {
       set_log_info("Varyings over maximum register limit");
       return false;
     }
 
     ExecuteBindAttribLocationCalls();
     if (!ExecuteTransformFeedbackVaryingsCall()) {
       return false;
     }
+
+    ExecuteProgramOutputBindCalls();
+
     before_time = TimeTicks::Now();
     if (cache && gfx::g_driver_gl.ext.b_GL_ARB_get_program_binary) {
       glProgramParameteri(service_id(),
                           PROGRAM_BINARY_RETRIEVABLE_HINT,
                           GL_TRUE);
     }
     glLinkProgram(service_id());
   }
 
   GLint success = 0;
@@ skipping 203 matching lines @@
   // string would exactly match the name of the variable if the suffix "[0]"
   // were appended to the string".
 
   // At this point we can not know if the string identifies a simple variable,
   // a base name of an array, or nothing.  Store both, so if user overwrites
   // either, both still work correctly.
   bind_fragment_input_location_map_[name] = location;
   bind_fragment_input_location_map_[name + "[0]"] = location;
 }
 
+void Program::SetProgramOutputLocationBinding(const std::string& name,
+                                              GLuint color_name) {
+  SetProgramOutputLocationIndexedBinding(name, color_name, 0);
+}
+
+void Program::SetProgramOutputLocationIndexedBinding(const std::string& name,
+                                                     GLuint color_name,
+                                                     GLuint index) {
+  bind_program_output_location_index_map_[name] =
+      std::make_pair(color_name, index);
+  bind_program_output_location_index_map_[name + "[0]"] =
+      std::make_pair(color_name, index);
+}
+
 void Program::GetVertexAttribData(
     const std::string& name, std::string* original_name, GLenum* type) const {
   DCHECK(original_name);
   DCHECK(type);
   Shader* shader = attached_shaders_[ShaderTypeToIndex(GL_VERTEX_SHADER)].get();
   if (shader) {
     // Vertex attributes can not be arrays or structs (GLSL ES 3.00.4, section
     // 4.3.4, "Input Variables"), so the top level sh::Attribute returns the
     // information we need.
     const sh::Attribute* info = shader->GetAttribInfo(name);
@@ skipping 373 matching lines @@
     const sh::Varying* fragment_input = shader->GetVaryingInfo(*mapped_name);
     if (fragment_input && fragment_input->staticUse) {
       auto result = location_binding_used.insert(it.second);
       if (!result.second)
         return true;
     }
   }
   return false;
 }
 
+bool Program::DetectProgramOutputLocationBindingConflicts() const {
+  if (feature_info().disable_shader_translator()) {
+    return false;
+  }
+
+  Shader* shader =
+      attached_shaders_[ShaderTypeToIndex(GL_FRAGMENT_SHADER)].get();
+  DCHECK(shader && shader->valid());
+
+  if (shader->shader_version() == 100)
+    return false;
+
+  std::set<LocationIndexMap::mapped_type> location_binding_used;
+  for (auto const& output_var : shader->output_variable_list()) {
+    if (!output_var.staticUse)
+      continue;
+
+    size_t count = std::max(output_var.arraySize, 1u);
+    bool is_array = output_var.arraySize > 0;
+
+    for (size_t jj = 0; jj < count; ++jj) {
+      std::string name = output_var.name;
+      if (is_array)
+        name += std::string("[") + base::IntToString(jj) + "]";
+
+      auto it = bind_program_output_location_index_map_.find(name);
+      if (it == bind_program_output_location_index_map_.end())
+        continue;
+      auto result = location_binding_used.insert(it->second);
+      if (!result.second)
+        return true;
+    }
+  }
+  return false;
+}
+
 bool Program::DetectBuiltInInvariantConflicts() const {
   DCHECK(attached_shaders_[0].get() &&
          attached_shaders_[0]->shader_type() == GL_VERTEX_SHADER &&
          attached_shaders_[1].get() &&
          attached_shaders_[1]->shader_type() == GL_FRAGMENT_SHADER);
   const VaryingMap& vertex_varyings = attached_shaders_[0]->varying_map();
   const VaryingMap& fragment_varyings = attached_shaders_[1]->varying_map();
 
   bool gl_position_invariant = IsBuiltInInvariant(
       vertex_varyings, "gl_Position");
@@ skipping 458 matching lines @@
     }
     glGetActiveUniformsiv(
         program, count, &indices[0], kPname[pname_index], &params[0]);
     for (GLsizei ii = 0; ii < count; ++ii) {
       entries[kStride * ii + pname_index] = params[ii];
     }
   }
   return true;
 }
 
+const Program::ProgramOutputInfo* Program::GetProgramOutputInfo(
+    const std::string& name) const {
+  for (const auto& info : program_output_infos_) {
+    if (info.name == name) {
+      return &info;
+    }
+  }
+  return nullptr;
+}
+
+GLint Program::GetFragDataLocation(const std::string& original_name) const {
+  DCHECK(IsValid());
+  const ProgramOutputInfo* info = GetProgramOutputInfo(original_name);
+  if (!info)
+    info = GetProgramOutputInfo(original_name + "[0]");
+  if (!info)
+    return -1;
+  return info->color_name;
+}
+
+GLint Program::GetFragDataIndex(const std::string& original_name) const {
+  DCHECK(IsValid());
+  const ProgramOutputInfo* info = GetProgramOutputInfo(original_name);
+  if (!info)
+    info = GetProgramOutputInfo(original_name + "[0]");
+  if (!info)
+    return -1;
+  return info->index;
+}
+
 void Program::TransformFeedbackVaryings(GLsizei count,
                                         const char* const* varyings,
                                         GLenum buffer_mode) {
   transform_feedback_varyings_.clear();
   for (GLsizei i = 0; i < count; ++i) {
     transform_feedback_varyings_.push_back(std::string(varyings[i]));
   }
   transform_feedback_buffer_mode_ = buffer_mode;
 }
 
 Program::~Program() {
   if (manager_) {
     if (manager_->have_context_) {
       glDeleteProgram(service_id());
     }
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
 ProgramManager::ProgramManager(ProgramCache* program_cache,
                                uint32 max_varying_vectors,
+                               uint32 max_dual_source_draw_buffers,
                                FeatureInfo* feature_info)
     : program_count_(0),
       have_context_(true),
       program_cache_(program_cache),
       max_varying_vectors_(max_varying_vectors),
+      max_dual_source_draw_buffers_(max_dual_source_draw_buffers),
       feature_info_(feature_info) {}
 
 ProgramManager::~ProgramManager() {
   DCHECK(programs_.empty());
 }
 
 void ProgramManager::Destroy(bool have_context) {
   have_context_ = have_context;
   programs_.clear();
 }
@@ skipping 94 matching lines @@
   DCHECK(program);
   program->ClearUniforms(&zero_);
 }
 
 int32 ProgramManager::MakeFakeLocation(int32 index, int32 element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu