diff --git a/scripts/code_generation_hashes/GL_EGL_entry_points.json b/scripts/code_generation_hashes/GL_EGL_entry_points.json index 69ebc828e..e63905439 100644 --- a/scripts/code_generation_hashes/GL_EGL_entry_points.json +++ b/scripts/code_generation_hashes/GL_EGL_entry_points.json @@ -6,7 +6,7 @@ "scripts/entry_point_packed_gl_enums.json": "44a89e71f42598b0596ef4c25b290dff", "scripts/generate_entry_points.py": - "18dd48631e551dcadf8b687953d3c6cb", + "679167787fd12c1ec3cbac70957c08df", "scripts/gl_angle_ext.xml": "8dd9662655c39ce22fecdc2449594e54", "scripts/registry_xml.py": @@ -35,52 +35,56 @@ "48567dca16fd881dfe6d61fee0e3106f", "src/libANGLE/Context_gles_ext_autogen.h": "0d065fb2339cc6b6e154d002502192c1", + "src/libANGLE/capture/capture_egl_autogen.cpp": + "96116af910de967f275d18f5a3dc2d42", + "src/libANGLE/capture/capture_egl_autogen.h": + "fae4b722da10aceb3cad63d067164940", "src/libANGLE/capture/capture_gl_1_autogen.cpp": - "f9bf8c9d8af9c097031be92ea3e805b5", + "5dfd57aea4a672d42fb4fd4df332709c", "src/libANGLE/capture/capture_gl_1_autogen.h": "48ab591d9671ea49aa9ae977b6a0d2fb", "src/libANGLE/capture/capture_gl_2_autogen.cpp": - "2fb35570619b2e7a2088e523d0017b15", + "8e4d812520a8f17c5ce1f006e7cacb09", "src/libANGLE/capture/capture_gl_2_autogen.h": "1e5b7623566fe1282567e3b31cddbee1", "src/libANGLE/capture/capture_gl_3_autogen.cpp": - "257e0e9b36c2111165122799054b6277", + "423e570a7f2264ca30b5d936505e24d0", "src/libANGLE/capture/capture_gl_3_autogen.h": "32e061964a2bccfc27dc95eb1a69558e", "src/libANGLE/capture/capture_gl_4_autogen.cpp": - "334403c06a9ae7b5a537ca762dfb32ff", + "9b160c5e3df64deb3d190d7c82d7dbd2", "src/libANGLE/capture/capture_gl_4_autogen.h": "985366fe10b1e96e557a84d26769a042", "src/libANGLE/capture/capture_gles_1_0_autogen.cpp": - "79678697323312af94be6a41cce62cc4", + "9c920afc742fd77145172494faa42146", "src/libANGLE/capture/capture_gles_1_0_autogen.h": "141838b474dda3d9a6122e73d3621972", "src/libANGLE/capture/capture_gles_2_0_autogen.cpp": - "80e9dd0750299f2ada17042bf0c337f9", + "44079a951893f3bd2424946f40b371d8", "src/libANGLE/capture/capture_gles_2_0_autogen.h": "73d813905e7e938cf11d1722f98de84b", "src/libANGLE/capture/capture_gles_3_0_autogen.cpp": - "124063a757419fa0246948e141312768", + "2030b9d08eecf9ec0ee960bd2af25a76", "src/libANGLE/capture/capture_gles_3_0_autogen.h": "c5bff0201be9dc51fdb507a63dd9d8f8", "src/libANGLE/capture/capture_gles_3_1_autogen.cpp": - "c94c8573246f3c281d3a4b68e8a3301a", + "071260877f00a8841751f3cd309069d3", "src/libANGLE/capture/capture_gles_3_1_autogen.h": "414b92fe8db95146d8af3c13830e3685", "src/libANGLE/capture/capture_gles_3_2_autogen.cpp": - "1c8511a8acf5a58bded506939dad0fef", + "3cdbd40c4f971a7770076326bfce51c7", "src/libANGLE/capture/capture_gles_3_2_autogen.h": "74ed7366af3a46c0661397cfa29ec6fc", "src/libANGLE/capture/capture_gles_ext_autogen.cpp": - "f332b5e5e0573f3f9f6887afb663a5c4", + "b9cae90fe442c5a5c081bfbcd3413a78", "src/libANGLE/capture/capture_gles_ext_autogen.h": "d9bb79d32a32b331dac93956065c0b66", "src/libANGLE/capture/frame_capture_replay_autogen.cpp": "f1c2b5949709f05f71aeddee6d00d701", "src/libANGLE/capture/frame_capture_utils_autogen.cpp": - "c87dd3000aef4270b40b98deeb497144", + "c332b27634067cc044b78b3d0de700ce", "src/libANGLE/capture/frame_capture_utils_autogen.h": - "5bcab4ec3a25b1894bd1715581a7b1d3", + "8e136ce01abc762b5cf1862256d14c83", "src/libANGLE/validationCL_autogen.h": "0022d0cdb6a9e2ef4a59b71164f62333", "src/libANGLE/validationEGL_autogen.h": @@ -122,11 +126,11 @@ "src/libGLESv2/entry_points_cl_autogen.h": "dde2f94c3004874a7da995dae69da811", "src/libGLESv2/entry_points_egl_autogen.cpp": - "2ae6b7456e2e8a858bbaf06ab62246fa", + "3ec155b49e891165d7e0cdc4cdad5258", "src/libGLESv2/entry_points_egl_autogen.h": "3bc7a8df9deadd7cfd615d0cfad0c6a8", "src/libGLESv2/entry_points_egl_ext_autogen.cpp": - "46e86754277c35b101784854532b2e5c", + "b02ab9c50a2740a284d044b4415e1383", "src/libGLESv2/entry_points_egl_ext_autogen.h": "132314c90c7f1a104d41f911316c169d", "src/libGLESv2/entry_points_gl_1_autogen.cpp": diff --git a/scripts/generate_entry_points.py b/scripts/generate_entry_points.py index 8046bb1ed..511b43619 100755 --- a/scripts/generate_entry_points.py +++ b/scripts/generate_entry_points.py @@ -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_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") diff --git a/src/libANGLE/AttributeMap.cpp b/src/libANGLE/AttributeMap.cpp index 6b56aee14..e0c82be1e 100644 --- a/src/libANGLE/AttributeMap.cpp +++ b/src/libANGLE/AttributeMap.cpp @@ -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; } diff --git a/src/libANGLE/AttributeMap.h b/src/libANGLE/AttributeMap.h index 60ba913fe..ceecce6af 100644 --- a/src/libANGLE/AttributeMap.h +++ b/src/libANGLE/AttributeMap.h @@ -24,6 +24,13 @@ struct ValidationContext; using AttributeValidationFunc = std::function; +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 diff --git a/src/libANGLE/capture/FrameCapture.cpp b/src/libANGLE/capture/FrameCapture.cpp index 977f571a2..0fabd25c3 100644 --- a/src/libANGLE/capture/FrameCapture.cpp +++ b/src/libANGLE/capture/FrameCapture.cpp @@ -32,7 +32,7 @@ #include "libANGLE/Shader.h" #include "libANGLE/Surface.h" #include "libANGLE/VertexArray.h" -#include "libANGLE/capture/capture_egl.h" +#include "libANGLE/capture/capture_egl_autogen.h" #include "libANGLE/capture/capture_gles_1_0_autogen.h" #include "libANGLE/capture/capture_gles_2_0_autogen.h" #include "libANGLE/capture/capture_gles_3_0_autogen.h" @@ -3843,11 +3843,11 @@ void CaptureShareGroupMidExecutionSetup( // Create the image on demand egl::Image *image = nullptr; - Capture(setupCalls, - CaptureEGLCreateImage(nullptr, context, EGL_GL_TEXTURE_2D_KHR, - reinterpret_cast( - static_cast(stagingTexId.value)), - retrievedAttribs, image)); + Capture(setupCalls, egl::CaptureCreateImage( + nullptr, true, nullptr, context, EGL_GL_TEXTURE_2D_KHR, + reinterpret_cast( + static_cast(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 +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(param.data[0].data()); + egl::AttributeMap attributeMap = factory(attribs); + attributeMap.initializeWithoutValidation(); + resourceTracker.getImageToAttribTable().insert( + std::pair(image, attributeMap)); +} + void FrameCaptureShared::maybeCapturePreCallUpdates( const gl::Context *context, CallCapture &call, @@ -6781,15 +6813,16 @@ void FrameCaptureShared::maybeCapturePreCallUpdates( } case EntryPoint::EGLCreateImage: + { + CreateEGLImagePreCallUpdate(call, mResourceTracker, + ParamType::TEGLAttribPointer, + egl::AttributeMap::CreateFromAttribArray); + break; + } case EntryPoint::EGLCreateImageKHR: { - GLeglImageOES image = call.params.getReturnValue().value.voidPointerVal; - const EGLAttrib *attribs = reinterpret_cast( - 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(image, attributeMap)); + CreateEGLImagePreCallUpdate(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(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(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(context) + << "ul]);\n\n"; } // Then append the Reset calls @@ -8716,10 +8749,8 @@ void WriteParamValueReplay(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(value); + // It's not necessary to implement correct capture for these types. + os << "0"; } template <> @@ -8727,10 +8758,8 @@ void WriteParamValueReplay(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(value); + // It's not necessary to implement correct capture for these types. + os << "0"; } template <> @@ -8738,10 +8767,96 @@ void WriteParamValueReplay(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(value); + // It's not necessary to implement correct capture for these types. + os << "0"; +} + +template <> +void WriteParamValueReplay(std::ostream &os, + const CallCapture &call, + egl::Config *value) +{ + os << "EGL_NO_CONFIG_KHR"; +} + +template <> +void WriteParamValueReplay(std::ostream &os, + const CallCapture &call, + egl::Surface *value) +{ + if (value == nullptr) + { + os << "EGL_NO_SURFACE"; + } + else + { + os << "gSurfaceMap[" << reinterpret_cast(value) << "ul]"; + } +} + +template <> +void WriteParamValueReplay(std::ostream &os, + const CallCapture &call, + gl::Context *value) +{ + if (value == nullptr) + { + os << "EGL_NO_CONTEXT"; + } + else + { + os << "gContextMap[" << reinterpret_cast(value) << "ul]"; + } +} + +template <> +void WriteParamValueReplay(std::ostream &os, + const CallCapture &call, + egl::Display *value) +{ + os << "EGL_NO_DISPLAY"; +} + +template <> +void WriteParamValueReplay(std::ostream &os, + const CallCapture &call, + egl::Image *value) +{ + uint64_t pointerValue = reinterpret_cast(value); + os << "gEGLImageMap[" << pointerValue << "ul]"; +} + +template <> +void WriteParamValueReplay(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(std::ostream &os, + const CallCapture &call, + egl::Sync *value) +{ + os << "EGL_NO_SYNC_KHR"; +} + +template <> +void WriteParamValueReplay(std::ostream &os, + const CallCapture &call, + EGLTime value) +{ + os << value << "ul"; +} + +template <> +void WriteParamValueReplay(std::ostream &os, + const CallCapture &call, + EGLTimeKHR value) +{ + os << value << "ul"; } // ReplayWriter implementation. @@ -9031,3 +9146,62 @@ std::vector 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 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 attribs; + for (const auto &[key, value] : attribMap) + { + attribs.push_back(static_cast(key)); + attribs.push_back(static_cast(value)); + } + attribs.push_back(EGL_NONE); + + angle::CaptureMemory(attribs.data(), attribs.size() * sizeof(EGLint), + ¶mCapture); + } + return paramCapture; + } + + default: + UNREACHABLE(); + return angle::ParamCapture(); + } +} +} // namespace egl diff --git a/src/libANGLE/capture/FrameCapture.h b/src/libANGLE/capture/FrameCapture.h index 6c94ad6b2..7b2241aa1 100644 --- a/src/libANGLE/capture/FrameCapture.h +++ b/src/libANGLE/capture/FrameCapture.h @@ -13,6 +13,7 @@ #include "common/PackedEnums.h" #include "common/system_utils.h" #include "libANGLE/Context.h" +#include "libANGLE/Thread.h" #include "libANGLE/angletypes.h" #include "libANGLE/capture/frame_capture_utils_autogen.h" #include "libANGLE/entry_points_utils.h" @@ -882,10 +883,10 @@ class FrameCaptureShared final : angle::NonCopyable }; template -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 +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 void ParamBuffer::addValueParam(const char *paramName, ParamType paramType, T paramValue) { @@ -1148,6 +1171,11 @@ void WriteParamValueReplay(std::ostream &os, const CallCapture &call, egl::Display *value); +template <> +void WriteParamValueReplay(std::ostream &os, + const CallCapture &call, + egl::Image *value); + template <> void WriteParamValueReplay(std::ostream &os, const CallCapture &call, @@ -1182,6 +1210,26 @@ void WriteParamValueReplay(std::ostream &os, const CallCapture &call, egl::Surface *value); +template <> +void WriteParamValueReplay(std::ostream &os, + const CallCapture &call, + EGLClientBuffer value); + +template <> +void WriteParamValueReplay(std::ostream &os, + const CallCapture &call, + egl::Sync *value); + +template <> +void WriteParamValueReplay(std::ostream &os, + const CallCapture &call, + EGLTime value); + +template <> +void WriteParamValueReplay(std::ostream &os, + const CallCapture &call, + EGLTimeKHR value); + // General fallback for any unspecific type. template 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_ diff --git a/src/libANGLE/capture/capture_egl.cpp b/src/libANGLE/capture/capture_egl.cpp deleted file mode 100644 index 89314a95d..000000000 --- a/src/libANGLE/capture/capture_egl.cpp +++ /dev/null @@ -1,246 +0,0 @@ -// -// Copyright 2022 The ANGLE Project Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. -// -// capture_egl.h: -// EGL capture functions -// - -#include "libANGLE/capture/capture_egl.h" -#include "libANGLE/Surface.h" -#include "libANGLE/capture/FrameCapture.h" -#include "libANGLE/capture/frame_capture_utils.h" -#include "libANGLE/capture/gl_enum_utils_autogen.h" - -#define USE_SYSTEM_ZLIB -#include "compression_utils_portable.h" - -#if !ANGLE_CAPTURE_ENABLED -# error Frame capture must be enabled to include this file. -#endif // !ANGLE_CAPTURE_ENABLED - -namespace angle -{ -template <> -void WriteParamValueReplay(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(std::ostream &os, - const CallCapture &call, - egl::Display *display) -{ - os << "EGL_NO_DISPLAY"; -} - -template <> -void WriteParamValueReplay(std::ostream &os, - const CallCapture &call, - egl::Config *config) -{ - os << "EGL_NO_CONFIG_KHR"; -} - -template <> -void WriteParamValueReplay(std::ostream &os, - const CallCapture &call, - egl::Surface *surface) -{ - if (surface == nullptr) - { - os << "EGL_NO_SURFACE"; - } - else - { - os << "gSurfaceMap[" << reinterpret_cast(surface) << "]"; - } -} - -template <> -void WriteParamValueReplay(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 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 attribs; - for (const auto &[key, value] : attribMap) - { - attribs.push_back(static_cast(key)); - attribs.push_back(static_cast(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(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(buffer); - angle::SetParamVal(bufferID, ¶msClientBuffer.value); - paramBuffer.addParam(std::move(paramsClientBuffer)); - - angle::ParamCapture paramsAttr = CaptureAttributeMap(attributes); - paramBuffer.addParam(std::move(paramsAttr)); - - angle::ParamCapture retval; - angle::SetParamVal(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(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(surface, &retval.value); - paramBuffer.addReturnValue(std::move(retval)); - - return angle::CallCapture(angle::EntryPoint::EGLCreatePbufferSurface, std::move(paramBuffer)); -} -angle::CallCapture CaptureEGLDestroySurface(egl::Display *display, egl::Surface *surface) -{ - angle::ParamBuffer paramBuffer; - paramBuffer.addValueParam("display", angle::ParamType::Tegl_DisplayPointer, display); - paramBuffer.addValueParam("surface", angle::ParamType::Tegl_SurfacePointer, surface); - - return angle::CallCapture(angle::EntryPoint::EGLDestroySurface, std::move(paramBuffer)); -} - -static angle::CallCapture CaptureEGLBindOrReleaseImage(egl::Display *display, - egl::Surface *surface, - EGLint buffer, - angle::EntryPoint entryPoint) -{ - angle::ParamBuffer paramBuffer; - paramBuffer.addValueParam("display", angle::ParamType::Tegl_DisplayPointer, display); - paramBuffer.addValueParam("surface", angle::ParamType::Tegl_SurfacePointer, surface); - paramBuffer.addValueParam("buffer", angle::ParamType::TEGLint, buffer); - return angle::CallCapture(entryPoint, std::move(paramBuffer)); -} - -angle::CallCapture CaptureEGLBindTexImage(egl::Display *display, - egl::Surface *surface, - EGLint buffer) -{ - return CaptureEGLBindOrReleaseImage(display, surface, buffer, - angle::EntryPoint::EGLBindTexImage); -} - -angle::CallCapture CaptureEGLReleaseTexImage(egl::Display *display, - egl::Surface *surface, - EGLint buffer) -{ - return CaptureEGLBindOrReleaseImage(display, surface, buffer, - angle::EntryPoint::EGLReleaseTexImage); -} - -angle::CallCapture CaptureEGLMakeCurrent(egl::Display *display, - Surface *drawSurface, - Surface *readSurface, - gl::Context *context) -{ - angle::ParamBuffer paramBuffer; - paramBuffer.addValueParam("display", angle::ParamType::Tegl_DisplayPointer, display); - paramBuffer.addValueParam("draw", angle::ParamType::Tegl_SurfacePointer, drawSurface); - paramBuffer.addValueParam("read", angle::ParamType::Tegl_SurfacePointer, readSurface); - paramBuffer.addValueParam("context", angle::ParamType::Tgl_ContextPointer, context); - - return angle::CallCapture(angle::EntryPoint::EGLMakeCurrent, std::move(paramBuffer)); -} - -} // namespace egl diff --git a/src/libANGLE/capture/capture_egl.h b/src/libANGLE/capture/capture_egl.h deleted file mode 100644 index 13f25a034..000000000 --- a/src/libANGLE/capture/capture_egl.h +++ /dev/null @@ -1,77 +0,0 @@ -// -// Copyright 2022 The ANGLE Project Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. -// -// capture_egl.h: -// EGL capture functions -// - -#ifndef LIBANGLE_CAPTURE_EGL_H_ -#define LIBANGLE_CAPTURE_EGL_H_ - -#include "libANGLE/Context.h" -#include "libANGLE/Thread.h" -#include "libANGLE/capture/FrameCapture.h" - -namespace gl -{ -enum class GLenumGroup; -} - -namespace egl -{ - -template -void CaptureCallToCaptureEGL(CaptureFuncT captureFunc, egl::Thread *thread, ArgsT... captureParams) -{ - gl::Context *context = thread->getContext(); - if (!context) - { - return; - } - - angle::FrameCaptureShared *frameCaptureShared = - context->getShareGroup()->getFrameCaptureShared(); - if (!frameCaptureShared->isCapturing()) - { - return; - } - - angle::CallCapture call = captureFunc(captureParams...); - - frameCaptureShared->captureCall(context, std::move(call), true); -} - -angle::CallCapture CaptureCreateNativeClientBufferANDROID(const egl::AttributeMap &attribMap, - EGLClientBuffer eglClientBuffer); -angle::CallCapture CaptureEGLCreateImage(egl::Display *display, - gl::Context *context, - EGLenum target, - EGLClientBuffer buffer, - const egl::AttributeMap &attributes, - egl::Image *image); -angle::CallCapture CaptureEGLDestroyImage(egl::Display *display, egl::Image *image); - -angle::CallCapture CaptureEGLCreatePbufferSurface(egl::Display *display, - egl::Config *config, - const AttributeMap &attrib_list, - egl::Surface *surface); - -angle::CallCapture CaptureEGLDestroySurface(egl::Display *display, Surface *surface); - -angle::CallCapture CaptureEGLBindTexImage(egl::Display *display, - egl::Surface *surface, - EGLint buffer); - -angle::CallCapture CaptureEGLReleaseTexImage(egl::Display *display, - egl::Surface *surface, - EGLint buffer); - -angle::CallCapture CaptureEGLMakeCurrent(egl::Display *display, - Surface *drawSurface, - Surface *readSurface, - gl::Context *context); -} // namespace egl - -#endif // LIBANGLE_FRAME_CAPTURE_H_ diff --git a/src/libANGLE/capture/capture_egl_autogen.cpp b/src/libANGLE/capture/capture_egl_autogen.cpp new file mode 100644 index 000000000..9e2225412 --- /dev/null +++ b/src/libANGLE/capture/capture_egl_autogen.cpp @@ -0,0 +1,2131 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by generate_entry_points.py using data from egl.xml and egl_angle_ext.xml. +// +// Copyright 2020 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// capture_egl_autogen.cpp: +// Capture functions for the OpenGL ES all entry points. + +#include "libANGLE/capture/capture_egl_autogen.h" + +#include "libANGLE/Context.h" +#include "libANGLE/capture/FrameCapture.h" +#include "libANGLE/capture/gl_enum_utils.h" +#include "libANGLE/validationEGL.h" + +using namespace angle; + +namespace egl +{ +CallCapture CaptureChooseConfig(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + const AttributeMap &attrib_listPacked, + EGLConfig *configs, + EGLint config_size, + EGLint *num_config, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + paramBuffer.addValueParam("configs", ParamType::TEGLConfigPointer, configs); + paramBuffer.addValueParam("config_size", ParamType::TEGLint, config_size); + paramBuffer.addValueParam("num_config", ParamType::TEGLintPointer, num_config); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLChooseConfig, std::move(paramBuffer)); +} + +CallCapture CaptureCopyBuffers(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLNativePixmapType target, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + paramBuffer.addValueParam("target", ParamType::TEGLNativePixmapType, target); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLCopyBuffers, std::move(paramBuffer)); +} + +CallCapture CaptureCreateContext(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Config *configPacked, + gl::Context *share_contextPacked, + const AttributeMap &attrib_listPacked, + EGLContext returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked); + paramBuffer.addValueParam("share_contextPacked", ParamType::Tgl_ContextPointer, + share_contextPacked); + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLContext); + InitParamValue(ParamType::TEGLContext, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLCreateContext, std::move(paramBuffer)); +} + +CallCapture CaptureCreatePbufferSurface(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Config *configPacked, + const AttributeMap &attrib_listPacked, + EGLSurface returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked); + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface); + InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLCreatePbufferSurface, std::move(paramBuffer)); +} + +CallCapture CaptureCreatePixmapSurface(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Config *configPacked, + EGLNativePixmapType pixmap, + const AttributeMap &attrib_listPacked, + EGLSurface returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked); + paramBuffer.addValueParam("pixmap", ParamType::TEGLNativePixmapType, pixmap); + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface); + InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLCreatePixmapSurface, std::move(paramBuffer)); +} + +CallCapture CaptureCreateWindowSurface(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Config *configPacked, + EGLNativeWindowType win, + const AttributeMap &attrib_listPacked, + EGLSurface returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked); + paramBuffer.addValueParam("win", ParamType::TEGLNativeWindowType, win); + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface); + InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLCreateWindowSurface, std::move(paramBuffer)); +} + +CallCapture CaptureDestroyContext(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + gl::Context *ctxPacked, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("ctxPacked", ParamType::Tgl_ContextPointer, ctxPacked); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLDestroyContext, std::move(paramBuffer)); +} + +CallCapture CaptureDestroySurface(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLDestroySurface, std::move(paramBuffer)); +} + +CallCapture CaptureGetConfigAttrib(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Config *configPacked, + EGLint attribute, + EGLint *value, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked); + paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute); + paramBuffer.addValueParam("value", ParamType::TEGLintPointer, value); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLGetConfigAttrib, std::move(paramBuffer)); +} + +CallCapture CaptureGetConfigs(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLConfig *configs, + EGLint config_size, + EGLint *num_config, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("configs", ParamType::TEGLConfigPointer, configs); + paramBuffer.addValueParam("config_size", ParamType::TEGLint, config_size); + paramBuffer.addValueParam("num_config", ParamType::TEGLintPointer, num_config); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLGetConfigs, std::move(paramBuffer)); +} + +CallCapture CaptureGetCurrentDisplay(egl::Thread *thread, bool isCallValid, EGLDisplay returnValue) +{ + ParamBuffer paramBuffer; + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLDisplay); + InitParamValue(ParamType::TEGLDisplay, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLGetCurrentDisplay, std::move(paramBuffer)); +} + +CallCapture CaptureGetCurrentSurface(egl::Thread *thread, + bool isCallValid, + EGLint readdraw, + EGLSurface returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("readdraw", ParamType::TEGLint, readdraw); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface); + InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLGetCurrentSurface, std::move(paramBuffer)); +} + +CallCapture CaptureGetDisplay(egl::Thread *thread, + bool isCallValid, + EGLNativeDisplayType display_id, + EGLDisplay returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("display_id", ParamType::TEGLNativeDisplayType, display_id); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLDisplay); + InitParamValue(ParamType::TEGLDisplay, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLGetDisplay, std::move(paramBuffer)); +} + +CallCapture CaptureGetError(egl::Thread *thread, bool isCallValid, EGLint returnValue) +{ + ParamBuffer paramBuffer; + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLint); + InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLGetError, std::move(paramBuffer)); +} + +CallCapture CaptureGetProcAddress(egl::Thread *thread, + bool isCallValid, + const char *procname, + __eglMustCastToProperFunctionPointerType returnValue) +{ + ParamBuffer paramBuffer; + + return CallCapture(angle::EntryPoint::EGLGetProcAddress, std::move(paramBuffer)); +} + +CallCapture CaptureInitialize(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLint *major, + EGLint *minor, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("major", ParamType::TEGLintPointer, major); + paramBuffer.addValueParam("minor", ParamType::TEGLintPointer, minor); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLInitialize, std::move(paramBuffer)); +} + +CallCapture CaptureMakeCurrent(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *drawPacked, + egl::Surface *readPacked, + gl::Context *ctxPacked, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("drawPacked", ParamType::Tegl_SurfacePointer, drawPacked); + paramBuffer.addValueParam("readPacked", ParamType::Tegl_SurfacePointer, readPacked); + paramBuffer.addValueParam("ctxPacked", ParamType::Tgl_ContextPointer, ctxPacked); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLMakeCurrent, std::move(paramBuffer)); +} + +CallCapture CaptureQueryContext(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + gl::Context *ctxPacked, + EGLint attribute, + EGLint *value, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("ctxPacked", ParamType::Tgl_ContextPointer, ctxPacked); + paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute); + paramBuffer.addValueParam("value", ParamType::TEGLintPointer, value); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLQueryContext, std::move(paramBuffer)); +} + +CallCapture CaptureQueryString(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLint name, + const char *returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("name", ParamType::TEGLint, name); + + ParamCapture returnValueCapture("returnValue", ParamType::TcharConstPointer); + InitParamValue(ParamType::TcharConstPointer, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLQueryString, std::move(paramBuffer)); +} + +CallCapture CaptureQuerySurface(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLint attribute, + EGLint *value, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute); + paramBuffer.addValueParam("value", ParamType::TEGLintPointer, value); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLQuerySurface, std::move(paramBuffer)); +} + +CallCapture CaptureSwapBuffers(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLSwapBuffers, std::move(paramBuffer)); +} + +CallCapture CaptureTerminate(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLTerminate, std::move(paramBuffer)); +} + +CallCapture CaptureWaitGL(egl::Thread *thread, bool isCallValid, EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLWaitGL, std::move(paramBuffer)); +} + +CallCapture CaptureWaitNative(egl::Thread *thread, + bool isCallValid, + EGLint engine, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("engine", ParamType::TEGLint, engine); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLWaitNative, std::move(paramBuffer)); +} + +CallCapture CaptureBindTexImage(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLint buffer, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + paramBuffer.addValueParam("buffer", ParamType::TEGLint, buffer); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLBindTexImage, std::move(paramBuffer)); +} + +CallCapture CaptureReleaseTexImage(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLint buffer, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + paramBuffer.addValueParam("buffer", ParamType::TEGLint, buffer); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLReleaseTexImage, std::move(paramBuffer)); +} + +CallCapture CaptureSurfaceAttrib(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLint attribute, + EGLint value, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute); + paramBuffer.addValueParam("value", ParamType::TEGLint, value); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLSurfaceAttrib, std::move(paramBuffer)); +} + +CallCapture CaptureSwapInterval(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLint interval, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("interval", ParamType::TEGLint, interval); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLSwapInterval, std::move(paramBuffer)); +} + +CallCapture CaptureBindAPI(egl::Thread *thread, + bool isCallValid, + EGLenum api, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("api", ParamType::TEGLenum, api); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLBindAPI, std::move(paramBuffer)); +} + +CallCapture CaptureCreatePbufferFromClientBuffer(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLenum buftype, + EGLClientBuffer buffer, + egl::Config *configPacked, + const AttributeMap &attrib_listPacked, + EGLSurface returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("buftype", ParamType::TEGLenum, buftype); + paramBuffer.addValueParam("buffer", ParamType::TEGLClientBuffer, buffer); + paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked); + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface); + InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLCreatePbufferFromClientBuffer, std::move(paramBuffer)); +} + +CallCapture CaptureQueryAPI(egl::Thread *thread, bool isCallValid, EGLenum returnValue) +{ + ParamBuffer paramBuffer; + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLenum); + InitParamValue(ParamType::TEGLenum, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLQueryAPI, std::move(paramBuffer)); +} + +CallCapture CaptureReleaseThread(egl::Thread *thread, bool isCallValid, EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLReleaseThread, std::move(paramBuffer)); +} + +CallCapture CaptureWaitClient(egl::Thread *thread, bool isCallValid, EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLWaitClient, std::move(paramBuffer)); +} + +CallCapture CaptureGetCurrentContext(egl::Thread *thread, bool isCallValid, EGLContext returnValue) +{ + ParamBuffer paramBuffer; + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLContext); + InitParamValue(ParamType::TEGLContext, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLGetCurrentContext, std::move(paramBuffer)); +} + +CallCapture CaptureClientWaitSync(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Sync *syncPacked, + EGLint flags, + EGLTime timeout, + EGLint returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncPointer, syncPacked); + paramBuffer.addValueParam("flags", ParamType::TEGLint, flags); + paramBuffer.addValueParam("timeout", ParamType::TEGLTime, timeout); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLint); + InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLClientWaitSync, std::move(paramBuffer)); +} + +CallCapture CaptureCreateImage(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + gl::Context *ctxPacked, + EGLenum target, + EGLClientBuffer buffer, + const AttributeMap &attrib_listPacked, + EGLImage returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("ctxPacked", ParamType::Tgl_ContextPointer, ctxPacked); + paramBuffer.addValueParam("target", ParamType::TEGLenum, target); + paramBuffer.addValueParam("buffer", ParamType::TEGLClientBuffer, buffer); + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLImage); + InitParamValue(ParamType::TEGLImage, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLCreateImage, std::move(paramBuffer)); +} + +CallCapture CaptureCreatePlatformPixmapSurface(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Config *configPacked, + void *native_pixmap, + const AttributeMap &attrib_listPacked, + EGLSurface returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked); + paramBuffer.addValueParam("native_pixmap", ParamType::TvoidPointer, native_pixmap); + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface); + InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLCreatePlatformPixmapSurface, std::move(paramBuffer)); +} + +CallCapture CaptureCreatePlatformWindowSurface(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Config *configPacked, + void *native_window, + const AttributeMap &attrib_listPacked, + EGLSurface returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked); + paramBuffer.addValueParam("native_window", ParamType::TvoidPointer, native_window); + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface); + InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLCreatePlatformWindowSurface, std::move(paramBuffer)); +} + +CallCapture CaptureCreateSync(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLenum type, + const AttributeMap &attrib_listPacked, + EGLSync returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("type", ParamType::TEGLenum, type); + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLSync); + InitParamValue(ParamType::TEGLSync, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLCreateSync, std::move(paramBuffer)); +} + +CallCapture CaptureDestroyImage(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Image *imagePacked, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("imagePacked", ParamType::Tegl_ImagePointer, imagePacked); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLDestroyImage, std::move(paramBuffer)); +} + +CallCapture CaptureDestroySync(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Sync *syncPacked, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncPointer, syncPacked); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLDestroySync, std::move(paramBuffer)); +} + +CallCapture CaptureGetPlatformDisplay(egl::Thread *thread, + bool isCallValid, + EGLenum platform, + void *native_display, + const AttributeMap &attrib_listPacked, + EGLDisplay returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("platform", ParamType::TEGLenum, platform); + paramBuffer.addValueParam("native_display", ParamType::TvoidPointer, native_display); + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLDisplay); + InitParamValue(ParamType::TEGLDisplay, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLGetPlatformDisplay, std::move(paramBuffer)); +} + +CallCapture CaptureGetSyncAttrib(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Sync *syncPacked, + EGLint attribute, + EGLAttrib *value, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncPointer, syncPacked); + paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute); + paramBuffer.addValueParam("value", ParamType::TEGLAttribPointer, value); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLGetSyncAttrib, std::move(paramBuffer)); +} + +CallCapture CaptureWaitSync(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Sync *syncPacked, + EGLint flags, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncPointer, syncPacked); + paramBuffer.addValueParam("flags", ParamType::TEGLint, flags); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLWaitSync, std::move(paramBuffer)); +} + +CallCapture CaptureSetBlobCacheFuncsANDROID(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLSetBlobFuncANDROID set, + EGLGetBlobFuncANDROID get) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("set", ParamType::TEGLSetBlobFuncANDROID, set); + paramBuffer.addValueParam("get", ParamType::TEGLGetBlobFuncANDROID, get); + + return CallCapture(angle::EntryPoint::EGLSetBlobCacheFuncsANDROID, std::move(paramBuffer)); +} + +CallCapture CaptureCreateNativeClientBufferANDROID(egl::Thread *thread, + bool isCallValid, + const AttributeMap &attrib_listPacked, + EGLClientBuffer returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLClientBuffer); + InitParamValue(ParamType::TEGLClientBuffer, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLCreateNativeClientBufferANDROID, + std::move(paramBuffer)); +} + +CallCapture CaptureGetCompositorTimingSupportedANDROID(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + CompositorTiming namePacked, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + paramBuffer.addValueParam("namePacked", ParamType::TCompositorTiming, namePacked); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLGetCompositorTimingSupportedANDROID, + std::move(paramBuffer)); +} + +CallCapture CaptureGetCompositorTimingANDROID(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLint numTimestamps, + const EGLint *names, + EGLnsecsANDROID *values, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + paramBuffer.addValueParam("numTimestamps", ParamType::TEGLint, numTimestamps); + paramBuffer.addValueParam("names", ParamType::TEGLintConstPointer, names); + paramBuffer.addValueParam("values", ParamType::TEGLnsecsANDROIDPointer, values); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLGetCompositorTimingANDROID, std::move(paramBuffer)); +} + +CallCapture CaptureGetNextFrameIdANDROID(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLuint64KHR *frameId, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + paramBuffer.addValueParam("frameId", ParamType::TEGLuint64KHRPointer, frameId); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLGetNextFrameIdANDROID, std::move(paramBuffer)); +} + +CallCapture CaptureGetFrameTimestampSupportedANDROID(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + Timestamp timestampPacked, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + paramBuffer.addValueParam("timestampPacked", ParamType::TTimestamp, timestampPacked); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLGetFrameTimestampSupportedANDROID, + std::move(paramBuffer)); +} + +CallCapture CaptureGetFrameTimestampsANDROID(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLuint64KHR frameId, + EGLint numTimestamps, + const EGLint *timestamps, + EGLnsecsANDROID *values, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + paramBuffer.addValueParam("frameId", ParamType::TEGLuint64KHR, frameId); + paramBuffer.addValueParam("numTimestamps", ParamType::TEGLint, numTimestamps); + paramBuffer.addValueParam("timestamps", ParamType::TEGLintConstPointer, timestamps); + paramBuffer.addValueParam("values", ParamType::TEGLnsecsANDROIDPointer, values); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLGetFrameTimestampsANDROID, std::move(paramBuffer)); +} + +CallCapture CaptureGetNativeClientBufferANDROID(egl::Thread *thread, + bool isCallValid, + const struct AHardwareBuffer *buffer, + EGLClientBuffer returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("buffer", ParamType::TAHardwareBufferConstPointer, buffer); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLClientBuffer); + InitParamValue(ParamType::TEGLClientBuffer, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLGetNativeClientBufferANDROID, std::move(paramBuffer)); +} + +CallCapture CaptureDupNativeFenceFDANDROID(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Sync *syncPacked, + EGLint returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncPointer, syncPacked); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLint); + InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLDupNativeFenceFDANDROID, std::move(paramBuffer)); +} + +CallCapture CapturePresentationTimeANDROID(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLnsecsANDROID time, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + paramBuffer.addValueParam("time", ParamType::TEGLnsecsANDROID, time); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLPresentationTimeANDROID, std::move(paramBuffer)); +} + +CallCapture CaptureCreateDeviceANGLE(egl::Thread *thread, + bool isCallValid, + EGLint device_type, + void *native_device, + const EGLAttrib *attrib_list, + EGLDeviceEXT returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("device_type", ParamType::TEGLint, device_type); + paramBuffer.addValueParam("native_device", ParamType::TvoidPointer, native_device); + paramBuffer.addValueParam("attrib_list", ParamType::TEGLAttribConstPointer, attrib_list); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLDeviceEXT); + InitParamValue(ParamType::TEGLDeviceEXT, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLCreateDeviceANGLE, std::move(paramBuffer)); +} + +CallCapture CaptureReleaseDeviceANGLE(egl::Thread *thread, + bool isCallValid, + egl::Device *devicePacked, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("devicePacked", ParamType::Tegl_DevicePointer, devicePacked); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLReleaseDeviceANGLE, std::move(paramBuffer)); +} + +CallCapture CaptureQueryStringiANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLint name, + EGLint index, + const char *returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("name", ParamType::TEGLint, name); + paramBuffer.addValueParam("index", ParamType::TEGLint, index); + + ParamCapture returnValueCapture("returnValue", ParamType::TcharConstPointer); + InitParamValue(ParamType::TcharConstPointer, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLQueryStringiANGLE, std::move(paramBuffer)); +} + +CallCapture CaptureQueryDisplayAttribANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLint attribute, + EGLAttrib *value, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute); + paramBuffer.addValueParam("value", ParamType::TEGLAttribPointer, value); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLQueryDisplayAttribANGLE, std::move(paramBuffer)); +} + +CallCapture CaptureCopyMetalSharedEventANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Sync *syncPacked, + void *returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncPointer, syncPacked); + + ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer); + InitParamValue(ParamType::TvoidPointer, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLCopyMetalSharedEventANGLE, std::move(paramBuffer)); +} + +CallCapture CaptureReleaseHighPowerGPUANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + gl::Context *ctxPacked) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("ctxPacked", ParamType::Tgl_ContextPointer, ctxPacked); + + return CallCapture(angle::EntryPoint::EGLReleaseHighPowerGPUANGLE, std::move(paramBuffer)); +} + +CallCapture CaptureReacquireHighPowerGPUANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + gl::Context *ctxPacked) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("ctxPacked", ParamType::Tgl_ContextPointer, ctxPacked); + + return CallCapture(angle::EntryPoint::EGLReacquireHighPowerGPUANGLE, std::move(paramBuffer)); +} + +CallCapture CaptureHandleGPUSwitchANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + + return CallCapture(angle::EntryPoint::EGLHandleGPUSwitchANGLE, std::move(paramBuffer)); +} + +CallCapture CaptureForceGPUSwitchANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLint gpuIDHigh, + EGLint gpuIDLow) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("gpuIDHigh", ParamType::TEGLint, gpuIDHigh); + paramBuffer.addValueParam("gpuIDLow", ParamType::TEGLint, gpuIDLow); + + return CallCapture(angle::EntryPoint::EGLForceGPUSwitchANGLE, std::move(paramBuffer)); +} + +CallCapture CapturePrepareSwapBuffersANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLPrepareSwapBuffersANGLE, std::move(paramBuffer)); +} + +CallCapture CaptureProgramCacheGetAttribANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLenum attrib, + EGLint returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("attrib", ParamType::TEGLenum, attrib); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLint); + InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLProgramCacheGetAttribANGLE, std::move(paramBuffer)); +} + +CallCapture CaptureProgramCacheQueryANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLint index, + void *key, + EGLint *keysize, + void *binary, + EGLint *binarysize) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("index", ParamType::TEGLint, index); + paramBuffer.addValueParam("key", ParamType::TvoidPointer, key); + paramBuffer.addValueParam("keysize", ParamType::TEGLintPointer, keysize); + paramBuffer.addValueParam("binary", ParamType::TvoidPointer, binary); + paramBuffer.addValueParam("binarysize", ParamType::TEGLintPointer, binarysize); + + return CallCapture(angle::EntryPoint::EGLProgramCacheQueryANGLE, std::move(paramBuffer)); +} + +CallCapture CaptureProgramCachePopulateANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + const void *key, + EGLint keysize, + const void *binary, + EGLint binarysize) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("key", ParamType::TvoidConstPointer, key); + paramBuffer.addValueParam("keysize", ParamType::TEGLint, keysize); + paramBuffer.addValueParam("binary", ParamType::TvoidConstPointer, binary); + paramBuffer.addValueParam("binarysize", ParamType::TEGLint, binarysize); + + return CallCapture(angle::EntryPoint::EGLProgramCachePopulateANGLE, std::move(paramBuffer)); +} + +CallCapture CaptureProgramCacheResizeANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLint limit, + EGLint mode, + EGLint returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("limit", ParamType::TEGLint, limit); + paramBuffer.addValueParam("mode", ParamType::TEGLint, mode); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLint); + InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLProgramCacheResizeANGLE, std::move(paramBuffer)); +} + +CallCapture CaptureQuerySurfacePointerANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLint attribute, + void **value, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute); + paramBuffer.addValueParam("value", ParamType::TvoidPointerPointer, value); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLQuerySurfacePointerANGLE, std::move(paramBuffer)); +} + +CallCapture CaptureCreateStreamProducerD3DTextureANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Stream *streamPacked, + const AttributeMap &attrib_listPacked, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked); + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLCreateStreamProducerD3DTextureANGLE, + std::move(paramBuffer)); +} + +CallCapture CaptureStreamPostD3DTextureANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Stream *streamPacked, + void *texture, + const AttributeMap &attrib_listPacked, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked); + paramBuffer.addValueParam("texture", ParamType::TvoidPointer, texture); + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLStreamPostD3DTextureANGLE, std::move(paramBuffer)); +} + +CallCapture CaptureSwapBuffersWithFrameTokenANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLFrameTokenANGLE frametoken, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + paramBuffer.addValueParam("frametoken", ParamType::TEGLFrameTokenANGLE, frametoken); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLSwapBuffersWithFrameTokenANGLE, + std::move(paramBuffer)); +} + +CallCapture CaptureGetMscRateANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLint *numerator, + EGLint *denominator, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + paramBuffer.addValueParam("numerator", ParamType::TEGLintPointer, numerator); + paramBuffer.addValueParam("denominator", ParamType::TEGLintPointer, denominator); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLGetMscRateANGLE, std::move(paramBuffer)); +} + +CallCapture CaptureExportVkImageANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Image *imagePacked, + void *vk_image, + void *vk_image_create_info, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("imagePacked", ParamType::Tegl_ImagePointer, imagePacked); + paramBuffer.addValueParam("vk_image", ParamType::TvoidPointer, vk_image); + paramBuffer.addValueParam("vk_image_create_info", ParamType::TvoidPointer, + vk_image_create_info); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLExportVkImageANGLE, std::move(paramBuffer)); +} + +CallCapture CaptureGetSyncValuesCHROMIUM(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLuint64KHR *ust, + EGLuint64KHR *msc, + EGLuint64KHR *sbc, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + paramBuffer.addValueParam("ust", ParamType::TEGLuint64KHRPointer, ust); + paramBuffer.addValueParam("msc", ParamType::TEGLuint64KHRPointer, msc); + paramBuffer.addValueParam("sbc", ParamType::TEGLuint64KHRPointer, sbc); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLGetSyncValuesCHROMIUM, std::move(paramBuffer)); +} + +CallCapture CaptureQueryDeviceAttribEXT(egl::Thread *thread, + bool isCallValid, + egl::Device *devicePacked, + EGLint attribute, + EGLAttrib *value, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("devicePacked", ParamType::Tegl_DevicePointer, devicePacked); + paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute); + paramBuffer.addValueParam("value", ParamType::TEGLAttribPointer, value); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLQueryDeviceAttribEXT, std::move(paramBuffer)); +} + +CallCapture CaptureQueryDeviceStringEXT(egl::Thread *thread, + bool isCallValid, + egl::Device *devicePacked, + EGLint name, + const char *returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("devicePacked", ParamType::Tegl_DevicePointer, devicePacked); + paramBuffer.addValueParam("name", ParamType::TEGLint, name); + + ParamCapture returnValueCapture("returnValue", ParamType::TcharConstPointer); + InitParamValue(ParamType::TcharConstPointer, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLQueryDeviceStringEXT, std::move(paramBuffer)); +} + +CallCapture CaptureQueryDisplayAttribEXT(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLint attribute, + EGLAttrib *value, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute); + paramBuffer.addValueParam("value", ParamType::TEGLAttribPointer, value); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLQueryDisplayAttribEXT, std::move(paramBuffer)); +} + +CallCapture CaptureQueryDmaBufFormatsEXT(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLint max_formats, + EGLint *formats, + EGLint *num_formats, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("max_formats", ParamType::TEGLint, max_formats); + paramBuffer.addValueParam("formats", ParamType::TEGLintPointer, formats); + paramBuffer.addValueParam("num_formats", ParamType::TEGLintPointer, num_formats); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLQueryDmaBufFormatsEXT, std::move(paramBuffer)); +} + +CallCapture CaptureQueryDmaBufModifiersEXT(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLint format, + EGLint max_modifiers, + EGLuint64KHR *modifiers, + EGLBoolean *external_only, + EGLint *num_modifiers, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("format", ParamType::TEGLint, format); + paramBuffer.addValueParam("max_modifiers", ParamType::TEGLint, max_modifiers); + paramBuffer.addValueParam("modifiers", ParamType::TEGLuint64KHRPointer, modifiers); + paramBuffer.addValueParam("external_only", ParamType::TEGLBooleanPointer, external_only); + paramBuffer.addValueParam("num_modifiers", ParamType::TEGLintPointer, num_modifiers); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLQueryDmaBufModifiersEXT, std::move(paramBuffer)); +} + +CallCapture CaptureCreatePlatformPixmapSurfaceEXT(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Config *configPacked, + void *native_pixmap, + const AttributeMap &attrib_listPacked, + EGLSurface returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked); + paramBuffer.addValueParam("native_pixmap", ParamType::TvoidPointer, native_pixmap); + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface); + InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLCreatePlatformPixmapSurfaceEXT, + std::move(paramBuffer)); +} + +CallCapture CaptureCreatePlatformWindowSurfaceEXT(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Config *configPacked, + void *native_window, + const AttributeMap &attrib_listPacked, + EGLSurface returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("configPacked", ParamType::Tegl_ConfigPointer, configPacked); + paramBuffer.addValueParam("native_window", ParamType::TvoidPointer, native_window); + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLSurface); + InitParamValue(ParamType::TEGLSurface, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLCreatePlatformWindowSurfaceEXT, + std::move(paramBuffer)); +} + +CallCapture CaptureGetPlatformDisplayEXT(egl::Thread *thread, + bool isCallValid, + EGLenum platform, + void *native_display, + const AttributeMap &attrib_listPacked, + EGLDisplay returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("platform", ParamType::TEGLenum, platform); + paramBuffer.addValueParam("native_display", ParamType::TvoidPointer, native_display); + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLDisplay); + InitParamValue(ParamType::TEGLDisplay, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLGetPlatformDisplayEXT, std::move(paramBuffer)); +} + +CallCapture CaptureDebugMessageControlKHR(egl::Thread *thread, + bool isCallValid, + EGLDEBUGPROCKHR callback, + const AttributeMap &attrib_listPacked, + EGLint returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("callback", ParamType::TEGLDEBUGPROCKHR, callback); + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLint); + InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLDebugMessageControlKHR, std::move(paramBuffer)); +} + +CallCapture CaptureLabelObjectKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *displayPacked, + ObjectType objectTypePacked, + EGLObjectKHR object, + EGLLabelKHR label, + EGLint returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("displayPacked", ParamType::Tegl_DisplayPointer, displayPacked); + paramBuffer.addValueParam("objectTypePacked", ParamType::TObjectType, objectTypePacked); + paramBuffer.addValueParam("object", ParamType::TEGLObjectKHR, object); + paramBuffer.addValueParam("label", ParamType::TEGLLabelKHR, label); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLint); + InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLLabelObjectKHR, std::move(paramBuffer)); +} + +CallCapture CaptureQueryDebugKHR(egl::Thread *thread, + bool isCallValid, + EGLint attribute, + EGLAttrib *value, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute); + paramBuffer.addValueParam("value", ParamType::TEGLAttribPointer, value); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLQueryDebugKHR, std::move(paramBuffer)); +} + +CallCapture CaptureClientWaitSyncKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Sync *syncPacked, + EGLint flags, + EGLTimeKHR timeout, + EGLint returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncPointer, syncPacked); + paramBuffer.addValueParam("flags", ParamType::TEGLint, flags); + paramBuffer.addValueParam("timeout", ParamType::TEGLTimeKHR, timeout); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLint); + InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLClientWaitSyncKHR, std::move(paramBuffer)); +} + +CallCapture CaptureCreateSyncKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLenum type, + const AttributeMap &attrib_listPacked, + EGLSyncKHR returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("type", ParamType::TEGLenum, type); + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLSyncKHR); + InitParamValue(ParamType::TEGLSyncKHR, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLCreateSyncKHR, std::move(paramBuffer)); +} + +CallCapture CaptureDestroySyncKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Sync *syncPacked, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncPointer, syncPacked); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLDestroySyncKHR, std::move(paramBuffer)); +} + +CallCapture CaptureGetSyncAttribKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Sync *syncPacked, + EGLint attribute, + EGLint *value, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncPointer, syncPacked); + paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute); + paramBuffer.addValueParam("value", ParamType::TEGLintPointer, value); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLGetSyncAttribKHR, std::move(paramBuffer)); +} + +CallCapture CaptureCreateImageKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + gl::Context *ctxPacked, + EGLenum target, + EGLClientBuffer buffer, + const AttributeMap &attrib_listPacked, + EGLImageKHR returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("ctxPacked", ParamType::Tgl_ContextPointer, ctxPacked); + paramBuffer.addValueParam("target", ParamType::TEGLenum, target); + paramBuffer.addValueParam("buffer", ParamType::TEGLClientBuffer, buffer); + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLImageKHR); + InitParamValue(ParamType::TEGLImageKHR, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLCreateImageKHR, std::move(paramBuffer)); +} + +CallCapture CaptureDestroyImageKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Image *imagePacked, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("imagePacked", ParamType::Tegl_ImagePointer, imagePacked); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLDestroyImageKHR, std::move(paramBuffer)); +} + +CallCapture CaptureLockSurfaceKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + const AttributeMap &attrib_listPacked, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLLockSurfaceKHR, std::move(paramBuffer)); +} + +CallCapture CaptureQuerySurface64KHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLint attribute, + EGLAttribKHR *value, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + paramBuffer.addValueParam("attribute", ParamType::TEGLint, attribute); + paramBuffer.addValueParam("value", ParamType::TEGLAttribKHRPointer, value); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLQuerySurface64KHR, std::move(paramBuffer)); +} + +CallCapture CaptureUnlockSurfaceKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLUnlockSurfaceKHR, std::move(paramBuffer)); +} + +CallCapture CaptureSetDamageRegionKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLint *rects, + EGLint n_rects, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + paramBuffer.addValueParam("rects", ParamType::TEGLintPointer, rects); + paramBuffer.addValueParam("n_rects", ParamType::TEGLint, n_rects); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLSetDamageRegionKHR, std::move(paramBuffer)); +} + +CallCapture CaptureSignalSyncKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Sync *syncPacked, + EGLenum mode, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncPointer, syncPacked); + paramBuffer.addValueParam("mode", ParamType::TEGLenum, mode); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLSignalSyncKHR, std::move(paramBuffer)); +} + +CallCapture CaptureCreateStreamKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + const AttributeMap &attrib_listPacked, + EGLStreamKHR returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLStreamKHR); + InitParamValue(ParamType::TEGLStreamKHR, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLCreateStreamKHR, std::move(paramBuffer)); +} + +CallCapture CaptureDestroyStreamKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Stream *streamPacked, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLDestroyStreamKHR, std::move(paramBuffer)); +} + +CallCapture CaptureQueryStreamKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Stream *streamPacked, + EGLenum attribute, + EGLint *value, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked); + paramBuffer.addValueParam("attribute", ParamType::TEGLenum, attribute); + paramBuffer.addValueParam("value", ParamType::TEGLintPointer, value); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLQueryStreamKHR, std::move(paramBuffer)); +} + +CallCapture CaptureQueryStreamu64KHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Stream *streamPacked, + EGLenum attribute, + EGLuint64KHR *value, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked); + paramBuffer.addValueParam("attribute", ParamType::TEGLenum, attribute); + paramBuffer.addValueParam("value", ParamType::TEGLuint64KHRPointer, value); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLQueryStreamu64KHR, std::move(paramBuffer)); +} + +CallCapture CaptureStreamAttribKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Stream *streamPacked, + EGLenum attribute, + EGLint value, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked); + paramBuffer.addValueParam("attribute", ParamType::TEGLenum, attribute); + paramBuffer.addValueParam("value", ParamType::TEGLint, value); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLStreamAttribKHR, std::move(paramBuffer)); +} + +CallCapture CaptureStreamConsumerAcquireKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Stream *streamPacked, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLStreamConsumerAcquireKHR, std::move(paramBuffer)); +} + +CallCapture CaptureStreamConsumerGLTextureExternalKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Stream *streamPacked, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLStreamConsumerGLTextureExternalKHR, + std::move(paramBuffer)); +} + +CallCapture CaptureStreamConsumerReleaseKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Stream *streamPacked, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLStreamConsumerReleaseKHR, std::move(paramBuffer)); +} + +CallCapture CaptureSwapBuffersWithDamageKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + const EGLint *rects, + EGLint n_rects, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + paramBuffer.addValueParam("rects", ParamType::TEGLintConstPointer, rects); + paramBuffer.addValueParam("n_rects", ParamType::TEGLint, n_rects); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLSwapBuffersWithDamageKHR, std::move(paramBuffer)); +} + +CallCapture CaptureWaitSyncKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Sync *syncPacked, + EGLint flags, + EGLint returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("syncPacked", ParamType::Tegl_SyncPointer, syncPacked); + paramBuffer.addValueParam("flags", ParamType::TEGLint, flags); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLint); + InitParamValue(ParamType::TEGLint, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLWaitSyncKHR, std::move(paramBuffer)); +} + +CallCapture CapturePostSubBufferNV(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLint x, + EGLint y, + EGLint width, + EGLint height, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("surfacePacked", ParamType::Tegl_SurfacePointer, surfacePacked); + paramBuffer.addValueParam("x", ParamType::TEGLint, x); + paramBuffer.addValueParam("y", ParamType::TEGLint, y); + paramBuffer.addValueParam("width", ParamType::TEGLint, width); + paramBuffer.addValueParam("height", ParamType::TEGLint, height); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLPostSubBufferNV, std::move(paramBuffer)); +} + +CallCapture CaptureStreamConsumerGLTextureExternalAttribsNV(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Stream *streamPacked, + const AttributeMap &attrib_listPacked, + EGLBoolean returnValue) +{ + ParamBuffer paramBuffer; + + paramBuffer.addValueParam("dpyPacked", ParamType::Tegl_DisplayPointer, dpyPacked); + paramBuffer.addValueParam("streamPacked", ParamType::Tegl_StreamPointer, streamPacked); + paramBuffer.addParam(CaptureAttributeMap(attrib_listPacked)); + + ParamCapture returnValueCapture("returnValue", ParamType::TEGLBoolean); + InitParamValue(ParamType::TEGLBoolean, returnValue, &returnValueCapture.value); + paramBuffer.addReturnValue(std::move(returnValueCapture)); + + return CallCapture(angle::EntryPoint::EGLStreamConsumerGLTextureExternalAttribsNV, + std::move(paramBuffer)); +} + +} // namespace egl diff --git a/src/libANGLE/capture/capture_egl_autogen.h b/src/libANGLE/capture/capture_egl_autogen.h new file mode 100644 index 000000000..f6c9b876b --- /dev/null +++ b/src/libANGLE/capture/capture_egl_autogen.h @@ -0,0 +1,654 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by generate_entry_points.py using data from egl.xml and egl_angle_ext.xml. +// +// Copyright 2020 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// capture_egl_autogen.h: +// Capture functions for the OpenGL ES EGL entry points. + +#ifndef LIBANGLE_CAPTURE_EGL_AUTOGEN_H_ +#define LIBANGLE_CAPTURE_EGL_AUTOGEN_H_ + +#include "common/PackedEnums.h" +#include "libANGLE/capture/FrameCapture.h" + +namespace egl +{ + +// Method Captures + +angle::CallCapture CaptureChooseConfig(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + const AttributeMap &attrib_listPacked, + EGLConfig *configs, + EGLint config_size, + EGLint *num_config, + EGLBoolean returnValue); +angle::CallCapture CaptureCopyBuffers(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLNativePixmapType target, + EGLBoolean returnValue); +angle::CallCapture CaptureCreateContext(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Config *configPacked, + gl::Context *share_contextPacked, + const AttributeMap &attrib_listPacked, + EGLContext returnValue); +angle::CallCapture CaptureCreatePbufferSurface(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Config *configPacked, + const AttributeMap &attrib_listPacked, + EGLSurface returnValue); +angle::CallCapture CaptureCreatePixmapSurface(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Config *configPacked, + EGLNativePixmapType pixmap, + const AttributeMap &attrib_listPacked, + EGLSurface returnValue); +angle::CallCapture CaptureCreateWindowSurface(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Config *configPacked, + EGLNativeWindowType win, + const AttributeMap &attrib_listPacked, + EGLSurface returnValue); +angle::CallCapture CaptureDestroyContext(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + gl::Context *ctxPacked, + EGLBoolean returnValue); +angle::CallCapture CaptureDestroySurface(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLBoolean returnValue); +angle::CallCapture CaptureGetConfigAttrib(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Config *configPacked, + EGLint attribute, + EGLint *value, + EGLBoolean returnValue); +angle::CallCapture CaptureGetConfigs(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLConfig *configs, + EGLint config_size, + EGLint *num_config, + EGLBoolean returnValue); +angle::CallCapture CaptureGetCurrentDisplay(egl::Thread *thread, + bool isCallValid, + EGLDisplay returnValue); +angle::CallCapture CaptureGetCurrentSurface(egl::Thread *thread, + bool isCallValid, + EGLint readdraw, + EGLSurface returnValue); +angle::CallCapture CaptureGetDisplay(egl::Thread *thread, + bool isCallValid, + EGLNativeDisplayType display_id, + EGLDisplay returnValue); +angle::CallCapture CaptureGetError(egl::Thread *thread, bool isCallValid, EGLint returnValue); +angle::CallCapture CaptureGetProcAddress(egl::Thread *thread, + bool isCallValid, + const char *procname, + __eglMustCastToProperFunctionPointerType returnValue); +angle::CallCapture CaptureInitialize(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLint *major, + EGLint *minor, + EGLBoolean returnValue); +angle::CallCapture CaptureMakeCurrent(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *drawPacked, + egl::Surface *readPacked, + gl::Context *ctxPacked, + EGLBoolean returnValue); +angle::CallCapture CaptureQueryContext(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + gl::Context *ctxPacked, + EGLint attribute, + EGLint *value, + EGLBoolean returnValue); +angle::CallCapture CaptureQueryString(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLint name, + const char *returnValue); +angle::CallCapture CaptureQuerySurface(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLint attribute, + EGLint *value, + EGLBoolean returnValue); +angle::CallCapture CaptureSwapBuffers(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLBoolean returnValue); +angle::CallCapture CaptureTerminate(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLBoolean returnValue); +angle::CallCapture CaptureWaitGL(egl::Thread *thread, bool isCallValid, EGLBoolean returnValue); +angle::CallCapture CaptureWaitNative(egl::Thread *thread, + bool isCallValid, + EGLint engine, + EGLBoolean returnValue); +angle::CallCapture CaptureBindTexImage(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLint buffer, + EGLBoolean returnValue); +angle::CallCapture CaptureReleaseTexImage(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLint buffer, + EGLBoolean returnValue); +angle::CallCapture CaptureSurfaceAttrib(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLint attribute, + EGLint value, + EGLBoolean returnValue); +angle::CallCapture CaptureSwapInterval(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLint interval, + EGLBoolean returnValue); +angle::CallCapture CaptureBindAPI(egl::Thread *thread, + bool isCallValid, + EGLenum api, + EGLBoolean returnValue); +angle::CallCapture CaptureCreatePbufferFromClientBuffer(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLenum buftype, + EGLClientBuffer buffer, + egl::Config *configPacked, + const AttributeMap &attrib_listPacked, + EGLSurface returnValue); +angle::CallCapture CaptureQueryAPI(egl::Thread *thread, bool isCallValid, EGLenum returnValue); +angle::CallCapture CaptureReleaseThread(egl::Thread *thread, + bool isCallValid, + EGLBoolean returnValue); +angle::CallCapture CaptureWaitClient(egl::Thread *thread, bool isCallValid, EGLBoolean returnValue); +angle::CallCapture CaptureGetCurrentContext(egl::Thread *thread, + bool isCallValid, + EGLContext returnValue); +angle::CallCapture CaptureClientWaitSync(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Sync *syncPacked, + EGLint flags, + EGLTime timeout, + EGLint returnValue); +angle::CallCapture CaptureCreateImage(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + gl::Context *ctxPacked, + EGLenum target, + EGLClientBuffer buffer, + const AttributeMap &attrib_listPacked, + EGLImage returnValue); +angle::CallCapture CaptureCreatePlatformPixmapSurface(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Config *configPacked, + void *native_pixmap, + const AttributeMap &attrib_listPacked, + EGLSurface returnValue); +angle::CallCapture CaptureCreatePlatformWindowSurface(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Config *configPacked, + void *native_window, + const AttributeMap &attrib_listPacked, + EGLSurface returnValue); +angle::CallCapture CaptureCreateSync(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLenum type, + const AttributeMap &attrib_listPacked, + EGLSync returnValue); +angle::CallCapture CaptureDestroyImage(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Image *imagePacked, + EGLBoolean returnValue); +angle::CallCapture CaptureDestroySync(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Sync *syncPacked, + EGLBoolean returnValue); +angle::CallCapture CaptureGetPlatformDisplay(egl::Thread *thread, + bool isCallValid, + EGLenum platform, + void *native_display, + const AttributeMap &attrib_listPacked, + EGLDisplay returnValue); +angle::CallCapture CaptureGetSyncAttrib(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Sync *syncPacked, + EGLint attribute, + EGLAttrib *value, + EGLBoolean returnValue); +angle::CallCapture CaptureWaitSync(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Sync *syncPacked, + EGLint flags, + EGLBoolean returnValue); +angle::CallCapture CaptureSetBlobCacheFuncsANDROID(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLSetBlobFuncANDROID set, + EGLGetBlobFuncANDROID get); +angle::CallCapture CaptureCreateNativeClientBufferANDROID(egl::Thread *thread, + bool isCallValid, + const AttributeMap &attrib_listPacked, + EGLClientBuffer returnValue); +angle::CallCapture CaptureGetCompositorTimingSupportedANDROID(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + CompositorTiming namePacked, + EGLBoolean returnValue); +angle::CallCapture CaptureGetCompositorTimingANDROID(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLint numTimestamps, + const EGLint *names, + EGLnsecsANDROID *values, + EGLBoolean returnValue); +angle::CallCapture CaptureGetNextFrameIdANDROID(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLuint64KHR *frameId, + EGLBoolean returnValue); +angle::CallCapture CaptureGetFrameTimestampSupportedANDROID(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + Timestamp timestampPacked, + EGLBoolean returnValue); +angle::CallCapture CaptureGetFrameTimestampsANDROID(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLuint64KHR frameId, + EGLint numTimestamps, + const EGLint *timestamps, + EGLnsecsANDROID *values, + EGLBoolean returnValue); +angle::CallCapture CaptureGetNativeClientBufferANDROID(egl::Thread *thread, + bool isCallValid, + const struct AHardwareBuffer *buffer, + EGLClientBuffer returnValue); +angle::CallCapture CaptureDupNativeFenceFDANDROID(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Sync *syncPacked, + EGLint returnValue); +angle::CallCapture CapturePresentationTimeANDROID(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLnsecsANDROID time, + EGLBoolean returnValue); +angle::CallCapture CaptureCreateDeviceANGLE(egl::Thread *thread, + bool isCallValid, + EGLint device_type, + void *native_device, + const EGLAttrib *attrib_list, + EGLDeviceEXT returnValue); +angle::CallCapture CaptureReleaseDeviceANGLE(egl::Thread *thread, + bool isCallValid, + egl::Device *devicePacked, + EGLBoolean returnValue); +angle::CallCapture CaptureQueryStringiANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLint name, + EGLint index, + const char *returnValue); +angle::CallCapture CaptureQueryDisplayAttribANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLint attribute, + EGLAttrib *value, + EGLBoolean returnValue); +angle::CallCapture CaptureCopyMetalSharedEventANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Sync *syncPacked, + void *returnValue); +angle::CallCapture CaptureReleaseHighPowerGPUANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + gl::Context *ctxPacked); +angle::CallCapture CaptureReacquireHighPowerGPUANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + gl::Context *ctxPacked); +angle::CallCapture CaptureHandleGPUSwitchANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked); +angle::CallCapture CaptureForceGPUSwitchANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLint gpuIDHigh, + EGLint gpuIDLow); +angle::CallCapture CapturePrepareSwapBuffersANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLBoolean returnValue); +angle::CallCapture CaptureProgramCacheGetAttribANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLenum attrib, + EGLint returnValue); +angle::CallCapture CaptureProgramCacheQueryANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLint index, + void *key, + EGLint *keysize, + void *binary, + EGLint *binarysize); +angle::CallCapture CaptureProgramCachePopulateANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + const void *key, + EGLint keysize, + const void *binary, + EGLint binarysize); +angle::CallCapture CaptureProgramCacheResizeANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLint limit, + EGLint mode, + EGLint returnValue); +angle::CallCapture CaptureQuerySurfacePointerANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLint attribute, + void **value, + EGLBoolean returnValue); +angle::CallCapture CaptureCreateStreamProducerD3DTextureANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Stream *streamPacked, + const AttributeMap &attrib_listPacked, + EGLBoolean returnValue); +angle::CallCapture CaptureStreamPostD3DTextureANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Stream *streamPacked, + void *texture, + const AttributeMap &attrib_listPacked, + EGLBoolean returnValue); +angle::CallCapture CaptureSwapBuffersWithFrameTokenANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLFrameTokenANGLE frametoken, + EGLBoolean returnValue); +angle::CallCapture CaptureGetMscRateANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLint *numerator, + EGLint *denominator, + EGLBoolean returnValue); +angle::CallCapture CaptureExportVkImageANGLE(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Image *imagePacked, + void *vk_image, + void *vk_image_create_info, + EGLBoolean returnValue); +angle::CallCapture CaptureGetSyncValuesCHROMIUM(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLuint64KHR *ust, + EGLuint64KHR *msc, + EGLuint64KHR *sbc, + EGLBoolean returnValue); +angle::CallCapture CaptureQueryDeviceAttribEXT(egl::Thread *thread, + bool isCallValid, + egl::Device *devicePacked, + EGLint attribute, + EGLAttrib *value, + EGLBoolean returnValue); +angle::CallCapture CaptureQueryDeviceStringEXT(egl::Thread *thread, + bool isCallValid, + egl::Device *devicePacked, + EGLint name, + const char *returnValue); +angle::CallCapture CaptureQueryDisplayAttribEXT(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLint attribute, + EGLAttrib *value, + EGLBoolean returnValue); +angle::CallCapture CaptureQueryDmaBufFormatsEXT(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLint max_formats, + EGLint *formats, + EGLint *num_formats, + EGLBoolean returnValue); +angle::CallCapture CaptureQueryDmaBufModifiersEXT(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLint format, + EGLint max_modifiers, + EGLuint64KHR *modifiers, + EGLBoolean *external_only, + EGLint *num_modifiers, + EGLBoolean returnValue); +angle::CallCapture CaptureCreatePlatformPixmapSurfaceEXT(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Config *configPacked, + void *native_pixmap, + const AttributeMap &attrib_listPacked, + EGLSurface returnValue); +angle::CallCapture CaptureCreatePlatformWindowSurfaceEXT(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Config *configPacked, + void *native_window, + const AttributeMap &attrib_listPacked, + EGLSurface returnValue); +angle::CallCapture CaptureGetPlatformDisplayEXT(egl::Thread *thread, + bool isCallValid, + EGLenum platform, + void *native_display, + const AttributeMap &attrib_listPacked, + EGLDisplay returnValue); +angle::CallCapture CaptureDebugMessageControlKHR(egl::Thread *thread, + bool isCallValid, + EGLDEBUGPROCKHR callback, + const AttributeMap &attrib_listPacked, + EGLint returnValue); +angle::CallCapture CaptureLabelObjectKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *displayPacked, + ObjectType objectTypePacked, + EGLObjectKHR object, + EGLLabelKHR label, + EGLint returnValue); +angle::CallCapture CaptureQueryDebugKHR(egl::Thread *thread, + bool isCallValid, + EGLint attribute, + EGLAttrib *value, + EGLBoolean returnValue); +angle::CallCapture CaptureClientWaitSyncKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Sync *syncPacked, + EGLint flags, + EGLTimeKHR timeout, + EGLint returnValue); +angle::CallCapture CaptureCreateSyncKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + EGLenum type, + const AttributeMap &attrib_listPacked, + EGLSyncKHR returnValue); +angle::CallCapture CaptureDestroySyncKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Sync *syncPacked, + EGLBoolean returnValue); +angle::CallCapture CaptureGetSyncAttribKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Sync *syncPacked, + EGLint attribute, + EGLint *value, + EGLBoolean returnValue); +angle::CallCapture CaptureCreateImageKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + gl::Context *ctxPacked, + EGLenum target, + EGLClientBuffer buffer, + const AttributeMap &attrib_listPacked, + EGLImageKHR returnValue); +angle::CallCapture CaptureDestroyImageKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Image *imagePacked, + EGLBoolean returnValue); +angle::CallCapture CaptureLockSurfaceKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + const AttributeMap &attrib_listPacked, + EGLBoolean returnValue); +angle::CallCapture CaptureQuerySurface64KHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLint attribute, + EGLAttribKHR *value, + EGLBoolean returnValue); +angle::CallCapture CaptureUnlockSurfaceKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLBoolean returnValue); +angle::CallCapture CaptureSetDamageRegionKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLint *rects, + EGLint n_rects, + EGLBoolean returnValue); +angle::CallCapture CaptureSignalSyncKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Sync *syncPacked, + EGLenum mode, + EGLBoolean returnValue); +angle::CallCapture CaptureCreateStreamKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + const AttributeMap &attrib_listPacked, + EGLStreamKHR returnValue); +angle::CallCapture CaptureDestroyStreamKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Stream *streamPacked, + EGLBoolean returnValue); +angle::CallCapture CaptureQueryStreamKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Stream *streamPacked, + EGLenum attribute, + EGLint *value, + EGLBoolean returnValue); +angle::CallCapture CaptureQueryStreamu64KHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Stream *streamPacked, + EGLenum attribute, + EGLuint64KHR *value, + EGLBoolean returnValue); +angle::CallCapture CaptureStreamAttribKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Stream *streamPacked, + EGLenum attribute, + EGLint value, + EGLBoolean returnValue); +angle::CallCapture CaptureStreamConsumerAcquireKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Stream *streamPacked, + EGLBoolean returnValue); +angle::CallCapture CaptureStreamConsumerGLTextureExternalKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Stream *streamPacked, + EGLBoolean returnValue); +angle::CallCapture CaptureStreamConsumerReleaseKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Stream *streamPacked, + EGLBoolean returnValue); +angle::CallCapture CaptureSwapBuffersWithDamageKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + const EGLint *rects, + EGLint n_rects, + EGLBoolean returnValue); +angle::CallCapture CaptureWaitSyncKHR(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Sync *syncPacked, + EGLint flags, + EGLint returnValue); +angle::CallCapture CapturePostSubBufferNV(egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Surface *surfacePacked, + EGLint x, + EGLint y, + EGLint width, + EGLint height, + EGLBoolean returnValue); +angle::CallCapture CaptureStreamConsumerGLTextureExternalAttribsNV( + egl::Thread *thread, + bool isCallValid, + egl::Display *dpyPacked, + egl::Stream *streamPacked, + const AttributeMap &attrib_listPacked, + EGLBoolean returnValue); +} // namespace egl + +#endif // LIBANGLE_CAPTURE_EGL_AUTOGEN_H_ diff --git a/src/libANGLE/capture/capture_gl_1_autogen.cpp b/src/libANGLE/capture/capture_gl_1_autogen.cpp index e4359f893..0159a9fe2 100644 --- a/src/libANGLE/capture/capture_gl_1_autogen.cpp +++ b/src/libANGLE/capture/capture_gl_1_autogen.cpp @@ -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, diff --git a/src/libANGLE/capture/capture_gl_2_autogen.cpp b/src/libANGLE/capture/capture_gl_2_autogen.cpp index 336522da7..e10738b7b 100644 --- a/src/libANGLE/capture/capture_gl_2_autogen.cpp +++ b/src/libANGLE/capture/capture_gl_2_autogen.cpp @@ -21,7 +21,6 @@ namespace gl { // GL 2.0 - CallCapture CaptureGetVertexAttribdv(const State &glState, bool isCallValid, GLuint index, diff --git a/src/libANGLE/capture/capture_gl_3_autogen.cpp b/src/libANGLE/capture/capture_gl_3_autogen.cpp index d0b950e7b..d5075101b 100644 --- a/src/libANGLE/capture/capture_gl_3_autogen.cpp +++ b/src/libANGLE/capture/capture_gl_3_autogen.cpp @@ -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, diff --git a/src/libANGLE/capture/capture_gl_4_autogen.cpp b/src/libANGLE/capture/capture_gl_4_autogen.cpp index b66ebf008..bd39def37 100644 --- a/src/libANGLE/capture/capture_gl_4_autogen.cpp +++ b/src/libANGLE/capture/capture_gl_4_autogen.cpp @@ -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, diff --git a/src/libANGLE/capture/capture_gles_1_0_autogen.cpp b/src/libANGLE/capture/capture_gles_1_0_autogen.cpp index 6c4be7a18..edd34fabd 100644 --- a/src/libANGLE/capture/capture_gles_1_0_autogen.cpp +++ b/src/libANGLE/capture/capture_gles_1_0_autogen.cpp @@ -19,7 +19,6 @@ using namespace angle; namespace gl { - CallCapture CaptureAlphaFunc(const State &glState, bool isCallValid, AlphaTestFunc funcPacked, diff --git a/src/libANGLE/capture/capture_gles_2_0_autogen.cpp b/src/libANGLE/capture/capture_gles_2_0_autogen.cpp index 0aff42aa8..dc15aaea9 100644 --- a/src/libANGLE/capture/capture_gles_2_0_autogen.cpp +++ b/src/libANGLE/capture/capture_gles_2_0_autogen.cpp @@ -19,7 +19,6 @@ using namespace angle; namespace gl { - CallCapture CaptureActiveTexture(const State &glState, bool isCallValid, GLenum texture) { ParamBuffer paramBuffer; diff --git a/src/libANGLE/capture/capture_gles_3_0_autogen.cpp b/src/libANGLE/capture/capture_gles_3_0_autogen.cpp index 9f30f1050..00bd25d28 100644 --- a/src/libANGLE/capture/capture_gles_3_0_autogen.cpp +++ b/src/libANGLE/capture/capture_gles_3_0_autogen.cpp @@ -19,7 +19,6 @@ using namespace angle; namespace gl { - CallCapture CaptureBeginQuery(const State &glState, bool isCallValid, QueryType targetPacked, diff --git a/src/libANGLE/capture/capture_gles_3_1_autogen.cpp b/src/libANGLE/capture/capture_gles_3_1_autogen.cpp index 2ec8de055..da2defada 100644 --- a/src/libANGLE/capture/capture_gles_3_1_autogen.cpp +++ b/src/libANGLE/capture/capture_gles_3_1_autogen.cpp @@ -19,7 +19,6 @@ using namespace angle; namespace gl { - CallCapture CaptureActiveShaderProgram(const State &glState, bool isCallValid, ProgramPipelineID pipelinePacked, diff --git a/src/libANGLE/capture/capture_gles_3_2_autogen.cpp b/src/libANGLE/capture/capture_gles_3_2_autogen.cpp index 91abf3620..8d7c1561c 100644 --- a/src/libANGLE/capture/capture_gles_3_2_autogen.cpp +++ b/src/libANGLE/capture/capture_gles_3_2_autogen.cpp @@ -19,7 +19,6 @@ using namespace angle; namespace gl { - CallCapture CaptureBlendBarrier(const State &glState, bool isCallValid) { ParamBuffer paramBuffer; diff --git a/src/libANGLE/capture/capture_gles_ext_autogen.cpp b/src/libANGLE/capture/capture_gles_ext_autogen.cpp index 81097ec22..4a508327c 100644 --- a/src/libANGLE/capture/capture_gles_ext_autogen.cpp +++ b/src/libANGLE/capture/capture_gles_ext_autogen.cpp @@ -19,7 +19,6 @@ using namespace angle; namespace gl { - CallCapture CaptureBeginPerfMonitorAMD(const State &glState, bool isCallValid, GLuint monitor) { ParamBuffer paramBuffer; diff --git a/src/libANGLE/capture/frame_capture_utils_autogen.cpp b/src/libANGLE/capture/frame_capture_utils_autogen.cpp index 1d37bcafe..717a50795 100644 --- a/src/libANGLE/capture/frame_capture_utils_autogen.cpp +++ b/src/libANGLE/capture/frame_capture_utils_autogen.cpp @@ -71,6 +71,9 @@ void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const Pa WriteParamValueReplay(os, call, param.value.EGLAttribPointerVal); break; + case ParamType::TEGLBoolean: + WriteParamValueReplay(os, call, param.value.EGLBooleanVal); + break; case ParamType::TEGLBooleanPointer: WriteParamValueReplay(os, call, param.value.EGLBooleanPointerVal); @@ -83,10 +86,19 @@ void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const Pa WriteParamValueReplay(os, call, param.value.EGLConfigPointerVal); break; + case ParamType::TEGLContext: + WriteParamValueReplay(os, call, param.value.EGLContextVal); + break; case ParamType::TEGLDEBUGPROCKHR: WriteParamValueReplay(os, call, param.value.EGLDEBUGPROCKHRVal); break; + case ParamType::TEGLDeviceEXT: + WriteParamValueReplay(os, call, param.value.EGLDeviceEXTVal); + break; + case ParamType::TEGLDisplay: + WriteParamValueReplay(os, call, param.value.EGLDisplayVal); + break; case ParamType::TEGLFrameTokenANGLE: WriteParamValueReplay( os, call, param.value.EGLFrameTokenANGLEVal); @@ -95,6 +107,12 @@ void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const Pa WriteParamValueReplay( os, call, param.value.EGLGetBlobFuncANDROIDVal); break; + case ParamType::TEGLImage: + WriteParamValueReplay(os, call, param.value.EGLImageVal); + break; + case ParamType::TEGLImageKHR: + WriteParamValueReplay(os, call, param.value.EGLImageKHRVal); + break; case ParamType::TEGLLabelKHR: WriteParamValueReplay(os, call, param.value.EGLLabelKHRVal); break; @@ -117,6 +135,18 @@ void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const Pa WriteParamValueReplay( os, call, param.value.EGLSetBlobFuncANDROIDVal); break; + case ParamType::TEGLStreamKHR: + WriteParamValueReplay(os, call, param.value.EGLStreamKHRVal); + break; + case ParamType::TEGLSurface: + WriteParamValueReplay(os, call, param.value.EGLSurfaceVal); + break; + case ParamType::TEGLSync: + WriteParamValueReplay(os, call, param.value.EGLSyncVal); + break; + case ParamType::TEGLSyncKHR: + WriteParamValueReplay(os, call, param.value.EGLSyncKHRVal); + break; case ParamType::TEGLTime: WriteParamValueReplay(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: diff --git a/src/libANGLE/capture/frame_capture_utils_autogen.h b/src/libANGLE/capture/frame_capture_utils_autogen.h index 653e70cfe..dddd7243b 100644 --- a/src/libANGLE/capture/frame_capture_utils_autogen.h +++ b/src/libANGLE/capture/frame_capture_utils_autogen.h @@ -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(const P return value.EGLAttribPointerVal; } +template <> +inline EGLBoolean GetParamVal(const ParamValue &value) +{ + return value.EGLBooleanVal; +} + template <> inline EGLBoolean *GetParamVal(const ParamValue &value) { @@ -463,6 +489,12 @@ inline EGLConfig *GetParamVal(const P return value.EGLConfigPointerVal; } +template <> +inline EGLContext GetParamVal(const ParamValue &value) +{ + return value.EGLContextVal; +} + template <> inline EGLDEBUGPROCKHR GetParamVal( const ParamValue &value) @@ -470,6 +502,18 @@ inline EGLDEBUGPROCKHR GetParamVal return value.EGLDEBUGPROCKHRVal; } +template <> +inline EGLDeviceEXT GetParamVal(const ParamValue &value) +{ + return value.EGLDeviceEXTVal; +} + +template <> +inline EGLDisplay GetParamVal(const ParamValue &value) +{ + return value.EGLDisplayVal; +} + template <> inline EGLFrameTokenANGLE GetParamVal( const ParamValue &value) @@ -484,6 +528,18 @@ inline EGLGetBlobFuncANDROID GetParamVal +inline EGLImage GetParamVal(const ParamValue &value) +{ + return value.EGLImageVal; +} + +template <> +inline EGLImageKHR GetParamVal(const ParamValue &value) +{ + return value.EGLImageKHRVal; +} + template <> inline EGLLabelKHR GetParamVal(const ParamValue &value) { @@ -524,6 +580,30 @@ inline EGLSetBlobFuncANDROID GetParamVal +inline EGLStreamKHR GetParamVal(const ParamValue &value) +{ + return value.EGLStreamKHRVal; +} + +template <> +inline EGLSurface GetParamVal(const ParamValue &value) +{ + return value.EGLSurfaceVal; +} + +template <> +inline EGLSync GetParamVal(const ParamValue &value) +{ + return value.EGLSyncVal; +} + +template <> +inline EGLSyncKHR GetParamVal(const ParamValue &value) +{ + return value.EGLSyncKHRVal; +} + template <> inline EGLTime GetParamVal(const ParamValue &value) { @@ -1449,18 +1529,30 @@ T AccessParamValue(ParamType paramType, const ParamValue &value) return GetParamVal(value); case ParamType::TEGLAttribPointer: return GetParamVal(value); + case ParamType::TEGLBoolean: + return GetParamVal(value); case ParamType::TEGLBooleanPointer: return GetParamVal(value); case ParamType::TEGLClientBuffer: return GetParamVal(value); case ParamType::TEGLConfigPointer: return GetParamVal(value); + case ParamType::TEGLContext: + return GetParamVal(value); case ParamType::TEGLDEBUGPROCKHR: return GetParamVal(value); + case ParamType::TEGLDeviceEXT: + return GetParamVal(value); + case ParamType::TEGLDisplay: + return GetParamVal(value); case ParamType::TEGLFrameTokenANGLE: return GetParamVal(value); case ParamType::TEGLGetBlobFuncANDROID: return GetParamVal(value); + case ParamType::TEGLImage: + return GetParamVal(value); + case ParamType::TEGLImageKHR: + return GetParamVal(value); case ParamType::TEGLLabelKHR: return GetParamVal(value); case ParamType::TEGLNativeDisplayType: @@ -1473,6 +1565,14 @@ T AccessParamValue(ParamType paramType, const ParamValue &value) return GetParamVal(value); case ParamType::TEGLSetBlobFuncANDROID: return GetParamVal(value); + case ParamType::TEGLStreamKHR: + return GetParamVal(value); + case ParamType::TEGLSurface: + return GetParamVal(value); + case ParamType::TEGLSync: + return GetParamVal(value); + case ParamType::TEGLSyncKHR: + return GetParamVal(value); case ParamType::TEGLTime: return GetParamVal(value); case ParamType::TEGLTimeKHR: @@ -1840,6 +1940,12 @@ inline void SetParamVal(EGLAttrib *valueIn, ParamV valueOut->EGLAttribPointerVal = valueIn; } +template <> +inline void SetParamVal(EGLBoolean valueIn, ParamValue *valueOut) +{ + valueOut->EGLBooleanVal = valueIn; +} + template <> inline void SetParamVal(EGLBoolean *valueIn, ParamValue *valueOut) { @@ -1858,12 +1964,30 @@ inline void SetParamVal(EGLConfig *valueIn, ParamV valueOut->EGLConfigPointerVal = valueIn; } +template <> +inline void SetParamVal(EGLContext valueIn, ParamValue *valueOut) +{ + valueOut->EGLContextVal = valueIn; +} + template <> inline void SetParamVal(EGLDEBUGPROCKHR valueIn, ParamValue *valueOut) { valueOut->EGLDEBUGPROCKHRVal = valueIn; } +template <> +inline void SetParamVal(EGLDeviceEXT valueIn, ParamValue *valueOut) +{ + valueOut->EGLDeviceEXTVal = valueIn; +} + +template <> +inline void SetParamVal(EGLDisplay valueIn, ParamValue *valueOut) +{ + valueOut->EGLDisplayVal = valueIn; +} + template <> inline void SetParamVal(EGLFrameTokenANGLE valueIn, ParamValue *valueOut) @@ -1878,6 +2002,18 @@ inline void SetParamVal(EGLGetBlobFuncANDROID valueOut->EGLGetBlobFuncANDROIDVal = valueIn; } +template <> +inline void SetParamVal(EGLImage valueIn, ParamValue *valueOut) +{ + valueOut->EGLImageVal = valueIn; +} + +template <> +inline void SetParamVal(EGLImageKHR valueIn, ParamValue *valueOut) +{ + valueOut->EGLImageKHRVal = valueIn; +} + template <> inline void SetParamVal(EGLLabelKHR valueIn, ParamValue *valueOut) { @@ -1918,6 +2054,30 @@ inline void SetParamVal(EGLSetBlobFuncANDROID valueOut->EGLSetBlobFuncANDROIDVal = valueIn; } +template <> +inline void SetParamVal(EGLStreamKHR valueIn, ParamValue *valueOut) +{ + valueOut->EGLStreamKHRVal = valueIn; +} + +template <> +inline void SetParamVal(EGLSurface valueIn, ParamValue *valueOut) +{ + valueOut->EGLSurfaceVal = valueIn; +} + +template <> +inline void SetParamVal(EGLSync valueIn, ParamValue *valueOut) +{ + valueOut->EGLSyncVal = valueIn; +} + +template <> +inline void SetParamVal(EGLSyncKHR valueIn, ParamValue *valueOut) +{ + valueOut->EGLSyncKHRVal = valueIn; +} + template <> inline void SetParamVal(EGLTime valueIn, ParamValue *valueOut) { @@ -2831,6 +2991,9 @@ void InitParamValue(ParamType paramType, T valueIn, ParamValue *valueOut) case ParamType::TEGLAttribPointer: SetParamVal(valueIn, valueOut); break; + case ParamType::TEGLBoolean: + SetParamVal(valueIn, valueOut); + break; case ParamType::TEGLBooleanPointer: SetParamVal(valueIn, valueOut); break; @@ -2840,15 +3003,30 @@ void InitParamValue(ParamType paramType, T valueIn, ParamValue *valueOut) case ParamType::TEGLConfigPointer: SetParamVal(valueIn, valueOut); break; + case ParamType::TEGLContext: + SetParamVal(valueIn, valueOut); + break; case ParamType::TEGLDEBUGPROCKHR: SetParamVal(valueIn, valueOut); break; + case ParamType::TEGLDeviceEXT: + SetParamVal(valueIn, valueOut); + break; + case ParamType::TEGLDisplay: + SetParamVal(valueIn, valueOut); + break; case ParamType::TEGLFrameTokenANGLE: SetParamVal(valueIn, valueOut); break; case ParamType::TEGLGetBlobFuncANDROID: SetParamVal(valueIn, valueOut); break; + case ParamType::TEGLImage: + SetParamVal(valueIn, valueOut); + break; + case ParamType::TEGLImageKHR: + SetParamVal(valueIn, valueOut); + break; case ParamType::TEGLLabelKHR: SetParamVal(valueIn, valueOut); break; @@ -2867,6 +3045,18 @@ void InitParamValue(ParamType paramType, T valueIn, ParamValue *valueOut) case ParamType::TEGLSetBlobFuncANDROID: SetParamVal(valueIn, valueOut); break; + case ParamType::TEGLStreamKHR: + SetParamVal(valueIn, valueOut); + break; + case ParamType::TEGLSurface: + SetParamVal(valueIn, valueOut); + break; + case ParamType::TEGLSync: + SetParamVal(valueIn, valueOut); + break; + case ParamType::TEGLSyncKHR: + SetParamVal(valueIn, valueOut); + break; case ParamType::TEGLTime: SetParamVal(valueIn, valueOut); break; diff --git a/src/libANGLE/capture/trace_fixture.h b/src/libANGLE/capture/trace_fixture.h index be9a4dd47..755da0e31 100644 --- a/src/libANGLE/capture/trace_fixture.h +++ b/src/libANGLE/capture/trace_fixture.h @@ -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; extern SyncResourceMap gSyncMap; -using ContextMap = std::unordered_map; +using ContextMap = std::unordered_map; extern ContextMap gContextMap; using SurfaceMap = std::unordered_map; @@ -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); diff --git a/src/libANGLE/entry_points_utils.h b/src/libANGLE/entry_points_utils.h index c5a317830..65981ce5f 100644 --- a/src/libANGLE/entry_points_utils.h +++ b/src/libANGLE/entry_points_utils.h @@ -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_ diff --git a/src/libGLESv2.gni b/src/libGLESv2.gni index 1626d63a9..a215c5c34 100644 --- a/src/libGLESv2.gni +++ b/src/libGLESv2.gni @@ -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", diff --git a/src/libGLESv2/egl_ext_stubs.cpp b/src/libGLESv2/egl_ext_stubs.cpp index a8b514208..78cdea492 100644 --- a/src/libGLESv2/egl_ext_stubs.cpp +++ b/src/libGLESv2/egl_ext_stubs.cpp @@ -13,8 +13,6 @@ #include "libANGLE/EGLSync.h" #include "libANGLE/Surface.h" #include "libANGLE/Thread.h" -#include "libANGLE/capture/capture_egl.h" -#include "libANGLE/capture/frame_capture_utils_autogen.h" #include "libANGLE/entry_points_utils.h" #include "libANGLE/queryutils.h" #include "libANGLE/renderer/DisplayImpl.h" @@ -55,8 +53,6 @@ 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(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; } diff --git a/src/libGLESv2/egl_stubs.cpp b/src/libGLESv2/egl_stubs.cpp index 6907cfc68..cdaa21aab 100644 --- a/src/libGLESv2/egl_stubs.cpp +++ b/src/libGLESv2/egl_stubs.cpp @@ -14,8 +14,6 @@ #include "libANGLE/EGLSync.h" #include "libANGLE/Surface.h" #include "libANGLE/Thread.h" -#include "libANGLE/capture/capture_egl.h" -#include "libANGLE/capture/frame_capture_utils_autogen.h" #include "libANGLE/capture/gl_enum_utils_autogen.h" #include "libANGLE/queryutils.h" #include "libANGLE/validationEGL.h" @@ -71,8 +69,6 @@ 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(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(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(); diff --git a/src/libGLESv2/entry_points_egl_autogen.cpp b/src/libGLESv2/entry_points_egl_autogen.cpp index 318f8f0e7..5f82b7f67 100644 --- a/src/libGLESv2/entry_points_egl_autogen.cpp +++ b/src/libGLESv2/entry_points_egl_autogen.cpp @@ -10,6 +10,7 @@ #include "libGLESv2/entry_points_egl_autogen.h" +#include "libANGLE/capture/capture_egl_autogen.h" #include "libANGLE/entry_points_utils.h" #include "libANGLE/validationEGL_autogen.h" #include "libGLESv2/egl_ext_stubs_autogen.h" @@ -43,7 +44,11 @@ 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" diff --git a/src/libGLESv2/entry_points_egl_ext_autogen.cpp b/src/libGLESv2/entry_points_egl_ext_autogen.cpp index c8957f0c7..224ce6f2d 100644 --- a/src/libGLESv2/entry_points_egl_ext_autogen.cpp +++ b/src/libGLESv2/entry_points_egl_ext_autogen.cpp @@ -10,6 +10,7 @@ #include "libGLESv2/entry_points_egl_ext_autogen.h" +#include "libANGLE/capture/capture_egl_autogen.h" #include "libANGLE/entry_points_utils.h" #include "libANGLE/validationEGL_autogen.h" #include "libGLESv2/egl_ext_stubs_autogen.h" @@ -38,6 +39,7 @@ 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"