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

Commit fda30bb8 authored by Marissa Wall's avatar Marissa Wall
Browse files

blast: send TransactionStats with callback 

Add TransactionStats to callback so the client knows when the
buffers were released and acquired. Also when transaction was
presented and latched.

Test: Transaction_test
Bug: 80477568

Change-Id: I578a7000193a4401783cb2538172167a552b043f
parent e2ffb426

libs/gui/ITransactionCompletedListener.cpp

+34 −2
Original line number Original line Diff line number Diff line
@@ -31,18 +31,50 @@ enum class Tag : uint32_t { 
} // Anonymous namespace

} // Anonymous namespace





status_t SurfaceStats::writeToParcel(Parcel* output) const {

status_t SurfaceStats::writeToParcel(Parcel* output) const {

    return output->writeStrongBinder(surfaceControl);

    status_t err = output->writeStrongBinder(surfaceControl);

    if (err != NO_ERROR) {

        return err;

    }

    err = output->writeInt64(acquireTime);

    if (err != NO_ERROR) {

        return err;

    }

    return output->writeBool(releasePreviousBuffer);

}

}





status_t SurfaceStats::readFromParcel(const Parcel* input) {

status_t SurfaceStats::readFromParcel(const Parcel* input) {

    return input->readStrongBinder(&surfaceControl);

    status_t err = input->readStrongBinder(&surfaceControl);

    if (err != NO_ERROR) {

        return err;

    }

    err = input->readInt64(&acquireTime);

    if (err != NO_ERROR) {

        return err;

    }

    return input->readBool(&releasePreviousBuffer);

}

}





status_t TransactionStats::writeToParcel(Parcel* output) const {

status_t TransactionStats::writeToParcel(Parcel* output) const {

    status_t err = output->writeInt64(latchTime);

    if (err != NO_ERROR) {

        return err;

    }

    err = output->writeInt64(presentTime);

    if (err != NO_ERROR) {

        return err;

    }

    return output->writeParcelableVector(surfaceStats);

    return output->writeParcelableVector(surfaceStats);

}

}





status_t TransactionStats::readFromParcel(const Parcel* input) {

status_t TransactionStats::readFromParcel(const Parcel* input) {

    status_t err = input->readInt64(&latchTime);

    if (err != NO_ERROR) {

        return err;

    }

    err = input->readInt64(&presentTime);

    if (err != NO_ERROR) {

        return err;

    }

    return input->readParcelableVector(&surfaceStats);

    return input->readParcelableVector(&surfaceStats);

}

}

libs/gui/include/gui/ITransactionCompletedListener.h

+6 −1
Original line number Original line Diff line number Diff line
@@ -51,9 +51,12 @@ public: 
    status_t readFromParcel(const Parcel* input) override;

    status_t readFromParcel(const Parcel* input) override;





    SurfaceStats() = default;

    SurfaceStats() = default;

    explicit SurfaceStats(const sp<IBinder>& sc) : surfaceControl(sc) {}

    SurfaceStats(const sp<IBinder>& sc, nsecs_t time, bool releasePrevBuffer)

          : surfaceControl(sc), acquireTime(time), releasePreviousBuffer(releasePrevBuffer) {}





    sp<IBinder> surfaceControl;

    sp<IBinder> surfaceControl;

    nsecs_t acquireTime = -1;

    bool releasePreviousBuffer = false;

};

};





class TransactionStats : public Parcelable {

class TransactionStats : public Parcelable {
@@ -61,6 +64,8 @@ public: 
    status_t writeToParcel(Parcel* output) const override;

    status_t writeToParcel(Parcel* output) const override;

    status_t readFromParcel(const Parcel* input) override;

    status_t readFromParcel(const Parcel* input) override;





    nsecs_t latchTime = -1;

    nsecs_t presentTime = -1;

    std::vector<SurfaceStats> surfaceStats;

    std::vector<SurfaceStats> surfaceStats;

};

};

services/surfaceflinger/BufferStateLayer.cpp

+27 −8
Original line number Original line Diff line number Diff line
@@ -41,9 +41,11 @@ BufferStateLayer::~BufferStateLayer() = default; 
// -----------------------------------------------------------------------

