| /* |
| * Copyright (C) 2011 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| #ifdef _WIN32 |
| #undef EGLAPI |
| #define EGLAPI __declspec(dllexport) |
| #endif |
| |
| #include <EGL/egl.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <stdio.h> |
| #include "ThreadInfo.h" |
| #include <GLcommon/TranslatorIfaces.h> |
| #include <OpenglOsUtils/osDynLibrary.h> |
| |
| #include "EglWindowSurface.h" |
| #include "EglPbufferSurface.h" |
| #include "EglPixmapSurface.h" |
| #include "EglGlobalInfo.h" |
| #include "EglThreadInfo.h" |
| #include "EglValidate.h" |
| #include "EglDisplay.h" |
| #include "EglContext.h" |
| #include "EglConfig.h" |
| #include "EglOsApi.h" |
| #include "ClientAPIExts.h" |
| |
| #define MAJOR 1 |
| #define MINOR 4 |
| |
| //declarations |
| |
| EglImage *attachEGLImage(unsigned int imageId); |
| void detachEGLImage(unsigned int imageId); |
| GLEScontext* getGLESContext(); |
| |
| #define tls_thread EglThreadInfo::get() |
| |
| EglGlobalInfo* g_eglInfo = NULL; |
| android::Mutex s_eglLock; |
| |
| void initGlobalInfo() |
| { |
| android::Mutex::Autolock mutex(s_eglLock); |
| if (!g_eglInfo) { |
| g_eglInfo = EglGlobalInfo::getInstance(); |
| } |
| } |
| |
| static EGLiface s_eglIface = { |
| getGLESContext : getGLESContext, |
| eglAttachEGLImage:attachEGLImage, |
| eglDetachEGLImage:detachEGLImage |
| }; |
| |
| /***************************************** supported extentions ***********************************************************************/ |
| |
| //extentions |
| #define EGL_EXTENTIONS 2 |
| |
| //decleration |
| EGLImageKHR eglCreateImageKHR(EGLDisplay display, EGLContext context, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list); |
| EGLBoolean eglDestroyImageKHR(EGLDisplay display, EGLImageKHR image); |
| |
| // extentions descriptors |
| static ExtentionDescriptor s_eglExtentions[] = { |
| {"eglCreateImageKHR" ,(__eglMustCastToProperFunctionPointerType)eglCreateImageKHR}, |
| {"eglDestroyImageKHR",(__eglMustCastToProperFunctionPointerType)eglDestroyImageKHR} |
| }; |
| static int s_eglExtentionsSize = sizeof(s_eglExtentions) / |
| sizeof(ExtentionDescriptor); |
| |
| /****************************************************************************************************************************************/ |
| //macros for accessing global egl info & tls objects |
| |
| #define CURRENT_THREAD() do {} while (0); |
| |
| #define RETURN_ERROR(ret,err) \ |
| CURRENT_THREAD() \ |
| if(tls_thread->getError() == EGL_SUCCESS) { \ |
| tls_thread->setError(err); \ |
| } \ |
| return ret; |
| |
| #define VALIDATE_DISPLAY_RETURN(EGLDisplay,ret) \ |
| EglDisplay* dpy = g_eglInfo->getDisplay(EGLDisplay); \ |
| if(!dpy){ \ |
| RETURN_ERROR(ret,EGL_BAD_DISPLAY); \ |
| } \ |
| if(!dpy->isInitialize()) { \ |
| RETURN_ERROR(ret,EGL_NOT_INITIALIZED); \ |
| } |
| |
| #define VALIDATE_CONFIG_RETURN(EGLConfig,ret) \ |
| EglConfig* cfg = dpy->getConfig(EGLConfig); \ |
| if(!cfg) { \ |
| RETURN_ERROR(ret,EGL_BAD_CONFIG); \ |
| } |
| |
| #define VALIDATE_SURFACE_RETURN(EGLSurface,ret,varName) \ |
| SurfacePtr varName = dpy->getSurface(EGLSurface); \ |
| if(!varName.Ptr()) { \ |
| RETURN_ERROR(ret,EGL_BAD_SURFACE); \ |
| } |
| |
| #define VALIDATE_CONTEXT_RETURN(EGLContext,ret) \ |
| ContextPtr ctx = dpy->getContext(EGLContext); \ |
| if(!ctx.Ptr()) { \ |
| RETURN_ERROR(ret,EGL_BAD_CONTEXT); \ |
| } |
| |
| |
| #define VALIDATE_DISPLAY(EGLDisplay) \ |
| VALIDATE_DISPLAY_RETURN(EGLDisplay,EGL_FALSE) |
| |
| #define VALIDATE_CONFIG(EGLConfig) \ |
| VALIDATE_CONFIG_RETURN(EGLConfig,EGL_FALSE) |
| |
| #define VALIDATE_SURFACE(EGLSurface,varName) \ |
| VALIDATE_SURFACE_RETURN(EGLSurface,EGL_FALSE,varName) |
| |
| #define VALIDATE_CONTEXT(EGLContext) \ |
| VALIDATE_CONTEXT_RETURN(EGLContext,EGL_FALSE) |
| |
| |
| GLEScontext* getGLESContext() |
| { |
| ThreadInfo* thread = getThreadInfo(); |
| return thread->glesContext; |
| } |
| |
| EGLAPI EGLint EGLAPIENTRY eglGetError(void) { |
| CURRENT_THREAD(); |
| EGLint err = tls_thread->getError(); |
| tls_thread->setError(EGL_SUCCESS); |
| return err; |
| } |
| |
| EGLAPI EGLDisplay EGLAPIENTRY eglGetDisplay(EGLNativeDisplayType display_id) { |
| EglDisplay* dpy = NULL; |
| EGLNativeInternalDisplayType internalDisplay = NULL; |
| |
| initGlobalInfo(); |
| |
| if ((dpy = g_eglInfo->getDisplay(display_id))) { |
| return dpy; |
| } else { |
| |
| if( display_id == EGL_DEFAULT_DISPLAY) { |
| internalDisplay = g_eglInfo->getDefaultNativeDisplay(); |
| } else { |
| internalDisplay = g_eglInfo->generateInternalDisplay(display_id); |
| } |
| |
| dpy = g_eglInfo->addDisplay(display_id,internalDisplay); |
| if(dpy) return dpy; |
| return EGL_NO_DISPLAY; |
| } |
| } |
| |
| |
| #define TRANSLATOR_GETIFACE_NAME "__translator_getIfaces" |
| |
| static __translator_getGLESIfaceFunc loadIfaces(const char* libName){ |
| osUtils::dynLibrary* libGLES = osUtils::dynLibrary::open(libName); |
| |
| if(!libGLES) return NULL; |
| __translator_getGLESIfaceFunc func = (__translator_getGLESIfaceFunc)libGLES->findSymbol(TRANSLATOR_GETIFACE_NAME); |
| if(!func) return NULL; |
| return func; |
| } |
| |
| #define LIB_GLES_CM_NAME EMUGL_LIBNAME("GLES_CM_translator") |
| #define LIB_GLES_V2_NAME EMUGL_LIBNAME("GLES_V2_translator") |
| |
| EGLAPI EGLBoolean EGLAPIENTRY eglInitialize(EGLDisplay display, EGLint *major, EGLint *minor) { |
| |
| initGlobalInfo(); |
| |
| EglDisplay* dpy = g_eglInfo->getDisplay(display); |
| if(!dpy) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_DISPLAY); |
| } |
| |
| if(major) *major = MAJOR; |
| if(minor) *minor = MINOR; |
| |
| __translator_getGLESIfaceFunc func = NULL; |
| int renderableType = EGL_OPENGL_ES_BIT; |
| |
| if(!g_eglInfo->getIface(GLES_1_1)) { |
| func = loadIfaces(LIB_GLES_CM_NAME); |
| if(func){ |
| g_eglInfo->setIface(func(&s_eglIface),GLES_1_1); |
| } else { |
| fprintf(stderr,"could not find ifaces for GLES CM 1.1\n"); |
| return EGL_FALSE; |
| } |
| } |
| if(!g_eglInfo->getIface(GLES_2_0)) { |
| func = loadIfaces(LIB_GLES_V2_NAME); |
| if(func){ |
| renderableType |= EGL_OPENGL_ES2_BIT; |
| g_eglInfo->setIface(func(&s_eglIface),GLES_2_0); |
| } else { |
| fprintf(stderr,"could not find ifaces for GLES 2.0\n"); |
| } |
| } |
| dpy->initialize(renderableType); |
| return EGL_TRUE; |
| } |
| |
| EGLAPI EGLBoolean EGLAPIENTRY eglTerminate(EGLDisplay display) { |
| VALIDATE_DISPLAY(display); |
| dpy->terminate(); |
| return EGL_TRUE; |
| } |
| |
| EGLAPI const char * EGLAPIENTRY eglQueryString(EGLDisplay display, EGLint name) { |
| VALIDATE_DISPLAY(display); |
| static const char* vendor = "Google"; |
| static const char* version = "1.4"; |
| static const char* extensions = "EGL_KHR_image_base EGL_KHR_gl_texture_2D_image"; |
| if(!EglValidate::stringName(name)) { |
| RETURN_ERROR(NULL,EGL_BAD_PARAMETER); |
| } |
| switch(name) { |
| case EGL_VENDOR: |
| return vendor; |
| case EGL_VERSION: |
| return version; |
| case EGL_EXTENSIONS: |
| return extensions; |
| } |
| return NULL; |
| } |
| |
| EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigs(EGLDisplay display, EGLConfig *configs, |
| EGLint config_size, EGLint *num_config) { |
| VALIDATE_DISPLAY(display); |
| if(!num_config) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_PARAMETER); |
| } |
| |
| if(configs == NULL) { |
| *num_config = dpy->nConfigs(); |
| } else { |
| *num_config = dpy->getConfigs(configs,config_size); |
| } |
| |
| return EGL_TRUE; |
| } |
| |
| EGLAPI EGLBoolean EGLAPIENTRY eglChooseConfig(EGLDisplay display, const EGLint *attrib_list, |
| EGLConfig *configs, EGLint config_size, |
| EGLint *num_config) { |
| VALIDATE_DISPLAY(display); |
| if(!num_config) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_PARAMETER); |
| } |
| |
| //selection defaults |
| EGLint surface_type = EGL_WINDOW_BIT; |
| EGLint renderable_type = EGL_OPENGL_ES_BIT; |
| EGLBoolean bind_to_tex_rgb = EGL_DONT_CARE; |
| EGLBoolean bind_to_tex_rgba = EGL_DONT_CARE; |
| EGLenum caveat = EGL_DONT_CARE; |
| EGLint config_id = EGL_DONT_CARE; |
| EGLBoolean native_renderable = EGL_DONT_CARE; |
| EGLint native_visual_type = EGL_DONT_CARE; |
| EGLint max_swap_interval = EGL_DONT_CARE; |
| EGLint min_swap_interval = EGL_DONT_CARE; |
| EGLint trans_red_val = EGL_DONT_CARE; |
| EGLint trans_green_val = EGL_DONT_CARE; |
| EGLint trans_blue_val = EGL_DONT_CARE; |
| EGLenum transparent_type = EGL_NONE; |
| EGLint buffer_size = 0; |
| EGLint red_size = 0; |
| EGLint green_size = 0; |
| EGLint blue_size = 0; |
| EGLint alpha_size = 0; |
| EGLint depth_size = 0; |
| EGLint frame_buffer_level = 0; |
| EGLint sample_buffers_num = 0; |
| EGLint samples_per_pixel = 0; |
| EGLint stencil_size = 0; |
| |
| if(!EglValidate::noAttribs(attrib_list)) { //there are attribs |
| int i = 0 ; |
| bool hasConfigId = false; |
| while(attrib_list[i] != EGL_NONE && !hasConfigId) { |
| switch(attrib_list[i]) { |
| case EGL_MAX_PBUFFER_WIDTH: |
| case EGL_MAX_PBUFFER_HEIGHT: |
| case EGL_MAX_PBUFFER_PIXELS: |
| case EGL_NATIVE_VISUAL_ID: |
| break; //we dont care from those selection crateria |
| case EGL_LEVEL: |
| if(attrib_list[i+1] == EGL_DONT_CARE) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); |
| } |
| frame_buffer_level = attrib_list[i+1]; |
| break; |
| case EGL_BUFFER_SIZE: |
| if(attrib_list[i+1] < 0) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); |
| } |
| buffer_size = attrib_list[i+1]; |
| break; |
| case EGL_RED_SIZE: |
| if(attrib_list[i+1] < 0) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); |
| } |
| red_size = attrib_list[i+1]; |
| break; |
| case EGL_GREEN_SIZE: |
| if(attrib_list[i+1] < 0) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); |
| } |
| green_size = attrib_list[i+1]; |
| break; |
| case EGL_BLUE_SIZE: |
| if(attrib_list[i+1] < 0) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); |
| } |
| blue_size = attrib_list[i+1]; |
| break; |
| case EGL_ALPHA_SIZE: |
| if(attrib_list[i+1] < 0) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); |
| } |
| alpha_size = attrib_list[i+1]; |
| break; |
| case EGL_BIND_TO_TEXTURE_RGB: |
| bind_to_tex_rgb = attrib_list[i+1]; |
| break; |
| case EGL_BIND_TO_TEXTURE_RGBA: |
| bind_to_tex_rgba = attrib_list[i+1]; |
| break; |
| case EGL_CONFIG_CAVEAT: |
| if(attrib_list[i+1] != EGL_NONE && attrib_list[i+1] != EGL_SLOW_CONFIG && attrib_list[i+1] != EGL_NON_CONFORMANT_CONFIG) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); |
| } |
| caveat = attrib_list[i+1]; |
| break; |
| case EGL_CONFIG_ID: |
| if(attrib_list[i+1] < 0) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); |
| } |
| config_id = attrib_list[i+1]; |
| hasConfigId = true; |
| break; |
| case EGL_DEPTH_SIZE: |
| if(attrib_list[i+1] < 0) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); |
| } |
| depth_size = attrib_list[i+1]; |
| break; |
| case EGL_MAX_SWAP_INTERVAL: |
| if(attrib_list[i+1] < 0) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); |
| } |
| max_swap_interval = attrib_list[i+1]; |
| break; |
| case EGL_MIN_SWAP_INTERVAL: |
| if(attrib_list[i+1] < 0) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); |
| } |
| min_swap_interval = attrib_list[i+1]; |
| break; |
| case EGL_NATIVE_RENDERABLE: |
| native_renderable = attrib_list[i+1]; |
| break; |
| case EGL_RENDERABLE_TYPE: |
| renderable_type = attrib_list[i+1]; |
| break; |
| case EGL_NATIVE_VISUAL_TYPE: |
| native_visual_type = attrib_list[i+1]; |
| break; |
| if(attrib_list[i+1] < 0 || attrib_list[i+1] > 1 ) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); |
| } |
| case EGL_SAMPLE_BUFFERS: |
| sample_buffers_num = attrib_list[i+1]; |
| break; |
| if(attrib_list[i+1] < 0) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); |
| } |
| case EGL_SAMPLES: |
| if(attrib_list[i+1] < 0) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); |
| } |
| samples_per_pixel = attrib_list[i+1]; |
| break; |
| case EGL_STENCIL_SIZE: |
| if(attrib_list[i+1] < 0) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); |
| } |
| stencil_size = attrib_list[i+1]; |
| break; |
| case EGL_SURFACE_TYPE: |
| surface_type = attrib_list[i+1]; |
| break; |
| case EGL_TRANSPARENT_TYPE: |
| if(attrib_list[i+1] != EGL_NONE && attrib_list[i+1] != EGL_TRANSPARENT_RGB ) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); |
| } |
| transparent_type = attrib_list[i+1]; |
| break; |
| case EGL_TRANSPARENT_RED_VALUE: |
| trans_red_val = attrib_list[i+1]; |
| break; |
| case EGL_TRANSPARENT_GREEN_VALUE: |
| trans_green_val = attrib_list[i+1]; |
| break; |
| case EGL_TRANSPARENT_BLUE_VALUE: |
| trans_blue_val = attrib_list[i+1]; |
| break; |
| default: |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); |
| } |
| i+=2; |
| } |
| if(hasConfigId) { |
| EglConfig* pConfig = dpy->getConfig(config_id); |
| if(pConfig) { |
| if(configs) { |
| configs[0] = static_cast<EGLConfig>(pConfig); |
| } |
| *num_config = 1; |
| return EGL_TRUE; |
| } else { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); |
| } |
| } |
| } |
| EGLNativePixelFormatType tmpfrmt = PIXEL_FORMAT_INITIALIZER; |
| EglConfig dummy(red_size,green_size,blue_size,alpha_size,caveat,config_id,depth_size, |
| frame_buffer_level,0,0,0,native_renderable,renderable_type,0,native_visual_type, |
| samples_per_pixel,stencil_size,surface_type,transparent_type, |
| trans_red_val,trans_green_val,trans_blue_val,tmpfrmt); |
| |
| *num_config = dpy->chooseConfigs(dummy,configs,config_size); |
| |
| |
| return EGL_TRUE; |
| } |
| |
| EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigAttrib(EGLDisplay display, EGLConfig config, |
| EGLint attribute, EGLint *value) { |
| VALIDATE_DISPLAY(display); |
| VALIDATE_CONFIG(config); |
| if(!EglValidate::confAttrib(attribute)){ |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); |
| } |
| return cfg->getConfAttrib(attribute,value)? EGL_TRUE:EGL_FALSE; |
| } |
| |
| EGLAPI EGLSurface EGLAPIENTRY eglCreateWindowSurface(EGLDisplay display, EGLConfig config, |
| EGLNativeWindowType win, |
| const EGLint *attrib_list) { |
| VALIDATE_DISPLAY_RETURN(display,EGL_NO_SURFACE); |
| VALIDATE_CONFIG_RETURN(config,EGL_NO_SURFACE); |
| |
| if(!(cfg->surfaceType() & EGL_WINDOW_BIT)) { |
| RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_MATCH); |
| } |
| if(!EglOS::validNativeWin(dpy->nativeType(),win)) { |
| RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_NATIVE_WINDOW); |
| } |
| if(!EglValidate::noAttribs(attrib_list)) { |
| RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ATTRIBUTE); |
| } |
| if(EglWindowSurface::alreadyAssociatedWithConfig(win)) { |
| RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ALLOC); |
| } |
| |
| unsigned int width,height; |
| if(!EglOS::checkWindowPixelFormatMatch(dpy->nativeType(),win,cfg,&width,&height)) { |
| RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ALLOC); |
| } |
| SurfacePtr wSurface(new EglWindowSurface(dpy, win,cfg,width,height)); |
| if(!wSurface.Ptr()) { |
| RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ALLOC); |
| } |
| return dpy->addSurface(wSurface); |
| } |
| |
| EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferSurface(EGLDisplay display, EGLConfig config, |
| const EGLint *attrib_list) { |
| VALIDATE_DISPLAY_RETURN(display,EGL_NO_SURFACE); |
| VALIDATE_CONFIG_RETURN(config,EGL_NO_SURFACE); |
| if(!(cfg->surfaceType() & EGL_PBUFFER_BIT)) { |
| RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_MATCH); |
| } |
| |
| |
| SurfacePtr pbSurface(new EglPbufferSurface(dpy,cfg)); |
| if(!pbSurface.Ptr()) { |
| RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ALLOC); |
| } |
| |
| if(!EglValidate::noAttribs(attrib_list)) { //there are attribs |
| int i = 0 ; |
| while(attrib_list[i] != EGL_NONE) { |
| if(!pbSurface->setAttrib(attrib_list[i],attrib_list[i+1])) { |
| RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ATTRIBUTE); |
| } |
| i+=2; |
| } |
| } |
| |
| EGLint width,height,largest,texTarget,texFormat; |
| EglPbufferSurface* tmpPbSurfacePtr = static_cast<EglPbufferSurface*>(pbSurface.Ptr()); |
| tmpPbSurfacePtr->getDim(&width,&height,&largest); |
| tmpPbSurfacePtr->getTexInfo(&texTarget,&texFormat); |
| |
| if(!EglValidate::pbufferAttribs(width,height,texFormat == EGL_NO_TEXTURE,texTarget == EGL_NO_TEXTURE)) { |
| //TODO: RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_VALUE); dont have bad_value |
| RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ATTRIBUTE); |
| } |
| |
| EGLNativeSurfaceType pb = EglOS::createPbufferSurface(dpy->nativeType(),cfg,tmpPbSurfacePtr); |
| if(!pb) { |
| //TODO: RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_VALUE); dont have bad value |
| RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ATTRIBUTE); |
| } |
| |
| tmpPbSurfacePtr->setNativePbuffer(pb); |
| return dpy->addSurface(pbSurface); |
| } |
| |
| EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurface(EGLDisplay display, EGLConfig config, |
| EGLNativePixmapType pixmap, |
| const EGLint *attrib_list) { |
| VALIDATE_DISPLAY_RETURN(display,EGL_NO_SURFACE); |
| VALIDATE_CONFIG_RETURN(config,EGL_NO_SURFACE); |
| if(!(cfg->surfaceType() & EGL_PIXMAP_BIT)) { |
| RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_MATCH); |
| } |
| if(!EglValidate::noAttribs(attrib_list)) { |
| RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ATTRIBUTE); |
| } |
| if(EglPixmapSurface::alreadyAssociatedWithConfig(pixmap)) { |
| RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ALLOC); |
| } |
| |
| unsigned int width,height; |
| if(!EglOS::checkPixmapPixelFormatMatch(dpy->nativeType(),pixmap,cfg,&width,&height)) { |
| RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ALLOC); |
| } |
| SurfacePtr pixSurface(new EglPixmapSurface(dpy, pixmap,cfg)); |
| if(!pixSurface.Ptr()) { |
| RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ALLOC); |
| } |
| |
| return dpy->addSurface(pixSurface); |
| } |
| |
| EGLAPI EGLBoolean EGLAPIENTRY eglDestroySurface(EGLDisplay display, EGLSurface surface) { |
| VALIDATE_DISPLAY(display); |
| SurfacePtr srfc = dpy->getSurface(surface); |
| if(!srfc.Ptr()) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_SURFACE); |
| } |
| |
| dpy->removeSurface(surface); |
| return EGL_TRUE; |
| } |
| |
| EGLAPI EGLBoolean EGLAPIENTRY eglQuerySurface(EGLDisplay display, EGLSurface surface, |
| EGLint attribute, EGLint *value) { |
| VALIDATE_DISPLAY(display); |
| VALIDATE_SURFACE(surface,srfc); |
| |
| if(!srfc->getAttrib(attribute,value)) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); |
| } |
| return EGL_TRUE; |
| } |
| |
| EGLAPI EGLBoolean EGLAPIENTRY eglSurfaceAttrib(EGLDisplay display, EGLSurface surface, |
| EGLint attribute, EGLint value) { |
| VALIDATE_DISPLAY(display); |
| VALIDATE_SURFACE(surface,srfc); |
| if(!srfc->setAttrib(attribute,value)) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); |
| } |
| return EGL_TRUE; |
| } |
| |
| EGLAPI EGLContext EGLAPIENTRY eglCreateContext(EGLDisplay display, EGLConfig config, |
| EGLContext share_context, |
| const EGLint *attrib_list) { |
| VALIDATE_DISPLAY_RETURN(display,EGL_NO_CONTEXT); |
| VALIDATE_CONFIG_RETURN(config,EGL_NO_CONTEXT); |
| |
| GLESVersion version = GLES_1_1; |
| if(!EglValidate::noAttribs(attrib_list)) { |
| int i = 0; |
| while(attrib_list[i] != EGL_NONE) { |
| switch(attrib_list[i]) { |
| case EGL_CONTEXT_CLIENT_VERSION: |
| if(attrib_list[i+1] == 2) { |
| version = GLES_2_0; |
| } else { |
| version = GLES_1_1; |
| } |
| break; |
| default: |
| RETURN_ERROR(EGL_NO_CONTEXT,EGL_BAD_ATTRIBUTE); |
| } |
| i+=2; |
| } |
| } |
| GLESiface* iface = g_eglInfo->getIface(version); |
| GLEScontext* glesCtx = NULL; |
| if(iface) { |
| glesCtx = iface->createGLESContext(); |
| } else { // there is no interface for this gles version |
| RETURN_ERROR(EGL_NO_CONTEXT,EGL_BAD_ATTRIBUTE); |
| } |
| |
| ContextPtr sharedCtxPtr; |
| EGLNativeContextType nativeShared = NULL; |
| if(share_context != EGL_NO_CONTEXT) { |
| sharedCtxPtr = dpy->getContext(share_context); |
| if(!sharedCtxPtr.Ptr()) { |
| RETURN_ERROR(EGL_NO_CONTEXT,EGL_BAD_CONTEXT); |
| } |
| nativeShared = sharedCtxPtr->nativeType(); |
| } |
| |
| EGLNativeContextType globalSharedContext = dpy->getGlobalSharedContext(); |
| EGLNativeContextType nativeContext = EglOS::createContext(dpy->nativeType(),cfg,globalSharedContext); |
| |
| if(nativeContext) { |
| ContextPtr ctx(new EglContext(dpy, nativeContext,sharedCtxPtr,cfg,glesCtx,version,dpy->getManager(version))); |
| return dpy->addContext(ctx); |
| } else { |
| iface->deleteGLESContext(glesCtx); |
| } |
| |
| return EGL_NO_CONTEXT; |
| } |
| |
| EGLAPI EGLBoolean EGLAPIENTRY eglDestroyContext(EGLDisplay display, EGLContext context) { |
| VALIDATE_DISPLAY(display); |
| VALIDATE_CONTEXT(context); |
| |
| dpy->removeContext(context); |
| return EGL_TRUE; |
| } |
| |
| EGLAPI EGLBoolean EGLAPIENTRY eglMakeCurrent(EGLDisplay display, EGLSurface draw, |
| EGLSurface read, EGLContext context) { |
| VALIDATE_DISPLAY(display); |
| |
| |
| bool releaseContext = EglValidate::releaseContext(context,read,draw); |
| if(!releaseContext && EglValidate::badContextMatch(context,read,draw)) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_MATCH); |
| } |
| |
| ThreadInfo* thread = getThreadInfo(); |
| ContextPtr prevCtx = thread->eglContext; |
| |
| if(releaseContext) { //releasing current context |
| if(prevCtx.Ptr()) { |
| g_eglInfo->getIface(prevCtx->version())->flush(); |
| if(!EglOS::makeCurrent(dpy->nativeType(),NULL,NULL,NULL)) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ACCESS); |
| } |
| thread->updateInfo(ContextPtr(NULL),dpy,NULL,ShareGroupPtr(NULL),dpy->getManager(prevCtx->version())); |
| } |
| } else { //assining new context |
| VALIDATE_CONTEXT(context); |
| VALIDATE_SURFACE(draw,newDrawSrfc); |
| VALIDATE_SURFACE(read,newReadSrfc); |
| |
| EglSurface* newDrawPtr = newDrawSrfc.Ptr(); |
| EglSurface* newReadPtr = newReadSrfc.Ptr(); |
| ContextPtr newCtx = ctx; |
| |
| if (newCtx.Ptr() && prevCtx.Ptr()) { |
| if (newCtx.Ptr() == prevCtx.Ptr()) { |
| if (newDrawPtr == prevCtx->draw().Ptr() && |
| newReadPtr == prevCtx->read().Ptr()) { |
| // nothing to do |
| return EGL_TRUE; |
| } |
| } |
| else { |
| // Make sure previous context is detached from surfaces |
| releaseContext = true; |
| } |
| } |
| |
| //surfaces compitability check |
| if(!((*ctx->getConfig()).compitableWith((*newDrawPtr->getConfig()))) || |
| !((*ctx->getConfig()).compitableWith((*newReadPtr->getConfig())))) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_MATCH); |
| } |
| |
| EGLNativeInternalDisplayType nativeDisplay = dpy->nativeType(); |
| EGLNativeSurfaceType nativeRead = newReadPtr->native(); |
| EGLNativeSurfaceType nativeDraw = newDrawPtr->native(); |
| //checking native window validity |
| if(newReadPtr->type() == EglSurface::WINDOW && !EglOS::validNativeWin(nativeDisplay,nativeRead)) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_NATIVE_WINDOW); |
| } |
| if(newDrawPtr->type() == EglSurface::WINDOW && !EglOS::validNativeWin(nativeDisplay,nativeDraw)) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_NATIVE_WINDOW); |
| } |
| |
| //checking native pixmap validity |
| if(newReadPtr->type() == EglSurface::PIXMAP && !EglOS::validNativePixmap(nativeDisplay,nativeRead)) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_NATIVE_PIXMAP); |
| } |
| if(newDrawPtr->type() == EglSurface::PIXMAP && !EglOS::validNativePixmap(nativeDisplay,nativeDraw)) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_NATIVE_PIXMAP); |
| } |
| if(prevCtx.Ptr()) { |
| g_eglInfo->getIface(prevCtx->version())->flush(); |
| } |
| if(!EglOS::makeCurrent(dpy->nativeType(),newReadPtr,newDrawPtr,newCtx->nativeType())) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ACCESS); |
| } |
| //TODO: handle the following errors |
| // EGL_BAD_CURRENT_SURFACE , EGL_CONTEXT_LOST , EGL_BAD_ACCESS |
| |
| thread->updateInfo(newCtx,dpy,newCtx->getGlesContext(),newCtx->getShareGroup(),dpy->getManager(newCtx->version())); |
| newCtx->setSurfaces(newReadSrfc,newDrawSrfc); |
| g_eglInfo->getIface(newCtx->version())->initContext(newCtx->getGlesContext(),newCtx->getShareGroup()); |
| |
| // Initialize the GLES extension function table used in |
| // eglGetProcAddress for the context's GLES version if not |
| // yet initialized. We initialize it here to make sure we call the |
| // GLES getProcAddress after when a context is bound. |
| g_eglInfo->initClientExtFuncTable(newCtx->version()); |
| } |
| |
| // release previous context surface binding |
| if(prevCtx.Ptr() && releaseContext) { |
| prevCtx->setSurfaces(SurfacePtr(NULL),SurfacePtr(NULL)); |
| } |
| |
| return EGL_TRUE; |
| } |
| |
| EGLAPI EGLBoolean EGLAPIENTRY eglQueryContext(EGLDisplay display, EGLContext context, |
| EGLint attribute, EGLint *value) { |
| VALIDATE_DISPLAY(display); |
| VALIDATE_CONTEXT(context); |
| |
| if(!ctx->getAttrib(attribute,value)){ |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); |
| } |
| return EGL_TRUE; |
| } |
| |
| EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffers(EGLDisplay display, EGLSurface surface) { |
| VALIDATE_DISPLAY(display); |
| VALIDATE_SURFACE(surface,Srfc); |
| ThreadInfo* thread = getThreadInfo(); |
| ContextPtr currentCtx = thread->eglContext; |
| |
| |
| //if surface not window return |
| if(Srfc->type() != EglSurface::WINDOW){ |
| RETURN_ERROR(EGL_TRUE,EGL_SUCCESS); |
| } |
| |
| if(!currentCtx.Ptr() || !currentCtx->usingSurface(Srfc) || !EglOS::validNativeWin(dpy->nativeType(),Srfc.Ptr()->native())) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_SURFACE); |
| } |
| |
| EglOS::swapBuffers(dpy->nativeType(),Srfc->native()); |
| return EGL_TRUE; |
| } |
| |
| EGLAPI EGLBoolean EGLAPIENTRY eglSwapInterval(EGLDisplay display, EGLint interval) { |
| VALIDATE_DISPLAY(display); |
| ThreadInfo* thread = getThreadInfo(); |
| ContextPtr currCtx = thread->eglContext; |
| if(currCtx.Ptr()) { |
| if(!currCtx->read().Ptr() || !currCtx->draw().Ptr() || currCtx->draw()->type()!=EglSurface::WINDOW) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_CURRENT_SURFACE); |
| } |
| EglOS::swapInterval(dpy->nativeType(),currCtx->draw()->native(),interval); |
| } else { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_SURFACE); |
| } |
| return EGL_TRUE; |
| } |
| |
| |
| EGLAPI EGLContext EGLAPIENTRY eglGetCurrentContext(void) { |
| ThreadInfo* thread = getThreadInfo(); |
| EglDisplay* dpy = static_cast<EglDisplay*>(thread->eglDisplay); |
| ContextPtr ctx = thread->eglContext; |
| if(dpy && ctx.Ptr()){ |
| // This double check is required because a context might still be current after it is destroyed - in which case |
| // its handle should be invalid, that is EGL_NO_CONTEXT should be returned even though the context is current |
| EGLContext c = (EGLContext)ctx->getHndl(); |
| if(dpy->getContext(c).Ptr()) |
| { |
| return c; |
| } |
| } |
| return EGL_NO_CONTEXT; |
| } |
| |
| EGLAPI EGLSurface EGLAPIENTRY eglGetCurrentSurface(EGLint readdraw) { |
| if(!EglValidate::surfaceTarget(readdraw)) return EGL_NO_SURFACE; |
| |
| ThreadInfo* thread = getThreadInfo(); |
| EglDisplay* dpy = static_cast<EglDisplay*>(thread->eglDisplay); |
| ContextPtr ctx = thread->eglContext; |
| |
| if(dpy && ctx.Ptr()) { |
| SurfacePtr surface = readdraw == EGL_READ ? ctx->read() : ctx->draw(); |
| if(surface.Ptr()) |
| { |
| // This double check is required because a surface might still be |
| // current after it is destroyed - in which case its handle should |
| // be invalid, that is EGL_NO_SURFACE should be returned even |
| // though the surface is current. |
| EGLSurface s = (EGLSurface)surface->getHndl(); |
| surface = dpy->getSurface(s); |
| if(surface.Ptr()) |
| { |
| return s; |
| } |
| } |
| } |
| return EGL_NO_SURFACE; |
| } |
| |
| EGLAPI EGLDisplay EGLAPIENTRY eglGetCurrentDisplay(void) { |
| ThreadInfo* thread = getThreadInfo(); |
| return (thread->eglContext.Ptr()) ? thread->eglDisplay : EGL_NO_DISPLAY; |
| } |
| |
| EGLAPI EGLBoolean EGLAPIENTRY eglWaitGL(void) { |
| EGLenum api = eglQueryAPI(); |
| eglBindAPI(EGL_OPENGL_ES_API); |
| return eglWaitClient(); |
| } |
| |
| EGLAPI EGLBoolean EGLAPIENTRY eglWaitNative(EGLint engine) { |
| if(!EglValidate::engine(engine)) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_PARAMETER); |
| } |
| ThreadInfo* thread = getThreadInfo(); |
| ContextPtr currCtx = thread->eglContext; |
| EglDisplay* dpy = static_cast<EglDisplay*>(thread->eglDisplay); |
| if(currCtx.Ptr()) { |
| SurfacePtr read = currCtx->read(); |
| SurfacePtr draw = currCtx->draw(); |
| |
| EGLNativeInternalDisplayType nativeDisplay = dpy->nativeType(); |
| if(read.Ptr()) { |
| if(read->type() == EglSurface::WINDOW && |
| !EglOS::validNativeWin(nativeDisplay,read->native())) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_SURFACE); |
| } |
| if(read->type() == EglSurface::PIXMAP && |
| !EglOS::validNativePixmap(nativeDisplay,read->native())) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_SURFACE); |
| } |
| } |
| if(draw.Ptr()) { |
| if(draw->type() == EglSurface::WINDOW && |
| !EglOS::validNativeWin(nativeDisplay,draw->native())) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_SURFACE); |
| } |
| if(draw->type() == EglSurface::PIXMAP && |
| !EglOS::validNativePixmap(nativeDisplay,draw->native())) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_SURFACE); |
| } |
| } |
| } |
| EglOS::waitNative(); |
| return EGL_TRUE; |
| } |
| |
| EGLAPI EGLBoolean EGLAPIENTRY eglBindAPI(EGLenum api) { |
| if(!EglValidate::supportedApi(api)) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_PARAMETER); |
| } |
| CURRENT_THREAD(); |
| tls_thread->setApi(api); |
| return EGL_TRUE; |
| } |
| |
| EGLAPI EGLenum EGLAPIENTRY eglQueryAPI(void) { |
| CURRENT_THREAD(); |
| return tls_thread->getApi(); |
| } |
| |
| EGLAPI EGLBoolean EGLAPIENTRY eglWaitClient(void) { |
| ThreadInfo* thread = getThreadInfo(); |
| ContextPtr currCtx = thread->eglContext; |
| if(currCtx.Ptr()) { |
| if(!currCtx->read().Ptr() || !currCtx->draw().Ptr()) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_CURRENT_SURFACE); |
| } |
| g_eglInfo->getIface(currCtx->version())->finish(); |
| } |
| return EGL_TRUE; |
| } |
| |
| EGLAPI EGLBoolean EGLAPIENTRY eglReleaseThread(void) { |
| ThreadInfo* thread = getThreadInfo(); |
| EglDisplay* dpy = static_cast<EglDisplay*>(thread->eglDisplay); |
| return eglMakeCurrent(dpy,EGL_NO_SURFACE,EGL_NO_SURFACE,EGL_NO_CONTEXT); |
| } |
| |
| EGLAPI __eglMustCastToProperFunctionPointerType EGLAPIENTRY |
| eglGetProcAddress(const char *procname){ |
| __eglMustCastToProperFunctionPointerType retVal = NULL; |
| |
| initGlobalInfo(); |
| |
| if(!strncmp(procname,"egl",3)) { //EGL proc |
| for(int i=0;i < s_eglExtentionsSize;i++){ |
| if(strcmp(procname,s_eglExtentions[i].name) == 0){ |
| retVal = s_eglExtentions[i].address; |
| break; |
| } |
| } |
| } |
| else { |
| // Look at the clientAPI (GLES) supported extension |
| // function table. |
| retVal = ClientAPIExts::getProcAddress(procname); |
| } |
| return retVal; |
| } |
| |
| //not supported for now |
| /************************* NOT SUPPORTED FOR NOW ***********************/ |
| EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferFromClientBuffer( |
| EGLDisplay display, EGLenum buftype, EGLClientBuffer buffer, |
| EGLConfig config, const EGLint *attrib_list) { |
| VALIDATE_DISPLAY(display); |
| VALIDATE_CONFIG(config); |
| //we do not support for now openVG, and the only client API resources which may be bound in this fashion are OpenVG |
| RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_PARAMETER); |
| } |
| |
| EGLAPI EGLBoolean EGLAPIENTRY eglCopyBuffers(EGLDisplay display, EGLSurface surface, |
| EGLNativePixmapType target) { |
| VALIDATE_DISPLAY(display); |
| VALIDATE_SURFACE(surface,srfc); |
| if(!EglOS::validNativePixmap(dpy->nativeType(),NULL)) { |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_NATIVE_PIXMAP); |
| } |
| |
| //we do not need to support this for android , since we are not gonna use pixmaps |
| RETURN_ERROR(EGL_FALSE,EGL_BAD_NATIVE_PIXMAP); |
| } |
| |
| /***********************************************************************/ |
| |
| |
| |
| //do last ( only if needed) |
| /*********************************************************************************************************/ |
| EGLAPI EGLBoolean EGLAPIENTRY eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) { |
| //TODO: |
| return 0; |
| } |
| |
| EGLAPI EGLBoolean EGLAPIENTRY eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) { |
| //TODO: |
| return 0; |
| } |
| /*********************************************************************************************************/ |
| |
| |
| /************************** KHR IMAGE *************************************************************/ |
| EglImage *attachEGLImage(unsigned int imageId) |
| { |
| ThreadInfo* thread = getThreadInfo(); |
| EglDisplay* dpy = static_cast<EglDisplay*>(thread->eglDisplay); |
| ContextPtr ctx = thread->eglContext; |
| if (ctx.Ptr()) { |
| ImagePtr img = dpy->getImage(reinterpret_cast<EGLImageKHR>(imageId)); |
| if(img.Ptr()) { |
| ctx->attachImage(imageId,img); |
| return img.Ptr(); |
| } |
| } |
| return NULL; |
| } |
| |
| void detachEGLImage(unsigned int imageId) |
| { |
| ThreadInfo* thread = getThreadInfo(); |
| EglDisplay* dpy = static_cast<EglDisplay*>(thread->eglDisplay); |
| ContextPtr ctx = thread->eglContext; |
| if (ctx.Ptr()) { |
| ctx->detachImage(imageId); |
| } |
| } |
| |
| |
| EGLImageKHR eglCreateImageKHR(EGLDisplay display, EGLContext context, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list) |
| { |
| VALIDATE_DISPLAY(display); |
| VALIDATE_CONTEXT(context); |
| |
| // We only support EGL_GL_TEXTURE_2D images |
| if (target != EGL_GL_TEXTURE_2D_KHR) { |
| RETURN_ERROR(EGL_NO_IMAGE_KHR,EGL_BAD_PARAMETER); |
| } |
| |
| ThreadInfo* thread = getThreadInfo(); |
| ShareGroupPtr sg = thread->shareGroup; |
| if (sg.Ptr() != NULL) { |
| unsigned int globalTexName = sg->getGlobalName(TEXTURE, (uintptr_t)buffer); |
| if (!globalTexName) return EGL_NO_IMAGE_KHR; |
| |
| ImagePtr img( new EglImage() ); |
| if (img.Ptr() != NULL) { |
| |
| ObjectDataPtr objData = sg->getObjectData(TEXTURE, (uintptr_t)buffer); |
| if (!objData.Ptr()) return EGL_NO_IMAGE_KHR; |
| |
| TextureData *texData = (TextureData *)objData.Ptr(); |
| if(!texData->width || !texData->height) return EGL_NO_IMAGE_KHR; |
| img->width = texData->width; |
| img->height = texData->height; |
| img->border = texData->border; |
| img->internalFormat = texData->internalFormat; |
| img->globalTexName = globalTexName; |
| return dpy->addImageKHR(img); |
| } |
| } |
| |
| return EGL_NO_IMAGE_KHR; |
| } |
| |
| |
| EGLBoolean eglDestroyImageKHR(EGLDisplay display, EGLImageKHR image) |
| { |
| VALIDATE_DISPLAY(display); |
| return dpy->destroyImageKHR(image) ? EGL_TRUE:EGL_FALSE; |
| } |
| |
| /*********************************************************************************/ |
