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