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:
~GLES2ImplementationErrorMessageCallback()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
NON_EXPORTED_BASE(public GLES2Interface)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
GetBufferParameterivHelper(GLenum,GLenum,GLint *)795 inline bool GLES2Implementation::GetBufferParameterivHelper(
796 GLenum /* target */, GLenum /* pname */, GLint* /* params */) {
797 return false;
798 }
799
GetFramebufferAttachmentParameterivHelper(GLenum,GLenum,GLenum,GLint *)800 inline bool GLES2Implementation::GetFramebufferAttachmentParameterivHelper(
801 GLenum /* target */,
802 GLenum /* attachment */,
803 GLenum /* pname */,
804 GLint* /* params */) {
805 return false;
806 }
807
GetRenderbufferParameterivHelper(GLenum,GLenum,GLint *)808 inline bool GLES2Implementation::GetRenderbufferParameterivHelper(
809 GLenum /* target */, GLenum /* pname */, GLint* /* params */) {
810 return false;
811 }
812
GetShaderivHelper(GLuint,GLenum,GLint *)813 inline bool GLES2Implementation::GetShaderivHelper(
814 GLuint /* shader */, GLenum /* pname */, GLint* /* params */) {
815 return false;
816 }
817
GetTexParameterfvHelper(GLenum,GLenum,GLfloat *)818 inline bool GLES2Implementation::GetTexParameterfvHelper(
819 GLenum /* target */, GLenum /* pname */, GLfloat* /* params */) {
820 return false;
821 }
822
GetTexParameterivHelper(GLenum,GLenum,GLint *)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