John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2014 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
Chris Craik | 5e00c7c | 2016-07-06 16:10:09 -0700 | [diff] [blame] | 17 | #pragma once |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 18 | |
John Reck | ba6adf6 | 2015-02-19 14:36:50 -0800 | [diff] [blame] | 19 | #include "DamageAccumulator.h" |
John Reck | ba6adf6 | 2015-02-19 14:36:50 -0800 | [diff] [blame] | 20 | #include "FrameInfo.h" |
John Reck | 4c9e59d | 2015-05-12 07:17:50 -0700 | [diff] [blame] | 21 | #include "FrameInfoVisualizer.h" |
Andres Morales | 910beb8 | 2016-02-02 16:19:40 -0800 | [diff] [blame] | 22 | #include "FrameMetricsReporter.h" |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 23 | #include "IContextFactory.h" |
Stan Iliev | 768e393 | 2016-07-08 21:34:52 -0400 | [diff] [blame] | 24 | #include "IRenderPipeline.h" |
Fedor Kudasov | 85d6f10 | 2019-07-31 15:58:16 +0100 | [diff] [blame] | 25 | #include "JankTracker.h" |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 26 | #include "LayerUpdateQueue.h" |
John Reck | 0fa0cbc | 2019-04-05 16:57:46 -0700 | [diff] [blame] | 27 | #include "Lighting.h" |
John Reck | 848f651 | 2018-12-03 13:26:43 -0800 | [diff] [blame] | 28 | #include "ReliableSurface.h" |
John Reck | 0fa0cbc | 2019-04-05 16:57:46 -0700 | [diff] [blame] | 29 | #include "RenderNode.h" |
John Reck | ba6adf6 | 2015-02-19 14:36:50 -0800 | [diff] [blame] | 30 | #include "renderthread/RenderTask.h" |
| 31 | #include "renderthread/RenderThread.h" |
Stan Iliev | 7203e1f | 2019-07-25 13:12:02 -0400 | [diff] [blame] | 32 | #include "utils/RingBuffer.h" |
John Reck | b36bfdd | 2020-07-23 13:47:49 -0700 | [diff] [blame] | 33 | #include "ColorMode.h" |
John Reck | 998a6d8 | 2014-08-28 15:35:53 -0700 | [diff] [blame] | 34 | |
John Reck | 19b6bcf | 2014-02-14 20:03:38 -0800 | [diff] [blame] | 35 | #include <SkBitmap.h> |
John Reck | d04794a | 2015-05-08 10:04:36 -0700 | [diff] [blame] | 36 | #include <SkRect.h> |
Leon Scroggins III | 6c5864c | 2019-04-03 15:09:25 -0400 | [diff] [blame] | 37 | #include <SkSize.h> |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 38 | #include <cutils/compiler.h> |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 39 | #include <utils/Functor.h> |
Jorim Jaggi | 71db889 | 2021-02-03 23:19:29 +0100 | [diff] [blame] | 40 | #include <utils/Mutex.h> |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 41 | |
John Reck | 38f6c03 | 2016-03-17 10:23:49 -0700 | [diff] [blame] | 42 | #include <functional> |
John Reck | 0fa0cbc | 2019-04-05 16:57:46 -0700 | [diff] [blame] | 43 | #include <future> |
John Reck | ba6adf6 | 2015-02-19 14:36:50 -0800 | [diff] [blame] | 44 | #include <set> |
John Reck | b36016c | 2015-03-11 08:50:53 -0700 | [diff] [blame] | 45 | #include <string> |
Stan Iliev | 7203e1f | 2019-07-25 13:12:02 -0400 | [diff] [blame] | 46 | #include <utility> |
Skuhne | ea7a7fb | 2015-08-28 07:10:31 -0700 | [diff] [blame] | 47 | #include <vector> |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 48 | |
| 49 | namespace android { |
| 50 | namespace uirenderer { |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 51 | |
John Reck | 119907c | 2014-08-14 09:02:01 -0700 | [diff] [blame] | 52 | class AnimationContext; |
John Reck | 19b6bcf | 2014-02-14 20:03:38 -0800 | [diff] [blame] | 53 | class DeferredLayerUpdater; |
Stan Iliev | 216b157 | 2018-03-26 14:29:50 -0400 | [diff] [blame] | 54 | class ErrorHandler; |
John Reck | 1949e79 | 2014-04-08 15:18:56 -0700 | [diff] [blame] | 55 | class Layer; |
Chris Craik | 5e00c7c | 2016-07-06 16:10:09 -0700 | [diff] [blame] | 56 | class Rect; |
John Reck | 443a714 | 2014-09-04 17:40:05 -0700 | [diff] [blame] | 57 | class RenderState; |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 58 | |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 59 | namespace renderthread { |
| 60 | |
Stan Iliev | 768e393 | 2016-07-08 21:34:52 -0400 | [diff] [blame] | 61 | class Frame; |
John Reck | 1125d1f | 2014-10-23 11:02:19 -0700 | [diff] [blame] | 62 | |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 63 | // This per-renderer class manages the bridge between the global EGL context |
| 64 | // and the render surface. |
John Reck | 119907c | 2014-08-14 09:02:01 -0700 | [diff] [blame] | 65 | // TODO: Rename to Renderer or some other per-window, top-level manager |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 66 | class CanvasContext : public IFrameCallback { |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 67 | public: |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 68 | static CanvasContext* create(RenderThread& thread, bool translucent, RenderNode* rootRenderNode, |
| 69 | IContextFactory* contextFactory); |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 70 | virtual ~CanvasContext(); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 71 | |
Derek Sollenberger | 6a21ca5 | 2016-09-28 13:39:55 -0400 | [diff] [blame] | 72 | /** |
| 73 | * Update or create a layer specific for the provided RenderNode. The layer |
| 74 | * attached to the node will be specific to the RenderPipeline used by this |
| 75 | * context |
| 76 | * |
| 77 | * @return true if the layer has been created or updated |
| 78 | */ |
Stan Iliev | 216b157 | 2018-03-26 14:29:50 -0400 | [diff] [blame] | 79 | bool createOrUpdateLayer(RenderNode* node, const DamageAccumulator& dmgAccumulator, |
| 80 | ErrorHandler* errorHandler) { |
Peiyong Lin | 1f6aa12 | 2018-09-10 16:28:08 -0700 | [diff] [blame] | 81 | return mRenderPipeline->createOrUpdateLayer(node, dmgAccumulator, errorHandler); |
Derek Sollenberger | 6a21ca5 | 2016-09-28 13:39:55 -0400 | [diff] [blame] | 82 | } |
| 83 | |
| 84 | /** |
Derek Sollenberger | b7d34b6 | 2016-11-04 10:46:18 -0400 | [diff] [blame] | 85 | * Pin any mutable images to the GPU cache. A pinned images is guaranteed to |
| 86 | * remain in the cache until it has been unpinned. We leverage this feature |
| 87 | * to avoid making a CPU copy of the pixels. |
| 88 | * |
Derek Sollenberger | 189e874 | 2016-11-16 16:00:17 -0500 | [diff] [blame] | 89 | * @return true if all images have been successfully pinned to the GPU cache |
Derek Sollenberger | b7d34b6 | 2016-11-04 10:46:18 -0400 | [diff] [blame] | 90 | * and false otherwise (e.g. cache limits have been exceeded). |
| 91 | */ |
| 92 | bool pinImages(std::vector<SkImage*>& mutableImages) { |
| 93 | return mRenderPipeline->pinImages(mutableImages); |
| 94 | } |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 95 | bool pinImages(LsaVector<sk_sp<Bitmap>>& images) { return mRenderPipeline->pinImages(images); } |
Derek Sollenberger | b7d34b6 | 2016-11-04 10:46:18 -0400 | [diff] [blame] | 96 | |
| 97 | /** |
| 98 | * Unpin any image that had be previously pinned to the GPU cache |
| 99 | */ |
| 100 | void unpinImages() { mRenderPipeline->unpinImages(); } |
| 101 | |
Derek Sollenberger | daf7229 | 2016-10-25 12:09:18 -0400 | [diff] [blame] | 102 | static void invokeFunctor(const RenderThread& thread, Functor* functor); |
| 103 | |
| 104 | static void prepareToDraw(const RenderThread& thread, Bitmap* bitmap); |
| 105 | |
Derek Sollenberger | 0df6209 | 2016-09-27 16:04:42 -0400 | [diff] [blame] | 106 | /* |
| 107 | * If Properties::isSkiaEnabled() is true then this will return the Skia |
| 108 | * grContext associated with the current RenderPipeline. |
| 109 | */ |
Adlai Holler | ab76215 | 2020-09-16 10:37:19 -0400 | [diff] [blame] | 110 | GrDirectContext* getGrContext() const { return mRenderThread.getGrContext(); } |
Derek Sollenberger | 0df6209 | 2016-09-27 16:04:42 -0400 | [diff] [blame] | 111 | |
Huihong Luo | 054b8d3 | 2021-02-24 18:48:12 -0800 | [diff] [blame] | 112 | ASurfaceControl* getSurfaceControl() const { return mSurfaceControl; } |
Huihong Luo | 540fdf8 | 2021-06-25 13:59:39 -0700 | [diff] [blame] | 113 | int32_t getSurfaceControlGenerationId() const { return mSurfaceControlGenerationId; } |
Huihong Luo | 054b8d3 | 2021-02-24 18:48:12 -0800 | [diff] [blame] | 114 | |
John Reck | 1125d1f | 2014-10-23 11:02:19 -0700 | [diff] [blame] | 115 | // Won't take effect until next EGLSurface creation |
| 116 | void setSwapBehavior(SwapBehavior swapBehavior); |
| 117 | |
Alec Mouri | 43fe6fc | 2019-12-23 07:46:19 -0800 | [diff] [blame] | 118 | void setSurface(ANativeWindow* window, bool enableTimeout = true); |
Huihong Luo | 5fdf7b8 | 2021-01-15 14:27:06 -0800 | [diff] [blame] | 119 | void setSurfaceControl(ASurfaceControl* surfaceControl); |
John Reck | f8441e6 | 2017-10-23 13:10:41 -0700 | [diff] [blame] | 120 | bool pauseSurface(); |
John Reck | 8afcc76 | 2016-04-13 10:24:06 -0700 | [diff] [blame] | 121 | void setStopped(bool stopped); |
Leon Scroggins III | 6c5864c | 2019-04-03 15:09:25 -0400 | [diff] [blame] | 122 | bool hasSurface() const { return mNativeSurface.get(); } |
John Reck | 8785ceb | 2018-10-29 16:45:58 -0700 | [diff] [blame] | 123 | void allocateBuffers(); |
John Reck | aa95a88 | 2014-11-07 11:02:07 -0800 | [diff] [blame] | 124 | |
John Reck | 8785ceb | 2018-10-29 16:45:58 -0700 | [diff] [blame] | 125 | void setLightAlpha(uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha); |
| 126 | void setLightGeometry(const Vector3& lightCenter, float lightRadius); |
John Reck | 63a0667 | 2014-05-07 13:45:54 -0700 | [diff] [blame] | 127 | void setOpaque(bool opaque); |
John Reck | b36bfdd | 2020-07-23 13:47:49 -0700 | [diff] [blame] | 128 | void setColorMode(ColorMode mode); |
John Reck | 8afcc76 | 2016-04-13 10:24:06 -0700 | [diff] [blame] | 129 | bool makeCurrent(); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 130 | void prepareTree(TreeInfo& info, int64_t* uiFrameInfo, int64_t syncQueued, RenderNode* target); |
Bo Liu | 4d0f1f1 | 2021-05-06 16:49:40 -0400 | [diff] [blame] | 131 | // Returns the DequeueBufferDuration. |
| 132 | nsecs_t draw(); |
John Reck | 2de950d | 2017-01-25 10:58:30 -0800 | [diff] [blame] | 133 | void destroy(); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 134 | |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 135 | // IFrameCallback, Choreographer-driven frame callback entry point |
Chris Craik | d41c4d8 | 2015-01-05 15:51:13 -0800 | [diff] [blame] | 136 | virtual void doFrame() override; |
Skuhne | ea7a7fb | 2015-08-28 07:10:31 -0700 | [diff] [blame] | 137 | void prepareAndDraw(RenderNode* node); |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 138 | |
John Reck | 2de950d | 2017-01-25 10:58:30 -0800 | [diff] [blame] | 139 | void buildLayer(RenderNode* node); |
John Reck | 998a6d8 | 2014-08-28 15:35:53 -0700 | [diff] [blame] | 140 | void markLayerInUse(RenderNode* node); |
John Reck | 19b6bcf | 2014-02-14 20:03:38 -0800 | [diff] [blame] | 141 | |
John Reck | 2de950d | 2017-01-25 10:58:30 -0800 | [diff] [blame] | 142 | void destroyHardwareResources(); |
John Reck | f47a594 | 2014-06-30 16:20:04 -0700 | [diff] [blame] | 143 | static void trimMemory(RenderThread& thread, int level); |
John Reck | e1628b7 | 2014-05-23 15:11:19 -0700 | [diff] [blame] | 144 | |
Derek Sollenberger | 56ad6ec | 2016-07-22 12:13:32 -0400 | [diff] [blame] | 145 | DeferredLayerUpdater* createTextureLayer(); |
John Reck | 1949e79 | 2014-04-08 15:18:56 -0700 | [diff] [blame] | 146 | |
John Reck | f47a594 | 2014-06-30 16:20:04 -0700 | [diff] [blame] | 147 | void stopDrawing(); |
John Reck | a5dda64 | 2014-05-22 15:43:54 -0700 | [diff] [blame] | 148 | void notifyFramePending(); |
| 149 | |
John Reck | 4c9e59d | 2015-05-12 07:17:50 -0700 | [diff] [blame] | 150 | FrameInfoVisualizer& profiler() { return mProfiler; } |
John Reck | fe5e7b7 | 2014-05-23 17:42:28 -0700 | [diff] [blame] | 151 | |
John Reck | ba6adf6 | 2015-02-19 14:36:50 -0800 | [diff] [blame] | 152 | void dumpFrames(int fd); |
| 153 | void resetFrameStats(); |
| 154 | |
John Reck | df1742e | 2017-01-19 15:56:21 -0800 | [diff] [blame] | 155 | void setName(const std::string&& name); |
John Reck | b36016c | 2015-03-11 08:50:53 -0700 | [diff] [blame] | 156 | |
John Reck | 2de950d | 2017-01-25 10:58:30 -0800 | [diff] [blame] | 157 | void addRenderNode(RenderNode* node, bool placeFront); |
| 158 | void removeRenderNode(RenderNode* node); |
Skuhne | ea7a7fb | 2015-08-28 07:10:31 -0700 | [diff] [blame] | 159 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 160 | void setContentDrawBounds(const Rect& bounds) { mContentDrawBounds = bounds; } |
Skuhne | ea7a7fb | 2015-08-28 07:10:31 -0700 | [diff] [blame] | 161 | |
Andres Morales | 910beb8 | 2016-02-02 16:19:40 -0800 | [diff] [blame] | 162 | void addFrameMetricsObserver(FrameMetricsObserver* observer) { |
Siarhei Vishniakou | 07d35cb | 2021-07-03 02:22:12 +0000 | [diff] [blame] | 163 | std::scoped_lock lock(mFrameMetricsReporterMutex); |
Andres Morales | 910beb8 | 2016-02-02 16:19:40 -0800 | [diff] [blame] | 164 | if (mFrameMetricsReporter.get() == nullptr) { |
| 165 | mFrameMetricsReporter.reset(new FrameMetricsReporter()); |
Andres Morales | 06f5bc7 | 2015-12-15 15:21:31 -0800 | [diff] [blame] | 166 | } |
| 167 | |
Andres Morales | 910beb8 | 2016-02-02 16:19:40 -0800 | [diff] [blame] | 168 | mFrameMetricsReporter->addObserver(observer); |
Andres Morales | 06f5bc7 | 2015-12-15 15:21:31 -0800 | [diff] [blame] | 169 | } |
| 170 | |
Andres Morales | 910beb8 | 2016-02-02 16:19:40 -0800 | [diff] [blame] | 171 | void removeFrameMetricsObserver(FrameMetricsObserver* observer) { |
Siarhei Vishniakou | 07d35cb | 2021-07-03 02:22:12 +0000 | [diff] [blame] | 172 | std::scoped_lock lock(mFrameMetricsReporterMutex); |
Andres Morales | 910beb8 | 2016-02-02 16:19:40 -0800 | [diff] [blame] | 173 | if (mFrameMetricsReporter.get() != nullptr) { |
| 174 | mFrameMetricsReporter->removeObserver(observer); |
| 175 | if (!mFrameMetricsReporter->hasObservers()) { |
| 176 | mFrameMetricsReporter.reset(nullptr); |
Andres Morales | 06f5bc7 | 2015-12-15 15:21:31 -0800 | [diff] [blame] | 177 | } |
| 178 | } |
| 179 | } |
| 180 | |
John Reck | 38f6c03 | 2016-03-17 10:23:49 -0700 | [diff] [blame] | 181 | // Used to queue up work that needs to be completed before this frame completes |
Derek Sollenberger | 3fedf5a | 2020-02-21 13:07:28 -0500 | [diff] [blame] | 182 | void enqueueFrameWork(std::function<void()>&& func); |
John Reck | 38f6c03 | 2016-03-17 10:23:49 -0700 | [diff] [blame] | 183 | |
Derek Sollenberger | 3fedf5a | 2020-02-21 13:07:28 -0500 | [diff] [blame] | 184 | int64_t getFrameNumber(); |
John Reck | 28912a5 | 2016-04-18 14:34:18 -0700 | [diff] [blame] | 185 | |
Chris Craik | 06e2e9c | 2016-08-31 17:32:46 -0700 | [diff] [blame] | 186 | void waitOnFences(); |
| 187 | |
Stan Iliev | 23c38a9 | 2017-03-23 00:12:50 -0400 | [diff] [blame] | 188 | IRenderPipeline* getRenderPipeline() { return mRenderPipeline.get(); } |
| 189 | |
chaviw | e97e296c | 2021-08-20 12:15:48 -0500 | [diff] [blame] | 190 | void addFrameCommitListener(std::function<void(bool)>&& func) { |
| 191 | mFrameCommitCallbacks.push_back(std::move(func)); |
John Reck | cc2eee8 | 2018-05-17 10:44:00 -0700 | [diff] [blame] | 192 | } |
| 193 | |
John Reck | 5cca8f2 | 2018-12-10 17:06:22 -0800 | [diff] [blame] | 194 | void setPictureCapturedCallback(const std::function<void(sk_sp<SkPicture>&&)>& callback) { |
| 195 | mRenderPipeline->setPictureCapturedCallback(callback); |
| 196 | } |
| 197 | |
John Reck | 0fa0cbc | 2019-04-05 16:57:46 -0700 | [diff] [blame] | 198 | void setForceDark(bool enable) { mUseForceDark = enable; } |
John Reck | bb3a358 | 2018-09-26 11:21:08 -0700 | [diff] [blame] | 199 | |
| 200 | bool useForceDark() { |
John Reck | bb3a358 | 2018-09-26 11:21:08 -0700 | [diff] [blame] | 201 | return mUseForceDark; |
| 202 | } |
| 203 | |
Leon Scroggins III | 6c5864c | 2019-04-03 15:09:25 -0400 | [diff] [blame] | 204 | SkISize getNextFrameSize() const; |
| 205 | |
Jorim Jaggi | 71db889 | 2021-02-03 23:19:29 +0100 | [diff] [blame] | 206 | // Called when SurfaceStats are available. |
| 207 | static void onSurfaceStatsAvailable(void* context, ASurfaceControl* control, |
| 208 | ASurfaceControlStats* stats); |
| 209 | |
Huihong Luo | 054b8d3 | 2021-02-24 18:48:12 -0800 | [diff] [blame] | 210 | void setASurfaceTransactionCallback( |
Huihong Luo | 4df4151 | 2021-06-24 10:04:32 -0700 | [diff] [blame] | 211 | const std::function<bool(int64_t, int64_t, int64_t)>& callback) { |
Huihong Luo | 054b8d3 | 2021-02-24 18:48:12 -0800 | [diff] [blame] | 212 | mASurfaceTransactionCallback = callback; |
| 213 | } |
| 214 | |
| 215 | bool mergeTransaction(ASurfaceTransaction* transaction, ASurfaceControl* control); |
| 216 | |
Huihong Luo | 34f42fd | 2021-05-03 14:47:36 -0700 | [diff] [blame] | 217 | void setPrepareSurfaceControlForWebviewCallback(const std::function<void()>& callback) { |
| 218 | mPrepareSurfaceControlForWebviewCallback = callback; |
| 219 | } |
| 220 | |
| 221 | void prepareSurfaceControlForWebview(); |
| 222 | |
Huihong Luo | 054b8d3 | 2021-02-24 18:48:12 -0800 | [diff] [blame] | 223 | static CanvasContext* getActiveContext(); |
| 224 | |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 225 | private: |
Stan Iliev | 03de074 | 2016-07-07 12:35:54 -0400 | [diff] [blame] | 226 | CanvasContext(RenderThread& thread, bool translucent, RenderNode* rootRenderNode, |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 227 | IContextFactory* contextFactory, std::unique_ptr<IRenderPipeline> renderPipeline); |
Stan Iliev | 03de074 | 2016-07-07 12:35:54 -0400 | [diff] [blame] | 228 | |
John Reck | a5dda64 | 2014-05-22 15:43:54 -0700 | [diff] [blame] | 229 | friend class RegisterFrameCallbackTask; |
John Reck | 443a714 | 2014-09-04 17:40:05 -0700 | [diff] [blame] | 230 | // TODO: Replace with something better for layer & other GL object |
| 231 | // lifecycle tracking |
| 232 | friend class android::uirenderer::RenderState; |
John Reck | a5dda64 | 2014-05-22 15:43:54 -0700 | [diff] [blame] | 233 | |
John Reck | 2de950d | 2017-01-25 10:58:30 -0800 | [diff] [blame] | 234 | void freePrefetchedLayers(); |
John Reck | 998a6d8 | 2014-08-28 15:35:53 -0700 | [diff] [blame] | 235 | |
John Reck | 0def73a | 2016-07-01 16:19:13 -0700 | [diff] [blame] | 236 | bool isSwapChainStuffed(); |
John Reck | 0b19a73 | 2019-03-07 17:18:25 -0800 | [diff] [blame] | 237 | bool surfaceRequiresRedraw(); |
John Reck | b36bfdd | 2020-07-23 13:47:49 -0700 | [diff] [blame] | 238 | void setupPipelineSurface(); |
John Reck | 0def73a | 2016-07-01 16:19:13 -0700 | [diff] [blame] | 239 | |
Stan Iliev | 768e393 | 2016-07-08 21:34:52 -0400 | [diff] [blame] | 240 | SkRect computeDirtyRect(const Frame& frame, SkRect* dirty); |
Jorim Jaggi | 71db889 | 2021-02-03 23:19:29 +0100 | [diff] [blame] | 241 | void finishFrame(FrameInfo* frameInfo); |
Stan Iliev | 768e393 | 2016-07-08 21:34:52 -0400 | [diff] [blame] | 242 | |
Siarhei Vishniakou | f0cf18d | 2021-02-26 00:15:04 +0000 | [diff] [blame] | 243 | /** |
| 244 | * Invoke 'reportFrameMetrics' on the last frame stored in 'mLast4FrameInfos'. |
| 245 | * Populate the 'presentTime' field before calling. |
| 246 | */ |
| 247 | void reportMetricsWithPresentTime(); |
| 248 | |
Siarhei Vishniakou | 07d35cb | 2021-07-03 02:22:12 +0000 | [diff] [blame] | 249 | FrameInfo* getFrameInfoFromLast4(uint64_t frameNumber); |
| 250 | |
Fedor Kudasov | 52abc90 | 2019-06-26 16:59:16 +0100 | [diff] [blame] | 251 | // The same type as Frame.mWidth and Frame.mHeight |
| 252 | int32_t mLastFrameWidth = 0; |
| 253 | int32_t mLastFrameHeight = 0; |
Chris Craik | ddf2215 | 2015-10-14 17:42:47 -0700 | [diff] [blame] | 254 | |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 255 | RenderThread& mRenderThread; |
Alec Mouri | f023a32 | 2019-11-25 10:02:21 -0800 | [diff] [blame] | 256 | std::unique_ptr<ReliableSurface> mNativeSurface; |
Huihong Luo | 5fdf7b8 | 2021-01-15 14:27:06 -0800 | [diff] [blame] | 257 | // The SurfaceControl reference is passed from ViewRootImpl, can be set to |
| 258 | // NULL to remove the reference |
| 259 | ASurfaceControl* mSurfaceControl = nullptr; |
Huihong Luo | 540fdf8 | 2021-06-25 13:59:39 -0700 | [diff] [blame] | 260 | // id to track surface control changes and WebViewFunctor uses it to determine |
| 261 | // whether reparenting is needed |
| 262 | int32_t mSurfaceControlGenerationId = 0; |
John Reck | 306f331 | 2016-06-10 16:01:55 -0700 | [diff] [blame] | 263 | // stopped indicates the CanvasContext will reject actual redraw operations, |
| 264 | // and defer repaint until it is un-stopped |
John Reck | 8afcc76 | 2016-04-13 10:24:06 -0700 | [diff] [blame] | 265 | bool mStopped = false; |
Leon Scroggins III | 4afdd1c | 2018-05-14 14:59:30 -0400 | [diff] [blame] | 266 | // Incremented each time the CanvasContext is stopped. Used to ignore |
| 267 | // delayed messages that are triggered after stopping. |
| 268 | int mGenerationID; |
John Reck | 306f331 | 2016-06-10 16:01:55 -0700 | [diff] [blame] | 269 | // CanvasContext is dirty if it has received an update that it has not |
| 270 | // painted onto its surface. |
| 271 | bool mIsDirty = false; |
Stan Iliev | 768e393 | 2016-07-08 21:34:52 -0400 | [diff] [blame] | 272 | SwapBehavior mSwapBehavior = SwapBehavior::kSwap_default; |
John Reck | e486d93 | 2015-10-28 09:21:19 -0700 | [diff] [blame] | 273 | struct SwapHistory { |
| 274 | SkRect damage; |
| 275 | nsecs_t vsyncTime; |
John Reck | 0def73a | 2016-07-01 16:19:13 -0700 | [diff] [blame] | 276 | nsecs_t swapCompletedTime; |
| 277 | nsecs_t dequeueDuration; |
| 278 | nsecs_t queueDuration; |
John Reck | e486d93 | 2015-10-28 09:21:19 -0700 | [diff] [blame] | 279 | }; |
| 280 | |
John Reck | ca718a0 | 2019-10-21 10:14:58 -0700 | [diff] [blame] | 281 | // Need at least 4 because we do quad buffer. Add a 5th for good measure. |
Jiang Tian | 0815ba2 | 2021-12-03 18:18:16 +0800 | [diff] [blame] | 282 | RingBuffer<SwapHistory, 7> mSwapHistory; |
John Reck | 28912a5 | 2016-04-18 14:34:18 -0700 | [diff] [blame] | 283 | int64_t mFrameNumber = -1; |
John Reck | 4145919 | 2019-10-31 15:04:58 -0700 | [diff] [blame] | 284 | int64_t mDamageId = 0; |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 285 | |
Chris Craik | 3163568 | 2016-07-19 17:59:12 -0700 | [diff] [blame] | 286 | // last vsync for a dropped frame due to stuffed queue |
| 287 | nsecs_t mLastDropVsync = 0; |
| 288 | |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 289 | bool mOpaque; |
John Reck | bb3a358 | 2018-09-26 11:21:08 -0700 | [diff] [blame] | 290 | bool mUseForceDark = false; |
John Reck | d9d7f12 | 2018-05-03 14:40:56 -0700 | [diff] [blame] | 291 | LightInfo mLightInfo; |
| 292 | LightGeometry mLightGeometry = {{0, 0, 0}, 0}; |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 293 | |
John Reck | edc524c | 2015-03-18 15:24:33 -0700 | [diff] [blame] | 294 | bool mHaveNewSurface = false; |
John Reck | e4267ea | 2014-06-03 15:53:15 -0700 | [diff] [blame] | 295 | DamageAccumulator mDamageAccumulator; |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 296 | LayerUpdateQueue mLayerUpdateQueue; |
Chris Craik | 51d6a3d | 2014-12-22 17:16:56 -0800 | [diff] [blame] | 297 | std::unique_ptr<AnimationContext> mAnimationContext; |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 298 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 299 | std::vector<sp<RenderNode>> mRenderNodes; |
John Reck | fe5e7b7 | 2014-05-23 17:42:28 -0700 | [diff] [blame] | 300 | |
John Reck | edc524c | 2015-03-18 15:24:33 -0700 | [diff] [blame] | 301 | FrameInfo* mCurrentFrameInfo = nullptr; |
Jorim Jaggi | 71db889 | 2021-02-03 23:19:29 +0100 | [diff] [blame] | 302 | |
| 303 | // List of frames that are awaiting GPU completion reporting |
| 304 | RingBuffer<std::pair<FrameInfo*, int64_t>, 4> mLast4FrameInfos |
| 305 | GUARDED_BY(mLast4FrameInfosMutex); |
| 306 | std::mutex mLast4FrameInfosMutex; |
| 307 | |
John Reck | b36016c | 2015-03-11 08:50:53 -0700 | [diff] [blame] | 308 | std::string mName; |
John Reck | edc524c | 2015-03-18 15:24:33 -0700 | [diff] [blame] | 309 | JankTracker mJankTracker; |
John Reck | 4c9e59d | 2015-05-12 07:17:50 -0700 | [diff] [blame] | 310 | FrameInfoVisualizer mProfiler; |
Siarhei Vishniakou | 07d35cb | 2021-07-03 02:22:12 +0000 | [diff] [blame] | 311 | std::unique_ptr<FrameMetricsReporter> mFrameMetricsReporter |
| 312 | GUARDED_BY(mFrameMetricsReporterMutex); |
Jorim Jaggi | e4a5271 | 2021-05-31 17:57:50 +0200 | [diff] [blame] | 313 | std::mutex mFrameMetricsReporterMutex; |
John Reck | 998a6d8 | 2014-08-28 15:35:53 -0700 | [diff] [blame] | 314 | |
John Reck | 51f2d60 | 2016-04-06 07:50:47 -0700 | [diff] [blame] | 315 | std::set<RenderNode*> mPrefetchedLayers; |
Skuhne | ea7a7fb | 2015-08-28 07:10:31 -0700 | [diff] [blame] | 316 | |
| 317 | // Stores the bounds of the main content. |
Skuhne | b816087 | 2015-09-22 09:51:39 -0700 | [diff] [blame] | 318 | Rect mContentDrawBounds; |
John Reck | 38f6c03 | 2016-03-17 10:23:49 -0700 | [diff] [blame] | 319 | |
John Reck | 322b8ab | 2019-03-14 13:15:28 -0700 | [diff] [blame] | 320 | std::vector<std::future<void>> mFrameFences; |
Stan Iliev | 768e393 | 2016-07-08 21:34:52 -0400 | [diff] [blame] | 321 | std::unique_ptr<IRenderPipeline> mRenderPipeline; |
John Reck | cc2eee8 | 2018-05-17 10:44:00 -0700 | [diff] [blame] | 322 | |
chaviw | e97e296c | 2021-08-20 12:15:48 -0500 | [diff] [blame] | 323 | std::vector<std::function<void(bool)>> mFrameCommitCallbacks; |
Jorim Jaggi | 71db889 | 2021-02-03 23:19:29 +0100 | [diff] [blame] | 324 | |
| 325 | // If set to true, we expect that callbacks into onSurfaceStatsAvailable |
| 326 | bool mExpectSurfaceStats = false; |
Huihong Luo | 054b8d3 | 2021-02-24 18:48:12 -0800 | [diff] [blame] | 327 | |
Huihong Luo | 4df4151 | 2021-06-24 10:04:32 -0700 | [diff] [blame] | 328 | std::function<bool(int64_t, int64_t, int64_t)> mASurfaceTransactionCallback; |
Huihong Luo | 34f42fd | 2021-05-03 14:47:36 -0700 | [diff] [blame] | 329 | std::function<void()> mPrepareSurfaceControlForWebviewCallback; |
| 330 | |
Nader Jawad | dd1fcab | 2021-06-10 18:54:23 -0700 | [diff] [blame] | 331 | void cleanupResources(); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 332 | }; |
| 333 | |
| 334 | } /* namespace renderthread */ |
| 335 | } /* namespace uirenderer */ |
| 336 | } /* namespace android */ |