// -----------------------------------------------------------------------

// Interface implementation for Layer

// Interface implementation for Layer

// -----------------------------------------------------------------------

// -----------------------------------------------------------------------

void BufferStateLayer::onLayerDisplayed(const sp<Fence>& /*releaseFence*/) {

void BufferStateLayer::onLayerDisplayed(const sp<Fence>& releaseFence) {

    // TODO(marissaw): send the release fence back to buffer owner

    // The transaction completed callback can only be sent if the release fence from the PREVIOUS

    return;

    // frame has fired. In practice, we should never actually wait on the previous release fence

    // but we should store it just in case.

    mPreviousReleaseFence = releaseFence;

}

}





void BufferStateLayer::setTransformHint(uint32_t /*orientation*/) const {

void BufferStateLayer::setTransformHint(uint32_t /*orientation*/) const {
@@ -52,7 +54,6 @@ void BufferStateLayer::setTransformHint(uint32_t /*orientation*/) const { 
}

}





void BufferStateLayer::releasePendingBuffer(nsecs_t /*dequeueReadyTime*/) {

void BufferStateLayer::releasePendingBuffer(nsecs_t /*dequeueReadyTime*/) {

    // TODO(marissaw): use this to signal the buffer owner

    return;

    return;

}

}
@@ -125,7 +126,11 @@ bool BufferStateLayer::setCrop(const Rect& crop) { 
    return true;

    return true;

}

}





