blob: cd3d80e8094f88d975c366f01083cbc27cc6a824 [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"
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -070040#include "FrameTimeline.h"
Lloyd Piquefeb73d72018-12-04 17:23:44 -080041#include "FrameTracker.h"
42#include "Layer.h"
43#include "LayerVector.h"
44#include "MonitoredProducer.h"
45#include "SurfaceFlinger.h"
David Sodman0c69cad2017-08-21 12:12:51 -070046
47namespace android {
48
Marissa Wallfd668622018-05-10 10:21:13 -070049class BufferLayer : public Layer {
David Sodman0c69cad2017-08-21 12:12:51 -070050public:
Lloyd Pique42ab75e2018-09-12 20:46:03 -070051 explicit BufferLayer(const LayerCreationArgs& args);
Alec Mouri4545a8a2019-08-08 20:05:32 -070052 virtual ~BufferLayer() override;
David Sodman0c69cad2017-08-21 12:12:51 -070053
Peiyong Linf243e5e2020-08-22 17:40:59 -070054 // Implements Layer.
Lloyd Piquede196652020-01-22 17:29:58 -080055 sp<compositionengine::LayerFE> getCompositionEngineLayerFE() const override;
56 compositionengine::LayerFECompositionState* editCompositionState() override;
Lloyd Piquefeb73d72018-12-04 17:23:44 -080057
Marissa Wallfd668622018-05-10 10:21:13 -070058 // 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 Sodman0c69cad2017-08-21 12:12:51 -070063
Marissa Wallfd668622018-05-10 10:21:13 -070064 bool isOpaque(const Layer::State& s) const override;
David Sodman0c69cad2017-08-21 12:12:51 -070065
Marissa Wallfd668622018-05-10 10:21:13 -070066 // isVisible - true if this layer is visible, false otherwise
Lloyd Pique0449b0f2018-12-20 16:23:45 -080067 bool isVisible() const override;
David Sodman0c69cad2017-08-21 12:12:51 -070068
Peiyong Linfb530cf2018-12-15 05:07:38 +000069 // isProtected - true if the layer may contain protected content in the
70 // GRALLOC_USAGE_PROTECTED sense.
71 bool isProtected() const override;
72
Marissa Wallfd668622018-05-10 10:21:13 -070073 // isFixedSize - true if content has a fixed size
David Sodman0c69cad2017-08-21 12:12:51 -070074 bool isFixedSize() const override;
75
Lloyd Piquea83776c2019-01-29 18:42:32 -080076 bool usesSourceCrop() const override;
77
Marissa Wallfd668622018-05-10 10:21:13 -070078 bool isHdrY410() const override;
David Sodmaneb085e02017-10-05 18:49:04 -070079
Dominik Laskowskib7251f42020-04-20 17:42:59 -070080 bool onPostComposition(const DisplayDevice*, const std::shared_ptr<FenceTime>& glDoneFence,
David Sodmaneb085e02017-10-05 18:49:04 -070081 const std::shared_ptr<FenceTime>& presentFence,
Dominik Laskowskib7251f42020-04-20 17:42:59 -070082 const CompositorTiming&) override;
David Sodmaneb085e02017-10-05 18:49:04 -070083
Marissa Wallfd668622018-05-10 10:21:13 -070084 // 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 Laskowskia8955dd2019-07-10 10:19:09 -070088 bool latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime,
89 nsecs_t expectedPresentTime) override;
Marissa Wallfd668622018-05-10 10:21:13 -070090
David Sodman0c69cad2017-08-21 12:12:51 -070091 bool isBufferLatched() const override { return mRefreshPending; }
92
Lloyd Pique0449b0f2018-12-20 16:23:45 -080093 bool hasReadyFrame() const override;
David Sodman0c69cad2017-08-21 12:12:51 -070094
Robert Carr916b0362020-10-06 13:53:03 -070095 // Returns the current scaling mode
David Sodman0c69cad2017-08-21 12:12:51 -070096 uint32_t getEffectiveScalingMode() const override;
chaviw49a108c2019-08-12 11:23:06 -070097
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
chaviw4244e032019-09-04 11:27:49 -0700104 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
chaviwd62d3062019-09-04 14:48:02 -0700112 sp<GraphicBuffer> getBuffer() const override;
113
Vishnu Nair6213bd92020-05-08 17:42:25 -0700114 ui::Transform::RotationFlags getTransformHint() const override { return mTransformHint; }
115
Vishnu Naire7f79c52020-10-29 14:45:03 -0700116 // 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 Wallfd668622018-05-10 10:21:13 -0700120protected:
chaviw4244e032019-09-04 11:27:49 -0700121 struct BufferInfo {
122 nsecs_t mDesiredPresentTime;
123 std::shared_ptr<FenceTime> mFenceTime;
124 sp<Fence> mFence;
chaviw4244e032019-09-04 11:27:49 -0700125 uint32_t mTransform{0};
chaviwf83ce182019-09-12 14:43:08 -0700126 ui::Dataspace mDataspace{ui::Dataspace::UNKNOWN};
chaviw4244e032019-09-04 11:27:49 -0700127 Rect mCrop;
128 uint32_t mScaleMode{NATIVE_WINDOW_SCALING_MODE_FREEZE};
129 Region mSurfaceDamage;
130 HdrMetadata mHdrMetadata;
131 int mApi;
chaviwdebadb82020-03-26 14:57:24 -0700132 PixelFormat mPixelFormat{PIXEL_FORMAT_NONE};
chaviw4244e032019-09-04 11:27:49 -0700133 bool mTransformToDisplayInverse{false};
chaviwd62d3062019-09-04 14:48:02 -0700134
Alec Mouria90a5702021-04-16 16:36:21 +0000135 std::shared_ptr<renderengine::ExternalTexture> mBuffer;
chaviwd62d3062019-09-04 14:48:02 -0700136 int mBufferSlot{BufferQueue::INVALID_BUFFER_SLOT};
chaviw74b03172019-08-19 11:09:03 -0700137
138 bool mFrameLatencyNeeded{false};
chaviw4244e032019-09-04 11:27:49 -0700139 };
140
141 BufferInfo mBufferInfo;
142 virtual void gatherBufferInfo() = 0;
143
Vishnu Nairb87d94f2020-02-13 09:17:36 -0800144 std::optional<compositionengine::LayerFE::LayerSettings> prepareClientComposition(
145 compositionengine::LayerFE::ClientCompositionTargetSettings&) override;
146
Lloyd Piquef16688f2019-02-19 17:47:57 -0800147 /*
148 * compositionengine::LayerFE overrides
149 */
Lloyd Piquede196652020-01-22 17:29:58 -0800150 const compositionengine::LayerFECompositionState* getCompositionState() const override;
Lloyd Piquef16688f2019-02-19 17:47:57 -0800151 bool onPreComposition(nsecs_t) override;
Lloyd Piquede196652020-01-22 17:29:58 -0800152 void preparePerFrameCompositionState() override;
Lloyd Piquef5275482019-01-29 18:42:42 -0800153
Marissa Wallfd668622018-05-10 10:21:13 -0700154 static bool getOpacityForFormat(uint32_t format);
David Sodman0c69cad2017-08-21 12:12:51 -0700155
Peiyong Linf3ffc4e2019-12-13 00:46:24 -0800156 // from graphics API
Marissa Wallfd668622018-05-10 10:21:13 -0700157 const uint32_t mTextureName;
158
chaviwf206b662019-01-11 13:07:19 -0800159 bool mRefreshPending{false};
160
chaviw4244e032019-09-04 11:27:49 -0700161 ui::Dataspace translateDataspace(ui::Dataspace dataspace);
chaviwb4c6e582019-08-16 14:35:07 -0700162 void setInitialValuesForClone(const sp<Layer>& clonedFrom);
chaviw74b03172019-08-19 11:09:03 -0700163 void updateCloneBufferInfo() override;
164 uint64_t mPreviousFrameNumber = 0;
chaviw4244e032019-09-04 11:27:49 -0700165
Vishnu Nair6b7c5c92020-09-29 17:27:05 -0700166 uint64_t getHeadFrameNumber(nsecs_t expectedPresentTime) const override;
Robert Carrfe1209c2020-02-11 12:25:35 -0800167
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700168 void setTransformHint(ui::Transform::RotationFlags displayTransformHint) override;
169
Vishnu Nair6213bd92020-05-08 17:42:25 -0700170 // Transform hint provided to the producer. This must be accessed holding
Ady Abraham63a3e592021-01-06 10:47:15 -0800171 // the mStateLock.
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700172 ui::Transform::RotationFlags mTransformHint = ui::Transform::ROT_0;
Vishnu Nair6213bd92020-05-08 17:42:25 -0700173
Vishnu Naircf26a0a2020-11-13 12:56:20 -0800174 bool getAutoRefresh() const { return mAutoRefresh; }
175 bool getSidebandStreamChanged() const { return mSidebandStreamChanged; }
176
Ady Abraham63a3e592021-01-06 10:47:15 -0800177 // Returns true if the next buffer should be presented at the expected present time
Robert Carr6a5dc1f2021-03-11 12:36:40 -0800178 bool shouldPresentNow(nsecs_t expectedPresentTime) const;
Ady Abraham63a3e592021-01-06 10:47:15 -0800179
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 Naircf26a0a2020-11-13 12:56:20 -0800185 std::atomic<bool> mAutoRefresh{false};
186 std::atomic<bool> mSidebandStreamChanged{false};
187
Marissa Wallfd668622018-05-10 10:21:13 -0700188private:
Peiyong Linf243e5e2020-08-22 17:40:59 -0700189 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 Linf243e5e2020-08-22 17:40:59 -0700193
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 Linf243e5e2020-08-22 17:40:59 -0700199 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 Linc2020ca2019-01-10 11:36:12 -0800210 // Returns true if this layer requires filtering
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700211 bool needsFiltering(const DisplayDevice*) const override;
212 bool needsFilteringForScreenshots(const DisplayDevice*,
Alec Mouri5a6d8572020-03-23 23:56:15 -0700213 const ui::Transform& inverseParentTransform) const override;
Marissa Wallfd668622018-05-10 10:21:13 -0700214
Marissa Wall290ad082019-03-06 13:23:47 -0800215 // BufferStateLayers can return Rect::INVALID_RECT if the layer does not have a display frame
216 // and its parent layer is not bounded
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800217 Rect getBufferSize(const State& s) const override;
Lloyd Piquefeb73d72018-12-04 17:23:44 -0800218
Peiyong Linf243e5e2020-08-22 17:40:59 -0700219 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 Piquede196652020-01-22 17:29:58 -0800225 std::unique_ptr<compositionengine::LayerFECompositionState> mCompositionState;
Vishnu Nair4351ad52019-02-11 14:13:02 -0800226
227 FloatRect computeSourceBounds(const FloatRect& parentBounds) const override;
David Sodman0c69cad2017-08-21 12:12:51 -0700228};
229
230} // namespace android