RenderEngine.cpp revision e0ea99cc4ba89452b9b6b1baa33bddcb11f3351a 
1/*
2 * Copyright 2013 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 <log/log.h>
18#include <ui/Rect.h>
19#include <ui/Region.h>
20
21#include "RenderEngine.h"
22#include "GLES20RenderEngine.h"
23#include "GLExtensions.h"
24#include "Mesh.h"
25
26EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name);
27
28// ---------------------------------------------------------------------------
29namespace android {
30// ---------------------------------------------------------------------------
31
32static bool findExtension(const char* exts, const char* name) {
33    if (!exts)
34        return false;
35    size_t len = strlen(name);
36
37    const char* pos = exts;
38    while ((pos = strstr(pos, name)) != NULL) {
39        if (pos[len] == '\0' || pos[len] == ' ')
40            return true;
41        pos += len;
42    }
43
44    return false;
45}
46
47RenderEngine* RenderEngine::create(EGLDisplay display, int hwcFormat) {
48    // EGL_ANDROIDX_no_config_context is an experimental extension with no
49    // written specification. It will be replaced by something more formal.
50    // SurfaceFlinger is using it to allow a single EGLContext to render to
51    // both a 16-bit primary display framebuffer and a 32-bit virtual display
52    // framebuffer.
53    //
54    // The code assumes that ES2 or later is available if this extension is
55    // supported.
56    EGLConfig config = EGL_NO_CONFIG;
57    if (!findExtension(
58            eglQueryStringImplementationANDROID(display, EGL_EXTENSIONS),
59            "EGL_ANDROIDX_no_config_context")) {
60        config = chooseEglConfig(display, hwcFormat);
61    }
62
63    EGLint renderableType = 0;
64    if (config == EGL_NO_CONFIG) {
65        renderableType = EGL_OPENGL_ES2_BIT;
66    } else if (!eglGetConfigAttrib(display, config,
67            EGL_RENDERABLE_TYPE, &renderableType)) {
68        LOG_ALWAYS_FATAL("can't query EGLConfig RENDERABLE_TYPE");
69    }
70    EGLint contextClientVersion = 0;
71    if (renderableType & EGL_OPENGL_ES2_BIT) {
72        contextClientVersion = 2;
73    } else if (renderableType & EGL_OPENGL_ES_BIT) {
74        contextClientVersion = 1;
75    } else {
76        LOG_ALWAYS_FATAL("no supported EGL_RENDERABLE_TYPEs");
77    }
78
79    // Also create our EGLContext
80    EGLint contextAttributes[] = {
81            EGL_CONTEXT_CLIENT_VERSION, contextClientVersion,      // MUST be first
82#ifdef EGL_IMG_context_priority
83#ifdef HAS_CONTEXT_PRIORITY
84#warning "using EGL_IMG_context_priority"
85            EGL_CONTEXT_PRIORITY_LEVEL_IMG, EGL_CONTEXT_PRIORITY_HIGH_IMG,
86#endif
87#endif
88            EGL_NONE, EGL_NONE
89    };
90    EGLContext ctxt = eglCreateContext(display, config, NULL, contextAttributes);
91
92    // if can't create a GL context, we can only abort.
93    LOG_ALWAYS_FATAL_IF(ctxt==EGL_NO_CONTEXT, "EGLContext creation failed");
94
95
96    // now figure out what version of GL did we actually get
97    // NOTE: a dummy surface is not needed if KHR_create_context is supported
98
99    EGLConfig dummyConfig = config;
100    if (dummyConfig == EGL_NO_CONFIG) {
101        dummyConfig = chooseEglConfig(display, hwcFormat);
102    }
103    EGLint attribs[] = { EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE, EGL_NONE };
104    EGLSurface dummy = eglCreatePbufferSurface(display, dummyConfig, attribs);
105    LOG_ALWAYS_FATAL_IF(dummy==EGL_NO_SURFACE, "can't create dummy pbuffer");
106    EGLBoolean success = eglMakeCurrent(display, dummy, dummy, ctxt);
107    LOG_ALWAYS_FATAL_IF(!success, "can't make dummy pbuffer current");
108
109    GLExtensions& extensions(GLExtensions::getInstance());
110    extensions.initWithGLStrings(
111            glGetString(GL_VENDOR),
112            glGetString(GL_RENDERER),
113            glGetString(GL_VERSION),
114            glGetString(GL_EXTENSIONS));
115
116    GlesVersion version = parseGlesVersion( extensions.getVersion() );
117
118    // initialize the renderer while GL is current
119
120    RenderEngine* engine = NULL;
121    switch (version) {
122    case GLES_VERSION_1_0:
123    case GLES_VERSION_1_1:
124        LOG_ALWAYS_FATAL("SurfaceFlinger requires OpenGL ES 2.0 minimum to run.");
125        break;
126    case GLES_VERSION_2_0:
127    case GLES_VERSION_3_0:
128        engine = new GLES20RenderEngine();
129        break;
130    }
131    engine->setEGLHandles(config, ctxt);
132
133    ALOGI("OpenGL ES informations:");
134    ALOGI("vendor    : %s", extensions.getVendor());
135    ALOGI("renderer  : %s", extensions.getRenderer());
136    ALOGI("version   : %s", extensions.getVersion());
137    ALOGI("extensions: %s", extensions.getExtension());
138    ALOGI("GL_MAX_TEXTURE_SIZE = %zu", engine->getMaxTextureSize());
139    ALOGI("GL_MAX_VIEWPORT_DIMS = %zu", engine->getMaxViewportDims());
140
141    eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
142    eglDestroySurface(display, dummy);
143
144    return engine;
145}
146
147RenderEngine::RenderEngine() : mEGLConfig(NULL), mEGLContext(EGL_NO_CONTEXT) {
148}
149
150RenderEngine::~RenderEngine() {
151}
152
153void RenderEngine::setEGLHandles(EGLConfig config, EGLContext ctxt) {
154    mEGLConfig = config;
155    mEGLContext = ctxt;
156}
157
158EGLContext RenderEngine::getEGLConfig() const {
159    return mEGLConfig;
160}
161
162EGLContext RenderEngine::getEGLContext() const {
163    return mEGLContext;
164}
165
166void RenderEngine::checkErrors() const {
167    do {
168        // there could be more than one error flag
169        GLenum error = glGetError();
170        if (error == GL_NO_ERROR)
171            break;
172        ALOGE("GL error 0x%04x", int(error));
173    } while (true);
174}
175
176RenderEngine::GlesVersion RenderEngine::parseGlesVersion(const char* str) {
177    int major, minor;
178    if (sscanf(str, "OpenGL ES-CM %d.%d", &major, &minor) != 2) {
179        if (sscanf(str, "OpenGL ES %d.%d", &major, &minor) != 2) {
180            ALOGW("Unable to parse GL_VERSION string: \"%s\"", str);
181            return GLES_VERSION_1_0;
182        }
183    }
184
185    if (major == 1 && minor == 0) return GLES_VERSION_1_0;
186    if (major == 1 && minor >= 1) return GLES_VERSION_1_1;
187    if (major == 2 && minor >= 0) return GLES_VERSION_2_0;
188    if (major == 3 && minor >= 0) return GLES_VERSION_3_0;
189
190    ALOGW("Unrecognized OpenGL ES version: %d.%d", major, minor);
191    return GLES_VERSION_1_0;
192}
193
194void RenderEngine::fillRegionWithColor(const Region& region, uint32_t height,
195        float red, float green, float blue, float alpha) {
196    size_t c;
197    Rect const* r = region.getArray(&c);
198    Mesh mesh(Mesh::TRIANGLES, c*6, 2);
199    Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>());
200    for (size_t i=0 ; i<c ; i++, r++) {
201        position[i*6 + 0].x = r->left;
202        position[i*6 + 0].y = height - r->top;
203        position[i*6 + 1].x = r->left;
204        position[i*6 + 1].y = height - r->bottom;
205        position[i*6 + 2].x = r->right;
206        position[i*6 + 2].y = height - r->bottom;
207        position[i*6 + 3].x = r->left;
208        position[i*6 + 3].y = height - r->top;
209        position[i*6 + 4].x = r->right;
210        position[i*6 + 4].y = height - r->bottom;
211        position[i*6 + 5].x = r->right;
212        position[i*6 + 5].y = height - r->top;
213    }
214    setupFillWithColor(red, green, blue, alpha);
215    drawMesh(mesh);
216}
217
218void RenderEngine::flush() {
219    glFlush();
220}
221
222void RenderEngine::clearWithColor(float red, float green, float blue, float alpha) {
223    glClearColor(red, green, blue, alpha);
224    glClear(GL_COLOR_BUFFER_BIT);
225}
226
227void RenderEngine::setScissor(
228        uint32_t left, uint32_t bottom, uint32_t right, uint32_t top) {
229    glScissor(left, bottom, right, top);
230    glEnable(GL_SCISSOR_TEST);
231}
232
233void RenderEngine::disableScissor() {
234    glDisable(GL_SCISSOR_TEST);
235}
236
237void RenderEngine::genTextures(size_t count, uint32_t* names) {
238    glGenTextures(count, names);
239}
240
241void RenderEngine::deleteTextures(size_t count, uint32_t const* names) {
242    glDeleteTextures(count, names);
243}
244
245void RenderEngine::readPixels(size_t l, size_t b, size_t w, size_t h, uint32_t* pixels) {
246    glReadPixels(l, b, w, h, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
247}
248
249void RenderEngine::dump(String8& result) {
250    const GLExtensions& extensions(GLExtensions::getInstance());
251    result.appendFormat("GLES: %s, %s, %s\n",
252            extensions.getVendor(),
253            extensions.getRenderer(),
254            extensions.getVersion());
255    result.appendFormat("%s\n", extensions.getExtension());
256}
257
258// ---------------------------------------------------------------------------
259
260RenderEngine::BindImageAsFramebuffer::BindImageAsFramebuffer(
261        RenderEngine& engine, EGLImageKHR image) : mEngine(engine)
262{
263    mEngine.bindImageAsFramebuffer(image, &mTexName, &mFbName, &mStatus);
264
265    ALOGE_IF(mStatus != GL_FRAMEBUFFER_COMPLETE_OES,
266            "glCheckFramebufferStatusOES error %d", mStatus);
267}
268
269RenderEngine::BindImageAsFramebuffer::~BindImageAsFramebuffer() {
270    // back to main framebuffer
271    mEngine.unbindFramebuffer(mTexName, mFbName);
272}
273
274status_t RenderEngine::BindImageAsFramebuffer::getStatus() const {
275    return mStatus == GL_FRAMEBUFFER_COMPLETE_OES ? NO_ERROR : BAD_VALUE;
276}
277
278// ---------------------------------------------------------------------------
279
280static status_t selectConfigForAttribute(EGLDisplay dpy, EGLint const* attrs,
281        EGLint attribute, EGLint wanted, EGLConfig* outConfig) {
282    EGLint numConfigs = -1, n = 0;
283    eglGetConfigs(dpy, NULL, 0, &numConfigs);
284    EGLConfig* const configs = new EGLConfig[numConfigs];
285    eglChooseConfig(dpy, attrs, configs, numConfigs, &n);
286
287    if (n) {
288        if (attribute != EGL_NONE) {
289            for (int i=0 ; i<n ; i++) {
290                EGLint value = 0;
291                eglGetConfigAttrib(dpy, configs[i], attribute, &value);
292                if (wanted == value) {
293                    *outConfig = configs[i];
294                    delete [] configs;
295                    return NO_ERROR;
296                }
297            }
298        } else {
299            // just pick the first one
300            *outConfig = configs[0];
301            delete [] configs;
302            return NO_ERROR;
303        }
304    }
305    delete [] configs;
306    return NAME_NOT_FOUND;
307}
308
309class EGLAttributeVector {
310    struct Attribute;
311    class Adder;
312    friend class Adder;
313    KeyedVector<Attribute, EGLint> mList;
314    struct Attribute {
315        Attribute() : v(0) {};
316        explicit Attribute(EGLint v) : v(v) { }
317        EGLint v;
318        bool operator < (const Attribute& other) const {
319            // this places EGL_NONE at the end
320            EGLint lhs(v);
321            EGLint rhs(other.v);
322            if (lhs == EGL_NONE) lhs = 0x7FFFFFFF;
323            if (rhs == EGL_NONE) rhs = 0x7FFFFFFF;
324            return lhs < rhs;
325        }
326    };
327    class Adder {
328        friend class EGLAttributeVector;
329        EGLAttributeVector& v;
330        EGLint attribute;
331        Adder(EGLAttributeVector& v, EGLint attribute)
332            : v(v), attribute(attribute) {
333        }
334    public:
335        void operator = (EGLint value) {
336            if (attribute != EGL_NONE) {
337                v.mList.add(Attribute(attribute), value);
338            }
339        }
340        operator EGLint () const { return v.mList[attribute]; }
341    };
342public:
343    EGLAttributeVector() {
344        mList.add(Attribute(EGL_NONE), EGL_NONE);
345    }
346    void remove(EGLint attribute) {
347        if (attribute != EGL_NONE) {
348            mList.removeItem(Attribute(attribute));
349        }
350    }
351    Adder operator [] (EGLint attribute) {
352        return Adder(*this, attribute);
353    }
354    EGLint operator [] (EGLint attribute) const {
355       return mList[attribute];
356    }
357    // cast-operator to (EGLint const*)
358    operator EGLint const* () const { return &mList.keyAt(0).v; }
359};
360
361
362static status_t selectEGLConfig(EGLDisplay display, EGLint format,
363    EGLint renderableType, EGLConfig* config) {
364    // select our EGLConfig. It must support EGL_RECORDABLE_ANDROID if
365    // it is to be used with WIFI displays
366    status_t err;
367    EGLint wantedAttribute;
368    EGLint wantedAttributeValue;
369
370    EGLAttributeVector attribs;
371    if (renderableType) {
372        attribs[EGL_RENDERABLE_TYPE]            = renderableType;
373        attribs[EGL_RECORDABLE_ANDROID]         = EGL_TRUE;
374        attribs[EGL_SURFACE_TYPE]               = EGL_WINDOW_BIT|EGL_PBUFFER_BIT;
375        attribs[EGL_FRAMEBUFFER_TARGET_ANDROID] = EGL_TRUE;
376        attribs[EGL_RED_SIZE]                   = 8;
377        attribs[EGL_GREEN_SIZE]                 = 8;
378        attribs[EGL_BLUE_SIZE]                  = 8;
379        wantedAttribute                         = EGL_NONE;
380        wantedAttributeValue                    = EGL_NONE;
381    } else {
382        // if no renderable type specified, fallback to a simplified query
383        wantedAttribute                         = EGL_NATIVE_VISUAL_ID;
384        wantedAttributeValue                    = format;
385    }
386
387    err = selectConfigForAttribute(display, attribs,
388            wantedAttribute, wantedAttributeValue, config);
389    if (err == NO_ERROR) {
390        EGLint caveat;
391        if (eglGetConfigAttrib(display, *config, EGL_CONFIG_CAVEAT, &caveat))
392            ALOGW_IF(caveat == EGL_SLOW_CONFIG, "EGL_SLOW_CONFIG selected!");
393    }
394
395    return err;
396}
397
398EGLConfig RenderEngine::chooseEglConfig(EGLDisplay display, int format) {
399    status_t err;
400    EGLConfig config;
401
402    // First try to get an ES2 config
403    err = selectEGLConfig(display, format, EGL_OPENGL_ES2_BIT, &config);
404    if (err != NO_ERROR) {
405        // If ES2 fails, try ES1
406        err = selectEGLConfig(display, format, EGL_OPENGL_ES_BIT, &config);
407        if (err != NO_ERROR) {
408            // still didn't work, probably because we're on the emulator...
409            // try a simplified query
410            ALOGW("no suitable EGLConfig found, trying a simpler query");
411            err = selectEGLConfig(display, format, 0, &config);
412            if (err != NO_ERROR) {
413                // this EGL is too lame for android
414                LOG_ALWAYS_FATAL("no suitable EGLConfig found, giving up");
415            }
416        }
417    }
418
419    // print some debugging info
420    EGLint r,g,b,a;
421    eglGetConfigAttrib(display, config, EGL_RED_SIZE,   &r);
422    eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &g);
423    eglGetConfigAttrib(display, config, EGL_BLUE_SIZE,  &b);
424    eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &a);
425    ALOGI("EGL information:");
426    ALOGI("vendor    : %s", eglQueryString(display, EGL_VENDOR));
427    ALOGI("version   : %s", eglQueryString(display, EGL_VERSION));
428    ALOGI("extensions: %s", eglQueryString(display, EGL_EXTENSIONS));
429    ALOGI("Client API: %s", eglQueryString(display, EGL_CLIENT_APIS)?:"Not Supported");
430    ALOGI("EGLSurface: %d-%d-%d-%d, config=%p", r, g, b, a, config);
431
432    return config;
433}
434
435
436void RenderEngine::primeCache() const {
437    // Getting the ProgramCache instance causes it to prime its shader cache,
438    // which is performed in its constructor
439    ProgramCache::getInstance();
440}
441
442// ---------------------------------------------------------------------------
443}; // namespace android
444// ---------------------------------------------------------------------------
445