Home | History | Annotate | Download | only in service 
      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 
    257