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

Commit d57b9698 authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Automerger Merge Worker
Browse files

Merge "[sf] Add support for transform hint in new front end" into udc-dev am: 978c2978 

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/native/+/22164338



Change-Id: I17cf74806550611e594b51b40c55b5dbb1f055e4
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 4c84a23d 978c2978

services/surfaceflinger/FrontEnd/LayerSnapshot.h

+1 −0
Original line number Diff line number Diff line
@@ -89,6 +89,7 @@ struct LayerSnapshot : public compositionengine::LayerFECompositionState { 
    gui::GameMode gameMode;

    scheduler::LayerInfo::FrameRate frameRate;

    ui::Transform::RotationFlags fixedTransformHint;

    std::optional<ui::Transform::RotationFlags> transformHint;

    bool handleSkipScreenshotFlag = false;

    int32_t frameRateSelectionPriority;

    LayerHierarchy::TraversalPath mirrorRootPath;

services/surfaceflinger/FrontEnd/LayerSnapshotBuilder.cpp

+37 −18
Original line number Diff line number Diff line
@@ -22,10 +22,15 @@ 
#include "LayerSnapshotBuilder.h"

#include <gui/TraceUtils.h>

#include <ui/FloatRect.h>



#include <numeric>

#include <optional>



#include <gui/TraceUtils.h>

#include "DisplayHardware/HWC2.h"

#include "DisplayHardware/Hal.h"

#include "LayerLog.h"

#include "LayerSnapshotBuilder.h"

#include "TimeStats/TimeStats.h"

#include "ftl/small_map.h"
@@ -649,12 +654,14 @@ void LayerSnapshotBuilder::resetRelativeState(LayerSnapshot& snapshot) { 
    snapshot.relativeLayerMetadata.mMap.clear();

}



uint32_t getDisplayRotationFlags(

        const display::DisplayMap<ui::LayerStack, frontend::DisplayInfo>& displays,

        const ui::LayerStack& layerStack) {

    static frontend::DisplayInfo sDefaultDisplayInfo = {.isPrimary = false};

    auto display = displays.get(layerStack).value_or(sDefaultDisplayInfo).get();

    return display.isPrimary ? display.rotationFlags : 0;

uint32_t getPrimaryDisplayRotationFlags(

        const display::DisplayMap<ui::LayerStack, frontend::DisplayInfo>& displays) {

    for (auto& [_, display] : displays) {

        if (display.isPrimary) {

            return display.rotationFlags;

        }

    }

    return 0;

}



void LayerSnapshotBuilder::updateSnapshot(LayerSnapshot& snapshot, const Args& args,
@@ -681,8 +688,7 @@ void LayerSnapshotBuilder::updateSnapshot(LayerSnapshot& snapshot, const Args& a 
            ? requested.layerStack

            : parentSnapshot.outputFilter.layerStack;



    uint32_t displayRotationFlags =

            getDisplayRotationFlags(args.displays, snapshot.outputFilter.layerStack);

    uint32_t primaryDisplayRotationFlags = getPrimaryDisplayRotationFlags(args.displays);

    const bool forceUpdate = args.forceUpdate == ForceUpdateFlags::ALL ||

            snapshot.changes.any(RequestedLayerState::Changes::Visibility |

                                 RequestedLayerState::Changes::Created);
@@ -696,7 +702,7 @@ void LayerSnapshotBuilder::updateSnapshot(LayerSnapshot& snapshot, const Args& a 
                : Fence::NO_FENCE;

        snapshot.buffer =

                requested.externalTexture ? requested.externalTexture->getBuffer() : nullptr;

        snapshot.bufferSize = requested.getBufferSize(displayRotationFlags);

        snapshot.bufferSize = requested.getBufferSize(primaryDisplayRotationFlags);

        snapshot.geomBufferSize = snapshot.bufferSize;

        snapshot.croppedBufferSize = requested.getCroppedBufferSize(snapshot.bufferSize);

        snapshot.dataspace = requested.dataspace;
@@ -751,15 +757,28 @@ void LayerSnapshotBuilder::updateSnapshot(LayerSnapshot& snapshot, const Args& a 
        snapshot.gameMode = requested.metadata.has(gui::METADATA_GAME_MODE)

                ? requested.gameMode

                : parentSnapshot.gameMode;

        snapshot.fixedTransformHint = requested.fixedTransformHint != ui::Transform::ROT_INVALID

                ? requested.fixedTransformHint

                : parentSnapshot.fixedTransformHint;

        // Display mirrors are always placed in a VirtualDisplay so we never want to capture layers

        // marked as skip capture

        snapshot.handleSkipScreenshotFlag = parentSnapshot.handleSkipScreenshotFlag ||

                (requested.layerStackToMirror != ui::INVALID_LAYER_STACK);

    }



    if (forceUpdate || snapshot.changes.any(RequestedLayerState::Changes::AffectsChildren) ||

        args.displayChanges) {

        snapshot.fixedTransformHint = requested.fixedTransformHint != ui::Transform::ROT_INVALID

                ? requested.fixedTransformHint

                : parentSnapshot.fixedTransformHint;



        if (snapshot.fixedTransformHint != ui::Transform::ROT_INVALID) {

            snapshot.transformHint = snapshot.fixedTransformHint;

        } else {

            const auto display = args.displays.get(snapshot.outputFilter.layerStack);

            snapshot.transformHint = display.has_value()

                    ? std::make_optional<>(display->get().transformHint)

                    : std::nullopt;

        }

    }



    if (forceUpdate ||

        snapshot.changes.any(RequestedLayerState::Changes::FrameRate |

                             RequestedLayerState::Changes::Hierarchy)) {
@@ -799,7 +818,7 @@ void LayerSnapshotBuilder::updateSnapshot(LayerSnapshot& snapshot, const Args& a 
    if (forceUpdate ||

        snapshot.changes.any(RequestedLayerState::Changes::Hierarchy |

                             RequestedLayerState::Changes::Geometry)) {

        updateLayerBounds(snapshot, requested, parentSnapshot, displayRotationFlags);

        updateLayerBounds(snapshot, requested, parentSnapshot, primaryDisplayRotationFlags);

        updateRoundedCorner(snapshot, requested, parentSnapshot);

    }
@@ -870,10 +889,10 @@ void LayerSnapshotBuilder::updateRoundedCorner(LayerSnapshot& snapshot, 
void LayerSnapshotBuilder::updateLayerBounds(LayerSnapshot& snapshot,

                                             const RequestedLayerState& requested,

                                             const LayerSnapshot& parentSnapshot,

                                             uint32_t displayRotationFlags) {

                                             uint32_t primaryDisplayRotationFlags) {

    snapshot.croppedBufferSize = requested.getCroppedBufferSize(snapshot.bufferSize);

    snapshot.geomCrop = requested.crop;

    snapshot.localTransform = requested.getTransform(displayRotationFlags);

    snapshot.localTransform = requested.getTransform(primaryDisplayRotationFlags);

    snapshot.localTransformInverse = snapshot.localTransform.inverse();

    snapshot.geomLayerTransform = parentSnapshot.geomLayerTransform * snapshot.localTransform;

    const bool transformWasInvalid = snapshot.invalidTransform;
@@ -887,14 +906,14 @@ void LayerSnapshotBuilder::updateLayerBounds(LayerSnapshot& snapshot, 
                                   requestedT.dsdy(), requestedT.dtdx(), requestedT.dtdy());

        std::string bufferDebug;

        if (requested.externalTexture) {

            auto unRotBuffer = requested.getUnrotatedBufferSize(displayRotationFlags);

            auto unRotBuffer = requested.getUnrotatedBufferSize(primaryDisplayRotationFlags);

            auto& destFrame = requested.destinationFrame;

            bufferDebug = base::StringPrintf(" buffer={%d,%d}  displayRot=%d"

                                             " destFrame={%d,%d,%d,%d} unRotBuffer={%d,%d}",

                                             requested.externalTexture->getWidth(),

                                             requested.externalTexture->getHeight(),

                                             displayRotationFlags, destFrame.left, destFrame.top,

                                             destFrame.right, destFrame.bottom,

                                             primaryDisplayRotationFlags, destFrame.left,

                                             destFrame.top, destFrame.right, destFrame.bottom,

                                             unRotBuffer.getHeight(), unRotBuffer.getWidth());

        }

        ALOGW("Resetting transform for %s because it is invalid.%s%s",

services/surfaceflinger/Layer.cpp

+12 −8
Original line number Diff line number Diff line
@@ -1505,7 +1505,7 @@ void Layer::updateTransformHint(ui::Transform::RotationFlags transformHint) { 
        transformHint = ui::Transform::ROT_0;

    }



    setTransformHint(transformHint);

    setTransformHintLegacy(transformHint);

}



// ----------------------------------------------------------------------------
@@ -2865,9 +2865,13 @@ void Layer::onSurfaceFrameCreated( 


void Layer::releasePendingBuffer(nsecs_t dequeueReadyTime) {

    for (const auto& handle : mDrawingState.callbackHandles) {

        if (mFlinger->mLayerLifecycleManagerEnabled) {

            handle->transformHint = mTransformHint;

        } else {

            handle->transformHint = mSkipReportingTransformHint

                    ? std::nullopt

                : std::make_optional<uint32_t>(mTransformHint);

                    : std::make_optional<uint32_t>(mTransformHintLegacy);

        }

        handle->dequeueReadyTime = dequeueReadyTime;

        handle->currentMaxAcquiredBufferCount =

                mFlinger->getMaxAcquiredBufferCountForCurrentRefreshRate(mOwnerUid);
@@ -4027,10 +4031,10 @@ sp<GraphicBuffer> Layer::getBuffer() const { 
    return mBufferInfo.mBuffer ? mBufferInfo.mBuffer->getBuffer() : nullptr;

}



void Layer::setTransformHint(ui::Transform::RotationFlags displayTransformHint) {

    mTransformHint = getFixedTransformHint();

    if (mTransformHint == ui::Transform::ROT_INVALID) {

        mTransformHint = displayTransformHint;

void Layer::setTransformHintLegacy(ui::Transform::RotationFlags displayTransformHint) {

    mTransformHintLegacy = getFixedTransformHint();

    if (mTransformHintLegacy == ui::Transform::ROT_INVALID) {

        mTransformHintLegacy = displayTransformHint;

    }

    mSkipReportingTransformHint = false;

}

services/surfaceflinger/Layer.h

+6 −4
Original line number Diff line number Diff line
@@ -455,8 +455,6 @@ public: 
    sp<GraphicBuffer> getBuffer() const;

    const std::shared_ptr<renderengine::ExternalTexture>& getExternalTexture() const;



    ui::Transform::RotationFlags getTransformHint() const { return mTransformHint; }



    /*

     * Returns if a frame is ready

     */
@@ -878,6 +876,9 @@ public: 
        };

    };

    bool hasBuffer() const { return mBufferInfo.mBuffer != nullptr; }

    void setTransformHint(std::optional<ui::Transform::RotationFlags> transformHint) {

        mTransformHint = transformHint;

    }



protected:

    // For unit tests
@@ -1154,14 +1155,15 @@ private: 
    float mBorderWidth;

    half4 mBorderColor;



    void setTransformHint(ui::Transform::RotationFlags);

    void setTransformHintLegacy(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;

    ui::Transform::RotationFlags mTransformHintLegacy = ui::Transform::ROT_0;

    bool mSkipReportingTransformHint = true;

    std::optional<ui::Transform::RotationFlags> mTransformHint = std::nullopt;



    ReleaseCallbackId mPreviousReleaseCallbackId = ReleaseCallbackId::INVALID_ID;

    uint64_t mPreviousReleasedFrameNumber = 0;

services/surfaceflinger/SurfaceFlinger.cpp

+6 −0
Original line number Diff line number Diff line
@@ -5137,6 +5137,12 @@ uint32_t SurfaceFlinger::updateLayerCallbacksAndStats(const FrameTimelineInfo& f 
        if (layer->setSidebandStream(s.sidebandStream)) flags |= eTraversalNeeded;

    }

    if (what & layer_state_t::eBufferChanged) {

        std::optional<ui::Transform::RotationFlags> transformHint = std::nullopt;

        frontend::LayerSnapshot* snapshot = mLayerSnapshotBuilder.getSnapshot(layer->sequence);

        if (snapshot) {

            transformHint = snapshot->transformHint;

        }

        layer->setTransformHint(transformHint);

        if (layer->setBuffer(composerState.externalTexture, *s.bufferData, postTime,

                             desiredPresentTime, isAutoTimestamp, dequeueBufferTimestamp,

                             frameTimelineInfo)) {