blob: ce660dbaf2c09884db498ca6b2af0ee6358ddf27 [file] [log] [blame]
//
// Copyright 2014 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_points_ext.cpp : Implements the EGL extension entry points.
#include "libGLESv2/entry_points_egl_ext.h"
#include "common/debug.h"
#include "libANGLE/Context.h"
#include "libANGLE/Device.h"
#include "libANGLE/Display.h"
#include "libANGLE/EGLSync.h"
#include "libANGLE/Stream.h"
#include "libANGLE/Surface.h"
#include "libANGLE/Thread.h"
#include "libANGLE/entry_points_utils.h"
#include "libANGLE/queryutils.h"
#include "libANGLE/validationEGL.h"
#include "libGLESv2/global_state.h"
using namespace egl;
extern "C" {
// EGL_ANGLE_query_surface_pointer
EGLBoolean EGLAPIENTRY EGL_QuerySurfacePointerANGLE(EGLDisplay dpy,
EGLSurface surface,
EGLint attribute,
void **value)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
", EGLint attribute = %d, void "
"**value = 0x%016" PRIxPTR,
(uintptr_t)dpy, (uintptr_t)surface, attribute, (uintptr_t)value);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
Surface *eglSurface = static_cast<Surface *>(surface);
Error error = ValidateSurface(display, eglSurface);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglQuerySurfacePointerANGLE",
GetSurfaceIfValid(display, eglSurface));
return EGL_FALSE;
}
if (!display->getExtensions().querySurfacePointer)
{
thread->setSuccess();
return EGL_FALSE;
}
if (surface == EGL_NO_SURFACE)
{
thread->setError(EglBadSurface(), GetDebug(), "eglQuerySurfacePointerANGLE",
GetSurfaceIfValid(display, eglSurface));
return EGL_FALSE;
}
// validate the attribute parameter
switch (attribute)
{
case EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE:
if (!display->getExtensions().surfaceD3DTexture2DShareHandle)
{
thread->setError(EglBadAttribute(), GetDebug(), "eglQuerySurfacePointerANGLE",
GetSurfaceIfValid(display, eglSurface));
return EGL_FALSE;
}
break;
case EGL_DXGI_KEYED_MUTEX_ANGLE:
if (!display->getExtensions().keyedMutex)
{
thread->setError(EglBadAttribute(), GetDebug(), "eglQuerySurfacePointerANGLE",
GetSurfaceIfValid(display, eglSurface));
return EGL_FALSE;
}
break;
default:
thread->setError(EglBadAttribute(), GetDebug(), "eglQuerySurfacePointerANGLE",
GetSurfaceIfValid(display, eglSurface));
return EGL_FALSE;
}
error = eglSurface->querySurfacePointerANGLE(attribute, value);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglQuerySurfacePointerANGLE",
GetSurfaceIfValid(display, eglSurface));
return EGL_FALSE;
}
thread->setSuccess();
return EGL_TRUE;
}
// EGL_NV_post_sub_buffer
EGLBoolean EGLAPIENTRY EGL_PostSubBufferNV(EGLDisplay dpy,
EGLSurface surface,
EGLint x,
EGLint y,
EGLint width,
EGLint height)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
", EGLint x = %d, EGLint y = %d, "
"EGLint width = %d, EGLint height = %d",
(uintptr_t)dpy, (uintptr_t)surface, x, y, width, height);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
Surface *eglSurface = static_cast<Surface *>(surface);
if (x < 0 || y < 0 || width < 0 || height < 0)
{
thread->setError(EglBadParameter(), GetDebug(), "eglPostSubBufferNV",
GetSurfaceIfValid(display, eglSurface));
return EGL_FALSE;
}
Error error = ValidateSurface(display, eglSurface);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglPostSubBufferNV",
GetSurfaceIfValid(display, eglSurface));
return EGL_FALSE;
}
if (display->testDeviceLost())
{
thread->setError(EglContextLost(), GetDebug(), "eglPostSubBufferNV",
GetSurfaceIfValid(display, eglSurface));
return EGL_FALSE;
}
if (surface == EGL_NO_SURFACE)
{
thread->setError(EglBadSurface(), GetDebug(), "eglPostSubBufferNV",
GetSurfaceIfValid(display, eglSurface));
return EGL_FALSE;
}
if (!display->getExtensions().postSubBuffer)
{
// Spec is not clear about how this should be handled.
thread->setSuccess();
return EGL_TRUE;
}
// TODO(jmadill): Validate Surface is bound to the thread.
error = eglSurface->postSubBuffer(thread->getContext(), x, y, width, height);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglPostSubBufferNV",
GetSurfaceIfValid(display, eglSurface));
return EGL_FALSE;
}
thread->setSuccess();
return EGL_TRUE;
}
// EGL_EXT_platform_base
EGLDisplay EGLAPIENTRY EGL_GetPlatformDisplayEXT(EGLenum platform,
void *native_display,
const EGLint *attrib_list)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLenum platform = %d, void* native_display = 0x%016" PRIxPTR
", const EGLint* attrib_list = "
"0x%016" PRIxPTR,
platform, (uintptr_t)native_display, (uintptr_t)attrib_list);
Thread *thread = egl::GetCurrentThread();
Error err = ValidateGetPlatformDisplayEXT(platform, native_display, attrib_list);
thread->setError(err, GetDebug(), "eglGetPlatformDisplayEXT", GetThreadIfValid(thread));
if (err.isError())
{
return EGL_NO_DISPLAY;
}
const auto &attribMap = AttributeMap::CreateFromIntArray(attrib_list);
if (platform == EGL_PLATFORM_ANGLE_ANGLE)
{
return egl::Display::GetDisplayFromNativeDisplay(
gl::bitCast<EGLNativeDisplayType>(native_display), attribMap);
}
else if (platform == EGL_PLATFORM_DEVICE_EXT)
{
Device *eglDevice = static_cast<Device *>(native_display);
return egl::Display::GetDisplayFromDevice(eglDevice, attribMap);
}
else
{
UNREACHABLE();
return EGL_NO_DISPLAY;
}
}
EGLSurface EGLAPIENTRY EGL_CreatePlatformWindowSurfaceEXT(EGLDisplay dpy,
EGLConfig config,
void *native_window,
const EGLint *attrib_list)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLConfig config = 0x%016" PRIxPTR
", void *native_window = 0x%016" PRIxPTR
", "
"const EGLint *attrib_list = 0x%016" PRIxPTR,
(uintptr_t)dpy, (uintptr_t)config, (uintptr_t)native_window, (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);
ANGLE_EGL_TRY_RETURN(
thread,
ValidateCreatePlatformWindowSurfaceEXT(display, configuration, native_window, attributes),
"eglCreatePlatformWindowSurfaceEXT", GetDisplayIfValid(display), EGL_NO_SURFACE);
thread->setError(EglBadDisplay() << "CreatePlatformWindowSurfaceEXT unimplemented.", GetDebug(),
"eglCreatePlatformWindowSurfaceEXT", GetDisplayIfValid(display));
return EGL_NO_SURFACE;
}
EGLSurface EGLAPIENTRY EGL_CreatePlatformPixmapSurfaceEXT(EGLDisplay dpy,
EGLConfig config,
void *native_pixmap,
const EGLint *attrib_list)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLConfig config = 0x%016" PRIxPTR
", void *native_pixmap = 0x%016" PRIxPTR
", "
"const EGLint *attrib_list = 0x%016" PRIxPTR,
(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);
ANGLE_EGL_TRY_RETURN(
thread,
ValidateCreatePlatformPixmapSurfaceEXT(display, configuration, native_pixmap, attributes),
"eglCreatePlatformPixmapSurfaceEXT", GetDisplayIfValid(display), EGL_NO_SURFACE);
thread->setError(EglBadDisplay() << "CreatePlatformPixmapSurfaceEXT unimplemented.", GetDebug(),
"eglCreatePlatformPixmapSurfaceEXT", GetDisplayIfValid(display));
return EGL_NO_SURFACE;
}
// EGL_EXT_device_query
EGLBoolean EGLAPIENTRY EGL_QueryDeviceAttribEXT(EGLDeviceEXT device,
EGLint attribute,
EGLAttrib *value)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDeviceEXT device = 0x%016" PRIxPTR
", EGLint attribute = %d, EGLAttrib *value = 0x%016" PRIxPTR,
(uintptr_t)device, attribute, (uintptr_t)value);
Thread *thread = egl::GetCurrentThread();
Device *dev = static_cast<Device *>(device);
Error error = ValidateDevice(dev);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglQueryDeviceAttribEXT", GetDeviceIfValid(dev));
return EGL_FALSE;
}
// If the device was created by (and is owned by) a display, and that display doesn't support
// device querying, then this call should fail
egl::Display *owningDisplay = dev->getOwningDisplay();
if (owningDisplay != nullptr && !owningDisplay->getExtensions().deviceQuery)
{
thread->setError(EglBadAccess() << "Device wasn't created using eglCreateDeviceANGLE, "
"and the egl::Display that created it doesn't support "
"device querying",
GetDebug(), "eglQueryDeviceAttribEXT", GetDeviceIfValid(dev));
return EGL_FALSE;
}
// validate the attribute parameter
switch (attribute)
{
case EGL_D3D11_DEVICE_ANGLE:
case EGL_D3D9_DEVICE_ANGLE:
if (!dev->getExtensions().deviceD3D || dev->getType() != attribute)
{
thread->setError(EglBadAttribute(), GetDebug(), "eglQueryDeviceAttribEXT",
GetDeviceIfValid(dev));
return EGL_FALSE;
}
error = dev->getAttribute(attribute, value);
break;
case EGL_CGL_CONTEXT_ANGLE:
case EGL_CGL_PIXEL_FORMAT_ANGLE:
if (!dev->getExtensions().deviceCGL)
{
thread->setError(EglBadAttribute(), GetDebug(), "eglQueryDeviceAttribEXT",
GetDeviceIfValid(dev));
return EGL_FALSE;
}
error = dev->getAttribute(attribute, value);
break;
default:
thread->setError(EglBadAttribute(), GetDebug(), "eglQueryDeviceAttribEXT",
GetDeviceIfValid(dev));
return EGL_FALSE;
}
if (error.isError())
{
thread->setError(error, GetDebug(), "eglQueryDeviceAttribEXT", GetDeviceIfValid(dev));
return EGL_FALSE;
}
thread->setSuccess();
return EGL_TRUE;
}
// EGL_EXT_device_query
const char *EGLAPIENTRY EGL_QueryDeviceStringEXT(EGLDeviceEXT device, EGLint name)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDeviceEXT device = 0x%016" PRIxPTR ", EGLint name = %d", (uintptr_t)device,
name);
Thread *thread = egl::GetCurrentThread();
Device *dev = static_cast<Device *>(device);
Error error = ValidateDevice(dev);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglQueryDeviceStringEXT", GetDeviceIfValid(dev));
return EGL_FALSE;
}
const char *result;
switch (name)
{
case EGL_EXTENSIONS:
result = dev->getExtensionString().c_str();
break;
default:
thread->setError(EglBadDevice(), GetDebug(), "eglQueryDeviceStringEXT",
GetDeviceIfValid(dev));
return nullptr;
}
thread->setSuccess();
return result;
}
// EGL_EXT_device_query
EGLBoolean EGLAPIENTRY EGL_QueryDisplayAttribEXT(EGLDisplay dpy, EGLint attribute, EGLAttrib *value)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR
", EGLint attribute = %d, EGLAttrib *value = 0x%016" PRIxPTR,
(uintptr_t)dpy, attribute, (uintptr_t)value);
egl::Display *display = static_cast<egl::Display *>(dpy);
Thread *thread = egl::GetCurrentThread();
ANGLE_EGL_TRY_RETURN(thread, ValidateQueryDisplayAttribEXT(display, attribute),
"eglQueryDisplayAttribEXT", GetDisplayIfValid(display), EGL_FALSE);
*value = display->queryAttrib(attribute);
thread->setSuccess();
return EGL_TRUE;
}
// EGL_ANGLE_feature_control
EGLBoolean EGLAPIENTRY EGL_QueryDisplayAttribANGLE(EGLDisplay dpy,
EGLint attribute,
EGLAttrib *value)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR
", EGLint attribute = %d, EGLAttrib *value = 0x%016" PRIxPTR,
(uintptr_t)dpy, attribute, (uintptr_t)value);
egl::Display *display = static_cast<egl::Display *>(dpy);
Thread *thread = egl::GetCurrentThread();
ANGLE_EGL_TRY_RETURN(thread, ValidateQueryDisplayAttribANGLE(display, attribute),
"eglQueryDisplayAttribANGLE", GetDisplayIfValid(display), EGL_FALSE);
*value = display->queryAttrib(attribute);
thread->setSuccess();
return EGL_TRUE;
}
ANGLE_EXPORT EGLImageKHR EGLAPIENTRY EGL_CreateImageKHR(EGLDisplay dpy,
EGLContext ctx,
EGLenum target,
EGLClientBuffer buffer,
const EGLint *attrib_list)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR
", EGLContext ctx = %d"
", EGLenum target = 0x%X, "
"EGLClientBuffer buffer = 0x%016" PRIxPTR
", const EGLAttrib *attrib_list = 0x%016" PRIxPTR,
(uintptr_t)dpy, CID(dpy, ctx), target, (uintptr_t)buffer, (uintptr_t)attrib_list);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
gl::Context *context = static_cast<gl::Context *>(ctx);
AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
Error error = ValidateCreateImageKHR(display, context, target, buffer, attributes);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglCreateImageKHR", GetDisplayIfValid(display));
return EGL_NO_IMAGE;
}
Image *image = nullptr;
error = display->createImage(context, target, buffer, attributes, &image);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglCreateImageKHR", GetDisplayIfValid(display));
return EGL_NO_IMAGE;
}
thread->setSuccess();
return static_cast<EGLImage>(image);
}
ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_DestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLImage image = 0x%016" PRIxPTR,
(uintptr_t)dpy, (uintptr_t)image);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
Image *img = static_cast<Image *>(image);
Error error = ValidateDestroyImageKHR(display, img);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglDestroyImageKHR", GetImageIfValid(display, img));
return EGL_FALSE;
}
display->destroyImage(img);
thread->setSuccess();
return EGL_TRUE;
}
ANGLE_EXPORT EGLDeviceEXT EGLAPIENTRY EGL_CreateDeviceANGLE(EGLint device_type,
void *native_device,
const EGLAttrib *attrib_list)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLint device_type = %d, void* native_device = 0x%016" PRIxPTR
", const EGLAttrib* attrib_list = "
"0x%016" PRIxPTR,
device_type, (uintptr_t)native_device, (uintptr_t)attrib_list);
Thread *thread = egl::GetCurrentThread();
Error error = ValidateCreateDeviceANGLE(device_type, native_device, attrib_list);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglCreateDeviceANGLE", GetThreadIfValid(thread));
return EGL_NO_DEVICE_EXT;
}
Device *device = nullptr;
error = Device::CreateDevice(device_type, native_device, &device);
if (error.isError())
{
ASSERT(device == nullptr);
thread->setError(error, GetDebug(), "eglCreateDeviceANGLE", GetThreadIfValid(thread));
return EGL_NO_DEVICE_EXT;
}
thread->setSuccess();
return device;
}
ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_ReleaseDeviceANGLE(EGLDeviceEXT device)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDeviceEXT device = 0x%016" PRIxPTR, (uintptr_t)device);
Thread *thread = egl::GetCurrentThread();
Device *dev = static_cast<Device *>(device);
Error error = ValidateReleaseDeviceANGLE(dev);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglReleaseDeviceANGLE", GetDeviceIfValid(dev));
return EGL_FALSE;
}
SafeDelete(dev);
thread->setSuccess();
return EGL_TRUE;
}
// EGL_KHR_stream
EGLStreamKHR EGLAPIENTRY EGL_CreateStreamKHR(EGLDisplay dpy, const EGLint *attrib_list)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", const EGLAttrib* attrib_list = 0x%016" PRIxPTR,
(uintptr_t)dpy, (uintptr_t)attrib_list);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
Error error = ValidateCreateStreamKHR(display, attributes);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglCreateStreamKHR", GetDisplayIfValid(display));
return EGL_NO_STREAM_KHR;
}
Stream *stream;
error = display->createStream(attributes, &stream);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglCreateStreamKHR", GetDisplayIfValid(display));
return EGL_NO_STREAM_KHR;
}
thread->setSuccess();
return static_cast<EGLStreamKHR>(stream);
}
EGLBoolean EGLAPIENTRY EGL_DestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLStreamKHR = 0x%016" PRIxPTR, (uintptr_t)dpy,
(uintptr_t)stream);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
Stream *streamObject = static_cast<Stream *>(stream);
Error error = ValidateDestroyStreamKHR(display, streamObject);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglDestroyStreamKHR",
GetStreamIfValid(display, streamObject));
return EGL_FALSE;
}
display->destroyStream(streamObject);
thread->setSuccess();
return EGL_TRUE;
}
EGLBoolean EGLAPIENTRY EGL_StreamAttribKHR(EGLDisplay dpy,
EGLStreamKHR stream,
EGLenum attribute,
EGLint value)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLStreamKHR stream = 0x%016" PRIxPTR
", EGLenum attribute = 0x%X, "
"EGLint value = 0x%X",
(uintptr_t)dpy, (uintptr_t)stream, attribute, value);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
Stream *streamObject = static_cast<Stream *>(stream);
Error error = ValidateStreamAttribKHR(display, streamObject, attribute, value);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglStreamAttribKHR",
GetStreamIfValid(display, streamObject));
return EGL_FALSE;
}
switch (attribute)
{
case EGL_CONSUMER_LATENCY_USEC_KHR:
streamObject->setConsumerLatency(value);
break;
case EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR:
streamObject->setConsumerAcquireTimeout(value);
break;
default:
UNREACHABLE();
}
thread->setSuccess();
return EGL_TRUE;
}
EGLBoolean EGLAPIENTRY EGL_QueryStreamKHR(EGLDisplay dpy,
EGLStreamKHR stream,
EGLenum attribute,
EGLint *value)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLStreamKHR stream = 0x%016" PRIxPTR
", EGLenum attribute = 0x%X, "
"EGLint value = 0x%016" PRIxPTR,
(uintptr_t)dpy, (uintptr_t)stream, attribute, (uintptr_t)value);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
Stream *streamObject = static_cast<Stream *>(stream);
Error error = ValidateQueryStreamKHR(display, streamObject, attribute, value);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglQueryStreamKHR",
GetStreamIfValid(display, streamObject));
return EGL_FALSE;
}
switch (attribute)
{
case EGL_STREAM_STATE_KHR:
*value = streamObject->getState();
break;
case EGL_CONSUMER_LATENCY_USEC_KHR:
*value = streamObject->getConsumerLatency();
break;
case EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR:
*value = streamObject->getConsumerAcquireTimeout();
break;
default:
UNREACHABLE();
}
thread->setSuccess();
return EGL_TRUE;
}
EGLBoolean EGLAPIENTRY EGL_QueryStreamu64KHR(EGLDisplay dpy,
EGLStreamKHR stream,
EGLenum attribute,
EGLuint64KHR *value)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLStreamKHR stream = 0x%016" PRIxPTR
", EGLenum attribute = 0x%X, "
"EGLuint64KHR value = 0x%016" PRIxPTR,
(uintptr_t)dpy, (uintptr_t)stream, attribute, (uintptr_t)value);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
Stream *streamObject = static_cast<Stream *>(stream);
Error error = ValidateQueryStreamu64KHR(display, streamObject, attribute, value);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglQueryStreamu64KHR",
GetStreamIfValid(display, streamObject));
return EGL_FALSE;
}
switch (attribute)
{
case EGL_PRODUCER_FRAME_KHR:
*value = streamObject->getProducerFrame();
break;
case EGL_CONSUMER_FRAME_KHR:
*value = streamObject->getConsumerFrame();
break;
default:
UNREACHABLE();
}
thread->setSuccess();
return EGL_TRUE;
}
EGLBoolean EGLAPIENTRY EGL_StreamConsumerGLTextureExternalKHR(EGLDisplay dpy, EGLStreamKHR stream)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLStreamKHR = 0x%016" PRIxPTR, (uintptr_t)dpy,
(uintptr_t)stream);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
Stream *streamObject = static_cast<Stream *>(stream);
gl::Context *context = gl::GetValidGlobalContext();
Error error = ValidateStreamConsumerGLTextureExternalKHR(display, context, streamObject);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglStreamConsumerGLTextureExternalKHR",
GetStreamIfValid(display, streamObject));
return EGL_FALSE;
}
error = streamObject->createConsumerGLTextureExternal(AttributeMap(), context);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglStreamConsumerGLTextureExternalKHR",
GetStreamIfValid(display, streamObject));
return EGL_FALSE;
}
thread->setSuccess();
return EGL_TRUE;
}
EGLBoolean EGLAPIENTRY EGL_StreamConsumerAcquireKHR(EGLDisplay dpy, EGLStreamKHR stream)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLStreamKHR = 0x%016" PRIxPTR, (uintptr_t)dpy,
(uintptr_t)stream);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
Stream *streamObject = static_cast<Stream *>(stream);
gl::Context *context = gl::GetValidGlobalContext();
Error error = ValidateStreamConsumerAcquireKHR(display, context, streamObject);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglStreamConsumerAcquireKHR",
GetStreamIfValid(display, streamObject));
return EGL_FALSE;
}
error = streamObject->consumerAcquire(context);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglStreamConsumerAcquireKHR",
GetStreamIfValid(display, streamObject));
return EGL_FALSE;
}
thread->setSuccess();
return EGL_TRUE;
}
EGLBoolean EGLAPIENTRY EGL_StreamConsumerReleaseKHR(EGLDisplay dpy, EGLStreamKHR stream)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLStreamKHR = 0x%016" PRIxPTR, (uintptr_t)dpy,
(uintptr_t)stream);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
Stream *streamObject = static_cast<Stream *>(stream);
gl::Context *context = gl::GetValidGlobalContext();
Error error = ValidateStreamConsumerReleaseKHR(display, context, streamObject);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglSStreamConsumerReleaseKHR",
GetStreamIfValid(display, streamObject));
return EGL_FALSE;
}
error = streamObject->consumerRelease(context);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglStreamConsumerReleaseKHR",
GetStreamIfValid(display, streamObject));
return EGL_FALSE;
}
thread->setSuccess();
return EGL_TRUE;
}
EGLBoolean EGLAPIENTRY EGL_StreamConsumerGLTextureExternalAttribsNV(EGLDisplay dpy,
EGLStreamKHR stream,
const EGLAttrib *attrib_list)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLStreamKHR stream = 0x%016" PRIxPTR
", EGLAttrib attrib_list = 0x%016" PRIxPTR "",
(uintptr_t)dpy, (uintptr_t)stream, (uintptr_t)attrib_list);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
Stream *streamObject = static_cast<Stream *>(stream);
gl::Context *context = gl::GetValidGlobalContext();
AttributeMap attributes = AttributeMap::CreateFromAttribArray(attrib_list);
Error error = ValidateStreamConsumerGLTextureExternalAttribsNV(display, context, streamObject,
attributes);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglStreamConsumerGLTextureExternalAttribsNV",
GetStreamIfValid(display, streamObject));
return EGL_FALSE;
}
error = streamObject->createConsumerGLTextureExternal(attributes, context);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglStreamConsumerGLTextureExternalAttribsNV",
GetStreamIfValid(display, streamObject));
return EGL_FALSE;
}
thread->setSuccess();
return EGL_TRUE;
}
EGLBoolean EGLAPIENTRY EGL_CreateStreamProducerD3DTextureANGLE(EGLDisplay dpy,
EGLStreamKHR stream,
const EGLAttrib *attrib_list)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLStreamKHR stream = 0x%016" PRIxPTR
", EGLAttrib attrib_list = 0x%016" PRIxPTR "",
(uintptr_t)dpy, (uintptr_t)stream, (uintptr_t)attrib_list);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
Stream *streamObject = static_cast<Stream *>(stream);
AttributeMap attributes = AttributeMap::CreateFromAttribArray(attrib_list);
Error error = ValidateCreateStreamProducerD3DTextureANGLE(display, streamObject, attributes);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglCreateStreamProducerD3DTextureANGLE",
GetStreamIfValid(display, streamObject));
return EGL_FALSE;
}
error = streamObject->createProducerD3D11Texture(attributes);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglCreateStreamProducerD3DTextureANGLE",
GetStreamIfValid(display, streamObject));
return EGL_FALSE;
}
thread->setSuccess();
return EGL_TRUE;
}
EGLBoolean EGLAPIENTRY EGL_StreamPostD3DTextureANGLE(EGLDisplay dpy,
EGLStreamKHR stream,
void *texture,
const EGLAttrib *attrib_list)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLStreamKHR stream = 0x%016" PRIxPTR
", void* texture = 0x%016" PRIxPTR
", "
"EGLAttrib attrib_list = 0x%016" PRIxPTR "",
(uintptr_t)dpy, (uintptr_t)stream, (uintptr_t)texture, (uintptr_t)attrib_list);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
Stream *streamObject = static_cast<Stream *>(stream);
AttributeMap attributes = AttributeMap::CreateFromAttribArray(attrib_list);
Error error = ValidateStreamPostD3DTextureANGLE(display, streamObject, texture, attributes);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglStreamPostD3DTextureANGLE",
GetStreamIfValid(display, streamObject));
return EGL_FALSE;
}
error = streamObject->postD3D11Texture(texture, attributes);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglStreamPostD3DTextureANGLE",
GetStreamIfValid(display, streamObject));
return EGL_FALSE;
}
thread->setSuccess();
return EGL_TRUE;
}
// EGL_KHR_fence_sync
ANGLE_EXPORT EGLSync EGLAPIENTRY EGL_CreateSyncKHR(EGLDisplay dpy,
EGLenum type,
const EGLint *attrib_list)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR
", EGLenum type = 0x%X, const EGLint* attrib_list = 0x%016" PRIxPTR,
(uintptr_t)dpy, type, (uintptr_t)attrib_list);
Thread *thread = egl::GetCurrentThread();
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_TRY_RETURN(
thread, ValidateCreateSyncKHR(display, type, attributes, currentDisplay, currentContext),
"eglCreateSync", GetDisplayIfValid(display), EGL_NO_SYNC);
egl::Sync *syncObject = nullptr;
ANGLE_EGL_TRY_RETURN(thread, display->createSync(currentContext, type, attributes, &syncObject),
"eglCreateSync", GetDisplayIfValid(display), EGL_NO_SYNC);
thread->setSuccess();
return static_cast<EGLSync>(syncObject);
}
ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_DestroySyncKHR(EGLDisplay dpy, EGLSync sync)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSync sync = 0x%016" PRIxPTR, (uintptr_t)dpy,
(uintptr_t)sync);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
egl::Sync *syncObject = static_cast<Sync *>(sync);
ANGLE_EGL_TRY_RETURN(thread, ValidateDestroySync(display, syncObject), "eglDestroySync",
GetDisplayIfValid(display), EGL_FALSE);
display->destroySync(syncObject);
thread->setSuccess();
return EGL_TRUE;
}
ANGLE_EXPORT EGLint EGLAPIENTRY EGL_ClientWaitSyncKHR(EGLDisplay dpy,
EGLSync sync,
EGLint flags,
EGLTime timeout)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSync sync = 0x%016" PRIxPTR
", EGLint flags = 0x%X, EGLTime timeout = "
"%llu",
(uintptr_t)dpy, (uintptr_t)sync, flags, static_cast<unsigned long long>(timeout));
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
egl::Sync *syncObject = static_cast<Sync *>(sync);
ANGLE_EGL_TRY_RETURN(thread, ValidateClientWaitSync(display, syncObject, flags, timeout),
"eglClientWaitSync", GetSyncIfValid(display, syncObject), EGL_FALSE);
gl::Context *currentContext = thread->getContext();
EGLint syncStatus = EGL_FALSE;
ANGLE_EGL_TRY_RETURN(
thread, syncObject->clientWait(display, currentContext, flags, timeout, &syncStatus),
"eglClientWaitSync", GetSyncIfValid(display, syncObject), EGL_FALSE);
thread->setSuccess();
return syncStatus;
}
ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetSyncAttribKHR(EGLDisplay dpy,
EGLSync sync,
EGLint attribute,
EGLint *value)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSync sync = 0x%016" PRIxPTR
", EGLint attribute = 0x%X, EGLAttrib "
"*value = 0x%016" PRIxPTR,
(uintptr_t)dpy, (uintptr_t)sync, attribute, (uintptr_t)value);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
egl::Sync *syncObject = static_cast<Sync *>(sync);
ANGLE_EGL_TRY_RETURN(thread, ValidateGetSyncAttribKHR(display, syncObject, attribute, value),
"eglGetSyncAttrib", GetSyncIfValid(display, syncObject), EGL_FALSE);
ANGLE_EGL_TRY_RETURN(thread, GetSyncAttrib(display, syncObject, attribute, value),
"eglGetSyncAttrib", GetSyncIfValid(display, syncObject), EGL_FALSE);
thread->setSuccess();
return EGL_TRUE;
}
// EGL_KHR_wait_sync
ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_WaitSyncKHR(EGLDisplay dpy, EGLSync sync, EGLint flags)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR "p, EGLSync sync = 0x%016" PRIxPTR
", EGLint flags = 0x%X",
(uintptr_t)dpy, (uintptr_t)sync, 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_TRY_RETURN(thread, ValidateWaitSync(display, context, syncObject, flags),
"eglWaitSync", GetSyncIfValid(display, syncObject), EGL_FALSE);
gl::Context *currentContext = thread->getContext();
ANGLE_EGL_TRY_RETURN(thread, syncObject->serverWait(display, currentContext, flags),
"eglWaitSync", GetSyncIfValid(display, syncObject), EGL_FALSE);
thread->setSuccess();
return EGL_TRUE;
}
EGLBoolean EGLAPIENTRY EGL_GetSyncValuesCHROMIUM(EGLDisplay dpy,
EGLSurface surface,
EGLuint64KHR *ust,
EGLuint64KHR *msc,
EGLuint64KHR *sbc)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
", EGLuint64KHR* ust = 0x%016" PRIxPTR
", "
"EGLuint64KHR* msc = 0x%016" PRIxPTR ", EGLuint64KHR* sbc = 0x%016" PRIxPTR "",
(uintptr_t)dpy, (uintptr_t)surface, (uintptr_t)ust, (uintptr_t)msc, (uintptr_t)sbc);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
Surface *eglSurface = static_cast<Surface *>(surface);
Error error = ValidateGetSyncValuesCHROMIUM(display, eglSurface, ust, msc, sbc);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglGetSyncValuesCHROMIUM",
GetSurfaceIfValid(display, eglSurface));
return EGL_FALSE;
}
error = eglSurface->getSyncValues(ust, msc, sbc);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglGetSyncValuesCHROMIUM",
GetSurfaceIfValid(display, eglSurface));
return EGL_FALSE;
}
thread->setSuccess();
return EGL_TRUE;
}
EGLBoolean EGLAPIENTRY EGL_SwapBuffersWithDamageKHR(EGLDisplay dpy,
EGLSurface surface,
EGLint *rects,
EGLint n_rects)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
", EGLint *rects = 0x%016" PRIxPTR
", EGLint "
"n_rects = %d",
(uintptr_t)dpy, (uintptr_t)surface, (uintptr_t)rects, n_rects);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
Surface *eglSurface = static_cast<Surface *>(surface);
Error error = ValidateSwapBuffersWithDamageKHR(display, eglSurface, rects, n_rects);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglSwapBuffersWithDamageEXT",
GetSurfaceIfValid(display, eglSurface));
return EGL_FALSE;
}
error = eglSurface->swapWithDamage(thread->getContext(), rects, n_rects);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglSwapBuffersWithDamageEXT",
GetSurfaceIfValid(display, eglSurface));
return EGL_FALSE;
}
thread->setSuccess();
return EGL_TRUE;
}
EGLBoolean EGLAPIENTRY EGL_PresentationTimeANDROID(EGLDisplay dpy,
EGLSurface surface,
EGLnsecsANDROID time)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
", EGLnsecsANDROID time = %llu",
(uintptr_t)dpy, (uintptr_t)surface, static_cast<unsigned long long>(time));
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
Surface *eglSurface = static_cast<Surface *>(surface);
ANGLE_EGL_TRY_RETURN(thread, ValidatePresentationTimeANDROID(display, eglSurface, time),
"eglPresentationTimeANDROID", GetSurfaceIfValid(display, eglSurface),
EGL_FALSE);
ANGLE_EGL_TRY_RETURN(thread, eglSurface->setPresentationTime(time),
"eglPresentationTimeANDROID", GetSurfaceIfValid(display, eglSurface),
EGL_FALSE);
return EGL_TRUE;
}
ANGLE_EXPORT void EGLAPIENTRY EGL_SetBlobCacheFuncsANDROID(EGLDisplay dpy,
EGLSetBlobFuncANDROID set,
EGLGetBlobFuncANDROID get)
{
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSetBlobFuncANDROID set = 0x%016" PRIxPTR
", EGLGetBlobFuncANDROID get "
"= 0x%016" PRIxPTR,
(uintptr_t)dpy, (uintptr_t)set, (uintptr_t)get);
Thread *thread = egl::GetCurrentThread();
egl::Display *display = static_cast<egl::Display *>(dpy);
ANGLE_EGL_TRY(thread, ValidateSetBlobCacheANDROID(display, set, get),
"eglSetBlobCacheFuncsANDROID", GetDisplayIfValid(display));
thread->setSuccess();
display->setBlobCacheFuncs(set, get);
}
EGLint EGLAPIENTRY EGL_ProgramCacheGetAttribANGLE(EGLDisplay dpy, EGLenum attrib)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLenum attrib = 0x%X", (uintptr_t)dpy, attrib);
egl::Display *display = static_cast<egl::Display *>(dpy);
Thread *thread = egl::GetCurrentThread();
ANGLE_EGL_TRY_RETURN(thread, ValidateProgramCacheGetAttribANGLE(display, attrib),
"eglProgramCacheGetAttribANGLE", GetDisplayIfValid(display), 0);
thread->setSuccess();
return display->programCacheGetAttrib(attrib);
}
void EGLAPIENTRY EGL_ProgramCacheQueryANGLE(EGLDisplay dpy,
EGLint index,
void *key,
EGLint *keysize,
void *binary,
EGLint *binarysize)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLint index = %d, void *key = 0x%016" PRIxPTR
", EGLint *keysize = "
"0x%016" PRIxPTR ", void *binary = 0x%016" PRIxPTR ", EGLint *size = 0x%016" PRIxPTR,
(uintptr_t)dpy, index, (uintptr_t)key, (uintptr_t)keysize, (uintptr_t)binary,
(uintptr_t)binarysize);
egl::Display *display = static_cast<egl::Display *>(dpy);
Thread *thread = egl::GetCurrentThread();
ANGLE_EGL_TRY(thread,
ValidateProgramCacheQueryANGLE(display, index, key, keysize, binary, binarysize),
"eglProgramCacheQueryANGLE", GetDisplayIfValid(display));
ANGLE_EGL_TRY(thread, display->programCacheQuery(index, key, keysize, binary, binarysize),
"eglProgramCacheQueryANGLE", GetDisplayIfValid(display));
thread->setSuccess();
}
void EGLAPIENTRY EGL_ProgramCachePopulateANGLE(EGLDisplay dpy,
const void *key,
EGLint keysize,
const void *binary,
EGLint binarysize)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", void *key = 0x%016" PRIxPTR
", EGLint keysize = %d, void *binary = "
"0x%016" PRIxPTR ", EGLint size = %d",
(uintptr_t)dpy, (uintptr_t)key, keysize, (uintptr_t)binary, binarysize);
egl::Display *display = static_cast<egl::Display *>(dpy);
Thread *thread = egl::GetCurrentThread();
ANGLE_EGL_TRY(thread,
ValidateProgramCachePopulateANGLE(display, key, keysize, binary, binarysize),
"eglProgramCachePopulateANGLE", GetDisplayIfValid(display));
ANGLE_EGL_TRY(thread, display->programCachePopulate(key, keysize, binary, binarysize),
"eglProgramCachePopulateANGLE", GetDisplayIfValid(display));
thread->setSuccess();
}
EGLint EGLAPIENTRY EGL_ProgramCacheResizeANGLE(EGLDisplay dpy, EGLint limit, EGLenum mode)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLint limit = %d, EGLenum mode = 0x%X",
(uintptr_t)dpy, limit, mode);
egl::Display *display = static_cast<egl::Display *>(dpy);
Thread *thread = egl::GetCurrentThread();
ANGLE_EGL_TRY_RETURN(thread, ValidateProgramCacheResizeANGLE(display, limit, mode),
"eglProgramCacheResizeANGLE", GetDisplayIfValid(display), 0);
thread->setSuccess();
return display->programCacheResize(limit, mode);
}
EGLint EGLAPIENTRY EGL_DebugMessageControlKHR(EGLDEBUGPROCKHR callback,
const EGLAttrib *attrib_list)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDEBUGPROCKHR callback = 0x%016" PRIxPTR
", EGLAttrib attrib_list = 0x%016" PRIxPTR,
(uintptr_t)callback, (uintptr_t)attrib_list);
Thread *thread = egl::GetCurrentThread();
AttributeMap attributes = AttributeMap::CreateFromAttribArray(attrib_list);
Error error = ValidateDebugMessageControlKHR(callback, attributes);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglDebugMessageControlKHR", nullptr);
return error.getCode();
}
Debug *debug = GetDebug();
debug->setCallback(callback, attributes);
thread->setSuccess();
return EGL_SUCCESS;
}
EGLBoolean EGLAPIENTRY EGL_QueryDebugKHR(EGLint attribute, EGLAttrib *value)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLint attribute = 0x%X, EGLAttrib* value = 0x%016" PRIxPTR, attribute,
(uintptr_t)value);
Thread *thread = egl::GetCurrentThread();
Error error = ValidateQueryDebugKHR(attribute, value);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglQueryDebugKHR", nullptr);
return EGL_FALSE;
}
Debug *debug = GetDebug();
switch (attribute)
{
case EGL_DEBUG_MSG_CRITICAL_KHR:
case EGL_DEBUG_MSG_ERROR_KHR:
case EGL_DEBUG_MSG_WARN_KHR:
case EGL_DEBUG_MSG_INFO_KHR:
*value = debug->isMessageTypeEnabled(FromEGLenum<MessageType>(attribute)) ? EGL_TRUE
: EGL_FALSE;
break;
case EGL_DEBUG_CALLBACK_KHR:
*value = reinterpret_cast<EGLAttrib>(debug->getCallback());
break;
default:
UNREACHABLE();
}
thread->setSuccess();
return EGL_TRUE;
}
EGLint EGLAPIENTRY EGL_LabelObjectKHR(EGLDisplay dpy,
EGLenum objectType,
EGLObjectKHR object,
EGLLabelKHR label)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR
", EGLenum objectType = 0x%X, EGLObjectKHR object = 0x%016" PRIxPTR
", "
"EGLLabelKHR label = 0x%016" PRIxPTR,
(uintptr_t)dpy, objectType, (uintptr_t)object, (uintptr_t)label);
egl::Display *display = static_cast<egl::Display *>(dpy);
Thread *thread = egl::GetCurrentThread();
ObjectType objectTypePacked = FromEGLenum<ObjectType>(objectType);
Error error = ValidateLabelObjectKHR(thread, display, objectTypePacked, object, label);
if (error.isError())
{
thread->setError(error, GetDebug(), "eglLabelObjectKHR",
GetLabeledObjectIfValid(thread, display, objectTypePacked, object));
return error.getCode();
}
LabeledObject *labeledObject =
GetLabeledObjectIfValid(thread, display, objectTypePacked, object);
ASSERT(labeledObject != nullptr);
labeledObject->setLabel(label);
thread->setSuccess();
return EGL_SUCCESS;
}
ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetCompositorTimingSupportedANDROID(EGLDisplay dpy,
EGLSurface surface,
EGLint name)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
", EGLint name = 0x%X",
(uintptr_t)dpy, (uintptr_t)surface, name);
egl::Display *display = static_cast<egl::Display *>(dpy);
Surface *eglSurface = static_cast<Surface *>(surface);
Thread *thread = egl::GetCurrentThread();
CompositorTiming nameInternal = FromEGLenum<CompositorTiming>(name);
ANGLE_EGL_TRY_RETURN(
thread, ValidateGetCompositorTimingSupportedANDROID(display, eglSurface, nameInternal),
"eglQueryTimestampSupportedANDROID", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
thread->setSuccess();
return eglSurface->getSupportedCompositorTimings().test(nameInternal);
}
ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetCompositorTimingANDROID(EGLDisplay dpy,
EGLSurface surface,
EGLint numTimestamps,
const EGLint *names,
EGLnsecsANDROID *values)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
", EGLint numTimestamps = %d, const EGLint *names = 0x%016" PRIxPTR
", EGLnsecsANDROID *values = 0x%016" PRIxPTR,
(uintptr_t)dpy, (uintptr_t)surface, numTimestamps, (uintptr_t)names,
(uintptr_t)values);
egl::Display *display = static_cast<egl::Display *>(dpy);
Surface *eglSurface = static_cast<Surface *>(surface);
Thread *thread = egl::GetCurrentThread();
ANGLE_EGL_TRY_RETURN(
thread,
ValidateGetCompositorTimingANDROID(display, eglSurface, numTimestamps, names, values),
"eglGetCompositorTimingANDROIDD", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
ANGLE_EGL_TRY_RETURN(thread, eglSurface->getCompositorTiming(numTimestamps, names, values),
"eglGetCompositorTimingANDROIDD", GetSurfaceIfValid(display, eglSurface),
EGL_FALSE);
thread->setSuccess();
return EGL_TRUE;
}
ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetNextFrameIdANDROID(EGLDisplay dpy,
EGLSurface surface,
EGLuint64KHR *frameId)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
", EGLuint64KHR *frameId = 0x%016" PRIxPTR,
(uintptr_t)dpy, (uintptr_t)surface, (uintptr_t)frameId);
egl::Display *display = static_cast<egl::Display *>(dpy);
Surface *eglSurface = static_cast<Surface *>(surface);
Thread *thread = egl::GetCurrentThread();
ANGLE_EGL_TRY_RETURN(thread, ValidateGetNextFrameIdANDROID(display, eglSurface, frameId),
"eglGetNextFrameIdANDROID", GetSurfaceIfValid(display, eglSurface),
EGL_FALSE);
ANGLE_EGL_TRY_RETURN(thread, eglSurface->getNextFrameId(frameId), "eglGetNextFrameIdANDROID",
GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
thread->setSuccess();
return EGL_TRUE;
}
ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetFrameTimestampSupportedANDROID(EGLDisplay dpy,
EGLSurface surface,
EGLint timestamp)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
", EGLint timestamp = 0x%X",
(uintptr_t)dpy, (uintptr_t)surface, timestamp);
egl::Display *display = static_cast<egl::Display *>(dpy);
Surface *eglSurface = static_cast<Surface *>(surface);
Thread *thread = egl::GetCurrentThread();
Timestamp timestampInternal = FromEGLenum<Timestamp>(timestamp);
ANGLE_EGL_TRY_RETURN(
thread, ValidateGetFrameTimestampSupportedANDROID(display, eglSurface, timestampInternal),
"eglQueryTimestampSupportedANDROID", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
thread->setSuccess();
return eglSurface->getSupportedTimestamps().test(timestampInternal);
}
ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetFrameTimestampsANDROID(EGLDisplay dpy,
EGLSurface surface,
EGLuint64KHR frameId,
EGLint numTimestamps,
const EGLint *timestamps,
EGLnsecsANDROID *values)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT(
"EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
", EGLuint64KHR frameId = %llu, EGLint numTimestamps = %d, const EGLint *timestamps = "
"0x%016" PRIxPTR ", EGLnsecsANDROID *values = 0x%016" PRIxPTR,
(uintptr_t)dpy, (uintptr_t)surface, (unsigned long long)frameId, numTimestamps,
(uintptr_t)timestamps, (uintptr_t)values);
egl::Display *display = static_cast<egl::Display *>(dpy);
Surface *eglSurface = static_cast<Surface *>(surface);
Thread *thread = egl::GetCurrentThread();
ANGLE_EGL_TRY_RETURN(thread,
ValidateGetFrameTimestampsANDROID(display, eglSurface, frameId,
numTimestamps, timestamps, values),
"eglGetFrameTimestampsANDROID", GetSurfaceIfValid(display, eglSurface),
EGL_FALSE);
ANGLE_EGL_TRY_RETURN(
thread, eglSurface->getFrameTimestamps(frameId, numTimestamps, timestamps, values),
"eglGetFrameTimestampsANDROID", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
thread->setSuccess();
return EGL_TRUE;
}
// EGL_ANGLE_feature_control
ANGLE_EXPORT const char *EGLAPIENTRY EGL_QueryStringiANGLE(EGLDisplay dpy,
EGLint name,
EGLint index)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLint name = %d, EGLint index = %d",
(uintptr_t)dpy, name, index);
egl::Display *display = static_cast<egl::Display *>(dpy);
Thread *thread = egl::GetCurrentThread();
ANGLE_EGL_TRY_RETURN(thread, ValidateQueryStringiANGLE(display, name, index),
"eglQueryStringiANGLE", GetDisplayIfValid(display), nullptr);
thread->setSuccess();
return display->queryStringi(name, index);
}
EGLClientBuffer EGLAPIENTRY EGL_GetNativeClientBufferANDROID(const struct AHardwareBuffer *buffer)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("const struct AHardwareBuffer *buffer = 0x%016" PRIxPTR, (uintptr_t)buffer);
Thread *thread = egl::GetCurrentThread();
ANGLE_EGL_TRY_RETURN(thread, ValidateGetNativeClientBufferANDROID(buffer),
"eglGetNativeClientBufferANDROID", nullptr, nullptr);
thread->setSuccess();
return egl::Display::GetNativeClientBuffer(buffer);
}
EGLint EGLAPIENTRY EGL_DupNativeFenceFDANDROID(EGLDisplay dpy, EGLSyncKHR sync)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSyncKHR sync = 0x%016" PRIxPTR,
(uintptr_t)dpy, (uintptr_t)sync);
egl::Display *display = static_cast<egl::Display *>(dpy);
Sync *syncObject = static_cast<Sync *>(sync);
Thread *thread = egl::GetCurrentThread();
ANGLE_EGL_TRY_RETURN(thread, ValidateDupNativeFenceFDANDROID(display, syncObject),
"eglDupNativeFenceFDANDROID", GetSyncIfValid(display, syncObject),
EGL_NO_NATIVE_FENCE_FD_ANDROID);
EGLint result = EGL_NO_NATIVE_FENCE_FD_ANDROID;
ANGLE_EGL_TRY_RETURN(thread, syncObject->dupNativeFenceFD(display, &result),
"eglDupNativeFenceFDANDROID", GetSyncIfValid(display, syncObject),
EGL_NO_NATIVE_FENCE_FD_ANDROID);
thread->setSuccess();
return result;
}
EGLBoolean EGLAPIENTRY EGL_SwapBuffersWithFrameTokenANGLE(EGLDisplay dpy,
EGLSurface surface,
EGLFrameTokenANGLE frametoken)
{
ANGLE_SCOPED_GLOBAL_LOCK();
FUNC_EVENT("EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
", EGLFrameTokenANGLE frametoken = 0x%llX",
(uintptr_t)dpy, (uintptr_t)surface, (unsigned long long)frametoken);
egl::Display *display = static_cast<egl::Display *>(dpy);
egl::Surface *eglSurface = static_cast<egl::Surface *>(surface);
Thread *thread = egl::GetCurrentThread();
ANGLE_EGL_TRY_RETURN(
thread, ValidateSwapBuffersWithFrameTokenANGLE(display, eglSurface, frametoken),
"eglSwapBuffersWithFrameTokenANGLE", GetDisplayIfValid(display), EGL_FALSE);
ANGLE_EGL_TRY_RETURN(thread, eglSurface->swapWithFrameToken(thread->getContext(), frametoken),
"eglSwapBuffersWithFrameTokenANGLE", GetDisplayIfValid(display),
EGL_FALSE);
thread->setSuccess();
return EGL_TRUE;
}
} // extern "C"