Skip to content

S
swiftshader
Commit f160b179 by Nicolas Capens Committed by Nicolas Capens
Options

Eliminate exception handling.

BUG=18525426 Change-Id: I4ce127fe56e30046fc316276b856767a036d13a1 Reviewed-on: https://swiftshader-review.googlesource.com/1490Reviewed-by: 's avatarAlexis Hétu <sugoi@google.com> Reviewed-by: 's avatarNicolas Capens <nicolascapens@google.com> Tested-by: 's avatarNicolas Capens <nicolascapens@google.com>
parent 4cb1124e
Showing with 643 additions and 958 deletions
src/OpenGL/libEGL/libEGL.cpp
...@@ -25,1251 +25,938 @@ ...@@ -25,1251 +25,938 @@
static bool validateDisplay(egl::Display *display) static bool validateDisplay(egl::Display *display)
{ {
if(display == EGL_NO_DISPLAY) if(display == EGL_NO_DISPLAY)
{ {
return error(EGL_BAD_DISPLAY, false); return error(EGL_BAD_DISPLAY, false);
} }
if(!display->isInitialized()) if(!display->isInitialized())
{ {
return error(EGL_NOT_INITIALIZED, false); return error(EGL_NOT_INITIALIZED, false);
} }
return true; return true;
} }
static bool validateConfig(egl::Display *display, EGLConfig config) static bool validateConfig(egl::Display *display, EGLConfig config)
{ {
if(!validateDisplay(display)) if(!validateDisplay(display))
{ {
return false; return false;
} }
if(!display->isValidConfig(config)) if(!display->isValidConfig(config))
{ {
return error(EGL_BAD_CONFIG, false); return error(EGL_BAD_CONFIG, false);
} }
return true; return true;
} }
static bool validateContext(egl::Display *display, egl::Context *context) static bool validateContext(egl::Display *display, egl::Context *context)
{ {
if(!validateDisplay(display)) if(!validateDisplay(display))
{ {
return false; return false;
} }
if(!display->isValidContext(context)) if(!display->isValidContext(context))
{ {
return error(EGL_BAD_CONTEXT, false); return error(EGL_BAD_CONTEXT, false);
} }
return true; return true;
} }
static bool validateSurface(egl::Display *display, egl::Surface *surface) static bool validateSurface(egl::Display *display, egl::Surface *surface)
{ {
if(!validateDisplay(display)) if(!validateDisplay(display))
{ {
return false; return false;
} }
if(!display->isValidSurface(surface)) if(!display->isValidSurface(surface))
{ {
return error(EGL_BAD_SURFACE, false); return error(EGL_BAD_SURFACE, false);
} }
return true; return true;
} }
extern "C" extern "C"
{ {
EGLint EGLAPIENTRY eglGetError(void) EGLint EGLAPIENTRY eglGetError(void)
{ {
TRACE("()"); TRACE("()");
EGLint error = egl::getCurrentError(); EGLint error = egl::getCurrentError();
if(error != EGL_SUCCESS) if(error != EGL_SUCCESS)
{ {
egl::setCurrentError(EGL_SUCCESS); egl::setCurrentError(EGL_SUCCESS);
} }
return error; return error;
} }
EGLDisplay EGLAPIENTRY eglGetDisplay(EGLNativeDisplayType display_id) EGLDisplay EGLAPIENTRY eglGetDisplay(EGLNativeDisplayType display_id)
{ {
TRACE("(EGLNativeDisplayType display_id = 0x%0.8p)", display_id); TRACE("(EGLNativeDisplayType display_id = 0x%0.8p)", display_id);
try return egl::Display::getPlatformDisplay(EGL_UNKNOWN, display_id);
{
return egl::Display::getPlatformDisplay(EGL_UNKNOWN, display_id);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_NO_DISPLAY);
}
return EGL_NO_DISPLAY;
} }
EGLBoolean EGLAPIENTRY eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor) EGLBoolean EGLAPIENTRY eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, EGLint *major = 0x%0.8p, EGLint *minor = 0x%0.8p)", TRACE("(EGLDisplay dpy = 0x%0.8p, EGLint *major = 0x%0.8p, EGLint *minor = 0x%0.8p)",
dpy, major, minor); dpy, major, minor);
try if(dpy == EGL_NO_DISPLAY)
{ {
if(dpy == EGL_NO_DISPLAY) return error(EGL_BAD_DISPLAY, EGL_FALSE);
{ }
return error(EGL_BAD_DISPLAY, EGL_FALSE);
} egl::Display *display = static_cast<egl::Display*>(dpy);
egl::Display *display = static_cast<egl::Display*>(dpy); if(!display->initialize())
{
if(!display->initialize()) return error(EGL_NOT_INITIALIZED, EGL_FALSE);
{ }
return error(EGL_NOT_INITIALIZED, EGL_FALSE);
} if(major) *major = 1;
if(minor) *minor = 4;
if(major) *major = 1;
if(minor) *minor = 4; return success(EGL_TRUE);
return success(EGL_TRUE);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE;
} }
EGLBoolean EGLAPIENTRY eglTerminate(EGLDisplay dpy) EGLBoolean EGLAPIENTRY eglTerminate(EGLDisplay dpy)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p)", dpy); TRACE("(EGLDisplay dpy = 0x%0.8p)", dpy);
try if(dpy == EGL_NO_DISPLAY)
{ {
if(dpy == EGL_NO_DISPLAY) return error(EGL_BAD_DISPLAY, EGL_FALSE);
{ }
return error(EGL_BAD_DISPLAY, EGL_FALSE);
}
egl::Display *display = static_cast<egl::Display*>(dpy); egl::Display *display = static_cast<egl::Display*>(dpy);
display->terminate(); display->terminate();
return success(EGL_TRUE); return success(EGL_TRUE);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE;
} }
const char *EGLAPIENTRY eglQueryString(EGLDisplay dpy, EGLint name) const char *EGLAPIENTRY eglQueryString(EGLDisplay dpy, EGLint name)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, EGLint name = %d)", dpy, name); TRACE("(EGLDisplay dpy = 0x%0.8p, EGLint name = %d)", dpy, name);
try if(dpy == EGL_NO_DISPLAY && name == EGL_EXTENSIONS)
{ {
if(dpy == EGL_NO_DISPLAY && name == EGL_EXTENSIONS) return success("EGL_KHR_platform_gbm "
{ "EGL_KHR_platform_x11 "
return success("EGL_KHR_platform_gbm " "EGL_EXT_client_extensions "
"EGL_KHR_platform_x11 " "EGL_EXT_platform_base");
"EGL_EXT_client_extensions " }
"EGL_EXT_platform_base");
} egl::Display *display = static_cast<egl::Display*>(dpy);
egl::Display *display = static_cast<egl::Display*>(dpy); if(!validateDisplay(display))
{
if(!validateDisplay(display)) return NULL;
{ }
return NULL;
} switch(name)
{
switch(name) case EGL_CLIENT_APIS:
{ return success("OpenGL_ES");
case EGL_CLIENT_APIS: case EGL_EXTENSIONS:
return success("OpenGL_ES"); return success("EGL_KHR_gl_texture_2D_image "
case EGL_EXTENSIONS: "EGL_KHR_gl_texture_cubemap_image "
return success("EGL_KHR_gl_texture_2D_image " "EGL_KHR_gl_renderbuffer_image "
"EGL_KHR_gl_texture_cubemap_image " "EGL_KHR_image_base");
"EGL_KHR_gl_renderbuffer_image " case EGL_VENDOR:
"EGL_KHR_image_base"); return success("TransGaming Inc.");
case EGL_VENDOR: case EGL_VERSION:
return success("TransGaming Inc."); return success("1.4 SwiftShader " VERSION_STRING);
case EGL_VERSION: }
return success("1.4 SwiftShader " VERSION_STRING);
} return error(EGL_BAD_PARAMETER, (const char*)NULL);
return error(EGL_BAD_PARAMETER, (const char*)NULL);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, (const char*)NULL);
}
return NULL;
} }
EGLBoolean EGLAPIENTRY eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config) EGLBoolean EGLAPIENTRY eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, EGLConfig *configs = 0x%0.8p, " TRACE("(EGLDisplay dpy = 0x%0.8p, EGLConfig *configs = 0x%0.8p, "
"EGLint config_size = %d, EGLint *num_config = 0x%0.8p)", "EGLint config_size = %d, EGLint *num_config = 0x%0.8p)",
dpy, configs, config_size, num_config); dpy, configs, config_size, num_config);
try egl::Display *display = static_cast<egl::Display*>(dpy);
{
egl::Display *display = static_cast<egl::Display*>(dpy); if(!validateDisplay(display))
{
if(!validateDisplay(display)) return EGL_FALSE;
{ }
return EGL_FALSE;
} if(!num_config)
{
if(!num_config) return error(EGL_BAD_PARAMETER, EGL_FALSE);
{ }
return error(EGL_BAD_PARAMETER, EGL_FALSE);
} const EGLint attribList[] = {EGL_NONE};
const EGLint attribList[] = {EGL_NONE}; if(!display->getConfigs(configs, attribList, config_size, num_config))
{
if(!display->getConfigs(configs, attribList, config_size, num_config)) return error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
{ }
return error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
} return success(EGL_TRUE);
return success(EGL_TRUE);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE;
} }
EGLBoolean EGLAPIENTRY eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config) EGLBoolean EGLAPIENTRY eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, const EGLint *attrib_list = 0x%0.8p, " TRACE("(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)", "EGLConfig *configs = 0x%0.8p, EGLint config_size = %d, EGLint *num_config = 0x%0.8p)",
dpy, attrib_list, configs, config_size, num_config); dpy, attrib_list, configs, config_size, num_config);
try
{
egl::Display *display = static_cast<egl::Display*>(dpy);
if(!validateDisplay(display)) egl::Display *display = static_cast<egl::Display*>(dpy);
{
return EGL_FALSE;
}
if(!num_config) if(!validateDisplay(display))
{ {
return error(EGL_BAD_PARAMETER, EGL_FALSE); return EGL_FALSE;
} }
const EGLint attribList[] = {EGL_NONE}; if(!num_config)
{
return error(EGL_BAD_PARAMETER, EGL_FALSE);
}
if(!attrib_list) const EGLint attribList[] = {EGL_NONE};
{
attrib_list = attribList;
}
display->getConfigs(configs, attrib_list, config_size, num_config); if(!attrib_list)
{
attrib_list = attribList;
}
return success(EGL_TRUE); display->getConfigs(configs, attrib_list, config_size, num_config);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE; return success(EGL_TRUE);
} }
EGLBoolean EGLAPIENTRY eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value) EGLBoolean EGLAPIENTRY eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, EGLConfig config = 0x%0.8p, EGLint attribute = %d, EGLint *value = 0x%0.8p)", TRACE("(EGLDisplay dpy = 0x%0.8p, EGLConfig config = 0x%0.8p, EGLint attribute = %d, EGLint *value = 0x%0.8p)",
dpy, config, attribute, value); dpy, config, attribute, value);
try egl::Display *display = static_cast<egl::Display*>(dpy);
{
egl::Display *display = static_cast<egl::Display*>(dpy); if(!validateConfig(display, config))
{
if(!validateConfig(display, config)) return EGL_FALSE;
{ }
return EGL_FALSE;
} if(!display->getConfigAttrib(config, attribute, value))
{
if(!display->getConfigAttrib(config, attribute, value)) return error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
{ }
return error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
} return success(EGL_TRUE);
return success(EGL_TRUE);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE;
} }
EGLSurface EGLAPIENTRY eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType window, const EGLint *attrib_list) EGLSurface EGLAPIENTRY eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType window, const EGLint *attrib_list)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, EGLConfig config = 0x%0.8p, EGLNativeWindowType win = 0x%0.8p, " TRACE("(EGLDisplay dpy = 0x%0.8p, EGLConfig config = 0x%0.8p, EGLNativeWindowType win = 0x%0.8p, "
"const EGLint *attrib_list = 0x%0.8p)", dpy, config, window, attrib_list); "const EGLint *attrib_list = 0x%0.8p)", dpy, config, window, attrib_list);
try egl::Display *display = static_cast<egl::Display*>(dpy);
{
egl::Display *display = static_cast<egl::Display*>(dpy);
if(!validateConfig(display, config)) if(!validateConfig(display, config))
{ {
return EGL_NO_SURFACE; return EGL_NO_SURFACE;
} }
if(!display->isValidWindow(window)) if(!display->isValidWindow(window))
{ {
return error(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE); return error(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
} }
return display->createWindowSurface(window, config, attrib_list);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
}
return EGL_NO_SURFACE; return display->createWindowSurface(window, config, attrib_list);
} }
EGLSurface EGLAPIENTRY eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list) EGLSurface EGLAPIENTRY eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, EGLConfig config = 0x%0.8p, const EGLint *attrib_list = 0x%0.8p)", TRACE("(EGLDisplay dpy = 0x%0.8p, EGLConfig config = 0x%0.8p, const EGLint *attrib_list = 0x%0.8p)",
dpy, config, attrib_list); dpy, config, attrib_list);
try egl::Display *display = static_cast<egl::Display*>(dpy);
{
egl::Display *display = static_cast<egl::Display*>(dpy); if(!validateConfig(display, config))
{
if(!validateConfig(display, config)) return EGL_NO_SURFACE;
{ }
return EGL_NO_SURFACE;
} return display->createOffscreenSurface(config, attrib_list);
return display->createOffscreenSurface(config, attrib_list);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
}
return EGL_NO_SURFACE;
} }
EGLSurface EGLAPIENTRY eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list) EGLSurface EGLAPIENTRY eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, EGLConfig config = 0x%0.8p, EGLNativePixmapType pixmap = 0x%0.8p, " TRACE("(EGLDisplay dpy = 0x%0.8p, EGLConfig config = 0x%0.8p, EGLNativePixmapType pixmap = 0x%0.8p, "
"const EGLint *attrib_list = 0x%0.8p)", dpy, config, pixmap, attrib_list); "const EGLint *attrib_list = 0x%0.8p)", dpy, config, pixmap, attrib_list);
try egl::Display *display = static_cast<egl::Display*>(dpy);
{
egl::Display *display = static_cast<egl::Display*>(dpy);
if(!validateConfig(display, config)) if(!validateConfig(display, config))
{ {
return EGL_NO_SURFACE; return EGL_NO_SURFACE;
} }
UNIMPLEMENTED(); // FIXME UNIMPLEMENTED(); // FIXME
return success(EGL_NO_SURFACE); return success(EGL_NO_SURFACE);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
}
return EGL_NO_SURFACE;
} }
EGLBoolean EGLAPIENTRY eglDestroySurface(EGLDisplay dpy, EGLSurface surface) EGLBoolean EGLAPIENTRY eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p)", dpy, surface); TRACE("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p)", dpy, surface);
try
{
egl::Display *display = static_cast<egl::Display*>(dpy);
egl::Surface *eglSurface = static_cast<egl::Surface*>(surface);
if(!validateSurface(display, eglSurface)) egl::Display *display = static_cast<egl::Display*>(dpy);
{ egl::Surface *eglSurface = static_cast<egl::Surface*>(surface);
return EGL_FALSE;
}
if(surface == EGL_NO_SURFACE) if(!validateSurface(display, eglSurface))
{ {
return error(EGL_BAD_SURFACE, EGL_FALSE); return EGL_FALSE;
} }
display->destroySurface((egl::Surface*)surface); if(surface == EGL_NO_SURFACE)
{
return error(EGL_BAD_SURFACE, EGL_FALSE);
}
return success(EGL_TRUE); display->destroySurface((egl::Surface*)surface);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE; return success(EGL_TRUE);
} }
EGLBoolean EGLAPIENTRY eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value) EGLBoolean EGLAPIENTRY eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLint attribute = %d, EGLint *value = 0x%0.8p)", TRACE("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLint attribute = %d, EGLint *value = 0x%0.8p)",
dpy, surface, attribute, value); dpy, surface, attribute, value);
try egl::Display *display = static_cast<egl::Display*>(dpy);
{ egl::Surface *eglSurface = (egl::Surface*)surface;
egl::Display *display = static_cast<egl::Display*>(dpy);
egl::Surface *eglSurface = (egl::Surface*)surface; if(!validateSurface(display, eglSurface))
{
if(!validateSurface(display, eglSurface)) return EGL_FALSE;
{ }
return EGL_FALSE;
} if(surface == EGL_NO_SURFACE)
{
if(surface == EGL_NO_SURFACE) return error(EGL_BAD_SURFACE, EGL_FALSE);
{ }
return error(EGL_BAD_SURFACE, EGL_FALSE);
} switch(attribute)
{
switch(attribute) case EGL_VG_ALPHA_FORMAT:
{ UNIMPLEMENTED(); // FIXME
case EGL_VG_ALPHA_FORMAT: break;
UNIMPLEMENTED(); // FIXME case EGL_VG_COLORSPACE:
break; UNIMPLEMENTED(); // FIXME
case EGL_VG_COLORSPACE: break;
UNIMPLEMENTED(); // FIXME case EGL_CONFIG_ID:
break; *value = eglSurface->getConfigID();
case EGL_CONFIG_ID: break;
*value = eglSurface->getConfigID(); case EGL_HEIGHT:
break; *value = eglSurface->getHeight();
case EGL_HEIGHT: break;
*value = eglSurface->getHeight(); case EGL_HORIZONTAL_RESOLUTION:
break; UNIMPLEMENTED(); // FIXME
case EGL_HORIZONTAL_RESOLUTION: break;
UNIMPLEMENTED(); // FIXME case EGL_LARGEST_PBUFFER:
break; UNIMPLEMENTED(); // FIXME
case EGL_LARGEST_PBUFFER: break;
UNIMPLEMENTED(); // FIXME case EGL_MIPMAP_TEXTURE:
break; UNIMPLEMENTED(); // FIXME
case EGL_MIPMAP_TEXTURE: break;
UNIMPLEMENTED(); // FIXME case EGL_MIPMAP_LEVEL:
break; UNIMPLEMENTED(); // FIXME
case EGL_MIPMAP_LEVEL: break;
UNIMPLEMENTED(); // FIXME case EGL_MULTISAMPLE_RESOLVE:
break; UNIMPLEMENTED(); // FIXME
case EGL_MULTISAMPLE_RESOLVE: break;
UNIMPLEMENTED(); // FIXME case EGL_PIXEL_ASPECT_RATIO:
break; *value = eglSurface->getPixelAspectRatio();
case EGL_PIXEL_ASPECT_RATIO: break;
*value = eglSurface->getPixelAspectRatio(); case EGL_RENDER_BUFFER:
break; *value = eglSurface->getRenderBuffer();
case EGL_RENDER_BUFFER: break;
*value = eglSurface->getRenderBuffer(); case EGL_SWAP_BEHAVIOR:
break; *value = eglSurface->getSwapBehavior();
case EGL_SWAP_BEHAVIOR: break;
*value = eglSurface->getSwapBehavior(); case EGL_TEXTURE_FORMAT:
break; *value = eglSurface->getTextureFormat();
case EGL_TEXTURE_FORMAT: break;
*value = eglSurface->getTextureFormat(); case EGL_TEXTURE_TARGET:
break; *value = eglSurface->getTextureTarget();
case EGL_TEXTURE_TARGET: break;
*value = eglSurface->getTextureTarget(); case EGL_VERTICAL_RESOLUTION:
break; UNIMPLEMENTED(); // FIXME
case EGL_VERTICAL_RESOLUTION: break;
UNIMPLEMENTED(); // FIXME case EGL_WIDTH:
break; *value = eglSurface->getWidth();
case EGL_WIDTH: break;
*value = eglSurface->getWidth(); default:
break; return error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
default: }
return error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
} return success(EGL_TRUE);
return success(EGL_TRUE);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE;
} }
EGLBoolean EGLAPIENTRY eglBindAPI(EGLenum api) EGLBoolean EGLAPIENTRY eglBindAPI(EGLenum api)
{ {
TRACE("(EGLenum api = 0x%X)", api); TRACE("(EGLenum api = 0x%X)", api);
try switch(api)
{ {
switch (api) case EGL_OPENGL_API:
{ case EGL_OPENVG_API:
case EGL_OPENGL_API: return error(EGL_BAD_PARAMETER, EGL_FALSE); // Not supported by this implementation
case EGL_OPENVG_API: case EGL_OPENGL_ES_API:
return error(EGL_BAD_PARAMETER, EGL_FALSE); // Not supported by this implementation break;
case EGL_OPENGL_ES_API: default:
break; return error(EGL_BAD_PARAMETER, EGL_FALSE);
default: }
return error(EGL_BAD_PARAMETER, EGL_FALSE);
} egl::setCurrentAPI(api);
egl::setCurrentAPI(api); return success(EGL_TRUE);
return success(EGL_TRUE);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE;
} }
EGLenum EGLAPIENTRY eglQueryAPI(void) EGLenum EGLAPIENTRY eglQueryAPI(void)
{ {
TRACE("()"); TRACE("()");
try
{
EGLenum API = egl::getCurrentAPI();
return success(API); EGLenum API = egl::getCurrentAPI();
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE; return success(API);
} }
EGLBoolean EGLAPIENTRY eglWaitClient(void) EGLBoolean EGLAPIENTRY eglWaitClient(void)
{ {
TRACE("()"); TRACE("()");
try UNIMPLEMENTED(); // FIXME
{
UNIMPLEMENTED(); // FIXME
return success(0); return success(EGL_FALSE);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE;
} }
EGLBoolean EGLAPIENTRY eglReleaseThread(void) EGLBoolean EGLAPIENTRY eglReleaseThread(void)
{ {
TRACE("()"); TRACE("()");
try
{
eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_CONTEXT, EGL_NO_SURFACE, EGL_NO_SURFACE);
return success(EGL_TRUE); eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_CONTEXT, EGL_NO_SURFACE, EGL_NO_SURFACE);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE; return success(EGL_TRUE);
} }
EGLSurface EGLAPIENTRY eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list) EGLSurface EGLAPIENTRY eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, EGLenum buftype = 0x%X, EGLClientBuffer buffer = 0x%0.8p, " TRACE("(EGLDisplay dpy = 0x%0.8p, EGLenum buftype = 0x%X, EGLClientBuffer buffer = 0x%0.8p, "
"EGLConfig config = 0x%0.8p, const EGLint *attrib_list = 0x%0.8p)", "EGLConfig config = 0x%0.8p, const EGLint *attrib_list = 0x%0.8p)",
dpy, buftype, buffer, config, attrib_list); dpy, buftype, buffer, config, attrib_list);
UNIMPLEMENTED(); UNIMPLEMENTED();
return error(EGL_BAD_PARAMETER, EGL_NO_SURFACE); return error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
} }
EGLBoolean EGLAPIENTRY eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value) EGLBoolean EGLAPIENTRY eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLint attribute = %d, EGLint value = %d)", TRACE("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLint attribute = %d, EGLint value = %d)",
dpy, surface, attribute, value); dpy, surface, attribute, value);
try
{
egl::Display *display = static_cast<egl::Display*>(dpy);
egl::Surface *eglSurface = static_cast<egl::Surface*>(surface);
if(!validateSurface(display, eglSurface)) egl::Display *display = static_cast<egl::Display*>(dpy);
{ egl::Surface *eglSurface = static_cast<egl::Surface*>(surface);
return EGL_FALSE;
}
UNIMPLEMENTED(); // FIXME if(!validateSurface(display, eglSurface))
{
return EGL_FALSE;
}
return success(EGL_TRUE); UNIMPLEMENTED(); // FIXME
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE; return success(EGL_TRUE);
} }
EGLBoolean EGLAPIENTRY eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) EGLBoolean EGLAPIENTRY eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLint buffer = %d)", dpy, surface, buffer); TRACE("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLint buffer = %d)", dpy, surface, buffer);
try egl::Display *display = static_cast<egl::Display*>(dpy);
{ egl::Surface *eglSurface = static_cast<egl::Surface*>(surface);
egl::Display *display = static_cast<egl::Display*>(dpy);
egl::Surface *eglSurface = static_cast<egl::Surface*>(surface);
if(!validateSurface(display, eglSurface)) if(!validateSurface(display, eglSurface))
{ {
return EGL_FALSE; return EGL_FALSE;
} }
if(buffer != EGL_BACK_BUFFER) if(buffer != EGL_BACK_BUFFER)
{ {
return error(EGL_BAD_PARAMETER, EGL_FALSE); return error(EGL_BAD_PARAMETER, EGL_FALSE);
} }
if(surface == EGL_NO_SURFACE || eglSurface->getWindowHandle()) if(surface == EGL_NO_SURFACE || eglSurface->getWindowHandle())
{ {
return error(EGL_BAD_SURFACE, EGL_FALSE); return error(EGL_BAD_SURFACE, EGL_FALSE);
} }
if(eglSurface->getBoundTexture()) if(eglSurface->getBoundTexture())
{ {
return error(EGL_BAD_ACCESS, EGL_FALSE); return error(EGL_BAD_ACCESS, EGL_FALSE);
} }
if(eglSurface->getTextureFormat() == EGL_NO_TEXTURE) if(eglSurface->getTextureFormat() == EGL_NO_TEXTURE)
{ {
return error(EGL_BAD_MATCH, EGL_FALSE); return error(EGL_BAD_MATCH, EGL_FALSE);
} }
egl::Context *context = static_cast<egl::Context*>(egl::getCurrentContext()); egl::Context *context = static_cast<egl::Context*>(egl::getCurrentContext());
if(context)
{
context->bindTexImage(eglSurface);
}
return success(EGL_TRUE); if(context)
} {
catch(std::bad_alloc&) context->bindTexImage(eglSurface);
{ }
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE; return success(EGL_TRUE);
} }
EGLBoolean EGLAPIENTRY eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) EGLBoolean EGLAPIENTRY eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLint buffer = %d)", dpy, surface, buffer); TRACE("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLint buffer = %d)", dpy, surface, buffer);
try egl::Display *display = static_cast<egl::Display*>(dpy);
{ egl::Surface *eglSurface = static_cast<egl::Surface*>(surface);
egl::Display *display = static_cast<egl::Display*>(dpy);
egl::Surface *eglSurface = static_cast<egl::Surface*>(surface); if(!validateSurface(display, eglSurface))
{
if(!validateSurface(display, eglSurface)) return EGL_FALSE;
{ }
return EGL_FALSE;
} if(buffer != EGL_BACK_BUFFER)
{
if(buffer != EGL_BACK_BUFFER) return error(EGL_BAD_PARAMETER, EGL_FALSE);
{ }
return error(EGL_BAD_PARAMETER, EGL_FALSE);
} if(surface == EGL_NO_SURFACE || eglSurface->getWindowHandle())
{
if(surface == EGL_NO_SURFACE || eglSurface->getWindowHandle()) return error(EGL_BAD_SURFACE, EGL_FALSE);
{ }
return error(EGL_BAD_SURFACE, EGL_FALSE);
} if(eglSurface->getTextureFormat() == EGL_NO_TEXTURE)
{
if(eglSurface->getTextureFormat() == EGL_NO_TEXTURE) return error(EGL_BAD_MATCH, EGL_FALSE);
{ }
return error(EGL_BAD_MATCH, EGL_FALSE);
} egl::Texture2D *texture = eglSurface->getBoundTexture();
egl::Texture2D *texture = eglSurface->getBoundTexture(); if(texture)
{
if(texture) texture->releaseTexImage();
{ }
texture->releaseTexImage();
} return success(EGL_TRUE);
return success(EGL_TRUE);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE;
} }
EGLBoolean EGLAPIENTRY eglSwapInterval(EGLDisplay dpy, EGLint interval) EGLBoolean EGLAPIENTRY eglSwapInterval(EGLDisplay dpy, EGLint interval)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, EGLint interval = %d)", dpy, interval); TRACE("(EGLDisplay dpy = 0x%0.8p, EGLint interval = %d)", dpy, interval);
try
{
egl::Display *display = static_cast<egl::Display*>(dpy);
if(!validateDisplay(display)) egl::Display *display = static_cast<egl::Display*>(dpy);
{
return EGL_FALSE;
}
egl::Surface *draw_surface = static_cast<egl::Surface*>(egl::getCurrentDrawSurface()); if(!validateDisplay(display))
{
return EGL_FALSE;
}
if(draw_surface == NULL) egl::Surface *draw_surface = static_cast<egl::Surface*>(egl::getCurrentDrawSurface());
{
return error(EGL_BAD_SURFACE, EGL_FALSE);
}
draw_surface->setSwapInterval(interval); if(draw_surface == NULL)
{
return error(EGL_BAD_SURFACE, EGL_FALSE);
}
return success(EGL_TRUE); draw_surface->setSwapInterval(interval);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE; return success(EGL_TRUE);
} }
EGLContext EGLAPIENTRY eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list) EGLContext EGLAPIENTRY eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, EGLConfig config = 0x%0.8p, EGLContext share_context = 0x%0.8p, " TRACE("(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); "const EGLint *attrib_list = 0x%0.8p)", dpy, config, share_context, attrib_list);
try EGLint clientVersion = 1;
{ if(attrib_list)
EGLint clientVersion = 1; {
if(attrib_list) for(const EGLint* attribute = attrib_list; attribute[0] != EGL_NONE; attribute += 2)
{ {
for(const EGLint* attribute = attrib_list; attribute[0] != EGL_NONE; attribute += 2) if(attribute[0] == EGL_CONTEXT_CLIENT_VERSION)
{ {
if(attribute[0] == EGL_CONTEXT_CLIENT_VERSION) clientVersion = attribute[1];
{ }
clientVersion = attribute[1]; else
} {
else return error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT);
{ }
return error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT); }
} }
}
} egl::Display *display = static_cast<egl::Display*>(dpy);
egl::Display *display = static_cast<egl::Display*>(dpy); if(!validateConfig(display, config))
{
if(!validateConfig(display, config)) return EGL_NO_CONTEXT;
{ }
return EGL_NO_CONTEXT;
} return display->createContext(config, static_cast<egl::Context*>(share_context), clientVersion);
return display->createContext(config, static_cast<egl::Context*>(share_context), clientVersion);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_NO_CONTEXT);
}
return EGL_NO_CONTEXT;
} }
EGLBoolean EGLAPIENTRY eglDestroyContext(EGLDisplay dpy, EGLContext ctx) EGLBoolean EGLAPIENTRY eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, EGLContext ctx = 0x%0.8p)", dpy, ctx); TRACE("(EGLDisplay dpy = 0x%0.8p, EGLContext ctx = 0x%0.8p)", dpy, ctx);
try
{
egl::Display *display = static_cast<egl::Display*>(dpy);
egl::Context *context = static_cast<egl::Context*>(ctx);
if(!validateContext(display, context)) egl::Display *display = static_cast<egl::Display*>(dpy);
{ egl::Context *context = static_cast<egl::Context*>(ctx);
return EGL_FALSE;
}
if(ctx == EGL_NO_CONTEXT) if(!validateContext(display, context))
{ {
return error(EGL_BAD_CONTEXT, EGL_FALSE); return EGL_FALSE;
} }
display->destroyContext(context); if(ctx == EGL_NO_CONTEXT)
{
return error(EGL_BAD_CONTEXT, EGL_FALSE);
}
return success(EGL_TRUE); display->destroyContext(context);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE; return success(EGL_TRUE);
} }
EGLBoolean EGLAPIENTRY eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) EGLBoolean EGLAPIENTRY eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, EGLSurface draw = 0x%0.8p, EGLSurface read = 0x%0.8p, EGLContext ctx = 0x%0.8p)", TRACE("(EGLDisplay dpy = 0x%0.8p, EGLSurface draw = 0x%0.8p, EGLSurface read = 0x%0.8p, EGLContext ctx = 0x%0.8p)",
dpy, draw, read, ctx); dpy, draw, read, ctx);
try
{
egl::Display *display = static_cast<egl::Display*>(dpy);
egl::Context *context = static_cast<egl::Context*>(ctx);
if(ctx != EGL_NO_CONTEXT || draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE) egl::Display *display = static_cast<egl::Display*>(dpy);
{ egl::Context *context = static_cast<egl::Context*>(ctx);
if(!validateDisplay(display))
{
return EGL_FALSE;
}
}
if(ctx == EGL_NO_CONTEXT && (draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE)) if(ctx != EGL_NO_CONTEXT || draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE)
{
if(!validateDisplay(display))
{ {
return error(EGL_BAD_MATCH, EGL_FALSE); return EGL_FALSE;
} }
}
if(ctx != EGL_NO_CONTEXT && !validateContext(display, context)) if(ctx == EGL_NO_CONTEXT && (draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE))
{ {
return EGL_FALSE; return error(EGL_BAD_MATCH, EGL_FALSE);
} }
if((draw != EGL_NO_SURFACE && !validateSurface(display, static_cast<egl::Surface*>(draw))) || if(ctx != EGL_NO_CONTEXT && !validateContext(display, context))
(read != EGL_NO_SURFACE && !validateSurface(display, static_cast<egl::Surface*>(read)))) {
{ return EGL_FALSE;
return EGL_FALSE; }
}
if((draw != EGL_NO_SURFACE) ^ (read != EGL_NO_SURFACE)) if((draw != EGL_NO_SURFACE && !validateSurface(display, static_cast<egl::Surface*>(draw))) ||
{ (read != EGL_NO_SURFACE && !validateSurface(display, static_cast<egl::Surface*>(read))))
return error(EGL_BAD_MATCH, EGL_FALSE); {
} return EGL_FALSE;
}
if(draw != read) if((draw != EGL_NO_SURFACE) ^ (read != EGL_NO_SURFACE))
{ {
UNIMPLEMENTED(); // FIXME return error(EGL_BAD_MATCH, EGL_FALSE);
} }
egl::setCurrentDisplay(dpy); if(draw != read)
egl::setCurrentDrawSurface(draw); {
egl::setCurrentReadSurface(read); UNIMPLEMENTED(); // FIXME
egl::setCurrentContext(ctx); }
if(context) egl::setCurrentDisplay(dpy);
{ egl::setCurrentDrawSurface(draw);
context->makeCurrent(static_cast<egl::Surface*>(draw)); egl::setCurrentReadSurface(read);
} egl::setCurrentContext(ctx);
return success(EGL_TRUE); if(context)
} {
catch(std::bad_alloc&) context->makeCurrent(static_cast<egl::Surface*>(draw));
{ }
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE; return success(EGL_TRUE);
} }
EGLContext EGLAPIENTRY eglGetCurrentContext(void) EGLContext EGLAPIENTRY eglGetCurrentContext(void)
{ {
TRACE("()"); TRACE("()");
try
{
EGLContext context = egl::getCurrentContext();
return success(context); EGLContext context = egl::getCurrentContext();
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_NO_CONTEXT);
}
return EGL_NO_CONTEXT; return success(context);
} }
EGLSurface EGLAPIENTRY eglGetCurrentSurface(EGLint readdraw) EGLSurface EGLAPIENTRY eglGetCurrentSurface(EGLint readdraw)
{ {
TRACE("(EGLint readdraw = %d)", readdraw); TRACE("(EGLint readdraw = %d)", readdraw);
try if(readdraw == EGL_READ)
{ {
if(readdraw == EGL_READ) EGLSurface read = egl::getCurrentReadSurface();
{ return success(read);
EGLSurface read = egl::getCurrentReadSurface(); }
return success(read); else if(readdraw == EGL_DRAW)
} {
else if(readdraw == EGL_DRAW) EGLSurface draw = egl::getCurrentDrawSurface();
{ return success(draw);
EGLSurface draw = egl::getCurrentDrawSurface(); }
return success(draw); else
} {
else return error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
{ }
return error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
}
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
}
return EGL_NO_SURFACE;
} }
EGLDisplay EGLAPIENTRY eglGetCurrentDisplay(void) EGLDisplay EGLAPIENTRY eglGetCurrentDisplay(void)
{ {
TRACE("()"); TRACE("()");
try
{
EGLDisplay dpy = egl::getCurrentDisplay();
return success(dpy); EGLDisplay dpy = egl::getCurrentDisplay();
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_NO_DISPLAY);
}
return EGL_NO_DISPLAY; return success(dpy);
} }
EGLBoolean EGLAPIENTRY eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value) EGLBoolean EGLAPIENTRY eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, EGLContext ctx = 0x%0.8p, EGLint attribute = %d, EGLint *value = 0x%0.8p)", TRACE("(EGLDisplay dpy = 0x%0.8p, EGLContext ctx = 0x%0.8p, EGLint attribute = %d, EGLint *value = 0x%0.8p)",
dpy, ctx, attribute, value); dpy, ctx, attribute, value);
try
{
egl::Display *display = static_cast<egl::Display*>(dpy);
egl::Context *context = static_cast<egl::Context*>(ctx);
if(!validateContext(display, context)) egl::Display *display = static_cast<egl::Display*>(dpy);
{ egl::Context *context = static_cast<egl::Context*>(ctx);
return EGL_FALSE;
}
UNIMPLEMENTED(); // FIXME if(!validateContext(display, context))
{
return EGL_FALSE;
}
return success(0); UNIMPLEMENTED(); // FIXME
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE; return success(0);
} }
EGLBoolean EGLAPIENTRY eglWaitGL(void) EGLBoolean EGLAPIENTRY eglWaitGL(void)
{ {
TRACE("()"); TRACE("()");
try UNIMPLEMENTED(); // FIXME
{
UNIMPLEMENTED(); // FIXME
return success(0); return success(EGL_FALSE);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE;
} }
EGLBoolean EGLAPIENTRY eglWaitNative(EGLint engine) EGLBoolean EGLAPIENTRY eglWaitNative(EGLint engine)
{ {
TRACE("(EGLint engine = %d)", engine); TRACE("(EGLint engine = %d)", engine);
try
{
UNIMPLEMENTED(); // FIXME
return success(0); UNIMPLEMENTED(); // FIXME
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE; return success(EGL_FALSE);
} }
EGLBoolean EGLAPIENTRY eglSwapBuffers(EGLDisplay dpy, EGLSurface surface) EGLBoolean EGLAPIENTRY eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p)", dpy, surface); TRACE("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p)", dpy, surface);
try
{
egl::Display *display = static_cast<egl::Display*>(dpy);
egl::Surface *eglSurface = (egl::Surface*)surface;
if(!validateSurface(display, eglSurface)) egl::Display *display = static_cast<egl::Display*>(dpy);
{ egl::Surface *eglSurface = (egl::Surface*)surface;
return EGL_FALSE;
}
if(surface == EGL_NO_SURFACE) if(!validateSurface(display, eglSurface))
{ {
return error(EGL_BAD_SURFACE, EGL_FALSE); return EGL_FALSE;
} }
eglSurface->swap(); if(surface == EGL_NO_SURFACE)
{
return error(EGL_BAD_SURFACE, EGL_FALSE);
}
return success(EGL_TRUE); eglSurface->swap();
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE; return success(EGL_TRUE);
} }
EGLBoolean EGLAPIENTRY eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target) EGLBoolean EGLAPIENTRY eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLNativePixmapType target = 0x%0.8p)", dpy, surface, target); TRACE("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLNativePixmapType target = 0x%0.8p)", dpy, surface, target);
try egl::Display *display = static_cast<egl::Display*>(dpy);
{ egl::Surface *eglSurface = static_cast<egl::Surface*>(surface);
egl::Display *display = static_cast<egl::Display*>(dpy);
egl::Surface *eglSurface = static_cast<egl::Surface*>(surface);
if(!validateSurface(display, eglSurface)) if(!validateSurface(display, eglSurface))
{ {
return EGL_FALSE; return EGL_FALSE;
} }
UNIMPLEMENTED(); // FIXME UNIMPLEMENTED(); // FIXME
return success(0); return success(EGL_FALSE);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE;
} }
EGLImageKHR EGLAPIENTRY eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list) EGLImageKHR EGLAPIENTRY eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, EGLContext ctx = 0x%0.8p, EGLenum target = 0x%X, buffer = 0x%0.8p, const EGLint attrib_list = 0x%0.8p)", dpy, ctx, target, buffer, attrib_list); TRACE("(EGLDisplay dpy = 0x%0.8p, EGLContext ctx = 0x%0.8p, EGLenum target = 0x%X, buffer = 0x%0.8p, const EGLint attrib_list = 0x%0.8p)", dpy, ctx, target, buffer, attrib_list);
try egl::Display *display = static_cast<egl::Display*>(dpy);
{ egl::Context *context = static_cast<egl::Context*>(ctx);
egl::Display *display = static_cast<egl::Display*>(dpy);
egl::Context *context = static_cast<egl::Context*>(ctx); if(!validateDisplay(display))
{
if(!validateDisplay(display)) return error(EGL_BAD_DISPLAY, EGL_NO_IMAGE_KHR);
{ }
return error(EGL_BAD_DISPLAY, EGL_NO_IMAGE_KHR);
} if(context != EGL_NO_CONTEXT && !display->isValidContext(context))
{
if(context != EGL_NO_CONTEXT && !display->isValidContext(context)) return error(EGL_BAD_CONTEXT, EGL_NO_IMAGE_KHR);
{ }
return error(EGL_BAD_CONTEXT, EGL_NO_IMAGE_KHR);
} EGLenum imagePreserved = EGL_FALSE;
GLuint textureLevel = 0;
EGLenum imagePreserved = EGL_FALSE; if(attrib_list)
GLuint textureLevel = 0; {
if(attrib_list) for(const EGLint *attribute = attrib_list; attribute[0] != EGL_NONE; attribute += 2)
{
for(const EGLint *attribute = attrib_list; attribute[0] != EGL_NONE; attribute += 2)
{
if(attribute[0] == EGL_IMAGE_PRESERVED_KHR)
{
imagePreserved = attribute[1];
}
else if(attribute[0] == EGL_GL_TEXTURE_LEVEL_KHR)
{
textureLevel = attribute[1];
}
else
{
return error(EGL_BAD_ATTRIBUTE, EGL_NO_IMAGE_KHR);
}
}
}
GLuint name = reinterpret_cast<intptr_t>(buffer);
if(name == 0)
{
return error(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
}
EGLenum validationResult = context->validateSharedImage(target, name, textureLevel);
if(validationResult != EGL_SUCCESS)
{ {
return error(validationResult, EGL_NO_IMAGE_KHR); if(attribute[0] == EGL_IMAGE_PRESERVED_KHR)
{
imagePreserved = attribute[1];
}
else if(attribute[0] == EGL_GL_TEXTURE_LEVEL_KHR)
{
textureLevel = attribute[1];
}
else
{
return error(EGL_BAD_ATTRIBUTE, EGL_NO_IMAGE_KHR);
}
} }
}
GLuint name = reinterpret_cast<intptr_t>(buffer);
if(name == 0)
{
return error(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
}
egl::Image *image = context->createSharedImage(target, name, textureLevel); EGLenum validationResult = context->validateSharedImage(target, name, textureLevel);
if(!image) if(validationResult != EGL_SUCCESS)
{ {
return error(EGL_BAD_MATCH, EGL_NO_IMAGE_KHR); return error(validationResult, EGL_NO_IMAGE_KHR);
} }
if(image->getMultiSampleDepth() > 1) egl::Image *image = context->createSharedImage(target, name, textureLevel);
{
return error(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
}
return success((EGLImageKHR)image); if(!image)
} {
catch(std::bad_alloc&) return error(EGL_BAD_MATCH, EGL_NO_IMAGE_KHR);
{ }
return error(EGL_BAD_ALLOC, EGL_NO_IMAGE_KHR);
}
return EGL_NO_IMAGE_KHR; if(image->getMultiSampleDepth() > 1)
{
return error(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
}
return success((EGLImageKHR)image);
} }
EGLBoolean EGLAPIENTRY eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image) EGLBoolean EGLAPIENTRY eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
{ {
TRACE("(EGLDisplay dpy = 0x%0.8p, EGLImageKHR image = 0x%0.8p)", dpy, image); TRACE("(EGLDisplay dpy = 0x%0.8p, EGLImageKHR image = 0x%0.8p)", dpy, image);
try egl::Display *display = static_cast<egl::Display*>(dpy);
{
egl::Display *display = static_cast<egl::Display*>(dpy);
if(!validateDisplay(display))
{
return error(EGL_BAD_DISPLAY, EGL_FALSE);
}
if(!image) if(!validateDisplay(display))
{ {
return error(EGL_BAD_PARAMETER, EGL_FALSE); return error(EGL_BAD_DISPLAY, EGL_FALSE);
} }
egl::Image *glImage = static_cast<egl::Image*>(image); if(!image)
glImage->destroyShared(); {
return error(EGL_BAD_PARAMETER, EGL_FALSE);
}
return success(EGL_TRUE); egl::Image *glImage = static_cast<egl::Image*>(image);
} glImage->destroyShared();
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_FALSE);
}
return EGL_FALSE; return success(EGL_TRUE);
} }
EGLDisplay EGLAPIENTRY eglGetPlatformDisplayEXT(EGLenum platform, void *native_display, const EGLint *attrib_list) EGLDisplay EGLAPIENTRY eglGetPlatformDisplayEXT(EGLenum platform, void *native_display, const EGLint *attrib_list)
{ {
TRACE("(EGLenum platform = 0x%X, void *native_display = 0x%0.8p, const EGLint *attrib_list = 0x%0.8p)", platform, native_display, attrib_list); TRACE("(EGLenum platform = 0x%X, void *native_display = 0x%0.8p, const EGLint *attrib_list = 0x%0.8p)", platform, native_display, attrib_list);
try return egl::Display::getPlatformDisplay(platform, (EGLNativeDisplayType)native_display);
{
return egl::Display::getPlatformDisplay(platform, (EGLNativeDisplayType)native_display);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, EGL_NO_DISPLAY);
}
return EGL_NO_DISPLAY;
} }
EGLSurface EGLAPIENTRY eglCreatePlatformWindowSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLint *attrib_list) EGLSurface EGLAPIENTRY eglCreatePlatformWindowSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLint *attrib_list)
{ {
return eglCreateWindowSurface(dpy, config, (EGLNativeWindowType)native_window, attrib_list); return eglCreateWindowSurface(dpy, config, (EGLNativeWindowType)native_window, attrib_list);
} }
EGLSurface EGLAPIENTRY eglCreatePlatformPixmapSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLint *attrib_list) EGLSurface EGLAPIENTRY eglCreatePlatformPixmapSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLint *attrib_list)
{ {
return eglCreatePixmapSurface(dpy, config, (EGLNativePixmapType)native_pixmap, attrib_list); return eglCreatePixmapSurface(dpy, config, (EGLNativePixmapType)native_pixmap, attrib_list);
} }
__eglMustCastToProperFunctionPointerType EGLAPIENTRY eglGetProcAddress(const char *procname) __eglMustCastToProperFunctionPointerType EGLAPIENTRY eglGetProcAddress(const char *procname)
{ {
TRACE("(const char *procname = \"%s\")", procname); TRACE("(const char *procname = \"%s\")", procname);
try struct Extension
{ {
struct Extension const char *name;
{ __eglMustCastToProperFunctionPointerType address;
const char *name; };
__eglMustCastToProperFunctionPointerType address;
};
static const Extension eglExtensions[] =
{
#define EXTENSION(name) {#name, (__eglMustCastToProperFunctionPointerType)name}
EXTENSION(eglCreateImageKHR),
EXTENSION(eglDestroyImageKHR),
EXTENSION(eglGetPlatformDisplayEXT),
EXTENSION(eglCreatePlatformWindowSurfaceEXT),
EXTENSION(eglCreatePlatformPixmapSurfaceEXT),
#undef EXTENSION
};
for(int ext = 0; ext < sizeof(eglExtensions) / sizeof(Extension); ext++)
{
if(strcmp(procname, eglExtensions[ext].name) == 0)
{
return (__eglMustCastToProperFunctionPointerType)eglExtensions[ext].address;
}
}
if(es2::getProcAddress != 0)
{
__eglMustCastToProperFunctionPointerType proc = es2::getProcAddress(procname);
if(proc) return proc;
}
if(es1::getProcAddress != 0) static const Extension eglExtensions[] =
{
#define EXTENSION(name) {#name, (__eglMustCastToProperFunctionPointerType)name}
EXTENSION(eglCreateImageKHR),
EXTENSION(eglDestroyImageKHR),
EXTENSION(eglGetPlatformDisplayEXT),
EXTENSION(eglCreatePlatformWindowSurfaceEXT),
EXTENSION(eglCreatePlatformPixmapSurfaceEXT),
#undef EXTENSION
};
for(int ext = 0; ext < sizeof(eglExtensions) / sizeof(Extension); ext++)
{
if(strcmp(procname, eglExtensions[ext].name) == 0)
{ {
__eglMustCastToProperFunctionPointerType proc = es1::getProcAddress(procname); return (__eglMustCastToProperFunctionPointerType)eglExtensions[ext].address;
if(proc) return proc;
} }
} }
catch(std::bad_alloc&)
{ if(es2::getProcAddress != 0)
return error(EGL_BAD_ALLOC, (__eglMustCastToProperFunctionPointerType)NULL); {
} __eglMustCastToProperFunctionPointerType proc = es2::getProcAddress(procname);
if(proc) return proc;
}
if(es1::getProcAddress != 0)
{
__eglMustCastToProperFunctionPointerType proc = es1::getProcAddress(procname);
if(proc) return proc;
}
return NULL; return NULL;
} }
} }
src/OpenGL/libGLES_CM/libGLES_CM.cpp
This source diff could not be displayed because it is too large. You can view the blob instead.
src/OpenGL/libGLESv2/libGLESv2.cpp
This source diff could not be displayed because it is too large. You can view the blob instead.
src/Reactor/Nucleus.hpp
...@@ -1358,7 +1358,6 @@ namespace sw ...@@ -1358,7 +1358,6 @@ namespace sw
// RValue<Bool> operator!=(RValue<Long1> lhs, RValue<Long1> rhs); // RValue<Bool> operator!=(RValue<Long1> lhs, RValue<Long1> rhs);
// RValue<Bool> operator==(RValue<Long1> lhs, RValue<Long1> rhs); // RValue<Bool> operator==(RValue<Long1> lhs, RValue<Long1> rhs);
// RValue<Long1> RoundLong1(RValue<Float> cast); // RValue<Long1> RoundLong1(RValue<Float> cast);
class Long2 : public Variable<Long2> class Long2 : public Variable<Long2>
...@@ -1512,7 +1511,6 @@ namespace sw ...@@ -1512,7 +1511,6 @@ namespace sw
static llvm::Type *getType(); static llvm::Type *getType();
}; };
RValue<Int2> operator+(RValue<Int2> lhs, RValue<Int2> rhs); RValue<Int2> operator+(RValue<Int2> lhs, RValue<Int2> rhs);
RValue<Int2> operator-(RValue<Int2> lhs, RValue<Int2> rhs); RValue<Int2> operator-(RValue<Int2> lhs, RValue<Int2> rhs);
// RValue<Int2> operator*(RValue<Int2> lhs, RValue<Int2> rhs); // RValue<Int2> operator*(RValue<Int2> lhs, RValue<Int2> rhs);
......
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