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/context_group.h" 6 7 #include <algorithm> 8 #include <string> 9 10 #include "base/command_line.h" 11 #include "base/strings/string_util.h" 12 #include "base/sys_info.h" 13 #include "gpu/command_buffer/common/id_allocator.h" 14 #include "gpu/command_buffer/service/buffer_manager.h" 15 #include "gpu/command_buffer/service/framebuffer_manager.h" 16 #include "gpu/command_buffer/service/gles2_cmd_decoder.h" 17 #include "gpu/command_buffer/service/gpu_switches.h" 18 #include "gpu/command_buffer/service/mailbox_manager.h" 19 #include "gpu/command_buffer/service/memory_tracking.h" 20 #include "gpu/command_buffer/service/program_manager.h" 21 #include "gpu/command_buffer/service/renderbuffer_manager.h" 22 #include "gpu/command_buffer/service/shader_manager.h" 23 #include "gpu/command_buffer/service/texture_manager.h" 24 #include "gpu/command_buffer/service/transfer_buffer_manager.h" 25 #include "ui/gl/gl_implementation.h" 26 27 namespace gpu { 28 namespace gles2 { 29 30 ContextGroup::ContextGroup( 31 const scoped_refptr<MailboxManager>& mailbox_manager, 32 const scoped_refptr<MemoryTracker>& memory_tracker, 33 const scoped_refptr<ShaderTranslatorCache>& shader_translator_cache, 34 const scoped_refptr<FeatureInfo>& feature_info, 35 bool bind_generates_resource) 36 : mailbox_manager_(mailbox_manager), 37 memory_tracker_(memory_tracker), 38 shader_translator_cache_(shader_translator_cache), 39 enforce_gl_minimums_(CommandLine::ForCurrentProcess()->HasSwitch( 40 switches::kEnforceGLMinimums)), 41 bind_generates_resource_(bind_generates_resource), 42 max_vertex_attribs_(0u), 43 max_texture_units_(0u), 44 max_texture_image_units_(0u), 45 max_vertex_texture_image_units_(0u), 46 max_fragment_uniform_vectors_(0u), 47 max_varying_vectors_(0u), 48 max_vertex_uniform_vectors_(0u), 49 max_color_attachments_(1u), 50 max_draw_buffers_(1u), 51 program_cache_(NULL), 52 feature_info_(feature_info), 53 draw_buffer_(GL_BACK) { 54 { 55 if (!mailbox_manager_.get()) 56 mailbox_manager_ = new MailboxManager; 57 if (!feature_info.get()) 58 feature_info_ = new FeatureInfo; 59 TransferBufferManager* manager = new TransferBufferManager(); 60 transfer_buffer_manager_.reset(manager); 61 manager->Initialize(); 62 } 63 64 id_namespaces_[id_namespaces::kBuffers].reset(new IdAllocator); 65 id_namespaces_[id_namespaces::kFramebuffers].reset(new IdAllocator); 66 id_namespaces_[id_namespaces::kProgramsAndShaders].reset( 67 new NonReusedIdAllocator); 68 id_namespaces_[id_namespaces::kRenderbuffers].reset(new IdAllocator); 69 id_namespaces_[id_namespaces::kTextures].reset(new IdAllocator); 70 id_namespaces_[id_namespaces::kQueries].reset(new IdAllocator); 71 id_namespaces_[id_namespaces::kVertexArrays].reset(new IdAllocator); 72 } 73 74 static void GetIntegerv(GLenum pname, uint32* var) { 75 GLint value = 0; 76 glGetIntegerv(pname, &value); 77 *var = value; 78 } 79 80 bool ContextGroup::Initialize( 81 GLES2Decoder* decoder, 82 const DisallowedFeatures& disallowed_features) { 83 // If we've already initialized the group just add the context. 84 if (HaveContexts()) { 85 decoders_.push_back(base::AsWeakPtr<GLES2Decoder>(decoder)); 86 return true; 87 } 88 89 if (!feature_info_->Initialize(disallowed_features)) { 90 LOG(ERROR) << "ContextGroup::Initialize failed because FeatureInfo " 91 << "initialization failed."; 92 return false; 93 } 94 95 const GLint kMinRenderbufferSize = 512; // GL says 1 pixel! 96 GLint max_renderbuffer_size = 0; 97 if (!QueryGLFeature( 98 GL_MAX_RENDERBUFFER_SIZE, kMinRenderbufferSize, 99 &max_renderbuffer_size)) { 100 LOG(ERROR) << "ContextGroup::Initialize failed because maximum " 101 << "renderbuffer size too small."; 102 return false; 103 } 104 GLint max_samples = 0; 105 if (feature_info_->feature_flags().chromium_framebuffer_multisample || 106 feature_info_->feature_flags().multisampled_render_to_texture) { 107 if (feature_info_->feature_flags( 108 ).use_img_for_multisampled_render_to_texture) { 109 glGetIntegerv(GL_MAX_SAMPLES_IMG, &max_samples); 110 } else { 111 glGetIntegerv(GL_MAX_SAMPLES, &max_samples); 112 } 113 } 114 115 if (feature_info_->feature_flags().ext_draw_buffers) { 116 GetIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT, &max_color_attachments_); 117 if (max_color_attachments_ < 1) 118 max_color_attachments_ = 1; 119 GetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &max_draw_buffers_); 120 if (max_draw_buffers_ < 1) 121 max_draw_buffers_ = 1; 122 draw_buffer_ = GL_BACK; 123 } 124 125 const bool depth24_supported = feature_info_->feature_flags().oes_depth24; 126 127 buffer_manager_.reset( 128 new BufferManager(memory_tracker_.get(), feature_info_.get())); 129 framebuffer_manager_.reset( 130 new FramebufferManager(max_draw_buffers_, max_color_attachments_)); 131 renderbuffer_manager_.reset(new RenderbufferManager( 132 memory_tracker_.get(), max_renderbuffer_size, max_samples, 133 depth24_supported)); 134 shader_manager_.reset(new ShaderManager()); 135 136 // Lookup GL things we need to know. 137 const GLint kGLES2RequiredMinimumVertexAttribs = 8u; 138 if (!QueryGLFeatureU( 139 GL_MAX_VERTEX_ATTRIBS, kGLES2RequiredMinimumVertexAttribs, 140 &max_vertex_attribs_)) { 141 LOG(ERROR) << "ContextGroup::Initialize failed because too few " 142 << "vertex attributes supported."; 143 return false; 144 } 145 146 const GLuint kGLES2RequiredMinimumTextureUnits = 8u; 147 if (!QueryGLFeatureU( 148 GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, kGLES2RequiredMinimumTextureUnits, 149 &max_texture_units_)) { 150 LOG(ERROR) << "ContextGroup::Initialize failed because too few " 151 << "texture units supported."; 152 return false; 153 } 154 155 GLint max_texture_size = 0; 156 GLint max_cube_map_texture_size = 0; 157 const GLint kMinTextureSize = 2048; // GL actually says 64!?!? 158 const GLint kMinCubeMapSize = 256; // GL actually says 16!?!? 159 if (!QueryGLFeature( 160 GL_MAX_TEXTURE_SIZE, kMinTextureSize, &max_texture_size) || 161 !QueryGLFeature( 162 GL_MAX_CUBE_MAP_TEXTURE_SIZE, kMinCubeMapSize, 163 &max_cube_map_texture_size)) { 164 LOG(ERROR) << "ContextGroup::Initialize failed because maximum texture size" 165 << "is too small."; 166 return false; 167 } 168 169 if (feature_info_->workarounds().max_texture_size) { 170 max_texture_size = std::min( 171 max_texture_size, feature_info_->workarounds().max_texture_size); 172 } 173 if (feature_info_->workarounds().max_cube_map_texture_size) { 174 max_cube_map_texture_size = std::min( 175 max_cube_map_texture_size, 176 feature_info_->workarounds().max_cube_map_texture_size); 177 } 178 179 texture_manager_.reset(new TextureManager(memory_tracker_.get(), 180 feature_info_.get(), 181 max_texture_size, 182 max_cube_map_texture_size, 183 bind_generates_resource_)); 184 texture_manager_->set_framebuffer_manager(framebuffer_manager_.get()); 185 186 const GLint kMinTextureImageUnits = 8; 187 const GLint kMinVertexTextureImageUnits = 0; 188 if (!QueryGLFeatureU( 189 GL_MAX_TEXTURE_IMAGE_UNITS, kMinTextureImageUnits, 190 &max_texture_image_units_) || 191 !QueryGLFeatureU( 192 GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, kMinVertexTextureImageUnits, 193 &max_vertex_texture_image_units_)) { 194 LOG(ERROR) << "ContextGroup::Initialize failed because too few " 195 << "texture units."; 196 return false; 197 } 198 199 if (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2) { 200 GetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS, 201 &max_fragment_uniform_vectors_); 202 GetIntegerv(GL_MAX_VARYING_VECTORS, &max_varying_vectors_); 203 GetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS, &max_vertex_uniform_vectors_); 204 } else { 205 GetIntegerv( 206 GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &max_fragment_uniform_vectors_); 207 max_fragment_uniform_vectors_ /= 4; 208 GetIntegerv(GL_MAX_VARYING_FLOATS, &max_varying_vectors_); 209 max_varying_vectors_ /= 4; 210 GetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, &max_vertex_uniform_vectors_); 211 max_vertex_uniform_vectors_ /= 4; 212 } 213 214 const GLint kMinFragmentUniformVectors = 16; 215 const GLint kMinVaryingVectors = 8; 216 const GLint kMinVertexUniformVectors = 128; 217 if (!CheckGLFeatureU( 218 kMinFragmentUniformVectors, &max_fragment_uniform_vectors_) || 219 !CheckGLFeatureU(kMinVaryingVectors, &max_varying_vectors_) || 220 !CheckGLFeatureU( 221 kMinVertexUniformVectors, &max_vertex_uniform_vectors_)) { 222 LOG(ERROR) << "ContextGroup::Initialize failed because too few " 223 << "uniforms or varyings supported."; 224 return false; 225 } 226 227 // Some shaders in Skia need more than the min available vertex and 228 // fragment shader uniform vectors in case of OSMesa GL Implementation 229 if (feature_info_->workarounds().max_fragment_uniform_vectors) { 230 max_fragment_uniform_vectors_ = std::min( 231 max_fragment_uniform_vectors_, 232 static_cast<uint32>( 233 feature_info_->workarounds().max_fragment_uniform_vectors)); 234 } 235 if (feature_info_->workarounds().max_varying_vectors) { 236 max_varying_vectors_ = std::min( 237 max_varying_vectors_, 238 static_cast<uint32>(feature_info_->workarounds().max_varying_vectors)); 239 } 240 if (feature_info_->workarounds().max_vertex_uniform_vectors) { 241 max_vertex_uniform_vectors_ = 242 std::min(max_vertex_uniform_vectors_, 243 static_cast<uint32>( 244 feature_info_->workarounds().max_vertex_uniform_vectors)); 245 } 246 247 program_manager_.reset(new ProgramManager( 248 program_cache_, max_varying_vectors_)); 249 250 if (!texture_manager_->Initialize()) { 251 LOG(ERROR) << "Context::Group::Initialize failed because texture manager " 252 << "failed to initialize."; 253 return false; 254 } 255 256 decoders_.push_back(base::AsWeakPtr<GLES2Decoder>(decoder)); 257 return true; 258 } 259 260 namespace { 261 262 bool IsNull(const base::WeakPtr<gles2::GLES2Decoder>& decoder) { 263 return !decoder.get(); 264 } 265 266 template <typename T> 267 class WeakPtrEquals { 268 public: 269 explicit WeakPtrEquals(T* t) : t_(t) {} 270 271 bool operator()(const base::WeakPtr<T>& t) { 272 return t.get() == t_; 273 } 274 275 private: 276 T* const t_; 277 }; 278 279 } // namespace anonymous 280 281 bool ContextGroup::HaveContexts() { 282 decoders_.erase(std::remove_if(decoders_.begin(), decoders_.end(), IsNull), 283 decoders_.end()); 284 return !decoders_.empty(); 285 } 286 287 void ContextGroup::Destroy(GLES2Decoder* decoder, bool have_context) { 288 decoders_.erase(std::remove_if(decoders_.begin(), decoders_.end(), 289 WeakPtrEquals<gles2::GLES2Decoder>(decoder)), 290 decoders_.end()); 291 // If we still have contexts do nothing. 292 if (HaveContexts()) { 293 return; 294 } 295 296 if (buffer_manager_ != NULL) { 297 buffer_manager_->Destroy(have_context); 298 buffer_manager_.reset(); 299 } 300 301 if (framebuffer_manager_ != NULL) { 302 framebuffer_manager_->Destroy(have_context); 303 if (texture_manager_) 304 texture_manager_->set_framebuffer_manager(NULL); 305 framebuffer_manager_.reset(); 306 } 307 308 if (renderbuffer_manager_ != NULL) { 309 renderbuffer_manager_->Destroy(have_context); 310 renderbuffer_manager_.reset(); 311 } 312 313 if (texture_manager_ != NULL) { 314 texture_manager_->Destroy(have_context); 315 texture_manager_.reset(); 316 } 317 318 if (program_manager_ != NULL) { 319 program_manager_->Destroy(have_context); 320 program_manager_.reset(); 321 } 322 323 if (shader_manager_ != NULL) { 324 shader_manager_->Destroy(have_context); 325 shader_manager_.reset(); 326 } 327 328 memory_tracker_ = NULL; 329 } 330 331 IdAllocatorInterface* ContextGroup::GetIdAllocator(unsigned namespace_id) { 332 if (namespace_id >= arraysize(id_namespaces_)) 333 return NULL; 334 335 return id_namespaces_[namespace_id].get(); 336 } 337 338 uint32 ContextGroup::GetMemRepresented() const { 339 uint32 total = 0; 340 if (buffer_manager_.get()) 341 total += buffer_manager_->mem_represented(); 342 if (renderbuffer_manager_.get()) 343 total += renderbuffer_manager_->mem_represented(); 344 if (texture_manager_.get()) 345 total += texture_manager_->mem_represented(); 346 return total; 347 } 348 349 void ContextGroup::LoseContexts(GLenum reset_status) { 350 for (size_t ii = 0; ii < decoders_.size(); ++ii) { 351 if (decoders_[ii].get()) { 352 decoders_[ii]->LoseContext(reset_status); 353 } 354 } 355 } 356 357 ContextGroup::~ContextGroup() { 358 CHECK(!HaveContexts()); 359 } 360 361 bool ContextGroup::CheckGLFeature(GLint min_required, GLint* v) { 362 GLint value = *v; 363 if (enforce_gl_minimums_) { 364 value = std::min(min_required, value); 365 } 366 *v = value; 367 return value >= min_required; 368 } 369 370 bool ContextGroup::CheckGLFeatureU(GLint min_required, uint32* v) { 371 GLint value = *v; 372 if (enforce_gl_minimums_) { 373 value = std::min(min_required, value); 374 } 375 *v = value; 376 return value >= min_required; 377 } 378 379 bool ContextGroup::QueryGLFeature( 380 GLenum pname, GLint min_required, GLint* v) { 381 GLint value = 0; 382 glGetIntegerv(pname, &value); 383 *v = value; 384 return CheckGLFeature(min_required, v); 385 } 386 387 bool ContextGroup::QueryGLFeatureU( 388 GLenum pname, GLint min_required, uint32* v) { 389 uint32 value = 0; 390 GetIntegerv(pname, &value); 391 bool result = CheckGLFeatureU(min_required, &value); 392 *v = value; 393 return result; 394 } 395 396 } // namespace gles2 397 } // namespace gpu 398
