Capture/Replay: Auto-generate EGL capture code.
Replaces the custom code in the EGL stubs. Skips a few "Get"
entry points because this CL doesn't implement pointer capture
like we do for all the GL entry points.
Includes a new state in the AttributeMap that indicates which
type of attribute values we used when initializing the map.
Bug: angleproject:4035
Change-Id: I272eac5e4068602ce710ef66c9a1dce5387943a5
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3949911
Reviewed-by: Yuxin Hu <yuxinhu@google.com>
Commit-Queue: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Cody Northrop <cnorthrop@google.com>
diff --git a/scripts/code_generation_hashes/GL_EGL_entry_points.json b/scripts/code_generation_hashes/GL_EGL_entry_points.json
index 69ebc82..e639054 100644
--- a/scripts/code_generation_hashes/GL_EGL_entry_points.json
+++ b/scripts/code_generation_hashes/GL_EGL_entry_points.json
@@ -6,7 +6,7 @@
"scripts/entry_point_packed_gl_enums.json":
"44a89e71f42598b0596ef4c25b290dff",
"scripts/generate_entry_points.py":
- "18dd48631e551dcadf8b687953d3c6cb",
+ "679167787fd12c1ec3cbac70957c08df",
"scripts/gl_angle_ext.xml":
"8dd9662655c39ce22fecdc2449594e54",
"scripts/registry_xml.py":
@@ -35,52 +35,56 @@
"48567dca16fd881dfe6d61fee0e3106f",
"src/libANGLE/Context_gles_ext_autogen.h":
"0d065fb2339cc6b6e154d002502192c1",
+ "src/libANGLE/capture/capture_egl_autogen.cpp":
+ "96116af910de967f275d18f5a3dc2d42",
+ "src/libANGLE/capture/capture_egl_autogen.h":
+ "fae4b722da10aceb3cad63d067164940",
"src/libANGLE/capture/capture_gl_1_autogen.cpp":
- "f9bf8c9d8af9c097031be92ea3e805b5",
+ "5dfd57aea4a672d42fb4fd4df332709c",
"src/libANGLE/capture/capture_gl_1_autogen.h":
"48ab591d9671ea49aa9ae977b6a0d2fb",
"src/libANGLE/capture/capture_gl_2_autogen.cpp":
- "2fb35570619b2e7a2088e523d0017b15",
+ "8e4d812520a8f17c5ce1f006e7cacb09",
"src/libANGLE/capture/capture_gl_2_autogen.h":
"1e5b7623566fe1282567e3b31cddbee1",
"src/libANGLE/capture/capture_gl_3_autogen.cpp":
- "257e0e9b36c2111165122799054b6277",
+ "423e570a7f2264ca30b5d936505e24d0",
"src/libANGLE/capture/capture_gl_3_autogen.h":
"32e061964a2bccfc27dc95eb1a69558e",
"src/libANGLE/capture/capture_gl_4_autogen.cpp":
- "334403c06a9ae7b5a537ca762dfb32ff",
+ "9b160c5e3df64deb3d190d7c82d7dbd2",
"src/libANGLE/capture/capture_gl_4_autogen.h":
"985366fe10b1e96e557a84d26769a042",
"src/libANGLE/capture/capture_gles_1_0_autogen.cpp":
- "79678697323312af94be6a41cce62cc4",
+ "9c920afc742fd77145172494faa42146",
"src/libANGLE/capture/capture_gles_1_0_autogen.h":
"141838b474dda3d9a6122e73d3621972",
"src/libANGLE/capture/capture_gles_2_0_autogen.cpp":
- "80e9dd0750299f2ada17042bf0c337f9",
+ "44079a951893f3bd2424946f40b371d8",
"src/libANGLE/capture/capture_gles_2_0_autogen.h":
"73d813905e7e938cf11d1722f98de84b",
"src/libANGLE/capture/capture_gles_3_0_autogen.cpp":
- "124063a757419fa0246948e141312768",
+ "2030b9d08eecf9ec0ee960bd2af25a76",
"src/libANGLE/capture/capture_gles_3_0_autogen.h":
"c5bff0201be9dc51fdb507a63dd9d8f8",
"src/libANGLE/capture/capture_gles_3_1_autogen.cpp":
- "c94c8573246f3c281d3a4b68e8a3301a",
+ "071260877f00a8841751f3cd309069d3",
"src/libANGLE/capture/capture_gles_3_1_autogen.h":
"414b92fe8db95146d8af3c13830e3685",
"src/libANGLE/capture/capture_gles_3_2_autogen.cpp":
- "1c8511a8acf5a58bded506939dad0fef",
+ "3cdbd40c4f971a7770076326bfce51c7",
"src/libANGLE/capture/capture_gles_3_2_autogen.h":
"74ed7366af3a46c0661397cfa29ec6fc",
"src/libANGLE/capture/capture_gles_ext_autogen.cpp":
- "f332b5e5e0573f3f9f6887afb663a5c4",
+ "b9cae90fe442c5a5c081bfbcd3413a78",
"src/libANGLE/capture/capture_gles_ext_autogen.h":
"d9bb79d32a32b331dac93956065c0b66",
"src/libANGLE/capture/frame_capture_replay_autogen.cpp":
"f1c2b5949709f05f71aeddee6d00d701",
"src/libANGLE/capture/frame_capture_utils_autogen.cpp":
- "c87dd3000aef4270b40b98deeb497144",
+ "c332b27634067cc044b78b3d0de700ce",
"src/libANGLE/capture/frame_capture_utils_autogen.h":
- "5bcab4ec3a25b1894bd1715581a7b1d3",
+ "8e136ce01abc762b5cf1862256d14c83",
"src/libANGLE/validationCL_autogen.h":
"0022d0cdb6a9e2ef4a59b71164f62333",
"src/libANGLE/validationEGL_autogen.h":
@@ -122,11 +126,11 @@
"src/libGLESv2/entry_points_cl_autogen.h":
"dde2f94c3004874a7da995dae69da811",
"src/libGLESv2/entry_points_egl_autogen.cpp":
- "2ae6b7456e2e8a858bbaf06ab62246fa",
+ "3ec155b49e891165d7e0cdc4cdad5258",
"src/libGLESv2/entry_points_egl_autogen.h":
"3bc7a8df9deadd7cfd615d0cfad0c6a8",
"src/libGLESv2/entry_points_egl_ext_autogen.cpp":
- "46e86754277c35b101784854532b2e5c",
+ "b02ab9c50a2740a284d044b4415e1383",
"src/libGLESv2/entry_points_egl_ext_autogen.h":
"132314c90c7f1a104d41f911316c169d",
"src/libGLESv2/entry_points_gl_1_autogen.cpp":
diff --git a/scripts/generate_entry_points.py b/scripts/generate_entry_points.py
index 8046bb1..511b436 100755
--- a/scripts/generate_entry_points.py
+++ b/scripts/generate_entry_points.py
@@ -180,7 +180,7 @@
{{
context->{name_lower_no_suffix}({internal_params});
}}
- ANGLE_CAPTURE_GL({name}, isCallValid, {capture_params});
+ ANGLE_CAPTURE_GL({name}, isCallValid, {gl_capture_params});
}}
else
{{
@@ -208,7 +208,7 @@
{{
returnValue = GetDefaultReturnValue<angle::EntryPoint::GL{name}, {return_type}>();
}}
- ANGLE_CAPTURE_GL({name}, isCallValid, {capture_params}, returnValue);
+ ANGLE_CAPTURE_GL({name}, isCallValid, {gl_capture_params}, returnValue);
}}
else
{{
@@ -233,6 +233,7 @@
ANGLE_EGL_VALIDATE_VOID(thread, {name}, {labeled_object}, {internal_params});
{name}(thread{comma_if_needed}{internal_params});
+ ANGLE_CAPTURE_EGL({name}, true, {egl_capture_params});
}}
"""
@@ -256,7 +257,9 @@
ANGLE_EGL_VALIDATE(thread, {name}, {labeled_object}, {return_type}{comma_if_needed}{internal_params});
- return {name}(thread{comma_if_needed}{internal_params});
+ {return_type} returnValue = {name}(thread{comma_if_needed}{internal_params});
+ ANGLE_CAPTURE_EGL({name}, true, {egl_capture_params}, returnValue);
+ return returnValue;
}}
"""
@@ -534,10 +537,10 @@
#include "common/PackedEnums.h"
#include "libANGLE/capture/FrameCapture.h"
-namespace gl
+namespace {namespace}
{{
{prototypes}
-}} // namespace gl
+}} // namespace {namespace}
#endif // LIBANGLE_CAPTURE_{annotation_upper}_AUTOGEN_H_
"""
@@ -562,13 +565,13 @@
using namespace angle;
-namespace gl
+namespace {namespace}
{{
{capture_methods}
-}} // namespace gl
+}} // namespace {namespace}
"""
-TEMPLATE_CAPTURE_METHOD_WITH_RETURN_VALUE = """
+TEMPLATE_CAPTURE_METHOD_WITH_RETURN_VALUE = """\
CallCapture Capture{short_name}({params_with_type}, {return_value_type_original} returnValue)
{{
ParamBuffer paramBuffer;
@@ -579,18 +582,18 @@
InitParamValue(ParamType::T{return_value_type_custom}, returnValue, &returnValueCapture.value);
paramBuffer.addReturnValue(std::move(returnValueCapture));
- return CallCapture(angle::EntryPoint::GL{short_name}, std::move(paramBuffer));
+ return CallCapture(angle::EntryPoint::{api_upper}{short_name}, std::move(paramBuffer));
}}
"""
-TEMPLATE_CAPTURE_METHOD_NO_RETURN_VALUE = """
+TEMPLATE_CAPTURE_METHOD_NO_RETURN_VALUE = """\
CallCapture Capture{short_name}({params_with_type})
{{
ParamBuffer paramBuffer;
{parameter_captures}
- return CallCapture(angle::EntryPoint::GL{short_name}, std::move(paramBuffer));
+ return CallCapture(angle::EntryPoint::{api_upper}{short_name}, std::move(paramBuffer));
}}
"""
@@ -881,6 +884,7 @@
EGL_SOURCE_INCLUDES = """\
#include "libGLESv2/entry_points_egl_autogen.h"
+#include "libANGLE/capture/capture_egl_autogen.h"
#include "libANGLE/entry_points_utils.h"
#include "libANGLE/validationEGL_autogen.h"
#include "libGLESv2/egl_stubs_autogen.h"
@@ -899,6 +903,7 @@
EGL_EXT_SOURCE_INCLUDES = """\
#include "libGLESv2/entry_points_egl_ext_autogen.h"
+#include "libANGLE/capture/capture_egl_autogen.h"
#include "libANGLE/entry_points_utils.h"
#include "libANGLE/validationEGL_autogen.h"
#include "libGLESv2/egl_ext_stubs_autogen.h"
@@ -1262,6 +1267,8 @@
"EGLSyncKHR": "egl::Sync *",
}
+CAPTURE_BLOCKLIST = ['eglGetProcAddress']
+
def is_aliasing_excepted(api, cmd_name):
return api == apis.GLES and cmd_name in ALIASING_EXCEPTIONS
@@ -1578,8 +1585,10 @@
", ".join(pass_params),
"comma_if_needed":
", " if len(params) > 0 else "",
- "capture_params":
+ "gl_capture_params":
", ".join(["context"] + internal_params),
+ "egl_capture_params":
+ ", ".join(["thread"] + internal_params),
"validate_params":
", ".join(["context"] + [entry_point_name] + internal_params),
"format_params":
@@ -1632,14 +1641,17 @@
def format_capture_method(api, command, cmd_name, proto, params, all_param_types,
capture_pointer_funcs, cmd_packed_gl_enums, packed_param_types):
+ context_param_typed = 'egl::Thread *thread' if api == apis.EGL else 'const State &glState'
+ context_param_name = 'thread' if api == apis.EGL else 'glState'
+
packed_gl_enums = get_packed_enums(api, cmd_packed_gl_enums, cmd_name, packed_param_types,
params)
params_with_type = get_internal_params(api, cmd_name,
- ["const State &glState", "bool isCallValid"] + params,
+ [context_param_typed, "bool isCallValid"] + params,
cmd_packed_gl_enums, packed_param_types)
params_just_name = ", ".join(
- ["glState", "isCallValid"] +
+ [context_param_name, "isCallValid"] +
[just_the_name_packed(param, packed_gl_enums) for param in params])
parameter_captures = []
@@ -1648,15 +1660,16 @@
param_name = just_the_name_packed(param, packed_gl_enums)
param_type = just_the_type_packed(param, packed_gl_enums).strip()
- # TODO(http://anglebug.com/4035: Add support for egl::AttributeMap.
if 'AttributeMap' in param_type:
- # egl::AttributeMap is too complex for ParamCapture to handle it.
+ capture = 'paramBuffer.addParam(CaptureAttributeMap(%s));' % param_name
+ parameter_captures += [capture]
continue
pointer_count = param_type.count("*")
capture_param_type = get_capture_param_type_name(param_type)
- if pointer_count > 0:
+ # With EGL capture, we don't currently support capturing specific pointer params.
+ if pointer_count > 0 and api != apis.EGL:
params = params_just_name
capture_name = "Capture%s_%s" % (strip_api_prefix(cmd_name), param_name)
capture = TEMPLATE_PARAMETER_CAPTURE_POINTER.format(
@@ -1680,23 +1693,32 @@
capture = TEMPLATE_PARAMETER_CAPTURE_VALUE.format(
name=param_name, type=capture_param_type)
- all_param_types.add(capture_param_type)
-
- parameter_captures += [capture]
+ # For specific methods we can't easily parse their types. Work around this by omitting
+ # parameter captures, but keeping the capture method as a mostly empty stub.
+ if cmd_name not in CAPTURE_BLOCKLIST:
+ all_param_types.add(capture_param_type)
+ parameter_captures += [capture]
return_type = proto[:-len(cmd_name)].strip()
+ capture_return_type = get_capture_param_type_name(return_type)
+ if capture_return_type != 'void':
+ if cmd_name in CAPTURE_BLOCKLIST:
+ params_with_type += ", %s returnValue" % capture_return_type
+ else:
+ all_param_types.add(capture_return_type)
format_args = {
+ "api_upper": "EGL" if api == apis.EGL else "GL",
"full_name": cmd_name,
"short_name": strip_api_prefix(cmd_name),
"params_with_type": params_with_type,
"params_just_name": params_just_name,
"parameter_captures": "\n ".join(parameter_captures),
"return_value_type_original": return_type,
- "return_value_type_custom": get_capture_param_type_name(return_type)
+ "return_value_type_custom": capture_return_type,
}
- if return_type == "void":
+ if return_type == "void" or cmd_name in CAPTURE_BLOCKLIST:
return TEMPLATE_CAPTURE_METHOD_NO_RETURN_VALUE.format(**format_args)
else:
return TEMPLATE_CAPTURE_METHOD_WITH_RETURN_VALUE.format(**format_args)
@@ -1781,8 +1803,9 @@
def format_capture_proto(api, cmd_name, proto, params, cmd_packed_gl_enums, packed_param_types):
+ context_param_typed = 'egl::Thread *thread' if api == apis.EGL else 'const State &glState'
internal_params = get_internal_params(api, cmd_name,
- ["const State &glState", "bool isCallValid"] + params,
+ [context_param_typed, "bool isCallValid"] + params,
cmd_packed_gl_enums, packed_param_types)
return_type = proto[:-len(cmd_name)].strip()
if return_type != "void":
@@ -1827,6 +1850,7 @@
self.validation_protos.append(
format_validation_proto(self.api, cmd_name, proto_text, param_text,
cmd_packed_enums, packed_param_types))
+
self.capture_protos.append(
format_capture_proto(self.api, cmd_name, proto_text, param_text, cmd_packed_enums,
packed_param_types))
@@ -2103,15 +2127,19 @@
TEMPLATE_GL_VALIDATION_HEADER)
-def write_capture_header(annotation, comment, protos, capture_pointer_funcs):
+def write_capture_header(api, annotation, comment, protos, capture_pointer_funcs):
+ ns = 'egl' if api == apis.EGL else 'gl'
+ combined_protos = ["\n// Method Captures\n"] + protos
+ if capture_pointer_funcs:
+ combined_protos += ["\n// Parameter Captures\n"] + capture_pointer_funcs
content = TEMPLATE_CAPTURE_HEADER.format(
script_name=os.path.basename(sys.argv[0]),
- data_source_name="gl.xml and gl_angle_ext.xml",
+ data_source_name="%s.xml and %s_angle_ext.xml" % (ns, ns),
annotation_lower=annotation.lower(),
annotation_upper=annotation.upper(),
comment=comment,
- prototypes="\n".join(["\n// Method Captures\n"] + protos + ["\n// Parameter Captures\n"] +
- capture_pointer_funcs))
+ namespace=ns,
+ prototypes="\n".join(combined_protos))
path = path_to(os.path.join("libANGLE", "capture"), "capture_%s_autogen.h" % annotation)
@@ -2120,13 +2148,15 @@
out.close()
-def write_capture_source(annotation_with_dash, annotation_no_dash, comment, capture_methods):
+def write_capture_source(api, annotation_with_dash, annotation_no_dash, comment, capture_methods):
+ ns = 'egl' if api == apis.EGL else 'gl'
content = TEMPLATE_CAPTURE_SOURCE.format(
script_name=os.path.basename(sys.argv[0]),
- data_source_name="gl.xml and gl_angle_ext.xml",
+ data_source_name="%s.xml and %s_angle_ext.xml" % (ns, ns),
annotation_with_dash=annotation_with_dash,
annotation_no_dash=annotation_no_dash,
comment=comment,
+ namespace=ns,
capture_methods="\n".join(capture_methods))
path = path_to(
@@ -2138,7 +2168,8 @@
def is_packed_enum_param_type(param_type):
- return param_type[0:2] != "GL" and "void" not in param_type
+ return not param_type.startswith("GL") and not param_type.startswith(
+ "EGL") and "void" not in param_type
def add_namespace(param_type):
@@ -2198,16 +2229,14 @@
def get_gl_param_type_type(param_type):
- if not is_packed_enum_param_type(param_type):
- return get_gl_pointer_type(param_type)
- else:
+ if is_packed_enum_param_type(param_type):
base_type = param_type.replace("Pointer", "").replace("Const", "")
if is_id_type(base_type):
replace_type = "GLuint"
else:
replace_type = "GLenum"
param_type = param_type.replace(base_type, replace_type)
- return get_gl_pointer_type(param_type)
+ return get_gl_pointer_type(param_type)
def get_param_type_union_name(param_type):
@@ -2672,6 +2701,8 @@
'../src/libANGLE/Context_gles_3_1_autogen.h',
'../src/libANGLE/Context_gles_3_2_autogen.h',
'../src/libANGLE/Context_gles_ext_autogen.h',
+ '../src/libANGLE/capture/capture_egl_autogen.cpp',
+ '../src/libANGLE/capture/capture_egl_autogen.h',
'../src/libANGLE/capture/capture_gl_1_autogen.cpp',
'../src/libANGLE/capture/capture_gl_1_autogen.h',
'../src/libANGLE/capture/capture_gl_2_autogen.cpp',
@@ -2829,9 +2860,9 @@
write_gl_validation_header(validation_annotation, "ES %s" % comment, eps.validation_protos,
"gl.xml and gl_angle_ext.xml")
- write_capture_header('gles_' + version, comment, eps.capture_protos,
+ write_capture_header(apis.GLES, 'gles_' + version, comment, eps.capture_protos,
eps.capture_pointer_funcs)
- write_capture_source('gles_' + version, validation_annotation, comment,
+ write_capture_source(apis.GLES, 'gles_' + version, validation_annotation, comment,
eps.capture_methods)
# After we finish with the main entry points, we process the extensions.
@@ -2970,9 +3001,10 @@
source_includes, "libGLESv2", "gl.xml")
# Capture files
- write_capture_header(annotation.lower(), name, capture_protos, capture_pointer_funcs)
- write_capture_source(annotation.lower(), 'GL' + str(major_version) + '_autogen', name,
- capture_defs)
+ write_capture_header(apis.GL, annotation.lower(), name, capture_protos,
+ capture_pointer_funcs)
+ write_capture_source(apis.GL, annotation.lower(), 'GL' + str(major_version) + '_autogen',
+ name, capture_defs)
# Validation files
write_gl_validation_header("GL%s" % major_version, name, validation_protos, "gl.xml")
@@ -3088,6 +3120,8 @@
libegl_ep_defs = []
libegl_windows_def_exports = []
egl_commands = []
+ egl_capture_protos = []
+ egl_capture_methods = []
for major_version, minor_version in registry_xml.EGL_VERSIONS:
version = "%d_%d" % (major_version, minor_version)
@@ -3116,6 +3150,8 @@
libegl_ep_defs += [comment] + eps.export_defs
egl_validation_protos += [comment] + eps.validation_protos
libegl_windows_def_exports += [win_def_comment] + get_exports(eglxml.commands[version])
+ egl_capture_protos += eps.capture_protos
+ egl_capture_methods += eps.capture_methods
egl_decls.append("} // extern \"C\"")
egl_defs.append("} // extern \"C\"")
@@ -3151,6 +3187,8 @@
libegl_ep_defs += [comment] + eps.export_defs
egl_validation_protos += [comment] + eps.validation_protos
libegl_windows_def_exports += [win_def_comment] + get_exports(ext_cmd_names)
+ egl_capture_protos += eps.capture_protos
+ egl_capture_methods += eps.capture_methods
# Avoid writing out entry points defined by a prior extension.
for dupe in eglxml.ext_dupes[extension_name]:
@@ -3170,6 +3208,9 @@
EGL_EXT_STUBS_HEADER_PATH, eglxml.all_commands, egl_ext_commands,
EGLEntryPoints.get_packed_enums(), EGL_PACKED_TYPES)
+ write_capture_header(apis.EGL, 'egl', 'EGL', egl_capture_protos, [])
+ write_capture_source(apis.EGL, 'egl', 'EGL', 'all', egl_capture_methods)
+
wglxml = registry_xml.RegistryXML('wgl.xml')
name_prefix = "WGL_VERSION_"
@@ -3200,8 +3241,9 @@
write_gl_validation_header("ESEXT", "ES extension", ext_validation_protos,
"gl.xml and gl_angle_ext.xml")
- write_capture_header("gles_ext", "extension", ext_capture_protos, ext_capture_pointer_funcs)
- write_capture_source("gles_ext", "ESEXT", "extension", ext_capture_methods)
+ write_capture_header(apis.GLES, "gles_ext", "extension", ext_capture_protos,
+ ext_capture_pointer_funcs)
+ write_capture_source(apis.GLES, "gles_ext", "ESEXT", "extension", ext_capture_methods)
write_context_api_decls(glesdecls, "gles")
write_context_api_decls(desktop_gl_decls, "gl")
diff --git a/src/libANGLE/AttributeMap.cpp b/src/libANGLE/AttributeMap.cpp
index 6b56aee..e0c82be 100644
--- a/src/libANGLE/AttributeMap.cpp
+++ b/src/libANGLE/AttributeMap.cpp
@@ -129,6 +129,7 @@
{
AttributeMap map;
map.mIntPointer = attributes;
+ map.mMapType = AttributeMapType::Int;
return map;
}
@@ -137,6 +138,7 @@
{
AttributeMap map;
map.mAttribPointer = attributes;
+ map.mMapType = AttributeMapType::Attrib;
return map;
}
diff --git a/src/libANGLE/AttributeMap.h b/src/libANGLE/AttributeMap.h
index 60ba913..ceecce6 100644
--- a/src/libANGLE/AttributeMap.h
+++ b/src/libANGLE/AttributeMap.h
@@ -24,6 +24,13 @@
using AttributeValidationFunc =
std::function<bool(const ValidationContext *, const Display *, EGLAttrib)>;
+enum AttributeMapType
+{
+ Invalid,
+ Attrib,
+ Int,
+};
+
class AttributeMap final
{
public:
@@ -76,6 +83,8 @@
static AttributeMap CreateFromIntArray(const EGLint *attributes);
static AttributeMap CreateFromAttribArray(const EGLAttrib *attributes);
+ AttributeMapType getType() const { return mMapType; }
+
private:
bool isValidated() const;
@@ -94,6 +103,7 @@
mutable const EGLint *mIntPointer = nullptr;
mutable const EGLAttrib *mAttribPointer = nullptr;
mutable Map mValidatedAttributes;
+ mutable AttributeMapType mMapType = AttributeMapType::Invalid;
};
} // namespace egl
diff --git a/src/libANGLE/capture/FrameCapture.cpp b/src/libANGLE/capture/FrameCapture.cpp
index 977f571..0fabd25 100644
--- a/src/libANGLE/capture/FrameCapture.cpp
+++ b/src/libANGLE/capture/FrameCapture.cpp
@@ -32,7 +32,7 @@
#include "libANGLE/Shader.h"
#include "libANGLE/Surface.h"
#include "libANGLE/VertexArray.h"
-#include "libANGLE/capture/capture_egl.h"
+#include "libANGLE/capture/capture_egl_autogen.h"
#include "libANGLE/capture/capture_gles_1_0_autogen.h"
#include "libANGLE/capture/capture_gles_2_0_autogen.h"
#include "libANGLE/capture/capture_gles_3_0_autogen.h"
@@ -3843,11 +3843,11 @@
// Create the image on demand
egl::Image *image = nullptr;
- Capture(setupCalls,
- CaptureEGLCreateImage(nullptr, context, EGL_GL_TEXTURE_2D_KHR,
- reinterpret_cast<EGLClientBuffer>(
- static_cast<GLuint64>(stagingTexId.value)),
- retrievedAttribs, image));
+ Capture(setupCalls, egl::CaptureCreateImage(
+ nullptr, true, nullptr, context, EGL_GL_TEXTURE_2D_KHR,
+ reinterpret_cast<EGLClientBuffer>(
+ static_cast<GLuint64>(stagingTexId.value)),
+ retrievedAttribs, image));
// Pass the eglImage to the texture that is bound to GL_TEXTURE_EXTERNAL_OES
// target
@@ -5077,6 +5077,22 @@
// - Same as uniforms, the value can vary, asking above GL_ACTIVE_ATTRIBUTES is an error
return true;
+ case EntryPoint::EGLChooseConfig:
+ case EntryPoint::EGLGetProcAddress:
+ case EntryPoint::EGLGetConfigAttrib:
+ case EntryPoint::EGLGetConfigs:
+ case EntryPoint::EGLGetSyncAttrib:
+ case EntryPoint::EGLGetSyncAttribKHR:
+ case EntryPoint::EGLQuerySurface:
+ // Skip these calls because:
+ // - Some EGL types and pointer parameters aren't yet implemented in EGL capture.
+ return true;
+
+ case EntryPoint::EGLSwapBuffers:
+ // Skip these calls because:
+ // - Swap is handled specially by the trace harness.
+ return true;
+
default:
break;
}
@@ -6235,6 +6251,22 @@
captureClientArraySnapshot(context, indexRange.end + 1, instanceCount);
}
+template <typename AttribT, typename FactoryT>
+void CreateEGLImagePreCallUpdate(const CallCapture &call,
+ ResourceTracker &resourceTracker,
+ ParamType paramType,
+ FactoryT factory)
+{
+ GLeglImageOES image = call.params.getReturnValue().value.voidPointerVal;
+ const ParamCapture ¶m = call.params.getParam("attrib_list", paramType, 4);
+ const AttribT *attribs =
+ param.data.empty() ? nullptr : reinterpret_cast<const AttribT *>(param.data[0].data());
+ egl::AttributeMap attributeMap = factory(attribs);
+ attributeMap.initializeWithoutValidation();
+ resourceTracker.getImageToAttribTable().insert(
+ std::pair<void *, egl::AttributeMap>(image, attributeMap));
+}
+
void FrameCaptureShared::maybeCapturePreCallUpdates(
const gl::Context *context,
CallCapture &call,
@@ -6781,15 +6813,16 @@
}
case EntryPoint::EGLCreateImage:
+ {
+ CreateEGLImagePreCallUpdate<EGLAttrib>(call, mResourceTracker,
+ ParamType::TEGLAttribPointer,
+ egl::AttributeMap::CreateFromAttribArray);
+ break;
+ }
case EntryPoint::EGLCreateImageKHR:
{
- GLeglImageOES image = call.params.getReturnValue().value.voidPointerVal;
- const EGLAttrib *attribs = reinterpret_cast<const EGLAttrib *>(
- call.params.getParam("attrib_list", ParamType::TGLint64Pointer, 4).data[0].data());
- egl::AttributeMap attributeMap = egl::AttributeMap::CreateFromAttribArray(attribs);
- attributeMap.initializeWithoutValidation();
- mResourceTracker.getImageToAttribTable().insert(
- std::pair<void *, egl::AttributeMap>(image, attributeMap));
+ CreateEGLImagePreCallUpdate<EGLint>(call, mResourceTracker, ParamType::TEGLintPointer,
+ egl::AttributeMap::CreateFromIntArray);
break;
}
@@ -7977,9 +8010,8 @@
out << proto << "\n";
out << "{\n";
- out << " gContextMap[0] = EGL_NO_CONTEXT;\n";
out << " EGLContext context = eglGetCurrentContext();\n";
- out << " gContextMap[" << context->id().value << "] = context;\n";
+ out << " gContextMap[" << reinterpret_cast<uintptr_t>(context) << "ul] = context;\n";
out << "\n";
// Setup all of the shared objects.
@@ -8010,8 +8042,8 @@
// beginning of the setup call stream.
out << " EGLContext context" << shareContext->id()
<< " = eglCreateContext(nullptr, nullptr, context, nullptr);\n";
- out << " gContextMap[" << shareContext->id().value << "] = context"
- << shareContext->id() << ";\n";
+ out << " gContextMap[" << reinterpret_cast<uintptr_t>(shareContext)
+ << "ul] = context" << shareContext->id() << ";\n";
// The SetupReplayContextXX() calls only exist if this is a mid-execution capture
// and we can only call them if they exist, so only output the calls if this is a
// MEC.
@@ -8136,7 +8168,8 @@
bodyStream << " // Switching contexts for non-shared Reset\n"
<< " eglMakeCurrent("
<< "EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE, "
- << "gContextMap[" << contextID.value << "]);\n\n";
+ << "gContextMap[" << reinterpret_cast<uintptr_t>(context)
+ << "ul]);\n\n";
}
// Then append the Reset calls
@@ -8716,10 +8749,8 @@
const CallCapture &call,
EGLDEBUGPROCKHR value)
{
- // The value isn't actually useful, but this fixes MSVC compile errors:
- // error: implicit conversion between pointer-to-function and pointer-to-object is a Microsoft
- // extension [-Werror,-Wmicrosoft-cast]
- os << reinterpret_cast<void *>(value);
+ // It's not necessary to implement correct capture for these types.
+ os << "0";
}
template <>
@@ -8727,10 +8758,8 @@
const CallCapture &call,
EGLGetBlobFuncANDROID value)
{
- // The value isn't actually useful, but this fixes MSVC compile errors:
- // error: implicit conversion between pointer-to-function and pointer-to-object is a Microsoft
- // extension [-Werror,-Wmicrosoft-cast]
- os << reinterpret_cast<void *>(value);
+ // It's not necessary to implement correct capture for these types.
+ os << "0";
}
template <>
@@ -8738,10 +8767,96 @@
const CallCapture &call,
EGLSetBlobFuncANDROID value)
{
- // The value isn't actually useful, but this fixes MSVC compile errors:
- // error: implicit conversion between pointer-to-function and pointer-to-object is a Microsoft
- // extension [-Werror,-Wmicrosoft-cast]
- os << reinterpret_cast<void *>(value);
+ // It's not necessary to implement correct capture for these types.
+ os << "0";
+}
+
+template <>
+void WriteParamValueReplay<ParamType::Tegl_ConfigPointer>(std::ostream &os,
+ const CallCapture &call,
+ egl::Config *value)
+{
+ os << "EGL_NO_CONFIG_KHR";
+}
+
+template <>
+void WriteParamValueReplay<ParamType::Tegl_SurfacePointer>(std::ostream &os,
+ const CallCapture &call,
+ egl::Surface *value)
+{
+ if (value == nullptr)
+ {
+ os << "EGL_NO_SURFACE";
+ }
+ else
+ {
+ os << "gSurfaceMap[" << reinterpret_cast<uintptr_t>(value) << "ul]";
+ }
+}
+
+template <>
+void WriteParamValueReplay<ParamType::Tgl_ContextPointer>(std::ostream &os,
+ const CallCapture &call,
+ gl::Context *value)
+{
+ if (value == nullptr)
+ {
+ os << "EGL_NO_CONTEXT";
+ }
+ else
+ {
+ os << "gContextMap[" << reinterpret_cast<uintptr_t>(value) << "ul]";
+ }
+}
+
+template <>
+void WriteParamValueReplay<ParamType::Tegl_DisplayPointer>(std::ostream &os,
+ const CallCapture &call,
+ egl::Display *value)
+{
+ os << "EGL_NO_DISPLAY";
+}
+
+template <>
+void WriteParamValueReplay<ParamType::Tegl_ImagePointer>(std::ostream &os,
+ const CallCapture &call,
+ egl::Image *value)
+{
+ uint64_t pointerValue = reinterpret_cast<uint64_t>(value);
+ os << "gEGLImageMap[" << pointerValue << "ul]";
+}
+
+template <>
+void WriteParamValueReplay<ParamType::TEGLClientBuffer>(std::ostream &os,
+ const CallCapture &call,
+ EGLClientBuffer value)
+{
+ const ParamCapture &targetParam = call.params.getParam("target", ParamType::TEGLenum, 2);
+ os << "GetClientBuffer(" << targetParam.value.EGLenumVal << ", " << value << ")";
+}
+
+template <>
+void WriteParamValueReplay<ParamType::Tegl_SyncPointer>(std::ostream &os,
+ const CallCapture &call,
+ egl::Sync *value)
+{
+ os << "EGL_NO_SYNC_KHR";
+}
+
+template <>
+void WriteParamValueReplay<ParamType::TEGLTime>(std::ostream &os,
+ const CallCapture &call,
+ EGLTime value)
+{
+ os << value << "ul";
+}
+
+template <>
+void WriteParamValueReplay<ParamType::TEGLTimeKHR>(std::ostream &os,
+ const CallCapture &call,
+ EGLTimeKHR value)
+{
+ os << value << "ul";
}
// ReplayWriter implementation.
@@ -9031,3 +9146,62 @@
return results;
}
} // namespace angle
+
+namespace egl
+{
+angle::ParamCapture CaptureAttributeMap(const egl::AttributeMap &attribMap)
+{
+ switch (attribMap.getType())
+ {
+ case AttributeMapType::Attrib:
+ {
+ angle::ParamCapture paramCapture("attrib_list", angle::ParamType::TEGLAttribPointer);
+ if (attribMap.isEmpty())
+ {
+ paramCapture.value.EGLAttribPointerVal = nullptr;
+ }
+ else
+ {
+ std::vector<EGLAttrib> attribs;
+ for (const auto &[key, value] : attribMap)
+ {
+ attribs.push_back(key);
+ attribs.push_back(value);
+ }
+ attribs.push_back(EGL_NONE);
+
+ angle::CaptureMemory(attribs.data(), attribs.size() * sizeof(EGLAttrib),
+ ¶mCapture);
+ }
+ return paramCapture;
+ }
+
+ case AttributeMapType::Int:
+ {
+ angle::ParamCapture paramCapture("attrib_list", angle::ParamType::TEGLintPointer);
+ if (attribMap.isEmpty())
+ {
+ paramCapture.value.EGLintPointerVal = nullptr;
+ }
+ else
+ {
+ std::vector<EGLint> attribs;
+ for (const auto &[key, value] : attribMap)
+ {
+ attribs.push_back(static_cast<EGLint>(key));
+ attribs.push_back(static_cast<EGLint>(value));
+ }
+ attribs.push_back(EGL_NONE);
+
+ angle::CaptureMemory(attribs.data(), attribs.size() * sizeof(EGLint),
+ ¶mCapture);
+ }
+ return paramCapture;
+ }
+
+ default:
+ UNREACHABLE();
+ return angle::ParamCapture();
+ }
+}
+} // namespace egl
diff --git a/src/libANGLE/capture/FrameCapture.h b/src/libANGLE/capture/FrameCapture.h
index 6c94ad6..7b2241a 100644
--- a/src/libANGLE/capture/FrameCapture.h
+++ b/src/libANGLE/capture/FrameCapture.h
@@ -13,6 +13,7 @@
#include "common/PackedEnums.h"
#include "common/system_utils.h"
#include "libANGLE/Context.h"
+#include "libANGLE/Thread.h"
#include "libANGLE/angletypes.h"
#include "libANGLE/capture/frame_capture_utils_autogen.h"
#include "libANGLE/entry_points_utils.h"
@@ -882,10 +883,10 @@
};
template <typename CaptureFuncT, typename... ArgsT>
-void CaptureCallToFrameCapture(CaptureFuncT captureFunc,
- bool isCallValid,
- gl::Context *context,
- ArgsT... captureParams)
+void CaptureGLCallToFrameCapture(CaptureFuncT captureFunc,
+ bool isCallValid,
+ gl::Context *context,
+ ArgsT... captureParams)
{
FrameCaptureShared *frameCaptureShared = context->getShareGroup()->getFrameCaptureShared();
if (!frameCaptureShared->isCapturing())
@@ -894,10 +895,32 @@
}
CallCapture call = captureFunc(context->getState(), isCallValid, captureParams...);
-
frameCaptureShared->captureCall(context, std::move(call), isCallValid);
}
+template <typename CaptureFuncT, typename... ArgsT>
+void CaptureEGLCallToFrameCapture(CaptureFuncT captureFunc,
+ bool isCallValid,
+ egl::Thread *thread,
+ ArgsT... captureParams)
+{
+ gl::Context *context = thread->getContext();
+ if (!context)
+ {
+ return;
+ }
+
+ angle::FrameCaptureShared *frameCaptureShared =
+ context->getShareGroup()->getFrameCaptureShared();
+ if (!frameCaptureShared->isCapturing())
+ {
+ return;
+ }
+
+ angle::CallCapture call = captureFunc(thread, isCallValid, captureParams...);
+ frameCaptureShared->captureCall(context, std::move(call), true);
+}
+
template <typename T>
void ParamBuffer::addValueParam(const char *paramName, ParamType paramType, T paramValue)
{
@@ -1149,6 +1172,11 @@
egl::Display *value);
template <>
+void WriteParamValueReplay<ParamType::Tegl_ImagePointer>(std::ostream &os,
+ const CallCapture &call,
+ egl::Image *value);
+
+template <>
void WriteParamValueReplay<ParamType::Tegl_SurfacePointer>(std::ostream &os,
const CallCapture &call,
egl::Surface *value);
@@ -1182,6 +1210,26 @@
const CallCapture &call,
egl::Surface *value);
+template <>
+void WriteParamValueReplay<ParamType::TEGLClientBuffer>(std::ostream &os,
+ const CallCapture &call,
+ EGLClientBuffer value);
+
+template <>
+void WriteParamValueReplay<ParamType::Tegl_SyncPointer>(std::ostream &os,
+ const CallCapture &call,
+ egl::Sync *value);
+
+template <>
+void WriteParamValueReplay<ParamType::TEGLTime>(std::ostream &os,
+ const CallCapture &call,
+ EGLTime value);
+
+template <>
+void WriteParamValueReplay<ParamType::TEGLTimeKHR>(std::ostream &os,
+ const CallCapture &call,
+ EGLTimeKHR value);
+
// General fallback for any unspecific type.
template <ParamType ParamT, typename T>
void WriteParamValueReplay(std::ostream &os, const CallCapture &call, T value)
@@ -1205,4 +1253,9 @@
}
}
+namespace egl
+{
+angle::ParamCapture CaptureAttributeMap(const egl::AttributeMap &attribMap);
+} // namespace egl
+
#endif // LIBANGLE_FRAME_CAPTURE_H_
diff --git a/src/libANGLE/capture/capture_egl.cpp b/src/libANGLE/capture/capture_egl.cpp
deleted file mode 100644
index 89314a9..0000000
--- a/src/libANGLE/capture/capture_egl.cpp
+++ /dev/null
@@ -1,246 +0,0 @@
-//
-// Copyright 2022 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.h:
-// EGL capture functions
-//
-
-#include "libANGLE/capture/capture_egl.h"
-#include "libANGLE/Surface.h"
-#include "libANGLE/capture/FrameCapture.h"
-#include "libANGLE/capture/frame_capture_utils.h"
-#include "libANGLE/capture/gl_enum_utils_autogen.h"
-
-#define USE_SYSTEM_ZLIB
-#include "compression_utils_portable.h"
-
-#if !ANGLE_CAPTURE_ENABLED
-# error Frame capture must be enabled to include this file.
-#endif // !ANGLE_CAPTURE_ENABLED
-
-namespace angle
-{
-template <>
-void WriteParamValueReplay<ParamType::Tgl_ContextPointer>(std::ostream &os,
- const CallCapture &call,
- gl::Context *context)
-{
- if (context == nullptr)
- {
- os << "EGL_NO_CONTEXT";
- }
- else
- {
- os << "gContextMap[" << context->id().value << "]";
- }
-}
-
-template <>
-void WriteParamValueReplay<ParamType::Tegl_DisplayPointer>(std::ostream &os,
- const CallCapture &call,
- egl::Display *display)
-{
- os << "EGL_NO_DISPLAY";
-}
-
-template <>
-void WriteParamValueReplay<ParamType::Tegl_ConfigPointer>(std::ostream &os,
- const CallCapture &call,
- egl::Config *config)
-{
- os << "EGL_NO_CONFIG_KHR";
-}
-
-template <>
-void WriteParamValueReplay<ParamType::Tegl_SurfacePointer>(std::ostream &os,
- const CallCapture &call,
- egl::Surface *surface)
-{
- if (surface == nullptr)
- {
- os << "EGL_NO_SURFACE";
- }
- else
- {
- os << "gSurfaceMap[" << reinterpret_cast<uintptr_t>(surface) << "]";
- }
-}
-
-template <>
-void WriteParamValueReplay<ParamType::TEGLClientBuffer>(std::ostream &os,
- const CallCapture &call,
- EGLClientBuffer value)
-{
- const auto &targetParam = call.params.getParam("target", ParamType::TEGLenum, 2);
- os << "GetClientBuffer(" << targetParam.value.EGLenumVal << ", " << value << ")";
-}
-
-} // namespace angle
-
-namespace egl
-{
-
-static angle::ParamCapture CaptureAttributeMap(const egl::AttributeMap &attribMap)
-{
- std::vector<EGLAttrib> attribs;
- for (const auto &[key, value] : attribMap)
- {
- attribs.push_back(key);
- attribs.push_back(value);
- }
- attribs.push_back(EGL_NONE);
-
- angle::ParamCapture paramCapture("attrib_list", angle::ParamType::TGLint64Pointer);
- angle::CaptureMemory(attribs.data(), attribs.size() * sizeof(EGLAttrib), ¶mCapture);
- return paramCapture;
-}
-
-static angle::ParamCapture CaptureAttributeMapInt(const egl::AttributeMap &attribMap)
-{
- std::vector<EGLint> attribs;
- for (const auto &[key, value] : attribMap)
- {
- attribs.push_back(static_cast<EGLint>(key));
- attribs.push_back(static_cast<EGLint>(value));
- }
- attribs.push_back(EGL_NONE);
-
- angle::ParamCapture paramCapture("attrib_list", angle::ParamType::TGLintPointer);
- angle::CaptureMemory(attribs.data(), attribs.size() * sizeof(EGLint), ¶mCapture);
- return paramCapture;
-}
-
-angle::CallCapture CaptureCreateNativeClientBufferANDROID(const egl::AttributeMap &attribMap,
- EGLClientBuffer eglClientBuffer)
-{
- angle::ParamBuffer paramBuffer;
- paramBuffer.addParam(CaptureAttributeMap(attribMap));
-
- angle::ParamCapture retval;
- angle::SetParamVal<angle::ParamType::TEGLClientBuffer, EGLClientBuffer>(eglClientBuffer,
- &retval.value);
- paramBuffer.addReturnValue(std::move(retval));
-
- return angle::CallCapture(angle::EntryPoint::EGLCreateNativeClientBufferANDROID,
- std::move(paramBuffer));
-}
-
-angle::CallCapture CaptureEGLCreateImage(egl::Display *display,
- gl::Context *context,
- EGLenum target,
- EGLClientBuffer buffer,
- const egl::AttributeMap &attributes,
- egl::Image *image)
-{
- angle::ParamBuffer paramBuffer;
-
- // The EGL display will be queried directly in the emitted code
- // so this is actually just a place holder
- paramBuffer.addValueParam("display", angle::ParamType::Tegl_DisplayPointer, display);
-
- // In CaptureMidExecutionSetup and FrameCaptureShared::captureCall
- // we capture the actual context ID (via CaptureMakeCurrent),
- // so we have to do the same here.
- paramBuffer.addValueParam("context", angle::ParamType::Tgl_ContextPointer, context);
-
- paramBuffer.addEnumParam("target", gl::GLESEnum::AllEnums, angle::ParamType::TEGLenum, target);
-
- angle::ParamCapture paramsClientBuffer("buffer", angle::ParamType::TEGLClientBuffer);
- uint64_t bufferID = reinterpret_cast<uintptr_t>(buffer);
- angle::SetParamVal<angle::ParamType::TGLuint64>(bufferID, ¶msClientBuffer.value);
- paramBuffer.addParam(std::move(paramsClientBuffer));
-
- angle::ParamCapture paramsAttr = CaptureAttributeMap(attributes);
- paramBuffer.addParam(std::move(paramsAttr));
-
- angle::ParamCapture retval;
- angle::SetParamVal<angle::ParamType::TGLeglImageOES, GLeglImageOES>(image, &retval.value);
- paramBuffer.addReturnValue(std::move(retval));
-
- return angle::CallCapture(angle::EntryPoint::EGLCreateImage, std::move(paramBuffer));
-}
-
-angle::CallCapture CaptureEGLDestroyImage(egl::Display *display, egl::Image *image)
-{
- angle::ParamBuffer paramBuffer;
- paramBuffer.addValueParam("display", angle::ParamType::Tegl_DisplayPointer, display);
-
- angle::ParamCapture paramImage("image", angle::ParamType::TGLeglImageOES);
- angle::SetParamVal<angle::ParamType::TGLeglImageOES, GLeglImageOES>(image, ¶mImage.value);
- paramBuffer.addParam(std::move(paramImage));
-
- return angle::CallCapture(angle::EntryPoint::EGLDestroyImage, std::move(paramBuffer));
-}
-
-angle::CallCapture CaptureEGLCreatePbufferSurface(egl::Display *display,
- egl::Config *config,
- const AttributeMap &attrib_list,
- egl::Surface *surface)
-{
- angle::ParamBuffer paramBuffer;
- paramBuffer.addValueParam("display", angle::ParamType::Tegl_DisplayPointer, display);
- paramBuffer.addValueParam("config", angle::ParamType::Tegl_ConfigPointer, config);
-
- angle::ParamCapture paramsAttr = CaptureAttributeMapInt(attrib_list);
- paramBuffer.addParam(std::move(paramsAttr));
-
- angle::ParamCapture retval;
- angle::SetParamVal<angle::ParamType::Tegl_SurfacePointer>(surface, &retval.value);
- paramBuffer.addReturnValue(std::move(retval));
-
- return angle::CallCapture(angle::EntryPoint::EGLCreatePbufferSurface, std::move(paramBuffer));
-}
-angle::CallCapture CaptureEGLDestroySurface(egl::Display *display, egl::Surface *surface)
-{
- angle::ParamBuffer paramBuffer;
- paramBuffer.addValueParam("display", angle::ParamType::Tegl_DisplayPointer, display);
- paramBuffer.addValueParam("surface", angle::ParamType::Tegl_SurfacePointer, surface);
-
- return angle::CallCapture(angle::EntryPoint::EGLDestroySurface, std::move(paramBuffer));
-}
-
-static angle::CallCapture CaptureEGLBindOrReleaseImage(egl::Display *display,
- egl::Surface *surface,
- EGLint buffer,
- angle::EntryPoint entryPoint)
-{
- angle::ParamBuffer paramBuffer;
- paramBuffer.addValueParam("display", angle::ParamType::Tegl_DisplayPointer, display);
- paramBuffer.addValueParam("surface", angle::ParamType::Tegl_SurfacePointer, surface);
- paramBuffer.addValueParam("buffer", angle::ParamType::TEGLint, buffer);
- return angle::CallCapture(entryPoint, std::move(paramBuffer));
-}
-
-angle::CallCapture CaptureEGLBindTexImage(egl::Display *display,
- egl::Surface *surface,
- EGLint buffer)
-{
- return CaptureEGLBindOrReleaseImage(display, surface, buffer,
- angle::EntryPoint::EGLBindTexImage);
-}
-
-angle::CallCapture CaptureEGLReleaseTexImage(egl::Display *display,
- egl::Surface *surface,
- EGLint buffer)
-{
- return CaptureEGLBindOrReleaseImage(display, surface, buffer,
- angle::EntryPoint::EGLReleaseTexImage);
-}
-
-angle::CallCapture CaptureEGLMakeCurrent(egl::Display *display,
- Surface *drawSurface,
- Surface *readSurface,
- gl::Context *context)
-{
- angle::ParamBuffer paramBuffer;
- paramBuffer.addValueParam("display", angle::ParamType::Tegl_DisplayPointer, display);
- paramBuffer.addValueParam("draw", angle::ParamType::Tegl_SurfacePointer, drawSurface);
- paramBuffer.addValueParam("read", angle::ParamType::Tegl_SurfacePointer, readSurface);
- paramBuffer.addValueParam("context", angle::ParamType::Tgl_ContextPointer, context);
-
- return angle::CallCapture(angle::EntryPoint::EGLMakeCurrent, std::move(paramBuffer));
-}
-
-} // namespace egl
diff --git a/src/libANGLE/capture/capture_egl.h b/src/libANGLE/capture/capture_egl.h
deleted file mode 100644
index 13f25a0..0000000
--- a/src/libANGLE/capture/capture_egl.h
+++ /dev/null
@@ -1,77 +0,0 @@
-//
-// Copyright 2022 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.h:
-// EGL capture functions
-//
-
-#ifndef LIBANGLE_CAPTURE_EGL_H_
-#define LIBANGLE_CAPTURE_EGL_H_
-
-#include "libANGLE/Context.h"
-#include "libANGLE/Thread.h"
-#include "libANGLE/capture/FrameCapture.h"
-
-namespace gl
-{
-enum class GLenumGroup;
-}
-
-namespace egl
-{
-
-template <typename CaptureFuncT, typename... ArgsT>
-void CaptureCallToCaptureEGL(CaptureFuncT captureFunc, egl::Thread *thread, ArgsT... captureParams)
-{
- gl::Context *context = thread->getContext();
- if (!context)
- {
- return;
- }
-
- angle::FrameCaptureShared *frameCaptureShared =
- context->getShareGroup()->getFrameCaptureShared();
- if (!frameCaptureShared->isCapturing())
- {
- return;
- }
-
- angle::CallCapture call = captureFunc(captureParams...);
-
- frameCaptureShared->captureCall(context, std::move(call), true);
-}
-
-angle::CallCapture CaptureCreateNativeClientBufferANDROID(const egl::AttributeMap &attribMap,
- EGLClientBuffer eglClientBuffer);
-angle::CallCapture CaptureEGLCreateImage(egl::Display *display,
- gl::Context *context,
- EGLenum target,
- EGLClientBuffer buffer,
- const egl::AttributeMap &attributes,
- egl::Image *image);
-angle::CallCapture CaptureEGLDestroyImage(egl::Display *display, egl::Image *image);
-
-angle::CallCapture CaptureEGLCreatePbufferSurface(egl::Display *display,
- egl::Config *config,
- const AttributeMap &attrib_list,
- egl::Surface *surface);
-
-angle::CallCapture CaptureEGLDestroySurface(egl::Display *display, Surface *surface);
-
-angle::CallCapture CaptureEGLBindTexImage(egl::Display *display,
- egl::Surface *surface,
- EGLint buffer);
-
-angle::CallCapture CaptureEGLReleaseTexImage(egl::Display *display,
- egl::Surface *surface,
- EGLint buffer);
-
-angle::CallCapture CaptureEGLMakeCurrent(egl::Display *display,
- Surface *drawSurface,
- Surface *readSurface,
- gl::Context *context);
-} // namespace egl
-
-#endif // LIBANGLE_FRAME_CAPTURE_H_
diff --git a/src/libANGLE/capture/capture_egl_autogen.cpp b/src/libANGLE/capture/capture_egl_autogen.cpp
new file mode 100644
index 0000000..9e22254
--- /dev/null
+++ b/src/libANGLE/capture/capture_egl_autogen.cpp
@@ -0,0 +1,2131 @@
+// 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 "libANGLE/Context.h"
+#include "libANGLE/capture/FrameCapture.h"
+#include "libANGLE/capture/gl_enum_utils.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,
+ egl::Surface *surfacePacked,
+ EGLNativePixmapType target,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, 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::Context *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::Tgl_ContextPointer,
+ 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::Context *ctxPacked,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("ctxPacked", ParamType::Tgl_ContextPointer, 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,
+ egl::Surface *surfacePacked,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, 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,
+ egl::Surface *drawPacked,
+ egl::Surface *readPacked,
+ gl::Context *ctxPacked,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("drawPacked", ParamType::Tegl_SurfacePointer, drawPacked);
+ paramBuffer.addValueParam("readPacked", ParamType::Tegl_SurfacePointer, readPacked);
+ paramBuffer.addValueParam("ctxPacked", ParamType::Tgl_ContextPointer, 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::Context *ctxPacked,
+ EGLint attribute,
+ EGLint *value,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("ctxPacked", ParamType::Tgl_ContextPointer, 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,
+ egl::Surface *surfacePacked,
+ EGLint attribute,
+ EGLint *value,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, 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,
+ egl::Surface *surfacePacked,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, 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,
+ egl::Surface *surfacePacked,
+ EGLint buffer,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, 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,
+ egl::Surface *surfacePacked,
+ EGLint buffer,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, 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,
+ egl::Surface *surfacePacked,
+ EGLint attribute,
+ EGLint value,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, 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::Sync *syncPacked,
+ EGLint flags,
+ EGLTime timeout,
+ EGLint returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncPointer, 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::Context *ctxPacked,
+ EGLenum target,
+ EGLClientBuffer buffer,
+ const AttributeMap &attrib_listPacked,
+ EGLImage returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("ctxPacked", ParamType::Tgl_ContextPointer, 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,
+ egl::Image *imagePacked,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("imagePacked", ParamType::Tegl_ImagePointer, 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::Sync *syncPacked,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncPointer, 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::Sync *syncPacked,
+ EGLint attribute,
+ EGLAttrib *value,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncPointer, 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::Sync *syncPacked,
+ EGLint flags,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncPointer, 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,
+ egl::Surface *surfacePacked,
+ CompositorTiming namePacked,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, 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,
+ egl::Surface *surfacePacked,
+ EGLint numTimestamps,
+ const EGLint *names,
+ EGLnsecsANDROID *values,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, 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,
+ egl::Surface *surfacePacked,
+ EGLuint64KHR *frameId,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, 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,
+ egl::Surface *surfacePacked,
+ Timestamp timestampPacked,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, 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,
+ egl::Surface *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::Tegl_SurfacePointer, 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::Sync *syncPacked,
+ EGLint returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncPointer, 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,
+ egl::Surface *surfacePacked,
+ EGLnsecsANDROID time,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, 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 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::Sync *syncPacked,
+ void *returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncPointer, 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 CaptureReleaseHighPowerGPUANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ gl::Context *ctxPacked)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("ctxPacked", ParamType::Tgl_ContextPointer, ctxPacked);
+
+ return CallCapture(angle::EntryPoint::EGLReleaseHighPowerGPUANGLE, std::move(paramBuffer));
+}
+
+CallCapture CaptureReacquireHighPowerGPUANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ gl::Context *ctxPacked)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("ctxPacked", ParamType::Tgl_ContextPointer, 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,
+ egl::Surface *surfacePacked,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, 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,
+ egl::Surface *surfacePacked,
+ EGLint attribute,
+ void **value,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, 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 CaptureSwapBuffersWithFrameTokenANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLFrameTokenANGLE frametoken,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked);
+ paramBuffer.addValueParam("frametoken", ParamType::TEGLFrameTokenANGLE, frametoken);
+
+ ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean);
+ InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value);
+ paramBuffer.addReturnValue(std::move(returnValueCapture));
+
+ return CallCapture(angle::EntryPoint::EGLSwapBuffersWithFrameTokenANGLE,
+ std::move(paramBuffer));
+}
+
+CallCapture CaptureGetMscRateANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLint *numerator,
+ EGLint *denominator,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, 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,
+ egl::Image *imagePacked,
+ void *vk_image,
+ void *vk_image_create_info,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("imagePacked", ParamType::Tegl_ImagePointer, 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 CaptureGetSyncValuesCHROMIUM(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLuint64KHR *ust,
+ EGLuint64KHR *msc,
+ EGLuint64KHR *sbc,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, 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 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::Sync *syncPacked,
+ EGLint flags,
+ EGLTimeKHR timeout,
+ EGLint returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncPointer, 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::Sync *syncPacked,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncPointer, 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::Sync *syncPacked,
+ EGLint attribute,
+ EGLint *value,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncPointer, 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::Context *ctxPacked,
+ EGLenum target,
+ EGLClientBuffer buffer,
+ const AttributeMap &attrib_listPacked,
+ EGLImageKHR returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("ctxPacked", ParamType::Tgl_ContextPointer, 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,
+ egl::Image *imagePacked,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("imagePacked", ParamType::Tegl_ImagePointer, 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,
+ egl::Surface *surfacePacked,
+ const AttributeMap &attrib_listPacked,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, 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,
+ egl::Surface *surfacePacked,
+ EGLint attribute,
+ EGLAttribKHR *value,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, 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,
+ egl::Surface *surfacePacked,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, 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,
+ egl::Surface *surfacePacked,
+ EGLint *rects,
+ EGLint n_rects,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, 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::Sync *syncPacked,
+ EGLenum mode,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncPointer, 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,
+ egl::Surface *surfacePacked,
+ const EGLint *rects,
+ EGLint n_rects,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, 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::Sync *syncPacked,
+ EGLint flags,
+ EGLint returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncPointer, 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,
+ egl::Surface *surfacePacked,
+ EGLint x,
+ EGLint y,
+ EGLint width,
+ EGLint height,
+ EGLBoolean returnValue)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked);
+ paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, 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
diff --git a/src/libANGLE/capture/capture_egl_autogen.h b/src/libANGLE/capture/capture_egl_autogen.h
new file mode 100644
index 0000000..f6c9b87
--- /dev/null
+++ b/src/libANGLE/capture/capture_egl_autogen.h
@@ -0,0 +1,654 @@
+// GENERATED FILE - DO NOT EDIT.
+// Generated by generate_entry_points.py using data from egl.xml and egl_angle_ext.xml.
+//
+// Copyright 2020 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// capture_egl_autogen.h:
+// Capture functions for the OpenGL ES EGL entry points.
+
+#ifndef LIBANGLE_CAPTURE_EGL_AUTOGEN_H_
+#define LIBANGLE_CAPTURE_EGL_AUTOGEN_H_
+
+#include "common/PackedEnums.h"
+#include "libANGLE/capture/FrameCapture.h"
+
+namespace egl
+{
+
+// Method Captures
+
+angle::CallCapture CaptureChooseConfig(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ const AttributeMap &attrib_listPacked,
+ EGLConfig *configs,
+ EGLint config_size,
+ EGLint *num_config,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureCopyBuffers(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLNativePixmapType target,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureCreateContext(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Config *configPacked,
+ gl::Context *share_contextPacked,
+ const AttributeMap &attrib_listPacked,
+ EGLContext returnValue);
+angle::CallCapture CaptureCreatePbufferSurface(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Config *configPacked,
+ const AttributeMap &attrib_listPacked,
+ EGLSurface returnValue);
+angle::CallCapture CaptureCreatePixmapSurface(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Config *configPacked,
+ EGLNativePixmapType pixmap,
+ const AttributeMap &attrib_listPacked,
+ EGLSurface returnValue);
+angle::CallCapture CaptureCreateWindowSurface(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Config *configPacked,
+ EGLNativeWindowType win,
+ const AttributeMap &attrib_listPacked,
+ EGLSurface returnValue);
+angle::CallCapture CaptureDestroyContext(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ gl::Context *ctxPacked,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureDestroySurface(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureGetConfigAttrib(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Config *configPacked,
+ EGLint attribute,
+ EGLint *value,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureGetConfigs(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ EGLConfig *configs,
+ EGLint config_size,
+ EGLint *num_config,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureGetCurrentDisplay(egl::Thread *thread,
+ bool isCallValid,
+ EGLDisplay returnValue);
+angle::CallCapture CaptureGetCurrentSurface(egl::Thread *thread,
+ bool isCallValid,
+ EGLint readdraw,
+ EGLSurface returnValue);
+angle::CallCapture CaptureGetDisplay(egl::Thread *thread,
+ bool isCallValid,
+ EGLNativeDisplayType display_id,
+ EGLDisplay returnValue);
+angle::CallCapture CaptureGetError(egl::Thread *thread, bool isCallValid, EGLint returnValue);
+angle::CallCapture CaptureGetProcAddress(egl::Thread *thread,
+ bool isCallValid,
+ const char *procname,
+ __eglMustCastToProperFunctionPointerType returnValue);
+angle::CallCapture CaptureInitialize(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ EGLint *major,
+ EGLint *minor,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureMakeCurrent(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *drawPacked,
+ egl::Surface *readPacked,
+ gl::Context *ctxPacked,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureQueryContext(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ gl::Context *ctxPacked,
+ EGLint attribute,
+ EGLint *value,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureQueryString(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ EGLint name,
+ const char *returnValue);
+angle::CallCapture CaptureQuerySurface(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLint attribute,
+ EGLint *value,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureSwapBuffers(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureTerminate(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureWaitGL(egl::Thread *thread, bool isCallValid, EGLBoolean returnValue);
+angle::CallCapture CaptureWaitNative(egl::Thread *thread,
+ bool isCallValid,
+ EGLint engine,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureBindTexImage(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLint buffer,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureReleaseTexImage(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLint buffer,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureSurfaceAttrib(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLint attribute,
+ EGLint value,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureSwapInterval(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ EGLint interval,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureBindAPI(egl::Thread *thread,
+ bool isCallValid,
+ EGLenum api,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureCreatePbufferFromClientBuffer(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ EGLenum buftype,
+ EGLClientBuffer buffer,
+ egl::Config *configPacked,
+ const AttributeMap &attrib_listPacked,
+ EGLSurface returnValue);
+angle::CallCapture CaptureQueryAPI(egl::Thread *thread, bool isCallValid, EGLenum returnValue);
+angle::CallCapture CaptureReleaseThread(egl::Thread *thread,
+ bool isCallValid,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureWaitClient(egl::Thread *thread, bool isCallValid, EGLBoolean returnValue);
+angle::CallCapture CaptureGetCurrentContext(egl::Thread *thread,
+ bool isCallValid,
+ EGLContext returnValue);
+angle::CallCapture CaptureClientWaitSync(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Sync *syncPacked,
+ EGLint flags,
+ EGLTime timeout,
+ EGLint returnValue);
+angle::CallCapture CaptureCreateImage(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ gl::Context *ctxPacked,
+ EGLenum target,
+ EGLClientBuffer buffer,
+ const AttributeMap &attrib_listPacked,
+ EGLImage returnValue);
+angle::CallCapture CaptureCreatePlatformPixmapSurface(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Config *configPacked,
+ void *native_pixmap,
+ const AttributeMap &attrib_listPacked,
+ EGLSurface returnValue);
+angle::CallCapture CaptureCreatePlatformWindowSurface(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Config *configPacked,
+ void *native_window,
+ const AttributeMap &attrib_listPacked,
+ EGLSurface returnValue);
+angle::CallCapture CaptureCreateSync(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ EGLenum type,
+ const AttributeMap &attrib_listPacked,
+ EGLSync returnValue);
+angle::CallCapture CaptureDestroyImage(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Image *imagePacked,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureDestroySync(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Sync *syncPacked,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureGetPlatformDisplay(egl::Thread *thread,
+ bool isCallValid,
+ EGLenum platform,
+ void *native_display,
+ const AttributeMap &attrib_listPacked,
+ EGLDisplay returnValue);
+angle::CallCapture CaptureGetSyncAttrib(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Sync *syncPacked,
+ EGLint attribute,
+ EGLAttrib *value,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureWaitSync(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Sync *syncPacked,
+ EGLint flags,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureSetBlobCacheFuncsANDROID(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ EGLSetBlobFuncANDROID set,
+ EGLGetBlobFuncANDROID get);
+angle::CallCapture CaptureCreateNativeClientBufferANDROID(egl::Thread *thread,
+ bool isCallValid,
+ const AttributeMap &attrib_listPacked,
+ EGLClientBuffer returnValue);
+angle::CallCapture CaptureGetCompositorTimingSupportedANDROID(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ CompositorTiming namePacked,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureGetCompositorTimingANDROID(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLint numTimestamps,
+ const EGLint *names,
+ EGLnsecsANDROID *values,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureGetNextFrameIdANDROID(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLuint64KHR *frameId,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureGetFrameTimestampSupportedANDROID(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ Timestamp timestampPacked,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureGetFrameTimestampsANDROID(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLuint64KHR frameId,
+ EGLint numTimestamps,
+ const EGLint *timestamps,
+ EGLnsecsANDROID *values,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureGetNativeClientBufferANDROID(egl::Thread *thread,
+ bool isCallValid,
+ const struct AHardwareBuffer *buffer,
+ EGLClientBuffer returnValue);
+angle::CallCapture CaptureDupNativeFenceFDANDROID(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Sync *syncPacked,
+ EGLint returnValue);
+angle::CallCapture CapturePresentationTimeANDROID(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLnsecsANDROID time,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureCreateDeviceANGLE(egl::Thread *thread,
+ bool isCallValid,
+ EGLint device_type,
+ void *native_device,
+ const EGLAttrib *attrib_list,
+ EGLDeviceEXT returnValue);
+angle::CallCapture CaptureReleaseDeviceANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Device *devicePacked,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureQueryStringiANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ EGLint name,
+ EGLint index,
+ const char *returnValue);
+angle::CallCapture CaptureQueryDisplayAttribANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ EGLint attribute,
+ EGLAttrib *value,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureCopyMetalSharedEventANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Sync *syncPacked,
+ void *returnValue);
+angle::CallCapture CaptureReleaseHighPowerGPUANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ gl::Context *ctxPacked);
+angle::CallCapture CaptureReacquireHighPowerGPUANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ gl::Context *ctxPacked);
+angle::CallCapture CaptureHandleGPUSwitchANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked);
+angle::CallCapture CaptureForceGPUSwitchANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ EGLint gpuIDHigh,
+ EGLint gpuIDLow);
+angle::CallCapture CapturePrepareSwapBuffersANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureProgramCacheGetAttribANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ EGLenum attrib,
+ EGLint returnValue);
+angle::CallCapture CaptureProgramCacheQueryANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ EGLint index,
+ void *key,
+ EGLint *keysize,
+ void *binary,
+ EGLint *binarysize);
+angle::CallCapture CaptureProgramCachePopulateANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ const void *key,
+ EGLint keysize,
+ const void *binary,
+ EGLint binarysize);
+angle::CallCapture CaptureProgramCacheResizeANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ EGLint limit,
+ EGLint mode,
+ EGLint returnValue);
+angle::CallCapture CaptureQuerySurfacePointerANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLint attribute,
+ void **value,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureCreateStreamProducerD3DTextureANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Stream *streamPacked,
+ const AttributeMap &attrib_listPacked,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureStreamPostD3DTextureANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Stream *streamPacked,
+ void *texture,
+ const AttributeMap &attrib_listPacked,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureSwapBuffersWithFrameTokenANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLFrameTokenANGLE frametoken,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureGetMscRateANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLint *numerator,
+ EGLint *denominator,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureExportVkImageANGLE(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Image *imagePacked,
+ void *vk_image,
+ void *vk_image_create_info,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureGetSyncValuesCHROMIUM(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLuint64KHR *ust,
+ EGLuint64KHR *msc,
+ EGLuint64KHR *sbc,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureQueryDeviceAttribEXT(egl::Thread *thread,
+ bool isCallValid,
+ egl::Device *devicePacked,
+ EGLint attribute,
+ EGLAttrib *value,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureQueryDeviceStringEXT(egl::Thread *thread,
+ bool isCallValid,
+ egl::Device *devicePacked,
+ EGLint name,
+ const char *returnValue);
+angle::CallCapture CaptureQueryDisplayAttribEXT(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ EGLint attribute,
+ EGLAttrib *value,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureQueryDmaBufFormatsEXT(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ EGLint max_formats,
+ EGLint *formats,
+ EGLint *num_formats,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureQueryDmaBufModifiersEXT(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ EGLint format,
+ EGLint max_modifiers,
+ EGLuint64KHR *modifiers,
+ EGLBoolean *external_only,
+ EGLint *num_modifiers,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureCreatePlatformPixmapSurfaceEXT(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Config *configPacked,
+ void *native_pixmap,
+ const AttributeMap &attrib_listPacked,
+ EGLSurface returnValue);
+angle::CallCapture CaptureCreatePlatformWindowSurfaceEXT(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Config *configPacked,
+ void *native_window,
+ const AttributeMap &attrib_listPacked,
+ EGLSurface returnValue);
+angle::CallCapture CaptureGetPlatformDisplayEXT(egl::Thread *thread,
+ bool isCallValid,
+ EGLenum platform,
+ void *native_display,
+ const AttributeMap &attrib_listPacked,
+ EGLDisplay returnValue);
+angle::CallCapture CaptureDebugMessageControlKHR(egl::Thread *thread,
+ bool isCallValid,
+ EGLDEBUGPROCKHR callback,
+ const AttributeMap &attrib_listPacked,
+ EGLint returnValue);
+angle::CallCapture CaptureLabelObjectKHR(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *displayPacked,
+ ObjectType objectTypePacked,
+ EGLObjectKHR object,
+ EGLLabelKHR label,
+ EGLint returnValue);
+angle::CallCapture CaptureQueryDebugKHR(egl::Thread *thread,
+ bool isCallValid,
+ EGLint attribute,
+ EGLAttrib *value,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureClientWaitSyncKHR(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Sync *syncPacked,
+ EGLint flags,
+ EGLTimeKHR timeout,
+ EGLint returnValue);
+angle::CallCapture CaptureCreateSyncKHR(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ EGLenum type,
+ const AttributeMap &attrib_listPacked,
+ EGLSyncKHR returnValue);
+angle::CallCapture CaptureDestroySyncKHR(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Sync *syncPacked,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureGetSyncAttribKHR(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Sync *syncPacked,
+ EGLint attribute,
+ EGLint *value,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureCreateImageKHR(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ gl::Context *ctxPacked,
+ EGLenum target,
+ EGLClientBuffer buffer,
+ const AttributeMap &attrib_listPacked,
+ EGLImageKHR returnValue);
+angle::CallCapture CaptureDestroyImageKHR(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Image *imagePacked,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureLockSurfaceKHR(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ const AttributeMap &attrib_listPacked,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureQuerySurface64KHR(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLint attribute,
+ EGLAttribKHR *value,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureUnlockSurfaceKHR(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureSetDamageRegionKHR(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLint *rects,
+ EGLint n_rects,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureSignalSyncKHR(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Sync *syncPacked,
+ EGLenum mode,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureCreateStreamKHR(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ const AttributeMap &attrib_listPacked,
+ EGLStreamKHR returnValue);
+angle::CallCapture CaptureDestroyStreamKHR(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Stream *streamPacked,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureQueryStreamKHR(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Stream *streamPacked,
+ EGLenum attribute,
+ EGLint *value,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureQueryStreamu64KHR(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Stream *streamPacked,
+ EGLenum attribute,
+ EGLuint64KHR *value,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureStreamAttribKHR(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Stream *streamPacked,
+ EGLenum attribute,
+ EGLint value,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureStreamConsumerAcquireKHR(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Stream *streamPacked,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureStreamConsumerGLTextureExternalKHR(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Stream *streamPacked,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureStreamConsumerReleaseKHR(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Stream *streamPacked,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureSwapBuffersWithDamageKHR(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ const EGLint *rects,
+ EGLint n_rects,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureWaitSyncKHR(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Sync *syncPacked,
+ EGLint flags,
+ EGLint returnValue);
+angle::CallCapture CapturePostSubBufferNV(egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Surface *surfacePacked,
+ EGLint x,
+ EGLint y,
+ EGLint width,
+ EGLint height,
+ EGLBoolean returnValue);
+angle::CallCapture CaptureStreamConsumerGLTextureExternalAttribsNV(
+ egl::Thread *thread,
+ bool isCallValid,
+ egl::Display *dpyPacked,
+ egl::Stream *streamPacked,
+ const AttributeMap &attrib_listPacked,
+ EGLBoolean returnValue);
+} // namespace egl
+
+#endif // LIBANGLE_CAPTURE_EGL_AUTOGEN_H_
diff --git a/src/libANGLE/capture/capture_gl_1_autogen.cpp b/src/libANGLE/capture/capture_gl_1_autogen.cpp
index e4359f8..0159a9f 100644
--- a/src/libANGLE/capture/capture_gl_1_autogen.cpp
+++ b/src/libANGLE/capture/capture_gl_1_autogen.cpp
@@ -21,7 +21,6 @@
{
// GL 1.0
-
CallCapture CaptureAccum(const State &glState, bool isCallValid, GLenum op, GLfloat value)
{
ParamBuffer paramBuffer;
@@ -4458,7 +4457,6 @@
}
// GL 1.1
-
CallCapture CaptureAreTexturesResident(const State &glState,
bool isCallValid,
GLsizei n,
@@ -4783,7 +4781,6 @@
// GL 1.2
// GL 1.3
-
CallCapture CaptureCompressedTexImage1D(const State &glState,
bool isCallValid,
GLenum target,
@@ -5638,7 +5635,6 @@
}
// GL 1.4
-
CallCapture CaptureFogCoordPointer(const State &glState,
bool isCallValid,
GLenum type,
@@ -6470,7 +6466,6 @@
}
// GL 1.5
-
CallCapture CaptureGetBufferSubData(const State &glState,
bool isCallValid,
GLenum target,
diff --git a/src/libANGLE/capture/capture_gl_2_autogen.cpp b/src/libANGLE/capture/capture_gl_2_autogen.cpp
index 336522d..e10738b 100644
--- a/src/libANGLE/capture/capture_gl_2_autogen.cpp
+++ b/src/libANGLE/capture/capture_gl_2_autogen.cpp
@@ -21,7 +21,6 @@
{
// GL 2.0
-
CallCapture CaptureGetVertexAttribdv(const State &glState,
bool isCallValid,
GLuint index,
diff --git a/src/libANGLE/capture/capture_gl_3_autogen.cpp b/src/libANGLE/capture/capture_gl_3_autogen.cpp
index d0b950e..d507510 100644
--- a/src/libANGLE/capture/capture_gl_3_autogen.cpp
+++ b/src/libANGLE/capture/capture_gl_3_autogen.cpp
@@ -21,7 +21,6 @@
{
// GL 3.0
-
CallCapture CaptureBeginConditionalRender(const State &glState,
bool isCallValid,
GLuint id,
@@ -479,7 +478,6 @@
}
// GL 3.1
-
CallCapture CaptureGetActiveUniformName(const State &glState,
bool isCallValid,
ShaderProgramID programPacked,
@@ -539,7 +537,6 @@
}
// GL 3.2
-
CallCapture CaptureMultiDrawElementsBaseVertex(const State &glState,
bool isCallValid,
PrimitiveMode modePacked,
@@ -669,7 +666,6 @@
}
// GL 3.3
-
CallCapture CaptureBindFragDataLocationIndexed(const State &glState,
bool isCallValid,
ShaderProgramID programPacked,
diff --git a/src/libANGLE/capture/capture_gl_4_autogen.cpp b/src/libANGLE/capture/capture_gl_4_autogen.cpp
index b66ebf0..bd39def 100644
--- a/src/libANGLE/capture/capture_gl_4_autogen.cpp
+++ b/src/libANGLE/capture/capture_gl_4_autogen.cpp
@@ -21,7 +21,6 @@
{
// GL 4.0
-
CallCapture CaptureBeginQueryIndexed(const State &glState,
bool isCallValid,
GLenum target,
@@ -931,7 +930,6 @@
}
// GL 4.1
-
CallCapture CaptureDepthRangeArrayv(const State &glState,
bool isCallValid,
GLuint first,
@@ -1923,7 +1921,6 @@
}
// GL 4.2
-
CallCapture CaptureDrawArraysInstancedBaseInstance(const State &glState,
bool isCallValid,
PrimitiveMode modePacked,
@@ -2108,7 +2105,6 @@
}
// GL 4.3
-
CallCapture CaptureClearBufferData(const State &glState,
bool isCallValid,
GLenum target,
@@ -2446,7 +2442,6 @@
}
// GL 4.4
-
CallCapture CaptureBindBuffersBase(const State &glState,
bool isCallValid,
GLenum target,
@@ -2811,7 +2806,6 @@
}
// GL 4.5
-
CallCapture CaptureBindTextureUnit(const State &glState,
bool isCallValid,
GLuint unit,
@@ -5961,7 +5955,6 @@
}
// GL 4.6
-
CallCapture CaptureMultiDrawArraysIndirectCount(const State &glState,
bool isCallValid,
GLenum mode,
diff --git a/src/libANGLE/capture/capture_gles_1_0_autogen.cpp b/src/libANGLE/capture/capture_gles_1_0_autogen.cpp
index 6c4be7a..edd34fa 100644
--- a/src/libANGLE/capture/capture_gles_1_0_autogen.cpp
+++ b/src/libANGLE/capture/capture_gles_1_0_autogen.cpp
@@ -19,7 +19,6 @@
namespace gl
{
-
CallCapture CaptureAlphaFunc(const State &glState,
bool isCallValid,
AlphaTestFunc funcPacked,
diff --git a/src/libANGLE/capture/capture_gles_2_0_autogen.cpp b/src/libANGLE/capture/capture_gles_2_0_autogen.cpp
index 0aff42a..dc15aae 100644
--- a/src/libANGLE/capture/capture_gles_2_0_autogen.cpp
+++ b/src/libANGLE/capture/capture_gles_2_0_autogen.cpp
@@ -19,7 +19,6 @@
namespace gl
{
-
CallCapture CaptureActiveTexture(const State &glState, bool isCallValid, GLenum texture)
{
ParamBuffer paramBuffer;
diff --git a/src/libANGLE/capture/capture_gles_3_0_autogen.cpp b/src/libANGLE/capture/capture_gles_3_0_autogen.cpp
index 9f30f10..00bd25d 100644
--- a/src/libANGLE/capture/capture_gles_3_0_autogen.cpp
+++ b/src/libANGLE/capture/capture_gles_3_0_autogen.cpp
@@ -19,7 +19,6 @@
namespace gl
{
-
CallCapture CaptureBeginQuery(const State &glState,
bool isCallValid,
QueryType targetPacked,
diff --git a/src/libANGLE/capture/capture_gles_3_1_autogen.cpp b/src/libANGLE/capture/capture_gles_3_1_autogen.cpp
index 2ec8de0..da2defa 100644
--- a/src/libANGLE/capture/capture_gles_3_1_autogen.cpp
+++ b/src/libANGLE/capture/capture_gles_3_1_autogen.cpp
@@ -19,7 +19,6 @@
namespace gl
{
-
CallCapture CaptureActiveShaderProgram(const State &glState,
bool isCallValid,
ProgramPipelineID pipelinePacked,
diff --git a/src/libANGLE/capture/capture_gles_3_2_autogen.cpp b/src/libANGLE/capture/capture_gles_3_2_autogen.cpp
index 91abf36..8d7c156 100644
--- a/src/libANGLE/capture/capture_gles_3_2_autogen.cpp
+++ b/src/libANGLE/capture/capture_gles_3_2_autogen.cpp
@@ -19,7 +19,6 @@
namespace gl
{
-
CallCapture CaptureBlendBarrier(const State &glState, bool isCallValid)
{
ParamBuffer paramBuffer;
diff --git a/src/libANGLE/capture/capture_gles_ext_autogen.cpp b/src/libANGLE/capture/capture_gles_ext_autogen.cpp
index 81097ec..4a50832 100644
--- a/src/libANGLE/capture/capture_gles_ext_autogen.cpp
+++ b/src/libANGLE/capture/capture_gles_ext_autogen.cpp
@@ -19,7 +19,6 @@
namespace gl
{
-
CallCapture CaptureBeginPerfMonitorAMD(const State &glState, bool isCallValid, GLuint monitor)
{
ParamBuffer paramBuffer;
diff --git a/src/libANGLE/capture/frame_capture_utils_autogen.cpp b/src/libANGLE/capture/frame_capture_utils_autogen.cpp
index 1d37bca..717a507 100644
--- a/src/libANGLE/capture/frame_capture_utils_autogen.cpp
+++ b/src/libANGLE/capture/frame_capture_utils_autogen.cpp
@@ -71,6 +71,9 @@
WriteParamValueReplay<ParamType::TEGLAttribPointer>(os, call,
param.value.EGLAttribPointerVal);
break;
+ case ParamType::TEGLBoolean:
+ WriteParamValueReplay<ParamType::TEGLBoolean>(os, call, param.value.EGLBooleanVal);
+ break;
case ParamType::TEGLBooleanPointer:
WriteParamValueReplay<ParamType::TEGLBooleanPointer>(os, call,
param.value.EGLBooleanPointerVal);
@@ -83,10 +86,19 @@
WriteParamValueReplay<ParamType::TEGLConfigPointer>(os, call,
param.value.EGLConfigPointerVal);
break;
+ case ParamType::TEGLContext:
+ WriteParamValueReplay<ParamType::TEGLContext>(os, call, param.value.EGLContextVal);
+ break;
case ParamType::TEGLDEBUGPROCKHR:
WriteParamValueReplay<ParamType::TEGLDEBUGPROCKHR>(os, call,
param.value.EGLDEBUGPROCKHRVal);
break;
+ case ParamType::TEGLDeviceEXT:
+ WriteParamValueReplay<ParamType::TEGLDeviceEXT>(os, call, param.value.EGLDeviceEXTVal);
+ break;
+ case ParamType::TEGLDisplay:
+ WriteParamValueReplay<ParamType::TEGLDisplay>(os, call, param.value.EGLDisplayVal);
+ break;
case ParamType::TEGLFrameTokenANGLE:
WriteParamValueReplay<ParamType::TEGLFrameTokenANGLE>(
os, call, param.value.EGLFrameTokenANGLEVal);
@@ -95,6 +107,12 @@
WriteParamValueReplay<ParamType::TEGLGetBlobFuncANDROID>(
os, call, param.value.EGLGetBlobFuncANDROIDVal);
break;
+ case ParamType::TEGLImage:
+ WriteParamValueReplay<ParamType::TEGLImage>(os, call, param.value.EGLImageVal);
+ break;
+ case ParamType::TEGLImageKHR:
+ WriteParamValueReplay<ParamType::TEGLImageKHR>(os, call, param.value.EGLImageKHRVal);
+ break;
case ParamType::TEGLLabelKHR:
WriteParamValueReplay<ParamType::TEGLLabelKHR>(os, call, param.value.EGLLabelKHRVal);
break;
@@ -117,6 +135,18 @@
WriteParamValueReplay<ParamType::TEGLSetBlobFuncANDROID>(
os, call, param.value.EGLSetBlobFuncANDROIDVal);
break;
+ case ParamType::TEGLStreamKHR:
+ WriteParamValueReplay<ParamType::TEGLStreamKHR>(os, call, param.value.EGLStreamKHRVal);
+ break;
+ case ParamType::TEGLSurface:
+ WriteParamValueReplay<ParamType::TEGLSurface>(os, call, param.value.EGLSurfaceVal);
+ break;
+ case ParamType::TEGLSync:
+ WriteParamValueReplay<ParamType::TEGLSync>(os, call, param.value.EGLSyncVal);
+ break;
+ case ParamType::TEGLSyncKHR:
+ WriteParamValueReplay<ParamType::TEGLSyncKHR>(os, call, param.value.EGLSyncKHRVal);
+ break;
case ParamType::TEGLTime:
WriteParamValueReplay<ParamType::TEGLTime>(os, call, param.value.EGLTimeVal);
break;
@@ -647,55 +677,75 @@
case ParamType::TDrawElementsType:
return "GLenum";
case ParamType::TEGLAttribConstPointer:
- return "const GLenum *";
+ return "const EGLAttrib *";
case ParamType::TEGLAttribKHRPointer:
- return "GLenum *";
+ return "EGLAttribKHR *";
case ParamType::TEGLAttribPointer:
- return "GLenum *";
+ return "EGLAttrib *";
+ case ParamType::TEGLBoolean:
+ return "EGLBoolean";
case ParamType::TEGLBooleanPointer:
- return "GLenum *";
+ return "EGLBoolean *";
case ParamType::TEGLClientBuffer:
- return "GLenum";
+ return "EGLClientBuffer";
case ParamType::TEGLConfigPointer:
- return "GLenum *";
+ return "EGLConfig *";
+ case ParamType::TEGLContext:
+ return "EGLContext";
case ParamType::TEGLDEBUGPROCKHR:
- return "GLenum";
+ return "EGLDEBUGPROCKHR";
+ case ParamType::TEGLDeviceEXT:
+ return "EGLDeviceEXT";
+ case ParamType::TEGLDisplay:
+ return "EGLDisplay";
case ParamType::TEGLFrameTokenANGLE:
- return "GLenum";
+ return "EGLFrameTokenANGLE";
case ParamType::TEGLGetBlobFuncANDROID:
- return "GLenum";
+ return "EGLGetBlobFuncANDROID";
+ case ParamType::TEGLImage:
+ return "EGLImage";
+ case ParamType::TEGLImageKHR:
+ return "EGLImageKHR";
case ParamType::TEGLLabelKHR:
- return "GLenum";
+ return "EGLLabelKHR";
case ParamType::TEGLNativeDisplayType:
- return "GLenum";
+ return "EGLNativeDisplayType";
case ParamType::TEGLNativePixmapType:
- return "GLenum";
+ return "EGLNativePixmapType";
case ParamType::TEGLNativeWindowType:
- return "GLenum";
+ return "EGLNativeWindowType";
case ParamType::TEGLObjectKHR:
- return "GLenum";
+ return "EGLObjectKHR";
case ParamType::TEGLSetBlobFuncANDROID:
- return "GLenum";
+ return "EGLSetBlobFuncANDROID";
+ case ParamType::TEGLStreamKHR:
+ return "EGLStreamKHR";
+ case ParamType::TEGLSurface:
+ return "EGLSurface";
+ case ParamType::TEGLSync:
+ return "EGLSync";
+ case ParamType::TEGLSyncKHR:
+ return "EGLSyncKHR";
case ParamType::TEGLTime:
- return "GLenum";
+ return "EGLTime";
case ParamType::TEGLTimeKHR:
- return "GLenum";
+ return "EGLTimeKHR";
case ParamType::TEGLenum:
- return "GLenum";
+ return "EGLenum";
case ParamType::TEGLint:
- return "GLenum";
+ return "EGLint";
case ParamType::TEGLintConstPointer:
- return "const GLenum *";
+ return "const EGLint *";
case ParamType::TEGLintPointer:
- return "GLenum *";
+ return "EGLint *";
case ParamType::TEGLnsecsANDROID:
- return "GLenum";
+ return "EGLnsecsANDROID";
case ParamType::TEGLnsecsANDROIDPointer:
- return "GLenum *";
+ return "EGLnsecsANDROID *";
case ParamType::TEGLuint64KHR:
- return "GLenum";
+ return "EGLuint64KHR";
case ParamType::TEGLuint64KHRPointer:
- return "GLenum *";
+ return "EGLuint64KHR *";
case ParamType::TFenceNVID:
return "GLuint";
case ParamType::TFenceNVIDConstPointer:
diff --git a/src/libANGLE/capture/frame_capture_utils_autogen.h b/src/libANGLE/capture/frame_capture_utils_autogen.h
index 653e70c..dddd724 100644
--- a/src/libANGLE/capture/frame_capture_utils_autogen.h
+++ b/src/libANGLE/capture/frame_capture_utils_autogen.h
@@ -31,18 +31,28 @@
TEGLAttribConstPointer,
TEGLAttribKHRPointer,
TEGLAttribPointer,
+ TEGLBoolean,
TEGLBooleanPointer,
TEGLClientBuffer,
TEGLConfigPointer,
+ TEGLContext,
TEGLDEBUGPROCKHR,
+ TEGLDeviceEXT,
+ TEGLDisplay,
TEGLFrameTokenANGLE,
TEGLGetBlobFuncANDROID,
+ TEGLImage,
+ TEGLImageKHR,
TEGLLabelKHR,
TEGLNativeDisplayType,
TEGLNativePixmapType,
TEGLNativeWindowType,
TEGLObjectKHR,
TEGLSetBlobFuncANDROID,
+ TEGLStreamKHR,
+ TEGLSurface,
+ TEGLSync,
+ TEGLSyncKHR,
TEGLTime,
TEGLTimeKHR,
TEGLenum,
@@ -179,7 +189,7 @@
TvoidPointerPointer,
};
-constexpr uint32_t kParamTypeCount = 160;
+constexpr uint32_t kParamTypeCount = 170;
union ParamValue
{
@@ -197,18 +207,28 @@
const EGLAttrib *EGLAttribConstPointerVal;
EGLAttribKHR *EGLAttribKHRPointerVal;
EGLAttrib *EGLAttribPointerVal;
+ EGLBoolean EGLBooleanVal;
EGLBoolean *EGLBooleanPointerVal;
EGLClientBuffer EGLClientBufferVal;
EGLConfig *EGLConfigPointerVal;
+ EGLContext EGLContextVal;
EGLDEBUGPROCKHR EGLDEBUGPROCKHRVal;
+ EGLDeviceEXT EGLDeviceEXTVal;
+ EGLDisplay EGLDisplayVal;
EGLFrameTokenANGLE EGLFrameTokenANGLEVal;
EGLGetBlobFuncANDROID EGLGetBlobFuncANDROIDVal;
+ EGLImage EGLImageVal;
+ EGLImageKHR EGLImageKHRVal;
EGLLabelKHR EGLLabelKHRVal;
EGLNativeDisplayType EGLNativeDisplayTypeVal;
EGLNativePixmapType EGLNativePixmapTypeVal;
EGLNativeWindowType EGLNativeWindowTypeVal;
EGLObjectKHR EGLObjectKHRVal;
EGLSetBlobFuncANDROID EGLSetBlobFuncANDROIDVal;
+ EGLStreamKHR EGLStreamKHRVal;
+ EGLSurface EGLSurfaceVal;
+ EGLSync EGLSyncVal;
+ EGLSyncKHR EGLSyncKHRVal;
EGLTime EGLTimeVal;
EGLTimeKHR EGLTimeKHRVal;
EGLenum EGLenumVal;
@@ -445,6 +465,12 @@
}
template <>
+inline EGLBoolean GetParamVal<ParamType::TEGLBoolean, EGLBoolean>(const ParamValue &value)
+{
+ return value.EGLBooleanVal;
+}
+
+template <>
inline EGLBoolean *GetParamVal<ParamType::TEGLBooleanPointer, EGLBoolean *>(const ParamValue &value)
{
return value.EGLBooleanPointerVal;
@@ -464,6 +490,12 @@
}
template <>
+inline EGLContext GetParamVal<ParamType::TEGLContext, EGLContext>(const ParamValue &value)
+{
+ return value.EGLContextVal;
+}
+
+template <>
inline EGLDEBUGPROCKHR GetParamVal<ParamType::TEGLDEBUGPROCKHR, EGLDEBUGPROCKHR>(
const ParamValue &value)
{
@@ -471,6 +503,18 @@
}
template <>
+inline EGLDeviceEXT GetParamVal<ParamType::TEGLDeviceEXT, EGLDeviceEXT>(const ParamValue &value)
+{
+ return value.EGLDeviceEXTVal;
+}
+
+template <>
+inline EGLDisplay GetParamVal<ParamType::TEGLDisplay, EGLDisplay>(const ParamValue &value)
+{
+ return value.EGLDisplayVal;
+}
+
+template <>
inline EGLFrameTokenANGLE GetParamVal<ParamType::TEGLFrameTokenANGLE, EGLFrameTokenANGLE>(
const ParamValue &value)
{
@@ -485,6 +529,18 @@
}
template <>
+inline EGLImage GetParamVal<ParamType::TEGLImage, EGLImage>(const ParamValue &value)
+{
+ return value.EGLImageVal;
+}
+
+template <>
+inline EGLImageKHR GetParamVal<ParamType::TEGLImageKHR, EGLImageKHR>(const ParamValue &value)
+{
+ return value.EGLImageKHRVal;
+}
+
+template <>
inline EGLLabelKHR GetParamVal<ParamType::TEGLLabelKHR, EGLLabelKHR>(const ParamValue &value)
{
return value.EGLLabelKHRVal;
@@ -525,6 +581,30 @@
}
template <>
+inline EGLStreamKHR GetParamVal<ParamType::TEGLStreamKHR, EGLStreamKHR>(const ParamValue &value)
+{
+ return value.EGLStreamKHRVal;
+}
+
+template <>
+inline EGLSurface GetParamVal<ParamType::TEGLSurface, EGLSurface>(const ParamValue &value)
+{
+ return value.EGLSurfaceVal;
+}
+
+template <>
+inline EGLSync GetParamVal<ParamType::TEGLSync, EGLSync>(const ParamValue &value)
+{
+ return value.EGLSyncVal;
+}
+
+template <>
+inline EGLSyncKHR GetParamVal<ParamType::TEGLSyncKHR, EGLSyncKHR>(const ParamValue &value)
+{
+ return value.EGLSyncKHRVal;
+}
+
+template <>
inline EGLTime GetParamVal<ParamType::TEGLTime, EGLTime>(const ParamValue &value)
{
return value.EGLTimeVal;
@@ -1449,18 +1529,30 @@
return GetParamVal<ParamType::TEGLAttribKHRPointer, T>(value);
case ParamType::TEGLAttribPointer:
return GetParamVal<ParamType::TEGLAttribPointer, T>(value);
+ case ParamType::TEGLBoolean:
+ return GetParamVal<ParamType::TEGLBoolean, T>(value);
case ParamType::TEGLBooleanPointer:
return GetParamVal<ParamType::TEGLBooleanPointer, T>(value);
case ParamType::TEGLClientBuffer:
return GetParamVal<ParamType::TEGLClientBuffer, T>(value);
case ParamType::TEGLConfigPointer:
return GetParamVal<ParamType::TEGLConfigPointer, T>(value);
+ case ParamType::TEGLContext:
+ return GetParamVal<ParamType::TEGLContext, T>(value);
case ParamType::TEGLDEBUGPROCKHR:
return GetParamVal<ParamType::TEGLDEBUGPROCKHR, T>(value);
+ case ParamType::TEGLDeviceEXT:
+ return GetParamVal<ParamType::TEGLDeviceEXT, T>(value);
+ case ParamType::TEGLDisplay:
+ return GetParamVal<ParamType::TEGLDisplay, T>(value);
case ParamType::TEGLFrameTokenANGLE:
return GetParamVal<ParamType::TEGLFrameTokenANGLE, T>(value);
case ParamType::TEGLGetBlobFuncANDROID:
return GetParamVal<ParamType::TEGLGetBlobFuncANDROID, T>(value);
+ case ParamType::TEGLImage:
+ return GetParamVal<ParamType::TEGLImage, T>(value);
+ case ParamType::TEGLImageKHR:
+ return GetParamVal<ParamType::TEGLImageKHR, T>(value);
case ParamType::TEGLLabelKHR:
return GetParamVal<ParamType::TEGLLabelKHR, T>(value);
case ParamType::TEGLNativeDisplayType:
@@ -1473,6 +1565,14 @@
return GetParamVal<ParamType::TEGLObjectKHR, T>(value);
case ParamType::TEGLSetBlobFuncANDROID:
return GetParamVal<ParamType::TEGLSetBlobFuncANDROID, T>(value);
+ case ParamType::TEGLStreamKHR:
+ return GetParamVal<ParamType::TEGLStreamKHR, T>(value);
+ case ParamType::TEGLSurface:
+ return GetParamVal<ParamType::TEGLSurface, T>(value);
+ case ParamType::TEGLSync:
+ return GetParamVal<ParamType::TEGLSync, T>(value);
+ case ParamType::TEGLSyncKHR:
+ return GetParamVal<ParamType::TEGLSyncKHR, T>(value);
case ParamType::TEGLTime:
return GetParamVal<ParamType::TEGLTime, T>(value);
case ParamType::TEGLTimeKHR:
@@ -1841,6 +1941,12 @@
}
template <>
+inline void SetParamVal<ParamType::TEGLBoolean>(EGLBoolean valueIn, ParamValue *valueOut)
+{
+ valueOut->EGLBooleanVal = valueIn;
+}
+
+template <>
inline void SetParamVal<ParamType::TEGLBooleanPointer>(EGLBoolean *valueIn, ParamValue *valueOut)
{
valueOut->EGLBooleanPointerVal = valueIn;
@@ -1859,12 +1965,30 @@
}
template <>
+inline void SetParamVal<ParamType::TEGLContext>(EGLContext valueIn, ParamValue *valueOut)
+{
+ valueOut->EGLContextVal = valueIn;
+}
+
+template <>
inline void SetParamVal<ParamType::TEGLDEBUGPROCKHR>(EGLDEBUGPROCKHR valueIn, ParamValue *valueOut)
{
valueOut->EGLDEBUGPROCKHRVal = valueIn;
}
template <>
+inline void SetParamVal<ParamType::TEGLDeviceEXT>(EGLDeviceEXT valueIn, ParamValue *valueOut)
+{
+ valueOut->EGLDeviceEXTVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLDisplay>(EGLDisplay valueIn, ParamValue *valueOut)
+{
+ valueOut->EGLDisplayVal = valueIn;
+}
+
+template <>
inline void SetParamVal<ParamType::TEGLFrameTokenANGLE>(EGLFrameTokenANGLE valueIn,
ParamValue *valueOut)
{
@@ -1879,6 +2003,18 @@
}
template <>
+inline void SetParamVal<ParamType::TEGLImage>(EGLImage valueIn, ParamValue *valueOut)
+{
+ valueOut->EGLImageVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLImageKHR>(EGLImageKHR valueIn, ParamValue *valueOut)
+{
+ valueOut->EGLImageKHRVal = valueIn;
+}
+
+template <>
inline void SetParamVal<ParamType::TEGLLabelKHR>(EGLLabelKHR valueIn, ParamValue *valueOut)
{
valueOut->EGLLabelKHRVal = valueIn;
@@ -1919,6 +2055,30 @@
}
template <>
+inline void SetParamVal<ParamType::TEGLStreamKHR>(EGLStreamKHR valueIn, ParamValue *valueOut)
+{
+ valueOut->EGLStreamKHRVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLSurface>(EGLSurface valueIn, ParamValue *valueOut)
+{
+ valueOut->EGLSurfaceVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLSync>(EGLSync valueIn, ParamValue *valueOut)
+{
+ valueOut->EGLSyncVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLSyncKHR>(EGLSyncKHR valueIn, ParamValue *valueOut)
+{
+ valueOut->EGLSyncKHRVal = valueIn;
+}
+
+template <>
inline void SetParamVal<ParamType::TEGLTime>(EGLTime valueIn, ParamValue *valueOut)
{
valueOut->EGLTimeVal = valueIn;
@@ -2831,6 +2991,9 @@
case ParamType::TEGLAttribPointer:
SetParamVal<ParamType::TEGLAttribPointer>(valueIn, valueOut);
break;
+ case ParamType::TEGLBoolean:
+ SetParamVal<ParamType::TEGLBoolean>(valueIn, valueOut);
+ break;
case ParamType::TEGLBooleanPointer:
SetParamVal<ParamType::TEGLBooleanPointer>(valueIn, valueOut);
break;
@@ -2840,15 +3003,30 @@
case ParamType::TEGLConfigPointer:
SetParamVal<ParamType::TEGLConfigPointer>(valueIn, valueOut);
break;
+ case ParamType::TEGLContext:
+ SetParamVal<ParamType::TEGLContext>(valueIn, valueOut);
+ break;
case ParamType::TEGLDEBUGPROCKHR:
SetParamVal<ParamType::TEGLDEBUGPROCKHR>(valueIn, valueOut);
break;
+ case ParamType::TEGLDeviceEXT:
+ SetParamVal<ParamType::TEGLDeviceEXT>(valueIn, valueOut);
+ break;
+ case ParamType::TEGLDisplay:
+ SetParamVal<ParamType::TEGLDisplay>(valueIn, valueOut);
+ break;
case ParamType::TEGLFrameTokenANGLE:
SetParamVal<ParamType::TEGLFrameTokenANGLE>(valueIn, valueOut);
break;
case ParamType::TEGLGetBlobFuncANDROID:
SetParamVal<ParamType::TEGLGetBlobFuncANDROID>(valueIn, valueOut);
break;
+ case ParamType::TEGLImage:
+ SetParamVal<ParamType::TEGLImage>(valueIn, valueOut);
+ break;
+ case ParamType::TEGLImageKHR:
+ SetParamVal<ParamType::TEGLImageKHR>(valueIn, valueOut);
+ break;
case ParamType::TEGLLabelKHR:
SetParamVal<ParamType::TEGLLabelKHR>(valueIn, valueOut);
break;
@@ -2867,6 +3045,18 @@
case ParamType::TEGLSetBlobFuncANDROID:
SetParamVal<ParamType::TEGLSetBlobFuncANDROID>(valueIn, valueOut);
break;
+ case ParamType::TEGLStreamKHR:
+ SetParamVal<ParamType::TEGLStreamKHR>(valueIn, valueOut);
+ break;
+ case ParamType::TEGLSurface:
+ SetParamVal<ParamType::TEGLSurface>(valueIn, valueOut);
+ break;
+ case ParamType::TEGLSync:
+ SetParamVal<ParamType::TEGLSync>(valueIn, valueOut);
+ break;
+ case ParamType::TEGLSyncKHR:
+ SetParamVal<ParamType::TEGLSyncKHR>(valueIn, valueOut);
+ break;
case ParamType::TEGLTime:
SetParamVal<ParamType::TEGLTime>(valueIn, valueOut);
break;
diff --git a/src/libANGLE/capture/trace_fixture.h b/src/libANGLE/capture/trace_fixture.h
index be9a4dd..755da0e 100644
--- a/src/libANGLE/capture/trace_fixture.h
+++ b/src/libANGLE/capture/trace_fixture.h
@@ -110,7 +110,7 @@
// TODO(http://www.anglebug.com/5878): avoid std::unordered_map, it's slow
using SyncResourceMap = std::unordered_map<uintptr_t, GLsync>;
extern SyncResourceMap gSyncMap;
-using ContextMap = std::unordered_map<uint32_t, EGLContext>;
+using ContextMap = std::unordered_map<uintptr_t, EGLContext>;
extern ContextMap gContextMap;
using SurfaceMap = std::unordered_map<uintptr_t, EGLSurface>;
@@ -137,7 +137,6 @@
void UpdateTextureID(GLuint id, GLsizei readBufferOffset);
void UpdateTransformFeedbackID(GLuint id, GLsizei readBufferOffset);
void UpdateVertexArrayID(GLuint id, GLsizei readBufferOffset);
-void UpdateBufferID2(GLuint id, GLsizei readBufferOffset);
void UpdateClientBuffer(EGLClientBuffer key, EGLClientBuffer data);
EGLClientBuffer GetClientBuffer(EGLenum target, uint64_t key);
diff --git a/src/libANGLE/entry_points_utils.h b/src/libANGLE/entry_points_utils.h
index c5a3178..65981ce 100644
--- a/src/libANGLE/entry_points_utils.h
+++ b/src/libANGLE/entry_points_utils.h
@@ -91,11 +91,9 @@
}
#if ANGLE_CAPTURE_ENABLED
-# define ANGLE_CAPTURE_GL(Func, ...) CaptureCallToFrameCapture(Capture##Func, __VA_ARGS__)
-# define ANGLE_CAPTURE_EGL(Func, ...) CaptureCallToCaptureEGL(Capture##Func, __VA_ARGS__)
+# define ANGLE_CAPTURE_GL(Func, ...) CaptureGLCallToFrameCapture(Capture##Func, __VA_ARGS__)
#else
# define ANGLE_CAPTURE_GL(...)
-# define ANGLE_CAPTURE_EGL(...)
#endif // ANGLE_CAPTURE_ENABLED
#define EGL_EVENT(EP, FMT, ...) EVENT(nullptr, EGL##EP, FMT, ##__VA_ARGS__)
@@ -122,6 +120,12 @@
}
return gl::CID(contextPtr);
}
+
+#if ANGLE_CAPTURE_ENABLED
+# define ANGLE_CAPTURE_EGL(Func, ...) CaptureEGLCallToFrameCapture(Capture##Func, __VA_ARGS__)
+#else
+# define ANGLE_CAPTURE_EGL(...)
+#endif // ANGLE_CAPTURE_ENABLED
} // namespace egl
#endif // LIBANGLE_ENTRY_POINT_UTILS_H_
diff --git a/src/libGLESv2.gni b/src/libGLESv2.gni
index 1626d63..a215c5c 100644
--- a/src/libGLESv2.gni
+++ b/src/libGLESv2.gni
@@ -543,7 +543,7 @@
# The frame capture headers are always visible to libANGLE.
libangle_sources += [
"src/libANGLE/capture/FrameCapture.h",
- "src/libANGLE/capture/capture_egl.h",
+ "src/libANGLE/capture/capture_egl_autogen.h",
"src/libANGLE/capture/capture_gl_1_autogen.h",
"src/libANGLE/capture/capture_gl_2_autogen.h",
"src/libANGLE/capture/capture_gl_3_autogen.h",
@@ -562,7 +562,7 @@
libangle_capture_sources = [
"src/libANGLE/capture/FrameCapture.cpp",
- "src/libANGLE/capture/capture_egl.cpp",
+ "src/libANGLE/capture/capture_egl_autogen.cpp",
"src/libANGLE/capture/capture_gl_1_autogen.cpp",
"src/libANGLE/capture/capture_gl_1_params.cpp",
"src/libANGLE/capture/capture_gl_2_autogen.cpp",
diff --git a/src/libGLESv2/egl_ext_stubs.cpp b/src/libGLESv2/egl_ext_stubs.cpp
index a8b5142..78cdea4 100644
--- a/src/libGLESv2/egl_ext_stubs.cpp
+++ b/src/libGLESv2/egl_ext_stubs.cpp
@@ -13,8 +13,6 @@
#include "libANGLE/EGLSync.h"
#include "libANGLE/Surface.h"
#include "libANGLE/Thread.h"
-#include "libANGLE/capture/capture_egl.h"
-#include "libANGLE/capture/frame_capture_utils_autogen.h"
#include "libANGLE/entry_points_utils.h"
#include "libANGLE/queryutils.h"
#include "libANGLE/renderer/DisplayImpl.h"
@@ -55,8 +53,6 @@
ANGLE_EGL_TRY_RETURN(thread, display->createImage(context, target, buffer, attributes, &image),
"", GetDisplayIfValid(display), EGL_NO_IMAGE);
- ANGLE_CAPTURE_EGL(EGLCreateImage, thread, display, context, target, buffer, attributes, image);
-
thread->setSuccess();
return static_cast<EGLImage>(image);
}
@@ -68,8 +64,6 @@
egl::Display::CreateNativeClientBuffer(attribMap, &eglClientBuffer),
"eglCreateNativeClientBufferANDROID", nullptr, nullptr);
- ANGLE_CAPTURE_EGL(CreateNativeClientBufferANDROID, thread, attribMap, eglClientBuffer);
-
thread->setSuccess();
return eglClientBuffer;
}
@@ -157,8 +151,6 @@
GetDisplayIfValid(display), EGL_FALSE);
display->destroyImage(img);
- ANGLE_CAPTURE_EGL(EGLDestroyImage, thread, display, img);
-
thread->setSuccess();
return EGL_TRUE;
}
diff --git a/src/libGLESv2/egl_stubs.cpp b/src/libGLESv2/egl_stubs.cpp
index 6907cfc..cdaa21a 100644
--- a/src/libGLESv2/egl_stubs.cpp
+++ b/src/libGLESv2/egl_stubs.cpp
@@ -14,8 +14,6 @@
#include "libANGLE/EGLSync.h"
#include "libANGLE/Surface.h"
#include "libANGLE/Thread.h"
-#include "libANGLE/capture/capture_egl.h"
-#include "libANGLE/capture/frame_capture_utils_autogen.h"
#include "libANGLE/capture/gl_enum_utils_autogen.h"
#include "libANGLE/queryutils.h"
#include "libANGLE/validationEGL.h"
@@ -71,8 +69,6 @@
gl::Texture *textureObject = context->getTextureByType(type);
ANGLE_EGL_TRY_RETURN(thread, eglSurface->bindTexImage(context, textureObject, buffer),
"eglBindTexImage", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
-
- ANGLE_CAPTURE_EGL(EGLBindTexImage, thread, display, eglSurface, buffer);
}
thread->setSuccess();
@@ -159,8 +155,6 @@
return EGL_NO_IMAGE;
}
- ANGLE_CAPTURE_EGL(EGLCreateImage, thread, display, context, target, buffer, attributes, image);
-
thread->setSuccess();
return static_cast<EGLImage>(image);
}
@@ -195,8 +189,6 @@
ANGLE_EGL_TRY_RETURN(thread, display->createPbufferSurface(configuration, attributes, &surface),
"eglCreatePbufferSurface", GetDisplayIfValid(display), EGL_NO_SURFACE);
- ANGLE_CAPTURE_EGL(EGLCreatePbufferSurface, thread, display, configuration, attributes, surface);
-
return static_cast<EGLSurface>(surface);
}
@@ -302,16 +294,12 @@
GetDisplayIfValid(display), EGL_FALSE);
display->destroyImage(img);
- ANGLE_CAPTURE_EGL(EGLDestroyImage, thread, display, img);
-
thread->setSuccess();
return EGL_TRUE;
}
EGLBoolean DestroySurface(Thread *thread, Display *display, Surface *eglSurface)
{
- ANGLE_CAPTURE_EGL(EGLDestroySurface, thread, display, eglSurface);
-
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglDestroySurface",
GetDisplayIfValid(display), EGL_FALSE);
@@ -502,8 +490,6 @@
thread,
display->makeCurrent(thread, previousContext, drawSurface, readSurface, context),
"eglMakeCurrent", GetContextIfValid(display, context), EGL_FALSE);
-
- ANGLE_CAPTURE_EGL(EGLMakeCurrent, thread, display, drawSurface, readSurface, context);
}
thread->setSuccess();
@@ -605,7 +591,6 @@
ANGLE_EGL_TRY_RETURN(thread, eglSurface->releaseTexImage(thread->getContext(), buffer),
"eglReleaseTexImage", GetSurfaceIfValid(display, eglSurface),
EGL_FALSE);
- ANGLE_CAPTURE_EGL(EGLReleaseTexImage, thread, display, eglSurface, buffer);
}
}
thread->setSuccess();
diff --git a/src/libGLESv2/entry_points_egl_autogen.cpp b/src/libGLESv2/entry_points_egl_autogen.cpp
index 318f8f0..5f82b7f 100644
--- a/src/libGLESv2/entry_points_egl_autogen.cpp
+++ b/src/libGLESv2/entry_points_egl_autogen.cpp
@@ -10,6 +10,7 @@
#include "libGLESv2/entry_points_egl_autogen.h"
+#include "libANGLE/capture/capture_egl_autogen.h"
#include "libANGLE/entry_points_utils.h"
#include "libANGLE/validationEGL_autogen.h"
#include "libGLESv2/egl_ext_stubs_autogen.h"
@@ -43,7 +44,11 @@
ANGLE_EGL_VALIDATE(thread, ChooseConfig, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
attrib_listPacked, configs, config_size, num_config);
- return ChooseConfig(thread, dpyPacked, attrib_listPacked, configs, config_size, num_config);
+ EGLBoolean returnValue =
+ ChooseConfig(thread, dpyPacked, attrib_listPacked, configs, config_size, num_config);
+ ANGLE_CAPTURE_EGL(ChooseConfig, true, thread, dpyPacked, attrib_listPacked, configs,
+ config_size, num_config, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_CopyBuffers(EGLDisplay dpy,
@@ -65,7 +70,9 @@
ANGLE_EGL_VALIDATE(thread, CopyBuffers, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
surfacePacked, target);
- return CopyBuffers(thread, dpyPacked, surfacePacked, target);
+ EGLBoolean returnValue = CopyBuffers(thread, dpyPacked, surfacePacked, target);
+ ANGLE_CAPTURE_EGL(CopyBuffers, true, thread, dpyPacked, surfacePacked, target, returnValue);
+ return returnValue;
}
EGLContext EGLAPIENTRY EGL_CreateContext(EGLDisplay dpy,
@@ -90,7 +97,11 @@
ANGLE_EGL_VALIDATE(thread, CreateContext, GetDisplayIfValid(dpyPacked), EGLContext, dpyPacked,
configPacked, share_contextPacked, attrib_listPacked);
- return CreateContext(thread, dpyPacked, configPacked, share_contextPacked, attrib_listPacked);
+ EGLContext returnValue =
+ CreateContext(thread, dpyPacked, configPacked, share_contextPacked, attrib_listPacked);
+ ANGLE_CAPTURE_EGL(CreateContext, true, thread, dpyPacked, configPacked, share_contextPacked,
+ attrib_listPacked, returnValue);
+ return returnValue;
}
EGLSurface EGLAPIENTRY EGL_CreatePbufferSurface(EGLDisplay dpy,
@@ -113,7 +124,11 @@
ANGLE_EGL_VALIDATE(thread, CreatePbufferSurface, GetDisplayIfValid(dpyPacked), EGLSurface,
dpyPacked, configPacked, attrib_listPacked);
- return CreatePbufferSurface(thread, dpyPacked, configPacked, attrib_listPacked);
+ EGLSurface returnValue =
+ CreatePbufferSurface(thread, dpyPacked, configPacked, attrib_listPacked);
+ ANGLE_CAPTURE_EGL(CreatePbufferSurface, true, thread, dpyPacked, configPacked,
+ attrib_listPacked, returnValue);
+ return returnValue;
}
EGLSurface EGLAPIENTRY EGL_CreatePixmapSurface(EGLDisplay dpy,
@@ -137,7 +152,11 @@
ANGLE_EGL_VALIDATE(thread, CreatePixmapSurface, GetDisplayIfValid(dpyPacked), EGLSurface,
dpyPacked, configPacked, pixmap, attrib_listPacked);
- return CreatePixmapSurface(thread, dpyPacked, configPacked, pixmap, attrib_listPacked);
+ EGLSurface returnValue =
+ CreatePixmapSurface(thread, dpyPacked, configPacked, pixmap, attrib_listPacked);
+ ANGLE_CAPTURE_EGL(CreatePixmapSurface, true, thread, dpyPacked, configPacked, pixmap,
+ attrib_listPacked, returnValue);
+ return returnValue;
}
EGLSurface EGLAPIENTRY EGL_CreateWindowSurface(EGLDisplay dpy,
@@ -161,7 +180,11 @@
ANGLE_EGL_VALIDATE(thread, CreateWindowSurface, GetDisplayIfValid(dpyPacked), EGLSurface,
dpyPacked, configPacked, win, attrib_listPacked);
- return CreateWindowSurface(thread, dpyPacked, configPacked, win, attrib_listPacked);
+ EGLSurface returnValue =
+ CreateWindowSurface(thread, dpyPacked, configPacked, win, attrib_listPacked);
+ ANGLE_CAPTURE_EGL(CreateWindowSurface, true, thread, dpyPacked, configPacked, win,
+ attrib_listPacked, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_DestroyContext(EGLDisplay dpy, EGLContext ctx)
@@ -179,7 +202,9 @@
ANGLE_EGL_VALIDATE(thread, DestroyContext, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
ctxPacked);
- return DestroyContext(thread, dpyPacked, ctxPacked);
+ EGLBoolean returnValue = DestroyContext(thread, dpyPacked, ctxPacked);
+ ANGLE_CAPTURE_EGL(DestroyContext, true, thread, dpyPacked, ctxPacked, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_DestroySurface(EGLDisplay dpy, EGLSurface surface)
@@ -198,7 +223,9 @@
ANGLE_EGL_VALIDATE(thread, DestroySurface, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
surfacePacked);
- return DestroySurface(thread, dpyPacked, surfacePacked);
+ EGLBoolean returnValue = DestroySurface(thread, dpyPacked, surfacePacked);
+ ANGLE_CAPTURE_EGL(DestroySurface, true, thread, dpyPacked, surfacePacked, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_GetConfigAttrib(EGLDisplay dpy,
@@ -221,7 +248,10 @@
ANGLE_EGL_VALIDATE(thread, GetConfigAttrib, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
configPacked, attribute, value);
- return GetConfigAttrib(thread, dpyPacked, configPacked, attribute, value);
+ EGLBoolean returnValue = GetConfigAttrib(thread, dpyPacked, configPacked, attribute, value);
+ ANGLE_CAPTURE_EGL(GetConfigAttrib, true, thread, dpyPacked, configPacked, attribute, value,
+ returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_GetConfigs(EGLDisplay dpy,
@@ -243,7 +273,10 @@
ANGLE_EGL_VALIDATE(thread, GetConfigs, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
configs, config_size, num_config);
- return GetConfigs(thread, dpyPacked, configs, config_size, num_config);
+ EGLBoolean returnValue = GetConfigs(thread, dpyPacked, configs, config_size, num_config);
+ ANGLE_CAPTURE_EGL(GetConfigs, true, thread, dpyPacked, configs, config_size, num_config,
+ returnValue);
+ return returnValue;
}
EGLDisplay EGLAPIENTRY EGL_GetCurrentDisplay()
@@ -256,7 +289,9 @@
ANGLE_EGL_VALIDATE(thread, GetCurrentDisplay, nullptr, EGLDisplay);
- return GetCurrentDisplay(thread);
+ EGLDisplay returnValue = GetCurrentDisplay(thread);
+ ANGLE_CAPTURE_EGL(GetCurrentDisplay, true, thread, returnValue);
+ return returnValue;
}
EGLSurface EGLAPIENTRY EGL_GetCurrentSurface(EGLint readdraw)
@@ -269,7 +304,9 @@
ANGLE_EGL_VALIDATE(thread, GetCurrentSurface, nullptr, EGLSurface, readdraw);
- return GetCurrentSurface(thread, readdraw);
+ EGLSurface returnValue = GetCurrentSurface(thread, readdraw);
+ ANGLE_CAPTURE_EGL(GetCurrentSurface, true, thread, readdraw, returnValue);
+ return returnValue;
}
EGLDisplay EGLAPIENTRY EGL_GetDisplay(EGLNativeDisplayType display_id)
@@ -282,7 +319,9 @@
ANGLE_EGL_VALIDATE(thread, GetDisplay, nullptr, EGLDisplay, display_id);
- return GetDisplay(thread, display_id);
+ EGLDisplay returnValue = GetDisplay(thread, display_id);
+ ANGLE_CAPTURE_EGL(GetDisplay, true, thread, display_id, returnValue);
+ return returnValue;
}
EGLint EGLAPIENTRY EGL_GetError()
@@ -295,7 +334,9 @@
ANGLE_EGL_VALIDATE(thread, GetError, nullptr, EGLint);
- return GetError(thread);
+ EGLint returnValue = GetError(thread);
+ ANGLE_CAPTURE_EGL(GetError, true, thread, returnValue);
+ return returnValue;
}
__eglMustCastToProperFunctionPointerType EGLAPIENTRY EGL_GetProcAddress(const char *procname)
@@ -309,7 +350,9 @@
ANGLE_EGL_VALIDATE(thread, GetProcAddress, nullptr, __eglMustCastToProperFunctionPointerType,
procname);
- return GetProcAddress(thread, procname);
+ __eglMustCastToProperFunctionPointerType returnValue = GetProcAddress(thread, procname);
+ ANGLE_CAPTURE_EGL(GetProcAddress, true, thread, procname, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_Initialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
@@ -327,7 +370,9 @@
ANGLE_EGL_VALIDATE(thread, Initialize, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
major, minor);
- return Initialize(thread, dpyPacked, major, minor);
+ EGLBoolean returnValue = Initialize(thread, dpyPacked, major, minor);
+ ANGLE_CAPTURE_EGL(Initialize, true, thread, dpyPacked, major, minor, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_MakeCurrent(EGLDisplay dpy,
@@ -353,7 +398,10 @@
ANGLE_EGL_VALIDATE(thread, MakeCurrent, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
drawPacked, readPacked, ctxPacked);
- return MakeCurrent(thread, dpyPacked, drawPacked, readPacked, ctxPacked);
+ EGLBoolean returnValue = MakeCurrent(thread, dpyPacked, drawPacked, readPacked, ctxPacked);
+ ANGLE_CAPTURE_EGL(MakeCurrent, true, thread, dpyPacked, drawPacked, readPacked, ctxPacked,
+ returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_QueryContext(EGLDisplay dpy,
@@ -376,7 +424,10 @@
ANGLE_EGL_VALIDATE(thread, QueryContext, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
ctxPacked, attribute, value);
- return QueryContext(thread, dpyPacked, ctxPacked, attribute, value);
+ EGLBoolean returnValue = QueryContext(thread, dpyPacked, ctxPacked, attribute, value);
+ ANGLE_CAPTURE_EGL(QueryContext, true, thread, dpyPacked, ctxPacked, attribute, value,
+ returnValue);
+ return returnValue;
}
const char *EGLAPIENTRY EGL_QueryString(EGLDisplay dpy, EGLint name)
@@ -392,7 +443,9 @@
ANGLE_EGL_VALIDATE(thread, QueryString, GetDisplayIfValid(dpyPacked), const char *, dpyPacked,
name);
- return QueryString(thread, dpyPacked, name);
+ const char *returnValue = QueryString(thread, dpyPacked, name);
+ ANGLE_CAPTURE_EGL(QueryString, true, thread, dpyPacked, name, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_QuerySurface(EGLDisplay dpy,
@@ -416,7 +469,10 @@
ANGLE_EGL_VALIDATE(thread, QuerySurface, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
surfacePacked, attribute, value);
- return QuerySurface(thread, dpyPacked, surfacePacked, attribute, value);
+ EGLBoolean returnValue = QuerySurface(thread, dpyPacked, surfacePacked, attribute, value);
+ ANGLE_CAPTURE_EGL(QuerySurface, true, thread, dpyPacked, surfacePacked, attribute, value,
+ returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_SwapBuffers(EGLDisplay dpy, EGLSurface surface)
@@ -435,7 +491,9 @@
ANGLE_EGL_VALIDATE(thread, SwapBuffers, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
surfacePacked);
- return SwapBuffers(thread, dpyPacked, surfacePacked);
+ EGLBoolean returnValue = SwapBuffers(thread, dpyPacked, surfacePacked);
+ ANGLE_CAPTURE_EGL(SwapBuffers, true, thread, dpyPacked, surfacePacked, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_Terminate(EGLDisplay dpy)
@@ -450,7 +508,9 @@
ANGLE_EGL_VALIDATE(thread, Terminate, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked);
- return Terminate(thread, dpyPacked);
+ EGLBoolean returnValue = Terminate(thread, dpyPacked);
+ ANGLE_CAPTURE_EGL(Terminate, true, thread, dpyPacked, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_WaitGL()
@@ -463,7 +523,9 @@
ANGLE_EGL_VALIDATE(thread, WaitGL, nullptr, EGLBoolean);
- return WaitGL(thread);
+ EGLBoolean returnValue = WaitGL(thread);
+ ANGLE_CAPTURE_EGL(WaitGL, true, thread, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_WaitNative(EGLint engine)
@@ -476,7 +538,9 @@
ANGLE_EGL_VALIDATE(thread, WaitNative, nullptr, EGLBoolean, engine);
- return WaitNative(thread, engine);
+ EGLBoolean returnValue = WaitNative(thread, engine);
+ ANGLE_CAPTURE_EGL(WaitNative, true, thread, engine, returnValue);
+ return returnValue;
}
// EGL 1.1
@@ -496,7 +560,9 @@
ANGLE_EGL_VALIDATE(thread, BindTexImage, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
surfacePacked, buffer);
- return BindTexImage(thread, dpyPacked, surfacePacked, buffer);
+ EGLBoolean returnValue = BindTexImage(thread, dpyPacked, surfacePacked, buffer);
+ ANGLE_CAPTURE_EGL(BindTexImage, true, thread, dpyPacked, surfacePacked, buffer, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_ReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
@@ -515,7 +581,9 @@
ANGLE_EGL_VALIDATE(thread, ReleaseTexImage, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
surfacePacked, buffer);
- return ReleaseTexImage(thread, dpyPacked, surfacePacked, buffer);
+ EGLBoolean returnValue = ReleaseTexImage(thread, dpyPacked, surfacePacked, buffer);
+ ANGLE_CAPTURE_EGL(ReleaseTexImage, true, thread, dpyPacked, surfacePacked, buffer, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_SurfaceAttrib(EGLDisplay dpy,
@@ -538,7 +606,10 @@
ANGLE_EGL_VALIDATE(thread, SurfaceAttrib, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
surfacePacked, attribute, value);
- return SurfaceAttrib(thread, dpyPacked, surfacePacked, attribute, value);
+ EGLBoolean returnValue = SurfaceAttrib(thread, dpyPacked, surfacePacked, attribute, value);
+ ANGLE_CAPTURE_EGL(SurfaceAttrib, true, thread, dpyPacked, surfacePacked, attribute, value,
+ returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_SwapInterval(EGLDisplay dpy, EGLint interval)
@@ -554,7 +625,9 @@
ANGLE_EGL_VALIDATE(thread, SwapInterval, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
interval);
- return SwapInterval(thread, dpyPacked, interval);
+ EGLBoolean returnValue = SwapInterval(thread, dpyPacked, interval);
+ ANGLE_CAPTURE_EGL(SwapInterval, true, thread, dpyPacked, interval, returnValue);
+ return returnValue;
}
// EGL 1.2
@@ -568,7 +641,9 @@
ANGLE_EGL_VALIDATE(thread, BindAPI, nullptr, EGLBoolean, api);
- return BindAPI(thread, api);
+ EGLBoolean returnValue = BindAPI(thread, api);
+ ANGLE_CAPTURE_EGL(BindAPI, true, thread, api, returnValue);
+ return returnValue;
}
EGLSurface EGLAPIENTRY EGL_CreatePbufferFromClientBuffer(EGLDisplay dpy,
@@ -594,8 +669,11 @@
ANGLE_EGL_VALIDATE(thread, CreatePbufferFromClientBuffer, GetDisplayIfValid(dpyPacked),
EGLSurface, dpyPacked, buftype, buffer, configPacked, attrib_listPacked);
- return CreatePbufferFromClientBuffer(thread, dpyPacked, buftype, buffer, configPacked,
- attrib_listPacked);
+ EGLSurface returnValue = CreatePbufferFromClientBuffer(thread, dpyPacked, buftype, buffer,
+ configPacked, attrib_listPacked);
+ ANGLE_CAPTURE_EGL(CreatePbufferFromClientBuffer, true, thread, dpyPacked, buftype, buffer,
+ configPacked, attrib_listPacked, returnValue);
+ return returnValue;
}
EGLenum EGLAPIENTRY EGL_QueryAPI()
@@ -608,7 +686,9 @@
ANGLE_EGL_VALIDATE(thread, QueryAPI, nullptr, EGLenum);
- return QueryAPI(thread);
+ EGLenum returnValue = QueryAPI(thread);
+ ANGLE_CAPTURE_EGL(QueryAPI, true, thread, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_ReleaseThread()
@@ -621,7 +701,9 @@
ANGLE_EGL_VALIDATE(thread, ReleaseThread, nullptr, EGLBoolean);
- return ReleaseThread(thread);
+ EGLBoolean returnValue = ReleaseThread(thread);
+ ANGLE_CAPTURE_EGL(ReleaseThread, true, thread, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_WaitClient()
@@ -634,7 +716,9 @@
ANGLE_EGL_VALIDATE(thread, WaitClient, nullptr, EGLBoolean);
- return WaitClient(thread);
+ EGLBoolean returnValue = WaitClient(thread);
+ ANGLE_CAPTURE_EGL(WaitClient, true, thread, returnValue);
+ return returnValue;
}
// EGL 1.4
@@ -648,7 +732,9 @@
ANGLE_EGL_VALIDATE(thread, GetCurrentContext, nullptr, EGLContext);
- return GetCurrentContext(thread);
+ EGLContext returnValue = GetCurrentContext(thread);
+ ANGLE_CAPTURE_EGL(GetCurrentContext, true, thread, returnValue);
+ return returnValue;
}
// EGL 1.5
@@ -668,7 +754,10 @@
ANGLE_EGL_VALIDATE(thread, ClientWaitSync, GetDisplayIfValid(dpyPacked), EGLint, dpyPacked,
syncPacked, flags, timeout);
- return ClientWaitSync(thread, dpyPacked, syncPacked, flags, timeout);
+ EGLint returnValue = ClientWaitSync(thread, dpyPacked, syncPacked, flags, timeout);
+ ANGLE_CAPTURE_EGL(ClientWaitSync, true, thread, dpyPacked, syncPacked, flags, timeout,
+ returnValue);
+ return returnValue;
}
EGLImage EGLAPIENTRY EGL_CreateImage(EGLDisplay dpy,
@@ -693,7 +782,11 @@
ANGLE_EGL_VALIDATE(thread, CreateImage, GetDisplayIfValid(dpyPacked), EGLImage, dpyPacked,
ctxPacked, target, buffer, attrib_listPacked);
- return CreateImage(thread, dpyPacked, ctxPacked, target, buffer, attrib_listPacked);
+ EGLImage returnValue =
+ CreateImage(thread, dpyPacked, ctxPacked, target, buffer, attrib_listPacked);
+ ANGLE_CAPTURE_EGL(CreateImage, true, thread, dpyPacked, ctxPacked, target, buffer,
+ attrib_listPacked, returnValue);
+ return returnValue;
}
EGLSurface EGLAPIENTRY EGL_CreatePlatformPixmapSurface(EGLDisplay dpy,
@@ -717,8 +810,11 @@
ANGLE_EGL_VALIDATE(thread, CreatePlatformPixmapSurface, GetDisplayIfValid(dpyPacked),
EGLSurface, dpyPacked, configPacked, native_pixmap, attrib_listPacked);
- return CreatePlatformPixmapSurface(thread, dpyPacked, configPacked, native_pixmap,
- attrib_listPacked);
+ EGLSurface returnValue = CreatePlatformPixmapSurface(thread, dpyPacked, configPacked,
+ native_pixmap, attrib_listPacked);
+ ANGLE_CAPTURE_EGL(CreatePlatformPixmapSurface, true, thread, dpyPacked, configPacked,
+ native_pixmap, attrib_listPacked, returnValue);
+ return returnValue;
}
EGLSurface EGLAPIENTRY EGL_CreatePlatformWindowSurface(EGLDisplay dpy,
@@ -742,8 +838,11 @@
ANGLE_EGL_VALIDATE(thread, CreatePlatformWindowSurface, GetDisplayIfValid(dpyPacked),
EGLSurface, dpyPacked, configPacked, native_window, attrib_listPacked);
- return CreatePlatformWindowSurface(thread, dpyPacked, configPacked, native_window,
- attrib_listPacked);
+ EGLSurface returnValue = CreatePlatformWindowSurface(thread, dpyPacked, configPacked,
+ native_window, attrib_listPacked);
+ ANGLE_CAPTURE_EGL(CreatePlatformWindowSurface, true, thread, dpyPacked, configPacked,
+ native_window, attrib_listPacked, returnValue);
+ return returnValue;
}
EGLSync EGLAPIENTRY EGL_CreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list)
@@ -761,7 +860,9 @@
ANGLE_EGL_VALIDATE(thread, CreateSync, GetDisplayIfValid(dpyPacked), EGLSync, dpyPacked, type,
attrib_listPacked);
- return CreateSync(thread, dpyPacked, type, attrib_listPacked);
+ EGLSync returnValue = CreateSync(thread, dpyPacked, type, attrib_listPacked);
+ ANGLE_CAPTURE_EGL(CreateSync, true, thread, dpyPacked, type, attrib_listPacked, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_DestroyImage(EGLDisplay dpy, EGLImage image)
@@ -779,7 +880,9 @@
ANGLE_EGL_VALIDATE(thread, DestroyImage, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
imagePacked);
- return DestroyImage(thread, dpyPacked, imagePacked);
+ EGLBoolean returnValue = DestroyImage(thread, dpyPacked, imagePacked);
+ ANGLE_CAPTURE_EGL(DestroyImage, true, thread, dpyPacked, imagePacked, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_DestroySync(EGLDisplay dpy, EGLSync sync)
@@ -797,7 +900,9 @@
ANGLE_EGL_VALIDATE(thread, DestroySync, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
syncPacked);
- return DestroySync(thread, dpyPacked, syncPacked);
+ EGLBoolean returnValue = DestroySync(thread, dpyPacked, syncPacked);
+ ANGLE_CAPTURE_EGL(DestroySync, true, thread, dpyPacked, syncPacked, returnValue);
+ return returnValue;
}
EGLDisplay EGLAPIENTRY EGL_GetPlatformDisplay(EGLenum platform,
@@ -818,7 +923,11 @@
ANGLE_EGL_VALIDATE(thread, GetPlatformDisplay, nullptr, EGLDisplay, platform, native_display,
attrib_listPacked);
- return GetPlatformDisplay(thread, platform, native_display, attrib_listPacked);
+ EGLDisplay returnValue =
+ GetPlatformDisplay(thread, platform, native_display, attrib_listPacked);
+ ANGLE_CAPTURE_EGL(GetPlatformDisplay, true, thread, platform, native_display, attrib_listPacked,
+ returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_GetSyncAttrib(EGLDisplay dpy,
@@ -841,7 +950,10 @@
ANGLE_EGL_VALIDATE(thread, GetSyncAttrib, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
syncPacked, attribute, value);
- return GetSyncAttrib(thread, dpyPacked, syncPacked, attribute, value);
+ EGLBoolean returnValue = GetSyncAttrib(thread, dpyPacked, syncPacked, attribute, value);
+ ANGLE_CAPTURE_EGL(GetSyncAttrib, true, thread, dpyPacked, syncPacked, attribute, value,
+ returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_WaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags)
@@ -859,7 +971,9 @@
ANGLE_EGL_VALIDATE(thread, WaitSync, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
syncPacked, flags);
- return WaitSync(thread, dpyPacked, syncPacked, flags);
+ EGLBoolean returnValue = WaitSync(thread, dpyPacked, syncPacked, flags);
+ ANGLE_CAPTURE_EGL(WaitSync, true, thread, dpyPacked, syncPacked, flags, returnValue);
+ return returnValue;
}
} // extern "C"
diff --git a/src/libGLESv2/entry_points_egl_ext_autogen.cpp b/src/libGLESv2/entry_points_egl_ext_autogen.cpp
index c8957f0..224ce6f 100644
--- a/src/libGLESv2/entry_points_egl_ext_autogen.cpp
+++ b/src/libGLESv2/entry_points_egl_ext_autogen.cpp
@@ -10,6 +10,7 @@
#include "libGLESv2/entry_points_egl_ext_autogen.h"
+#include "libANGLE/capture/capture_egl_autogen.h"
#include "libANGLE/entry_points_utils.h"
#include "libANGLE/validationEGL_autogen.h"
#include "libGLESv2/egl_ext_stubs_autogen.h"
@@ -38,6 +39,7 @@
dpyPacked, set, get);
SetBlobCacheFuncsANDROID(thread, dpyPacked, set, get);
+ ANGLE_CAPTURE_EGL(SetBlobCacheFuncsANDROID, true, thread, dpyPacked, set, get);
}
// EGL_ANDROID_create_native_client_buffer
@@ -55,7 +57,10 @@
ANGLE_EGL_VALIDATE(thread, CreateNativeClientBufferANDROID, nullptr, EGLClientBuffer,
attrib_listPacked);
- return CreateNativeClientBufferANDROID(thread, attrib_listPacked);
+ EGLClientBuffer returnValue = CreateNativeClientBufferANDROID(thread, attrib_listPacked);
+ ANGLE_CAPTURE_EGL(CreateNativeClientBufferANDROID, true, thread, attrib_listPacked,
+ returnValue);
+ return returnValue;
}
// EGL_ANDROID_get_frame_timestamps
@@ -79,7 +84,11 @@
ANGLE_EGL_VALIDATE(thread, GetCompositorTimingSupportedANDROID, GetDisplayIfValid(dpyPacked),
EGLBoolean, dpyPacked, surfacePacked, namePacked);
- return GetCompositorTimingSupportedANDROID(thread, dpyPacked, surfacePacked, namePacked);
+ EGLBoolean returnValue =
+ GetCompositorTimingSupportedANDROID(thread, dpyPacked, surfacePacked, namePacked);
+ ANGLE_CAPTURE_EGL(GetCompositorTimingSupportedANDROID, true, thread, dpyPacked, surfacePacked,
+ namePacked, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_GetCompositorTimingANDROID(EGLDisplay dpy,
@@ -105,8 +114,11 @@
ANGLE_EGL_VALIDATE(thread, GetCompositorTimingANDROID, GetDisplayIfValid(dpyPacked), EGLBoolean,
dpyPacked, surfacePacked, numTimestamps, names, values);
- return GetCompositorTimingANDROID(thread, dpyPacked, surfacePacked, numTimestamps, names,
- values);
+ EGLBoolean returnValue =
+ GetCompositorTimingANDROID(thread, dpyPacked, surfacePacked, numTimestamps, names, values);
+ ANGLE_CAPTURE_EGL(GetCompositorTimingANDROID, true, thread, dpyPacked, surfacePacked,
+ numTimestamps, names, values, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_GetNextFrameIdANDROID(EGLDisplay dpy,
@@ -128,7 +140,10 @@
ANGLE_EGL_VALIDATE(thread, GetNextFrameIdANDROID, GetDisplayIfValid(dpyPacked), EGLBoolean,
dpyPacked, surfacePacked, frameId);
- return GetNextFrameIdANDROID(thread, dpyPacked, surfacePacked, frameId);
+ EGLBoolean returnValue = GetNextFrameIdANDROID(thread, dpyPacked, surfacePacked, frameId);
+ ANGLE_CAPTURE_EGL(GetNextFrameIdANDROID, true, thread, dpyPacked, surfacePacked, frameId,
+ returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_GetFrameTimestampSupportedANDROID(EGLDisplay dpy,
@@ -151,7 +166,11 @@
ANGLE_EGL_VALIDATE(thread, GetFrameTimestampSupportedANDROID, GetDisplayIfValid(dpyPacked),
EGLBoolean, dpyPacked, surfacePacked, timestampPacked);
- return GetFrameTimestampSupportedANDROID(thread, dpyPacked, surfacePacked, timestampPacked);
+ EGLBoolean returnValue =
+ GetFrameTimestampSupportedANDROID(thread, dpyPacked, surfacePacked, timestampPacked);
+ ANGLE_CAPTURE_EGL(GetFrameTimestampSupportedANDROID, true, thread, dpyPacked, surfacePacked,
+ timestampPacked, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_GetFrameTimestampsANDROID(EGLDisplay dpy,
@@ -179,8 +198,11 @@
ANGLE_EGL_VALIDATE(thread, GetFrameTimestampsANDROID, GetDisplayIfValid(dpyPacked), EGLBoolean,
dpyPacked, surfacePacked, frameId, numTimestamps, timestamps, values);
- return GetFrameTimestampsANDROID(thread, dpyPacked, surfacePacked, frameId, numTimestamps,
- timestamps, values);
+ EGLBoolean returnValue = GetFrameTimestampsANDROID(thread, dpyPacked, surfacePacked, frameId,
+ numTimestamps, timestamps, values);
+ ANGLE_CAPTURE_EGL(GetFrameTimestampsANDROID, true, thread, dpyPacked, surfacePacked, frameId,
+ numTimestamps, timestamps, values, returnValue);
+ return returnValue;
}
// EGL_ANDROID_get_native_client_buffer
@@ -194,7 +216,9 @@
ANGLE_EGL_VALIDATE(thread, GetNativeClientBufferANDROID, nullptr, EGLClientBuffer, buffer);
- return GetNativeClientBufferANDROID(thread, buffer);
+ EGLClientBuffer returnValue = GetNativeClientBufferANDROID(thread, buffer);
+ ANGLE_CAPTURE_EGL(GetNativeClientBufferANDROID, true, thread, buffer, returnValue);
+ return returnValue;
}
// EGL_ANDROID_native_fence_sync
@@ -213,7 +237,9 @@
ANGLE_EGL_VALIDATE(thread, DupNativeFenceFDANDROID, GetDisplayIfValid(dpyPacked), EGLint,
dpyPacked, syncPacked);
- return DupNativeFenceFDANDROID(thread, dpyPacked, syncPacked);
+ EGLint returnValue = DupNativeFenceFDANDROID(thread, dpyPacked, syncPacked);
+ ANGLE_CAPTURE_EGL(DupNativeFenceFDANDROID, true, thread, dpyPacked, syncPacked, returnValue);
+ return returnValue;
}
// EGL_ANDROID_presentation_time
@@ -236,7 +262,10 @@
ANGLE_EGL_VALIDATE(thread, PresentationTimeANDROID, GetDisplayIfValid(dpyPacked), EGLBoolean,
dpyPacked, surfacePacked, time);
- return PresentationTimeANDROID(thread, dpyPacked, surfacePacked, time);
+ EGLBoolean returnValue = PresentationTimeANDROID(thread, dpyPacked, surfacePacked, time);
+ ANGLE_CAPTURE_EGL(PresentationTimeANDROID, true, thread, dpyPacked, surfacePacked, time,
+ returnValue);
+ return returnValue;
}
// EGL_ANGLE_device_creation
@@ -256,7 +285,10 @@
ANGLE_EGL_VALIDATE(thread, CreateDeviceANGLE, nullptr, EGLDeviceEXT, device_type, native_device,
attrib_list);
- return CreateDeviceANGLE(thread, device_type, native_device, attrib_list);
+ EGLDeviceEXT returnValue = CreateDeviceANGLE(thread, device_type, native_device, attrib_list);
+ ANGLE_CAPTURE_EGL(CreateDeviceANGLE, true, thread, device_type, native_device, attrib_list,
+ returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_ReleaseDeviceANGLE(EGLDeviceEXT device)
@@ -271,7 +303,9 @@
ANGLE_EGL_VALIDATE(thread, ReleaseDeviceANGLE, nullptr, EGLBoolean, devicePacked);
- return ReleaseDeviceANGLE(thread, devicePacked);
+ EGLBoolean returnValue = ReleaseDeviceANGLE(thread, devicePacked);
+ ANGLE_CAPTURE_EGL(ReleaseDeviceANGLE, true, thread, devicePacked, returnValue);
+ return returnValue;
}
// EGL_ANGLE_feature_control
@@ -289,7 +323,9 @@
ANGLE_EGL_VALIDATE(thread, QueryStringiANGLE, GetDisplayIfValid(dpyPacked), const char *,
dpyPacked, name, index);
- return QueryStringiANGLE(thread, dpyPacked, name, index);
+ const char *returnValue = QueryStringiANGLE(thread, dpyPacked, name, index);
+ ANGLE_CAPTURE_EGL(QueryStringiANGLE, true, thread, dpyPacked, name, index, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_QueryDisplayAttribANGLE(EGLDisplay dpy,
@@ -309,7 +345,10 @@
ANGLE_EGL_VALIDATE(thread, QueryDisplayAttribANGLE, GetDisplayIfValid(dpyPacked), EGLBoolean,
dpyPacked, attribute, value);
- return QueryDisplayAttribANGLE(thread, dpyPacked, attribute, value);
+ EGLBoolean returnValue = QueryDisplayAttribANGLE(thread, dpyPacked, attribute, value);
+ ANGLE_CAPTURE_EGL(QueryDisplayAttribANGLE, true, thread, dpyPacked, attribute, value,
+ returnValue);
+ return returnValue;
}
// EGL_ANGLE_metal_shared_event_sync
@@ -328,7 +367,9 @@
ANGLE_EGL_VALIDATE(thread, CopyMetalSharedEventANGLE, GetDisplayIfValid(dpyPacked), void *,
dpyPacked, syncPacked);
- return CopyMetalSharedEventANGLE(thread, dpyPacked, syncPacked);
+ void *returnValue = CopyMetalSharedEventANGLE(thread, dpyPacked, syncPacked);
+ ANGLE_CAPTURE_EGL(CopyMetalSharedEventANGLE, true, thread, dpyPacked, syncPacked, returnValue);
+ return returnValue;
}
// EGL_ANGLE_power_preference
@@ -348,6 +389,7 @@
dpyPacked, ctxPacked);
ReleaseHighPowerGPUANGLE(thread, dpyPacked, ctxPacked);
+ ANGLE_CAPTURE_EGL(ReleaseHighPowerGPUANGLE, true, thread, dpyPacked, ctxPacked);
}
void EGLAPIENTRY EGL_ReacquireHighPowerGPUANGLE(EGLDisplay dpy, EGLContext ctx)
@@ -366,6 +408,7 @@
dpyPacked, ctxPacked);
ReacquireHighPowerGPUANGLE(thread, dpyPacked, ctxPacked);
+ ANGLE_CAPTURE_EGL(ReacquireHighPowerGPUANGLE, true, thread, dpyPacked, ctxPacked);
}
void EGLAPIENTRY EGL_HandleGPUSwitchANGLE(EGLDisplay dpy)
@@ -381,6 +424,7 @@
ANGLE_EGL_VALIDATE_VOID(thread, HandleGPUSwitchANGLE, GetDisplayIfValid(dpyPacked), dpyPacked);
HandleGPUSwitchANGLE(thread, dpyPacked);
+ ANGLE_CAPTURE_EGL(HandleGPUSwitchANGLE, true, thread, dpyPacked);
}
void EGLAPIENTRY EGL_ForceGPUSwitchANGLE(EGLDisplay dpy, EGLint gpuIDHigh, EGLint gpuIDLow)
@@ -398,6 +442,7 @@
gpuIDHigh, gpuIDLow);
ForceGPUSwitchANGLE(thread, dpyPacked, gpuIDHigh, gpuIDLow);
+ ANGLE_CAPTURE_EGL(ForceGPUSwitchANGLE, true, thread, dpyPacked, gpuIDHigh, gpuIDLow);
}
// EGL_ANGLE_prepare_swap_buffers
@@ -421,7 +466,9 @@
ANGLE_EGL_VALIDATE(thread, ProgramCacheGetAttribANGLE, GetDisplayIfValid(dpyPacked), EGLint,
dpyPacked, attrib);
- return ProgramCacheGetAttribANGLE(thread, dpyPacked, attrib);
+ EGLint returnValue = ProgramCacheGetAttribANGLE(thread, dpyPacked, attrib);
+ ANGLE_CAPTURE_EGL(ProgramCacheGetAttribANGLE, true, thread, dpyPacked, attrib, returnValue);
+ return returnValue;
}
void EGLAPIENTRY EGL_ProgramCacheQueryANGLE(EGLDisplay dpy,
@@ -448,6 +495,8 @@
index, key, keysize, binary, binarysize);
ProgramCacheQueryANGLE(thread, dpyPacked, index, key, keysize, binary, binarysize);
+ ANGLE_CAPTURE_EGL(ProgramCacheQueryANGLE, true, thread, dpyPacked, index, key, keysize, binary,
+ binarysize);
}
void EGLAPIENTRY EGL_ProgramCachePopulateANGLE(EGLDisplay dpy,
@@ -471,6 +520,8 @@
dpyPacked, key, keysize, binary, binarysize);
ProgramCachePopulateANGLE(thread, dpyPacked, key, keysize, binary, binarysize);
+ ANGLE_CAPTURE_EGL(ProgramCachePopulateANGLE, true, thread, dpyPacked, key, keysize, binary,
+ binarysize);
}
EGLint EGLAPIENTRY EGL_ProgramCacheResizeANGLE(EGLDisplay dpy, EGLint limit, EGLint mode)
@@ -487,7 +538,9 @@
ANGLE_EGL_VALIDATE(thread, ProgramCacheResizeANGLE, GetDisplayIfValid(dpyPacked), EGLint,
dpyPacked, limit, mode);
- return ProgramCacheResizeANGLE(thread, dpyPacked, limit, mode);
+ EGLint returnValue = ProgramCacheResizeANGLE(thread, dpyPacked, limit, mode);
+ ANGLE_CAPTURE_EGL(ProgramCacheResizeANGLE, true, thread, dpyPacked, limit, mode, returnValue);
+ return returnValue;
}
// EGL_ANGLE_query_surface_pointer
@@ -512,7 +565,11 @@
ANGLE_EGL_VALIDATE(thread, QuerySurfacePointerANGLE, GetDisplayIfValid(dpyPacked), EGLBoolean,
dpyPacked, surfacePacked, attribute, value);
- return QuerySurfacePointerANGLE(thread, dpyPacked, surfacePacked, attribute, value);
+ EGLBoolean returnValue =
+ QuerySurfacePointerANGLE(thread, dpyPacked, surfacePacked, attribute, value);
+ ANGLE_CAPTURE_EGL(QuerySurfacePointerANGLE, true, thread, dpyPacked, surfacePacked, attribute,
+ value, returnValue);
+ return returnValue;
}
// EGL_ANGLE_stream_producer_d3d_texture
@@ -536,7 +593,11 @@
ANGLE_EGL_VALIDATE(thread, CreateStreamProducerD3DTextureANGLE, GetDisplayIfValid(dpyPacked),
EGLBoolean, dpyPacked, streamPacked, attrib_listPacked);
- return CreateStreamProducerD3DTextureANGLE(thread, dpyPacked, streamPacked, attrib_listPacked);
+ EGLBoolean returnValue =
+ CreateStreamProducerD3DTextureANGLE(thread, dpyPacked, streamPacked, attrib_listPacked);
+ ANGLE_CAPTURE_EGL(CreateStreamProducerD3DTextureANGLE, true, thread, dpyPacked, streamPacked,
+ attrib_listPacked, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_StreamPostD3DTextureANGLE(EGLDisplay dpy,
@@ -560,7 +621,11 @@
ANGLE_EGL_VALIDATE(thread, StreamPostD3DTextureANGLE, GetDisplayIfValid(dpyPacked), EGLBoolean,
dpyPacked, streamPacked, texture, attrib_listPacked);
- return StreamPostD3DTextureANGLE(thread, dpyPacked, streamPacked, texture, attrib_listPacked);
+ EGLBoolean returnValue =
+ StreamPostD3DTextureANGLE(thread, dpyPacked, streamPacked, texture, attrib_listPacked);
+ ANGLE_CAPTURE_EGL(StreamPostD3DTextureANGLE, true, thread, dpyPacked, streamPacked, texture,
+ attrib_listPacked, returnValue);
+ return returnValue;
}
// EGL_ANGLE_swap_with_frame_token
@@ -583,7 +648,11 @@
ANGLE_EGL_VALIDATE(thread, SwapBuffersWithFrameTokenANGLE, GetDisplayIfValid(dpyPacked),
EGLBoolean, dpyPacked, surfacePacked, frametoken);
- return SwapBuffersWithFrameTokenANGLE(thread, dpyPacked, surfacePacked, frametoken);
+ EGLBoolean returnValue =
+ SwapBuffersWithFrameTokenANGLE(thread, dpyPacked, surfacePacked, frametoken);
+ ANGLE_CAPTURE_EGL(SwapBuffersWithFrameTokenANGLE, true, thread, dpyPacked, surfacePacked,
+ frametoken, returnValue);
+ return returnValue;
}
// EGL_ANGLE_sync_control_rate
@@ -608,7 +677,11 @@
ANGLE_EGL_VALIDATE(thread, GetMscRateANGLE, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
surfacePacked, numerator, denominator);
- return GetMscRateANGLE(thread, dpyPacked, surfacePacked, numerator, denominator);
+ EGLBoolean returnValue =
+ GetMscRateANGLE(thread, dpyPacked, surfacePacked, numerator, denominator);
+ ANGLE_CAPTURE_EGL(GetMscRateANGLE, true, thread, dpyPacked, surfacePacked, numerator,
+ denominator, returnValue);
+ return returnValue;
}
// EGL_ANGLE_vulkan_image
@@ -633,7 +706,11 @@
ANGLE_EGL_VALIDATE(thread, ExportVkImageANGLE, GetDisplayIfValid(dpyPacked), EGLBoolean,
dpyPacked, imagePacked, vk_image, vk_image_create_info);
- return ExportVkImageANGLE(thread, dpyPacked, imagePacked, vk_image, vk_image_create_info);
+ EGLBoolean returnValue =
+ ExportVkImageANGLE(thread, dpyPacked, imagePacked, vk_image, vk_image_create_info);
+ ANGLE_CAPTURE_EGL(ExportVkImageANGLE, true, thread, dpyPacked, imagePacked, vk_image,
+ vk_image_create_info, returnValue);
+ return returnValue;
}
// EGL_CHROMIUM_sync_control
@@ -659,7 +736,10 @@
ANGLE_EGL_VALIDATE(thread, GetSyncValuesCHROMIUM, GetDisplayIfValid(dpyPacked), EGLBoolean,
dpyPacked, surfacePacked, ust, msc, sbc);
- return GetSyncValuesCHROMIUM(thread, dpyPacked, surfacePacked, ust, msc, sbc);
+ EGLBoolean returnValue = GetSyncValuesCHROMIUM(thread, dpyPacked, surfacePacked, ust, msc, sbc);
+ ANGLE_CAPTURE_EGL(GetSyncValuesCHROMIUM, true, thread, dpyPacked, surfacePacked, ust, msc, sbc,
+ returnValue);
+ return returnValue;
}
// EGL_EXT_device_query
@@ -680,7 +760,10 @@
ANGLE_EGL_VALIDATE(thread, QueryDeviceAttribEXT, nullptr, EGLBoolean, devicePacked, attribute,
value);
- return QueryDeviceAttribEXT(thread, devicePacked, attribute, value);
+ EGLBoolean returnValue = QueryDeviceAttribEXT(thread, devicePacked, attribute, value);
+ ANGLE_CAPTURE_EGL(QueryDeviceAttribEXT, true, thread, devicePacked, attribute, value,
+ returnValue);
+ return returnValue;
}
const char *EGLAPIENTRY EGL_QueryDeviceStringEXT(EGLDeviceEXT device, EGLint name)
@@ -696,7 +779,9 @@
ANGLE_EGL_VALIDATE(thread, QueryDeviceStringEXT, nullptr, const char *, devicePacked, name);
- return QueryDeviceStringEXT(thread, devicePacked, name);
+ const char *returnValue = QueryDeviceStringEXT(thread, devicePacked, name);
+ ANGLE_CAPTURE_EGL(QueryDeviceStringEXT, true, thread, devicePacked, name, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_QueryDisplayAttribEXT(EGLDisplay dpy, EGLint attribute, EGLAttrib *value)
@@ -714,7 +799,10 @@
ANGLE_EGL_VALIDATE(thread, QueryDisplayAttribEXT, GetDisplayIfValid(dpyPacked), EGLBoolean,
dpyPacked, attribute, value);
- return QueryDisplayAttribEXT(thread, dpyPacked, attribute, value);
+ EGLBoolean returnValue = QueryDisplayAttribEXT(thread, dpyPacked, attribute, value);
+ ANGLE_CAPTURE_EGL(QueryDisplayAttribEXT, true, thread, dpyPacked, attribute, value,
+ returnValue);
+ return returnValue;
}
// EGL_EXT_image_dma_buf_import_modifiers
@@ -737,7 +825,11 @@
ANGLE_EGL_VALIDATE(thread, QueryDmaBufFormatsEXT, GetDisplayIfValid(dpyPacked), EGLBoolean,
dpyPacked, max_formats, formats, num_formats);
- return QueryDmaBufFormatsEXT(thread, dpyPacked, max_formats, formats, num_formats);
+ EGLBoolean returnValue =
+ QueryDmaBufFormatsEXT(thread, dpyPacked, max_formats, formats, num_formats);
+ ANGLE_CAPTURE_EGL(QueryDmaBufFormatsEXT, true, thread, dpyPacked, max_formats, formats,
+ num_formats, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_QueryDmaBufModifiersEXT(EGLDisplay dpy,
@@ -762,8 +854,11 @@
ANGLE_EGL_VALIDATE(thread, QueryDmaBufModifiersEXT, GetDisplayIfValid(dpyPacked), EGLBoolean,
dpyPacked, format, max_modifiers, modifiers, external_only, num_modifiers);
- return QueryDmaBufModifiersEXT(thread, dpyPacked, format, max_modifiers, modifiers,
- external_only, num_modifiers);
+ EGLBoolean returnValue = QueryDmaBufModifiersEXT(thread, dpyPacked, format, max_modifiers,
+ modifiers, external_only, num_modifiers);
+ ANGLE_CAPTURE_EGL(QueryDmaBufModifiersEXT, true, thread, dpyPacked, format, max_modifiers,
+ modifiers, external_only, num_modifiers, returnValue);
+ return returnValue;
}
// EGL_EXT_platform_base
@@ -788,8 +883,11 @@
ANGLE_EGL_VALIDATE(thread, CreatePlatformPixmapSurfaceEXT, GetDisplayIfValid(dpyPacked),
EGLSurface, dpyPacked, configPacked, native_pixmap, attrib_listPacked);
- return CreatePlatformPixmapSurfaceEXT(thread, dpyPacked, configPacked, native_pixmap,
- attrib_listPacked);
+ EGLSurface returnValue = CreatePlatformPixmapSurfaceEXT(thread, dpyPacked, configPacked,
+ native_pixmap, attrib_listPacked);
+ ANGLE_CAPTURE_EGL(CreatePlatformPixmapSurfaceEXT, true, thread, dpyPacked, configPacked,
+ native_pixmap, attrib_listPacked, returnValue);
+ return returnValue;
}
EGLSurface EGLAPIENTRY EGL_CreatePlatformWindowSurfaceEXT(EGLDisplay dpy,
@@ -813,8 +911,11 @@
ANGLE_EGL_VALIDATE(thread, CreatePlatformWindowSurfaceEXT, GetDisplayIfValid(dpyPacked),
EGLSurface, dpyPacked, configPacked, native_window, attrib_listPacked);
- return CreatePlatformWindowSurfaceEXT(thread, dpyPacked, configPacked, native_window,
- attrib_listPacked);
+ EGLSurface returnValue = CreatePlatformWindowSurfaceEXT(thread, dpyPacked, configPacked,
+ native_window, attrib_listPacked);
+ ANGLE_CAPTURE_EGL(CreatePlatformWindowSurfaceEXT, true, thread, dpyPacked, configPacked,
+ native_window, attrib_listPacked, returnValue);
+ return returnValue;
}
EGLDisplay EGLAPIENTRY EGL_GetPlatformDisplayEXT(EGLenum platform,
@@ -835,7 +936,11 @@
ANGLE_EGL_VALIDATE(thread, GetPlatformDisplayEXT, nullptr, EGLDisplay, platform, native_display,
attrib_listPacked);
- return GetPlatformDisplayEXT(thread, platform, native_display, attrib_listPacked);
+ EGLDisplay returnValue =
+ GetPlatformDisplayEXT(thread, platform, native_display, attrib_listPacked);
+ ANGLE_CAPTURE_EGL(GetPlatformDisplayEXT, true, thread, platform, native_display,
+ attrib_listPacked, returnValue);
+ return returnValue;
}
// EGL_KHR_debug
@@ -855,7 +960,10 @@
ANGLE_EGL_VALIDATE(thread, DebugMessageControlKHR, nullptr, EGLint, callback,
attrib_listPacked);
- return DebugMessageControlKHR(thread, callback, attrib_listPacked);
+ EGLint returnValue = DebugMessageControlKHR(thread, callback, attrib_listPacked);
+ ANGLE_CAPTURE_EGL(DebugMessageControlKHR, true, thread, callback, attrib_listPacked,
+ returnValue);
+ return returnValue;
}
EGLint EGLAPIENTRY EGL_LabelObjectKHR(EGLDisplay display,
@@ -878,7 +986,10 @@
ANGLE_EGL_VALIDATE(thread, LabelObjectKHR, GetDisplayIfValid(displayPacked), EGLint,
displayPacked, objectTypePacked, object, label);
- return LabelObjectKHR(thread, displayPacked, objectTypePacked, object, label);
+ EGLint returnValue = LabelObjectKHR(thread, displayPacked, objectTypePacked, object, label);
+ ANGLE_CAPTURE_EGL(LabelObjectKHR, true, thread, displayPacked, objectTypePacked, object, label,
+ returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_QueryDebugKHR(EGLint attribute, EGLAttrib *value)
@@ -892,7 +1003,9 @@
ANGLE_EGL_VALIDATE(thread, QueryDebugKHR, nullptr, EGLBoolean, attribute, value);
- return QueryDebugKHR(thread, attribute, value);
+ EGLBoolean returnValue = QueryDebugKHR(thread, attribute, value);
+ ANGLE_CAPTURE_EGL(QueryDebugKHR, true, thread, attribute, value, returnValue);
+ return returnValue;
}
// EGL_KHR_fence_sync
@@ -915,7 +1028,10 @@
ANGLE_EGL_VALIDATE(thread, ClientWaitSyncKHR, GetDisplayIfValid(dpyPacked), EGLint, dpyPacked,
syncPacked, flags, timeout);
- return ClientWaitSyncKHR(thread, dpyPacked, syncPacked, flags, timeout);
+ EGLint returnValue = ClientWaitSyncKHR(thread, dpyPacked, syncPacked, flags, timeout);
+ ANGLE_CAPTURE_EGL(ClientWaitSyncKHR, true, thread, dpyPacked, syncPacked, flags, timeout,
+ returnValue);
+ return returnValue;
}
EGLSyncKHR EGLAPIENTRY EGL_CreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list)
@@ -934,7 +1050,9 @@
ANGLE_EGL_VALIDATE(thread, CreateSyncKHR, GetDisplayIfValid(dpyPacked), EGLSyncKHR, dpyPacked,
type, attrib_listPacked);
- return CreateSyncKHR(thread, dpyPacked, type, attrib_listPacked);
+ EGLSyncKHR returnValue = CreateSyncKHR(thread, dpyPacked, type, attrib_listPacked);
+ ANGLE_CAPTURE_EGL(CreateSyncKHR, true, thread, dpyPacked, type, attrib_listPacked, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_DestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync)
@@ -952,7 +1070,9 @@
ANGLE_EGL_VALIDATE(thread, DestroySyncKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
syncPacked);
- return DestroySyncKHR(thread, dpyPacked, syncPacked);
+ EGLBoolean returnValue = DestroySyncKHR(thread, dpyPacked, syncPacked);
+ ANGLE_CAPTURE_EGL(DestroySyncKHR, true, thread, dpyPacked, syncPacked, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_GetSyncAttribKHR(EGLDisplay dpy,
@@ -975,7 +1095,10 @@
ANGLE_EGL_VALIDATE(thread, GetSyncAttribKHR, GetDisplayIfValid(dpyPacked), EGLBoolean,
dpyPacked, syncPacked, attribute, value);
- return GetSyncAttribKHR(thread, dpyPacked, syncPacked, attribute, value);
+ EGLBoolean returnValue = GetSyncAttribKHR(thread, dpyPacked, syncPacked, attribute, value);
+ ANGLE_CAPTURE_EGL(GetSyncAttribKHR, true, thread, dpyPacked, syncPacked, attribute, value,
+ returnValue);
+ return returnValue;
}
// EGL_KHR_image
@@ -1001,7 +1124,11 @@
ANGLE_EGL_VALIDATE(thread, CreateImageKHR, GetDisplayIfValid(dpyPacked), EGLImageKHR, dpyPacked,
ctxPacked, target, buffer, attrib_listPacked);
- return CreateImageKHR(thread, dpyPacked, ctxPacked, target, buffer, attrib_listPacked);
+ EGLImageKHR returnValue =
+ CreateImageKHR(thread, dpyPacked, ctxPacked, target, buffer, attrib_listPacked);
+ ANGLE_CAPTURE_EGL(CreateImageKHR, true, thread, dpyPacked, ctxPacked, target, buffer,
+ attrib_listPacked, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_DestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
@@ -1019,7 +1146,9 @@
ANGLE_EGL_VALIDATE(thread, DestroyImageKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
imagePacked);
- return DestroyImageKHR(thread, dpyPacked, imagePacked);
+ EGLBoolean returnValue = DestroyImageKHR(thread, dpyPacked, imagePacked);
+ ANGLE_CAPTURE_EGL(DestroyImageKHR, true, thread, dpyPacked, imagePacked, returnValue);
+ return returnValue;
}
// EGL_KHR_lock_surface3
@@ -1044,7 +1173,10 @@
ANGLE_EGL_VALIDATE(thread, LockSurfaceKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
surfacePacked, attrib_listPacked);
- return LockSurfaceKHR(thread, dpyPacked, surfacePacked, attrib_listPacked);
+ EGLBoolean returnValue = LockSurfaceKHR(thread, dpyPacked, surfacePacked, attrib_listPacked);
+ ANGLE_CAPTURE_EGL(LockSurfaceKHR, true, thread, dpyPacked, surfacePacked, attrib_listPacked,
+ returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_QuerySurface64KHR(EGLDisplay dpy,
@@ -1068,7 +1200,10 @@
ANGLE_EGL_VALIDATE(thread, QuerySurface64KHR, GetDisplayIfValid(dpyPacked), EGLBoolean,
dpyPacked, surfacePacked, attribute, value);
- return QuerySurface64KHR(thread, dpyPacked, surfacePacked, attribute, value);
+ EGLBoolean returnValue = QuerySurface64KHR(thread, dpyPacked, surfacePacked, attribute, value);
+ ANGLE_CAPTURE_EGL(QuerySurface64KHR, true, thread, dpyPacked, surfacePacked, attribute, value,
+ returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_UnlockSurfaceKHR(EGLDisplay dpy, EGLSurface surface)
@@ -1087,7 +1222,9 @@
ANGLE_EGL_VALIDATE(thread, UnlockSurfaceKHR, GetDisplayIfValid(dpyPacked), EGLBoolean,
dpyPacked, surfacePacked);
- return UnlockSurfaceKHR(thread, dpyPacked, surfacePacked);
+ EGLBoolean returnValue = UnlockSurfaceKHR(thread, dpyPacked, surfacePacked);
+ ANGLE_CAPTURE_EGL(UnlockSurfaceKHR, true, thread, dpyPacked, surfacePacked, returnValue);
+ return returnValue;
}
// EGL_KHR_partial_update
@@ -1112,7 +1249,10 @@
ANGLE_EGL_VALIDATE(thread, SetDamageRegionKHR, GetDisplayIfValid(dpyPacked), EGLBoolean,
dpyPacked, surfacePacked, rects, n_rects);
- return SetDamageRegionKHR(thread, dpyPacked, surfacePacked, rects, n_rects);
+ EGLBoolean returnValue = SetDamageRegionKHR(thread, dpyPacked, surfacePacked, rects, n_rects);
+ ANGLE_CAPTURE_EGL(SetDamageRegionKHR, true, thread, dpyPacked, surfacePacked, rects, n_rects,
+ returnValue);
+ return returnValue;
}
// EGL_KHR_reusable_sync
@@ -1131,7 +1271,9 @@
ANGLE_EGL_VALIDATE(thread, SignalSyncKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
syncPacked, mode);
- return SignalSyncKHR(thread, dpyPacked, syncPacked, mode);
+ EGLBoolean returnValue = SignalSyncKHR(thread, dpyPacked, syncPacked, mode);
+ ANGLE_CAPTURE_EGL(SignalSyncKHR, true, thread, dpyPacked, syncPacked, mode, returnValue);
+ return returnValue;
}
// ClientWaitSyncKHR is already defined.
@@ -1158,7 +1300,9 @@
ANGLE_EGL_VALIDATE(thread, CreateStreamKHR, GetDisplayIfValid(dpyPacked), EGLStreamKHR,
dpyPacked, attrib_listPacked);
- return CreateStreamKHR(thread, dpyPacked, attrib_listPacked);
+ EGLStreamKHR returnValue = CreateStreamKHR(thread, dpyPacked, attrib_listPacked);
+ ANGLE_CAPTURE_EGL(CreateStreamKHR, true, thread, dpyPacked, attrib_listPacked, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_DestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream)
@@ -1176,7 +1320,9 @@
ANGLE_EGL_VALIDATE(thread, DestroyStreamKHR, GetDisplayIfValid(dpyPacked), EGLBoolean,
dpyPacked, streamPacked);
- return DestroyStreamKHR(thread, dpyPacked, streamPacked);
+ EGLBoolean returnValue = DestroyStreamKHR(thread, dpyPacked, streamPacked);
+ ANGLE_CAPTURE_EGL(DestroyStreamKHR, true, thread, dpyPacked, streamPacked, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_QueryStreamKHR(EGLDisplay dpy,
@@ -1199,7 +1345,10 @@
ANGLE_EGL_VALIDATE(thread, QueryStreamKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
streamPacked, attribute, value);
- return QueryStreamKHR(thread, dpyPacked, streamPacked, attribute, value);
+ EGLBoolean returnValue = QueryStreamKHR(thread, dpyPacked, streamPacked, attribute, value);
+ ANGLE_CAPTURE_EGL(QueryStreamKHR, true, thread, dpyPacked, streamPacked, attribute, value,
+ returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_QueryStreamu64KHR(EGLDisplay dpy,
@@ -1222,7 +1371,10 @@
ANGLE_EGL_VALIDATE(thread, QueryStreamu64KHR, GetDisplayIfValid(dpyPacked), EGLBoolean,
dpyPacked, streamPacked, attribute, value);
- return QueryStreamu64KHR(thread, dpyPacked, streamPacked, attribute, value);
+ EGLBoolean returnValue = QueryStreamu64KHR(thread, dpyPacked, streamPacked, attribute, value);
+ ANGLE_CAPTURE_EGL(QueryStreamu64KHR, true, thread, dpyPacked, streamPacked, attribute, value,
+ returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_StreamAttribKHR(EGLDisplay dpy,
@@ -1244,7 +1396,10 @@
ANGLE_EGL_VALIDATE(thread, StreamAttribKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
streamPacked, attribute, value);
- return StreamAttribKHR(thread, dpyPacked, streamPacked, attribute, value);
+ EGLBoolean returnValue = StreamAttribKHR(thread, dpyPacked, streamPacked, attribute, value);
+ ANGLE_CAPTURE_EGL(StreamAttribKHR, true, thread, dpyPacked, streamPacked, attribute, value,
+ returnValue);
+ return returnValue;
}
// EGL_KHR_stream_consumer_gltexture
@@ -1263,7 +1418,9 @@
ANGLE_EGL_VALIDATE(thread, StreamConsumerAcquireKHR, GetDisplayIfValid(dpyPacked), EGLBoolean,
dpyPacked, streamPacked);
- return StreamConsumerAcquireKHR(thread, dpyPacked, streamPacked);
+ EGLBoolean returnValue = StreamConsumerAcquireKHR(thread, dpyPacked, streamPacked);
+ ANGLE_CAPTURE_EGL(StreamConsumerAcquireKHR, true, thread, dpyPacked, streamPacked, returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_StreamConsumerGLTextureExternalKHR(EGLDisplay dpy, EGLStreamKHR stream)
@@ -1282,7 +1439,10 @@
ANGLE_EGL_VALIDATE(thread, StreamConsumerGLTextureExternalKHR, GetDisplayIfValid(dpyPacked),
EGLBoolean, dpyPacked, streamPacked);
- return StreamConsumerGLTextureExternalKHR(thread, dpyPacked, streamPacked);
+ EGLBoolean returnValue = StreamConsumerGLTextureExternalKHR(thread, dpyPacked, streamPacked);
+ ANGLE_CAPTURE_EGL(StreamConsumerGLTextureExternalKHR, true, thread, dpyPacked, streamPacked,
+ returnValue);
+ return returnValue;
}
EGLBoolean EGLAPIENTRY EGL_StreamConsumerReleaseKHR(EGLDisplay dpy, EGLStreamKHR stream)
@@ -1300,7 +1460,9 @@
ANGLE_EGL_VALIDATE(thread, StreamConsumerReleaseKHR, GetDisplayIfValid(dpyPacked), EGLBoolean,
dpyPacked, streamPacked);
- return StreamConsumerReleaseKHR(thread, dpyPacked, streamPacked);
+ EGLBoolean returnValue = StreamConsumerReleaseKHR(thread, dpyPacked, streamPacked);
+ ANGLE_CAPTURE_EGL(StreamConsumerReleaseKHR, true, thread, dpyPacked, streamPacked, returnValue);
+ return returnValue;
}
// EGL_KHR_swap_buffers_with_damage
@@ -1325,7 +1487,11 @@
ANGLE_EGL_VALIDATE(thread, SwapBuffersWithDamageKHR, GetDisplayIfValid(dpyPacked), EGLBoolean,
dpyPacked, surfacePacked, rects, n_rects);
- return SwapBuffersWithDamageKHR(thread, dpyPacked, surfacePacked, rects, n_rects);
+ EGLBoolean returnValue =
+ SwapBuffersWithDamageKHR(thread, dpyPacked, surfacePacked, rects, n_rects);
+ ANGLE_CAPTURE_EGL(SwapBuffersWithDamageKHR, true, thread, dpyPacked, surfacePacked, rects,
+ n_rects, returnValue);
+ return returnValue;
}
// EGL_KHR_wait_sync
@@ -1344,7 +1510,9 @@
ANGLE_EGL_VALIDATE(thread, WaitSyncKHR, GetDisplayIfValid(dpyPacked), EGLint, dpyPacked,
syncPacked, flags);
- return WaitSyncKHR(thread, dpyPacked, syncPacked, flags);
+ EGLint returnValue = WaitSyncKHR(thread, dpyPacked, syncPacked, flags);
+ ANGLE_CAPTURE_EGL(WaitSyncKHR, true, thread, dpyPacked, syncPacked, flags, returnValue);
+ return returnValue;
}
// EGL_NV_post_sub_buffer
@@ -1371,7 +1539,10 @@
ANGLE_EGL_VALIDATE(thread, PostSubBufferNV, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked,
surfacePacked, x, y, width, height);
- return PostSubBufferNV(thread, dpyPacked, surfacePacked, x, y, width, height);
+ EGLBoolean returnValue = PostSubBufferNV(thread, dpyPacked, surfacePacked, x, y, width, height);
+ ANGLE_CAPTURE_EGL(PostSubBufferNV, true, thread, dpyPacked, surfacePacked, x, y, width, height,
+ returnValue);
+ return returnValue;
}
// EGL_NV_stream_consumer_gltexture_yuv
@@ -1396,8 +1567,11 @@
GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, streamPacked,
attrib_listPacked);
- return StreamConsumerGLTextureExternalAttribsNV(thread, dpyPacked, streamPacked,
- attrib_listPacked);
+ EGLBoolean returnValue = StreamConsumerGLTextureExternalAttribsNV(
+ thread, dpyPacked, streamPacked, attrib_listPacked);
+ ANGLE_CAPTURE_EGL(StreamConsumerGLTextureExternalAttribsNV, true, thread, dpyPacked,
+ streamPacked, attrib_listPacked, returnValue);
+ return returnValue;
}
} // extern "C"
