зеркало из https://github.com/AvaloniaUI/angle.git
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>
This commit is contained in:
Jamie Madill
Angle LUCI CQ
Родитель
7c4dc25328
Коммит
2265e37bf9
|
|
@ -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":
|
||||
|
|
|
|||
|
|
@ -180,7 +180,7 @@ void GL_APIENTRY GL_{name}({params})
|
|||
{{
|
||||
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 @@ TEMPLATE_GLES_ENTRY_POINT_WITH_RETURN = """\
|
|||
{{
|
||||
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 @@ void EGLAPIENTRY EGL_{name}({params})
|
|||
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 @@ TEMPLATE_EGL_ENTRY_POINT_WITH_RETURN = """\
|
|||
|
||||
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 @@ TEMPLATE_CAPTURE_HEADER = """\
|
|||
#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 @@ TEMPLATE_CAPTURE_SOURCE = """\
|
|||
|
||||
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 @@ CallCapture Capture{short_name}({params_with_type}, {return_value_type_original}
|
|||
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_HEADER_INCLUDES = """\
|
|||
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_HEADER_INCLUDES = """\
|
|||
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 @@ EGL_PACKED_TYPES = {
|
|||
"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 @@ def format_entry_point_def(api, command_node, cmd_name, proto, params, cmd_packe
|
|||
", ".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 get_capture_param_type_name(param_type):
|
|||
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 @@ def format_capture_method(api, command, cmd_name, proto, params, all_param_types
|
|||
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 @@ def format_capture_method(api, command, cmd_name, proto, params, all_param_types
|
|||
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_validation_proto(api, cmd_name, proto, params, cmd_packed_gl_enums, p
|
|||
|
||||
|
||||
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 @@ class ANGLEEntryPoints(registry_xml.EntryPoints):
|
|||
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 @@ def write_gl_validation_header(annotation, comment, protos, source):
|
|||
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 @@ def write_capture_header(annotation, comment, protos, capture_pointer_funcs):
|
|||
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 write_capture_source(annotation_with_dash, annotation_no_dash, comment, capt
|
|||
|
||||
|
||||
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 is_id_pointer_type(t):
|
|||
|
||||
|
||||
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 @@ def main():
|
|||
'../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 @@ def main():
|
|||
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 @@ def main():
|
|||
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 @@ def main():
|
|||
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 @@ def main():
|
|||
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 @@ def main():
|
|||
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 @@ def main():
|
|||
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 @@ def main():
|
|||
|
||||
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")
|
||||
|
|
|
|||
|
|
@ -129,6 +129,7 @@ AttributeMap AttributeMap::CreateFromIntArray(const EGLint *attributes)
|
|||
{
|
||||
AttributeMap map;
|
||||
map.mIntPointer = attributes;
|
||||
map.mMapType = AttributeMapType::Int;
|
||||
return map;
|
||||
}
|
||||
|
||||
|
|
@ -137,6 +138,7 @@ AttributeMap AttributeMap::CreateFromAttribArray(const EGLAttrib *attributes)
|
|||
{
|
||||
AttributeMap map;
|
||||
map.mAttribPointer = attributes;
|
||||
map.mMapType = AttributeMapType::Attrib;
|
||||
return map;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -24,6 +24,13 @@ struct ValidationContext;
|
|||
using AttributeValidationFunc =
|
||||
std::function<bool(const ValidationContext *, const Display *, EGLAttrib)>;
|
||||
|
||||
enum AttributeMapType
|
||||
{
|
||||
Invalid,
|
||||
Attrib,
|
||||
Int,
|
||||
};
|
||||
|
||||
class AttributeMap final
|
||||
{
|
||||
public:
|
||||
|
|
@ -76,6 +83,8 @@ class AttributeMap final
|
|||
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 @@ class AttributeMap final
|
|||
mutable const EGLint *mIntPointer = nullptr;
|
||||
mutable const EGLAttrib *mAttribPointer = nullptr;
|
||||
mutable Map mValidatedAttributes;
|
||||
mutable AttributeMapType mMapType = AttributeMapType::Invalid;
|
||||
};
|
||||
} // namespace egl
|
||||
|
||||
|
|
|
|||
|
|
@ -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 @@ void CaptureShareGroupMidExecutionSetup(
|
|||
|
||||
// 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 @@ bool SkipCall(EntryPoint entryPoint)
|
|||
// - 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 @@ void FrameCaptureShared::maybeCaptureDrawElementsClientData(const gl::Context *c
|
|||
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 @@ void FrameCaptureShared::maybeCapturePreCallUpdates(
|
|||
}
|
||||
|
||||
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 @@ void FrameCaptureShared::writeMainContextCppReplay(const gl::Context *context,
|
|||
|
||||
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 @@ void FrameCaptureShared::writeMainContextCppReplay(const gl::Context *context,
|
|||
// 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 @@ void FrameCaptureShared::writeMainContextCppReplay(const gl::Context *context,
|
|||
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 @@ void WriteParamValueReplay<ParamType::TEGLDEBUGPROCKHR>(std::ostream &os,
|
|||
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 @@ void WriteParamValueReplay<ParamType::TEGLGetBlobFuncANDROID>(std::ostream &os,
|
|||
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 @@ void WriteParamValueReplay<ParamType::TEGLSetBlobFuncANDROID>(std::ostream &os,
|
|||
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 @@ std::vector<std::string> ReplayWriter::getAndResetWrittenFiles()
|
|||
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
|
||||
|
|
|
|||
|
|
@ -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 @@ class FrameCaptureShared final : angle::NonCopyable
|
|||
};
|
||||
|
||||
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 @@ void CaptureCallToFrameCapture(CaptureFuncT captureFunc,
|
|||
}
|
||||
|
||||
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)
|
||||
{
|
||||
|
|
@ -1148,6 +1171,11 @@ void WriteParamValueReplay<ParamType::Tegl_DisplayPointer>(std::ostream &os,
|
|||
const CallCapture &call,
|
||||
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,
|
||||
|
|
@ -1182,6 +1210,26 @@ void WriteParamValueReplay<ParamType::Tegl_SurfacePointer>(std::ostream &os,
|
|||
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 @@ void CaptureTextureAndSamplerParameter_params(GLenum pname,
|
|||
}
|
||||
}
|
||||
|
||||
namespace egl
|
||||
{
|
||||
angle::ParamCapture CaptureAttributeMap(const egl::AttributeMap &attribMap);
|
||||
} // namespace egl
|
||||
|
||||
#endif // LIBANGLE_FRAME_CAPTURE_H_
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
@ -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_
|
||||
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
|
|
@ -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_
|
||||
|
|
@ -21,7 +21,6 @@ namespace gl
|
|||
{
|
||||
|
||||
// GL 1.0
|
||||
|
||||
CallCapture CaptureAccum(const State &glState, bool isCallValid, GLenum op, GLfloat value)
|
||||
{
|
||||
ParamBuffer paramBuffer;
|
||||
|
|
@ -4458,7 +4457,6 @@ CallCapture CaptureVertex4sv(const State &glState, bool isCallValid, const GLsho
|
|||
}
|
||||
|
||||
// GL 1.1
|
||||
|
||||
CallCapture CaptureAreTexturesResident(const State &glState,
|
||||
bool isCallValid,
|
||||
GLsizei n,
|
||||
|
|
@ -4783,7 +4781,6 @@ CallCapture CaptureTexSubImage1D(const State &glState,
|
|||
// GL 1.2
|
||||
|
||||
// GL 1.3
|
||||
|
||||
CallCapture CaptureCompressedTexImage1D(const State &glState,
|
||||
bool isCallValid,
|
||||
GLenum target,
|
||||
|
|
@ -5638,7 +5635,6 @@ CallCapture CaptureMultiTexCoord4sv(const State &glState,
|
|||
}
|
||||
|
||||
// GL 1.4
|
||||
|
||||
CallCapture CaptureFogCoordPointer(const State &glState,
|
||||
bool isCallValid,
|
||||
GLenum type,
|
||||
|
|
@ -6470,7 +6466,6 @@ CallCapture CaptureWindowPos3sv(const State &glState, bool isCallValid, const GL
|
|||
}
|
||||
|
||||
// GL 1.5
|
||||
|
||||
CallCapture CaptureGetBufferSubData(const State &glState,
|
||||
bool isCallValid,
|
||||
GLenum target,
|
||||
|
|
|
|||
|
|
@ -21,7 +21,6 @@ namespace gl
|
|||
{
|
||||
|
||||
// GL 2.0
|
||||
|
||||
CallCapture CaptureGetVertexAttribdv(const State &glState,
|
||||
bool isCallValid,
|
||||
GLuint index,
|
||||
|
|
|
|||
|
|
@ -21,7 +21,6 @@ namespace gl
|
|||
{
|
||||
|
||||
// GL 3.0
|
||||
|
||||
CallCapture CaptureBeginConditionalRender(const State &glState,
|
||||
bool isCallValid,
|
||||
GLuint id,
|
||||
|
|
@ -479,7 +478,6 @@ CallCapture CaptureVertexAttribI4usv(const State &glState,
|
|||
}
|
||||
|
||||
// GL 3.1
|
||||
|
||||
CallCapture CaptureGetActiveUniformName(const State &glState,
|
||||
bool isCallValid,
|
||||
ShaderProgramID programPacked,
|
||||
|
|
@ -539,7 +537,6 @@ CallCapture CapturePrimitiveRestartIndex(const State &glState, bool isCallValid,
|
|||
}
|
||||
|
||||
// GL 3.2
|
||||
|
||||
CallCapture CaptureMultiDrawElementsBaseVertex(const State &glState,
|
||||
bool isCallValid,
|
||||
PrimitiveMode modePacked,
|
||||
|
|
@ -669,7 +666,6 @@ CallCapture CaptureTexImage3DMultisample(const State &glState,
|
|||
}
|
||||
|
||||
// GL 3.3
|
||||
|
||||
CallCapture CaptureBindFragDataLocationIndexed(const State &glState,
|
||||
bool isCallValid,
|
||||
ShaderProgramID programPacked,
|
||||
|
|
|
|||
|
|
@ -21,7 +21,6 @@ namespace gl
|
|||
{
|
||||
|
||||
// GL 4.0
|
||||
|
||||
CallCapture CaptureBeginQueryIndexed(const State &glState,
|
||||
bool isCallValid,
|
||||
GLenum target,
|
||||
|
|
@ -931,7 +930,6 @@ CallCapture CaptureUniformSubroutinesuiv(const State &glState,
|
|||
}
|
||||
|
||||
// GL 4.1
|
||||
|
||||
CallCapture CaptureDepthRangeArrayv(const State &glState,
|
||||
bool isCallValid,
|
||||
GLuint first,
|
||||
|
|
@ -1923,7 +1921,6 @@ CallCapture CaptureViewportIndexedfv(const State &glState,
|
|||
}
|
||||
|
||||
// GL 4.2
|
||||
|
||||
CallCapture CaptureDrawArraysInstancedBaseInstance(const State &glState,
|
||||
bool isCallValid,
|
||||
PrimitiveMode modePacked,
|
||||
|
|
@ -2108,7 +2105,6 @@ CallCapture CaptureTexStorage1D(const State &glState,
|
|||
}
|
||||
|
||||
// GL 4.3
|
||||
|
||||
CallCapture CaptureClearBufferData(const State &glState,
|
||||
bool isCallValid,
|
||||
GLenum target,
|
||||
|
|
@ -2446,7 +2442,6 @@ CallCapture CaptureVertexAttribLFormat(const State &glState,
|
|||
}
|
||||
|
||||
// GL 4.4
|
||||
|
||||
CallCapture CaptureBindBuffersBase(const State &glState,
|
||||
bool isCallValid,
|
||||
GLenum target,
|
||||
|
|
@ -2811,7 +2806,6 @@ CallCapture CaptureClearTexSubImage(const State &glState,
|
|||
}
|
||||
|
||||
// GL 4.5
|
||||
|
||||
CallCapture CaptureBindTextureUnit(const State &glState,
|
||||
bool isCallValid,
|
||||
GLuint unit,
|
||||
|
|
@ -5961,7 +5955,6 @@ CallCapture CaptureVertexArrayVertexBuffers(const State &glState,
|
|||
}
|
||||
|
||||
// GL 4.6
|
||||
|
||||
CallCapture CaptureMultiDrawArraysIndirectCount(const State &glState,
|
||||
bool isCallValid,
|
||||
GLenum mode,
|
||||
|
|
|
|||
|
|
@ -19,7 +19,6 @@ using namespace angle;
|
|||
|
||||
namespace gl
|
||||
{
|
||||
|
||||
CallCapture CaptureAlphaFunc(const State &glState,
|
||||
bool isCallValid,
|
||||
AlphaTestFunc funcPacked,
|
||||
|
|
|
|||
|
|
@ -19,7 +19,6 @@ using namespace angle;
|
|||
|
||||
namespace gl
|
||||
{
|
||||
|
||||
CallCapture CaptureActiveTexture(const State &glState, bool isCallValid, GLenum texture)
|
||||
{
|
||||
ParamBuffer paramBuffer;
|
||||
|
|
|
|||
|
|
@ -19,7 +19,6 @@ using namespace angle;
|
|||
|
||||
namespace gl
|
||||
{
|
||||
|
||||
CallCapture CaptureBeginQuery(const State &glState,
|
||||
bool isCallValid,
|
||||
QueryType targetPacked,
|
||||
|
|
|
|||
|
|
@ -19,7 +19,6 @@ using namespace angle;
|
|||
|
||||
namespace gl
|
||||
{
|
||||
|
||||
CallCapture CaptureActiveShaderProgram(const State &glState,
|
||||
bool isCallValid,
|
||||
ProgramPipelineID pipelinePacked,
|
||||
|
|
|
|||
|
|
@ -19,7 +19,6 @@ using namespace angle;
|
|||
|
||||
namespace gl
|
||||
{
|
||||
|
||||
CallCapture CaptureBlendBarrier(const State &glState, bool isCallValid)
|
||||
{
|
||||
ParamBuffer paramBuffer;
|
||||
|
|
|
|||
|
|
@ -19,7 +19,6 @@ using namespace angle;
|
|||
|
||||
namespace gl
|
||||
{
|
||||
|
||||
CallCapture CaptureBeginPerfMonitorAMD(const State &glState, bool isCallValid, GLuint monitor)
|
||||
{
|
||||
ParamBuffer paramBuffer;
|
||||
|
|
|
|||
|
|
@ -71,6 +71,9 @@ void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const Pa
|
|||
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 @@ void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const Pa
|
|||
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 @@ void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const Pa
|
|||
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 @@ void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const Pa
|
|||
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 @@ const char *ParamTypeToString(ParamType paramType)
|
|||
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:
|
||||
|
|
|
|||
|
|
@ -31,18 +31,28 @@ enum class ParamType
|
|||
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 @@ enum class ParamType
|
|||
TvoidPointerPointer,
|
||||
};
|
||||
|
||||
constexpr uint32_t kParamTypeCount = 160;
|
||||
constexpr uint32_t kParamTypeCount = 170;
|
||||
|
||||
union ParamValue
|
||||
{
|
||||
|
|
@ -197,18 +207,28 @@ union ParamValue
|
|||
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;
|
||||
|
|
@ -444,6 +464,12 @@ inline EGLAttrib *GetParamVal<ParamType::TEGLAttribPointer, EGLAttrib *>(const P
|
|||
return value.EGLAttribPointerVal;
|
||||
}
|
||||
|
||||
template <>
|
||||
inline EGLBoolean GetParamVal<ParamType::TEGLBoolean, EGLBoolean>(const ParamValue &value)
|
||||
{
|
||||
return value.EGLBooleanVal;
|
||||
}
|
||||
|
||||
template <>
|
||||
inline EGLBoolean *GetParamVal<ParamType::TEGLBooleanPointer, EGLBoolean *>(const ParamValue &value)
|
||||
{
|
||||
|
|
@ -463,6 +489,12 @@ inline EGLConfig *GetParamVal<ParamType::TEGLConfigPointer, EGLConfig *>(const P
|
|||
return value.EGLConfigPointerVal;
|
||||
}
|
||||
|
||||
template <>
|
||||
inline EGLContext GetParamVal<ParamType::TEGLContext, EGLContext>(const ParamValue &value)
|
||||
{
|
||||
return value.EGLContextVal;
|
||||
}
|
||||
|
||||
template <>
|
||||
inline EGLDEBUGPROCKHR GetParamVal<ParamType::TEGLDEBUGPROCKHR, EGLDEBUGPROCKHR>(
|
||||
const ParamValue &value)
|
||||
|
|
@ -470,6 +502,18 @@ inline EGLDEBUGPROCKHR GetParamVal<ParamType::TEGLDEBUGPROCKHR, EGLDEBUGPROCKHR>
|
|||
return value.EGLDEBUGPROCKHRVal;
|
||||
}
|
||||
|
||||
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)
|
||||
|
|
@ -484,6 +528,18 @@ inline EGLGetBlobFuncANDROID GetParamVal<ParamType::TEGLGetBlobFuncANDROID, EGLG
|
|||
return value.EGLGetBlobFuncANDROIDVal;
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
|
|
@ -524,6 +580,30 @@ inline EGLSetBlobFuncANDROID GetParamVal<ParamType::TEGLSetBlobFuncANDROID, EGLS
|
|||
return value.EGLSetBlobFuncANDROIDVal;
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
|
|
@ -1449,18 +1529,30 @@ T AccessParamValue(ParamType paramType, const ParamValue &value)
|
|||
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 @@ T AccessParamValue(ParamType paramType, const ParamValue &value)
|
|||
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:
|
||||
|
|
@ -1840,6 +1940,12 @@ inline void SetParamVal<ParamType::TEGLAttribPointer>(EGLAttrib *valueIn, ParamV
|
|||
valueOut->EGLAttribPointerVal = valueIn;
|
||||
}
|
||||
|
||||
template <>
|
||||
inline void SetParamVal<ParamType::TEGLBoolean>(EGLBoolean valueIn, ParamValue *valueOut)
|
||||
{
|
||||
valueOut->EGLBooleanVal = valueIn;
|
||||
}
|
||||
|
||||
template <>
|
||||
inline void SetParamVal<ParamType::TEGLBooleanPointer>(EGLBoolean *valueIn, ParamValue *valueOut)
|
||||
{
|
||||
|
|
@ -1858,12 +1964,30 @@ inline void SetParamVal<ParamType::TEGLConfigPointer>(EGLConfig *valueIn, ParamV
|
|||
valueOut->EGLConfigPointerVal = valueIn;
|
||||
}
|
||||
|
||||
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)
|
||||
|
|
@ -1878,6 +2002,18 @@ inline void SetParamVal<ParamType::TEGLGetBlobFuncANDROID>(EGLGetBlobFuncANDROID
|
|||
valueOut->EGLGetBlobFuncANDROIDVal = valueIn;
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
|
|
@ -1918,6 +2054,30 @@ inline void SetParamVal<ParamType::TEGLSetBlobFuncANDROID>(EGLSetBlobFuncANDROID
|
|||
valueOut->EGLSetBlobFuncANDROIDVal = valueIn;
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
|
|
@ -2831,6 +2991,9 @@ void InitParamValue(ParamType paramType, T valueIn, ParamValue *valueOut)
|
|||
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 @@ void InitParamValue(ParamType paramType, T valueIn, ParamValue *valueOut)
|
|||
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 @@ void InitParamValue(ParamType paramType, T valueIn, ParamValue *valueOut)
|
|||
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;
|
||||
|
|
|
|||
|
|
@ -110,7 +110,7 @@ extern EGLImageMap gEGLImageMap;
|
|||
// 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 UpdateShaderProgramID(GLuint id, GLsizei readBufferOffset);
|
|||
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);
|
||||
|
|
|
|||
|
|
@ -91,11 +91,9 @@ constexpr ANGLE_INLINE ReturnType GetDefaultReturnValue()
|
|||
}
|
||||
|
||||
#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 @@ inline int CID(EGLDisplay display, EGLContext context)
|
|||
}
|
||||
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_
|
||||
|
|
|
|||
|
|
@ -543,7 +543,7 @@ libangle_mac_sources = [
|
|||
# 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_sources += [
|
|||
|
||||
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",
|
||||
|
|
|
|||
|
|
@ -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 @@ EGLImageKHR CreateImageKHR(Thread *thread,
|
|||
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 @@ EGLClientBuffer CreateNativeClientBufferANDROID(Thread *thread, const AttributeM
|
|||
egl::Display::CreateNativeClientBuffer(attribMap, &eglClientBuffer),
|
||||
"eglCreateNativeClientBufferANDROID", nullptr, nullptr);
|
||||
|
||||
ANGLE_CAPTURE_EGL(CreateNativeClientBufferANDROID, thread, attribMap, eglClientBuffer);
|
||||
|
||||
thread->setSuccess();
|
||||
return eglClientBuffer;
|
||||
}
|
||||
|
|
@ -157,8 +151,6 @@ EGLBoolean DestroyImageKHR(Thread *thread, Display *display, Image *img)
|
|||
GetDisplayIfValid(display), EGL_FALSE);
|
||||
display->destroyImage(img);
|
||||
|
||||
ANGLE_CAPTURE_EGL(EGLDestroyImage, thread, display, img);
|
||||
|
||||
thread->setSuccess();
|
||||
return EGL_TRUE;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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 @@ EGLBoolean BindTexImage(Thread *thread, Display *display, Surface *eglSurface, E
|
|||
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 @@ EGLImage CreateImage(Thread *thread,
|
|||
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 @@ EGLSurface CreatePbufferSurface(Thread *thread,
|
|||
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 @@ EGLBoolean DestroyImage(Thread *thread, Display *display, Image *img)
|
|||
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 @@ EGLBoolean MakeCurrent(Thread *thread,
|
|||
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 @@ EGLBoolean ReleaseTexImage(Thread *thread, Display *display, Surface *eglSurface
|
|||
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();
|
||||
|
|
|
|||
|
|
@ -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 @@ EGLBoolean EGLAPIENTRY EGL_ChooseConfig(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_CopyBuffers(EGLDisplay dpy,
|
|||
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 @@ EGLContext EGLAPIENTRY EGL_CreateContext(EGLDisplay dpy,
|
|||
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 @@ EGLSurface EGLAPIENTRY EGL_CreatePbufferSurface(EGLDisplay dpy,
|
|||
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 @@ EGLSurface EGLAPIENTRY EGL_CreatePixmapSurface(EGLDisplay dpy,
|
|||
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 @@ EGLSurface EGLAPIENTRY EGL_CreateWindowSurface(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_DestroyContext(EGLDisplay dpy, EGLContext ctx)
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_DestroySurface(EGLDisplay dpy, EGLSurface surface)
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_GetConfigAttrib(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_GetConfigs(EGLDisplay dpy,
|
|||
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 @@ EGLDisplay EGLAPIENTRY EGL_GetCurrentDisplay()
|
|||
|
||||
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 @@ EGLSurface EGLAPIENTRY EGL_GetCurrentSurface(EGLint readdraw)
|
|||
|
||||
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 @@ EGLDisplay EGLAPIENTRY EGL_GetDisplay(EGLNativeDisplayType display_id)
|
|||
|
||||
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 @@ EGLint EGLAPIENTRY EGL_GetError()
|
|||
|
||||
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 @@ __eglMustCastToProperFunctionPointerType EGLAPIENTRY EGL_GetProcAddress(const ch
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_Initialize(EGLDisplay dpy, EGLint *major, EGLint *min
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_MakeCurrent(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_QueryContext(EGLDisplay dpy,
|
|||
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 @@ const char *EGLAPIENTRY EGL_QueryString(EGLDisplay dpy, EGLint name)
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_QuerySurface(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_SwapBuffers(EGLDisplay dpy, EGLSurface surface)
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_Terminate(EGLDisplay dpy)
|
|||
|
||||
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 @@ EGLBoolean EGLAPIENTRY EGL_WaitGL()
|
|||
|
||||
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 @@ EGLBoolean EGLAPIENTRY EGL_WaitNative(EGLint engine)
|
|||
|
||||
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 @@ EGLBoolean EGLAPIENTRY EGL_BindTexImage(EGLDisplay dpy, EGLSurface surface, EGLi
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_ReleaseTexImage(EGLDisplay dpy, EGLSurface surface, E
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_SurfaceAttrib(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_SwapInterval(EGLDisplay dpy, EGLint interval)
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_BindAPI(EGLenum api)
|
|||
|
||||
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 @@ EGLSurface EGLAPIENTRY EGL_CreatePbufferFromClientBuffer(EGLDisplay dpy,
|
|||
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 @@ EGLenum EGLAPIENTRY EGL_QueryAPI()
|
|||
|
||||
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 @@ EGLBoolean EGLAPIENTRY EGL_ReleaseThread()
|
|||
|
||||
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 @@ EGLBoolean EGLAPIENTRY EGL_WaitClient()
|
|||
|
||||
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 @@ EGLContext EGLAPIENTRY EGL_GetCurrentContext()
|
|||
|
||||
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 @@ EGLint EGLAPIENTRY EGL_ClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags
|
|||
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 @@ EGLImage EGLAPIENTRY EGL_CreateImage(EGLDisplay dpy,
|
|||
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 @@ EGLSurface EGLAPIENTRY EGL_CreatePlatformPixmapSurface(EGLDisplay dpy,
|
|||
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 @@ EGLSurface EGLAPIENTRY EGL_CreatePlatformWindowSurface(EGLDisplay dpy,
|
|||
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 @@ EGLSync EGLAPIENTRY EGL_CreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_DestroyImage(EGLDisplay dpy, EGLImage image)
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_DestroySync(EGLDisplay dpy, EGLSync sync)
|
|||
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 @@ EGLDisplay EGLAPIENTRY EGL_GetPlatformDisplay(EGLenum platform,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_GetSyncAttrib(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_WaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags)
|
|||
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"
|
||||
|
|
|
|||
|
|
@ -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 @@ void EGLAPIENTRY EGL_SetBlobCacheFuncsANDROID(EGLDisplay dpy,
|
|||
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 @@ EGLClientBuffer EGLAPIENTRY EGL_CreateNativeClientBufferANDROID(const EGLint *at
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_GetCompositorTimingSupportedANDROID(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_GetCompositorTimingANDROID(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_GetNextFrameIdANDROID(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_GetFrameTimestampSupportedANDROID(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_GetFrameTimestampsANDROID(EGLDisplay dpy,
|
|||
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 @@ EGLClientBuffer EGLAPIENTRY EGL_GetNativeClientBufferANDROID(const struct AHardw
|
|||
|
||||
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 @@ EGLint EGLAPIENTRY EGL_DupNativeFenceFDANDROID(EGLDisplay dpy, EGLSyncKHR sync)
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_PresentationTimeANDROID(EGLDisplay dpy,
|
|||
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 @@ EGLDeviceEXT EGLAPIENTRY EGL_CreateDeviceANGLE(EGLint device_type,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_ReleaseDeviceANGLE(EGLDeviceEXT device)
|
|||
|
||||
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 @@ const char *EGLAPIENTRY EGL_QueryStringiANGLE(EGLDisplay dpy, EGLint name, EGLin
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_QueryDisplayAttribANGLE(EGLDisplay dpy,
|
|||
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 @@ void *EGLAPIENTRY EGL_CopyMetalSharedEventANGLE(EGLDisplay dpy, EGLSyncKHR sync)
|
|||
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 @@ void EGLAPIENTRY EGL_ReleaseHighPowerGPUANGLE(EGLDisplay dpy, EGLContext ctx)
|
|||
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 @@ void EGLAPIENTRY EGL_ReacquireHighPowerGPUANGLE(EGLDisplay dpy, EGLContext ctx)
|
|||
dpyPacked, ctxPacked);
|
||||
|
||||
ReacquireHighPowerGPUANGLE(thread, dpyPacked, ctxPacked);
|
||||
ANGLE_CAPTURE_EGL(ReacquireHighPowerGPUANGLE, true, thread, dpyPacked, ctxPacked);
|
||||
}
|
||||
|
||||
void EGLAPIENTRY EGL_HandleGPUSwitchANGLE(EGLDisplay dpy)
|
||||
|
|
@ -381,6 +424,7 @@ void EGLAPIENTRY EGL_HandleGPUSwitchANGLE(EGLDisplay dpy)
|
|||
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 @@ void EGLAPIENTRY EGL_ForceGPUSwitchANGLE(EGLDisplay dpy, EGLint gpuIDHigh, EGLin
|
|||
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 @@ EGLint EGLAPIENTRY EGL_ProgramCacheGetAttribANGLE(EGLDisplay dpy, EGLenum attrib
|
|||
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 @@ void EGLAPIENTRY EGL_ProgramCacheQueryANGLE(EGLDisplay dpy,
|
|||
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 @@ void EGLAPIENTRY EGL_ProgramCachePopulateANGLE(EGLDisplay dpy,
|
|||
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 @@ EGLint EGLAPIENTRY EGL_ProgramCacheResizeANGLE(EGLDisplay dpy, EGLint limit, EGL
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_QuerySurfacePointerANGLE(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_CreateStreamProducerD3DTextureANGLE(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_StreamPostD3DTextureANGLE(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_SwapBuffersWithFrameTokenANGLE(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_GetMscRateANGLE(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_ExportVkImageANGLE(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_GetSyncValuesCHROMIUM(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_QueryDeviceAttribEXT(EGLDeviceEXT device,
|
|||
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 @@ const char *EGLAPIENTRY EGL_QueryDeviceStringEXT(EGLDeviceEXT device, EGLint nam
|
|||
|
||||
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 @@ EGLBoolean EGLAPIENTRY EGL_QueryDisplayAttribEXT(EGLDisplay dpy, EGLint attribut
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_QueryDmaBufFormatsEXT(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_QueryDmaBufModifiersEXT(EGLDisplay dpy,
|
|||
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 @@ EGLSurface EGLAPIENTRY EGL_CreatePlatformPixmapSurfaceEXT(EGLDisplay dpy,
|
|||
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 @@ EGLSurface EGLAPIENTRY EGL_CreatePlatformWindowSurfaceEXT(EGLDisplay dpy,
|
|||
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 @@ EGLDisplay EGLAPIENTRY EGL_GetPlatformDisplayEXT(EGLenum platform,
|
|||
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 @@ EGLint EGLAPIENTRY EGL_DebugMessageControlKHR(EGLDEBUGPROCKHR callback,
|
|||
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 @@ EGLint EGLAPIENTRY EGL_LabelObjectKHR(EGLDisplay display,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_QueryDebugKHR(EGLint attribute, EGLAttrib *value)
|
|||
|
||||
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 @@ EGLint EGLAPIENTRY EGL_ClientWaitSyncKHR(EGLDisplay dpy,
|
|||
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 @@ EGLSyncKHR EGLAPIENTRY EGL_CreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGL
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_DestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync)
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_GetSyncAttribKHR(EGLDisplay dpy,
|
|||
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 @@ EGLImageKHR EGLAPIENTRY EGL_CreateImageKHR(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_DestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_LockSurfaceKHR(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_QuerySurface64KHR(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_UnlockSurfaceKHR(EGLDisplay dpy, EGLSurface surface)
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_SetDamageRegionKHR(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_SignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenu
|
|||
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 @@ EGLStreamKHR EGLAPIENTRY EGL_CreateStreamKHR(EGLDisplay dpy, const EGLint *attri
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_DestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream)
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_QueryStreamKHR(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_QueryStreamu64KHR(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_StreamAttribKHR(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_StreamConsumerAcquireKHR(EGLDisplay dpy, EGLStreamKHR
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_StreamConsumerGLTextureExternalKHR(EGLDisplay dpy, EG
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_StreamConsumerReleaseKHR(EGLDisplay dpy, EGLStreamKHR
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_SwapBuffersWithDamageKHR(EGLDisplay dpy,
|
|||
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 @@ EGLint EGLAPIENTRY EGL_WaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_PostSubBufferNV(EGLDisplay dpy,
|
|||
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 @@ EGLBoolean EGLAPIENTRY EGL_StreamConsumerGLTextureExternalAttribsNV(EGLDisplay d
|
|||
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"
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче