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

Commit ba4320c0 authored by chaviw's avatar chaviw
Browse files

Combine Buffer Properties when calling setBuffer 

There are several properties, like releaseCallback, acquireFence,
frameNumber, that are tied to the buffer being set. If a new buffer is
set, all those properties should also be overwritten, rather than
through a separate call.

1. Remove Transaction.setAcquireFence and Transaction.setFrameNumber and
added them to the setBuffer as optional

2. Combine all the buffer info into a struct called BufferData that's
sent to SF as one. This will also help with merging or overwriting
buffer data since the callback, frameNumber, and acquireFence should
also be updated.

3. Combine the functions in SF so there's no longer a separate call to
BSL to set fence. Instead, send all buffer related data to BSL.setBuffer

Test: SurfaceFlinger_test
Fixes: 200065015
Change-Id: I53ad12dd105cd4cac6c3a7ecd48279d1b3cd2b8f
parent 4eecba7d

libs/gui/BLASTBufferQueue.cpp

+3 −4
Original line number Diff line number Diff line
@@ -468,12 +468,12 @@ void BLASTBufferQueue::processNextBufferLocked(bool useNextTransaction) { 
            std::bind(releaseBufferCallbackThunk, wp<BLASTBufferQueue>(this) /* callbackContext */,

                      std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,

                      std::placeholders::_4);

    t->setBuffer(mSurfaceControl, buffer, releaseCallbackId, releaseBufferCallback);

    sp<Fence> fence = bufferItem.mFence ? new Fence(bufferItem.mFence->dup()) : Fence::NO_FENCE;

    t->setBuffer(mSurfaceControl, buffer, fence, bufferItem.mFrameNumber, releaseCallbackId,

                 releaseBufferCallback);

    t->setDataspace(mSurfaceControl, static_cast<ui::Dataspace>(bufferItem.mDataSpace));

    t->setHdrMetadata(mSurfaceControl, bufferItem.mHdrMetadata);

    t->setSurfaceDamageRegion(mSurfaceControl, bufferItem.mSurfaceDamage);

    t->setAcquireFence(mSurfaceControl,

                       bufferItem.mFence ? new Fence(bufferItem.mFence->dup()) : Fence::NO_FENCE);

    t->addTransactionCompletedCallback(transactionCallbackThunk, static_cast<void*>(this));

    mSurfaceControlsWithPendingCallback.push(mSurfaceControl);
@@ -486,7 +486,6 @@ void BLASTBufferQueue::processNextBufferLocked(bool useNextTransaction) { 
    if (!bufferItem.mIsAutoTimestamp) {

        t->setDesiredPresentTime(bufferItem.mTimestamp);

    }

    t->setFrameNumber(mSurfaceControl, bufferItem.mFrameNumber);



    if (!mNextFrameTimelineInfoQueue.empty()) {

        t->setFrameTimelineInfo(mNextFrameTimelineInfoQueue.front());

libs/gui/LayerState.cpp

+69 −70
Original line number Diff line number Diff line
@@ -64,12 +64,10 @@ layer_state_t::layer_state_t() 
        frameRateCompatibility(ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_DEFAULT),

        changeFrameRateStrategy(ANATIVEWINDOW_CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS),

        fixedTransformHint(ui::Transform::ROT_INVALID),

        frameNumber(0),

        autoRefresh(false),

        isTrustedOverlay(false),

        bufferCrop(Rect::INVALID_RECT),

        destinationFrame(Rect::INVALID_RECT),

        releaseBufferListener(nullptr),

        dropInputMode(gui::DropInputMode::NONE) {

    matrix.dsdx = matrix.dtdy = 1.0f;

    matrix.dsdy = matrix.dtdx = 0.0f;
@@ -104,20 +102,6 @@ status_t layer_state_t::write(Parcel& output) const 
    SAFE_PARCEL(output.writeBool, transformToDisplayInverse);

    SAFE_PARCEL(output.write, orientedDisplaySpaceRect);



    if (buffer) {

        SAFE_PARCEL(output.writeBool, true);

        SAFE_PARCEL(output.write, *buffer);

    } else {

        SAFE_PARCEL(output.writeBool, false);

    }



    if (acquireFence) {

        SAFE_PARCEL(output.writeBool, true);

        SAFE_PARCEL(output.write, *acquireFence);

    } else {

        SAFE_PARCEL(output.writeBool, false);

    }



    SAFE_PARCEL(output.writeUint32, static_cast<uint32_t>(dataspace));

    SAFE_PARCEL(output.write, hdrMetadata);

    SAFE_PARCEL(output.write, surfaceDamageRegion);
@@ -133,8 +117,6 @@ status_t layer_state_t::write(Parcel& output) const 
    SAFE_PARCEL(output.write, colorTransform.asArray(), 16 * sizeof(float));

    SAFE_PARCEL(output.writeFloat, cornerRadius);

    SAFE_PARCEL(output.writeUint32, backgroundBlurRadius);

    SAFE_PARCEL(output.writeStrongBinder, cachedBuffer.token.promote());

    SAFE_PARCEL(output.writeUint64, cachedBuffer.id);

    SAFE_PARCEL(output.writeParcelable, metadata);

    SAFE_PARCEL(output.writeFloat, bgColorAlpha);

    SAFE_PARCEL(output.writeUint32, static_cast<uint32_t>(bgColorDataspace));
@@ -151,9 +133,7 @@ status_t layer_state_t::write(Parcel& output) const 
    SAFE_PARCEL(output.writeByte, frameRateCompatibility);

    SAFE_PARCEL(output.writeByte, changeFrameRateStrategy);

    SAFE_PARCEL(output.writeUint32, fixedTransformHint);

    SAFE_PARCEL(output.writeUint64, frameNumber);

    SAFE_PARCEL(output.writeBool, autoRefresh);

    SAFE_PARCEL(output.writeStrongBinder, IInterface::asBinder(releaseBufferListener));



    SAFE_PARCEL(output.writeUint32, blurRegions.size());

    for (auto region : blurRegions) {
@@ -174,8 +154,8 @@ status_t layer_state_t::write(Parcel& output) const 
    SAFE_PARCEL(output.write, destinationFrame);

    SAFE_PARCEL(output.writeBool, isTrustedOverlay);



    SAFE_PARCEL(output.writeStrongBinder, releaseBufferEndpoint);

    SAFE_PARCEL(output.writeUint32, static_cast<uint32_t>(dropInputMode));

    SAFE_PARCEL(bufferData.write, output);

    return NO_ERROR;

}
@@ -217,19 +197,6 @@ status_t layer_state_t::read(const Parcel& input) 
    SAFE_PARCEL(input.readBool, &transformToDisplayInverse);

    SAFE_PARCEL(input.read, orientedDisplaySpaceRect);



    bool tmpBool = false;

    SAFE_PARCEL(input.readBool, &tmpBool);

    if (tmpBool) {

        buffer = new GraphicBuffer();

        SAFE_PARCEL(input.read, *buffer);

    }



    SAFE_PARCEL(input.readBool, &tmpBool);

    if (tmpBool) {

        acquireFence = new Fence();

        SAFE_PARCEL(input.read, *acquireFence);

    }



    uint32_t tmpUint32 = 0;

    SAFE_PARCEL(input.readUint32, &tmpUint32);

    dataspace = static_cast<ui::Dataspace>(tmpUint32);
@@ -237,6 +204,8 @@ status_t layer_state_t::read(const Parcel& input) 
    SAFE_PARCEL(input.read, hdrMetadata);

    SAFE_PARCEL(input.read, surfaceDamageRegion);

    SAFE_PARCEL(input.readInt32, &api);



    bool tmpBool = false;

    SAFE_PARCEL(input.readBool, &tmpBool);

    if (tmpBool) {

        sidebandStream = NativeHandle::create(input.readNativeHandle(), true);
@@ -245,10 +214,6 @@ status_t layer_state_t::read(const Parcel& input) 
    SAFE_PARCEL(input.read, &colorTransform, 16 * sizeof(float));

    SAFE_PARCEL(input.readFloat, &cornerRadius);

    SAFE_PARCEL(input.readUint32, &backgroundBlurRadius);

    sp<IBinder> tmpBinder;

    SAFE_PARCEL(input.readNullableStrongBinder, &tmpBinder);

    cachedBuffer.token = tmpBinder;

    SAFE_PARCEL(input.readUint64, &cachedBuffer.id);

    SAFE_PARCEL(input.readParcelable, &metadata);



    SAFE_PARCEL(input.readFloat, &bgColorAlpha);
@@ -273,15 +238,8 @@ status_t layer_state_t::read(const Parcel& input) 
    SAFE_PARCEL(input.readByte, &changeFrameRateStrategy);

    SAFE_PARCEL(input.readUint32, &tmpUint32);

    fixedTransformHint = static_cast<ui::Transform::RotationFlags>(tmpUint32);

    SAFE_PARCEL(input.readUint64, &frameNumber);

    SAFE_PARCEL(input.readBool, &autoRefresh);



    tmpBinder = nullptr;

    SAFE_PARCEL(input.readNullableStrongBinder, &tmpBinder);

    if (tmpBinder) {

        releaseBufferListener = checked_interface_cast<ITransactionCompletedListener>(tmpBinder);

    }



    uint32_t numRegions = 0;

    SAFE_PARCEL(input.readUint32, &numRegions);

    blurRegions.clear();
@@ -305,11 +263,10 @@ status_t layer_state_t::read(const Parcel& input) 
    SAFE_PARCEL(input.read, destinationFrame);

    SAFE_PARCEL(input.readBool, &isTrustedOverlay);



    SAFE_PARCEL(input.readNullableStrongBinder, &releaseBufferEndpoint);



    uint32_t mode;

    SAFE_PARCEL(input.readUint32, &mode);

    dropInputMode = static_cast<gui::DropInputMode>(mode);

    SAFE_PARCEL(bufferData.read, input);

    return NO_ERROR;

}
@@ -460,12 +417,7 @@ void layer_state_t::merge(const layer_state_t& other) { 
    }

    if (other.what & eBufferChanged) {

        what |= eBufferChanged;

        buffer = other.buffer;

        releaseBufferEndpoint = other.releaseBufferEndpoint;

    }

    if (other.what & eAcquireFenceChanged) {

        what |= eAcquireFenceChanged;

        acquireFence = other.acquireFence;

        bufferData = other.bufferData;

    }

    if (other.what & eDataspaceChanged) {

        what |= eDataspaceChanged;
@@ -498,10 +450,6 @@ void layer_state_t::merge(const layer_state_t& other) { 
        what |= eInputInfoChanged;

        windowInfoHandle = new WindowInfoHandle(*other.windowInfoHandle);

    }

    if (other.what & eCachedBufferChanged) {

        what |= eCachedBufferChanged;

        cachedBuffer = other.cachedBuffer;

    }

    if (other.what & eBackgroundColorChanged) {

        what |= eBackgroundColorChanged;

        color = other.color;
@@ -530,10 +478,6 @@ void layer_state_t::merge(const layer_state_t& other) { 
        what |= eFixedTransformHintChanged;

        fixedTransformHint = other.fixedTransformHint;

    }

    if (other.what & eFrameNumberChanged) {

        what |= eFrameNumberChanged;

        frameNumber = other.frameNumber;

    }

    if (other.what & eAutoRefreshChanged) {

        what |= eAutoRefreshChanged;

        autoRefresh = other.autoRefresh;
@@ -542,13 +486,6 @@ void layer_state_t::merge(const layer_state_t& other) { 
        what |= eTrustedOverlayChanged;

        isTrustedOverlay = other.isTrustedOverlay;

    }

    if (other.what & eReleaseBufferListenerChanged) {

        if (releaseBufferListener) {

            ALOGW("Overriding releaseBufferListener");

        }

        what |= eReleaseBufferListenerChanged;

        releaseBufferListener = other.releaseBufferListener;

    }

    if (other.what & eStretchChanged) {

        what |= eStretchChanged;

        stretchEffect = other.stretchEffect;
@@ -576,11 +513,11 @@ void layer_state_t::merge(const layer_state_t& other) { 
}



bool layer_state_t::hasBufferChanges() const {

    return (what & layer_state_t::eBufferChanged) || (what & layer_state_t::eCachedBufferChanged);

    return what & layer_state_t::eBufferChanged;

}



bool layer_state_t::hasValidBuffer() const {

    return buffer || cachedBuffer.isValid();

    return bufferData.buffer || bufferData.cachedBuffer.isValid();

}



status_t layer_state_t::matrix22_t::write(Parcel& output) const {
@@ -741,4 +678,66 @@ status_t LayerCaptureArgs::read(const Parcel& input) { 
    return NO_ERROR;

}



status_t BufferData::write(Parcel& output) const {

    SAFE_PARCEL(output.writeInt32, flags.get());



    if (buffer) {

        SAFE_PARCEL(output.writeBool, true);

        SAFE_PARCEL(output.write, *buffer);

    } else {

        SAFE_PARCEL(output.writeBool, false);

    }



    if (acquireFence) {

        SAFE_PARCEL(output.writeBool, true);

        SAFE_PARCEL(output.write, *acquireFence);

    } else {

        SAFE_PARCEL(output.writeBool, false);

    }



    SAFE_PARCEL(output.writeUint64, frameNumber);

    SAFE_PARCEL(output.writeStrongBinder, IInterface::asBinder(releaseBufferListener));

    SAFE_PARCEL(output.writeStrongBinder, releaseBufferEndpoint);



    SAFE_PARCEL(output.writeStrongBinder, cachedBuffer.token.promote());

    SAFE_PARCEL(output.writeUint64, cachedBuffer.id);



    return NO_ERROR;

}



status_t BufferData::read(const Parcel& input) {

    int32_t tmpInt32;

    SAFE_PARCEL(input.readInt32, &tmpInt32);

    flags = Flags<BufferDataChange>(tmpInt32);



    bool tmpBool = false;

    SAFE_PARCEL(input.readBool, &tmpBool);

    if (tmpBool) {

        buffer = new GraphicBuffer();

        SAFE_PARCEL(input.read, *buffer);

    }



    SAFE_PARCEL(input.readBool, &tmpBool);

    if (tmpBool) {

        acquireFence = new Fence();

        SAFE_PARCEL(input.read, *acquireFence);

    }



    SAFE_PARCEL(input.readUint64, &frameNumber);



    sp<IBinder> tmpBinder = nullptr;

    SAFE_PARCEL(input.readNullableStrongBinder, &tmpBinder);

    if (tmpBinder) {

        releaseBufferListener = checked_interface_cast<ITransactionCompletedListener>(tmpBinder);

    }

    SAFE_PARCEL(input.readNullableStrongBinder, &releaseBufferEndpoint);



    tmpBinder = nullptr;

    SAFE_PARCEL(input.readNullableStrongBinder, &tmpBinder);

    cachedBuffer.token = tmpBinder;

    SAFE_PARCEL(input.readUint64, &cachedBuffer.id);



    return NO_ERROR;

}



}; // namespace android

libs/gui/SurfaceComposerClient.cpp

+32 −54
Original line number Diff line number Diff line
@@ -805,7 +805,7 @@ void SurfaceComposerClient::Transaction::cacheBuffers() { 
        layer_state_t* s = &(mComposerStates[handle].state);

        if (!(s->what & layer_state_t::eBufferChanged)) {

            continue;

        } else if (s->what & layer_state_t::eCachedBufferChanged) {

        } else if (s->bufferData.flags.test(BufferData::BufferDataChange::cachedBufferChanged)) {

            // If eBufferChanged and eCachedBufferChanged are both trued then that means

            // we already cached the buffer in a previous call to cacheBuffers, perhaps

            // from writeToParcel on a Transaction that was merged in to this one.
@@ -814,23 +814,22 @@ void SurfaceComposerClient::Transaction::cacheBuffers() { 


        // Don't try to cache a null buffer. Sending null buffers is cheap so we shouldn't waste

        // time trying to cache them.

        if (!s->buffer) {

        if (!s->bufferData.buffer) {

            continue;

        }



        uint64_t cacheId = 0;

        status_t ret = BufferCache::getInstance().getCacheId(s->buffer, &cacheId);

        status_t ret = BufferCache::getInstance().getCacheId(s->bufferData.buffer, &cacheId);

        if (ret == NO_ERROR) {

            // Cache-hit. Strip the buffer and send only the id.

            s->what &= ~static_cast<uint64_t>(layer_state_t::eBufferChanged);

            s->buffer = nullptr;

            s->bufferData.buffer = nullptr;

        } else {

            // Cache-miss. Include the buffer and send the new cacheId.

            cacheId = BufferCache::getInstance().cache(s->buffer);

            cacheId = BufferCache::getInstance().cache(s->bufferData.buffer);

        }

        s->what |= layer_state_t::eCachedBufferChanged;

        s->cachedBuffer.token = BufferCache::getInstance().getToken();

        s->cachedBuffer.id = cacheId;

        s->bufferData.flags |= BufferData::BufferDataChange::cachedBufferChanged;

        s->bufferData.cachedBuffer.token = BufferCache::getInstance().getToken();

        s->bufferData.cachedBuffer.id = cacheId;



        // If we have more buffers than the size of the cache, we should stop caching so we don't

        // evict other buffers in this transaction
@@ -1289,22 +1288,33 @@ SurfaceComposerClient::Transaction::setTransformToDisplayInverse(const sp<Surfac 
}



SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setBuffer(

        const sp<SurfaceControl>& sc, const sp<GraphicBuffer>& buffer, const ReleaseCallbackId& id,

        ReleaseBufferCallback callback) {

        const sp<SurfaceControl>& sc, const sp<GraphicBuffer>& buffer,

        const std::optional<sp<Fence>>& fence, const std::optional<uint64_t>& frameNumber,

        const ReleaseCallbackId& id, ReleaseBufferCallback callback) {

    layer_state_t* s = getLayerState(sc);

    if (!s) {

        mStatus = BAD_INDEX;

        return *this;

    }

    removeReleaseBufferCallback(s);

    s->what |= layer_state_t::eBufferChanged;

    s->buffer = buffer;

    s->releaseBufferEndpoint = IInterface::asBinder(TransactionCompletedListener::getIInstance());

    BufferData bufferData;

    bufferData.buffer = buffer;

    if (frameNumber) {

        bufferData.frameNumber = *frameNumber;

        bufferData.flags |= BufferData::BufferDataChange::frameNumberChanged;

    }

    if (fence) {

        bufferData.acquireFence = *fence;

        bufferData.flags |= BufferData::BufferDataChange::fenceChanged;

    }

    bufferData.releaseBufferEndpoint =

            IInterface::asBinder(TransactionCompletedListener::getIInstance());

    if (mIsAutoTimestamp) {

        mDesiredPresentTime = systemTime();

    }

    setReleaseBufferCallback(s, id, callback);



    setReleaseBufferCallback(&bufferData, id, callback);

    s->what |= layer_state_t::eBufferChanged;

    s->bufferData = bufferData;

    registerSurfaceControlForCallback(sc);



    mContainsBuffer = true;
@@ -1312,51 +1322,33 @@ SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setBuffe 
}



void SurfaceComposerClient::Transaction::removeReleaseBufferCallback(layer_state_t* s) {

    if (!s->releaseBufferListener) {

    if (!(s->what & layer_state_t::eBufferChanged)) {

        return;

    }



    s->what &= ~static_cast<uint64_t>(layer_state_t::eReleaseBufferListenerChanged);

    s->releaseBufferListener = nullptr;

    auto listener = TransactionCompletedListener::getInstance();

    listener->removeReleaseBufferCallback(s->releaseCallbackId);

    s->releaseCallbackId = ReleaseCallbackId::INVALID_ID;

    listener->removeReleaseBufferCallback(s->bufferData.releaseCallbackId);

}



void SurfaceComposerClient::Transaction::setReleaseBufferCallback(layer_state_t* s,

void SurfaceComposerClient::Transaction::setReleaseBufferCallback(BufferData* bufferData,

                                                                  const ReleaseCallbackId& id,

                                                                  ReleaseBufferCallback callback) {

    if (!callback) {

        return;

    }



    if (!s->buffer) {

    if (!bufferData->buffer) {

        ALOGW("Transaction::setReleaseBufferCallback"

              "ignored trying to set a callback on a null buffer.");

        return;

    }



    s->what |= layer_state_t::eReleaseBufferListenerChanged;

    s->releaseBufferListener = TransactionCompletedListener::getIInstance();

    s->releaseCallbackId = id;

    bufferData->releaseBufferListener = TransactionCompletedListener::getIInstance();

    bufferData->releaseCallbackId = id;

    auto listener = TransactionCompletedListener::getInstance();

    listener->setReleaseBufferCallback(id, callback);

}



SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setAcquireFence(

        const sp<SurfaceControl>& sc, const sp<Fence>& fence) {

    layer_state_t* s = getLayerState(sc);

    if (!s) {

        mStatus = BAD_INDEX;

        return *this;

    }

    s->what |= layer_state_t::eAcquireFenceChanged;

    s->acquireFence = fence;



    registerSurfaceControlForCallback(sc);

    return *this;

}



SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setDataspace(

        const sp<SurfaceControl>& sc, ui::Dataspace dataspace) {

    layer_state_t* s = getLayerState(sc);
@@ -1506,20 +1498,6 @@ SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::notifyPr 
    return *this;

}



SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setFrameNumber(

        const sp<SurfaceControl>& sc, uint64_t frameNumber) {

    layer_state_t* s = getLayerState(sc);

    if (!s) {

        mStatus = BAD_INDEX;

        return *this;

    }



    s->what |= layer_state_t::eFrameNumberChanged;

    s->frameNumber = frameNumber;



    return *this;

}



SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setInputWindowInfo(

        const sp<SurfaceControl>& sc, const WindowInfo& info) {

    layer_state_t* s = getLayerState(sc);

libs/gui/include/gui/LayerState.h

+43 −28
Original line number Diff line number Diff line
@@ -58,6 +58,44 @@ struct client_cache_t { 
    bool isValid() const { return token != nullptr; }

};



struct BufferData {

    enum class BufferDataChange : uint32_t {

        fenceChanged = 0x01,

        frameNumberChanged = 0x02,

        cachedBufferChanged = 0x04,

    };



    sp<GraphicBuffer> buffer;

    sp<Fence> acquireFence;



    // Used by BlastBufferQueue to forward the framenumber generated by the

    // graphics producer.

    uint64_t frameNumber = 0;



    // Listens to when the buffer is safe to be released. This is used for blast

    // layers only. The callback includes a release fence as well as the graphic

    // buffer id to identify the buffer.

    sp<ITransactionCompletedListener> releaseBufferListener = nullptr;



    // Keeps track of the release callback id associated with the listener. This

    // is not sent to the server since the id can be reconstructed there. This

    // is used to remove the old callback from the client process map if it is

    // overwritten by another setBuffer call.

    ReleaseCallbackId releaseCallbackId = ReleaseCallbackId::INVALID_ID;



    // Stores which endpoint the release information should be sent to. We don't want to send the

    // releaseCallbackId and release fence to all listeners so we store which listener the setBuffer

    // was called with.

    sp<IBinder> releaseBufferEndpoint;



    Flags<BufferDataChange> flags;



    client_cache_t cachedBuffer;



    status_t write(Parcel& output) const;

    status_t read(const Parcel& input);

};



/*

 * Used to communicate layer information between SurfaceFlinger and its clients.

 */
@@ -82,7 +120,7 @@ struct layer_state_t { 
        eTransparentRegionChanged = 0x00000020,

        eFlagsChanged = 0x00000040,

        eLayerStackChanged = 0x00000080,

        eReleaseBufferListenerChanged = 0x00000400,

        /* unused 0x00000400, */

        eShadowRadiusChanged = 0x00000800,

        eLayerCreated = 0x00001000,

        eBufferCropChanged = 0x00002000,
@@ -94,7 +132,7 @@ struct layer_state_t { 
        eTransformToDisplayInverseChanged = 0x00080000,

        eCropChanged = 0x00100000,

        eBufferChanged = 0x00200000,

        eAcquireFenceChanged = 0x00400000,

        /* unused 0x00400000, */

        eDataspaceChanged = 0x00800000,

        eHdrMetadataChanged = 0x01000000,

        eSurfaceDamageRegionChanged = 0x02000000,
@@ -105,7 +143,7 @@ struct layer_state_t { 
        eInputInfoChanged = 0x40000000,

        eCornerRadiusChanged = 0x80000000,

        eDestinationFrameChanged = 0x1'00000000,

        eCachedBufferChanged = 0x2'00000000,

        /* unused = 0x2'00000000, */

        eBackgroundColorChanged = 0x4'00000000,

        eMetadataChanged = 0x8'00000000,

        eColorSpaceAgnosticChanged = 0x10'00000000,
@@ -114,7 +152,7 @@ struct layer_state_t { 
        eBackgroundBlurRadiusChanged = 0x80'00000000,

        eProducerDisconnect = 0x100'00000000,

        eFixedTransformHintChanged = 0x200'00000000,

        eFrameNumberChanged = 0x400'00000000,

        /* unused 0x400'00000000, */

        eBlurRegionsChanged = 0x800'00000000,

        eAutoRefreshChanged = 0x1000'00000000,

        eStretchChanged = 0x2000'00000000,
@@ -169,8 +207,7 @@ struct layer_state_t { 
    bool transformToDisplayInverse;

    Rect crop;

    Rect orientedDisplaySpaceRect;

    sp<GraphicBuffer> buffer;

    sp<Fence> acquireFence;

    BufferData bufferData;

    ui::Dataspace dataspace;

    HdrMetadata hdrMetadata;

    Region surfaceDamageRegion;
@@ -181,8 +218,6 @@ struct layer_state_t { 


    sp<gui::WindowInfoHandle> windowInfoHandle = new gui::WindowInfoHandle();



    client_cache_t cachedBuffer;



    LayerMetadata metadata;



    // The following refer to the alpha, and dataspace, respectively of
@@ -216,10 +251,6 @@ struct layer_state_t { 
    // otherwise the value will be a valid ui::Rotation.

    ui::Transform::RotationFlags fixedTransformHint;



    // Used by BlastBufferQueue to forward the framenumber generated by the

    // graphics producer.

    uint64_t frameNumber;



    // Indicates that the consumer should acquire the next frame as soon as it

    // can and not wait for a frame to become available. This is only relevant

    // in shared buffer mode.
@@ -235,22 +266,6 @@ struct layer_state_t { 
    Rect bufferCrop;

    Rect destinationFrame;



    // Listens to when the buffer is safe to be released. This is used for blast

    // layers only. The callback includes a release fence as well as the graphic

    // buffer id to identify the buffer.

    sp<ITransactionCompletedListener> releaseBufferListener;



    // Keeps track of the release callback id associated with the listener. This

    // is not sent to the server since the id can be reconstructed there. This

    // is used to remove the old callback from the client process map if it is

    // overwritten by another setBuffer call.

    ReleaseCallbackId releaseCallbackId;



    // Stores which endpoint the release information should be sent to. We don't want to send the

    // releaseCallbackId and release fence to all listeners so we store which listener the setBuffer

    // was called with.

    sp<IBinder> releaseBufferEndpoint;



    // Force inputflinger to drop all input events for the layer and its children.

    gui::DropInputMode dropInputMode;

};

libs/gui/include/gui/SurfaceComposerClient.h

+3 −6
Original line number Diff line number Diff line
@@ -399,8 +399,7 @@ public: 


        void cacheBuffers();

        void registerSurfaceControlForCallback(const sp<SurfaceControl>& sc);

        void setReleaseBufferCallback(layer_state_t*, const ReleaseCallbackId&,

                                      ReleaseBufferCallback);

        void setReleaseBufferCallback(BufferData*, const ReleaseCallbackId&, ReleaseBufferCallback);

        void removeReleaseBufferCallback(layer_state_t*);



    public:
@@ -473,10 +472,10 @@ public: 
        Transaction& setTransformToDisplayInverse(const sp<SurfaceControl>& sc,

                                                  bool transformToDisplayInverse);

        Transaction& setBuffer(const sp<SurfaceControl>& sc, const sp<GraphicBuffer>& buffer,

                               const std::optional<sp<Fence>>& fence = std::nullopt,

                               const std::optional<uint64_t>& frameNumber = std::nullopt,

                               const ReleaseCallbackId& id = ReleaseCallbackId::INVALID_ID,

                               ReleaseBufferCallback callback = nullptr);

        Transaction& setCachedBuffer(const sp<SurfaceControl>& sc, int32_t bufferId);

        Transaction& setAcquireFence(const sp<SurfaceControl>& sc, const sp<Fence>& fence);

        Transaction& setDataspace(const sp<SurfaceControl>& sc, ui::Dataspace dataspace);

        Transaction& setHdrMetadata(const sp<SurfaceControl>& sc, const HdrMetadata& hdrMetadata);

        Transaction& setSurfaceDamageRegion(const sp<SurfaceControl>& sc,
@@ -501,8 +500,6 @@ public: 


        // ONLY FOR BLAST ADAPTER

        Transaction& notifyProducerDisconnect(const sp<SurfaceControl>& sc);

        // Set the framenumber generated by the graphics producer to mimic BufferQueue behaviour.

        Transaction& setFrameNumber(const sp<SurfaceControl>& sc, uint64_t frameNumber);



        Transaction& setInputWindowInfo(const sp<SurfaceControl>& sc, const gui::WindowInfo& info);

        Transaction& setFocusedWindow(const gui::FocusRequest& request);