Skip to content

A
angle
Commit 3efa290d by Jamie Madill Committed by Commit Bot
Options

EGL: Auto-generate validation header.

This is a first step towards auto-generating more EGL code. It includes format handling for all the EGL parameter types, type reinterpretation for EGL types using the "packed enum" handling, and code refactoring to support the new consistent validation entry point pattern. Bug: angleproject:2621 Change-Id: I2740e82928db311aa934825cbe74bd75bf49c33c Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2552976 Commit-Queue: Jamie Madill <jmadill@chromium.org> Reviewed-by: 's avatarTim Van Patten <timvp@google.com> Reviewed-by: 's avatarCody Northrop <cnorthrop@google.com>
parent 10b22c11
Showing with 1543 additions and 1154 deletions
scripts/code_generation_hashes/GL_EGL_WGL_loader.json
......@@ -2,7 +2,7 @@
"scripts/egl.xml":
"4e5911cfe91274cc5112ff2f70092376",
"scripts/egl_angle_ext.xml":
"087d6a3996a91fbb0b664cac57c50c4c",
"91f7718effe50d444f8d81ce285721db",
"scripts/generate_loader.py":
"ef16088fdf3e7e97132f7737d20f563a",
"scripts/gl.xml":
......
scripts/code_generation_hashes/GL_EGL_entry_points.json
......@@ -2,11 +2,13 @@
"scripts/egl.xml":
"4e5911cfe91274cc5112ff2f70092376",
"scripts/egl_angle_ext.xml":
"087d6a3996a91fbb0b664cac57c50c4c",
"91f7718effe50d444f8d81ce285721db",
"scripts/entry_point_packed_egl_enums.json":
"7cb78d6bea4e0df9e74d3ce5faf824dc",
"scripts/entry_point_packed_gl_enums.json":
"846be5dc8cb36076207699b025633fcc",
"scripts/generate_entry_points.py":
"bce338a2d1cae08cd5836405759107bc",
"ec6a54bce430567b493ac6a5ee145a7e",
"scripts/gl.xml":
"f66967f3f3d696b5d8306fd80bbd49a8",
"scripts/gl_angle_ext.xml":
......@@ -99,6 +101,8 @@
"442ed8cd644833c56ff5e50083e3d94d",
"src/libANGLE/frame_capture_utils_autogen.h":
"652b821a877d6eb2c62ba8d151157eea",
"src/libANGLE/validationEGL_autogen.h":
"ecdb1d2c7cd19d2a4faeafb19de4d77e",
"src/libANGLE/validationES1_autogen.h":
"c8edb0a5b26303bf7c4692b9d0b05c1f",
"src/libANGLE/validationES2_autogen.h":
......
scripts/code_generation_hashes/proc_table.json
......@@ -2,7 +2,7 @@
"scripts/egl.xml":
"4e5911cfe91274cc5112ff2f70092376",
"scripts/egl_angle_ext.xml":
"087d6a3996a91fbb0b664cac57c50c4c",
"91f7718effe50d444f8d81ce285721db",
"scripts/gen_proc_table.py":
"30317d8175c0dafe55c80e67a2d3aeae",
"scripts/gl.xml":
......
scripts/egl_angle_ext.xml
......@@ -14,7 +14,7 @@
<proto><ptype>EGLDeviceEXT</ptype> <name>eglCreateDeviceANGLE</name></proto>
<param><ptype>EGLint</ptype> <name>device_type</name></param>
<param>void *<name>native_device</name></param>
<param>const <ptype>EGLattrib</ptype> *<name>attrib_list</name></param>
<param>const <ptype>EGLAttrib</ptype> *<name>attrib_list</name></param>
</command>
<command>
<proto><ptype>EGLBoolean</ptype> <name>eglReleaseDeviceANGLE</name></proto>
......@@ -108,6 +108,12 @@
<proto><pytpe>void</pytpe> <name>eglHandleGPUSwitchANGLE</name></proto>
<param><ptype>EGLDisplay</ptype> <name>dpy</name></param>
</command>
<command>
<proto><ptype>EGLBoolean</ptype> <name>eglQueryDisplayAttribANGLE</name></proto>
<param><ptype>EGLDisplay</ptype> <name>dpy</name></param>
<param><ptype>EGLint</ptype> <name>attribute</name></param>
<param><ptype>EGLAttrib *</ptype> <name>value</name></param>
</command>
</commands>
<!-- SECTION: ANGLE extension interface definitions -->
<extensions>
......
scripts/entry_point_packed_egl_enums.json 0 → 100644
{
"description": [
"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.",
"",
"entry_point_packed_egl_enums.json: Metadata for packing entry point params.",
"",
"Note that all entry points have their suffixes stripped in this file.",
"These enums are used by generate_entry_points.py."
],
"eglChooseConfig": {
"attrib_list": "const AttributeMap &"
},
"eglCreateContext": {
"attrib_list": "const AttributeMap &"
},
"eglCreateImage": {
"attrib_list": "const AttributeMap &"
},
"eglCreateNativeClientBuffer": {
"attrib_list": "const AttributeMap &"
},
"eglCreatePbufferSurface": {
"attrib_list": "const AttributeMap &"
},
"eglCreatePixmapSurface": {
"attrib_list": "const AttributeMap &"
},
"eglCreatePbufferFromClientBuffer": {
"attrib_list": "const AttributeMap &"
},
"eglCreatePlatformPixmapSurface": {
"native_pixmap": "EGLNativePixmapType",
"attrib_list": "const AttributeMap &"
},
"eglCreatePlatformWindowSurface": {
"native_window": "EGLNativeWindowType",
"attrib_list": "const AttributeMap &"
},
"eglCreateStream": {
"attrib_list": "const AttributeMap &"
},
"eglCreateStreamProducerD3DTexture": {
"attrib_list": "const AttributeMap &"
},
"eglCreateSync": {
"attrib_list": "const AttributeMap &"
},
"eglCreateWindowSurface": {
"attrib_list": "const AttributeMap &"
},
"eglDebugMessageControl": {
"attrib_list": "const AttributeMap &"
},
"eglGetCompositorTimingSupported": {
"name": "CompositorTiming"
},
"eglGetFrameTimestampSupported": {
"timestamp": "Timestamp"
},
"eglGetPlatformDisplay": {
"attrib_list": "const AttributeMap &"
},
"eglLabelObject": {
"objectType": "ObjectType"
},
"eglStreamConsumerGLTextureExternalAttribsNV": {
"attrib_list": "const AttributeMap &"
},
"eglStreamPostD3DTexture": {
"attrib_list": "const AttributeMap &"
}
}
\ No newline at end of file
scripts/generate_entry_points.py
......@@ -12,6 +12,9 @@ import sys, os, pprint, json
from datetime import date
import registry_xml
# API types
GL, GLES, WGL, EGL = ["GL", "GLES", "WGL", "EGL"]
# List of GLES1 extensions for which we don't need to add Context.h decls.
GLES1_NO_CONTEXT_DECL_EXTENSIONS = [
"GL_OES_framebuffer_object",
......@@ -34,7 +37,7 @@ ALIASING_EXCEPTIONS = [
]
# Strip these suffixes from Context entry point names. NV is excluded (for now).
STRIP_SUFFIXES = ["ANGLE", "EXT", "KHR", "OES", "CHROMIUM", "OVR"]
STRIP_SUFFIXES = ["ANDROID", "ANGLE", "EXT", "KHR", "OES", "CHROMIUM", "OVR"]
TEMPLATE_ENTRY_POINT_HEADER = """\
// GENERATED FILE - DO NOT EDIT.
......@@ -257,7 +260,7 @@ TEMPLATE_GLEXT_EXPLICIT_CONTEXT_INC = """\
TEMPLATE_GLEXT_FUNCTION_POINTER = """typedef {return_type}(GL_APIENTRYP PFN{name_upper}{explicit_context_suffix_upper}PROC)({explicit_context_param}{explicit_context_comma}{params});"""
TEMPLATE_GLEXT_FUNCTION_PROTOTYPE = """{apicall} {return_type}GL_APIENTRY {name}{explicit_context_suffix}({explicit_context_param}{explicit_context_comma}{params});"""
TEMPLATE_VALIDATION_HEADER = """\
TEMPLATE_GL_VALIDATION_HEADER = """\
// GENERATED FILE - DO NOT EDIT.
// Generated by {script_name} using data from {data_source_name}.
//
......@@ -283,6 +286,30 @@ class Context;
#endif // LIBANGLE_VALIDATION_{annotation}_AUTOGEN_H_
"""
TEMPLATE_EGL_VALIDATION_HEADER = """\
// GENERATED FILE - DO NOT EDIT.
// Generated by {script_name} using data from {data_source_name}.
//
// 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.
//
// validation{annotation}_autogen.h:
// Validation functions for the {comment} entry points.
#ifndef LIBANGLE_VALIDATION_{annotation}_AUTOGEN_H_
#define LIBANGLE_VALIDATION_{annotation}_AUTOGEN_H_
#include "libANGLE/validationEGL.h"
namespace egl
{{
{prototypes}
}} // namespace egl
#endif // LIBANGLE_VALIDATION_{annotation}_AUTOGEN_H_
"""
TEMPLATE_CAPTURE_HEADER = """\
// GENERATED FILE - DO NOT EDIT.
// Generated by {script_name} using data from {data_source_name}.
......@@ -464,7 +491,34 @@ FORMAT_DICT = {
"GLuint64": "%llu",
"GLushort": "%u",
"int": "%d",
# WGL specific types
# EGL-specific types
"EGLConfig": "0x%016\" PRIxPTR \"",
"EGLContext": "0x%016\" PRIxPTR \"",
"EGLDisplay": "0x%016\" PRIxPTR \"",
"EGLSurface": "0x%016\" PRIxPTR \"",
"EGLSync": "0x%016\" PRIxPTR \"",
"EGLNativeDisplayType": "0x%016\" PRIxPTR \"",
"EGLNativePixmapType": "0x%016\" PRIxPTR \"",
"EGLNativeWindowType": "0x%016\" PRIxPTR \"",
"EGLClientBuffer": "0x%016\" PRIxPTR \"",
"EGLenum": "0x%X",
"EGLint": "%d",
"EGLImage": "0x%016\" PRIxPTR \"",
"EGLTime": "%llu",
"EGLGetBlobFuncANDROID": "0x%016\" PRIxPTR \"",
"EGLSetBlobFuncANDROID": "0x%016\" PRIxPTR \"",
"EGLuint64KHR": "%llu",
"EGLSyncKHR": "0x%016\" PRIxPTR \"",
"EGLnsecsANDROID": "%llu",
"EGLDeviceEXT": "0x%016\" PRIxPTR \"",
"EGLDEBUGPROCKHR": "0x%016\" PRIxPTR \"",
"EGLObjectKHR": "0x%016\" PRIxPTR \"",
"EGLLabelKHR": "0x%016\" PRIxPTR \"",
"EGLTimeKHR": "%llu",
"EGLImageKHR": "0x%016\" PRIxPTR \"",
"EGLStreamKHR": "0x%016\" PRIxPTR \"",
"EGLFrameTokenANGLE": "0x%llX",
# WGL-specific types
"BOOL": "%u",
"DWORD": "0x%016\" PRIxPTR \"",
"FLOAT": "%f",
......@@ -729,19 +783,36 @@ TEMPLATE_RESOURCE_ID_TYPE_NAME_CASE = """\
case ResourceIDType::{resource_id_type}:
return "{resource_id_type}";"""
EGL_PACKED_TYPES = {
"EGLContext": "gl::Context *",
"EGLConfig": "Config *",
"EGLDeviceEXT": "Device *",
"EGLDisplay": "Display *",
"EGLImage": "Image *",
"EGLImageKHR": "Image *",
"EGLStreamKHR": "Stream *",
"EGLSurface": "Surface *",
"EGLSync": "Sync *",
"EGLSyncKHR": "Sync *",
}
def is_aliasing_excepted(cmd_name, is_gles):
return is_gles and cmd_name in ALIASING_EXCEPTIONS
def is_aliasing_excepted(api, cmd_name):
return api == GLES and cmd_name in ALIASING_EXCEPTIONS
def script_relative(path):
return os.path.join(os.path.dirname(sys.argv[0]), path)
def strip_api_prefix(cmd_name):
return cmd_name.lstrip("egl")
def format_entry_point_decl(cmd_name, proto, params, is_explicit_context):
comma_if_needed = ", " if len(params) > 0 else ""
return TEMPLATE_ENTRY_POINT_DECL.format(
name=cmd_name[2:],
name=strip_api_prefix(cmd_name),
return_type=proto[:-len(cmd_name)],
params=", ".join(params),
comma_if_needed=comma_if_needed,
......@@ -827,7 +898,8 @@ def param_format_string(param):
def default_return_value(cmd_name, return_type):
if return_type == "void":
return ""
return "GetDefaultReturnValue<EntryPoint::" + cmd_name[2:] + ", " + return_type + ">()"
return "GetDefaultReturnValue<EntryPoint::%s, %s>()" % (strip_api_prefix(cmd_name),
return_type)
def is_context_lost_acceptable_cmd(cmd_name):
......@@ -877,9 +949,9 @@ def get_constext_lost_error_generator(cmd_name, is_explicit_context):
return "GenerateContextLostErrorOnCurrentGlobalContext();"
def strip_suffix(name, is_gles):
def strip_suffix(api, name):
# For commands where aliasing is excepted, keep the suffix
if is_aliasing_excepted(name, is_gles):
if is_aliasing_excepted(api, name):
return name
for suffix in STRIP_SUFFIXES:
......@@ -901,14 +973,20 @@ def find_gl_enum_group_in_command(command_node, param_name):
return group_name
def get_packed_enums(cmd_packed_gl_enums, cmd_name, is_gles):
def get_packed_enums(api, cmd_packed_gl_enums, cmd_name, packed_param_types, params):
# Always strip the suffix when querying packed enums.
return cmd_packed_gl_enums.get(strip_suffix(cmd_name, is_gles), {})
result = cmd_packed_gl_enums.get(strip_suffix(api, cmd_name), {})
for param in params:
param_type = just_the_type(param)
if param_type in packed_param_types:
result[just_the_name(param)] = packed_param_types[param_type]
return result
def format_entry_point_def(command_node, cmd_name, proto, params, is_explicit_context,
cmd_packed_gl_enums, is_gles):
packed_gl_enums = get_packed_enums(cmd_packed_gl_enums, cmd_name, is_gles)
def format_entry_point_def(api, command_node, cmd_name, proto, params, is_explicit_context,
cmd_packed_gl_enums, packed_param_types):
packed_gl_enums = get_packed_enums(api, cmd_packed_gl_enums, cmd_name, packed_param_types,
params)
internal_params = [just_the_name_packed(param, packed_gl_enums) for param in params]
packed_gl_enum_conversions = []
for param in params:
......@@ -926,11 +1004,11 @@ def format_entry_point_def(command_node, cmd_name, proto, params, is_explicit_co
return_type = proto[:-len(cmd_name)]
default_return = default_return_value(cmd_name, return_type.strip())
event_comment = TEMPLATE_EVENT_COMMENT if cmd_name in NO_EVENT_MARKER_EXCEPTIONS_LIST else ""
name_lower_no_suffix = strip_suffix(cmd_name[2:3].lower() + cmd_name[3:], is_gles)
name_lower_no_suffix = strip_suffix(api, cmd_name[2:3].lower() + cmd_name[3:])
format_params = {
"name":
cmd_name[2:],
strip_api_prefix(cmd_name),
"name_lower_no_suffix":
name_lower_no_suffix,
"return_type":
......@@ -989,14 +1067,15 @@ def get_capture_param_type_name(param_type):
return param_type
def format_capture_method(command, cmd_name, proto, params, all_param_types, capture_pointer_funcs,
cmd_packed_gl_enums, is_gles):
def format_capture_method(api, command, cmd_name, proto, params, all_param_types,
capture_pointer_funcs, cmd_packed_gl_enums, packed_param_types):
packed_gl_enums = get_packed_enums(cmd_packed_gl_enums, cmd_name, is_gles)
packed_gl_enums = get_packed_enums(api, cmd_packed_gl_enums, cmd_name, packed_param_types,
params)
params_with_type = get_internal_params(cmd_name,
params_with_type = get_internal_params(api, cmd_name,
["const State &glState", "bool isCallValid"] + params,
cmd_packed_gl_enums, is_gles)
cmd_packed_gl_enums, packed_param_types)
params_just_name = ", ".join(
["glState", "isCallValid"] +
[just_the_name_packed(param, packed_gl_enums) for param in params])
......@@ -1011,7 +1090,7 @@ def format_capture_method(command, cmd_name, proto, params, all_param_types, cap
if pointer_count > 0:
params = params_just_name
capture_name = "Capture%s_%s" % (cmd_name[2:], param_name)
capture_name = "Capture%s_%s" % (strip_api_prefix(cmd_name), param_name)
capture = TEMPLATE_PARAMETER_CAPTURE_POINTER.format(
name=param_name,
type=capture_param_type,
......@@ -1038,7 +1117,7 @@ def format_capture_method(command, cmd_name, proto, params, all_param_types, cap
format_args = {
"full_name": cmd_name,
"short_name": cmd_name[2:],
"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),
......@@ -1062,8 +1141,9 @@ def const_pointer_type(param, packed_gl_enums):
return type
def get_internal_params(cmd_name, params, cmd_packed_gl_enums, is_gles):
packed_gl_enums = get_packed_enums(cmd_packed_gl_enums, cmd_name, is_gles)
def get_internal_params(api, cmd_name, params, cmd_packed_gl_enums, packed_param_types):
packed_gl_enums = get_packed_enums(api, cmd_packed_gl_enums, cmd_name, packed_param_types,
params)
return ", ".join([
make_param(
just_the_type_packed(param, packed_gl_enums),
......@@ -1071,8 +1151,9 @@ def get_internal_params(cmd_name, params, cmd_packed_gl_enums, is_gles):
])
def get_validation_params(cmd_name, params, cmd_packed_gl_enums, is_gles):
packed_gl_enums = get_packed_enums(cmd_packed_gl_enums, cmd_name, is_gles)
def get_validation_params(api, cmd_name, params, cmd_packed_gl_enums, packed_param_types):
packed_gl_enums = get_packed_enums(api, cmd_packed_gl_enums, cmd_name, packed_param_types,
params)
return ", ".join([
make_param(
const_pointer_type(param, packed_gl_enums), just_the_name_packed(
......@@ -1080,12 +1161,14 @@ def get_validation_params(cmd_name, params, cmd_packed_gl_enums, is_gles):
])
def format_context_decl(cmd_name, proto, params, template, cmd_packed_gl_enums, is_gles):
internal_params = get_internal_params(cmd_name, params, cmd_packed_gl_enums, is_gles)
def format_context_decl(api, cmd_name, proto, params, template, cmd_packed_gl_enums,
packed_param_types):
internal_params = get_internal_params(api, cmd_name, params, cmd_packed_gl_enums,
packed_param_types)
return_type = proto[:-len(cmd_name)]
name_lower_no_suffix = cmd_name[2:3].lower() + cmd_name[3:]
name_lower_no_suffix = strip_suffix(name_lower_no_suffix, is_gles)
name_lower_no_suffix = strip_suffix(api, name_lower_no_suffix)
maybe_const = " const" if name_lower_no_suffix.startswith(
"is") and name_lower_no_suffix[2].isupper() else ""
......@@ -1101,7 +1184,7 @@ def format_libgles_entry_point_def(cmd_name, proto, params, is_explicit_context)
return_type = proto[:-len(cmd_name)]
return LIBGLES_ENTRY_POINT_DEF.format(
name=cmd_name[2:],
name=strip_api_prefix(cmd_name),
return_type=return_type,
params=", ".join(params),
internal_params=", ".join(internal_params),
......@@ -1111,28 +1194,39 @@ def format_libgles_entry_point_def(cmd_name, proto, params, is_explicit_context)
explicit_context_internal_param="ctx" if is_explicit_context else "")
def format_validation_proto(cmd_name, params, cmd_packed_gl_enums, is_gles):
internal_params = get_validation_params(cmd_name, ["Context *context"] + params,
cmd_packed_gl_enums, is_gles)
return TEMPLATE_VALIDATION_PROTO % (cmd_name[2:], internal_params)
def format_validation_proto(api, cmd_name, params, cmd_packed_gl_enums, packed_param_types):
if api in ["GL", "GLES"]:
with_extra_params = ["Context *context"] + params
elif api == "EGL":
with_extra_params = ["ValidationContext *val"] + params
else:
with_extra_params = params
internal_params = get_validation_params(api, cmd_name, with_extra_params, cmd_packed_gl_enums,
packed_param_types)
return TEMPLATE_VALIDATION_PROTO % (strip_api_prefix(cmd_name), internal_params)
def format_capture_proto(cmd_name, proto, params, cmd_packed_gl_enums, is_gles):
internal_params = get_internal_params(cmd_name,
def format_capture_proto(api, cmd_name, proto, params, cmd_packed_gl_enums, packed_param_types):
internal_params = get_internal_params(api, cmd_name,
["const State &glState", "bool isCallValid"] + params,
cmd_packed_gl_enums, is_gles)
cmd_packed_gl_enums, packed_param_types)
return_type = proto[:-len(cmd_name)].strip()
if return_type != "void":
internal_params += ", %s returnValue" % return_type
return TEMPLATE_CAPTURE_PROTO % (cmd_name[2:], internal_params)
return TEMPLATE_CAPTURE_PROTO % (strip_api_prefix(cmd_name), internal_params)
def path_to(folder, file):
return os.path.join(script_relative(".."), "src", folder, file)
def get_entry_points(all_commands, commands, is_explicit_context, is_wgl, all_param_types,
cmd_packed_gl_enums, is_gles):
def get_entry_points(api,
all_commands,
commands,
is_explicit_context,
all_param_types,
cmd_packed_gl_enums,
packed_param_types=[]):
decls = []
defs = []
export_defs = []
......@@ -1145,7 +1239,7 @@ def get_entry_points(all_commands, commands, is_explicit_context, is_wgl, all_pa
proto = command.find('proto')
cmd_name = proto.find('name').text
if is_wgl:
if api == WGL:
cmd_name = cmd_name if cmd_name[:3] == 'wgl' else 'wgl' + cmd_name
if cmd_name not in commands:
......@@ -1156,25 +1250,32 @@ def get_entry_points(all_commands, commands, is_explicit_context, is_wgl, all_pa
decls.append(
format_entry_point_decl(cmd_name, proto_text, param_text, is_explicit_context))
defs.append(
format_entry_point_def(command, cmd_name, proto_text, param_text, is_explicit_context,
cmd_packed_gl_enums, is_gles))
format_entry_point_def(api, command, cmd_name, proto_text, param_text,
is_explicit_context, cmd_packed_gl_enums, packed_param_types))
export_defs.append(
format_libgles_entry_point_def(cmd_name, proto_text, param_text, is_explicit_context))
validation_protos.append(
format_validation_proto(cmd_name, param_text, cmd_packed_gl_enums, is_gles))
format_validation_proto(api, cmd_name, param_text, cmd_packed_gl_enums,
packed_param_types))
capture_protos.append(
format_capture_proto(cmd_name, proto_text, param_text, cmd_packed_gl_enums, is_gles))
format_capture_proto(api, cmd_name, proto_text, param_text, cmd_packed_gl_enums,
packed_param_types))
capture_methods.append(
format_capture_method(command, cmd_name, proto_text, param_text, all_param_types,
capture_pointer_funcs, cmd_packed_gl_enums, is_gles))
format_capture_method(api, command, cmd_name, proto_text, param_text, all_param_types,
capture_pointer_funcs, cmd_packed_gl_enums, packed_param_types))
return decls, defs, export_defs, validation_protos, capture_protos, capture_methods, capture_pointer_funcs
def get_decls(formatter, all_commands, gles_commands, already_included, cmd_packed_gl_enums,
is_gles):
def get_decls(api,
formatter,
all_commands,
gles_commands,
already_included,
cmd_packed_gl_enums,
packed_param_types=[]):
decls = []
for command in all_commands:
proto = command.find('proto')
......@@ -1183,15 +1284,15 @@ def get_decls(formatter, all_commands, gles_commands, already_included, cmd_pack
if cmd_name not in gles_commands:
continue
name_no_suffix = strip_suffix(cmd_name, is_gles)
name_no_suffix = strip_suffix(api, cmd_name)
if name_no_suffix in already_included:
continue
param_text = ["".join(param.itertext()) for param in command.findall('param')]
proto_text = "".join(proto.itertext())
decls.append(
format_context_decl(cmd_name, proto_text, param_text, formatter, cmd_packed_gl_enums,
is_gles))
format_context_decl(api, cmd_name, proto_text, param_text, formatter,
cmd_packed_gl_enums, packed_param_types))
return decls
......@@ -1338,8 +1439,8 @@ def write_glext_explicit_context_inc(version, ptrs, protos):
out.close()
def write_validation_header(annotation, comment, protos, source):
content = TEMPLATE_VALIDATION_HEADER.format(
def write_validation_header(annotation, comment, protos, source, template):
content = template.format(
script_name=os.path.basename(sys.argv[0]),
data_source_name=source,
annotation=annotation,
......@@ -1353,6 +1454,11 @@ def write_validation_header(annotation, comment, protos, source):
out.close()
def write_gl_validation_header(annotation, comment, protos, source):
return write_validation_header(annotation, comment, protos, source,
TEMPLATE_GL_VALIDATION_HEADER)
def write_capture_header(annotation, comment, protos, capture_pointer_funcs):
content = TEMPLATE_CAPTURE_HEADER.format(
script_name=os.path.basename(sys.argv[0]),
......@@ -1575,10 +1681,11 @@ def is_get_pointer_command(command_name):
return command_name.endswith('Pointerv') and command_name.startswith('glGet')
def format_capture_replay_param_access(command_name, param_text_list, cmd_packed_gl_enums,
is_gles):
def format_capture_replay_param_access(api, command_name, param_text_list, cmd_packed_gl_enums,
packed_param_types):
param_access_strs = list()
cmd_packed_enums = get_packed_enums(cmd_packed_gl_enums, command_name, is_gles)
cmd_packed_enums = get_packed_enums(api, cmd_packed_gl_enums, command_name, packed_param_types,
param_text_list)
for i, param_text in enumerate(param_text_list):
param_type = just_the_type_packed(param_text, cmd_packed_enums)
param_name = just_the_name_packed(param_text, cmd_packed_enums)
......@@ -1605,24 +1712,25 @@ def format_capture_replay_param_access(command_name, param_text_list, cmd_packed
return ",".join(param_access_strs)
def format_capture_replay_call_case(command_to_param_types_mapping, cmd_packed_gl_enums, is_gles):
def format_capture_replay_call_case(api, command_to_param_types_mapping, cmd_packed_gl_enums,
packed_param_types):
call_str_list = list()
for command_name, cmd_param_texts in sorted(command_to_param_types_mapping.items()):
entry_point_name = command_name[2:] # strip the 'gl' prefix
entry_point_name = strip_api_prefix(command_name)
call_str_list.append(
TEMPLATE_CAPTURE_REPLAY_CALL_CASE.format(
entry_point=entry_point_name,
param_value_access=format_capture_replay_param_access(
command_name, cmd_param_texts, cmd_packed_gl_enums, is_gles),
api, command_name, cmd_param_texts, cmd_packed_gl_enums, packed_param_types),
context_call=entry_point_name[0].lower() + entry_point_name[1:],
))
return '\n'.join(call_str_list)
def write_capture_replay_source(all_commands_nodes, gles_command_names, cmd_packed_gl_enums,
is_gles):
def write_capture_replay_source(api, all_commands_nodes, gles_command_names, cmd_packed_gl_enums,
packed_param_types):
all_commands_names = set(gles_command_names)
command_to_param_types_mapping = dict()
......@@ -1634,8 +1742,8 @@ def write_capture_replay_source(all_commands_nodes, gles_command_names, cmd_pack
command_to_param_types_mapping[command_name] = get_command_params_text(
command_node, command_name)
call_replay_cases = format_capture_replay_call_case(command_to_param_types_mapping,
cmd_packed_gl_enums, is_gles)
call_replay_cases = format_capture_replay_call_case(api, command_to_param_types_mapping,
cmd_packed_gl_enums, packed_param_types)
source_content = TEMPLATE_CAPTURE_REPLAY_SOURCE.format(
script_name=os.path.basename(sys.argv[0]),
......@@ -1711,7 +1819,8 @@ def main():
# auto_script parameters.
if len(sys.argv) > 1:
inputs = ['entry_point_packed_gl_enums.json'] + registry_xml.xml_inputs
inputs = ['entry_point_packed_egl_enums.json', 'entry_point_packed_gl_enums.json'
] + registry_xml.xml_inputs
outputs = [
'../src/common/entry_points_enum_autogen.cpp',
'../src/common/entry_points_enum_autogen.h',
......@@ -1755,6 +1864,7 @@ def main():
'../src/libANGLE/frame_capture_replay_autogen.cpp',
'../src/libANGLE/frame_capture_utils_autogen.cpp',
'../src/libANGLE/frame_capture_utils_autogen.h',
'../src/libANGLE/validationEGL_autogen.h',
'../src/libANGLE/validationES1_autogen.h',
'../src/libANGLE/validationES2_autogen.h',
'../src/libANGLE/validationES31_autogen.h',
......@@ -1890,8 +2000,7 @@ def main():
all_commands_with_suffix.extend(xml.commands[version])
decls, defs, libgles_defs, validation_protos, capture_protos, capture_methods, capture_pointer_funcs = get_entry_points(
all_commands, gles_commands, False, False, all_gles_param_types, cmd_packed_gl_enums,
True)
GLES, all_commands, gles_commands, False, all_gles_param_types, cmd_packed_gl_enums)
# Write the version as a comment before the first EP.
libgles_defs.insert(0, "\n// OpenGL ES %s" % comment)
......@@ -1920,13 +2029,12 @@ def main():
"cpp", source_includes, "libGLESv2", "gl.xml")
glesdecls['core'][(major_version,
minor_version)] = get_decls(CONTEXT_DECL_FORMAT, all_commands,
gles_commands, [], cmd_packed_gl_enums,
True)
minor_version)] = get_decls(GLES, CONTEXT_DECL_FORMAT, all_commands,
gles_commands, [], cmd_packed_gl_enums)
validation_annotation = "ES%s%s" % (major_version, minor_if_not_zero)
write_validation_header(validation_annotation, "ES %s" % comment, validation_protos,
"gl.xml and gl_angle_ext.xml")
write_gl_validation_header(validation_annotation, "ES %s" % comment, validation_protos,
"gl.xml and gl_angle_ext.xml")
write_capture_header(version, comment, capture_protos, capture_pointer_funcs)
write_capture_source(version, validation_annotation, comment, capture_methods)
......@@ -1956,12 +2064,12 @@ def main():
# Detect and filter duplicate extensions.
decls, defs, libgles_defs, validation_protos, capture_protos, capture_methods, capture_param_funcs = get_entry_points(
xml.all_commands, ext_cmd_names, False, False, all_gles_param_types,
cmd_packed_gl_enums, True)
GLES, xml.all_commands, ext_cmd_names, False, all_gles_param_types,
cmd_packed_gl_enums)
# Avoid writing out entry points defined by a prior extension.
for dupe in xml.ext_dupes[extension_name]:
msg = "// {} is already defined.\n".format(dupe[2:])
msg = "// {} is already defined.\n".format(strip_api_prefix(dupe))
defs.append(msg)
# Write the extension name as a comment before the first EP.
......@@ -1985,20 +2093,20 @@ def main():
if (extension_name in registry_xml.gles1_extensions and
extension_name not in GLES1_NO_CONTEXT_DECL_EXTENSIONS):
glesdecls['exts']['GLES1 Extensions'][extension_name] = get_decls(
CONTEXT_DECL_FORMAT, all_commands, ext_cmd_names, all_commands_no_suffix,
cmd_packed_gl_enums, True)
GLES, CONTEXT_DECL_FORMAT, all_commands, ext_cmd_names, all_commands_no_suffix,
cmd_packed_gl_enums)
if extension_name in registry_xml.gles_extensions:
glesdecls['exts']['GLES2+ Extensions'][extension_name] = get_decls(
CONTEXT_DECL_FORMAT, all_commands, ext_cmd_names, all_commands_no_suffix,
cmd_packed_gl_enums, True)
GLES, CONTEXT_DECL_FORMAT, all_commands, ext_cmd_names, all_commands_no_suffix,
cmd_packed_gl_enums)
if extension_name in registry_xml.angle_extensions:
glesdecls['exts']['ANGLE Extensions'][extension_name] = get_decls(
CONTEXT_DECL_FORMAT, all_commands, ext_cmd_names, all_commands_no_suffix,
cmd_packed_gl_enums, True)
GLES, CONTEXT_DECL_FORMAT, all_commands, ext_cmd_names, all_commands_no_suffix,
cmd_packed_gl_enums)
for name in extension_commands:
all_commands_with_suffix.append(name)
all_commands_no_suffix.append(strip_suffix(name, True))
all_commands_no_suffix.append(strip_suffix(GLES, name))
# Special handling for EGL_ANGLE_explicit_context extension
if registry_xml.support_EGL_ANGLE_explicit_context:
......@@ -2011,7 +2119,7 @@ def main():
# Get the explicit context entry points
decls, defs, libgles_defs, validation_protos, capture_protos, capture_methods, capture_param_funcs = get_entry_points(
xml.all_commands, cmds, True, False, all_gles_param_types, cmd_packed_gl_enums, True)
GLES, xml.all_commands, cmds, True, all_gles_param_types, cmd_packed_gl_enums)
# Append the explicit context entry points
extension_decls += decls
......@@ -2086,14 +2194,14 @@ def main():
all_commands32 = glxml.all_commands
# Validation duplicates handled with suffix
_, _, _, validation_protos32, _, _, _ = get_entry_points(all_commands32,
_, _, _, validation_protos32, _, _, _ = get_entry_points(GL, all_commands32,
just_libgl_commands_suffix, False,
False, all_gles_param_types,
cmd_packed_gl_enums, False)
decls_gl, defs_gl, libgl_defs, _, _, _, _ = get_entry_points(all_commands32,
all_gles_param_types,
cmd_packed_gl_enums)
decls_gl, defs_gl, libgl_defs, _, _, _, _ = get_entry_points(GL, all_commands32,
all_libgl_commands, False,
False, all_gles_param_types,
cmd_packed_gl_enums, False)
all_gles_param_types,
cmd_packed_gl_enums)
# Write the version as a comment before the first EP.
libgl_defs.insert(0, "\n// GL %s" % comment)
......@@ -2115,14 +2223,77 @@ def main():
"cpp", source_includes, "libGL", "gl.xml")
gldecls['core'][(major_version,
minor_version)] = get_decls(CONTEXT_DECL_FORMAT, all_commands32,
minor_version)] = get_decls(GL, CONTEXT_DECL_FORMAT, all_commands32,
just_libgl_commands, all_commands_no_suffix,
cmd_packed_gl_enums, False)
cmd_packed_gl_enums)
# Validation files
validation_annotation = "GL%s%s" % (major_version, minor_if_not_zero)
write_validation_header(validation_annotation, "%s" % comment, validation_protos32,
"gl.xml and wgl.xml")
write_gl_validation_header(validation_annotation, "%s" % comment, validation_protos32,
"gl.xml and wgl.xml")
# EGL
eglxml = registry_xml.RegistryXML('egl.xml', 'egl_angle_ext.xml')
egl_param_types = set()
with open(script_relative('entry_point_packed_egl_enums.json')) as f:
cmd_packed_egl_enums = json.loads(f.read())
egl_validation_protos = []
for major_version, minor_version in [[1, 0], [1, 1], [1, 2], [1, 3], [1, 4], [1, 5]]:
version = "%d_%d" % (major_version, minor_version)
annotation = "EGL_%s" % version
name_prefix = "EGL_VERSION_"
comment = version.replace("_", ".")
feature_name = "%s%s" % (name_prefix, version)
eglxml.AddCommands(feature_name, version)
egl_version_commands = eglxml.commands[version]
# Spec revs may have no new commands.
if not egl_version_commands:
continue
_, _, _, validation_protos, _, _, _ = get_entry_points(EGL, eglxml.all_commands,
egl_version_commands, False,
egl_param_types,
cmd_packed_egl_enums,
EGL_PACKED_TYPES)
comment = "\n// EGL %d.%d" % (major_version, minor_version)
egl_validation_protos += [comment] + validation_protos
eglxml.AddExtensionCommands(registry_xml.supported_egl_extensions, ['egl'])
for extension_name, ext_cmd_names in sorted(eglxml.ext_data.iteritems()):
# Extensions may have no new commands.
if not ext_cmd_names:
continue
# Detect and filter duplicate extensions.
_, _, _, validation_protos, _, _, _ = get_entry_points(EGL, eglxml.all_commands,
ext_cmd_names, False,
egl_param_types,
cmd_packed_egl_enums,
EGL_PACKED_TYPES)
# Avoid writing out entry points defined by a prior extension.
for dupe in eglxml.ext_dupes[extension_name]:
msg = "// %s is already defined.\n" % strip_api_prefix(dupe)
defs.append(msg)
# Write the extension name as a comment before the first EP.
comment = "\n// %s" % extension_name
egl_validation_protos += [comment] + validation_protos
write_validation_header("EGL", "EGL", egl_validation_protos, "egl.xml and egl_angle_ext.xml",
TEMPLATE_EGL_VALIDATION_HEADER)
# WGL
wglxml = registry_xml.RegistryXML('wgl.xml')
......@@ -2139,7 +2310,7 @@ def main():
wgl_param_types = set()
decls_wgl, defs_wgl, wgl_defs, validation_protos_wgl, _, _, _ = get_entry_points(
all_commands32, wgl_commands, False, True, wgl_param_types, {}, False)
WGL, all_commands32, wgl_commands, False, wgl_param_types, {})
# Write the version as a comment before the first EP.
libgl_ep_exports.append("\n ; WGL %s" % comment)
......@@ -2180,8 +2351,8 @@ def main():
"\n".join([item for item in extension_defs]), "cpp", source_includes, "libGLESv2",
"gl.xml and gl_angle_ext.xml")
write_validation_header("ESEXT", "ES extension", ext_validation_protos,
"gl.xml and gl_angle_ext.xml")
write_gl_validation_header("ESEXT", "ES extension", ext_validation_protos,
"gl.xml and gl_angle_ext.xml")
write_capture_header("ext", "extension", ext_capture_protos, ext_capture_param_funcs)
write_capture_source("ext", "ESEXT", "extension", ext_capture_methods)
......@@ -2189,8 +2360,9 @@ def main():
write_context_api_decls(CONTEXT_HEADER, gldecls, "gl")
# Entry point enum
cmd_names = ["Invalid"] + [cmd[2:] for cmd in xml.all_cmd_names.get_all_commands()]
gl_cmd_names = [cmd[2:] for cmd in glxml.all_cmd_names.get_all_commands()]
cmd_names = ["Invalid"
] + [strip_api_prefix(cmd) for cmd in xml.all_cmd_names.get_all_commands()]
gl_cmd_names = [strip_api_prefix(cmd) for cmd in glxml.all_cmd_names.get_all_commands()]
cmd_names.extend([cmd for cmd in gl_cmd_names if cmd not in cmd_names])
sorted_cmd_names = sorted(cmd_names)
......@@ -2278,8 +2450,8 @@ def main():
all_gles_param_types = sorted(all_gles_param_types)
write_capture_helper_header(all_gles_param_types)
write_capture_helper_source(all_gles_param_types)
write_capture_replay_source(xml.all_commands, all_commands_no_suffix, cmd_packed_gl_enums,
True)
write_capture_replay_source(GLES, xml.all_commands, all_commands_no_suffix,
cmd_packed_gl_enums, [])
if __name__ == '__main__':
......
src/libANGLE/validationEGL.cpp
......@@ -139,7 +139,7 @@ bool ValidateStreamAttribute(const ValidationContext *val,
}
bool ValidateCreateImageMipLevelCommon(const ValidationContext *val,
gl::Context *context,
const gl::Context *context,
const gl::Texture *texture,
EGLAttrib level)
{
......@@ -503,7 +503,7 @@ bool ValidatePlatformType(const ValidationContext *val,
bool ValidateGetPlatformDisplayCommon(const ValidationContext *val,
EGLenum platform,
void *native_display,
const void *native_display,
const AttributeMap &attribMap)
{
const ClientExtensions &clientExtensions = Display::GetClientExtensions();
......@@ -894,7 +894,7 @@ bool ValidateGetPlatformDisplayCommon(const ValidationContext *val,
}
else if (platform == EGL_PLATFORM_DEVICE_EXT)
{
Device *eglDevice = static_cast<Device *>(native_display);
const Device *eglDevice = static_cast<const Device *>(native_display);
if (eglDevice == nullptr || !Device::IsValidDevice(eglDevice))
{
val->setError(EGL_BAD_ATTRIBUTE,
......@@ -961,7 +961,6 @@ bool ValidateStream(const ValidationContext *val, const Display *display, const
}
bool ValidateLabeledObject(const ValidationContext *val,
Thread *thread,
const Display *display,
ObjectType objectType,
EGLObjectKHR object,
......@@ -1029,7 +1028,8 @@ bool ValidateLabeledObject(const ValidationContext *val,
case ObjectType::Thread:
{
*outLabeledObject = thread;
ASSERT(val);
*outLabeledObject = val->eglThread;
break;
}
......@@ -1102,6 +1102,293 @@ bool ValidTimestampType(Timestamp timestamp)
}
}
bool ValidateCompatibleSurface(const ValidationContext *val,
const Display *display,
const gl::Context *context,
const Surface *surface)
{
const Config *contextConfig = context->getConfig();
const Config *surfaceConfig = surface->getConfig();
// Surface compatible with client API - only OPENGL_ES supported
switch (context->getClientMajorVersion())
{
case 1:
if (!(surfaceConfig->renderableType & EGL_OPENGL_ES_BIT))
{
val->setError(EGL_BAD_MATCH, "Surface not compatible with OpenGL ES 1.x.");
return false;
}
break;
case 2:
if (!(surfaceConfig->renderableType & EGL_OPENGL_ES2_BIT))
{
val->setError(EGL_BAD_MATCH, "Surface not compatible with OpenGL ES 2.x.");
return false;
}
break;
case 3:
if (!(surfaceConfig->renderableType & (EGL_OPENGL_ES2_BIT | EGL_OPENGL_ES3_BIT)))
{
val->setError(EGL_BAD_MATCH, "Surface not compatible with OpenGL ES 3.x.");
return false;
}
break;
default:
val->setError(EGL_BAD_MATCH, "Surface not compatible with Context API.");
return false;
}
// EGL KHR no config context
if (context->getConfig() == EGL_NO_CONFIG_KHR)
{
const DisplayExtensions &displayExtensions = display->getExtensions();
if (displayExtensions.noConfigContext)
{
return true;
}
val->setError(EGL_BAD_MATCH, "Context with no config is not supported.");
return false;
}
if (!surface->flexibleSurfaceCompatibilityRequested())
{
// Config compatibility is defined in section 2.2 of the EGL 1.5 spec
bool colorBufferCompat = surfaceConfig->colorBufferType == contextConfig->colorBufferType;
if (!colorBufferCompat)
{
val->setError(EGL_BAD_MATCH, "Color buffer types are not compatible.");
return false;
}
bool colorCompat = surfaceConfig->redSize == contextConfig->redSize &&
surfaceConfig->greenSize == contextConfig->greenSize &&
surfaceConfig->blueSize == contextConfig->blueSize &&
surfaceConfig->alphaSize == contextConfig->alphaSize &&
surfaceConfig->luminanceSize == contextConfig->luminanceSize;
if (!colorCompat)
{
val->setError(EGL_BAD_MATCH, "Color buffer sizes are not compatible.");
return false;
}
bool componentTypeCompat =
surfaceConfig->colorComponentType == contextConfig->colorComponentType;
if (!componentTypeCompat)
{
val->setError(EGL_BAD_MATCH, "Color buffer component types are not compatible.");
return false;
}
bool dsCompat = surfaceConfig->depthSize == contextConfig->depthSize &&
surfaceConfig->stencilSize == contextConfig->stencilSize;
if (!dsCompat)
{
val->setError(EGL_BAD_MATCH, "Depth-stencil buffer types are not compatible.");
return false;
}
}
bool surfaceTypeCompat = (surfaceConfig->surfaceType & contextConfig->surfaceType) != 0;
if (!surfaceTypeCompat)
{
val->setError(EGL_BAD_MATCH, "Surface type is not compatible.");
return false;
}
return true;
}
bool ValidateCreateSyncBase(const ValidationContext *val,
const Display *display,
EGLenum type,
const AttributeMap &attribs,
bool isExt)
{
ANGLE_VALIDATION_TRY(ValidateDisplay(val, display));
gl::Context *currentContext = val->eglThread->getContext();
egl::Display *currentDisplay = currentContext ? currentContext->getDisplay() : nullptr;
switch (type)
{
case EGL_SYNC_FENCE_KHR:
if (!attribs.isEmpty())
{
val->setError(EGL_BAD_ATTRIBUTE, "Invalid attribute");
return false;
}
if (!display->getExtensions().fenceSync)
{
val->setError(EGL_BAD_MATCH, "EGL_KHR_fence_sync extension is not available");
return false;
}
if (display != currentDisplay)
{
val->setError(EGL_BAD_MATCH,
"CreateSync can only be called on the current display");
return false;
}
ANGLE_VALIDATION_TRY(ValidateContext(val, currentDisplay, currentContext));
if (!currentContext->getExtensions().eglSyncOES)
{
val->setError(EGL_BAD_MATCH,
"EGL_SYNC_FENCE_KHR cannot be used without "
"GL_OES_EGL_sync support.");
return false;
}
break;
case EGL_SYNC_NATIVE_FENCE_ANDROID:
if (!display->getExtensions().fenceSync)
{
val->setError(EGL_BAD_MATCH, "EGL_KHR_fence_sync extension is not available");
return false;
}
if (!display->getExtensions().nativeFenceSyncANDROID)
{
val->setError(EGL_BAD_DISPLAY,
"EGL_ANDROID_native_fence_sync extension is not available.");
return false;
}
if (display != currentDisplay)
{
val->setError(EGL_BAD_MATCH,
"CreateSync can only be called on the current display");
return false;
}
ANGLE_VALIDATION_TRY(ValidateContext(val, currentDisplay, currentContext));
if (!currentContext->getExtensions().eglSyncOES)
{
val->setError(EGL_BAD_MATCH,
"EGL_SYNC_FENCE_KHR cannot be used without "
"GL_OES_EGL_sync support.");
return false;
}
for (const auto &attributeIter : attribs)
{
EGLAttrib attribute = attributeIter.first;
switch (attribute)
{
case EGL_SYNC_NATIVE_FENCE_FD_ANDROID:
break;
default:
val->setError(EGL_BAD_ATTRIBUTE, "Invalid attribute");
return false;
}
}
break;
case EGL_SYNC_REUSABLE_KHR:
if (!attribs.isEmpty())
{
val->setError(EGL_BAD_ATTRIBUTE, "Invalid attribute");
return false;
}
if (!display->getExtensions().reusableSyncKHR)
{
val->setError(EGL_BAD_MATCH, "EGL_KHR_reusable_sync extension is not available.");
return false;
}
break;
default:
if (isExt)
{
val->setError(EGL_BAD_ATTRIBUTE, "Invalid type parameter");
return false;
}
else
{
val->setError(EGL_BAD_PARAMETER, "Invalid type parameter");
return false;
}
}
return true;
}
bool ValidateGetSyncAttribBase(const ValidationContext *val,
const Display *display,
const Sync *sync,
EGLint attribute)
{
ANGLE_VALIDATION_TRY(ValidateSync(val, display, sync));
switch (attribute)
{
case EGL_SYNC_CONDITION_KHR:
switch (sync->getType())
{
case EGL_SYNC_FENCE_KHR:
case EGL_SYNC_NATIVE_FENCE_ANDROID:
break;
default:
val->setError(EGL_BAD_ATTRIBUTE,
"EGL_SYNC_CONDITION_KHR is not valid for this sync type.");
return false;
}
break;
// The following attributes are accepted by all types
case EGL_SYNC_TYPE_KHR:
case EGL_SYNC_STATUS_KHR:
break;
default:
val->setError(EGL_BAD_ATTRIBUTE, "Invalid attribute");
return false;
}
return true;
}
bool ValidateQueryDisplayAttribBase(const ValidationContext *val,
const Display *display,
const EGLint attribute)
{
ANGLE_VALIDATION_TRY(ValidateDisplay(val, display));
switch (attribute)
{
case EGL_DEVICE_EXT:
if (!Display::GetClientExtensions().deviceQueryEXT)
{
val->setError(EGL_BAD_DISPLAY, "EGL_EXT_device_query extension is not available.");
return false;
}
break;
case EGL_FEATURE_COUNT_ANGLE:
if (!Display::GetClientExtensions().featureControlANGLE)
{
val->setError(EGL_BAD_DISPLAY,
"EGL_ANGLE_feature_control extension is not available.");
return false;
}
break;
default:
val->setError(EGL_BAD_ATTRIBUTE, "attribute is not valid.");
return false;
}
return true;
}
} // anonymous namespace
void ValidationContext::setError(EGLint error) const
......@@ -1299,8 +1586,13 @@ LabeledObject *GetLabeledObjectIfValid(Thread *thread,
ObjectType objectType,
EGLObjectKHR object)
{
if (objectType == ObjectType::Thread)
{
return thread;
}
LabeledObject *labeledObject = nullptr;
if (ValidateLabeledObject(nullptr, thread, display, objectType, object, &labeledObject))
if (ValidateLabeledObject(nullptr, display, objectType, object, &labeledObject))
{
return labeledObject;
}
......@@ -1308,7 +1600,10 @@ LabeledObject *GetLabeledObjectIfValid(Thread *thread,
return nullptr;
}
bool ValidateInitialize(const ValidationContext *val, const Display *display)
bool ValidateInitialize(const ValidationContext *val,
const Display *display,
const EGLint *major,
const EGLint *minor)
{
return ValidateDisplayPointer(val, display);
}
......@@ -1319,9 +1614,9 @@ bool ValidateTerminate(const ValidationContext *val, const Display *display)
}
bool ValidateCreateContext(const ValidationContext *val,
Display *display,
Config *configuration,
gl::Context *shareContext,
const Display *display,
const Config *configuration,
const gl::Context *shareContext,
const AttributeMap &attributes)
{
if (configuration)
......@@ -1748,8 +2043,8 @@ bool ValidateCreateContext(const ValidationContext *val,
}
bool ValidateCreateWindowSurface(const ValidationContext *val,
Display *display,
Config *config,
const Display *display,
const Config *config,
EGLNativeWindowType window,
const AttributeMap &attributes)
{
......@@ -1895,8 +2190,8 @@ bool ValidateCreateWindowSurface(const ValidationContext *val,
}
bool ValidateCreatePbufferSurface(const ValidationContext *val,
Display *display,
Config *config,
const Display *display,
const Config *config,
const AttributeMap &attributes)
{
ANGLE_VALIDATION_TRY(ValidateConfig(val, display, config));
......@@ -2033,10 +2328,10 @@ bool ValidateCreatePbufferSurface(const ValidationContext *val,
}
bool ValidateCreatePbufferFromClientBuffer(const ValidationContext *val,
Display *display,
const Display *display,
EGLenum buftype,
EGLClientBuffer buffer,
Config *config,
const Config *config,
const AttributeMap &attributes)
{
ANGLE_VALIDATION_TRY(ValidateConfig(val, display, config));
......@@ -2318,8 +2613,8 @@ bool ValidateCreatePbufferFromClientBuffer(const ValidationContext *val,
}
bool ValidateCreatePixmapSurface(const ValidationContext *val,
Display *display,
Config *config,
const Display *display,
const Config *config,
EGLNativePixmapType pixmap,
const AttributeMap &attributes)
{
......@@ -2406,10 +2701,10 @@ bool ValidateCreatePixmapSurface(const ValidationContext *val,
}
bool ValidateMakeCurrent(const ValidationContext *val,
Display *display,
Surface *draw,
Surface *read,
gl::Context *context)
const Display *display,
const Surface *draw,
const Surface *read,
const gl::Context *context)
{
if (context == EGL_NO_CONTEXT && (draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE))
{
......@@ -2447,158 +2742,60 @@ bool ValidateMakeCurrent(const ValidationContext *val,
"read and draw must both be valid surfaces, or both be EGL_NO_SURFACE");
return false;
}
if (display == EGL_NO_DISPLAY || !Display::isValidDisplay(display))
{
val->setError(EGL_BAD_DISPLAY, "'dpy' not a valid EGLDisplay handle");
return false;
}
// EGL 1.5 spec: dpy can be uninitialized if all other parameters are null
if (!display->isInitialized() &&
(context != EGL_NO_CONTEXT || draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE))
{
val->setError(EGL_NOT_INITIALIZED, "'dpy' not initialized");
return false;
}
if (context != EGL_NO_CONTEXT)
{
ANGLE_VALIDATION_TRY(ValidateContext(val, display, context));
}
if (display->isInitialized() && display->isDeviceLost())
{
val->setError(EGL_CONTEXT_LOST);
return false;
}
if (draw != EGL_NO_SURFACE)
{
ANGLE_VALIDATION_TRY(ValidateSurface(val, display, draw));
}
if (read != EGL_NO_SURFACE)
{
ANGLE_VALIDATION_TRY(ValidateSurface(val, display, read));
ANGLE_VALIDATION_TRY(ValidateCompatibleSurface(val, display, context, read));
}
if (draw != read)
{
if (draw)
{
ANGLE_VALIDATION_TRY(ValidateCompatibleSurface(val, display, context, draw));
}
if (read)
{
ANGLE_VALIDATION_TRY(ValidateCompatibleSurface(val, display, context, read));
}
}
return true;
}
bool ValidateCompatibleSurface(const ValidationContext *val,
const Display *display,
gl::Context *context,
const Surface *surface)
{
const Config *contextConfig = context->getConfig();
const Config *surfaceConfig = surface->getConfig();
// Surface compatible with client API - only OPENGL_ES supported
switch (context->getClientMajorVersion())
{
case 1:
if (!(surfaceConfig->renderableType & EGL_OPENGL_ES_BIT))
{
val->setError(EGL_BAD_MATCH, "Surface not compatible with OpenGL ES 1.x.");
return false;
}
break;
case 2:
if (!(surfaceConfig->renderableType & EGL_OPENGL_ES2_BIT))
{
val->setError(EGL_BAD_MATCH, "Surface not compatible with OpenGL ES 2.x.");
return false;
}
break;
case 3:
if (!(surfaceConfig->renderableType & (EGL_OPENGL_ES2_BIT | EGL_OPENGL_ES3_BIT)))
{
val->setError(EGL_BAD_MATCH, "Surface not compatible with OpenGL ES 3.x.");
return false;
}
break;
default:
val->setError(EGL_BAD_MATCH, "Surface not compatible with Context API.");
return false;
if (display == EGL_NO_DISPLAY || !Display::isValidDisplay(display))
{
val->setError(EGL_BAD_DISPLAY, "'dpy' not a valid EGLDisplay handle");
return false;
}
// EGL KHR no config context
if (context->getConfig() == EGL_NO_CONFIG_KHR)
// EGL 1.5 spec: dpy can be uninitialized if all other parameters are null
if (!display->isInitialized() &&
(context != EGL_NO_CONTEXT || draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE))
{
const DisplayExtensions &displayExtensions = display->getExtensions();
if (displayExtensions.noConfigContext)
{
return true;
}
val->setError(EGL_BAD_MATCH, "Context with no config is not supported.");
val->setError(EGL_NOT_INITIALIZED, "'dpy' not initialized");
return false;
}
if (!surface->flexibleSurfaceCompatibilityRequested())
if (context != EGL_NO_CONTEXT)
{
// Config compatibility is defined in section 2.2 of the EGL 1.5 spec
ANGLE_VALIDATION_TRY(ValidateContext(val, display, context));
}
bool colorBufferCompat = surfaceConfig->colorBufferType == contextConfig->colorBufferType;
if (!colorBufferCompat)
{
val->setError(EGL_BAD_MATCH, "Color buffer types are not compatible.");
return false;
}
if (display->isInitialized() && display->isDeviceLost())
{
val->setError(EGL_CONTEXT_LOST);
return false;
}
bool colorCompat = surfaceConfig->redSize == contextConfig->redSize &&
surfaceConfig->greenSize == contextConfig->greenSize &&
surfaceConfig->blueSize == contextConfig->blueSize &&
surfaceConfig->alphaSize == contextConfig->alphaSize &&
surfaceConfig->luminanceSize == contextConfig->luminanceSize;
if (!colorCompat)
{
val->setError(EGL_BAD_MATCH, "Color buffer sizes are not compatible.");
return false;
}
if (draw != EGL_NO_SURFACE)
{
ANGLE_VALIDATION_TRY(ValidateSurface(val, display, draw));
}
bool componentTypeCompat =
surfaceConfig->colorComponentType == contextConfig->colorComponentType;
if (!componentTypeCompat)
if (read != EGL_NO_SURFACE)
{
ANGLE_VALIDATION_TRY(ValidateSurface(val, display, read));
ANGLE_VALIDATION_TRY(ValidateCompatibleSurface(val, display, context, read));
}
if (draw != read)
{
if (draw)
{
val->setError(EGL_BAD_MATCH, "Color buffer component types are not compatible.");
return false;
ANGLE_VALIDATION_TRY(ValidateCompatibleSurface(val, display, context, draw));
}
bool dsCompat = surfaceConfig->depthSize == contextConfig->depthSize &&
surfaceConfig->stencilSize == contextConfig->stencilSize;
if (!dsCompat)
if (read)
{
val->setError(EGL_BAD_MATCH, "Depth-stencil buffer types are not compatible.");
return false;
ANGLE_VALIDATION_TRY(ValidateCompatibleSurface(val, display, context, read));
}
}
bool surfaceTypeCompat = (surfaceConfig->surfaceType & contextConfig->surfaceType) != 0;
if (!surfaceTypeCompat)
{
val->setError(EGL_BAD_MATCH, "Surface type is not compatible.");
return false;
}
return true;
}
bool ValidateCreateImage(const ValidationContext *val,
const Display *display,
gl::Context *context,
const gl::Context *context,
EGLenum target,
EGLClientBuffer buffer,
const AttributeMap &attributes)
......@@ -3149,7 +3346,7 @@ bool ValidateDestroyImage(const ValidationContext *val, const Display *display,
bool ValidateCreateImageKHR(const ValidationContext *val,
const Display *display,
gl::Context *context,
const gl::Context *context,
EGLenum target,
EGLClientBuffer buffer,
const AttributeMap &attributes)
......@@ -3160,268 +3357,106 @@ bool ValidateCreateImageKHR(const ValidationContext *val,
{
// It is out of spec what happens when calling an extension function when the extension is
// not available.
// EGL_BAD_DISPLAY seems like a reasonable error.
val->setError(EGL_BAD_DISPLAY, "EGL_KHR_image not supported.");
return false;
}
return ValidateCreateImage(val, display, context, target, buffer, attributes);
}
bool ValidateDestroyImageKHR(const ValidationContext *val,
const Display *display,
const Image *image)
{
ANGLE_VALIDATION_TRY(ValidateImage(val, display, image));
if (!display->getExtensions().imageBase && !display->getExtensions().image)
{
// It is out of spec what happens when calling an extension function when the extension is
// not available.
// EGL_BAD_DISPLAY seems like a reasonable error.
val->setError(EGL_BAD_DISPLAY);
return false;
}
return true;
}
bool ValidateCreateDeviceANGLE(const ValidationContext *val,
EGLint device_type,
void *native_device,
const EGLAttrib *attrib_list)
{
const ClientExtensions &clientExtensions = Display::GetClientExtensions();
if (!clientExtensions.deviceCreation)
{
val->setError(EGL_BAD_ACCESS, "Device creation extension not active");
return false;
}
if (attrib_list != nullptr && attrib_list[0] != EGL_NONE)
{
val->setError(EGL_BAD_ATTRIBUTE, "Invalid attrib_list parameter");
return false;
}
switch (device_type)
{
case EGL_D3D11_DEVICE_ANGLE:
if (!clientExtensions.deviceCreationD3D11)
{
val->setError(EGL_BAD_ATTRIBUTE, "D3D11 device creation extension not active");
return false;
}
break;
default:
val->setError(EGL_BAD_ATTRIBUTE, "Invalid device_type parameter");
return false;
}
return true;
}
bool ValidateReleaseDeviceANGLE(const ValidationContext *val, Device *device)
{
const ClientExtensions &clientExtensions = Display::GetClientExtensions();
if (!clientExtensions.deviceCreation)
{
val->setError(EGL_BAD_ACCESS, "Device creation extension not active");
return false;
}
if (device == EGL_NO_DEVICE_EXT || !Device::IsValidDevice(device))
{
val->setError(EGL_BAD_DEVICE_EXT, "Invalid device parameter");
return false;
}
Display *owningDisplay = device->getOwningDisplay();
if (owningDisplay != nullptr)
{
val->setError(EGL_BAD_DEVICE_EXT, "Device must have been created using eglCreateDevice");
return false;
}
return true;
}
bool ValidateCreateSyncBase(const ValidationContext *val,
const Display *display,
EGLenum type,
const AttributeMap &attribs,
const Display *currentDisplay,
const gl::Context *currentContext,
bool isExt)
{
ANGLE_VALIDATION_TRY(ValidateDisplay(val, display));
switch (type)
{
case EGL_SYNC_FENCE_KHR:
if (!attribs.isEmpty())
{
val->setError(EGL_BAD_ATTRIBUTE, "Invalid attribute");
return false;
}
if (!display->getExtensions().fenceSync)
{
val->setError(EGL_BAD_MATCH, "EGL_KHR_fence_sync extension is not available");
return false;
}
if (display != currentDisplay)
{
val->setError(EGL_BAD_MATCH,
"CreateSync can only be called on the current display");
return false;
}
ANGLE_VALIDATION_TRY(ValidateContext(val, currentDisplay, currentContext));
if (!currentContext->getExtensions().eglSyncOES)
{
val->setError(EGL_BAD_MATCH,
"EGL_SYNC_FENCE_KHR cannot be used without "
"GL_OES_EGL_sync support.");
return false;
}
break;
case EGL_SYNC_NATIVE_FENCE_ANDROID:
if (!display->getExtensions().fenceSync)
{
val->setError(EGL_BAD_MATCH, "EGL_KHR_fence_sync extension is not available");
return false;
}
if (!display->getExtensions().nativeFenceSyncANDROID)
{
val->setError(EGL_BAD_DISPLAY,
"EGL_ANDROID_native_fence_sync extension is not available.");
return false;
}
if (display != currentDisplay)
{
val->setError(EGL_BAD_MATCH,
"CreateSync can only be called on the current display");
return false;
}
ANGLE_VALIDATION_TRY(ValidateContext(val, currentDisplay, currentContext));
if (!currentContext->getExtensions().eglSyncOES)
{
val->setError(EGL_BAD_MATCH,
"EGL_SYNC_FENCE_KHR cannot be used without "
"GL_OES_EGL_sync support.");
return false;
}
for (const auto &attributeIter : attribs)
{
EGLAttrib attribute = attributeIter.first;
switch (attribute)
{
case EGL_SYNC_NATIVE_FENCE_FD_ANDROID:
break;
default:
val->setError(EGL_BAD_ATTRIBUTE, "Invalid attribute");
return false;
}
}
break;
case EGL_SYNC_REUSABLE_KHR:
if (!attribs.isEmpty())
{
val->setError(EGL_BAD_ATTRIBUTE, "Invalid attribute");
return false;
}
// EGL_BAD_DISPLAY seems like a reasonable error.
val->setError(EGL_BAD_DISPLAY, "EGL_KHR_image not supported.");
return false;
}
if (!display->getExtensions().reusableSyncKHR)
{
val->setError(EGL_BAD_MATCH, "EGL_KHR_reusable_sync extension is not available.");
return false;
}
break;
return ValidateCreateImage(val, display, context, target, buffer, attributes);
}
default:
if (isExt)
{
val->setError(EGL_BAD_ATTRIBUTE, "Invalid type parameter");
return false;
}
else
{
val->setError(EGL_BAD_PARAMETER, "Invalid type parameter");
return false;
}
bool ValidateDestroyImageKHR(const ValidationContext *val,
const Display *display,
const Image *image)
{
ANGLE_VALIDATION_TRY(ValidateImage(val, display, image));
if (!display->getExtensions().imageBase && !display->getExtensions().image)
{
// It is out of spec what happens when calling an extension function when the extension is
// not available.
// EGL_BAD_DISPLAY seems like a reasonable error.
val->setError(EGL_BAD_DISPLAY);
return false;
}
return true;
}
bool ValidateGetSyncAttribBase(const ValidationContext *val,
const Display *display,
const Sync *sync,
EGLint attribute)
bool ValidateCreateDeviceANGLE(const ValidationContext *val,
EGLint device_type,
const void *native_device,
const EGLAttrib *attrib_list)
{
ANGLE_VALIDATION_TRY(ValidateSync(val, display, sync));
const ClientExtensions &clientExtensions = Display::GetClientExtensions();
if (!clientExtensions.deviceCreation)
{
val->setError(EGL_BAD_ACCESS, "Device creation extension not active");
return false;
}
switch (attribute)
if (attrib_list != nullptr && attrib_list[0] != EGL_NONE)
{
case EGL_SYNC_CONDITION_KHR:
switch (sync->getType())
{
case EGL_SYNC_FENCE_KHR:
case EGL_SYNC_NATIVE_FENCE_ANDROID:
break;
val->setError(EGL_BAD_ATTRIBUTE, "Invalid attrib_list parameter");
return false;
}
default:
val->setError(EGL_BAD_ATTRIBUTE,
"EGL_SYNC_CONDITION_KHR is not valid for this sync type.");
return false;
switch (device_type)
{
case EGL_D3D11_DEVICE_ANGLE:
if (!clientExtensions.deviceCreationD3D11)
{
val->setError(EGL_BAD_ATTRIBUTE, "D3D11 device creation extension not active");
return false;
}
break;
// The following attributes are accepted by all types
case EGL_SYNC_TYPE_KHR:
case EGL_SYNC_STATUS_KHR:
break;
default:
val->setError(EGL_BAD_ATTRIBUTE, "Invalid attribute");
val->setError(EGL_BAD_ATTRIBUTE, "Invalid device_type parameter");
return false;
}
return true;
}
bool ValidateCreateSyncKHR(const ValidationContext *val,
const Display *display,
EGLenum type,
const AttributeMap &attribs,
const Display *currentDisplay,
const gl::Context *currentContext)
bool ValidateReleaseDeviceANGLE(const ValidationContext *val, const Device *device)
{
return ValidateCreateSyncBase(val, display, type, attribs, currentDisplay, currentContext,
true);
const ClientExtensions &clientExtensions = Display::GetClientExtensions();
if (!clientExtensions.deviceCreation)
{
val->setError(EGL_BAD_ACCESS, "Device creation extension not active");
return false;
}
if (device == EGL_NO_DEVICE_EXT || !Device::IsValidDevice(device))
{
val->setError(EGL_BAD_DEVICE_EXT, "Invalid device parameter");
return false;
}
Display *owningDisplay = device->getOwningDisplay();
if (owningDisplay != nullptr)
{
val->setError(EGL_BAD_DEVICE_EXT, "Device must have been created using eglCreateDevice");
return false;
}
return true;
}
bool ValidateCreateSync(const ValidationContext *val,
const Display *display,
EGLenum type,
const AttributeMap &attribs,
const Display *currentDisplay,
const gl::Context *currentContext)
const AttributeMap &attribs)
{
return ValidateCreateSyncBase(val, display, type, attribs, currentDisplay, currentContext,
false);
return ValidateCreateSyncBase(val, display, type, attribs, false);
}
bool ValidateCreateSyncKHR(const ValidationContext *val,
const Display *display,
EGLenum type,
const AttributeMap &attribs)
{
return ValidateCreateSyncBase(val, display, type, attribs, true);
}
bool ValidateDestroySync(const ValidationContext *val, const Display *display, const Sync *sync)
......@@ -3430,6 +3465,13 @@ bool ValidateDestroySync(const ValidationContext *val, const Display *display, c
return true;
}
bool ValidateDestroySyncKHR(const ValidationContext *val,
const Display *dpyPacked,
const Sync *syncPacked)
{
return ValidateDestroySync(val, dpyPacked, syncPacked);
}
bool ValidateClientWaitSync(const ValidationContext *val,
const Display *display,
const Sync *sync,
......@@ -3440,9 +3482,17 @@ bool ValidateClientWaitSync(const ValidationContext *val,
return true;
}
bool ValidateClientWaitSyncKHR(const ValidationContext *val,
const Display *dpyPacked,
const Sync *syncPacked,
EGLint flags,
EGLTimeKHR timeout)
{
return ValidateClientWaitSync(val, dpyPacked, syncPacked, flags, timeout);
}
bool ValidateWaitSync(const ValidationContext *val,
const Display *display,
const gl::Context *context,
const Sync *sync,
EGLint flags)
{
......@@ -3457,6 +3507,7 @@ bool ValidateWaitSync(const ValidationContext *val,
ANGLE_VALIDATION_TRY(ValidateSync(val, display, sync));
gl::Context *context = val->eglThread->getContext();
if (context == nullptr)
{
val->setError(EGL_BAD_MATCH, "No context is current.");
......@@ -3480,11 +3531,19 @@ bool ValidateWaitSync(const ValidationContext *val,
return true;
}
bool ValidateGetSyncAttribKHR(const ValidationContext *val,
const Display *display,
const Sync *sync,
EGLint attribute,
EGLint *value)
bool ValidateWaitSyncKHR(const ValidationContext *val,
const Display *dpyPacked,
const Sync *syncPacked,
EGLint flags)
{
return ValidateWaitSync(val, dpyPacked, syncPacked, flags);
}
bool ValidateGetSyncAttrib(const ValidationContext *val,
const Display *display,
const Sync *sync,
EGLint attribute,
const EGLAttrib *value)
{
if (value == nullptr)
{
......@@ -3494,11 +3553,11 @@ bool ValidateGetSyncAttribKHR(const ValidationContext *val,
return ValidateGetSyncAttribBase(val, display, sync, attribute);
}
bool ValidateGetSyncAttrib(const ValidationContext *val,
const Display *display,
const Sync *sync,
EGLint attribute,
EGLAttrib *value)
bool ValidateGetSyncAttribKHR(const ValidationContext *val,
const Display *display,
const Sync *sync,
EGLint attribute,
const EGLint *value)
{
if (value == nullptr)
{
......@@ -3543,7 +3602,7 @@ bool ValidateDestroyStreamKHR(const ValidationContext *val,
bool ValidateStreamAttribKHR(const ValidationContext *val,
const Display *display,
const Stream *stream,
EGLint attribute,
EGLenum attribute,
EGLint value)
{
ANGLE_VALIDATION_TRY(ValidateStream(val, display, stream));
......@@ -3561,7 +3620,7 @@ bool ValidateQueryStreamKHR(const ValidationContext *val,
const Display *display,
const Stream *stream,
EGLenum attribute,
EGLint *value)
const EGLint *value)
{
ANGLE_VALIDATION_TRY(ValidateStream(val, display, stream));
......@@ -3589,7 +3648,7 @@ bool ValidateQueryStreamu64KHR(const ValidationContext *val,
const Display *display,
const Stream *stream,
EGLenum attribute,
EGLuint64KHR *value)
const EGLuint64KHR *value)
{
ANGLE_VALIDATION_TRY(ValidateStream(val, display, stream));
......@@ -3608,9 +3667,9 @@ bool ValidateQueryStreamu64KHR(const ValidationContext *val,
bool ValidateStreamConsumerGLTextureExternalKHR(const ValidationContext *val,
const Display *display,
gl::Context *context,
const Stream *stream)
{
gl::Context *context = val->eglThread->getContext();
ANGLE_VALIDATION_TRY(ValidateContext(val, display, context));
const DisplayExtensions &displayExtensions = display->getExtensions();
......@@ -3651,7 +3710,6 @@ bool ValidateStreamConsumerGLTextureExternalKHR(const ValidationContext *val,
bool ValidateStreamConsumerAcquireKHR(const ValidationContext *val,
const Display *display,
gl::Context *context,
const Stream *stream)
{
ANGLE_VALIDATION_TRY(ValidateDisplay(val, display));
......@@ -3669,6 +3727,7 @@ bool ValidateStreamConsumerAcquireKHR(const ValidationContext *val,
return false;
}
gl::Context *context = val->eglThread->getContext();
if (!context)
{
val->setError(EGL_BAD_ACCESS, "No GL context current to calling thread.");
......@@ -3705,7 +3764,6 @@ bool ValidateStreamConsumerAcquireKHR(const ValidationContext *val,
bool ValidateStreamConsumerReleaseKHR(const ValidationContext *val,
const Display *display,
gl::Context *context,
const Stream *stream)
{
ANGLE_VALIDATION_TRY(ValidateDisplay(val, display));
......@@ -3723,6 +3781,7 @@ bool ValidateStreamConsumerReleaseKHR(const ValidationContext *val,
return false;
}
gl::Context *context = val->eglThread->getContext();
if (!context)
{
val->setError(EGL_BAD_ACCESS, "No GL context current to calling thread.");
......@@ -3756,7 +3815,6 @@ bool ValidateStreamConsumerReleaseKHR(const ValidationContext *val,
bool ValidateStreamConsumerGLTextureExternalAttribsNV(const ValidationContext *val,
const Display *display,
gl::Context *context,
const Stream *stream,
const AttributeMap &attribs)
{
......@@ -3769,6 +3827,7 @@ bool ValidateStreamConsumerGLTextureExternalAttribsNV(const ValidationContext *v
return false;
}
gl::Context *context = val->eglThread->getContext();
ANGLE_VALIDATION_TRY(ValidateContext(val, display, context));
// Although technically not a requirement in spec, the context needs to be checked for support
......@@ -3982,7 +4041,7 @@ bool ValidateCreateStreamProducerD3DTextureANGLE(const ValidationContext *val,
bool ValidateStreamPostD3DTextureANGLE(const ValidationContext *val,
const Display *display,
const Stream *stream,
void *texture,
const void *texture,
const AttributeMap &attribs)
{
ANGLE_VALIDATION_TRY(ValidateDisplay(val, display));
......@@ -4135,38 +4194,21 @@ bool ValidateGetSyncValuesCHROMIUM(const ValidationContext *val,
bool ValidateDestroySurface(const ValidationContext *val,
const Display *display,
const Surface *surface,
const EGLSurface eglSurface)
const Surface *surface)
{
ANGLE_VALIDATION_TRY(ValidateSurface(val, display, surface));
if (eglSurface == EGL_NO_SURFACE)
{
val->setError(EGL_BAD_SURFACE);
return false;
}
return true;
}
bool ValidateDestroyContext(const ValidationContext *val,
const Display *display,
const gl::Context *glCtx,
const EGLContext eglCtx)
const gl::Context *glCtx)
{
ANGLE_VALIDATION_TRY(ValidateContext(val, display, glCtx));
if (eglCtx == EGL_NO_CONTEXT)
{
val->setError(EGL_BAD_CONTEXT);
return false;
}
return true;
}
bool ValidateSwapBuffers(const ValidationContext *val,
Thread *thread,
const Display *display,
const Surface *eglSurface)
{
......@@ -4178,8 +4220,8 @@ bool ValidateSwapBuffers(const ValidationContext *val,
return false;
}
if (eglSurface == EGL_NO_SURFACE || !thread->getContext() ||
thread->getCurrentDrawSurface() != eglSurface)
if (eglSurface == EGL_NO_SURFACE || !val->eglThread->getContext() ||
val->eglThread->getCurrentDrawSurface() != eglSurface)
{
val->setError(EGL_BAD_SURFACE);
return false;
......@@ -4191,7 +4233,7 @@ bool ValidateSwapBuffers(const ValidationContext *val,
bool ValidateSwapBuffersWithDamageKHR(const ValidationContext *val,
const Display *display,
const Surface *surface,
EGLint *rects,
const EGLint *rects,
EGLint n_rects)
{
ANGLE_VALIDATION_TRY(ValidateSurface(val, display, surface));
......@@ -4227,9 +4269,9 @@ bool ValidateSwapBuffersWithDamageKHR(const ValidationContext *val,
return true;
}
bool ValidateWaitNative(const ValidationContext *val, const Display *display, const EGLint engine)
bool ValidateWaitNative(const ValidationContext *val, const EGLint engine)
{
ANGLE_VALIDATION_TRY(ValidateDisplay(val, display));
ANGLE_VALIDATION_TRY(ValidateDisplay(val, val->eglThread->getDisplay()));
if (engine != EGL_CORE_NATIVE_ENGINE)
{
......@@ -4240,11 +4282,14 @@ bool ValidateWaitNative(const ValidationContext *val, const Display *display, co
return true;
}
bool ValidateCopyBuffers(const ValidationContext *val, Display *display, const Surface *surface)
bool ValidateCopyBuffers(const ValidationContext *val,
const Display *display,
const Surface *surface,
EGLNativePixmapType target)
{
ANGLE_VALIDATION_TRY(ValidateSurface(val, display, surface));
if (display->testDeviceLost())
if (display->isDeviceLost())
{
val->setError(EGL_CONTEXT_LOST);
return false;
......@@ -4253,15 +4298,10 @@ bool ValidateCopyBuffers(const ValidationContext *val, Display *display, const S
return true;
}
// Validate state for eglBindTexImage. If context is non-null then textureObject will be set to
// surface's texture that will have an image bound to it
bool ValidateBindTexImage(const ValidationContext *val,
const Display *display,
const Surface *surface,
const EGLSurface eglSurface,
const EGLint buffer,
const gl::Context *context,
gl::Texture **textureObject)
const EGLint buffer)
{
ANGLE_VALIDATION_TRY(ValidateSurface(val, display, surface));
......@@ -4271,7 +4311,7 @@ bool ValidateBindTexImage(const ValidationContext *val,
return false;
}
if (eglSurface == EGL_NO_SURFACE || surface->getType() == EGL_WINDOW_BIT)
if (surface->getType() == EGL_WINDOW_BIT)
{
val->setError(EGL_BAD_SURFACE);
return false;
......@@ -4289,13 +4329,14 @@ bool ValidateBindTexImage(const ValidationContext *val,
return false;
}
gl::Context *context = val->eglThread->getContext();
if (context)
{
gl::TextureType type = egl_gl::EGLTextureTargetToTextureType(surface->getTextureTarget());
*textureObject = context->getTextureByType(type);
ASSERT(*textureObject != nullptr);
gl::Texture *textureObject = context->getTextureByType(type);
ASSERT(textureObject != nullptr);
if ((*textureObject)->getImmutableFormat())
if (textureObject->getImmutableFormat())
{
val->setError(EGL_BAD_MATCH);
return false;
......@@ -4308,7 +4349,6 @@ bool ValidateBindTexImage(const ValidationContext *val,
bool ValidateReleaseTexImage(const ValidationContext *val,
const Display *display,
const Surface *surface,
const EGLSurface eglSurface,
const EGLint buffer)
{
ANGLE_VALIDATION_TRY(ValidateSurface(val, display, surface));
......@@ -4319,7 +4359,7 @@ bool ValidateReleaseTexImage(const ValidationContext *val,
return false;
}
if (eglSurface == EGL_NO_SURFACE || surface->getType() == EGL_WINDOW_BIT)
if (surface->getType() == EGL_WINDOW_BIT)
{
val->setError(EGL_BAD_SURFACE);
return false;
......@@ -4334,14 +4374,13 @@ bool ValidateReleaseTexImage(const ValidationContext *val,
return true;
}
bool ValidateSwapInterval(const ValidationContext *val,
const Display *display,
const Surface *draw_surface,
const gl::Context *context)
bool ValidateSwapInterval(const ValidationContext *val, const Display *display, EGLint interval)
{
const gl::Context *context = val->eglThread->getContext();
ANGLE_VALIDATION_TRY(ValidateContext(val, display, context));
if (draw_surface == nullptr)
Surface *drawSurface = val->eglThread->getCurrentDrawSurface();
if (drawSurface == nullptr)
{
val->setError(EGL_BAD_SURFACE);
return false;
......@@ -4388,10 +4427,10 @@ bool ValidatePresentationTimeANDROID(const ValidationContext *val,
return true;
}
bool ValidateSetBlobCacheANDROID(const ValidationContext *val,
const Display *display,
EGLSetBlobFuncANDROID set,
EGLGetBlobFuncANDROID get)
bool ValidateSetBlobCacheFuncsANDROID(const ValidationContext *val,
const Display *display,
EGLSetBlobFuncANDROID set,
EGLGetBlobFuncANDROID get)
{
ANGLE_VALIDATION_TRY(ValidateDisplay(val, display));
......@@ -4414,7 +4453,8 @@ bool ValidateSetBlobCacheANDROID(const ValidationContext *val,
bool ValidateGetConfigAttrib(const ValidationContext *val,
const Display *display,
const Config *config,
EGLint attribute)
EGLint attribute,
const EGLint *value)
{
ANGLE_VALIDATION_TRY(ValidateConfig(val, display, config));
ANGLE_TRY(ValidateConfigAttribute(val, display, static_cast<EGLAttrib>(attribute)));
......@@ -4424,8 +4464,9 @@ bool ValidateGetConfigAttrib(const ValidationContext *val,
bool ValidateChooseConfig(const ValidationContext *val,
const Display *display,
const AttributeMap &attribs,
const EGLConfig *configs,
EGLint configSize,
EGLint *numConfig)
const EGLint *numConfig)
{
ANGLE_VALIDATION_TRY(ValidateDisplay(val, display));
ANGLE_VALIDATION_TRY(ValidateConfigAttributes(val, display, attribs));
......@@ -4441,8 +4482,9 @@ bool ValidateChooseConfig(const ValidationContext *val,
bool ValidateGetConfigs(const ValidationContext *val,
const Display *display,
const EGLConfig *configs,
EGLint configSize,
EGLint *numConfig)
const EGLint *numConfig)
{
ANGLE_VALIDATION_TRY(ValidateDisplay(val, display));
......@@ -4457,26 +4499,24 @@ bool ValidateGetConfigs(const ValidationContext *val,
bool ValidateGetPlatformDisplay(const ValidationContext *val,
EGLenum platform,
void *native_display,
const EGLAttrib *attrib_list)
const void *native_display,
const AttributeMap &attribMap)
{
const auto &attribMap = AttributeMap::CreateFromAttribArray(attrib_list);
return ValidateGetPlatformDisplayCommon(val, platform, native_display, attribMap);
}
bool ValidateGetPlatformDisplayEXT(const ValidationContext *val,
EGLenum platform,
void *native_display,
const EGLint *attrib_list)
const void *native_display,
const AttributeMap &attribMap)
{
const auto &attribMap = AttributeMap::CreateFromIntArray(attrib_list);
return ValidateGetPlatformDisplayCommon(val, platform, native_display, attribMap);
}
bool ValidateCreatePlatformWindowSurfaceEXT(const ValidationContext *val,
const Display *display,
const Config *configuration,
void *nativeWindow,
EGLNativeWindowType nativeWindow,
const AttributeMap &attributes)
{
if (!Display::GetClientExtensions().platformBase)
......@@ -4494,7 +4534,7 @@ bool ValidateCreatePlatformWindowSurfaceEXT(const ValidationContext *val,
bool ValidateCreatePlatformPixmapSurfaceEXT(const ValidationContext *val,
const Display *display,
const Config *configuration,
void *nativePixmap,
EGLNativePixmapType nativePixmap,
const AttributeMap &attributes)
{
if (!Display::GetClientExtensions().platformBase)
......@@ -4538,10 +4578,10 @@ bool ValidateProgramCacheGetAttribANGLE(const ValidationContext *val,
bool ValidateProgramCacheQueryANGLE(const ValidationContext *val,
const Display *display,
EGLint index,
void *key,
EGLint *keysize,
void *binary,
EGLint *binarysize)
const void *key,
const EGLint *keysize,
const void *binary,
const EGLint *binarysize)
{
ANGLE_VALIDATION_TRY(ValidateDisplay(val, display));
......@@ -4618,7 +4658,7 @@ bool ValidateProgramCachePopulateANGLE(const ValidationContext *val,
bool ValidateProgramCacheResizeANGLE(const ValidationContext *val,
const Display *display,
EGLint limit,
EGLenum mode)
EGLint mode)
{
ANGLE_VALIDATION_TRY(ValidateDisplay(val, display));
......@@ -4760,7 +4800,7 @@ bool ValidateQuerySurface(const ValidationContext *val,
const Display *display,
const Surface *surface,
EGLint attribute,
EGLint *value)
const EGLint *value)
{
ANGLE_VALIDATION_TRY(ValidateDisplay(val, display));
ANGLE_VALIDATION_TRY(ValidateSurface(val, display, surface));
......@@ -4877,7 +4917,7 @@ bool ValidateQueryContext(const ValidationContext *val,
const Display *display,
const gl::Context *context,
EGLint attribute,
EGLint *value)
const EGLint *value)
{
ANGLE_VALIDATION_TRY(ValidateContext(val, display, context));
......@@ -4940,7 +4980,7 @@ bool ValidateDebugMessageControlKHR(const ValidationContext *val,
return true;
}
bool ValidateQueryDebugKHR(const ValidationContext *val, EGLint attribute, EGLAttrib *value)
bool ValidateQueryDebugKHR(const ValidationContext *val, EGLint attribute, const EGLAttrib *value)
{
const ClientExtensions &clientExtensions = Display::GetClientExtensions();
if (!clientExtensions.debug)
......@@ -4967,7 +5007,6 @@ bool ValidateQueryDebugKHR(const ValidationContext *val, EGLint attribute, EGLAt
}
bool ValidateLabelObjectKHR(const ValidationContext *val,
Thread *thread,
const Display *display,
ObjectType objectType,
EGLObjectKHR object,
......@@ -4981,8 +5020,7 @@ bool ValidateLabelObjectKHR(const ValidationContext *val,
}
LabeledObject *labeledObject = nullptr;
ANGLE_VALIDATION_TRY(
ValidateLabeledObject(val, thread, display, objectType, object, &labeledObject));
ANGLE_VALIDATION_TRY(ValidateLabeledObject(val, display, objectType, object, &labeledObject));
return true;
}
......@@ -5017,7 +5055,7 @@ bool ValidateGetCompositorTimingANDROID(const ValidationContext *val,
const Surface *surface,
EGLint numTimestamps,
const EGLint *names,
EGLnsecsANDROID *values)
const EGLnsecsANDROID *values)
{
ANGLE_VALIDATION_TRY(ValidateDisplay(val, display));
......@@ -5071,7 +5109,7 @@ bool ValidateGetCompositorTimingANDROID(const ValidationContext *val,
bool ValidateGetNextFrameIdANDROID(const ValidationContext *val,
const Display *display,
const Surface *surface,
EGLuint64KHR *frameId)
const EGLuint64KHR *frameId)
{
ANGLE_VALIDATION_TRY(ValidateDisplay(val, display));
......@@ -5124,7 +5162,7 @@ bool ValidateGetFrameTimestampsANDROID(const ValidationContext *val,
EGLuint64KHR frameId,
EGLint numTimestamps,
const EGLint *timestamps,
EGLnsecsANDROID *values)
const EGLnsecsANDROID *values)
{
ANGLE_VALIDATION_TRY(ValidateDisplay(val, display));
......@@ -5223,54 +5261,21 @@ bool ValidateQueryStringiANGLE(const ValidationContext *val,
return true;
}
bool ValidateQueryDisplayAttribBase(const ValidationContext *val,
const Display *display,
const EGLint attribute)
{
ANGLE_VALIDATION_TRY(ValidateDisplay(val, display));
switch (attribute)
{
case EGL_DEVICE_EXT:
if (!Display::GetClientExtensions().deviceQueryEXT)
{
val->setError(EGL_BAD_DISPLAY, "EGL_EXT_device_query extension is not available.");
return false;
}
break;
case EGL_FEATURE_COUNT_ANGLE:
if (!Display::GetClientExtensions().featureControlANGLE)
{
val->setError(EGL_BAD_DISPLAY,
"EGL_ANGLE_feature_control extension is not available.");
return false;
}
break;
default:
val->setError(EGL_BAD_ATTRIBUTE, "attribute is not valid.");
return false;
}
return true;
}
bool ValidateQueryDisplayAttribEXT(const ValidationContext *val,
const Display *display,
const EGLint attribute)
const EGLint attribute,
const EGLAttrib *value)
{
ANGLE_VALIDATION_TRY(ValidateQueryDisplayAttribBase(val, display, attribute));
return true;
}
bool ValidateQueryDisplayAttribANGLE(const ValidationContext *val,
const Display *display,
const EGLint attribute)
const EGLint attribute,
const EGLAttrib *value)
{
ANGLE_VALIDATION_TRY(ValidateQueryDisplayAttribBase(val, display, attribute));
return true;
}
......@@ -5391,7 +5396,7 @@ bool ValidateSwapBuffersWithFrameTokenANGLE(const ValidationContext *val,
bool ValidateSignalSyncKHR(const ValidationContext *val,
const Display *display,
const Sync *sync,
EGLint mode)
EGLenum mode)
{
ANGLE_VALIDATION_TRY(ValidateDisplay(val, display));
......@@ -5420,9 +5425,9 @@ bool ValidateSignalSyncKHR(const ValidationContext *val,
bool ValidateQuerySurfacePointerANGLE(const ValidationContext *val,
const Display *display,
Surface *eglSurface,
const Surface *eglSurface,
EGLint attribute,
void **value)
void *const *value)
{
ANGLE_VALIDATION_TRY(ValidateDisplay(val, display));
......@@ -5460,8 +5465,8 @@ bool ValidateQuerySurfacePointerANGLE(const ValidationContext *val,
}
bool ValidatePostSubBufferNV(const ValidationContext *val,
Display *display,
Surface *eglSurface,
const Display *display,
const Surface *eglSurface,
EGLint x,
EGLint y,
EGLint width,
......@@ -5483,7 +5488,7 @@ bool ValidatePostSubBufferNV(const ValidationContext *val,
ANGLE_VALIDATION_TRY(ValidateSurface(val, display, eglSurface));
if (display->testDeviceLost())
if (display->isDeviceLost())
{
val->setError(EGL_CONTEXT_LOST);
return false;
......@@ -5493,9 +5498,9 @@ bool ValidatePostSubBufferNV(const ValidationContext *val,
}
bool ValidateQueryDeviceAttribEXT(const ValidationContext *val,
Device *device,
const Device *device,
EGLint attribute,
EGLAttrib *value)
const EGLAttrib *value)
{
ANGLE_VALIDATION_TRY(ValidateDevice(val, device));
......@@ -5538,31 +5543,124 @@ bool ValidateQueryDeviceAttribEXT(const ValidationContext *val,
return true;
}
bool ValidateQueryDeviceStringEXT(const ValidationContext *val, Device *device, EGLint name)
bool ValidateQueryDeviceStringEXT(const ValidationContext *val, const Device *device, EGLint name)
{
ANGLE_VALIDATION_TRY(ValidateDevice(val, device));
return true;
}
bool ValidateReleaseHighPowerGPUANGLE(const ValidationContext *val,
Display *display,
gl::Context *context)
const Display *display,
const gl::Context *context)
{
ANGLE_VALIDATION_TRY(ValidateContext(val, display, context));
return true;
}
bool ValidateReacquireHighPowerGPUANGLE(const ValidationContext *val,
Display *display,
gl::Context *context)
const Display *display,
const gl::Context *context)
{
ANGLE_VALIDATION_TRY(ValidateContext(val, display, context));
return true;
}
bool ValidateHandleGPUSwitchANGLE(const ValidationContext *val, Display *display)
bool ValidateHandleGPUSwitchANGLE(const ValidationContext *val, const Display *display)
{
ANGLE_VALIDATION_TRY(ValidateDisplay(val, display));
return true;
}
bool ValidateGetCurrentDisplay(const ValidationContext *val)
{
return true;
}
bool ValidateGetCurrentSurface(const ValidationContext *val, EGLint readdraw)
{
return true;
}
bool ValidateGetDisplay(const ValidationContext *val, EGLNativeDisplayType display_id)
{
return true;
}
bool ValidateGetError(const ValidationContext *val)
{
return true;
}
bool ValidateGetProcAddress(const ValidationContext *val, const char *procname)
{
return true;
}
bool ValidateQueryString(const ValidationContext *val, const Display *dpyPacked, EGLint name)
{
if (name != EGL_EXTENSIONS || dpyPacked != nullptr)
{
ANGLE_VALIDATION_TRY(ValidateDisplay(val, dpyPacked));
}
switch (name)
{
case EGL_CLIENT_APIS:
case EGL_EXTENSIONS:
case EGL_VENDOR:
case EGL_VERSION:
break;
default:
val->setError(EGL_BAD_PARAMETER);
return false;
}
return true;
}
bool ValidateWaitGL(const ValidationContext *val)
{
ANGLE_VALIDATION_TRY(ValidateDisplay(val, val->eglThread->getDisplay()));
return true;
}
bool ValidateQueryAPI(const ValidationContext *val)
{
return true;
}
bool ValidateReleaseThread(const ValidationContext *val)
{
return true;
}
bool ValidateWaitClient(const ValidationContext *val)
{
return true;
}
bool ValidateGetCurrentContext(const ValidationContext *val)
{
return true;
}
bool ValidateCreatePlatformPixmapSurface(const ValidationContext *val,
const Display *dpyPacked,
const Config *configPacked,
EGLNativePixmapType native_pixmap,
const AttributeMap &attrib_listPacked)
{
return ValidateCreatePixmapSurface(val, dpyPacked, configPacked, native_pixmap,
attrib_listPacked);
}
bool ValidateCreatePlatformWindowSurface(const ValidationContext *val,
const Display *dpyPacked,
const Config *configPacked,
EGLNativeWindowType native_window,
const AttributeMap &attrib_listPacked)
{
return ValidateCreateWindowSurface(val, dpyPacked, configPacked, native_window,
attrib_listPacked);
}
} // namespace egl
src/libANGLE/validationEGL.h
......@@ -76,447 +76,30 @@ LabeledObject *GetLabeledObjectIfValid(Thread *thread,
ObjectType objectType,
EGLObjectKHR object);
// Entry point validation
bool ValidateInitialize(const ValidationContext *val, const Display *display);
bool ValidateTerminate(const ValidationContext *val, const Display *display);
bool ValidateCreateContext(const ValidationContext *val,
Display *display,
Config *configuration,
gl::Context *shareContext,
const AttributeMap &attributes);
bool ValidateCreateWindowSurface(const ValidationContext *val,
Display *display,
Config *config,
EGLNativeWindowType window,
const AttributeMap &attributes);
bool ValidateCreatePbufferSurface(const ValidationContext *val,
Display *display,
Config *config,
const AttributeMap &attributes);
bool ValidateCreatePbufferFromClientBuffer(const ValidationContext *val,
Display *display,
EGLenum buftype,
EGLClientBuffer buffer,
Config *config,
const AttributeMap &attributes);
bool ValidateCreatePixmapSurface(const ValidationContext *val,
Display *display,
Config *config,
EGLNativePixmapType pixmap,
const AttributeMap &attributes);
bool ValidateMakeCurrent(const ValidationContext *val,
Display *display,
Surface *draw,
Surface *read,
gl::Context *context);
bool ValidateCreateImage(const ValidationContext *val,
const Display *display,
gl::Context *context,
EGLenum target,
EGLClientBuffer buffer,
const AttributeMap &attributes);
bool ValidateDestroyImage(const ValidationContext *val, const Display *display, const Image *image);
bool ValidateCreateImageKHR(const ValidationContext *val,
const Display *display,
gl::Context *context,
EGLenum target,
EGLClientBuffer buffer,
const AttributeMap &attributes);
bool ValidateDestroyImageKHR(const ValidationContext *val,
const Display *display,
const Image *image);
bool ValidateCreateDeviceANGLE(const ValidationContext *val,
EGLint device_type,
void *native_device,
const EGLAttrib *attrib_list);
bool ValidateReleaseDeviceANGLE(const ValidationContext *val, Device *device);
bool ValidateCreateSyncBase(const ValidationContext *val,
const Display *display,
EGLenum type,
const AttributeMap &attribs,
const Display *currentDisplay,
const gl::Context *currentContext,
bool isExt);
bool ValidateGetSyncAttribBase(const ValidationContext *val,
const Display *display,
const Sync *sync,
EGLint attribute);
bool ValidateCreateSyncKHR(const ValidationContext *val,
const Display *display,
EGLenum type,
const AttributeMap &attribs,
const Display *currentDisplay,
const gl::Context *currentContext);
bool ValidateCreateSync(const ValidationContext *val,
const Display *display,
EGLenum type,
const AttributeMap &attribs,
const Display *currentDisplay,
const gl::Context *currentContext);
bool ValidateDestroySync(const ValidationContext *val, const Display *display, const Sync *sync);
bool ValidateClientWaitSync(const ValidationContext *val,
const Display *display,
const Sync *sync,
EGLint flags,
EGLTime timeout);
bool ValidateWaitSync(const ValidationContext *val,
const Display *display,
const gl::Context *context,
const Sync *sync,
EGLint flags);
bool ValidateGetSyncAttribKHR(const ValidationContext *val,
const Display *display,
const Sync *sync,
EGLint attribute,
EGLint *value);
bool ValidateGetSyncAttrib(const ValidationContext *val,
const Display *display,
const Sync *sync,
EGLint attribute,
EGLAttrib *value);
bool ValidateCreateStreamKHR(const ValidationContext *val,
const Display *display,
const AttributeMap &attributes);
bool ValidateDestroyStreamKHR(const ValidationContext *val,
const Display *display,
const Stream *stream);
bool ValidateStreamAttribKHR(const ValidationContext *val,
const Display *display,
const Stream *stream,
EGLint attribute,
EGLint value);
bool ValidateQueryStreamKHR(const ValidationContext *val,
const Display *display,
const Stream *stream,
EGLenum attribute,
EGLint *value);
bool ValidateQueryStreamu64KHR(const ValidationContext *val,
const Display *display,
const Stream *stream,
EGLenum attribute,
EGLuint64KHR *value);
bool ValidateStreamConsumerGLTextureExternalKHR(const ValidationContext *val,
const Display *display,
gl::Context *context,
const Stream *stream);
bool ValidateStreamConsumerAcquireKHR(const ValidationContext *val,
const Display *display,
gl::Context *context,
const Stream *stream);
bool ValidateStreamConsumerReleaseKHR(const ValidationContext *val,
const Display *display,
gl::Context *context,
const Stream *stream);
bool ValidateStreamConsumerGLTextureExternalAttribsNV(const ValidationContext *val,
const Display *display,
gl::Context *context,
const Stream *stream,
const AttributeMap &attribs);
bool ValidateCreateStreamProducerD3DTextureANGLE(const ValidationContext *val,
const Display *display,
const Stream *stream,
const AttributeMap &attribs);
bool ValidateStreamPostD3DTextureANGLE(const ValidationContext *val,
const Display *display,
const Stream *stream,
void *texture,
const AttributeMap &attribs);
bool ValidateGetMscRateANGLE(const ValidationContext *val,
const Display *display,
const Surface *surface,
const EGLint *numerator,
const EGLint *denominator);
bool ValidateGetSyncValuesCHROMIUM(const ValidationContext *val,
const Display *display,
const Surface *surface,
const EGLuint64KHR *ust,
const EGLuint64KHR *msc,
const EGLuint64KHR *sbc);
bool ValidateDestroySurface(const ValidationContext *val,
const Display *display,
const Surface *surface,
const EGLSurface eglSurface);
bool ValidateDestroyContext(const ValidationContext *val,
const Display *display,
const gl::Context *glCtx,
const EGLContext eglCtx);
bool ValidateSwapBuffers(const ValidationContext *val,
Thread *thread,
const Display *display,
const Surface *surface);
bool ValidateWaitNative(const ValidationContext *val, const Display *display, const EGLint engine);
bool ValidateCopyBuffers(const ValidationContext *val, Display *display, const Surface *surface);
bool ValidateSwapBuffersWithDamageKHR(const ValidationContext *val,
const Display *display,
const Surface *surface,
EGLint *rects,
EGLint n_rects);
bool ValidateBindTexImage(const ValidationContext *val,
const Display *display,
const Surface *surface,
const EGLSurface eglSurface,
const EGLint buffer,
const gl::Context *context,
gl::Texture **textureObject);
bool ValidateReleaseTexImage(const ValidationContext *val,
const Display *display,
const Surface *surface,
const EGLSurface eglSurface,
const EGLint buffer);
bool ValidateSwapInterval(const ValidationContext *val,
const Display *display,
const Surface *draw_surface,
const gl::Context *context);
bool ValidateBindAPI(const ValidationContext *val, const EGLenum api);
bool ValidatePresentationTimeANDROID(const ValidationContext *val,
const Display *display,
const Surface *surface,
EGLnsecsANDROID time);
bool ValidateSetBlobCacheANDROID(const ValidationContext *val,
const Display *display,
EGLSetBlobFuncANDROID set,
EGLGetBlobFuncANDROID get);
bool ValidateGetConfigAttrib(const ValidationContext *val,
const Display *display,
const Config *config,
EGLint attribute);
bool ValidateChooseConfig(const ValidationContext *val,
const Display *display,
const AttributeMap &attribs,
EGLint configSize,
EGLint *numConfig);
bool ValidateGetConfigs(const ValidationContext *val,
const Display *display,
EGLint configSize,
EGLint *numConfig);
// Other validation
bool ValidateCompatibleSurface(const ValidationContext *val,
const Display *display,
gl::Context *context,
const Surface *surface);
bool ValidateGetPlatformDisplay(const ValidationContext *val,
EGLenum platform,
void *native_display,
const EGLAttrib *attrib_list);
bool ValidateGetPlatformDisplayEXT(const ValidationContext *val,
EGLenum platform,
void *native_display,
const EGLint *attrib_list);
bool ValidateCreatePlatformWindowSurfaceEXT(const ValidationContext *val,
const Display *display,
const Config *configuration,
void *nativeWindow,
const AttributeMap &attributes);
bool ValidateCreatePlatformPixmapSurfaceEXT(const ValidationContext *val,
const Display *display,
const Config *configuration,
void *nativePixmap,
const AttributeMap &attributes);
bool ValidateProgramCacheGetAttribANGLE(const ValidationContext *val,
const Display *display,
EGLenum attrib);
bool ValidateProgramCacheQueryANGLE(const ValidationContext *val,
const Display *display,
EGLint index,
void *key,
EGLint *keysize,
void *binary,
EGLint *binarysize);
bool ValidateProgramCachePopulateANGLE(const ValidationContext *val,
const Display *display,
const void *key,
EGLint keysize,
const void *binary,
EGLint binarysize);
bool ValidateProgramCacheResizeANGLE(const ValidationContext *val,
const Display *display,
EGLint limit,
EGLenum mode);
bool ValidateSurfaceAttrib(const ValidationContext *val,
const Display *display,
const Surface *surface,
EGLint attribute,
EGLint value);
bool ValidateQuerySurface(const ValidationContext *val,
const Display *display,
const Surface *surface,
EGLint attribute,
EGLint *value);
bool ValidateQueryContext(const ValidationContext *val,
const Display *display,
const gl::Context *context,
EGLint attribute,
EGLint *value);
// EGL_KHR_debug
bool ValidateDebugMessageControlKHR(const ValidationContext *val,
EGLDEBUGPROCKHR callback,
const AttributeMap &attribs);
bool ValidateQueryDebugKHR(const ValidationContext *val, EGLint attribute, EGLAttrib *value);
bool ValidateLabelObjectKHR(const ValidationContext *val,
Thread *thread,
const Display *display,
ObjectType objectType,
EGLObjectKHR object,
EGLLabelKHR label);
// ANDROID_get_frame_timestamps
bool ValidateGetCompositorTimingSupportedANDROID(const ValidationContext *val,
const Display *display,
const Surface *surface,
CompositorTiming name);
bool ValidateGetCompositorTimingANDROID(const ValidationContext *val,
const Display *display,
const Surface *surface,
EGLint numTimestamps,
const EGLint *names,
EGLnsecsANDROID *values);
bool ValidateGetNextFrameIdANDROID(const ValidationContext *val,
const Display *display,
const Surface *surface,
EGLuint64KHR *frameId);
bool ValidateGetFrameTimestampSupportedANDROID(const ValidationContext *val,
const Display *display,
const Surface *surface,
Timestamp timestamp);
bool ValidateGetFrameTimestampsANDROID(const ValidationContext *val,
const Display *display,
const Surface *surface,
EGLuint64KHR frameId,
EGLint numTimestamps,
const EGLint *timestamps,
EGLnsecsANDROID *values);
bool ValidateQueryStringiANGLE(const ValidationContext *val,
const Display *display,
EGLint name,
EGLint index);
bool ValidateQueryDisplayAttribEXT(const ValidationContext *val,
const Display *display,
const EGLint attribute);
bool ValidateQueryDisplayAttribANGLE(const ValidationContext *val,
const Display *display,
const EGLint attribute);
// EGL_ANDROID_get_native_client_buffer
bool ValidateGetNativeClientBufferANDROID(const ValidationContext *val,
const struct AHardwareBuffer *buffer);
// EGL_ANDROID_create_native_client_buffer
bool ValidateCreateNativeClientBufferANDROID(const ValidationContext *val,
const egl::AttributeMap &attribMap);
// EGL_ANDROID_native_fence_sync
bool ValidateDupNativeFenceFDANDROID(const ValidationContext *val,
const Display *display,
const Sync *sync);
// EGL_ANGLE_swap_with_frame_token
bool ValidateSwapBuffersWithFrameTokenANGLE(const ValidationContext *val,
const Display *display,
const Surface *surface,
EGLFrameTokenANGLE frametoken);
// EGL_KHR_reusable_sync
bool ValidateSignalSyncKHR(const ValidationContext *val,
const Display *display,
const Sync *sync,
EGLint mode);
// EGL_ANGLE_query_surface_pointer
bool ValidateQuerySurfacePointerANGLE(const ValidationContext *val,
const Display *display,
Surface *eglSurface,
EGLint attribute,
void **value);
// EGL_NV_post_sub_buffer
bool ValidatePostSubBufferNV(const ValidationContext *val,
Display *display,
Surface *eglSurface,
EGLint x,
EGLint y,
EGLint width,
EGLint height);
// EGL_EXT_device_query
bool ValidateQueryDeviceAttribEXT(const ValidationContext *val,
Device *device,
EGLint attribute,
EGLAttrib *value);
bool ValidateQueryDeviceStringEXT(const ValidationContext *val, Device *device, EGLint name);
bool ValidateReleaseHighPowerGPUANGLE(const ValidationContext *val,
Display *display,
gl::Context *context);
bool ValidateReacquireHighPowerGPUANGLE(const ValidationContext *val,
Display *display,
gl::Context *context);
bool ValidateHandleGPUSwitchANGLE(const ValidationContext *val, Display *display);
} // namespace egl
#define ANGLE_EGL_VALIDATE(THREAD, EP, OBJ, RETVAL, ...) \
do \
{ \
const char *epname = "egl" #EP; \
ValidationContext vctx(THREAD, epname, OBJ); \
auto ANGLE_LOCAL_VAR = (Validate##EP(&vctx, __VA_ARGS__)); \
if (!ANGLE_LOCAL_VAR) \
{ \
return RETVAL; \
} \
#define ANGLE_EGL_VALIDATE(THREAD, EP, OBJ, RETVAL, ...) \
do \
{ \
const char *epname = "egl" #EP; \
ValidationContext vctx(THREAD, epname, OBJ); \
auto ANGLE_LOCAL_VAR = (Validate##EP(&vctx, ##__VA_ARGS__)); \
if (!ANGLE_LOCAL_VAR) \
{ \
return RETVAL; \
} \
} while (0)
#define ANGLE_EGL_VALIDATE_VOID(THREAD, EP, OBJ, ...) \
do \
{ \
const char *epname = "egl" #EP; \
ValidationContext vctx(THREAD, epname, OBJ); \
auto ANGLE_LOCAL_VAR = (Validate##EP(&vctx, __VA_ARGS__)); \
if (!ANGLE_LOCAL_VAR) \
{ \
return; \
} \
#define ANGLE_EGL_VALIDATE_VOID(THREAD, EP, OBJ, ...) \
do \
{ \
const char *epname = "egl" #EP; \
ValidationContext vctx(THREAD, epname, OBJ); \
auto ANGLE_LOCAL_VAR = (Validate##EP(&vctx, ##__VA_ARGS__)); \
if (!ANGLE_LOCAL_VAR) \
{ \
return; \
} \
} while (0)
#define ANGLE_EGL_TRY(THREAD, EXPR, FUNCNAME, LABELOBJECT) \
......
src/libANGLE/validationEGL_autogen.h 0 → 100644
// 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.
//
// validationEGL_autogen.h:
// Validation functions for the EGL entry points.
#ifndef LIBANGLE_VALIDATION_EGL_AUTOGEN_H_
#define LIBANGLE_VALIDATION_EGL_AUTOGEN_H_
#include "libANGLE/validationEGL.h"
namespace egl
{
// EGL 1.0
bool ValidateChooseConfig(const ValidationContext *val,
const Display *dpyPacked,
const AttributeMap &attrib_listPacked,
const EGLConfig *configs,
EGLint config_size,
const EGLint *num_config);
bool ValidateCopyBuffers(const ValidationContext *val,
const Display *dpyPacked,
const Surface *surfacePacked,
EGLNativePixmapType target);
bool ValidateCreateContext(const ValidationContext *val,
const Display *dpyPacked,
const Config *configPacked,
const gl::Context *share_contextPacked,
const AttributeMap &attrib_listPacked);
bool ValidateCreatePbufferSurface(const ValidationContext *val,
const Display *dpyPacked,
const Config *configPacked,
const AttributeMap &attrib_listPacked);
bool ValidateCreatePixmapSurface(const ValidationContext *val,
const Display *dpyPacked,
const Config *configPacked,
EGLNativePixmapType pixmap,
const AttributeMap &attrib_listPacked);
bool ValidateCreateWindowSurface(const ValidationContext *val,
const Display *dpyPacked,
const Config *configPacked,
EGLNativeWindowType win,
const AttributeMap &attrib_listPacked);
bool ValidateDestroyContext(const ValidationContext *val,
const Display *dpyPacked,
const gl::Context *ctxPacked);
bool ValidateDestroySurface(const ValidationContext *val,
const Display *dpyPacked,
const Surface *surfacePacked);
bool ValidateGetConfigAttrib(const ValidationContext *val,
const Display *dpyPacked,
const Config *configPacked,
EGLint attribute,
const EGLint *value);
bool ValidateGetConfigs(const ValidationContext *val,
const Display *dpyPacked,
const EGLConfig *configs,
EGLint config_size,
const EGLint *num_config);
bool ValidateGetCurrentDisplay(const ValidationContext *val);
bool ValidateGetCurrentSurface(const ValidationContext *val, EGLint readdraw);
bool ValidateGetDisplay(const ValidationContext *val, EGLNativeDisplayType display_id);
bool ValidateGetError(const ValidationContext *val);
bool ValidateGetProcAddress(const ValidationContext *val, const char *procname);
bool ValidateInitialize(const ValidationContext *val,
const Display *dpyPacked,
const EGLint *major,
const EGLint *minor);
bool ValidateMakeCurrent(const ValidationContext *val,
const Display *dpyPacked,
const Surface *drawPacked,
const Surface *readPacked,
const gl::Context *ctxPacked);
bool ValidateQueryContext(const ValidationContext *val,
const Display *dpyPacked,
const gl::Context *ctxPacked,
EGLint attribute,
const EGLint *value);
bool ValidateQueryString(const ValidationContext *val, const Display *dpyPacked, EGLint name);
bool ValidateQuerySurface(const ValidationContext *val,
const Display *dpyPacked,
const Surface *surfacePacked,
EGLint attribute,
const EGLint *value);
bool ValidateSwapBuffers(const ValidationContext *val,
const Display *dpyPacked,
const Surface *surfacePacked);
bool ValidateTerminate(const ValidationContext *val, const Display *dpyPacked);
bool ValidateWaitGL(const ValidationContext *val);
bool ValidateWaitNative(const ValidationContext *val, EGLint engine);
// EGL 1.1
bool ValidateBindTexImage(const ValidationContext *val,
const Display *dpyPacked,
const Surface *surfacePacked,
EGLint buffer);
bool ValidateReleaseTexImage(const ValidationContext *val,
const Display *dpyPacked,
const Surface *surfacePacked,
EGLint buffer);
bool ValidateSurfaceAttrib(const ValidationContext *val,
const Display *dpyPacked,
const Surface *surfacePacked,
EGLint attribute,
EGLint value);
bool ValidateSwapInterval(const ValidationContext *val, const Display *dpyPacked, EGLint interval);
// EGL 1.2
bool ValidateBindAPI(const ValidationContext *val, EGLenum api);
bool ValidateCreatePbufferFromClientBuffer(const ValidationContext *val,
const Display *dpyPacked,
EGLenum buftype,
EGLClientBuffer buffer,
const Config *configPacked,
const AttributeMap &attrib_listPacked);
bool ValidateQueryAPI(const ValidationContext *val);
bool ValidateReleaseThread(const ValidationContext *val);
bool ValidateWaitClient(const ValidationContext *val);
// EGL 1.4
bool ValidateGetCurrentContext(const ValidationContext *val);
// EGL 1.5
bool ValidateClientWaitSync(const ValidationContext *val,
const Display *dpyPacked,
const Sync *syncPacked,
EGLint flags,
EGLTime timeout);
bool ValidateCreateImage(const ValidationContext *val,
const Display *dpyPacked,
const gl::Context *ctxPacked,
EGLenum target,
EGLClientBuffer buffer,
const AttributeMap &attrib_listPacked);
bool ValidateCreatePlatformPixmapSurface(const ValidationContext *val,
const Display *dpyPacked,
const Config *configPacked,
EGLNativePixmapType native_pixmapPacked,
const AttributeMap &attrib_listPacked);
bool ValidateCreatePlatformWindowSurface(const ValidationContext *val,
const Display *dpyPacked,
const Config *configPacked,
EGLNativeWindowType native_windowPacked,
const AttributeMap &attrib_listPacked);
bool ValidateCreateSync(const ValidationContext *val,
const Display *dpyPacked,
EGLenum type,
const AttributeMap &attrib_listPacked);
bool ValidateDestroyImage(const ValidationContext *val,
const Display *dpyPacked,
const Image *imagePacked);
bool ValidateDestroySync(const ValidationContext *val,
const Display *dpyPacked,
const Sync *syncPacked);
bool ValidateGetPlatformDisplay(const ValidationContext *val,
EGLenum platform,
const void *native_display,
const AttributeMap &attrib_listPacked);
bool ValidateGetSyncAttrib(const ValidationContext *val,
const Display *dpyPacked,
const Sync *syncPacked,
EGLint attribute,
const EGLAttrib *value);
bool ValidateWaitSync(const ValidationContext *val,
const Display *dpyPacked,
const Sync *syncPacked,
EGLint flags);
// EGL_ANDROID_blob_cache
bool ValidateSetBlobCacheFuncsANDROID(const ValidationContext *val,
const Display *dpyPacked,
EGLSetBlobFuncANDROID set,
EGLGetBlobFuncANDROID get);
// EGL_ANDROID_create_native_client_buffer
bool ValidateCreateNativeClientBufferANDROID(const ValidationContext *val,
const AttributeMap &attrib_listPacked);
// EGL_ANDROID_get_frame_timestamps
bool ValidateGetCompositorTimingSupportedANDROID(const ValidationContext *val,
const Display *dpyPacked,
const Surface *surfacePacked,
CompositorTiming namePacked);
bool ValidateGetCompositorTimingANDROID(const ValidationContext *val,
const Display *dpyPacked,
const Surface *surfacePacked,
EGLint numTimestamps,
const EGLint *names,
const EGLnsecsANDROID *values);
bool ValidateGetNextFrameIdANDROID(const ValidationContext *val,
const Display *dpyPacked,
const Surface *surfacePacked,
const EGLuint64KHR *frameId);
bool ValidateGetFrameTimestampSupportedANDROID(const ValidationContext *val,
const Display *dpyPacked,
const Surface *surfacePacked,
Timestamp timestampPacked);
bool ValidateGetFrameTimestampsANDROID(const ValidationContext *val,
const Display *dpyPacked,
const Surface *surfacePacked,
EGLuint64KHR frameId,
EGLint numTimestamps,
const EGLint *timestamps,
const EGLnsecsANDROID *values);
// EGL_ANDROID_get_native_client_buffer
bool ValidateGetNativeClientBufferANDROID(const ValidationContext *val,
const struct AHardwareBuffer *buffer);
// EGL_ANDROID_native_fence_sync
bool ValidateDupNativeFenceFDANDROID(const ValidationContext *val,
const Display *dpyPacked,
const Sync *syncPacked);
// EGL_ANDROID_presentation_time
bool ValidatePresentationTimeANDROID(const ValidationContext *val,
const Display *dpyPacked,
const Surface *surfacePacked,
EGLnsecsANDROID time);
// EGL_ANGLE_device_creation
bool ValidateCreateDeviceANGLE(const ValidationContext *val,
EGLint device_type,
const void *native_device,
const EGLAttrib *attrib_list);
bool ValidateReleaseDeviceANGLE(const ValidationContext *val, const Device *devicePacked);
// EGL_ANGLE_feature_control
bool ValidateQueryStringiANGLE(const ValidationContext *val,
const Display *dpyPacked,
EGLint name,
EGLint index);
bool ValidateQueryDisplayAttribANGLE(const ValidationContext *val,
const Display *dpyPacked,
EGLint attribute,
const EGLAttrib *value);
// EGL_ANGLE_power_preference
bool ValidateReleaseHighPowerGPUANGLE(const ValidationContext *val,
const Display *dpyPacked,
const gl::Context *ctxPacked);
bool ValidateReacquireHighPowerGPUANGLE(const ValidationContext *val,
const Display *dpyPacked,
const gl::Context *ctxPacked);
bool ValidateHandleGPUSwitchANGLE(const ValidationContext *val, const Display *dpyPacked);
// EGL_ANGLE_program_cache_control
bool ValidateProgramCacheGetAttribANGLE(const ValidationContext *val,
const Display *dpyPacked,
EGLenum attrib);
bool ValidateProgramCacheQueryANGLE(const ValidationContext *val,
const Display *dpyPacked,
EGLint index,
const void *key,
const EGLint *keysize,
const void *binary,
const EGLint *binarysize);
bool ValidateProgramCachePopulateANGLE(const ValidationContext *val,
const Display *dpyPacked,
const void *key,
EGLint keysize,
const void *binary,
EGLint binarysize);
bool ValidateProgramCacheResizeANGLE(const ValidationContext *val,
const Display *dpyPacked,
EGLint limit,
EGLint mode);
// EGL_ANGLE_query_surface_pointer
bool ValidateQuerySurfacePointerANGLE(const ValidationContext *val,
const Display *dpyPacked,
const Surface *surfacePacked,
EGLint attribute,
void *const *value);
// EGL_ANGLE_stream_producer_d3d_texture
bool ValidateCreateStreamProducerD3DTextureANGLE(const ValidationContext *val,
const Display *dpyPacked,
const Stream *streamPacked,
const AttributeMap &attrib_listPacked);
bool ValidateStreamPostD3DTextureANGLE(const ValidationContext *val,
const Display *dpyPacked,
const Stream *streamPacked,
const void *texture,
const AttributeMap &attrib_listPacked);
// EGL_ANGLE_swap_with_frame_token
bool ValidateSwapBuffersWithFrameTokenANGLE(const ValidationContext *val,
const Display *dpyPacked,
const Surface *surfacePacked,
EGLFrameTokenANGLE frametoken);
// EGL_ANGLE_sync_control_rate
bool ValidateGetMscRateANGLE(const ValidationContext *val,
const Display *dpyPacked,
const Surface *surfacePacked,
const EGLint *numerator,
const EGLint *denominator);
// EGL_CHROMIUM_sync_control
bool ValidateGetSyncValuesCHROMIUM(const ValidationContext *val,
const Display *dpyPacked,
const Surface *surfacePacked,
const EGLuint64KHR *ust,
const EGLuint64KHR *msc,
const EGLuint64KHR *sbc);
// EGL_EXT_device_query
bool ValidateQueryDeviceAttribEXT(const ValidationContext *val,
const Device *devicePacked,
EGLint attribute,
const EGLAttrib *value);
bool ValidateQueryDeviceStringEXT(const ValidationContext *val,
const Device *devicePacked,
EGLint name);
bool ValidateQueryDisplayAttribEXT(const ValidationContext *val,
const Display *dpyPacked,
EGLint attribute,
const EGLAttrib *value);
// EGL_EXT_platform_base
bool ValidateCreatePlatformPixmapSurfaceEXT(const ValidationContext *val,
const Display *dpyPacked,
const Config *configPacked,
EGLNativePixmapType native_pixmapPacked,
const AttributeMap &attrib_listPacked);
bool ValidateCreatePlatformWindowSurfaceEXT(const ValidationContext *val,
const Display *dpyPacked,
const Config *configPacked,
EGLNativeWindowType native_windowPacked,
const AttributeMap &attrib_listPacked);
bool ValidateGetPlatformDisplayEXT(const ValidationContext *val,
EGLenum platform,
const void *native_display,
const AttributeMap &attrib_listPacked);
// EGL_KHR_debug
bool ValidateDebugMessageControlKHR(const ValidationContext *val,
EGLDEBUGPROCKHR callback,
const AttributeMap &attrib_listPacked);
bool ValidateLabelObjectKHR(const ValidationContext *val,
const Display *displayPacked,
ObjectType objectTypePacked,
EGLObjectKHR object,
EGLLabelKHR label);
bool ValidateQueryDebugKHR(const ValidationContext *val, EGLint attribute, const EGLAttrib *value);
// EGL_KHR_fence_sync
bool ValidateClientWaitSyncKHR(const ValidationContext *val,
const Display *dpyPacked,
const Sync *syncPacked,
EGLint flags,
EGLTimeKHR timeout);
bool ValidateCreateSyncKHR(const ValidationContext *val,
const Display *dpyPacked,
EGLenum type,
const AttributeMap &attrib_listPacked);
bool ValidateDestroySyncKHR(const ValidationContext *val,
const Display *dpyPacked,
const Sync *syncPacked);
bool ValidateGetSyncAttribKHR(const ValidationContext *val,
const Display *dpyPacked,
const Sync *syncPacked,
EGLint attribute,
const EGLint *value);
// EGL_KHR_image
bool ValidateCreateImageKHR(const ValidationContext *val,
const Display *dpyPacked,
const gl::Context *ctxPacked,
EGLenum target,
EGLClientBuffer buffer,
const AttributeMap &attrib_listPacked);
bool ValidateDestroyImageKHR(const ValidationContext *val,
const Display *dpyPacked,
const Image *imagePacked);
// EGL_KHR_reusable_sync
bool ValidateSignalSyncKHR(const ValidationContext *val,
const Display *dpyPacked,
const Sync *syncPacked,
EGLenum mode);
// EGL_KHR_stream
bool ValidateCreateStreamKHR(const ValidationContext *val,
const Display *dpyPacked,
const AttributeMap &attrib_listPacked);
bool ValidateDestroyStreamKHR(const ValidationContext *val,
const Display *dpyPacked,
const Stream *streamPacked);
bool ValidateQueryStreamKHR(const ValidationContext *val,
const Display *dpyPacked,
const Stream *streamPacked,
EGLenum attribute,
const EGLint *value);
bool ValidateQueryStreamu64KHR(const ValidationContext *val,
const Display *dpyPacked,
const Stream *streamPacked,
EGLenum attribute,
const EGLuint64KHR *value);
bool ValidateStreamAttribKHR(const ValidationContext *val,
const Display *dpyPacked,
const Stream *streamPacked,
EGLenum attribute,
EGLint value);
// EGL_KHR_stream_consumer_gltexture
bool ValidateStreamConsumerAcquireKHR(const ValidationContext *val,
const Display *dpyPacked,
const Stream *streamPacked);
bool ValidateStreamConsumerGLTextureExternalKHR(const ValidationContext *val,
const Display *dpyPacked,
const Stream *streamPacked);
bool ValidateStreamConsumerReleaseKHR(const ValidationContext *val,
const Display *dpyPacked,
const Stream *streamPacked);
// EGL_KHR_swap_buffers_with_damage
bool ValidateSwapBuffersWithDamageKHR(const ValidationContext *val,
const Display *dpyPacked,
const Surface *surfacePacked,
const EGLint *rects,
EGLint n_rects);
// EGL_KHR_wait_sync
bool ValidateWaitSyncKHR(const ValidationContext *val,
const Display *dpyPacked,
const Sync *syncPacked,
EGLint flags);
// EGL_NV_post_sub_buffer
bool ValidatePostSubBufferNV(const ValidationContext *val,
const Display *dpyPacked,
const Surface *surfacePacked,
EGLint x,
EGLint y,
EGLint width,
EGLint height);
// EGL_NV_stream_consumer_gltexture_yuv
bool ValidateStreamConsumerGLTextureExternalAttribsNV(const ValidationContext *val,
const Display *dpyPacked,
const Stream *streamPacked,
const AttributeMap &attrib_listPacked);
} // namespace egl
#endif // LIBANGLE_VALIDATION_EGL_AUTOGEN_H_
src/libGLESv2.gni
......@@ -325,6 +325,7 @@ libangle_headers = [
"src/libANGLE/renderer/renderer_utils.h",
"src/libANGLE/renderer/serial_utils.h",
"src/libANGLE/validationEGL.h",
"src/libANGLE/validationEGL_autogen.h",
"src/libANGLE/validationES.h",
"src/libANGLE/validationES1.h",
"src/libANGLE/validationES1_autogen.h",
......
src/libGLESv2/entry_points_egl.cpp
......@@ -20,6 +20,7 @@
#include "libANGLE/entry_points_utils.h"
#include "libANGLE/queryutils.h"
#include "libANGLE/validationEGL.h"
#include "libANGLE/validationEGL_autogen.h"
#include "libGLESv2/global_state.h"
#include "libGLESv2/proc_table_egl.h"
......@@ -81,7 +82,8 @@ EGLBoolean EGLAPIENTRY EGL_Initialize(EGLDisplay dpy, EGLint *major, EGLint *min
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
ANGLE_EGL_VALIDATE(thread, Initialize, GetDisplayIfValid(display), EGL_FALSE, display);
ANGLE_EGL_VALIDATE(thread, Initialize, GetDisplayIfValid(display), EGL_FALSE, display, major,
minor);
ANGLE_EGL_TRY_RETURN(thread, display->initialize(), "eglInitialize", GetDisplayIfValid(display),
EGL_FALSE);
......@@ -120,17 +122,18 @@ const char *EGLAPIENTRY EGL_QueryString(EGLDisplay dpy, EGLint name)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLint name = %d", (uintptr_t)dpy, name);
Thread *thread = egl::GetCurrentThread();
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
if (!(display == EGL_NO_DISPLAY && name == EGL_EXTENSIONS))
ANGLE_EGL_VALIDATE(thread, QueryString, GetDisplayIfValid(display), nullptr, display, name);
if (display)
{
ANGLE_EGL_VALIDATE(thread, Display, GetDisplayIfValid(display), nullptr, display);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQueryString",
GetDisplayIfValid(display), nullptr);
}
const char *result;
const char *result = nullptr;
switch (name)
{
case EGL_CLIENT_APIS:
......@@ -153,8 +156,8 @@ const char *EGLAPIENTRY EGL_QueryString(EGLDisplay dpy, EGLint name)
result = "1.5 (ANGLE " ANGLE_VERSION_STRING ")";
break;
default:
thread->setError(EglBadParameter(), "eglQueryString", GetDisplayIfValid(display));
return nullptr;
UNREACHABLE();
break;
}
thread->setSuccess();
......@@ -175,7 +178,7 @@ EGLBoolean EGLAPIENTRY EGL_GetConfigs(EGLDisplay dpy,
egl::Display *display = static_cast<egl::Display *>(dpy);
ANGLE_EGL_VALIDATE(thread, GetConfigs, GetDisplayIfValid(display), EGL_FALSE, display,
ANGLE_EGL_VALIDATE(thread, GetConfigs, GetDisplayIfValid(display), EGL_FALSE, display, configs,
config_size, num_config);
ClipConfigs(display->getConfigs(AttributeMap()), configs, config_size, num_config);
......@@ -203,7 +206,7 @@ EGLBoolean EGLAPIENTRY EGL_ChooseConfig(EGLDisplay dpy,
AttributeMap attribMap = AttributeMap::CreateFromIntArray(attrib_list);
ANGLE_EGL_VALIDATE(thread, ChooseConfig, GetDisplayIfValid(display), EGL_FALSE, display,
attribMap, config_size, num_config);
attribMap, configs, config_size, num_config);
ClipConfigs(display->chooseConfig(attribMap), configs, config_size, num_config);
......@@ -227,7 +230,7 @@ EGLBoolean EGLAPIENTRY EGL_GetConfigAttrib(EGLDisplay dpy,
Config *configuration = static_cast<Config *>(config);
ANGLE_EGL_VALIDATE(thread, GetConfigAttrib, GetDisplayIfValid(display), EGL_FALSE, display,
configuration, attribute);
configuration, attribute, value);
QueryConfigAttrib(configuration, attribute, value);
......@@ -333,7 +336,7 @@ EGLBoolean EGLAPIENTRY EGL_DestroySurface(EGLDisplay dpy, EGLSurface surface)
Surface *eglSurface = static_cast<Surface *>(surface);
ANGLE_EGL_VALIDATE(thread, DestroySurface, GetSurfaceIfValid(display, eglSurface), EGL_FALSE,
display, eglSurface, surface);
display, eglSurface);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglDestroySurface",
GetDisplayIfValid(display), EGL_FALSE);
ANGLE_EGL_TRY_RETURN(thread, display->destroySurface(eglSurface), "eglDestroySurface",
......@@ -411,7 +414,7 @@ EGLBoolean EGLAPIENTRY EGL_DestroyContext(EGLDisplay dpy, EGLContext ctx)
gl::Context *context = static_cast<gl::Context *>(ctx);
ANGLE_EGL_VALIDATE(thread, DestroyContext, GetContextIfValid(display, context), EGL_FALSE,
display, context, ctx);
display, context);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglDestroyContext",
GetDisplayIfValid(display), EGL_FALSE);
bool contextWasCurrent = context == thread->getContext();
......@@ -540,8 +543,7 @@ EGLBoolean EGLAPIENTRY EGL_WaitGL(void)
Thread *thread = egl::GetCurrentThread();
egl::Display *display = thread->getDisplay();
ANGLE_EGL_VALIDATE(thread, Display, GetDisplayIfValid(display), EGL_FALSE, display);
ANGLE_EGL_VALIDATE(thread, WaitGL, GetDisplayIfValid(display), EGL_FALSE);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglWaitGL", GetDisplayIfValid(display),
EGL_FALSE);
......@@ -560,12 +562,11 @@ EGLBoolean EGLAPIENTRY EGL_WaitNative(EGLint engine)
FUNC_EVENT("EGLint engine = %d", engine);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = thread->getDisplay();
ANGLE_EGL_VALIDATE(thread, WaitNative, GetThreadIfValid(thread), EGL_FALSE, engine);
ANGLE_EGL_VALIDATE(thread, WaitNative, GetThreadIfValid(thread), EGL_FALSE, display, engine);
egl::Display *display = thread->getDisplay();
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglWaitNative",
GetDisplayIfValid(display), EGL_FALSE);
ANGLE_EGL_TRY_RETURN(thread, display->waitNative(thread->getContext(), engine), "eglWaitNative",
GetThreadIfValid(thread), EGL_FALSE);
......@@ -584,7 +585,7 @@ EGLBoolean EGLAPIENTRY EGL_SwapBuffers(EGLDisplay dpy, EGLSurface surface)
Surface *eglSurface = (Surface *)surface;
ANGLE_EGL_VALIDATE(thread, SwapBuffers, GetSurfaceIfValid(display, eglSurface), EGL_FALSE,
thread, display, eglSurface);
display, eglSurface);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglSwapBuffers",
GetDisplayIfValid(display), EGL_FALSE);
......@@ -610,7 +611,7 @@ EGLBoolean EGLAPIENTRY EGL_CopyBuffers(EGLDisplay dpy,
Surface *eglSurface = static_cast<Surface *>(surface);
ANGLE_EGL_VALIDATE(thread, CopyBuffers, GetSurfaceIfValid(display, eglSurface), EGL_FALSE,
display, eglSurface);
display, eglSurface, target);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCopyBuffers",
GetDisplayIfValid(display), EGL_FALSE);
UNIMPLEMENTED(); // FIXME
......@@ -628,17 +629,19 @@ EGLBoolean EGLAPIENTRY EGL_BindTexImage(EGLDisplay dpy, EGLSurface surface, EGLi
(uintptr_t)dpy, (uintptr_t)surface, buffer);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
Surface *eglSurface = static_cast<Surface *>(surface);
gl::Context *context = thread->getContext();
gl::Texture *textureObject = nullptr;
egl::Display *display = static_cast<egl::Display *>(dpy);
Surface *eglSurface = static_cast<Surface *>(surface);
gl::Context *context = thread->getContext();
ANGLE_EGL_VALIDATE(thread, BindTexImage, GetSurfaceIfValid(display, eglSurface), EGL_FALSE,
display, eglSurface, surface, buffer, context, &textureObject);
display, eglSurface, buffer);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglBindTexImage",
GetDisplayIfValid(display), EGL_FALSE);
if (context)
{
gl::TextureType type =
egl_gl::EGLTextureTargetToTextureType(eglSurface->getTextureTarget());
gl::Texture *textureObject = context->getTextureByType(type);
ANGLE_EGL_TRY_RETURN(thread, eglSurface->bindTexImage(context, textureObject, buffer),
"eglBindTexImage", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
}
......@@ -684,7 +687,7 @@ EGLBoolean EGLAPIENTRY EGL_ReleaseTexImage(EGLDisplay dpy, EGLSurface surface, E
Surface *eglSurface = static_cast<Surface *>(surface);
ANGLE_EGL_VALIDATE(thread, ReleaseTexImage, GetSurfaceIfValid(display, eglSurface), EGL_FALSE,
display, eglSurface, surface, buffer);
display, eglSurface, buffer);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglReleaseTexImage",
GetDisplayIfValid(display), EGL_FALSE);
......@@ -706,14 +709,13 @@ EGLBoolean EGLAPIENTRY EGL_SwapInterval(EGLDisplay dpy, EGLint interval)
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLint interval = %d", (uintptr_t)dpy,
interval);
Thread *thread = egl::GetCurrentThread();
gl::Context *context = thread->getContext();
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
Surface *draw_surface = static_cast<Surface *>(thread->getCurrentDrawSurface());
ANGLE_EGL_VALIDATE(thread, SwapInterval, GetDisplayIfValid(display), EGL_FALSE, display,
draw_surface, context);
interval);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglSwapInterval",
GetDisplayIfValid(display), EGL_FALSE);
const egl::Config *surfaceConfig = draw_surface->getConfig();
......@@ -862,11 +864,10 @@ EGLSync EGLAPIENTRY EGL_CreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib
egl::Display *display = static_cast<egl::Display *>(dpy);
AttributeMap attributes = AttributeMap::CreateFromAttribArray(attrib_list);
gl::Context *currentContext = thread->getContext();
egl::Display *currentDisplay = currentContext ? currentContext->getDisplay() : nullptr;
gl::Context *currentContext = thread->getContext();
ANGLE_EGL_VALIDATE(thread, CreateSync, GetDisplayIfValid(display), EGL_NO_SYNC, display, type,
attributes, currentDisplay, currentContext);
attributes);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreateSync",
GetDisplayIfValid(display), EGL_FALSE);
egl::Sync *syncObject = nullptr;
......@@ -1016,10 +1017,11 @@ EGLDisplay EGLAPIENTRY EGL_GetPlatformDisplay(EGLenum platform,
platform, (uintptr_t)native_display, (uintptr_t)attrib_list);
Thread *thread = egl::GetCurrentThread();
const egl::AttributeMap &attribMap = AttributeMap::CreateFromAttribArray(attrib_list);
ANGLE_EGL_VALIDATE(thread, GetPlatformDisplay, GetThreadIfValid(thread), EGL_NO_DISPLAY,
platform, native_display, attrib_list);
platform, native_display, attribMap);
const auto &attribMap = AttributeMap::CreateFromAttribArray(attrib_list);
if (platform == EGL_PLATFORM_ANGLE_ANGLE)
{
return egl::Display::GetDisplayFromNativeDisplay(
......@@ -1057,8 +1059,8 @@ EGLSurface EGLAPIENTRY EGL_CreatePlatformWindowSurface(EGLDisplay dpy,
EGLNativeWindowType win = reinterpret_cast<EGLNativeWindowType>(native_window);
AttributeMap attributes = AttributeMap::CreateFromAttribArray(attrib_list);
ANGLE_EGL_VALIDATE(thread, CreateWindowSurface, GetDisplayIfValid(display), EGL_NO_SURFACE,
display, configuration, win, attributes);
ANGLE_EGL_VALIDATE(thread, CreatePlatformWindowSurface, GetDisplayIfValid(display),
EGL_NO_SURFACE, display, configuration, win, attributes);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreateWindowSurface",
GetDisplayIfValid(display), EGL_NO_SURFACE);
egl::Surface *surface = nullptr;
......@@ -1088,8 +1090,8 @@ EGLSurface EGLAPIENTRY EGL_CreatePlatformPixmapSurface(EGLDisplay dpy,
EGLNativePixmapType pixmap = reinterpret_cast<EGLNativePixmapType>(native_pixmap);
AttributeMap attributes = AttributeMap::CreateFromAttribArray(attrib_list);
ANGLE_EGL_VALIDATE(thread, CreatePixmapSurface, GetDisplayIfValid(display), EGL_NO_SURFACE,
display, configuration, pixmap, attributes);
ANGLE_EGL_VALIDATE(thread, CreatePlatformPixmapSurface, GetDisplayIfValid(display),
EGL_NO_SURFACE, display, configuration, pixmap, attributes);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreatePlatformPixmapSurface",
GetDisplayIfValid(display), EGL_NO_SURFACE);
egl::Surface *surface = nullptr;
......@@ -1110,11 +1112,10 @@ EGLBoolean EGLAPIENTRY EGL_WaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags)
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
gl::Context *context = thread->getContext();
egl::Sync *syncObject = static_cast<Sync *>(sync);
ANGLE_EGL_VALIDATE(thread, WaitSync, GetSyncIfValid(display, syncObject), EGL_FALSE, display,
context, syncObject, flags);
syncObject, flags);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglWaitSync",
GetDisplayIfValid(display), EGL_FALSE);
gl::Context *currentContext = thread->getContext();
......
src/libGLESv2/entry_points_egl_ext.cpp
......@@ -19,6 +19,7 @@
#include "libANGLE/entry_points_utils.h"
#include "libANGLE/queryutils.h"
#include "libANGLE/validationEGL.h"
#include "libANGLE/validationEGL_autogen.h"
#include "libGLESv2/global_state.h"
using namespace egl;
......@@ -101,10 +102,10 @@ EGLDisplay EGLAPIENTRY EGL_GetPlatformDisplayEXT(EGLenum platform,
platform, (uintptr_t)native_display, (uintptr_t)attrib_list);
Thread *thread = egl::GetCurrentThread();
const auto &attribMap = AttributeMap::CreateFromIntArray(attrib_list);
ANGLE_EGL_VALIDATE(thread, GetPlatformDisplayEXT, GetThreadIfValid(thread), EGL_NO_DISPLAY,
platform, native_display, attrib_list);
platform, native_display, attribMap);
const auto &attribMap = AttributeMap::CreateFromIntArray(attrib_list);
if (platform == EGL_PLATFORM_ANGLE_ANGLE)
{
return egl::Display::GetDisplayFromNativeDisplay(
......@@ -138,13 +139,14 @@ EGLSurface EGLAPIENTRY EGL_CreatePlatformWindowSurfaceEXT(EGLDisplay dpy,
egl::Display *display = static_cast<egl::Display *>(dpy);
Config *configuration = static_cast<Config *>(config);
AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
EGLNativeWindowType win = reinterpret_cast<EGLNativeWindowType>(native_window);
ANGLE_EGL_VALIDATE(thread, CreatePlatformWindowSurfaceEXT, GetDisplayIfValid(display),
EGL_NO_SURFACE, display, configuration, native_window, attributes);
EGL_NO_SURFACE, display, configuration, win, attributes);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreatePlatformWindowSurfaceEXT",
GetDisplayIfValid(display), EGL_NO_SURFACE);
thread->setError(EglBadDisplay() << "CreatePlatformWindowSurfaceEXT unimplemented.",
"eglCreatePlatformWindowSurfaceEXT", GetDisplayIfValid(display));
thread->setError(EGL_BAD_DISPLAY, "eglCreatePlatformWindowSurfaceEXT",
GetDisplayIfValid(display), "CreatePlatformWindowSurfaceEXT unimplemented.");
return EGL_NO_SURFACE;
}
......@@ -161,16 +163,17 @@ EGLSurface EGLAPIENTRY EGL_CreatePlatformPixmapSurfaceEXT(EGLDisplay dpy,
(uintptr_t)dpy, (uintptr_t)config, (uintptr_t)native_pixmap, (uintptr_t)attrib_list);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
Config *configuration = static_cast<Config *>(config);
AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
egl::Display *display = static_cast<egl::Display *>(dpy);
Config *configuration = static_cast<Config *>(config);
AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
EGLNativePixmapType pixmap = reinterpret_cast<EGLNativePixmapType>(native_pixmap);
ANGLE_EGL_VALIDATE(thread, CreatePlatformPixmapSurfaceEXT, GetDisplayIfValid(display),
EGL_NO_SURFACE, display, configuration, native_pixmap, attributes);
EGL_NO_SURFACE, display, configuration, pixmap, attributes);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreatePlatformPixmapSurfaceEXT",
GetDisplayIfValid(display), EGL_NO_SURFACE);
thread->setError(EglBadDisplay() << "CreatePlatformPixmapSurfaceEXT unimplemented.",
"eglCreatePlatformPixmapSurfaceEXT", GetDisplayIfValid(display));
thread->setError(EGL_BAD_DISPLAY, "eglCreatePlatformPixmapSurfaceEXT",
GetDisplayIfValid(display), "CreatePlatformPixmapSurfaceEXT unimplemented.");
return EGL_NO_SURFACE;
}
......@@ -238,7 +241,7 @@ EGLBoolean EGLAPIENTRY EGL_QueryDisplayAttribEXT(EGLDisplay dpy, EGLint attribut
Thread *thread = egl::GetCurrentThread();
ANGLE_EGL_VALIDATE(thread, QueryDisplayAttribEXT, GetDisplayIfValid(display), EGL_FALSE,
display, attribute);
display, attribute, value);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQueryDisplayAttribEXT",
GetDisplayIfValid(display), EGL_FALSE);
*value = display->queryAttrib(attribute);
......@@ -260,7 +263,7 @@ EGLBoolean EGLAPIENTRY EGL_QueryDisplayAttribANGLE(EGLDisplay dpy,
Thread *thread = egl::GetCurrentThread();
ANGLE_EGL_VALIDATE(thread, QueryDisplayAttribANGLE, GetDisplayIfValid(display), EGL_FALSE,
display, attribute);
display, attribute, value);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQueryDisplayAttribANGLE",
GetDisplayIfValid(display), EGL_FALSE);
*value = display->queryAttrib(attribute);
......@@ -516,17 +519,15 @@ EGLBoolean EGLAPIENTRY EGL_StreamConsumerGLTextureExternalKHR(EGLDisplay dpy, EG
egl::Display *display = static_cast<egl::Display *>(dpy);
Stream *streamObject = static_cast<Stream *>(stream);
gl::Context *context = gl::GetValidGlobalContext();
ANGLE_EGL_VALIDATE(thread, StreamConsumerGLTextureExternalKHR,
GetStreamIfValid(display, streamObject), EGL_FALSE, display, context,
streamObject);
GetStreamIfValid(display, streamObject), EGL_FALSE, display, streamObject);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglStreamConsumerGLTextureExternalKHR",
GetDisplayIfValid(display), EGL_FALSE);
ANGLE_EGL_TRY_RETURN(thread,
streamObject->createConsumerGLTextureExternal(AttributeMap(), context),
"eglStreamConsumerGLTextureExternalKHR",
GetStreamIfValid(display, streamObject), EGL_FALSE);
ANGLE_EGL_TRY_RETURN(
thread, streamObject->createConsumerGLTextureExternal(AttributeMap(), thread->getContext()),
"eglStreamConsumerGLTextureExternalKHR", GetStreamIfValid(display, streamObject),
EGL_FALSE);
thread->setSuccess();
return EGL_TRUE;
}
......@@ -540,13 +541,12 @@ EGLBoolean EGLAPIENTRY EGL_StreamConsumerAcquireKHR(EGLDisplay dpy, EGLStreamKHR
egl::Display *display = static_cast<egl::Display *>(dpy);
Stream *streamObject = static_cast<Stream *>(stream);
gl::Context *context = gl::GetValidGlobalContext();
ANGLE_EGL_VALIDATE(thread, StreamConsumerAcquireKHR, GetStreamIfValid(display, streamObject),
EGL_FALSE, display, context, streamObject);
EGL_FALSE, display, streamObject);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglStreamConsumerAcquireKHR",
GetDisplayIfValid(display), EGL_FALSE);
ANGLE_EGL_TRY_RETURN(thread, streamObject->consumerAcquire(context),
ANGLE_EGL_TRY_RETURN(thread, streamObject->consumerAcquire(thread->getContext()),
"eglStreamConsumerAcquireKHR", GetStreamIfValid(display, streamObject),
EGL_FALSE);
thread->setSuccess();
......@@ -565,7 +565,7 @@ EGLBoolean EGLAPIENTRY EGL_StreamConsumerReleaseKHR(EGLDisplay dpy, EGLStreamKHR
gl::Context *context = gl::GetValidGlobalContext();
ANGLE_EGL_VALIDATE(thread, StreamConsumerReleaseKHR, GetStreamIfValid(display, streamObject),
EGL_FALSE, display, context, streamObject);
EGL_FALSE, display, streamObject);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglStreamConsumerReleaseKHR",
GetDisplayIfValid(display), EGL_FALSE);
ANGLE_EGL_TRY_RETURN(thread, streamObject->consumerRelease(context),
......@@ -591,8 +591,8 @@ EGLBoolean EGLAPIENTRY EGL_StreamConsumerGLTextureExternalAttribsNV(EGLDisplay d
AttributeMap attributes = AttributeMap::CreateFromAttribArray(attrib_list);
ANGLE_EGL_VALIDATE(thread, StreamConsumerGLTextureExternalAttribsNV,
GetStreamIfValid(display, streamObject), EGL_FALSE, display, context,
streamObject, attributes);
GetStreamIfValid(display, streamObject), EGL_FALSE, display, streamObject,
attributes);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(),
"eglStreamConsumerGLTextureExternalAttribsNV", GetDisplayIfValid(display),
EGL_FALSE);
......@@ -672,15 +672,13 @@ ANGLE_EXPORT EGLSync EGLAPIENTRY EGL_CreateSyncKHR(EGLDisplay dpy,
egl::Display *display = static_cast<egl::Display *>(dpy);
AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
gl::Context *currentContext = thread->getContext();
egl::Display *currentDisplay = currentContext ? currentContext->getDisplay() : nullptr;
ANGLE_EGL_VALIDATE(thread, CreateSyncKHR, GetDisplayIfValid(display), EGL_NO_SYNC, display,
type, attributes, currentDisplay, currentContext);
type, attributes);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreateSync",
GetDisplayIfValid(display), EGL_NO_SYNC);
egl::Sync *syncObject = nullptr;
ANGLE_EGL_TRY_RETURN(thread, display->createSync(currentContext, type, attributes, &syncObject),
ANGLE_EGL_TRY_RETURN(thread,
display->createSync(thread->getContext(), type, attributes, &syncObject),
"eglCreateSync", GetDisplayIfValid(display), EGL_NO_SYNC);
thread->setSuccess();
......@@ -697,7 +695,7 @@ ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_DestroySyncKHR(EGLDisplay dpy, EGLSync s
egl::Display *display = static_cast<egl::Display *>(dpy);
egl::Sync *syncObject = static_cast<Sync *>(sync);
ANGLE_EGL_VALIDATE(thread, DestroySync, GetDisplayIfValid(display), EGL_FALSE, display,
ANGLE_EGL_VALIDATE(thread, DestroySyncKHR, GetDisplayIfValid(display), EGL_FALSE, display,
syncObject);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglDestroySync",
GetDisplayIfValid(display), EGL_FALSE);
......@@ -722,7 +720,7 @@ ANGLE_EXPORT EGLint EGLAPIENTRY EGL_ClientWaitSyncKHR(EGLDisplay dpy,
egl::Display *display = static_cast<egl::Display *>(dpy);
egl::Sync *syncObject = static_cast<Sync *>(sync);
ANGLE_EGL_VALIDATE(thread, ClientWaitSync, GetSyncIfValid(display, syncObject), EGL_FALSE,
ANGLE_EGL_VALIDATE(thread, ClientWaitSyncKHR, GetSyncIfValid(display, syncObject), EGL_FALSE,
display, syncObject, flags, timeout);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglClientWaitSync",
GetDisplayIfValid(display), EGL_FALSE);
......@@ -772,11 +770,10 @@ ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_WaitSyncKHR(EGLDisplay dpy, EGLSync sync
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
gl::Context *context = thread->getContext();
egl::Sync *syncObject = static_cast<Sync *>(sync);
ANGLE_EGL_VALIDATE(thread, WaitSync, GetSyncIfValid(display, syncObject), EGL_FALSE, display,
context, syncObject, flags);
ANGLE_EGL_VALIDATE(thread, WaitSyncKHR, GetSyncIfValid(display, syncObject), EGL_FALSE, display,
syncObject, flags);
ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglWaitSync",
GetDisplayIfValid(display), EGL_FALSE);
gl::Context *currentContext = thread->getContext();
......@@ -907,8 +904,8 @@ ANGLE_EXPORT void EGLAPIENTRY EGL_SetBlobCacheFuncsANDROID(EGLDisplay dpy,
egl::Display *display = static_cast<egl::Display *>(dpy);
ANGLE_EGL_VALIDATE_VOID(thread, SetBlobCacheANDROID, GetDisplayIfValid(display), display, set,
get);
ANGLE_EGL_VALIDATE_VOID(thread, SetBlobCacheFuncsANDROID, GetDisplayIfValid(display), display,
set, get);
ANGLE_EGL_TRY(thread, display->prepareForCall(), "eglSetBlobCacheFuncsANDROID",
GetDisplayIfValid(display));
thread->setSuccess();
......@@ -1072,7 +1069,7 @@ EGLint EGLAPIENTRY EGL_LabelObjectKHR(EGLDisplay dpy,
ObjectType objectTypePacked = FromEGLenum<ObjectType>(objectType);
ANGLE_EGL_VALIDATE(thread, LabelObjectKHR,
GetLabeledObjectIfValid(thread, display, objectTypePacked, object),
thread->getError(), thread, display, objectTypePacked, object, label);
thread->getError(), display, objectTypePacked, object, label);
LabeledObject *labeledObject =
GetLabeledObjectIfValid(thread, display, objectTypePacked, object);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment