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

Commit d8ab4396 authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge "egl: Remove retire event."

parents 53485d51 4e606e39

include/gui/FrameTimestamps.h

+2 −12
Original line number Diff line number Diff line
@@ -43,7 +43,6 @@ enum class FrameEvent { 
    LAST_REFRESH_START,

    GPU_COMPOSITION_DONE,

    DISPLAY_PRESENT,

    DISPLAY_RETIRE,

    DEQUEUE_READY,

    RELEASE,

    EVENT_COUNT, // Not an actual event.
@@ -70,7 +69,6 @@ struct FrameEvents { 
    bool hasAcquireInfo() const;

    bool hasGpuCompositionDoneInfo() const;

    bool hasDisplayPresentInfo() const;

    bool hasDisplayRetireInfo() const;

    bool hasReleaseInfo() const;

    bool hasDequeueReadyInfo() const;
@@ -85,7 +83,6 @@ struct FrameEvents { 
    // encountered help us determine if timestamps aren't available because

    // a) we'll just never get them or b) they're not ready yet.

    bool addPostCompositeCalled{false};

    bool addRetireCalled{false};

    bool addReleaseCalled{false};



    nsecs_t postedTime{TIMESTAMP_PENDING};
@@ -98,7 +95,6 @@ struct FrameEvents { 
    std::shared_ptr<FenceTime> acquireFence{FenceTime::NO_FENCE};

    std::shared_ptr<FenceTime> gpuCompositionDoneFence{FenceTime::NO_FENCE};

    std::shared_ptr<FenceTime> displayPresentFence{FenceTime::NO_FENCE};

    std::shared_ptr<FenceTime> displayRetireFence{FenceTime::NO_FENCE};

    std::shared_ptr<FenceTime> releaseFence{FenceTime::NO_FENCE};

};
@@ -167,7 +163,6 @@ protected: 
    FenceTimeline mAcquireTimeline;

    FenceTimeline mGpuCompositionDoneTimeline;

    FenceTimeline mPresentTimeline;

    FenceTimeline mRetireTimeline;

    FenceTimeline mReleaseTimeline;

};
@@ -224,8 +219,6 @@ public: 
            const std::shared_ptr<FenceTime>& gpuCompositionDone,

            const std::shared_ptr<FenceTime>& displayPresent,

            const CompositorTiming& compositorTiming);

    void addRetire(uint64_t frameNumber,

            const std::shared_ptr<FenceTime>& displayRetire);

    void addRelease(uint64_t frameNumber, nsecs_t dequeueReadyTime,

            std::shared_ptr<FenceTime>&& release);
@@ -239,7 +232,6 @@ private: 


    size_t mQueueOffset{0};

    size_t mCompositionOffset{0};

    size_t mRetireOffset{0};

    size_t mReleaseOffset{0};



    int mCurrentConnectId{0};
@@ -281,7 +273,6 @@ private: 
    uint64_t mFrameNumber{0};



    bool mAddPostCompositeCalled{0};

    bool mAddRetireCalled{0};

    bool mAddReleaseCalled{0};



    nsecs_t mPostedTime{FrameEvents::TIMESTAMP_PENDING};
@@ -293,17 +284,16 @@ private: 


    FenceTime::Snapshot mGpuCompositionDoneFence;

    FenceTime::Snapshot mDisplayPresentFence;

    FenceTime::Snapshot mDisplayRetireFence;

    FenceTime::Snapshot mReleaseFence;



    // This is a static method with an auto return value so we can call

    // it without needing const and non-const versions.

    template <typename ThisT>

    static inline auto allFences(ThisT fed) ->

            std::array<decltype(&fed->mReleaseFence), 4> {

            std::array<decltype(&fed->mReleaseFence), 3> {

        return {{

            &fed->mGpuCompositionDoneFence, &fed->mDisplayPresentFence,

            &fed->mDisplayRetireFence, &fed->mReleaseFence

            &fed->mReleaseFence

        }};

    }

};

include/gui/ISurfaceComposer.h

+0 −5
Original line number Diff line number Diff line
@@ -126,11 +126,6 @@ public: 
    virtual bool authenticateSurfaceTexture(

            const sp<IGraphicBufferProducer>& surface) const = 0;



    /* Returns the frame timestamps supported by SurfaceFlinger.

     */

    virtual status_t getSupportedFrameTimestamps(

            std::vector<FrameEvent>* outSupported) const = 0;



    /* set display power mode. depending on the mode, it can either trigger

     * screen on, off or low power mode and wait for it to complete.

     * requires ACCESS_SURFACE_FLINGER permission.

include/gui/Surface.h

+2 −7
Original line number Diff line number Diff line
@@ -152,8 +152,8 @@ public: 
            nsecs_t* outRequestedPresentTime, nsecs_t* outAcquireTime,

            nsecs_t* outLatchTime, nsecs_t* outFirstRefreshStartTime,

            nsecs_t* outLastRefreshStartTime, nsecs_t* outGlCompositionDoneTime,

            nsecs_t* outDisplayPresentTime, nsecs_t* outDisplayRetireTime,

            nsecs_t* outDequeueReadyTime, nsecs_t* outReleaseTime);

            nsecs_t* outDisplayPresentTime, nsecs_t* outDequeueReadyTime,

            nsecs_t* outReleaseTime);



    status_t getWideColorSupport(bool* supported);

    status_t getHdrSupport(bool* supported);
@@ -411,11 +411,6 @@ protected: 
    uint64_t mNextFrameNumber = 1;

    uint64_t mLastFrameNumber = 0;



    // Mutable because ANativeWindow::query needs this class const.

    mutable bool mQueriedSupportedTimestamps;

    mutable bool mFrameTimestampsSupportsPresent;

    mutable bool mFrameTimestampsSupportsRetire;



    // A cached copy of the FrameEventHistory maintained by the consumer.

    bool mEnableFrameTimestamps = false;

    std::unique_ptr<ProducerFrameEventHistory> mFrameEventHistory;

libs/gui/FrameTimestamps.cpp

+15 −49
Original line number Diff line number Diff line
@@ -52,9 +52,8 @@ bool FrameEvents::hasFirstRefreshStartInfo() const { 


bool FrameEvents::hasLastRefreshStartInfo() const {

    // The last refresh start time may continue to update until a new frame

    // is latched. We know we have the final value once the release or retire

    // info is set. See ConsumerFrameEventHistory::addRetire/Release.

    return addRetireCalled || addReleaseCalled;

    // is latched. We know we have the final value once the release info is set.

    return addReleaseCalled;

}



bool FrameEvents::hasDequeueReadyInfo() const {
@@ -76,11 +75,6 @@ bool FrameEvents::hasDisplayPresentInfo() const { 
    return addPostCompositeCalled;

}



bool FrameEvents::hasDisplayRetireInfo() const {

    // We may not get a displayRetire in addRetire for HWC2.

    return addRetireCalled;

}



bool FrameEvents::hasReleaseInfo() const {

    return addReleaseCalled;

}
@@ -89,7 +83,6 @@ void FrameEvents::checkFencesForCompletion() { 
    acquireFence->getSignalTime();

    gpuCompositionDoneFence->getSignalTime();

    displayPresentFence->getSignalTime();

    displayRetireFence->getSignalTime();

    releaseFence->getSignalTime();

}
@@ -145,8 +138,6 @@ void FrameEvents::dump(String8& outString) const 
            !addPostCompositeCalled, *gpuCompositionDoneFence);

    dumpFenceTime(outString, "Display Present   \t",

            !addPostCompositeCalled, *displayPresentFence);

    dumpFenceTime(outString, "Display Retire    \t",

            !addRetireCalled, *displayRetireFence);



    outString.appendFormat("--- DequeueReady  \t");

    if (FrameEvents::isValidTimestamp(dequeueReadyTime)) {
@@ -286,7 +277,6 @@ void ProducerFrameEventHistory::applyDelta( 
        FrameEvents& frame = mFrames[d.mIndex];



        frame.addPostCompositeCalled = d.mAddPostCompositeCalled != 0;

        frame.addRetireCalled = d.mAddRetireCalled != 0;

        frame.addReleaseCalled = d.mAddReleaseCalled != 0;



        frame.postedTime = d.mPostedTime;
@@ -302,7 +292,6 @@ void ProducerFrameEventHistory::applyDelta( 
            frame.acquireFence = FenceTime::NO_FENCE;

            frame.gpuCompositionDoneFence = FenceTime::NO_FENCE;

            frame.displayPresentFence = FenceTime::NO_FENCE;

            frame.displayRetireFence = FenceTime::NO_FENCE;

            frame.releaseFence = FenceTime::NO_FENCE;

            // The consumer only sends valid frames.

            frame.valid = true;
@@ -312,8 +301,6 @@ void ProducerFrameEventHistory::applyDelta( 
                &frame.gpuCompositionDoneFence, d.mGpuCompositionDoneFence);

        applyFenceDelta(&mPresentTimeline,

                &frame.displayPresentFence, d.mDisplayPresentFence);

        applyFenceDelta(&mRetireTimeline,

                &frame.displayRetireFence, d.mDisplayRetireFence);

        applyFenceDelta(&mReleaseTimeline,

                &frame.releaseFence, d.mReleaseFence);

    }
@@ -323,7 +310,6 @@ void ProducerFrameEventHistory::updateSignalTimes() { 
    mAcquireTimeline.updateSignalTimes();

    mGpuCompositionDoneTimeline.updateSignalTimes();

    mPresentTimeline.updateSignalTimes();

    mRetireTimeline.updateSignalTimes();

    mReleaseTimeline.updateSignalTimes();

}
@@ -444,18 +430,6 @@ void ConsumerFrameEventHistory::addPostComposition(uint64_t frameNumber, 
    }

}



void ConsumerFrameEventHistory::addRetire(

        uint64_t frameNumber, const std::shared_ptr<FenceTime>& displayRetire) {

    FrameEvents* frame = getFrame(frameNumber, &mRetireOffset);

    if (frame == nullptr) {

        ALOGE_IF(mProducerWantsEvents, "addRetire: Did not find frame.");

        return;

    }

    frame->addRetireCalled = true;

    frame->displayRetireFence = displayRetire;

    mFramesDirty[mRetireOffset].setDirty<FrameEvent::DISPLAY_RETIRE>();

}



void ConsumerFrameEventHistory::addRelease(uint64_t frameNumber,

        nsecs_t dequeueReadyTime, std::shared_ptr<FenceTime>&& release) {

    FrameEvents* frame = getFrame(frameNumber, &mReleaseOffset);
@@ -515,7 +489,6 @@ FrameEventsDelta::FrameEventsDelta( 
    : mIndex(index),

      mFrameNumber(frameTimestamps.frameNumber),

      mAddPostCompositeCalled(frameTimestamps.addPostCompositeCalled),

      mAddRetireCalled(frameTimestamps.addRetireCalled),

      mAddReleaseCalled(frameTimestamps.addReleaseCalled),

      mPostedTime(frameTimestamps.postedTime),

      mRequestedPresentTime(frameTimestamps.requestedPresentTime),
@@ -531,9 +504,6 @@ FrameEventsDelta::FrameEventsDelta( 
        mDisplayPresentFence =

                frameTimestamps.displayPresentFence->getSnapshot();

    }

    if (dirtyFields.isDirty<FrameEvent::DISPLAY_RETIRE>()) {

        mDisplayRetireFence = frameTimestamps.displayRetireFence->getSnapshot();

    }

    if (dirtyFields.isDirty<FrameEvent::RELEASE>()) {

        mReleaseFence = frameTimestamps.releaseFence->getSnapshot();

    }
@@ -541,9 +511,8 @@ FrameEventsDelta::FrameEventsDelta( 


constexpr size_t FrameEventsDelta::minFlattenedSize() {

    return sizeof(FrameEventsDelta::mFrameNumber) +

            sizeof(uint8_t) + // mIndex

            sizeof(uint16_t) + // mIndex

            sizeof(uint8_t) + // mAddPostCompositeCalled

            sizeof(uint8_t) + // mAddRetireCalled

            sizeof(uint8_t) + // mAddReleaseCalled

            sizeof(FrameEventsDelta::mPostedTime) +

            sizeof(FrameEventsDelta::mRequestedPresentTime) +
@@ -578,18 +547,16 @@ status_t FrameEventsDelta::flatten(void*& buffer, size_t& size, int*& fds, 
    }



    if (mIndex >= FrameEventHistory::MAX_FRAME_HISTORY ||

            mIndex > std::numeric_limits<uint8_t>::max()) {

            mIndex > std::numeric_limits<uint16_t>::max()) {

        return BAD_VALUE;

    }



    FlattenableUtils::write(buffer, size, mFrameNumber);



    // These are static_cast to uint8_t for alignment.

    FlattenableUtils::write(buffer, size, static_cast<uint8_t>(mIndex));

    // These are static_cast to uint16_t/uint8_t for alignment.

    FlattenableUtils::write(buffer, size, static_cast<uint16_t>(mIndex));

    FlattenableUtils::write(

            buffer, size, static_cast<uint8_t>(mAddPostCompositeCalled));

    FlattenableUtils::write(

            buffer, size, static_cast<uint8_t>(mAddRetireCalled));

    FlattenableUtils::write(

            buffer, size, static_cast<uint8_t>(mAddReleaseCalled));
@@ -618,19 +585,18 @@ status_t FrameEventsDelta::unflatten(void const*& buffer, size_t& size, 


    FlattenableUtils::read(buffer, size, mFrameNumber);



    // These were written as uint8_t for alignment.

    uint8_t temp = 0;

    FlattenableUtils::read(buffer, size, temp);

    mIndex = temp;

    // These were written as uint16_t/uint8_t for alignment.

    uint16_t temp16 = 0;

    FlattenableUtils::read(buffer, size, temp16);

    mIndex = temp16;

    if (mIndex >= FrameEventHistory::MAX_FRAME_HISTORY) {

        return BAD_VALUE;

    }

    FlattenableUtils::read(buffer, size, temp);

    mAddPostCompositeCalled = static_cast<bool>(temp);

    FlattenableUtils::read(buffer, size, temp);

    mAddRetireCalled = static_cast<bool>(temp);

    FlattenableUtils::read(buffer, size, temp);

    mAddReleaseCalled = static_cast<bool>(temp);

    uint8_t temp8 = 0;

    FlattenableUtils::read(buffer, size, temp8);

    mAddPostCompositeCalled = static_cast<bool>(temp8);

    FlattenableUtils::read(buffer, size, temp8);

    mAddReleaseCalled = static_cast<bool>(temp8);



    FlattenableUtils::read(buffer, size, mPostedTime);

    FlattenableUtils::read(buffer, size, mRequestedPresentTime);

libs/gui/ISurfaceComposer.cpp

+0 −63
Original line number Diff line number Diff line
@@ -166,50 +166,6 @@ public: 
        return result != 0;

    }



    virtual status_t getSupportedFrameTimestamps(

            std::vector<FrameEvent>* outSupported) const {

        if (!outSupported) {

            return UNEXPECTED_NULL;

        }

        outSupported->clear();



        Parcel data, reply;



        status_t err = data.writeInterfaceToken(

                ISurfaceComposer::getInterfaceDescriptor());

        if (err != NO_ERROR) {

            return err;

        }



        err = remote()->transact(

                BnSurfaceComposer::GET_SUPPORTED_FRAME_TIMESTAMPS,

                data, &reply);

        if (err != NO_ERROR) {

            return err;

        }



        int32_t result = 0;

        err = reply.readInt32(&result);

        if (err != NO_ERROR) {

            return err;

        }

        if (result != NO_ERROR) {

            return result;

        }



        std::vector<int32_t> supported;

        err = reply.readInt32Vector(&supported);

        if (err != NO_ERROR) {

            return err;

        }



        outSupported->reserve(supported.size());

        for (int32_t s : supported) {

            outSupported->push_back(static_cast<FrameEvent>(s));

        }

        return NO_ERROR;

    }



    virtual sp<IDisplayEventConnection> createDisplayEventConnection()

    {

        Parcel data, reply;
@@ -580,25 +536,6 @@ status_t BnSurfaceComposer::onTransact( 
            reply->writeInt32(result);

            return NO_ERROR;

        }

        case GET_SUPPORTED_FRAME_TIMESTAMPS: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            std::vector<FrameEvent> supportedTimestamps;

            status_t result = getSupportedFrameTimestamps(&supportedTimestamps);

            status_t err = reply->writeInt32(result);

            if (err != NO_ERROR) {

                return err;

            }

            if (result != NO_ERROR) {

                return result;

            }



            std::vector<int32_t> supported;

            supported.reserve(supportedTimestamps.size());

            for (FrameEvent s : supportedTimestamps) {

                supported.push_back(static_cast<int32_t>(s));

            }

            return reply->writeInt32Vector(supported);

        }

        case CREATE_DISPLAY_EVENT_CONNECTION: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            sp<IDisplayEventConnection> connection(createDisplayEventConnection());