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