xref: /aosp_15_r20/external/angle/src/libANGLE/capture/capture_egl_autogen.h (revision 8975f5c5ed3d1c378011245431ada316dfb6f244)
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.h:
9 //   Capture functions for the OpenGL ES EGL entry points.
10 
11 #ifndef LIBANGLE_CAPTURE_EGL_AUTOGEN_H_
12 #define LIBANGLE_CAPTURE_EGL_AUTOGEN_H_
13 
14 #include "common/PackedEnums.h"
15 #include "libANGLE/capture/FrameCapture.h"
16 
17 namespace egl
18 {
19 
20 // Method Captures
21 
22 angle::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 angle::CallCapture CaptureCopyBuffers(egl::Thread *thread,
31                                       bool isCallValid,
32                                       egl::Display *dpyPacked,
33                                       SurfaceID surfacePacked,
34                                       EGLNativePixmapType target,
35                                       EGLBoolean returnValue);
36 angle::CallCapture CaptureCreateContext(egl::Thread *thread,
37                                         bool isCallValid,
38                                         egl::Display *dpyPacked,
39                                         egl::Config *configPacked,
40                                         gl::ContextID share_contextPacked,
41                                         const AttributeMap &attrib_listPacked,
42                                         EGLContext returnValue);
43 angle::CallCapture CaptureCreatePbufferSurface(egl::Thread *thread,
44                                                bool isCallValid,
45                                                egl::Display *dpyPacked,
46                                                egl::Config *configPacked,
47                                                const AttributeMap &attrib_listPacked,
48                                                EGLSurface returnValue);
49 angle::CallCapture CaptureCreatePixmapSurface(egl::Thread *thread,
50                                               bool isCallValid,
51                                               egl::Display *dpyPacked,
52                                               egl::Config *configPacked,
53                                               EGLNativePixmapType pixmap,
54                                               const AttributeMap &attrib_listPacked,
55                                               EGLSurface returnValue);
56 angle::CallCapture CaptureCreateWindowSurface(egl::Thread *thread,
57                                               bool isCallValid,
58                                               egl::Display *dpyPacked,
59                                               egl::Config *configPacked,
60                                               EGLNativeWindowType win,
61                                               const AttributeMap &attrib_listPacked,
62                                               EGLSurface returnValue);
63 angle::CallCapture CaptureDestroyContext(egl::Thread *thread,
64                                          bool isCallValid,
65                                          egl::Display *dpyPacked,
66                                          gl::ContextID ctxPacked,
67                                          EGLBoolean returnValue);
68 angle::CallCapture CaptureDestroySurface(egl::Thread *thread,
69                                          bool isCallValid,
70                                          egl::Display *dpyPacked,
71                                          SurfaceID surfacePacked,
72                                          EGLBoolean returnValue);
73 angle::CallCapture CaptureGetConfigAttrib(egl::Thread *thread,
74                                           bool isCallValid,
75                                           egl::Display *dpyPacked,
76                                           egl::Config *configPacked,
77                                           EGLint attribute,
78                                           EGLint *value,
79                                           EGLBoolean returnValue);
80 angle::CallCapture CaptureGetConfigs(egl::Thread *thread,
81                                      bool isCallValid,
82                                      egl::Display *dpyPacked,
83                                      EGLConfig *configs,
84                                      EGLint config_size,
85                                      EGLint *num_config,
86                                      EGLBoolean returnValue);
87 angle::CallCapture CaptureGetCurrentDisplay(egl::Thread *thread,
88                                             bool isCallValid,
89                                             EGLDisplay returnValue);
90 angle::CallCapture CaptureGetCurrentSurface(egl::Thread *thread,
91                                             bool isCallValid,
92                                             EGLint readdraw,
93                                             EGLSurface returnValue);
94 angle::CallCapture CaptureGetDisplay(egl::Thread *thread,
95                                      bool isCallValid,
96                                      EGLNativeDisplayType display_id,
97                                      EGLDisplay returnValue);
98 angle::CallCapture CaptureGetError(egl::Thread *thread, bool isCallValid, EGLint returnValue);
99 angle::CallCapture CaptureGetProcAddress(egl::Thread *thread,
100                                          bool isCallValid,
101                                          const char *procname,
102                                          __eglMustCastToProperFunctionPointerType returnValue);
103 angle::CallCapture CaptureInitialize(egl::Thread *thread,
104                                      bool isCallValid,
105                                      egl::Display *dpyPacked,
106                                      EGLint *major,
107                                      EGLint *minor,
108                                      EGLBoolean returnValue);
109 angle::CallCapture CaptureMakeCurrent(egl::Thread *thread,
110                                       bool isCallValid,
111                                       egl::Display *dpyPacked,
112                                       SurfaceID drawPacked,
113                                       SurfaceID readPacked,
114                                       gl::ContextID ctxPacked,
115                                       EGLBoolean returnValue);
116 angle::CallCapture CaptureQueryContext(egl::Thread *thread,
117                                        bool isCallValid,
118                                        egl::Display *dpyPacked,
119                                        gl::ContextID ctxPacked,
120                                        EGLint attribute,
121                                        EGLint *value,
122                                        EGLBoolean returnValue);
123 angle::CallCapture CaptureQueryString(egl::Thread *thread,
124                                       bool isCallValid,
125                                       egl::Display *dpyPacked,
126                                       EGLint name,
127                                       const char *returnValue);
128 angle::CallCapture CaptureQuerySurface(egl::Thread *thread,
129                                        bool isCallValid,
130                                        egl::Display *dpyPacked,
131                                        SurfaceID surfacePacked,
132                                        EGLint attribute,
133                                        EGLint *value,
134                                        EGLBoolean returnValue);
135 angle::CallCapture CaptureSwapBuffers(egl::Thread *thread,
136                                       bool isCallValid,
137                                       egl::Display *dpyPacked,
138                                       SurfaceID surfacePacked,
139                                       EGLBoolean returnValue);
140 angle::CallCapture CaptureTerminate(egl::Thread *thread,
141                                     bool isCallValid,
142                                     egl::Display *dpyPacked,
143                                     EGLBoolean returnValue);
144 angle::CallCapture CaptureWaitGL(egl::Thread *thread, bool isCallValid, EGLBoolean returnValue);
145 angle::CallCapture CaptureWaitNative(egl::Thread *thread,
146                                      bool isCallValid,
147                                      EGLint engine,
148                                      EGLBoolean returnValue);
149 angle::CallCapture CaptureBindTexImage(egl::Thread *thread,
150                                        bool isCallValid,
151                                        egl::Display *dpyPacked,
152                                        SurfaceID surfacePacked,
153                                        EGLint buffer,
154                                        EGLBoolean returnValue);
155 angle::CallCapture CaptureReleaseTexImage(egl::Thread *thread,
156                                           bool isCallValid,
157                                           egl::Display *dpyPacked,
158                                           SurfaceID surfacePacked,
159                                           EGLint buffer,
160                                           EGLBoolean returnValue);
161 angle::CallCapture CaptureSurfaceAttrib(egl::Thread *thread,
162                                         bool isCallValid,
163                                         egl::Display *dpyPacked,
164                                         SurfaceID surfacePacked,
165                                         EGLint attribute,
166                                         EGLint value,
167                                         EGLBoolean returnValue);
168 angle::CallCapture CaptureSwapInterval(egl::Thread *thread,
169                                        bool isCallValid,
170                                        egl::Display *dpyPacked,
171                                        EGLint interval,
172                                        EGLBoolean returnValue);
173 angle::CallCapture CaptureBindAPI(egl::Thread *thread,
174                                   bool isCallValid,
175                                   EGLenum api,
176                                   EGLBoolean returnValue);
177 angle::CallCapture CaptureCreatePbufferFromClientBuffer(egl::Thread *thread,
178                                                         bool isCallValid,
179                                                         egl::Display *dpyPacked,
180                                                         EGLenum buftype,
181                                                         EGLClientBuffer buffer,
182                                                         egl::Config *configPacked,
183                                                         const AttributeMap &attrib_listPacked,
184                                                         EGLSurface returnValue);
185 angle::CallCapture CaptureQueryAPI(egl::Thread *thread, bool isCallValid, EGLenum returnValue);
186 angle::CallCapture CaptureReleaseThread(egl::Thread *thread,
187                                         bool isCallValid,
188                                         EGLBoolean returnValue);
189 angle::CallCapture CaptureWaitClient(egl::Thread *thread, bool isCallValid, EGLBoolean returnValue);
190 angle::CallCapture CaptureGetCurrentContext(egl::Thread *thread,
191                                             bool isCallValid,
192                                             EGLContext returnValue);
193 angle::CallCapture CaptureClientWaitSync(egl::Thread *thread,
194                                          bool isCallValid,
195                                          egl::Display *dpyPacked,
196                                          egl::SyncID syncPacked,
197                                          EGLint flags,
198                                          EGLTime timeout,
199                                          EGLint returnValue);
200 angle::CallCapture CaptureCreateImage(egl::Thread *thread,
201                                       bool isCallValid,
202                                       egl::Display *dpyPacked,
203                                       gl::ContextID ctxPacked,
204                                       EGLenum target,
205                                       EGLClientBuffer buffer,
206                                       const AttributeMap &attrib_listPacked,
207                                       EGLImage returnValue);
208 angle::CallCapture CaptureCreatePlatformPixmapSurface(egl::Thread *thread,
209                                                       bool isCallValid,
210                                                       egl::Display *dpyPacked,
211                                                       egl::Config *configPacked,
212                                                       void *native_pixmap,
213                                                       const AttributeMap &attrib_listPacked,
214                                                       EGLSurface returnValue);
215 angle::CallCapture CaptureCreatePlatformWindowSurface(egl::Thread *thread,
216                                                       bool isCallValid,
217                                                       egl::Display *dpyPacked,
218                                                       egl::Config *configPacked,
219                                                       void *native_window,
220                                                       const AttributeMap &attrib_listPacked,
221                                                       EGLSurface returnValue);
222 angle::CallCapture CaptureCreateSync(egl::Thread *thread,
223                                      bool isCallValid,
224                                      egl::Display *dpyPacked,
225                                      EGLenum type,
226                                      const AttributeMap &attrib_listPacked,
227                                      EGLSync returnValue);
228 angle::CallCapture CaptureDestroyImage(egl::Thread *thread,
229                                        bool isCallValid,
230                                        egl::Display *dpyPacked,
231                                        ImageID imagePacked,
232                                        EGLBoolean returnValue);
233 angle::CallCapture CaptureDestroySync(egl::Thread *thread,
234                                       bool isCallValid,
235                                       egl::Display *dpyPacked,
236                                       egl::SyncID syncPacked,
237                                       EGLBoolean returnValue);
238 angle::CallCapture CaptureGetPlatformDisplay(egl::Thread *thread,
239                                              bool isCallValid,
240                                              EGLenum platform,
241                                              void *native_display,
242                                              const AttributeMap &attrib_listPacked,
243                                              EGLDisplay returnValue);
244 angle::CallCapture CaptureGetSyncAttrib(egl::Thread *thread,
245                                         bool isCallValid,
246                                         egl::Display *dpyPacked,
247                                         egl::SyncID syncPacked,
248                                         EGLint attribute,
249                                         EGLAttrib *value,
250                                         EGLBoolean returnValue);
251 angle::CallCapture CaptureWaitSync(egl::Thread *thread,
252                                    bool isCallValid,
253                                    egl::Display *dpyPacked,
254                                    egl::SyncID syncPacked,
255                                    EGLint flags,
256                                    EGLBoolean returnValue);
257 angle::CallCapture CaptureSetBlobCacheFuncsANDROID(egl::Thread *thread,
258                                                    bool isCallValid,
259                                                    egl::Display *dpyPacked,
260                                                    EGLSetBlobFuncANDROID set,
261                                                    EGLGetBlobFuncANDROID get);
262 angle::CallCapture CaptureCreateNativeClientBufferANDROID(egl::Thread *thread,
263                                                           bool isCallValid,
264                                                           const AttributeMap &attrib_listPacked,
265                                                           EGLClientBuffer returnValue);
266 angle::CallCapture CaptureGetCompositorTimingSupportedANDROID(egl::Thread *thread,
267                                                               bool isCallValid,
268                                                               egl::Display *dpyPacked,
269                                                               SurfaceID surfacePacked,
270                                                               CompositorTiming namePacked,
271                                                               EGLBoolean returnValue);
272 angle::CallCapture CaptureGetCompositorTimingANDROID(egl::Thread *thread,
273                                                      bool isCallValid,
274                                                      egl::Display *dpyPacked,
275                                                      SurfaceID surfacePacked,
276                                                      EGLint numTimestamps,
277                                                      const EGLint *names,
278                                                      EGLnsecsANDROID *values,
279                                                      EGLBoolean returnValue);
280 angle::CallCapture CaptureGetNextFrameIdANDROID(egl::Thread *thread,
281                                                 bool isCallValid,
282                                                 egl::Display *dpyPacked,
283                                                 SurfaceID surfacePacked,
284                                                 EGLuint64KHR *frameId,
285                                                 EGLBoolean returnValue);
286 angle::CallCapture CaptureGetFrameTimestampSupportedANDROID(egl::Thread *thread,
287                                                             bool isCallValid,
288                                                             egl::Display *dpyPacked,
289                                                             SurfaceID surfacePacked,
290                                                             Timestamp timestampPacked,
291                                                             EGLBoolean returnValue);
292 angle::CallCapture CaptureGetFrameTimestampsANDROID(egl::Thread *thread,
293                                                     bool isCallValid,
294                                                     egl::Display *dpyPacked,
295                                                     SurfaceID surfacePacked,
296                                                     EGLuint64KHR frameId,
297                                                     EGLint numTimestamps,
298                                                     const EGLint *timestamps,
299                                                     EGLnsecsANDROID *values,
300                                                     EGLBoolean returnValue);
301 angle::CallCapture CaptureGetNativeClientBufferANDROID(egl::Thread *thread,
302                                                        bool isCallValid,
303                                                        const struct AHardwareBuffer *buffer,
304                                                        EGLClientBuffer returnValue);
305 angle::CallCapture CaptureDupNativeFenceFDANDROID(egl::Thread *thread,
306                                                   bool isCallValid,
307                                                   egl::Display *dpyPacked,
308                                                   egl::SyncID syncPacked,
309                                                   EGLint returnValue);
310 angle::CallCapture CapturePresentationTimeANDROID(egl::Thread *thread,
311                                                   bool isCallValid,
312                                                   egl::Display *dpyPacked,
313                                                   SurfaceID surfacePacked,
314                                                   EGLnsecsANDROID time,
315                                                   EGLBoolean returnValue);
316 angle::CallCapture CaptureCreateDeviceANGLE(egl::Thread *thread,
317                                             bool isCallValid,
318                                             EGLint device_type,
319                                             void *native_device,
320                                             const EGLAttrib *attrib_list,
321                                             EGLDeviceEXT returnValue);
322 angle::CallCapture CaptureReleaseDeviceANGLE(egl::Thread *thread,
323                                              bool isCallValid,
324                                              egl::Device *devicePacked,
325                                              EGLBoolean returnValue);
326 angle::CallCapture CaptureAcquireExternalContextANGLE(egl::Thread *thread,
327                                                       bool isCallValid,
328                                                       egl::Display *dpyPacked,
329                                                       SurfaceID drawAndReadPacked);
330 angle::CallCapture CaptureReleaseExternalContextANGLE(egl::Thread *thread,
331                                                       bool isCallValid,
332                                                       egl::Display *dpyPacked);
333 angle::CallCapture CaptureQueryStringiANGLE(egl::Thread *thread,
334                                             bool isCallValid,
335                                             egl::Display *dpyPacked,
336                                             EGLint name,
337                                             EGLint index,
338                                             const char *returnValue);
339 angle::CallCapture CaptureQueryDisplayAttribANGLE(egl::Thread *thread,
340                                                   bool isCallValid,
341                                                   egl::Display *dpyPacked,
342                                                   EGLint attribute,
343                                                   EGLAttrib *value,
344                                                   EGLBoolean returnValue);
345 angle::CallCapture CaptureCopyMetalSharedEventANGLE(egl::Thread *thread,
346                                                     bool isCallValid,
347                                                     egl::Display *dpyPacked,
348                                                     egl::SyncID syncPacked,
349                                                     void *returnValue);
350 angle::CallCapture CaptureSetValidationEnabledANGLE(egl::Thread *thread,
351                                                     bool isCallValid,
352                                                     EGLBoolean validationState);
353 angle::CallCapture CaptureReleaseHighPowerGPUANGLE(egl::Thread *thread,
354                                                    bool isCallValid,
355                                                    egl::Display *dpyPacked,
356                                                    gl::ContextID ctxPacked);
357 angle::CallCapture CaptureReacquireHighPowerGPUANGLE(egl::Thread *thread,
358                                                      bool isCallValid,
359                                                      egl::Display *dpyPacked,
360                                                      gl::ContextID ctxPacked);
361 angle::CallCapture CaptureHandleGPUSwitchANGLE(egl::Thread *thread,
362                                                bool isCallValid,
363                                                egl::Display *dpyPacked);
364 angle::CallCapture CaptureForceGPUSwitchANGLE(egl::Thread *thread,
365                                               bool isCallValid,
366                                               egl::Display *dpyPacked,
367                                               EGLint gpuIDHigh,
368                                               EGLint gpuIDLow);
369 angle::CallCapture CapturePrepareSwapBuffersANGLE(egl::Thread *thread,
370                                                   bool isCallValid,
371                                                   egl::Display *dpyPacked,
372                                                   SurfaceID surfacePacked,
373                                                   EGLBoolean returnValue);
374 angle::CallCapture CaptureProgramCacheGetAttribANGLE(egl::Thread *thread,
375                                                      bool isCallValid,
376                                                      egl::Display *dpyPacked,
377                                                      EGLenum attrib,
378                                                      EGLint returnValue);
379 angle::CallCapture CaptureProgramCacheQueryANGLE(egl::Thread *thread,
380                                                  bool isCallValid,
381                                                  egl::Display *dpyPacked,
382                                                  EGLint index,
383                                                  void *key,
384                                                  EGLint *keysize,
385                                                  void *binary,
386                                                  EGLint *binarysize);
387 angle::CallCapture CaptureProgramCachePopulateANGLE(egl::Thread *thread,
388                                                     bool isCallValid,
389                                                     egl::Display *dpyPacked,
390                                                     const void *key,
391                                                     EGLint keysize,
392                                                     const void *binary,
393                                                     EGLint binarysize);
394 angle::CallCapture CaptureProgramCacheResizeANGLE(egl::Thread *thread,
395                                                   bool isCallValid,
396                                                   egl::Display *dpyPacked,
397                                                   EGLint limit,
398                                                   EGLint mode,
399                                                   EGLint returnValue);
400 angle::CallCapture CaptureQuerySurfacePointerANGLE(egl::Thread *thread,
401                                                    bool isCallValid,
402                                                    egl::Display *dpyPacked,
403                                                    SurfaceID surfacePacked,
404                                                    EGLint attribute,
405                                                    void **value,
406                                                    EGLBoolean returnValue);
407 angle::CallCapture CaptureCreateStreamProducerD3DTextureANGLE(egl::Thread *thread,
408                                                               bool isCallValid,
409                                                               egl::Display *dpyPacked,
410                                                               egl::Stream *streamPacked,
411                                                               const AttributeMap &attrib_listPacked,
412                                                               EGLBoolean returnValue);
413 angle::CallCapture CaptureStreamPostD3DTextureANGLE(egl::Thread *thread,
414                                                     bool isCallValid,
415                                                     egl::Display *dpyPacked,
416                                                     egl::Stream *streamPacked,
417                                                     void *texture,
418                                                     const AttributeMap &attrib_listPacked,
419                                                     EGLBoolean returnValue);
420 angle::CallCapture CaptureSwapBuffersWithFrameTokenANGLE(egl::Thread *thread,
421                                                          bool isCallValid,
422                                                          egl::Display *dpyPacked,
423                                                          SurfaceID surfacePacked,
424                                                          EGLFrameTokenANGLE frametoken,
425                                                          EGLBoolean returnValue);
426 angle::CallCapture CaptureGetMscRateANGLE(egl::Thread *thread,
427                                           bool isCallValid,
428                                           egl::Display *dpyPacked,
429                                           SurfaceID surfacePacked,
430                                           EGLint *numerator,
431                                           EGLint *denominator,
432                                           EGLBoolean returnValue);
433 angle::CallCapture CaptureExportVkImageANGLE(egl::Thread *thread,
434                                              bool isCallValid,
435                                              egl::Display *dpyPacked,
436                                              ImageID imagePacked,
437                                              void *vk_image,
438                                              void *vk_image_create_info,
439                                              EGLBoolean returnValue);
440 angle::CallCapture CaptureWaitUntilWorkScheduledANGLE(egl::Thread *thread,
441                                                       bool isCallValid,
442                                                       egl::Display *dpyPacked);
443 angle::CallCapture CaptureGetSyncValuesCHROMIUM(egl::Thread *thread,
444                                                 bool isCallValid,
445                                                 egl::Display *dpyPacked,
446                                                 SurfaceID surfacePacked,
447                                                 EGLuint64KHR *ust,
448                                                 EGLuint64KHR *msc,
449                                                 EGLuint64KHR *sbc,
450                                                 EGLBoolean returnValue);
451 angle::CallCapture CaptureQueryDeviceAttribEXT(egl::Thread *thread,
452                                                bool isCallValid,
453                                                egl::Device *devicePacked,
454                                                EGLint attribute,
455                                                EGLAttrib *value,
456                                                EGLBoolean returnValue);
457 angle::CallCapture CaptureQueryDeviceStringEXT(egl::Thread *thread,
458                                                bool isCallValid,
459                                                egl::Device *devicePacked,
460                                                EGLint name,
461                                                const char *returnValue);
462 angle::CallCapture CaptureQueryDisplayAttribEXT(egl::Thread *thread,
463                                                 bool isCallValid,
464                                                 egl::Display *dpyPacked,
465                                                 EGLint attribute,
466                                                 EGLAttrib *value,
467                                                 EGLBoolean returnValue);
468 angle::CallCapture CaptureQueryDmaBufFormatsEXT(egl::Thread *thread,
469                                                 bool isCallValid,
470                                                 egl::Display *dpyPacked,
471                                                 EGLint max_formats,
472                                                 EGLint *formats,
473                                                 EGLint *num_formats,
474                                                 EGLBoolean returnValue);
475 angle::CallCapture CaptureQueryDmaBufModifiersEXT(egl::Thread *thread,
476                                                   bool isCallValid,
477                                                   egl::Display *dpyPacked,
478                                                   EGLint format,
479                                                   EGLint max_modifiers,
480                                                   EGLuint64KHR *modifiers,
481                                                   EGLBoolean *external_only,
482                                                   EGLint *num_modifiers,
483                                                   EGLBoolean returnValue);
484 angle::CallCapture CaptureCreatePlatformPixmapSurfaceEXT(egl::Thread *thread,
485                                                          bool isCallValid,
486                                                          egl::Display *dpyPacked,
487                                                          egl::Config *configPacked,
488                                                          void *native_pixmap,
489                                                          const AttributeMap &attrib_listPacked,
490                                                          EGLSurface returnValue);
491 angle::CallCapture CaptureCreatePlatformWindowSurfaceEXT(egl::Thread *thread,
492                                                          bool isCallValid,
493                                                          egl::Display *dpyPacked,
494                                                          egl::Config *configPacked,
495                                                          void *native_window,
496                                                          const AttributeMap &attrib_listPacked,
497                                                          EGLSurface returnValue);
498 angle::CallCapture CaptureGetPlatformDisplayEXT(egl::Thread *thread,
499                                                 bool isCallValid,
500                                                 EGLenum platform,
501                                                 void *native_display,
502                                                 const AttributeMap &attrib_listPacked,
503                                                 EGLDisplay returnValue);
504 angle::CallCapture CaptureDebugMessageControlKHR(egl::Thread *thread,
505                                                  bool isCallValid,
506                                                  EGLDEBUGPROCKHR callback,
507                                                  const AttributeMap &attrib_listPacked,
508                                                  EGLint returnValue);
509 angle::CallCapture CaptureLabelObjectKHR(egl::Thread *thread,
510                                          bool isCallValid,
511                                          egl::Display *displayPacked,
512                                          ObjectType objectTypePacked,
513                                          EGLObjectKHR object,
514                                          EGLLabelKHR label,
515                                          EGLint returnValue);
516 angle::CallCapture CaptureQueryDebugKHR(egl::Thread *thread,
517                                         bool isCallValid,
518                                         EGLint attribute,
519                                         EGLAttrib *value,
520                                         EGLBoolean returnValue);
521 angle::CallCapture CaptureClientWaitSyncKHR(egl::Thread *thread,
522                                             bool isCallValid,
523                                             egl::Display *dpyPacked,
524                                             egl::SyncID syncPacked,
525                                             EGLint flags,
526                                             EGLTimeKHR timeout,
527                                             EGLint returnValue);
528 angle::CallCapture CaptureCreateSyncKHR(egl::Thread *thread,
529                                         bool isCallValid,
530                                         egl::Display *dpyPacked,
531                                         EGLenum type,
532                                         const AttributeMap &attrib_listPacked,
533                                         EGLSyncKHR returnValue);
534 angle::CallCapture CaptureDestroySyncKHR(egl::Thread *thread,
535                                          bool isCallValid,
536                                          egl::Display *dpyPacked,
537                                          egl::SyncID syncPacked,
538                                          EGLBoolean returnValue);
539 angle::CallCapture CaptureGetSyncAttribKHR(egl::Thread *thread,
540                                            bool isCallValid,
541                                            egl::Display *dpyPacked,
542                                            egl::SyncID syncPacked,
543                                            EGLint attribute,
544                                            EGLint *value,
545                                            EGLBoolean returnValue);
546 angle::CallCapture CaptureCreateImageKHR(egl::Thread *thread,
547                                          bool isCallValid,
548                                          egl::Display *dpyPacked,
549                                          gl::ContextID ctxPacked,
550                                          EGLenum target,
551                                          EGLClientBuffer buffer,
552                                          const AttributeMap &attrib_listPacked,
553                                          EGLImageKHR returnValue);
554 angle::CallCapture CaptureDestroyImageKHR(egl::Thread *thread,
555                                           bool isCallValid,
556                                           egl::Display *dpyPacked,
557                                           ImageID imagePacked,
558                                           EGLBoolean returnValue);
559 angle::CallCapture CaptureLockSurfaceKHR(egl::Thread *thread,
560                                          bool isCallValid,
561                                          egl::Display *dpyPacked,
562                                          SurfaceID surfacePacked,
563                                          const AttributeMap &attrib_listPacked,
564                                          EGLBoolean returnValue);
565 angle::CallCapture CaptureQuerySurface64KHR(egl::Thread *thread,
566                                             bool isCallValid,
567                                             egl::Display *dpyPacked,
568                                             SurfaceID surfacePacked,
569                                             EGLint attribute,
570                                             EGLAttribKHR *value,
571                                             EGLBoolean returnValue);
572 angle::CallCapture CaptureUnlockSurfaceKHR(egl::Thread *thread,
573                                            bool isCallValid,
574                                            egl::Display *dpyPacked,
575                                            SurfaceID surfacePacked,
576                                            EGLBoolean returnValue);
577 angle::CallCapture CaptureSetDamageRegionKHR(egl::Thread *thread,
578                                              bool isCallValid,
579                                              egl::Display *dpyPacked,
580                                              SurfaceID surfacePacked,
581                                              EGLint *rects,
582                                              EGLint n_rects,
583                                              EGLBoolean returnValue);
584 angle::CallCapture CaptureSignalSyncKHR(egl::Thread *thread,
585                                         bool isCallValid,
586                                         egl::Display *dpyPacked,
587                                         egl::SyncID syncPacked,
588                                         EGLenum mode,
589                                         EGLBoolean returnValue);
590 angle::CallCapture CaptureCreateStreamKHR(egl::Thread *thread,
591                                           bool isCallValid,
592                                           egl::Display *dpyPacked,
593                                           const AttributeMap &attrib_listPacked,
594                                           EGLStreamKHR returnValue);
595 angle::CallCapture CaptureDestroyStreamKHR(egl::Thread *thread,
596                                            bool isCallValid,
597                                            egl::Display *dpyPacked,
598                                            egl::Stream *streamPacked,
599                                            EGLBoolean returnValue);
600 angle::CallCapture CaptureQueryStreamKHR(egl::Thread *thread,
601                                          bool isCallValid,
602                                          egl::Display *dpyPacked,
603                                          egl::Stream *streamPacked,
604                                          EGLenum attribute,
605                                          EGLint *value,
606                                          EGLBoolean returnValue);
607 angle::CallCapture CaptureQueryStreamu64KHR(egl::Thread *thread,
608                                             bool isCallValid,
609                                             egl::Display *dpyPacked,
610                                             egl::Stream *streamPacked,
611                                             EGLenum attribute,
612                                             EGLuint64KHR *value,
613                                             EGLBoolean returnValue);
614 angle::CallCapture CaptureStreamAttribKHR(egl::Thread *thread,
615                                           bool isCallValid,
616                                           egl::Display *dpyPacked,
617                                           egl::Stream *streamPacked,
618                                           EGLenum attribute,
619                                           EGLint value,
620                                           EGLBoolean returnValue);
621 angle::CallCapture CaptureStreamConsumerAcquireKHR(egl::Thread *thread,
622                                                    bool isCallValid,
623                                                    egl::Display *dpyPacked,
624                                                    egl::Stream *streamPacked,
625                                                    EGLBoolean returnValue);
626 angle::CallCapture CaptureStreamConsumerGLTextureExternalKHR(egl::Thread *thread,
627                                                              bool isCallValid,
628                                                              egl::Display *dpyPacked,
629                                                              egl::Stream *streamPacked,
630                                                              EGLBoolean returnValue);
631 angle::CallCapture CaptureStreamConsumerReleaseKHR(egl::Thread *thread,
632                                                    bool isCallValid,
633                                                    egl::Display *dpyPacked,
634                                                    egl::Stream *streamPacked,
635                                                    EGLBoolean returnValue);
636 angle::CallCapture CaptureSwapBuffersWithDamageKHR(egl::Thread *thread,
637                                                    bool isCallValid,
638                                                    egl::Display *dpyPacked,
639                                                    SurfaceID surfacePacked,
640                                                    const EGLint *rects,
641                                                    EGLint n_rects,
642                                                    EGLBoolean returnValue);
643 angle::CallCapture CaptureWaitSyncKHR(egl::Thread *thread,
644                                       bool isCallValid,
645                                       egl::Display *dpyPacked,
646                                       egl::SyncID syncPacked,
647                                       EGLint flags,
648                                       EGLint returnValue);
649 angle::CallCapture CapturePostSubBufferNV(egl::Thread *thread,
650                                           bool isCallValid,
651                                           egl::Display *dpyPacked,
652                                           SurfaceID surfacePacked,
653                                           EGLint x,
654                                           EGLint y,
655                                           EGLint width,
656                                           EGLint height,
657                                           EGLBoolean returnValue);
658 angle::CallCapture CaptureStreamConsumerGLTextureExternalAttribsNV(
659     egl::Thread *thread,
660     bool isCallValid,
661     egl::Display *dpyPacked,
662     egl::Stream *streamPacked,
663     const AttributeMap &attrib_listPacked,
664     EGLBoolean returnValue);
665 }  // namespace egl
666 
667 #endif  // LIBANGLE_CAPTURE_EGL_AUTOGEN_H_
668