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

Commit 66f2fb13 authored by Sally Qi's avatar Sally Qi
Browse files

Add metrics for logging luts in the SurfaceControlEvents 

Bug: 383391288
Test: android.cts.statsdatom.coregraphics.GraphicsAtomTests#surfaceControlLutsEvents
Flag: EXEMPT proto cannot be flagged

Change-Id: I189b3cfaf8b969f719b777f5e83a36ac5ff8fdeb
parent 2fabbc07

services/surfaceflinger/Layer.cpp

+28 −15
Original line number Diff line number Diff line
@@ -186,11 +186,11 @@ Layer::~Layer() { 
    mFlinger->onLayerDestroyed(this);



    const auto currentTime = std::chrono::steady_clock::now();

    if (mBufferInfo.mTimeSinceDataspaceUpdate > std::chrono::steady_clock::time_point::min()) {

        mFlinger->mLayerEvents.emplace_back(mOwnerUid, getSequence(), mBufferInfo.mDataspace,

                                            std::chrono::duration_cast<std::chrono::milliseconds>(

                                                    currentTime -

                                                    mBufferInfo.mTimeSinceDataspaceUpdate));

    if (mLastLayerEvent.has_value() &&

        mTimeSinceLayerEventsUpdate > std::chrono::steady_clock::time_point::min()) {

        mLastLayerEvent->timeSinceLastEvent = std::chrono::duration_cast<std::chrono::milliseconds>(

                currentTime - mTimeSinceLayerEventsUpdate);

        mFlinger->mLayerEvents.emplace_back(mLastLayerEvent.value());

    }



    if (mDrawingState.sidebandStream != nullptr) {
@@ -1326,17 +1326,8 @@ void Layer::gatherBufferInfo() { 
            }

        }

    }

    if (lastDataspace != mBufferInfo.mDataspace ||

        mBufferInfo.mTimeSinceDataspaceUpdate == std::chrono::steady_clock::time_point::min()) {

    if (lastDataspace != mBufferInfo.mDataspace) {

        mFlinger->mHdrLayerInfoChanged = true;

        const auto currentTime = std::chrono::steady_clock::now();

        if (mBufferInfo.mTimeSinceDataspaceUpdate > std::chrono::steady_clock::time_point::min()) {

            mFlinger->mLayerEvents

                    .emplace_back(mOwnerUid, getSequence(), lastDataspace,

                                  std::chrono::duration_cast<std::chrono::milliseconds>(

                                          currentTime - mBufferInfo.mTimeSinceDataspaceUpdate));

        }

        mBufferInfo.mTimeSinceDataspaceUpdate = currentTime;

    }

    if (mBufferInfo.mDesiredHdrSdrRatio != mDrawingState.desiredHdrSdrRatio) {

        mBufferInfo.mDesiredHdrSdrRatio = mDrawingState.desiredHdrSdrRatio;
@@ -1344,6 +1335,28 @@ void Layer::gatherBufferInfo() { 
    }

    mBufferInfo.mCrop = computeBufferCrop(mDrawingState);

    mBufferInfo.mTransformToDisplayInverse = mDrawingState.transformToDisplayInverse;



    // update layer event

    // a new layer event instance is added if any defined parameter changes.

    if (!mLastLayerEvent.has_value()) {

        mLastLayerEvent =

                std::make_optional<SurfaceFlinger::LayerEvent>({mOwnerUid, getSequence()});

    }



    if (mLastLayerEvent->dataspace != mBufferInfo.mDataspace ||

        mLastLayerEvent->useLuts != mDrawingState.useLuts ||

        mTimeSinceLayerEventsUpdate == std::chrono::steady_clock::time_point::min()) {

        const auto currentTime = std::chrono::steady_clock::now();

        if (mTimeSinceLayerEventsUpdate > std::chrono::steady_clock::time_point::min()) {

            mLastLayerEvent->timeSinceLastEvent =

                    std::chrono::duration_cast<std::chrono::milliseconds>(

                            currentTime - mTimeSinceLayerEventsUpdate);

            mFlinger->mLayerEvents.emplace_back(mLastLayerEvent.value());

        }

        mTimeSinceLayerEventsUpdate = currentTime;

        mLastLayerEvent->dataspace = mBufferInfo.mDataspace;

        mLastLayerEvent->useLuts = mDrawingState.useLuts;

    }

}



Rect Layer::computeBufferCrop(const State& s) {

services/surfaceflinger/Layer.h

+5 −2
Original line number Diff line number Diff line
@@ -160,6 +160,7 @@ public: 
        float desiredHdrSdrRatio = -1.f;

        int64_t latchedVsyncId = 0;

        bool useVsyncIdForRefreshRateSelection = false;

        bool useLuts = false;

    };



    explicit Layer(const surfaceflinger::LayerCreationArgs& args);
@@ -187,6 +188,7 @@ public: 
    bool setDataspace(ui::Dataspace /*dataspace*/);

    bool setExtendedRangeBrightness(float currentBufferRatio, float desiredRatio);

    bool setDesiredHdrHeadroom(float desiredRatio);

    void setUseLuts(bool useLuts) { mDrawingState.useLuts = useLuts; }

    bool setSidebandStream(const sp<NativeHandle>& /*sidebandStream*/,

                           const FrameTimelineInfo& /* info*/, nsecs_t /* postTime */,

                           gui::GameMode gameMode);
@@ -245,8 +247,6 @@ public: 
        sp<Fence> mFence;

        uint32_t mTransform{0};

        ui::Dataspace mDataspace{ui::Dataspace::UNKNOWN};

        std::chrono::steady_clock::time_point mTimeSinceDataspaceUpdate =

                std::chrono::steady_clock::time_point::min();

        Rect mCrop;

        PixelFormat mPixelFormat{PIXEL_FORMAT_NONE};

        bool mTransformToDisplayInverse{false};
@@ -258,6 +258,9 @@ public: 
    };



    BufferInfo mBufferInfo;

    std::optional<SurfaceFlinger::LayerEvent> mLastLayerEvent;

    std::chrono::steady_clock::time_point mTimeSinceLayerEventsUpdate =

            std::chrono::steady_clock::time_point::min();

    std::shared_ptr<gui::BufferReleaseChannel::ProducerEndpoint> mBufferReleaseChannel;



    bool fenceHasSignaled() const;

services/surfaceflinger/SurfaceFlinger.cpp

+6 −1
Original line number Diff line number Diff line
@@ -3388,7 +3388,8 @@ void SurfaceFlinger::onCompositionPresented(PhysicalDisplayId pacesetterId, 
                stats::stats_write(stats::SURFACE_CONTROL_EVENT,

                                   static_cast<int32_t>(layerEvent.uid),

                                   static_cast<int64_t>(layerEvent.timeSinceLastEvent.count()),

                                   static_cast<int32_t>(layerEvent.dataspace));

                                   static_cast<int32_t>(layerEvent.dataspace),

                                   static_cast<bool>(layerEvent.useLuts));

        if (result < 0) {

            ALOGW("Failed to report layer event with error: %d", result);

        }
@@ -5436,6 +5437,10 @@ uint32_t SurfaceFlinger::updateLayerCallbacksAndStats(const FrameTimelineInfo& f 
        layer->setBufferReleaseChannel(s.bufferReleaseChannel);

    }



    if (what & layer_state_t::eLutsChanged) {

        layer->setUseLuts(s.luts ? true : false);

    }



    const auto& requestedLayerState = mLayerLifecycleManager.getLayerFromId(layer->getSequence());

    bool willPresentCurrentTransaction = requestedLayerState &&

            (requestedLayerState->hasReadyFrame() ||

services/surfaceflinger/SurfaceFlinger.h

+1 −0
Original line number Diff line number Diff line
@@ -1330,6 +1330,7 @@ private: 
        int32_t layerId;

        ui::Dataspace dataspace;

        std::chrono::milliseconds timeSinceLastEvent;

        bool useLuts;

    };

    std::vector<LayerEvent> mLayerEvents;