blob: 9898a1c30856d014e06101daf5c3daf203d6c5e2 [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 Reck23b797a2014-01-03 18:08:34 -080017#include "CanvasContext.h"
John Reck1bcacfd2017-11-03 10:12:19 -070018#include <GpuMemoryTracker.h>
John Reck23b797a2014-01-03 18:08:34 -080019
John Reck0fa0cbc2019-04-05 16:57:46 -070020#include "../Properties.h"
John Reckd04794a2015-05-08 10:04:36 -070021#include "AnimationContext.h"
John Reck3b202512014-06-23 13:13:08 -070022#include "EglManager.h"
Greg Danielcd558522016-11-17 13:31:40 -050023#include "Frame.h"
Chris Craik5e00c7c2016-07-06 16:10:09 -070024#include "LayerUpdateQueue.h"
John Reckd04794a2015-05-08 10:04:36 -070025#include "Properties.h"
John Reck4f02bf42014-01-03 18:09:17 -080026#include "RenderThread.h"
sergeyvdccca442016-03-21 15:38:21 -070027#include "hwui/Canvas.h"
Stan Iliev500a0c32016-10-26 10:30:09 -040028#include "pipeline/skia/SkiaOpenGLPipeline.h"
29#include "pipeline/skia/SkiaPipeline.h"
30#include "pipeline/skia/SkiaVulkanPipeline.h"
John Reck322b8ab2019-03-14 13:15:28 -070031#include "thread/CommonPool.h"
John Reck9372ac32016-01-19 11:46:52 -080032#include "utils/GLUtils.h"
John Recke486d932015-10-28 09:21:19 -070033#include "utils/TimeUtils.h"
John Reck322b8ab2019-03-14 13:15:28 -070034#include "utils/TraceUtils.h"
John Recke248bd12015-08-05 13:53:53 -070035
36#include <cutils/properties.h>
John Recke248bd12015-08-05 13:53:53 -070037#include <private/hwui/DrawGlInfo.h>
38#include <strings.h>
John Reck23b797a2014-01-03 18:08:34 -080039
John Recke248bd12015-08-05 13:53:53 -070040#include <fcntl.h>
41#include <sys/stat.h>
John Reck1bcacfd2017-11-03 10:12:19 -070042#include <algorithm>
Chris Craik65fe5ee2015-01-26 18:06:29 -080043
Leon Scroggins III6c5864c2019-04-03 15:09:25 -040044#include <cstdint>
Colin Cross290b23a2015-11-05 14:10:47 -080045#include <cstdlib>
John Reckcc2eee82018-05-17 10:44:00 -070046#include <functional>
Colin Cross290b23a2015-11-05 14:10:47 -080047
John Reckf47a5942014-06-30 16:20:04 -070048#define TRIM_MEMORY_COMPLETE 80
49#define TRIM_MEMORY_UI_HIDDEN 20
50
John Reck149173d2015-08-10 09:52:29 -070051#define LOG_FRAMETIME_MMA 0
52
53#if LOG_FRAMETIME_MMA
54static float sBenchMma = 0;
55static int sFrameCount = 0;
56static const float NANOS_PER_MILLIS_F = 1000000.0f;
57#endif
58
John Reck23b797a2014-01-03 18:08:34 -080059namespace android {
60namespace uirenderer {
61namespace renderthread {
62
John Reck1bcacfd2017-11-03 10:12:19 -070063CanvasContext* CanvasContext::create(RenderThread& thread, bool translucent,
64 RenderNode* rootRenderNode, IContextFactory* contextFactory) {
Stan Iliev03de0742016-07-07 12:35:54 -040065 auto renderType = Properties::getRenderPipelineType();
Stan Iliev768e3932016-07-08 21:34:52 -040066
Stan Iliev03de0742016-07-07 12:35:54 -040067 switch (renderType) {
Stan Iliev03de0742016-07-07 12:35:54 -040068 case RenderPipelineType::SkiaGL:
Stan Iliev500a0c32016-10-26 10:30:09 -040069 return new CanvasContext(thread, translucent, rootRenderNode, contextFactory,
John Reck1bcacfd2017-11-03 10:12:19 -070070 std::make_unique<skiapipeline::SkiaOpenGLPipeline>(thread));
Stan Iliev8a33e402016-07-08 09:57:49 -040071 case RenderPipelineType::SkiaVulkan:
Stan Iliev500a0c32016-10-26 10:30:09 -040072 return new CanvasContext(thread, translucent, rootRenderNode, contextFactory,
John Reck1bcacfd2017-11-03 10:12:19 -070073 std::make_unique<skiapipeline::SkiaVulkanPipeline>(thread));
Stan Iliev03de0742016-07-07 12:35:54 -040074 default:
John Reck1bcacfd2017-11-03 10:12:19 -070075 LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t)renderType);
Stan Iliev03de0742016-07-07 12:35:54 -040076 break;
77 }
78 return nullptr;
79}
80
Derek Sollenbergerdaf72292016-10-25 12:09:18 -040081void CanvasContext::invokeFunctor(const RenderThread& thread, Functor* functor) {
82 ATRACE_CALL();
83 auto renderType = Properties::getRenderPipelineType();
84 switch (renderType) {
Stan Iliev500a0c32016-10-26 10:30:09 -040085 case RenderPipelineType::SkiaGL:
86 skiapipeline::SkiaOpenGLPipeline::invokeFunctor(thread, functor);
87 break;
88 case RenderPipelineType::SkiaVulkan:
89 skiapipeline::SkiaVulkanPipeline::invokeFunctor(thread, functor);
90 break;
Derek Sollenbergerdaf72292016-10-25 12:09:18 -040091 default:
John Reck1bcacfd2017-11-03 10:12:19 -070092 LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t)renderType);
Derek Sollenbergerdaf72292016-10-25 12:09:18 -040093 break;
94 }
95}
96
97void CanvasContext::prepareToDraw(const RenderThread& thread, Bitmap* bitmap) {
John Reck18f442e2018-04-09 16:56:34 -070098 skiapipeline::SkiaPipeline::prepareToDraw(thread, bitmap);
Derek Sollenbergerdaf72292016-10-25 12:09:18 -040099}
100
John Reck1bcacfd2017-11-03 10:12:19 -0700101CanvasContext::CanvasContext(RenderThread& thread, bool translucent, RenderNode* rootRenderNode,
102 IContextFactory* contextFactory,
103 std::unique_ptr<IRenderPipeline> renderPipeline)
John Reck3b202512014-06-23 13:13:08 -0700104 : mRenderThread(thread)
Leon Scroggins III4afdd1c2018-05-14 14:59:30 -0400105 , mGenerationID(0)
John Reck4f02bf42014-01-03 18:09:17 -0800106 , mOpaque(!translucent)
Chris Craik51d6a3d2014-12-22 17:16:56 -0800107 , mAnimationContext(contextFactory->createAnimationContext(mRenderThread.timeLord()))
John Reckcf185f52019-04-11 16:11:24 -0700108 , mJankTracker(&thread.globalProfileData(), DeviceInfo::get()->displayInfo())
John Reck3c0f5632019-03-15 16:36:01 -0700109 , mProfiler(mJankTracker.frames(), thread.timeLord().frameIntervalNanos())
Stan Iliev768e3932016-07-08 21:34:52 -0400110 , mContentDrawBounds(0, 0, 0, 0)
111 , mRenderPipeline(std::move(renderPipeline)) {
John Reck2de950d2017-01-25 10:58:30 -0800112 rootRenderNode->makeRoot();
Skuhneea7a7fb2015-08-28 07:10:31 -0700113 mRenderNodes.emplace_back(rootRenderNode);
John Reckcf185f52019-04-11 16:11:24 -0700114 mProfiler.setDensity(DeviceInfo::get()->displayInfo().density);
John Reck4d527222019-03-13 16:25:20 -0700115 setRenderAheadDepth(Properties::defaultRenderAhead);
John Reck23b797a2014-01-03 18:08:34 -0800116}
117
118CanvasContext::~CanvasContext() {
John Reck2de950d2017-01-25 10:58:30 -0800119 destroy();
John Reck2de950d2017-01-25 10:58:30 -0800120 for (auto& node : mRenderNodes) {
121 node->clearRoot();
122 }
123 mRenderNodes.clear();
John Reck4f02bf42014-01-03 18:09:17 -0800124}
125
John Reck2de950d2017-01-25 10:58:30 -0800126void CanvasContext::addRenderNode(RenderNode* node, bool placeFront) {
127 int pos = placeFront ? 0 : static_cast<int>(mRenderNodes.size());
128 node->makeRoot();
129 mRenderNodes.emplace(mRenderNodes.begin() + pos, node);
130}
131
132void CanvasContext::removeRenderNode(RenderNode* node) {
133 node->clearRoot();
134 mRenderNodes.erase(std::remove(mRenderNodes.begin(), mRenderNodes.end(), node),
John Reck1bcacfd2017-11-03 10:12:19 -0700135 mRenderNodes.end());
John Reck2de950d2017-01-25 10:58:30 -0800136}
137
138void CanvasContext::destroy() {
John Reck17035b02014-09-03 07:39:53 -0700139 stopDrawing();
Chris Craikd41c4d82015-01-05 15:51:13 -0800140 setSurface(nullptr);
John Reck2de950d2017-01-25 10:58:30 -0800141 freePrefetchedLayers();
142 destroyHardwareResources();
John Recke2478d42014-09-03 16:46:05 -0700143 mAnimationContext->destroy();
John Reck23b797a2014-01-03 18:08:34 -0800144}
145
John Reckf8441e62017-10-23 13:10:41 -0700146void CanvasContext::setSurface(sp<Surface>&& surface) {
John Reckfbc8df02014-11-14 16:18:41 -0800147 ATRACE_CALL();
148
John Reck848f6512018-12-03 13:26:43 -0800149 if (surface) {
150 mNativeSurface = new ReliableSurface{std::move(surface)};
John Reck3f333d62019-07-17 11:12:32 -0700151 // TODO: Fix error handling & re-shorten timeout
152 mNativeSurface->setDequeueTimeout(4000_ms);
John Reck848f6512018-12-03 13:26:43 -0800153 } else {
154 mNativeSurface = nullptr;
155 }
John Recka5dda642014-05-22 15:43:54 -0700156
Miguel de Dios509627b2019-05-14 23:55:36 +0000157 if (mRenderAheadDepth == 0 && DeviceInfo::get()->getMaxRefreshRate() > 66.6f) {
John Reckcf185f52019-04-11 16:11:24 -0700158 mFixedRenderAhead = false;
159 mRenderAheadCapacity = 1;
160 } else {
161 mFixedRenderAhead = true;
162 mRenderAheadCapacity = mRenderAheadDepth;
163 }
164
Peiyong Lin189021b2018-09-27 16:41:40 -0700165 ColorMode colorMode = mWideColorGamut ? ColorMode::WideColorGamut : ColorMode::SRGB;
John Reck0fa0cbc2019-04-05 16:57:46 -0700166 bool hasSurface = mRenderPipeline->setSurface(mNativeSurface.get(), mSwapBehavior, colorMode,
John Reckcf185f52019-04-11 16:11:24 -0700167 mRenderAheadCapacity);
John Reck23b797a2014-01-03 18:08:34 -0800168
John Reck28912a52016-04-18 14:34:18 -0700169 mFrameNumber = -1;
170
Stan Iliev768e3932016-07-08 21:34:52 -0400171 if (hasSurface) {
John Reck1bcacfd2017-11-03 10:12:19 -0700172 mHaveNewSurface = true;
173 mSwapHistory.clear();
John Reck368cdd82014-05-07 13:11:00 -0700174 } else {
John Reck1bcacfd2017-11-03 10:12:19 -0700175 mRenderThread.removeFrameCallback(this);
Leon Scroggins III4afdd1c2018-05-14 14:59:30 -0400176 mGenerationID++;
John Reck23b797a2014-01-03 18:08:34 -0800177 }
John Reck23b797a2014-01-03 18:08:34 -0800178}
179
John Reck1125d1f2014-10-23 11:02:19 -0700180void CanvasContext::setSwapBehavior(SwapBehavior swapBehavior) {
181 mSwapBehavior = swapBehavior;
182}
183
John Reckf8441e62017-10-23 13:10:41 -0700184bool CanvasContext::pauseSurface() {
Leon Scroggins III4afdd1c2018-05-14 14:59:30 -0400185 mGenerationID++;
John Reck01a5ea32014-12-03 13:01:07 -0800186 return mRenderThread.removeFrameCallback(this);
John Reck4f02bf42014-01-03 18:09:17 -0800187}
188
John Reck8afcc762016-04-13 10:24:06 -0700189void CanvasContext::setStopped(bool stopped) {
190 if (mStopped != stopped) {
191 mStopped = stopped;
192 if (mStopped) {
Leon Scroggins III4afdd1c2018-05-14 14:59:30 -0400193 mGenerationID++;
John Reck8afcc762016-04-13 10:24:06 -0700194 mRenderThread.removeFrameCallback(this);
Stan Iliev768e3932016-07-08 21:34:52 -0400195 mRenderPipeline->onStop();
John Reck306f3312016-06-10 16:01:55 -0700196 } else if (mIsDirty && hasSurface()) {
197 mRenderThread.postFrameCallback(this);
John Reck8afcc762016-04-13 10:24:06 -0700198 }
199 }
200}
201
John Reck8785ceb2018-10-29 16:45:58 -0700202void CanvasContext::allocateBuffers() {
203 if (mNativeSurface) {
204 mNativeSurface->allocateBuffers();
205 }
206}
207
208void CanvasContext::setLightAlpha(uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha) {
Chris Craik98787e62015-11-13 10:55:30 -0800209 mLightInfo.ambientShadowAlpha = ambientShadowAlpha;
210 mLightInfo.spotShadowAlpha = spotShadowAlpha;
Alan Viverette50210d92015-05-14 18:05:36 -0700211}
212
John Reck8785ceb2018-10-29 16:45:58 -0700213void CanvasContext::setLightGeometry(const Vector3& lightCenter, float lightRadius) {
Chris Craik6e068c012016-01-15 16:15:30 -0800214 mLightGeometry.center = lightCenter;
John Reck8785ceb2018-10-29 16:45:58 -0700215 mLightGeometry.radius = lightRadius;
John Reck4f02bf42014-01-03 18:09:17 -0800216}
217
John Reck63a06672014-05-07 13:45:54 -0700218void CanvasContext::setOpaque(bool opaque) {
219 mOpaque = opaque;
220}
221
Romain Guy26a2b972017-04-17 09:39:51 -0700222void CanvasContext::setWideGamut(bool wideGamut) {
223 mWideColorGamut = wideGamut;
224}
225
John Reck8afcc762016-04-13 10:24:06 -0700226bool CanvasContext::makeCurrent() {
227 if (mStopped) return false;
228
Stan Iliev768e3932016-07-08 21:34:52 -0400229 auto result = mRenderPipeline->makeCurrent();
230 switch (result) {
231 case MakeCurrentResult::AlreadyCurrent:
232 return true;
233 case MakeCurrentResult::Failed:
234 mHaveNewSurface = true;
235 setSurface(nullptr);
236 return false;
237 case MakeCurrentResult::Succeeded:
238 mHaveNewSurface = true;
239 return true;
240 default:
241 LOG_ALWAYS_FATAL("unexpected result %d from IRenderPipeline::makeCurrent",
John Reck1bcacfd2017-11-03 10:12:19 -0700242 (int32_t)result);
John Reckf2dcc2a2015-07-16 09:17:59 -0700243 }
Stan Iliev768e3932016-07-08 21:34:52 -0400244
245 return true;
John Reck860d1552014-04-11 19:15:05 -0700246}
247
John Reckbf3c6022015-06-02 15:55:00 -0700248static bool wasSkipped(FrameInfo* info) {
Chris Craik1b54fb22015-06-02 17:40:58 -0700249 return info && ((*info)[FrameInfoIndex::Flags] & FrameInfoFlags::SkippedFrame);
John Reckbf3c6022015-06-02 15:55:00 -0700250}
251
John Reck0def73a2016-07-01 16:19:13 -0700252bool CanvasContext::isSwapChainStuffed() {
John Recka3d795a2016-07-27 19:28:05 -0700253 static const auto SLOW_THRESHOLD = 6_ms;
254
John Reck0def73a2016-07-01 16:19:13 -0700255 if (mSwapHistory.size() != mSwapHistory.capacity()) {
256 // We want at least 3 frames of history before attempting to
257 // guess if the queue is stuffed
258 return false;
259 }
260 nsecs_t frameInterval = mRenderThread.timeLord().frameIntervalNanos();
261 auto& swapA = mSwapHistory[0];
262
263 // Was there a happy queue & dequeue time? If so, don't
264 // consider it stuffed
John Reck1bcacfd2017-11-03 10:12:19 -0700265 if (swapA.dequeueDuration < SLOW_THRESHOLD && swapA.queueDuration < SLOW_THRESHOLD) {
John Reck0def73a2016-07-01 16:19:13 -0700266 return false;
267 }
268
269 for (size_t i = 1; i < mSwapHistory.size(); i++) {
270 auto& swapB = mSwapHistory[i];
271
Chris Craik31635682016-07-19 17:59:12 -0700272 // If there's a multi-frameInterval gap we effectively already dropped a frame,
John Reck0def73a2016-07-01 16:19:13 -0700273 // so consider the queue healthy.
Yu Jiae57493a2018-05-30 11:18:05 +0800274 if (std::abs(swapA.swapCompletedTime - swapB.swapCompletedTime) > frameInterval * 3) {
John Reck0def73a2016-07-01 16:19:13 -0700275 return false;
276 }
277
278 // Was there a happy queue & dequeue time? If so, don't
279 // consider it stuffed
John Reck1bcacfd2017-11-03 10:12:19 -0700280 if (swapB.dequeueDuration < SLOW_THRESHOLD && swapB.queueDuration < SLOW_THRESHOLD) {
John Reck0def73a2016-07-01 16:19:13 -0700281 return false;
282 }
283
284 swapA = swapB;
285 }
286
287 // All signs point to a stuffed swap chain
Tim Murrayffde6272016-07-18 14:11:28 -0700288 ATRACE_NAME("swap chain stuffed");
John Reck0def73a2016-07-01 16:19:13 -0700289 return true;
290}
291
John Reck1bcacfd2017-11-03 10:12:19 -0700292void CanvasContext::prepareTree(TreeInfo& info, int64_t* uiFrameInfo, int64_t syncQueued,
293 RenderNode* target) {
John Reckf9be7792014-05-02 18:21:16 -0700294 mRenderThread.removeFrameCallback(this);
John Reck18f16e62014-05-02 16:46:41 -0700295
John Reckbf3c6022015-06-02 15:55:00 -0700296 // If the previous frame was dropped we don't need to hold onto it, so
297 // just keep using the previous frame's structure instead
298 if (!wasSkipped(mCurrentFrameInfo)) {
John Reck34781b22017-07-05 16:39:36 -0700299 mCurrentFrameInfo = mJankTracker.startFrame();
John Reckbf3c6022015-06-02 15:55:00 -0700300 }
John Reckba6adf62015-02-19 14:36:50 -0800301 mCurrentFrameInfo->importUiThreadInfo(uiFrameInfo);
John Reckbe3fba02015-07-06 13:49:58 -0700302 mCurrentFrameInfo->set(FrameInfoIndex::SyncQueued) = syncQueued;
John Reckba6adf62015-02-19 14:36:50 -0800303 mCurrentFrameInfo->markSyncStart();
304
John Recke4267ea2014-06-03 15:53:15 -0700305 info.damageAccumulator = &mDamageAccumulator;
Chris Craik0b7e8242015-10-28 16:50:44 -0700306 info.layerUpdateQueue = &mLayerUpdateQueue;
John Reck848f6512018-12-03 13:26:43 -0800307 info.out.canDrawThisFrame = true;
John Reck00e79c92015-07-21 10:23:59 -0700308
John Reckec845a22014-09-05 15:23:38 -0700309 mAnimationContext->startFrame(info.mode);
Stan Iliev47fed6ba2017-10-18 17:56:43 -0400310 mRenderPipeline->onPrepareTree();
John Reck0fa0cbc2019-04-05 16:57:46 -0700311 for (const sp<RenderNode>& node : mRenderNodes) {
Skuhneea7a7fb2015-08-28 07:10:31 -0700312 // Only the primary target node will be drawn full - all other nodes would get drawn in
313 // real time mode. In case of a window, the primary node is the window content and the other
314 // node(s) are non client / filler nodes.
315 info.mode = (node.get() == target ? TreeInfo::MODE_FULL : TreeInfo::MODE_RT_ONLY);
316 node->prepareTree(info);
John Reck975591a2016-01-22 16:28:07 -0800317 GL_CHECKPOINT(MODERATE);
Skuhneea7a7fb2015-08-28 07:10:31 -0700318 }
John Reck119907c2014-08-14 09:02:01 -0700319 mAnimationContext->runRemainingAnimations(info);
John Reck975591a2016-01-22 16:28:07 -0800320 GL_CHECKPOINT(MODERATE);
John Recke45b1fd2014-04-15 09:50:16 -0700321
John Reck2de950d2017-01-25 10:58:30 -0800322 freePrefetchedLayers();
John Reck975591a2016-01-22 16:28:07 -0800323 GL_CHECKPOINT(MODERATE);
John Reck998a6d82014-08-28 15:35:53 -0700324
John Reck306f3312016-06-10 16:01:55 -0700325 mIsDirty = true;
326
John Reck848f6512018-12-03 13:26:43 -0800327 if (CC_UNLIKELY(!hasSurface())) {
Chris Craik1b54fb22015-06-02 17:40:58 -0700328 mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
John Reckaa95a882014-11-07 11:02:07 -0800329 info.out.canDrawThisFrame = false;
330 return;
331 }
332
John Reckf1480762016-07-03 18:28:25 -0700333 if (CC_LIKELY(mSwapHistory.size() && !Properties::forceDrawFrame)) {
John Recke486d932015-10-28 09:21:19 -0700334 nsecs_t latestVsync = mRenderThread.timeLord().latestVsync();
John Reck0fa0cbc2019-04-05 16:57:46 -0700335 SwapHistory& lastSwap = mSwapHistory.back();
John Reck52b783f2015-11-24 11:12:55 -0800336 nsecs_t vsyncDelta = std::abs(lastSwap.vsyncTime - latestVsync);
John Recke486d932015-10-28 09:21:19 -0700337 // The slight fudge-factor is to deal with cases where
338 // the vsync was estimated due to being slow handling the signal.
339 // See the logic in TimeLord#computeFrameTimeNanos or in
340 // Choreographer.java for details on when this happens
341 if (vsyncDelta < 2_ms) {
342 // Already drew for this vsync pulse, UI draw request missed
343 // the deadline for RT animations
344 info.out.canDrawThisFrame = false;
John Reck6f75da02018-03-21 14:43:40 -0700345 }
Bo Hudd082242018-12-02 05:22:41 +0000346 } else {
347 info.out.canDrawThisFrame = true;
John Recke486d932015-10-28 09:21:19 -0700348 }
John Recka5dda642014-05-22 15:43:54 -0700349
John Reckcc2eee82018-05-17 10:44:00 -0700350 // TODO: Do we need to abort out if the backdrop is added but not ready? Should that even
351 // be an allowable combination?
352 if (mRenderNodes.size() > 2 && !mRenderNodes[1]->isRenderable()) {
353 info.out.canDrawThisFrame = false;
354 }
355
John Reck848f6512018-12-03 13:26:43 -0800356 if (info.out.canDrawThisFrame) {
357 int err = mNativeSurface->reserveNext();
358 if (err != OK) {
359 mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
360 info.out.canDrawThisFrame = false;
361 ALOGW("reserveNext failed, error = %d (%s)", err, strerror(-err));
362 if (err != TIMED_OUT) {
363 // A timed out surface can still recover, but assume others are permanently dead.
364 setSurface(nullptr);
365 return;
366 }
367 }
368 } else {
Chris Craik1b54fb22015-06-02 17:40:58 -0700369 mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
John Reckaef9dc82015-05-08 14:10:57 -0700370 }
371
Leon Scroggins III4afdd1c2018-05-14 14:59:30 -0400372 bool postedFrameCallback = false;
John Recka5dda642014-05-22 15:43:54 -0700373 if (info.out.hasAnimations || !info.out.canDrawThisFrame) {
John Reck9f516442017-09-25 10:27:21 -0700374 if (CC_UNLIKELY(!Properties::enableRTAnimations)) {
375 info.out.requiresUiRedraw = true;
376 }
John Reckcd028f32014-06-24 08:44:29 -0700377 if (!info.out.requiresUiRedraw) {
John Reckf9be7792014-05-02 18:21:16 -0700378 // If animationsNeedsRedraw is set don't bother posting for an RT anim
379 // as we will just end up fighting the UI thread.
380 mRenderThread.postFrameCallback(this);
Leon Scroggins III4afdd1c2018-05-14 14:59:30 -0400381 postedFrameCallback = true;
382 }
383 }
384
385 if (!postedFrameCallback &&
386 info.out.animatedImageDelay != TreeInfo::Out::kNoAnimatedImageDelay) {
387 // Subtract the time of one frame so it can be displayed on time.
388 const nsecs_t kFrameTime = mRenderThread.timeLord().frameIntervalNanos();
389 if (info.out.animatedImageDelay <= kFrameTime) {
390 mRenderThread.postFrameCallback(this);
391 } else {
392 const auto delay = info.out.animatedImageDelay - kFrameTime;
393 int genId = mGenerationID;
394 mRenderThread.queue().postDelayed(delay, [this, genId]() {
395 if (mGenerationID == genId) {
396 mRenderThread.postFrameCallback(this);
397 }
398 });
John Reckf9be7792014-05-02 18:21:16 -0700399 }
John Recke45b1fd2014-04-15 09:50:16 -0700400 }
401}
402
John Reckf47a5942014-06-30 16:20:04 -0700403void CanvasContext::stopDrawing() {
404 mRenderThread.removeFrameCallback(this);
Doris Liuc82e8792016-07-29 16:45:24 -0700405 mAnimationContext->pauseAnimators();
Leon Scroggins III4afdd1c2018-05-14 14:59:30 -0400406 mGenerationID++;
John Reckf47a5942014-06-30 16:20:04 -0700407}
408
John Recka5dda642014-05-22 15:43:54 -0700409void CanvasContext::notifyFramePending() {
410 ATRACE_CALL();
411 mRenderThread.pushBackFrameCallback(this);
412}
413
John Reckcf185f52019-04-11 16:11:24 -0700414void CanvasContext::setPresentTime() {
415 int64_t presentTime = NATIVE_WINDOW_TIMESTAMP_AUTO;
416 int renderAhead = 0;
417 const auto frameIntervalNanos = mRenderThread.timeLord().frameIntervalNanos();
418 if (mFixedRenderAhead) {
419 renderAhead = std::min(mRenderAheadDepth, mRenderAheadCapacity);
420 } else if (frameIntervalNanos < 15_ms) {
421 renderAhead = std::min(1, static_cast<int>(mRenderAheadCapacity));
422 }
423
424 if (renderAhead) {
425 presentTime = mCurrentFrameInfo->get(FrameInfoIndex::Vsync) +
426 (frameIntervalNanos * (renderAhead + 1));
427 }
428 native_window_set_buffers_timestamp(mNativeSurface.get(), presentTime);
429}
430
John Recke4267ea2014-06-03 15:53:15 -0700431void CanvasContext::draw() {
John Recke4267ea2014-06-03 15:53:15 -0700432 SkRect dirty;
433 mDamageAccumulator.finish(&dirty);
434
John Reck0fa0cbc2019-04-05 16:57:46 -0700435 if (dirty.isEmpty() && Properties::skipEmptyFrames && !surfaceRequiresRedraw()) {
John Reck0b19a732019-03-07 17:18:25 -0800436 mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
437 return;
438 }
John Reck240ff622015-04-28 13:50:00 -0700439
John Reck240ff622015-04-28 13:50:00 -0700440 mCurrentFrameInfo->markIssueDrawCommandsStart();
441
Stan Iliev768e3932016-07-08 21:34:52 -0400442 Frame frame = mRenderPipeline->getFrame();
John Reckcf185f52019-04-11 16:11:24 -0700443 setPresentTime();
Chris Craikb565df12015-10-05 13:00:52 -0700444
Stan Iliev768e3932016-07-08 21:34:52 -0400445 SkRect windowDirty = computeDirtyRect(frame, &dirty);
John Reck4f02bf42014-01-03 18:09:17 -0800446
Stan Iliev768e3932016-07-08 21:34:52 -0400447 bool drew = mRenderPipeline->draw(frame, windowDirty, dirty, mLightGeometry, &mLayerUpdateQueue,
John Reck0fa0cbc2019-04-05 16:57:46 -0700448 mContentDrawBounds, mOpaque, mLightInfo, mRenderNodes,
449 &(profiler()));
Chris Craik1dfa0702016-03-04 15:59:24 -0800450
John Reckcc2eee82018-05-17 10:44:00 -0700451 int64_t frameCompleteNr = mFrameCompleteCallbacks.size() ? getFrameNumber() : -1;
452
John Reck38f6c032016-03-17 10:23:49 -0700453 waitOnFences();
454
Stan Iliev768e3932016-07-08 21:34:52 -0400455 bool requireSwap = false;
John Reck1bcacfd2017-11-03 10:12:19 -0700456 bool didSwap =
457 mRenderPipeline->swapBuffers(frame, drew, windowDirty, mCurrentFrameInfo, &requireSwap);
John Reck9372ac32016-01-19 11:46:52 -0800458
John Reck306f3312016-06-10 16:01:55 -0700459 mIsDirty = false;
John Reckba6adf62015-02-19 14:36:50 -0800460
Stan Iliev768e3932016-07-08 21:34:52 -0400461 if (requireSwap) {
John Reck1bcacfd2017-11-03 10:12:19 -0700462 if (!didSwap) { // some error happened
John Reck149173d2015-08-10 09:52:29 -0700463 setSurface(nullptr);
464 }
John Recke486d932015-10-28 09:21:19 -0700465 SwapHistory& swap = mSwapHistory.next();
Stan Iliev768e3932016-07-08 21:34:52 -0400466 swap.damage = windowDirty;
John Reck0def73a2016-07-01 16:19:13 -0700467 swap.swapCompletedTime = systemTime(CLOCK_MONOTONIC);
John Recke486d932015-10-28 09:21:19 -0700468 swap.vsyncTime = mRenderThread.timeLord().latestVsync();
John Reck882d5152016-08-01 14:41:08 -0700469 if (mNativeSurface.get()) {
470 int durationUs;
John Reck32414ee2017-05-31 14:02:50 -0700471 nsecs_t dequeueStart = mNativeSurface->getLastDequeueStartTime();
John Recka67b62e2017-06-01 12:44:58 -0700472 if (dequeueStart < mCurrentFrameInfo->get(FrameInfoIndex::SyncStart)) {
473 // Ignoring dequeue duration as it happened prior to frame render start
John Reck32414ee2017-05-31 14:02:50 -0700474 // and thus is not part of the frame.
475 swap.dequeueDuration = 0;
476 } else {
477 mNativeSurface->query(NATIVE_WINDOW_LAST_DEQUEUE_DURATION, &durationUs);
478 swap.dequeueDuration = us2ns(durationUs);
479 }
John Reck882d5152016-08-01 14:41:08 -0700480 mNativeSurface->query(NATIVE_WINDOW_LAST_QUEUE_DURATION, &durationUs);
481 swap.queueDuration = us2ns(durationUs);
482 } else {
483 swap.dequeueDuration = 0;
484 swap.queueDuration = 0;
485 }
John Reck1bcacfd2017-11-03 10:12:19 -0700486 mCurrentFrameInfo->set(FrameInfoIndex::DequeueBufferDuration) = swap.dequeueDuration;
487 mCurrentFrameInfo->set(FrameInfoIndex::QueueBufferDuration) = swap.queueDuration;
John Reck149173d2015-08-10 09:52:29 -0700488 mHaveNewSurface = false;
John Reck28912a52016-04-18 14:34:18 -0700489 mFrameNumber = -1;
John Reck70e89c92016-08-05 10:50:36 -0700490 } else {
491 mCurrentFrameInfo->set(FrameInfoIndex::DequeueBufferDuration) = 0;
492 mCurrentFrameInfo->set(FrameInfoIndex::QueueBufferDuration) = 0;
John Reck4f02bf42014-01-03 18:09:17 -0800493 }
John Reckfe5e7b72014-05-23 17:42:28 -0700494
John Reckba6adf62015-02-19 14:36:50 -0800495 // TODO: Use a fence for real completion?
496 mCurrentFrameInfo->markFrameCompleted();
John Reck149173d2015-08-10 09:52:29 -0700497
498#if LOG_FRAMETIME_MMA
John Reck1bcacfd2017-11-03 10:12:19 -0700499 float thisFrame = mCurrentFrameInfo->duration(FrameInfoIndex::IssueDrawCommandsStart,
500 FrameInfoIndex::FrameCompleted) /
501 NANOS_PER_MILLIS_F;
John Reck149173d2015-08-10 09:52:29 -0700502 if (sFrameCount) {
503 sBenchMma = ((9 * sBenchMma) + thisFrame) / 10;
504 } else {
505 sBenchMma = thisFrame;
506 }
507 if (++sFrameCount == 10) {
508 sFrameCount = 1;
509 ALOGD("Average frame time: %.4f", sBenchMma);
510 }
511#endif
512
John Reckcc2eee82018-05-17 10:44:00 -0700513 if (didSwap) {
514 for (auto& func : mFrameCompleteCallbacks) {
515 std::invoke(func, frameCompleteNr);
516 }
517 mFrameCompleteCallbacks.clear();
518 }
519
John Reck34781b22017-07-05 16:39:36 -0700520 mJankTracker.finishFrame(*mCurrentFrameInfo);
Andres Morales910beb82016-02-02 16:19:40 -0800521 if (CC_UNLIKELY(mFrameMetricsReporter.get() != nullptr)) {
522 mFrameMetricsReporter->reportFrameMetrics(mCurrentFrameInfo->data());
Andres Morales06f5bc72015-12-15 15:21:31 -0800523 }
John Reck38e0c322015-11-10 12:19:17 -0800524
525 GpuMemoryTracker::onFrameCompleted();
John Reck4f02bf42014-01-03 18:09:17 -0800526}
527
John Recke45b1fd2014-04-15 09:50:16 -0700528// Called by choreographer to do an RT-driven animation
John Reck18f16e62014-05-02 16:46:41 -0700529void CanvasContext::doFrame() {
Stan Iliev768e3932016-07-08 21:34:52 -0400530 if (!mRenderPipeline->isSurfaceReady()) return;
Skuhneea7a7fb2015-08-28 07:10:31 -0700531 prepareAndDraw(nullptr);
532}
John Reck368cdd82014-05-07 13:11:00 -0700533
Leon Scroggins III6c5864c2019-04-03 15:09:25 -0400534SkISize CanvasContext::getNextFrameSize() const {
535 ReliableSurface* surface = mNativeSurface.get();
536 if (surface) {
537 SkISize size;
538 surface->query(NATIVE_WINDOW_WIDTH, &size.fWidth);
539 surface->query(NATIVE_WINDOW_HEIGHT, &size.fHeight);
540 return size;
541 }
542 return {INT32_MAX, INT32_MAX};
543}
544
Skuhneea7a7fb2015-08-28 07:10:31 -0700545void CanvasContext::prepareAndDraw(RenderNode* node) {
John Recke45b1fd2014-04-15 09:50:16 -0700546 ATRACE_CALL();
547
Matthew Bouyack7f667e72016-01-12 12:01:48 -0800548 nsecs_t vsync = mRenderThread.timeLord().computeFrameTimeNanos();
John Reckba6adf62015-02-19 14:36:50 -0800549 int64_t frameInfo[UI_THREAD_FRAME_INFO_SIZE];
John Reck1bcacfd2017-11-03 10:12:19 -0700550 UiFrameInfoBuilder(frameInfo).addFlag(FrameInfoFlags::RTAnimation).setVsync(vsync, vsync);
John Reckfe5e7b72014-05-23 17:42:28 -0700551
Chris Craike2e53a72015-10-28 15:55:40 -0700552 TreeInfo info(TreeInfo::MODE_RT_ONLY, *this);
Skuhneea7a7fb2015-08-28 07:10:31 -0700553 prepareTree(info, frameInfo, systemTime(CLOCK_MONOTONIC), node);
John Recka5dda642014-05-22 15:43:54 -0700554 if (info.out.canDrawThisFrame) {
John Recke4267ea2014-06-03 15:53:15 -0700555 draw();
Chris Craik06e2e9c2016-08-31 17:32:46 -0700556 } else {
557 // wait on fences so tasks don't overlap next frame
558 waitOnFences();
John Recka5dda642014-05-22 15:43:54 -0700559 }
John Recke45b1fd2014-04-15 09:50:16 -0700560}
561
John Reck998a6d82014-08-28 15:35:53 -0700562void CanvasContext::markLayerInUse(RenderNode* node) {
John Reck51f2d602016-04-06 07:50:47 -0700563 if (mPrefetchedLayers.erase(node)) {
Chris Craikd41c4d82015-01-05 15:51:13 -0800564 node->decStrong(nullptr);
John Reck998a6d82014-08-28 15:35:53 -0700565 }
566}
567
John Reck2de950d2017-01-25 10:58:30 -0800568void CanvasContext::freePrefetchedLayers() {
John Reck51f2d602016-04-06 07:50:47 -0700569 if (mPrefetchedLayers.size()) {
570 for (auto& node : mPrefetchedLayers) {
571 ALOGW("Incorrectly called buildLayer on View: %s, destroying layer...",
John Reck1bcacfd2017-11-03 10:12:19 -0700572 node->getName());
John Reck2de950d2017-01-25 10:58:30 -0800573 node->destroyLayers();
574 node->decStrong(nullptr);
John Reck51f2d602016-04-06 07:50:47 -0700575 }
576 mPrefetchedLayers.clear();
John Reck998a6d82014-08-28 15:35:53 -0700577 }
578}
579
John Reck2de950d2017-01-25 10:58:30 -0800580void CanvasContext::buildLayer(RenderNode* node) {
John Reck3e824952014-08-20 10:08:39 -0700581 ATRACE_CALL();
Stan Iliev768e3932016-07-08 21:34:52 -0400582 if (!mRenderPipeline->isContextReady()) return;
Chris Craik6246d2782016-03-29 15:01:41 -0700583
John Reck3e824952014-08-20 10:08:39 -0700584 // buildLayer() will leave the tree in an unknown state, so we must stop drawing
585 stopDrawing();
586
Chris Craike2e53a72015-10-28 15:55:40 -0700587 TreeInfo info(TreeInfo::MODE_FULL, *this);
John Reck3e824952014-08-20 10:08:39 -0700588 info.damageAccumulator = &mDamageAccumulator;
Chris Craik0b7e8242015-10-28 16:50:44 -0700589 info.layerUpdateQueue = &mLayerUpdateQueue;
John Reck9eb9f6f2014-08-21 11:23:05 -0700590 info.runAnimations = false;
John Reck3e824952014-08-20 10:08:39 -0700591 node->prepareTree(info);
592 SkRect ignore;
593 mDamageAccumulator.finish(&ignore);
594 // Tickle the GENERIC property on node to mark it as dirty for damaging
595 // purposes when the frame is actually drawn
596 node->setPropertyFieldsDirty(RenderNode::GENERIC);
597
Peiyong Lin1f6aa122018-09-10 16:28:08 -0700598 mRenderPipeline->renderLayers(mLightGeometry, &mLayerUpdateQueue, mOpaque, mLightInfo);
John Reck998a6d82014-08-28 15:35:53 -0700599
Chris Craikd41c4d82015-01-05 15:51:13 -0800600 node->incStrong(nullptr);
John Reck51f2d602016-04-06 07:50:47 -0700601 mPrefetchedLayers.insert(node);
John Reck3e824952014-08-20 10:08:39 -0700602}
603
John Reck2de950d2017-01-25 10:58:30 -0800604void CanvasContext::destroyHardwareResources() {
John Reckf47a5942014-06-30 16:20:04 -0700605 stopDrawing();
Stan Iliev768e3932016-07-08 21:34:52 -0400606 if (mRenderPipeline->isContextReady()) {
John Reck2de950d2017-01-25 10:58:30 -0800607 freePrefetchedLayers();
Skuhneea7a7fb2015-08-28 07:10:31 -0700608 for (const sp<RenderNode>& node : mRenderNodes) {
John Reck2de950d2017-01-25 10:58:30 -0800609 node->destroyHardwareResources();
Skuhneea7a7fb2015-08-28 07:10:31 -0700610 }
Stan Iliev768e3932016-07-08 21:34:52 -0400611 mRenderPipeline->onDestroyHardwareResources();
John Reckf47a5942014-06-30 16:20:04 -0700612 }
613}
614
615void CanvasContext::trimMemory(RenderThread& thread, int level) {
John Reck18f442e2018-04-09 16:56:34 -0700616 ATRACE_CALL();
617 if (!thread.getGrContext()) return;
618 ATRACE_CALL();
619 if (level >= TRIM_MEMORY_COMPLETE) {
620 thread.cacheManager().trimMemory(CacheManager::TrimMemoryMode::Complete);
John Reck283bb462018-12-13 16:40:14 -0800621 thread.destroyRenderingContext();
John Reck18f442e2018-04-09 16:56:34 -0700622 } else if (level >= TRIM_MEMORY_UI_HIDDEN) {
623 thread.cacheManager().trimMemory(CacheManager::TrimMemoryMode::UiHidden);
John Recke1628b72014-05-23 15:11:19 -0700624 }
625}
626
Derek Sollenberger56ad6ec2016-07-22 12:13:32 -0400627DeferredLayerUpdater* CanvasContext::createTextureLayer() {
Stan Iliev768e3932016-07-08 21:34:52 -0400628 return mRenderPipeline->createTextureLayer();
John Reck1949e792014-04-08 15:18:56 -0700629}
630
John Reckba6adf62015-02-19 14:36:50 -0800631void CanvasContext::dumpFrames(int fd) {
John Reck34781b22017-07-05 16:39:36 -0700632 mJankTracker.dumpStats(fd);
633 mJankTracker.dumpFrames(fd);
John Reckba6adf62015-02-19 14:36:50 -0800634}
635
636void CanvasContext::resetFrameStats() {
John Reck34781b22017-07-05 16:39:36 -0700637 mJankTracker.reset();
John Reckba6adf62015-02-19 14:36:50 -0800638}
639
John Reckdf1742e2017-01-19 15:56:21 -0800640void CanvasContext::setName(const std::string&& name) {
641 mJankTracker.setDescription(JankTrackerType::Window, std::move(name));
642}
643
John Reck38f6c032016-03-17 10:23:49 -0700644void CanvasContext::waitOnFences() {
645 if (mFrameFences.size()) {
646 ATRACE_CALL();
647 for (auto& fence : mFrameFences) {
John Reck322b8ab2019-03-14 13:15:28 -0700648 fence.get();
John Reck38f6c032016-03-17 10:23:49 -0700649 }
650 mFrameFences.clear();
651 }
652}
653
John Reck38f6c032016-03-17 10:23:49 -0700654void CanvasContext::enqueueFrameWork(std::function<void()>&& func) {
John Reck322b8ab2019-03-14 13:15:28 -0700655 mFrameFences.push_back(CommonPool::async(std::move(func)));
John Reck38f6c032016-03-17 10:23:49 -0700656}
657
John Reck28912a52016-04-18 14:34:18 -0700658int64_t CanvasContext::getFrameNumber() {
659 // mFrameNumber is reset to -1 when the surface changes or we swap buffers
660 if (mFrameNumber == -1 && mNativeSurface.get()) {
661 mFrameNumber = static_cast<int64_t>(mNativeSurface->getNextFrameNumber());
662 }
663 return mFrameNumber;
664}
665
John Reck0b19a732019-03-07 17:18:25 -0800666bool CanvasContext::surfaceRequiresRedraw() {
667 if (!mNativeSurface) return false;
668 if (mHaveNewSurface) return true;
669
670 int width = -1;
671 int height = -1;
672 ReliableSurface* surface = mNativeSurface.get();
673 surface->query(NATIVE_WINDOW_WIDTH, &width);
674 surface->query(NATIVE_WINDOW_HEIGHT, &height);
675
676 return width == mLastFrameWidth && height == mLastFrameHeight;
677}
678
John Reckcf185f52019-04-11 16:11:24 -0700679void CanvasContext::setRenderAheadDepth(int renderAhead) {
680 if (renderAhead > 2 || renderAhead < 0 || mNativeSurface) {
John Reck4d527222019-03-13 16:25:20 -0700681 return;
682 }
John Reckcf185f52019-04-11 16:11:24 -0700683 mFixedRenderAhead = true;
684 mRenderAheadDepth = static_cast<uint32_t>(renderAhead);
John Reck4d527222019-03-13 16:25:20 -0700685}
686
Stan Iliev768e3932016-07-08 21:34:52 -0400687SkRect CanvasContext::computeDirtyRect(const Frame& frame, SkRect* dirty) {
688 if (frame.width() != mLastFrameWidth || frame.height() != mLastFrameHeight) {
689 // can't rely on prior content of window if viewport size changes
690 dirty->setEmpty();
691 mLastFrameWidth = frame.width();
692 mLastFrameHeight = frame.height();
693 } else if (mHaveNewSurface || frame.bufferAge() == 0) {
694 // New surface needs a full draw
695 dirty->setEmpty();
696 } else {
697 if (!dirty->isEmpty() && !dirty->intersect(0, 0, frame.width(), frame.height())) {
John Reck1bcacfd2017-11-03 10:12:19 -0700698 ALOGW("Dirty " RECT_STRING " doesn't intersect with 0 0 %d %d ?", SK_RECT_ARGS(*dirty),
699 frame.width(), frame.height());
Stan Iliev768e3932016-07-08 21:34:52 -0400700 dirty->setEmpty();
701 }
702 profiler().unionDirty(dirty);
703 }
704
705 if (dirty->isEmpty()) {
706 dirty->set(0, 0, frame.width(), frame.height());
707 }
708
709 // At this point dirty is the area of the window to update. However,
710 // the area of the frame we need to repaint is potentially different, so
711 // stash the screen area for later
712 SkRect windowDirty(*dirty);
713
714 // If the buffer age is 0 we do a full-screen repaint (handled above)
715 // If the buffer age is 1 the buffer contents are the same as they were
716 // last frame so there's nothing to union() against
717 // Therefore we only care about the > 1 case.
718 if (frame.bufferAge() > 1) {
John Reck1bcacfd2017-11-03 10:12:19 -0700719 if (frame.bufferAge() > (int)mSwapHistory.size()) {
Stan Iliev768e3932016-07-08 21:34:52 -0400720 // We don't have enough history to handle this old of a buffer
721 // Just do a full-draw
722 dirty->set(0, 0, frame.width(), frame.height());
723 } else {
724 // At this point we haven't yet added the latest frame
725 // to the damage history (happens below)
726 // So we need to damage
727 for (int i = mSwapHistory.size() - 1;
John Reck1bcacfd2017-11-03 10:12:19 -0700728 i > ((int)mSwapHistory.size()) - frame.bufferAge(); i--) {
Stan Iliev768e3932016-07-08 21:34:52 -0400729 dirty->join(mSwapHistory[i].damage);
730 }
731 }
732 }
733
734 return windowDirty;
735}
736
John Reck23b797a2014-01-03 18:08:34 -0800737} /* namespace renderthread */
738} /* namespace uirenderer */
739} /* namespace android */