blob: bb0b1352c360ad2cf29b9894e30be1a8dafcfb56 [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"
Alec Mouri8d451742019-08-01 19:19:16 -070018
Alec Mouri8d451742019-08-01 19:19:16 -070019#include <apex/window.h>
20#include <fcntl.h>
21#include <strings.h>
22#include <sys/stat.h>
23
24#include <algorithm>
25#include <cstdint>
26#include <cstdlib>
27#include <functional>
John Reck23b797a2014-01-03 18:08:34 -080028
rnleece9762b2021-05-21 15:40:53 -070029#include <gui/TraceUtils.h>
John Reck0fa0cbc2019-04-05 16:57:46 -070030#include "../Properties.h"
John Reckd04794a2015-05-08 10:04:36 -070031#include "AnimationContext.h"
Greg Danielcd558522016-11-17 13:31:40 -050032#include "Frame.h"
Chris Craik5e00c7c2016-07-06 16:10:09 -070033#include "LayerUpdateQueue.h"
John Reckd04794a2015-05-08 10:04:36 -070034#include "Properties.h"
John Reck4f02bf42014-01-03 18:09:17 -080035#include "RenderThread.h"
sergeyvdccca442016-03-21 15:38:21 -070036#include "hwui/Canvas.h"
Stan Iliev500a0c32016-10-26 10:30:09 -040037#include "pipeline/skia/SkiaOpenGLPipeline.h"
38#include "pipeline/skia/SkiaPipeline.h"
39#include "pipeline/skia/SkiaVulkanPipeline.h"
John Reck322b8ab2019-03-14 13:15:28 -070040#include "thread/CommonPool.h"
John Reck9372ac32016-01-19 11:46:52 -080041#include "utils/GLUtils.h"
John Recke486d932015-10-28 09:21:19 -070042#include "utils/TimeUtils.h"
John Recke248bd12015-08-05 13:53:53 -070043
John Reckf47a5942014-06-30 16:20:04 -070044#define TRIM_MEMORY_COMPLETE 80
45#define TRIM_MEMORY_UI_HIDDEN 20
46
John Reck149173d2015-08-10 09:52:29 -070047#define LOG_FRAMETIME_MMA 0
48
49#if LOG_FRAMETIME_MMA
50static float sBenchMma = 0;
51static int sFrameCount = 0;
52static const float NANOS_PER_MILLIS_F = 1000000.0f;
53#endif
54
John Reck23b797a2014-01-03 18:08:34 -080055namespace android {
56namespace uirenderer {
57namespace renderthread {
58
Huihong Luo054b8d32021-02-24 18:48:12 -080059namespace {
60class ScopedActiveContext {
61public:
62 ScopedActiveContext(CanvasContext* context) { sActiveContext = context; }
63
64 ~ScopedActiveContext() { sActiveContext = nullptr; }
65
66 static CanvasContext* getActiveContext() { return sActiveContext; }
67
68private:
69 static CanvasContext* sActiveContext;
70};
71
72CanvasContext* ScopedActiveContext::sActiveContext = nullptr;
73} /* namespace */
74
John Reck1bcacfd2017-11-03 10:12:19 -070075CanvasContext* CanvasContext::create(RenderThread& thread, bool translucent,
76 RenderNode* rootRenderNode, IContextFactory* contextFactory) {
Stan Iliev03de0742016-07-07 12:35:54 -040077 auto renderType = Properties::getRenderPipelineType();
Stan Iliev768e3932016-07-08 21:34:52 -040078
Stan Iliev03de0742016-07-07 12:35:54 -040079 switch (renderType) {
Stan Iliev03de0742016-07-07 12:35:54 -040080 case RenderPipelineType::SkiaGL:
Stan Iliev500a0c32016-10-26 10:30:09 -040081 return new CanvasContext(thread, translucent, rootRenderNode, contextFactory,
John Reck1bcacfd2017-11-03 10:12:19 -070082 std::make_unique<skiapipeline::SkiaOpenGLPipeline>(thread));
Stan Iliev8a33e402016-07-08 09:57:49 -040083 case RenderPipelineType::SkiaVulkan:
Stan Iliev500a0c32016-10-26 10:30:09 -040084 return new CanvasContext(thread, translucent, rootRenderNode, contextFactory,
John Reck1bcacfd2017-11-03 10:12:19 -070085 std::make_unique<skiapipeline::SkiaVulkanPipeline>(thread));
Stan Iliev03de0742016-07-07 12:35:54 -040086 default:
John Reck1bcacfd2017-11-03 10:12:19 -070087 LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t)renderType);
Stan Iliev03de0742016-07-07 12:35:54 -040088 break;
89 }
90 return nullptr;
91}
92
Derek Sollenbergerdaf72292016-10-25 12:09:18 -040093void CanvasContext::invokeFunctor(const RenderThread& thread, Functor* functor) {
94 ATRACE_CALL();
95 auto renderType = Properties::getRenderPipelineType();
96 switch (renderType) {
Stan Iliev500a0c32016-10-26 10:30:09 -040097 case RenderPipelineType::SkiaGL:
98 skiapipeline::SkiaOpenGLPipeline::invokeFunctor(thread, functor);
99 break;
100 case RenderPipelineType::SkiaVulkan:
101 skiapipeline::SkiaVulkanPipeline::invokeFunctor(thread, functor);
102 break;
Derek Sollenbergerdaf72292016-10-25 12:09:18 -0400103 default:
John Reck1bcacfd2017-11-03 10:12:19 -0700104 LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t)renderType);
Derek Sollenbergerdaf72292016-10-25 12:09:18 -0400105 break;
106 }
107}
108
109void CanvasContext::prepareToDraw(const RenderThread& thread, Bitmap* bitmap) {
John Reck18f442e2018-04-09 16:56:34 -0700110 skiapipeline::SkiaPipeline::prepareToDraw(thread, bitmap);
Derek Sollenbergerdaf72292016-10-25 12:09:18 -0400111}
112
John Reck1bcacfd2017-11-03 10:12:19 -0700113CanvasContext::CanvasContext(RenderThread& thread, bool translucent, RenderNode* rootRenderNode,
114 IContextFactory* contextFactory,
115 std::unique_ptr<IRenderPipeline> renderPipeline)
John Reck3b202512014-06-23 13:13:08 -0700116 : mRenderThread(thread)
Leon Scroggins III4afdd1c2018-05-14 14:59:30 -0400117 , mGenerationID(0)
John Reck4f02bf42014-01-03 18:09:17 -0800118 , mOpaque(!translucent)
Chris Craik51d6a3d2014-12-22 17:16:56 -0800119 , mAnimationContext(contextFactory->createAnimationContext(mRenderThread.timeLord()))
Alec Mouri22d753f2019-09-05 17:11:45 -0700120 , mJankTracker(&thread.globalProfileData())
John Reck3c0f5632019-03-15 16:36:01 -0700121 , mProfiler(mJankTracker.frames(), thread.timeLord().frameIntervalNanos())
Stan Iliev768e3932016-07-08 21:34:52 -0400122 , mContentDrawBounds(0, 0, 0, 0)
123 , mRenderPipeline(std::move(renderPipeline)) {
John Reck2de950d2017-01-25 10:58:30 -0800124 rootRenderNode->makeRoot();
Skuhneea7a7fb2015-08-28 07:10:31 -0700125 mRenderNodes.emplace_back(rootRenderNode);
Alec Mouri22d753f2019-09-05 17:11:45 -0700126 mProfiler.setDensity(DeviceInfo::getDensity());
John Reck23b797a2014-01-03 18:08:34 -0800127}
128
129CanvasContext::~CanvasContext() {
John Reck2de950d2017-01-25 10:58:30 -0800130 destroy();
John Reck2de950d2017-01-25 10:58:30 -0800131 for (auto& node : mRenderNodes) {
132 node->clearRoot();
133 }
134 mRenderNodes.clear();
John Reck4f02bf42014-01-03 18:09:17 -0800135}
136
John Reck2de950d2017-01-25 10:58:30 -0800137void CanvasContext::addRenderNode(RenderNode* node, bool placeFront) {
138 int pos = placeFront ? 0 : static_cast<int>(mRenderNodes.size());
139 node->makeRoot();
140 mRenderNodes.emplace(mRenderNodes.begin() + pos, node);
141}
142
143void CanvasContext::removeRenderNode(RenderNode* node) {
144 node->clearRoot();
145 mRenderNodes.erase(std::remove(mRenderNodes.begin(), mRenderNodes.end(), node),
John Reck1bcacfd2017-11-03 10:12:19 -0700146 mRenderNodes.end());
John Reck2de950d2017-01-25 10:58:30 -0800147}
148
149void CanvasContext::destroy() {
John Reck17035b02014-09-03 07:39:53 -0700150 stopDrawing();
Chris Craikd41c4d82015-01-05 15:51:13 -0800151 setSurface(nullptr);
Huihong Luo5fdf7b82021-01-15 14:27:06 -0800152 setSurfaceControl(nullptr);
John Reck2de950d2017-01-25 10:58:30 -0800153 freePrefetchedLayers();
154 destroyHardwareResources();
John Recke2478d42014-09-03 16:46:05 -0700155 mAnimationContext->destroy();
John Reck23b797a2014-01-03 18:08:34 -0800156}
157
John Reckfbe14bb2020-09-21 14:37:41 -0700158static void setBufferCount(ANativeWindow* window) {
John Reck8ddbc592020-05-07 16:11:18 -0700159 int query_value;
160 int err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &query_value);
161 if (err != 0 || query_value < 0) {
162 ALOGE("window->query failed: %s (%d) value=%d", strerror(-err), err, query_value);
163 return;
164 }
165 auto min_undequeued_buffers = static_cast<uint32_t>(query_value);
166
John Reckfbe14bb2020-09-21 14:37:41 -0700167 // We only need to set min_undequeued + 2 because the renderahead amount was already factored into the
168 // query for min_undequeued
169 int bufferCount = min_undequeued_buffers + 2;
John Reck8ddbc592020-05-07 16:11:18 -0700170 native_window_set_buffer_count(window, bufferCount);
171}
172
Alec Mouri43fe6fc2019-12-23 07:46:19 -0800173void CanvasContext::setSurface(ANativeWindow* window, bool enableTimeout) {
John Reckfbc8df02014-11-14 16:18:41 -0800174 ATRACE_CALL();
175
John Reck8ddbc592020-05-07 16:11:18 -0700176 if (window) {
177 mNativeSurface = std::make_unique<ReliableSurface>(window);
178 mNativeSurface->init();
179 if (enableTimeout) {
180 // TODO: Fix error handling & re-shorten timeout
181 ANativeWindow_setDequeueTimeout(window, 4000_ms);
182 }
John Reck8ddbc592020-05-07 16:11:18 -0700183 } else {
184 mNativeSurface = nullptr;
185 }
John Reckb36bfdd2020-07-23 13:47:49 -0700186 setupPipelineSurface();
187}
John Reck8ddbc592020-05-07 16:11:18 -0700188
Huihong Luo5fdf7b82021-01-15 14:27:06 -0800189void CanvasContext::setSurfaceControl(ASurfaceControl* surfaceControl) {
190 if (surfaceControl == mSurfaceControl) return;
191
192 auto funcs = mRenderThread.getASurfaceControlFunctions();
Jorim Jaggi71db8892021-02-03 23:19:29 +0100193
Huihong Luoe76f1812021-05-06 10:28:12 -0700194 if (surfaceControl == nullptr) {
195 setASurfaceTransactionCallback(nullptr);
Huihong Luo34f42fd2021-05-03 14:47:36 -0700196 setPrepareSurfaceControlForWebviewCallback(nullptr);
Huihong Luoe76f1812021-05-06 10:28:12 -0700197 }
198
Huihong Luo5fdf7b82021-01-15 14:27:06 -0800199 if (mSurfaceControl != nullptr) {
Jorim Jaggi71db8892021-02-03 23:19:29 +0100200 funcs.unregisterListenerFunc(this, &onSurfaceStatsAvailable);
Huihong Luo5fdf7b82021-01-15 14:27:06 -0800201 funcs.releaseFunc(mSurfaceControl);
202 }
203 mSurfaceControl = surfaceControl;
Huihong Luo540fdf82021-06-25 13:59:39 -0700204 mSurfaceControlGenerationId++;
Jorim Jaggi71db8892021-02-03 23:19:29 +0100205 mExpectSurfaceStats = surfaceControl != nullptr;
Huihong Luo5fdf7b82021-01-15 14:27:06 -0800206 if (mSurfaceControl != nullptr) {
207 funcs.acquireFunc(mSurfaceControl);
Jorim Jaggi71db8892021-02-03 23:19:29 +0100208 funcs.registerListenerFunc(surfaceControl, this, &onSurfaceStatsAvailable);
Huihong Luo5fdf7b82021-01-15 14:27:06 -0800209 }
210}
211
John Reckb36bfdd2020-07-23 13:47:49 -0700212void CanvasContext::setupPipelineSurface() {
Alec Mourif023a322019-11-25 10:02:21 -0800213 bool hasSurface = mRenderPipeline->setSurface(
John Reck8ddbc592020-05-07 16:11:18 -0700214 mNativeSurface ? mNativeSurface->getNativeWindow() : nullptr, mSwapBehavior);
215
216 if (mNativeSurface && !mNativeSurface->didSetExtraBuffers()) {
John Reckfbe14bb2020-09-21 14:37:41 -0700217 setBufferCount(mNativeSurface->getNativeWindow());
218
John Reck8ddbc592020-05-07 16:11:18 -0700219 }
John Reck23b797a2014-01-03 18:08:34 -0800220
John Reck28912a52016-04-18 14:34:18 -0700221 mFrameNumber = -1;
222
John Reckb36bfdd2020-07-23 13:47:49 -0700223 if (mNativeSurface != nullptr && hasSurface) {
John Reck1bcacfd2017-11-03 10:12:19 -0700224 mHaveNewSurface = true;
225 mSwapHistory.clear();
Stan Iliev10689992019-11-13 10:25:22 -0500226 // Enable frame stats after the surface has been bound to the appropriate graphics API.
227 // Order is important when new and old surfaces are the same, because old surface has
228 // its frame stats disabled automatically.
Alec Mouriff07c8f2019-12-11 16:32:22 -0800229 native_window_enable_frame_timestamps(mNativeSurface->getNativeWindow(), true);
John Reck368cdd82014-05-07 13:11:00 -0700230 } else {
John Reck1bcacfd2017-11-03 10:12:19 -0700231 mRenderThread.removeFrameCallback(this);
Leon Scroggins III4afdd1c2018-05-14 14:59:30 -0400232 mGenerationID++;
John Reck23b797a2014-01-03 18:08:34 -0800233 }
John Reck23b797a2014-01-03 18:08:34 -0800234}
235
John Reck1125d1f2014-10-23 11:02:19 -0700236void CanvasContext::setSwapBehavior(SwapBehavior swapBehavior) {
237 mSwapBehavior = swapBehavior;
238}
239
John Reckf8441e62017-10-23 13:10:41 -0700240bool CanvasContext::pauseSurface() {
Leon Scroggins III4afdd1c2018-05-14 14:59:30 -0400241 mGenerationID++;
John Reck01a5ea32014-12-03 13:01:07 -0800242 return mRenderThread.removeFrameCallback(this);
John Reck4f02bf42014-01-03 18:09:17 -0800243}
244
John Reck8afcc762016-04-13 10:24:06 -0700245void CanvasContext::setStopped(bool stopped) {
246 if (mStopped != stopped) {
247 mStopped = stopped;
248 if (mStopped) {
Leon Scroggins III4afdd1c2018-05-14 14:59:30 -0400249 mGenerationID++;
John Reck8afcc762016-04-13 10:24:06 -0700250 mRenderThread.removeFrameCallback(this);
Stan Iliev768e3932016-07-08 21:34:52 -0400251 mRenderPipeline->onStop();
John Reck306f3312016-06-10 16:01:55 -0700252 } else if (mIsDirty && hasSurface()) {
253 mRenderThread.postFrameCallback(this);
John Reck8afcc762016-04-13 10:24:06 -0700254 }
255 }
256}
257
John Reck8785ceb2018-10-29 16:45:58 -0700258void CanvasContext::allocateBuffers() {
Brett Chabot856db9e2021-05-21 08:41:58 -0700259 if (mNativeSurface && Properties::isDrawingEnabled()) {
Alec Mouric9d5f3d2020-02-13 13:58:25 -0800260 ANativeWindow_tryAllocateBuffers(mNativeSurface->getNativeWindow());
John Reck8785ceb2018-10-29 16:45:58 -0700261 }
262}
263
264void CanvasContext::setLightAlpha(uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha) {
Chris Craik98787e62015-11-13 10:55:30 -0800265 mLightInfo.ambientShadowAlpha = ambientShadowAlpha;
266 mLightInfo.spotShadowAlpha = spotShadowAlpha;
Alan Viverette50210d92015-05-14 18:05:36 -0700267}
268
John Reck8785ceb2018-10-29 16:45:58 -0700269void CanvasContext::setLightGeometry(const Vector3& lightCenter, float lightRadius) {
Chris Craik6e068c012016-01-15 16:15:30 -0800270 mLightGeometry.center = lightCenter;
John Reck8785ceb2018-10-29 16:45:58 -0700271 mLightGeometry.radius = lightRadius;
John Reck4f02bf42014-01-03 18:09:17 -0800272}
273
John Reck63a06672014-05-07 13:45:54 -0700274void CanvasContext::setOpaque(bool opaque) {
275 mOpaque = opaque;
276}
277
John Reckb36bfdd2020-07-23 13:47:49 -0700278void CanvasContext::setColorMode(ColorMode mode) {
279 mRenderPipeline->setSurfaceColorProperties(mode);
280 setupPipelineSurface();
Romain Guy26a2b972017-04-17 09:39:51 -0700281}
282
John Reck8afcc762016-04-13 10:24:06 -0700283bool CanvasContext::makeCurrent() {
284 if (mStopped) return false;
285
Stan Iliev768e3932016-07-08 21:34:52 -0400286 auto result = mRenderPipeline->makeCurrent();
287 switch (result) {
288 case MakeCurrentResult::AlreadyCurrent:
289 return true;
290 case MakeCurrentResult::Failed:
291 mHaveNewSurface = true;
292 setSurface(nullptr);
293 return false;
294 case MakeCurrentResult::Succeeded:
295 mHaveNewSurface = true;
296 return true;
297 default:
298 LOG_ALWAYS_FATAL("unexpected result %d from IRenderPipeline::makeCurrent",
John Reck1bcacfd2017-11-03 10:12:19 -0700299 (int32_t)result);
John Reckf2dcc2a2015-07-16 09:17:59 -0700300 }
Stan Iliev768e3932016-07-08 21:34:52 -0400301
302 return true;
John Reck860d1552014-04-11 19:15:05 -0700303}
304
John Reckbf3c6022015-06-02 15:55:00 -0700305static bool wasSkipped(FrameInfo* info) {
Chris Craik1b54fb22015-06-02 17:40:58 -0700306 return info && ((*info)[FrameInfoIndex::Flags] & FrameInfoFlags::SkippedFrame);
John Reckbf3c6022015-06-02 15:55:00 -0700307}
308
John Reck0def73a2016-07-01 16:19:13 -0700309bool CanvasContext::isSwapChainStuffed() {
John Recka3d795a2016-07-27 19:28:05 -0700310 static const auto SLOW_THRESHOLD = 6_ms;
311
John Reck0def73a2016-07-01 16:19:13 -0700312 if (mSwapHistory.size() != mSwapHistory.capacity()) {
313 // We want at least 3 frames of history before attempting to
314 // guess if the queue is stuffed
315 return false;
316 }
317 nsecs_t frameInterval = mRenderThread.timeLord().frameIntervalNanos();
318 auto& swapA = mSwapHistory[0];
319
320 // Was there a happy queue & dequeue time? If so, don't
321 // consider it stuffed
John Reck1bcacfd2017-11-03 10:12:19 -0700322 if (swapA.dequeueDuration < SLOW_THRESHOLD && swapA.queueDuration < SLOW_THRESHOLD) {
John Reck0def73a2016-07-01 16:19:13 -0700323 return false;
324 }
325
326 for (size_t i = 1; i < mSwapHistory.size(); i++) {
327 auto& swapB = mSwapHistory[i];
328
Chris Craik31635682016-07-19 17:59:12 -0700329 // If there's a multi-frameInterval gap we effectively already dropped a frame,
John Reck0def73a2016-07-01 16:19:13 -0700330 // so consider the queue healthy.
Yu Jiae57493a2018-05-30 11:18:05 +0800331 if (std::abs(swapA.swapCompletedTime - swapB.swapCompletedTime) > frameInterval * 3) {
John Reck0def73a2016-07-01 16:19:13 -0700332 return false;
333 }
334
335 // Was there a happy queue & dequeue time? If so, don't
336 // consider it stuffed
John Reck1bcacfd2017-11-03 10:12:19 -0700337 if (swapB.dequeueDuration < SLOW_THRESHOLD && swapB.queueDuration < SLOW_THRESHOLD) {
John Reck0def73a2016-07-01 16:19:13 -0700338 return false;
339 }
340
341 swapA = swapB;
342 }
343
344 // All signs point to a stuffed swap chain
Tim Murrayffde62742016-07-18 14:11:28 -0700345 ATRACE_NAME("swap chain stuffed");
John Reck0def73a2016-07-01 16:19:13 -0700346 return true;
347}
348
John Reck1bcacfd2017-11-03 10:12:19 -0700349void CanvasContext::prepareTree(TreeInfo& info, int64_t* uiFrameInfo, int64_t syncQueued,
350 RenderNode* target) {
John Reckf9be7792014-05-02 18:21:16 -0700351 mRenderThread.removeFrameCallback(this);
John Reck18f16e62014-05-02 16:46:41 -0700352
John Reckbf3c6022015-06-02 15:55:00 -0700353 // If the previous frame was dropped we don't need to hold onto it, so
354 // just keep using the previous frame's structure instead
355 if (!wasSkipped(mCurrentFrameInfo)) {
John Reck34781b22017-07-05 16:39:36 -0700356 mCurrentFrameInfo = mJankTracker.startFrame();
John Reckbf3c6022015-06-02 15:55:00 -0700357 }
Jorim Jaggi71db8892021-02-03 23:19:29 +0100358
John Reckba6adf62015-02-19 14:36:50 -0800359 mCurrentFrameInfo->importUiThreadInfo(uiFrameInfo);
John Reckbe3fba02015-07-06 13:49:58 -0700360 mCurrentFrameInfo->set(FrameInfoIndex::SyncQueued) = syncQueued;
John Reckba6adf62015-02-19 14:36:50 -0800361 mCurrentFrameInfo->markSyncStart();
362
John Recke4267ea2014-06-03 15:53:15 -0700363 info.damageAccumulator = &mDamageAccumulator;
Chris Craik0b7e8242015-10-28 16:50:44 -0700364 info.layerUpdateQueue = &mLayerUpdateQueue;
John Reck41459192019-10-31 15:04:58 -0700365 info.damageGenerationId = mDamageId++;
John Reck848f6512018-12-03 13:26:43 -0800366 info.out.canDrawThisFrame = true;
John Reck00e79c92015-07-21 10:23:59 -0700367
John Reckec845a22014-09-05 15:23:38 -0700368 mAnimationContext->startFrame(info.mode);
John Reck0fa0cbc2019-04-05 16:57:46 -0700369 for (const sp<RenderNode>& node : mRenderNodes) {
Skuhneea7a7fb2015-08-28 07:10:31 -0700370 // Only the primary target node will be drawn full - all other nodes would get drawn in
371 // real time mode. In case of a window, the primary node is the window content and the other
372 // node(s) are non client / filler nodes.
373 info.mode = (node.get() == target ? TreeInfo::MODE_FULL : TreeInfo::MODE_RT_ONLY);
374 node->prepareTree(info);
John Reck975591a2016-01-22 16:28:07 -0800375 GL_CHECKPOINT(MODERATE);
Skuhneea7a7fb2015-08-28 07:10:31 -0700376 }
John Reck119907c2014-08-14 09:02:01 -0700377 mAnimationContext->runRemainingAnimations(info);
John Reck975591a2016-01-22 16:28:07 -0800378 GL_CHECKPOINT(MODERATE);
John Recke45b1fd2014-04-15 09:50:16 -0700379
John Reck2de950d2017-01-25 10:58:30 -0800380 freePrefetchedLayers();
John Reck975591a2016-01-22 16:28:07 -0800381 GL_CHECKPOINT(MODERATE);
John Reck998a6d82014-08-28 15:35:53 -0700382
John Reck306f3312016-06-10 16:01:55 -0700383 mIsDirty = true;
384
John Reck848f6512018-12-03 13:26:43 -0800385 if (CC_UNLIKELY(!hasSurface())) {
Chris Craik1b54fb22015-06-02 17:40:58 -0700386 mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
John Reckaa95a882014-11-07 11:02:07 -0800387 info.out.canDrawThisFrame = false;
388 return;
389 }
390
John Reckf1480762016-07-03 18:28:25 -0700391 if (CC_LIKELY(mSwapHistory.size() && !Properties::forceDrawFrame)) {
John Recke486d932015-10-28 09:21:19 -0700392 nsecs_t latestVsync = mRenderThread.timeLord().latestVsync();
John Reck0fa0cbc2019-04-05 16:57:46 -0700393 SwapHistory& lastSwap = mSwapHistory.back();
John Reck52b783f2015-11-24 11:12:55 -0800394 nsecs_t vsyncDelta = std::abs(lastSwap.vsyncTime - latestVsync);
John Recke486d932015-10-28 09:21:19 -0700395 // The slight fudge-factor is to deal with cases where
396 // the vsync was estimated due to being slow handling the signal.
397 // See the logic in TimeLord#computeFrameTimeNanos or in
398 // Choreographer.java for details on when this happens
399 if (vsyncDelta < 2_ms) {
400 // Already drew for this vsync pulse, UI draw request missed
401 // the deadline for RT animations
402 info.out.canDrawThisFrame = false;
John Reck6f75da02018-03-21 14:43:40 -0700403 }
Bo Hudd082242018-12-02 05:22:41 +0000404 } else {
405 info.out.canDrawThisFrame = true;
John Recke486d932015-10-28 09:21:19 -0700406 }
John Recka5dda642014-05-22 15:43:54 -0700407
John Reckcc2eee82018-05-17 10:44:00 -0700408 // TODO: Do we need to abort out if the backdrop is added but not ready? Should that even
409 // be an allowable combination?
410 if (mRenderNodes.size() > 2 && !mRenderNodes[1]->isRenderable()) {
411 info.out.canDrawThisFrame = false;
412 }
413
John Reck848f6512018-12-03 13:26:43 -0800414 if (info.out.canDrawThisFrame) {
415 int err = mNativeSurface->reserveNext();
416 if (err != OK) {
417 mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
418 info.out.canDrawThisFrame = false;
419 ALOGW("reserveNext failed, error = %d (%s)", err, strerror(-err));
420 if (err != TIMED_OUT) {
421 // A timed out surface can still recover, but assume others are permanently dead.
422 setSurface(nullptr);
423 return;
424 }
425 }
426 } else {
Chris Craik1b54fb22015-06-02 17:40:58 -0700427 mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
John Reckaef9dc82015-05-08 14:10:57 -0700428 }
429
Leon Scroggins III4afdd1c2018-05-14 14:59:30 -0400430 bool postedFrameCallback = false;
John Recka5dda642014-05-22 15:43:54 -0700431 if (info.out.hasAnimations || !info.out.canDrawThisFrame) {
John Reck9f516442017-09-25 10:27:21 -0700432 if (CC_UNLIKELY(!Properties::enableRTAnimations)) {
433 info.out.requiresUiRedraw = true;
434 }
John Reckcd028f32014-06-24 08:44:29 -0700435 if (!info.out.requiresUiRedraw) {
John Reckf9be7792014-05-02 18:21:16 -0700436 // If animationsNeedsRedraw is set don't bother posting for an RT anim
437 // as we will just end up fighting the UI thread.
438 mRenderThread.postFrameCallback(this);
Leon Scroggins III4afdd1c2018-05-14 14:59:30 -0400439 postedFrameCallback = true;
440 }
441 }
442
443 if (!postedFrameCallback &&
444 info.out.animatedImageDelay != TreeInfo::Out::kNoAnimatedImageDelay) {
445 // Subtract the time of one frame so it can be displayed on time.
446 const nsecs_t kFrameTime = mRenderThread.timeLord().frameIntervalNanos();
447 if (info.out.animatedImageDelay <= kFrameTime) {
448 mRenderThread.postFrameCallback(this);
449 } else {
450 const auto delay = info.out.animatedImageDelay - kFrameTime;
451 int genId = mGenerationID;
452 mRenderThread.queue().postDelayed(delay, [this, genId]() {
453 if (mGenerationID == genId) {
454 mRenderThread.postFrameCallback(this);
455 }
456 });
John Reckf9be7792014-05-02 18:21:16 -0700457 }
John Recke45b1fd2014-04-15 09:50:16 -0700458 }
459}
460
John Reckf47a5942014-06-30 16:20:04 -0700461void CanvasContext::stopDrawing() {
Nader Jawaddd1fcab2021-06-10 18:54:23 -0700462 cleanupResources();
John Reckf47a5942014-06-30 16:20:04 -0700463 mRenderThread.removeFrameCallback(this);
Doris Liuc82e8792016-07-29 16:45:24 -0700464 mAnimationContext->pauseAnimators();
Leon Scroggins III4afdd1c2018-05-14 14:59:30 -0400465 mGenerationID++;
John Reckf47a5942014-06-30 16:20:04 -0700466}
467
John Recka5dda642014-05-22 15:43:54 -0700468void CanvasContext::notifyFramePending() {
469 ATRACE_CALL();
470 mRenderThread.pushBackFrameCallback(this);
471}
472
Bo Liu4d0f1f12021-05-06 16:49:40 -0400473nsecs_t CanvasContext::draw() {
Greg Daniel16d11c62021-04-08 16:17:35 -0400474 if (auto grContext = getGrContext()) {
475 if (grContext->abandoned()) {
476 LOG_ALWAYS_FATAL("GrContext is abandoned/device lost at start of CanvasContext::draw");
Bo Liu4d0f1f12021-05-06 16:49:40 -0400477 return 0;
Greg Daniel16d11c62021-04-08 16:17:35 -0400478 }
479 }
John Recke4267ea2014-06-03 15:53:15 -0700480 SkRect dirty;
481 mDamageAccumulator.finish(&dirty);
482
Brett Chabot856db9e2021-05-21 08:41:58 -0700483 if (!Properties::isDrawingEnabled() ||
484 (dirty.isEmpty() && Properties::skipEmptyFrames && !surfaceRequiresRedraw())) {
John Reck0b19a732019-03-07 17:18:25 -0800485 mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
Leon Scroggins III7fbd0ad2021-08-06 13:42:49 -0400486 if (auto grContext = getGrContext()) {
487 // Submit to ensure that any texture uploads complete and Skia can
488 // free its staging buffers.
489 grContext->flushAndSubmit();
490 }
491
chaviw5fc80e72020-04-30 12:14:35 -0700492 // Notify the callbacks, even if there's nothing to draw so they aren't waiting
493 // indefinitely
Vishnu Nair70a8f0e2020-10-14 18:47:46 -0700494 waitOnFences();
chaviw5fc80e72020-04-30 12:14:35 -0700495 for (auto& func : mFrameCompleteCallbacks) {
496 std::invoke(func, mFrameNumber);
497 }
498 mFrameCompleteCallbacks.clear();
Bo Liu4d0f1f12021-05-06 16:49:40 -0400499 return 0;
John Reck0b19a732019-03-07 17:18:25 -0800500 }
John Reck240ff622015-04-28 13:50:00 -0700501
Huihong Luo054b8d32021-02-24 18:48:12 -0800502 ScopedActiveContext activeContext(this);
Jorim Jaggi10f328c2021-01-19 00:08:02 +0100503 mCurrentFrameInfo->set(FrameInfoIndex::FrameInterval) =
504 mRenderThread.timeLord().frameIntervalNanos();
505
John Reck240ff622015-04-28 13:50:00 -0700506 mCurrentFrameInfo->markIssueDrawCommandsStart();
507
Stan Iliev768e3932016-07-08 21:34:52 -0400508 Frame frame = mRenderPipeline->getFrame();
Stan Iliev768e3932016-07-08 21:34:52 -0400509 SkRect windowDirty = computeDirtyRect(frame, &dirty);
John Reck4f02bf42014-01-03 18:09:17 -0800510
Stan Iliev768e3932016-07-08 21:34:52 -0400511 bool drew = mRenderPipeline->draw(frame, windowDirty, dirty, mLightGeometry, &mLayerUpdateQueue,
John Reck0fa0cbc2019-04-05 16:57:46 -0700512 mContentDrawBounds, mOpaque, mLightInfo, mRenderNodes,
513 &(profiler()));
Chris Craik1dfa0702016-03-04 15:59:24 -0800514
Stan Iliev7203e1f2019-07-25 13:12:02 -0400515 int64_t frameCompleteNr = getFrameNumber();
John Reckcc2eee82018-05-17 10:44:00 -0700516
John Reck38f6c032016-03-17 10:23:49 -0700517 waitOnFences();
518
Steven Thomas6fabb5a2020-08-21 16:56:08 -0700519 if (mNativeSurface) {
520 // TODO(b/165985262): measure performance impact
Siarhei Vishniakoud11f38f2021-01-12 20:45:29 -1000521 const auto vsyncId = mCurrentFrameInfo->get(FrameInfoIndex::FrameTimelineVsyncId);
522 if (vsyncId != UiFrameInfoBuilder::INVALID_VSYNC_ID) {
Siarhei Vishniakou4bcbffd2021-02-17 06:19:36 +0000523 const auto inputEventId =
524 static_cast<int32_t>(mCurrentFrameInfo->get(FrameInfoIndex::InputEventId));
Siarhei Vishniakoud11f38f2021-01-12 20:45:29 -1000525 native_window_set_frame_timeline_info(mNativeSurface->getNativeWindow(), vsyncId,
526 inputEventId);
Steven Thomas6fabb5a2020-08-21 16:56:08 -0700527 }
528 }
529
Stan Iliev768e3932016-07-08 21:34:52 -0400530 bool requireSwap = false;
John Reck59dd2ea2019-07-26 16:51:08 -0700531 int error = OK;
John Reck1bcacfd2017-11-03 10:12:19 -0700532 bool didSwap =
533 mRenderPipeline->swapBuffers(frame, drew, windowDirty, mCurrentFrameInfo, &requireSwap);
John Reck9372ac32016-01-19 11:46:52 -0800534
John Reck306f3312016-06-10 16:01:55 -0700535 mIsDirty = false;
John Reckba6adf62015-02-19 14:36:50 -0800536
Stan Iliev768e3932016-07-08 21:34:52 -0400537 if (requireSwap) {
John Reck59dd2ea2019-07-26 16:51:08 -0700538 bool didDraw = true;
539 // Handle any swapchain errors
540 error = mNativeSurface->getAndClearError();
541 if (error == TIMED_OUT) {
542 // Try again
543 mRenderThread.postFrameCallback(this);
544 // But since this frame didn't happen, we need to mark full damage in the swap
545 // history
546 didDraw = false;
547
548 } else if (error != OK || !didSwap) {
549 // Unknown error, abandon the surface
John Reck149173d2015-08-10 09:52:29 -0700550 setSurface(nullptr);
John Reck59dd2ea2019-07-26 16:51:08 -0700551 didDraw = false;
John Reck149173d2015-08-10 09:52:29 -0700552 }
John Reck59dd2ea2019-07-26 16:51:08 -0700553
John Recke486d932015-10-28 09:21:19 -0700554 SwapHistory& swap = mSwapHistory.next();
John Reck59dd2ea2019-07-26 16:51:08 -0700555 if (didDraw) {
556 swap.damage = windowDirty;
557 } else {
Nick Desaulniersb451d872019-11-04 17:18:51 -0800558 float max = static_cast<float>(INT_MAX);
559 swap.damage = SkRect::MakeWH(max, max);
John Reck59dd2ea2019-07-26 16:51:08 -0700560 }
Jerome Gaillarde218c692019-06-14 12:58:57 +0100561 swap.swapCompletedTime = systemTime(SYSTEM_TIME_MONOTONIC);
John Recke486d932015-10-28 09:21:19 -0700562 swap.vsyncTime = mRenderThread.timeLord().latestVsync();
John Reck59dd2ea2019-07-26 16:51:08 -0700563 if (didDraw) {
Alec Mourif023a322019-11-25 10:02:21 -0800564 nsecs_t dequeueStart =
565 ANativeWindow_getLastDequeueStartTime(mNativeSurface->getNativeWindow());
John Recka67b62e2017-06-01 12:44:58 -0700566 if (dequeueStart < mCurrentFrameInfo->get(FrameInfoIndex::SyncStart)) {
567 // Ignoring dequeue duration as it happened prior to frame render start
John Reck32414ee2017-05-31 14:02:50 -0700568 // and thus is not part of the frame.
569 swap.dequeueDuration = 0;
570 } else {
Alec Mouri8d451742019-08-01 19:19:16 -0700571 swap.dequeueDuration =
Alec Mourif023a322019-11-25 10:02:21 -0800572 ANativeWindow_getLastDequeueDuration(mNativeSurface->getNativeWindow());
John Reck32414ee2017-05-31 14:02:50 -0700573 }
Alec Mourif023a322019-11-25 10:02:21 -0800574 swap.queueDuration =
575 ANativeWindow_getLastQueueDuration(mNativeSurface->getNativeWindow());
John Reck882d5152016-08-01 14:41:08 -0700576 } else {
577 swap.dequeueDuration = 0;
578 swap.queueDuration = 0;
579 }
John Reck1bcacfd2017-11-03 10:12:19 -0700580 mCurrentFrameInfo->set(FrameInfoIndex::DequeueBufferDuration) = swap.dequeueDuration;
581 mCurrentFrameInfo->set(FrameInfoIndex::QueueBufferDuration) = swap.queueDuration;
John Reck149173d2015-08-10 09:52:29 -0700582 mHaveNewSurface = false;
John Reck28912a52016-04-18 14:34:18 -0700583 mFrameNumber = -1;
John Reck70e89c92016-08-05 10:50:36 -0700584 } else {
585 mCurrentFrameInfo->set(FrameInfoIndex::DequeueBufferDuration) = 0;
586 mCurrentFrameInfo->set(FrameInfoIndex::QueueBufferDuration) = 0;
John Reck4f02bf42014-01-03 18:09:17 -0800587 }
John Reckfe5e7b72014-05-23 17:42:28 -0700588
Jorim Jaggi71db8892021-02-03 23:19:29 +0100589 mCurrentFrameInfo->markSwapBuffersCompleted();
John Reck149173d2015-08-10 09:52:29 -0700590
591#if LOG_FRAMETIME_MMA
John Reck1bcacfd2017-11-03 10:12:19 -0700592 float thisFrame = mCurrentFrameInfo->duration(FrameInfoIndex::IssueDrawCommandsStart,
593 FrameInfoIndex::FrameCompleted) /
594 NANOS_PER_MILLIS_F;
John Reck149173d2015-08-10 09:52:29 -0700595 if (sFrameCount) {
596 sBenchMma = ((9 * sBenchMma) + thisFrame) / 10;
597 } else {
598 sBenchMma = thisFrame;
599 }
600 if (++sFrameCount == 10) {
601 sFrameCount = 1;
602 ALOGD("Average frame time: %.4f", sBenchMma);
603 }
604#endif
605
John Reckcc2eee82018-05-17 10:44:00 -0700606 if (didSwap) {
607 for (auto& func : mFrameCompleteCallbacks) {
608 std::invoke(func, frameCompleteNr);
609 }
610 mFrameCompleteCallbacks.clear();
611 }
612
Jorim Jaggi71db8892021-02-03 23:19:29 +0100613 if (requireSwap) {
614 if (mExpectSurfaceStats) {
Siarhei Vishniakouadf50242021-03-11 21:21:05 +0000615 reportMetricsWithPresentTime();
Jorim Jaggi71db8892021-02-03 23:19:29 +0100616 std::lock_guard lock(mLast4FrameInfosMutex);
617 std::pair<FrameInfo*, int64_t>& next = mLast4FrameInfos.next();
618 next.first = mCurrentFrameInfo;
619 next.second = frameCompleteNr;
620 } else {
621 mCurrentFrameInfo->markFrameCompleted();
622 mCurrentFrameInfo->set(FrameInfoIndex::GpuCompleted)
623 = mCurrentFrameInfo->get(FrameInfoIndex::FrameCompleted);
Siarhei Vishniakou07d35cb2021-07-03 02:22:12 +0000624 std::scoped_lock lock(mFrameMetricsReporterMutex);
Jorim Jaggi10f328c2021-01-19 00:08:02 +0100625 mJankTracker.finishFrame(*mCurrentFrameInfo, mFrameMetricsReporter);
Alec Mouri026106f2020-03-26 17:17:09 -0700626 }
Stan Iliev7203e1f2019-07-25 13:12:02 -0400627 }
628
Nader Jawaddd1fcab2021-06-10 18:54:23 -0700629 cleanupResources();
Stan Ilieve0fae232020-01-07 17:21:49 -0500630 mRenderThread.cacheManager().onFrameCompleted();
Bo Liu4d0f1f12021-05-06 16:49:40 -0400631 return mCurrentFrameInfo->get(FrameInfoIndex::DequeueBufferDuration);
John Reck4f02bf42014-01-03 18:09:17 -0800632}
633
Nader Jawaddd1fcab2021-06-10 18:54:23 -0700634void CanvasContext::cleanupResources() {
635 auto& tracker = mJankTracker.frames();
636 auto size = tracker.size();
637 auto capacity = tracker.capacity();
638 if (size == capacity) {
639 nsecs_t nowNanos = systemTime(SYSTEM_TIME_MONOTONIC);
640 nsecs_t frameCompleteNanos =
641 tracker[0].get(FrameInfoIndex::FrameCompleted);
642 nsecs_t frameDiffNanos = nowNanos - frameCompleteNanos;
643 nsecs_t cleanupMillis = ns2ms(std::max(frameDiffNanos, 10_s));
644 mRenderThread.cacheManager().performDeferredCleanup(cleanupMillis);
645 }
646}
647
Siarhei Vishniakouf0cf18d2021-02-26 00:15:04 +0000648void CanvasContext::reportMetricsWithPresentTime() {
Siarhei Vishniakou07d35cb2021-07-03 02:22:12 +0000649 { // acquire lock
650 std::scoped_lock lock(mFrameMetricsReporterMutex);
651 if (mFrameMetricsReporter == nullptr) {
652 return;
653 }
654 } // release lock
Siarhei Vishniakouf0cf18d2021-02-26 00:15:04 +0000655 if (mNativeSurface == nullptr) {
656 return;
657 }
John Reckb7039c62021-07-07 19:18:34 -0400658 ATRACE_CALL();
Siarhei Vishniakouf0cf18d2021-02-26 00:15:04 +0000659 FrameInfo* forthBehind;
660 int64_t frameNumber;
661 { // acquire lock
662 std::scoped_lock lock(mLast4FrameInfosMutex);
663 if (mLast4FrameInfos.size() != mLast4FrameInfos.capacity()) {
664 // Not enough frames yet
665 return;
666 }
667 // Surface object keeps stats for the last 8 frames.
668 std::tie(forthBehind, frameNumber) = mLast4FrameInfos.front();
669 } // release lock
670
671 nsecs_t presentTime = 0;
672 native_window_get_frame_timestamps(
673 mNativeSurface->getNativeWindow(), frameNumber, nullptr /*outRequestedPresentTime*/,
674 nullptr /*outAcquireTime*/, nullptr /*outLatchTime*/,
675 nullptr /*outFirstRefreshStartTime*/, nullptr /*outLastRefreshStartTime*/,
676 nullptr /*outGpuCompositionDoneTime*/, &presentTime, nullptr /*outDequeueReadyTime*/,
677 nullptr /*outReleaseTime*/);
678
679 forthBehind->set(FrameInfoIndex::DisplayPresentTime) = presentTime;
Siarhei Vishniakou07d35cb2021-07-03 02:22:12 +0000680 { // acquire lock
681 std::scoped_lock lock(mFrameMetricsReporterMutex);
682 if (mFrameMetricsReporter != nullptr) {
683 mFrameMetricsReporter->reportFrameMetrics(forthBehind->data(), true /*hasPresentTime*/);
684 }
685 } // release lock
686}
687
688FrameInfo* CanvasContext::getFrameInfoFromLast4(uint64_t frameNumber) {
689 std::scoped_lock lock(mLast4FrameInfosMutex);
690 for (size_t i = 0; i < mLast4FrameInfos.size(); i++) {
691 if (mLast4FrameInfos[i].second == frameNumber) {
692 return mLast4FrameInfos[i].first;
693 }
694 }
695 return nullptr;
Siarhei Vishniakouf0cf18d2021-02-26 00:15:04 +0000696}
697
Jorim Jaggi71db8892021-02-03 23:19:29 +0100698void CanvasContext::onSurfaceStatsAvailable(void* context, ASurfaceControl* control,
699 ASurfaceControlStats* stats) {
700
701 CanvasContext* instance = static_cast<CanvasContext*>(context);
702
703 const ASurfaceControlFunctions& functions =
704 instance->mRenderThread.getASurfaceControlFunctions();
705
706 nsecs_t gpuCompleteTime = functions.getAcquireTimeFunc(stats);
707 uint64_t frameNumber = functions.getFrameNumberFunc(stats);
708
Siarhei Vishniakou07d35cb2021-07-03 02:22:12 +0000709 FrameInfo* frameInfo = instance->getFrameInfoFromLast4(frameNumber);
Siarhei Vishniakouf0cf18d2021-02-26 00:15:04 +0000710
Jorim Jaggi71db8892021-02-03 23:19:29 +0100711 if (frameInfo != nullptr) {
Jorim Jaggib891cdf2021-05-11 14:57:25 +0200712 frameInfo->set(FrameInfoIndex::FrameCompleted) = std::max(gpuCompleteTime,
713 frameInfo->get(FrameInfoIndex::SwapBuffersCompleted));
Jorim Jaggi71db8892021-02-03 23:19:29 +0100714 frameInfo->set(FrameInfoIndex::GpuCompleted) = gpuCompleteTime;
Siarhei Vishniakou07d35cb2021-07-03 02:22:12 +0000715 std::scoped_lock lock(instance->mFrameMetricsReporterMutex);
Jorim Jaggi10f328c2021-01-19 00:08:02 +0100716 instance->mJankTracker.finishFrame(*frameInfo, instance->mFrameMetricsReporter);
Jorim Jaggi71db8892021-02-03 23:19:29 +0100717 }
718}
719
John Recke45b1fd2014-04-15 09:50:16 -0700720// Called by choreographer to do an RT-driven animation
John Reck18f16e62014-05-02 16:46:41 -0700721void CanvasContext::doFrame() {
Stan Iliev768e3932016-07-08 21:34:52 -0400722 if (!mRenderPipeline->isSurfaceReady()) return;
Skuhneea7a7fb2015-08-28 07:10:31 -0700723 prepareAndDraw(nullptr);
724}
John Reck368cdd82014-05-07 13:11:00 -0700725
Leon Scroggins III6c5864c2019-04-03 15:09:25 -0400726SkISize CanvasContext::getNextFrameSize() const {
Alec Mourif023a322019-11-25 10:02:21 -0800727 static constexpr SkISize defaultFrameSize = {INT32_MAX, INT32_MAX};
728 if (mNativeSurface == nullptr) {
729 return defaultFrameSize;
Leon Scroggins III6c5864c2019-04-03 15:09:25 -0400730 }
Alec Mourif023a322019-11-25 10:02:21 -0800731 ANativeWindow* anw = mNativeSurface->getNativeWindow();
732
733 SkISize size;
734 size.fWidth = ANativeWindow_getWidth(anw);
735 size.fHeight = ANativeWindow_getHeight(anw);
736 return size;
Leon Scroggins III6c5864c2019-04-03 15:09:25 -0400737}
738
Skuhneea7a7fb2015-08-28 07:10:31 -0700739void CanvasContext::prepareAndDraw(RenderNode* node) {
John Recke45b1fd2014-04-15 09:50:16 -0700740 ATRACE_CALL();
741
Matthew Bouyack7f667e72016-01-12 12:01:48 -0800742 nsecs_t vsync = mRenderThread.timeLord().computeFrameTimeNanos();
Steven Thomas6fabb5a2020-08-21 16:56:08 -0700743 int64_t vsyncId = mRenderThread.timeLord().lastVsyncId();
Ady Abrahamdfb13982020-10-05 17:59:09 -0700744 int64_t frameDeadline = mRenderThread.timeLord().lastFrameDeadline();
Jorim Jaggi10f328c2021-01-19 00:08:02 +0100745 int64_t frameInterval = mRenderThread.timeLord().frameIntervalNanos();
John Reckba6adf62015-02-19 14:36:50 -0800746 int64_t frameInfo[UI_THREAD_FRAME_INFO_SIZE];
Steven Thomas6fabb5a2020-08-21 16:56:08 -0700747 UiFrameInfoBuilder(frameInfo)
748 .addFlag(FrameInfoFlags::RTAnimation)
Jorim Jaggi10f328c2021-01-19 00:08:02 +0100749 .setVsync(vsync, vsync, vsyncId, frameDeadline, frameInterval);
John Reckfe5e7b72014-05-23 17:42:28 -0700750
Chris Craike2e53a72015-10-28 15:55:40 -0700751 TreeInfo info(TreeInfo::MODE_RT_ONLY, *this);
Jerome Gaillarde218c692019-06-14 12:58:57 +0100752 prepareTree(info, frameInfo, systemTime(SYSTEM_TIME_MONOTONIC), node);
John Recka5dda642014-05-22 15:43:54 -0700753 if (info.out.canDrawThisFrame) {
John Recke4267ea2014-06-03 15:53:15 -0700754 draw();
Chris Craik06e2e9c2016-08-31 17:32:46 -0700755 } else {
756 // wait on fences so tasks don't overlap next frame
757 waitOnFences();
John Recka5dda642014-05-22 15:43:54 -0700758 }
John Recke45b1fd2014-04-15 09:50:16 -0700759}
760
John Reck998a6d82014-08-28 15:35:53 -0700761void CanvasContext::markLayerInUse(RenderNode* node) {
John Reck51f2d602016-04-06 07:50:47 -0700762 if (mPrefetchedLayers.erase(node)) {
Chris Craikd41c4d82015-01-05 15:51:13 -0800763 node->decStrong(nullptr);
John Reck998a6d82014-08-28 15:35:53 -0700764 }
765}
766
John Reck2de950d2017-01-25 10:58:30 -0800767void CanvasContext::freePrefetchedLayers() {
John Reck51f2d602016-04-06 07:50:47 -0700768 if (mPrefetchedLayers.size()) {
769 for (auto& node : mPrefetchedLayers) {
770 ALOGW("Incorrectly called buildLayer on View: %s, destroying layer...",
John Reck1bcacfd2017-11-03 10:12:19 -0700771 node->getName());
John Reck2de950d2017-01-25 10:58:30 -0800772 node->destroyLayers();
773 node->decStrong(nullptr);
John Reck51f2d602016-04-06 07:50:47 -0700774 }
775 mPrefetchedLayers.clear();
John Reck998a6d82014-08-28 15:35:53 -0700776 }
777}
778
John Reck2de950d2017-01-25 10:58:30 -0800779void CanvasContext::buildLayer(RenderNode* node) {
John Reck3e824952014-08-20 10:08:39 -0700780 ATRACE_CALL();
Stan Iliev768e3932016-07-08 21:34:52 -0400781 if (!mRenderPipeline->isContextReady()) return;
Chris Craik6246d2782016-03-29 15:01:41 -0700782
John Reck3e824952014-08-20 10:08:39 -0700783 // buildLayer() will leave the tree in an unknown state, so we must stop drawing
784 stopDrawing();
785
Chris Craike2e53a72015-10-28 15:55:40 -0700786 TreeInfo info(TreeInfo::MODE_FULL, *this);
John Reck3e824952014-08-20 10:08:39 -0700787 info.damageAccumulator = &mDamageAccumulator;
Chris Craik0b7e8242015-10-28 16:50:44 -0700788 info.layerUpdateQueue = &mLayerUpdateQueue;
John Reck9eb9f6f2014-08-21 11:23:05 -0700789 info.runAnimations = false;
John Reck3e824952014-08-20 10:08:39 -0700790 node->prepareTree(info);
791 SkRect ignore;
792 mDamageAccumulator.finish(&ignore);
793 // Tickle the GENERIC property on node to mark it as dirty for damaging
794 // purposes when the frame is actually drawn
795 node->setPropertyFieldsDirty(RenderNode::GENERIC);
796
Peiyong Lin1f6aa122018-09-10 16:28:08 -0700797 mRenderPipeline->renderLayers(mLightGeometry, &mLayerUpdateQueue, mOpaque, mLightInfo);
John Reck998a6d82014-08-28 15:35:53 -0700798
Chris Craikd41c4d82015-01-05 15:51:13 -0800799 node->incStrong(nullptr);
John Reck51f2d602016-04-06 07:50:47 -0700800 mPrefetchedLayers.insert(node);
John Reck3e824952014-08-20 10:08:39 -0700801}
802
John Reck2de950d2017-01-25 10:58:30 -0800803void CanvasContext::destroyHardwareResources() {
John Reckf47a5942014-06-30 16:20:04 -0700804 stopDrawing();
Stan Iliev768e3932016-07-08 21:34:52 -0400805 if (mRenderPipeline->isContextReady()) {
John Reck2de950d2017-01-25 10:58:30 -0800806 freePrefetchedLayers();
Skuhneea7a7fb2015-08-28 07:10:31 -0700807 for (const sp<RenderNode>& node : mRenderNodes) {
John Reck2de950d2017-01-25 10:58:30 -0800808 node->destroyHardwareResources();
Skuhneea7a7fb2015-08-28 07:10:31 -0700809 }
Stan Iliev768e3932016-07-08 21:34:52 -0400810 mRenderPipeline->onDestroyHardwareResources();
John Reckf47a5942014-06-30 16:20:04 -0700811 }
812}
813
814void CanvasContext::trimMemory(RenderThread& thread, int level) {
John Reck18f442e2018-04-09 16:56:34 -0700815 ATRACE_CALL();
816 if (!thread.getGrContext()) return;
817 ATRACE_CALL();
818 if (level >= TRIM_MEMORY_COMPLETE) {
819 thread.cacheManager().trimMemory(CacheManager::TrimMemoryMode::Complete);
John Reck283bb462018-12-13 16:40:14 -0800820 thread.destroyRenderingContext();
John Reck18f442e2018-04-09 16:56:34 -0700821 } else if (level >= TRIM_MEMORY_UI_HIDDEN) {
822 thread.cacheManager().trimMemory(CacheManager::TrimMemoryMode::UiHidden);
John Recke1628b72014-05-23 15:11:19 -0700823 }
824}
825
Derek Sollenberger56ad6ec2016-07-22 12:13:32 -0400826DeferredLayerUpdater* CanvasContext::createTextureLayer() {
Stan Iliev768e3932016-07-08 21:34:52 -0400827 return mRenderPipeline->createTextureLayer();
John Reck1949e792014-04-08 15:18:56 -0700828}
829
John Reckba6adf62015-02-19 14:36:50 -0800830void CanvasContext::dumpFrames(int fd) {
John Reck34781b22017-07-05 16:39:36 -0700831 mJankTracker.dumpStats(fd);
832 mJankTracker.dumpFrames(fd);
John Reckba6adf62015-02-19 14:36:50 -0800833}
834
835void CanvasContext::resetFrameStats() {
John Reck34781b22017-07-05 16:39:36 -0700836 mJankTracker.reset();
John Reckba6adf62015-02-19 14:36:50 -0800837}
838
John Reckdf1742e2017-01-19 15:56:21 -0800839void CanvasContext::setName(const std::string&& name) {
840 mJankTracker.setDescription(JankTrackerType::Window, std::move(name));
841}
842
John Reck38f6c032016-03-17 10:23:49 -0700843void CanvasContext::waitOnFences() {
844 if (mFrameFences.size()) {
845 ATRACE_CALL();
846 for (auto& fence : mFrameFences) {
John Reck322b8ab2019-03-14 13:15:28 -0700847 fence.get();
John Reck38f6c032016-03-17 10:23:49 -0700848 }
849 mFrameFences.clear();
850 }
851}
852
John Reck38f6c032016-03-17 10:23:49 -0700853void CanvasContext::enqueueFrameWork(std::function<void()>&& func) {
John Reck322b8ab2019-03-14 13:15:28 -0700854 mFrameFences.push_back(CommonPool::async(std::move(func)));
John Reck38f6c032016-03-17 10:23:49 -0700855}
856
John Reck28912a52016-04-18 14:34:18 -0700857int64_t CanvasContext::getFrameNumber() {
858 // mFrameNumber is reset to -1 when the surface changes or we swap buffers
859 if (mFrameNumber == -1 && mNativeSurface.get()) {
Alec Mouri80c7ef12019-12-10 15:09:01 -0800860 mFrameNumber = ANativeWindow_getNextFrameId(mNativeSurface->getNativeWindow());
John Reck28912a52016-04-18 14:34:18 -0700861 }
862 return mFrameNumber;
863}
864
John Reck0b19a732019-03-07 17:18:25 -0800865bool CanvasContext::surfaceRequiresRedraw() {
866 if (!mNativeSurface) return false;
867 if (mHaveNewSurface) return true;
868
Alec Mourif023a322019-11-25 10:02:21 -0800869 ANativeWindow* anw = mNativeSurface->getNativeWindow();
870 const int width = ANativeWindow_getWidth(anw);
871 const int height = ANativeWindow_getHeight(anw);
John Reck0b19a732019-03-07 17:18:25 -0800872
John Reck41459192019-10-31 15:04:58 -0700873 return width != mLastFrameWidth || height != mLastFrameHeight;
John Reck0b19a732019-03-07 17:18:25 -0800874}
875
Stan Iliev768e3932016-07-08 21:34:52 -0400876SkRect CanvasContext::computeDirtyRect(const Frame& frame, SkRect* dirty) {
877 if (frame.width() != mLastFrameWidth || frame.height() != mLastFrameHeight) {
878 // can't rely on prior content of window if viewport size changes
879 dirty->setEmpty();
880 mLastFrameWidth = frame.width();
881 mLastFrameHeight = frame.height();
882 } else if (mHaveNewSurface || frame.bufferAge() == 0) {
883 // New surface needs a full draw
884 dirty->setEmpty();
885 } else {
Mike Reed39adc882019-08-22 11:53:05 -0400886 if (!dirty->isEmpty() && !dirty->intersect(SkRect::MakeIWH(frame.width(), frame.height()))) {
John Reck1bcacfd2017-11-03 10:12:19 -0700887 ALOGW("Dirty " RECT_STRING " doesn't intersect with 0 0 %d %d ?", SK_RECT_ARGS(*dirty),
888 frame.width(), frame.height());
Stan Iliev768e3932016-07-08 21:34:52 -0400889 dirty->setEmpty();
890 }
891 profiler().unionDirty(dirty);
892 }
893
894 if (dirty->isEmpty()) {
Mike Reed39adc882019-08-22 11:53:05 -0400895 dirty->setIWH(frame.width(), frame.height());
Stan Iliev768e3932016-07-08 21:34:52 -0400896 }
897
898 // At this point dirty is the area of the window to update. However,
899 // the area of the frame we need to repaint is potentially different, so
900 // stash the screen area for later
901 SkRect windowDirty(*dirty);
902
903 // If the buffer age is 0 we do a full-screen repaint (handled above)
904 // If the buffer age is 1 the buffer contents are the same as they were
905 // last frame so there's nothing to union() against
906 // Therefore we only care about the > 1 case.
907 if (frame.bufferAge() > 1) {
John Reck1bcacfd2017-11-03 10:12:19 -0700908 if (frame.bufferAge() > (int)mSwapHistory.size()) {
Stan Iliev768e3932016-07-08 21:34:52 -0400909 // We don't have enough history to handle this old of a buffer
910 // Just do a full-draw
Mike Reed39adc882019-08-22 11:53:05 -0400911 dirty->setIWH(frame.width(), frame.height());
Stan Iliev768e3932016-07-08 21:34:52 -0400912 } else {
913 // At this point we haven't yet added the latest frame
914 // to the damage history (happens below)
915 // So we need to damage
916 for (int i = mSwapHistory.size() - 1;
John Reck1bcacfd2017-11-03 10:12:19 -0700917 i > ((int)mSwapHistory.size()) - frame.bufferAge(); i--) {
Stan Iliev768e3932016-07-08 21:34:52 -0400918 dirty->join(mSwapHistory[i].damage);
919 }
920 }
921 }
922
923 return windowDirty;
924}
925
Huihong Luo054b8d32021-02-24 18:48:12 -0800926CanvasContext* CanvasContext::getActiveContext() {
927 return ScopedActiveContext::getActiveContext();
928}
929
930bool CanvasContext::mergeTransaction(ASurfaceTransaction* transaction, ASurfaceControl* control) {
931 if (!mASurfaceTransactionCallback) return false;
Huihong Luo4df41512021-06-24 10:04:32 -0700932 return std::invoke(mASurfaceTransactionCallback, reinterpret_cast<int64_t>(transaction),
933 reinterpret_cast<int64_t>(control), getFrameNumber());
Huihong Luo054b8d32021-02-24 18:48:12 -0800934}
935
Huihong Luo34f42fd2021-05-03 14:47:36 -0700936void CanvasContext::prepareSurfaceControlForWebview() {
937 if (mPrepareSurfaceControlForWebviewCallback) {
938 std::invoke(mPrepareSurfaceControlForWebviewCallback);
939 }
940}
941
John Reck23b797a2014-01-03 18:08:34 -0800942} /* namespace renderthread */
943} /* namespace uirenderer */
944} /* namespace android */