David Sodman | 0c69cad | 2017-08-21 12:12:51 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2017 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 | #pragma once |
| 18 | |
Lloyd Pique | feb73d7 | 2018-12-04 17:23:44 -0800 | [diff] [blame] | 19 | #include <sys/types.h> |
| 20 | #include <cstdint> |
| 21 | #include <list> |
David Sodman | 0c69cad | 2017-08-21 12:12:51 -0700 | [diff] [blame] | 22 | |
| 23 | #include <gui/ISurfaceComposerClient.h> |
| 24 | #include <gui/LayerState.h> |
Alec Mouri | e7d1d4a | 2019-02-05 01:13:46 +0000 | [diff] [blame] | 25 | #include <renderengine/Image.h> |
Peiyong Lin | cbc184f | 2018-08-22 13:24:10 -0700 | [diff] [blame] | 26 | #include <renderengine/Mesh.h> |
| 27 | #include <renderengine/Texture.h> |
Lloyd Pique | feb73d7 | 2018-12-04 17:23:44 -0800 | [diff] [blame] | 28 | #include <system/window.h> // For NATIVE_WINDOW_SCALING_MODE_FREEZE |
David Sodman | 0c69cad | 2017-08-21 12:12:51 -0700 | [diff] [blame] | 29 | #include <ui/FrameStats.h> |
| 30 | #include <ui/GraphicBuffer.h> |
| 31 | #include <ui/PixelFormat.h> |
| 32 | #include <ui/Region.h> |
David Sodman | 0c69cad | 2017-08-21 12:12:51 -0700 | [diff] [blame] | 33 | #include <utils/RefBase.h> |
| 34 | #include <utils/String8.h> |
| 35 | #include <utils/Timers.h> |
| 36 | |
Lloyd Pique | feb73d7 | 2018-12-04 17:23:44 -0800 | [diff] [blame] | 37 | #include "BufferLayerConsumer.h" |
| 38 | #include "Client.h" |
| 39 | #include "DisplayHardware/HWComposer.h" |
Adithya Srinivasan | 5f683cf | 2020-09-15 14:21:04 -0700 | [diff] [blame] | 40 | #include "FrameTimeline.h" |
Lloyd Pique | feb73d7 | 2018-12-04 17:23:44 -0800 | [diff] [blame] | 41 | #include "FrameTracker.h" |
| 42 | #include "Layer.h" |
| 43 | #include "LayerVector.h" |
| 44 | #include "MonitoredProducer.h" |
| 45 | #include "SurfaceFlinger.h" |
David Sodman | 0c69cad | 2017-08-21 12:12:51 -0700 | [diff] [blame] | 46 | |
| 47 | namespace android { |
| 48 | |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 49 | class BufferLayer : public Layer { |
David Sodman | 0c69cad | 2017-08-21 12:12:51 -0700 | [diff] [blame] | 50 | public: |
Lloyd Pique | 42ab75e | 2018-09-12 20:46:03 -0700 | [diff] [blame] | 51 | explicit BufferLayer(const LayerCreationArgs& args); |
Alec Mouri | 4545a8a | 2019-08-08 20:05:32 -0700 | [diff] [blame] | 52 | virtual ~BufferLayer() override; |
David Sodman | 0c69cad | 2017-08-21 12:12:51 -0700 | [diff] [blame] | 53 | |
Peiyong Lin | f243e5e | 2020-08-22 17:40:59 -0700 | [diff] [blame] | 54 | // Implements Layer. |
Lloyd Pique | de19665 | 2020-01-22 17:29:58 -0800 | [diff] [blame] | 55 | sp<compositionengine::LayerFE> getCompositionEngineLayerFE() const override; |
| 56 | compositionengine::LayerFECompositionState* editCompositionState() override; |
Lloyd Pique | feb73d7 | 2018-12-04 17:23:44 -0800 | [diff] [blame] | 57 | |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 58 | // If we have received a new buffer this frame, we will pass its surface |
| 59 | // damage down to hardware composer. Otherwise, we must send a region with |
| 60 | // one empty rect. |
| 61 | void useSurfaceDamage() override; |
| 62 | void useEmptyDamage() override; |
David Sodman | 0c69cad | 2017-08-21 12:12:51 -0700 | [diff] [blame] | 63 | |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 64 | bool isOpaque(const Layer::State& s) const override; |
David Sodman | 0c69cad | 2017-08-21 12:12:51 -0700 | [diff] [blame] | 65 | |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 66 | // isVisible - true if this layer is visible, false otherwise |
Lloyd Pique | 0449b0f | 2018-12-20 16:23:45 -0800 | [diff] [blame] | 67 | bool isVisible() const override; |
David Sodman | 0c69cad | 2017-08-21 12:12:51 -0700 | [diff] [blame] | 68 | |
Peiyong Lin | fb530cf | 2018-12-15 05:07:38 +0000 | [diff] [blame] | 69 | // isProtected - true if the layer may contain protected content in the |
| 70 | // GRALLOC_USAGE_PROTECTED sense. |
| 71 | bool isProtected() const override; |
| 72 | |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 73 | // isFixedSize - true if content has a fixed size |
David Sodman | 0c69cad | 2017-08-21 12:12:51 -0700 | [diff] [blame] | 74 | bool isFixedSize() const override; |
| 75 | |
Lloyd Pique | a83776c | 2019-01-29 18:42:32 -0800 | [diff] [blame] | 76 | bool usesSourceCrop() const override; |
| 77 | |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 78 | bool isHdrY410() const override; |
David Sodman | eb085e0 | 2017-10-05 18:49:04 -0700 | [diff] [blame] | 79 | |
Dominik Laskowski | b7251f4 | 2020-04-20 17:42:59 -0700 | [diff] [blame] | 80 | bool onPostComposition(const DisplayDevice*, const std::shared_ptr<FenceTime>& glDoneFence, |
David Sodman | eb085e0 | 2017-10-05 18:49:04 -0700 | [diff] [blame] | 81 | const std::shared_ptr<FenceTime>& presentFence, |
Dominik Laskowski | b7251f4 | 2020-04-20 17:42:59 -0700 | [diff] [blame] | 82 | const CompositorTiming&) override; |
David Sodman | eb085e0 | 2017-10-05 18:49:04 -0700 | [diff] [blame] | 83 | |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 84 | // latchBuffer - called each time the screen is redrawn and returns whether |
| 85 | // the visible regions need to be recomputed (this is a fairly heavy |
| 86 | // operation, so this should be set only if needed). Typically this is used |
| 87 | // to figure out if the content or size of a surface has changed. |
Dominik Laskowski | a8955dd | 2019-07-10 10:19:09 -0700 | [diff] [blame] | 88 | bool latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime, |
| 89 | nsecs_t expectedPresentTime) override; |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 90 | |
David Sodman | 0c69cad | 2017-08-21 12:12:51 -0700 | [diff] [blame] | 91 | bool isBufferLatched() const override { return mRefreshPending; } |
| 92 | |
Lloyd Pique | 0449b0f | 2018-12-20 16:23:45 -0800 | [diff] [blame] | 93 | bool hasReadyFrame() const override; |
David Sodman | 0c69cad | 2017-08-21 12:12:51 -0700 | [diff] [blame] | 94 | |
Robert Carr | 916b036 | 2020-10-06 13:53:03 -0700 | [diff] [blame] | 95 | // Returns the current scaling mode |
David Sodman | 0c69cad | 2017-08-21 12:12:51 -0700 | [diff] [blame] | 96 | uint32_t getEffectiveScalingMode() const override; |
chaviw | 49a108c | 2019-08-12 11:23:06 -0700 | [diff] [blame] | 97 | |
| 98 | // Calls latchBuffer if the buffer has a frame queued and then releases the buffer. |
| 99 | // This is used if the buffer is just latched and releases to free up the buffer |
| 100 | // and will not be shown on screen. |
| 101 | // Should only be called on the main thread. |
| 102 | void latchAndReleaseBuffer() override; |
| 103 | |
chaviw | 4244e03 | 2019-09-04 11:27:49 -0700 | [diff] [blame] | 104 | bool getTransformToDisplayInverse() const override; |
| 105 | |
| 106 | Rect getBufferCrop() const override; |
| 107 | |
| 108 | uint32_t getBufferTransform() const override; |
| 109 | |
| 110 | ui::Dataspace getDataSpace() const override; |
| 111 | |
chaviw | d62d306 | 2019-09-04 14:48:02 -0700 | [diff] [blame] | 112 | sp<GraphicBuffer> getBuffer() const override; |
| 113 | |
Vishnu Nair | 6213bd9 | 2020-05-08 17:42:25 -0700 | [diff] [blame] | 114 | ui::Transform::RotationFlags getTransformHint() const override { return mTransformHint; } |
| 115 | |
Vishnu Nair | e7f79c5 | 2020-10-29 14:45:03 -0700 | [diff] [blame] | 116 | // Returns true if the transformed buffer size does not match the layer size and we need |
| 117 | // to apply filtering. |
| 118 | virtual bool bufferNeedsFiltering() const; |
| 119 | |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 120 | protected: |
chaviw | 4244e03 | 2019-09-04 11:27:49 -0700 | [diff] [blame] | 121 | struct BufferInfo { |
| 122 | nsecs_t mDesiredPresentTime; |
| 123 | std::shared_ptr<FenceTime> mFenceTime; |
| 124 | sp<Fence> mFence; |
chaviw | 4244e03 | 2019-09-04 11:27:49 -0700 | [diff] [blame] | 125 | uint32_t mTransform{0}; |
chaviw | f83ce18 | 2019-09-12 14:43:08 -0700 | [diff] [blame] | 126 | ui::Dataspace mDataspace{ui::Dataspace::UNKNOWN}; |
chaviw | 4244e03 | 2019-09-04 11:27:49 -0700 | [diff] [blame] | 127 | Rect mCrop; |
| 128 | uint32_t mScaleMode{NATIVE_WINDOW_SCALING_MODE_FREEZE}; |
| 129 | Region mSurfaceDamage; |
| 130 | HdrMetadata mHdrMetadata; |
| 131 | int mApi; |
chaviw | debadb8 | 2020-03-26 14:57:24 -0700 | [diff] [blame] | 132 | PixelFormat mPixelFormat{PIXEL_FORMAT_NONE}; |
chaviw | 4244e03 | 2019-09-04 11:27:49 -0700 | [diff] [blame] | 133 | bool mTransformToDisplayInverse{false}; |
chaviw | d62d306 | 2019-09-04 14:48:02 -0700 | [diff] [blame] | 134 | |
Alec Mouri | a90a570 | 2021-04-16 16:36:21 +0000 | [diff] [blame^] | 135 | std::shared_ptr<renderengine::ExternalTexture> mBuffer; |
chaviw | d62d306 | 2019-09-04 14:48:02 -0700 | [diff] [blame] | 136 | int mBufferSlot{BufferQueue::INVALID_BUFFER_SLOT}; |
chaviw | 74b0317 | 2019-08-19 11:09:03 -0700 | [diff] [blame] | 137 | |
| 138 | bool mFrameLatencyNeeded{false}; |
chaviw | 4244e03 | 2019-09-04 11:27:49 -0700 | [diff] [blame] | 139 | }; |
| 140 | |
| 141 | BufferInfo mBufferInfo; |
| 142 | virtual void gatherBufferInfo() = 0; |
| 143 | |
Vishnu Nair | b87d94f | 2020-02-13 09:17:36 -0800 | [diff] [blame] | 144 | std::optional<compositionengine::LayerFE::LayerSettings> prepareClientComposition( |
| 145 | compositionengine::LayerFE::ClientCompositionTargetSettings&) override; |
| 146 | |
Lloyd Pique | f16688f | 2019-02-19 17:47:57 -0800 | [diff] [blame] | 147 | /* |
| 148 | * compositionengine::LayerFE overrides |
| 149 | */ |
Lloyd Pique | de19665 | 2020-01-22 17:29:58 -0800 | [diff] [blame] | 150 | const compositionengine::LayerFECompositionState* getCompositionState() const override; |
Lloyd Pique | f16688f | 2019-02-19 17:47:57 -0800 | [diff] [blame] | 151 | bool onPreComposition(nsecs_t) override; |
Lloyd Pique | de19665 | 2020-01-22 17:29:58 -0800 | [diff] [blame] | 152 | void preparePerFrameCompositionState() override; |
Lloyd Pique | f527548 | 2019-01-29 18:42:42 -0800 | [diff] [blame] | 153 | |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 154 | static bool getOpacityForFormat(uint32_t format); |
David Sodman | 0c69cad | 2017-08-21 12:12:51 -0700 | [diff] [blame] | 155 | |
Peiyong Lin | f3ffc4e | 2019-12-13 00:46:24 -0800 | [diff] [blame] | 156 | // from graphics API |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 157 | const uint32_t mTextureName; |
| 158 | |
chaviw | f206b66 | 2019-01-11 13:07:19 -0800 | [diff] [blame] | 159 | bool mRefreshPending{false}; |
| 160 | |
chaviw | 4244e03 | 2019-09-04 11:27:49 -0700 | [diff] [blame] | 161 | ui::Dataspace translateDataspace(ui::Dataspace dataspace); |
chaviw | b4c6e58 | 2019-08-16 14:35:07 -0700 | [diff] [blame] | 162 | void setInitialValuesForClone(const sp<Layer>& clonedFrom); |
chaviw | 74b0317 | 2019-08-19 11:09:03 -0700 | [diff] [blame] | 163 | void updateCloneBufferInfo() override; |
| 164 | uint64_t mPreviousFrameNumber = 0; |
chaviw | 4244e03 | 2019-09-04 11:27:49 -0700 | [diff] [blame] | 165 | |
Vishnu Nair | 6b7c5c9 | 2020-09-29 17:27:05 -0700 | [diff] [blame] | 166 | uint64_t getHeadFrameNumber(nsecs_t expectedPresentTime) const override; |
Robert Carr | fe1209c | 2020-02-11 12:25:35 -0800 | [diff] [blame] | 167 | |
Dominik Laskowski | b7251f4 | 2020-04-20 17:42:59 -0700 | [diff] [blame] | 168 | void setTransformHint(ui::Transform::RotationFlags displayTransformHint) override; |
| 169 | |
Vishnu Nair | 6213bd9 | 2020-05-08 17:42:25 -0700 | [diff] [blame] | 170 | // Transform hint provided to the producer. This must be accessed holding |
Ady Abraham | 63a3e59 | 2021-01-06 10:47:15 -0800 | [diff] [blame] | 171 | // the mStateLock. |
Dominik Laskowski | b7251f4 | 2020-04-20 17:42:59 -0700 | [diff] [blame] | 172 | ui::Transform::RotationFlags mTransformHint = ui::Transform::ROT_0; |
Vishnu Nair | 6213bd9 | 2020-05-08 17:42:25 -0700 | [diff] [blame] | 173 | |
Vishnu Nair | cf26a0a | 2020-11-13 12:56:20 -0800 | [diff] [blame] | 174 | bool getAutoRefresh() const { return mAutoRefresh; } |
| 175 | bool getSidebandStreamChanged() const { return mSidebandStreamChanged; } |
| 176 | |
Ady Abraham | 63a3e59 | 2021-01-06 10:47:15 -0800 | [diff] [blame] | 177 | // Returns true if the next buffer should be presented at the expected present time |
Robert Carr | 6a5dc1f | 2021-03-11 12:36:40 -0800 | [diff] [blame] | 178 | bool shouldPresentNow(nsecs_t expectedPresentTime) const; |
Ady Abraham | 63a3e59 | 2021-01-06 10:47:15 -0800 | [diff] [blame] | 179 | |
| 180 | // Returns true if the next buffer should be presented at the expected present time, |
| 181 | // overridden by BufferStateLayer and BufferQueueLayer for implementation |
| 182 | // specific logic |
| 183 | virtual bool isBufferDue(nsecs_t /*expectedPresentTime*/) const = 0; |
| 184 | |
Vishnu Nair | cf26a0a | 2020-11-13 12:56:20 -0800 | [diff] [blame] | 185 | std::atomic<bool> mAutoRefresh{false}; |
| 186 | std::atomic<bool> mSidebandStreamChanged{false}; |
| 187 | |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 188 | private: |
Peiyong Lin | f243e5e | 2020-08-22 17:40:59 -0700 | [diff] [blame] | 189 | virtual bool fenceHasSignaled() const = 0; |
| 190 | virtual bool framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const = 0; |
| 191 | virtual uint64_t getFrameNumber(nsecs_t expectedPresentTime) const = 0; |
| 192 | |
Peiyong Lin | f243e5e | 2020-08-22 17:40:59 -0700 | [diff] [blame] | 193 | |
| 194 | // Latch sideband stream and returns true if the dirty region should be updated. |
| 195 | virtual bool latchSidebandStream(bool& recomputeVisibleRegions) = 0; |
| 196 | |
| 197 | virtual bool hasFrameUpdate() const = 0; |
| 198 | |
Peiyong Lin | f243e5e | 2020-08-22 17:40:59 -0700 | [diff] [blame] | 199 | virtual status_t updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime, |
| 200 | nsecs_t expectedPresentTime) = 0; |
| 201 | |
| 202 | virtual status_t updateActiveBuffer() = 0; |
| 203 | virtual status_t updateFrameNumber(nsecs_t latchTime) = 0; |
| 204 | |
| 205 | // We generate InputWindowHandles for all non-cursor buffered layers regardless of whether they |
| 206 | // have an InputChannel. This is to enable the InputDispatcher to do PID based occlusion |
| 207 | // detection. |
| 208 | bool needsInputInfo() const override { return !mPotentialCursor; } |
| 209 | |
Peiyong Lin | c2020ca | 2019-01-10 11:36:12 -0800 | [diff] [blame] | 210 | // Returns true if this layer requires filtering |
Dominik Laskowski | b7251f4 | 2020-04-20 17:42:59 -0700 | [diff] [blame] | 211 | bool needsFiltering(const DisplayDevice*) const override; |
| 212 | bool needsFilteringForScreenshots(const DisplayDevice*, |
Alec Mouri | 5a6d857 | 2020-03-23 23:56:15 -0700 | [diff] [blame] | 213 | const ui::Transform& inverseParentTransform) const override; |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 214 | |
Marissa Wall | 290ad08 | 2019-03-06 13:23:47 -0800 | [diff] [blame] | 215 | // BufferStateLayers can return Rect::INVALID_RECT if the layer does not have a display frame |
| 216 | // and its parent layer is not bounded |
Lloyd Pique | 0449b0f | 2018-12-20 16:23:45 -0800 | [diff] [blame] | 217 | Rect getBufferSize(const State& s) const override; |
Lloyd Pique | feb73d7 | 2018-12-04 17:23:44 -0800 | [diff] [blame] | 218 | |
Peiyong Lin | f243e5e | 2020-08-22 17:40:59 -0700 | [diff] [blame] | 219 | PixelFormat getPixelFormat() const; |
| 220 | |
| 221 | // Computes the transform matrix using the setFilteringEnabled to determine whether the |
| 222 | // transform matrix should be computed for use with bilinear filtering. |
| 223 | void getDrawingTransformMatrix(bool filteringEnabled, float outMatrix[16]); |
| 224 | |
Lloyd Pique | de19665 | 2020-01-22 17:29:58 -0800 | [diff] [blame] | 225 | std::unique_ptr<compositionengine::LayerFECompositionState> mCompositionState; |
Vishnu Nair | 4351ad5 | 2019-02-11 14:13:02 -0800 | [diff] [blame] | 226 | |
| 227 | FloatRect computeSourceBounds(const FloatRect& parentBounds) const override; |
David Sodman | 0c69cad | 2017-08-21 12:12:51 -0700 | [diff] [blame] | 228 | }; |
| 229 | |
| 230 | } // namespace android |