kc3-lang/angle/src/libANGLE/capture/capture_egl_autogen.h

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Gregg Tavares
  Date : 2022-12-14 14:13:39
  Hash : be9e8e7b
  Message : Add EGL_ANGLE_wait_until_work_scheduled extension We're changing eglReleaseTexImage so it calls flushCommandBuffer(mtl::NoWait) instead of flushCommandBuffer(mtl::WaitUntilScheduled) and then adding an extension to allow us to WaitUntilScheduled. This is because Chrome calls eglReleaseTexImage for every canvas and having it WaitUntilScheduled per call is very slow. So instead we'll call eglWaitUntilWorkScheduledANGLE once which will effectively wait just once. Bug: angleproject:7890 Change-Id: I87bc9f9a1a7f4a0f99d93736cc3083799e76afeb Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4109311 Reviewed-by: Kenneth Russell <kbr@chromium.org> Commit-Queue: Gregg Tavares <gman@chromium.org>

• src/libANGLE/capture/capture_egl_autogen.h

• // 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::Sync *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::Sync *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::Sync *syncPacked,
                                          EGLint attribute,
                                          EGLAttrib *value,
                                          EGLBoolean returnValue);
  angle::CallCapture CaptureWaitSync(egl::Thread *thread,
                                     bool isCallValid,
                                     egl::Display *dpyPacked,
                                     egl::Sync *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::Sync *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 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::Sync *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::Sync *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::Sync *syncPacked,
                                           EGLBoolean returnValue);
  angle::CallCapture CaptureGetSyncAttribKHR(egl::Thread *thread,
                                             bool isCallValid,
                                             egl::Display *dpyPacked,
                                             egl::Sync *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::Sync *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::Sync *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_