blob: 54c060bf9f74588259245285ec9fff0bc4644c3b [file] [log] [blame]
David Sodman0c69cad2017-08-21 12:12:51 -07001/*
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 Piquefeb73d72018-12-04 17:23:44 -080019#include <sys/types.h>
20#include <cstdint>
21#include <list>
David Sodman0c69cad2017-08-21 12:12:51 -070022
23#include <gui/ISurfaceComposerClient.h>
24#include <gui/LayerState.h>
Alec Mourie7d1d4a2019-02-05 01:13:46 +000025#include <renderengine/Image.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070026#include <renderengine/Mesh.h>
27#include <renderengine/Texture.h>
Lloyd Piquefeb73d72018-12-04 17:23:44 -080028#include <system/window.h> // For NATIVE_WINDOW_SCALING_MODE_FREEZE
David Sodman0c69cad2017-08-21 12:12:51 -070029#include <ui/FrameStats.h>
30#include <ui/GraphicBuffer.h>
31#include <ui/PixelFormat.h>
32#include <ui/Region.h>
David Sodman0c69cad2017-08-21 12:12:51 -070033#include <utils/RefBase.h>
34#include <utils/String8.h>
35#include <utils/Timers.h>
36
Lloyd Piquefeb73d72018-12-04 17:23:44 -080037#include "BufferLayerConsumer.h"
38#include "Client.h"
39#include "DisplayHardware/HWComposer.h"
Lloyd Piquefeb73d72018-12-04 17:23:44 -080040#include "FrameTracker.h"
41#include "Layer.h"
42#include "LayerVector.h"
43#include "MonitoredProducer.h"
44#include "SurfaceFlinger.h"
David Sodman0c69cad2017-08-21 12:12:51 -070045
46namespace android {
47
Marissa Wallfd668622018-05-10 10:21:13 -070048class BufferLayer : public Layer {
David Sodman0c69cad2017-08-21 12:12:51 -070049public:
Lloyd Pique42ab75e2018-09-12 20:46:03 -070050 explicit BufferLayer(const LayerCreationArgs& args);
Alec Mouri4545a8a2019-08-08 20:05:32 -070051 virtual ~BufferLayer() override;
David Sodman0c69cad2017-08-21 12:12:51 -070052
Peiyong Linf243e5e2020-08-22 17:40:59 -070053 // Implements Layer.
Lloyd Piquede196652020-01-22 17:29:58 -080054 sp<compositionengine::LayerFE> getCompositionEngineLayerFE() const override;
55 compositionengine::LayerFECompositionState* editCompositionState() override;
Lloyd Piquefeb73d72018-12-04 17:23:44 -080056
Marissa Wallfd668622018-05-10 10:21:13 -070057 // If we have received a new buffer this frame, we will pass its surface
58 // damage down to hardware composer. Otherwise, we must send a region with
59 // one empty rect.
60 void useSurfaceDamage() override;
61 void useEmptyDamage() override;
David Sodman0c69cad2017-08-21 12:12:51 -070062
Marissa Wallfd668622018-05-10 10:21:13 -070063 bool isOpaque(const Layer::State& s) const override;
David Sodman0c69cad2017-08-21 12:12:51 -070064
Marissa Wallfd668622018-05-10 10:21:13 -070065 // isVisible - true if this layer is visible, false otherwise
Lloyd Pique0449b0f2018-12-20 16:23:45 -080066 bool isVisible() const override;
David Sodman0c69cad2017-08-21 12:12:51 -070067
Peiyong Linfb530cf2018-12-15 05:07:38 +000068 // isProtected - true if the layer may contain protected content in the
69 // GRALLOC_USAGE_PROTECTED sense.
70 bool isProtected() const override;
71
Marissa Wallfd668622018-05-10 10:21:13 -070072 // isFixedSize - true if content has a fixed size
David Sodman0c69cad2017-08-21 12:12:51 -070073 bool isFixedSize() const override;
74
Lloyd Piquea83776c2019-01-29 18:42:32 -080075 bool usesSourceCrop() const override;
76
Marissa Wallfd668622018-05-10 10:21:13 -070077 bool isHdrY410() const override;
David Sodmaneb085e02017-10-05 18:49:04 -070078
Dominik Laskowskib7251f42020-04-20 17:42:59 -070079 bool onPostComposition(const DisplayDevice*, const std::shared_ptr<FenceTime>& glDoneFence,
David Sodmaneb085e02017-10-05 18:49:04 -070080 const std::shared_ptr<FenceTime>& presentFence,
Dominik Laskowskib7251f42020-04-20 17:42:59 -070081 const CompositorTiming&) override;
David Sodmaneb085e02017-10-05 18:49:04 -070082
Marissa Wallfd668622018-05-10 10:21:13 -070083 // latchBuffer - called each time the screen is redrawn and returns whether
84 // the visible regions need to be recomputed (this is a fairly heavy
85 // operation, so this should be set only if needed). Typically this is used
86 // to figure out if the content or size of a surface has changed.
Dominik Laskowskia8955dd2019-07-10 10:19:09 -070087 bool latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime,
88 nsecs_t expectedPresentTime) override;
Marissa Wallfd668622018-05-10 10:21:13 -070089
David Sodman0c69cad2017-08-21 12:12:51 -070090 bool isBufferLatched() const override { return mRefreshPending; }
91
Dominik Laskowskia8955dd2019-07-10 10:19:09 -070092 void notifyAvailableFrames(nsecs_t expectedPresentTime) override;
Chia-I Wu692e0832018-06-05 15:46:58 -070093
Lloyd Pique0449b0f2018-12-20 16:23:45 -080094 bool hasReadyFrame() const override;
David Sodman0c69cad2017-08-21 12:12:51 -070095
David Sodman0c69cad2017-08-21 12:12:51 -070096 // Returns the current scaling mode, unless mOverrideScalingMode
97 // is set, in which case, it returns mOverrideScalingMode
98 uint32_t getEffectiveScalingMode() const override;
chaviw49a108c2019-08-12 11:23:06 -070099
100 // Calls latchBuffer if the buffer has a frame queued and then releases the buffer.
101 // This is used if the buffer is just latched and releases to free up the buffer
102 // and will not be shown on screen.
103 // Should only be called on the main thread.
104 void latchAndReleaseBuffer() override;
105
chaviw4244e032019-09-04 11:27:49 -0700106 bool getTransformToDisplayInverse() const override;
107
108 Rect getBufferCrop() const override;
109
110 uint32_t getBufferTransform() const override;
111
112 ui::Dataspace getDataSpace() const override;
113
chaviwd62d3062019-09-04 14:48:02 -0700114 sp<GraphicBuffer> getBuffer() const override;
115
Vishnu Nair6213bd92020-05-08 17:42:25 -0700116 ui::Transform::RotationFlags getTransformHint() const override { return mTransformHint; }
117
Marissa Wallfd668622018-05-10 10:21:13 -0700118protected:
chaviw4244e032019-09-04 11:27:49 -0700119 struct BufferInfo {
120 nsecs_t mDesiredPresentTime;
121 std::shared_ptr<FenceTime> mFenceTime;
122 sp<Fence> mFence;
chaviw4244e032019-09-04 11:27:49 -0700123 uint32_t mTransform{0};
chaviwf83ce182019-09-12 14:43:08 -0700124 ui::Dataspace mDataspace{ui::Dataspace::UNKNOWN};
chaviw4244e032019-09-04 11:27:49 -0700125 Rect mCrop;
126 uint32_t mScaleMode{NATIVE_WINDOW_SCALING_MODE_FREEZE};
127 Region mSurfaceDamage;
128 HdrMetadata mHdrMetadata;
129 int mApi;
chaviwdebadb82020-03-26 14:57:24 -0700130 PixelFormat mPixelFormat{PIXEL_FORMAT_NONE};
chaviw4244e032019-09-04 11:27:49 -0700131 bool mTransformToDisplayInverse{false};
chaviwd62d3062019-09-04 14:48:02 -0700132
133 sp<GraphicBuffer> mBuffer;
134 int mBufferSlot{BufferQueue::INVALID_BUFFER_SLOT};
chaviw74b03172019-08-19 11:09:03 -0700135
136 bool mFrameLatencyNeeded{false};
chaviw4244e032019-09-04 11:27:49 -0700137 };
138
139 BufferInfo mBufferInfo;
140 virtual void gatherBufferInfo() = 0;
141
Vishnu Nairb87d94f2020-02-13 09:17:36 -0800142 std::optional<compositionengine::LayerFE::LayerSettings> prepareClientComposition(
143 compositionengine::LayerFE::ClientCompositionTargetSettings&) override;
144
Lloyd Piquef16688f2019-02-19 17:47:57 -0800145 /*
146 * compositionengine::LayerFE overrides
147 */
Lloyd Piquede196652020-01-22 17:29:58 -0800148 const compositionengine::LayerFECompositionState* getCompositionState() const override;
Lloyd Piquef16688f2019-02-19 17:47:57 -0800149 bool onPreComposition(nsecs_t) override;
Lloyd Piquede196652020-01-22 17:29:58 -0800150 void preparePerFrameCompositionState() override;
Lloyd Piquef5275482019-01-29 18:42:42 -0800151
David Sodman0c69cad2017-08-21 12:12:51 -0700152 // Check all of the local sync points to ensure that all transactions
153 // which need to have been applied prior to the frame which is about to
154 // be latched have signaled
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700155 bool allTransactionsSignaled(nsecs_t expectedPresentTime);
David Sodman0c69cad2017-08-21 12:12:51 -0700156
Marissa Wallfd668622018-05-10 10:21:13 -0700157 static bool getOpacityForFormat(uint32_t format);
David Sodman0c69cad2017-08-21 12:12:51 -0700158
Peiyong Linf3ffc4e2019-12-13 00:46:24 -0800159 // from graphics API
Marissa Wallfd668622018-05-10 10:21:13 -0700160 const uint32_t mTextureName;
161
chaviwf206b662019-01-11 13:07:19 -0800162 bool mRefreshPending{false};
163
chaviw4244e032019-09-04 11:27:49 -0700164 ui::Dataspace translateDataspace(ui::Dataspace dataspace);
chaviwb4c6e582019-08-16 14:35:07 -0700165 void setInitialValuesForClone(const sp<Layer>& clonedFrom);
chaviw74b03172019-08-19 11:09:03 -0700166 void updateCloneBufferInfo() override;
167 uint64_t mPreviousFrameNumber = 0;
chaviw4244e032019-09-04 11:27:49 -0700168
Robert Carrfe1209c2020-02-11 12:25:35 -0800169 virtual uint64_t getHeadFrameNumber(nsecs_t expectedPresentTime) const;
170
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700171 void setTransformHint(ui::Transform::RotationFlags displayTransformHint) override;
172
Vishnu Nair6213bd92020-05-08 17:42:25 -0700173 // Transform hint provided to the producer. This must be accessed holding
174 /// the mStateLock.
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700175 ui::Transform::RotationFlags mTransformHint = ui::Transform::ROT_0;
Vishnu Nair6213bd92020-05-08 17:42:25 -0700176
Marissa Wallfd668622018-05-10 10:21:13 -0700177private:
Peiyong Linf243e5e2020-08-22 17:40:59 -0700178 virtual bool fenceHasSignaled() const = 0;
179 virtual bool framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const = 0;
180 virtual uint64_t getFrameNumber(nsecs_t expectedPresentTime) const = 0;
181
182 virtual bool getAutoRefresh() const = 0;
183 virtual bool getSidebandStreamChanged() const = 0;
184
185 // Latch sideband stream and returns true if the dirty region should be updated.
186 virtual bool latchSidebandStream(bool& recomputeVisibleRegions) = 0;
187
188 virtual bool hasFrameUpdate() const = 0;
189
190 virtual status_t bindTextureImage() = 0;
191 virtual status_t updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime,
192 nsecs_t expectedPresentTime) = 0;
193
194 virtual status_t updateActiveBuffer() = 0;
195 virtual status_t updateFrameNumber(nsecs_t latchTime) = 0;
196
197 // We generate InputWindowHandles for all non-cursor buffered layers regardless of whether they
198 // have an InputChannel. This is to enable the InputDispatcher to do PID based occlusion
199 // detection.
200 bool needsInputInfo() const override { return !mPotentialCursor; }
201
Peiyong Linc2020ca2019-01-10 11:36:12 -0800202 // Returns true if this layer requires filtering
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700203 bool needsFiltering(const DisplayDevice*) const override;
204 bool needsFilteringForScreenshots(const DisplayDevice*,
Alec Mouri5a6d8572020-03-23 23:56:15 -0700205 const ui::Transform& inverseParentTransform) const override;
Marissa Wallfd668622018-05-10 10:21:13 -0700206
Marissa Wall290ad082019-03-06 13:23:47 -0800207 // BufferStateLayers can return Rect::INVALID_RECT if the layer does not have a display frame
208 // and its parent layer is not bounded
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800209 Rect getBufferSize(const State& s) const override;
Lloyd Piquefeb73d72018-12-04 17:23:44 -0800210
Peiyong Linf243e5e2020-08-22 17:40:59 -0700211 PixelFormat getPixelFormat() const;
212
213 // Computes the transform matrix using the setFilteringEnabled to determine whether the
214 // transform matrix should be computed for use with bilinear filtering.
215 void getDrawingTransformMatrix(bool filteringEnabled, float outMatrix[16]);
216
Lloyd Piquede196652020-01-22 17:29:58 -0800217 std::unique_ptr<compositionengine::LayerFECompositionState> mCompositionState;
Vishnu Nair4351ad52019-02-11 14:13:02 -0800218
219 FloatRect computeSourceBounds(const FloatRect& parentBounds) const override;
David Sodman0c69cad2017-08-21 12:12:51 -0700220};
221
222} // namespace android