bool BufferStateLayer::setBuffer(sp<GraphicBuffer> buffer) {

bool BufferStateLayer::setBuffer(const sp<GraphicBuffer>& buffer) {

    if (mCurrentState.buffer) {

        mReleasePreviousBuffer = true;

    }



    mCurrentState.sequence++;

    mCurrentState.sequence++;

    mCurrentState.buffer = buffer;

    mCurrentState.buffer = buffer;

    mCurrentState.modified = true;

    mCurrentState.modified = true;
@@ -134,6 +139,9 @@ bool BufferStateLayer::setBuffer(sp<GraphicBuffer> buffer) { 
}

}





bool BufferStateLayer::setAcquireFence(const sp<Fence>& fence) {

bool BufferStateLayer::setAcquireFence(const sp<Fence>& fence) {

    // The acquire fences of BufferStateLayers have already signaled before they are set

    mCallbackHandleAcquireTime = fence->getSignalTime();



    mCurrentState.acquireFence = fence;

    mCurrentState.acquireFence = fence;

    mCurrentState.modified = true;

    mCurrentState.modified = true;

    setTransactionFlags(eTransactionNeeded);

    setTransactionFlags(eTransactionNeeded);
@@ -191,16 +199,23 @@ bool BufferStateLayer::setSidebandStream(const sp<NativeHandle>& sidebandStream) 




bool BufferStateLayer::setTransactionCompletedListeners(

bool BufferStateLayer::setTransactionCompletedListeners(

        const std::vector<sp<CallbackHandle>>& handles) {

        const std::vector<sp<CallbackHandle>>& handles) {

    // If there is no handle, we will not send a callback

    // If there is no handle, we will not send a callback so reset mReleasePreviousBuffer and return

    if (handles.empty()) {

    if (handles.empty()) {

        mReleasePreviousBuffer = false;

        return false;

        return false;

    }

    }





    const bool willPresent = willPresentCurrentTransaction();

    const bool willPresent = willPresentCurrentTransaction();





    for (const auto& handle : handles) {

    for (const auto& handle : handles) {

        // If this transaction set a buffer on this layer, release its previous buffer

        handle->releasePreviousBuffer = mReleasePreviousBuffer;



        // If this layer will be presented in this frame

        // If this layer will be presented in this frame

        if (willPresent) {

        if (willPresent) {

            // If this transaction set an acquire fence on this layer, set its acquire time

            handle->acquireTime = mCallbackHandleAcquireTime;



            // Notify the transaction completed thread that there is a pending latched callback

            // Notify the transaction completed thread that there is a pending latched callback

            // handle

            // handle

            mFlinger->getTransactionCompletedThread().registerPendingLatchedCallbackHandle(handle);

            mFlinger->getTransactionCompletedThread().registerPendingLatchedCallbackHandle(handle);
@@ -214,6 +229,9 @@ bool BufferStateLayer::setTransactionCompletedListeners( 
        }

        }

    }

    }





    mReleasePreviousBuffer = false;

    mCallbackHandleAcquireTime = -1;



    return willPresent;

    return willPresent;

}

}
@@ -438,8 +456,9 @@ status_t BufferStateLayer::updateTexImage(bool& /*recomputeVisibleRegions*/, nse 
        return BAD_VALUE;

        return BAD_VALUE;

    }

    }





    mFlinger->getTransactionCompletedThread().addLatchedCallbackHandles(

    mFlinger->getTransactionCompletedThread()

            getDrawingState().callbackHandles);

            .addLatchedCallbackHandles(getDrawingState().callbackHandles, latchTime,

                                       mPreviousReleaseFence);





    // Handle sync fences

    // Handle sync fences

    if (SyncFeatures::getInstance().useNativeFenceSync() && releaseFence != Fence::NO_FENCE) {

    if (SyncFeatures::getInstance().useNativeFenceSync() && releaseFence != Fence::NO_FENCE) {

services/surfaceflinger/BufferStateLayer.h

+5 −1
Original line number Original line Diff line number Diff line
@@ -62,7 +62,7 @@ public: 
    bool setTransform(uint32_t transform) override;

    bool setTransform(uint32_t transform) override;

    bool setTransformToDisplayInverse(bool transformToDisplayInverse) override;

    bool setTransformToDisplayInverse(bool transformToDisplayInverse) override;

    bool setCrop(const Rect& crop) override;

    bool setCrop(const Rect& crop) override;

    bool setBuffer(sp<GraphicBuffer> buffer) override;

    bool setBuffer(const sp<GraphicBuffer>& buffer) override;

    bool setAcquireFence(const sp<Fence>& fence) override;

    bool setAcquireFence(const sp<Fence>& fence) override;

    bool setDataspace(ui::Dataspace dataspace) override;

    bool setDataspace(ui::Dataspace dataspace) override;

    bool setHdrMetadata(const HdrMetadata& hdrMetadata) override;

    bool setHdrMetadata(const HdrMetadata& hdrMetadata) override;
@@ -138,7 +138,11 @@ private: 




    uint32_t mFrameNumber{0};

    uint32_t mFrameNumber{0};





    sp<Fence> mPreviousReleaseFence;



    bool mCurrentStateModified = false;

    bool mCurrentStateModified = false;

    bool mReleasePreviousBuffer = false;

    nsecs_t mCallbackHandleAcquireTime = -1;





    // TODO(marissaw): support sticky transform for LEGACY camera mode

    // TODO(marissaw): support sticky transform for LEGACY camera mode

};

};

services/surfaceflinger/Layer.h

+1 −1
Original line number Original line Diff line number Diff line
@@ -270,7 +270,7 @@ public: 
    virtual bool setTransform(uint32_t /*transform*/) { return false; };

    virtual bool setTransform(uint32_t /*transform*/) { return false; };

    virtual bool setTransformToDisplayInverse(bool /*transformToDisplayInverse*/) { return false; };

    virtual bool setTransformToDisplayInverse(bool /*transformToDisplayInverse*/) { return false; };

    virtual bool setCrop(const Rect& /*crop*/) { return false; };

    virtual bool setCrop(const Rect& /*crop*/) { return false; };

    virtual bool setBuffer(sp<GraphicBuffer> /*buffer*/) { return false; };

    virtual bool setBuffer(const sp<GraphicBuffer>& /*buffer*/) { return false; };

    virtual bool setAcquireFence(const sp<Fence>& /*fence*/) { return false; };

    virtual bool setAcquireFence(const sp<Fence>& /*fence*/) { return false; };

    virtual bool setDataspace(ui::Dataspace /*dataspace*/) { return false; };

    virtual bool setDataspace(ui::Dataspace /*dataspace*/) { return false; };

    virtual bool setHdrMetadata(const HdrMetadata& /*hdrMetadata*/) { return false; };

    virtual bool setHdrMetadata(const HdrMetadata& /*hdrMetadata*/) { return false; };