gpu/command_buffer/client/program_info_manager.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 <map>
   6
   7 #include "base/compiler_specific.h"
   8 #include "gpu/command_buffer/client/atomicops.h"
   9 #include "gpu/command_buffer/client/gles2_implementation.h"
  10 #include "gpu/command_buffer/client/program_info_manager.h"
  11 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
  12
  13 namespace gpu {
  14 namespace gles2 {
  15
  16 class NonCachedProgramInfoManager : public ProgramInfoManager {
  17  public:
  18   NonCachedProgramInfoManager();
  19   virtual ~NonCachedProgramInfoManager();
  20
  21   virtual void CreateInfo(GLuint program) OVERRIDE;
  22
  23   virtual void DeleteInfo(GLuint program) OVERRIDE;
  24
  25   virtual bool GetProgramiv(GLES2Implementation* gl,
  26                             GLuint program,
  27                             GLenum pname,
  28                             GLint* params) OVERRIDE;
  29
  30   virtual GLint GetAttribLocation(GLES2Implementation* gl,
  31                                   GLuint program,
  32                                   const char* name) OVERRIDE;
  33
  34   virtual GLint GetUniformLocation(GLES2Implementation* gl,
  35                                    GLuint program,
  36                                    const char* name) OVERRIDE;
  37
  38   virtual bool GetActiveAttrib(GLES2Implementation* gl,
  39                                GLuint program,
  40                                GLuint index,
  41                                GLsizei bufsize,
  42                                GLsizei* length,
  43                                GLint* size,
  44                                GLenum* type,
  45                                char* name) OVERRIDE;
  46
  47   virtual bool GetActiveUniform(GLES2Implementation* gl,
  48                                 GLuint program,
  49                                 GLuint index,
  50                                 GLsizei bufsize,
  51                                 GLsizei* length,
  52                                 GLint* size,
  53                                 GLenum* type,
  54                                 char* name) OVERRIDE;
  55
  56 };
  57
  58 NonCachedProgramInfoManager::NonCachedProgramInfoManager() {
  59 }
  60
  61 NonCachedProgramInfoManager::~NonCachedProgramInfoManager() {
  62 }
  63
  64 void NonCachedProgramInfoManager::CreateInfo(GLuint /* program */) {
  65 }
  66
  67 void NonCachedProgramInfoManager::DeleteInfo(GLuint /* program */) {
  68 }
  69
  70 bool NonCachedProgramInfoManager::GetProgramiv(
  71     GLES2Implementation* /* gl */,
  72     GLuint /* program */,
  73     GLenum /* pname */,
  74     GLint* /* params */) {
  75   return false;
  76 }
  77
  78 GLint NonCachedProgramInfoManager::GetAttribLocation(
  79     GLES2Implementation* gl, GLuint program, const char* name) {
  80   return gl->GetAttribLocationHelper(program, name);
  81 }
  82
  83 GLint NonCachedProgramInfoManager::GetUniformLocation(
  84     GLES2Implementation* gl, GLuint program, const char* name) {
  85   return gl->GetUniformLocationHelper(program, name);
  86 }
  87
  88 bool NonCachedProgramInfoManager::GetActiveAttrib(
  89     GLES2Implementation* gl,
  90     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length,
  91     GLint* size, GLenum* type, char* name) {
  92   return gl->GetActiveAttribHelper(
  93       program, index, bufsize, length, size, type, name);
  94 }
  95
  96 bool NonCachedProgramInfoManager::GetActiveUniform(
  97     GLES2Implementation* gl,
  98     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length,
  99     GLint* size, GLenum* type, char* name) {
 100   return gl->GetActiveUniformHelper(
 101       program, index, bufsize, length, size, type, name);
 102 }
 103
 104 class CachedProgramInfoManager : public ProgramInfoManager {
 105  public:
 106   CachedProgramInfoManager();
 107   virtual ~CachedProgramInfoManager();
 108
 109   virtual void CreateInfo(GLuint program) OVERRIDE;
 110
 111   virtual void DeleteInfo(GLuint program) OVERRIDE;
 112
 113   virtual bool GetProgramiv(GLES2Implementation* gl,
 114                             GLuint program,
 115                             GLenum pname,
 116                             GLint* params) OVERRIDE;
 117
 118   virtual GLint GetAttribLocation(GLES2Implementation* gl,
 119                                   GLuint program,
 120                                   const char* name) OVERRIDE;
 121
 122   virtual GLint GetUniformLocation(GLES2Implementation* gl,
 123                                    GLuint program,
 124                                    const char* name) OVERRIDE;
 125
 126   virtual bool GetActiveAttrib(GLES2Implementation* gl,
 127                                GLuint program,
 128                                GLuint index,
 129                                GLsizei bufsize,
 130                                GLsizei* length,
 131                                GLint* size,
 132                                GLenum* type,
 133                                char* name) OVERRIDE;
 134
 135   virtual bool GetActiveUniform(GLES2Implementation* gl,
 136                                 GLuint program,
 137                                 GLuint index,
 138                                 GLsizei bufsize,
 139                                 GLsizei* length,
 140                                 GLint* size,
 141                                 GLenum* type,
 142                                 char* name) OVERRIDE;
 143
 144  private:
 145   class Program {
 146    public:
 147     struct UniformInfo {
 148       UniformInfo(GLsizei _size, GLenum _type, const std::string& _name);
 149
 150       GLsizei size;
 151       GLenum type;
 152       bool is_array;
 153       std::string name;
 154       std::vector<GLint> element_locations;
 155     };
 156     struct VertexAttrib {
 157       VertexAttrib(GLsizei _size, GLenum _type, const std::string& _name,
 158                        GLint _location)
 159           : size(_size),
 160             type(_type),
 161             location(_location),
 162             name(_name) {
 163       }
 164       GLsizei size;
 165       GLenum type;
 166       GLint location;
 167       std::string name;
 168     };
 169
 170     typedef std::vector<UniformInfo> UniformInfoVector;
 171     typedef std::vector<VertexAttrib> AttribInfoVector;
 172
 173     Program();
 174
 175     const AttribInfoVector& GetAttribInfos() const {
 176       return attrib_infos_;
 177     }
 178
 179     const VertexAttrib* GetAttribInfo(GLint index) const {
 180       return (static_cast<size_t>(index) < attrib_infos_.size()) ?
 181          &attrib_infos_[index] : NULL;
 182     }
 183
 184     GLint GetAttribLocation(const std::string& name) const;
 185
 186     const UniformInfo* GetUniformInfo(GLint index) const {
 187       return (static_cast<size_t>(index) < uniform_infos_.size()) ?
 188          &uniform_infos_[index] : NULL;
 189     }
 190
 191     // Gets the location of a uniform by name.
 192     GLint GetUniformLocation(const std::string& name) const;
 193
 194     bool GetProgramiv(GLenum pname, GLint* params);
 195
 196     // Updates the program info after a successful link.
 197     void Update(GLES2Implementation* gl, GLuint program);
 198
 199    private:
 200     bool cached_;
 201
 202     GLsizei max_attrib_name_length_;
 203
 204     // Attrib by index.
 205     AttribInfoVector attrib_infos_;
 206
 207     GLsizei max_uniform_name_length_;
 208
 209     // Uniform info by index.
 210     UniformInfoVector uniform_infos_;
 211
 212     // This is true if glLinkProgram was successful last time it was called.
 213     bool link_status_;
 214   };
 215
 216   Program* GetProgramInfo(GLES2Implementation* gl, GLuint program);
 217
 218   // TODO(gman): Switch to a faster container.
 219   typedef std::map<GLuint, Program> ProgramInfoMap;
 220
 221   ProgramInfoMap program_infos_;
 222
 223   mutable Lock lock_;
 224 };
 225
 226 CachedProgramInfoManager::Program::UniformInfo::UniformInfo(
 227     GLsizei _size, GLenum _type, const std::string& _name)
 228     : size(_size),
 229       type(_type),
 230       name(_name) {
 231   is_array = (!name.empty() && name[name.size() - 1] == ']');
 232   GPU_DCHECK(!(size > 1 && !is_array));
 233 }
 234
 235 CachedProgramInfoManager::Program::Program()
 236     : cached_(false),
 237       max_attrib_name_length_(0),
 238       max_uniform_name_length_(0),
 239       link_status_(false) {
 240 }
 241
 242 // TODO(gman): Add a faster lookup.
 243 GLint CachedProgramInfoManager::Program::GetAttribLocation(
 244     const std::string& name) const {
 245   for (GLuint ii = 0; ii < attrib_infos_.size(); ++ii) {
 246     const VertexAttrib& info = attrib_infos_[ii];
 247     if (info.name == name) {
 248       return info.location;
 249     }
 250   }
 251   return -1;
 252 }
 253
 254 GLint CachedProgramInfoManager::Program::GetUniformLocation(
 255     const std::string& name) const {
 256   bool getting_array_location = false;
 257   size_t open_pos = std::string::npos;
 258   int index = 0;
 259   if (!GLES2Util::ParseUniformName(
 260       name, &open_pos, &index, &getting_array_location)) {
 261     return -1;
 262   }
 263   for (GLuint ii = 0; ii < uniform_infos_.size(); ++ii) {
 264     const UniformInfo& info = uniform_infos_[ii];
 265     if (info.name == name ||
 266         (info.is_array &&
 267          info.name.compare(0, info.name.size() - 3, name) == 0)) {
 268       return info.element_locations[0];
 269     } else if (getting_array_location && info.is_array) {
 270       // Look for an array specification.
 271       size_t open_pos_2 = info.name.find_last_of('[');
 272       if (open_pos_2 == open_pos &&
 273           name.compare(0, open_pos, info.name, 0, open_pos) == 0) {
 274         if (index >= 0 && index < info.size) {
 275           return info.element_locations[index];
 276         }
 277       }
 278     }
 279   }
 280   return -1;
 281 }
 282
 283 bool CachedProgramInfoManager::Program::GetProgramiv(
 284     GLenum pname, GLint* params) {
 285   switch (pname) {
 286     case GL_LINK_STATUS:
 287       *params = link_status_;
 288       return true;
 289     case GL_ACTIVE_ATTRIBUTES:
 290       *params = attrib_infos_.size();
 291       return true;
 292     case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
 293       *params = max_attrib_name_length_;
 294       return true;
 295     case GL_ACTIVE_UNIFORMS:
 296       *params = uniform_infos_.size();
 297       return true;
 298     case GL_ACTIVE_UNIFORM_MAX_LENGTH:
 299       *params = max_uniform_name_length_;
 300       return true;
 301     default:
 302       break;
 303   }
 304   return false;
 305 }
 306
 307 template<typename T> static T LocalGetAs(
 308     const std::vector<int8>& data, uint32 offset, size_t size) {
 309   const int8* p = &data[0] + offset;
 310   if (offset + size > data.size()) {
 311     GPU_NOTREACHED();
 312     return NULL;
 313   }
 314   return static_cast<T>(static_cast<const void*>(p));
 315 }
 316
 317 void CachedProgramInfoManager::Program::Update(
 318     GLES2Implementation* gl, GLuint program) {
 319   if (cached_) {
 320     return;
 321   }
 322   std::vector<int8> result;
 323   gl->GetProgramInfoCHROMIUMHelper(program, &result);
 324   if (result.empty()) {
 325     // This should only happen on a lost context.
 326     return;
 327   }
 328   GPU_DCHECK_GE(result.size(), sizeof(ProgramInfoHeader));
 329   const ProgramInfoHeader* header = LocalGetAs<const ProgramInfoHeader*>(
 330       result, 0, sizeof(header));
 331   link_status_ = header->link_status != 0;
 332   if (!link_status_) {
 333     return;
 334   }
 335   attrib_infos_.clear();
 336   uniform_infos_.clear();
 337   max_attrib_name_length_ = 0;
 338   max_uniform_name_length_ = 0;
 339   const ProgramInput* inputs = LocalGetAs<const ProgramInput*>(
 340       result, sizeof(*header),
 341       sizeof(ProgramInput) * (header->num_attribs + header->num_uniforms));
 342   const ProgramInput* input = inputs;
 343   for (uint32 ii = 0; ii < header->num_attribs; ++ii) {
 344     const int32* location = LocalGetAs<const int32*>(
 345         result, input->location_offset, sizeof(int32));
 346     const char* name_buf = LocalGetAs<const char*>(
 347         result, input->name_offset, input->name_length);
 348     std::string name(name_buf, input->name_length);
 349     attrib_infos_.push_back(
 350         VertexAttrib(input->size, input->type, name, *location));
 351     max_attrib_name_length_ = std::max(
 352         static_cast<GLsizei>(name.size() + 1), max_attrib_name_length_);
 353     ++input;
 354   }
 355   for (uint32 ii = 0; ii < header->num_uniforms; ++ii) {
 356     const int32* locations = LocalGetAs<const int32*>(
 357         result, input->location_offset, sizeof(int32) * input->size);
 358     const char* name_buf = LocalGetAs<const char*>(
 359         result, input->name_offset, input->name_length);
 360     std::string name(name_buf, input->name_length);
 361     UniformInfo info(input->size, input->type, name);
 362     max_uniform_name_length_ = std::max(
 363         static_cast<GLsizei>(name.size() + 1), max_uniform_name_length_);
 364     for (int32 jj = 0; jj < input->size; ++jj) {
 365       info.element_locations.push_back(locations[jj]);
 366     }
 367     uniform_infos_.push_back(info);
 368     ++input;
 369   }
 370   GPU_DCHECK_EQ(header->num_attribs + header->num_uniforms,
 371                 static_cast<uint32>(input - inputs));
 372   cached_ = true;
 373 }
 374
 375 CachedProgramInfoManager::CachedProgramInfoManager() {
 376 }
 377
 378 CachedProgramInfoManager::~CachedProgramInfoManager() {
 379
 380 }
 381
 382 CachedProgramInfoManager::Program*
 383     CachedProgramInfoManager::GetProgramInfo(
 384         GLES2Implementation* gl, GLuint program) {
 385   ProgramInfoMap::iterator it = program_infos_.find(program);
 386   if (it == program_infos_.end()) {
 387     return NULL;
 388   }
 389   Program* info = &it->second;
 390   info->Update(gl, program);
 391   return info;
 392 }
 393
 394 void CachedProgramInfoManager::CreateInfo(GLuint program) {
 395   AutoLock auto_lock(lock_);
 396   DeleteInfo(program);
 397   std::pair<ProgramInfoMap::iterator, bool> result =
 398       program_infos_.insert(std::make_pair(program, Program()));
 399
 400   GPU_DCHECK(result.second);
 401 }
 402
 403 void CachedProgramInfoManager::DeleteInfo(GLuint program) {
 404   program_infos_.erase(program);
 405 }
 406
 407 bool CachedProgramInfoManager::GetProgramiv(
 408     GLES2Implementation* gl, GLuint program, GLenum pname, GLint* params) {
 409   AutoLock auto_lock(lock_);
 410   Program* info = GetProgramInfo(gl, program);
 411   if (!info) {
 412     return false;
 413   }
 414   return info->GetProgramiv(pname, params);
 415 }
 416
 417 GLint CachedProgramInfoManager::GetAttribLocation(
 418     GLES2Implementation* gl, GLuint program, const char* name) {
 419   AutoLock auto_lock(lock_);
 420   Program* info = GetProgramInfo(gl, program);
 421   if (info) {
 422     return info->GetAttribLocation(name);
 423   }
 424   return gl->GetAttribLocationHelper(program, name);
 425 }
 426
 427 GLint CachedProgramInfoManager::GetUniformLocation(
 428     GLES2Implementation* gl, GLuint program, const char* name) {
 429   AutoLock auto_lock(lock_);
 430   Program* info = GetProgramInfo(gl, program);
 431   if (info) {
 432     return info->GetUniformLocation(name);
 433   }
 434   return gl->GetUniformLocationHelper(program, name);
 435 }
 436
 437 bool CachedProgramInfoManager::GetActiveAttrib(
 438     GLES2Implementation* gl,
 439     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length,
 440     GLint* size, GLenum* type, char* name) {
 441   AutoLock auto_lock(lock_);
 442   Program* info = GetProgramInfo(gl, program);
 443   if (info) {
 444     const Program::VertexAttrib* attrib_info =
 445         info->GetAttribInfo(index);
 446     if (attrib_info) {
 447       if (size) {
 448         *size = attrib_info->size;
 449       }
 450       if (type) {
 451         *type = attrib_info->type;
 452       }
 453       if (length || name) {
 454         GLsizei max_size = std::min(static_cast<size_t>(bufsize) - 1,
 455                                     std::max(static_cast<size_t>(0),
 456                                              attrib_info->name.size()));
 457         if (length) {
 458           *length = max_size;
 459         }
 460         if (name && bufsize > 0) {
 461           memcpy(name, attrib_info->name.c_str(), max_size);
 462           name[max_size] = '\0';
 463         }
 464       }
 465       return true;
 466     }
 467   }
 468   return gl->GetActiveAttribHelper(
 469       program, index, bufsize, length, size, type, name);
 470 }
 471
 472 bool CachedProgramInfoManager::GetActiveUniform(
 473     GLES2Implementation* gl,
 474     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length,
 475     GLint* size, GLenum* type, char* name) {
 476   AutoLock auto_lock(lock_);
 477   Program* info = GetProgramInfo(gl, program);
 478   if (info) {
 479     const Program::UniformInfo* uniform_info = info->GetUniformInfo(index);
 480     if (uniform_info) {
 481       if (size) {
 482         *size = uniform_info->size;
 483       }
 484       if (type) {
 485         *type = uniform_info->type;
 486       }
 487       if (length || name) {
 488         GLsizei max_size = std::min(static_cast<size_t>(bufsize) - 1,
 489                                     std::max(static_cast<size_t>(0),
 490                                              uniform_info->name.size()));
 491         if (length) {
 492           *length = max_size;
 493         }
 494         if (name && bufsize > 0) {
 495           memcpy(name, uniform_info->name.c_str(), max_size);
 496           name[max_size] = '\0';
 497         }
 498       }
 499       return true;
 500     }
 501   }
 502   return gl->GetActiveUniformHelper(
 503       program, index, bufsize, length, size, type, name);
 504 }
 505
 506 ProgramInfoManager::ProgramInfoManager() {
 507 }
 508
 509 ProgramInfoManager::~ProgramInfoManager() {
 510 }
 511
 512 ProgramInfoManager* ProgramInfoManager::Create(
 513     bool shared_resources_across_processes) {
 514   if (shared_resources_across_processes) {
 515     return new NonCachedProgramInfoManager();
 516   } else {
 517     return new CachedProgramInfoManager();
 518   }
 519 }
 520
 521 }  // namespace gles2
 522 }  // namespace gpu
 523