• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 CaptureReleaseHighPowerGPUANGLE(egl::Thread *thread,
351                                                    bool isCallValid,
352                                                    egl::Display *dpyPacked,
353                                                    gl::ContextID ctxPacked);
354 angle::CallCapture CaptureReacquireHighPowerGPUANGLE(egl::Thread *thread,
355                                                      bool isCallValid,
356                                                      egl::Display *dpyPacked,
357                                                      gl::ContextID ctxPacked);
358 angle::CallCapture CaptureHandleGPUSwitchANGLE(egl::Thread *thread,
359                                                bool isCallValid,
360                                                egl::Display *dpyPacked);
361 angle::CallCapture CaptureForceGPUSwitchANGLE(egl::Thread *thread,
362                                               bool isCallValid,
363                                               egl::Display *dpyPacked,
364                                               EGLint gpuIDHigh,
365                                               EGLint gpuIDLow);
366 angle::CallCapture CapturePrepareSwapBuffersANGLE(egl::Thread *thread,
367                                                   bool isCallValid,
368                                                   egl::Display *dpyPacked,
369                                                   SurfaceID surfacePacked,
370                                                   EGLBoolean returnValue);
371 angle::CallCapture CaptureProgramCacheGetAttribANGLE(egl::Thread *thread,
372                                                      bool isCallValid,
373                                                      egl::Display *dpyPacked,
374                                                      EGLenum attrib,
375                                                      EGLint returnValue);
376 angle::CallCapture CaptureProgramCacheQueryANGLE(egl::Thread *thread,
377                                                  bool isCallValid,
378                                                  egl::Display *dpyPacked,
379                                                  EGLint index,
380                                                  void *key,
381                                                  EGLint *keysize,
382                                                  void *binary,
383                                                  EGLint *binarysize);
384 angle::CallCapture CaptureProgramCachePopulateANGLE(egl::Thread *thread,
385                                                     bool isCallValid,
386                                                     egl::Display *dpyPacked,
387                                                     const void *key,
388                                                     EGLint keysize,
389                                                     const void *binary,
390                                                     EGLint binarysize);
391 angle::CallCapture CaptureProgramCacheResizeANGLE(egl::Thread *thread,
392                                                   bool isCallValid,
393                                                   egl::Display *dpyPacked,
394                                                   EGLint limit,
395                                                   EGLint mode,
396                                                   EGLint returnValue);
397 angle::CallCapture CaptureQuerySurfacePointerANGLE(egl::Thread *thread,
398                                                    bool isCallValid,
399                                                    egl::Display *dpyPacked,
400                                                    SurfaceID surfacePacked,
401                                                    EGLint attribute,
402                                                    void **value,
403                                                    EGLBoolean returnValue);
404 angle::CallCapture CaptureCreateStreamProducerD3DTextureANGLE(egl::Thread *thread,
405                                                               bool isCallValid,
406                                                               egl::Display *dpyPacked,
407                                                               egl::Stream *streamPacked,
408                                                               const AttributeMap &attrib_listPacked,
409                                                               EGLBoolean returnValue);
410 angle::CallCapture CaptureStreamPostD3DTextureANGLE(egl::Thread *thread,
411                                                     bool isCallValid,
412                                                     egl::Display *dpyPacked,
413                                                     egl::Stream *streamPacked,
414                                                     void *texture,
415                                                     const AttributeMap &attrib_listPacked,
416                                                     EGLBoolean returnValue);
417 angle::CallCapture CaptureSwapBuffersWithFrameTokenANGLE(egl::Thread *thread,
418                                                          bool isCallValid,
419                                                          egl::Display *dpyPacked,
420                                                          SurfaceID surfacePacked,
421                                                          EGLFrameTokenANGLE frametoken,
422                                                          EGLBoolean returnValue);
423 angle::CallCapture CaptureGetMscRateANGLE(egl::Thread *thread,
424                                           bool isCallValid,
425                                           egl::Display *dpyPacked,
426                                           SurfaceID surfacePacked,
427                                           EGLint *numerator,
428                                           EGLint *denominator,
429                                           EGLBoolean returnValue);
430 angle::CallCapture CaptureExportVkImageANGLE(egl::Thread *thread,
431                                              bool isCallValid,
432                                              egl::Display *dpyPacked,
433                                              ImageID imagePacked,
434                                              void *vk_image,
435                                              void *vk_image_create_info,
436                                              EGLBoolean returnValue);
437 angle::CallCapture CaptureWaitUntilWorkScheduledANGLE(egl::Thread *thread,
438                                                       bool isCallValid,
439                                                       egl::Display *dpyPacked);
440 angle::CallCapture CaptureGetSyncValuesCHROMIUM(egl::Thread *thread,
441                                                 bool isCallValid,
442                                                 egl::Display *dpyPacked,
443                                                 SurfaceID surfacePacked,
444                                                 EGLuint64KHR *ust,
445                                                 EGLuint64KHR *msc,
446                                                 EGLuint64KHR *sbc,
447                                                 EGLBoolean returnValue);
448 angle::CallCapture CaptureQueryDeviceAttribEXT(egl::Thread *thread,
449                                                bool isCallValid,
450                                                egl::Device *devicePacked,
451                                                EGLint attribute,
452                                                EGLAttrib *value,
453                                                EGLBoolean returnValue);
454 angle::CallCapture CaptureQueryDeviceStringEXT(egl::Thread *thread,
455                                                bool isCallValid,
456                                                egl::Device *devicePacked,
457                                                EGLint name,
458                                                const char *returnValue);
459 angle::CallCapture CaptureQueryDisplayAttribEXT(egl::Thread *thread,
460                                                 bool isCallValid,
461                                                 egl::Display *dpyPacked,
462                                                 EGLint attribute,
463                                                 EGLAttrib *value,
464                                                 EGLBoolean returnValue);
465 angle::CallCapture CaptureQueryDmaBufFormatsEXT(egl::Thread *thread,
466                                                 bool isCallValid,
467                                                 egl::Display *dpyPacked,
468                                                 EGLint max_formats,
469                                                 EGLint *formats,
470                                                 EGLint *num_formats,
471                                                 EGLBoolean returnValue);
472 angle::CallCapture CaptureQueryDmaBufModifiersEXT(egl::Thread *thread,
473                                                   bool isCallValid,
474                                                   egl::Display *dpyPacked,
475                                                   EGLint format,
476                                                   EGLint max_modifiers,
477                                                   EGLuint64KHR *modifiers,
478                                                   EGLBoolean *external_only,
479                                                   EGLint *num_modifiers,
480                                                   EGLBoolean returnValue);
481 angle::CallCapture CaptureCreatePlatformPixmapSurfaceEXT(egl::Thread *thread,
482                                                          bool isCallValid,
483                                                          egl::Display *dpyPacked,
484                                                          egl::Config *configPacked,
485                                                          void *native_pixmap,
486                                                          const AttributeMap &attrib_listPacked,
487                                                          EGLSurface returnValue);
488 angle::CallCapture CaptureCreatePlatformWindowSurfaceEXT(egl::Thread *thread,
489                                                          bool isCallValid,
490                                                          egl::Display *dpyPacked,
491                                                          egl::Config *configPacked,
492                                                          void *native_window,
493                                                          const AttributeMap &attrib_listPacked,
494                                                          EGLSurface returnValue);
495 angle::CallCapture CaptureGetPlatformDisplayEXT(egl::Thread *thread,
496                                                 bool isCallValid,
497                                                 EGLenum platform,
498                                                 void *native_display,
499                                                 const AttributeMap &attrib_listPacked,
500                                                 EGLDisplay returnValue);
501 angle::CallCapture CaptureDebugMessageControlKHR(egl::Thread *thread,
502                                                  bool isCallValid,
503                                                  EGLDEBUGPROCKHR callback,
504                                                  const AttributeMap &attrib_listPacked,
505                                                  EGLint returnValue);
506 angle::CallCapture CaptureLabelObjectKHR(egl::Thread *thread,
507                                          bool isCallValid,
508                                          egl::Display *displayPacked,
509                                          ObjectType objectTypePacked,
510                                          EGLObjectKHR object,
511                                          EGLLabelKHR label,
512                                          EGLint returnValue);
513 angle::CallCapture CaptureQueryDebugKHR(egl::Thread *thread,
514                                         bool isCallValid,
515                                         EGLint attribute,
516                                         EGLAttrib *value,
517                                         EGLBoolean returnValue);
518 angle::CallCapture CaptureClientWaitSyncKHR(egl::Thread *thread,
519                                             bool isCallValid,
520                                             egl::Display *dpyPacked,
521                                             egl::SyncID syncPacked,
522                                             EGLint flags,
523                                             EGLTimeKHR timeout,
524                                             EGLint returnValue);
525 angle::CallCapture CaptureCreateSyncKHR(egl::Thread *thread,
526                                         bool isCallValid,
527                                         egl::Display *dpyPacked,
528                                         EGLenum type,
529                                         const AttributeMap &attrib_listPacked,
530                                         EGLSyncKHR returnValue);
531 angle::CallCapture CaptureDestroySyncKHR(egl::Thread *thread,
532                                          bool isCallValid,
533                                          egl::Display *dpyPacked,
534                                          egl::SyncID syncPacked,
535                                          EGLBoolean returnValue);
536 angle::CallCapture CaptureGetSyncAttribKHR(egl::Thread *thread,
537                                            bool isCallValid,
538                                            egl::Display *dpyPacked,
539                                            egl::SyncID syncPacked,
540                                            EGLint attribute,
541                                            EGLint *value,
542                                            EGLBoolean returnValue);
543 angle::CallCapture CaptureCreateImageKHR(egl::Thread *thread,
544                                          bool isCallValid,
545                                          egl::Display *dpyPacked,
546                                          gl::ContextID ctxPacked,
547                                          EGLenum target,
548                                          EGLClientBuffer buffer,
549                                          const AttributeMap &attrib_listPacked,
550                                          EGLImageKHR returnValue);
551 angle::CallCapture CaptureDestroyImageKHR(egl::Thread *thread,
552                                           bool isCallValid,
553                                           egl::Display *dpyPacked,
554                                           ImageID imagePacked,
555                                           EGLBoolean returnValue);
556 angle::CallCapture CaptureLockSurfaceKHR(egl::Thread *thread,
557                                          bool isCallValid,
558                                          egl::Display *dpyPacked,
559                                          SurfaceID surfacePacked,
560                                          const AttributeMap &attrib_listPacked,
561                                          EGLBoolean returnValue);
562 angle::CallCapture CaptureQuerySurface64KHR(egl::Thread *thread,
563                                             bool isCallValid,
564                                             egl::Display *dpyPacked,
565                                             SurfaceID surfacePacked,
566                                             EGLint attribute,
567                                             EGLAttribKHR *value,
568                                             EGLBoolean returnValue);
569 angle::CallCapture CaptureUnlockSurfaceKHR(egl::Thread *thread,
570                                            bool isCallValid,
571                                            egl::Display *dpyPacked,
572                                            SurfaceID surfacePacked,
573                                            EGLBoolean returnValue);
574 angle::CallCapture CaptureSetDamageRegionKHR(egl::Thread *thread,
575                                              bool isCallValid,
576                                              egl::Display *dpyPacked,
577                                              SurfaceID surfacePacked,
578                                              EGLint *rects,
579                                              EGLint n_rects,
580                                              EGLBoolean returnValue);
581 angle::CallCapture CaptureSignalSyncKHR(egl::Thread *thread,
582                                         bool isCallValid,
583                                         egl::Display *dpyPacked,
584                                         egl::SyncID syncPacked,
585                                         EGLenum mode,
586                                         EGLBoolean returnValue);
587 angle::CallCapture CaptureCreateStreamKHR(egl::Thread *thread,
588                                           bool isCallValid,
589                                           egl::Display *dpyPacked,
590                                           const AttributeMap &attrib_listPacked,
591                                           EGLStreamKHR returnValue);
592 angle::CallCapture CaptureDestroyStreamKHR(egl::Thread *thread,
593                                            bool isCallValid,
594                                            egl::Display *dpyPacked,
595                                            egl::Stream *streamPacked,
596                                            EGLBoolean returnValue);
597 angle::CallCapture CaptureQueryStreamKHR(egl::Thread *thread,
598                                          bool isCallValid,
599                                          egl::Display *dpyPacked,
600                                          egl::Stream *streamPacked,
601                                          EGLenum attribute,
602                                          EGLint *value,
603                                          EGLBoolean returnValue);
604 angle::CallCapture CaptureQueryStreamu64KHR(egl::Thread *thread,
605                                             bool isCallValid,
606                                             egl::Display *dpyPacked,
607                                             egl::Stream *streamPacked,
608                                             EGLenum attribute,
609                                             EGLuint64KHR *value,
610                                             EGLBoolean returnValue);
611 angle::CallCapture CaptureStreamAttribKHR(egl::Thread *thread,
612                                           bool isCallValid,
613                                           egl::Display *dpyPacked,
614                                           egl::Stream *streamPacked,
615                                           EGLenum attribute,
616                                           EGLint value,
617                                           EGLBoolean returnValue);
618 angle::CallCapture CaptureStreamConsumerAcquireKHR(egl::Thread *thread,
619                                                    bool isCallValid,
620                                                    egl::Display *dpyPacked,
621                                                    egl::Stream *streamPacked,
622                                                    EGLBoolean returnValue);
623 angle::CallCapture CaptureStreamConsumerGLTextureExternalKHR(egl::Thread *thread,
624                                                              bool isCallValid,
625                                                              egl::Display *dpyPacked,
626                                                              egl::Stream *streamPacked,
627                                                              EGLBoolean returnValue);
628 angle::CallCapture CaptureStreamConsumerReleaseKHR(egl::Thread *thread,
629                                                    bool isCallValid,
630                                                    egl::Display *dpyPacked,
631                                                    egl::Stream *streamPacked,
632                                                    EGLBoolean returnValue);
633 angle::CallCapture CaptureSwapBuffersWithDamageKHR(egl::Thread *thread,
634                                                    bool isCallValid,
635                                                    egl::Display *dpyPacked,
636                                                    SurfaceID surfacePacked,
637                                                    const EGLint *rects,
638                                                    EGLint n_rects,
639                                                    EGLBoolean returnValue);
640 angle::CallCapture CaptureWaitSyncKHR(egl::Thread *thread,
641                                       bool isCallValid,
642                                       egl::Display *dpyPacked,
643                                       egl::SyncID syncPacked,
644                                       EGLint flags,
645                                       EGLint returnValue);
646 angle::CallCapture CapturePostSubBufferNV(egl::Thread *thread,
647                                           bool isCallValid,
648                                           egl::Display *dpyPacked,
649                                           SurfaceID surfacePacked,
650                                           EGLint x,
651                                           EGLint y,
652                                           EGLint width,
653                                           EGLint height,
654                                           EGLBoolean returnValue);
655 angle::CallCapture CaptureStreamConsumerGLTextureExternalAttribsNV(
656     egl::Thread *thread,
657     bool isCallValid,
658     egl::Display *dpyPacked,
659     egl::Stream *streamPacked,
660     const AttributeMap &attrib_listPacked,
661     EGLBoolean returnValue);
662 }  // namespace egl
663 
664 #endif  // LIBANGLE_CAPTURE_EGL_AUTOGEN_H_
665