John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2014 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #ifndef CANVASCONTEXT_H_ |
| 18 | #define CANVASCONTEXT_H_ |
| 19 | |
John Reck | ba6adf6 | 2015-02-19 14:36:50 -0800 | [diff] [blame] | 20 | #include "DamageAccumulator.h" |
John Reck | ba6adf6 | 2015-02-19 14:36:50 -0800 | [diff] [blame] | 21 | #include "FrameInfo.h" |
John Reck | 4c9e59d | 2015-05-12 07:17:50 -0700 | [diff] [blame] | 22 | #include "FrameInfoVisualizer.h" |
Andres Morales | 910beb8 | 2016-02-02 16:19:40 -0800 | [diff] [blame] | 23 | #include "FrameMetricsReporter.h" |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 24 | #include "IContextFactory.h" |
| 25 | #include "LayerUpdateQueue.h" |
John Reck | ba6adf6 | 2015-02-19 14:36:50 -0800 | [diff] [blame] | 26 | #include "RenderNode.h" |
John Reck | 38f6c03 | 2016-03-17 10:23:49 -0700 | [diff] [blame] | 27 | #include "thread/Task.h" |
| 28 | #include "thread/TaskProcessor.h" |
John Reck | ba6adf6 | 2015-02-19 14:36:50 -0800 | [diff] [blame] | 29 | #include "utils/RingBuffer.h" |
| 30 | #include "renderthread/RenderTask.h" |
| 31 | #include "renderthread/RenderThread.h" |
John Reck | 998a6d8 | 2014-08-28 15:35:53 -0700 | [diff] [blame] | 32 | |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 33 | #if HWUI_NEW_OPS |
Chris Craik | 9e7fcfd | 2015-11-25 13:27:33 -0800 | [diff] [blame] | 34 | #include "BakedOpDispatcher.h" |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 35 | #include "BakedOpRenderer.h" |
Chris Craik | 6e068c01 | 2016-01-15 16:15:30 -0800 | [diff] [blame] | 36 | #include "FrameBuilder.h" |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 37 | #endif |
| 38 | |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 39 | #include <cutils/compiler.h> |
| 40 | #include <EGL/egl.h> |
John Reck | 19b6bcf | 2014-02-14 20:03:38 -0800 | [diff] [blame] | 41 | #include <SkBitmap.h> |
John Reck | d04794a | 2015-05-08 10:04:36 -0700 | [diff] [blame] | 42 | #include <SkRect.h> |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 43 | #include <utils/Functor.h> |
John Reck | f648108 | 2016-02-02 15:18:23 -0800 | [diff] [blame] | 44 | #include <gui/Surface.h> |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 45 | |
John Reck | 38f6c03 | 2016-03-17 10:23:49 -0700 | [diff] [blame] | 46 | #include <functional> |
John Reck | ba6adf6 | 2015-02-19 14:36:50 -0800 | [diff] [blame] | 47 | #include <set> |
John Reck | b36016c | 2015-03-11 08:50:53 -0700 | [diff] [blame] | 48 | #include <string> |
Skuhne | ea7a7fb | 2015-08-28 07:10:31 -0700 | [diff] [blame] | 49 | #include <vector> |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 50 | |
| 51 | namespace android { |
| 52 | namespace uirenderer { |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 53 | |
John Reck | 119907c | 2014-08-14 09:02:01 -0700 | [diff] [blame] | 54 | class AnimationContext; |
John Reck | 19b6bcf | 2014-02-14 20:03:38 -0800 | [diff] [blame] | 55 | class DeferredLayerUpdater; |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 56 | class OpenGLRenderer; |
| 57 | class Rect; |
John Reck | 1949e79 | 2014-04-08 15:18:56 -0700 | [diff] [blame] | 58 | class Layer; |
John Reck | 443a714 | 2014-09-04 17:40:05 -0700 | [diff] [blame] | 59 | class RenderState; |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 60 | |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 61 | namespace renderthread { |
| 62 | |
John Reck | 3b20251 | 2014-06-23 13:13:08 -0700 | [diff] [blame] | 63 | class EglManager; |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 64 | |
John Reck | 1125d1f | 2014-10-23 11:02:19 -0700 | [diff] [blame] | 65 | enum SwapBehavior { |
| 66 | kSwap_default, |
| 67 | kSwap_discardBuffer, |
| 68 | }; |
| 69 | |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 70 | // This per-renderer class manages the bridge between the global EGL context |
| 71 | // and the render surface. |
John Reck | 119907c | 2014-08-14 09:02:01 -0700 | [diff] [blame] | 72 | // TODO: Rename to Renderer or some other per-window, top-level manager |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 73 | class CanvasContext : public IFrameCallback { |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 74 | public: |
John Reck | 119907c | 2014-08-14 09:02:01 -0700 | [diff] [blame] | 75 | CanvasContext(RenderThread& thread, bool translucent, RenderNode* rootRenderNode, |
| 76 | IContextFactory* contextFactory); |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 77 | virtual ~CanvasContext(); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 78 | |
John Reck | 1125d1f | 2014-10-23 11:02:19 -0700 | [diff] [blame] | 79 | // Won't take effect until next EGLSurface creation |
| 80 | void setSwapBehavior(SwapBehavior swapBehavior); |
| 81 | |
John Reck | f648108 | 2016-02-02 15:18:23 -0800 | [diff] [blame] | 82 | void initialize(Surface* surface); |
| 83 | void updateSurface(Surface* surface); |
| 84 | bool pauseSurface(Surface* surface); |
| 85 | bool hasSurface() { return mNativeSurface.get(); } |
John Reck | aa95a88 | 2014-11-07 11:02:07 -0800 | [diff] [blame] | 86 | |
Alan Viverette | 50210d9 | 2015-05-14 18:05:36 -0700 | [diff] [blame] | 87 | void setup(int width, int height, float lightRadius, |
Chris Craik | 058fc64 | 2014-07-23 18:19:28 -0700 | [diff] [blame] | 88 | uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha); |
Alan Viverette | 50210d9 | 2015-05-14 18:05:36 -0700 | [diff] [blame] | 89 | void setLightCenter(const Vector3& lightCenter); |
John Reck | 63a0667 | 2014-05-07 13:45:54 -0700 | [diff] [blame] | 90 | void setOpaque(bool opaque); |
John Reck | 860d155 | 2014-04-11 19:15:05 -0700 | [diff] [blame] | 91 | void makeCurrent(); |
Skuhne | ea7a7fb | 2015-08-28 07:10:31 -0700 | [diff] [blame] | 92 | void prepareTree(TreeInfo& info, int64_t* uiFrameInfo, |
| 93 | int64_t syncQueued, RenderNode* target); |
John Reck | e4267ea | 2014-06-03 15:53:15 -0700 | [diff] [blame] | 94 | void draw(); |
John Reck | 51f2d60 | 2016-04-06 07:50:47 -0700 | [diff] [blame^] | 95 | void destroy(TreeObserver* observer); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 96 | |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 97 | // IFrameCallback, Choreographer-driven frame callback entry point |
Chris Craik | d41c4d8 | 2015-01-05 15:51:13 -0800 | [diff] [blame] | 98 | virtual void doFrame() override; |
Skuhne | ea7a7fb | 2015-08-28 07:10:31 -0700 | [diff] [blame] | 99 | void prepareAndDraw(RenderNode* node); |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 100 | |
John Reck | 51f2d60 | 2016-04-06 07:50:47 -0700 | [diff] [blame^] | 101 | void buildLayer(RenderNode* node, TreeObserver* observer); |
John Reck | 19b6bcf | 2014-02-14 20:03:38 -0800 | [diff] [blame] | 102 | bool copyLayerInto(DeferredLayerUpdater* layer, SkBitmap* bitmap); |
John Reck | 998a6d8 | 2014-08-28 15:35:53 -0700 | [diff] [blame] | 103 | void markLayerInUse(RenderNode* node); |
John Reck | 19b6bcf | 2014-02-14 20:03:38 -0800 | [diff] [blame] | 104 | |
John Reck | 51f2d60 | 2016-04-06 07:50:47 -0700 | [diff] [blame^] | 105 | void destroyHardwareResources(TreeObserver* observer); |
John Reck | f47a594 | 2014-06-30 16:20:04 -0700 | [diff] [blame] | 106 | static void trimMemory(RenderThread& thread, int level); |
John Reck | e1628b7 | 2014-05-23 15:11:19 -0700 | [diff] [blame] | 107 | |
John Reck | 3b20251 | 2014-06-23 13:13:08 -0700 | [diff] [blame] | 108 | static void invokeFunctor(RenderThread& thread, Functor* functor); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 109 | |
John Reck | fc53ef27 | 2014-02-11 10:40:25 -0800 | [diff] [blame] | 110 | void runWithGlContext(RenderTask* task); |
| 111 | |
John Reck | 1949e79 | 2014-04-08 15:18:56 -0700 | [diff] [blame] | 112 | Layer* createTextureLayer(); |
| 113 | |
John Reck | 3b20251 | 2014-06-23 13:13:08 -0700 | [diff] [blame] | 114 | ANDROID_API static void setTextureAtlas(RenderThread& thread, |
| 115 | const sp<GraphicBuffer>& buffer, int64_t* map, size_t mapSize); |
John Reck | 66f0be6 | 2014-05-13 13:39:31 -0700 | [diff] [blame] | 116 | |
John Reck | f47a594 | 2014-06-30 16:20:04 -0700 | [diff] [blame] | 117 | void stopDrawing(); |
John Reck | a5dda64 | 2014-05-22 15:43:54 -0700 | [diff] [blame] | 118 | void notifyFramePending(); |
| 119 | |
John Reck | 4c9e59d | 2015-05-12 07:17:50 -0700 | [diff] [blame] | 120 | FrameInfoVisualizer& profiler() { return mProfiler; } |
John Reck | fe5e7b7 | 2014-05-23 17:42:28 -0700 | [diff] [blame] | 121 | |
John Reck | ba6adf6 | 2015-02-19 14:36:50 -0800 | [diff] [blame] | 122 | void dumpFrames(int fd); |
| 123 | void resetFrameStats(); |
| 124 | |
John Reck | b36016c | 2015-03-11 08:50:53 -0700 | [diff] [blame] | 125 | void setName(const std::string&& name) { mName = name; } |
| 126 | const std::string& name() { return mName; } |
| 127 | |
John Reck | e248bd1 | 2015-08-05 13:53:53 -0700 | [diff] [blame] | 128 | void serializeDisplayListTree(); |
| 129 | |
Skuhne | ea7a7fb | 2015-08-28 07:10:31 -0700 | [diff] [blame] | 130 | void addRenderNode(RenderNode* node, bool placeFront) { |
| 131 | int pos = placeFront ? 0 : static_cast<int>(mRenderNodes.size()); |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 132 | mRenderNodes.emplace(mRenderNodes.begin() + pos, node); |
Skuhne | ea7a7fb | 2015-08-28 07:10:31 -0700 | [diff] [blame] | 133 | } |
| 134 | |
| 135 | void removeRenderNode(RenderNode* node) { |
| 136 | mRenderNodes.erase(std::remove(mRenderNodes.begin(), mRenderNodes.end(), node), |
| 137 | mRenderNodes.end()); |
| 138 | } |
| 139 | |
Skuhne | b816087 | 2015-09-22 09:51:39 -0700 | [diff] [blame] | 140 | void setContentDrawBounds(int left, int top, int right, int bottom) { |
| 141 | mContentDrawBounds.set(left, top, right, bottom); |
Skuhne | ea7a7fb | 2015-08-28 07:10:31 -0700 | [diff] [blame] | 142 | } |
| 143 | |
Chris Craik | e2e53a7 | 2015-10-28 15:55:40 -0700 | [diff] [blame] | 144 | RenderState& getRenderState() { |
| 145 | return mRenderThread.renderState(); |
| 146 | } |
| 147 | |
Andres Morales | 910beb8 | 2016-02-02 16:19:40 -0800 | [diff] [blame] | 148 | void addFrameMetricsObserver(FrameMetricsObserver* observer) { |
| 149 | if (mFrameMetricsReporter.get() == nullptr) { |
| 150 | mFrameMetricsReporter.reset(new FrameMetricsReporter()); |
Andres Morales | 06f5bc7 | 2015-12-15 15:21:31 -0800 | [diff] [blame] | 151 | } |
| 152 | |
Andres Morales | 910beb8 | 2016-02-02 16:19:40 -0800 | [diff] [blame] | 153 | mFrameMetricsReporter->addObserver(observer); |
Andres Morales | 06f5bc7 | 2015-12-15 15:21:31 -0800 | [diff] [blame] | 154 | } |
| 155 | |
Andres Morales | 910beb8 | 2016-02-02 16:19:40 -0800 | [diff] [blame] | 156 | void removeFrameMetricsObserver(FrameMetricsObserver* observer) { |
| 157 | if (mFrameMetricsReporter.get() != nullptr) { |
| 158 | mFrameMetricsReporter->removeObserver(observer); |
| 159 | if (!mFrameMetricsReporter->hasObservers()) { |
| 160 | mFrameMetricsReporter.reset(nullptr); |
Andres Morales | 06f5bc7 | 2015-12-15 15:21:31 -0800 | [diff] [blame] | 161 | } |
| 162 | } |
| 163 | } |
| 164 | |
John Reck | 38f6c03 | 2016-03-17 10:23:49 -0700 | [diff] [blame] | 165 | // Used to queue up work that needs to be completed before this frame completes |
| 166 | ANDROID_API void enqueueFrameWork(std::function<void()>&& func); |
| 167 | |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 168 | private: |
John Reck | a5dda64 | 2014-05-22 15:43:54 -0700 | [diff] [blame] | 169 | friend class RegisterFrameCallbackTask; |
John Reck | 443a714 | 2014-09-04 17:40:05 -0700 | [diff] [blame] | 170 | // TODO: Replace with something better for layer & other GL object |
| 171 | // lifecycle tracking |
| 172 | friend class android::uirenderer::RenderState; |
John Reck | a5dda64 | 2014-05-22 15:43:54 -0700 | [diff] [blame] | 173 | |
John Reck | f648108 | 2016-02-02 15:18:23 -0800 | [diff] [blame] | 174 | void setSurface(Surface* window); |
John Reck | f7d9c1d | 2014-04-09 10:01:03 -0700 | [diff] [blame] | 175 | void requireSurface(); |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 176 | |
John Reck | 51f2d60 | 2016-04-06 07:50:47 -0700 | [diff] [blame^] | 177 | void freePrefetchedLayers(TreeObserver* observer); |
John Reck | 998a6d8 | 2014-08-28 15:35:53 -0700 | [diff] [blame] | 178 | |
John Reck | 38f6c03 | 2016-03-17 10:23:49 -0700 | [diff] [blame] | 179 | void waitOnFences(); |
| 180 | |
John Reck | 77c4010 | 2015-10-26 15:49:47 -0700 | [diff] [blame] | 181 | EGLint mLastFrameWidth = 0; |
| 182 | EGLint mLastFrameHeight = 0; |
Chris Craik | ddf2215 | 2015-10-14 17:42:47 -0700 | [diff] [blame] | 183 | |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 184 | RenderThread& mRenderThread; |
John Reck | 3b20251 | 2014-06-23 13:13:08 -0700 | [diff] [blame] | 185 | EglManager& mEglManager; |
John Reck | f648108 | 2016-02-02 15:18:23 -0800 | [diff] [blame] | 186 | sp<Surface> mNativeSurface; |
John Reck | edc524c | 2015-03-18 15:24:33 -0700 | [diff] [blame] | 187 | EGLSurface mEglSurface = EGL_NO_SURFACE; |
| 188 | bool mBufferPreserved = false; |
| 189 | SwapBehavior mSwapBehavior = kSwap_default; |
John Reck | e486d93 | 2015-10-28 09:21:19 -0700 | [diff] [blame] | 190 | struct SwapHistory { |
| 191 | SkRect damage; |
| 192 | nsecs_t vsyncTime; |
| 193 | nsecs_t swapTime; |
| 194 | }; |
| 195 | |
| 196 | RingBuffer<SwapHistory, 3> mSwapHistory; |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 197 | |
| 198 | bool mOpaque; |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 199 | #if HWUI_NEW_OPS |
| 200 | BakedOpRenderer::LightInfo mLightInfo; |
Chris Craik | 6e068c01 | 2016-01-15 16:15:30 -0800 | [diff] [blame] | 201 | FrameBuilder::LightGeometry mLightGeometry = { {0, 0, 0}, 0 }; |
Chris Craik | 6246d278 | 2016-03-29 15:01:41 -0700 | [diff] [blame] | 202 | #else |
| 203 | OpenGLRenderer* mCanvas = nullptr; |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 204 | #endif |
| 205 | |
John Reck | edc524c | 2015-03-18 15:24:33 -0700 | [diff] [blame] | 206 | bool mHaveNewSurface = false; |
John Reck | e4267ea | 2014-06-03 15:53:15 -0700 | [diff] [blame] | 207 | DamageAccumulator mDamageAccumulator; |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 208 | LayerUpdateQueue mLayerUpdateQueue; |
Chris Craik | 51d6a3d | 2014-12-22 17:16:56 -0800 | [diff] [blame] | 209 | std::unique_ptr<AnimationContext> mAnimationContext; |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 210 | |
Skuhne | ea7a7fb | 2015-08-28 07:10:31 -0700 | [diff] [blame] | 211 | std::vector< sp<RenderNode> > mRenderNodes; |
John Reck | fe5e7b7 | 2014-05-23 17:42:28 -0700 | [diff] [blame] | 212 | |
John Reck | edc524c | 2015-03-18 15:24:33 -0700 | [diff] [blame] | 213 | FrameInfo* mCurrentFrameInfo = nullptr; |
John Reck | 4c9e59d | 2015-05-12 07:17:50 -0700 | [diff] [blame] | 214 | // Ring buffer large enough for 2 seconds worth of frames |
| 215 | RingBuffer<FrameInfo, 120> mFrames; |
John Reck | b36016c | 2015-03-11 08:50:53 -0700 | [diff] [blame] | 216 | std::string mName; |
John Reck | edc524c | 2015-03-18 15:24:33 -0700 | [diff] [blame] | 217 | JankTracker mJankTracker; |
John Reck | 4c9e59d | 2015-05-12 07:17:50 -0700 | [diff] [blame] | 218 | FrameInfoVisualizer mProfiler; |
Andres Morales | 910beb8 | 2016-02-02 16:19:40 -0800 | [diff] [blame] | 219 | std::unique_ptr<FrameMetricsReporter> mFrameMetricsReporter; |
John Reck | 998a6d8 | 2014-08-28 15:35:53 -0700 | [diff] [blame] | 220 | |
John Reck | 51f2d60 | 2016-04-06 07:50:47 -0700 | [diff] [blame^] | 221 | std::set<RenderNode*> mPrefetchedLayers; |
Skuhne | ea7a7fb | 2015-08-28 07:10:31 -0700 | [diff] [blame] | 222 | |
| 223 | // Stores the bounds of the main content. |
Skuhne | b816087 | 2015-09-22 09:51:39 -0700 | [diff] [blame] | 224 | Rect mContentDrawBounds; |
John Reck | 38f6c03 | 2016-03-17 10:23:49 -0700 | [diff] [blame] | 225 | |
| 226 | // TODO: This is really a Task<void> but that doesn't really work |
| 227 | // when Future<> expects to be able to get/set a value |
| 228 | struct FuncTask : public Task<bool> { |
| 229 | std::function<void()> func; |
| 230 | }; |
| 231 | class FuncTaskProcessor; |
| 232 | |
| 233 | std::vector< sp<FuncTask> > mFrameFences; |
| 234 | sp<TaskProcessor<bool> > mFrameWorkProcessor; |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 235 | }; |
| 236 | |
| 237 | } /* namespace renderthread */ |
| 238 | } /* namespace uirenderer */ |
| 239 | } /* namespace android */ |
| 240 | #endif /* CANVASCONTEXT_H_ */ |