rsdGL.cpp revision b8eba193f3f0d25a6156236fa80f79a5b1dc89f6 
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
20#include <system/window.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    struct EGLUtils {
51        static const char *strerror(EGLint err) {
52            switch (err){
53                case EGL_SUCCESS:           return "EGL_SUCCESS";
54                case EGL_NOT_INITIALIZED:   return "EGL_NOT_INITIALIZED";
55                case EGL_BAD_ACCESS:        return "EGL_BAD_ACCESS";
56                case EGL_BAD_ALLOC:         return "EGL_BAD_ALLOC";
57                case EGL_BAD_ATTRIBUTE:     return "EGL_BAD_ATTRIBUTE";
58                case EGL_BAD_CONFIG:        return "EGL_BAD_CONFIG";
59                case EGL_BAD_CONTEXT:       return "EGL_BAD_CONTEXT";
60                case EGL_BAD_CURRENT_SURFACE: return "EGL_BAD_CURRENT_SURFACE";
61                case EGL_BAD_DISPLAY:       return "EGL_BAD_DISPLAY";
62                case EGL_BAD_MATCH:         return "EGL_BAD_MATCH";
63                case EGL_BAD_NATIVE_PIXMAP: return "EGL_BAD_NATIVE_PIXMAP";
64                case EGL_BAD_NATIVE_WINDOW: return "EGL_BAD_NATIVE_WINDOW";
65                case EGL_BAD_PARAMETER:     return "EGL_BAD_PARAMETER";
66                case EGL_BAD_SURFACE:       return "EGL_BAD_SURFACE";
67                case EGL_CONTEXT_LOST:      return "EGL_CONTEXT_LOST";
68                default: return "UNKNOWN";
69            }
70        }
71    };
72
73    if (returnVal != EGL_TRUE) {
74        fprintf(stderr, "%s() returned %d\n", op, returnVal);
75    }
76
77    for (EGLint error = eglGetError(); error != EGL_SUCCESS; error
78            = eglGetError()) {
79        fprintf(stderr, "after %s() eglError %s (0x%x)\n", op, EGLUtils::strerror(error),
80                error);
81    }
82}
83
84static void printEGLConfiguration(EGLDisplay dpy, EGLConfig config) {
85
86#define X(VAL) {VAL, #VAL}
87    struct {EGLint attribute; const char* name;} names[] = {
88    X(EGL_BUFFER_SIZE),
89    X(EGL_ALPHA_SIZE),
90    X(EGL_BLUE_SIZE),
91    X(EGL_GREEN_SIZE),
92    X(EGL_RED_SIZE),
93    X(EGL_DEPTH_SIZE),
94    X(EGL_STENCIL_SIZE),
95    X(EGL_CONFIG_CAVEAT),
96    X(EGL_CONFIG_ID),
97    X(EGL_LEVEL),
98    X(EGL_MAX_PBUFFER_HEIGHT),
99    X(EGL_MAX_PBUFFER_PIXELS),
100    X(EGL_MAX_PBUFFER_WIDTH),
101    X(EGL_NATIVE_RENDERABLE),
102    X(EGL_NATIVE_VISUAL_ID),
103    X(EGL_NATIVE_VISUAL_TYPE),
104    X(EGL_SAMPLES),
105    X(EGL_SAMPLE_BUFFERS),
106    X(EGL_SURFACE_TYPE),
107    X(EGL_TRANSPARENT_TYPE),
108    X(EGL_TRANSPARENT_RED_VALUE),
109    X(EGL_TRANSPARENT_GREEN_VALUE),
110    X(EGL_TRANSPARENT_BLUE_VALUE),
111    X(EGL_BIND_TO_TEXTURE_RGB),
112    X(EGL_BIND_TO_TEXTURE_RGBA),
113    X(EGL_MIN_SWAP_INTERVAL),
114    X(EGL_MAX_SWAP_INTERVAL),
115    X(EGL_LUMINANCE_SIZE),
116    X(EGL_ALPHA_MASK_SIZE),
117    X(EGL_COLOR_BUFFER_TYPE),
118    X(EGL_RENDERABLE_TYPE),
119    X(EGL_CONFORMANT),
120   };
121#undef X
122
123    for (size_t j = 0; j < sizeof(names) / sizeof(names[0]); j++) {
124        EGLint value = -1;
125        EGLBoolean returnVal = eglGetConfigAttrib(dpy, config, names[j].attribute, &value);
126        if (returnVal) {
127            ALOGV(" %s: %d (0x%x)", names[j].name, value, value);
128        }
129    }
130}
131
132static void DumpDebug(RsdHal *dc) {
133    ALOGE(" EGL ver %i %i", dc->gl.egl.majorVersion, dc->gl.egl.minorVersion);
134    ALOGE(" EGL context %p  surface %p,  Display=%p", dc->gl.egl.context, dc->gl.egl.surface,
135         dc->gl.egl.display);
136    ALOGE(" GL vendor: %s", dc->gl.gl.vendor);
137    ALOGE(" GL renderer: %s", dc->gl.gl.renderer);
138    ALOGE(" GL Version: %s", dc->gl.gl.version);
139    ALOGE(" GL Extensions: %s", dc->gl.gl.extensions);
140    ALOGE(" GL int Versions %i %i", dc->gl.gl.majorVersion, dc->gl.gl.minorVersion);
141
142    ALOGV("MAX Textures %i, %i  %i", dc->gl.gl.maxVertexTextureUnits,
143         dc->gl.gl.maxFragmentTextureImageUnits, dc->gl.gl.maxTextureImageUnits);
144    ALOGV("MAX Attribs %i", dc->gl.gl.maxVertexAttribs);
145    ALOGV("MAX Uniforms %i, %i", dc->gl.gl.maxVertexUniformVectors,
146         dc->gl.gl.maxFragmentUniformVectors);
147    ALOGV("MAX Varyings %i", dc->gl.gl.maxVaryingVectors);
148}
149
150void rsdGLShutdown(const Context *rsc) {
151    RsdHal *dc = (RsdHal *)rsc->mHal.drv;
152
153    dc->gl.shaderCache->cleanupAll();
154    delete dc->gl.shaderCache;
155    delete dc->gl.vertexArrayState;
156
157    if (dc->gl.egl.context != EGL_NO_CONTEXT) {
158        RSD_CALL_GL(eglMakeCurrent, dc->gl.egl.display,
159                    EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
160        RSD_CALL_GL(eglDestroySurface, dc->gl.egl.display, dc->gl.egl.surfaceDefault);
161        if (dc->gl.egl.surface != EGL_NO_SURFACE) {
162            RSD_CALL_GL(eglDestroySurface, dc->gl.egl.display, dc->gl.egl.surface);
163        }
164        RSD_CALL_GL(eglDestroyContext, dc->gl.egl.display, dc->gl.egl.context);
165        checkEglError("eglDestroyContext");
166    }
167
168    gGLContextCount--;
169    if (!gGLContextCount) {
170        RSD_CALL_GL(eglTerminate, dc->gl.egl.display);
171    }
172}
173
174bool rsdGLInit(const Context *rsc) {
175    RsdHal *dc = (RsdHal *)rsc->mHal.drv;
176
177    dc->gl.egl.numConfigs = -1;
178    EGLint configAttribs[128];
179    EGLint *configAttribsPtr = configAttribs;
180    EGLint context_attribs2[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
181
182    memset(configAttribs, 0, sizeof(configAttribs));
183
184    configAttribsPtr[0] = EGL_SURFACE_TYPE;
185    configAttribsPtr[1] = EGL_WINDOW_BIT;
186    configAttribsPtr += 2;
187
188    configAttribsPtr[0] = EGL_RENDERABLE_TYPE;
189    configAttribsPtr[1] = EGL_OPENGL_ES2_BIT;
190    configAttribsPtr += 2;
191
192    configAttribsPtr[0] = EGL_RED_SIZE;
193    configAttribsPtr[1] = 8;
194    configAttribsPtr += 2;
195
196    configAttribsPtr[0] = EGL_GREEN_SIZE;
197    configAttribsPtr[1] = 8;
198    configAttribsPtr += 2;
199
200    configAttribsPtr[0] = EGL_BLUE_SIZE;
201    configAttribsPtr[1] = 8;
202    configAttribsPtr += 2;
203
204    if (rsc->mUserSurfaceConfig.alphaMin > 0) {
205        configAttribsPtr[0] = EGL_ALPHA_SIZE;
206        configAttribsPtr[1] = rsc->mUserSurfaceConfig.alphaMin;
207        configAttribsPtr += 2;
208    }
209
210    if (rsc->mUserSurfaceConfig.depthMin > 0) {
211        configAttribsPtr[0] = EGL_DEPTH_SIZE;
212        configAttribsPtr[1] = rsc->mUserSurfaceConfig.depthMin;
213        configAttribsPtr += 2;
214    }
215
216    if (rsc->mDev->mForceSW) {
217        configAttribsPtr[0] = EGL_CONFIG_CAVEAT;
218        configAttribsPtr[1] = EGL_SLOW_CONFIG;
219        configAttribsPtr += 2;
220    }
221
222    configAttribsPtr[0] = EGL_NONE;
223    rsAssert(configAttribsPtr < (configAttribs + (sizeof(configAttribs) / sizeof(EGLint))));
224
225    ALOGV("%p initEGL start", rsc);
226    rsc->setWatchdogGL("eglGetDisplay", __LINE__, __FILE__);
227    dc->gl.egl.display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
228    checkEglError("eglGetDisplay");
229
230    RSD_CALL_GL(eglInitialize, dc->gl.egl.display,
231                &dc->gl.egl.majorVersion, &dc->gl.egl.minorVersion);
232    checkEglError("eglInitialize");
233
234    EGLBoolean ret;
235
236    EGLint numConfigs = -1, n = 0;
237    rsc->setWatchdogGL("eglChooseConfig", __LINE__, __FILE__);
238    ret = eglChooseConfig(dc->gl.egl.display, configAttribs, 0, 0, &numConfigs);
239    checkEglError("eglGetConfigs", ret);
240
241    eglSwapInterval(dc->gl.egl.display, 0);
242
243    if (numConfigs) {
244        EGLConfig* const configs = new EGLConfig[numConfigs];
245
246        rsc->setWatchdogGL("eglChooseConfig", __LINE__, __FILE__);
247        ret = eglChooseConfig(dc->gl.egl.display,
248                configAttribs, configs, numConfigs, &n);
249        if (!ret || !n) {
250            checkEglError("eglChooseConfig", ret);
251            ALOGE("%p, couldn't find an EGLConfig matching the screen format\n", rsc);
252        }
253
254        // The first config is guaranteed to over-satisfy the constraints
255        dc->gl.egl.config = configs[0];
256
257        // go through the list and skip configs that over-satisfy our needs
258        for (int i=0 ; i<n ; i++) {
259            if (rsc->mUserSurfaceConfig.alphaMin <= 0) {
260                EGLint alphaSize;
261                eglGetConfigAttrib(dc->gl.egl.display,
262                        configs[i], EGL_ALPHA_SIZE, &alphaSize);
263                if (alphaSize > 0) {
264                    continue;
265                }
266            }
267
268            if (rsc->mUserSurfaceConfig.depthMin <= 0) {
269                EGLint depthSize;
270                eglGetConfigAttrib(dc->gl.egl.display,
271                        configs[i], EGL_DEPTH_SIZE, &depthSize);
272                if (depthSize > 0) {
273                    continue;
274                }
275            }
276
277            // Found one!
278            dc->gl.egl.config = configs[i];
279            break;
280        }
281
282        delete [] configs;
283    }
284
285    //if (props.mLogVisual) {
286    if (0) {
287        printEGLConfiguration(dc->gl.egl.display, dc->gl.egl.config);
288    }
289    //}
290
291    rsc->setWatchdogGL("eglCreateContext", __LINE__, __FILE__);
292    dc->gl.egl.context = eglCreateContext(dc->gl.egl.display, dc->gl.egl.config,
293                                          EGL_NO_CONTEXT, context_attribs2);
294    checkEglError("eglCreateContext");
295    if (dc->gl.egl.context == EGL_NO_CONTEXT) {
296        ALOGE("%p, eglCreateContext returned EGL_NO_CONTEXT", rsc);
297        rsc->setWatchdogGL(NULL, 0, NULL);
298        return false;
299    }
300    gGLContextCount++;
301
302
303    EGLint pbuffer_attribs[] = { EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE };
304    rsc->setWatchdogGL("eglCreatePbufferSurface", __LINE__, __FILE__);
305    dc->gl.egl.surfaceDefault = eglCreatePbufferSurface(dc->gl.egl.display, dc->gl.egl.config,
306                                                        pbuffer_attribs);
307    checkEglError("eglCreatePbufferSurface");
308    if (dc->gl.egl.surfaceDefault == EGL_NO_SURFACE) {
309        ALOGE("eglCreatePbufferSurface returned EGL_NO_SURFACE");
310        rsdGLShutdown(rsc);
311        rsc->setWatchdogGL(NULL, 0, NULL);
312        return false;
313    }
314
315    rsc->setWatchdogGL("eglMakeCurrent", __LINE__, __FILE__);
316    ret = eglMakeCurrent(dc->gl.egl.display, dc->gl.egl.surfaceDefault,
317                         dc->gl.egl.surfaceDefault, dc->gl.egl.context);
318    if (ret == EGL_FALSE) {
319        ALOGE("eglMakeCurrent returned EGL_FALSE");
320        checkEglError("eglMakeCurrent", ret);
321        rsdGLShutdown(rsc);
322        rsc->setWatchdogGL(NULL, 0, NULL);
323        return false;
324    }
325
326    dc->gl.gl.version = glGetString(GL_VERSION);
327    dc->gl.gl.vendor = glGetString(GL_VENDOR);
328    dc->gl.gl.renderer = glGetString(GL_RENDERER);
329    dc->gl.gl.extensions = glGetString(GL_EXTENSIONS);
330
331    //ALOGV("EGL Version %i %i", mEGL.mMajorVersion, mEGL.mMinorVersion);
332    //ALOGV("GL Version %s", mGL.mVersion);
333    //ALOGV("GL Vendor %s", mGL.mVendor);
334    //ALOGV("GL Renderer %s", mGL.mRenderer);
335    //ALOGV("GL Extensions %s", mGL.mExtensions);
336
337    const char *verptr = NULL;
338    if (strlen((const char *)dc->gl.gl.version) > 9) {
339        if (!memcmp(dc->gl.gl.version, "OpenGL ES-CM", 12)) {
340            verptr = (const char *)dc->gl.gl.version + 12;
341        }
342        if (!memcmp(dc->gl.gl.version, "OpenGL ES ", 10)) {
343            verptr = (const char *)dc->gl.gl.version + 9;
344        }
345    }
346
347    if (!verptr) {
348        ALOGE("Error, OpenGL ES Lite not supported");
349        rsdGLShutdown(rsc);
350        rsc->setWatchdogGL(NULL, 0, NULL);
351        return false;
352    } else {
353        sscanf(verptr, " %i.%i", &dc->gl.gl.majorVersion, &dc->gl.gl.minorVersion);
354    }
355
356    glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &dc->gl.gl.maxVertexAttribs);
357    glGetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS, &dc->gl.gl.maxVertexUniformVectors);
358    glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &dc->gl.gl.maxVertexTextureUnits);
359
360    glGetIntegerv(GL_MAX_VARYING_VECTORS, &dc->gl.gl.maxVaryingVectors);
361    glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &dc->gl.gl.maxTextureImageUnits);
362
363    glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &dc->gl.gl.maxFragmentTextureImageUnits);
364    glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS, &dc->gl.gl.maxFragmentUniformVectors);
365
366    dc->gl.gl.OES_texture_npot = NULL != strstr((const char *)dc->gl.gl.extensions,
367                                                "GL_OES_texture_npot");
368    dc->gl.gl.IMG_texture_npot = NULL != strstr((const char *)dc->gl.gl.extensions,
369                                                   "GL_IMG_texture_npot");
370    dc->gl.gl.NV_texture_npot_2D_mipmap = NULL != strstr((const char *)dc->gl.gl.extensions,
371                                                            "GL_NV_texture_npot_2D_mipmap");
372    dc->gl.gl.EXT_texture_max_aniso = 1.0f;
373    bool hasAniso = NULL != strstr((const char *)dc->gl.gl.extensions,
374                                   "GL_EXT_texture_filter_anisotropic");
375    if (hasAniso) {
376        glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &dc->gl.gl.EXT_texture_max_aniso);
377    }
378
379    if (0) {
380        DumpDebug(dc);
381    }
382
383    dc->gl.shaderCache = new RsdShaderCache();
384    dc->gl.vertexArrayState = new RsdVertexArrayState();
385    dc->gl.vertexArrayState->init(dc->gl.gl.maxVertexAttribs);
386    dc->gl.currentFrameBuffer = NULL;
387    dc->mHasGraphics = true;
388
389    ALOGV("%p initGLThread end", rsc);
390    rsc->setWatchdogGL(NULL, 0, NULL);
391    return true;
392}
393
394
395bool rsdGLSetSurface(const Context *rsc, uint32_t w, uint32_t h, RsNativeWindow sur) {
396    RsdHal *dc = (RsdHal *)rsc->mHal.drv;
397
398    EGLBoolean ret;
399    // WAR: Some drivers fail to handle 0 size surfaces correcntly.
400    // Use the pbuffer to avoid this pitfall.
401    if ((dc->gl.egl.surface != NULL) || (w == 0) || (h == 0)) {
402        rsc->setWatchdogGL("eglMakeCurrent", __LINE__, __FILE__);
403        ret = eglMakeCurrent(dc->gl.egl.display, dc->gl.egl.surfaceDefault,
404                             dc->gl.egl.surfaceDefault, dc->gl.egl.context);
405        checkEglError("eglMakeCurrent", ret);
406
407        rsc->setWatchdogGL("eglDestroySurface", __LINE__, __FILE__);
408        ret = eglDestroySurface(dc->gl.egl.display, dc->gl.egl.surface);
409        checkEglError("eglDestroySurface", ret);
410
411        dc->gl.egl.surface = NULL;
412        dc->gl.width = 1;
413        dc->gl.height = 1;
414    }
415
416    if (dc->gl.wndSurface != NULL) {
417        dc->gl.wndSurface->decStrong(NULL);
418    }
419
420    dc->gl.wndSurface = (ANativeWindow *)sur;
421    if (dc->gl.wndSurface != NULL) {
422        dc->gl.wndSurface->incStrong(NULL);
423        dc->gl.width = w;
424        dc->gl.height = h;
425
426        rsc->setWatchdogGL("eglCreateWindowSurface", __LINE__, __FILE__);
427        dc->gl.egl.surface = eglCreateWindowSurface(dc->gl.egl.display, dc->gl.egl.config,
428                                                    dc->gl.wndSurface, NULL);
429        checkEglError("eglCreateWindowSurface");
430        if (dc->gl.egl.surface == EGL_NO_SURFACE) {
431            ALOGE("eglCreateWindowSurface returned EGL_NO_SURFACE");
432        }
433
434        rsc->setWatchdogGL("eglMakeCurrent", __LINE__, __FILE__);
435        ret = eglMakeCurrent(dc->gl.egl.display, dc->gl.egl.surface,
436                             dc->gl.egl.surface, dc->gl.egl.context);
437        checkEglError("eglMakeCurrent", ret);
438    }
439    rsc->setWatchdogGL(NULL, 0, NULL);
440    return true;
441}
442
443void rsdGLSwap(const android::renderscript::Context *rsc) {
444    RsdHal *dc = (RsdHal *)rsc->mHal.drv;
445    RSD_CALL_GL(eglSwapBuffers, dc->gl.egl.display, dc->gl.egl.surface);
446}
447
448void rsdGLSetPriority(const Context *rsc, int32_t priority) {
449    if (priority > 0) {
450        // Mark context as low priority.
451        ALOGV("low pri");
452    } else {
453        ALOGV("normal pri");
454    }
455}
456
457void rsdGLCheckError(const android::renderscript::Context *rsc,
458                     const char *msg, bool isFatal) {
459    GLenum err = glGetError();
460    if (err != GL_NO_ERROR) {
461        char buf[1024];
462        snprintf(buf, sizeof(buf), "GL Error = 0x%08x, from: %s", err, msg);
463
464        if (isFatal) {
465            rsc->setError(RS_ERROR_FATAL_DRIVER, buf);
466        } else {
467            switch (err) {
468            case GL_OUT_OF_MEMORY:
469                rsc->setError(RS_ERROR_OUT_OF_MEMORY, buf);
470                break;
471            default:
472                rsc->setError(RS_ERROR_DRIVER, buf);
473                break;
474            }
475        }
476
477        ALOGE("%p, %s", rsc, buf);
478    }
479
480}
481