rsdGL.cpp revision af12ac6a08651464f8d823add667c706f993b587
1a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian/* 2a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian * Copyright (C) 2011 The Android Open Source Project 3a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian * 4a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian * Licensed under the Apache License, Version 2.0 (the "License"); 5a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian * you may not use this file except in compliance with the License. 6a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian * You may obtain a copy of the License at 7a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian * 8a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian * http://www.apache.org/licenses/LICENSE-2.0 9a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian * 10a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian * Unless required by applicable law or agreed to in writing, software 11a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian * distributed under the License is distributed on an "AS IS" BASIS, 12a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian * See the License for the specific language governing permissions and 14a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian * limitations under the License. 15a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian */ 16a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian 17a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian#include <ui/FramebufferNativeWindow.h> 18f1352df47fe20aed23c216a78923c7d248f2bb91Mathias Agopian#include <ui/PixelFormat.h> 19f1352df47fe20aed23c216a78923c7d248f2bb91Mathias Agopian#include <ui/EGLUtils.h> 20f1352df47fe20aed23c216a78923c7d248f2bb91Mathias Agopian#include <ui/egl/android_natives.h> 21a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian 22a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian#include <sys/types.h> 23a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian#include <sys/resource.h> 248372785879d329f592f6883620b5a32d80d74691Mathias Agopian#include <sched.h> 25a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian 26a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian#include <cutils/properties.h> 27a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian 28a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian#include <GLES/gl.h> 29a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian#include <GLES/glext.h> 30a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian#include <GLES2/gl2.h> 31a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian#include <GLES2/gl2ext.h> 32a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian 33c7d14e247117392fbd44aa454622778a25c076aeMathias Agopian#include <string.h> 34a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian 35a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian#include "rsdCore.h" 36a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian#include "rsdGL.h" 37a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian 38c7d14e247117392fbd44aa454622778a25c076aeMathias Agopian#include <malloc.h> 39c7d14e247117392fbd44aa454622778a25c076aeMathias Agopian#include "rsContext.h" 40c7d14e247117392fbd44aa454622778a25c076aeMathias Agopian#include "rsdShaderCache.h" 41a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian#include "rsdVertexArray.h" 42a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian#include "rsdFrameBufferObj.h" 43a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian 44a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopianusing namespace android; 45a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopianusing namespace android::renderscript; 46a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian 47a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopianstatic int32_t gGLContextCount = 0; 48a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian 49c7d14e247117392fbd44aa454622778a25c076aeMathias Agopianstatic void checkEglError(const char* op, EGLBoolean returnVal = EGL_TRUE) { 50c7d14e247117392fbd44aa454622778a25c076aeMathias Agopian if (returnVal != EGL_TRUE) { 51c7d14e247117392fbd44aa454622778a25c076aeMathias Agopian fprintf(stderr, "%s() returned %d\n", op, returnVal); 52c7d14e247117392fbd44aa454622778a25c076aeMathias Agopian } 53c7d14e247117392fbd44aa454622778a25c076aeMathias Agopian 54c7d14e247117392fbd44aa454622778a25c076aeMathias Agopian for (EGLint error = eglGetError(); error != EGL_SUCCESS; error 55c7d14e247117392fbd44aa454622778a25c076aeMathias Agopian = eglGetError()) { 56a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian fprintf(stderr, "after %s() eglError %s (0x%x)\n", op, EGLUtils::strerror(error), 57a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian error); 58a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian } 59a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian} 60a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian 61a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopianstatic void printEGLConfiguration(EGLDisplay dpy, EGLConfig config) { 62a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian 63a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian#define X(VAL) {VAL, #VAL} 64a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian struct {EGLint attribute; const char* name;} names[] = { 65a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian X(EGL_BUFFER_SIZE), 66a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian X(EGL_ALPHA_SIZE), 67a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian X(EGL_BLUE_SIZE), 68a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian X(EGL_GREEN_SIZE), 69a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian X(EGL_RED_SIZE), 70c7d14e247117392fbd44aa454622778a25c076aeMathias Agopian X(EGL_DEPTH_SIZE), 71c7d14e247117392fbd44aa454622778a25c076aeMathias Agopian X(EGL_STENCIL_SIZE), 72c7d14e247117392fbd44aa454622778a25c076aeMathias Agopian X(EGL_CONFIG_CAVEAT), 73c7d14e247117392fbd44aa454622778a25c076aeMathias Agopian X(EGL_CONFIG_ID), 74c7d14e247117392fbd44aa454622778a25c076aeMathias Agopian X(EGL_LEVEL), 75c7d14e247117392fbd44aa454622778a25c076aeMathias Agopian X(EGL_MAX_PBUFFER_HEIGHT), 76c7d14e247117392fbd44aa454622778a25c076aeMathias Agopian X(EGL_MAX_PBUFFER_PIXELS), 77c7d14e247117392fbd44aa454622778a25c076aeMathias Agopian X(EGL_MAX_PBUFFER_WIDTH), 78a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian X(EGL_NATIVE_RENDERABLE), 79a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian X(EGL_NATIVE_VISUAL_ID), 80a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian X(EGL_NATIVE_VISUAL_TYPE), 81a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian X(EGL_SAMPLES), 82a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian X(EGL_SAMPLE_BUFFERS), 83a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian X(EGL_SURFACE_TYPE), 8445721773e1a68e96da4b6cc04cef276bae7ca3e9Mathias Agopian X(EGL_TRANSPARENT_TYPE), 8545721773e1a68e96da4b6cc04cef276bae7ca3e9Mathias Agopian X(EGL_TRANSPARENT_RED_VALUE), 8645721773e1a68e96da4b6cc04cef276bae7ca3e9Mathias Agopian X(EGL_TRANSPARENT_GREEN_VALUE), 8745721773e1a68e96da4b6cc04cef276bae7ca3e9Mathias Agopian X(EGL_TRANSPARENT_BLUE_VALUE), 8845721773e1a68e96da4b6cc04cef276bae7ca3e9Mathias Agopian X(EGL_BIND_TO_TEXTURE_RGB), 8945721773e1a68e96da4b6cc04cef276bae7ca3e9Mathias Agopian X(EGL_BIND_TO_TEXTURE_RGBA), 9045721773e1a68e96da4b6cc04cef276bae7ca3e9Mathias Agopian X(EGL_MIN_SWAP_INTERVAL), 91a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian X(EGL_MAX_SWAP_INTERVAL), 92a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian X(EGL_LUMINANCE_SIZE), 93a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian X(EGL_ALPHA_MASK_SIZE), 94a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian X(EGL_COLOR_BUFFER_TYPE), 95a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian X(EGL_RENDERABLE_TYPE), 96a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian X(EGL_CONFORMANT), 97a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian }; 98a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian#undef X 99a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian 100a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian for (size_t j = 0; j < sizeof(names) / sizeof(names[0]); j++) { 101a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian EGLint value = -1; 102a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian EGLBoolean returnVal = eglGetConfigAttrib(dpy, config, names[j].attribute, &value); 103a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian if (returnVal) { 10458959343dbdb6157fa5f5463262d4842b8954353Mathias Agopian ALOGV(" %s: %d (0x%x)", names[j].name, value, value); 10558959343dbdb6157fa5f5463262d4842b8954353Mathias Agopian } 10658959343dbdb6157fa5f5463262d4842b8954353Mathias Agopian } 107a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian} 108a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian 109a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopianstatic void DumpDebug(RsdHal *dc) { 110f5f2712854599b4970643c6000fe6ae950a08ba9Antti Hatala ALOGE(" EGL ver %i %i", dc->gl.egl.majorVersion, dc->gl.egl.minorVersion); 1117ee4cd5556cef1878e1d4729f1b389f186311027Mathias Agopian ALOGE(" EGL context %p surface %p, Display=%p", dc->gl.egl.context, dc->gl.egl.surface, 1127ee4cd5556cef1878e1d4729f1b389f186311027Mathias Agopian dc->gl.egl.display); 1137ee4cd5556cef1878e1d4729f1b389f186311027Mathias Agopian ALOGE(" GL vendor: %s", dc->gl.gl.vendor); 1147ee4cd5556cef1878e1d4729f1b389f186311027Mathias Agopian ALOGE(" GL renderer: %s", dc->gl.gl.renderer); 1157ee4cd5556cef1878e1d4729f1b389f186311027Mathias Agopian ALOGE(" GL Version: %s", dc->gl.gl.version); 1167ee4cd5556cef1878e1d4729f1b389f186311027Mathias Agopian ALOGE(" GL Extensions: %s", dc->gl.gl.extensions); 1177ee4cd5556cef1878e1d4729f1b389f186311027Mathias Agopian ALOGE(" GL int Versions %i %i", dc->gl.gl.majorVersion, dc->gl.gl.minorVersion); 1187ee4cd5556cef1878e1d4729f1b389f186311027Mathias Agopian 1197ee4cd5556cef1878e1d4729f1b389f186311027Mathias Agopian ALOGV("MAX Textures %i, %i %i", dc->gl.gl.maxVertexTextureUnits, 1207ee4cd5556cef1878e1d4729f1b389f186311027Mathias Agopian dc->gl.gl.maxFragmentTextureImageUnits, dc->gl.gl.maxTextureImageUnits); 1217ee4cd5556cef1878e1d4729f1b389f186311027Mathias Agopian ALOGV("MAX Attribs %i", dc->gl.gl.maxVertexAttribs); 1227ee4cd5556cef1878e1d4729f1b389f186311027Mathias Agopian ALOGV("MAX Uniforms %i, %i", dc->gl.gl.maxVertexUniformVectors, 1237ee4cd5556cef1878e1d4729f1b389f186311027Mathias Agopian dc->gl.gl.maxFragmentUniformVectors); 1247ee4cd5556cef1878e1d4729f1b389f186311027Mathias Agopian ALOGV("MAX Varyings %i", dc->gl.gl.maxVaryingVectors); 1257ee4cd5556cef1878e1d4729f1b389f186311027Mathias Agopian} 126f5f2712854599b4970643c6000fe6ae950a08ba9Antti Hatala 127f5f2712854599b4970643c6000fe6ae950a08ba9Antti Hatalavoid rsdGLShutdown(const Context *rsc) { 12845721773e1a68e96da4b6cc04cef276bae7ca3e9Mathias Agopian RsdHal *dc = (RsdHal *)rsc->mHal.drv; 12945721773e1a68e96da4b6cc04cef276bae7ca3e9Mathias Agopian 130a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian dc->gl.shaderCache->cleanupAll(); 131a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian delete dc->gl.shaderCache; 13245721773e1a68e96da4b6cc04cef276bae7ca3e9Mathias Agopian delete dc->gl.vertexArrayState; 13345721773e1a68e96da4b6cc04cef276bae7ca3e9Mathias Agopian 134a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian if (dc->gl.egl.context != EGL_NO_CONTEXT) { 135a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian RSD_CALL_GL(eglMakeCurrent, dc->gl.egl.display, 1368372785879d329f592f6883620b5a32d80d74691Mathias Agopian EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); 1378372785879d329f592f6883620b5a32d80d74691Mathias Agopian RSD_CALL_GL(eglDestroySurface, dc->gl.egl.display, dc->gl.egl.surfaceDefault); 1388372785879d329f592f6883620b5a32d80d74691Mathias Agopian if (dc->gl.egl.surface != EGL_NO_SURFACE) { 1398372785879d329f592f6883620b5a32d80d74691Mathias Agopian RSD_CALL_GL(eglDestroySurface, dc->gl.egl.display, dc->gl.egl.surface); 1408372785879d329f592f6883620b5a32d80d74691Mathias Agopian } 1418372785879d329f592f6883620b5a32d80d74691Mathias Agopian RSD_CALL_GL(eglDestroyContext, dc->gl.egl.display, dc->gl.egl.context); 1428372785879d329f592f6883620b5a32d80d74691Mathias Agopian checkEglError("eglDestroyContext"); 1438372785879d329f592f6883620b5a32d80d74691Mathias Agopian } 1448372785879d329f592f6883620b5a32d80d74691Mathias Agopian 1458372785879d329f592f6883620b5a32d80d74691Mathias Agopian gGLContextCount--; 1468372785879d329f592f6883620b5a32d80d74691Mathias Agopian if (!gGLContextCount) { 1478372785879d329f592f6883620b5a32d80d74691Mathias Agopian RSD_CALL_GL(eglTerminate, dc->gl.egl.display); 1488372785879d329f592f6883620b5a32d80d74691Mathias Agopian } 1498372785879d329f592f6883620b5a32d80d74691Mathias Agopian} 1508372785879d329f592f6883620b5a32d80d74691Mathias Agopian 1518372785879d329f592f6883620b5a32d80d74691Mathias Agopianbool rsdGLInit(const Context *rsc) { 1528372785879d329f592f6883620b5a32d80d74691Mathias Agopian RsdHal *dc = (RsdHal *)rsc->mHal.drv; 1531d21a9cafc534c34a2f28c985c4c7aa176d0e67bErik Gilling 1541d21a9cafc534c34a2f28c985c4c7aa176d0e67bErik Gilling dc->gl.egl.numConfigs = -1; 1551d21a9cafc534c34a2f28c985c4c7aa176d0e67bErik Gilling EGLint configAttribs[128]; 1561d21a9cafc534c34a2f28c985c4c7aa176d0e67bErik Gilling EGLint *configAttribsPtr = configAttribs; 1571d21a9cafc534c34a2f28c985c4c7aa176d0e67bErik Gilling EGLint context_attribs2[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; 1588372785879d329f592f6883620b5a32d80d74691Mathias Agopian 1598372785879d329f592f6883620b5a32d80d74691Mathias Agopian memset(configAttribs, 0, sizeof(configAttribs)); 1608372785879d329f592f6883620b5a32d80d74691Mathias Agopian 161a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian configAttribsPtr[0] = EGL_SURFACE_TYPE; 162a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian configAttribsPtr[1] = EGL_WINDOW_BIT; 163 configAttribsPtr += 2; 164 165 configAttribsPtr[0] = EGL_RENDERABLE_TYPE; 166 configAttribsPtr[1] = EGL_OPENGL_ES2_BIT; 167 configAttribsPtr += 2; 168 169 configAttribsPtr[0] = EGL_RED_SIZE; 170 configAttribsPtr[1] = 8; 171 configAttribsPtr += 2; 172 173 configAttribsPtr[0] = EGL_GREEN_SIZE; 174 configAttribsPtr[1] = 8; 175 configAttribsPtr += 2; 176 177 configAttribsPtr[0] = EGL_BLUE_SIZE; 178 configAttribsPtr[1] = 8; 179 configAttribsPtr += 2; 180 181 if (rsc->mUserSurfaceConfig.alphaMin > 0) { 182 configAttribsPtr[0] = EGL_ALPHA_SIZE; 183 configAttribsPtr[1] = rsc->mUserSurfaceConfig.alphaMin; 184 configAttribsPtr += 2; 185 } 186 187 if (rsc->mUserSurfaceConfig.depthMin > 0) { 188 configAttribsPtr[0] = EGL_DEPTH_SIZE; 189 configAttribsPtr[1] = rsc->mUserSurfaceConfig.depthMin; 190 configAttribsPtr += 2; 191 } 192 193 if (rsc->mDev->mForceSW) { 194 configAttribsPtr[0] = EGL_CONFIG_CAVEAT; 195 configAttribsPtr[1] = EGL_SLOW_CONFIG; 196 configAttribsPtr += 2; 197 } 198 199 configAttribsPtr[0] = EGL_NONE; 200 rsAssert(configAttribsPtr < (configAttribs + (sizeof(configAttribs) / sizeof(EGLint)))); 201 202 ALOGV("%p initEGL start", rsc); 203 rsc->setWatchdogGL("eglGetDisplay", __LINE__, __FILE__); 204 dc->gl.egl.display = eglGetDisplay(EGL_DEFAULT_DISPLAY); 205 checkEglError("eglGetDisplay"); 206 207 RSD_CALL_GL(eglInitialize, dc->gl.egl.display, 208 &dc->gl.egl.majorVersion, &dc->gl.egl.minorVersion); 209 checkEglError("eglInitialize"); 210 211 EGLBoolean ret; 212 213 EGLint numConfigs = -1, n = 0; 214 rsc->setWatchdogGL("eglChooseConfig", __LINE__, __FILE__); 215 ret = eglChooseConfig(dc->gl.egl.display, configAttribs, 0, 0, &numConfigs); 216 checkEglError("eglGetConfigs", ret); 217 218 if (numConfigs) { 219 EGLConfig* const configs = new EGLConfig[numConfigs]; 220 221 rsc->setWatchdogGL("eglChooseConfig", __LINE__, __FILE__); 222 ret = eglChooseConfig(dc->gl.egl.display, 223 configAttribs, configs, numConfigs, &n); 224 if (!ret || !n) { 225 checkEglError("eglChooseConfig", ret); 226 ALOGE("%p, couldn't find an EGLConfig matching the screen format\n", rsc); 227 } 228 229 // The first config is guaranteed to over-satisfy the constraints 230 dc->gl.egl.config = configs[0]; 231 232 // go through the list and skip configs that over-satisfy our needs 233 for (int i=0 ; i<n ; i++) { 234 if (rsc->mUserSurfaceConfig.alphaMin <= 0) { 235 EGLint alphaSize; 236 eglGetConfigAttrib(dc->gl.egl.display, 237 configs[i], EGL_ALPHA_SIZE, &alphaSize); 238 if (alphaSize > 0) { 239 continue; 240 } 241 } 242 243 if (rsc->mUserSurfaceConfig.depthMin <= 0) { 244 EGLint depthSize; 245 eglGetConfigAttrib(dc->gl.egl.display, 246 configs[i], EGL_DEPTH_SIZE, &depthSize); 247 if (depthSize > 0) { 248 continue; 249 } 250 } 251 252 // Found one! 253 dc->gl.egl.config = configs[i]; 254 break; 255 } 256 257 delete [] configs; 258 } 259 260 //if (props.mLogVisual) { 261 if (0) { 262 printEGLConfiguration(dc->gl.egl.display, dc->gl.egl.config); 263 } 264 //} 265 266 rsc->setWatchdogGL("eglCreateContext", __LINE__, __FILE__); 267 dc->gl.egl.context = eglCreateContext(dc->gl.egl.display, dc->gl.egl.config, 268 EGL_NO_CONTEXT, context_attribs2); 269 checkEglError("eglCreateContext"); 270 if (dc->gl.egl.context == EGL_NO_CONTEXT) { 271 ALOGE("%p, eglCreateContext returned EGL_NO_CONTEXT", rsc); 272 rsc->setWatchdogGL(NULL, 0, NULL); 273 return false; 274 } 275 gGLContextCount++; 276 277 278 EGLint pbuffer_attribs[] = { EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE }; 279 rsc->setWatchdogGL("eglCreatePbufferSurface", __LINE__, __FILE__); 280 dc->gl.egl.surfaceDefault = eglCreatePbufferSurface(dc->gl.egl.display, dc->gl.egl.config, 281 pbuffer_attribs); 282 checkEglError("eglCreatePbufferSurface"); 283 if (dc->gl.egl.surfaceDefault == EGL_NO_SURFACE) { 284 ALOGE("eglCreatePbufferSurface returned EGL_NO_SURFACE"); 285 rsdGLShutdown(rsc); 286 rsc->setWatchdogGL(NULL, 0, NULL); 287 return false; 288 } 289 290 rsc->setWatchdogGL("eglMakeCurrent", __LINE__, __FILE__); 291 ret = eglMakeCurrent(dc->gl.egl.display, dc->gl.egl.surfaceDefault, 292 dc->gl.egl.surfaceDefault, dc->gl.egl.context); 293 if (ret == EGL_FALSE) { 294 ALOGE("eglMakeCurrent returned EGL_FALSE"); 295 checkEglError("eglMakeCurrent", ret); 296 rsdGLShutdown(rsc); 297 rsc->setWatchdogGL(NULL, 0, NULL); 298 return false; 299 } 300 301 dc->gl.gl.version = glGetString(GL_VERSION); 302 dc->gl.gl.vendor = glGetString(GL_VENDOR); 303 dc->gl.gl.renderer = glGetString(GL_RENDERER); 304 dc->gl.gl.extensions = glGetString(GL_EXTENSIONS); 305 306 //ALOGV("EGL Version %i %i", mEGL.mMajorVersion, mEGL.mMinorVersion); 307 //ALOGV("GL Version %s", mGL.mVersion); 308 //ALOGV("GL Vendor %s", mGL.mVendor); 309 //ALOGV("GL Renderer %s", mGL.mRenderer); 310 //ALOGV("GL Extensions %s", mGL.mExtensions); 311 312 const char *verptr = NULL; 313 if (strlen((const char *)dc->gl.gl.version) > 9) { 314 if (!memcmp(dc->gl.gl.version, "OpenGL ES-CM", 12)) { 315 verptr = (const char *)dc->gl.gl.version + 12; 316 } 317 if (!memcmp(dc->gl.gl.version, "OpenGL ES ", 10)) { 318 verptr = (const char *)dc->gl.gl.version + 9; 319 } 320 } 321 322 if (!verptr) { 323 ALOGE("Error, OpenGL ES Lite not supported"); 324 rsdGLShutdown(rsc); 325 rsc->setWatchdogGL(NULL, 0, NULL); 326 return false; 327 } else { 328 sscanf(verptr, " %i.%i", &dc->gl.gl.majorVersion, &dc->gl.gl.minorVersion); 329 } 330 331 glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &dc->gl.gl.maxVertexAttribs); 332 glGetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS, &dc->gl.gl.maxVertexUniformVectors); 333 glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &dc->gl.gl.maxVertexTextureUnits); 334 335 glGetIntegerv(GL_MAX_VARYING_VECTORS, &dc->gl.gl.maxVaryingVectors); 336 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &dc->gl.gl.maxTextureImageUnits); 337 338 glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &dc->gl.gl.maxFragmentTextureImageUnits); 339 glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS, &dc->gl.gl.maxFragmentUniformVectors); 340 341 dc->gl.gl.OES_texture_npot = NULL != strstr((const char *)dc->gl.gl.extensions, 342 "GL_OES_texture_npot"); 343 dc->gl.gl.GL_IMG_texture_npot = NULL != strstr((const char *)dc->gl.gl.extensions, 344 "GL_IMG_texture_npot"); 345 dc->gl.gl.GL_NV_texture_npot_2D_mipmap = NULL != strstr((const char *)dc->gl.gl.extensions, 346 "GL_NV_texture_npot_2D_mipmap"); 347 dc->gl.gl.EXT_texture_max_aniso = 1.0f; 348 bool hasAniso = NULL != strstr((const char *)dc->gl.gl.extensions, 349 "GL_EXT_texture_filter_anisotropic"); 350 if (hasAniso) { 351 glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &dc->gl.gl.EXT_texture_max_aniso); 352 } 353 354 if (0) { 355 DumpDebug(dc); 356 } 357 358 dc->gl.shaderCache = new RsdShaderCache(); 359 dc->gl.vertexArrayState = new RsdVertexArrayState(); 360 dc->gl.vertexArrayState->init(dc->gl.gl.maxVertexAttribs); 361 dc->gl.currentFrameBuffer = NULL; 362 363 ALOGV("%p initGLThread end", rsc); 364 rsc->setWatchdogGL(NULL, 0, NULL); 365 return true; 366} 367 368 369bool rsdGLSetSurface(const Context *rsc, uint32_t w, uint32_t h, RsNativeWindow sur) { 370 RsdHal *dc = (RsdHal *)rsc->mHal.drv; 371 372 EGLBoolean ret; 373 // WAR: Some drivers fail to handle 0 size surfaces correcntly. 374 // Use the pbuffer to avoid this pitfall. 375 if ((dc->gl.egl.surface != NULL) || (w == 0) || (h == 0)) { 376 rsc->setWatchdogGL("eglMakeCurrent", __LINE__, __FILE__); 377 ret = eglMakeCurrent(dc->gl.egl.display, dc->gl.egl.surfaceDefault, 378 dc->gl.egl.surfaceDefault, dc->gl.egl.context); 379 checkEglError("eglMakeCurrent", ret); 380 381 rsc->setWatchdogGL("eglDestroySurface", __LINE__, __FILE__); 382 ret = eglDestroySurface(dc->gl.egl.display, dc->gl.egl.surface); 383 checkEglError("eglDestroySurface", ret); 384 385 dc->gl.egl.surface = NULL; 386 dc->gl.width = 1; 387 dc->gl.height = 1; 388 } 389 390 if (dc->gl.wndSurface != NULL) { 391 dc->gl.wndSurface->decStrong(NULL); 392 } 393 394 dc->gl.wndSurface = (ANativeWindow *)sur; 395 if (dc->gl.wndSurface != NULL) { 396 dc->gl.wndSurface->incStrong(NULL); 397 dc->gl.width = w; 398 dc->gl.height = h; 399 400 rsc->setWatchdogGL("eglCreateWindowSurface", __LINE__, __FILE__); 401 dc->gl.egl.surface = eglCreateWindowSurface(dc->gl.egl.display, dc->gl.egl.config, 402 dc->gl.wndSurface, NULL); 403 checkEglError("eglCreateWindowSurface"); 404 if (dc->gl.egl.surface == EGL_NO_SURFACE) { 405 ALOGE("eglCreateWindowSurface returned EGL_NO_SURFACE"); 406 } 407 408 rsc->setWatchdogGL("eglMakeCurrent", __LINE__, __FILE__); 409 ret = eglMakeCurrent(dc->gl.egl.display, dc->gl.egl.surface, 410 dc->gl.egl.surface, dc->gl.egl.context); 411 checkEglError("eglMakeCurrent", ret); 412 } 413 rsc->setWatchdogGL(NULL, 0, NULL); 414 return true; 415} 416 417void rsdGLSwap(const android::renderscript::Context *rsc) { 418 RsdHal *dc = (RsdHal *)rsc->mHal.drv; 419 RSD_CALL_GL(eglSwapBuffers, dc->gl.egl.display, dc->gl.egl.surface); 420} 421 422void rsdGLCheckError(const android::renderscript::Context *rsc, 423 const char *msg, bool isFatal) { 424 GLenum err = glGetError(); 425 if (err != GL_NO_ERROR) { 426 char buf[1024]; 427 snprintf(buf, sizeof(buf), "GL Error = 0x%08x, from: %s", err, msg); 428 429 if (isFatal) { 430 rsc->setError(RS_ERROR_FATAL_DRIVER, buf); 431 } else { 432 switch (err) { 433 case GL_OUT_OF_MEMORY: 434 rsc->setError(RS_ERROR_OUT_OF_MEMORY, buf); 435 break; 436 default: 437 rsc->setError(RS_ERROR_DRIVER, buf); 438 break; 439 } 440 } 441 442 ALOGE("%p, %s", rsc, buf); 443 } 444 445} 446