John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 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 | #define LOG_TAG "CanvasContext" |
| 18 | |
| 19 | #include "CanvasContext.h" |
| 20 | |
| 21 | #include <cutils/properties.h> |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 22 | #include <private/hwui/DrawGlInfo.h> |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 23 | #include <strings.h> |
| 24 | |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 25 | #include "RenderThread.h" |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 26 | #include "../Caches.h" |
John Reck | 19b6bcf | 2014-02-14 20:03:38 -0800 | [diff] [blame] | 27 | #include "../DeferredLayerUpdater.h" |
| 28 | #include "../LayerRenderer.h" |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 29 | #include "../OpenGLRenderer.h" |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 30 | #include "../Stencil.h" |
| 31 | |
| 32 | #define PROPERTY_RENDER_DIRTY_REGIONS "debug.hwui.render_dirty_regions" |
| 33 | #define GLES_VERSION 2 |
| 34 | |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 35 | // Android-specific addition that is used to show when frames began in systrace |
| 36 | EGLAPI void EGLAPIENTRY eglBeginFrame(EGLDisplay dpy, EGLSurface surface); |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 37 | |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 38 | namespace android { |
| 39 | namespace uirenderer { |
| 40 | namespace renderthread { |
| 41 | |
| 42 | #define ERROR_CASE(x) case x: return #x; |
| 43 | static const char* egl_error_str(EGLint error) { |
| 44 | switch (error) { |
| 45 | ERROR_CASE(EGL_SUCCESS) |
| 46 | ERROR_CASE(EGL_NOT_INITIALIZED) |
| 47 | ERROR_CASE(EGL_BAD_ACCESS) |
| 48 | ERROR_CASE(EGL_BAD_ALLOC) |
| 49 | ERROR_CASE(EGL_BAD_ATTRIBUTE) |
| 50 | ERROR_CASE(EGL_BAD_CONFIG) |
| 51 | ERROR_CASE(EGL_BAD_CONTEXT) |
| 52 | ERROR_CASE(EGL_BAD_CURRENT_SURFACE) |
| 53 | ERROR_CASE(EGL_BAD_DISPLAY) |
| 54 | ERROR_CASE(EGL_BAD_MATCH) |
| 55 | ERROR_CASE(EGL_BAD_NATIVE_PIXMAP) |
| 56 | ERROR_CASE(EGL_BAD_NATIVE_WINDOW) |
| 57 | ERROR_CASE(EGL_BAD_PARAMETER) |
| 58 | ERROR_CASE(EGL_BAD_SURFACE) |
| 59 | ERROR_CASE(EGL_CONTEXT_LOST) |
| 60 | default: |
| 61 | return "Unknown error"; |
| 62 | } |
| 63 | } |
| 64 | static const char* egl_error_str() { |
| 65 | return egl_error_str(eglGetError()); |
| 66 | } |
| 67 | |
| 68 | static bool load_dirty_regions_property() { |
| 69 | char buf[PROPERTY_VALUE_MAX]; |
| 70 | int len = property_get(PROPERTY_RENDER_DIRTY_REGIONS, buf, "true"); |
| 71 | return !strncasecmp("true", buf, len); |
| 72 | } |
| 73 | |
| 74 | // This class contains the shared global EGL objects, such as EGLDisplay |
| 75 | // and EGLConfig, which are re-used by CanvasContext |
| 76 | class GlobalContext { |
| 77 | public: |
| 78 | static GlobalContext* get(); |
| 79 | |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 80 | // Returns true on success, false on failure |
| 81 | void initialize(); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 82 | |
John Reck | 0d1f634 | 2014-03-28 20:30:27 -0700 | [diff] [blame] | 83 | bool hasContext(); |
| 84 | |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 85 | void usePBufferSurface(); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 86 | EGLSurface createSurface(EGLNativeWindowType window); |
| 87 | void destroySurface(EGLSurface surface); |
| 88 | |
| 89 | void destroy(); |
| 90 | |
| 91 | bool isCurrent(EGLSurface surface) { return mCurrentSurface == surface; } |
John Reck | dbc9a86 | 2014-04-17 20:25:13 -0700 | [diff] [blame] | 92 | // Returns true if the current surface changed, false if it was already current |
| 93 | bool makeCurrent(EGLSurface surface); |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 94 | void beginFrame(EGLSurface surface, EGLint* width, EGLint* height); |
| 95 | void swapBuffers(EGLSurface surface); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 96 | |
| 97 | bool enableDirtyRegions(EGLSurface surface); |
| 98 | |
John Reck | 66f0be6 | 2014-05-13 13:39:31 -0700 | [diff] [blame] | 99 | void setTextureAtlas(const sp<GraphicBuffer>& buffer, int64_t* map, size_t mapSize); |
| 100 | |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 101 | private: |
| 102 | GlobalContext(); |
| 103 | // GlobalContext is never destroyed, method is purposely not implemented |
| 104 | ~GlobalContext(); |
| 105 | |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 106 | void loadConfig(); |
| 107 | void createContext(); |
| 108 | void initAtlas(); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 109 | |
| 110 | static GlobalContext* sContext; |
| 111 | |
| 112 | EGLDisplay mEglDisplay; |
| 113 | EGLConfig mEglConfig; |
| 114 | EGLContext mEglContext; |
| 115 | EGLSurface mPBufferSurface; |
| 116 | |
| 117 | const bool mRequestDirtyRegions; |
| 118 | bool mCanSetDirtyRegions; |
| 119 | |
| 120 | EGLSurface mCurrentSurface; |
John Reck | 66f0be6 | 2014-05-13 13:39:31 -0700 | [diff] [blame] | 121 | |
| 122 | sp<GraphicBuffer> mAtlasBuffer; |
| 123 | int64_t* mAtlasMap; |
| 124 | size_t mAtlasMapSize; |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 125 | }; |
| 126 | |
| 127 | GlobalContext* GlobalContext::sContext = 0; |
| 128 | |
| 129 | GlobalContext* GlobalContext::get() { |
| 130 | if (!sContext) { |
| 131 | sContext = new GlobalContext(); |
| 132 | } |
| 133 | return sContext; |
| 134 | } |
| 135 | |
| 136 | GlobalContext::GlobalContext() |
| 137 | : mEglDisplay(EGL_NO_DISPLAY) |
| 138 | , mEglConfig(0) |
| 139 | , mEglContext(EGL_NO_CONTEXT) |
| 140 | , mPBufferSurface(EGL_NO_SURFACE) |
| 141 | , mRequestDirtyRegions(load_dirty_regions_property()) |
John Reck | 66f0be6 | 2014-05-13 13:39:31 -0700 | [diff] [blame] | 142 | , mCurrentSurface(EGL_NO_SURFACE) |
| 143 | , mAtlasMap(NULL) |
| 144 | , mAtlasMapSize(0) { |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 145 | mCanSetDirtyRegions = mRequestDirtyRegions; |
| 146 | ALOGD("Render dirty regions requested: %s", mRequestDirtyRegions ? "true" : "false"); |
| 147 | } |
| 148 | |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 149 | void GlobalContext::initialize() { |
John Reck | 0d1f634 | 2014-03-28 20:30:27 -0700 | [diff] [blame] | 150 | if (hasContext()) return; |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 151 | |
| 152 | mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY); |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 153 | LOG_ALWAYS_FATAL_IF(mEglDisplay == EGL_NO_DISPLAY, |
| 154 | "Failed to get EGL_DEFAULT_DISPLAY! err=%s", egl_error_str()); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 155 | |
| 156 | EGLint major, minor; |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 157 | LOG_ALWAYS_FATAL_IF(eglInitialize(mEglDisplay, &major, &minor) == EGL_FALSE, |
| 158 | "Failed to initialize display %p! err=%s", mEglDisplay, egl_error_str()); |
| 159 | |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 160 | ALOGI("Initialized EGL, version %d.%d", (int)major, (int)minor); |
| 161 | |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 162 | loadConfig(); |
| 163 | createContext(); |
| 164 | usePBufferSurface(); |
| 165 | Caches::getInstance().init(); |
| 166 | initAtlas(); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 167 | } |
| 168 | |
John Reck | 0d1f634 | 2014-03-28 20:30:27 -0700 | [diff] [blame] | 169 | bool GlobalContext::hasContext() { |
| 170 | return mEglDisplay != EGL_NO_DISPLAY; |
| 171 | } |
| 172 | |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 173 | void GlobalContext::loadConfig() { |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 174 | EGLint swapBehavior = mCanSetDirtyRegions ? EGL_SWAP_BEHAVIOR_PRESERVED_BIT : 0; |
| 175 | EGLint attribs[] = { |
| 176 | EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, |
| 177 | EGL_RED_SIZE, 8, |
| 178 | EGL_GREEN_SIZE, 8, |
| 179 | EGL_BLUE_SIZE, 8, |
| 180 | EGL_ALPHA_SIZE, 8, |
| 181 | EGL_DEPTH_SIZE, 0, |
| 182 | EGL_CONFIG_CAVEAT, EGL_NONE, |
| 183 | EGL_STENCIL_SIZE, Stencil::getStencilSize(), |
| 184 | EGL_SURFACE_TYPE, EGL_WINDOW_BIT | swapBehavior, |
| 185 | EGL_NONE |
| 186 | }; |
| 187 | |
| 188 | EGLint num_configs = 1; |
| 189 | if (!eglChooseConfig(mEglDisplay, attribs, &mEglConfig, num_configs, &num_configs) |
| 190 | || num_configs != 1) { |
| 191 | // Failed to get a valid config |
| 192 | if (mCanSetDirtyRegions) { |
| 193 | ALOGW("Failed to choose config with EGL_SWAP_BEHAVIOR_PRESERVED, retrying without..."); |
| 194 | // Try again without dirty regions enabled |
| 195 | mCanSetDirtyRegions = false; |
| 196 | loadConfig(); |
| 197 | } else { |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 198 | LOG_ALWAYS_FATAL("Failed to choose config, error = %s", egl_error_str()); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 199 | } |
| 200 | } |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 201 | } |
| 202 | |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 203 | void GlobalContext::createContext() { |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 204 | EGLint attribs[] = { EGL_CONTEXT_CLIENT_VERSION, GLES_VERSION, EGL_NONE }; |
| 205 | mEglContext = eglCreateContext(mEglDisplay, mEglConfig, EGL_NO_CONTEXT, attribs); |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 206 | LOG_ALWAYS_FATAL_IF(mEglContext == EGL_NO_CONTEXT, |
| 207 | "Failed to create context, error = %s", egl_error_str()); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 208 | } |
| 209 | |
John Reck | 66f0be6 | 2014-05-13 13:39:31 -0700 | [diff] [blame] | 210 | void GlobalContext::setTextureAtlas(const sp<GraphicBuffer>& buffer, |
| 211 | int64_t* map, size_t mapSize) { |
| 212 | |
| 213 | // Already initialized |
| 214 | if (mAtlasBuffer.get()) { |
| 215 | ALOGW("Multiple calls to setTextureAtlas!"); |
| 216 | delete map; |
| 217 | return; |
| 218 | } |
| 219 | |
| 220 | mAtlasBuffer = buffer; |
| 221 | mAtlasMap = map; |
| 222 | mAtlasMapSize = mapSize; |
| 223 | |
| 224 | if (hasContext()) { |
| 225 | usePBufferSurface(); |
| 226 | initAtlas(); |
| 227 | } |
| 228 | } |
| 229 | |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 230 | void GlobalContext::initAtlas() { |
John Reck | c8affe0 | 2014-05-29 14:50:37 -0700 | [diff] [blame] | 231 | if (mAtlasBuffer.get()) { |
John Reck | cdfeef6 | 2014-05-14 16:35:46 -0700 | [diff] [blame] | 232 | Caches::getInstance().assetAtlas.init(mAtlasBuffer, mAtlasMap, mAtlasMapSize); |
| 233 | } |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 234 | } |
| 235 | |
| 236 | void GlobalContext::usePBufferSurface() { |
| 237 | LOG_ALWAYS_FATAL_IF(mEglDisplay == EGL_NO_DISPLAY, |
| 238 | "usePBufferSurface() called on uninitialized GlobalContext!"); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 239 | |
| 240 | if (mPBufferSurface == EGL_NO_SURFACE) { |
| 241 | EGLint attribs[] = { EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE }; |
| 242 | mPBufferSurface = eglCreatePbufferSurface(mEglDisplay, mEglConfig, attribs); |
| 243 | } |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 244 | makeCurrent(mPBufferSurface); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 245 | } |
| 246 | |
| 247 | EGLSurface GlobalContext::createSurface(EGLNativeWindowType window) { |
| 248 | initialize(); |
| 249 | return eglCreateWindowSurface(mEglDisplay, mEglConfig, window, NULL); |
| 250 | } |
| 251 | |
| 252 | void GlobalContext::destroySurface(EGLSurface surface) { |
| 253 | if (isCurrent(surface)) { |
| 254 | makeCurrent(EGL_NO_SURFACE); |
| 255 | } |
| 256 | if (!eglDestroySurface(mEglDisplay, surface)) { |
| 257 | ALOGW("Failed to destroy surface %p, error=%s", (void*)surface, egl_error_str()); |
| 258 | } |
| 259 | } |
| 260 | |
| 261 | void GlobalContext::destroy() { |
| 262 | if (mEglDisplay == EGL_NO_DISPLAY) return; |
| 263 | |
| 264 | usePBufferSurface(); |
| 265 | if (Caches::hasInstance()) { |
| 266 | Caches::getInstance().terminate(); |
| 267 | } |
| 268 | |
| 269 | eglDestroyContext(mEglDisplay, mEglContext); |
| 270 | eglDestroySurface(mEglDisplay, mPBufferSurface); |
| 271 | eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); |
| 272 | eglTerminate(mEglDisplay); |
| 273 | eglReleaseThread(); |
| 274 | |
| 275 | mEglDisplay = EGL_NO_DISPLAY; |
| 276 | mEglContext = EGL_NO_CONTEXT; |
| 277 | mPBufferSurface = EGL_NO_SURFACE; |
| 278 | mCurrentSurface = EGL_NO_SURFACE; |
| 279 | } |
| 280 | |
John Reck | dbc9a86 | 2014-04-17 20:25:13 -0700 | [diff] [blame] | 281 | bool GlobalContext::makeCurrent(EGLSurface surface) { |
| 282 | if (isCurrent(surface)) return false; |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 283 | |
| 284 | if (surface == EGL_NO_SURFACE) { |
| 285 | // If we are setting EGL_NO_SURFACE we don't care about any of the potential |
| 286 | // return errors, which would only happen if mEglDisplay had already been |
| 287 | // destroyed in which case the current context is already NO_CONTEXT |
| 288 | eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); |
| 289 | } else if (!eglMakeCurrent(mEglDisplay, surface, surface, mEglContext)) { |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 290 | LOG_ALWAYS_FATAL("Failed to make current on surface %p, error=%s", |
| 291 | (void*)surface, egl_error_str()); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 292 | } |
| 293 | mCurrentSurface = surface; |
John Reck | dbc9a86 | 2014-04-17 20:25:13 -0700 | [diff] [blame] | 294 | return true; |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 295 | } |
| 296 | |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 297 | void GlobalContext::beginFrame(EGLSurface surface, EGLint* width, EGLint* height) { |
| 298 | LOG_ALWAYS_FATAL_IF(surface == EGL_NO_SURFACE, |
| 299 | "Tried to beginFrame on EGL_NO_SURFACE!"); |
| 300 | makeCurrent(surface); |
| 301 | if (width) { |
| 302 | eglQuerySurface(mEglDisplay, surface, EGL_WIDTH, width); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 303 | } |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 304 | if (height) { |
| 305 | eglQuerySurface(mEglDisplay, surface, EGL_HEIGHT, height); |
| 306 | } |
| 307 | eglBeginFrame(mEglDisplay, surface); |
| 308 | } |
| 309 | |
| 310 | void GlobalContext::swapBuffers(EGLSurface surface) { |
| 311 | eglSwapBuffers(mEglDisplay, surface); |
| 312 | EGLint err = eglGetError(); |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 313 | LOG_ALWAYS_FATAL_IF(err != EGL_SUCCESS, |
| 314 | "Encountered EGL error %d %s during rendering", err, egl_error_str(err)); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 315 | } |
| 316 | |
| 317 | bool GlobalContext::enableDirtyRegions(EGLSurface surface) { |
| 318 | if (!mRequestDirtyRegions) return false; |
| 319 | |
| 320 | if (mCanSetDirtyRegions) { |
| 321 | if (!eglSurfaceAttrib(mEglDisplay, surface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED)) { |
| 322 | ALOGW("Failed to set EGL_SWAP_BEHAVIOR on surface %p, error=%s", |
| 323 | (void*) surface, egl_error_str()); |
| 324 | return false; |
| 325 | } |
| 326 | return true; |
| 327 | } |
| 328 | // Perhaps it is already enabled? |
| 329 | EGLint value; |
| 330 | if (!eglQuerySurface(mEglDisplay, surface, EGL_SWAP_BEHAVIOR, &value)) { |
| 331 | ALOGW("Failed to query EGL_SWAP_BEHAVIOR on surface %p, error=%p", |
| 332 | (void*) surface, egl_error_str()); |
| 333 | return false; |
| 334 | } |
| 335 | return value == EGL_BUFFER_PRESERVED; |
| 336 | } |
| 337 | |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 338 | CanvasContext::CanvasContext(bool translucent, RenderNode* rootRenderNode) |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 339 | : mRenderThread(RenderThread::getInstance()) |
| 340 | , mEglSurface(EGL_NO_SURFACE) |
| 341 | , mDirtyRegionsEnabled(false) |
| 342 | , mOpaque(!translucent) |
| 343 | , mCanvas(0) |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 344 | , mHaveNewSurface(false) |
| 345 | , mRootRenderNode(rootRenderNode) { |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 346 | mGlobalContext = GlobalContext::get(); |
| 347 | } |
| 348 | |
| 349 | CanvasContext::~CanvasContext() { |
John Reck | fae904d | 2014-04-14 11:01:57 -0700 | [diff] [blame] | 350 | destroyCanvasAndSurface(); |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 351 | mRenderThread.removeFrameCallback(this); |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 352 | } |
| 353 | |
John Reck | fae904d | 2014-04-14 11:01:57 -0700 | [diff] [blame] | 354 | void CanvasContext::destroyCanvasAndSurface() { |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 355 | if (mCanvas) { |
| 356 | delete mCanvas; |
| 357 | mCanvas = 0; |
| 358 | } |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 359 | setSurface(NULL); |
| 360 | } |
| 361 | |
John Reck | a5dda64 | 2014-05-22 15:43:54 -0700 | [diff] [blame] | 362 | void CanvasContext::setSurface(ANativeWindow* window) { |
| 363 | mNativeWindow = window; |
| 364 | |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 365 | if (mEglSurface != EGL_NO_SURFACE) { |
| 366 | mGlobalContext->destroySurface(mEglSurface); |
| 367 | mEglSurface = EGL_NO_SURFACE; |
| 368 | } |
| 369 | |
| 370 | if (window) { |
| 371 | mEglSurface = mGlobalContext->createSurface(window); |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 372 | LOG_ALWAYS_FATAL_IF(mEglSurface == EGL_NO_SURFACE, |
| 373 | "Failed to create EGLSurface for window %p, eglErr = %s", |
| 374 | (void*) window, egl_error_str()); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 375 | } |
| 376 | |
| 377 | if (mEglSurface != EGL_NO_SURFACE) { |
| 378 | mDirtyRegionsEnabled = mGlobalContext->enableDirtyRegions(mEglSurface); |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 379 | mHaveNewSurface = true; |
John Reck | dbc9a86 | 2014-04-17 20:25:13 -0700 | [diff] [blame] | 380 | makeCurrent(); |
John Reck | 368cdd8 | 2014-05-07 13:11:00 -0700 | [diff] [blame] | 381 | } else { |
| 382 | mRenderThread.removeFrameCallback(this); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 383 | } |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 384 | } |
| 385 | |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 386 | void CanvasContext::swapBuffers() { |
| 387 | mGlobalContext->swapBuffers(mEglSurface); |
| 388 | mHaveNewSurface = false; |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 389 | } |
| 390 | |
John Reck | f7d9c1d | 2014-04-09 10:01:03 -0700 | [diff] [blame] | 391 | void CanvasContext::requireSurface() { |
| 392 | LOG_ALWAYS_FATAL_IF(mEglSurface == EGL_NO_SURFACE, |
| 393 | "requireSurface() called but no surface set!"); |
John Reck | dbc9a86 | 2014-04-17 20:25:13 -0700 | [diff] [blame] | 394 | makeCurrent(); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 395 | } |
| 396 | |
John Reck | a5dda64 | 2014-05-22 15:43:54 -0700 | [diff] [blame] | 397 | bool CanvasContext::initialize(ANativeWindow* window) { |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 398 | if (mCanvas) return false; |
| 399 | setSurface(window); |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 400 | mCanvas = new OpenGLRenderer(); |
| 401 | mCanvas->initProperties(); |
| 402 | return true; |
| 403 | } |
| 404 | |
John Reck | a5dda64 | 2014-05-22 15:43:54 -0700 | [diff] [blame] | 405 | void CanvasContext::updateSurface(ANativeWindow* window) { |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 406 | setSurface(window); |
John Reck | f7d9c1d | 2014-04-09 10:01:03 -0700 | [diff] [blame] | 407 | } |
| 408 | |
John Reck | a5dda64 | 2014-05-22 15:43:54 -0700 | [diff] [blame] | 409 | void CanvasContext::pauseSurface(ANativeWindow* window) { |
John Reck | f7d9c1d | 2014-04-09 10:01:03 -0700 | [diff] [blame] | 410 | // TODO: For now we just need a fence, in the future suspend any animations |
| 411 | // and such to prevent from trying to render into this surface |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 412 | } |
| 413 | |
Chris Craik | 797b95b | 2014-05-20 18:10:25 -0700 | [diff] [blame] | 414 | void CanvasContext::setup(int width, int height, const Vector3& lightCenter, float lightRadius) { |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 415 | if (!mCanvas) return; |
| 416 | mCanvas->setViewport(width, height); |
Chris Craik | 797b95b | 2014-05-20 18:10:25 -0700 | [diff] [blame] | 417 | mCanvas->initializeLight(lightCenter, lightRadius); |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 418 | } |
| 419 | |
John Reck | 63a0667 | 2014-05-07 13:45:54 -0700 | [diff] [blame] | 420 | void CanvasContext::setOpaque(bool opaque) { |
| 421 | mOpaque = opaque; |
| 422 | } |
| 423 | |
John Reck | 860d155 | 2014-04-11 19:15:05 -0700 | [diff] [blame] | 424 | void CanvasContext::makeCurrent() { |
John Reck | dbc9a86 | 2014-04-17 20:25:13 -0700 | [diff] [blame] | 425 | // TODO: Figure out why this workaround is needed, see b/13913604 |
| 426 | // In the meantime this matches the behavior of GLRenderer, so it is not a regression |
| 427 | mHaveNewSurface |= mGlobalContext->makeCurrent(mEglSurface); |
John Reck | 860d155 | 2014-04-11 19:15:05 -0700 | [diff] [blame] | 428 | } |
| 429 | |
John Reck | d72e0a3 | 2014-05-29 18:56:11 -0700 | [diff] [blame] | 430 | void CanvasContext::processLayerUpdate(DeferredLayerUpdater* layerUpdater, TreeInfo& info) { |
| 431 | bool success = layerUpdater->apply(info); |
| 432 | LOG_ALWAYS_FATAL_IF(!success, "Failed to update layer!"); |
| 433 | if (layerUpdater->backingLayer()->deferredUpdateScheduled) { |
| 434 | mCanvas->pushLayerUpdate(layerUpdater->backingLayer()); |
John Reck | 19b6bcf | 2014-02-14 20:03:38 -0800 | [diff] [blame] | 435 | } |
| 436 | } |
| 437 | |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 438 | void CanvasContext::prepareTree(TreeInfo& info) { |
John Reck | f9be779 | 2014-05-02 18:21:16 -0700 | [diff] [blame] | 439 | mRenderThread.removeFrameCallback(this); |
John Reck | 18f16e6 | 2014-05-02 16:46:41 -0700 | [diff] [blame] | 440 | |
John Reck | f9be779 | 2014-05-02 18:21:16 -0700 | [diff] [blame] | 441 | info.frameTimeMs = mRenderThread.timeLord().frameTimeMs(); |
John Reck | e4267ea | 2014-06-03 15:53:15 -0700 | [diff] [blame] | 442 | info.damageAccumulator = &mDamageAccumulator; |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame^] | 443 | info.renderer = mCanvas; |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 444 | mRootRenderNode->prepareTree(info); |
| 445 | |
John Reck | a5dda64 | 2014-05-22 15:43:54 -0700 | [diff] [blame] | 446 | int runningBehind = 0; |
| 447 | // TODO: This query is moderately expensive, investigate adding some sort |
| 448 | // of fast-path based off when we last called eglSwapBuffers() as well as |
| 449 | // last vsync time. Or something. |
| 450 | mNativeWindow->query(mNativeWindow.get(), |
| 451 | NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND, &runningBehind); |
| 452 | info.out.canDrawThisFrame = !runningBehind; |
| 453 | |
| 454 | if (info.out.hasAnimations || !info.out.canDrawThisFrame) { |
John Reck | f9be779 | 2014-05-02 18:21:16 -0700 | [diff] [blame] | 455 | if (info.out.hasFunctors) { |
| 456 | info.out.requiresUiRedraw = true; |
| 457 | } else if (!info.out.requiresUiRedraw) { |
| 458 | // If animationsNeedsRedraw is set don't bother posting for an RT anim |
| 459 | // as we will just end up fighting the UI thread. |
| 460 | mRenderThread.postFrameCallback(this); |
| 461 | } |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 462 | } |
| 463 | } |
| 464 | |
John Reck | a5dda64 | 2014-05-22 15:43:54 -0700 | [diff] [blame] | 465 | void CanvasContext::notifyFramePending() { |
| 466 | ATRACE_CALL(); |
| 467 | mRenderThread.pushBackFrameCallback(this); |
| 468 | } |
| 469 | |
John Reck | e4267ea | 2014-06-03 15:53:15 -0700 | [diff] [blame] | 470 | void CanvasContext::draw() { |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 471 | LOG_ALWAYS_FATAL_IF(!mCanvas || mEglSurface == EGL_NO_SURFACE, |
| 472 | "drawDisplayList called on a context with no canvas or surface!"); |
| 473 | |
John Reck | fe5e7b7 | 2014-05-23 17:42:28 -0700 | [diff] [blame] | 474 | profiler().markPlaybackStart(); |
| 475 | |
John Reck | e4267ea | 2014-06-03 15:53:15 -0700 | [diff] [blame] | 476 | SkRect dirty; |
| 477 | mDamageAccumulator.finish(&dirty); |
| 478 | |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 479 | EGLint width, height; |
| 480 | mGlobalContext->beginFrame(mEglSurface, &width, &height); |
| 481 | if (width != mCanvas->getViewportWidth() || height != mCanvas->getViewportHeight()) { |
| 482 | mCanvas->setViewport(width, height); |
John Reck | e4267ea | 2014-06-03 15:53:15 -0700 | [diff] [blame] | 483 | dirty.setEmpty(); |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 484 | } else if (!mDirtyRegionsEnabled || mHaveNewSurface) { |
John Reck | e4267ea | 2014-06-03 15:53:15 -0700 | [diff] [blame] | 485 | dirty.setEmpty(); |
John Reck | fe5e7b7 | 2014-05-23 17:42:28 -0700 | [diff] [blame] | 486 | } else { |
John Reck | e4267ea | 2014-06-03 15:53:15 -0700 | [diff] [blame] | 487 | profiler().unionDirty(&dirty); |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 488 | } |
| 489 | |
| 490 | status_t status; |
John Reck | e4267ea | 2014-06-03 15:53:15 -0700 | [diff] [blame] | 491 | if (!dirty.isEmpty()) { |
| 492 | status = mCanvas->prepareDirty(dirty.fLeft, dirty.fTop, |
| 493 | dirty.fRight, dirty.fBottom, mOpaque); |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 494 | } else { |
| 495 | status = mCanvas->prepare(mOpaque); |
| 496 | } |
| 497 | |
| 498 | Rect outBounds; |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 499 | status |= mCanvas->drawDisplayList(mRootRenderNode.get(), outBounds); |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 500 | |
John Reck | fe5e7b7 | 2014-05-23 17:42:28 -0700 | [diff] [blame] | 501 | profiler().draw(mCanvas); |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 502 | |
| 503 | mCanvas->finish(); |
| 504 | |
John Reck | fe5e7b7 | 2014-05-23 17:42:28 -0700 | [diff] [blame] | 505 | profiler().markPlaybackEnd(); |
| 506 | |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 507 | if (status & DrawGlInfo::kStatusDrew) { |
| 508 | swapBuffers(); |
| 509 | } |
John Reck | fe5e7b7 | 2014-05-23 17:42:28 -0700 | [diff] [blame] | 510 | |
| 511 | profiler().finishFrame(); |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 512 | } |
| 513 | |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 514 | // Called by choreographer to do an RT-driven animation |
John Reck | 18f16e6 | 2014-05-02 16:46:41 -0700 | [diff] [blame] | 515 | void CanvasContext::doFrame() { |
John Reck | 368cdd8 | 2014-05-07 13:11:00 -0700 | [diff] [blame] | 516 | if (CC_UNLIKELY(!mCanvas || mEglSurface == EGL_NO_SURFACE)) { |
| 517 | return; |
| 518 | } |
| 519 | |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 520 | ATRACE_CALL(); |
| 521 | |
John Reck | fe5e7b7 | 2014-05-23 17:42:28 -0700 | [diff] [blame] | 522 | profiler().startFrame(); |
| 523 | |
John Reck | e4267ea | 2014-06-03 15:53:15 -0700 | [diff] [blame] | 524 | TreeInfo info(TreeInfo::MODE_RT_ONLY); |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 525 | info.prepareTextures = false; |
| 526 | |
| 527 | prepareTree(info); |
John Reck | a5dda64 | 2014-05-22 15:43:54 -0700 | [diff] [blame] | 528 | if (info.out.canDrawThisFrame) { |
John Reck | e4267ea | 2014-06-03 15:53:15 -0700 | [diff] [blame] | 529 | draw(); |
John Reck | a5dda64 | 2014-05-22 15:43:54 -0700 | [diff] [blame] | 530 | } |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 531 | } |
| 532 | |
John Reck | 0d1f634 | 2014-03-28 20:30:27 -0700 | [diff] [blame] | 533 | void CanvasContext::invokeFunctor(Functor* functor) { |
John Reck | d3d8daf | 2014-04-10 15:00:13 -0700 | [diff] [blame] | 534 | ATRACE_CALL(); |
John Reck | 0d1f634 | 2014-03-28 20:30:27 -0700 | [diff] [blame] | 535 | DrawGlInfo::Mode mode = DrawGlInfo::kModeProcessNoContext; |
| 536 | if (mGlobalContext->hasContext()) { |
| 537 | requireGlContext(); |
| 538 | mode = DrawGlInfo::kModeProcess; |
| 539 | } |
John Reck | 832b1514 | 2014-05-07 14:39:44 -0700 | [diff] [blame] | 540 | (*functor)(mode, NULL); |
John Reck | 6f07a0d | 2014-04-16 21:31:25 -0700 | [diff] [blame] | 541 | |
| 542 | if (mCanvas) { |
| 543 | mCanvas->resume(); |
| 544 | } |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 545 | } |
| 546 | |
John Reck | 19b6bcf | 2014-02-14 20:03:38 -0800 | [diff] [blame] | 547 | bool CanvasContext::copyLayerInto(DeferredLayerUpdater* layer, SkBitmap* bitmap) { |
| 548 | requireGlContext(); |
John Reck | e4267ea | 2014-06-03 15:53:15 -0700 | [diff] [blame] | 549 | TreeInfo info(TreeInfo::MODE_FULL); |
John Reck | 860d155 | 2014-04-11 19:15:05 -0700 | [diff] [blame] | 550 | layer->apply(info); |
John Reck | 19b6bcf | 2014-02-14 20:03:38 -0800 | [diff] [blame] | 551 | return LayerRenderer::copyLayer(layer->backingLayer(), bitmap); |
| 552 | } |
| 553 | |
John Reck | e1628b7 | 2014-05-23 15:11:19 -0700 | [diff] [blame] | 554 | void CanvasContext::flushCaches(Caches::FlushMode flushMode) { |
| 555 | if (mGlobalContext->hasContext()) { |
| 556 | requireGlContext(); |
| 557 | Caches::getInstance().flush(flushMode); |
| 558 | } |
| 559 | } |
| 560 | |
John Reck | fc53ef27 | 2014-02-11 10:40:25 -0800 | [diff] [blame] | 561 | void CanvasContext::runWithGlContext(RenderTask* task) { |
John Reck | 19b6bcf | 2014-02-14 20:03:38 -0800 | [diff] [blame] | 562 | requireGlContext(); |
| 563 | task->run(); |
| 564 | } |
| 565 | |
John Reck | 1949e79 | 2014-04-08 15:18:56 -0700 | [diff] [blame] | 566 | Layer* CanvasContext::createRenderLayer(int width, int height) { |
John Reck | f7d9c1d | 2014-04-09 10:01:03 -0700 | [diff] [blame] | 567 | requireSurface(); |
John Reck | 1949e79 | 2014-04-08 15:18:56 -0700 | [diff] [blame] | 568 | return LayerRenderer::createRenderLayer(width, height); |
| 569 | } |
| 570 | |
| 571 | Layer* CanvasContext::createTextureLayer() { |
John Reck | f7d9c1d | 2014-04-09 10:01:03 -0700 | [diff] [blame] | 572 | requireSurface(); |
John Reck | 1949e79 | 2014-04-08 15:18:56 -0700 | [diff] [blame] | 573 | return LayerRenderer::createTextureLayer(); |
| 574 | } |
| 575 | |
John Reck | 19b6bcf | 2014-02-14 20:03:38 -0800 | [diff] [blame] | 576 | void CanvasContext::requireGlContext() { |
John Reck | fc53ef27 | 2014-02-11 10:40:25 -0800 | [diff] [blame] | 577 | if (mEglSurface != EGL_NO_SURFACE) { |
John Reck | dbc9a86 | 2014-04-17 20:25:13 -0700 | [diff] [blame] | 578 | makeCurrent(); |
John Reck | fc53ef27 | 2014-02-11 10:40:25 -0800 | [diff] [blame] | 579 | } else { |
| 580 | mGlobalContext->usePBufferSurface(); |
| 581 | } |
John Reck | fc53ef27 | 2014-02-11 10:40:25 -0800 | [diff] [blame] | 582 | } |
| 583 | |
John Reck | 66f0be6 | 2014-05-13 13:39:31 -0700 | [diff] [blame] | 584 | void CanvasContext::setTextureAtlas(const sp<GraphicBuffer>& buffer, |
| 585 | int64_t* map, size_t mapSize) { |
| 586 | GlobalContext::get()->setTextureAtlas(buffer, map, mapSize); |
| 587 | } |
| 588 | |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 589 | } /* namespace renderthread */ |
| 590 | } /* namespace uirenderer */ |
| 591 | } /* namespace android */ |