gpu/command_buffer/service/shader_translator.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "gpu/command_buffer/service/shader_translator.h"
   6
   7 #include <string.h>
   8 #include <GLES2/gl2.h>
   9 #include <algorithm>
  10
  11 #include "base/at_exit.h"
  12 #include "base/debug/trace_event.h"
  13 #include "base/lazy_instance.h"
  14 #include "base/logging.h"
  15 #include "base/strings/string_number_conversions.h"
  16
  17 namespace {
  18
  19 using gpu::gles2::ShaderTranslator;
  20
  21 class ShaderTranslatorInitializer {
  22  public:
  23   ShaderTranslatorInitializer() {
  24     TRACE_EVENT0("gpu", "ShInitialize");
  25     CHECK(ShInitialize());
  26   }
  27
  28   ~ShaderTranslatorInitializer() {
  29     TRACE_EVENT0("gpu", "ShFinalize");
  30     ShFinalize();
  31   }
  32 };
  33
  34 base::LazyInstance<ShaderTranslatorInitializer> g_translator_initializer =
  35     LAZY_INSTANCE_INITIALIZER;
  36
  37 void GetVariableInfo(ShHandle compiler, ShShaderInfo var_type,
  38                      ShaderTranslator::VariableMap* var_map) {
  39   if (!var_map)
  40     return;
  41   var_map->clear();
  42
  43   size_t name_len = 0, mapped_name_len = 0;
  44   switch (var_type) {
  45     case SH_ACTIVE_ATTRIBUTES:
  46       ShGetInfo(compiler, SH_ACTIVE_ATTRIBUTE_MAX_LENGTH, &name_len);
  47       break;
  48     case SH_ACTIVE_UNIFORMS:
  49       ShGetInfo(compiler, SH_ACTIVE_UNIFORM_MAX_LENGTH, &name_len);
  50       break;
  51     case SH_VARYINGS:
  52       ShGetInfo(compiler, SH_VARYING_MAX_LENGTH, &name_len);
  53       break;
  54     default: NOTREACHED();
  55   }
  56   ShGetInfo(compiler, SH_MAPPED_NAME_MAX_LENGTH, &mapped_name_len);
  57   if (name_len <= 1 || mapped_name_len <= 1) return;
  58   scoped_ptr<char[]> name(new char[name_len]);
  59   scoped_ptr<char[]> mapped_name(new char[mapped_name_len]);
  60
  61   size_t num_vars = 0;
  62   ShGetInfo(compiler, var_type, &num_vars);
  63   for (size_t i = 0; i < num_vars; ++i) {
  64     size_t len = 0;
  65     int size = 0;
  66     sh::GLenum type = GL_NONE;
  67     ShPrecisionType precision = SH_PRECISION_UNDEFINED;
  68     int static_use = 0;
  69
  70     ShGetVariableInfo(compiler, var_type, i,
  71                       &len, &size, &type, &precision, &static_use,
  72                       name.get(), mapped_name.get());
  73
  74     // In theory we should CHECK(len <= name_len - 1) here, but ANGLE needs
  75     // to handle long struct field name mapping before we can do this.
  76     // Also, we should modify the ANGLE interface to also return a length
  77     // for mapped_name.
  78     std::string name_string(name.get(), std::min(len, name_len - 1));
  79     mapped_name.get()[mapped_name_len - 1] = '\0';
  80
  81     ShaderTranslator::VariableInfo info(
  82         type, size, precision, static_use, name_string);
  83     (*var_map)[mapped_name.get()] = info;
  84   }
  85 }
  86
  87 void GetNameHashingInfo(
  88     ShHandle compiler, ShaderTranslator::NameMap* name_map) {
  89   if (!name_map)
  90     return;
  91   name_map->clear();
  92
  93   size_t hashed_names_count = 0;
  94   ShGetInfo(compiler, SH_HASHED_NAMES_COUNT, &hashed_names_count);
  95   if (hashed_names_count == 0)
  96     return;
  97
  98   size_t name_max_len = 0, hashed_name_max_len = 0;
  99   ShGetInfo(compiler, SH_NAME_MAX_LENGTH, &name_max_len);
 100   ShGetInfo(compiler, SH_HASHED_NAME_MAX_LENGTH, &hashed_name_max_len);
 101
 102   scoped_ptr<char[]> name(new char[name_max_len]);
 103   scoped_ptr<char[]> hashed_name(new char[hashed_name_max_len]);
 104
 105   for (size_t i = 0; i < hashed_names_count; ++i) {
 106     ShGetNameHashingEntry(compiler, i, name.get(), hashed_name.get());
 107     (*name_map)[hashed_name.get()] = name.get();
 108   }
 109 }
 110
 111 }  // namespace
 112
 113 namespace gpu {
 114 namespace gles2 {
 115
 116 ShaderTranslator::DestructionObserver::DestructionObserver() {
 117 }
 118
 119 ShaderTranslator::DestructionObserver::~DestructionObserver() {
 120 }
 121
 122 ShaderTranslator::ShaderTranslator()
 123     : compiler_(NULL),
 124       implementation_is_glsl_es_(false),
 125       driver_bug_workarounds_(static_cast<ShCompileOptions>(0)) {
 126 }
 127
 128 bool ShaderTranslator::Init(
 129     GLenum shader_type,
 130     ShShaderSpec shader_spec,
 131     const ShBuiltInResources* resources,
 132     ShaderTranslatorInterface::GlslImplementationType glsl_implementation_type,
 133     ShCompileOptions driver_bug_workarounds) {
 134   // Make sure Init is called only once.
 135   DCHECK(compiler_ == NULL);
 136   DCHECK(shader_type == GL_FRAGMENT_SHADER || shader_type == GL_VERTEX_SHADER);
 137   DCHECK(shader_spec == SH_GLES2_SPEC || shader_spec == SH_WEBGL_SPEC);
 138   DCHECK(resources != NULL);
 139
 140   g_translator_initializer.Get();
 141
 142   ShShaderOutput shader_output =
 143       (glsl_implementation_type == kGlslES ? SH_ESSL_OUTPUT : SH_GLSL_OUTPUT);
 144
 145   {
 146     TRACE_EVENT0("gpu", "ShConstructCompiler");
 147     compiler_ = ShConstructCompiler(
 148         shader_type, shader_spec, shader_output, resources);
 149   }
 150   compiler_options_ = *resources;
 151   implementation_is_glsl_es_ = (glsl_implementation_type == kGlslES);
 152   driver_bug_workarounds_ = driver_bug_workarounds;
 153   return compiler_ != NULL;
 154 }
 155
 156 int ShaderTranslator::GetCompileOptions() const {
 157   int compile_options =
 158       SH_OBJECT_CODE | SH_VARIABLES | SH_ENFORCE_PACKING_RESTRICTIONS |
 159       SH_LIMIT_EXPRESSION_COMPLEXITY | SH_LIMIT_CALL_STACK_DEPTH |
 160       SH_CLAMP_INDIRECT_ARRAY_BOUNDS;
 161
 162   compile_options |= driver_bug_workarounds_;
 163
 164   return compile_options;
 165 }
 166
 167 bool ShaderTranslator::Translate(const std::string& shader_source,
 168                                  std::string* info_log,
 169                                  std::string* translated_source,
 170                                  VariableMap* attrib_map,
 171                                  VariableMap* uniform_map,
 172                                  VariableMap* varying_map,
 173                                  NameMap* name_map) const {
 174   // Make sure this instance is initialized.
 175   DCHECK(compiler_ != NULL);
 176
 177   bool success = false;
 178   {
 179     TRACE_EVENT0("gpu", "ShCompile");
 180     const char* const shader_strings[] = { shader_source.c_str() };
 181     success = !!ShCompile(
 182         compiler_, shader_strings, 1, GetCompileOptions());
 183   }
 184   if (success) {
 185     if (translated_source) {
 186       translated_source->clear();
 187       // Get translated shader.
 188       size_t obj_code_len = 0;
 189       ShGetInfo(compiler_, SH_OBJECT_CODE_LENGTH, &obj_code_len);
 190       if (obj_code_len > 1) {
 191         scoped_ptr<char[]> buffer(new char[obj_code_len]);
 192         ShGetObjectCode(compiler_, buffer.get());
 193         *translated_source = std::string(buffer.get(), obj_code_len - 1);
 194       }
 195     }
 196     // Get info for attribs, uniforms, and varyings.
 197     GetVariableInfo(compiler_, SH_ACTIVE_ATTRIBUTES, attrib_map);
 198     GetVariableInfo(compiler_, SH_ACTIVE_UNIFORMS, uniform_map);
 199     GetVariableInfo(compiler_, SH_VARYINGS, varying_map);
 200     // Get info for name hashing.
 201     GetNameHashingInfo(compiler_, name_map);
 202   }
 203
 204   // Get info log.
 205   if (info_log) {
 206     info_log->clear();
 207     size_t info_log_len = 0;
 208     ShGetInfo(compiler_, SH_INFO_LOG_LENGTH, &info_log_len);
 209     if (info_log_len > 1) {
 210       scoped_ptr<char[]> buffer(new char[info_log_len]);
 211       ShGetInfoLog(compiler_, buffer.get());
 212       *info_log = std::string(buffer.get(), info_log_len - 1);
 213     }
 214   }
 215
 216   return success;
 217 }
 218
 219 std::string ShaderTranslator::GetStringForOptionsThatWouldAffectCompilation()
 220     const {
 221   DCHECK(compiler_ != NULL);
 222
 223   size_t resource_len = 0;
 224   ShGetInfo(compiler_, SH_RESOURCES_STRING_LENGTH, &resource_len);
 225   DCHECK(resource_len > 1);
 226   scoped_ptr<char[]> resource_str(new char[resource_len]);
 227
 228   ShGetBuiltInResourcesString(compiler_, resource_len, resource_str.get());
 229
 230   return std::string(":CompileOptions:" +
 231          base::IntToString(GetCompileOptions())) +
 232          std::string(resource_str.get());
 233 }
 234
 235 void ShaderTranslator::AddDestructionObserver(
 236     DestructionObserver* observer) {
 237   destruction_observers_.AddObserver(observer);
 238 }
 239
 240 void ShaderTranslator::RemoveDestructionObserver(
 241     DestructionObserver* observer) {
 242   destruction_observers_.RemoveObserver(observer);
 243 }
 244
 245 ShaderTranslator::~ShaderTranslator() {
 246   FOR_EACH_OBSERVER(DestructionObserver,
 247                     destruction_observers_,
 248                     OnDestruct(this));
 249
 250   if (compiler_ != NULL)
 251     ShDestruct(compiler_);
 252 }
 253
 254 }  // namespace gles2
 255 }  // namespace gpu
 256