• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //
2 // Copyright 2021 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6 // trace_fixture.h:
7 //   Common code for the ANGLE trace replays.
8 //
9 
10 #ifndef ANGLE_TRACE_FIXTURE_H_
11 #define ANGLE_TRACE_FIXTURE_H_
12 
13 #include <EGL/egl.h>
14 #include <EGL/eglext.h>
15 #include <math.h>
16 #include <stddef.h>
17 #include <stdint.h>
18 
19 #include "angle_gl.h"
20 #include "trace_interface.h"
21 #include "traces_export.h"
22 
23 #if defined(__cplusplus)
24 #    include <cstdio>
25 #    include <cstring>
26 #    include <limits>
27 #    include <unordered_map>
28 #    include <vector>
29 
30 // TODO(jmadill): Consolidate. http://anglebug.com/7753
31 using BlockIndexesMap = std::unordered_map<GLuint, std::unordered_map<GLuint, GLuint>>;
32 extern BlockIndexesMap gUniformBlockIndexes;
33 using BufferHandleMap = std::unordered_map<GLuint, void *>;
34 extern BufferHandleMap gMappedBufferData;
35 using ClientBufferMap = std::unordered_map<uintptr_t, EGLClientBuffer>;
36 extern ClientBufferMap gClientBufferMap;
37 using EGLImageMap = std::unordered_map<uintptr_t, GLeglImageOES>;
38 extern EGLImageMap gEGLImageMap;
39 using SyncResourceMap = std::unordered_map<uintptr_t, GLsync>;
40 extern SyncResourceMap gSyncMap;
41 using SurfaceMap = std::unordered_map<uintptr_t, EGLSurface>;
42 extern SurfaceMap gSurfaceMap;
43 using ContextMap = std::unordered_map<uintptr_t, EGLContext>;
44 extern ContextMap gContextMap;
45 
46 extern std::string gBinaryDataDir;
47 extern angle::TraceInfo gTraceInfo;
48 extern std::string gTraceGzPath;
49 
50 using ValidateSerializedStateCallback = void (*)(const char *, const char *, uint32_t);
51 
52 extern "C" {
53 
54 // Functions implemented by traces.
55 // "not exported" tag is a hack to get around trace interpreter codegen -_-
56 /* not exported */ void SetupReplay();
57 /* not exported */ void ReplayFrame(uint32_t frameIndex);
58 /* not exported */ void ResetReplay();
59 /* not exported */ void FinishReplay();
60 
61 ANGLE_REPLAY_EXPORT void SetValidateSerializedStateCallback(
62     ValidateSerializedStateCallback callback);
63 
64 // Only defined if serialization is enabled.
65 ANGLE_REPLAY_EXPORT const char *GetSerializedContextState(uint32_t frameIndex);
66 
67 ANGLE_REPLAY_EXPORT void SetupEntryPoints(angle::TraceCallbacks *traceCallbacks,
68                                           angle::TraceFunctions **traceFunctions);
69 #endif  // defined(__cplusplus)
70 
71 // Maps from <captured Program ID, captured location> to run-time location.
72 extern GLint **gUniformLocations;
73 extern GLuint gCurrentProgram;
74 
75 void UpdateUniformLocation(GLuint program, const char *name, GLint location, GLint count);
76 void DeleteUniformLocations(GLuint program);
77 void UpdateUniformBlockIndex(GLuint program, const char *name, GLuint index);
78 void UniformBlockBinding(GLuint program, GLuint uniformblockIndex, GLuint binding);
79 void UpdateCurrentProgram(GLuint program);
80 
81 // Global state
82 
83 extern uint8_t *gBinaryData;
84 extern uint8_t *gReadBuffer;
85 extern uint8_t *gClientArrays[];
86 extern GLuint *gResourceIDBuffer;
87 
88 extern GLuint *gBufferMap;
89 extern GLuint *gFenceNVMap;
90 extern GLuint *gFramebufferMap;
91 extern GLuint *gMemoryObjectMap;
92 extern GLuint *gProgramPipelineMap;
93 extern GLuint *gQueryMap;
94 extern GLuint *gRenderbufferMap;
95 extern GLuint *gSamplerMap;
96 extern GLuint *gSemaphoreMap;
97 extern GLuint *gShaderProgramMap;
98 extern GLuint *gTextureMap;
99 extern GLuint *gTransformFeedbackMap;
100 extern GLuint *gVertexArrayMap;
101 
102 // TODO(jmadill): Consolidate. http://anglebug.com/7753
103 extern GLeglImageOES *gEGLImageMap2;
104 extern EGLSurface *gSurfaceMap2;
105 extern EGLContext *gContextMap2;
106 extern GLsync *gSyncMap2;
107 extern EGLSync *gEGLSyncMap;
108 extern EGLDisplay gEGLDisplay;
109 extern angle::ReplayResourceMode gReplayResourceMode;
110 
111 void InitializeReplay4(const char *binaryDataFileName,
112                        size_t maxClientArraySize,
113                        size_t readBufferSize,
114                        size_t resourceIDBufferSize,
115                        GLuint contextId,
116                        uint32_t maxBuffer,
117                        uint32_t maxContext,
118                        uint32_t maxFenceNV,
119                        uint32_t maxFramebuffer,
120                        uint32_t maxImage,
121                        uint32_t maxMemoryObject,
122                        uint32_t maxProgramPipeline,
123                        uint32_t maxQuery,
124                        uint32_t maxRenderbuffer,
125                        uint32_t maxSampler,
126                        uint32_t maxSemaphore,
127                        uint32_t maxShaderProgram,
128                        uint32_t maxSurface,
129                        uint32_t maxSync,
130                        uint32_t maxTexture,
131                        uint32_t maxTransformFeedback,
132                        uint32_t maxVertexArray,
133                        uint32_t maxEGLSyncID);
134 
135 void InitializeReplay3(const char *binaryDataFileName,
136                        size_t maxClientArraySize,
137                        size_t readBufferSize,
138                        size_t resourceIDBufferSize,
139                        GLuint contextId,
140                        uint32_t maxBuffer,
141                        uint32_t maxContext,
142                        uint32_t maxFenceNV,
143                        uint32_t maxFramebuffer,
144                        uint32_t maxImage,
145                        uint32_t maxMemoryObject,
146                        uint32_t maxProgramPipeline,
147                        uint32_t maxQuery,
148                        uint32_t maxRenderbuffer,
149                        uint32_t maxSampler,
150                        uint32_t maxSemaphore,
151                        uint32_t maxShaderProgram,
152                        uint32_t maxSurface,
153                        uint32_t maxSync,
154                        uint32_t maxTexture,
155                        uint32_t maxTransformFeedback,
156                        uint32_t maxVertexArray);
157 
158 void InitializeReplay2(const char *binaryDataFileName,
159                        size_t maxClientArraySize,
160                        size_t readBufferSize,
161                        GLuint contextId,
162                        uint32_t maxBuffer,
163                        uint32_t maxContext,
164                        uint32_t maxFenceNV,
165                        uint32_t maxFramebuffer,
166                        uint32_t maxImage,
167                        uint32_t maxMemoryObject,
168                        uint32_t maxProgramPipeline,
169                        uint32_t maxQuery,
170                        uint32_t maxRenderbuffer,
171                        uint32_t maxSampler,
172                        uint32_t maxSemaphore,
173                        uint32_t maxShaderProgram,
174                        uint32_t maxSurface,
175                        uint32_t maxTexture,
176                        uint32_t maxTransformFeedback,
177                        uint32_t maxVertexArray);
178 
179 void InitializeReplay(const char *binaryDataFileName,
180                       size_t maxClientArraySize,
181                       size_t readBufferSize,
182                       uint32_t maxBuffer,
183                       uint32_t maxFenceNV,
184                       uint32_t maxFramebuffer,
185                       uint32_t maxMemoryObject,
186                       uint32_t maxProgramPipeline,
187                       uint32_t maxQuery,
188                       uint32_t maxRenderbuffer,
189                       uint32_t maxSampler,
190                       uint32_t maxSemaphore,
191                       uint32_t maxShaderProgram,
192                       uint32_t maxTexture,
193                       uint32_t maxTransformFeedback,
194                       uint32_t maxVertexArray);
195 
196 void UpdateClientArrayPointer(int arrayIndex, const void *data, uint64_t size);
197 void UpdateClientBufferData(GLuint bufferID, const void *source, GLsizei size);
198 void UpdateClientBufferDataWithOffset(GLuint bufferID,
199                                       const void *source,
200                                       GLsizei size,
201                                       GLsizei offset);
202 void UpdateResourceIDBuffer(int resourceIndex, GLuint id);
203 void UpdateBufferID(GLuint id, GLsizei readBufferOffset);
204 void UpdateFenceNVID(GLuint id, GLsizei readBufferOffset);
205 void UpdateFramebufferID(GLuint id, GLsizei readBufferOffset);
206 void UpdateMemoryObjectID(GLuint id, GLsizei readBufferOffset);
207 void UpdateProgramPipelineID(GLuint id, GLsizei readBufferOffset);
208 void UpdateQueryID(GLuint id, GLsizei readBufferOffset);
209 void UpdateRenderbufferID(GLuint id, GLsizei readBufferOffset);
210 void UpdateSamplerID(GLuint id, GLsizei readBufferOffset);
211 void UpdateSemaphoreID(GLuint id, GLsizei readBufferOffset);
212 void UpdateShaderProgramID(GLuint id, GLsizei readBufferOffset);
213 void UpdateTextureID(GLuint id, GLsizei readBufferOffset);
214 void UpdateTransformFeedbackID(GLuint id, GLsizei readBufferOffset);
215 void UpdateVertexArrayID(GLuint id, GLsizei readBufferOffset);
216 
217 void SetCurrentContextID(GLuint id);
218 
219 void SetFramebufferID(GLuint id);
220 void SetBufferID(GLuint id);
221 void SetRenderbufferID(GLuint id);
222 void SetTextureID(GLuint id);
223 
224 // These functions allow the traces to change variable assignments into function calls,
225 // which makes it so the trace C interpreter doesn't need to implement operators at all.
226 void MapBufferRange(GLenum target,
227                     GLintptr offset,
228                     GLsizeiptr length,
229                     GLbitfield access,
230                     GLuint buffer);
231 void MapBufferRangeEXT(GLenum target,
232                        GLintptr offset,
233                        GLsizeiptr length,
234                        GLbitfield access,
235                        GLuint buffer);
236 void MapBufferOES(GLenum target, GLbitfield access, GLuint buffer);
237 void CreateShader(GLenum shaderType, GLuint shaderProgram);
238 void CreateProgram(GLuint shaderProgram);
239 void CreateShaderProgramv(GLenum type,
240                           GLsizei count,
241                           const GLchar *const *strings,
242                           GLuint shaderProgram);
243 void FenceSync(GLenum condition, GLbitfield flags, uintptr_t fenceSync);
244 void FenceSync2(GLenum condition, GLbitfield flags, uintptr_t fenceSync);
245 void CreateEGLImage(EGLDisplay dpy,
246                     EGLContext ctx,
247                     EGLenum target,
248                     uintptr_t buffer,
249                     const EGLAttrib *attrib_list,
250                     GLsizei width,
251                     GLsizei height,
252                     GLuint imageID);
253 void CreateEGLImageKHR(EGLDisplay dpy,
254                        EGLContext ctx,
255                        EGLenum target,
256                        uintptr_t buffer,
257                        const EGLint *attrib_list,
258                        GLsizei width,
259                        GLsizei height,
260                        GLuint imageID);
261 void DestroyEGLImage(EGLDisplay dpy, EGLImage image, GLuint imageID);
262 void DestroyEGLImageKHR(EGLDisplay dpy, EGLImageKHR image, GLuint imageID);
263 void CreateEGLSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list, GLuint syncID);
264 void CreateEGLSync(EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list, GLuint syncID);
265 void CreatePbufferSurface(EGLDisplay dpy,
266                           EGLConfig config,
267                           const EGLint *attrib_list,
268                           GLuint surfaceID);
269 void CreateNativeClientBufferANDROID(const EGLint *attrib_list, uintptr_t clientBuffer);
270 void CreateContext(GLuint contextID);
271 
272 void ValidateSerializedState(const char *serializedState, const char *fileName, uint32_t line);
273 #define VALIDATE_CHECKPOINT(STATE) ValidateSerializedState(STATE, __FILE__, __LINE__)
274 
275 #if defined(__cplusplus)
276 }       // extern "C"
277 #endif  // defined(__cplusplus)
278 
279 #endif  // ANGLE_TRACE_FIXTURE_H_
280