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

Branch - branch -main

• Show log

  Commit

• Hash : 5b343e8f
  Author :
  Date : 2025-03-11T11:35:08
  

  Vulkan: Remove support for Stadia
  
  Bug: angleproject:42262714
  Change-Id: Icae5fe828fe4e0bcd287d297df1bc586708ef86e
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6344390
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Yuly Novikov <ynovikov@chromium.org>
  

Download

• src/libANGLE/capture/capture_egl_autogen.cpp

• // 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.cpp:
  //   Capture functions for the OpenGL ES all entry points.
  
  #include "libANGLE/capture/capture_egl_autogen.h"
  
  #include "common/gl_enum_utils.h"
  #include "libANGLE/Context.h"
  #include "libANGLE/capture/FrameCapture.h"
  #include "libANGLE/validationEGL.h"
  
  using namespace angle;
  
  namespace egl
  {
  CallCapture CaptureChooseConfig(egl::Thread *thread,
                                  bool isCallValid,
                                  egl::Display *dpyPacked,
                                  const AttributeMap &attrib_listPacked,
                                  EGLConfig *configs,
                                  EGLint config_size,
                                  EGLint *num_config,
                                  EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
      paramBuffer.addValueParam("configs", ParamType::TEGLConfigPointer, configs);
      paramBuffer.addValueParam("config_size", ParamType::TEGLint, config_size);
      paramBuffer.addValueParam("num_config", ParamType::TEGLintPointer, num_config);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLChooseConfig, std::move(paramBuffer));
  }
  
  CallCapture CaptureCopyBuffers(egl::Thread *thread,
                                 bool isCallValid,
                                 egl::Display *dpyPacked,
                                 SurfaceID surfacePacked,
                                 EGLNativePixmapType target,
                                 EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
      paramBuffer.addValueParam("target", ParamType::TEGLNativePixmapType, target);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLCopyBuffers, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreateContext(egl::Thread *thread,
                                   bool isCallValid,
                                   egl::Display *dpyPacked,
                                   egl::Config *configPacked,
                                   gl::ContextID share_contextPacked,
                                   const AttributeMap &attrib_listPacked,
                                   EGLContext returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
      paramBuffer.addValueParam("share_contextPacked", ParamType::TContextID, share_contextPacked);
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLContext);
      InitParamValue(ParamType::TEGLContext, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLCreateContext, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreatePbufferSurface(egl::Thread *thread,
                                          bool isCallValid,
                                          egl::Display *dpyPacked,
                                          egl::Config *configPacked,
                                          const AttributeMap &attrib_listPacked,
                                          EGLSurface returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface);
      InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLCreatePbufferSurface, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreatePixmapSurface(egl::Thread *thread,
                                         bool isCallValid,
                                         egl::Display *dpyPacked,
                                         egl::Config *configPacked,
                                         EGLNativePixmapType pixmap,
                                         const AttributeMap &attrib_listPacked,
                                         EGLSurface returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
      paramBuffer.addValueParam("pixmap", ParamType::TEGLNativePixmapType, pixmap);
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface);
      InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLCreatePixmapSurface, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreateWindowSurface(egl::Thread *thread,
                                         bool isCallValid,
                                         egl::Display *dpyPacked,
                                         egl::Config *configPacked,
                                         EGLNativeWindowType win,
                                         const AttributeMap &attrib_listPacked,
                                         EGLSurface returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
      paramBuffer.addValueParam("win", ParamType::TEGLNativeWindowType, win);
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface);
      InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLCreateWindowSurface, std::move(paramBuffer));
  }
  
  CallCapture CaptureDestroyContext(egl::Thread *thread,
                                    bool isCallValid,
                                    egl::Display *dpyPacked,
                                    gl::ContextID ctxPacked,
                                    EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("ctxPacked", ParamType::TContextID, ctxPacked);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLDestroyContext, std::move(paramBuffer));
  }
  
  CallCapture CaptureDestroySurface(egl::Thread *thread,
                                    bool isCallValid,
                                    egl::Display *dpyPacked,
                                    SurfaceID surfacePacked,
                                    EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLDestroySurface, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetConfigAttrib(egl::Thread *thread,
                                     bool isCallValid,
                                     egl::Display *dpyPacked,
                                     egl::Config *configPacked,
                                     EGLint attribute,
                                     EGLint *value,
                                     EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
      paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
      paramBuffer.addValueParam("value", ParamType::TEGLintPointer, value);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLGetConfigAttrib, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetConfigs(egl::Thread *thread,
                                bool isCallValid,
                                egl::Display *dpyPacked,
                                EGLConfig *configs,
                                EGLint config_size,
                                EGLint *num_config,
                                EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("configs", ParamType::TEGLConfigPointer, configs);
      paramBuffer.addValueParam("config_size", ParamType::TEGLint, config_size);
      paramBuffer.addValueParam("num_config", ParamType::TEGLintPointer, num_config);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLGetConfigs, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetCurrentDisplay(egl::Thread *thread, bool isCallValid, EGLDisplay returnValue)
  {
      ParamBuffer paramBuffer;
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLDisplay);
      InitParamValue(ParamType::TEGLDisplay, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLGetCurrentDisplay, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetCurrentSurface(egl::Thread *thread,
                                       bool isCallValid,
                                       EGLint readdraw,
                                       EGLSurface returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("readdraw", ParamType::TEGLint, readdraw);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface);
      InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLGetCurrentSurface, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetDisplay(egl::Thread *thread,
                                bool isCallValid,
                                EGLNativeDisplayType display_id,
                                EGLDisplay returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("display_id", ParamType::TEGLNativeDisplayType, display_id);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLDisplay);
      InitParamValue(ParamType::TEGLDisplay, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLGetDisplay, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetError(egl::Thread *thread, bool isCallValid, EGLint returnValue)
  {
      ParamBuffer paramBuffer;
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
      InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLGetError, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetProcAddress(egl::Thread *thread,
                                    bool isCallValid,
                                    const char *procname,
                                    __eglMustCastToProperFunctionPointerType returnValue)
  {
      ParamBuffer paramBuffer;
  
      return CallCapture(angle::EntryPoint::EGLGetProcAddress, std::move(paramBuffer));
  }
  
  CallCapture CaptureInitialize(egl::Thread *thread,
                                bool isCallValid,
                                egl::Display *dpyPacked,
                                EGLint *major,
                                EGLint *minor,
                                EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("major", ParamType::TEGLintPointer, major);
      paramBuffer.addValueParam("minor", ParamType::TEGLintPointer, minor);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLInitialize, std::move(paramBuffer));
  }
  
  CallCapture CaptureMakeCurrent(egl::Thread *thread,
                                 bool isCallValid,
                                 egl::Display *dpyPacked,
                                 SurfaceID drawPacked,
                                 SurfaceID readPacked,
                                 gl::ContextID ctxPacked,
                                 EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("drawPacked", ParamType::TSurfaceID, drawPacked);
      paramBuffer.addValueParam("readPacked", ParamType::TSurfaceID, readPacked);
      paramBuffer.addValueParam("ctxPacked", ParamType::TContextID, ctxPacked);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLMakeCurrent, std::move(paramBuffer));
  }
  
  CallCapture CaptureQueryContext(egl::Thread *thread,
                                  bool isCallValid,
                                  egl::Display *dpyPacked,
                                  gl::ContextID ctxPacked,
                                  EGLint attribute,
                                  EGLint *value,
                                  EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("ctxPacked", ParamType::TContextID, ctxPacked);
      paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
      paramBuffer.addValueParam("value", ParamType::TEGLintPointer, value);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLQueryContext, std::move(paramBuffer));
  }
  
  CallCapture CaptureQueryString(egl::Thread *thread,
                                 bool isCallValid,
                                 egl::Display *dpyPacked,
                                 EGLint name,
                                 const char *returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("name", ParamType::TEGLint, name);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TcharConstPointer);
      InitParamValue(ParamType::TcharConstPointer, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLQueryString, std::move(paramBuffer));
  }
  
  CallCapture CaptureQuerySurface(egl::Thread *thread,
                                  bool isCallValid,
                                  egl::Display *dpyPacked,
                                  SurfaceID surfacePacked,
                                  EGLint attribute,
                                  EGLint *value,
                                  EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
      paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
      paramBuffer.addValueParam("value", ParamType::TEGLintPointer, value);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLQuerySurface, std::move(paramBuffer));
  }
  
  CallCapture CaptureSwapBuffers(egl::Thread *thread,
                                 bool isCallValid,
                                 egl::Display *dpyPacked,
                                 SurfaceID surfacePacked,
                                 EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLSwapBuffers, std::move(paramBuffer));
  }
  
  CallCapture CaptureTerminate(egl::Thread *thread,
                               bool isCallValid,
                               egl::Display *dpyPacked,
                               EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLTerminate, std::move(paramBuffer));
  }
  
  CallCapture CaptureWaitGL(egl::Thread *thread, bool isCallValid, EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLWaitGL, std::move(paramBuffer));
  }
  
  CallCapture CaptureWaitNative(egl::Thread *thread,
                                bool isCallValid,
                                EGLint engine,
                                EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("engine", ParamType::TEGLint, engine);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLWaitNative, std::move(paramBuffer));
  }
  
  CallCapture CaptureBindTexImage(egl::Thread *thread,
                                  bool isCallValid,
                                  egl::Display *dpyPacked,
                                  SurfaceID surfacePacked,
                                  EGLint buffer,
                                  EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
      paramBuffer.addValueParam("buffer", ParamType::TEGLint, buffer);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLBindTexImage, std::move(paramBuffer));
  }
  
  CallCapture CaptureReleaseTexImage(egl::Thread *thread,
                                     bool isCallValid,
                                     egl::Display *dpyPacked,
                                     SurfaceID surfacePacked,
                                     EGLint buffer,
                                     EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
      paramBuffer.addValueParam("buffer", ParamType::TEGLint, buffer);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLReleaseTexImage, std::move(paramBuffer));
  }
  
  CallCapture CaptureSurfaceAttrib(egl::Thread *thread,
                                   bool isCallValid,
                                   egl::Display *dpyPacked,
                                   SurfaceID surfacePacked,
                                   EGLint attribute,
                                   EGLint value,
                                   EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
      paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
      paramBuffer.addValueParam("value", ParamType::TEGLint, value);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLSurfaceAttrib, std::move(paramBuffer));
  }
  
  CallCapture CaptureSwapInterval(egl::Thread *thread,
                                  bool isCallValid,
                                  egl::Display *dpyPacked,
                                  EGLint interval,
                                  EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("interval", ParamType::TEGLint, interval);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLSwapInterval, std::move(paramBuffer));
  }
  
  CallCapture CaptureBindAPI(egl::Thread *thread,
                             bool isCallValid,
                             EGLenum api,
                             EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("api", ParamType::TEGLenum, api);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLBindAPI, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreatePbufferFromClientBuffer(egl::Thread *thread,
                                                   bool isCallValid,
                                                   egl::Display *dpyPacked,
                                                   EGLenum buftype,
                                                   EGLClientBuffer buffer,
                                                   egl::Config *configPacked,
                                                   const AttributeMap &attrib_listPacked,
                                                   EGLSurface returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("buftype", ParamType::TEGLenum, buftype);
      paramBuffer.addValueParam("buffer", ParamType::TEGLClientBuffer, buffer);
      paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface);
      InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLCreatePbufferFromClientBuffer, std::move(paramBuffer));
  }
  
  CallCapture CaptureQueryAPI(egl::Thread *thread, bool isCallValid, EGLenum returnValue)
  {
      ParamBuffer paramBuffer;
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLenum);
      InitParamValue(ParamType::TEGLenum, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLQueryAPI, std::move(paramBuffer));
  }
  
  CallCapture CaptureReleaseThread(egl::Thread *thread, bool isCallValid, EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLReleaseThread, std::move(paramBuffer));
  }
  
  CallCapture CaptureWaitClient(egl::Thread *thread, bool isCallValid, EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLWaitClient, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetCurrentContext(egl::Thread *thread, bool isCallValid, EGLContext returnValue)
  {
      ParamBuffer paramBuffer;
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLContext);
      InitParamValue(ParamType::TEGLContext, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLGetCurrentContext, std::move(paramBuffer));
  }
  
  CallCapture CaptureClientWaitSync(egl::Thread *thread,
                                    bool isCallValid,
                                    egl::Display *dpyPacked,
                                    egl::SyncID syncPacked,
                                    EGLint flags,
                                    EGLTime timeout,
                                    EGLint returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
      paramBuffer.addValueParam("flags", ParamType::TEGLint, flags);
      paramBuffer.addValueParam("timeout", ParamType::TEGLTime, timeout);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
      InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLClientWaitSync, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreateImage(egl::Thread *thread,
                                 bool isCallValid,
                                 egl::Display *dpyPacked,
                                 gl::ContextID ctxPacked,
                                 EGLenum target,
                                 EGLClientBuffer buffer,
                                 const AttributeMap &attrib_listPacked,
                                 EGLImage returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("ctxPacked", ParamType::TContextID, ctxPacked);
      paramBuffer.addValueParam("target", ParamType::TEGLenum, target);
      paramBuffer.addValueParam("buffer", ParamType::TEGLClientBuffer, buffer);
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLImage);
      InitParamValue(ParamType::TEGLImage, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLCreateImage, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreatePlatformPixmapSurface(egl::Thread *thread,
                                                 bool isCallValid,
                                                 egl::Display *dpyPacked,
                                                 egl::Config *configPacked,
                                                 void *native_pixmap,
                                                 const AttributeMap &attrib_listPacked,
                                                 EGLSurface returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
      paramBuffer.addValueParam("native_pixmap", ParamType::TvoidPointer, native_pixmap);
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface);
      InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLCreatePlatformPixmapSurface, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreatePlatformWindowSurface(egl::Thread *thread,
                                                 bool isCallValid,
                                                 egl::Display *dpyPacked,
                                                 egl::Config *configPacked,
                                                 void *native_window,
                                                 const AttributeMap &attrib_listPacked,
                                                 EGLSurface returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
      paramBuffer.addValueParam("native_window", ParamType::TvoidPointer, native_window);
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface);
      InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLCreatePlatformWindowSurface, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreateSync(egl::Thread *thread,
                                bool isCallValid,
                                egl::Display *dpyPacked,
                                EGLenum type,
                                const AttributeMap &attrib_listPacked,
                                EGLSync returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("type", ParamType::TEGLenum, type);
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLSync);
      InitParamValue(ParamType::TEGLSync, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLCreateSync, std::move(paramBuffer));
  }
  
  CallCapture CaptureDestroyImage(egl::Thread *thread,
                                  bool isCallValid,
                                  egl::Display *dpyPacked,
                                  ImageID imagePacked,
                                  EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("imagePacked", ParamType::TImageID, imagePacked);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLDestroyImage, std::move(paramBuffer));
  }
  
  CallCapture CaptureDestroySync(egl::Thread *thread,
                                 bool isCallValid,
                                 egl::Display *dpyPacked,
                                 egl::SyncID syncPacked,
                                 EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLDestroySync, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetPlatformDisplay(egl::Thread *thread,
                                        bool isCallValid,
                                        EGLenum platform,
                                        void *native_display,
                                        const AttributeMap &attrib_listPacked,
                                        EGLDisplay returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("platform", ParamType::TEGLenum, platform);
      paramBuffer.addValueParam("native_display", ParamType::TvoidPointer, native_display);
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLDisplay);
      InitParamValue(ParamType::TEGLDisplay, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLGetPlatformDisplay, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetSyncAttrib(egl::Thread *thread,
                                   bool isCallValid,
                                   egl::Display *dpyPacked,
                                   egl::SyncID syncPacked,
                                   EGLint attribute,
                                   EGLAttrib *value,
                                   EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
      paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
      paramBuffer.addValueParam("value", ParamType::TEGLAttribPointer, value);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLGetSyncAttrib, std::move(paramBuffer));
  }
  
  CallCapture CaptureWaitSync(egl::Thread *thread,
                              bool isCallValid,
                              egl::Display *dpyPacked,
                              egl::SyncID syncPacked,
                              EGLint flags,
                              EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
      paramBuffer.addValueParam("flags", ParamType::TEGLint, flags);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLWaitSync, std::move(paramBuffer));
  }
  
  CallCapture CaptureSetBlobCacheFuncsANDROID(egl::Thread *thread,
                                              bool isCallValid,
                                              egl::Display *dpyPacked,
                                              EGLSetBlobFuncANDROID set,
                                              EGLGetBlobFuncANDROID get)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("set", ParamType::TEGLSetBlobFuncANDROID, set);
      paramBuffer.addValueParam("get", ParamType::TEGLGetBlobFuncANDROID, get);
  
      return CallCapture(angle::EntryPoint::EGLSetBlobCacheFuncsANDROID, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreateNativeClientBufferANDROID(egl::Thread *thread,
                                                     bool isCallValid,
                                                     const AttributeMap &attrib_listPacked,
                                                     EGLClientBuffer returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLClientBuffer);
      InitParamValue(ParamType::TEGLClientBuffer, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLCreateNativeClientBufferANDROID,
                         std::move(paramBuffer));
  }
  
  CallCapture CaptureGetCompositorTimingSupportedANDROID(egl::Thread *thread,
                                                         bool isCallValid,
                                                         egl::Display *dpyPacked,
                                                         SurfaceID surfacePacked,
                                                         CompositorTiming namePacked,
                                                         EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
      paramBuffer.addValueParam("namePacked", ParamType::TCompositorTiming, namePacked);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLGetCompositorTimingSupportedANDROID,
                         std::move(paramBuffer));
  }
  
  CallCapture CaptureGetCompositorTimingANDROID(egl::Thread *thread,
                                                bool isCallValid,
                                                egl::Display *dpyPacked,
                                                SurfaceID surfacePacked,
                                                EGLint numTimestamps,
                                                const EGLint *names,
                                                EGLnsecsANDROID *values,
                                                EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
      paramBuffer.addValueParam("numTimestamps", ParamType::TEGLint, numTimestamps);
      paramBuffer.addValueParam("names", ParamType::TEGLintConstPointer, names);
      paramBuffer.addValueParam("values", ParamType::TEGLnsecsANDROIDPointer, values);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLGetCompositorTimingANDROID, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetNextFrameIdANDROID(egl::Thread *thread,
                                           bool isCallValid,
                                           egl::Display *dpyPacked,
                                           SurfaceID surfacePacked,
                                           EGLuint64KHR *frameId,
                                           EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
      paramBuffer.addValueParam("frameId", ParamType::TEGLuint64KHRPointer, frameId);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLGetNextFrameIdANDROID, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetFrameTimestampSupportedANDROID(egl::Thread *thread,
                                                       bool isCallValid,
                                                       egl::Display *dpyPacked,
                                                       SurfaceID surfacePacked,
                                                       Timestamp timestampPacked,
                                                       EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
      paramBuffer.addValueParam("timestampPacked", ParamType::TTimestamp, timestampPacked);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLGetFrameTimestampSupportedANDROID,
                         std::move(paramBuffer));
  }
  
  CallCapture CaptureGetFrameTimestampsANDROID(egl::Thread *thread,
                                               bool isCallValid,
                                               egl::Display *dpyPacked,
                                               SurfaceID surfacePacked,
                                               EGLuint64KHR frameId,
                                               EGLint numTimestamps,
                                               const EGLint *timestamps,
                                               EGLnsecsANDROID *values,
                                               EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
      paramBuffer.addValueParam("frameId", ParamType::TEGLuint64KHR, frameId);
      paramBuffer.addValueParam("numTimestamps", ParamType::TEGLint, numTimestamps);
      paramBuffer.addValueParam("timestamps", ParamType::TEGLintConstPointer, timestamps);
      paramBuffer.addValueParam("values", ParamType::TEGLnsecsANDROIDPointer, values);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLGetFrameTimestampsANDROID, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetNativeClientBufferANDROID(egl::Thread *thread,
                                                  bool isCallValid,
                                                  const struct AHardwareBuffer *buffer,
                                                  EGLClientBuffer returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("buffer", ParamType::TAHardwareBufferConstPointer, buffer);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLClientBuffer);
      InitParamValue(ParamType::TEGLClientBuffer, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLGetNativeClientBufferANDROID, std::move(paramBuffer));
  }
  
  CallCapture CaptureDupNativeFenceFDANDROID(egl::Thread *thread,
                                             bool isCallValid,
                                             egl::Display *dpyPacked,
                                             egl::SyncID syncPacked,
                                             EGLint returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
      InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLDupNativeFenceFDANDROID, std::move(paramBuffer));
  }
  
  CallCapture CapturePresentationTimeANDROID(egl::Thread *thread,
                                             bool isCallValid,
                                             egl::Display *dpyPacked,
                                             SurfaceID surfacePacked,
                                             EGLnsecsANDROID time,
                                             EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
      paramBuffer.addValueParam("time", ParamType::TEGLnsecsANDROID, time);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLPresentationTimeANDROID, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreateDeviceANGLE(egl::Thread *thread,
                                       bool isCallValid,
                                       EGLint device_type,
                                       void *native_device,
                                       const EGLAttrib *attrib_list,
                                       EGLDeviceEXT returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("device_type", ParamType::TEGLint, device_type);
      paramBuffer.addValueParam("native_device", ParamType::TvoidPointer, native_device);
      paramBuffer.addValueParam("attrib_list", ParamType::TEGLAttribConstPointer, attrib_list);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLDeviceEXT);
      InitParamValue(ParamType::TEGLDeviceEXT, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLCreateDeviceANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureReleaseDeviceANGLE(egl::Thread *thread,
                                        bool isCallValid,
                                        egl::Device *devicePacked,
                                        EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("devicePacked", ParamType::Tegl_DevicePointer, devicePacked);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLReleaseDeviceANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureLockVulkanQueueANGLE(egl::Thread *thread,
                                          bool isCallValid,
                                          egl::Display *dpyPacked)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
  
      return CallCapture(angle::EntryPoint::EGLLockVulkanQueueANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureUnlockVulkanQueueANGLE(egl::Thread *thread,
                                            bool isCallValid,
                                            egl::Display *dpyPacked)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
  
      return CallCapture(angle::EntryPoint::EGLUnlockVulkanQueueANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureAcquireExternalContextANGLE(egl::Thread *thread,
                                                 bool isCallValid,
                                                 egl::Display *dpyPacked,
                                                 SurfaceID drawAndReadPacked)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("drawAndReadPacked", ParamType::TSurfaceID, drawAndReadPacked);
  
      return CallCapture(angle::EntryPoint::EGLAcquireExternalContextANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureReleaseExternalContextANGLE(egl::Thread *thread,
                                                 bool isCallValid,
                                                 egl::Display *dpyPacked)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
  
      return CallCapture(angle::EntryPoint::EGLReleaseExternalContextANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureQueryStringiANGLE(egl::Thread *thread,
                                       bool isCallValid,
                                       egl::Display *dpyPacked,
                                       EGLint name,
                                       EGLint index,
                                       const char *returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("name", ParamType::TEGLint, name);
      paramBuffer.addValueParam("index", ParamType::TEGLint, index);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TcharConstPointer);
      InitParamValue(ParamType::TcharConstPointer, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLQueryStringiANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureQueryDisplayAttribANGLE(egl::Thread *thread,
                                             bool isCallValid,
                                             egl::Display *dpyPacked,
                                             EGLint attribute,
                                             EGLAttrib *value,
                                             EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
      paramBuffer.addValueParam("value", ParamType::TEGLAttribPointer, value);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLQueryDisplayAttribANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureCopyMetalSharedEventANGLE(egl::Thread *thread,
                                               bool isCallValid,
                                               egl::Display *dpyPacked,
                                               egl::SyncID syncPacked,
                                               void *returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer);
      InitParamValue(ParamType::TvoidPointer, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLCopyMetalSharedEventANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureSetValidationEnabledANGLE(egl::Thread *thread,
                                               bool isCallValid,
                                               EGLBoolean validationState)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("validationState", ParamType::TEGLBoolean, validationState);
  
      return CallCapture(angle::EntryPoint::EGLSetValidationEnabledANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureReleaseHighPowerGPUANGLE(egl::Thread *thread,
                                              bool isCallValid,
                                              egl::Display *dpyPacked,
                                              gl::ContextID ctxPacked)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("ctxPacked", ParamType::TContextID, ctxPacked);
  
      return CallCapture(angle::EntryPoint::EGLReleaseHighPowerGPUANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureReacquireHighPowerGPUANGLE(egl::Thread *thread,
                                                bool isCallValid,
                                                egl::Display *dpyPacked,
                                                gl::ContextID ctxPacked)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("ctxPacked", ParamType::TContextID, ctxPacked);
  
      return CallCapture(angle::EntryPoint::EGLReacquireHighPowerGPUANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureHandleGPUSwitchANGLE(egl::Thread *thread,
                                          bool isCallValid,
                                          egl::Display *dpyPacked)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
  
      return CallCapture(angle::EntryPoint::EGLHandleGPUSwitchANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureForceGPUSwitchANGLE(egl::Thread *thread,
                                         bool isCallValid,
                                         egl::Display *dpyPacked,
                                         EGLint gpuIDHigh,
                                         EGLint gpuIDLow)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("gpuIDHigh", ParamType::TEGLint, gpuIDHigh);
      paramBuffer.addValueParam("gpuIDLow", ParamType::TEGLint, gpuIDLow);
  
      return CallCapture(angle::EntryPoint::EGLForceGPUSwitchANGLE, std::move(paramBuffer));
  }
  
  CallCapture CapturePrepareSwapBuffersANGLE(egl::Thread *thread,
                                             bool isCallValid,
                                             egl::Display *dpyPacked,
                                             SurfaceID surfacePacked,
                                             EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLPrepareSwapBuffersANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureProgramCacheGetAttribANGLE(egl::Thread *thread,
                                                bool isCallValid,
                                                egl::Display *dpyPacked,
                                                EGLenum attrib,
                                                EGLint returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("attrib", ParamType::TEGLenum, attrib);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
      InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLProgramCacheGetAttribANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureProgramCacheQueryANGLE(egl::Thread *thread,
                                            bool isCallValid,
                                            egl::Display *dpyPacked,
                                            EGLint index,
                                            void *key,
                                            EGLint *keysize,
                                            void *binary,
                                            EGLint *binarysize)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("index", ParamType::TEGLint, index);
      paramBuffer.addValueParam("key", ParamType::TvoidPointer, key);
      paramBuffer.addValueParam("keysize", ParamType::TEGLintPointer, keysize);
      paramBuffer.addValueParam("binary", ParamType::TvoidPointer, binary);
      paramBuffer.addValueParam("binarysize", ParamType::TEGLintPointer, binarysize);
  
      return CallCapture(angle::EntryPoint::EGLProgramCacheQueryANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureProgramCachePopulateANGLE(egl::Thread *thread,
                                               bool isCallValid,
                                               egl::Display *dpyPacked,
                                               const void *key,
                                               EGLint keysize,
                                               const void *binary,
                                               EGLint binarysize)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("key", ParamType::TvoidConstPointer, key);
      paramBuffer.addValueParam("keysize", ParamType::TEGLint, keysize);
      paramBuffer.addValueParam("binary", ParamType::TvoidConstPointer, binary);
      paramBuffer.addValueParam("binarysize", ParamType::TEGLint, binarysize);
  
      return CallCapture(angle::EntryPoint::EGLProgramCachePopulateANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureProgramCacheResizeANGLE(egl::Thread *thread,
                                             bool isCallValid,
                                             egl::Display *dpyPacked,
                                             EGLint limit,
                                             EGLint mode,
                                             EGLint returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("limit", ParamType::TEGLint, limit);
      paramBuffer.addValueParam("mode", ParamType::TEGLint, mode);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
      InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLProgramCacheResizeANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureQuerySurfacePointerANGLE(egl::Thread *thread,
                                              bool isCallValid,
                                              egl::Display *dpyPacked,
                                              SurfaceID surfacePacked,
                                              EGLint attribute,
                                              void **value,
                                              EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
      paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
      paramBuffer.addValueParam("value", ParamType::TvoidPointerPointer, value);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLQuerySurfacePointerANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreateStreamProducerD3DTextureANGLE(egl::Thread *thread,
                                                         bool isCallValid,
                                                         egl::Display *dpyPacked,
                                                         egl::Stream *streamPacked,
                                                         const AttributeMap &attrib_listPacked,
                                                         EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLCreateStreamProducerD3DTextureANGLE,
                         std::move(paramBuffer));
  }
  
  CallCapture CaptureStreamPostD3DTextureANGLE(egl::Thread *thread,
                                               bool isCallValid,
                                               egl::Display *dpyPacked,
                                               egl::Stream *streamPacked,
                                               void *texture,
                                               const AttributeMap &attrib_listPacked,
                                               EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
      paramBuffer.addValueParam("texture", ParamType::TvoidPointer, texture);
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLStreamPostD3DTextureANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetMscRateANGLE(egl::Thread *thread,
                                     bool isCallValid,
                                     egl::Display *dpyPacked,
                                     SurfaceID surfacePacked,
                                     EGLint *numerator,
                                     EGLint *denominator,
                                     EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
      paramBuffer.addValueParam("numerator", ParamType::TEGLintPointer, numerator);
      paramBuffer.addValueParam("denominator", ParamType::TEGLintPointer, denominator);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLGetMscRateANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureExportVkImageANGLE(egl::Thread *thread,
                                        bool isCallValid,
                                        egl::Display *dpyPacked,
                                        ImageID imagePacked,
                                        void *vk_image,
                                        void *vk_image_create_info,
                                        EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("imagePacked", ParamType::TImageID, imagePacked);
      paramBuffer.addValueParam("vk_image", ParamType::TvoidPointer, vk_image);
      paramBuffer.addValueParam("vk_image_create_info", ParamType::TvoidPointer,
                                vk_image_create_info);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLExportVkImageANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureWaitUntilWorkScheduledANGLE(egl::Thread *thread,
                                                 bool isCallValid,
                                                 egl::Display *dpyPacked)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
  
      return CallCapture(angle::EntryPoint::EGLWaitUntilWorkScheduledANGLE, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetSyncValuesCHROMIUM(egl::Thread *thread,
                                           bool isCallValid,
                                           egl::Display *dpyPacked,
                                           SurfaceID surfacePacked,
                                           EGLuint64KHR *ust,
                                           EGLuint64KHR *msc,
                                           EGLuint64KHR *sbc,
                                           EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
      paramBuffer.addValueParam("ust", ParamType::TEGLuint64KHRPointer, ust);
      paramBuffer.addValueParam("msc", ParamType::TEGLuint64KHRPointer, msc);
      paramBuffer.addValueParam("sbc", ParamType::TEGLuint64KHRPointer, sbc);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLGetSyncValuesCHROMIUM, std::move(paramBuffer));
  }
  
  CallCapture CaptureQueryDeviceAttribEXT(egl::Thread *thread,
                                          bool isCallValid,
                                          egl::Device *devicePacked,
                                          EGLint attribute,
                                          EGLAttrib *value,
                                          EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("devicePacked", ParamType::Tegl_DevicePointer, devicePacked);
      paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
      paramBuffer.addValueParam("value", ParamType::TEGLAttribPointer, value);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLQueryDeviceAttribEXT, std::move(paramBuffer));
  }
  
  CallCapture CaptureQueryDeviceStringEXT(egl::Thread *thread,
                                          bool isCallValid,
                                          egl::Device *devicePacked,
                                          EGLint name,
                                          const char *returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("devicePacked", ParamType::Tegl_DevicePointer, devicePacked);
      paramBuffer.addValueParam("name", ParamType::TEGLint, name);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TcharConstPointer);
      InitParamValue(ParamType::TcharConstPointer, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLQueryDeviceStringEXT, std::move(paramBuffer));
  }
  
  CallCapture CaptureQueryDisplayAttribEXT(egl::Thread *thread,
                                           bool isCallValid,
                                           egl::Display *dpyPacked,
                                           EGLint attribute,
                                           EGLAttrib *value,
                                           EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
      paramBuffer.addValueParam("value", ParamType::TEGLAttribPointer, value);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLQueryDisplayAttribEXT, std::move(paramBuffer));
  }
  
  CallCapture CaptureQueryDmaBufFormatsEXT(egl::Thread *thread,
                                           bool isCallValid,
                                           egl::Display *dpyPacked,
                                           EGLint max_formats,
                                           EGLint *formats,
                                           EGLint *num_formats,
                                           EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("max_formats", ParamType::TEGLint, max_formats);
      paramBuffer.addValueParam("formats", ParamType::TEGLintPointer, formats);
      paramBuffer.addValueParam("num_formats", ParamType::TEGLintPointer, num_formats);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLQueryDmaBufFormatsEXT, std::move(paramBuffer));
  }
  
  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)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("format", ParamType::TEGLint, format);
      paramBuffer.addValueParam("max_modifiers", ParamType::TEGLint, max_modifiers);
      paramBuffer.addValueParam("modifiers", ParamType::TEGLuint64KHRPointer, modifiers);
      paramBuffer.addValueParam("external_only", ParamType::TEGLBooleanPointer, external_only);
      paramBuffer.addValueParam("num_modifiers", ParamType::TEGLintPointer, num_modifiers);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLQueryDmaBufModifiersEXT, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreatePlatformPixmapSurfaceEXT(egl::Thread *thread,
                                                    bool isCallValid,
                                                    egl::Display *dpyPacked,
                                                    egl::Config *configPacked,
                                                    void *native_pixmap,
                                                    const AttributeMap &attrib_listPacked,
                                                    EGLSurface returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
      paramBuffer.addValueParam("native_pixmap", ParamType::TvoidPointer, native_pixmap);
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface);
      InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLCreatePlatformPixmapSurfaceEXT,
                         std::move(paramBuffer));
  }
  
  CallCapture CaptureCreatePlatformWindowSurfaceEXT(egl::Thread *thread,
                                                    bool isCallValid,
                                                    egl::Display *dpyPacked,
                                                    egl::Config *configPacked,
                                                    void *native_window,
                                                    const AttributeMap &attrib_listPacked,
                                                    EGLSurface returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
      paramBuffer.addValueParam("native_window", ParamType::TvoidPointer, native_window);
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface);
      InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLCreatePlatformWindowSurfaceEXT,
                         std::move(paramBuffer));
  }
  
  CallCapture CaptureGetPlatformDisplayEXT(egl::Thread *thread,
                                           bool isCallValid,
                                           EGLenum platform,
                                           void *native_display,
                                           const AttributeMap &attrib_listPacked,
                                           EGLDisplay returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("platform", ParamType::TEGLenum, platform);
      paramBuffer.addValueParam("native_display", ParamType::TvoidPointer, native_display);
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLDisplay);
      InitParamValue(ParamType::TEGLDisplay, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLGetPlatformDisplayEXT, std::move(paramBuffer));
  }
  
  CallCapture CaptureQuerySupportedCompressionRatesEXT(egl::Thread *thread,
                                                       bool isCallValid,
                                                       egl::Display *dpyPacked,
                                                       egl::Config *configPacked,
                                                       const EGLAttrib *attrib_list,
                                                       EGLint *rates,
                                                       EGLint rate_size,
                                                       EGLint *num_rates,
                                                       EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked);
      paramBuffer.addValueParam("attrib_list", ParamType::TEGLAttribConstPointer, attrib_list);
      paramBuffer.addValueParam("rates", ParamType::TEGLintPointer, rates);
      paramBuffer.addValueParam("rate_size", ParamType::TEGLint, rate_size);
      paramBuffer.addValueParam("num_rates", ParamType::TEGLintPointer, num_rates);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLQuerySupportedCompressionRatesEXT,
                         std::move(paramBuffer));
  }
  
  CallCapture CaptureDebugMessageControlKHR(egl::Thread *thread,
                                            bool isCallValid,
                                            EGLDEBUGPROCKHR callback,
                                            const AttributeMap &attrib_listPacked,
                                            EGLint returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("callback", ParamType::TEGLDEBUGPROCKHR, callback);
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
      InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLDebugMessageControlKHR, std::move(paramBuffer));
  }
  
  CallCapture CaptureLabelObjectKHR(egl::Thread *thread,
                                    bool isCallValid,
                                    egl::Display *displayPacked,
                                    ObjectType objectTypePacked,
                                    EGLObjectKHR object,
                                    EGLLabelKHR label,
                                    EGLint returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("displayPacked", ParamType::Tegl_DisplayPointer, displayPacked);
      paramBuffer.addValueParam("objectTypePacked", ParamType::TObjectType, objectTypePacked);
      paramBuffer.addValueParam("object", ParamType::TEGLObjectKHR, object);
      paramBuffer.addValueParam("label", ParamType::TEGLLabelKHR, label);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
      InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLLabelObjectKHR, std::move(paramBuffer));
  }
  
  CallCapture CaptureQueryDebugKHR(egl::Thread *thread,
                                   bool isCallValid,
                                   EGLint attribute,
                                   EGLAttrib *value,
                                   EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
      paramBuffer.addValueParam("value", ParamType::TEGLAttribPointer, value);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLQueryDebugKHR, std::move(paramBuffer));
  }
  
  CallCapture CaptureClientWaitSyncKHR(egl::Thread *thread,
                                       bool isCallValid,
                                       egl::Display *dpyPacked,
                                       egl::SyncID syncPacked,
                                       EGLint flags,
                                       EGLTimeKHR timeout,
                                       EGLint returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
      paramBuffer.addValueParam("flags", ParamType::TEGLint, flags);
      paramBuffer.addValueParam("timeout", ParamType::TEGLTimeKHR, timeout);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
      InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLClientWaitSyncKHR, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreateSyncKHR(egl::Thread *thread,
                                   bool isCallValid,
                                   egl::Display *dpyPacked,
                                   EGLenum type,
                                   const AttributeMap &attrib_listPacked,
                                   EGLSyncKHR returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("type", ParamType::TEGLenum, type);
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLSyncKHR);
      InitParamValue(ParamType::TEGLSyncKHR, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLCreateSyncKHR, std::move(paramBuffer));
  }
  
  CallCapture CaptureDestroySyncKHR(egl::Thread *thread,
                                    bool isCallValid,
                                    egl::Display *dpyPacked,
                                    egl::SyncID syncPacked,
                                    EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLDestroySyncKHR, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetSyncAttribKHR(egl::Thread *thread,
                                      bool isCallValid,
                                      egl::Display *dpyPacked,
                                      egl::SyncID syncPacked,
                                      EGLint attribute,
                                      EGLint *value,
                                      EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
      paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
      paramBuffer.addValueParam("value", ParamType::TEGLintPointer, value);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLGetSyncAttribKHR, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreateImageKHR(egl::Thread *thread,
                                    bool isCallValid,
                                    egl::Display *dpyPacked,
                                    gl::ContextID ctxPacked,
                                    EGLenum target,
                                    EGLClientBuffer buffer,
                                    const AttributeMap &attrib_listPacked,
                                    EGLImageKHR returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("ctxPacked", ParamType::TContextID, ctxPacked);
      paramBuffer.addValueParam("target", ParamType::TEGLenum, target);
      paramBuffer.addValueParam("buffer", ParamType::TEGLClientBuffer, buffer);
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLImageKHR);
      InitParamValue(ParamType::TEGLImageKHR, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLCreateImageKHR, std::move(paramBuffer));
  }
  
  CallCapture CaptureDestroyImageKHR(egl::Thread *thread,
                                     bool isCallValid,
                                     egl::Display *dpyPacked,
                                     ImageID imagePacked,
                                     EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("imagePacked", ParamType::TImageID, imagePacked);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLDestroyImageKHR, std::move(paramBuffer));
  }
  
  CallCapture CaptureLockSurfaceKHR(egl::Thread *thread,
                                    bool isCallValid,
                                    egl::Display *dpyPacked,
                                    SurfaceID surfacePacked,
                                    const AttributeMap &attrib_listPacked,
                                    EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLLockSurfaceKHR, std::move(paramBuffer));
  }
  
  CallCapture CaptureQuerySurface64KHR(egl::Thread *thread,
                                       bool isCallValid,
                                       egl::Display *dpyPacked,
                                       SurfaceID surfacePacked,
                                       EGLint attribute,
                                       EGLAttribKHR *value,
                                       EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
      paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute);
      paramBuffer.addValueParam("value", ParamType::TEGLAttribKHRPointer, value);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLQuerySurface64KHR, std::move(paramBuffer));
  }
  
  CallCapture CaptureUnlockSurfaceKHR(egl::Thread *thread,
                                      bool isCallValid,
                                      egl::Display *dpyPacked,
                                      SurfaceID surfacePacked,
                                      EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLUnlockSurfaceKHR, std::move(paramBuffer));
  }
  
  CallCapture CaptureSetDamageRegionKHR(egl::Thread *thread,
                                        bool isCallValid,
                                        egl::Display *dpyPacked,
                                        SurfaceID surfacePacked,
                                        EGLint *rects,
                                        EGLint n_rects,
                                        EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
      paramBuffer.addValueParam("rects", ParamType::TEGLintPointer, rects);
      paramBuffer.addValueParam("n_rects", ParamType::TEGLint, n_rects);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLSetDamageRegionKHR, std::move(paramBuffer));
  }
  
  CallCapture CaptureSignalSyncKHR(egl::Thread *thread,
                                   bool isCallValid,
                                   egl::Display *dpyPacked,
                                   egl::SyncID syncPacked,
                                   EGLenum mode,
                                   EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
      paramBuffer.addValueParam("mode", ParamType::TEGLenum, mode);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLSignalSyncKHR, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreateStreamKHR(egl::Thread *thread,
                                     bool isCallValid,
                                     egl::Display *dpyPacked,
                                     const AttributeMap &attrib_listPacked,
                                     EGLStreamKHR returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLStreamKHR);
      InitParamValue(ParamType::TEGLStreamKHR, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLCreateStreamKHR, std::move(paramBuffer));
  }
  
  CallCapture CaptureDestroyStreamKHR(egl::Thread *thread,
                                      bool isCallValid,
                                      egl::Display *dpyPacked,
                                      egl::Stream *streamPacked,
                                      EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLDestroyStreamKHR, std::move(paramBuffer));
  }
  
  CallCapture CaptureQueryStreamKHR(egl::Thread *thread,
                                    bool isCallValid,
                                    egl::Display *dpyPacked,
                                    egl::Stream *streamPacked,
                                    EGLenum attribute,
                                    EGLint *value,
                                    EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
      paramBuffer.addValueParam("attribute", ParamType::TEGLenum, attribute);
      paramBuffer.addValueParam("value", ParamType::TEGLintPointer, value);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLQueryStreamKHR, std::move(paramBuffer));
  }
  
  CallCapture CaptureQueryStreamu64KHR(egl::Thread *thread,
                                       bool isCallValid,
                                       egl::Display *dpyPacked,
                                       egl::Stream *streamPacked,
                                       EGLenum attribute,
                                       EGLuint64KHR *value,
                                       EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
      paramBuffer.addValueParam("attribute", ParamType::TEGLenum, attribute);
      paramBuffer.addValueParam("value", ParamType::TEGLuint64KHRPointer, value);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLQueryStreamu64KHR, std::move(paramBuffer));
  }
  
  CallCapture CaptureStreamAttribKHR(egl::Thread *thread,
                                     bool isCallValid,
                                     egl::Display *dpyPacked,
                                     egl::Stream *streamPacked,
                                     EGLenum attribute,
                                     EGLint value,
                                     EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
      paramBuffer.addValueParam("attribute", ParamType::TEGLenum, attribute);
      paramBuffer.addValueParam("value", ParamType::TEGLint, value);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLStreamAttribKHR, std::move(paramBuffer));
  }
  
  CallCapture CaptureStreamConsumerAcquireKHR(egl::Thread *thread,
                                              bool isCallValid,
                                              egl::Display *dpyPacked,
                                              egl::Stream *streamPacked,
                                              EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLStreamConsumerAcquireKHR, std::move(paramBuffer));
  }
  
  CallCapture CaptureStreamConsumerGLTextureExternalKHR(egl::Thread *thread,
                                                        bool isCallValid,
                                                        egl::Display *dpyPacked,
                                                        egl::Stream *streamPacked,
                                                        EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLStreamConsumerGLTextureExternalKHR,
                         std::move(paramBuffer));
  }
  
  CallCapture CaptureStreamConsumerReleaseKHR(egl::Thread *thread,
                                              bool isCallValid,
                                              egl::Display *dpyPacked,
                                              egl::Stream *streamPacked,
                                              EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLStreamConsumerReleaseKHR, std::move(paramBuffer));
  }
  
  CallCapture CaptureSwapBuffersWithDamageKHR(egl::Thread *thread,
                                              bool isCallValid,
                                              egl::Display *dpyPacked,
                                              SurfaceID surfacePacked,
                                              const EGLint *rects,
                                              EGLint n_rects,
                                              EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
      paramBuffer.addValueParam("rects", ParamType::TEGLintConstPointer, rects);
      paramBuffer.addValueParam("n_rects", ParamType::TEGLint, n_rects);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLSwapBuffersWithDamageKHR, std::move(paramBuffer));
  }
  
  CallCapture CaptureWaitSyncKHR(egl::Thread *thread,
                                 bool isCallValid,
                                 egl::Display *dpyPacked,
                                 egl::SyncID syncPacked,
                                 EGLint flags,
                                 EGLint returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncID, syncPacked);
      paramBuffer.addValueParam("flags", ParamType::TEGLint, flags);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLint);
      InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLWaitSyncKHR, std::move(paramBuffer));
  }
  
  CallCapture CapturePostSubBufferNV(egl::Thread *thread,
                                     bool isCallValid,
                                     egl::Display *dpyPacked,
                                     SurfaceID surfacePacked,
                                     EGLint x,
                                     EGLint y,
                                     EGLint width,
                                     EGLint height,
                                     EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("surfacePacked", ParamType::TSurfaceID, surfacePacked);
      paramBuffer.addValueParam("x", ParamType::TEGLint, x);
      paramBuffer.addValueParam("y", ParamType::TEGLint, y);
      paramBuffer.addValueParam("width", ParamType::TEGLint, width);
      paramBuffer.addValueParam("height", ParamType::TEGLint, height);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLPostSubBufferNV, std::move(paramBuffer));
  }
  
  CallCapture CaptureStreamConsumerGLTextureExternalAttribsNV(egl::Thread *thread,
                                                              bool isCallValid,
                                                              egl::Display *dpyPacked,
                                                              egl::Stream *streamPacked,
                                                              const AttributeMap &attrib_listPacked,
                                                              EGLBoolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
      paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked);
      paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked));
  
      ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
      InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::EGLStreamConsumerGLTextureExternalAttribsNV,
                         std::move(paramBuffer));
  }
  
  }  // namespace egl
  

Download