1 // GENERATED FILE - DO NOT EDIT.
2 // Generated by generate_entry_points.py using data from egl.xml and egl_angle_ext.xml.
3 //
4 // Copyright 2020 The ANGLE Project Authors. All rights reserved.
5 // Use of this source code is governed by a BSD-style license that can be
6 // found in the LICENSE file.
7 //
8 // capture_egl_autogen.cpp:
9 // Capture functions for the OpenGL ES all entry points.
10
11 #include "libANGLE/capture/capture_egl_autogen.h"
12
13 #include "common/gl_enum_utils.h"
14 #include "libANGLE/Context.h"
15 #include "libANGLE/capture/FrameCapture.h"
16 #include "libANGLE/validationEGL.h"
17
18 using namespace angle;
19
20 namespace egl
21 {
CaptureChooseConfig(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,const AttributeMap & attrib_listPacked,EGLConfig * configs,EGLint config_size,EGLint * num_config,EGLBoolean returnValue)22 CallCapture CaptureChooseConfig(egl::Thread *thread,
23 bool isCallValid,
24 egl::Display *dpyPacked,
25 const AttributeMap &attrib_listPacked,
26 EGLConfig *configs,
27 EGLint config_size,
28 EGLint *num_config,
29 EGLBoolean returnValue)
30 {
31 ParamBuffer paramBuffer;
32
33 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
34 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
35 paramBuffer.addValueParam("configs", ParamType::TEGLConfigPointer, configs);
36 paramBuffer.addValueParam("config_size", ParamType::TEGLint, config_size);
37 paramBuffer.addValueParam("num_config", ParamType::TEGLintPointer, num_config);
38
39 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
40 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
41 paramBuffer.addReturnValue(std::move(returnValueCapture));
42
43 return CallCapture(angle::EntryPoint::EGLChooseConfig, std::move(paramBuffer));
44 }
45
CaptureCopyBuffers(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLNativePixmapType target,EGLBoolean returnValue)46 CallCapture CaptureCopyBuffers(egl::Thread *thread,
47 bool isCallValid,
48 egl::Display *dpyPacked,
49 SurfaceID surfacePacked,
50 EGLNativePixmapType target,
51 EGLBoolean returnValue)
52 {
53 ParamBuffer paramBuffer;
54
55 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
56 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
57 paramBuffer.addValueParam("target", ParamType::TEGLNativePixmapType, target);
58
59 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
60 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
61 paramBuffer.addReturnValue(std::move(returnValueCapture));
62
63 return CallCapture(angle::EntryPoint::EGLCopyBuffers, std::move(paramBuffer));
64 }
65
CaptureCreateContext(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Config * configPacked,gl::ContextID share_contextPacked,const AttributeMap & attrib_listPacked,EGLContext returnValue)66 CallCapture CaptureCreateContext(egl::Thread *thread,
67 bool isCallValid,
68 egl::Display *dpyPacked,
69 egl::Config *configPacked,
70 gl::ContextID share_contextPacked,
71 const AttributeMap &attrib_listPacked,
72 EGLContext returnValue)
73 {
74 ParamBuffer paramBuffer;
75
76 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
77 paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
78 paramBuffer.addValueParam("share_contextPacked", ParamType::TContextID, share_contextPacked);
79 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
80
81 ParamCapture returnValueCapture("returnValue", ParamType::TEGLContext);
82 InitParamValue(ParamType::TEGLContext, returnValue, &returnValueCapture.value);
83 paramBuffer.addReturnValue(std::move(returnValueCapture));
84
85 return CallCapture(angle::EntryPoint::EGLCreateContext, std::move(paramBuffer));
86 }
87
CaptureCreatePbufferSurface(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Config * configPacked,const AttributeMap & attrib_listPacked,EGLSurface returnValue)88 CallCapture CaptureCreatePbufferSurface(egl::Thread *thread,
89 bool isCallValid,
90 egl::Display *dpyPacked,
91 egl::Config *configPacked,
92 const AttributeMap &attrib_listPacked,
93 EGLSurface returnValue)
94 {
95 ParamBuffer paramBuffer;
96
97 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
98 paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
99 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
100
101 ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface);
102 InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value);
103 paramBuffer.addReturnValue(std::move(returnValueCapture));
104
105 return CallCapture(angle::EntryPoint::EGLCreatePbufferSurface, std::move(paramBuffer));
106 }
107
CaptureCreatePixmapSurface(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Config * configPacked,EGLNativePixmapType pixmap,const AttributeMap & attrib_listPacked,EGLSurface returnValue)108 CallCapture CaptureCreatePixmapSurface(egl::Thread *thread,
109 bool isCallValid,
110 egl::Display *dpyPacked,
111 egl::Config *configPacked,
112 EGLNativePixmapType pixmap,
113 const AttributeMap &attrib_listPacked,
114 EGLSurface returnValue)
115 {
116 ParamBuffer paramBuffer;
117
118 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
119 paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
120 paramBuffer.addValueParam("pixmap", ParamType::TEGLNativePixmapType, pixmap);
121 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
122
123 ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface);
124 InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value);
125 paramBuffer.addReturnValue(std::move(returnValueCapture));
126
127 return CallCapture(angle::EntryPoint::EGLCreatePixmapSurface, std::move(paramBuffer));
128 }
129
CaptureCreateWindowSurface(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Config * configPacked,EGLNativeWindowType win,const AttributeMap & attrib_listPacked,EGLSurface returnValue)130 CallCapture CaptureCreateWindowSurface(egl::Thread *thread,
131 bool isCallValid,
132 egl::Display *dpyPacked,
133 egl::Config *configPacked,
134 EGLNativeWindowType win,
135 const AttributeMap &attrib_listPacked,
136 EGLSurface returnValue)
137 {
138 ParamBuffer paramBuffer;
139
140 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
141 paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
142 paramBuffer.addValueParam("win", ParamType::TEGLNativeWindowType, win);
143 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
144
145 ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface);
146 InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value);
147 paramBuffer.addReturnValue(std::move(returnValueCapture));
148
149 return CallCapture(angle::EntryPoint::EGLCreateWindowSurface, std::move(paramBuffer));
150 }
151
CaptureDestroyContext(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,gl::ContextID ctxPacked,EGLBoolean returnValue)152 CallCapture CaptureDestroyContext(egl::Thread *thread,
153 bool isCallValid,
154 egl::Display *dpyPacked,
155 gl::ContextID ctxPacked,
156 EGLBoolean returnValue)
157 {
158 ParamBuffer paramBuffer;
159
160 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
161 paramBuffer.addValueParam("ctxPacked", ParamType::TContextID, ctxPacked);
162
163 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
164 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
165 paramBuffer.addReturnValue(std::move(returnValueCapture));
166
167 return CallCapture(angle::EntryPoint::EGLDestroyContext, std::move(paramBuffer));
168 }
169
CaptureDestroySurface(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLBoolean returnValue)170 CallCapture CaptureDestroySurface(egl::Thread *thread,
171 bool isCallValid,
172 egl::Display *dpyPacked,
173 SurfaceID surfacePacked,
174 EGLBoolean returnValue)
175 {
176 ParamBuffer paramBuffer;
177
178 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
179 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
180
181 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
182 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
183 paramBuffer.addReturnValue(std::move(returnValueCapture));
184
185 return CallCapture(angle::EntryPoint::EGLDestroySurface, std::move(paramBuffer));
186 }
187
CaptureGetConfigAttrib(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Config * configPacked,EGLint attribute,EGLint * value,EGLBoolean returnValue)188 CallCapture CaptureGetConfigAttrib(egl::Thread *thread,
189 bool isCallValid,
190 egl::Display *dpyPacked,
191 egl::Config *configPacked,
192 EGLint attribute,
193 EGLint *value,
194 EGLBoolean returnValue)
195 {
196 ParamBuffer paramBuffer;
197
198 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
199 paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
200 paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
201 paramBuffer.addValueParam("value", ParamType::TEGLintPointer, value);
202
203 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
204 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
205 paramBuffer.addReturnValue(std::move(returnValueCapture));
206
207 return CallCapture(angle::EntryPoint::EGLGetConfigAttrib, std::move(paramBuffer));
208 }
209
CaptureGetConfigs(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLConfig * configs,EGLint config_size,EGLint * num_config,EGLBoolean returnValue)210 CallCapture CaptureGetConfigs(egl::Thread *thread,
211 bool isCallValid,
212 egl::Display *dpyPacked,
213 EGLConfig *configs,
214 EGLint config_size,
215 EGLint *num_config,
216 EGLBoolean returnValue)
217 {
218 ParamBuffer paramBuffer;
219
220 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
221 paramBuffer.addValueParam("configs", ParamType::TEGLConfigPointer, configs);
222 paramBuffer.addValueParam("config_size", ParamType::TEGLint, config_size);
223 paramBuffer.addValueParam("num_config", ParamType::TEGLintPointer, num_config);
224
225 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
226 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
227 paramBuffer.addReturnValue(std::move(returnValueCapture));
228
229 return CallCapture(angle::EntryPoint::EGLGetConfigs, std::move(paramBuffer));
230 }
231
CaptureGetCurrentDisplay(egl::Thread * thread,bool isCallValid,EGLDisplay returnValue)232 CallCapture CaptureGetCurrentDisplay(egl::Thread *thread, bool isCallValid, EGLDisplay returnValue)
233 {
234 ParamBuffer paramBuffer;
235
236 ParamCapture returnValueCapture("returnValue", ParamType::TEGLDisplay);
237 InitParamValue(ParamType::TEGLDisplay, returnValue, &returnValueCapture.value);
238 paramBuffer.addReturnValue(std::move(returnValueCapture));
239
240 return CallCapture(angle::EntryPoint::EGLGetCurrentDisplay, std::move(paramBuffer));
241 }
242
CaptureGetCurrentSurface(egl::Thread * thread,bool isCallValid,EGLint readdraw,EGLSurface returnValue)243 CallCapture CaptureGetCurrentSurface(egl::Thread *thread,
244 bool isCallValid,
245 EGLint readdraw,
246 EGLSurface returnValue)
247 {
248 ParamBuffer paramBuffer;
249
250 paramBuffer.addValueParam("readdraw", ParamType::TEGLint, readdraw);
251
252 ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface);
253 InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value);
254 paramBuffer.addReturnValue(std::move(returnValueCapture));
255
256 return CallCapture(angle::EntryPoint::EGLGetCurrentSurface, std::move(paramBuffer));
257 }
258
CaptureGetDisplay(egl::Thread * thread,bool isCallValid,EGLNativeDisplayType display_id,EGLDisplay returnValue)259 CallCapture CaptureGetDisplay(egl::Thread *thread,
260 bool isCallValid,
261 EGLNativeDisplayType display_id,
262 EGLDisplay returnValue)
263 {
264 ParamBuffer paramBuffer;
265
266 paramBuffer.addValueParam("display_id", ParamType::TEGLNativeDisplayType, display_id);
267
268 ParamCapture returnValueCapture("returnValue", ParamType::TEGLDisplay);
269 InitParamValue(ParamType::TEGLDisplay, returnValue, &returnValueCapture.value);
270 paramBuffer.addReturnValue(std::move(returnValueCapture));
271
272 return CallCapture(angle::EntryPoint::EGLGetDisplay, std::move(paramBuffer));
273 }
274
CaptureGetError(egl::Thread * thread,bool isCallValid,EGLint returnValue)275 CallCapture CaptureGetError(egl::Thread *thread, bool isCallValid, EGLint returnValue)
276 {
277 ParamBuffer paramBuffer;
278
279 ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
280 InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
281 paramBuffer.addReturnValue(std::move(returnValueCapture));
282
283 return CallCapture(angle::EntryPoint::EGLGetError, std::move(paramBuffer));
284 }
285
CaptureGetProcAddress(egl::Thread * thread,bool isCallValid,const char * procname,__eglMustCastToProperFunctionPointerType returnValue)286 CallCapture CaptureGetProcAddress(egl::Thread *thread,
287 bool isCallValid,
288 const char *procname,
289 __eglMustCastToProperFunctionPointerType returnValue)
290 {
291 ParamBuffer paramBuffer;
292
293 return CallCapture(angle::EntryPoint::EGLGetProcAddress, std::move(paramBuffer));
294 }
295
CaptureInitialize(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLint * major,EGLint * minor,EGLBoolean returnValue)296 CallCapture CaptureInitialize(egl::Thread *thread,
297 bool isCallValid,
298 egl::Display *dpyPacked,
299 EGLint *major,
300 EGLint *minor,
301 EGLBoolean returnValue)
302 {
303 ParamBuffer paramBuffer;
304
305 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
306 paramBuffer.addValueParam("major", ParamType::TEGLintPointer, major);
307 paramBuffer.addValueParam("minor", ParamType::TEGLintPointer, minor);
308
309 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
310 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
311 paramBuffer.addReturnValue(std::move(returnValueCapture));
312
313 return CallCapture(angle::EntryPoint::EGLInitialize, std::move(paramBuffer));
314 }
315
CaptureMakeCurrent(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID drawPacked,SurfaceID readPacked,gl::ContextID ctxPacked,EGLBoolean returnValue)316 CallCapture CaptureMakeCurrent(egl::Thread *thread,
317 bool isCallValid,
318 egl::Display *dpyPacked,
319 SurfaceID drawPacked,
320 SurfaceID readPacked,
321 gl::ContextID ctxPacked,
322 EGLBoolean returnValue)
323 {
324 ParamBuffer paramBuffer;
325
326 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
327 paramBuffer.addValueParam("drawPacked", ParamType::TSurfaceID, drawPacked);
328 paramBuffer.addValueParam("readPacked", ParamType::TSurfaceID, readPacked);
329 paramBuffer.addValueParam("ctxPacked", ParamType::TContextID, ctxPacked);
330
331 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
332 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
333 paramBuffer.addReturnValue(std::move(returnValueCapture));
334
335 return CallCapture(angle::EntryPoint::EGLMakeCurrent, std::move(paramBuffer));
336 }
337
CaptureQueryContext(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,gl::ContextID ctxPacked,EGLint attribute,EGLint * value,EGLBoolean returnValue)338 CallCapture CaptureQueryContext(egl::Thread *thread,
339 bool isCallValid,
340 egl::Display *dpyPacked,
341 gl::ContextID ctxPacked,
342 EGLint attribute,
343 EGLint *value,
344 EGLBoolean returnValue)
345 {
346 ParamBuffer paramBuffer;
347
348 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
349 paramBuffer.addValueParam("ctxPacked", ParamType::TContextID, ctxPacked);
350 paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
351 paramBuffer.addValueParam("value", ParamType::TEGLintPointer, value);
352
353 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
354 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
355 paramBuffer.addReturnValue(std::move(returnValueCapture));
356
357 return CallCapture(angle::EntryPoint::EGLQueryContext, std::move(paramBuffer));
358 }
359
CaptureQueryString(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLint name,const char * returnValue)360 CallCapture CaptureQueryString(egl::Thread *thread,
361 bool isCallValid,
362 egl::Display *dpyPacked,
363 EGLint name,
364 const char *returnValue)
365 {
366 ParamBuffer paramBuffer;
367
368 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
369 paramBuffer.addValueParam("name", ParamType::TEGLint, name);
370
371 ParamCapture returnValueCapture("returnValue", ParamType::TcharConstPointer);
372 InitParamValue(ParamType::TcharConstPointer, returnValue, &returnValueCapture.value);
373 paramBuffer.addReturnValue(std::move(returnValueCapture));
374
375 return CallCapture(angle::EntryPoint::EGLQueryString, std::move(paramBuffer));
376 }
377
CaptureQuerySurface(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLint attribute,EGLint * value,EGLBoolean returnValue)378 CallCapture CaptureQuerySurface(egl::Thread *thread,
379 bool isCallValid,
380 egl::Display *dpyPacked,
381 SurfaceID surfacePacked,
382 EGLint attribute,
383 EGLint *value,
384 EGLBoolean returnValue)
385 {
386 ParamBuffer paramBuffer;
387
388 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
389 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
390 paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
391 paramBuffer.addValueParam("value", ParamType::TEGLintPointer, value);
392
393 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
394 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
395 paramBuffer.addReturnValue(std::move(returnValueCapture));
396
397 return CallCapture(angle::EntryPoint::EGLQuerySurface, std::move(paramBuffer));
398 }
399
CaptureSwapBuffers(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLBoolean returnValue)400 CallCapture CaptureSwapBuffers(egl::Thread *thread,
401 bool isCallValid,
402 egl::Display *dpyPacked,
403 SurfaceID surfacePacked,
404 EGLBoolean returnValue)
405 {
406 ParamBuffer paramBuffer;
407
408 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
409 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
410
411 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
412 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
413 paramBuffer.addReturnValue(std::move(returnValueCapture));
414
415 return CallCapture(angle::EntryPoint::EGLSwapBuffers, std::move(paramBuffer));
416 }
417
CaptureTerminate(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLBoolean returnValue)418 CallCapture CaptureTerminate(egl::Thread *thread,
419 bool isCallValid,
420 egl::Display *dpyPacked,
421 EGLBoolean returnValue)
422 {
423 ParamBuffer paramBuffer;
424
425 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
426
427 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
428 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
429 paramBuffer.addReturnValue(std::move(returnValueCapture));
430
431 return CallCapture(angle::EntryPoint::EGLTerminate, std::move(paramBuffer));
432 }
433
CaptureWaitGL(egl::Thread * thread,bool isCallValid,EGLBoolean returnValue)434 CallCapture CaptureWaitGL(egl::Thread *thread, bool isCallValid, EGLBoolean returnValue)
435 {
436 ParamBuffer paramBuffer;
437
438 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
439 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
440 paramBuffer.addReturnValue(std::move(returnValueCapture));
441
442 return CallCapture(angle::EntryPoint::EGLWaitGL, std::move(paramBuffer));
443 }
444
CaptureWaitNative(egl::Thread * thread,bool isCallValid,EGLint engine,EGLBoolean returnValue)445 CallCapture CaptureWaitNative(egl::Thread *thread,
446 bool isCallValid,
447 EGLint engine,
448 EGLBoolean returnValue)
449 {
450 ParamBuffer paramBuffer;
451
452 paramBuffer.addValueParam("engine", ParamType::TEGLint, engine);
453
454 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
455 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
456 paramBuffer.addReturnValue(std::move(returnValueCapture));
457
458 return CallCapture(angle::EntryPoint::EGLWaitNative, std::move(paramBuffer));
459 }
460
CaptureBindTexImage(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLint buffer,EGLBoolean returnValue)461 CallCapture CaptureBindTexImage(egl::Thread *thread,
462 bool isCallValid,
463 egl::Display *dpyPacked,
464 SurfaceID surfacePacked,
465 EGLint buffer,
466 EGLBoolean returnValue)
467 {
468 ParamBuffer paramBuffer;
469
470 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
471 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
472 paramBuffer.addValueParam("buffer", ParamType::TEGLint, buffer);
473
474 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
475 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
476 paramBuffer.addReturnValue(std::move(returnValueCapture));
477
478 return CallCapture(angle::EntryPoint::EGLBindTexImage, std::move(paramBuffer));
479 }
480
CaptureReleaseTexImage(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLint buffer,EGLBoolean returnValue)481 CallCapture CaptureReleaseTexImage(egl::Thread *thread,
482 bool isCallValid,
483 egl::Display *dpyPacked,
484 SurfaceID surfacePacked,
485 EGLint buffer,
486 EGLBoolean returnValue)
487 {
488 ParamBuffer paramBuffer;
489
490 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
491 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
492 paramBuffer.addValueParam("buffer", ParamType::TEGLint, buffer);
493
494 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
495 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
496 paramBuffer.addReturnValue(std::move(returnValueCapture));
497
498 return CallCapture(angle::EntryPoint::EGLReleaseTexImage, std::move(paramBuffer));
499 }
500
CaptureSurfaceAttrib(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLint attribute,EGLint value,EGLBoolean returnValue)501 CallCapture CaptureSurfaceAttrib(egl::Thread *thread,
502 bool isCallValid,
503 egl::Display *dpyPacked,
504 SurfaceID surfacePacked,
505 EGLint attribute,
506 EGLint value,
507 EGLBoolean returnValue)
508 {
509 ParamBuffer paramBuffer;
510
511 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
512 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
513 paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
514 paramBuffer.addValueParam("value", ParamType::TEGLint, value);
515
516 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
517 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
518 paramBuffer.addReturnValue(std::move(returnValueCapture));
519
520 return CallCapture(angle::EntryPoint::EGLSurfaceAttrib, std::move(paramBuffer));
521 }
522
CaptureSwapInterval(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLint interval,EGLBoolean returnValue)523 CallCapture CaptureSwapInterval(egl::Thread *thread,
524 bool isCallValid,
525 egl::Display *dpyPacked,
526 EGLint interval,
527 EGLBoolean returnValue)
528 {
529 ParamBuffer paramBuffer;
530
531 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
532 paramBuffer.addValueParam("interval", ParamType::TEGLint, interval);
533
534 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
535 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
536 paramBuffer.addReturnValue(std::move(returnValueCapture));
537
538 return CallCapture(angle::EntryPoint::EGLSwapInterval, std::move(paramBuffer));
539 }
540
CaptureBindAPI(egl::Thread * thread,bool isCallValid,EGLenum api,EGLBoolean returnValue)541 CallCapture CaptureBindAPI(egl::Thread *thread,
542 bool isCallValid,
543 EGLenum api,
544 EGLBoolean returnValue)
545 {
546 ParamBuffer paramBuffer;
547
548 paramBuffer.addValueParam("api", ParamType::TEGLenum, api);
549
550 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
551 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
552 paramBuffer.addReturnValue(std::move(returnValueCapture));
553
554 return CallCapture(angle::EntryPoint::EGLBindAPI, std::move(paramBuffer));
555 }
556
CaptureCreatePbufferFromClientBuffer(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLenum buftype,EGLClientBuffer buffer,egl::Config * configPacked,const AttributeMap & attrib_listPacked,EGLSurface returnValue)557 CallCapture CaptureCreatePbufferFromClientBuffer(egl::Thread *thread,
558 bool isCallValid,
559 egl::Display *dpyPacked,
560 EGLenum buftype,
561 EGLClientBuffer buffer,
562 egl::Config *configPacked,
563 const AttributeMap &attrib_listPacked,
564 EGLSurface returnValue)
565 {
566 ParamBuffer paramBuffer;
567
568 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
569 paramBuffer.addValueParam("buftype", ParamType::TEGLenum, buftype);
570 paramBuffer.addValueParam("buffer", ParamType::TEGLClientBuffer, buffer);
571 paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
572 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
573
574 ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface);
575 InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value);
576 paramBuffer.addReturnValue(std::move(returnValueCapture));
577
578 return CallCapture(angle::EntryPoint::EGLCreatePbufferFromClientBuffer, std::move(paramBuffer));
579 }
580
CaptureQueryAPI(egl::Thread * thread,bool isCallValid,EGLenum returnValue)581 CallCapture CaptureQueryAPI(egl::Thread *thread, bool isCallValid, EGLenum returnValue)
582 {
583 ParamBuffer paramBuffer;
584
585 ParamCapture returnValueCapture("returnValue", ParamType::TEGLenum);
586 InitParamValue(ParamType::TEGLenum, returnValue, &returnValueCapture.value);
587 paramBuffer.addReturnValue(std::move(returnValueCapture));
588
589 return CallCapture(angle::EntryPoint::EGLQueryAPI, std::move(paramBuffer));
590 }
591
CaptureReleaseThread(egl::Thread * thread,bool isCallValid,EGLBoolean returnValue)592 CallCapture CaptureReleaseThread(egl::Thread *thread, bool isCallValid, EGLBoolean returnValue)
593 {
594 ParamBuffer paramBuffer;
595
596 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
597 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
598 paramBuffer.addReturnValue(std::move(returnValueCapture));
599
600 return CallCapture(angle::EntryPoint::EGLReleaseThread, std::move(paramBuffer));
601 }
602
CaptureWaitClient(egl::Thread * thread,bool isCallValid,EGLBoolean returnValue)603 CallCapture CaptureWaitClient(egl::Thread *thread, bool isCallValid, EGLBoolean returnValue)
604 {
605 ParamBuffer paramBuffer;
606
607 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
608 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
609 paramBuffer.addReturnValue(std::move(returnValueCapture));
610
611 return CallCapture(angle::EntryPoint::EGLWaitClient, std::move(paramBuffer));
612 }
613
CaptureGetCurrentContext(egl::Thread * thread,bool isCallValid,EGLContext returnValue)614 CallCapture CaptureGetCurrentContext(egl::Thread *thread, bool isCallValid, EGLContext returnValue)
615 {
616 ParamBuffer paramBuffer;
617
618 ParamCapture returnValueCapture("returnValue", ParamType::TEGLContext);
619 InitParamValue(ParamType::TEGLContext, returnValue, &returnValueCapture.value);
620 paramBuffer.addReturnValue(std::move(returnValueCapture));
621
622 return CallCapture(angle::EntryPoint::EGLGetCurrentContext, std::move(paramBuffer));
623 }
624
CaptureClientWaitSync(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::SyncID syncPacked,EGLint flags,EGLTime timeout,EGLint returnValue)625 CallCapture CaptureClientWaitSync(egl::Thread *thread,
626 bool isCallValid,
627 egl::Display *dpyPacked,
628 egl::SyncID syncPacked,
629 EGLint flags,
630 EGLTime timeout,
631 EGLint returnValue)
632 {
633 ParamBuffer paramBuffer;
634
635 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
636 paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
637 paramBuffer.addValueParam("flags", ParamType::TEGLint, flags);
638 paramBuffer.addValueParam("timeout", ParamType::TEGLTime, timeout);
639
640 ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
641 InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
642 paramBuffer.addReturnValue(std::move(returnValueCapture));
643
644 return CallCapture(angle::EntryPoint::EGLClientWaitSync, std::move(paramBuffer));
645 }
646
CaptureCreateImage(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,gl::ContextID ctxPacked,EGLenum target,EGLClientBuffer buffer,const AttributeMap & attrib_listPacked,EGLImage returnValue)647 CallCapture CaptureCreateImage(egl::Thread *thread,
648 bool isCallValid,
649 egl::Display *dpyPacked,
650 gl::ContextID ctxPacked,
651 EGLenum target,
652 EGLClientBuffer buffer,
653 const AttributeMap &attrib_listPacked,
654 EGLImage returnValue)
655 {
656 ParamBuffer paramBuffer;
657
658 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
659 paramBuffer.addValueParam("ctxPacked", ParamType::TContextID, ctxPacked);
660 paramBuffer.addValueParam("target", ParamType::TEGLenum, target);
661 paramBuffer.addValueParam("buffer", ParamType::TEGLClientBuffer, buffer);
662 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
663
664 ParamCapture returnValueCapture("returnValue", ParamType::TEGLImage);
665 InitParamValue(ParamType::TEGLImage, returnValue, &returnValueCapture.value);
666 paramBuffer.addReturnValue(std::move(returnValueCapture));
667
668 return CallCapture(angle::EntryPoint::EGLCreateImage, std::move(paramBuffer));
669 }
670
CaptureCreatePlatformPixmapSurface(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Config * configPacked,void * native_pixmap,const AttributeMap & attrib_listPacked,EGLSurface returnValue)671 CallCapture CaptureCreatePlatformPixmapSurface(egl::Thread *thread,
672 bool isCallValid,
673 egl::Display *dpyPacked,
674 egl::Config *configPacked,
675 void *native_pixmap,
676 const AttributeMap &attrib_listPacked,
677 EGLSurface returnValue)
678 {
679 ParamBuffer paramBuffer;
680
681 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
682 paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
683 paramBuffer.addValueParam("native_pixmap", ParamType::TvoidPointer, native_pixmap);
684 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
685
686 ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface);
687 InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value);
688 paramBuffer.addReturnValue(std::move(returnValueCapture));
689
690 return CallCapture(angle::EntryPoint::EGLCreatePlatformPixmapSurface, std::move(paramBuffer));
691 }
692
CaptureCreatePlatformWindowSurface(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Config * configPacked,void * native_window,const AttributeMap & attrib_listPacked,EGLSurface returnValue)693 CallCapture CaptureCreatePlatformWindowSurface(egl::Thread *thread,
694 bool isCallValid,
695 egl::Display *dpyPacked,
696 egl::Config *configPacked,
697 void *native_window,
698 const AttributeMap &attrib_listPacked,
699 EGLSurface returnValue)
700 {
701 ParamBuffer paramBuffer;
702
703 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
704 paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
705 paramBuffer.addValueParam("native_window", ParamType::TvoidPointer, native_window);
706 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
707
708 ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface);
709 InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value);
710 paramBuffer.addReturnValue(std::move(returnValueCapture));
711
712 return CallCapture(angle::EntryPoint::EGLCreatePlatformWindowSurface, std::move(paramBuffer));
713 }
714
CaptureCreateSync(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLenum type,const AttributeMap & attrib_listPacked,EGLSync returnValue)715 CallCapture CaptureCreateSync(egl::Thread *thread,
716 bool isCallValid,
717 egl::Display *dpyPacked,
718 EGLenum type,
719 const AttributeMap &attrib_listPacked,
720 EGLSync returnValue)
721 {
722 ParamBuffer paramBuffer;
723
724 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
725 paramBuffer.addValueParam("type", ParamType::TEGLenum, type);
726 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
727
728 ParamCapture returnValueCapture("returnValue", ParamType::TEGLSync);
729 InitParamValue(ParamType::TEGLSync, returnValue, &returnValueCapture.value);
730 paramBuffer.addReturnValue(std::move(returnValueCapture));
731
732 return CallCapture(angle::EntryPoint::EGLCreateSync, std::move(paramBuffer));
733 }
734
CaptureDestroyImage(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,ImageID imagePacked,EGLBoolean returnValue)735 CallCapture CaptureDestroyImage(egl::Thread *thread,
736 bool isCallValid,
737 egl::Display *dpyPacked,
738 ImageID imagePacked,
739 EGLBoolean returnValue)
740 {
741 ParamBuffer paramBuffer;
742
743 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
744 paramBuffer.addValueParam("imagePacked", ParamType::TImageID, imagePacked);
745
746 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
747 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
748 paramBuffer.addReturnValue(std::move(returnValueCapture));
749
750 return CallCapture(angle::EntryPoint::EGLDestroyImage, std::move(paramBuffer));
751 }
752
CaptureDestroySync(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::SyncID syncPacked,EGLBoolean returnValue)753 CallCapture CaptureDestroySync(egl::Thread *thread,
754 bool isCallValid,
755 egl::Display *dpyPacked,
756 egl::SyncID syncPacked,
757 EGLBoolean returnValue)
758 {
759 ParamBuffer paramBuffer;
760
761 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
762 paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
763
764 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
765 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
766 paramBuffer.addReturnValue(std::move(returnValueCapture));
767
768 return CallCapture(angle::EntryPoint::EGLDestroySync, std::move(paramBuffer));
769 }
770
CaptureGetPlatformDisplay(egl::Thread * thread,bool isCallValid,EGLenum platform,void * native_display,const AttributeMap & attrib_listPacked,EGLDisplay returnValue)771 CallCapture CaptureGetPlatformDisplay(egl::Thread *thread,
772 bool isCallValid,
773 EGLenum platform,
774 void *native_display,
775 const AttributeMap &attrib_listPacked,
776 EGLDisplay returnValue)
777 {
778 ParamBuffer paramBuffer;
779
780 paramBuffer.addValueParam("platform", ParamType::TEGLenum, platform);
781 paramBuffer.addValueParam("native_display", ParamType::TvoidPointer, native_display);
782 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
783
784 ParamCapture returnValueCapture("returnValue", ParamType::TEGLDisplay);
785 InitParamValue(ParamType::TEGLDisplay, returnValue, &returnValueCapture.value);
786 paramBuffer.addReturnValue(std::move(returnValueCapture));
787
788 return CallCapture(angle::EntryPoint::EGLGetPlatformDisplay, std::move(paramBuffer));
789 }
790
CaptureGetSyncAttrib(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::SyncID syncPacked,EGLint attribute,EGLAttrib * value,EGLBoolean returnValue)791 CallCapture CaptureGetSyncAttrib(egl::Thread *thread,
792 bool isCallValid,
793 egl::Display *dpyPacked,
794 egl::SyncID syncPacked,
795 EGLint attribute,
796 EGLAttrib *value,
797 EGLBoolean returnValue)
798 {
799 ParamBuffer paramBuffer;
800
801 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
802 paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
803 paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
804 paramBuffer.addValueParam("value", ParamType::TEGLAttribPointer, value);
805
806 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
807 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
808 paramBuffer.addReturnValue(std::move(returnValueCapture));
809
810 return CallCapture(angle::EntryPoint::EGLGetSyncAttrib, std::move(paramBuffer));
811 }
812
CaptureWaitSync(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::SyncID syncPacked,EGLint flags,EGLBoolean returnValue)813 CallCapture CaptureWaitSync(egl::Thread *thread,
814 bool isCallValid,
815 egl::Display *dpyPacked,
816 egl::SyncID syncPacked,
817 EGLint flags,
818 EGLBoolean returnValue)
819 {
820 ParamBuffer paramBuffer;
821
822 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
823 paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
824 paramBuffer.addValueParam("flags", ParamType::TEGLint, flags);
825
826 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
827 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
828 paramBuffer.addReturnValue(std::move(returnValueCapture));
829
830 return CallCapture(angle::EntryPoint::EGLWaitSync, std::move(paramBuffer));
831 }
832
CaptureSetBlobCacheFuncsANDROID(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLSetBlobFuncANDROID set,EGLGetBlobFuncANDROID get)833 CallCapture CaptureSetBlobCacheFuncsANDROID(egl::Thread *thread,
834 bool isCallValid,
835 egl::Display *dpyPacked,
836 EGLSetBlobFuncANDROID set,
837 EGLGetBlobFuncANDROID get)
838 {
839 ParamBuffer paramBuffer;
840
841 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
842 paramBuffer.addValueParam("set", ParamType::TEGLSetBlobFuncANDROID, set);
843 paramBuffer.addValueParam("get", ParamType::TEGLGetBlobFuncANDROID, get);
844
845 return CallCapture(angle::EntryPoint::EGLSetBlobCacheFuncsANDROID, std::move(paramBuffer));
846 }
847
CaptureCreateNativeClientBufferANDROID(egl::Thread * thread,bool isCallValid,const AttributeMap & attrib_listPacked,EGLClientBuffer returnValue)848 CallCapture CaptureCreateNativeClientBufferANDROID(egl::Thread *thread,
849 bool isCallValid,
850 const AttributeMap &attrib_listPacked,
851 EGLClientBuffer returnValue)
852 {
853 ParamBuffer paramBuffer;
854
855 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
856
857 ParamCapture returnValueCapture("returnValue", ParamType::TEGLClientBuffer);
858 InitParamValue(ParamType::TEGLClientBuffer, returnValue, &returnValueCapture.value);
859 paramBuffer.addReturnValue(std::move(returnValueCapture));
860
861 return CallCapture(angle::EntryPoint::EGLCreateNativeClientBufferANDROID,
862 std::move(paramBuffer));
863 }
864
CaptureGetCompositorTimingSupportedANDROID(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,CompositorTiming namePacked,EGLBoolean returnValue)865 CallCapture CaptureGetCompositorTimingSupportedANDROID(egl::Thread *thread,
866 bool isCallValid,
867 egl::Display *dpyPacked,
868 SurfaceID surfacePacked,
869 CompositorTiming namePacked,
870 EGLBoolean returnValue)
871 {
872 ParamBuffer paramBuffer;
873
874 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
875 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
876 paramBuffer.addValueParam("namePacked", ParamType::TCompositorTiming, namePacked);
877
878 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
879 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
880 paramBuffer.addReturnValue(std::move(returnValueCapture));
881
882 return CallCapture(angle::EntryPoint::EGLGetCompositorTimingSupportedANDROID,
883 std::move(paramBuffer));
884 }
885
CaptureGetCompositorTimingANDROID(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLint numTimestamps,const EGLint * names,EGLnsecsANDROID * values,EGLBoolean returnValue)886 CallCapture CaptureGetCompositorTimingANDROID(egl::Thread *thread,
887 bool isCallValid,
888 egl::Display *dpyPacked,
889 SurfaceID surfacePacked,
890 EGLint numTimestamps,
891 const EGLint *names,
892 EGLnsecsANDROID *values,
893 EGLBoolean returnValue)
894 {
895 ParamBuffer paramBuffer;
896
897 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
898 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
899 paramBuffer.addValueParam("numTimestamps", ParamType::TEGLint, numTimestamps);
900 paramBuffer.addValueParam("names", ParamType::TEGLintConstPointer, names);
901 paramBuffer.addValueParam("values", ParamType::TEGLnsecsANDROIDPointer, values);
902
903 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
904 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
905 paramBuffer.addReturnValue(std::move(returnValueCapture));
906
907 return CallCapture(angle::EntryPoint::EGLGetCompositorTimingANDROID, std::move(paramBuffer));
908 }
909
CaptureGetNextFrameIdANDROID(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLuint64KHR * frameId,EGLBoolean returnValue)910 CallCapture CaptureGetNextFrameIdANDROID(egl::Thread *thread,
911 bool isCallValid,
912 egl::Display *dpyPacked,
913 SurfaceID surfacePacked,
914 EGLuint64KHR *frameId,
915 EGLBoolean returnValue)
916 {
917 ParamBuffer paramBuffer;
918
919 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
920 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
921 paramBuffer.addValueParam("frameId", ParamType::TEGLuint64KHRPointer, frameId);
922
923 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
924 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
925 paramBuffer.addReturnValue(std::move(returnValueCapture));
926
927 return CallCapture(angle::EntryPoint::EGLGetNextFrameIdANDROID, std::move(paramBuffer));
928 }
929
CaptureGetFrameTimestampSupportedANDROID(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,Timestamp timestampPacked,EGLBoolean returnValue)930 CallCapture CaptureGetFrameTimestampSupportedANDROID(egl::Thread *thread,
931 bool isCallValid,
932 egl::Display *dpyPacked,
933 SurfaceID surfacePacked,
934 Timestamp timestampPacked,
935 EGLBoolean returnValue)
936 {
937 ParamBuffer paramBuffer;
938
939 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
940 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
941 paramBuffer.addValueParam("timestampPacked", ParamType::TTimestamp, timestampPacked);
942
943 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
944 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
945 paramBuffer.addReturnValue(std::move(returnValueCapture));
946
947 return CallCapture(angle::EntryPoint::EGLGetFrameTimestampSupportedANDROID,
948 std::move(paramBuffer));
949 }
950
CaptureGetFrameTimestampsANDROID(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLuint64KHR frameId,EGLint numTimestamps,const EGLint * timestamps,EGLnsecsANDROID * values,EGLBoolean returnValue)951 CallCapture CaptureGetFrameTimestampsANDROID(egl::Thread *thread,
952 bool isCallValid,
953 egl::Display *dpyPacked,
954 SurfaceID surfacePacked,
955 EGLuint64KHR frameId,
956 EGLint numTimestamps,
957 const EGLint *timestamps,
958 EGLnsecsANDROID *values,
959 EGLBoolean returnValue)
960 {
961 ParamBuffer paramBuffer;
962
963 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
964 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
965 paramBuffer.addValueParam("frameId", ParamType::TEGLuint64KHR, frameId);
966 paramBuffer.addValueParam("numTimestamps", ParamType::TEGLint, numTimestamps);
967 paramBuffer.addValueParam("timestamps", ParamType::TEGLintConstPointer, timestamps);
968 paramBuffer.addValueParam("values", ParamType::TEGLnsecsANDROIDPointer, values);
969
970 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
971 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
972 paramBuffer.addReturnValue(std::move(returnValueCapture));
973
974 return CallCapture(angle::EntryPoint::EGLGetFrameTimestampsANDROID, std::move(paramBuffer));
975 }
976
CaptureGetNativeClientBufferANDROID(egl::Thread * thread,bool isCallValid,const struct AHardwareBuffer * buffer,EGLClientBuffer returnValue)977 CallCapture CaptureGetNativeClientBufferANDROID(egl::Thread *thread,
978 bool isCallValid,
979 const struct AHardwareBuffer *buffer,
980 EGLClientBuffer returnValue)
981 {
982 ParamBuffer paramBuffer;
983
984 paramBuffer.addValueParam("buffer", ParamType::TAHardwareBufferConstPointer, buffer);
985
986 ParamCapture returnValueCapture("returnValue", ParamType::TEGLClientBuffer);
987 InitParamValue(ParamType::TEGLClientBuffer, returnValue, &returnValueCapture.value);
988 paramBuffer.addReturnValue(std::move(returnValueCapture));
989
990 return CallCapture(angle::EntryPoint::EGLGetNativeClientBufferANDROID, std::move(paramBuffer));
991 }
992
CaptureDupNativeFenceFDANDROID(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::SyncID syncPacked,EGLint returnValue)993 CallCapture CaptureDupNativeFenceFDANDROID(egl::Thread *thread,
994 bool isCallValid,
995 egl::Display *dpyPacked,
996 egl::SyncID syncPacked,
997 EGLint returnValue)
998 {
999 ParamBuffer paramBuffer;
1000
1001 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1002 paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
1003
1004 ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
1005 InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
1006 paramBuffer.addReturnValue(std::move(returnValueCapture));
1007
1008 return CallCapture(angle::EntryPoint::EGLDupNativeFenceFDANDROID, std::move(paramBuffer));
1009 }
1010
CapturePresentationTimeANDROID(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLnsecsANDROID time,EGLBoolean returnValue)1011 CallCapture CapturePresentationTimeANDROID(egl::Thread *thread,
1012 bool isCallValid,
1013 egl::Display *dpyPacked,
1014 SurfaceID surfacePacked,
1015 EGLnsecsANDROID time,
1016 EGLBoolean returnValue)
1017 {
1018 ParamBuffer paramBuffer;
1019
1020 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1021 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
1022 paramBuffer.addValueParam("time", ParamType::TEGLnsecsANDROID, time);
1023
1024 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1025 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1026 paramBuffer.addReturnValue(std::move(returnValueCapture));
1027
1028 return CallCapture(angle::EntryPoint::EGLPresentationTimeANDROID, std::move(paramBuffer));
1029 }
1030
CaptureCreateDeviceANGLE(egl::Thread * thread,bool isCallValid,EGLint device_type,void * native_device,const EGLAttrib * attrib_list,EGLDeviceEXT returnValue)1031 CallCapture CaptureCreateDeviceANGLE(egl::Thread *thread,
1032 bool isCallValid,
1033 EGLint device_type,
1034 void *native_device,
1035 const EGLAttrib *attrib_list,
1036 EGLDeviceEXT returnValue)
1037 {
1038 ParamBuffer paramBuffer;
1039
1040 paramBuffer.addValueParam("device_type", ParamType::TEGLint, device_type);
1041 paramBuffer.addValueParam("native_device", ParamType::TvoidPointer, native_device);
1042 paramBuffer.addValueParam("attrib_list", ParamType::TEGLAttribConstPointer, attrib_list);
1043
1044 ParamCapture returnValueCapture("returnValue", ParamType::TEGLDeviceEXT);
1045 InitParamValue(ParamType::TEGLDeviceEXT, returnValue, &returnValueCapture.value);
1046 paramBuffer.addReturnValue(std::move(returnValueCapture));
1047
1048 return CallCapture(angle::EntryPoint::EGLCreateDeviceANGLE, std::move(paramBuffer));
1049 }
1050
CaptureReleaseDeviceANGLE(egl::Thread * thread,bool isCallValid,egl::Device * devicePacked,EGLBoolean returnValue)1051 CallCapture CaptureReleaseDeviceANGLE(egl::Thread *thread,
1052 bool isCallValid,
1053 egl::Device *devicePacked,
1054 EGLBoolean returnValue)
1055 {
1056 ParamBuffer paramBuffer;
1057
1058 paramBuffer.addValueParam("devicePacked", ParamType::Tegl_DevicePointer, devicePacked);
1059
1060 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1061 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1062 paramBuffer.addReturnValue(std::move(returnValueCapture));
1063
1064 return CallCapture(angle::EntryPoint::EGLReleaseDeviceANGLE, std::move(paramBuffer));
1065 }
1066
CaptureAcquireExternalContextANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID drawAndReadPacked)1067 CallCapture CaptureAcquireExternalContextANGLE(egl::Thread *thread,
1068 bool isCallValid,
1069 egl::Display *dpyPacked,
1070 SurfaceID drawAndReadPacked)
1071 {
1072 ParamBuffer paramBuffer;
1073
1074 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1075 paramBuffer.addValueParam("drawAndReadPacked", ParamType::TSurfaceID, drawAndReadPacked);
1076
1077 return CallCapture(angle::EntryPoint::EGLAcquireExternalContextANGLE, std::move(paramBuffer));
1078 }
1079
CaptureReleaseExternalContextANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked)1080 CallCapture CaptureReleaseExternalContextANGLE(egl::Thread *thread,
1081 bool isCallValid,
1082 egl::Display *dpyPacked)
1083 {
1084 ParamBuffer paramBuffer;
1085
1086 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1087
1088 return CallCapture(angle::EntryPoint::EGLReleaseExternalContextANGLE, std::move(paramBuffer));
1089 }
1090
CaptureQueryStringiANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLint name,EGLint index,const char * returnValue)1091 CallCapture CaptureQueryStringiANGLE(egl::Thread *thread,
1092 bool isCallValid,
1093 egl::Display *dpyPacked,
1094 EGLint name,
1095 EGLint index,
1096 const char *returnValue)
1097 {
1098 ParamBuffer paramBuffer;
1099
1100 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1101 paramBuffer.addValueParam("name", ParamType::TEGLint, name);
1102 paramBuffer.addValueParam("index", ParamType::TEGLint, index);
1103
1104 ParamCapture returnValueCapture("returnValue", ParamType::TcharConstPointer);
1105 InitParamValue(ParamType::TcharConstPointer, returnValue, &returnValueCapture.value);
1106 paramBuffer.addReturnValue(std::move(returnValueCapture));
1107
1108 return CallCapture(angle::EntryPoint::EGLQueryStringiANGLE, std::move(paramBuffer));
1109 }
1110
CaptureQueryDisplayAttribANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLint attribute,EGLAttrib * value,EGLBoolean returnValue)1111 CallCapture CaptureQueryDisplayAttribANGLE(egl::Thread *thread,
1112 bool isCallValid,
1113 egl::Display *dpyPacked,
1114 EGLint attribute,
1115 EGLAttrib *value,
1116 EGLBoolean returnValue)
1117 {
1118 ParamBuffer paramBuffer;
1119
1120 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1121 paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
1122 paramBuffer.addValueParam("value", ParamType::TEGLAttribPointer, value);
1123
1124 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1125 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1126 paramBuffer.addReturnValue(std::move(returnValueCapture));
1127
1128 return CallCapture(angle::EntryPoint::EGLQueryDisplayAttribANGLE, std::move(paramBuffer));
1129 }
1130
CaptureCopyMetalSharedEventANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::SyncID syncPacked,void * returnValue)1131 CallCapture CaptureCopyMetalSharedEventANGLE(egl::Thread *thread,
1132 bool isCallValid,
1133 egl::Display *dpyPacked,
1134 egl::SyncID syncPacked,
1135 void *returnValue)
1136 {
1137 ParamBuffer paramBuffer;
1138
1139 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1140 paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
1141
1142 ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer);
1143 InitParamValue(ParamType::TvoidPointer, returnValue, &returnValueCapture.value);
1144 paramBuffer.addReturnValue(std::move(returnValueCapture));
1145
1146 return CallCapture(angle::EntryPoint::EGLCopyMetalSharedEventANGLE, std::move(paramBuffer));
1147 }
1148
CaptureSetValidationEnabledANGLE(egl::Thread * thread,bool isCallValid,EGLBoolean validationState)1149 CallCapture CaptureSetValidationEnabledANGLE(egl::Thread *thread,
1150 bool isCallValid,
1151 EGLBoolean validationState)
1152 {
1153 ParamBuffer paramBuffer;
1154
1155 paramBuffer.addValueParam("validationState", ParamType::TEGLBoolean, validationState);
1156
1157 return CallCapture(angle::EntryPoint::EGLSetValidationEnabledANGLE, std::move(paramBuffer));
1158 }
1159
CaptureReleaseHighPowerGPUANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,gl::ContextID ctxPacked)1160 CallCapture CaptureReleaseHighPowerGPUANGLE(egl::Thread *thread,
1161 bool isCallValid,
1162 egl::Display *dpyPacked,
1163 gl::ContextID ctxPacked)
1164 {
1165 ParamBuffer paramBuffer;
1166
1167 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1168 paramBuffer.addValueParam("ctxPacked", ParamType::TContextID, ctxPacked);
1169
1170 return CallCapture(angle::EntryPoint::EGLReleaseHighPowerGPUANGLE, std::move(paramBuffer));
1171 }
1172
CaptureReacquireHighPowerGPUANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,gl::ContextID ctxPacked)1173 CallCapture CaptureReacquireHighPowerGPUANGLE(egl::Thread *thread,
1174 bool isCallValid,
1175 egl::Display *dpyPacked,
1176 gl::ContextID ctxPacked)
1177 {
1178 ParamBuffer paramBuffer;
1179
1180 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1181 paramBuffer.addValueParam("ctxPacked", ParamType::TContextID, ctxPacked);
1182
1183 return CallCapture(angle::EntryPoint::EGLReacquireHighPowerGPUANGLE, std::move(paramBuffer));
1184 }
1185
CaptureHandleGPUSwitchANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked)1186 CallCapture CaptureHandleGPUSwitchANGLE(egl::Thread *thread,
1187 bool isCallValid,
1188 egl::Display *dpyPacked)
1189 {
1190 ParamBuffer paramBuffer;
1191
1192 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1193
1194 return CallCapture(angle::EntryPoint::EGLHandleGPUSwitchANGLE, std::move(paramBuffer));
1195 }
1196
CaptureForceGPUSwitchANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLint gpuIDHigh,EGLint gpuIDLow)1197 CallCapture CaptureForceGPUSwitchANGLE(egl::Thread *thread,
1198 bool isCallValid,
1199 egl::Display *dpyPacked,
1200 EGLint gpuIDHigh,
1201 EGLint gpuIDLow)
1202 {
1203 ParamBuffer paramBuffer;
1204
1205 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1206 paramBuffer.addValueParam("gpuIDHigh", ParamType::TEGLint, gpuIDHigh);
1207 paramBuffer.addValueParam("gpuIDLow", ParamType::TEGLint, gpuIDLow);
1208
1209 return CallCapture(angle::EntryPoint::EGLForceGPUSwitchANGLE, std::move(paramBuffer));
1210 }
1211
CapturePrepareSwapBuffersANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLBoolean returnValue)1212 CallCapture CapturePrepareSwapBuffersANGLE(egl::Thread *thread,
1213 bool isCallValid,
1214 egl::Display *dpyPacked,
1215 SurfaceID surfacePacked,
1216 EGLBoolean returnValue)
1217 {
1218 ParamBuffer paramBuffer;
1219
1220 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1221 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
1222
1223 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1224 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1225 paramBuffer.addReturnValue(std::move(returnValueCapture));
1226
1227 return CallCapture(angle::EntryPoint::EGLPrepareSwapBuffersANGLE, std::move(paramBuffer));
1228 }
1229
CaptureProgramCacheGetAttribANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLenum attrib,EGLint returnValue)1230 CallCapture CaptureProgramCacheGetAttribANGLE(egl::Thread *thread,
1231 bool isCallValid,
1232 egl::Display *dpyPacked,
1233 EGLenum attrib,
1234 EGLint returnValue)
1235 {
1236 ParamBuffer paramBuffer;
1237
1238 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1239 paramBuffer.addValueParam("attrib", ParamType::TEGLenum, attrib);
1240
1241 ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
1242 InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
1243 paramBuffer.addReturnValue(std::move(returnValueCapture));
1244
1245 return CallCapture(angle::EntryPoint::EGLProgramCacheGetAttribANGLE, std::move(paramBuffer));
1246 }
1247
CaptureProgramCacheQueryANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLint index,void * key,EGLint * keysize,void * binary,EGLint * binarysize)1248 CallCapture CaptureProgramCacheQueryANGLE(egl::Thread *thread,
1249 bool isCallValid,
1250 egl::Display *dpyPacked,
1251 EGLint index,
1252 void *key,
1253 EGLint *keysize,
1254 void *binary,
1255 EGLint *binarysize)
1256 {
1257 ParamBuffer paramBuffer;
1258
1259 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1260 paramBuffer.addValueParam("index", ParamType::TEGLint, index);
1261 paramBuffer.addValueParam("key", ParamType::TvoidPointer, key);
1262 paramBuffer.addValueParam("keysize", ParamType::TEGLintPointer, keysize);
1263 paramBuffer.addValueParam("binary", ParamType::TvoidPointer, binary);
1264 paramBuffer.addValueParam("binarysize", ParamType::TEGLintPointer, binarysize);
1265
1266 return CallCapture(angle::EntryPoint::EGLProgramCacheQueryANGLE, std::move(paramBuffer));
1267 }
1268
CaptureProgramCachePopulateANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,const void * key,EGLint keysize,const void * binary,EGLint binarysize)1269 CallCapture CaptureProgramCachePopulateANGLE(egl::Thread *thread,
1270 bool isCallValid,
1271 egl::Display *dpyPacked,
1272 const void *key,
1273 EGLint keysize,
1274 const void *binary,
1275 EGLint binarysize)
1276 {
1277 ParamBuffer paramBuffer;
1278
1279 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1280 paramBuffer.addValueParam("key", ParamType::TvoidConstPointer, key);
1281 paramBuffer.addValueParam("keysize", ParamType::TEGLint, keysize);
1282 paramBuffer.addValueParam("binary", ParamType::TvoidConstPointer, binary);
1283 paramBuffer.addValueParam("binarysize", ParamType::TEGLint, binarysize);
1284
1285 return CallCapture(angle::EntryPoint::EGLProgramCachePopulateANGLE, std::move(paramBuffer));
1286 }
1287
CaptureProgramCacheResizeANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLint limit,EGLint mode,EGLint returnValue)1288 CallCapture CaptureProgramCacheResizeANGLE(egl::Thread *thread,
1289 bool isCallValid,
1290 egl::Display *dpyPacked,
1291 EGLint limit,
1292 EGLint mode,
1293 EGLint returnValue)
1294 {
1295 ParamBuffer paramBuffer;
1296
1297 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1298 paramBuffer.addValueParam("limit", ParamType::TEGLint, limit);
1299 paramBuffer.addValueParam("mode", ParamType::TEGLint, mode);
1300
1301 ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
1302 InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
1303 paramBuffer.addReturnValue(std::move(returnValueCapture));
1304
1305 return CallCapture(angle::EntryPoint::EGLProgramCacheResizeANGLE, std::move(paramBuffer));
1306 }
1307
CaptureQuerySurfacePointerANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLint attribute,void ** value,EGLBoolean returnValue)1308 CallCapture CaptureQuerySurfacePointerANGLE(egl::Thread *thread,
1309 bool isCallValid,
1310 egl::Display *dpyPacked,
1311 SurfaceID surfacePacked,
1312 EGLint attribute,
1313 void **value,
1314 EGLBoolean returnValue)
1315 {
1316 ParamBuffer paramBuffer;
1317
1318 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1319 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
1320 paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
1321 paramBuffer.addValueParam("value", ParamType::TvoidPointerPointer, value);
1322
1323 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1324 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1325 paramBuffer.addReturnValue(std::move(returnValueCapture));
1326
1327 return CallCapture(angle::EntryPoint::EGLQuerySurfacePointerANGLE, std::move(paramBuffer));
1328 }
1329
CaptureCreateStreamProducerD3DTextureANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Stream * streamPacked,const AttributeMap & attrib_listPacked,EGLBoolean returnValue)1330 CallCapture CaptureCreateStreamProducerD3DTextureANGLE(egl::Thread *thread,
1331 bool isCallValid,
1332 egl::Display *dpyPacked,
1333 egl::Stream *streamPacked,
1334 const AttributeMap &attrib_listPacked,
1335 EGLBoolean returnValue)
1336 {
1337 ParamBuffer paramBuffer;
1338
1339 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1340 paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
1341 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
1342
1343 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1344 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1345 paramBuffer.addReturnValue(std::move(returnValueCapture));
1346
1347 return CallCapture(angle::EntryPoint::EGLCreateStreamProducerD3DTextureANGLE,
1348 std::move(paramBuffer));
1349 }
1350
CaptureStreamPostD3DTextureANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Stream * streamPacked,void * texture,const AttributeMap & attrib_listPacked,EGLBoolean returnValue)1351 CallCapture CaptureStreamPostD3DTextureANGLE(egl::Thread *thread,
1352 bool isCallValid,
1353 egl::Display *dpyPacked,
1354 egl::Stream *streamPacked,
1355 void *texture,
1356 const AttributeMap &attrib_listPacked,
1357 EGLBoolean returnValue)
1358 {
1359 ParamBuffer paramBuffer;
1360
1361 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1362 paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
1363 paramBuffer.addValueParam("texture", ParamType::TvoidPointer, texture);
1364 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
1365
1366 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1367 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1368 paramBuffer.addReturnValue(std::move(returnValueCapture));
1369
1370 return CallCapture(angle::EntryPoint::EGLStreamPostD3DTextureANGLE, std::move(paramBuffer));
1371 }
1372
CaptureSwapBuffersWithFrameTokenANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLFrameTokenANGLE frametoken,EGLBoolean returnValue)1373 CallCapture CaptureSwapBuffersWithFrameTokenANGLE(egl::Thread *thread,
1374 bool isCallValid,
1375 egl::Display *dpyPacked,
1376 SurfaceID surfacePacked,
1377 EGLFrameTokenANGLE frametoken,
1378 EGLBoolean returnValue)
1379 {
1380 ParamBuffer paramBuffer;
1381
1382 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1383 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
1384 paramBuffer.addValueParam("frametoken", ParamType::TEGLFrameTokenANGLE, frametoken);
1385
1386 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1387 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1388 paramBuffer.addReturnValue(std::move(returnValueCapture));
1389
1390 return CallCapture(angle::EntryPoint::EGLSwapBuffersWithFrameTokenANGLE,
1391 std::move(paramBuffer));
1392 }
1393
CaptureGetMscRateANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLint * numerator,EGLint * denominator,EGLBoolean returnValue)1394 CallCapture CaptureGetMscRateANGLE(egl::Thread *thread,
1395 bool isCallValid,
1396 egl::Display *dpyPacked,
1397 SurfaceID surfacePacked,
1398 EGLint *numerator,
1399 EGLint *denominator,
1400 EGLBoolean returnValue)
1401 {
1402 ParamBuffer paramBuffer;
1403
1404 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1405 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
1406 paramBuffer.addValueParam("numerator", ParamType::TEGLintPointer, numerator);
1407 paramBuffer.addValueParam("denominator", ParamType::TEGLintPointer, denominator);
1408
1409 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1410 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1411 paramBuffer.addReturnValue(std::move(returnValueCapture));
1412
1413 return CallCapture(angle::EntryPoint::EGLGetMscRateANGLE, std::move(paramBuffer));
1414 }
1415
CaptureExportVkImageANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,ImageID imagePacked,void * vk_image,void * vk_image_create_info,EGLBoolean returnValue)1416 CallCapture CaptureExportVkImageANGLE(egl::Thread *thread,
1417 bool isCallValid,
1418 egl::Display *dpyPacked,
1419 ImageID imagePacked,
1420 void *vk_image,
1421 void *vk_image_create_info,
1422 EGLBoolean returnValue)
1423 {
1424 ParamBuffer paramBuffer;
1425
1426 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1427 paramBuffer.addValueParam("imagePacked", ParamType::TImageID, imagePacked);
1428 paramBuffer.addValueParam("vk_image", ParamType::TvoidPointer, vk_image);
1429 paramBuffer.addValueParam("vk_image_create_info", ParamType::TvoidPointer,
1430 vk_image_create_info);
1431
1432 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1433 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1434 paramBuffer.addReturnValue(std::move(returnValueCapture));
1435
1436 return CallCapture(angle::EntryPoint::EGLExportVkImageANGLE, std::move(paramBuffer));
1437 }
1438
CaptureWaitUntilWorkScheduledANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked)1439 CallCapture CaptureWaitUntilWorkScheduledANGLE(egl::Thread *thread,
1440 bool isCallValid,
1441 egl::Display *dpyPacked)
1442 {
1443 ParamBuffer paramBuffer;
1444
1445 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1446
1447 return CallCapture(angle::EntryPoint::EGLWaitUntilWorkScheduledANGLE, std::move(paramBuffer));
1448 }
1449
CaptureGetSyncValuesCHROMIUM(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLuint64KHR * ust,EGLuint64KHR * msc,EGLuint64KHR * sbc,EGLBoolean returnValue)1450 CallCapture CaptureGetSyncValuesCHROMIUM(egl::Thread *thread,
1451 bool isCallValid,
1452 egl::Display *dpyPacked,
1453 SurfaceID surfacePacked,
1454 EGLuint64KHR *ust,
1455 EGLuint64KHR *msc,
1456 EGLuint64KHR *sbc,
1457 EGLBoolean returnValue)
1458 {
1459 ParamBuffer paramBuffer;
1460
1461 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1462 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
1463 paramBuffer.addValueParam("ust", ParamType::TEGLuint64KHRPointer, ust);
1464 paramBuffer.addValueParam("msc", ParamType::TEGLuint64KHRPointer, msc);
1465 paramBuffer.addValueParam("sbc", ParamType::TEGLuint64KHRPointer, sbc);
1466
1467 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1468 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1469 paramBuffer.addReturnValue(std::move(returnValueCapture));
1470
1471 return CallCapture(angle::EntryPoint::EGLGetSyncValuesCHROMIUM, std::move(paramBuffer));
1472 }
1473
CaptureQueryDeviceAttribEXT(egl::Thread * thread,bool isCallValid,egl::Device * devicePacked,EGLint attribute,EGLAttrib * value,EGLBoolean returnValue)1474 CallCapture CaptureQueryDeviceAttribEXT(egl::Thread *thread,
1475 bool isCallValid,
1476 egl::Device *devicePacked,
1477 EGLint attribute,
1478 EGLAttrib *value,
1479 EGLBoolean returnValue)
1480 {
1481 ParamBuffer paramBuffer;
1482
1483 paramBuffer.addValueParam("devicePacked", ParamType::Tegl_DevicePointer, devicePacked);
1484 paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
1485 paramBuffer.addValueParam("value", ParamType::TEGLAttribPointer, value);
1486
1487 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1488 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1489 paramBuffer.addReturnValue(std::move(returnValueCapture));
1490
1491 return CallCapture(angle::EntryPoint::EGLQueryDeviceAttribEXT, std::move(paramBuffer));
1492 }
1493
CaptureQueryDeviceStringEXT(egl::Thread * thread,bool isCallValid,egl::Device * devicePacked,EGLint name,const char * returnValue)1494 CallCapture CaptureQueryDeviceStringEXT(egl::Thread *thread,
1495 bool isCallValid,
1496 egl::Device *devicePacked,
1497 EGLint name,
1498 const char *returnValue)
1499 {
1500 ParamBuffer paramBuffer;
1501
1502 paramBuffer.addValueParam("devicePacked", ParamType::Tegl_DevicePointer, devicePacked);
1503 paramBuffer.addValueParam("name", ParamType::TEGLint, name);
1504
1505 ParamCapture returnValueCapture("returnValue", ParamType::TcharConstPointer);
1506 InitParamValue(ParamType::TcharConstPointer, returnValue, &returnValueCapture.value);
1507 paramBuffer.addReturnValue(std::move(returnValueCapture));
1508
1509 return CallCapture(angle::EntryPoint::EGLQueryDeviceStringEXT, std::move(paramBuffer));
1510 }
1511
CaptureQueryDisplayAttribEXT(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLint attribute,EGLAttrib * value,EGLBoolean returnValue)1512 CallCapture CaptureQueryDisplayAttribEXT(egl::Thread *thread,
1513 bool isCallValid,
1514 egl::Display *dpyPacked,
1515 EGLint attribute,
1516 EGLAttrib *value,
1517 EGLBoolean returnValue)
1518 {
1519 ParamBuffer paramBuffer;
1520
1521 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1522 paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
1523 paramBuffer.addValueParam("value", ParamType::TEGLAttribPointer, value);
1524
1525 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1526 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1527 paramBuffer.addReturnValue(std::move(returnValueCapture));
1528
1529 return CallCapture(angle::EntryPoint::EGLQueryDisplayAttribEXT, std::move(paramBuffer));
1530 }
1531
CaptureQueryDmaBufFormatsEXT(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLint max_formats,EGLint * formats,EGLint * num_formats,EGLBoolean returnValue)1532 CallCapture CaptureQueryDmaBufFormatsEXT(egl::Thread *thread,
1533 bool isCallValid,
1534 egl::Display *dpyPacked,
1535 EGLint max_formats,
1536 EGLint *formats,
1537 EGLint *num_formats,
1538 EGLBoolean returnValue)
1539 {
1540 ParamBuffer paramBuffer;
1541
1542 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1543 paramBuffer.addValueParam("max_formats", ParamType::TEGLint, max_formats);
1544 paramBuffer.addValueParam("formats", ParamType::TEGLintPointer, formats);
1545 paramBuffer.addValueParam("num_formats", ParamType::TEGLintPointer, num_formats);
1546
1547 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1548 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1549 paramBuffer.addReturnValue(std::move(returnValueCapture));
1550
1551 return CallCapture(angle::EntryPoint::EGLQueryDmaBufFormatsEXT, std::move(paramBuffer));
1552 }
1553
CaptureQueryDmaBufModifiersEXT(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLint format,EGLint max_modifiers,EGLuint64KHR * modifiers,EGLBoolean * external_only,EGLint * num_modifiers,EGLBoolean returnValue)1554 CallCapture CaptureQueryDmaBufModifiersEXT(egl::Thread *thread,
1555 bool isCallValid,
1556 egl::Display *dpyPacked,
1557 EGLint format,
1558 EGLint max_modifiers,
1559 EGLuint64KHR *modifiers,
1560 EGLBoolean *external_only,
1561 EGLint *num_modifiers,
1562 EGLBoolean returnValue)
1563 {
1564 ParamBuffer paramBuffer;
1565
1566 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1567 paramBuffer.addValueParam("format", ParamType::TEGLint, format);
1568 paramBuffer.addValueParam("max_modifiers", ParamType::TEGLint, max_modifiers);
1569 paramBuffer.addValueParam("modifiers", ParamType::TEGLuint64KHRPointer, modifiers);
1570 paramBuffer.addValueParam("external_only", ParamType::TEGLBooleanPointer, external_only);
1571 paramBuffer.addValueParam("num_modifiers", ParamType::TEGLintPointer, num_modifiers);
1572
1573 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1574 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1575 paramBuffer.addReturnValue(std::move(returnValueCapture));
1576
1577 return CallCapture(angle::EntryPoint::EGLQueryDmaBufModifiersEXT, std::move(paramBuffer));
1578 }
1579
CaptureCreatePlatformPixmapSurfaceEXT(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Config * configPacked,void * native_pixmap,const AttributeMap & attrib_listPacked,EGLSurface returnValue)1580 CallCapture CaptureCreatePlatformPixmapSurfaceEXT(egl::Thread *thread,
1581 bool isCallValid,
1582 egl::Display *dpyPacked,
1583 egl::Config *configPacked,
1584 void *native_pixmap,
1585 const AttributeMap &attrib_listPacked,
1586 EGLSurface returnValue)
1587 {
1588 ParamBuffer paramBuffer;
1589
1590 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1591 paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
1592 paramBuffer.addValueParam("native_pixmap", ParamType::TvoidPointer, native_pixmap);
1593 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
1594
1595 ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface);
1596 InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value);
1597 paramBuffer.addReturnValue(std::move(returnValueCapture));
1598
1599 return CallCapture(angle::EntryPoint::EGLCreatePlatformPixmapSurfaceEXT,
1600 std::move(paramBuffer));
1601 }
1602
CaptureCreatePlatformWindowSurfaceEXT(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Config * configPacked,void * native_window,const AttributeMap & attrib_listPacked,EGLSurface returnValue)1603 CallCapture CaptureCreatePlatformWindowSurfaceEXT(egl::Thread *thread,
1604 bool isCallValid,
1605 egl::Display *dpyPacked,
1606 egl::Config *configPacked,
1607 void *native_window,
1608 const AttributeMap &attrib_listPacked,
1609 EGLSurface returnValue)
1610 {
1611 ParamBuffer paramBuffer;
1612
1613 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1614 paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
1615 paramBuffer.addValueParam("native_window", ParamType::TvoidPointer, native_window);
1616 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
1617
1618 ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface);
1619 InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value);
1620 paramBuffer.addReturnValue(std::move(returnValueCapture));
1621
1622 return CallCapture(angle::EntryPoint::EGLCreatePlatformWindowSurfaceEXT,
1623 std::move(paramBuffer));
1624 }
1625
CaptureGetPlatformDisplayEXT(egl::Thread * thread,bool isCallValid,EGLenum platform,void * native_display,const AttributeMap & attrib_listPacked,EGLDisplay returnValue)1626 CallCapture CaptureGetPlatformDisplayEXT(egl::Thread *thread,
1627 bool isCallValid,
1628 EGLenum platform,
1629 void *native_display,
1630 const AttributeMap &attrib_listPacked,
1631 EGLDisplay returnValue)
1632 {
1633 ParamBuffer paramBuffer;
1634
1635 paramBuffer.addValueParam("platform", ParamType::TEGLenum, platform);
1636 paramBuffer.addValueParam("native_display", ParamType::TvoidPointer, native_display);
1637 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
1638
1639 ParamCapture returnValueCapture("returnValue", ParamType::TEGLDisplay);
1640 InitParamValue(ParamType::TEGLDisplay, returnValue, &returnValueCapture.value);
1641 paramBuffer.addReturnValue(std::move(returnValueCapture));
1642
1643 return CallCapture(angle::EntryPoint::EGLGetPlatformDisplayEXT, std::move(paramBuffer));
1644 }
1645
CaptureDebugMessageControlKHR(egl::Thread * thread,bool isCallValid,EGLDEBUGPROCKHR callback,const AttributeMap & attrib_listPacked,EGLint returnValue)1646 CallCapture CaptureDebugMessageControlKHR(egl::Thread *thread,
1647 bool isCallValid,
1648 EGLDEBUGPROCKHR callback,
1649 const AttributeMap &attrib_listPacked,
1650 EGLint returnValue)
1651 {
1652 ParamBuffer paramBuffer;
1653
1654 paramBuffer.addValueParam("callback", ParamType::TEGLDEBUGPROCKHR, callback);
1655 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
1656
1657 ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
1658 InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
1659 paramBuffer.addReturnValue(std::move(returnValueCapture));
1660
1661 return CallCapture(angle::EntryPoint::EGLDebugMessageControlKHR, std::move(paramBuffer));
1662 }
1663
CaptureLabelObjectKHR(egl::Thread * thread,bool isCallValid,egl::Display * displayPacked,ObjectType objectTypePacked,EGLObjectKHR object,EGLLabelKHR label,EGLint returnValue)1664 CallCapture CaptureLabelObjectKHR(egl::Thread *thread,
1665 bool isCallValid,
1666 egl::Display *displayPacked,
1667 ObjectType objectTypePacked,
1668 EGLObjectKHR object,
1669 EGLLabelKHR label,
1670 EGLint returnValue)
1671 {
1672 ParamBuffer paramBuffer;
1673
1674 paramBuffer.addValueParam("displayPacked", ParamType::Tegl_DisplayPointer, displayPacked);
1675 paramBuffer.addValueParam("objectTypePacked", ParamType::TObjectType, objectTypePacked);
1676 paramBuffer.addValueParam("object", ParamType::TEGLObjectKHR, object);
1677 paramBuffer.addValueParam("label", ParamType::TEGLLabelKHR, label);
1678
1679 ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
1680 InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
1681 paramBuffer.addReturnValue(std::move(returnValueCapture));
1682
1683 return CallCapture(angle::EntryPoint::EGLLabelObjectKHR, std::move(paramBuffer));
1684 }
1685
CaptureQueryDebugKHR(egl::Thread * thread,bool isCallValid,EGLint attribute,EGLAttrib * value,EGLBoolean returnValue)1686 CallCapture CaptureQueryDebugKHR(egl::Thread *thread,
1687 bool isCallValid,
1688 EGLint attribute,
1689 EGLAttrib *value,
1690 EGLBoolean returnValue)
1691 {
1692 ParamBuffer paramBuffer;
1693
1694 paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
1695 paramBuffer.addValueParam("value", ParamType::TEGLAttribPointer, value);
1696
1697 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1698 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1699 paramBuffer.addReturnValue(std::move(returnValueCapture));
1700
1701 return CallCapture(angle::EntryPoint::EGLQueryDebugKHR, std::move(paramBuffer));
1702 }
1703
CaptureClientWaitSyncKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::SyncID syncPacked,EGLint flags,EGLTimeKHR timeout,EGLint returnValue)1704 CallCapture CaptureClientWaitSyncKHR(egl::Thread *thread,
1705 bool isCallValid,
1706 egl::Display *dpyPacked,
1707 egl::SyncID syncPacked,
1708 EGLint flags,
1709 EGLTimeKHR timeout,
1710 EGLint returnValue)
1711 {
1712 ParamBuffer paramBuffer;
1713
1714 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1715 paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
1716 paramBuffer.addValueParam("flags", ParamType::TEGLint, flags);
1717 paramBuffer.addValueParam("timeout", ParamType::TEGLTimeKHR, timeout);
1718
1719 ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
1720 InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
1721 paramBuffer.addReturnValue(std::move(returnValueCapture));
1722
1723 return CallCapture(angle::EntryPoint::EGLClientWaitSyncKHR, std::move(paramBuffer));
1724 }
1725
CaptureCreateSyncKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLenum type,const AttributeMap & attrib_listPacked,EGLSyncKHR returnValue)1726 CallCapture CaptureCreateSyncKHR(egl::Thread *thread,
1727 bool isCallValid,
1728 egl::Display *dpyPacked,
1729 EGLenum type,
1730 const AttributeMap &attrib_listPacked,
1731 EGLSyncKHR returnValue)
1732 {
1733 ParamBuffer paramBuffer;
1734
1735 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1736 paramBuffer.addValueParam("type", ParamType::TEGLenum, type);
1737 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
1738
1739 ParamCapture returnValueCapture("returnValue", ParamType::TEGLSyncKHR);
1740 InitParamValue(ParamType::TEGLSyncKHR, returnValue, &returnValueCapture.value);
1741 paramBuffer.addReturnValue(std::move(returnValueCapture));
1742
1743 return CallCapture(angle::EntryPoint::EGLCreateSyncKHR, std::move(paramBuffer));
1744 }
1745
CaptureDestroySyncKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::SyncID syncPacked,EGLBoolean returnValue)1746 CallCapture CaptureDestroySyncKHR(egl::Thread *thread,
1747 bool isCallValid,
1748 egl::Display *dpyPacked,
1749 egl::SyncID syncPacked,
1750 EGLBoolean returnValue)
1751 {
1752 ParamBuffer paramBuffer;
1753
1754 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1755 paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
1756
1757 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1758 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1759 paramBuffer.addReturnValue(std::move(returnValueCapture));
1760
1761 return CallCapture(angle::EntryPoint::EGLDestroySyncKHR, std::move(paramBuffer));
1762 }
1763
CaptureGetSyncAttribKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::SyncID syncPacked,EGLint attribute,EGLint * value,EGLBoolean returnValue)1764 CallCapture CaptureGetSyncAttribKHR(egl::Thread *thread,
1765 bool isCallValid,
1766 egl::Display *dpyPacked,
1767 egl::SyncID syncPacked,
1768 EGLint attribute,
1769 EGLint *value,
1770 EGLBoolean returnValue)
1771 {
1772 ParamBuffer paramBuffer;
1773
1774 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1775 paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
1776 paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
1777 paramBuffer.addValueParam("value", ParamType::TEGLintPointer, value);
1778
1779 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1780 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1781 paramBuffer.addReturnValue(std::move(returnValueCapture));
1782
1783 return CallCapture(angle::EntryPoint::EGLGetSyncAttribKHR, std::move(paramBuffer));
1784 }
1785
CaptureCreateImageKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,gl::ContextID ctxPacked,EGLenum target,EGLClientBuffer buffer,const AttributeMap & attrib_listPacked,EGLImageKHR returnValue)1786 CallCapture CaptureCreateImageKHR(egl::Thread *thread,
1787 bool isCallValid,
1788 egl::Display *dpyPacked,
1789 gl::ContextID ctxPacked,
1790 EGLenum target,
1791 EGLClientBuffer buffer,
1792 const AttributeMap &attrib_listPacked,
1793 EGLImageKHR returnValue)
1794 {
1795 ParamBuffer paramBuffer;
1796
1797 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1798 paramBuffer.addValueParam("ctxPacked", ParamType::TContextID, ctxPacked);
1799 paramBuffer.addValueParam("target", ParamType::TEGLenum, target);
1800 paramBuffer.addValueParam("buffer", ParamType::TEGLClientBuffer, buffer);
1801 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
1802
1803 ParamCapture returnValueCapture("returnValue", ParamType::TEGLImageKHR);
1804 InitParamValue(ParamType::TEGLImageKHR, returnValue, &returnValueCapture.value);
1805 paramBuffer.addReturnValue(std::move(returnValueCapture));
1806
1807 return CallCapture(angle::EntryPoint::EGLCreateImageKHR, std::move(paramBuffer));
1808 }
1809
CaptureDestroyImageKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,ImageID imagePacked,EGLBoolean returnValue)1810 CallCapture CaptureDestroyImageKHR(egl::Thread *thread,
1811 bool isCallValid,
1812 egl::Display *dpyPacked,
1813 ImageID imagePacked,
1814 EGLBoolean returnValue)
1815 {
1816 ParamBuffer paramBuffer;
1817
1818 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1819 paramBuffer.addValueParam("imagePacked", ParamType::TImageID, imagePacked);
1820
1821 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1822 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1823 paramBuffer.addReturnValue(std::move(returnValueCapture));
1824
1825 return CallCapture(angle::EntryPoint::EGLDestroyImageKHR, std::move(paramBuffer));
1826 }
1827
CaptureLockSurfaceKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,const AttributeMap & attrib_listPacked,EGLBoolean returnValue)1828 CallCapture CaptureLockSurfaceKHR(egl::Thread *thread,
1829 bool isCallValid,
1830 egl::Display *dpyPacked,
1831 SurfaceID surfacePacked,
1832 const AttributeMap &attrib_listPacked,
1833 EGLBoolean returnValue)
1834 {
1835 ParamBuffer paramBuffer;
1836
1837 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1838 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
1839 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
1840
1841 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1842 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1843 paramBuffer.addReturnValue(std::move(returnValueCapture));
1844
1845 return CallCapture(angle::EntryPoint::EGLLockSurfaceKHR, std::move(paramBuffer));
1846 }
1847
CaptureQuerySurface64KHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLint attribute,EGLAttribKHR * value,EGLBoolean returnValue)1848 CallCapture CaptureQuerySurface64KHR(egl::Thread *thread,
1849 bool isCallValid,
1850 egl::Display *dpyPacked,
1851 SurfaceID surfacePacked,
1852 EGLint attribute,
1853 EGLAttribKHR *value,
1854 EGLBoolean returnValue)
1855 {
1856 ParamBuffer paramBuffer;
1857
1858 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1859 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
1860 paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
1861 paramBuffer.addValueParam("value", ParamType::TEGLAttribKHRPointer, value);
1862
1863 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1864 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1865 paramBuffer.addReturnValue(std::move(returnValueCapture));
1866
1867 return CallCapture(angle::EntryPoint::EGLQuerySurface64KHR, std::move(paramBuffer));
1868 }
1869
CaptureUnlockSurfaceKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLBoolean returnValue)1870 CallCapture CaptureUnlockSurfaceKHR(egl::Thread *thread,
1871 bool isCallValid,
1872 egl::Display *dpyPacked,
1873 SurfaceID surfacePacked,
1874 EGLBoolean returnValue)
1875 {
1876 ParamBuffer paramBuffer;
1877
1878 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1879 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
1880
1881 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1882 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1883 paramBuffer.addReturnValue(std::move(returnValueCapture));
1884
1885 return CallCapture(angle::EntryPoint::EGLUnlockSurfaceKHR, std::move(paramBuffer));
1886 }
1887
CaptureSetDamageRegionKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLint * rects,EGLint n_rects,EGLBoolean returnValue)1888 CallCapture CaptureSetDamageRegionKHR(egl::Thread *thread,
1889 bool isCallValid,
1890 egl::Display *dpyPacked,
1891 SurfaceID surfacePacked,
1892 EGLint *rects,
1893 EGLint n_rects,
1894 EGLBoolean returnValue)
1895 {
1896 ParamBuffer paramBuffer;
1897
1898 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1899 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
1900 paramBuffer.addValueParam("rects", ParamType::TEGLintPointer, rects);
1901 paramBuffer.addValueParam("n_rects", ParamType::TEGLint, n_rects);
1902
1903 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1904 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1905 paramBuffer.addReturnValue(std::move(returnValueCapture));
1906
1907 return CallCapture(angle::EntryPoint::EGLSetDamageRegionKHR, std::move(paramBuffer));
1908 }
1909
CaptureSignalSyncKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::SyncID syncPacked,EGLenum mode,EGLBoolean returnValue)1910 CallCapture CaptureSignalSyncKHR(egl::Thread *thread,
1911 bool isCallValid,
1912 egl::Display *dpyPacked,
1913 egl::SyncID syncPacked,
1914 EGLenum mode,
1915 EGLBoolean returnValue)
1916 {
1917 ParamBuffer paramBuffer;
1918
1919 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1920 paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
1921 paramBuffer.addValueParam("mode", ParamType::TEGLenum, mode);
1922
1923 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1924 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1925 paramBuffer.addReturnValue(std::move(returnValueCapture));
1926
1927 return CallCapture(angle::EntryPoint::EGLSignalSyncKHR, std::move(paramBuffer));
1928 }
1929
CaptureCreateStreamKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,const AttributeMap & attrib_listPacked,EGLStreamKHR returnValue)1930 CallCapture CaptureCreateStreamKHR(egl::Thread *thread,
1931 bool isCallValid,
1932 egl::Display *dpyPacked,
1933 const AttributeMap &attrib_listPacked,
1934 EGLStreamKHR returnValue)
1935 {
1936 ParamBuffer paramBuffer;
1937
1938 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1939 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
1940
1941 ParamCapture returnValueCapture("returnValue", ParamType::TEGLStreamKHR);
1942 InitParamValue(ParamType::TEGLStreamKHR, returnValue, &returnValueCapture.value);
1943 paramBuffer.addReturnValue(std::move(returnValueCapture));
1944
1945 return CallCapture(angle::EntryPoint::EGLCreateStreamKHR, std::move(paramBuffer));
1946 }
1947
CaptureDestroyStreamKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Stream * streamPacked,EGLBoolean returnValue)1948 CallCapture CaptureDestroyStreamKHR(egl::Thread *thread,
1949 bool isCallValid,
1950 egl::Display *dpyPacked,
1951 egl::Stream *streamPacked,
1952 EGLBoolean returnValue)
1953 {
1954 ParamBuffer paramBuffer;
1955
1956 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1957 paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
1958
1959 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1960 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1961 paramBuffer.addReturnValue(std::move(returnValueCapture));
1962
1963 return CallCapture(angle::EntryPoint::EGLDestroyStreamKHR, std::move(paramBuffer));
1964 }
1965
CaptureQueryStreamKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Stream * streamPacked,EGLenum attribute,EGLint * value,EGLBoolean returnValue)1966 CallCapture CaptureQueryStreamKHR(egl::Thread *thread,
1967 bool isCallValid,
1968 egl::Display *dpyPacked,
1969 egl::Stream *streamPacked,
1970 EGLenum attribute,
1971 EGLint *value,
1972 EGLBoolean returnValue)
1973 {
1974 ParamBuffer paramBuffer;
1975
1976 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1977 paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
1978 paramBuffer.addValueParam("attribute", ParamType::TEGLenum, attribute);
1979 paramBuffer.addValueParam("value", ParamType::TEGLintPointer, value);
1980
1981 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1982 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1983 paramBuffer.addReturnValue(std::move(returnValueCapture));
1984
1985 return CallCapture(angle::EntryPoint::EGLQueryStreamKHR, std::move(paramBuffer));
1986 }
1987
CaptureQueryStreamu64KHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Stream * streamPacked,EGLenum attribute,EGLuint64KHR * value,EGLBoolean returnValue)1988 CallCapture CaptureQueryStreamu64KHR(egl::Thread *thread,
1989 bool isCallValid,
1990 egl::Display *dpyPacked,
1991 egl::Stream *streamPacked,
1992 EGLenum attribute,
1993 EGLuint64KHR *value,
1994 EGLBoolean returnValue)
1995 {
1996 ParamBuffer paramBuffer;
1997
1998 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1999 paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
2000 paramBuffer.addValueParam("attribute", ParamType::TEGLenum, attribute);
2001 paramBuffer.addValueParam("value", ParamType::TEGLuint64KHRPointer, value);
2002
2003 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
2004 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
2005 paramBuffer.addReturnValue(std::move(returnValueCapture));
2006
2007 return CallCapture(angle::EntryPoint::EGLQueryStreamu64KHR, std::move(paramBuffer));
2008 }
2009
CaptureStreamAttribKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Stream * streamPacked,EGLenum attribute,EGLint value,EGLBoolean returnValue)2010 CallCapture CaptureStreamAttribKHR(egl::Thread *thread,
2011 bool isCallValid,
2012 egl::Display *dpyPacked,
2013 egl::Stream *streamPacked,
2014 EGLenum attribute,
2015 EGLint value,
2016 EGLBoolean returnValue)
2017 {
2018 ParamBuffer paramBuffer;
2019
2020 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
2021 paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
2022 paramBuffer.addValueParam("attribute", ParamType::TEGLenum, attribute);
2023 paramBuffer.addValueParam("value", ParamType::TEGLint, value);
2024
2025 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
2026 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
2027 paramBuffer.addReturnValue(std::move(returnValueCapture));
2028
2029 return CallCapture(angle::EntryPoint::EGLStreamAttribKHR, std::move(paramBuffer));
2030 }
2031
CaptureStreamConsumerAcquireKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Stream * streamPacked,EGLBoolean returnValue)2032 CallCapture CaptureStreamConsumerAcquireKHR(egl::Thread *thread,
2033 bool isCallValid,
2034 egl::Display *dpyPacked,
2035 egl::Stream *streamPacked,
2036 EGLBoolean returnValue)
2037 {
2038 ParamBuffer paramBuffer;
2039
2040 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
2041 paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
2042
2043 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
2044 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
2045 paramBuffer.addReturnValue(std::move(returnValueCapture));
2046
2047 return CallCapture(angle::EntryPoint::EGLStreamConsumerAcquireKHR, std::move(paramBuffer));
2048 }
2049
CaptureStreamConsumerGLTextureExternalKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Stream * streamPacked,EGLBoolean returnValue)2050 CallCapture CaptureStreamConsumerGLTextureExternalKHR(egl::Thread *thread,
2051 bool isCallValid,
2052 egl::Display *dpyPacked,
2053 egl::Stream *streamPacked,
2054 EGLBoolean returnValue)
2055 {
2056 ParamBuffer paramBuffer;
2057
2058 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
2059 paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
2060
2061 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
2062 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
2063 paramBuffer.addReturnValue(std::move(returnValueCapture));
2064
2065 return CallCapture(angle::EntryPoint::EGLStreamConsumerGLTextureExternalKHR,
2066 std::move(paramBuffer));
2067 }
2068
CaptureStreamConsumerReleaseKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Stream * streamPacked,EGLBoolean returnValue)2069 CallCapture CaptureStreamConsumerReleaseKHR(egl::Thread *thread,
2070 bool isCallValid,
2071 egl::Display *dpyPacked,
2072 egl::Stream *streamPacked,
2073 EGLBoolean returnValue)
2074 {
2075 ParamBuffer paramBuffer;
2076
2077 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
2078 paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
2079
2080 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
2081 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
2082 paramBuffer.addReturnValue(std::move(returnValueCapture));
2083
2084 return CallCapture(angle::EntryPoint::EGLStreamConsumerReleaseKHR, std::move(paramBuffer));
2085 }
2086
CaptureSwapBuffersWithDamageKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,const EGLint * rects,EGLint n_rects,EGLBoolean returnValue)2087 CallCapture CaptureSwapBuffersWithDamageKHR(egl::Thread *thread,
2088 bool isCallValid,
2089 egl::Display *dpyPacked,
2090 SurfaceID surfacePacked,
2091 const EGLint *rects,
2092 EGLint n_rects,
2093 EGLBoolean returnValue)
2094 {
2095 ParamBuffer paramBuffer;
2096
2097 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
2098 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
2099 paramBuffer.addValueParam("rects", ParamType::TEGLintConstPointer, rects);
2100 paramBuffer.addValueParam("n_rects", ParamType::TEGLint, n_rects);
2101
2102 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
2103 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
2104 paramBuffer.addReturnValue(std::move(returnValueCapture));
2105
2106 return CallCapture(angle::EntryPoint::EGLSwapBuffersWithDamageKHR, std::move(paramBuffer));
2107 }
2108
CaptureWaitSyncKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::SyncID syncPacked,EGLint flags,EGLint returnValue)2109 CallCapture CaptureWaitSyncKHR(egl::Thread *thread,
2110 bool isCallValid,
2111 egl::Display *dpyPacked,
2112 egl::SyncID syncPacked,
2113 EGLint flags,
2114 EGLint returnValue)
2115 {
2116 ParamBuffer paramBuffer;
2117
2118 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
2119 paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
2120 paramBuffer.addValueParam("flags", ParamType::TEGLint, flags);
2121
2122 ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
2123 InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
2124 paramBuffer.addReturnValue(std::move(returnValueCapture));
2125
2126 return CallCapture(angle::EntryPoint::EGLWaitSyncKHR, std::move(paramBuffer));
2127 }
2128
CapturePostSubBufferNV(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLint x,EGLint y,EGLint width,EGLint height,EGLBoolean returnValue)2129 CallCapture CapturePostSubBufferNV(egl::Thread *thread,
2130 bool isCallValid,
2131 egl::Display *dpyPacked,
2132 SurfaceID surfacePacked,
2133 EGLint x,
2134 EGLint y,
2135 EGLint width,
2136 EGLint height,
2137 EGLBoolean returnValue)
2138 {
2139 ParamBuffer paramBuffer;
2140
2141 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
2142 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
2143 paramBuffer.addValueParam("x", ParamType::TEGLint, x);
2144 paramBuffer.addValueParam("y", ParamType::TEGLint, y);
2145 paramBuffer.addValueParam("width", ParamType::TEGLint, width);
2146 paramBuffer.addValueParam("height", ParamType::TEGLint, height);
2147
2148 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
2149 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
2150 paramBuffer.addReturnValue(std::move(returnValueCapture));
2151
2152 return CallCapture(angle::EntryPoint::EGLPostSubBufferNV, std::move(paramBuffer));
2153 }
2154
CaptureStreamConsumerGLTextureExternalAttribsNV(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Stream * streamPacked,const AttributeMap & attrib_listPacked,EGLBoolean returnValue)2155 CallCapture CaptureStreamConsumerGLTextureExternalAttribsNV(egl::Thread *thread,
2156 bool isCallValid,
2157 egl::Display *dpyPacked,
2158 egl::Stream *streamPacked,
2159 const AttributeMap &attrib_listPacked,
2160 EGLBoolean returnValue)
2161 {
2162 ParamBuffer paramBuffer;
2163
2164 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
2165 paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
2166 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
2167
2168 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
2169 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
2170 paramBuffer.addReturnValue(std::move(returnValueCapture));
2171
2172 return CallCapture(angle::EntryPoint::EGLStreamConsumerGLTextureExternalAttribsNV,
2173 std::move(paramBuffer));
2174 }
2175
2176 } // namespace egl
2177