1 /*
2  * Copyright (C) 2014 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 "EglManager.h"
18 
19 #include "Caches.h"
20 #include "Properties.h"
21 #include "RenderThread.h"
22 #include "renderstate/RenderState.h"
23 
24 #include <cutils/log.h>
25 #include <cutils/properties.h>
26 #include <EGL/eglext.h>
27 
28 #define PROPERTY_RENDER_DIRTY_REGIONS "debug.hwui.render_dirty_regions"
29 #define GLES_VERSION 2
30 
31 #define WAIT_FOR_GPU_COMPLETION 0
32 
33 // Android-specific addition that is used to show when frames began in systrace
34 EGLAPI void EGLAPIENTRY eglBeginFrame(EGLDisplay dpy, EGLSurface surface);
35 
36 namespace android {
37 namespace uirenderer {
38 namespace renderthread {
39 
40 #define ERROR_CASE(x) case x: return #x;
egl_error_str(EGLint error)41 static const char* egl_error_str(EGLint error) {
42     switch (error) {
43         ERROR_CASE(EGL_SUCCESS)
44         ERROR_CASE(EGL_NOT_INITIALIZED)
45         ERROR_CASE(EGL_BAD_ACCESS)
46         ERROR_CASE(EGL_BAD_ALLOC)
47         ERROR_CASE(EGL_BAD_ATTRIBUTE)
48         ERROR_CASE(EGL_BAD_CONFIG)
49         ERROR_CASE(EGL_BAD_CONTEXT)
50         ERROR_CASE(EGL_BAD_CURRENT_SURFACE)
51         ERROR_CASE(EGL_BAD_DISPLAY)
52         ERROR_CASE(EGL_BAD_MATCH)
53         ERROR_CASE(EGL_BAD_NATIVE_PIXMAP)
54         ERROR_CASE(EGL_BAD_NATIVE_WINDOW)
55         ERROR_CASE(EGL_BAD_PARAMETER)
56         ERROR_CASE(EGL_BAD_SURFACE)
57         ERROR_CASE(EGL_CONTEXT_LOST)
58     default:
59         return "Unknown error";
60     }
61 }
egl_error_str()62 static const char* egl_error_str() {
63     return egl_error_str(eglGetError());
64 }
65 
load_dirty_regions_property()66 static bool load_dirty_regions_property() {
67     char buf[PROPERTY_VALUE_MAX];
68     int len = property_get(PROPERTY_RENDER_DIRTY_REGIONS, buf, "true");
69     return !strncasecmp("true", buf, len);
70 }
71 
EglManager(RenderThread & thread)72 EglManager::EglManager(RenderThread& thread)
73         : mRenderThread(thread)
74         , mEglDisplay(EGL_NO_DISPLAY)
75         , mEglConfig(nullptr)
76         , mEglContext(EGL_NO_CONTEXT)
77         , mPBufferSurface(EGL_NO_SURFACE)
78         , mAllowPreserveBuffer(load_dirty_regions_property())
79         , mCurrentSurface(EGL_NO_SURFACE)
80         , mAtlasMap(nullptr)
81         , mAtlasMapSize(0) {
82     mCanSetPreserveBuffer = mAllowPreserveBuffer;
83     ALOGD("Use EGL_SWAP_BEHAVIOR_PRESERVED: %s", mAllowPreserveBuffer ? "true" : "false");
84 }
85 
initialize()86 void EglManager::initialize() {
87     if (hasEglContext()) return;
88 
89     ATRACE_NAME("Creating EGLContext");
90 
91     mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
92     LOG_ALWAYS_FATAL_IF(mEglDisplay == EGL_NO_DISPLAY,
93             "Failed to get EGL_DEFAULT_DISPLAY! err=%s", egl_error_str());
94 
95     EGLint major, minor;
96     LOG_ALWAYS_FATAL_IF(eglInitialize(mEglDisplay, &major, &minor) == EGL_FALSE,
97             "Failed to initialize display %p! err=%s", mEglDisplay, egl_error_str());
98 
99     ALOGI("Initialized EGL, version %d.%d", (int)major, (int)minor);
100 
101     loadConfig();
102     createContext();
103     createPBufferSurface();
104     makeCurrent(mPBufferSurface);
105     mRenderThread.renderState().onGLContextCreated();
106     initAtlas();
107 }
108 
hasEglContext()109 bool EglManager::hasEglContext() {
110     return mEglDisplay != EGL_NO_DISPLAY;
111 }
112 
loadConfig()113 void EglManager::loadConfig() {
114     EGLint swapBehavior = mCanSetPreserveBuffer ? EGL_SWAP_BEHAVIOR_PRESERVED_BIT : 0;
115     EGLint attribs[] = {
116             EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
117             EGL_RED_SIZE, 8,
118             EGL_GREEN_SIZE, 8,
119             EGL_BLUE_SIZE, 8,
120             EGL_ALPHA_SIZE, 8,
121             EGL_DEPTH_SIZE, 0,
122             EGL_CONFIG_CAVEAT, EGL_NONE,
123             EGL_STENCIL_SIZE, Stencil::getStencilSize(),
124             EGL_SURFACE_TYPE, EGL_WINDOW_BIT | swapBehavior,
125             EGL_NONE
126     };
127 
128     EGLint num_configs = 1;
129     if (!eglChooseConfig(mEglDisplay, attribs, &mEglConfig, num_configs, &num_configs)
130             || num_configs != 1) {
131         // Failed to get a valid config
132         if (mCanSetPreserveBuffer) {
133             ALOGW("Failed to choose config with EGL_SWAP_BEHAVIOR_PRESERVED, retrying without...");
134             // Try again without dirty regions enabled
135             mCanSetPreserveBuffer = false;
136             loadConfig();
137         } else {
138             LOG_ALWAYS_FATAL("Failed to choose config, error = %s", egl_error_str());
139         }
140     }
141 }
142 
createContext()143 void EglManager::createContext() {
144     EGLint attribs[] = { EGL_CONTEXT_CLIENT_VERSION, GLES_VERSION, EGL_NONE };
145     mEglContext = eglCreateContext(mEglDisplay, mEglConfig, EGL_NO_CONTEXT, attribs);
146     LOG_ALWAYS_FATAL_IF(mEglContext == EGL_NO_CONTEXT,
147         "Failed to create context, error = %s", egl_error_str());
148 }
149 
setTextureAtlas(const sp<GraphicBuffer> & buffer,int64_t * map,size_t mapSize)150 void EglManager::setTextureAtlas(const sp<GraphicBuffer>& buffer,
151         int64_t* map, size_t mapSize) {
152 
153     // Already initialized
154     if (mAtlasBuffer.get()) {
155         ALOGW("Multiple calls to setTextureAtlas!");
156         delete map;
157         return;
158     }
159 
160     mAtlasBuffer = buffer;
161     mAtlasMap = map;
162     mAtlasMapSize = mapSize;
163 
164     if (hasEglContext()) {
165         initAtlas();
166     }
167 }
168 
initAtlas()169 void EglManager::initAtlas() {
170     if (mAtlasBuffer.get()) {
171         mRenderThread.renderState().assetAtlas().init(mAtlasBuffer,
172                 mAtlasMap, mAtlasMapSize);
173     }
174 }
175 
createPBufferSurface()176 void EglManager::createPBufferSurface() {
177     LOG_ALWAYS_FATAL_IF(mEglDisplay == EGL_NO_DISPLAY,
178             "usePBufferSurface() called on uninitialized GlobalContext!");
179 
180     if (mPBufferSurface == EGL_NO_SURFACE) {
181         EGLint attribs[] = { EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE };
182         mPBufferSurface = eglCreatePbufferSurface(mEglDisplay, mEglConfig, attribs);
183     }
184 }
185 
createSurface(EGLNativeWindowType window)186 EGLSurface EglManager::createSurface(EGLNativeWindowType window) {
187     initialize();
188     EGLSurface surface = eglCreateWindowSurface(mEglDisplay, mEglConfig, window, nullptr);
189     LOG_ALWAYS_FATAL_IF(surface == EGL_NO_SURFACE,
190             "Failed to create EGLSurface for window %p, eglErr = %s",
191             (void*) window, egl_error_str());
192     return surface;
193 }
194 
destroySurface(EGLSurface surface)195 void EglManager::destroySurface(EGLSurface surface) {
196     if (isCurrent(surface)) {
197         makeCurrent(EGL_NO_SURFACE);
198     }
199     if (!eglDestroySurface(mEglDisplay, surface)) {
200         ALOGW("Failed to destroy surface %p, error=%s", (void*)surface, egl_error_str());
201     }
202 }
203 
destroy()204 void EglManager::destroy() {
205     if (mEglDisplay == EGL_NO_DISPLAY) return;
206 
207     mRenderThread.renderState().onGLContextDestroyed();
208     eglDestroyContext(mEglDisplay, mEglContext);
209     eglDestroySurface(mEglDisplay, mPBufferSurface);
210     eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
211     eglTerminate(mEglDisplay);
212     eglReleaseThread();
213 
214     mEglDisplay = EGL_NO_DISPLAY;
215     mEglContext = EGL_NO_CONTEXT;
216     mPBufferSurface = EGL_NO_SURFACE;
217     mCurrentSurface = EGL_NO_SURFACE;
218 }
219 
makeCurrent(EGLSurface surface,EGLint * errOut)220 bool EglManager::makeCurrent(EGLSurface surface, EGLint* errOut) {
221     if (isCurrent(surface)) return false;
222 
223     if (surface == EGL_NO_SURFACE) {
224         // Ensure we always have a valid surface & context
225         surface = mPBufferSurface;
226     }
227     if (!eglMakeCurrent(mEglDisplay, surface, surface, mEglContext)) {
228         if (errOut) {
229             *errOut = eglGetError();
230             ALOGW("Failed to make current on surface %p, error=%s",
231                     (void*)surface, egl_error_str(*errOut));
232         } else {
233             LOG_ALWAYS_FATAL("Failed to make current on surface %p, error=%s",
234                     (void*)surface, egl_error_str());
235         }
236     }
237     mCurrentSurface = surface;
238     return true;
239 }
240 
beginFrame(EGLSurface surface,EGLint * width,EGLint * height)241 void EglManager::beginFrame(EGLSurface surface, EGLint* width, EGLint* height) {
242     LOG_ALWAYS_FATAL_IF(surface == EGL_NO_SURFACE,
243             "Tried to beginFrame on EGL_NO_SURFACE!");
244     makeCurrent(surface);
245     if (width) {
246         eglQuerySurface(mEglDisplay, surface, EGL_WIDTH, width);
247     }
248     if (height) {
249         eglQuerySurface(mEglDisplay, surface, EGL_HEIGHT, height);
250     }
251     eglBeginFrame(mEglDisplay, surface);
252 }
253 
swapBuffers(EGLSurface surface,const SkRect & dirty,EGLint width,EGLint height)254 bool EglManager::swapBuffers(EGLSurface surface, const SkRect& dirty,
255         EGLint width, EGLint height) {
256 
257 #if WAIT_FOR_GPU_COMPLETION
258     {
259         ATRACE_NAME("Finishing GPU work");
260         fence();
261     }
262 #endif
263 
264 #ifdef EGL_KHR_swap_buffers_with_damage
265     if (CC_LIKELY(Properties::swapBuffersWithDamage)) {
266         SkIRect idirty;
267         dirty.roundOut(&idirty);
268         /*
269          * EGL_KHR_swap_buffers_with_damage spec states:
270          *
271          * The rectangles are specified relative to the bottom-left of the surface
272          * and the x and y components of each rectangle specify the bottom-left
273          * position of that rectangle.
274          *
275          * HWUI does everything with 0,0 being top-left, so need to map
276          * the rect
277          */
278         EGLint y = height - (idirty.y() + idirty.height());
279         // layout: {x, y, width, height}
280         EGLint rects[4] = { idirty.x(), y, idirty.width(), idirty.height() };
281         EGLint numrects = dirty.isEmpty() ? 0 : 1;
282         eglSwapBuffersWithDamageKHR(mEglDisplay, surface, rects, numrects);
283     } else {
284         eglSwapBuffers(mEglDisplay, surface);
285     }
286 #else
287     eglSwapBuffers(mEglDisplay, surface);
288 #endif
289 
290     EGLint err = eglGetError();
291     if (CC_LIKELY(err == EGL_SUCCESS)) {
292         return true;
293     }
294     if (err == EGL_BAD_SURFACE) {
295         // For some reason our surface was destroyed out from under us
296         // This really shouldn't happen, but if it does we can recover easily
297         // by just not trying to use the surface anymore
298         ALOGW("swapBuffers encountered EGL_BAD_SURFACE on %p, halting rendering...", surface);
299         return false;
300     }
301     LOG_ALWAYS_FATAL("Encountered EGL error %d %s during rendering",
302             err, egl_error_str(err));
303     // Impossible to hit this, but the compiler doesn't know that
304     return false;
305 }
306 
fence()307 void EglManager::fence() {
308     EGLSyncKHR fence = eglCreateSyncKHR(mEglDisplay, EGL_SYNC_FENCE_KHR, NULL);
309     eglClientWaitSyncKHR(mEglDisplay, fence,
310             EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, EGL_FOREVER_KHR);
311     eglDestroySyncKHR(mEglDisplay, fence);
312 }
313 
setPreserveBuffer(EGLSurface surface,bool preserve)314 bool EglManager::setPreserveBuffer(EGLSurface surface, bool preserve) {
315     if (CC_UNLIKELY(!mAllowPreserveBuffer)) return false;
316 
317     bool preserved = false;
318     if (mCanSetPreserveBuffer) {
319         preserved = eglSurfaceAttrib(mEglDisplay, surface, EGL_SWAP_BEHAVIOR,
320                 preserve ? EGL_BUFFER_PRESERVED : EGL_BUFFER_DESTROYED);
321         if (CC_UNLIKELY(!preserved)) {
322             ALOGW("Failed to set EGL_SWAP_BEHAVIOR on surface %p, error=%s",
323                     (void*) surface, egl_error_str());
324         }
325     }
326     if (CC_UNLIKELY(!preserved)) {
327         // Maybe it's already set?
328         EGLint swapBehavior;
329         if (eglQuerySurface(mEglDisplay, surface, EGL_SWAP_BEHAVIOR, &swapBehavior)) {
330             preserved = (swapBehavior == EGL_BUFFER_PRESERVED);
331         } else {
332             ALOGW("Failed to query EGL_SWAP_BEHAVIOR on surface %p, error=%p",
333                                 (void*) surface, egl_error_str());
334         }
335     }
336 
337     return preserved;
338 }
339 
340 } /* namespace renderthread */
341 } /* namespace uirenderer */
342 } /* namespace android */
343