blob: 5003c6aefb8b898bf731ccb9bbf15eb2e8bb2c97 [file] [log] [blame]
John Reck23b797a2014-01-03 18:08:34 -08001/*
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
John Reck38e0c322015-11-10 12:19:17 -080017#include <GpuMemoryTracker.h>
John Reck23b797a2014-01-03 18:08:34 -080018#include "CanvasContext.h"
19
John Reckd04794a2015-05-08 10:04:36 -070020#include "AnimationContext.h"
21#include "Caches.h"
22#include "DeferredLayerUpdater.h"
John Reck3b202512014-06-23 13:13:08 -070023#include "EglManager.h"
Chris Craik0b7e8242015-10-28 16:50:44 -070024#include "LayerUpdateQueue.h"
John Reckd04794a2015-05-08 10:04:36 -070025#include "LayerRenderer.h"
26#include "OpenGLRenderer.h"
27#include "Properties.h"
John Reck4f02bf42014-01-03 18:09:17 -080028#include "RenderThread.h"
sergeyvdccca442016-03-21 15:38:21 -070029#include "hwui/Canvas.h"
John Reckd04794a2015-05-08 10:04:36 -070030#include "renderstate/RenderState.h"
31#include "renderstate/Stencil.h"
John Recke248bd12015-08-05 13:53:53 -070032#include "protos/hwui.pb.h"
John Reck9372ac32016-01-19 11:46:52 -080033#include "utils/GLUtils.h"
John Recke486d932015-10-28 09:21:19 -070034#include "utils/TimeUtils.h"
John Recke248bd12015-08-05 13:53:53 -070035
36#include <cutils/properties.h>
37#include <google/protobuf/io/zero_copy_stream_impl.h>
38#include <private/hwui/DrawGlInfo.h>
39#include <strings.h>
John Reck23b797a2014-01-03 18:08:34 -080040
Chris Craik65fe5ee2015-01-26 18:06:29 -080041#include <algorithm>
John Recke248bd12015-08-05 13:53:53 -070042#include <fcntl.h>
43#include <sys/stat.h>
Chris Craik65fe5ee2015-01-26 18:06:29 -080044
Colin Cross290b23a2015-11-05 14:10:47 -080045#include <cstdlib>
46
John Reckf47a5942014-06-30 16:20:04 -070047#define TRIM_MEMORY_COMPLETE 80
48#define TRIM_MEMORY_UI_HIDDEN 20
49
John Recke248bd12015-08-05 13:53:53 -070050#define ENABLE_RENDERNODE_SERIALIZATION false
51
John Reck149173d2015-08-10 09:52:29 -070052#define LOG_FRAMETIME_MMA 0
53
54#if LOG_FRAMETIME_MMA
55static float sBenchMma = 0;
56static int sFrameCount = 0;
57static const float NANOS_PER_MILLIS_F = 1000000.0f;
58#endif
59
John Reck23b797a2014-01-03 18:08:34 -080060namespace android {
61namespace uirenderer {
62namespace renderthread {
63
John Reck119907c2014-08-14 09:02:01 -070064CanvasContext::CanvasContext(RenderThread& thread, bool translucent,
65 RenderNode* rootRenderNode, IContextFactory* contextFactory)
John Reck3b202512014-06-23 13:13:08 -070066 : mRenderThread(thread)
67 , mEglManager(thread.eglManager())
John Reck4f02bf42014-01-03 18:09:17 -080068 , mOpaque(!translucent)
Chris Craik51d6a3d2014-12-22 17:16:56 -080069 , mAnimationContext(contextFactory->createAnimationContext(mRenderThread.timeLord()))
John Reck4c9e59d2015-05-12 07:17:50 -070070 , mJankTracker(thread.timeLord().frameIntervalNanos())
Skuhneea7a7fb2015-08-28 07:10:31 -070071 , mProfiler(mFrames)
Skuhneb8160872015-09-22 09:51:39 -070072 , mContentDrawBounds(0, 0, 0, 0) {
Skuhneea7a7fb2015-08-28 07:10:31 -070073 mRenderNodes.emplace_back(rootRenderNode);
John Reck443a7142014-09-04 17:40:05 -070074 mRenderThread.renderState().registerCanvasContext(this);
John Reckb36016c2015-03-11 08:50:53 -070075 mProfiler.setDensity(mRenderThread.mainDisplayInfo().density);
John Reck23b797a2014-01-03 18:08:34 -080076}
77
78CanvasContext::~CanvasContext() {
John Reck51f2d602016-04-06 07:50:47 -070079 destroy(nullptr);
John Reck443a7142014-09-04 17:40:05 -070080 mRenderThread.renderState().unregisterCanvasContext(this);
John Reck4f02bf42014-01-03 18:09:17 -080081}
82
John Reck51f2d602016-04-06 07:50:47 -070083void CanvasContext::destroy(TreeObserver* observer) {
John Reck17035b02014-09-03 07:39:53 -070084 stopDrawing();
Chris Craikd41c4d82015-01-05 15:51:13 -080085 setSurface(nullptr);
John Reck51f2d602016-04-06 07:50:47 -070086 freePrefetchedLayers(observer);
87 destroyHardwareResources(observer);
John Recke2478d42014-09-03 16:46:05 -070088 mAnimationContext->destroy();
Chris Craik6246d2782016-03-29 15:01:41 -070089#if !HWUI_NEW_OPS
John Reck4f02bf42014-01-03 18:09:17 -080090 if (mCanvas) {
91 delete mCanvas;
Chris Craikd41c4d82015-01-05 15:51:13 -080092 mCanvas = nullptr;
John Reck4f02bf42014-01-03 18:09:17 -080093 }
Chris Craik6246d2782016-03-29 15:01:41 -070094#endif
John Reck23b797a2014-01-03 18:08:34 -080095}
96
John Reckf6481082016-02-02 15:18:23 -080097void CanvasContext::setSurface(Surface* surface) {
John Reckfbc8df02014-11-14 16:18:41 -080098 ATRACE_CALL();
99
John Reckf6481082016-02-02 15:18:23 -0800100 mNativeSurface = surface;
John Recka5dda642014-05-22 15:43:54 -0700101
John Reck23b797a2014-01-03 18:08:34 -0800102 if (mEglSurface != EGL_NO_SURFACE) {
John Reck3b202512014-06-23 13:13:08 -0700103 mEglManager.destroySurface(mEglSurface);
John Reck23b797a2014-01-03 18:08:34 -0800104 mEglSurface = EGL_NO_SURFACE;
105 }
106
John Reckf6481082016-02-02 15:18:23 -0800107 if (surface) {
108 mEglSurface = mEglManager.createSurface(surface);
John Reck23b797a2014-01-03 18:08:34 -0800109 }
110
John Reck28912a52016-04-18 14:34:18 -0700111 mFrameNumber = -1;
112
John Reck23b797a2014-01-03 18:08:34 -0800113 if (mEglSurface != EGL_NO_SURFACE) {
John Reck1125d1f2014-10-23 11:02:19 -0700114 const bool preserveBuffer = (mSwapBehavior != kSwap_discardBuffer);
115 mBufferPreserved = mEglManager.setPreserveBuffer(mEglSurface, preserveBuffer);
John Reck4f02bf42014-01-03 18:09:17 -0800116 mHaveNewSurface = true;
John Recke486d932015-10-28 09:21:19 -0700117 mSwapHistory.clear();
John Reck368cdd82014-05-07 13:11:00 -0700118 } else {
119 mRenderThread.removeFrameCallback(this);
John Reck23b797a2014-01-03 18:08:34 -0800120 }
John Reck23b797a2014-01-03 18:08:34 -0800121}
122
John Reck1125d1f2014-10-23 11:02:19 -0700123void CanvasContext::setSwapBehavior(SwapBehavior swapBehavior) {
124 mSwapBehavior = swapBehavior;
125}
126
John Reckf6481082016-02-02 15:18:23 -0800127void CanvasContext::initialize(Surface* surface) {
128 setSurface(surface);
Chris Craikb565df12015-10-05 13:00:52 -0700129#if !HWUI_NEW_OPS
Thomas Buhot0bcd0cb2015-12-04 12:18:03 +0100130 if (mCanvas) return;
John Reck3b202512014-06-23 13:13:08 -0700131 mCanvas = new OpenGLRenderer(mRenderThread.renderState());
John Reck4f02bf42014-01-03 18:09:17 -0800132 mCanvas->initProperties();
Chris Craikb565df12015-10-05 13:00:52 -0700133#endif
John Reck4f02bf42014-01-03 18:09:17 -0800134}
135
John Reckf6481082016-02-02 15:18:23 -0800136void CanvasContext::updateSurface(Surface* surface) {
137 setSurface(surface);
John Reckf7d9c1d2014-04-09 10:01:03 -0700138}
139
John Reckf6481082016-02-02 15:18:23 -0800140bool CanvasContext::pauseSurface(Surface* surface) {
John Reck01a5ea32014-12-03 13:01:07 -0800141 return mRenderThread.removeFrameCallback(this);
John Reck4f02bf42014-01-03 18:09:17 -0800142}
143
John Reck8afcc762016-04-13 10:24:06 -0700144void CanvasContext::setStopped(bool stopped) {
145 if (mStopped != stopped) {
146 mStopped = stopped;
147 if (mStopped) {
148 mRenderThread.removeFrameCallback(this);
149 if (mEglManager.isCurrent(mEglSurface)) {
150 mEglManager.makeCurrent(EGL_NO_SURFACE);
151 }
John Reck306f3312016-06-10 16:01:55 -0700152 } else if (mIsDirty && hasSurface()) {
153 mRenderThread.postFrameCallback(this);
John Reck8afcc762016-04-13 10:24:06 -0700154 }
155 }
156}
157
Chris Craik284b2432014-09-18 16:05:35 -0700158// TODO: don't pass viewport size, it's automatic via EGL
Alan Viverette50210d92015-05-14 18:05:36 -0700159void CanvasContext::setup(int width, int height, float lightRadius,
Andreas Gampe64bb4132014-11-22 00:35:09 +0000160 uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha) {
Chris Craik98787e62015-11-13 10:55:30 -0800161#if HWUI_NEW_OPS
Chris Craik6e068c012016-01-15 16:15:30 -0800162 mLightGeometry.radius = lightRadius;
Chris Craik98787e62015-11-13 10:55:30 -0800163 mLightInfo.ambientShadowAlpha = ambientShadowAlpha;
164 mLightInfo.spotShadowAlpha = spotShadowAlpha;
165#else
John Reck4f02bf42014-01-03 18:09:17 -0800166 if (!mCanvas) return;
Alan Viverette50210d92015-05-14 18:05:36 -0700167 mCanvas->initLight(lightRadius, ambientShadowAlpha, spotShadowAlpha);
Chris Craik98787e62015-11-13 10:55:30 -0800168#endif
Alan Viverette50210d92015-05-14 18:05:36 -0700169}
170
171void CanvasContext::setLightCenter(const Vector3& lightCenter) {
Chris Craik98787e62015-11-13 10:55:30 -0800172#if HWUI_NEW_OPS
Chris Craik6e068c012016-01-15 16:15:30 -0800173 mLightGeometry.center = lightCenter;
Chris Craik98787e62015-11-13 10:55:30 -0800174#else
Alan Viverette50210d92015-05-14 18:05:36 -0700175 if (!mCanvas) return;
176 mCanvas->setLightCenter(lightCenter);
Chris Craik98787e62015-11-13 10:55:30 -0800177#endif
John Reck4f02bf42014-01-03 18:09:17 -0800178}
179
John Reck63a06672014-05-07 13:45:54 -0700180void CanvasContext::setOpaque(bool opaque) {
181 mOpaque = opaque;
182}
183
John Reck8afcc762016-04-13 10:24:06 -0700184bool CanvasContext::makeCurrent() {
185 if (mStopped) return false;
186
John Reckdbc9a862014-04-17 20:25:13 -0700187 // TODO: Figure out why this workaround is needed, see b/13913604
188 // In the meantime this matches the behavior of GLRenderer, so it is not a regression
John Reckf2dcc2a2015-07-16 09:17:59 -0700189 EGLint error = 0;
190 mHaveNewSurface |= mEglManager.makeCurrent(mEglSurface, &error);
191 if (error) {
192 setSurface(nullptr);
193 }
John Reck8afcc762016-04-13 10:24:06 -0700194 return !error;
John Reck860d1552014-04-11 19:15:05 -0700195}
196
John Reckbf3c6022015-06-02 15:55:00 -0700197static bool wasSkipped(FrameInfo* info) {
Chris Craik1b54fb22015-06-02 17:40:58 -0700198 return info && ((*info)[FrameInfoIndex::Flags] & FrameInfoFlags::SkippedFrame);
John Reckbf3c6022015-06-02 15:55:00 -0700199}
200
John Reck0def73a2016-07-01 16:19:13 -0700201bool CanvasContext::isSwapChainStuffed() {
202 if (mSwapHistory.size() != mSwapHistory.capacity()) {
203 // We want at least 3 frames of history before attempting to
204 // guess if the queue is stuffed
205 return false;
206 }
207 nsecs_t frameInterval = mRenderThread.timeLord().frameIntervalNanos();
208 auto& swapA = mSwapHistory[0];
209
210 // Was there a happy queue & dequeue time? If so, don't
211 // consider it stuffed
212 if (swapA.dequeueDuration < 3_ms
213 && swapA.queueDuration < 3_ms) {
214 return false;
215 }
216
217 for (size_t i = 1; i < mSwapHistory.size(); i++) {
218 auto& swapB = mSwapHistory[i];
219
220 // If there's a frameInterval gap we effectively already dropped a frame,
221 // so consider the queue healthy.
222 if (swapA.swapCompletedTime - swapB.swapCompletedTime > frameInterval) {
223 return false;
224 }
225
226 // Was there a happy queue & dequeue time? If so, don't
227 // consider it stuffed
228 if (swapB.dequeueDuration < 3_ms
229 && swapB.queueDuration < 3_ms) {
230 return false;
231 }
232
233 swapA = swapB;
234 }
235
236 // All signs point to a stuffed swap chain
237 return true;
238}
239
Skuhneea7a7fb2015-08-28 07:10:31 -0700240void CanvasContext::prepareTree(TreeInfo& info, int64_t* uiFrameInfo,
241 int64_t syncQueued, RenderNode* target) {
John Reckf9be7792014-05-02 18:21:16 -0700242 mRenderThread.removeFrameCallback(this);
John Reck18f16e62014-05-02 16:46:41 -0700243
John Reckbf3c6022015-06-02 15:55:00 -0700244 // If the previous frame was dropped we don't need to hold onto it, so
245 // just keep using the previous frame's structure instead
246 if (!wasSkipped(mCurrentFrameInfo)) {
247 mCurrentFrameInfo = &mFrames.next();
248 }
John Reckba6adf62015-02-19 14:36:50 -0800249 mCurrentFrameInfo->importUiThreadInfo(uiFrameInfo);
John Reckbe3fba02015-07-06 13:49:58 -0700250 mCurrentFrameInfo->set(FrameInfoIndex::SyncQueued) = syncQueued;
John Reckba6adf62015-02-19 14:36:50 -0800251 mCurrentFrameInfo->markSyncStart();
252
John Recke4267ea2014-06-03 15:53:15 -0700253 info.damageAccumulator = &mDamageAccumulator;
Chris Craik0b7e8242015-10-28 16:50:44 -0700254#if HWUI_NEW_OPS
255 info.layerUpdateQueue = &mLayerUpdateQueue;
256#else
John Reck25fbb3f2014-06-12 13:46:45 -0700257 info.renderer = mCanvas;
Chris Craik0b7e8242015-10-28 16:50:44 -0700258#endif
John Reck00e79c92015-07-21 10:23:59 -0700259
John Reckec845a22014-09-05 15:23:38 -0700260 mAnimationContext->startFrame(info.mode);
Skuhneea7a7fb2015-08-28 07:10:31 -0700261 for (const sp<RenderNode>& node : mRenderNodes) {
262 // Only the primary target node will be drawn full - all other nodes would get drawn in
263 // real time mode. In case of a window, the primary node is the window content and the other
264 // node(s) are non client / filler nodes.
265 info.mode = (node.get() == target ? TreeInfo::MODE_FULL : TreeInfo::MODE_RT_ONLY);
266 node->prepareTree(info);
John Reck975591a2016-01-22 16:28:07 -0800267 GL_CHECKPOINT(MODERATE);
Skuhneea7a7fb2015-08-28 07:10:31 -0700268 }
John Reck119907c2014-08-14 09:02:01 -0700269 mAnimationContext->runRemainingAnimations(info);
John Reck975591a2016-01-22 16:28:07 -0800270 GL_CHECKPOINT(MODERATE);
John Recke45b1fd2014-04-15 09:50:16 -0700271
John Reck51f2d602016-04-06 07:50:47 -0700272 freePrefetchedLayers(info.observer);
John Reck975591a2016-01-22 16:28:07 -0800273 GL_CHECKPOINT(MODERATE);
John Reck998a6d82014-08-28 15:35:53 -0700274
John Reck306f3312016-06-10 16:01:55 -0700275 mIsDirty = true;
276
John Reckf6481082016-02-02 15:18:23 -0800277 if (CC_UNLIKELY(!mNativeSurface.get())) {
Chris Craik1b54fb22015-06-02 17:40:58 -0700278 mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
John Reckaa95a882014-11-07 11:02:07 -0800279 info.out.canDrawThisFrame = false;
280 return;
281 }
282
John Recke486d932015-10-28 09:21:19 -0700283 if (CC_LIKELY(mSwapHistory.size())) {
284 nsecs_t latestVsync = mRenderThread.timeLord().latestVsync();
John Reck0def73a2016-07-01 16:19:13 -0700285 SwapHistory& lastSwap = mSwapHistory.back();
286 int durationUs;
287 mNativeSurface->query(NATIVE_WINDOW_LAST_DEQUEUE_DURATION, &durationUs);
288 lastSwap.dequeueDuration = us2ns(durationUs);
289 mNativeSurface->query(NATIVE_WINDOW_LAST_QUEUE_DURATION, &durationUs);
290 lastSwap.queueDuration = us2ns(durationUs);
John Reck52b783f2015-11-24 11:12:55 -0800291 nsecs_t vsyncDelta = std::abs(lastSwap.vsyncTime - latestVsync);
John Recke486d932015-10-28 09:21:19 -0700292 // The slight fudge-factor is to deal with cases where
293 // the vsync was estimated due to being slow handling the signal.
294 // See the logic in TimeLord#computeFrameTimeNanos or in
295 // Choreographer.java for details on when this happens
296 if (vsyncDelta < 2_ms) {
297 // Already drew for this vsync pulse, UI draw request missed
298 // the deadline for RT animations
299 info.out.canDrawThisFrame = false;
John Reck0def73a2016-07-01 16:19:13 -0700300 } else if (vsyncDelta >= mRenderThread.timeLord().frameIntervalNanos()) {
301 // It's been at least an entire frame interval, assume
302 // the buffer queue is fine
John Recke486d932015-10-28 09:21:19 -0700303 info.out.canDrawThisFrame = true;
304 } else {
John Reck0def73a2016-07-01 16:19:13 -0700305 info.out.canDrawThisFrame = !isSwapChainStuffed();
John Recke486d932015-10-28 09:21:19 -0700306 }
307 } else {
308 info.out.canDrawThisFrame = true;
309 }
John Recka5dda642014-05-22 15:43:54 -0700310
John Reckaef9dc82015-05-08 14:10:57 -0700311 if (!info.out.canDrawThisFrame) {
Chris Craik1b54fb22015-06-02 17:40:58 -0700312 mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
John Reckaef9dc82015-05-08 14:10:57 -0700313 }
314
John Recka5dda642014-05-22 15:43:54 -0700315 if (info.out.hasAnimations || !info.out.canDrawThisFrame) {
John Reckcd028f32014-06-24 08:44:29 -0700316 if (!info.out.requiresUiRedraw) {
John Reckf9be7792014-05-02 18:21:16 -0700317 // If animationsNeedsRedraw is set don't bother posting for an RT anim
318 // as we will just end up fighting the UI thread.
319 mRenderThread.postFrameCallback(this);
320 }
John Recke45b1fd2014-04-15 09:50:16 -0700321 }
322}
323
John Reckf47a5942014-06-30 16:20:04 -0700324void CanvasContext::stopDrawing() {
325 mRenderThread.removeFrameCallback(this);
Doris Liu718cd3e2016-05-17 16:50:31 -0700326 mAnimationContext->detachAnimators();
John Reckf47a5942014-06-30 16:20:04 -0700327}
328
John Recka5dda642014-05-22 15:43:54 -0700329void CanvasContext::notifyFramePending() {
330 ATRACE_CALL();
331 mRenderThread.pushBackFrameCallback(this);
332}
333
John Recke4267ea2014-06-03 15:53:15 -0700334void CanvasContext::draw() {
Chris Craikb565df12015-10-05 13:00:52 -0700335#if !HWUI_NEW_OPS
John Reck4f02bf42014-01-03 18:09:17 -0800336 LOG_ALWAYS_FATAL_IF(!mCanvas || mEglSurface == EGL_NO_SURFACE,
Chris Craika7090e02014-06-20 16:01:00 -0700337 "drawRenderNode called on a context with no canvas or surface!");
Chris Craikb565df12015-10-05 13:00:52 -0700338#endif
John Reck4f02bf42014-01-03 18:09:17 -0800339
John Recke4267ea2014-06-03 15:53:15 -0700340 SkRect dirty;
341 mDamageAccumulator.finish(&dirty);
342
John Reck6d4d0db2015-08-03 15:34:52 -0700343 // TODO: Re-enable after figuring out cause of b/22592975
344// if (dirty.isEmpty() && Properties::skipEmptyFrames) {
345// mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
346// return;
347// }
John Reck240ff622015-04-28 13:50:00 -0700348
John Reck240ff622015-04-28 13:50:00 -0700349 mCurrentFrameInfo->markIssueDrawCommandsStart();
350
John Reck149173d2015-08-10 09:52:29 -0700351 Frame frame = mEglManager.beginFrame(mEglSurface);
Chris Craikb565df12015-10-05 13:00:52 -0700352
John Reck77c40102015-10-26 15:49:47 -0700353 if (frame.width() != mLastFrameWidth || frame.height() != mLastFrameHeight) {
Chris Craik64e445b2015-09-02 14:23:49 -0700354 // can't rely on prior content of window if viewport size changes
John Recke4267ea2014-06-03 15:53:15 -0700355 dirty.setEmpty();
John Reck77c40102015-10-26 15:49:47 -0700356 mLastFrameWidth = frame.width();
357 mLastFrameHeight = frame.height();
John Reck149173d2015-08-10 09:52:29 -0700358 } else if (mHaveNewSurface || frame.bufferAge() == 0) {
359 // New surface needs a full draw
John Recke4267ea2014-06-03 15:53:15 -0700360 dirty.setEmpty();
John Reckfe5e7b72014-05-23 17:42:28 -0700361 } else {
John Reck149173d2015-08-10 09:52:29 -0700362 if (!dirty.isEmpty() && !dirty.intersect(0, 0, frame.width(), frame.height())) {
John Reck0a973302014-07-16 13:29:45 -0700363 ALOGW("Dirty " RECT_STRING " doesn't intersect with 0 0 %d %d ?",
John Reck149173d2015-08-10 09:52:29 -0700364 SK_RECT_ARGS(dirty), frame.width(), frame.height());
John Reck0a973302014-07-16 13:29:45 -0700365 dirty.setEmpty();
366 }
John Recke4267ea2014-06-03 15:53:15 -0700367 profiler().unionDirty(&dirty);
John Reck4f02bf42014-01-03 18:09:17 -0800368 }
369
John Reck149173d2015-08-10 09:52:29 -0700370 if (dirty.isEmpty()) {
371 dirty.set(0, 0, frame.width(), frame.height());
Season Li13d1b4a2015-07-29 17:16:19 -0700372 }
373
John Reck149173d2015-08-10 09:52:29 -0700374 // At this point dirty is the area of the screen to update. However,
375 // the area of the frame we need to repaint is potentially different, so
376 // stash the screen area for later
377 SkRect screenDirty(dirty);
378
379 // If the buffer age is 0 we do a full-screen repaint (handled above)
380 // If the buffer age is 1 the buffer contents are the same as they were
381 // last frame so there's nothing to union() against
382 // Therefore we only care about the > 1 case.
383 if (frame.bufferAge() > 1) {
John Recke486d932015-10-28 09:21:19 -0700384 if (frame.bufferAge() > (int) mSwapHistory.size()) {
John Reck149173d2015-08-10 09:52:29 -0700385 // We don't have enough history to handle this old of a buffer
386 // Just do a full-draw
387 dirty.set(0, 0, frame.width(), frame.height());
388 } else {
389 // At this point we haven't yet added the latest frame
390 // to the damage history (happens below)
391 // So we need to damage
John Recke486d932015-10-28 09:21:19 -0700392 for (int i = mSwapHistory.size() - 1;
393 i > ((int) mSwapHistory.size()) - frame.bufferAge(); i--) {
394 dirty.join(mSwapHistory[i].damage);
John Reck149173d2015-08-10 09:52:29 -0700395 }
396 }
John Reck4f02bf42014-01-03 18:09:17 -0800397 }
398
John Reck149173d2015-08-10 09:52:29 -0700399 mEglManager.damageFrame(frame, dirty);
Chris Craikddf22152015-10-14 17:42:47 -0700400
401#if HWUI_NEW_OPS
Chris Craik3a5811b2016-03-22 15:03:08 -0700402 auto& caches = Caches::getInstance();
Chris Craik9cd1bbe2016-04-14 16:08:25 -0700403 FrameBuilder frameBuilder(dirty, frame.width(), frame.height(), mLightGeometry, caches);
404
405 frameBuilder.deferLayers(mLayerUpdateQueue);
Chris Craik0b7e8242015-10-28 16:50:44 -0700406 mLayerUpdateQueue.clear();
Chris Craik9cd1bbe2016-04-14 16:08:25 -0700407
408 frameBuilder.deferRenderNodeScene(mRenderNodes, mContentDrawBounds);
409
Chris Craik1dfa0702016-03-04 15:59:24 -0800410 BakedOpRenderer renderer(caches, mRenderThread.renderState(),
Chris Craik98787e62015-11-13 10:55:30 -0800411 mOpaque, mLightInfo);
Chris Craikf158b492016-01-12 14:45:08 -0800412 frameBuilder.replayBakedOps<BakedOpDispatcher>(renderer);
Chris Craik1dfa0702016-03-04 15:59:24 -0800413 profiler().draw(&renderer);
Chris Craik5854b342015-10-26 15:49:56 -0700414 bool drew = renderer.didDraw();
Chris Craikddf22152015-10-14 17:42:47 -0700415
Chris Craik1dfa0702016-03-04 15:59:24 -0800416 // post frame cleanup
417 caches.clearGarbage();
418 caches.pathCache.trim();
419 caches.tessellationCache.trim();
420
421#if DEBUG_MEMORY_USAGE
422 mCaches.dumpMemoryUsage();
423#else
424 if (CC_UNLIKELY(Properties::debugLevel & kDebugMemory)) {
425 caches.dumpMemoryUsage();
426 }
427#endif
428
Chris Craikddf22152015-10-14 17:42:47 -0700429#else
Chris Craik64e445b2015-09-02 14:23:49 -0700430 mCanvas->prepareDirty(frame.width(), frame.height(),
431 dirty.fLeft, dirty.fTop, dirty.fRight, dirty.fBottom, mOpaque);
John Reck149173d2015-08-10 09:52:29 -0700432
John Reck4f02bf42014-01-03 18:09:17 -0800433 Rect outBounds;
Robert Carrb6c26242015-10-22 12:03:28 -0700434 // It there are multiple render nodes, they are laid out as follows:
435 // #0 - backdrop (content + caption)
Skuhneb8160872015-09-22 09:51:39 -0700436 // #1 - content (positioned at (0,0) and clipped to - its bounds mContentDrawBounds)
Robert Carrb6c26242015-10-22 12:03:28 -0700437 // #2 - additional overlay nodes
Skuhneea7a7fb2015-08-28 07:10:31 -0700438 // Usually the backdrop cannot be seen since it will be entirely covered by the content. While
439 // resizing however it might become partially visible. The following render loop will crop the
Robert Carrb6c26242015-10-22 12:03:28 -0700440 // backdrop against the content and draw the remaining part of it. It will then draw the content
441 // cropped to the backdrop (since that indicates a shrinking of the window).
442 //
443 // Additional nodes will be drawn on top with no particular clipping semantics.
444
Skuhneea7a7fb2015-08-28 07:10:31 -0700445 // The bounds of the backdrop against which the content should be clipped.
Skuhneb8160872015-09-22 09:51:39 -0700446 Rect backdropBounds = mContentDrawBounds;
447 // Usually the contents bounds should be mContentDrawBounds - however - we will
448 // move it towards the fixed edge to give it a more stable appearance (for the moment).
449 Rect contentBounds;
Skuhneea7a7fb2015-08-28 07:10:31 -0700450 // If there is no content bounds we ignore the layering as stated above and start with 2.
Robert Carrb6c26242015-10-22 12:03:28 -0700451 int layer = (mContentDrawBounds.isEmpty() || mRenderNodes.size() == 1) ? 2 : 0;
Skuhneea7a7fb2015-08-28 07:10:31 -0700452 // Draw all render nodes. Note that
453 for (const sp<RenderNode>& node : mRenderNodes) {
454 if (layer == 0) { // Backdrop.
Skuhneb8160872015-09-22 09:51:39 -0700455 // Draw the backdrop clipped to the inverse content bounds, but assume that the content
456 // was moved to the upper left corner.
Skuhneea7a7fb2015-08-28 07:10:31 -0700457 const RenderProperties& properties = node->properties();
458 Rect targetBounds(properties.getLeft(), properties.getTop(),
459 properties.getRight(), properties.getBottom());
Skuhneb8160872015-09-22 09:51:39 -0700460 // Move the content bounds towards the fixed corner of the backdrop.
461 const int x = targetBounds.left;
462 const int y = targetBounds.top;
463 contentBounds.set(x, y, x + mContentDrawBounds.getWidth(),
464 y + mContentDrawBounds.getHeight());
Skuhneea7a7fb2015-08-28 07:10:31 -0700465 // Remember the intersection of the target bounds and the intersection bounds against
466 // which we have to crop the content.
Skuhneb8160872015-09-22 09:51:39 -0700467 backdropBounds.set(x, y, x + backdropBounds.getWidth(), y + backdropBounds.getHeight());
Chris Craikac02eb92015-10-05 12:23:46 -0700468 backdropBounds.doIntersect(targetBounds);
Skuhneea7a7fb2015-08-28 07:10:31 -0700469 // Check if we have to draw something on the left side ...
Skuhneb8160872015-09-22 09:51:39 -0700470 if (targetBounds.left < contentBounds.left) {
Florin Malitaeecff562015-12-21 10:43:01 -0500471 mCanvas->save(SaveFlags::Clip);
Skuhneea7a7fb2015-08-28 07:10:31 -0700472 if (mCanvas->clipRect(targetBounds.left, targetBounds.top,
Skuhneb8160872015-09-22 09:51:39 -0700473 contentBounds.left, targetBounds.bottom,
Skuhneea7a7fb2015-08-28 07:10:31 -0700474 SkRegion::kIntersect_Op)) {
475 mCanvas->drawRenderNode(node.get(), outBounds);
476 }
477 // Reduce the target area by the area we have just painted.
Skuhneb8160872015-09-22 09:51:39 -0700478 targetBounds.left = std::min(contentBounds.left, targetBounds.right);
Skuhneea7a7fb2015-08-28 07:10:31 -0700479 mCanvas->restore();
480 }
481 // ... or on the right side ...
Skuhneb8160872015-09-22 09:51:39 -0700482 if (targetBounds.right > contentBounds.right &&
Skuhneea7a7fb2015-08-28 07:10:31 -0700483 !targetBounds.isEmpty()) {
Florin Malitaeecff562015-12-21 10:43:01 -0500484 mCanvas->save(SaveFlags::Clip);
Skuhneb8160872015-09-22 09:51:39 -0700485 if (mCanvas->clipRect(contentBounds.right, targetBounds.top,
Skuhneea7a7fb2015-08-28 07:10:31 -0700486 targetBounds.right, targetBounds.bottom,
487 SkRegion::kIntersect_Op)) {
488 mCanvas->drawRenderNode(node.get(), outBounds);
489 }
490 // Reduce the target area by the area we have just painted.
Skuhneb8160872015-09-22 09:51:39 -0700491 targetBounds.right = std::max(targetBounds.left, contentBounds.right);
Skuhneea7a7fb2015-08-28 07:10:31 -0700492 mCanvas->restore();
493 }
494 // ... or at the top ...
Skuhneb8160872015-09-22 09:51:39 -0700495 if (targetBounds.top < contentBounds.top &&
Skuhneea7a7fb2015-08-28 07:10:31 -0700496 !targetBounds.isEmpty()) {
Florin Malitaeecff562015-12-21 10:43:01 -0500497 mCanvas->save(SaveFlags::Clip);
Skuhneea7a7fb2015-08-28 07:10:31 -0700498 if (mCanvas->clipRect(targetBounds.left, targetBounds.top, targetBounds.right,
Skuhneb8160872015-09-22 09:51:39 -0700499 contentBounds.top,
Skuhneea7a7fb2015-08-28 07:10:31 -0700500 SkRegion::kIntersect_Op)) {
501 mCanvas->drawRenderNode(node.get(), outBounds);
502 }
503 // Reduce the target area by the area we have just painted.
Skuhneb8160872015-09-22 09:51:39 -0700504 targetBounds.top = std::min(contentBounds.top, targetBounds.bottom);
Skuhneea7a7fb2015-08-28 07:10:31 -0700505 mCanvas->restore();
506 }
507 // ... or at the bottom.
Skuhneb8160872015-09-22 09:51:39 -0700508 if (targetBounds.bottom > contentBounds.bottom &&
Skuhneea7a7fb2015-08-28 07:10:31 -0700509 !targetBounds.isEmpty()) {
Florin Malitaeecff562015-12-21 10:43:01 -0500510 mCanvas->save(SaveFlags::Clip);
Skuhneb8160872015-09-22 09:51:39 -0700511 if (mCanvas->clipRect(targetBounds.left, contentBounds.bottom, targetBounds.right,
Skuhneea7a7fb2015-08-28 07:10:31 -0700512 targetBounds.bottom, SkRegion::kIntersect_Op)) {
513 mCanvas->drawRenderNode(node.get(), outBounds);
514 }
515 mCanvas->restore();
516 }
517 } else if (layer == 1) { // Content
518 // It gets cropped against the bounds of the backdrop to stay inside.
Florin Malitaeecff562015-12-21 10:43:01 -0500519 mCanvas->save(SaveFlags::MatrixClip);
Skuhneb8160872015-09-22 09:51:39 -0700520
521 // We shift and clip the content to match its final location in the window.
522 const float left = mContentDrawBounds.left;
523 const float top = mContentDrawBounds.top;
524 const float dx = backdropBounds.left - left;
525 const float dy = backdropBounds.top - top;
526 const float width = backdropBounds.getWidth();
527 const float height = backdropBounds.getHeight();
Robert Carrb6c26242015-10-22 12:03:28 -0700528
Skuhneb8160872015-09-22 09:51:39 -0700529 mCanvas->translate(dx, dy);
530 if (mCanvas->clipRect(left, top, left + width, top + height, SkRegion::kIntersect_Op)) {
Skuhneea7a7fb2015-08-28 07:10:31 -0700531 mCanvas->drawRenderNode(node.get(), outBounds);
532 }
533 mCanvas->restore();
534 } else { // draw the rest on top at will!
535 mCanvas->drawRenderNode(node.get(), outBounds);
536 }
537 layer++;
538 }
John Reck4f02bf42014-01-03 18:09:17 -0800539
John Reckfe5e7b72014-05-23 17:42:28 -0700540 profiler().draw(mCanvas);
John Reck4f02bf42014-01-03 18:09:17 -0800541
Tom Hudson107843d2014-09-08 11:26:26 -0400542 bool drew = mCanvas->finish();
Chris Craikddf22152015-10-14 17:42:47 -0700543#endif
John Reck9372ac32016-01-19 11:46:52 -0800544
John Reck38f6c032016-03-17 10:23:49 -0700545 waitOnFences();
546
John Reck975591a2016-01-22 16:28:07 -0800547 GL_CHECKPOINT(LOW);
John Reck9372ac32016-01-19 11:46:52 -0800548
John Reckba6adf62015-02-19 14:36:50 -0800549 // Even if we decided to cancel the frame, from the perspective of jank
550 // metrics the frame was swapped at this point
551 mCurrentFrameInfo->markSwapBuffers();
John Reck306f3312016-06-10 16:01:55 -0700552 mIsDirty = false;
John Reckba6adf62015-02-19 14:36:50 -0800553
John Reckc96955d2016-02-26 14:56:44 -0800554 if (drew || mEglManager.damageRequiresSwap()) {
John Reck149173d2015-08-10 09:52:29 -0700555 if (CC_UNLIKELY(!mEglManager.swapBuffers(frame, screenDirty))) {
556 setSurface(nullptr);
557 }
John Recke486d932015-10-28 09:21:19 -0700558 SwapHistory& swap = mSwapHistory.next();
559 swap.damage = screenDirty;
John Reck0def73a2016-07-01 16:19:13 -0700560 swap.swapCompletedTime = systemTime(CLOCK_MONOTONIC);
John Recke486d932015-10-28 09:21:19 -0700561 swap.vsyncTime = mRenderThread.timeLord().latestVsync();
John Reck149173d2015-08-10 09:52:29 -0700562 mHaveNewSurface = false;
John Reck28912a52016-04-18 14:34:18 -0700563 mFrameNumber = -1;
John Reck4f02bf42014-01-03 18:09:17 -0800564 }
John Reckfe5e7b72014-05-23 17:42:28 -0700565
John Reckba6adf62015-02-19 14:36:50 -0800566 // TODO: Use a fence for real completion?
567 mCurrentFrameInfo->markFrameCompleted();
John Reck149173d2015-08-10 09:52:29 -0700568
569#if LOG_FRAMETIME_MMA
570 float thisFrame = mCurrentFrameInfo->duration(
571 FrameInfoIndex::IssueDrawCommandsStart,
572 FrameInfoIndex::FrameCompleted) / NANOS_PER_MILLIS_F;
573 if (sFrameCount) {
574 sBenchMma = ((9 * sBenchMma) + thisFrame) / 10;
575 } else {
576 sBenchMma = thisFrame;
577 }
578 if (++sFrameCount == 10) {
579 sFrameCount = 1;
580 ALOGD("Average frame time: %.4f", sBenchMma);
581 }
582#endif
583
John Reckedc524c2015-03-18 15:24:33 -0700584 mJankTracker.addFrame(*mCurrentFrameInfo);
John Reckba6adf62015-02-19 14:36:50 -0800585 mRenderThread.jankTracker().addFrame(*mCurrentFrameInfo);
Andres Morales910beb82016-02-02 16:19:40 -0800586 if (CC_UNLIKELY(mFrameMetricsReporter.get() != nullptr)) {
587 mFrameMetricsReporter->reportFrameMetrics(mCurrentFrameInfo->data());
Andres Morales06f5bc72015-12-15 15:21:31 -0800588 }
John Reck38e0c322015-11-10 12:19:17 -0800589
590 GpuMemoryTracker::onFrameCompleted();
John Reck4f02bf42014-01-03 18:09:17 -0800591}
592
John Recke45b1fd2014-04-15 09:50:16 -0700593// Called by choreographer to do an RT-driven animation
John Reck18f16e62014-05-02 16:46:41 -0700594void CanvasContext::doFrame() {
Chris Craikadfeec92015-12-15 19:17:32 -0800595#if HWUI_NEW_OPS
596 if (CC_UNLIKELY(mEglSurface == EGL_NO_SURFACE)) return;
597#else
598 if (CC_UNLIKELY(!mCanvas || mEglSurface == EGL_NO_SURFACE)) return;
599#endif
Skuhneea7a7fb2015-08-28 07:10:31 -0700600 prepareAndDraw(nullptr);
601}
John Reck368cdd82014-05-07 13:11:00 -0700602
Skuhneea7a7fb2015-08-28 07:10:31 -0700603void CanvasContext::prepareAndDraw(RenderNode* node) {
John Recke45b1fd2014-04-15 09:50:16 -0700604 ATRACE_CALL();
605
Matthew Bouyack7f667e72016-01-12 12:01:48 -0800606 nsecs_t vsync = mRenderThread.timeLord().computeFrameTimeNanos();
John Reckba6adf62015-02-19 14:36:50 -0800607 int64_t frameInfo[UI_THREAD_FRAME_INFO_SIZE];
608 UiFrameInfoBuilder(frameInfo)
Chris Craik1b54fb22015-06-02 17:40:58 -0700609 .addFlag(FrameInfoFlags::RTAnimation)
Matthew Bouyack7f667e72016-01-12 12:01:48 -0800610 .setVsync(vsync, vsync);
John Reckfe5e7b72014-05-23 17:42:28 -0700611
Chris Craike2e53a72015-10-28 15:55:40 -0700612 TreeInfo info(TreeInfo::MODE_RT_ONLY, *this);
Skuhneea7a7fb2015-08-28 07:10:31 -0700613 prepareTree(info, frameInfo, systemTime(CLOCK_MONOTONIC), node);
John Recka5dda642014-05-22 15:43:54 -0700614 if (info.out.canDrawThisFrame) {
John Recke4267ea2014-06-03 15:53:15 -0700615 draw();
John Recka5dda642014-05-22 15:43:54 -0700616 }
John Recke45b1fd2014-04-15 09:50:16 -0700617}
618
John Reck3b202512014-06-23 13:13:08 -0700619void CanvasContext::invokeFunctor(RenderThread& thread, Functor* functor) {
John Reckd3d8daf2014-04-10 15:00:13 -0700620 ATRACE_CALL();
John Reck0d1f6342014-03-28 20:30:27 -0700621 DrawGlInfo::Mode mode = DrawGlInfo::kModeProcessNoContext;
John Reck3b202512014-06-23 13:13:08 -0700622 if (thread.eglManager().hasEglContext()) {
John Reck0d1f6342014-03-28 20:30:27 -0700623 mode = DrawGlInfo::kModeProcess;
624 }
John Reck6f07a0d2014-04-16 21:31:25 -0700625
Chris Craikd41c4d82015-01-05 15:51:13 -0800626 thread.renderState().invokeFunctor(functor, mode, nullptr);
John Reck23b797a2014-01-03 18:08:34 -0800627}
628
John Reck998a6d82014-08-28 15:35:53 -0700629void CanvasContext::markLayerInUse(RenderNode* node) {
John Reck51f2d602016-04-06 07:50:47 -0700630 if (mPrefetchedLayers.erase(node)) {
Chris Craikd41c4d82015-01-05 15:51:13 -0800631 node->decStrong(nullptr);
John Reck998a6d82014-08-28 15:35:53 -0700632 }
633}
634
John Reck51f2d602016-04-06 07:50:47 -0700635void CanvasContext::freePrefetchedLayers(TreeObserver* observer) {
636 if (mPrefetchedLayers.size()) {
637 for (auto& node : mPrefetchedLayers) {
638 ALOGW("Incorrectly called buildLayer on View: %s, destroying layer...",
639 node->getName());
640 node->destroyHardwareResources(observer);
641 node->decStrong(observer);
642 }
643 mPrefetchedLayers.clear();
John Reck998a6d82014-08-28 15:35:53 -0700644 }
645}
646
John Reck51f2d602016-04-06 07:50:47 -0700647void CanvasContext::buildLayer(RenderNode* node, TreeObserver* observer) {
John Reck3e824952014-08-20 10:08:39 -0700648 ATRACE_CALL();
Chris Craik6246d2782016-03-29 15:01:41 -0700649 if (!mEglManager.hasEglContext()) return;
650#if !HWUI_NEW_OPS
651 if (!mCanvas) return;
652#endif
653
John Reck3e824952014-08-20 10:08:39 -0700654 // buildLayer() will leave the tree in an unknown state, so we must stop drawing
655 stopDrawing();
656
Chris Craike2e53a72015-10-28 15:55:40 -0700657 TreeInfo info(TreeInfo::MODE_FULL, *this);
John Reck3e824952014-08-20 10:08:39 -0700658 info.damageAccumulator = &mDamageAccumulator;
John Reck51f2d602016-04-06 07:50:47 -0700659 info.observer = observer;
Chris Craik0b7e8242015-10-28 16:50:44 -0700660#if HWUI_NEW_OPS
661 info.layerUpdateQueue = &mLayerUpdateQueue;
662#else
John Reck3e824952014-08-20 10:08:39 -0700663 info.renderer = mCanvas;
Chris Craik0b7e8242015-10-28 16:50:44 -0700664#endif
John Reck9eb9f6f2014-08-21 11:23:05 -0700665 info.runAnimations = false;
John Reck3e824952014-08-20 10:08:39 -0700666 node->prepareTree(info);
667 SkRect ignore;
668 mDamageAccumulator.finish(&ignore);
669 // Tickle the GENERIC property on node to mark it as dirty for damaging
670 // purposes when the frame is actually drawn
671 node->setPropertyFieldsDirty(RenderNode::GENERIC);
672
Chris Craik98787e62015-11-13 10:55:30 -0800673#if HWUI_NEW_OPS
Chris Craik6246d2782016-03-29 15:01:41 -0700674 static const std::vector< sp<RenderNode> > emptyNodeList;
675 auto& caches = Caches::getInstance();
Chris Craik9cd1bbe2016-04-14 16:08:25 -0700676 FrameBuilder frameBuilder(mLayerUpdateQueue, mLightGeometry, caches);
Chris Craik6246d2782016-03-29 15:01:41 -0700677 mLayerUpdateQueue.clear();
678 BakedOpRenderer renderer(caches, mRenderThread.renderState(),
679 mOpaque, mLightInfo);
680 LOG_ALWAYS_FATAL_IF(renderer.didDraw(), "shouldn't draw in buildlayer case");
681 frameBuilder.replayBakedOps<BakedOpDispatcher>(renderer);
Chris Craik98787e62015-11-13 10:55:30 -0800682#else
John Reck443a7142014-09-04 17:40:05 -0700683 mCanvas->markLayersAsBuildLayers();
John Reck3e824952014-08-20 10:08:39 -0700684 mCanvas->flushLayerUpdates();
Chris Craik98787e62015-11-13 10:55:30 -0800685#endif
John Reck998a6d82014-08-28 15:35:53 -0700686
Chris Craikd41c4d82015-01-05 15:51:13 -0800687 node->incStrong(nullptr);
John Reck51f2d602016-04-06 07:50:47 -0700688 mPrefetchedLayers.insert(node);
John Reck3e824952014-08-20 10:08:39 -0700689}
690
John Reck19b6bcf2014-02-14 20:03:38 -0800691bool CanvasContext::copyLayerInto(DeferredLayerUpdater* layer, SkBitmap* bitmap) {
John Reck68bfe0a2014-06-24 15:34:58 -0700692 layer->apply();
John Reck3b202512014-06-23 13:13:08 -0700693 return LayerRenderer::copyLayer(mRenderThread.renderState(), layer->backingLayer(), bitmap);
John Reck19b6bcf2014-02-14 20:03:38 -0800694}
695
John Reck51f2d602016-04-06 07:50:47 -0700696void CanvasContext::destroyHardwareResources(TreeObserver* observer) {
John Reckf47a5942014-06-30 16:20:04 -0700697 stopDrawing();
John Reck3b202512014-06-23 13:13:08 -0700698 if (mEglManager.hasEglContext()) {
John Reck51f2d602016-04-06 07:50:47 -0700699 freePrefetchedLayers(observer);
Skuhneea7a7fb2015-08-28 07:10:31 -0700700 for (const sp<RenderNode>& node : mRenderNodes) {
John Reck51f2d602016-04-06 07:50:47 -0700701 node->destroyHardwareResources(observer);
Skuhneea7a7fb2015-08-28 07:10:31 -0700702 }
John Reck00e79c92015-07-21 10:23:59 -0700703 Caches& caches = Caches::getInstance();
704 // Make sure to release all the textures we were owning as there won't
705 // be another draw
706 caches.textureCache.resetMarkInUse(this);
Chris Craik9fded232015-11-11 16:42:34 -0800707 mRenderThread.renderState().flush(Caches::FlushMode::Layers);
John Reckf47a5942014-06-30 16:20:04 -0700708 }
709}
710
711void CanvasContext::trimMemory(RenderThread& thread, int level) {
712 // No context means nothing to free
713 if (!thread.eglManager().hasEglContext()) return;
714
Jorim Jaggi786afcb2014-09-25 02:41:29 +0200715 ATRACE_CALL();
John Reckf47a5942014-06-30 16:20:04 -0700716 if (level >= TRIM_MEMORY_COMPLETE) {
Chris Craik9fded232015-11-11 16:42:34 -0800717 thread.renderState().flush(Caches::FlushMode::Full);
John Reckf47a5942014-06-30 16:20:04 -0700718 thread.eglManager().destroy();
719 } else if (level >= TRIM_MEMORY_UI_HIDDEN) {
Chris Craik9fded232015-11-11 16:42:34 -0800720 thread.renderState().flush(Caches::FlushMode::Moderate);
John Recke1628b72014-05-23 15:11:19 -0700721 }
722}
723
John Reckfc53ef272014-02-11 10:40:25 -0800724void CanvasContext::runWithGlContext(RenderTask* task) {
John Reckd7db4d72015-05-20 07:18:55 -0700725 LOG_ALWAYS_FATAL_IF(!mEglManager.hasEglContext(),
726 "GL context not initialized!");
John Reck19b6bcf2014-02-14 20:03:38 -0800727 task->run();
728}
729
John Reck1949e792014-04-08 15:18:56 -0700730Layer* CanvasContext::createTextureLayer() {
John Reck8afcc762016-04-13 10:24:06 -0700731 mEglManager.initialize();
John Reck3b202512014-06-23 13:13:08 -0700732 return LayerRenderer::createTextureLayer(mRenderThread.renderState());
John Reck1949e792014-04-08 15:18:56 -0700733}
734
John Reck3b202512014-06-23 13:13:08 -0700735void CanvasContext::setTextureAtlas(RenderThread& thread,
736 const sp<GraphicBuffer>& buffer, int64_t* map, size_t mapSize) {
737 thread.eglManager().setTextureAtlas(buffer, map, mapSize);
John Reck66f0be62014-05-13 13:39:31 -0700738}
739
John Reckba6adf62015-02-19 14:36:50 -0800740void CanvasContext::dumpFrames(int fd) {
741 FILE* file = fdopen(fd, "a");
John Reck4db3d172015-06-02 15:58:43 -0700742 fprintf(file, "\n\n---PROFILEDATA---\n");
Chris Craik1b54fb22015-06-02 17:40:58 -0700743 for (size_t i = 0; i < static_cast<size_t>(FrameInfoIndex::NumIndexes); i++) {
John Reck2a8bb052015-06-03 09:52:01 -0700744 fprintf(file, "%s", FrameInfoNames[i].c_str());
John Reck4db3d172015-06-02 15:58:43 -0700745 fprintf(file, ",");
746 }
John Reckba6adf62015-02-19 14:36:50 -0800747 for (size_t i = 0; i < mFrames.size(); i++) {
748 FrameInfo& frame = mFrames[i];
Chris Craik1b54fb22015-06-02 17:40:58 -0700749 if (frame[FrameInfoIndex::SyncStart] == 0) {
John Reckba6adf62015-02-19 14:36:50 -0800750 continue;
751 }
752 fprintf(file, "\n");
Chris Craik1b54fb22015-06-02 17:40:58 -0700753 for (int i = 0; i < static_cast<int>(FrameInfoIndex::NumIndexes); i++) {
John Reckba6adf62015-02-19 14:36:50 -0800754 fprintf(file, "%" PRId64 ",", frame[i]);
755 }
756 }
757 fprintf(file, "\n---PROFILEDATA---\n\n");
758 fflush(file);
759}
760
761void CanvasContext::resetFrameStats() {
762 mFrames.clear();
763 mRenderThread.jankTracker().reset();
764}
765
John Recke248bd12015-08-05 13:53:53 -0700766void CanvasContext::serializeDisplayListTree() {
767#if ENABLE_RENDERNODE_SERIALIZATION
768 using namespace google::protobuf::io;
769 char package[128];
770 // Check whether tracing is enabled for this process.
771 FILE * file = fopen("/proc/self/cmdline", "r");
772 if (file) {
773 if (!fgets(package, 128, file)) {
774 ALOGE("Error reading cmdline: %s (%d)", strerror(errno), errno);
775 fclose(file);
776 return;
777 }
778 fclose(file);
779 } else {
780 ALOGE("Error opening /proc/self/cmdline: %s (%d)", strerror(errno),
781 errno);
782 return;
783 }
784 char path[1024];
785 snprintf(path, 1024, "/data/data/%s/cache/rendertree_dump", package);
786 int fd = open(path, O_CREAT | O_WRONLY, S_IRWXU | S_IRGRP | S_IROTH);
787 if (fd == -1) {
788 ALOGD("Failed to open '%s'", path);
789 return;
790 }
791 proto::RenderNode tree;
792 // TODO: Streaming writes?
793 mRootRenderNode->copyTo(&tree);
794 std::string data = tree.SerializeAsString();
795 write(fd, data.c_str(), data.length());
796 close(fd);
797#endif
798}
799
John Reck38f6c032016-03-17 10:23:49 -0700800void CanvasContext::waitOnFences() {
801 if (mFrameFences.size()) {
802 ATRACE_CALL();
803 for (auto& fence : mFrameFences) {
804 fence->getResult();
805 }
806 mFrameFences.clear();
807 }
808}
809
810class CanvasContext::FuncTaskProcessor : public TaskProcessor<bool> {
811public:
812 FuncTaskProcessor(Caches& caches)
813 : TaskProcessor<bool>(&caches.tasks) {}
814
815 virtual void onProcess(const sp<Task<bool> >& task) override {
816 FuncTask* t = static_cast<FuncTask*>(task.get());
817 t->func();
818 task->setResult(true);
819 }
820};
821
822void CanvasContext::enqueueFrameWork(std::function<void()>&& func) {
823 if (!mFrameWorkProcessor.get()) {
824 mFrameWorkProcessor = new FuncTaskProcessor(Caches::getInstance());
825 }
826 sp<FuncTask> task(new FuncTask());
827 task->func = func;
John Reck7b570de2016-06-27 13:27:23 -0700828 mFrameFences.push_back(task);
John Reck38f6c032016-03-17 10:23:49 -0700829 mFrameWorkProcessor->add(task);
830}
831
John Reck28912a52016-04-18 14:34:18 -0700832int64_t CanvasContext::getFrameNumber() {
833 // mFrameNumber is reset to -1 when the surface changes or we swap buffers
834 if (mFrameNumber == -1 && mNativeSurface.get()) {
835 mFrameNumber = static_cast<int64_t>(mNativeSurface->getNextFrameNumber());
836 }
837 return mFrameNumber;
838}
839
John Reck23b797a2014-01-03 18:08:34 -0800840} /* namespace renderthread */
841} /* namespace uirenderer */
842} /* namespace android */