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
CaptureLockVulkanQueueANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked)1067 CallCapture CaptureLockVulkanQueueANGLE(egl::Thread *thread,
1068 bool isCallValid,
1069 egl::Display *dpyPacked)
1070 {
1071 ParamBuffer paramBuffer;
1072
1073 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1074
1075 return CallCapture(angle::EntryPoint::EGLLockVulkanQueueANGLE, std::move(paramBuffer));
1076 }
1077
CaptureUnlockVulkanQueueANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked)1078 CallCapture CaptureUnlockVulkanQueueANGLE(egl::Thread *thread,
1079 bool isCallValid,
1080 egl::Display *dpyPacked)
1081 {
1082 ParamBuffer paramBuffer;
1083
1084 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1085
1086 return CallCapture(angle::EntryPoint::EGLUnlockVulkanQueueANGLE, std::move(paramBuffer));
1087 }
1088
CaptureAcquireExternalContextANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID drawAndReadPacked)1089 CallCapture CaptureAcquireExternalContextANGLE(egl::Thread *thread,
1090 bool isCallValid,
1091 egl::Display *dpyPacked,
1092 SurfaceID drawAndReadPacked)
1093 {
1094 ParamBuffer paramBuffer;
1095
1096 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1097 paramBuffer.addValueParam("drawAndReadPacked", ParamType::TSurfaceID, drawAndReadPacked);
1098
1099 return CallCapture(angle::EntryPoint::EGLAcquireExternalContextANGLE, std::move(paramBuffer));
1100 }
1101
CaptureReleaseExternalContextANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked)1102 CallCapture CaptureReleaseExternalContextANGLE(egl::Thread *thread,
1103 bool isCallValid,
1104 egl::Display *dpyPacked)
1105 {
1106 ParamBuffer paramBuffer;
1107
1108 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1109
1110 return CallCapture(angle::EntryPoint::EGLReleaseExternalContextANGLE, std::move(paramBuffer));
1111 }
1112
CaptureQueryStringiANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLint name,EGLint index,const char * returnValue)1113 CallCapture CaptureQueryStringiANGLE(egl::Thread *thread,
1114 bool isCallValid,
1115 egl::Display *dpyPacked,
1116 EGLint name,
1117 EGLint index,
1118 const char *returnValue)
1119 {
1120 ParamBuffer paramBuffer;
1121
1122 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1123 paramBuffer.addValueParam("name", ParamType::TEGLint, name);
1124 paramBuffer.addValueParam("index", ParamType::TEGLint, index);
1125
1126 ParamCapture returnValueCapture("returnValue", ParamType::TcharConstPointer);
1127 InitParamValue(ParamType::TcharConstPointer, returnValue, &returnValueCapture.value);
1128 paramBuffer.addReturnValue(std::move(returnValueCapture));
1129
1130 return CallCapture(angle::EntryPoint::EGLQueryStringiANGLE, std::move(paramBuffer));
1131 }
1132
CaptureQueryDisplayAttribANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLint attribute,EGLAttrib * value,EGLBoolean returnValue)1133 CallCapture CaptureQueryDisplayAttribANGLE(egl::Thread *thread,
1134 bool isCallValid,
1135 egl::Display *dpyPacked,
1136 EGLint attribute,
1137 EGLAttrib *value,
1138 EGLBoolean returnValue)
1139 {
1140 ParamBuffer paramBuffer;
1141
1142 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1143 paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
1144 paramBuffer.addValueParam("value", ParamType::TEGLAttribPointer, value);
1145
1146 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1147 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1148 paramBuffer.addReturnValue(std::move(returnValueCapture));
1149
1150 return CallCapture(angle::EntryPoint::EGLQueryDisplayAttribANGLE, std::move(paramBuffer));
1151 }
1152
CaptureCopyMetalSharedEventANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::SyncID syncPacked,void * returnValue)1153 CallCapture CaptureCopyMetalSharedEventANGLE(egl::Thread *thread,
1154 bool isCallValid,
1155 egl::Display *dpyPacked,
1156 egl::SyncID syncPacked,
1157 void *returnValue)
1158 {
1159 ParamBuffer paramBuffer;
1160
1161 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1162 paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
1163
1164 ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer);
1165 InitParamValue(ParamType::TvoidPointer, returnValue, &returnValueCapture.value);
1166 paramBuffer.addReturnValue(std::move(returnValueCapture));
1167
1168 return CallCapture(angle::EntryPoint::EGLCopyMetalSharedEventANGLE, std::move(paramBuffer));
1169 }
1170
CaptureSetValidationEnabledANGLE(egl::Thread * thread,bool isCallValid,EGLBoolean validationState)1171 CallCapture CaptureSetValidationEnabledANGLE(egl::Thread *thread,
1172 bool isCallValid,
1173 EGLBoolean validationState)
1174 {
1175 ParamBuffer paramBuffer;
1176
1177 paramBuffer.addValueParam("validationState", ParamType::TEGLBoolean, validationState);
1178
1179 return CallCapture(angle::EntryPoint::EGLSetValidationEnabledANGLE, std::move(paramBuffer));
1180 }
1181
CaptureReleaseHighPowerGPUANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,gl::ContextID ctxPacked)1182 CallCapture CaptureReleaseHighPowerGPUANGLE(egl::Thread *thread,
1183 bool isCallValid,
1184 egl::Display *dpyPacked,
1185 gl::ContextID ctxPacked)
1186 {
1187 ParamBuffer paramBuffer;
1188
1189 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1190 paramBuffer.addValueParam("ctxPacked", ParamType::TContextID, ctxPacked);
1191
1192 return CallCapture(angle::EntryPoint::EGLReleaseHighPowerGPUANGLE, std::move(paramBuffer));
1193 }
1194
CaptureReacquireHighPowerGPUANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,gl::ContextID ctxPacked)1195 CallCapture CaptureReacquireHighPowerGPUANGLE(egl::Thread *thread,
1196 bool isCallValid,
1197 egl::Display *dpyPacked,
1198 gl::ContextID ctxPacked)
1199 {
1200 ParamBuffer paramBuffer;
1201
1202 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1203 paramBuffer.addValueParam("ctxPacked", ParamType::TContextID, ctxPacked);
1204
1205 return CallCapture(angle::EntryPoint::EGLReacquireHighPowerGPUANGLE, std::move(paramBuffer));
1206 }
1207
CaptureHandleGPUSwitchANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked)1208 CallCapture CaptureHandleGPUSwitchANGLE(egl::Thread *thread,
1209 bool isCallValid,
1210 egl::Display *dpyPacked)
1211 {
1212 ParamBuffer paramBuffer;
1213
1214 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1215
1216 return CallCapture(angle::EntryPoint::EGLHandleGPUSwitchANGLE, std::move(paramBuffer));
1217 }
1218
CaptureForceGPUSwitchANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLint gpuIDHigh,EGLint gpuIDLow)1219 CallCapture CaptureForceGPUSwitchANGLE(egl::Thread *thread,
1220 bool isCallValid,
1221 egl::Display *dpyPacked,
1222 EGLint gpuIDHigh,
1223 EGLint gpuIDLow)
1224 {
1225 ParamBuffer paramBuffer;
1226
1227 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1228 paramBuffer.addValueParam("gpuIDHigh", ParamType::TEGLint, gpuIDHigh);
1229 paramBuffer.addValueParam("gpuIDLow", ParamType::TEGLint, gpuIDLow);
1230
1231 return CallCapture(angle::EntryPoint::EGLForceGPUSwitchANGLE, std::move(paramBuffer));
1232 }
1233
CapturePrepareSwapBuffersANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLBoolean returnValue)1234 CallCapture CapturePrepareSwapBuffersANGLE(egl::Thread *thread,
1235 bool isCallValid,
1236 egl::Display *dpyPacked,
1237 SurfaceID surfacePacked,
1238 EGLBoolean returnValue)
1239 {
1240 ParamBuffer paramBuffer;
1241
1242 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1243 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
1244
1245 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1246 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1247 paramBuffer.addReturnValue(std::move(returnValueCapture));
1248
1249 return CallCapture(angle::EntryPoint::EGLPrepareSwapBuffersANGLE, std::move(paramBuffer));
1250 }
1251
CaptureProgramCacheGetAttribANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLenum attrib,EGLint returnValue)1252 CallCapture CaptureProgramCacheGetAttribANGLE(egl::Thread *thread,
1253 bool isCallValid,
1254 egl::Display *dpyPacked,
1255 EGLenum attrib,
1256 EGLint returnValue)
1257 {
1258 ParamBuffer paramBuffer;
1259
1260 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1261 paramBuffer.addValueParam("attrib", ParamType::TEGLenum, attrib);
1262
1263 ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
1264 InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
1265 paramBuffer.addReturnValue(std::move(returnValueCapture));
1266
1267 return CallCapture(angle::EntryPoint::EGLProgramCacheGetAttribANGLE, std::move(paramBuffer));
1268 }
1269
CaptureProgramCacheQueryANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLint index,void * key,EGLint * keysize,void * binary,EGLint * binarysize)1270 CallCapture CaptureProgramCacheQueryANGLE(egl::Thread *thread,
1271 bool isCallValid,
1272 egl::Display *dpyPacked,
1273 EGLint index,
1274 void *key,
1275 EGLint *keysize,
1276 void *binary,
1277 EGLint *binarysize)
1278 {
1279 ParamBuffer paramBuffer;
1280
1281 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1282 paramBuffer.addValueParam("index", ParamType::TEGLint, index);
1283 paramBuffer.addValueParam("key", ParamType::TvoidPointer, key);
1284 paramBuffer.addValueParam("keysize", ParamType::TEGLintPointer, keysize);
1285 paramBuffer.addValueParam("binary", ParamType::TvoidPointer, binary);
1286 paramBuffer.addValueParam("binarysize", ParamType::TEGLintPointer, binarysize);
1287
1288 return CallCapture(angle::EntryPoint::EGLProgramCacheQueryANGLE, std::move(paramBuffer));
1289 }
1290
CaptureProgramCachePopulateANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,const void * key,EGLint keysize,const void * binary,EGLint binarysize)1291 CallCapture CaptureProgramCachePopulateANGLE(egl::Thread *thread,
1292 bool isCallValid,
1293 egl::Display *dpyPacked,
1294 const void *key,
1295 EGLint keysize,
1296 const void *binary,
1297 EGLint binarysize)
1298 {
1299 ParamBuffer paramBuffer;
1300
1301 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1302 paramBuffer.addValueParam("key", ParamType::TvoidConstPointer, key);
1303 paramBuffer.addValueParam("keysize", ParamType::TEGLint, keysize);
1304 paramBuffer.addValueParam("binary", ParamType::TvoidConstPointer, binary);
1305 paramBuffer.addValueParam("binarysize", ParamType::TEGLint, binarysize);
1306
1307 return CallCapture(angle::EntryPoint::EGLProgramCachePopulateANGLE, std::move(paramBuffer));
1308 }
1309
CaptureProgramCacheResizeANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLint limit,EGLint mode,EGLint returnValue)1310 CallCapture CaptureProgramCacheResizeANGLE(egl::Thread *thread,
1311 bool isCallValid,
1312 egl::Display *dpyPacked,
1313 EGLint limit,
1314 EGLint mode,
1315 EGLint returnValue)
1316 {
1317 ParamBuffer paramBuffer;
1318
1319 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1320 paramBuffer.addValueParam("limit", ParamType::TEGLint, limit);
1321 paramBuffer.addValueParam("mode", ParamType::TEGLint, mode);
1322
1323 ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
1324 InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
1325 paramBuffer.addReturnValue(std::move(returnValueCapture));
1326
1327 return CallCapture(angle::EntryPoint::EGLProgramCacheResizeANGLE, std::move(paramBuffer));
1328 }
1329
CaptureQuerySurfacePointerANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLint attribute,void ** value,EGLBoolean returnValue)1330 CallCapture CaptureQuerySurfacePointerANGLE(egl::Thread *thread,
1331 bool isCallValid,
1332 egl::Display *dpyPacked,
1333 SurfaceID surfacePacked,
1334 EGLint attribute,
1335 void **value,
1336 EGLBoolean returnValue)
1337 {
1338 ParamBuffer paramBuffer;
1339
1340 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1341 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
1342 paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
1343 paramBuffer.addValueParam("value", ParamType::TvoidPointerPointer, value);
1344
1345 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1346 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1347 paramBuffer.addReturnValue(std::move(returnValueCapture));
1348
1349 return CallCapture(angle::EntryPoint::EGLQuerySurfacePointerANGLE, std::move(paramBuffer));
1350 }
1351
CaptureCreateStreamProducerD3DTextureANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Stream * streamPacked,const AttributeMap & attrib_listPacked,EGLBoolean returnValue)1352 CallCapture CaptureCreateStreamProducerD3DTextureANGLE(egl::Thread *thread,
1353 bool isCallValid,
1354 egl::Display *dpyPacked,
1355 egl::Stream *streamPacked,
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.addParam(CaptureAttributeMap(attrib_listPacked));
1364
1365 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1366 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1367 paramBuffer.addReturnValue(std::move(returnValueCapture));
1368
1369 return CallCapture(angle::EntryPoint::EGLCreateStreamProducerD3DTextureANGLE,
1370 std::move(paramBuffer));
1371 }
1372
CaptureStreamPostD3DTextureANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Stream * streamPacked,void * texture,const AttributeMap & attrib_listPacked,EGLBoolean returnValue)1373 CallCapture CaptureStreamPostD3DTextureANGLE(egl::Thread *thread,
1374 bool isCallValid,
1375 egl::Display *dpyPacked,
1376 egl::Stream *streamPacked,
1377 void *texture,
1378 const AttributeMap &attrib_listPacked,
1379 EGLBoolean returnValue)
1380 {
1381 ParamBuffer paramBuffer;
1382
1383 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1384 paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
1385 paramBuffer.addValueParam("texture", ParamType::TvoidPointer, texture);
1386 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
1387
1388 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1389 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1390 paramBuffer.addReturnValue(std::move(returnValueCapture));
1391
1392 return CallCapture(angle::EntryPoint::EGLStreamPostD3DTextureANGLE, std::move(paramBuffer));
1393 }
1394
CaptureGetMscRateANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLint * numerator,EGLint * denominator,EGLBoolean returnValue)1395 CallCapture CaptureGetMscRateANGLE(egl::Thread *thread,
1396 bool isCallValid,
1397 egl::Display *dpyPacked,
1398 SurfaceID surfacePacked,
1399 EGLint *numerator,
1400 EGLint *denominator,
1401 EGLBoolean returnValue)
1402 {
1403 ParamBuffer paramBuffer;
1404
1405 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1406 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
1407 paramBuffer.addValueParam("numerator", ParamType::TEGLintPointer, numerator);
1408 paramBuffer.addValueParam("denominator", ParamType::TEGLintPointer, denominator);
1409
1410 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1411 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1412 paramBuffer.addReturnValue(std::move(returnValueCapture));
1413
1414 return CallCapture(angle::EntryPoint::EGLGetMscRateANGLE, std::move(paramBuffer));
1415 }
1416
CaptureExportVkImageANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,ImageID imagePacked,void * vk_image,void * vk_image_create_info,EGLBoolean returnValue)1417 CallCapture CaptureExportVkImageANGLE(egl::Thread *thread,
1418 bool isCallValid,
1419 egl::Display *dpyPacked,
1420 ImageID imagePacked,
1421 void *vk_image,
1422 void *vk_image_create_info,
1423 EGLBoolean returnValue)
1424 {
1425 ParamBuffer paramBuffer;
1426
1427 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1428 paramBuffer.addValueParam("imagePacked", ParamType::TImageID, imagePacked);
1429 paramBuffer.addValueParam("vk_image", ParamType::TvoidPointer, vk_image);
1430 paramBuffer.addValueParam("vk_image_create_info", ParamType::TvoidPointer,
1431 vk_image_create_info);
1432
1433 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1434 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1435 paramBuffer.addReturnValue(std::move(returnValueCapture));
1436
1437 return CallCapture(angle::EntryPoint::EGLExportVkImageANGLE, std::move(paramBuffer));
1438 }
1439
CaptureWaitUntilWorkScheduledANGLE(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked)1440 CallCapture CaptureWaitUntilWorkScheduledANGLE(egl::Thread *thread,
1441 bool isCallValid,
1442 egl::Display *dpyPacked)
1443 {
1444 ParamBuffer paramBuffer;
1445
1446 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1447
1448 return CallCapture(angle::EntryPoint::EGLWaitUntilWorkScheduledANGLE, std::move(paramBuffer));
1449 }
1450
CaptureGetSyncValuesCHROMIUM(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLuint64KHR * ust,EGLuint64KHR * msc,EGLuint64KHR * sbc,EGLBoolean returnValue)1451 CallCapture CaptureGetSyncValuesCHROMIUM(egl::Thread *thread,
1452 bool isCallValid,
1453 egl::Display *dpyPacked,
1454 SurfaceID surfacePacked,
1455 EGLuint64KHR *ust,
1456 EGLuint64KHR *msc,
1457 EGLuint64KHR *sbc,
1458 EGLBoolean returnValue)
1459 {
1460 ParamBuffer paramBuffer;
1461
1462 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1463 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
1464 paramBuffer.addValueParam("ust", ParamType::TEGLuint64KHRPointer, ust);
1465 paramBuffer.addValueParam("msc", ParamType::TEGLuint64KHRPointer, msc);
1466 paramBuffer.addValueParam("sbc", ParamType::TEGLuint64KHRPointer, sbc);
1467
1468 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1469 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1470 paramBuffer.addReturnValue(std::move(returnValueCapture));
1471
1472 return CallCapture(angle::EntryPoint::EGLGetSyncValuesCHROMIUM, std::move(paramBuffer));
1473 }
1474
CaptureQueryDeviceAttribEXT(egl::Thread * thread,bool isCallValid,egl::Device * devicePacked,EGLint attribute,EGLAttrib * value,EGLBoolean returnValue)1475 CallCapture CaptureQueryDeviceAttribEXT(egl::Thread *thread,
1476 bool isCallValid,
1477 egl::Device *devicePacked,
1478 EGLint attribute,
1479 EGLAttrib *value,
1480 EGLBoolean returnValue)
1481 {
1482 ParamBuffer paramBuffer;
1483
1484 paramBuffer.addValueParam("devicePacked", ParamType::Tegl_DevicePointer, devicePacked);
1485 paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
1486 paramBuffer.addValueParam("value", ParamType::TEGLAttribPointer, value);
1487
1488 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1489 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1490 paramBuffer.addReturnValue(std::move(returnValueCapture));
1491
1492 return CallCapture(angle::EntryPoint::EGLQueryDeviceAttribEXT, std::move(paramBuffer));
1493 }
1494
CaptureQueryDeviceStringEXT(egl::Thread * thread,bool isCallValid,egl::Device * devicePacked,EGLint name,const char * returnValue)1495 CallCapture CaptureQueryDeviceStringEXT(egl::Thread *thread,
1496 bool isCallValid,
1497 egl::Device *devicePacked,
1498 EGLint name,
1499 const char *returnValue)
1500 {
1501 ParamBuffer paramBuffer;
1502
1503 paramBuffer.addValueParam("devicePacked", ParamType::Tegl_DevicePointer, devicePacked);
1504 paramBuffer.addValueParam("name", ParamType::TEGLint, name);
1505
1506 ParamCapture returnValueCapture("returnValue", ParamType::TcharConstPointer);
1507 InitParamValue(ParamType::TcharConstPointer, returnValue, &returnValueCapture.value);
1508 paramBuffer.addReturnValue(std::move(returnValueCapture));
1509
1510 return CallCapture(angle::EntryPoint::EGLQueryDeviceStringEXT, std::move(paramBuffer));
1511 }
1512
CaptureQueryDisplayAttribEXT(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLint attribute,EGLAttrib * value,EGLBoolean returnValue)1513 CallCapture CaptureQueryDisplayAttribEXT(egl::Thread *thread,
1514 bool isCallValid,
1515 egl::Display *dpyPacked,
1516 EGLint attribute,
1517 EGLAttrib *value,
1518 EGLBoolean returnValue)
1519 {
1520 ParamBuffer paramBuffer;
1521
1522 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1523 paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
1524 paramBuffer.addValueParam("value", ParamType::TEGLAttribPointer, value);
1525
1526 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1527 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1528 paramBuffer.addReturnValue(std::move(returnValueCapture));
1529
1530 return CallCapture(angle::EntryPoint::EGLQueryDisplayAttribEXT, std::move(paramBuffer));
1531 }
1532
CaptureQueryDmaBufFormatsEXT(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLint max_formats,EGLint * formats,EGLint * num_formats,EGLBoolean returnValue)1533 CallCapture CaptureQueryDmaBufFormatsEXT(egl::Thread *thread,
1534 bool isCallValid,
1535 egl::Display *dpyPacked,
1536 EGLint max_formats,
1537 EGLint *formats,
1538 EGLint *num_formats,
1539 EGLBoolean returnValue)
1540 {
1541 ParamBuffer paramBuffer;
1542
1543 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1544 paramBuffer.addValueParam("max_formats", ParamType::TEGLint, max_formats);
1545 paramBuffer.addValueParam("formats", ParamType::TEGLintPointer, formats);
1546 paramBuffer.addValueParam("num_formats", ParamType::TEGLintPointer, num_formats);
1547
1548 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1549 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1550 paramBuffer.addReturnValue(std::move(returnValueCapture));
1551
1552 return CallCapture(angle::EntryPoint::EGLQueryDmaBufFormatsEXT, std::move(paramBuffer));
1553 }
1554
CaptureQueryDmaBufModifiersEXT(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLint format,EGLint max_modifiers,EGLuint64KHR * modifiers,EGLBoolean * external_only,EGLint * num_modifiers,EGLBoolean returnValue)1555 CallCapture CaptureQueryDmaBufModifiersEXT(egl::Thread *thread,
1556 bool isCallValid,
1557 egl::Display *dpyPacked,
1558 EGLint format,
1559 EGLint max_modifiers,
1560 EGLuint64KHR *modifiers,
1561 EGLBoolean *external_only,
1562 EGLint *num_modifiers,
1563 EGLBoolean returnValue)
1564 {
1565 ParamBuffer paramBuffer;
1566
1567 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1568 paramBuffer.addValueParam("format", ParamType::TEGLint, format);
1569 paramBuffer.addValueParam("max_modifiers", ParamType::TEGLint, max_modifiers);
1570 paramBuffer.addValueParam("modifiers", ParamType::TEGLuint64KHRPointer, modifiers);
1571 paramBuffer.addValueParam("external_only", ParamType::TEGLBooleanPointer, external_only);
1572 paramBuffer.addValueParam("num_modifiers", ParamType::TEGLintPointer, num_modifiers);
1573
1574 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1575 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1576 paramBuffer.addReturnValue(std::move(returnValueCapture));
1577
1578 return CallCapture(angle::EntryPoint::EGLQueryDmaBufModifiersEXT, std::move(paramBuffer));
1579 }
1580
CaptureCreatePlatformPixmapSurfaceEXT(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Config * configPacked,void * native_pixmap,const AttributeMap & attrib_listPacked,EGLSurface returnValue)1581 CallCapture CaptureCreatePlatformPixmapSurfaceEXT(egl::Thread *thread,
1582 bool isCallValid,
1583 egl::Display *dpyPacked,
1584 egl::Config *configPacked,
1585 void *native_pixmap,
1586 const AttributeMap &attrib_listPacked,
1587 EGLSurface returnValue)
1588 {
1589 ParamBuffer paramBuffer;
1590
1591 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1592 paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
1593 paramBuffer.addValueParam("native_pixmap", ParamType::TvoidPointer, native_pixmap);
1594 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
1595
1596 ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface);
1597 InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value);
1598 paramBuffer.addReturnValue(std::move(returnValueCapture));
1599
1600 return CallCapture(angle::EntryPoint::EGLCreatePlatformPixmapSurfaceEXT,
1601 std::move(paramBuffer));
1602 }
1603
CaptureCreatePlatformWindowSurfaceEXT(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Config * configPacked,void * native_window,const AttributeMap & attrib_listPacked,EGLSurface returnValue)1604 CallCapture CaptureCreatePlatformWindowSurfaceEXT(egl::Thread *thread,
1605 bool isCallValid,
1606 egl::Display *dpyPacked,
1607 egl::Config *configPacked,
1608 void *native_window,
1609 const AttributeMap &attrib_listPacked,
1610 EGLSurface returnValue)
1611 {
1612 ParamBuffer paramBuffer;
1613
1614 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1615 paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
1616 paramBuffer.addValueParam("native_window", ParamType::TvoidPointer, native_window);
1617 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
1618
1619 ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface);
1620 InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value);
1621 paramBuffer.addReturnValue(std::move(returnValueCapture));
1622
1623 return CallCapture(angle::EntryPoint::EGLCreatePlatformWindowSurfaceEXT,
1624 std::move(paramBuffer));
1625 }
1626
CaptureGetPlatformDisplayEXT(egl::Thread * thread,bool isCallValid,EGLenum platform,void * native_display,const AttributeMap & attrib_listPacked,EGLDisplay returnValue)1627 CallCapture CaptureGetPlatformDisplayEXT(egl::Thread *thread,
1628 bool isCallValid,
1629 EGLenum platform,
1630 void *native_display,
1631 const AttributeMap &attrib_listPacked,
1632 EGLDisplay returnValue)
1633 {
1634 ParamBuffer paramBuffer;
1635
1636 paramBuffer.addValueParam("platform", ParamType::TEGLenum, platform);
1637 paramBuffer.addValueParam("native_display", ParamType::TvoidPointer, native_display);
1638 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
1639
1640 ParamCapture returnValueCapture("returnValue", ParamType::TEGLDisplay);
1641 InitParamValue(ParamType::TEGLDisplay, returnValue, &returnValueCapture.value);
1642 paramBuffer.addReturnValue(std::move(returnValueCapture));
1643
1644 return CallCapture(angle::EntryPoint::EGLGetPlatformDisplayEXT, std::move(paramBuffer));
1645 }
1646
CaptureQuerySupportedCompressionRatesEXT(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Config * configPacked,const EGLAttrib * attrib_list,EGLint * rates,EGLint rate_size,EGLint * num_rates,EGLBoolean returnValue)1647 CallCapture CaptureQuerySupportedCompressionRatesEXT(egl::Thread *thread,
1648 bool isCallValid,
1649 egl::Display *dpyPacked,
1650 egl::Config *configPacked,
1651 const EGLAttrib *attrib_list,
1652 EGLint *rates,
1653 EGLint rate_size,
1654 EGLint *num_rates,
1655 EGLBoolean returnValue)
1656 {
1657 ParamBuffer paramBuffer;
1658
1659 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1660 paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
1661 paramBuffer.addValueParam("attrib_list", ParamType::TEGLAttribConstPointer, attrib_list);
1662 paramBuffer.addValueParam("rates", ParamType::TEGLintPointer, rates);
1663 paramBuffer.addValueParam("rate_size", ParamType::TEGLint, rate_size);
1664 paramBuffer.addValueParam("num_rates", ParamType::TEGLintPointer, num_rates);
1665
1666 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1667 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1668 paramBuffer.addReturnValue(std::move(returnValueCapture));
1669
1670 return CallCapture(angle::EntryPoint::EGLQuerySupportedCompressionRatesEXT,
1671 std::move(paramBuffer));
1672 }
1673
CaptureDebugMessageControlKHR(egl::Thread * thread,bool isCallValid,EGLDEBUGPROCKHR callback,const AttributeMap & attrib_listPacked,EGLint returnValue)1674 CallCapture CaptureDebugMessageControlKHR(egl::Thread *thread,
1675 bool isCallValid,
1676 EGLDEBUGPROCKHR callback,
1677 const AttributeMap &attrib_listPacked,
1678 EGLint returnValue)
1679 {
1680 ParamBuffer paramBuffer;
1681
1682 paramBuffer.addValueParam("callback", ParamType::TEGLDEBUGPROCKHR, callback);
1683 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
1684
1685 ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
1686 InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
1687 paramBuffer.addReturnValue(std::move(returnValueCapture));
1688
1689 return CallCapture(angle::EntryPoint::EGLDebugMessageControlKHR, std::move(paramBuffer));
1690 }
1691
CaptureLabelObjectKHR(egl::Thread * thread,bool isCallValid,egl::Display * displayPacked,ObjectType objectTypePacked,EGLObjectKHR object,EGLLabelKHR label,EGLint returnValue)1692 CallCapture CaptureLabelObjectKHR(egl::Thread *thread,
1693 bool isCallValid,
1694 egl::Display *displayPacked,
1695 ObjectType objectTypePacked,
1696 EGLObjectKHR object,
1697 EGLLabelKHR label,
1698 EGLint returnValue)
1699 {
1700 ParamBuffer paramBuffer;
1701
1702 paramBuffer.addValueParam("displayPacked", ParamType::Tegl_DisplayPointer, displayPacked);
1703 paramBuffer.addValueParam("objectTypePacked", ParamType::TObjectType, objectTypePacked);
1704 paramBuffer.addValueParam("object", ParamType::TEGLObjectKHR, object);
1705 paramBuffer.addValueParam("label", ParamType::TEGLLabelKHR, label);
1706
1707 ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
1708 InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
1709 paramBuffer.addReturnValue(std::move(returnValueCapture));
1710
1711 return CallCapture(angle::EntryPoint::EGLLabelObjectKHR, std::move(paramBuffer));
1712 }
1713
CaptureQueryDebugKHR(egl::Thread * thread,bool isCallValid,EGLint attribute,EGLAttrib * value,EGLBoolean returnValue)1714 CallCapture CaptureQueryDebugKHR(egl::Thread *thread,
1715 bool isCallValid,
1716 EGLint attribute,
1717 EGLAttrib *value,
1718 EGLBoolean returnValue)
1719 {
1720 ParamBuffer paramBuffer;
1721
1722 paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
1723 paramBuffer.addValueParam("value", ParamType::TEGLAttribPointer, value);
1724
1725 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1726 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1727 paramBuffer.addReturnValue(std::move(returnValueCapture));
1728
1729 return CallCapture(angle::EntryPoint::EGLQueryDebugKHR, std::move(paramBuffer));
1730 }
1731
CaptureClientWaitSyncKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::SyncID syncPacked,EGLint flags,EGLTimeKHR timeout,EGLint returnValue)1732 CallCapture CaptureClientWaitSyncKHR(egl::Thread *thread,
1733 bool isCallValid,
1734 egl::Display *dpyPacked,
1735 egl::SyncID syncPacked,
1736 EGLint flags,
1737 EGLTimeKHR timeout,
1738 EGLint returnValue)
1739 {
1740 ParamBuffer paramBuffer;
1741
1742 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1743 paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
1744 paramBuffer.addValueParam("flags", ParamType::TEGLint, flags);
1745 paramBuffer.addValueParam("timeout", ParamType::TEGLTimeKHR, timeout);
1746
1747 ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
1748 InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
1749 paramBuffer.addReturnValue(std::move(returnValueCapture));
1750
1751 return CallCapture(angle::EntryPoint::EGLClientWaitSyncKHR, std::move(paramBuffer));
1752 }
1753
CaptureCreateSyncKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,EGLenum type,const AttributeMap & attrib_listPacked,EGLSyncKHR returnValue)1754 CallCapture CaptureCreateSyncKHR(egl::Thread *thread,
1755 bool isCallValid,
1756 egl::Display *dpyPacked,
1757 EGLenum type,
1758 const AttributeMap &attrib_listPacked,
1759 EGLSyncKHR returnValue)
1760 {
1761 ParamBuffer paramBuffer;
1762
1763 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1764 paramBuffer.addValueParam("type", ParamType::TEGLenum, type);
1765 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
1766
1767 ParamCapture returnValueCapture("returnValue", ParamType::TEGLSyncKHR);
1768 InitParamValue(ParamType::TEGLSyncKHR, returnValue, &returnValueCapture.value);
1769 paramBuffer.addReturnValue(std::move(returnValueCapture));
1770
1771 return CallCapture(angle::EntryPoint::EGLCreateSyncKHR, std::move(paramBuffer));
1772 }
1773
CaptureDestroySyncKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::SyncID syncPacked,EGLBoolean returnValue)1774 CallCapture CaptureDestroySyncKHR(egl::Thread *thread,
1775 bool isCallValid,
1776 egl::Display *dpyPacked,
1777 egl::SyncID syncPacked,
1778 EGLBoolean returnValue)
1779 {
1780 ParamBuffer paramBuffer;
1781
1782 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1783 paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
1784
1785 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1786 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1787 paramBuffer.addReturnValue(std::move(returnValueCapture));
1788
1789 return CallCapture(angle::EntryPoint::EGLDestroySyncKHR, std::move(paramBuffer));
1790 }
1791
CaptureGetSyncAttribKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::SyncID syncPacked,EGLint attribute,EGLint * value,EGLBoolean returnValue)1792 CallCapture CaptureGetSyncAttribKHR(egl::Thread *thread,
1793 bool isCallValid,
1794 egl::Display *dpyPacked,
1795 egl::SyncID syncPacked,
1796 EGLint attribute,
1797 EGLint *value,
1798 EGLBoolean returnValue)
1799 {
1800 ParamBuffer paramBuffer;
1801
1802 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1803 paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
1804 paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
1805 paramBuffer.addValueParam("value", ParamType::TEGLintPointer, value);
1806
1807 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1808 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1809 paramBuffer.addReturnValue(std::move(returnValueCapture));
1810
1811 return CallCapture(angle::EntryPoint::EGLGetSyncAttribKHR, std::move(paramBuffer));
1812 }
1813
CaptureCreateImageKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,gl::ContextID ctxPacked,EGLenum target,EGLClientBuffer buffer,const AttributeMap & attrib_listPacked,EGLImageKHR returnValue)1814 CallCapture CaptureCreateImageKHR(egl::Thread *thread,
1815 bool isCallValid,
1816 egl::Display *dpyPacked,
1817 gl::ContextID ctxPacked,
1818 EGLenum target,
1819 EGLClientBuffer buffer,
1820 const AttributeMap &attrib_listPacked,
1821 EGLImageKHR returnValue)
1822 {
1823 ParamBuffer paramBuffer;
1824
1825 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1826 paramBuffer.addValueParam("ctxPacked", ParamType::TContextID, ctxPacked);
1827 paramBuffer.addValueParam("target", ParamType::TEGLenum, target);
1828 paramBuffer.addValueParam("buffer", ParamType::TEGLClientBuffer, buffer);
1829 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
1830
1831 ParamCapture returnValueCapture("returnValue", ParamType::TEGLImageKHR);
1832 InitParamValue(ParamType::TEGLImageKHR, returnValue, &returnValueCapture.value);
1833 paramBuffer.addReturnValue(std::move(returnValueCapture));
1834
1835 return CallCapture(angle::EntryPoint::EGLCreateImageKHR, std::move(paramBuffer));
1836 }
1837
CaptureDestroyImageKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,ImageID imagePacked,EGLBoolean returnValue)1838 CallCapture CaptureDestroyImageKHR(egl::Thread *thread,
1839 bool isCallValid,
1840 egl::Display *dpyPacked,
1841 ImageID imagePacked,
1842 EGLBoolean returnValue)
1843 {
1844 ParamBuffer paramBuffer;
1845
1846 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1847 paramBuffer.addValueParam("imagePacked", ParamType::TImageID, imagePacked);
1848
1849 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1850 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1851 paramBuffer.addReturnValue(std::move(returnValueCapture));
1852
1853 return CallCapture(angle::EntryPoint::EGLDestroyImageKHR, std::move(paramBuffer));
1854 }
1855
CaptureLockSurfaceKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,const AttributeMap & attrib_listPacked,EGLBoolean returnValue)1856 CallCapture CaptureLockSurfaceKHR(egl::Thread *thread,
1857 bool isCallValid,
1858 egl::Display *dpyPacked,
1859 SurfaceID surfacePacked,
1860 const AttributeMap &attrib_listPacked,
1861 EGLBoolean returnValue)
1862 {
1863 ParamBuffer paramBuffer;
1864
1865 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1866 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
1867 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
1868
1869 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1870 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1871 paramBuffer.addReturnValue(std::move(returnValueCapture));
1872
1873 return CallCapture(angle::EntryPoint::EGLLockSurfaceKHR, std::move(paramBuffer));
1874 }
1875
CaptureQuerySurface64KHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLint attribute,EGLAttribKHR * value,EGLBoolean returnValue)1876 CallCapture CaptureQuerySurface64KHR(egl::Thread *thread,
1877 bool isCallValid,
1878 egl::Display *dpyPacked,
1879 SurfaceID surfacePacked,
1880 EGLint attribute,
1881 EGLAttribKHR *value,
1882 EGLBoolean returnValue)
1883 {
1884 ParamBuffer paramBuffer;
1885
1886 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1887 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
1888 paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
1889 paramBuffer.addValueParam("value", ParamType::TEGLAttribKHRPointer, value);
1890
1891 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1892 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1893 paramBuffer.addReturnValue(std::move(returnValueCapture));
1894
1895 return CallCapture(angle::EntryPoint::EGLQuerySurface64KHR, std::move(paramBuffer));
1896 }
1897
CaptureUnlockSurfaceKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLBoolean returnValue)1898 CallCapture CaptureUnlockSurfaceKHR(egl::Thread *thread,
1899 bool isCallValid,
1900 egl::Display *dpyPacked,
1901 SurfaceID surfacePacked,
1902 EGLBoolean returnValue)
1903 {
1904 ParamBuffer paramBuffer;
1905
1906 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1907 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
1908
1909 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1910 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1911 paramBuffer.addReturnValue(std::move(returnValueCapture));
1912
1913 return CallCapture(angle::EntryPoint::EGLUnlockSurfaceKHR, std::move(paramBuffer));
1914 }
1915
CaptureSetDamageRegionKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLint * rects,EGLint n_rects,EGLBoolean returnValue)1916 CallCapture CaptureSetDamageRegionKHR(egl::Thread *thread,
1917 bool isCallValid,
1918 egl::Display *dpyPacked,
1919 SurfaceID surfacePacked,
1920 EGLint *rects,
1921 EGLint n_rects,
1922 EGLBoolean returnValue)
1923 {
1924 ParamBuffer paramBuffer;
1925
1926 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1927 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
1928 paramBuffer.addValueParam("rects", ParamType::TEGLintPointer, rects);
1929 paramBuffer.addValueParam("n_rects", ParamType::TEGLint, n_rects);
1930
1931 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1932 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1933 paramBuffer.addReturnValue(std::move(returnValueCapture));
1934
1935 return CallCapture(angle::EntryPoint::EGLSetDamageRegionKHR, std::move(paramBuffer));
1936 }
1937
CaptureSignalSyncKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::SyncID syncPacked,EGLenum mode,EGLBoolean returnValue)1938 CallCapture CaptureSignalSyncKHR(egl::Thread *thread,
1939 bool isCallValid,
1940 egl::Display *dpyPacked,
1941 egl::SyncID syncPacked,
1942 EGLenum mode,
1943 EGLBoolean returnValue)
1944 {
1945 ParamBuffer paramBuffer;
1946
1947 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1948 paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
1949 paramBuffer.addValueParam("mode", ParamType::TEGLenum, mode);
1950
1951 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1952 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1953 paramBuffer.addReturnValue(std::move(returnValueCapture));
1954
1955 return CallCapture(angle::EntryPoint::EGLSignalSyncKHR, std::move(paramBuffer));
1956 }
1957
CaptureCreateStreamKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,const AttributeMap & attrib_listPacked,EGLStreamKHR returnValue)1958 CallCapture CaptureCreateStreamKHR(egl::Thread *thread,
1959 bool isCallValid,
1960 egl::Display *dpyPacked,
1961 const AttributeMap &attrib_listPacked,
1962 EGLStreamKHR returnValue)
1963 {
1964 ParamBuffer paramBuffer;
1965
1966 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1967 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
1968
1969 ParamCapture returnValueCapture("returnValue", ParamType::TEGLStreamKHR);
1970 InitParamValue(ParamType::TEGLStreamKHR, returnValue, &returnValueCapture.value);
1971 paramBuffer.addReturnValue(std::move(returnValueCapture));
1972
1973 return CallCapture(angle::EntryPoint::EGLCreateStreamKHR, std::move(paramBuffer));
1974 }
1975
CaptureDestroyStreamKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Stream * streamPacked,EGLBoolean returnValue)1976 CallCapture CaptureDestroyStreamKHR(egl::Thread *thread,
1977 bool isCallValid,
1978 egl::Display *dpyPacked,
1979 egl::Stream *streamPacked,
1980 EGLBoolean returnValue)
1981 {
1982 ParamBuffer paramBuffer;
1983
1984 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
1985 paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
1986
1987 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
1988 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
1989 paramBuffer.addReturnValue(std::move(returnValueCapture));
1990
1991 return CallCapture(angle::EntryPoint::EGLDestroyStreamKHR, std::move(paramBuffer));
1992 }
1993
CaptureQueryStreamKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Stream * streamPacked,EGLenum attribute,EGLint * value,EGLBoolean returnValue)1994 CallCapture CaptureQueryStreamKHR(egl::Thread *thread,
1995 bool isCallValid,
1996 egl::Display *dpyPacked,
1997 egl::Stream *streamPacked,
1998 EGLenum attribute,
1999 EGLint *value,
2000 EGLBoolean returnValue)
2001 {
2002 ParamBuffer paramBuffer;
2003
2004 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
2005 paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
2006 paramBuffer.addValueParam("attribute", ParamType::TEGLenum, attribute);
2007 paramBuffer.addValueParam("value", ParamType::TEGLintPointer, value);
2008
2009 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
2010 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
2011 paramBuffer.addReturnValue(std::move(returnValueCapture));
2012
2013 return CallCapture(angle::EntryPoint::EGLQueryStreamKHR, std::move(paramBuffer));
2014 }
2015
CaptureQueryStreamu64KHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Stream * streamPacked,EGLenum attribute,EGLuint64KHR * value,EGLBoolean returnValue)2016 CallCapture CaptureQueryStreamu64KHR(egl::Thread *thread,
2017 bool isCallValid,
2018 egl::Display *dpyPacked,
2019 egl::Stream *streamPacked,
2020 EGLenum attribute,
2021 EGLuint64KHR *value,
2022 EGLBoolean returnValue)
2023 {
2024 ParamBuffer paramBuffer;
2025
2026 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
2027 paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
2028 paramBuffer.addValueParam("attribute", ParamType::TEGLenum, attribute);
2029 paramBuffer.addValueParam("value", ParamType::TEGLuint64KHRPointer, value);
2030
2031 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
2032 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
2033 paramBuffer.addReturnValue(std::move(returnValueCapture));
2034
2035 return CallCapture(angle::EntryPoint::EGLQueryStreamu64KHR, std::move(paramBuffer));
2036 }
2037
CaptureStreamAttribKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Stream * streamPacked,EGLenum attribute,EGLint value,EGLBoolean returnValue)2038 CallCapture CaptureStreamAttribKHR(egl::Thread *thread,
2039 bool isCallValid,
2040 egl::Display *dpyPacked,
2041 egl::Stream *streamPacked,
2042 EGLenum attribute,
2043 EGLint value,
2044 EGLBoolean returnValue)
2045 {
2046 ParamBuffer paramBuffer;
2047
2048 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
2049 paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
2050 paramBuffer.addValueParam("attribute", ParamType::TEGLenum, attribute);
2051 paramBuffer.addValueParam("value", ParamType::TEGLint, value);
2052
2053 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
2054 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
2055 paramBuffer.addReturnValue(std::move(returnValueCapture));
2056
2057 return CallCapture(angle::EntryPoint::EGLStreamAttribKHR, std::move(paramBuffer));
2058 }
2059
CaptureStreamConsumerAcquireKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Stream * streamPacked,EGLBoolean returnValue)2060 CallCapture CaptureStreamConsumerAcquireKHR(egl::Thread *thread,
2061 bool isCallValid,
2062 egl::Display *dpyPacked,
2063 egl::Stream *streamPacked,
2064 EGLBoolean returnValue)
2065 {
2066 ParamBuffer paramBuffer;
2067
2068 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
2069 paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
2070
2071 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
2072 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
2073 paramBuffer.addReturnValue(std::move(returnValueCapture));
2074
2075 return CallCapture(angle::EntryPoint::EGLStreamConsumerAcquireKHR, std::move(paramBuffer));
2076 }
2077
CaptureStreamConsumerGLTextureExternalKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Stream * streamPacked,EGLBoolean returnValue)2078 CallCapture CaptureStreamConsumerGLTextureExternalKHR(egl::Thread *thread,
2079 bool isCallValid,
2080 egl::Display *dpyPacked,
2081 egl::Stream *streamPacked,
2082 EGLBoolean returnValue)
2083 {
2084 ParamBuffer paramBuffer;
2085
2086 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
2087 paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
2088
2089 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
2090 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
2091 paramBuffer.addReturnValue(std::move(returnValueCapture));
2092
2093 return CallCapture(angle::EntryPoint::EGLStreamConsumerGLTextureExternalKHR,
2094 std::move(paramBuffer));
2095 }
2096
CaptureStreamConsumerReleaseKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Stream * streamPacked,EGLBoolean returnValue)2097 CallCapture CaptureStreamConsumerReleaseKHR(egl::Thread *thread,
2098 bool isCallValid,
2099 egl::Display *dpyPacked,
2100 egl::Stream *streamPacked,
2101 EGLBoolean returnValue)
2102 {
2103 ParamBuffer paramBuffer;
2104
2105 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
2106 paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
2107
2108 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
2109 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
2110 paramBuffer.addReturnValue(std::move(returnValueCapture));
2111
2112 return CallCapture(angle::EntryPoint::EGLStreamConsumerReleaseKHR, std::move(paramBuffer));
2113 }
2114
CaptureSwapBuffersWithDamageKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,const EGLint * rects,EGLint n_rects,EGLBoolean returnValue)2115 CallCapture CaptureSwapBuffersWithDamageKHR(egl::Thread *thread,
2116 bool isCallValid,
2117 egl::Display *dpyPacked,
2118 SurfaceID surfacePacked,
2119 const EGLint *rects,
2120 EGLint n_rects,
2121 EGLBoolean returnValue)
2122 {
2123 ParamBuffer paramBuffer;
2124
2125 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
2126 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
2127 paramBuffer.addValueParam("rects", ParamType::TEGLintConstPointer, rects);
2128 paramBuffer.addValueParam("n_rects", ParamType::TEGLint, n_rects);
2129
2130 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
2131 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
2132 paramBuffer.addReturnValue(std::move(returnValueCapture));
2133
2134 return CallCapture(angle::EntryPoint::EGLSwapBuffersWithDamageKHR, std::move(paramBuffer));
2135 }
2136
CaptureWaitSyncKHR(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::SyncID syncPacked,EGLint flags,EGLint returnValue)2137 CallCapture CaptureWaitSyncKHR(egl::Thread *thread,
2138 bool isCallValid,
2139 egl::Display *dpyPacked,
2140 egl::SyncID syncPacked,
2141 EGLint flags,
2142 EGLint returnValue)
2143 {
2144 ParamBuffer paramBuffer;
2145
2146 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
2147 paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
2148 paramBuffer.addValueParam("flags", ParamType::TEGLint, flags);
2149
2150 ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
2151 InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
2152 paramBuffer.addReturnValue(std::move(returnValueCapture));
2153
2154 return CallCapture(angle::EntryPoint::EGLWaitSyncKHR, std::move(paramBuffer));
2155 }
2156
CapturePostSubBufferNV(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,SurfaceID surfacePacked,EGLint x,EGLint y,EGLint width,EGLint height,EGLBoolean returnValue)2157 CallCapture CapturePostSubBufferNV(egl::Thread *thread,
2158 bool isCallValid,
2159 egl::Display *dpyPacked,
2160 SurfaceID surfacePacked,
2161 EGLint x,
2162 EGLint y,
2163 EGLint width,
2164 EGLint height,
2165 EGLBoolean returnValue)
2166 {
2167 ParamBuffer paramBuffer;
2168
2169 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
2170 paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
2171 paramBuffer.addValueParam("x", ParamType::TEGLint, x);
2172 paramBuffer.addValueParam("y", ParamType::TEGLint, y);
2173 paramBuffer.addValueParam("width", ParamType::TEGLint, width);
2174 paramBuffer.addValueParam("height", ParamType::TEGLint, height);
2175
2176 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
2177 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
2178 paramBuffer.addReturnValue(std::move(returnValueCapture));
2179
2180 return CallCapture(angle::EntryPoint::EGLPostSubBufferNV, std::move(paramBuffer));
2181 }
2182
CaptureStreamConsumerGLTextureExternalAttribsNV(egl::Thread * thread,bool isCallValid,egl::Display * dpyPacked,egl::Stream * streamPacked,const AttributeMap & attrib_listPacked,EGLBoolean returnValue)2183 CallCapture CaptureStreamConsumerGLTextureExternalAttribsNV(egl::Thread *thread,
2184 bool isCallValid,
2185 egl::Display *dpyPacked,
2186 egl::Stream *streamPacked,
2187 const AttributeMap &attrib_listPacked,
2188 EGLBoolean returnValue)
2189 {
2190 ParamBuffer paramBuffer;
2191
2192 paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
2193 paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
2194 paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
2195
2196 ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
2197 InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
2198 paramBuffer.addReturnValue(std::move(returnValueCapture));
2199
2200 return CallCapture(angle::EntryPoint::EGLStreamConsumerGLTextureExternalAttribsNV,
2201 std::move(paramBuffer));
2202 }
2203
2204 } // namespace egl
2205