rsdGL.cpp revision d3e4b744900ed6666f4dd3182ad5443be26c96dd 
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            ALOGV(" %s: %d (0x%x)", names[j].name, value, value);
105        }
106    }
107}
108
109static void DumpDebug(RsdHal *dc) {
110    ALOGE(" EGL ver %i %i", dc->gl.egl.majorVersion, dc->gl.egl.minorVersion);
111    ALOGE(" EGL context %p  surface %p,  Display=%p", dc->gl.egl.context, dc->gl.egl.surface,
112         dc->gl.egl.display);
113    ALOGE(" GL vendor: %s", dc->gl.gl.vendor);
114    ALOGE(" GL renderer: %s", dc->gl.gl.renderer);
115    ALOGE(" GL Version: %s", dc->gl.gl.version);
116    ALOGE(" GL Extensions: %s", dc->gl.gl.extensions);
117    ALOGE(" GL int Versions %i %i", dc->gl.gl.majorVersion, dc->gl.gl.minorVersion);
118
119    ALOGV("MAX Textures %i, %i  %i", dc->gl.gl.maxVertexTextureUnits,
120         dc->gl.gl.maxFragmentTextureImageUnits, dc->gl.gl.maxTextureImageUnits);
121    ALOGV("MAX Attribs %i", dc->gl.gl.maxVertexAttribs);
122    ALOGV("MAX Uniforms %i, %i", dc->gl.gl.maxVertexUniformVectors,
123         dc->gl.gl.maxFragmentUniformVectors);
124    ALOGV("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    delete dc->gl.vertexArrayState;
133
134    if (dc->gl.egl.context != EGL_NO_CONTEXT) {
135        RSD_CALL_GL(eglMakeCurrent, dc->gl.egl.display,
136                    EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
137        RSD_CALL_GL(eglDestroySurface, dc->gl.egl.display, dc->gl.egl.surfaceDefault);
138        if (dc->gl.egl.surface != EGL_NO_SURFACE) {
139            RSD_CALL_GL(eglDestroySurface, dc->gl.egl.display, dc->gl.egl.surface);
140        }
141        RSD_CALL_GL(eglDestroyContext, dc->gl.egl.display, dc->gl.egl.context);
142        checkEglError("eglDestroyContext");
143    }
144
145    gGLContextCount--;
146    if (!gGLContextCount) {
147        RSD_CALL_GL(eglTerminate, dc->gl.egl.display);
148    }
149}
150
151bool rsdGLInit(const Context *rsc) {
152    RsdHal *dc = (RsdHal *)rsc->mHal.drv;
153
154    dc->gl.egl.numConfigs = -1;
155    EGLint configAttribs[128];
156    EGLint *configAttribsPtr = configAttribs;
157    EGLint context_attribs2[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
158
159    memset(configAttribs, 0, sizeof(configAttribs));
160
161    configAttribsPtr[0] = EGL_SURFACE_TYPE;
162    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    eglSwapInterval(dc->gl.egl.display, 0);
219
220    if (numConfigs) {
221        EGLConfig* const configs = new EGLConfig[numConfigs];
222
223        rsc->setWatchdogGL("eglChooseConfig", __LINE__, __FILE__);
224        ret = eglChooseConfig(dc->gl.egl.display,
225                configAttribs, configs, numConfigs, &n);
226        if (!ret || !n) {
227            checkEglError("eglChooseConfig", ret);
228            ALOGE("%p, couldn't find an EGLConfig matching the screen format\n", rsc);
229        }
230
231        // The first config is guaranteed to over-satisfy the constraints
232        dc->gl.egl.config = configs[0];
233
234        // go through the list and skip configs that over-satisfy our needs
235        for (int i=0 ; i<n ; i++) {
236            if (rsc->mUserSurfaceConfig.alphaMin <= 0) {
237                EGLint alphaSize;
238                eglGetConfigAttrib(dc->gl.egl.display,
239                        configs[i], EGL_ALPHA_SIZE, &alphaSize);
240                if (alphaSize > 0) {
241                    continue;
242                }
243            }
244
245            if (rsc->mUserSurfaceConfig.depthMin <= 0) {
246                EGLint depthSize;
247                eglGetConfigAttrib(dc->gl.egl.display,
248                        configs[i], EGL_DEPTH_SIZE, &depthSize);
249                if (depthSize > 0) {
250                    continue;
251                }
252            }
253
254            // Found one!
255            dc->gl.egl.config = configs[i];
256            break;
257        }
258
259        delete [] configs;
260    }
261
262    //if (props.mLogVisual) {
263    if (0) {
264        printEGLConfiguration(dc->gl.egl.display, dc->gl.egl.config);
265    }
266    //}
267
268    rsc->setWatchdogGL("eglCreateContext", __LINE__, __FILE__);
269    dc->gl.egl.context = eglCreateContext(dc->gl.egl.display, dc->gl.egl.config,
270                                          EGL_NO_CONTEXT, context_attribs2);
271    checkEglError("eglCreateContext");
272    if (dc->gl.egl.context == EGL_NO_CONTEXT) {
273        ALOGE("%p, eglCreateContext returned EGL_NO_CONTEXT", rsc);
274        rsc->setWatchdogGL(NULL, 0, NULL);
275        return false;
276    }
277    gGLContextCount++;
278
279
280    EGLint pbuffer_attribs[] = { EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE };
281    rsc->setWatchdogGL("eglCreatePbufferSurface", __LINE__, __FILE__);
282    dc->gl.egl.surfaceDefault = eglCreatePbufferSurface(dc->gl.egl.display, dc->gl.egl.config,
283                                                        pbuffer_attribs);
284    checkEglError("eglCreatePbufferSurface");
285    if (dc->gl.egl.surfaceDefault == EGL_NO_SURFACE) {
286        ALOGE("eglCreatePbufferSurface returned EGL_NO_SURFACE");
287        rsdGLShutdown(rsc);
288        rsc->setWatchdogGL(NULL, 0, NULL);
289        return false;
290    }
291
292    rsc->setWatchdogGL("eglMakeCurrent", __LINE__, __FILE__);
293    ret = eglMakeCurrent(dc->gl.egl.display, dc->gl.egl.surfaceDefault,
294                         dc->gl.egl.surfaceDefault, dc->gl.egl.context);
295    if (ret == EGL_FALSE) {
296        ALOGE("eglMakeCurrent returned EGL_FALSE");
297        checkEglError("eglMakeCurrent", ret);
298        rsdGLShutdown(rsc);
299        rsc->setWatchdogGL(NULL, 0, NULL);
300        return false;
301    }
302
303    dc->gl.gl.version = glGetString(GL_VERSION);
304    dc->gl.gl.vendor = glGetString(GL_VENDOR);
305    dc->gl.gl.renderer = glGetString(GL_RENDERER);
306    dc->gl.gl.extensions = glGetString(GL_EXTENSIONS);
307
308    //ALOGV("EGL Version %i %i", mEGL.mMajorVersion, mEGL.mMinorVersion);
309    //ALOGV("GL Version %s", mGL.mVersion);
310    //ALOGV("GL Vendor %s", mGL.mVendor);
311    //ALOGV("GL Renderer %s", mGL.mRenderer);
312    //ALOGV("GL Extensions %s", mGL.mExtensions);
313
314    const char *verptr = NULL;
315    if (strlen((const char *)dc->gl.gl.version) > 9) {
316        if (!memcmp(dc->gl.gl.version, "OpenGL ES-CM", 12)) {
317            verptr = (const char *)dc->gl.gl.version + 12;
318        }
319        if (!memcmp(dc->gl.gl.version, "OpenGL ES ", 10)) {
320            verptr = (const char *)dc->gl.gl.version + 9;
321        }
322    }
323
324    if (!verptr) {
325        ALOGE("Error, OpenGL ES Lite not supported");
326        rsdGLShutdown(rsc);
327        rsc->setWatchdogGL(NULL, 0, NULL);
328        return false;
329    } else {
330        sscanf(verptr, " %i.%i", &dc->gl.gl.majorVersion, &dc->gl.gl.minorVersion);
331    }
332
333    glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &dc->gl.gl.maxVertexAttribs);
334    glGetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS, &dc->gl.gl.maxVertexUniformVectors);
335    glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &dc->gl.gl.maxVertexTextureUnits);
336
337    glGetIntegerv(GL_MAX_VARYING_VECTORS, &dc->gl.gl.maxVaryingVectors);
338    glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &dc->gl.gl.maxTextureImageUnits);
339
340    glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &dc->gl.gl.maxFragmentTextureImageUnits);
341    glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS, &dc->gl.gl.maxFragmentUniformVectors);
342
343    dc->gl.gl.OES_texture_npot = NULL != strstr((const char *)dc->gl.gl.extensions,
344                                                "GL_OES_texture_npot");
345    dc->gl.gl.IMG_texture_npot = NULL != strstr((const char *)dc->gl.gl.extensions,
346                                                   "GL_IMG_texture_npot");
347    dc->gl.gl.NV_texture_npot_2D_mipmap = NULL != strstr((const char *)dc->gl.gl.extensions,
348                                                            "GL_NV_texture_npot_2D_mipmap");
349    dc->gl.gl.EXT_texture_max_aniso = 1.0f;
350    bool hasAniso = NULL != strstr((const char *)dc->gl.gl.extensions,
351                                   "GL_EXT_texture_filter_anisotropic");
352    if (hasAniso) {
353        glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &dc->gl.gl.EXT_texture_max_aniso);
354    }
355
356    if (0) {
357        DumpDebug(dc);
358    }
359
360    dc->gl.shaderCache = new RsdShaderCache();
361    dc->gl.vertexArrayState = new RsdVertexArrayState();
362    dc->gl.vertexArrayState->init(dc->gl.gl.maxVertexAttribs);
363    dc->gl.currentFrameBuffer = NULL;
364    dc->mHasGraphics = true;
365
366    ALOGV("%p initGLThread end", rsc);
367    rsc->setWatchdogGL(NULL, 0, NULL);
368    return true;
369}
370
371
372bool rsdGLSetSurface(const Context *rsc, uint32_t w, uint32_t h, RsNativeWindow sur) {
373    RsdHal *dc = (RsdHal *)rsc->mHal.drv;
374
375    EGLBoolean ret;
376    // WAR: Some drivers fail to handle 0 size surfaces correcntly.
377    // Use the pbuffer to avoid this pitfall.
378    if ((dc->gl.egl.surface != NULL) || (w == 0) || (h == 0)) {
379        rsc->setWatchdogGL("eglMakeCurrent", __LINE__, __FILE__);
380        ret = eglMakeCurrent(dc->gl.egl.display, dc->gl.egl.surfaceDefault,
381                             dc->gl.egl.surfaceDefault, dc->gl.egl.context);
382        checkEglError("eglMakeCurrent", ret);
383
384        rsc->setWatchdogGL("eglDestroySurface", __LINE__, __FILE__);
385        ret = eglDestroySurface(dc->gl.egl.display, dc->gl.egl.surface);
386        checkEglError("eglDestroySurface", ret);
387
388        dc->gl.egl.surface = NULL;
389        dc->gl.width = 1;
390        dc->gl.height = 1;
391    }
392
393    if (dc->gl.wndSurface != NULL) {
394        dc->gl.wndSurface->decStrong(NULL);
395    }
396
397    dc->gl.wndSurface = (ANativeWindow *)sur;
398    if (dc->gl.wndSurface != NULL) {
399        dc->gl.wndSurface->incStrong(NULL);
400        dc->gl.width = w;
401        dc->gl.height = h;
402
403        rsc->setWatchdogGL("eglCreateWindowSurface", __LINE__, __FILE__);
404        dc->gl.egl.surface = eglCreateWindowSurface(dc->gl.egl.display, dc->gl.egl.config,
405                                                    dc->gl.wndSurface, NULL);
406        checkEglError("eglCreateWindowSurface");
407        if (dc->gl.egl.surface == EGL_NO_SURFACE) {
408            ALOGE("eglCreateWindowSurface returned EGL_NO_SURFACE");
409        }
410
411        rsc->setWatchdogGL("eglMakeCurrent", __LINE__, __FILE__);
412        ret = eglMakeCurrent(dc->gl.egl.display, dc->gl.egl.surface,
413                             dc->gl.egl.surface, dc->gl.egl.context);
414        checkEglError("eglMakeCurrent", ret);
415    }
416    rsc->setWatchdogGL(NULL, 0, NULL);
417    return true;
418}
419
420void rsdGLSwap(const android::renderscript::Context *rsc) {
421    RsdHal *dc = (RsdHal *)rsc->mHal.drv;
422    RSD_CALL_GL(eglSwapBuffers, dc->gl.egl.display, dc->gl.egl.surface);
423}
424
425void rsdGLSetPriority(const Context *rsc, int32_t priority) {
426    if (priority > 0) {
427        // Mark context as low priority.
428        ALOGV("low pri");
429    } else {
430        ALOGV("normal pri");
431    }
432}
433
434void rsdGLCheckError(const android::renderscript::Context *rsc,
435                     const char *msg, bool isFatal) {
436    GLenum err = glGetError();
437    if (err != GL_NO_ERROR) {
438        char buf[1024];
439        snprintf(buf, sizeof(buf), "GL Error = 0x%08x, from: %s", err, msg);
440
441        if (isFatal) {
442            rsc->setError(RS_ERROR_FATAL_DRIVER, buf);
443        } else {
444            switch (err) {
445            case GL_OUT_OF_MEMORY:
446                rsc->setError(RS_ERROR_OUT_OF_MEMORY, buf);
447                break;
448            default:
449                rsc->setError(RS_ERROR_DRIVER, buf);
450                break;
451            }
452        }
453
454        ALOGE("%p, %s", rsc, buf);
455    }
456
457}
458