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 #ifndef GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_ 6 #define GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_ 7 8 #include <GLES2/gl2.h> 9 10 #include <map> 11 #include <queue> 12 #include <set> 13 #include <string> 14 #include <vector> 15 16 #include "base/compiler_specific.h" 17 #include "base/memory/scoped_ptr.h" 18 #include "base/memory/weak_ptr.h" 19 #include "gles2_impl_export.h" 20 #include "gpu/command_buffer/client/buffer_tracker.h" 21 #include "gpu/command_buffer/client/client_context_state.h" 22 #include "gpu/command_buffer/client/context_support.h" 23 #include "gpu/command_buffer/client/gles2_cmd_helper.h" 24 #include "gpu/command_buffer/client/gles2_interface.h" 25 #include "gpu/command_buffer/client/gpu_memory_buffer_tracker.h" 26 #include "gpu/command_buffer/client/mapped_memory.h" 27 #include "gpu/command_buffer/client/query_tracker.h" 28 #include "gpu/command_buffer/client/ref_counted.h" 29 #include "gpu/command_buffer/client/ring_buffer.h" 30 #include "gpu/command_buffer/client/share_group.h" 31 #include "gpu/command_buffer/common/capabilities.h" 32 #include "gpu/command_buffer/common/debug_marker_manager.h" 33 #include "gpu/command_buffer/common/gles2_cmd_utils.h" 34 35 #if !defined(NDEBUG) && !defined(__native_client__) && !defined(GLES2_CONFORMANCE_TESTS) // NOLINT 36 #if defined(GLES2_INLINE_OPTIMIZATION) 37 // TODO(gman): Replace with macros that work with inline optmization. 38 #define GPU_CLIENT_SINGLE_THREAD_CHECK() 39 #define GPU_CLIENT_LOG(args) 40 #define GPU_CLIENT_LOG_CODE_BLOCK(code) 41 #define GPU_CLIENT_DCHECK_CODE_BLOCK(code) 42 #else 43 #include "base/logging.h" 44 #define GPU_CLIENT_SINGLE_THREAD_CHECK() SingleThreadChecker checker(this); 45 #define GPU_CLIENT_LOG(args) DLOG_IF(INFO, debug_) << args; 46 #define GPU_CLIENT_LOG_CODE_BLOCK(code) code 47 #define GPU_CLIENT_DCHECK_CODE_BLOCK(code) code 48 #define GPU_CLIENT_DEBUG 49 #endif 50 #else 51 #define GPU_CLIENT_SINGLE_THREAD_CHECK() 52 #define GPU_CLIENT_LOG(args) 53 #define GPU_CLIENT_LOG_CODE_BLOCK(code) 54 #define GPU_CLIENT_DCHECK_CODE_BLOCK(code) 55 #endif 56 57 #if defined(GPU_CLIENT_DEBUG) 58 // Set to 1 to have the client fail when a GL error is generated. 59 // This helps find bugs in the renderer since the debugger stops on the error. 60 # if 0 61 # define GL_CLIENT_FAIL_GL_ERRORS 62 # endif 63 #endif 64 65 // Check that destination pointers point to initialized memory. 66 // When the context is lost, calling GL function has no effect so if destination 67 // pointers point to initialized memory it can often lead to crash bugs. eg. 68 // 69 // GLsizei len; 70 // glGetShaderSource(shader, max_size, &len, buffer); 71 // std::string src(buffer, buffer + len); // len can be uninitialized here!!! 72 // 73 // Because this check is not official GL this check happens only on Chrome code, 74 // not Pepper. 75 // 76 // If it was up to us we'd just always write to the destination but the OpenGL 77 // spec defines the behavior of OpenGL functions, not us. :-( 78 #if defined(__native_client__) || defined(GLES2_CONFORMANCE_TESTS) 79 #define GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(v) 80 #define GPU_CLIENT_DCHECK(v) 81 #elif defined(GPU_DCHECK) 82 #define GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(v) GPU_DCHECK(v) 83 #define GPU_CLIENT_DCHECK(v) GPU_DCHECK(v) 84 #elif defined(DCHECK) 85 #define GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(v) DCHECK(v) 86 #define GPU_CLIENT_DCHECK(v) DCHECK(v) 87 #else 88 #define GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(v) ASSERT(v) 89 #define GPU_CLIENT_DCHECK(v) ASSERT(v) 90 #endif 91 92 #define GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION(type, ptr) \ 93 GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(ptr && \ 94 (ptr[0] == static_cast<type>(0) || ptr[0] == static_cast<type>(-1))); 95 96 #define GPU_CLIENT_VALIDATE_DESTINATION_OPTIONAL_INITALIZATION(type, ptr) \ 97 GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(!ptr || \ 98 (ptr[0] == static_cast<type>(0) || ptr[0] == static_cast<type>(-1))); 99 100 struct GLUniformDefinitionCHROMIUM; 101 102 namespace gpu { 103 104 class GpuControl; 105 class ScopedTransferBufferPtr; 106 class TransferBufferInterface; 107 108 namespace gles2 { 109 110 class ImageFactory; 111 class VertexArrayObjectManager; 112 113 class GLES2ImplementationErrorMessageCallback { 114 public: 115 virtual ~GLES2ImplementationErrorMessageCallback() { } 116 virtual void OnErrorMessage(const char* msg, int id) = 0; 117 }; 118 119 // This class emulates GLES2 over command buffers. It can be used by a client 120 // program so that the program does not need deal with shared memory and command 121 // buffer management. See gl2_lib.h. Note that there is a performance gain to 122 // be had by changing your code to use command buffers directly by using the 123 // GLES2CmdHelper but that entails changing your code to use and deal with 124 // shared memory and synchronization issues. 125 class GLES2_IMPL_EXPORT GLES2Implementation 126 : NON_EXPORTED_BASE(public GLES2Interface), 127 NON_EXPORTED_BASE(public ContextSupport) { 128 public: 129 enum MappedMemoryLimit { 130 kNoLimit = MappedMemoryManager::kNoLimit, 131 }; 132 133 // Stores GL state that never changes. 134 struct GLES2_IMPL_EXPORT GLStaticState { 135 GLStaticState(); 136 ~GLStaticState(); 137 138 struct GLES2_IMPL_EXPORT IntState { 139 IntState(); 140 GLint max_combined_texture_image_units; 141 GLint max_cube_map_texture_size; 142 GLint max_fragment_uniform_vectors; 143 GLint max_renderbuffer_size; 144 GLint max_texture_image_units; 145 GLint max_texture_size; 146 GLint max_varying_vectors; 147 GLint max_vertex_attribs; 148 GLint max_vertex_texture_image_units; 149 GLint max_vertex_uniform_vectors; 150 GLint num_compressed_texture_formats; 151 GLint num_shader_binary_formats; 152 GLint bind_generates_resource_chromium; 153 }; 154 IntState int_state; 155 156 typedef std::pair<GLenum,GLenum> ShaderPrecisionKey; 157 typedef std::map<ShaderPrecisionKey, 158 cmds::GetShaderPrecisionFormat::Result> 159 ShaderPrecisionMap; 160 ShaderPrecisionMap shader_precisions; 161 }; 162 163 // The maxiumum result size from simple GL get commands. 164 static const size_t kMaxSizeOfSimpleResult = 16 * sizeof(uint32); // NOLINT. 165 166 // used for testing only. If more things are reseved add them here. 167 static const unsigned int kStartingOffset = kMaxSizeOfSimpleResult; 168 169 // Size in bytes to issue async flush for transfer buffer. 170 static const unsigned int kSizeToFlush = 256 * 1024; 171 172 // The bucket used for results. Public for testing only. 173 static const uint32 kResultBucketId = 1; 174 175 // Alignment of allocations. 176 static const unsigned int kAlignment = 4; 177 178 // GL names for the buffers used to emulate client side buffers. 179 static const GLuint kClientSideArrayId = 0xFEDCBA98u; 180 static const GLuint kClientSideElementArrayId = 0xFEDCBA99u; 181 182 // Number of swap buffers allowed before waiting. 183 static const size_t kMaxSwapBuffers = 2; 184 185 GLES2Implementation(GLES2CmdHelper* helper, 186 ShareGroup* share_group, 187 TransferBufferInterface* transfer_buffer, 188 bool bind_generates_resource, 189 bool lose_context_when_out_of_memory, 190 GpuControl* gpu_control); 191 192 virtual ~GLES2Implementation(); 193 194 bool Initialize( 195 unsigned int starting_transfer_buffer_size, 196 unsigned int min_transfer_buffer_size, 197 unsigned int max_transfer_buffer_size, 198 unsigned int mapped_memory_limit); 199 200 // The GLES2CmdHelper being used by this GLES2Implementation. You can use 201 // this to issue cmds at a lower level for certain kinds of optimization. 202 GLES2CmdHelper* helper() const; 203 204 // Gets client side generated errors. 205 GLenum GetClientSideGLError(); 206 207 // Include the auto-generated part of this class. We split this because 208 // it means we can easily edit the non-auto generated parts right here in 209 // this file instead of having to edit some template or the code generator. 210 #include "gpu/command_buffer/client/gles2_implementation_autogen.h" 211 212 virtual void DisableVertexAttribArray(GLuint index) OVERRIDE; 213 virtual void EnableVertexAttribArray(GLuint index) OVERRIDE; 214 virtual void GetVertexAttribfv( 215 GLuint index, GLenum pname, GLfloat* params) OVERRIDE; 216 virtual void GetVertexAttribiv( 217 GLuint index, GLenum pname, GLint* params) OVERRIDE; 218 219 // ContextSupport implementation. 220 virtual void Swap() OVERRIDE; 221 virtual void PartialSwapBuffers(const gfx::Rect& sub_buffer) OVERRIDE; 222 virtual void SetSwapBuffersCompleteCallback( 223 const base::Closure& swap_buffers_complete_callback) 224 OVERRIDE; 225 virtual void ScheduleOverlayPlane(int plane_z_order, 226 gfx::OverlayTransform plane_transform, 227 unsigned overlay_texture_id, 228 const gfx::Rect& display_bounds, 229 const gfx::RectF& uv_rect) OVERRIDE; 230 231 void GetProgramInfoCHROMIUMHelper(GLuint program, std::vector<int8>* result); 232 GLint GetAttribLocationHelper(GLuint program, const char* name); 233 GLint GetUniformLocationHelper(GLuint program, const char* name); 234 bool GetActiveAttribHelper( 235 GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, 236 GLint* size, GLenum* type, char* name); 237 bool GetActiveUniformHelper( 238 GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, 239 GLint* size, GLenum* type, char* name); 240 241 void FreeUnusedSharedMemory(); 242 void FreeEverything(); 243 244 // ContextSupport implementation. 245 virtual void SignalSyncPoint(uint32 sync_point, 246 const base::Closure& callback) OVERRIDE; 247 virtual void SignalQuery(uint32 query, 248 const base::Closure& callback) OVERRIDE; 249 virtual void SetSurfaceVisible(bool visible) OVERRIDE; 250 251 void SetErrorMessageCallback( 252 GLES2ImplementationErrorMessageCallback* callback) { 253 error_message_callback_ = callback; 254 } 255 256 ShareGroup* share_group() const { 257 return share_group_.get(); 258 } 259 260 const Capabilities& capabilities() const { 261 return capabilities_; 262 } 263 264 GpuControl* gpu_control() { 265 return gpu_control_; 266 } 267 268 ShareGroupContextData* share_group_context_data() { 269 return &share_group_context_data_; 270 } 271 272 private: 273 friend class GLES2ImplementationTest; 274 friend class VertexArrayObjectManager; 275 276 // Used to track whether an extension is available 277 enum ExtensionStatus { 278 kAvailableExtensionStatus, 279 kUnavailableExtensionStatus, 280 kUnknownExtensionStatus 281 }; 282 283 // Base class for mapped resources. 284 struct MappedResource { 285 MappedResource(GLenum _access, int _shm_id, void* mem, unsigned int offset) 286 : access(_access), 287 shm_id(_shm_id), 288 shm_memory(mem), 289 shm_offset(offset) { 290 } 291 292 // access mode. Currently only GL_WRITE_ONLY is valid 293 GLenum access; 294 295 // Shared memory ID for buffer. 296 int shm_id; 297 298 // Address of shared memory 299 void* shm_memory; 300 301 // Offset of shared memory 302 unsigned int shm_offset; 303 }; 304 305 // Used to track mapped textures. 306 struct MappedTexture : public MappedResource { 307 MappedTexture( 308 GLenum access, 309 int shm_id, 310 void* shm_mem, 311 unsigned int shm_offset, 312 GLenum _target, 313 GLint _level, 314 GLint _xoffset, 315 GLint _yoffset, 316 GLsizei _width, 317 GLsizei _height, 318 GLenum _format, 319 GLenum _type) 320 : MappedResource(access, shm_id, shm_mem, shm_offset), 321 target(_target), 322 level(_level), 323 xoffset(_xoffset), 324 yoffset(_yoffset), 325 width(_width), 326 height(_height), 327 format(_format), 328 type(_type) { 329 } 330 331 // These match the arguments to TexSubImage2D. 332 GLenum target; 333 GLint level; 334 GLint xoffset; 335 GLint yoffset; 336 GLsizei width; 337 GLsizei height; 338 GLenum format; 339 GLenum type; 340 }; 341 342 // Used to track mapped buffers. 343 struct MappedBuffer : public MappedResource { 344 MappedBuffer( 345 GLenum access, 346 int shm_id, 347 void* shm_mem, 348 unsigned int shm_offset, 349 GLenum _target, 350 GLintptr _offset, 351 GLsizeiptr _size) 352 : MappedResource(access, shm_id, shm_mem, shm_offset), 353 target(_target), 354 offset(_offset), 355 size(_size) { 356 } 357 358 // These match the arguments to BufferSubData. 359 GLenum target; 360 GLintptr offset; 361 GLsizeiptr size; 362 }; 363 364 struct TextureUnit { 365 TextureUnit() 366 : bound_texture_2d(0), 367 bound_texture_cube_map(0), 368 bound_texture_external_oes(0) {} 369 370 // texture currently bound to this unit's GL_TEXTURE_2D with glBindTexture 371 GLuint bound_texture_2d; 372 373 // texture currently bound to this unit's GL_TEXTURE_CUBE_MAP with 374 // glBindTexture 375 GLuint bound_texture_cube_map; 376 377 // texture currently bound to this unit's GL_TEXTURE_EXTERNAL_OES with 378 // glBindTexture 379 GLuint bound_texture_external_oes; 380 }; 381 382 // Checks for single threaded access. 383 class SingleThreadChecker { 384 public: 385 SingleThreadChecker(GLES2Implementation* gles2_implementation); 386 ~SingleThreadChecker(); 387 388 private: 389 GLES2Implementation* gles2_implementation_; 390 }; 391 392 // Gets the value of the result. 393 template <typename T> 394 T GetResultAs() { 395 return static_cast<T>(GetResultBuffer()); 396 } 397 398 void* GetResultBuffer(); 399 int32 GetResultShmId(); 400 uint32 GetResultShmOffset(); 401 402 bool QueryAndCacheStaticState(); 403 404 // Helpers used to batch synchronous GetIntergerv calls with other 405 // synchronous calls. 406 struct GetMultipleIntegervState { 407 GetMultipleIntegervState(const GLenum* pnames, GLuint pnames_count, 408 GLint* results, GLsizeiptr results_size) 409 : pnames(pnames), 410 pnames_count(pnames_count), 411 results(results), 412 results_size(results_size) 413 { } 414 // inputs 415 const GLenum* pnames; 416 GLuint pnames_count; 417 // outputs 418 GLint* results; 419 GLsizeiptr results_size; 420 // transfer buffer 421 int num_results; 422 int transfer_buffer_size_needed; 423 void* buffer; 424 void* results_buffer; 425 }; 426 bool GetMultipleIntegervSetup( 427 GetMultipleIntegervState* state); 428 void GetMultipleIntegervRequest( 429 GetMultipleIntegervState* state); 430 void GetMultipleIntegervOnCompleted( 431 GetMultipleIntegervState* state); 432 433 // Helpers used to batch synchronous GetShaderPrecision calls with other 434 // synchronous calls. 435 struct GetAllShaderPrecisionFormatsState { 436 GetAllShaderPrecisionFormatsState( 437 const GLenum (*precision_params)[2], 438 int precision_params_count) 439 : precision_params(precision_params), 440 precision_params_count(precision_params_count) 441 { } 442 const GLenum (*precision_params)[2]; 443 int precision_params_count; 444 int transfer_buffer_size_needed; 445 void* results_buffer; 446 }; 447 void GetAllShaderPrecisionFormatsSetup( 448 GetAllShaderPrecisionFormatsState* state); 449 void GetAllShaderPrecisionFormatsRequest( 450 GetAllShaderPrecisionFormatsState* state); 451 void GetAllShaderPrecisionFormatsOnCompleted( 452 GetAllShaderPrecisionFormatsState* state); 453 454 // Lazily determines if GL_ANGLE_pack_reverse_row_order is available 455 bool IsAnglePackReverseRowOrderAvailable(); 456 bool IsChromiumFramebufferMultisampleAvailable(); 457 458 bool IsExtensionAvailableHelper( 459 const char* extension, ExtensionStatus* status); 460 461 // Gets the GLError through our wrapper. 462 GLenum GetGLError(); 463 464 // Sets our wrapper for the GLError. 465 void SetGLError(GLenum error, const char* function_name, const char* msg); 466 void SetGLErrorInvalidEnum( 467 const char* function_name, GLenum value, const char* label); 468 469 // Returns the last error and clears it. Useful for debugging. 470 const std::string& GetLastError() { 471 return last_error_; 472 } 473 474 // Waits for all commands to execute. 475 void WaitForCmd(); 476 477 // TODO(gman): These bucket functions really seem like they belong in 478 // CommandBufferHelper (or maybe BucketHelper?). Unfortunately they need 479 // a transfer buffer to function which is currently managed by this class. 480 481 // Gets the contents of a bucket. 482 bool GetBucketContents(uint32 bucket_id, std::vector<int8>* data); 483 484 // Sets the contents of a bucket. 485 void SetBucketContents(uint32 bucket_id, const void* data, size_t size); 486 487 // Sets the contents of a bucket as a string. 488 void SetBucketAsCString(uint32 bucket_id, const char* str); 489 490 // Gets the contents of a bucket as a string. Returns false if there is no 491 // string available which is a separate case from the empty string. 492 bool GetBucketAsString(uint32 bucket_id, std::string* str); 493 494 // Sets the contents of a bucket as a string. 495 void SetBucketAsString(uint32 bucket_id, const std::string& str); 496 497 // Returns true if id is reserved. 498 bool IsBufferReservedId(GLuint id); 499 bool IsFramebufferReservedId(GLuint id) { return false; } 500 bool IsRenderbufferReservedId(GLuint id) { return false; } 501 bool IsTextureReservedId(GLuint id) { return false; } 502 bool IsVertexArrayReservedId(GLuint id) { return false; } 503 bool IsProgramReservedId(GLuint id) { return false; } 504 505 bool BindBufferHelper(GLenum target, GLuint texture); 506 bool BindFramebufferHelper(GLenum target, GLuint texture); 507 bool BindRenderbufferHelper(GLenum target, GLuint texture); 508 bool BindTextureHelper(GLenum target, GLuint texture); 509 bool BindVertexArrayOESHelper(GLuint array); 510 bool UseProgramHelper(GLuint program); 511 512 void GenBuffersHelper(GLsizei n, const GLuint* buffers); 513 void GenFramebuffersHelper(GLsizei n, const GLuint* framebuffers); 514 void GenRenderbuffersHelper(GLsizei n, const GLuint* renderbuffers); 515 void GenTexturesHelper(GLsizei n, const GLuint* textures); 516 void GenVertexArraysOESHelper(GLsizei n, const GLuint* arrays); 517 void GenQueriesEXTHelper(GLsizei n, const GLuint* queries); 518 519 void DeleteBuffersHelper(GLsizei n, const GLuint* buffers); 520 void DeleteFramebuffersHelper(GLsizei n, const GLuint* framebuffers); 521 void DeleteRenderbuffersHelper(GLsizei n, const GLuint* renderbuffers); 522 void DeleteTexturesHelper(GLsizei n, const GLuint* textures); 523 bool DeleteProgramHelper(GLuint program); 524 bool DeleteShaderHelper(GLuint shader); 525 void DeleteQueriesEXTHelper(GLsizei n, const GLuint* queries); 526 void DeleteVertexArraysOESHelper(GLsizei n, const GLuint* arrays); 527 528 void DeleteBuffersStub(GLsizei n, const GLuint* buffers); 529 void DeleteFramebuffersStub(GLsizei n, const GLuint* framebuffers); 530 void DeleteRenderbuffersStub(GLsizei n, const GLuint* renderbuffers); 531 void DeleteTexturesStub(GLsizei n, const GLuint* textures); 532 void DeleteProgramStub(GLsizei n, const GLuint* programs); 533 void DeleteShaderStub(GLsizei n, const GLuint* shaders); 534 // TODO(gman): Remove this as queries are not shared. 535 void DeleteQueriesStub(GLsizei n, const GLuint* queries); 536 void DeleteVertexArraysOESStub(GLsizei n, const GLuint* arrays); 537 538 void BufferDataHelper( 539 GLenum target, GLsizeiptr size, const void* data, GLenum usage); 540 void BufferSubDataHelper( 541 GLenum target, GLintptr offset, GLsizeiptr size, const void* data); 542 void BufferSubDataHelperImpl( 543 GLenum target, GLintptr offset, GLsizeiptr size, const void* data, 544 ScopedTransferBufferPtr* buffer); 545 546 GLuint CreateImageCHROMIUMHelper(GLsizei width, 547 GLsizei height, 548 GLenum internalformat, 549 GLenum usage); 550 void DestroyImageCHROMIUMHelper(GLuint image_id); 551 void* MapImageCHROMIUMHelper(GLuint image_id); 552 void UnmapImageCHROMIUMHelper(GLuint image_id); 553 void GetImageParameterivCHROMIUMHelper( 554 GLuint image_id, GLenum pname, GLint* params); 555 556 // Helper for GetVertexAttrib 557 bool GetVertexAttribHelper(GLuint index, GLenum pname, uint32* param); 558 559 GLuint GetMaxValueInBufferCHROMIUMHelper( 560 GLuint buffer_id, GLsizei count, GLenum type, GLuint offset); 561 562 void RestoreElementAndArrayBuffers(bool restore); 563 void RestoreArrayBuffer(bool restrore); 564 565 // The pixels pointer should already account for unpack skip rows and skip 566 // pixels. 567 void TexSubImage2DImpl( 568 GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, 569 GLsizei height, GLenum format, GLenum type, uint32 unpadded_row_size, 570 const void* pixels, uint32 pixels_padded_row_size, GLboolean internal, 571 ScopedTransferBufferPtr* buffer, uint32 buffer_padded_row_size); 572 573 // Helpers for query functions. 574 bool GetHelper(GLenum pname, GLint* params); 575 bool GetBooleanvHelper(GLenum pname, GLboolean* params); 576 bool GetBufferParameterivHelper(GLenum target, GLenum pname, GLint* params); 577 bool GetFloatvHelper(GLenum pname, GLfloat* params); 578 bool GetFramebufferAttachmentParameterivHelper( 579 GLenum target, GLenum attachment, GLenum pname, GLint* params); 580 bool GetIntegervHelper(GLenum pname, GLint* params); 581 bool GetProgramivHelper(GLuint program, GLenum pname, GLint* params); 582 bool GetRenderbufferParameterivHelper( 583 GLenum target, GLenum pname, GLint* params); 584 bool GetShaderivHelper(GLuint shader, GLenum pname, GLint* params); 585 bool GetTexParameterfvHelper(GLenum target, GLenum pname, GLfloat* params); 586 bool GetTexParameterivHelper(GLenum target, GLenum pname, GLint* params); 587 const GLubyte* GetStringHelper(GLenum name); 588 589 bool IsExtensionAvailable(const char* ext); 590 591 // Caches certain capabilties state. Return true if cached. 592 bool SetCapabilityState(GLenum cap, bool enabled); 593 594 IdHandlerInterface* GetIdHandler(int id_namespace) const; 595 596 void FinishHelper(); 597 598 void RunIfContextNotLost(const base::Closure& callback); 599 600 void OnSwapBuffersComplete(); 601 602 // Validate if an offset is valid, i.e., non-negative and fit into 32-bit. 603 // If not, generate an approriate error, and return false. 604 bool ValidateOffset(const char* func, GLintptr offset); 605 606 // Validate if a size is valid, i.e., non-negative and fit into 32-bit. 607 // If not, generate an approriate error, and return false. 608 bool ValidateSize(const char* func, GLsizeiptr offset); 609 610 // Remove the transfer buffer from the buffer tracker. For buffers used 611 // asynchronously the memory is free:ed if the upload has completed. For 612 // other buffers, the memory is either free:ed immediately or free:ed pending 613 // a token. 614 void RemoveTransferBuffer(BufferTracker::Buffer* buffer); 615 616 // Returns true if the async upload token has passed. 617 // 618 // NOTE: This will detect wrapped async tokens by checking if the most 619 // significant bit of async token to check is 1 but the last read is 0, i.e. 620 // the uint32 wrapped. 621 bool HasAsyncUploadTokenPassed(uint32 token) const { 622 return async_upload_sync_->HasAsyncUploadTokenPassed(token); 623 } 624 625 // Get the next async upload token. 626 uint32 NextAsyncUploadToken(); 627 628 // Ensure that the shared memory used for synchronizing async upload tokens 629 // has been mapped. 630 // 631 // Returns false on error, true on success. 632 bool EnsureAsyncUploadSync(); 633 634 // Checks the last read asynchronously upload token and frees any unmanaged 635 // transfer buffer that has its async token passed. 636 void PollAsyncUploads(); 637 638 // Free every async upload buffer. If some async upload buffer is still in use 639 // wait for them to finish before freeing. 640 void FreeAllAsyncUploadBuffers(); 641 642 bool GetBoundPixelTransferBuffer( 643 GLenum target, const char* function_name, GLuint* buffer_id); 644 BufferTracker::Buffer* GetBoundPixelUnpackTransferBufferIfValid( 645 GLuint buffer_id, 646 const char* function_name, GLuint offset, GLsizei size); 647 648 const std::string& GetLogPrefix() const; 649 650 #if defined(GL_CLIENT_FAIL_GL_ERRORS) 651 void CheckGLError(); 652 void FailGLError(GLenum error); 653 #else 654 void CheckGLError() { } 655 void FailGLError(GLenum /* error */) { } 656 #endif 657 658 GLES2Util util_; 659 GLES2CmdHelper* helper_; 660 TransferBufferInterface* transfer_buffer_; 661 std::string last_error_; 662 DebugMarkerManager debug_marker_manager_; 663 std::string this_in_hex_; 664 665 std::queue<int32> swap_buffers_tokens_; 666 std::queue<int32> rate_limit_tokens_; 667 668 ExtensionStatus angle_pack_reverse_row_order_status_; 669 ExtensionStatus chromium_framebuffer_multisample_; 670 671 GLStaticState static_state_; 672 ClientContextState state_; 673 674 // pack alignment as last set by glPixelStorei 675 GLint pack_alignment_; 676 677 // unpack alignment as last set by glPixelStorei 678 GLint unpack_alignment_; 679 680 // unpack yflip as last set by glPixelstorei 681 bool unpack_flip_y_; 682 683 // unpack row length as last set by glPixelStorei 684 GLint unpack_row_length_; 685 686 // unpack skip rows as last set by glPixelStorei 687 GLint unpack_skip_rows_; 688 689 // unpack skip pixels as last set by glPixelStorei 690 GLint unpack_skip_pixels_; 691 692 // pack reverse row order as last set by glPixelstorei 693 bool pack_reverse_row_order_; 694 695 scoped_ptr<TextureUnit[]> texture_units_; 696 697 // 0 to gl_state_.max_combined_texture_image_units. 698 GLuint active_texture_unit_; 699 700 GLuint bound_framebuffer_; 701 GLuint bound_read_framebuffer_; 702 GLuint bound_renderbuffer_; 703 704 // The program in use by glUseProgram 705 GLuint current_program_; 706 707 // The currently bound array buffer. 708 GLuint bound_array_buffer_id_; 709 710 // The currently bound pixel transfer buffers. 711 GLuint bound_pixel_pack_transfer_buffer_id_; 712 GLuint bound_pixel_unpack_transfer_buffer_id_; 713 714 // The current asynchronous pixel buffer upload token. 715 uint32 async_upload_token_; 716 717 // The shared memory used for synchronizing asynchronous upload tokens. 718 AsyncUploadSync* async_upload_sync_; 719 int32 async_upload_sync_shm_id_; 720 unsigned int async_upload_sync_shm_offset_; 721 722 // Unmanaged pixel transfer buffer memory pending asynchronous upload token. 723 typedef std::list<std::pair<void*, uint32> > DetachedAsyncUploadMemoryList; 724 DetachedAsyncUploadMemoryList detached_async_upload_memory_; 725 726 // Client side management for vertex array objects. Needed to correctly 727 // track client side arrays. 728 scoped_ptr<VertexArrayObjectManager> vertex_array_object_manager_; 729 730 GLuint reserved_ids_[2]; 731 732 // Current GL error bits. 733 uint32 error_bits_; 734 735 // Whether or not to print debugging info. 736 bool debug_; 737 738 // When true, the context is lost when a GL_OUT_OF_MEMORY error occurs. 739 bool lose_context_when_out_of_memory_; 740 741 // Used to check for single threaded access. 742 int use_count_; 743 744 // Map of GLenum to Strings for glGetString. We need to cache these because 745 // the pointer passed back to the client has to remain valid for eternity. 746 typedef std::map<uint32, std::set<std::string> > GLStringMap; 747 GLStringMap gl_strings_; 748 749 // Similar cache for glGetRequestableExtensionsCHROMIUM. We don't 750 // have an enum for this so handle it separately. 751 std::set<std::string> requestable_extensions_set_; 752 753 typedef std::map<const void*, MappedBuffer> MappedBufferMap; 754 MappedBufferMap mapped_buffers_; 755 756 typedef std::map<const void*, MappedTexture> MappedTextureMap; 757 MappedTextureMap mapped_textures_; 758 759 scoped_ptr<MappedMemoryManager> mapped_memory_; 760 761 scoped_refptr<ShareGroup> share_group_; 762 ShareGroupContextData share_group_context_data_; 763 764 scoped_ptr<QueryTracker> query_tracker_; 765 typedef std::map<GLuint, QueryTracker::Query*> QueryMap; 766 QueryMap current_queries_; 767 768 scoped_ptr<BufferTracker> buffer_tracker_; 769 770 scoped_ptr<GpuMemoryBufferTracker> gpu_memory_buffer_tracker_; 771 772 GLES2ImplementationErrorMessageCallback* error_message_callback_; 773 774 scoped_ptr<std::string> current_trace_name_; 775 776 GpuControl* gpu_control_; 777 778 Capabilities capabilities_; 779 780 base::Closure swap_buffers_complete_callback_; 781 782 base::WeakPtrFactory<GLES2Implementation> weak_ptr_factory_; 783 784 DISALLOW_COPY_AND_ASSIGN(GLES2Implementation); 785 }; 786 787 inline bool GLES2Implementation::GetBufferParameterivHelper( 788 GLenum /* target */, GLenum /* pname */, GLint* /* params */) { 789 return false; 790 } 791 792 inline bool GLES2Implementation::GetFramebufferAttachmentParameterivHelper( 793 GLenum /* target */, 794 GLenum /* attachment */, 795 GLenum /* pname */, 796 GLint* /* params */) { 797 return false; 798 } 799 800 inline bool GLES2Implementation::GetRenderbufferParameterivHelper( 801 GLenum /* target */, GLenum /* pname */, GLint* /* params */) { 802 return false; 803 } 804 805 inline bool GLES2Implementation::GetShaderivHelper( 806 GLuint /* shader */, GLenum /* pname */, GLint* /* params */) { 807 return false; 808 } 809 810 inline bool GLES2Implementation::GetTexParameterfvHelper( 811 GLenum /* target */, GLenum /* pname */, GLfloat* /* params */) { 812 return false; 813 } 814 815 inline bool GLES2Implementation::GetTexParameterivHelper( 816 GLenum /* target */, GLenum /* pname */, GLint* /* params */) { 817 return false; 818 } 819 820 } // namespace gles2 821 } // namespace gpu 822 823 #endif // GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_ 824