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