Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 50c151ad authored by Melody Hsu's avatar Melody Hsu
Browse files

Store layer snapshot in LayerRenderArea 

Accessing the layer snapshot from a RenderArea lessens the
dependency on getting the layer snapshot from SF's
mLayerSnapshotBuilder, which needs to run on the main thread.

Bug: b/294936197
Test: atest SurfaceFlinger_test
Change-Id: I7c2a77a432ddae3f7bdd39311a3a505aa8f763d6
parent 278e699b

services/surfaceflinger/LayerRenderArea.cpp

+5 −4
Original line number Original line Diff line number Diff line
@@ -25,13 +25,14 @@ 




namespace android {

namespace android {





LayerRenderArea::LayerRenderArea(sp<Layer> layer, const Rect& crop, ui::Size reqSize,

LayerRenderArea::LayerRenderArea(sp<Layer> layer, frontend::LayerSnapshot layerSnapshot,

                                 ui::Dataspace reqDataSpace, bool allowSecureLayers,

                                 const Rect& crop, ui::Size reqSize, ui::Dataspace reqDataSpace,

                                 const ui::Transform& layerTransform, const Rect& layerBufferSize,

                                 bool allowSecureLayers, const ui::Transform& layerTransform,

                                 bool hintForSeamlessTransition)

                                 const Rect& layerBufferSize, bool hintForSeamlessTransition)

      : RenderArea(reqSize, CaptureFill::CLEAR, reqDataSpace, hintForSeamlessTransition,

      : RenderArea(reqSize, CaptureFill::CLEAR, reqDataSpace, hintForSeamlessTransition,

                   allowSecureLayers),

                   allowSecureLayers),

        mLayer(std::move(layer)),

        mLayer(std::move(layer)),

        mLayerSnapshot(std::move(layerSnapshot)),

        mLayerBufferSize(layerBufferSize),

        mLayerBufferSize(layerBufferSize),

        mCrop(crop),

        mCrop(crop),

        mTransform(layerTransform) {}

        mTransform(layerTransform) {}

services/surfaceflinger/LayerRenderArea.h

+7 −4
Original line number Original line Diff line number Diff line
@@ -32,19 +32,22 @@ class SurfaceFlinger; 




class LayerRenderArea : public RenderArea {

class LayerRenderArea : public RenderArea {

public:

public:

    LayerRenderArea(sp<Layer> layer, const Rect& crop, ui::Size reqSize, ui::Dataspace reqDataSpace,

    LayerRenderArea(sp<Layer> layer, frontend::LayerSnapshot layerSnapshot, const Rect& crop,

                    bool allowSecureLayers, const ui::Transform& layerTransform,

                    ui::Size reqSize, ui::Dataspace reqDataSpace, bool allowSecureLayers,

                    const Rect& layerBufferSize, bool hintForSeamlessTransition);

                    const ui::Transform& layerTransform, const Rect& layerBufferSize,

                    bool hintForSeamlessTransition);





    const ui::Transform& getTransform() const override;

    const ui::Transform& getTransform() const override;

    bool isSecure() const override;

    bool isSecure() const override;

    sp<const DisplayDevice> getDisplayDevice() const override;

    sp<const DisplayDevice> getDisplayDevice() const override;

    Rect getSourceCrop() const override;

    Rect getSourceCrop() const override;





    virtual sp<Layer> getParentLayer() const { return mLayer; }

    sp<Layer> getParentLayer() const override { return mLayer; }

    const frontend::LayerSnapshot* getLayerSnapshot() const override { return &mLayerSnapshot; }





private:

private:

    const sp<Layer> mLayer;

    const sp<Layer> mLayer;

    const frontend::LayerSnapshot mLayerSnapshot;

    const Rect mLayerBufferSize;

    const Rect mLayerBufferSize;

    const Rect mCrop;

    const Rect mCrop;

services/surfaceflinger/RenderArea.h

+6 −0
Original line number Original line Diff line number Diff line
@@ -4,6 +4,8 @@ 
#include <ui/Transform.h>

#include <ui/Transform.h>





#include <functional>

#include <functional>



#include "FrontEnd/LayerSnapshot.h"

#include "Layer.h"

#include "Layer.h"





namespace android {

namespace android {
@@ -82,6 +84,10 @@ public: 
    // capture operation.

    // capture operation.

    virtual sp<Layer> getParentLayer() const { return nullptr; }

    virtual sp<Layer> getParentLayer() const { return nullptr; }





