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