// GENERATED FILE - DO NOT EDIT.
// Generated by generate_entry_points.py using data from egl.xml and egl_angle_ext.xml.
//
// Copyright 2020 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// capture_egl_autogen.h:
//   Capture functions for the OpenGL ES EGL entry points.

#ifndef LIBANGLE_CAPTURE_EGL_AUTOGEN_H_
#define LIBANGLE_CAPTURE_EGL_AUTOGEN_H_

#include "common/PackedEnums.h"
#include "libANGLE/capture/FrameCapture.h"

namespace egl
{

// Method Captures

angle::CallCapture CaptureChooseConfig(egl::Thread *thread,
                                       bool isCallValid,
                                       egl::Display *dpyPacked,
                                       const AttributeMap &attrib_listPacked,
                                       EGLConfig *configs,
                                       EGLint config_size,
                                       EGLint *num_config,
                                       EGLBoolean returnValue);
angle::CallCapture CaptureCopyBuffers(egl::Thread *thread,
                                      bool isCallValid,
                                      egl::Display *dpyPacked,
                                      SurfaceID surfacePacked,
                                      EGLNativePixmapType target,
                                      EGLBoolean returnValue);
angle::CallCapture CaptureCreateContext(egl::Thread *thread,
                                        bool isCallValid,
                                        egl::Display *dpyPacked,
                                        egl::Config *configPacked,
                                        gl::ContextID share_contextPacked,
                                        const AttributeMap &attrib_listPacked,
                                        EGLContext returnValue);
angle::CallCapture CaptureCreatePbufferSurface(egl::Thread *thread,
                                               bool isCallValid,
                                               egl::Display *dpyPacked,
                                               egl::Config *configPacked,
                                               const AttributeMap &attrib_listPacked,
                                               EGLSurface returnValue);
angle::CallCapture CaptureCreatePixmapSurface(egl::Thread *thread,
                                              bool isCallValid,
                                              egl::Display *dpyPacked,
                                              egl::Config *configPacked,
                                              EGLNativePixmapType pixmap,
                                              const AttributeMap &attrib_listPacked,
                                              EGLSurface returnValue);
angle::CallCapture CaptureCreateWindowSurface(egl::Thread *thread,
                                              bool isCallValid,
                                              egl::Display *dpyPacked,
                                              egl::Config *configPacked,
                                              EGLNativeWindowType win,
                                              const AttributeMap &attrib_listPacked,
                                              EGLSurface returnValue);
angle::CallCapture CaptureDestroyContext(egl::Thread *thread,
                                         bool isCallValid,
                                         egl::Display *dpyPacked,
                                         gl::ContextID ctxPacked,
                                         EGLBoolean returnValue);
angle::CallCapture CaptureDestroySurface(egl::Thread *thread,
                                         bool isCallValid,
                                         egl::Display *dpyPacked,
                                         SurfaceID surfacePacked,
                                         EGLBoolean returnValue);
angle::CallCapture CaptureGetConfigAttrib(egl::Thread *thread,
                                          bool isCallValid,
                                          egl::Display *dpyPacked,
                                          egl::Config *configPacked,
                                          EGLint attribute,
                                          EGLint *value,
                                          EGLBoolean returnValue);
angle::CallCapture CaptureGetConfigs(egl::Thread *thread,
                                     bool isCallValid,
                                     egl::Display *dpyPacked,
                                     EGLConfig *configs,
                                     EGLint config_size,
                                     EGLint *num_config,
                                     EGLBoolean returnValue);
angle::CallCapture CaptureGetCurrentDisplay(egl::Thread *thread,
                                            bool isCallValid,
                                            EGLDisplay returnValue);
angle::CallCapture CaptureGetCurrentSurface(egl::Thread *thread,
                                            bool isCallValid,
                                            EGLint readdraw,
                                            EGLSurface returnValue);
angle::CallCapture CaptureGetDisplay(egl::Thread *thread,
                                     bool isCallValid,
                                     EGLNativeDisplayType display_id,
                                     EGLDisplay returnValue);
angle::CallCapture CaptureGetError(egl::Thread *thread, bool isCallValid, EGLint returnValue);
angle::CallCapture CaptureGetProcAddress(egl::Thread *thread,
                                         bool isCallValid,
                                         const char *procname,
                                         __eglMustCastToProperFunctionPointerType returnValue);
angle::CallCapture CaptureInitialize(egl::Thread *thread,
                                     bool isCallValid,
                                     egl::Display *dpyPacked,
                                     EGLint *major,
                                     EGLint *minor,
                                     EGLBoolean returnValue);
angle::CallCapture CaptureMakeCurrent(egl::Thread *thread,
                                      bool isCallValid,
                                      egl::Display *dpyPacked,
                                      SurfaceID drawPacked,
                                      SurfaceID readPacked,
                                      gl::ContextID ctxPacked,
                                      EGLBoolean returnValue);
angle::CallCapture CaptureQueryContext(egl::Thread *thread,
                                       bool isCallValid,
                                       egl::Display *dpyPacked,
                                       gl::ContextID ctxPacked,
                                       EGLint attribute,
                                       EGLint *value,
                                       EGLBoolean returnValue);
angle::CallCapture CaptureQueryString(egl::Thread *thread,
                                      bool isCallValid,
                                      egl::Display *dpyPacked,
                                      EGLint name,
                                      const char *returnValue);
angle::CallCapture CaptureQuerySurface(egl::Thread *thread,
                                       bool isCallValid,
                                       egl::Display *dpyPacked,
                                       SurfaceID surfacePacked,
                                       EGLint attribute,
                                       EGLint *value,
                                       EGLBoolean returnValue);
angle::CallCapture CaptureSwapBuffers(egl::Thread *thread,
                                      bool isCallValid,
                                      egl::Display *dpyPacked,
                                      SurfaceID surfacePacked,
                                      EGLBoolean returnValue);
angle::CallCapture CaptureTerminate(egl::Thread *thread,
                                    bool isCallValid,
                                    egl::Display *dpyPacked,
                                    EGLBoolean returnValue);
angle::CallCapture CaptureWaitGL(egl::Thread *thread, bool isCallValid, EGLBoolean returnValue);
angle::CallCapture CaptureWaitNative(egl::Thread *thread,
                                     bool isCallValid,
                                     EGLint engine,
                                     EGLBoolean returnValue);
angle::CallCapture CaptureBindTexImage(egl::Thread *thread,
                                       bool isCallValid,
                                       egl::Display *dpyPacked,
                                       SurfaceID surfacePacked,
                                       EGLint buffer,
                                       EGLBoolean returnValue);
angle::CallCapture CaptureReleaseTexImage(egl::Thread *thread,
                                          bool isCallValid,
                                          egl::Display *dpyPacked,
                                          SurfaceID surfacePacked,
                                          EGLint buffer,
                                          EGLBoolean returnValue);
angle::CallCapture CaptureSurfaceAttrib(egl::Thread *thread,
                                        bool isCallValid,
                                        egl::Display *dpyPacked,
                                        SurfaceID surfacePacked,
                                        EGLint attribute,
                                        EGLint value,
                                        EGLBoolean returnValue);
angle::CallCapture CaptureSwapInterval(egl::Thread *thread,
                                       bool isCallValid,
                                       egl::Display *dpyPacked,
                                       EGLint interval,
                                       EGLBoolean returnValue);
angle::CallCapture CaptureBindAPI(egl::Thread *thread,
                                  bool isCallValid,
                                  EGLenum api,
                                  EGLBoolean returnValue);
angle::CallCapture CaptureCreatePbufferFromClientBuffer(egl::Thread *thread,
                                                        bool isCallValid,
                                                        egl::Display *dpyPacked,
                                                        EGLenum buftype,
                                                        EGLClientBuffer buffer,
                                                        egl::Config *configPacked,
                                                        const AttributeMap &attrib_listPacked,
                                                        EGLSurface returnValue);
angle::CallCapture CaptureQueryAPI(egl::Thread *thread, bool isCallValid, EGLenum returnValue);
angle::CallCapture CaptureReleaseThread(egl::Thread *thread,
                                        bool isCallValid,
                                        EGLBoolean returnValue);
angle::CallCapture CaptureWaitClient(egl::Thread *thread, bool isCallValid, EGLBoolean returnValue);
angle::CallCapture CaptureGetCurrentContext(egl::Thread *thread,
                                            bool isCallValid,
                                            EGLContext returnValue);
angle::CallCapture CaptureClientWaitSync(egl::Thread *thread,
                                         bool isCallValid,
                                         egl::Display *dpyPacked,
                                         egl::SyncID syncPacked,
                                         EGLint flags,
                                         EGLTime timeout,
                                         EGLint returnValue);
angle::CallCapture CaptureCreateImage(egl::Thread *thread,
                                      bool isCallValid,
                                      egl::Display *dpyPacked,
                                      gl::ContextID ctxPacked,
                                      EGLenum target,
                                      EGLClientBuffer buffer,
                                      const AttributeMap &attrib_listPacked,
                                      EGLImage returnValue);
angle::CallCapture CaptureCreatePlatformPixmapSurface(egl::Thread *thread,
                                                      bool isCallValid,
                                                      egl::Display *dpyPacked,
                                                      egl::Config *configPacked,
                                                      void *native_pixmap,
                                                      const AttributeMap &attrib_listPacked,
                                                      EGLSurface returnValue);
angle::CallCapture CaptureCreatePlatformWindowSurface(egl::Thread *thread,
                                                      bool isCallValid,
                                                      egl::Display *dpyPacked,
                                                      egl::Config *configPacked,
                                                      void *native_window,
                                                      const AttributeMap &attrib_listPacked,
                                                      EGLSurface returnValue);
angle::CallCapture CaptureCreateSync(egl::Thread *thread,
                                     bool isCallValid,
                                     egl::Display *dpyPacked,
                                     EGLenum type,
                                     const AttributeMap &attrib_listPacked,
                                     EGLSync returnValue);
angle::CallCapture CaptureDestroyImage(egl::Thread *thread,
                                       bool isCallValid,
                                       egl::Display *dpyPacked,
                                       ImageID imagePacked,
                                       EGLBoolean returnValue);
angle::CallCapture CaptureDestroySync(egl::Thread *thread,
                                      bool isCallValid,
                                      egl::Display *dpyPacked,
                                      egl::SyncID syncPacked,
                                      EGLBoolean returnValue);
angle::CallCapture CaptureGetPlatformDisplay(egl::Thread *thread,
                                             bool isCallValid,
                                             EGLenum platform,
                                             void *native_display,
                                             const AttributeMap &attrib_listPacked,
                                             EGLDisplay returnValue);
angle::CallCapture CaptureGetSyncAttrib(egl::Thread *thread,
                                        bool isCallValid,
                                        egl::Display *dpyPacked,
                                        egl::SyncID syncPacked,
                                        EGLint attribute,
                                        EGLAttrib *value,
                                        EGLBoolean returnValue);
angle::CallCapture CaptureWaitSync(egl::Thread *thread,
                                   bool isCallValid,
                                   egl::Display *dpyPacked,
                                   egl::SyncID syncPacked,
                                   EGLint flags,
                                   EGLBoolean returnValue);
angle::CallCapture CaptureSetBlobCacheFuncsANDROID(egl::Thread *thread,
                                                   bool isCallValid,
                                                   egl::Display *dpyPacked,
                                                   EGLSetBlobFuncANDROID set,
                                                   EGLGetBlobFuncANDROID get);
angle::CallCapture CaptureCreateNativeClientBufferANDROID(egl::Thread *thread,
                                                          bool isCallValid,
                                                          const AttributeMap &attrib_listPacked,
                                                          EGLClientBuffer returnValue);
angle::CallCapture CaptureGetCompositorTimingSupportedANDROID(egl::Thread *thread,
                                                              bool isCallValid,
                                                              egl::Display *dpyPacked,
                                                              SurfaceID surfacePacked,
                                                              CompositorTiming namePacked,
                                                              EGLBoolean returnValue);
angle::CallCapture CaptureGetCompositorTimingANDROID(egl::Thread *thread,
                                                     bool isCallValid,
                                                     egl::Display *dpyPacked,
                                                     SurfaceID surfacePacked,
                                                     EGLint numTimestamps,
                                                     const EGLint *names,
                                                     EGLnsecsANDROID *values,
                                                     EGLBoolean returnValue);
angle::CallCapture CaptureGetNextFrameIdANDROID(egl::Thread *thread,
                                                bool isCallValid,
                                                egl::Display *dpyPacked,
                                                SurfaceID surfacePacked,
                                                EGLuint64KHR *frameId,
                                                EGLBoolean returnValue);
angle::CallCapture CaptureGetFrameTimestampSupportedANDROID(egl::Thread *thread,
                                                            bool isCallValid,
                                                            egl::Display *dpyPacked,
                                                            SurfaceID surfacePacked,
                                                            Timestamp timestampPacked,
                                                            EGLBoolean returnValue);
angle::CallCapture CaptureGetFrameTimestampsANDROID(egl::Thread *thread,
                                                    bool isCallValid,
                                                    egl::Display *dpyPacked,
                                                    SurfaceID surfacePacked,
                                                    EGLuint64KHR frameId,
                                                    EGLint numTimestamps,
                                                    const EGLint *timestamps,
                                                    EGLnsecsANDROID *values,
                                                    EGLBoolean returnValue);
angle::CallCapture CaptureGetNativeClientBufferANDROID(egl::Thread *thread,
                                                       bool isCallValid,
                                                       const struct AHardwareBuffer *buffer,
                                                       EGLClientBuffer returnValue);
angle::CallCapture CaptureDupNativeFenceFDANDROID(egl::Thread *thread,
                                                  bool isCallValid,
                                                  egl::Display *dpyPacked,
                                                  egl::SyncID syncPacked,
                                                  EGLint returnValue);
angle::CallCapture CapturePresentationTimeANDROID(egl::Thread *thread,
                                                  bool isCallValid,
                                                  egl::Display *dpyPacked,
                                                  SurfaceID surfacePacked,
                                                  EGLnsecsANDROID time,
                                                  EGLBoolean returnValue);
angle::CallCapture CaptureCreateDeviceANGLE(egl::Thread *thread,
                                            bool isCallValid,
                                            EGLint device_type,
                                            void *native_device,
                                            const EGLAttrib *attrib_list,
                                            EGLDeviceEXT returnValue);
angle::CallCapture CaptureReleaseDeviceANGLE(egl::Thread *thread,
                                             bool isCallValid,
                                             egl::Device *devicePacked,
                                             EGLBoolean returnValue);
angle::CallCapture CaptureAcquireExternalContextANGLE(egl::Thread *thread,
                                                      bool isCallValid,
                                                      egl::Display *dpyPacked,
                                                      SurfaceID drawAndReadPacked);
angle::CallCapture CaptureReleaseExternalContextANGLE(egl::Thread *thread,
                                                      bool isCallValid,
                                                      egl::Display *dpyPacked);
angle::CallCapture CaptureQueryStringiANGLE(egl::Thread *thread,
                                            bool isCallValid,
                                            egl::Display *dpyPacked,
                                            EGLint name,
                                            EGLint index,
                                            const char *returnValue);
angle::CallCapture CaptureQueryDisplayAttribANGLE(egl::Thread *thread,
                                                  bool isCallValid,
                                                  egl::Display *dpyPacked,
                                                  EGLint attribute,
                                                  EGLAttrib *value,
                                                  EGLBoolean returnValue);
angle::CallCapture CaptureCopyMetalSharedEventANGLE(egl::Thread *thread,
                                                    bool isCallValid,
                                                    egl::Display *dpyPacked,
                                                    egl::SyncID syncPacked,
                                                    void *returnValue);
angle::CallCapture CaptureReleaseHighPowerGPUANGLE(egl::Thread *thread,
                                                   bool isCallValid,
                                                   egl::Display *dpyPacked,
                                                   gl::ContextID ctxPacked);
angle::CallCapture CaptureReacquireHighPowerGPUANGLE(egl::Thread *thread,
                                                     bool isCallValid,
                                                     egl::Display *dpyPacked,
                                                     gl::ContextID ctxPacked);
angle::CallCapture CaptureHandleGPUSwitchANGLE(egl::Thread *thread,
                                               bool isCallValid,
                                               egl::Display *dpyPacked);
angle::CallCapture CaptureForceGPUSwitchANGLE(egl::Thread *thread,
                                              bool isCallValid,
                                              egl::Display *dpyPacked,
                                              EGLint gpuIDHigh,
                                              EGLint gpuIDLow);
angle::CallCapture CapturePrepareSwapBuffersANGLE(egl::Thread *thread,
                                                  bool isCallValid,
                                                  egl::Display *dpyPacked,
                                                  SurfaceID surfacePacked,
                                                  EGLBoolean returnValue);
angle::CallCapture CaptureProgramCacheGetAttribANGLE(egl::Thread *thread,
                                                     bool isCallValid,
                                                     egl::Display *dpyPacked,
                                                     EGLenum attrib,
                                                     EGLint returnValue);
angle::CallCapture CaptureProgramCacheQueryANGLE(egl::Thread *thread,
                                                 bool isCallValid,
                                                 egl::Display *dpyPacked,
                                                 EGLint index,
                                                 void *key,
                                                 EGLint *keysize,
                                                 void *binary,
                                                 EGLint *binarysize);
angle::CallCapture CaptureProgramCachePopulateANGLE(egl::Thread *thread,
                                                    bool isCallValid,
                                                    egl::Display *dpyPacked,
                                                    const void *key,
                                                    EGLint keysize,
                                                    const void *binary,
                                                    EGLint binarysize);
angle::CallCapture CaptureProgramCacheResizeANGLE(egl::Thread *thread,
                                                  bool isCallValid,
                                                  egl::Display *dpyPacked,
                                                  EGLint limit,
                                                  EGLint mode,
                                                  EGLint returnValue);
angle::CallCapture CaptureQuerySurfacePointerANGLE(egl::Thread *thread,
                                                   bool isCallValid,
                                                   egl::Display *dpyPacked,
                                                   SurfaceID surfacePacked,
                                                   EGLint attribute,
                                                   void **value,
                                                   EGLBoolean returnValue);
angle::CallCapture CaptureCreateStreamProducerD3DTextureANGLE(egl::Thread *thread,
                                                              bool isCallValid,
                                                              egl::Display *dpyPacked,
                                                              egl::Stream *streamPacked,
                                                              const AttributeMap &attrib_listPacked,
                                                              EGLBoolean returnValue);
angle::CallCapture CaptureStreamPostD3DTextureANGLE(egl::Thread *thread,
                                                    bool isCallValid,
                                                    egl::Display *dpyPacked,
                                                    egl::Stream *streamPacked,
                                                    void *texture,
                                                    const AttributeMap &attrib_listPacked,
                                                    EGLBoolean returnValue);
angle::CallCapture CaptureSwapBuffersWithFrameTokenANGLE(egl::Thread *thread,
                                                         bool isCallValid,
                                                         egl::Display *dpyPacked,
                                                         SurfaceID surfacePacked,
                                                         EGLFrameTokenANGLE frametoken,
                                                         EGLBoolean returnValue);
angle::CallCapture CaptureGetMscRateANGLE(egl::Thread *thread,
                                          bool isCallValid,
                                          egl::Display *dpyPacked,
                                          SurfaceID surfacePacked,
                                          EGLint *numerator,
                                          EGLint *denominator,
                                          EGLBoolean returnValue);
angle::CallCapture CaptureExportVkImageANGLE(egl::Thread *thread,
                                             bool isCallValid,
                                             egl::Display *dpyPacked,
                                             ImageID imagePacked,
                                             void *vk_image,
                                             void *vk_image_create_info,
                                             EGLBoolean returnValue);
angle::CallCapture CaptureWaitUntilWorkScheduledANGLE(egl::Thread *thread,
                                                      bool isCallValid,
                                                      egl::Display *dpyPacked);
angle::CallCapture CaptureGetSyncValuesCHROMIUM(egl::Thread *thread,
                                                bool isCallValid,
                                                egl::Display *dpyPacked,
                                                SurfaceID surfacePacked,
                                                EGLuint64KHR *ust,
                                                EGLuint64KHR *msc,
                                                EGLuint64KHR *sbc,
                                                EGLBoolean returnValue);
angle::CallCapture CaptureQueryDeviceAttribEXT(egl::Thread *thread,
                                               bool isCallValid,
                                               egl::Device *devicePacked,
                                               EGLint attribute,
                                               EGLAttrib *value,
                                               EGLBoolean returnValue);
angle::CallCapture CaptureQueryDeviceStringEXT(egl::Thread *thread,
                                               bool isCallValid,
                                               egl::Device *devicePacked,
                                               EGLint name,
                                               const char *returnValue);
angle::CallCapture CaptureQueryDisplayAttribEXT(egl::Thread *thread,
                                                bool isCallValid,
                                                egl::Display *dpyPacked,
                                                EGLint attribute,
                                                EGLAttrib *value,
                                                EGLBoolean returnValue);
angle::CallCapture CaptureQueryDmaBufFormatsEXT(egl::Thread *thread,
                                                bool isCallValid,
                                                egl::Display *dpyPacked,
                                                EGLint max_formats,
                                                EGLint *formats,
                                                EGLint *num_formats,
                                                EGLBoolean returnValue);
angle::CallCapture CaptureQueryDmaBufModifiersEXT(egl::Thread *thread,
                                                  bool isCallValid,
                                                  egl::Display *dpyPacked,
                                                  EGLint format,
                                                  EGLint max_modifiers,
                                                  EGLuint64KHR *modifiers,
                                                  EGLBoolean *external_only,
                                                  EGLint *num_modifiers,
                                                  EGLBoolean returnValue);
angle::CallCapture CaptureCreatePlatformPixmapSurfaceEXT(egl::Thread *thread,
                                                         bool isCallValid,
                                                         egl::Display *dpyPacked,
                                                         egl::Config *configPacked,
                                                         void *native_pixmap,
                                                         const AttributeMap &attrib_listPacked,
                                                         EGLSurface returnValue);
angle::CallCapture CaptureCreatePlatformWindowSurfaceEXT(egl::Thread *thread,
                                                         bool isCallValid,
                                                         egl::Display *dpyPacked,
                                                         egl::Config *configPacked,
                                                         void *native_window,
                                                         const AttributeMap &attrib_listPacked,
                                                         EGLSurface returnValue);
angle::CallCapture CaptureGetPlatformDisplayEXT(egl::Thread *thread,
                                                bool isCallValid,
                                                EGLenum platform,
                                                void *native_display,
                                                const AttributeMap &attrib_listPacked,
                                                EGLDisplay returnValue);
angle::CallCapture CaptureDebugMessageControlKHR(egl::Thread *thread,
                                                 bool isCallValid,
                                                 EGLDEBUGPROCKHR callback,
                                                 const AttributeMap &attrib_listPacked,
                                                 EGLint returnValue);
angle::CallCapture CaptureLabelObjectKHR(egl::Thread *thread,
                                         bool isCallValid,
                                         egl::Display *displayPacked,
                                         ObjectType objectTypePacked,
                                         EGLObjectKHR object,
                                         EGLLabelKHR label,
                                         EGLint returnValue);
angle::CallCapture CaptureQueryDebugKHR(egl::Thread *thread,
                                        bool isCallValid,
                                        EGLint attribute,
                                        EGLAttrib *value,
                                        EGLBoolean returnValue);
angle::CallCapture CaptureClientWaitSyncKHR(egl::Thread *thread,
                                            bool isCallValid,
                                            egl::Display *dpyPacked,
                                            egl::SyncID syncPacked,
                                            EGLint flags,
                                            EGLTimeKHR timeout,
                                            EGLint returnValue);
angle::CallCapture CaptureCreateSyncKHR(egl::Thread *thread,
                                        bool isCallValid,
                                        egl::Display *dpyPacked,
                                        EGLenum type,
                                        const AttributeMap &attrib_listPacked,
                                        EGLSyncKHR returnValue);
angle::CallCapture CaptureDestroySyncKHR(egl::Thread *thread,
                                         bool isCallValid,
                                         egl::Display *dpyPacked,
                                         egl::SyncID syncPacked,
                                         EGLBoolean returnValue);
angle::CallCapture CaptureGetSyncAttribKHR(egl::Thread *thread,
                                           bool isCallValid,
                                           egl::Display *dpyPacked,
                                           egl::SyncID syncPacked,
                                           EGLint attribute,
                                           EGLint *value,
                                           EGLBoolean returnValue);
angle::CallCapture CaptureCreateImageKHR(egl::Thread *thread,
                                         bool isCallValid,
                                         egl::Display *dpyPacked,
                                         gl::ContextID ctxPacked,
                                         EGLenum target,
                                         EGLClientBuffer buffer,
                                         const AttributeMap &attrib_listPacked,
                                         EGLImageKHR returnValue);
angle::CallCapture CaptureDestroyImageKHR(egl::Thread *thread,
                                          bool isCallValid,
                                          egl::Display *dpyPacked,
                                          ImageID imagePacked,
                                          EGLBoolean returnValue);
angle::CallCapture CaptureLockSurfaceKHR(egl::Thread *thread,
                                         bool isCallValid,
                                         egl::Display *dpyPacked,
                                         SurfaceID surfacePacked,
                                         const AttributeMap &attrib_listPacked,
                                         EGLBoolean returnValue);
angle::CallCapture CaptureQuerySurface64KHR(egl::Thread *thread,
                                            bool isCallValid,
                                            egl::Display *dpyPacked,
                                            SurfaceID surfacePacked,
                                            EGLint attribute,
                                            EGLAttribKHR *value,
                                            EGLBoolean returnValue);
angle::CallCapture CaptureUnlockSurfaceKHR(egl::Thread *thread,
                                           bool isCallValid,
                                           egl::Display *dpyPacked,
                                           SurfaceID surfacePacked,
                                           EGLBoolean returnValue);
angle::CallCapture CaptureSetDamageRegionKHR(egl::Thread *thread,
                                             bool isCallValid,
                                             egl::Display *dpyPacked,
                                             SurfaceID surfacePacked,
                                             EGLint *rects,
                                             EGLint n_rects,
                                             EGLBoolean returnValue);
angle::CallCapture CaptureSignalSyncKHR(egl::Thread *thread,
                                        bool isCallValid,
                                        egl::Display *dpyPacked,
                                        egl::SyncID syncPacked,
                                        EGLenum mode,
                                        EGLBoolean returnValue);
angle::CallCapture CaptureCreateStreamKHR(egl::Thread *thread,
                                          bool isCallValid,
                                          egl::Display *dpyPacked,
                                          const AttributeMap &attrib_listPacked,
                                          EGLStreamKHR returnValue);
angle::CallCapture CaptureDestroyStreamKHR(egl::Thread *thread,
                                           bool isCallValid,
                                           egl::Display *dpyPacked,
                                           egl::Stream *streamPacked,
                                           EGLBoolean returnValue);
angle::CallCapture CaptureQueryStreamKHR(egl::Thread *thread,
                                         bool isCallValid,
                                         egl::Display *dpyPacked,
                                         egl::Stream *streamPacked,
                                         EGLenum attribute,
                                         EGLint *value,
                                         EGLBoolean returnValue);
angle::CallCapture CaptureQueryStreamu64KHR(egl::Thread *thread,
                                            bool isCallValid,
                                            egl::Display *dpyPacked,
                                            egl::Stream *streamPacked,
                                            EGLenum attribute,
                                            EGLuint64KHR *value,
                                            EGLBoolean returnValue);
angle::CallCapture CaptureStreamAttribKHR(egl::Thread *thread,
                                          bool isCallValid,
                                          egl::Display *dpyPacked,
                                          egl::Stream *streamPacked,
                                          EGLenum attribute,
                                          EGLint value,
                                          EGLBoolean returnValue);
angle::CallCapture CaptureStreamConsumerAcquireKHR(egl::Thread *thread,
                                                   bool isCallValid,
                                                   egl::Display *dpyPacked,
                                                   egl::Stream *streamPacked,
                                                   EGLBoolean returnValue);
angle::CallCapture CaptureStreamConsumerGLTextureExternalKHR(egl::Thread *thread,
                                                             bool isCallValid,
                                                             egl::Display *dpyPacked,
                                                             egl::Stream *streamPacked,
                                                             EGLBoolean returnValue);
angle::CallCapture CaptureStreamConsumerReleaseKHR(egl::Thread *thread,
                                                   bool isCallValid,
                                                   egl::Display *dpyPacked,
                                                   egl::Stream *streamPacked,
                                                   EGLBoolean returnValue);
angle::CallCapture CaptureSwapBuffersWithDamageKHR(egl::Thread *thread,
                                                   bool isCallValid,
                                                   egl::Display *dpyPacked,
                                                   SurfaceID surfacePacked,
                                                   const EGLint *rects,
                                                   EGLint n_rects,
                                                   EGLBoolean returnValue);
angle::CallCapture CaptureWaitSyncKHR(egl::Thread *thread,
                                      bool isCallValid,
                                      egl::Display *dpyPacked,
                                      egl::SyncID syncPacked,
                                      EGLint flags,
                                      EGLint returnValue);
angle::CallCapture CapturePostSubBufferNV(egl::Thread *thread,
                                          bool isCallValid,
                                          egl::Display *dpyPacked,
                                          SurfaceID surfacePacked,
                                          EGLint x,
                                          EGLint y,
                                          EGLint width,
                                          EGLint height,
                                          EGLBoolean returnValue);
angle::CallCapture CaptureStreamConsumerGLTextureExternalAttribsNV(
    egl::Thread *thread,
    bool isCallValid,
    egl::Display *dpyPacked,
    egl::Stream *streamPacked,
    const AttributeMap &attrib_listPacked,
    EGLBoolean returnValue);
}  // namespace egl

#endif  // LIBANGLE_CAPTURE_EGL_AUTOGEN_H_
