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