blob: fb8d7d027f98c68944639dc10342870b4f4a0896 [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
53 // -----------------------------------------------------------------------
54 // Overriden from Layer
55 // -----------------------------------------------------------------------
Marissa Wallfd668622018-05-10 10:21:13 -070056public:
Lloyd Piquefeb73d72018-12-04 17:23:44 -080057 std::shared_ptr<compositionengine::Layer> getCompositionLayer() const override;
58
Marissa Wallfd668622018-05-10 10:21:13 -070059 // If we have received a new buffer this frame, we will pass its surface
60 // damage down to hardware composer. Otherwise, we must send a region with
61 // one empty rect.
62 void useSurfaceDamage() override;
63 void useEmptyDamage() override;
David Sodman0c69cad2017-08-21 12:12:51 -070064
Marissa Wallfd668622018-05-10 10:21:13 -070065 // getTypeId - Provide unique string for each class type in the Layer
66 // hierarchy
David Sodman0c69cad2017-08-21 12:12:51 -070067 const char* getTypeId() const override { return "BufferLayer"; }
68
Marissa Wallfd668622018-05-10 10:21:13 -070069 bool isOpaque(const Layer::State& s) const override;
David Sodman0c69cad2017-08-21 12:12:51 -070070
Marissa Wallfd668622018-05-10 10:21:13 -070071 // isVisible - true if this layer is visible, false otherwise
Lloyd Pique0449b0f2018-12-20 16:23:45 -080072 bool isVisible() const override;
David Sodman0c69cad2017-08-21 12:12:51 -070073
Peiyong Linfb530cf2018-12-15 05:07:38 +000074 // isProtected - true if the layer may contain protected content in the
75 // GRALLOC_USAGE_PROTECTED sense.
76 bool isProtected() const override;
77
Marissa Wallfd668622018-05-10 10:21:13 -070078 // isFixedSize - true if content has a fixed size
David Sodman0c69cad2017-08-21 12:12:51 -070079 bool isFixedSize() const override;
80
Lloyd Piquea83776c2019-01-29 18:42:32 -080081 bool usesSourceCrop() const override;
82
Marissa Wallfd668622018-05-10 10:21:13 -070083 bool isHdrY410() const override;
David Sodmaneb085e02017-10-05 18:49:04 -070084
Dominik Laskowski075d3172018-05-24 15:50:06 -070085 bool onPostComposition(const std::optional<DisplayId>& displayId,
86 const std::shared_ptr<FenceTime>& glDoneFence,
David Sodmaneb085e02017-10-05 18:49:04 -070087 const std::shared_ptr<FenceTime>& presentFence,
Lloyd Pique0449b0f2018-12-20 16:23:45 -080088 const CompositorTiming& compositorTiming) override;
David Sodmaneb085e02017-10-05 18:49:04 -070089
Marissa Wallfd668622018-05-10 10:21:13 -070090 // latchBuffer - called each time the screen is redrawn and returns whether
91 // the visible regions need to be recomputed (this is a fairly heavy
92 // operation, so this should be set only if needed). Typically this is used
93 // to figure out if the content or size of a surface has changed.
Dominik Laskowskia8955dd2019-07-10 10:19:09 -070094 bool latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime,
95 nsecs_t expectedPresentTime) override;
Marissa Wallfd668622018-05-10 10:21:13 -070096
David Sodman0c69cad2017-08-21 12:12:51 -070097 bool isBufferLatched() const override { return mRefreshPending; }
98
Dominik Laskowskia8955dd2019-07-10 10:19:09 -070099 void notifyAvailableFrames(nsecs_t expectedPresentTime) override;
Chia-I Wu692e0832018-06-05 15:46:58 -0700100
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800101 bool hasReadyFrame() const override;
David Sodman0c69cad2017-08-21 12:12:51 -0700102
David Sodman0c69cad2017-08-21 12:12:51 -0700103 // Returns the current scaling mode, unless mOverrideScalingMode
104 // is set, in which case, it returns mOverrideScalingMode
105 uint32_t getEffectiveScalingMode() const override;
chaviw49a108c2019-08-12 11:23:06 -0700106
107 // Calls latchBuffer if the buffer has a frame queued and then releases the buffer.
108 // This is used if the buffer is just latched and releases to free up the buffer
109 // and will not be shown on screen.
110 // Should only be called on the main thread.
111 void latchAndReleaseBuffer() override;
112
Marissa Wallfd668622018-05-10 10:21:13 -0700113 // -----------------------------------------------------------------------
114
115 // -----------------------------------------------------------------------
116 // Functions that must be implemented by derived classes
117 // -----------------------------------------------------------------------
118private:
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800119 virtual bool fenceHasSignaled() const = 0;
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700120 virtual bool framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const = 0;
Marissa Wallfd668622018-05-10 10:21:13 -0700121
122 virtual nsecs_t getDesiredPresentTime() = 0;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800123 virtual std::shared_ptr<FenceTime> getCurrentFenceTime() const = 0;
Marissa Wallfd668622018-05-10 10:21:13 -0700124
Marissa Wall61c58622018-07-18 10:12:20 -0700125 virtual void getDrawingTransformMatrix(float *matrix) = 0;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800126 virtual uint32_t getDrawingTransform() const = 0;
127 virtual ui::Dataspace getDrawingDataSpace() const = 0;
128 virtual Rect getDrawingCrop() const = 0;
Marissa Wallfd668622018-05-10 10:21:13 -0700129 virtual uint32_t getDrawingScalingMode() const = 0;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800130 virtual Region getDrawingSurfaceDamage() const = 0;
131 virtual const HdrMetadata& getDrawingHdrMetadata() const = 0;
132 virtual int getDrawingApi() const = 0;
Marissa Wallfd668622018-05-10 10:21:13 -0700133 virtual PixelFormat getPixelFormat() const = 0;
134
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700135 virtual uint64_t getFrameNumber(nsecs_t expectedPresentTime) const = 0;
Marissa Wallfd668622018-05-10 10:21:13 -0700136
137 virtual bool getAutoRefresh() const = 0;
138 virtual bool getSidebandStreamChanged() const = 0;
139
Vishnu Nair6194e2e2019-02-06 12:58:39 -0800140 // Latch sideband stream and returns true if the dirty region should be updated.
141 virtual bool latchSidebandStream(bool& recomputeVisibleRegions) = 0;
Marissa Wallfd668622018-05-10 10:21:13 -0700142
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800143 virtual bool hasFrameUpdate() const = 0;
Marissa Wallfd668622018-05-10 10:21:13 -0700144
Marissa Wall61c58622018-07-18 10:12:20 -0700145 virtual void setFilteringEnabled(bool enabled) = 0;
Marissa Wallfd668622018-05-10 10:21:13 -0700146
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800147 virtual status_t bindTextureImage() = 0;
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700148 virtual status_t updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime,
149 nsecs_t expectedPresentTime) = 0;
Marissa Wallfd668622018-05-10 10:21:13 -0700150
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800151 virtual status_t updateActiveBuffer() = 0;
Marissa Wallfd668622018-05-10 10:21:13 -0700152 virtual status_t updateFrameNumber(nsecs_t latchTime) = 0;
153
Marissa Wallfd668622018-05-10 10:21:13 -0700154protected:
Lloyd Piquef16688f2019-02-19 17:47:57 -0800155 /*
156 * compositionengine::LayerFE overrides
157 */
158 bool onPreComposition(nsecs_t) override;
159 void latchPerFrameState(compositionengine::LayerFECompositionState&) const override;
160 std::optional<renderengine::LayerSettings> prepareClientComposition(
161 compositionengine::LayerFE::ClientCompositionTargetSettings&) override;
Lloyd Piquef5275482019-01-29 18:42:42 -0800162
Marissa Wallfd668622018-05-10 10:21:13 -0700163 // Loads the corresponding system property once per process
164 static bool latchUnsignaledBuffers();
David Sodmaneb085e02017-10-05 18:49:04 -0700165
David Sodman0c69cad2017-08-21 12:12:51 -0700166 // Check all of the local sync points to ensure that all transactions
167 // which need to have been applied prior to the frame which is about to
168 // be latched have signaled
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700169 bool allTransactionsSignaled(nsecs_t expectedPresentTime);
David Sodman0c69cad2017-08-21 12:12:51 -0700170
Marissa Wallfd668622018-05-10 10:21:13 -0700171 static bool getOpacityForFormat(uint32_t format);
David Sodman0c69cad2017-08-21 12:12:51 -0700172
Marissa Wallfd668622018-05-10 10:21:13 -0700173 // from GLES
174 const uint32_t mTextureName;
175
chaviwf206b662019-01-11 13:07:19 -0800176 bool mRefreshPending{false};
177
Marissa Wallfd668622018-05-10 10:21:13 -0700178private:
Peiyong Linc2020ca2019-01-10 11:36:12 -0800179 // Returns true if this layer requires filtering
Lloyd Piquef16688f2019-02-19 17:47:57 -0800180 bool needsFiltering(const sp<const DisplayDevice>& displayDevice) const override;
Marissa Wallfd668622018-05-10 10:21:13 -0700181
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700182 uint64_t getHeadFrameNumber(nsecs_t expectedPresentTime) const;
Marissa Wallfd668622018-05-10 10:21:13 -0700183
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700184 uint32_t mCurrentScalingMode{NATIVE_WINDOW_SCALING_MODE_FREEZE};
Marissa Wallfd668622018-05-10 10:21:13 -0700185
Vishnu Nair6194e2e2019-02-06 12:58:39 -0800186 bool mTransformToDisplayInverse{false};
187
Marissa Wallfd668622018-05-10 10:21:13 -0700188 // main thread.
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700189 bool mBufferLatched{false}; // TODO: Use mActiveBuffer?
Marissa Wallfd668622018-05-10 10:21:13 -0700190
Marissa Wall290ad082019-03-06 13:23:47 -0800191 // BufferStateLayers can return Rect::INVALID_RECT if the layer does not have a display frame
192 // and its parent layer is not bounded
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800193 Rect getBufferSize(const State& s) const override;
Lloyd Piquefeb73d72018-12-04 17:23:44 -0800194
195 std::shared_ptr<compositionengine::Layer> mCompositionLayer;
Vishnu Nair4351ad52019-02-11 14:13:02 -0800196
197 FloatRect computeSourceBounds(const FloatRect& parentBounds) const override;
David Sodman0c69cad2017-08-21 12:12:51 -0700198};
199
200} // namespace android