EGLBoolean EGLAPIENTRY CopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
{
EVENT("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLNativePixmapType target = 0x%0.8p)", dpy, surface, target);
Display *display = static_cast<Display*>(dpy);
Surface *eglSurface = static_cast<Surface*>(surface);
Error error = ValidateSurface(display, eglSurface);
if (error.isError())
{
SetGlobalError(error);
return EGL_FALSE;
}
if (display->isDeviceLost())
{
SetGlobalError(Error(EGL_CONTEXT_LOST));
return EGL_FALSE;
}
UNIMPLEMENTED(); // FIXME
SetGlobalError(Error(EGL_SUCCESS));
return 0;
}
EGLBoolean EGLAPIENTRY SwapInterval(EGLDisplay dpy, EGLint interval)
{
EVENT("(EGLDisplay dpy = 0x%0.8p, EGLint interval = %d)", dpy, interval);
Display *display = static_cast<Display*>(dpy);
Error error = ValidateDisplay(display);
if (error.isError())
{
SetGlobalError(error);
return EGL_FALSE;
}
Surface *draw_surface = static_cast<Surface*>(GetGlobalDrawSurface());
if (draw_surface == NULL)
{
SetGlobalError(Error(EGL_BAD_SURFACE));
return EGL_FALSE;
}
draw_surface->setSwapInterval(interval);
SetGlobalError(Error(EGL_SUCCESS));
return EGL_TRUE;
}
EGLBoolean EGLAPIENTRY Initialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
{
EVENT("(EGLDisplay dpy = 0x%0.8p, EGLint *major = 0x%0.8p, EGLint *minor = 0x%0.8p)",
dpy, major, minor);
if (dpy == EGL_NO_DISPLAY)
{
SetGlobalError(Error(EGL_BAD_DISPLAY));
return EGL_FALSE;
}
Display *display = static_cast<Display*>(dpy);
Error error = display->initialize();
if (error.isError())
{
SetGlobalError(error);
return EGL_FALSE;
}
if (major) *major = 1;
if (minor) *minor = 4;
SetGlobalError(Error(EGL_SUCCESS));
return EGL_TRUE;
}
EGLBoolean EGLAPIENTRY DestroyContext(EGLDisplay dpy, EGLContext ctx)
{
EVENT("(EGLDisplay dpy = 0x%0.8p, EGLContext ctx = 0x%0.8p)", dpy, ctx);
Display *display = static_cast<Display*>(dpy);
gl::Context *context = static_cast<gl::Context*>(ctx);
Error error = ValidateContext(display, context);
if (error.isError())
{
SetGlobalError(error);
return EGL_FALSE;
}
if (ctx == EGL_NO_CONTEXT)
{
SetGlobalError(Error(EGL_BAD_CONTEXT));
return EGL_FALSE;
}
if (context == GetGlobalContext())
{
SetGlobalDisplay(NULL);
SetGlobalContext(NULL);
}
display->destroyContext(context);
SetGlobalError(Error(EGL_SUCCESS));
return EGL_TRUE;
}
EGLBoolean EGLAPIENTRY SwapInterval(EGLDisplay dpy, EGLint interval)
{
EVENT("(EGLDisplay dpy = 0x%0.8p, EGLint interval = %d)", dpy, interval);
Display *display = static_cast<Display*>(dpy);
Error error = ValidateDisplay(display);
if (error.isError())
{
SetGlobalError(error);
return EGL_FALSE;
}
Surface *draw_surface = static_cast<Surface*>(GetGlobalDrawSurface());
if (draw_surface == NULL)
{
SetGlobalError(Error(EGL_BAD_SURFACE));
return EGL_FALSE;
}
const egl::Config *surfaceConfig = draw_surface->getConfig();
EGLint clampedInterval = std::min(std::max(interval, surfaceConfig->minSwapInterval), surfaceConfig->maxSwapInterval);
draw_surface->setSwapInterval(clampedInterval);
SetGlobalError(Error(EGL_SUCCESS));
return EGL_TRUE;
}
EGLContext EGLAPIENTRY CreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list)
{
EVENT("(EGLDisplay dpy = 0x%0.8p, EGLConfig config = 0x%0.8p, EGLContext share_context = 0x%0.8p, "
"const EGLint *attrib_list = 0x%0.8p)", dpy, config, share_context, attrib_list);
Display *display = static_cast<Display*>(dpy);
Config *configuration = static_cast<Config*>(config);
gl::Context* sharedGLContext = static_cast<gl::Context*>(share_context);
AttributeMap attributes(attrib_list);
Error error = ValidateCreateContext(display, configuration, sharedGLContext, attributes);
if (error.isError())
{
SetGlobalError(error);
return EGL_NO_CONTEXT;
}
gl::Context *context = nullptr;
error = display->createContext(configuration, sharedGLContext, attributes, &context);
if (error.isError())
{
SetGlobalError(error);
return EGL_NO_CONTEXT;
}
SetGlobalError(Error(EGL_SUCCESS));
return static_cast<EGLContext>(context);
}
EGLBoolean EGLAPIENTRY StreamPostD3DTextureNV12ANGLE(EGLDisplay dpy,
EGLStreamKHR stream,
void *texture,
const EGLAttrib *attrib_list)
{
EVENT(
"(EGLDisplay dpy = 0x%0.8p, EGLStreamKHR stream = 0x%0.8p, void* texture = 0x%0.8p, "
"EGLAttrib attrib_list = 0x%0.8p",
dpy, stream, texture, attrib_list);
Display *display = static_cast<Display *>(dpy);
Stream *streamObject = static_cast<Stream *>(stream);
AttributeMap attributes = AttributeMap::CreateFromAttribArray(attrib_list);
Error error = ValidateStreamPostD3DTextureNV12ANGLE(display, streamObject, texture, attributes);
if (error.isError())
{
SetGlobalError(error);
return EGL_FALSE;
}
error = streamObject->postD3D11NV12Texture(texture, attributes);
if (error.isError())
{
SetGlobalError(error);
return EGL_FALSE;
}
SetGlobalError(error);
return EGL_TRUE;
}
EGLBoolean EGLAPIENTRY StreamConsumerGLTextureExternalAttribsNV(EGLDisplay dpy,
EGLStreamKHR stream,
const EGLAttrib *attrib_list)
{
EVENT(
"(EGLDisplay dpy = 0x%0.8p, EGLStreamKHR stream = 0x%0.8p, EGLAttrib attrib_list = 0x%0.8p",
dpy, stream, attrib_list);
Display *display = static_cast<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())
{
SetGlobalError(error);
return EGL_FALSE;
}
error = streamObject->createConsumerGLTextureExternal(attributes, context);
if (error.isError())
{
SetGlobalError(error);
return EGL_FALSE;
}
SetGlobalError(error);
return EGL_TRUE;
}
EGLBoolean EGLAPIENTRY QueryStreamu64KHR(EGLDisplay dpy,
EGLStreamKHR stream,
EGLenum attribute,
EGLuint64KHR *value)
{
EVENT(
"(EGLDisplay dpy = 0x%0.8p, EGLStreamKHR stream = 0x%0.8p, EGLenum attribute = 0x%X, "
"EGLuint64KHR value = 0x%0.8p)",
dpy, stream, attribute, value);
Display *display = static_cast<Display *>(dpy);
Stream *streamObject = static_cast<Stream *>(stream);
Error error = ValidateQueryStreamu64KHR(display, streamObject, attribute, value);
if (error.isError())
{
SetGlobalError(error);
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();
}
SetGlobalError(error);
return EGL_TRUE;
}
EGLBoolean EGLAPIENTRY ChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config)
{
EVENT("(EGLDisplay dpy = 0x%0.8p, const EGLint *attrib_list = 0x%0.8p, "
"EGLConfig *configs = 0x%0.8p, EGLint config_size = %d, EGLint *num_config = 0x%0.8p)",
dpy, attrib_list, configs, config_size, num_config);
Display *display = static_cast<Display*>(dpy);
Error error = ValidateDisplay(display);
if (error.isError())
{
SetGlobalError(error);
return EGL_FALSE;
}
if (!num_config)
{
SetGlobalError(Error(EGL_BAD_PARAMETER));
return EGL_FALSE;
}
std::vector<const Config*> filteredConfigs = display->getConfigs(AttributeMap(attrib_list));
if (configs)
{
filteredConfigs.resize(std::min<size_t>(filteredConfigs.size(), config_size));
for (size_t i = 0; i < filteredConfigs.size(); i++)
{
configs[i] = const_cast<Config*>(filteredConfigs[i]);
}
}
*num_config = static_cast<EGLint>(filteredConfigs.size());
SetGlobalError(Error(EGL_SUCCESS));
return EGL_TRUE;
}
EGLSurface EGLAPIENTRY CreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)
{
EVENT("(EGLDisplay dpy = 0x%0.8p, EGLConfig config = 0x%0.8p, const EGLint *attrib_list = 0x%0.8p)",
dpy, config, attrib_list);
Display *display = static_cast<Display*>(dpy);
Config *configuration = static_cast<Config*>(config);
AttributeMap attributes(attrib_list);
Error error = ValidateCreatePbufferSurface(display, configuration, attributes);
if (error.isError())
{
SetGlobalError(error);
return EGL_NO_SURFACE;
}
egl::Surface *surface = nullptr;
error = display->createPbufferSurface(configuration, attributes, &surface);
if (error.isError())
{
SetGlobalError(error);
return EGL_NO_SURFACE;
}
return static_cast<EGLSurface>(surface);
}
// EGL_KHR_stream
EGLStreamKHR EGLAPIENTRY CreateStreamKHR(EGLDisplay dpy, const EGLint *attrib_list)
{
EVENT("(EGLDisplay dpy = 0x%0.8p, const EGLAttrib* attrib_list = 0x%0.8p)", dpy, attrib_list);
Display *display = static_cast<Display *>(dpy);
AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
Error error = ValidateCreateStreamKHR(display, attributes);
if (error.isError())
{
SetGlobalError(error);
return EGL_NO_STREAM_KHR;
}
Stream *stream;
error = display->createStream(attributes, &stream);
if (error.isError())
{
SetGlobalError(error);
return EGL_NO_STREAM_KHR;
}
SetGlobalError(error);
return static_cast<EGLStreamKHR>(stream);
}
ANGLE_EXPORT EGLImageKHR EGLAPIENTRY CreateImageKHR(EGLDisplay dpy,
EGLContext ctx,
EGLenum target,
EGLClientBuffer buffer,
const EGLint *attrib_list)
{
EVENT(
"(EGLDisplay dpy = 0x%0.8p, EGLContext ctx = 0x%0.8p, EGLenum target = 0x%X, "
"EGLClientBuffer buffer = 0x%0.8p, const EGLAttrib *attrib_list = 0x%0.8p)",
dpy, ctx, target, buffer, attrib_list);
Display *display = static_cast<Display *>(dpy);
gl::Context *context = static_cast<gl::Context *>(ctx);
AttributeMap attributes(attrib_list);
Error error = ValidateCreateImageKHR(display, context, target, buffer, attributes);
if (error.isError())
{
SetGlobalError(error);
return EGL_NO_IMAGE;
}
Image *image = nullptr;
error = display->createImage(context, target, buffer, attributes, &image);
if (error.isError())
{
SetGlobalError(error);
return EGL_NO_IMAGE;
}
return static_cast<EGLImage>(image);
}
EGLBoolean EGLAPIENTRY DestroySurface(EGLDisplay dpy, EGLSurface surface)
{
EVENT("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p)", dpy, surface);
Display *display = static_cast<Display*>(dpy);
Surface *eglSurface = static_cast<Surface*>(surface);
Error error = ValidateSurface(display, eglSurface);
if (error.isError())
{
SetGlobalError(error);
return EGL_FALSE;
}
if (surface == EGL_NO_SURFACE)
{
SetGlobalError(Error(EGL_BAD_SURFACE));
return EGL_FALSE;
}
display->destroySurface((Surface*)surface);
SetGlobalError(Error(EGL_SUCCESS));
return EGL_TRUE;
}
// EGL_EXT_device_query
const char * EGLAPIENTRY QueryDeviceStringEXT(EGLDeviceEXT device, EGLint name)
{
EVENT("(EGLDeviceEXT device = 0x%0.8p, EGLint name = %d)",
device, name);
Device *dev = static_cast<Device*>(device);
if (dev == EGL_NO_DEVICE_EXT)
{
SetGlobalError(Error(EGL_BAD_DEVICE_EXT));
return nullptr;
}
const char *result;
switch (name)
{
case EGL_EXTENSIONS:
result = dev->getExtensionString().c_str();
break;
default:
SetGlobalError(Error(EGL_BAD_DEVICE_EXT));
return nullptr;
}
SetGlobalError(Error(EGL_SUCCESS));
return result;
}
// EGL_EXT_device_query
EGLBoolean EGLAPIENTRY QueryDisplayAttribEXT(EGLDisplay dpy, EGLint attribute, EGLAttrib *value)
{
EVENT("(EGLDisplay dpy = 0x%0.8p, EGLint attribute = %d, EGLAttrib *value = 0x%0.8p)",
dpy, attribute, value);
Display *display = static_cast<Display*>(dpy);
Error error(EGL_SUCCESS);
if (!display->getExtensions().deviceQuery)
{
SetGlobalError(Error(EGL_BAD_ACCESS));
return EGL_FALSE;
}
// validate the attribute parameter
switch (attribute)
{
case EGL_DEVICE_EXT:
*value = reinterpret_cast<EGLAttrib>(display->getDevice());
break;
default:
SetGlobalError(Error(EGL_BAD_ATTRIBUTE));
return EGL_FALSE;
}
SetGlobalError(error);
return (error.isError() ? EGL_FALSE : EGL_TRUE);
}
ANGLE_EXPORT EGLDeviceEXT EGLAPIENTRY CreateDeviceANGLE(EGLint device_type,
void *native_device,
const EGLAttrib *attrib_list)
{
EVENT(
"(EGLint device_type = %d, void* native_device = 0x%0.8p, const EGLAttrib* attrib_list = "
"0x%0.8p)",
device_type, native_device, attrib_list);
Error error = ValidateCreateDeviceANGLE(device_type, native_device, attrib_list);
if (error.isError())
{
SetGlobalError(error);
return EGL_NO_DEVICE_EXT;
}
Device *device = nullptr;
error = Device::CreateDevice(native_device, device_type, &device);
if (error.isError())
{
ASSERT(device == nullptr);
SetGlobalError(error);
return EGL_NO_DEVICE_EXT;
}
return device;
}
EGLBoolean EGLAPIENTRY StreamAttribKHR(EGLDisplay dpy,
EGLStreamKHR stream,
EGLenum attribute,
EGLint value)
{
EVENT(
"(EGLDisplay dpy = 0x%0.8p, EGLStreamKHR stream = 0x%0.8p, EGLenum attribute = 0x%X, "
"EGLint value = 0x%X)",
dpy, stream, attribute, value);
Display *display = static_cast<Display *>(dpy);
Stream *streamObject = static_cast<Stream *>(stream);
Error error = ValidateStreamAttribKHR(display, streamObject, attribute, value);
if (error.isError())
{
SetGlobalError(error);
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();
}
SetGlobalError(error);
return EGL_TRUE;
}
const KDchar *KD_APIENTRY QueryIndexedAttribcv(KDint attribute, KDint index)
{
EVENT("(KDint attribute = %d, KDint index = %d)", attribute, index);
SetGlobalError(Error(KD_EINVAL));
return KD_NULL;
}
KDint KD_APIENTRY QueryAttribi(KDint attribute, KDint *value)
{
EVENT("(KDint attribute = %d, KDint *value = 0x%0.8p)", attribute, value);
SetGlobalError(Error(KD_EINVAL));
return -1;
}
void *KD_APIENTRY Malloc(KDsize size)
{
EVENT("(KDsize size = %d)", size);
void *result = malloc(size);
if (result == NULL && size != 0) SetGlobalError(Error(KD_ENOMEM));
return result;
}
void *KD_APIENTRY Realloc(void *ptr, KDsize size)
{
EVENT("(void *ptr = 0x%0.8p, KDsize size = %d)", ptr, size);
void *result = realloc(ptr, size);
if (result == NULL && size != 0) SetGlobalError(Error(KD_ENOMEM));
return result;
}
// EGL_EXT_device_query
EGLBoolean EGLAPIENTRY QueryDeviceAttribEXT(EGLDeviceEXT device, EGLint attribute, EGLAttrib *value)
{
EVENT("(EGLDeviceEXT device = 0x%0.8p, EGLint attribute = %d, EGLAttrib *value = 0x%0.8p)",
device, attribute, value);
Device *dev = static_cast<Device*>(device);
if (dev == EGL_NO_DEVICE_EXT || !Device::IsValidDevice(dev))
{
SetGlobalError(Error(EGL_BAD_ACCESS));
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
Display *owningDisplay = dev->getOwningDisplay();
if (owningDisplay != nullptr && !owningDisplay->getExtensions().deviceQuery)
{
SetGlobalError(Error(EGL_BAD_ACCESS,
"Device wasn't created using eglCreateDeviceANGLE, and the Display "
"that created it doesn't support device querying"));
return EGL_FALSE;
}
Error error(EGL_SUCCESS);
// validate the attribute parameter
switch (attribute)
{
case EGL_D3D11_DEVICE_ANGLE:
case EGL_D3D9_DEVICE_ANGLE:
if (!dev->getExtensions().deviceD3D || dev->getType() != attribute)
{
SetGlobalError(Error(EGL_BAD_ATTRIBUTE));
return EGL_FALSE;
}
error = dev->getDevice(value);
break;
default:
SetGlobalError(Error(EGL_BAD_ATTRIBUTE));
return EGL_FALSE;
}
SetGlobalError(error);
return (error.isError() ? EGL_FALSE : EGL_TRUE);
}
const char *EGLAPIENTRY QueryString(EGLDisplay dpy, EGLint name)
{
EVENT("(EGLDisplay dpy = 0x%0.8p, EGLint name = %d)", dpy, name);
Display *display = static_cast<Display*>(dpy);
if (!(display == EGL_NO_DISPLAY && name == EGL_EXTENSIONS))
{
Error error = ValidateDisplay(display);
if (error.isError())
{
SetGlobalError(error);
return NULL;
}
}
const char *result;
switch (name)
{
case EGL_CLIENT_APIS:
result = "OpenGL_ES";
break;
case EGL_EXTENSIONS:
if (display == EGL_NO_DISPLAY)
{
result = Display::getClientExtensionString().c_str();
}
else
{
result = display->getExtensionString().c_str();
}
break;
case EGL_VENDOR:
result = display->getVendorString().c_str();
break;
case EGL_VERSION:
result = "1.4 (ANGLE " ANGLE_VERSION_STRING ")";
break;
default:
SetGlobalError(Error(EGL_BAD_PARAMETER));
return NULL;
}
SetGlobalError(Error(EGL_SUCCESS));
return result;
}
EGLenum EGLAPIENTRY QueryAPI(void)
{
EVENT("()");
EGLenum API = GetGlobalAPI();
SetGlobalError(Error(EGL_SUCCESS));
return API;
}
EGLBoolean EGLAPIENTRY WaitNative(EGLint engine)
{
EVENT("(EGLint engine = %d)", engine);
UNIMPLEMENTED(); // FIXME
SetGlobalError(Error(EGL_SUCCESS));
return 0;
}
EGLBoolean EGLAPIENTRY WaitGL(void)
{
EVENT("()");
UNIMPLEMENTED(); // FIXME
SetGlobalError(Error(EGL_SUCCESS));
return 0;
}
EGLDisplay EGLAPIENTRY GetCurrentDisplay(void)
{
EVENT("()");
EGLDisplay dpy = GetGlobalDisplay();
SetGlobalError(Error(EGL_SUCCESS));
return dpy;
}
EGLBoolean EGLAPIENTRY ReleaseThread(void)
{
EVENT("()");
MakeCurrent(EGL_NO_DISPLAY, EGL_NO_CONTEXT, EGL_NO_SURFACE, EGL_NO_SURFACE);
SetGlobalError(Error(EGL_SUCCESS));
return EGL_TRUE;
}
// EGL 1.4
EGLContext EGLAPIENTRY GetCurrentContext(void)
{
EVENT("()");
gl::Context *context = GetGlobalContext();
SetGlobalError(Error(EGL_SUCCESS));
return static_cast<EGLContext>(context);
}