    // If this is a LayerRenderArea, return the layer snapshot

    // of the root layer of the capture operation

    virtual const frontend::LayerSnapshot* getLayerSnapshot() const { return nullptr; }



    // Returns whether the render result may be used for system animations that

    // Returns whether the render result may be used for system animations that

    // must preserve the exact colors of the display.

    // must preserve the exact colors of the display.

    bool getHintForSeamlessTransition() const { return mHintForSeamlessTransition; }

    bool getHintForSeamlessTransition() const { return mHintForSeamlessTransition; }

services/surfaceflinger/RenderAreaBuilder.h

+11 −7
Original line number Original line Diff line number Diff line
@@ -83,9 +83,12 @@ struct LayerRenderAreaBuilder : RenderAreaBuilder { 
            layer(layer),

            layer(layer),

            childrenOnly(childrenOnly) {}

            childrenOnly(childrenOnly) {}





    // Layer that the render area will be on

    // Root layer of the render area

    sp<Layer> layer;

    sp<Layer> layer;





    // Layer snapshot of the root layer

    frontend::LayerSnapshot layerSnapshot;



    // Transform to be applied on the layers to transform them

    // Transform to be applied on the layers to transform them

    // into the logical render area

    // into the logical render area

    ui::Transform layerTransform{ui::Transform()};

    ui::Transform layerTransform{ui::Transform()};
@@ -97,17 +100,18 @@ struct LayerRenderAreaBuilder : RenderAreaBuilder { 
    bool childrenOnly;

    bool childrenOnly;





    // Uses parent snapshot to determine layer transform and buffer size

    // Uses parent snapshot to determine layer transform and buffer size

    void setLayerInfo(const frontend::LayerSnapshot* parentSnapshot) {

    void setLayerSnapshot(const frontend::LayerSnapshot& parentSnapshot) {

        layerSnapshot = parentSnapshot;

        if (!childrenOnly) {

        if (!childrenOnly) {

            layerTransform = parentSnapshot->localTransform.inverse();

            layerTransform = parentSnapshot.localTransform.inverse();

        }

        }

        layerBufferSize = parentSnapshot->bufferSize;

        layerBufferSize = parentSnapshot.bufferSize;

    }

    }





    std::unique_ptr<RenderArea> build() const override {

    std::unique_ptr<RenderArea> build() const override {

        return std::make_unique<LayerRenderArea>(layer, crop, reqSize, reqDataSpace,

        return std::make_unique<LayerRenderArea>(layer, std::move(layerSnapshot), crop, reqSize,

                                                 allowSecureLayers, layerTransform, layerBufferSize,

                                                 reqDataSpace, allowSecureLayers, layerTransform,

                                                 hintForSeamlessTransition);

                                                 layerBufferSize, hintForSeamlessTransition);

    }

    }

};

};

services/surfaceflinger/SurfaceFlinger.cpp

+3 −4
Original line number Original line Diff line number Diff line
@@ -8207,7 +8207,7 @@ ftl::SharedFuture<FenceResult> SurfaceFlinger::captureScreenshot( 
                ALOGW("Couldn't find layer snapshot for %d",

                ALOGW("Couldn't find layer snapshot for %d",

                      layerRenderAreaBuilder->layer->getSequence());

                      layerRenderAreaBuilder->layer->getSequence());

            } else {

            } else {

                layerRenderAreaBuilder->setLayerInfo(snapshot);

                layerRenderAreaBuilder->setLayerSnapshot(*snapshot);

            }

            }

        }

        }
@@ -8302,9 +8302,8 @@ ftl::SharedFuture<FenceResult> SurfaceFlinger::renderScreenImpl( 
        Mutex::Autolock lock(mStateLock);

        Mutex::Autolock lock(mStateLock);

        const DisplayDevice* display = nullptr;

        const DisplayDevice* display = nullptr;

        if (parent) {

        if (parent) {

            const frontend::LayerSnapshot* snapshot = mLayerLifecycleManagerEnabled

            const frontend::LayerSnapshot* snapshot =

                    ? mLayerSnapshotBuilder.getSnapshot(parent->sequence)

                    mLayerSnapshotBuilder.getSnapshot(parent->sequence);

                    : parent->getLayerSnapshot();

            if (snapshot) {

            if (snapshot) {

                display = findDisplay([layerStack = snapshot->outputFilter.layerStack](

                display = findDisplay([layerStack = snapshot->outputFilter.layerStack](

                                              const auto& display) {

                                              const auto& display) {