SF: merge BufferLayer and BufferStateLayer
Test: builds and boots
Bug: 238781169
Change-Id: If4b22aea96ba9c0c52df16a0af5fad648afc4cf1
diff --git a/services/surfaceflinger/BufferStateLayer.h b/services/surfaceflinger/BufferStateLayer.h
index bf98a27..df7ae61 100644
--- a/services/surfaceflinger/BufferStateLayer.h
+++ b/services/surfaceflinger/BufferStateLayer.h
@@ -16,27 +16,106 @@
#pragma once
-#include "BufferLayer.h"
-#include "Layer.h"
-
-#include <renderengine/Image.h>
-#include <renderengine/RenderEngine.h>
-#include <system/window.h>
-#include <utils/String8.h>
-
+#include <sys/types.h>
+#include <cstdint>
+#include <list>
#include <stack>
+#include <android/gui/ISurfaceComposerClient.h>
+#include <gui/LayerState.h>
+#include <renderengine/Image.h>
+#include <renderengine/Mesh.h>
+#include <renderengine/RenderEngine.h>
+#include <renderengine/Texture.h>
+#include <system/window.h> // For NATIVE_WINDOW_SCALING_MODE_FREEZE
+#include <ui/FrameStats.h>
+#include <ui/GraphicBuffer.h>
+#include <ui/PixelFormat.h>
+#include <ui/Region.h>
+#include <utils/RefBase.h>
+#include <utils/String8.h>
+#include <utils/Timers.h>
+
+#include "Client.h"
+#include "DisplayHardware/HWComposer.h"
+#include "FrameTimeline.h"
+#include "FrameTracker.h"
+#include "Layer.h"
+#include "LayerVector.h"
+#include "SurfaceFlinger.h"
+
namespace android {
class SlotGenerationTest;
-class BufferStateLayer : public BufferLayer {
+class BufferStateLayer : public Layer {
public:
explicit BufferStateLayer(const LayerCreationArgs&);
~BufferStateLayer() override;
// Implements Layer.
+ sp<compositionengine::LayerFE> getCompositionEngineLayerFE() const override;
+ compositionengine::LayerFECompositionState* editCompositionState() override;
+
+ // 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.
+ void useSurfaceDamage() override;
+ void useEmptyDamage() override;
+
+ bool isOpaque(const Layer::State& s) const override;
+ bool canReceiveInput() const override;
+
+ // isVisible - true if this layer is visible, false otherwise
+ bool isVisible() const override;
+
+ // isProtected - true if the layer may contain protected content in the
+ // GRALLOC_USAGE_PROTECTED sense.
+ bool isProtected() const override;
+
+ // isFixedSize - true if content has a fixed size
+ bool isFixedSize() const override;
+
+ bool usesSourceCrop() const override;
+
+ bool isHdrY410() const override;
+
+ void onPostComposition(const DisplayDevice*, const std::shared_ptr<FenceTime>& glDoneFence,
+ const std::shared_ptr<FenceTime>& presentFence,
+ const CompositorTiming&) override;
+
+ // latchBuffer - called each time the screen is redrawn and returns whether
+ // the visible regions need to be recomputed (this is a fairly heavy
+ // 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.
+ bool latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime,
+ nsecs_t expectedPresentTime) override;
+ bool hasReadyFrame() const override;
+
+ // Returns the current scaling mode
+ uint32_t getEffectiveScalingMode() const override;
+
+ // 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() override;
+
+ bool getTransformToDisplayInverse() const override;
+
+ Rect getBufferCrop() const override;
+
+ uint32_t getBufferTransform() const override;
+
+ ui::Dataspace getDataSpace() const override;
+
+ sp<GraphicBuffer> getBuffer() const override;
+ const std::shared_ptr<renderengine::ExternalTexture>& getExternalTexture() const override;
+
+ ui::Transform::RotationFlags getTransformHint() const override { return mTransformHint; }
+
+ // Implements Layer.
const char* getType() const override { return "BufferStateLayer"; }
void onLayerDisplayed(ftl::SharedFuture<FenceResult>) override;
@@ -46,7 +125,10 @@
void finalizeFrameEventHistory(const std::shared_ptr<FenceTime>& glDoneFence,
const CompositorTiming& compositorTiming) override;
- bool isBufferDue(nsecs_t /*expectedPresentTime*/) const override { return true; }
+ // Returns true if the next buffer should be presented at the expected present time,
+ // overridden by BufferStateLayer and BufferQueueLayer for implementation
+ // specific logic
+ bool isBufferDue(nsecs_t /*expectedPresentTime*/) const { return true; }
Region getActiveTransparentRegion(const Layer::State& s) const override {
return s.transparentRegionHint;
@@ -73,6 +155,8 @@
bool setSize(uint32_t /*w*/, uint32_t /*h*/) override { return false; }
bool setTransparentRegionHint(const Region& transparent) override;
+ // BufferStateLayers can return Rect::INVALID_RECT if the layer does not have a display frame
+ // and its parent layer is not bounded
Rect getBufferSize(const State& s) const override;
FloatRect computeSourceBounds(const FloatRect& parentBounds) const override;
void setAutoRefresh(bool autoRefresh) override;
@@ -81,48 +165,114 @@
bool setDestinationFrame(const Rect& destinationFrame) override;
bool updateGeometry() override;
- // -----------------------------------------------------------------------
-
- // -----------------------------------------------------------------------
- // Interface implementation for BufferLayer
- // -----------------------------------------------------------------------
- bool fenceHasSignaled() const override;
- bool framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const override;
- bool onPreComposition(nsecs_t refreshStartTime) override;
- uint32_t getEffectiveScalingMode() const override;
+ bool fenceHasSignaled() const;
+ bool framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const;
+ bool onPreComposition(nsecs_t) override;
// See mPendingBufferTransactions
void decrementPendingBufferCount();
std::atomic<int32_t>* getPendingBufferCounter() override { return &mPendingBufferTransactions; }
std::string getPendingBufferCounterName() override { return mBlastTransactionName; }
+ // Returns true if the next buffer should be presented at the expected present time
bool shouldPresentNow(nsecs_t /*expectedPresentTime*/) const override { return true; }
protected:
- void gatherBufferInfo() override;
+ void gatherBufferInfo();
void onSurfaceFrameCreated(const std::shared_ptr<frametimeline::SurfaceFrame>& surfaceFrame);
ui::Transform getInputTransform() const override;
Rect getInputBounds() const 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;
+
+ std::optional<compositionengine::LayerFE::LayerSettings> prepareClientComposition(
+ compositionengine::LayerFE::ClientCompositionTargetSettings&) override;
+
+ /*
+ * compositionengine::LayerFE overrides
+ */
+ const compositionengine::LayerFECompositionState* getCompositionState() const override;
+ void preparePerFrameCompositionState() override;
+
+ static bool getOpacityForFormat(PixelFormat format);
+
+ // from graphics API
+ const uint32_t mTextureName;
+ ui::Dataspace translateDataspace(ui::Dataspace dataspace);
+ void setInitialValuesForClone(const sp<Layer>& clonedFrom);
+ void updateCloneBufferInfo() override;
+ uint64_t mPreviousFrameNumber = 0;
+
+ void setTransformHint(ui::Transform::RotationFlags displayTransformHint) override;
+
+ // Transform hint provided to the producer. This must be accessed holding
+ // the mStateLock.
+ ui::Transform::RotationFlags mTransformHint = ui::Transform::ROT_0;
+
+ bool getAutoRefresh() const { return mDrawingState.autoRefresh; }
+ bool getSidebandStreamChanged() const { return mSidebandStreamChanged; }
+
+ std::atomic<bool> mSidebandStreamChanged{false};
+
private:
friend class SlotGenerationTest;
friend class TransactionFrameTracerTest;
friend class TransactionSurfaceFrameTest;
+ // 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.
+ bool needsInputInfo() const override { return !mPotentialCursor; }
+
+ // Returns true if this layer requires filtering
+ bool needsFiltering(const DisplayDevice*) const override;
+ bool needsFilteringForScreenshots(const DisplayDevice*,
+ const ui::Transform& inverseParentTransform) const override;
+
+ PixelFormat getPixelFormat() const;
+
+ // 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]);
+
+ std::unique_ptr<compositionengine::LayerFECompositionState> mCompositionState;
+
inline void tracePendingBufferCount(int32_t pendingBuffers);
bool updateFrameEventHistory(const sp<Fence>& acquireFence, nsecs_t postedTime,
nsecs_t requestedPresentTime);
- bool latchSidebandStream(bool& recomputeVisibleRegions) override;
+ // Latch sideband stream and returns true if the dirty region should be updated.
+ bool latchSidebandStream(bool& recomputeVisibleRegions);
- bool hasFrameUpdate() const override;
+ bool hasFrameUpdate() const;
status_t updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime,
- nsecs_t expectedPresentTime) override;
+ nsecs_t expectedPresentTime);
- status_t updateActiveBuffer() override;
- status_t updateFrameNumber() override;
+ status_t updateActiveBuffer();
+ status_t updateFrameNumber();
sp<Layer> createClone() override;
@@ -131,7 +281,9 @@
bool willPresentCurrentTransaction() const;
- bool bufferNeedsFiltering() const override;
+ // Returns true if the transformed buffer size does not match the layer size and we need
+ // to apply filtering.
+ bool bufferNeedsFiltering() const;
bool simpleBufferUpdate(const layer_state_t& s) const override;