SF: Merge BufferStateLayer into Layer
Test: go/wm-smoke
Bug: 238781169
Change-Id: I1521ffa6995ce41a04a664ff65516431aead4dca
diff --git a/services/surfaceflinger/Layer.h b/services/surfaceflinger/Layer.h
index 946b7d0..f6b9b0f 100644
--- a/services/surfaceflinger/Layer.h
+++ b/services/surfaceflinger/Layer.h
@@ -48,12 +48,10 @@
#include <vector>
#include "Client.h"
-#include "ClientCache.h"
-#include "DisplayHardware/ComposerHal.h"
#include "DisplayHardware/HWComposer.h"
#include "FrameTracker.h"
+#include "HwcSlotGenerator.h"
#include "LayerVector.h"
-#include "RenderArea.h"
#include "Scheduler/LayerInfo.h"
#include "SurfaceFlinger.h"
#include "Tracing/LayerTracing.h"
@@ -170,11 +168,9 @@
gui::WindowInfo inputInfo;
wp<Layer> touchableRegionCrop;
- // dataspace is only used by BufferStateLayer and EffectLayer
ui::Dataspace dataspace;
bool dataspaceRequested;
- // The fields below this point are only used by BufferStateLayer
uint64_t frameNumber;
ui::Transform transform;
uint32_t bufferTransform;
@@ -308,17 +304,17 @@
static void miniDumpHeader(std::string& result);
// Provide unique string for each class type in the Layer hierarchy
- virtual const char* getType() const = 0;
+ virtual const char* getType() const { return "Layer"; }
// true if this layer is visible, false otherwise
- virtual bool isVisible() const = 0;
+ virtual bool isVisible() const;
- virtual sp<Layer> createClone() = 0;
+ virtual sp<Layer> createClone();
// Set a 2x2 transformation matrix on the layer. This transform
// will be applied after parent transforms, but before any final
// producer specified transform.
- virtual bool setMatrix(const layer_state_t::matrix22_t& matrix) = 0;
+ bool setMatrix(const layer_state_t::matrix22_t& matrix);
// This second set of geometry attributes are controlled by
// setGeometryAppliesWithResize, and their default mode is to be
@@ -328,7 +324,7 @@
// setPosition operates in parent buffer space (pre parent-transform) or display
// space for top-level layers.
- virtual bool setPosition(float x, float y) = 0;
+ bool setPosition(float x, float y);
// Buffer space
bool setCrop(const Rect& crop);
@@ -339,7 +335,7 @@
virtual bool setRelativeLayer(const sp<IBinder>& relativeToHandle, int32_t relativeZ);
virtual bool setAlpha(float alpha);
- virtual bool setColor(const half3& /*color*/) = 0;
+ bool setColor(const half3& /*color*/);
// Set rounded corner radius for this layer and its children.
//
@@ -365,28 +361,25 @@
virtual bool isColorSpaceAgnostic() const { return mDrawingState.colorSpaceAgnostic; }
virtual bool isDimmingEnabled() const { return getDrawingState().dimmingEnabled; };
- // Used only to set BufferStateLayer state
- virtual bool setTransform(uint32_t /*transform*/) = 0;
- virtual bool setTransformToDisplayInverse(bool /*transformToDisplayInverse*/) = 0;
- virtual bool setBuffer(std::shared_ptr<renderengine::ExternalTexture>& /* buffer */,
- const BufferData& /* bufferData */, nsecs_t /* postTime */,
- nsecs_t /*desiredPresentTime*/, bool /*isAutoTimestamp*/,
- std::optional<nsecs_t> /* dequeueTime */,
- const FrameTimelineInfo& /*info*/) = 0;
- virtual bool setDataspace(ui::Dataspace /*dataspace*/) = 0;
- virtual bool setHdrMetadata(const HdrMetadata& /*hdrMetadata*/) = 0;
- virtual bool setSurfaceDamageRegion(const Region& /*surfaceDamage*/) = 0;
- virtual bool setApi(int32_t /*api*/) = 0;
- virtual bool setSidebandStream(const sp<NativeHandle>& /*sidebandStream*/) = 0;
- virtual bool setTransactionCompletedListeners(
- const std::vector<sp<CallbackHandle>>& /*handles*/) = 0;
+ bool setTransform(uint32_t /*transform*/);
+ bool setTransformToDisplayInverse(bool /*transformToDisplayInverse*/);
+ bool setBuffer(std::shared_ptr<renderengine::ExternalTexture>& /* buffer */,
+ const BufferData& /* bufferData */, nsecs_t /* postTime */,
+ nsecs_t /*desiredPresentTime*/, bool /*isAutoTimestamp*/,
+ std::optional<nsecs_t> /* dequeueTime */, const FrameTimelineInfo& /*info*/);
+ bool setDataspace(ui::Dataspace /*dataspace*/);
+ bool setHdrMetadata(const HdrMetadata& /*hdrMetadata*/);
+ bool setSurfaceDamageRegion(const Region& /*surfaceDamage*/);
+ bool setApi(int32_t /*api*/);
+ bool setSidebandStream(const sp<NativeHandle>& /*sidebandStream*/);
+ bool setTransactionCompletedListeners(const std::vector<sp<CallbackHandle>>& /*handles*/);
virtual bool setBackgroundColor(const half3& color, float alpha, ui::Dataspace dataspace);
virtual bool setColorSpaceAgnostic(const bool agnostic);
virtual bool setDimmingEnabled(const bool dimmingEnabled);
virtual bool setDefaultFrameRateCompatibility(FrameRateCompatibility compatibility);
virtual bool setFrameRateSelectionPriority(int32_t priority);
virtual bool setFixedTransformHint(ui::Transform::RotationFlags fixedTransformHint);
- virtual void setAutoRefresh(bool /* autoRefresh */) = 0;
+ void setAutoRefresh(bool /* autoRefresh */);
bool setDropInputMode(gui::DropInputMode);
// If the variable is not set on the layer, it traverses up the tree to inherit the frame
@@ -395,16 +388,17 @@
//
virtual FrameRateCompatibility getDefaultFrameRateCompatibility() const;
//
- virtual ui::Dataspace getDataSpace() const = 0;
+ ui::Dataspace getDataSpace() const;
+ ui::Dataspace getRequestedDataSpace() const;
- virtual sp<compositionengine::LayerFE> getCompositionEngineLayerFE() const = 0;
- virtual compositionengine::LayerFECompositionState* editCompositionState() = 0;
+ virtual sp<compositionengine::LayerFE> getCompositionEngineLayerFE() const;
+ compositionengine::LayerFECompositionState* editCompositionState();
// If we have received a new buffer this frame, we will pass its surface
// damage down to hardware composer. Otherwise, we must send a region with
// one empty rect.
- virtual void useSurfaceDamage() {}
- virtual void useEmptyDamage() {}
+ void useSurfaceDamage();
+ void useEmptyDamage();
Region getVisibleRegion(const DisplayDevice*) const;
/*
@@ -414,18 +408,18 @@
* pixel format includes an alpha channel) and the "opaque" flag set
* on the layer. It does not examine the current plane alpha value.
*/
- virtual bool isOpaque(const Layer::State&) const = 0;
+ bool isOpaque(const Layer::State&) const;
/*
* Returns whether this layer can receive input.
*/
- virtual bool canReceiveInput() const = 0;
+ bool canReceiveInput() const;
/*
* isProtected - true if the layer may contain protected contents in the
* GRALLOC_USAGE_PROTECTED sense.
*/
- virtual bool isProtected() const = 0;
+ bool isProtected() const;
/*
* isFixedSize - true if content has a fixed size
@@ -435,7 +429,7 @@
/*
* usesSourceCrop - true if content should use a source crop
*/
- virtual bool usesSourceCrop() const = 0;
+ bool usesSourceCrop() const { return hasBufferOrSidebandStream(); }
// Most layers aren't created from the main thread, and therefore need to
// grab the SF state lock to access HWC, but ContainerLayer does, so we need
@@ -443,9 +437,11 @@
virtual bool isCreatedFromMainThread() const { return false; }
ui::Transform getActiveTransform(const Layer::State& s) const { return s.transform; }
- virtual Region getActiveTransparentRegion(const Layer::State& s) const = 0;
+ Region getActiveTransparentRegion(const Layer::State& s) const {
+ return s.transparentRegionHint;
+ }
Rect getCrop(const Layer::State& s) const { return s.crop; }
- virtual bool needsFiltering(const DisplayDevice*) const = 0;
+ bool needsFiltering(const DisplayDevice*) const;
// True if this layer requires filtering
// This method is distinct from needsFiltering() in how the filter
@@ -456,23 +452,25 @@
// different.
// If the parent transform needs to be undone when capturing the layer, then
// the inverse parent transform is also required.
- virtual bool needsFilteringForScreenshots(const DisplayDevice*, const ui::Transform&) const = 0;
+ bool needsFilteringForScreenshots(const DisplayDevice*, const ui::Transform&) const;
- virtual void updateCloneBufferInfo(){};
+ // from graphics API
+ ui::Dataspace translateDataspace(ui::Dataspace dataspace);
+ void updateCloneBufferInfo();
+ uint64_t mPreviousFrameNumber = 0;
- virtual bool isHdrY410() const = 0;
+ bool isHdrY410() const;
/*
* called after composition.
* returns true if the layer latched a new buffer this frame.
*/
- virtual void onPostComposition(const DisplayDevice*,
- const std::shared_ptr<FenceTime>& /*glDoneFence*/,
- const std::shared_ptr<FenceTime>& /*presentFence*/,
- const CompositorTiming&) = 0;
+ void onPostComposition(const DisplayDevice*, const std::shared_ptr<FenceTime>& /*glDoneFence*/,
+ const std::shared_ptr<FenceTime>& /*presentFence*/,
+ const CompositorTiming&);
// If a buffer was replaced this frame, release the former buffer
- virtual void releasePendingBuffer(nsecs_t /*dequeueReadyTime*/) = 0;
+ void releasePendingBuffer(nsecs_t /*dequeueReadyTime*/);
/*
* latchBuffer - called each time the screen is redrawn and returns whether
@@ -480,48 +478,55 @@
* operation, so this should be set only if needed). Typically this is used
* to figure out if the content or size of a surface has changed.
*/
- virtual bool latchBuffer(bool& /*recomputeVisibleRegions*/, nsecs_t /*latchTime*/) = 0;
+ bool latchBuffer(bool& /*recomputeVisibleRegions*/, nsecs_t /*latchTime*/);
- virtual void latchAndReleaseBuffer() = 0;
+ /*
+ * Calls latchBuffer if the buffer has a frame queued and then releases the buffer.
+ * This is used if the buffer is just latched and releases to free up the buffer
+ * and will not be shown on screen.
+ * Should only be called on the main thread.
+ */
+ void latchAndReleaseBuffer();
/*
* returns the rectangle that crops the content of the layer and scales it
* to the layer's size.
*/
- virtual Rect getBufferCrop() const = 0;
+ Rect getBufferCrop() const;
/*
* Returns the transform applied to the buffer.
*/
- virtual uint32_t getBufferTransform() const = 0;
+ uint32_t getBufferTransform() const;
- virtual sp<GraphicBuffer> getBuffer() const = 0;
- virtual const std::shared_ptr<renderengine::ExternalTexture>& getExternalTexture() const = 0;
+ sp<GraphicBuffer> getBuffer() const;
+ const std::shared_ptr<renderengine::ExternalTexture>& getExternalTexture() const;
- virtual ui::Transform::RotationFlags getTransformHint() const = 0;
+ ui::Transform::RotationFlags getTransformHint() const { return mTransformHint; }
/*
* Returns if a frame is ready
*/
- virtual bool hasReadyFrame() const = 0;
+ bool hasReadyFrame() const;
virtual int32_t getQueuedFrameCount() const { return 0; }
/**
* Returns active buffer size in the correct orientation. Buffer size is determined by undoing
- * any buffer transformations. If the layer has no buffer then return INVALID_RECT.
+ * any buffer transformations. Returns Rect::INVALID_RECT if the layer has no buffer or the
+ * layer does not have a display frame and its parent is not bounded.
*/
- virtual Rect getBufferSize(const Layer::State&) const = 0;
+ Rect getBufferSize(const Layer::State&) const;
/**
* Returns the source bounds. If the bounds are not defined, it is inferred from the
* buffer size. Failing that, the bounds are determined from the passed in parent bounds.
* For the root layer, this is the display viewport size.
*/
- virtual FloatRect computeSourceBounds(const FloatRect& parentBounds) const = 0;
+ FloatRect computeSourceBounds(const FloatRect& parentBounds) const;
virtual FrameRate getFrameRateForLayerTree() const;
- virtual bool getTransformToDisplayInverse() const = 0;
+ bool getTransformToDisplayInverse() const;
// Returns how rounded corners should be drawn for this layer.
// A layer can override its parent's rounded corner settings if the parent's rounded
@@ -530,26 +535,51 @@
bool hasRoundedCorners() const override { return getRoundedCornerState().hasRoundedCorners(); }
- virtual PixelFormat getPixelFormat() const { return PIXEL_FORMAT_NONE; }
+ PixelFormat getPixelFormat() const;
/**
- * Return whether this layer needs an input info. For most layer types
- * this is only true if they explicitly set an input-info but BufferLayer
- * overrides this so we can generate input-info for Buffered layers that don't
- * have them (for input occlusion detection checks).
+ * Return whether this layer needs an input info. We generate InputWindowHandles for all
+ * non-cursor buffered layers regardless of whether they have an InputChannel. This is to enable
+ * the InputDispatcher to do PID based occlusion detection.
*/
- virtual bool needsInputInfo() const = 0;
+ bool needsInputInfo() const {
+ return (hasInputInfo() || hasBufferOrSidebandStream()) && !mPotentialCursor;
+ }
// Implements RefBase.
void onFirstRef() override;
+ struct BufferInfo {
+ nsecs_t mDesiredPresentTime;
+ std::shared_ptr<FenceTime> mFenceTime;
+ sp<Fence> mFence;
+ uint32_t mTransform{0};
+ ui::Dataspace mDataspace{ui::Dataspace::UNKNOWN};
+ Rect mCrop;
+ uint32_t mScaleMode{NATIVE_WINDOW_SCALING_MODE_FREEZE};
+ Region mSurfaceDamage;
+ HdrMetadata mHdrMetadata;
+ int mApi;
+ PixelFormat mPixelFormat{PIXEL_FORMAT_NONE};
+ bool mTransformToDisplayInverse{false};
+
+ std::shared_ptr<renderengine::ExternalTexture> mBuffer;
+ uint64_t mFrameNumber;
+ int mBufferSlot{BufferQueue::INVALID_BUFFER_SLOT};
+
+ bool mFrameLatencyNeeded{false};
+ };
+
+ BufferInfo mBufferInfo;
+
// implements compositionengine::LayerFE
- virtual const compositionengine::LayerFECompositionState* getCompositionState() const = 0;
- virtual bool onPreComposition(nsecs_t) = 0;
+ const compositionengine::LayerFECompositionState* getCompositionState() const;
+ bool fenceHasSignaled() const;
+ bool onPreComposition(nsecs_t);
void prepareCompositionState(compositionengine::LayerFE::StateSubset subset) override;
std::optional<compositionengine::LayerFE::LayerSettings> prepareClientComposition(
compositionengine::LayerFE::ClientCompositionTargetSettings&) const override;
- virtual void onLayerDisplayed(ftl::SharedFuture<FenceResult>) = 0;
+ void onLayerDisplayed(ftl::SharedFuture<FenceResult>);
void setWasClientComposed(const sp<Fence>& fence) override {
mLastClientCompositionFence = fence;
@@ -827,13 +857,17 @@
float getBorderWidth();
const half4& getBorderColor();
- virtual bool setBufferCrop(const Rect& /* bufferCrop */) = 0;
- virtual bool setDestinationFrame(const Rect& /* destinationFrame */) = 0;
- virtual std::atomic<int32_t>* getPendingBufferCounter() = 0;
- virtual std::string getPendingBufferCounterName() = 0;
- virtual bool updateGeometry() = 0;
+ bool setBufferCrop(const Rect& /* bufferCrop */);
+ bool setDestinationFrame(const Rect& /* destinationFrame */);
+ // See mPendingBufferTransactions
+ void decrementPendingBufferCount();
+ std::atomic<int32_t>* getPendingBufferCounter() { return &mPendingBufferTransactions; }
+ std::string getPendingBufferCounterName() { return mBlastTransactionName; }
+ bool updateGeometry();
- virtual bool simpleBufferUpdate(const layer_state_t&) const = 0;
+ bool simpleBufferUpdate(const layer_state_t&) const;
+
+ static bool isOpaqueFormat(PixelFormat format);
protected:
friend class impl::SurfaceInterceptor;
@@ -847,9 +881,12 @@
friend class TransactionSurfaceFrameTest;
virtual void setInitialValuesForClone(const sp<Layer>& clonedFrom);
- virtual void preparePerFrameCompositionState();
+ void preparePerFrameCompositionState();
+ void preparePerFrameBufferCompositionState();
+ void preparePerFrameEffectsCompositionState();
virtual void commitTransaction(State& stateToCommit);
- virtual void onSurfaceFrameCreated(const std::shared_ptr<frametimeline::SurfaceFrame>&) {}
+ void gatherBufferInfo();
+ void onSurfaceFrameCreated(const std::shared_ptr<frametimeline::SurfaceFrame>&);
sp<compositionengine::LayerFE> asLayerFE() const;
sp<Layer> getClonedFrom() { return mClonedFrom != nullptr ? mClonedFrom.promote() : nullptr; }
@@ -888,7 +925,7 @@
compositionengine::OutputLayer* findOutputLayerForDisplay(const DisplayDevice*) const;
bool usingRelativeZ(LayerVector::StateSet) const;
- virtual ui::Transform getInputTransform() const = 0;
+ virtual ui::Transform getInputTransform() const;
/**
* Get the bounds in layer space within which this layer can receive input.
*
@@ -902,7 +939,7 @@
* "replaceTouchableRegionWithCrop" is specified. In this case, the layer will receive input
* in this layer's space, regardless of the specified crop layer.
*/
- virtual Rect getInputBounds() const = 0;
+ Rect getInputBounds() const;
// constant
sp<SurfaceFlinger> mFlinger;
@@ -973,7 +1010,14 @@
sp<Fence> mLastClientCompositionFence;
bool mClearClientCompositionFenceOnLayerDisplayed = false;
private:
- virtual void setTransformHint(ui::Transform::RotationFlags) = 0;
+ friend class SlotGenerationTest;
+ friend class TransactionFrameTracerTest;
+ friend class TransactionSurfaceFrameTest;
+
+ bool getAutoRefresh() const { return mDrawingState.autoRefresh; }
+ bool getSidebandStreamChanged() const { return mSidebandStreamChanged; }
+
+ std::atomic<bool> mSidebandStreamChanged{false};
// Returns true if the layer can draw shadows on its border.
virtual bool canDrawShadows() const { return true; }
@@ -1018,6 +1062,52 @@
// Fills in the frame and transform info for the gui::WindowInfo.
void fillInputFrameInfo(gui::WindowInfo&, const ui::Transform& screenToDisplay);
+ // Computes the transform matrix using the setFilteringEnabled to determine whether the
+ // transform matrix should be computed for use with bilinear filtering.
+ void getDrawingTransformMatrix(bool filteringEnabled, float outMatrix[16]) const;
+
+ inline void tracePendingBufferCount(int32_t pendingBuffers);
+
+ // Latch sideband stream and returns true if the dirty region should be updated.
+ bool latchSidebandStream(bool& recomputeVisibleRegions);
+
+ bool hasFrameUpdate() const;
+
+ void updateTexImage(nsecs_t latchTime);
+
+ // Crop that applies to the buffer
+ Rect computeBufferCrop(const State& s);
+
+ bool willPresentCurrentTransaction() const;
+
+ // Returns true if the transformed buffer size does not match the layer size and we need
+ // to apply filtering.
+ bool bufferNeedsFiltering() const;
+
+ void callReleaseBufferCallback(const sp<ITransactionCompletedListener>& listener,
+ const sp<GraphicBuffer>& buffer, uint64_t framenumber,
+ const sp<Fence>& releaseFence,
+ uint32_t currentMaxAcquiredBufferCount);
+
+ std::optional<compositionengine::LayerFE::LayerSettings> prepareClientCompositionInternal(
+ compositionengine::LayerFE::ClientCompositionTargetSettings&) const;
+ // Returns true if there is a valid color to fill.
+ bool fillsColor() const;
+ // Returns true if this layer has a blur value.
+ bool hasBlur() const;
+ bool hasEffect() const { return fillsColor() || drawShadows() || hasBlur(); }
+ bool hasBufferOrSidebandStream() const {
+ return ((mSidebandStream != nullptr) || (mBufferInfo.mBuffer != nullptr));
+ }
+
+ bool hasSomethingToDraw() const { return hasEffect() || hasBufferOrSidebandStream(); }
+ void prepareBufferStateClientComposition(
+ compositionengine::LayerFE::LayerSettings&,
+ compositionengine::LayerFE::ClientCompositionTargetSettings&) const;
+ void prepareEffectsClientComposition(
+ compositionengine::LayerFE::LayerSettings&,
+ compositionengine::LayerFE::ClientCompositionTargetSettings&) const;
+
// Cached properties computed from drawing state
// Effective transform taking into account parent transforms and any parent scaling, which is
// a transform from the current layer coordinate space to display(screen) coordinate space.
@@ -1067,6 +1157,49 @@
bool mBorderEnabled = false;
float mBorderWidth;
half4 mBorderColor;
+
+ void setTransformHint(ui::Transform::RotationFlags);
+
+ const uint32_t mTextureName;
+
+ // Transform hint provided to the producer. This must be accessed holding
+ // the mStateLock.
+ ui::Transform::RotationFlags mTransformHint = ui::Transform::ROT_0;
+
+ std::unique_ptr<compositionengine::LayerFECompositionState> mCompositionState;
+
+ ReleaseCallbackId mPreviousReleaseCallbackId = ReleaseCallbackId::INVALID_ID;
+ uint64_t mPreviousReleasedFrameNumber = 0;
+
+ uint64_t mPreviousBarrierFrameNumber = 0;
+
+ bool mReleasePreviousBuffer = false;
+
+ // Stores the last set acquire fence signal time used to populate the callback handle's acquire
+ // time.
+ std::variant<nsecs_t, sp<Fence>> mCallbackHandleAcquireTimeOrFence = -1;
+
+ std::deque<std::shared_ptr<android::frametimeline::SurfaceFrame>> mPendingJankClassifications;
+ // An upper bound on the number of SurfaceFrames in the pending classifications deque.
+ static constexpr int kPendingClassificationMaxSurfaceFrames = 25;
+
+ const std::string mBlastTransactionName{"BufferTX - " + mName};
+ // This integer is incremented everytime a buffer arrives at the server for this layer,
+ // and decremented when a buffer is dropped or latched. When changed the integer is exported
+ // to systrace with ATRACE_INT and mBlastTransactionName. This way when debugging perf it is
+ // possible to see when a buffer arrived at the server, and in which frame it latched.
+ //
+ // You can understand the trace this way:
+ // - If the integer increases, a buffer arrived at the server.
+ // - If the integer decreases in latchBuffer, that buffer was latched
+ // - If the integer decreases in setBuffer or doTransaction, a buffer was dropped
+ std::atomic<int32_t> mPendingBufferTransactions{0};
+
+ // Contains requested position and matrix updates. This will be applied if the client does
+ // not specify a destination frame.
+ ui::Transform mRequestedTransform;
+
+ sp<HwcSlotGenerator> mHwcSlotGenerator;
};
std::ostream& operator<<(std::ostream& stream, const Layer::FrameRate& rate);