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

Commit 61c58627 authored by Marissa Wall's avatar Marissa Wall
Browse files

blast: BufferStateLayer 

Adds the initial foundation for supporting buffers on
transactions as well as the other metadata that had been passed
over BufferQueue.

Bug: 80477568
Test: Transaction_test.cpp
Change-Id: I61e44462c66c1a912adbabf62015e66bde44c216
parent f58c14b3

libs/gui/LayerState.cpp

+85 −0
Original line number Diff line number Diff line
@@ -50,6 +50,32 @@ status_t layer_state_t::write(Parcel& output) const 
    output.writeFloat(color.g);

    output.writeFloat(color.b);

    output.write(transparentRegion);

    output.writeUint32(transform);

    output.writeBool(transformToDisplayInverse);

    output.write(crop);

    if (buffer) {

        output.writeBool(true);

        output.write(*buffer);

    } else {

        output.writeBool(false);

    }

    if (acquireFence) {

        output.writeBool(true);

        output.write(*acquireFence);

    } else {

        output.writeBool(false);

    }

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

    output.write(hdrMetadata);

    output.write(surfaceDamageRegion);

    output.writeInt32(api);

    if (sidebandStream) {

        output.writeBool(true);

        output.writeNativeHandle(sidebandStream->handle());

    } else {

        output.writeBool(false);

    }



    return NO_ERROR;

}
@@ -85,6 +111,25 @@ status_t layer_state_t::read(const Parcel& input) 
    color.g = input.readFloat();

    color.b = input.readFloat();

    input.read(transparentRegion);

    transform = input.readUint32();

    transformToDisplayInverse = input.readBool();

    input.read(crop);

    buffer = new GraphicBuffer();

    if (input.readBool()) {

        input.read(*buffer);

    }

    acquireFence = new Fence();

    if (input.readBool()) {

        input.read(*acquireFence);

    }

    dataspace = static_cast<ui::Dataspace>(input.readUint32());

    input.read(hdrMetadata);

    input.read(surfaceDamageRegion);

    api = input.readInt32();

    if (input.readBool()) {

        sidebandStream = NativeHandle::create(input.readNativeHandle(), true);

    }



    return NO_ERROR;

}
@@ -233,6 +278,46 @@ void layer_state_t::merge(const layer_state_t& other) { 
    if (other.what & eDestroySurface) {

        what |= eDestroySurface;

    }

    if (other.what & eTransformChanged) {

        what |= eTransformChanged;

        transform = other.transform;

    }

    if (other.what & eTransformToDisplayInverseChanged) {

        what |= eTransformToDisplayInverseChanged;

        transformToDisplayInverse = other.transformToDisplayInverse;

    }

    if (other.what & eCropChanged) {

        what |= eCropChanged;

        crop = other.crop;

    }

    if (other.what & eBufferChanged) {

        what |= eBufferChanged;

        buffer = other.buffer;

    }

    if (other.what & eAcquireFenceChanged) {

        what |= eAcquireFenceChanged;

        acquireFence = other.acquireFence;

    }

    if (other.what & eDataspaceChanged) {

        what |= eDataspaceChanged;

        dataspace = other.dataspace;

    }

    if (other.what & eHdrMetadataChanged) {

        what |= eHdrMetadataChanged;

        hdrMetadata = other.hdrMetadata;

    }

    if (other.what & eSurfaceDamageRegionChanged) {

        what |= eSurfaceDamageRegionChanged;

        surfaceDamageRegion = other.surfaceDamageRegion;

    }

    if (other.what & eApiChanged) {

        what |= eApiChanged;

        api = other.api;

    }

    if (other.what & eSidebandStreamChanged) {

        what |= eSidebandStreamChanged;

        sidebandStream = other.sidebandStream;

    }

}



}; // namespace android

libs/gui/SurfaceComposerClient.cpp

+121 −0
Original line number Diff line number Diff line
@@ -437,6 +437,127 @@ SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setColor 
    return *this;

}



SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setTransform(

        const sp<SurfaceControl>& sc, uint32_t transform) {

    layer_state_t* s = getLayerState(sc);

    if (!s) {

        mStatus = BAD_INDEX;

        return *this;

    }

    s->what |= layer_state_t::eTransformChanged;

    s->transform = transform;

    return *this;

}



SurfaceComposerClient::Transaction&

SurfaceComposerClient::Transaction::setTransformToDisplayInverse(const sp<SurfaceControl>& sc,

                                                                 bool transformToDisplayInverse) {

    layer_state_t* s = getLayerState(sc);

    if (!s) {

        mStatus = BAD_INDEX;

        return *this;

    }

    s->what |= layer_state_t::eTransformToDisplayInverseChanged;

    s->transformToDisplayInverse = transformToDisplayInverse;

    return *this;

}



SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setCrop(

        const sp<SurfaceControl>& sc, const Rect& crop) {

    layer_state_t* s = getLayerState(sc);

    if (!s) {

        mStatus = BAD_INDEX;

        return *this;

    }

    s->what |= layer_state_t::eCropChanged;

    s->crop = crop;

    return *this;

}



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

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

    layer_state_t* s = getLayerState(sc);

    if (!s) {

        mStatus = BAD_INDEX;

        return *this;

    }

    s->what |= layer_state_t::eBufferChanged;

    s->buffer = buffer;

    return *this;

}



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;

    return *this;

}



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

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

    layer_state_t* s = getLayerState(sc);

    if (!s) {

        mStatus = BAD_INDEX;

        return *this;

    }

    s->what |= layer_state_t::eDataspaceChanged;

    s->dataspace = dataspace;

    return *this;

}



SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setHdrMetadata(

        const sp<SurfaceControl>& sc, const HdrMetadata& hdrMetadata) {

    layer_state_t* s = getLayerState(sc);

    if (!s) {

        mStatus = BAD_INDEX;

        return *this;

    }

    s->what |= layer_state_t::eHdrMetadataChanged;

    s->hdrMetadata = hdrMetadata;

    return *this;

}



SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setSurfaceDamageRegion(

        const sp<SurfaceControl>& sc, const Region& surfaceDamageRegion) {

    layer_state_t* s = getLayerState(sc);

    if (!s) {

        mStatus = BAD_INDEX;

        return *this;

    }

    s->what |= layer_state_t::eSurfaceDamageRegionChanged;

    s->surfaceDamageRegion = surfaceDamageRegion;

    return *this;

}



SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setApi(

        const sp<SurfaceControl>& sc, int32_t api) {

    layer_state_t* s = getLayerState(sc);

    if (!s) {

        mStatus = BAD_INDEX;

        return *this;

    }

    s->what |= layer_state_t::eApiChanged;

    s->api = api;

    return *this;

}



SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setSidebandStream(

        const sp<SurfaceControl>& sc, const sp<NativeHandle>& sidebandStream) {

    layer_state_t* s = getLayerState(sc);

    if (!s) {

        mStatus = BAD_INDEX;

        return *this;

    }

    s->what |= layer_state_t::eSidebandStreamChanged;

    s->sidebandStream = sidebandStream;

    return *this;

}



SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::detachChildren(

        const sp<SurfaceControl>& sc) {

    layer_state_t* s = getLayerState(sc);

libs/gui/include/gui/ISurfaceComposerClient.h

+2 −1
Original line number Diff line number Diff line
@@ -40,8 +40,9 @@ public: 
        eProtectedByDRM = 0x00001000,

        eCursorWindow = 0x00002000,



        eFXSurfaceNormal = 0x00000000,

        eFXSurfaceBufferQueue = 0x00000000,

        eFXSurfaceColor = 0x00020000,

        eFXSurfaceBufferState = 0x00040000,

        eFXSurfaceMask = 0x000F0000,

    };

libs/gui/include/gui/LayerState.h

+31 −2
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ 


#include <gui/IGraphicBufferProducer.h>

#include <math/vec3.h>

#include <ui/GraphicTypes.h>

#include <ui/Rect.h>

#include <ui/Region.h>
@@ -61,7 +62,17 @@ struct layer_state_t { 
        eRelativeLayerChanged = 0x00008000,

        eReparent = 0x00010000,

        eColorChanged = 0x00020000,

        eDestroySurface = 0x00040000

        eDestroySurface = 0x00040000,

        eTransformChanged = 0x00100000,

        eTransformToDisplayInverseChanged = 0x00200000,

        eCropChanged = 0x00400000,

        eBufferChanged = 0x00800000,

        eAcquireFenceChanged = 0x01000000,

        eDataspaceChanged = 0x02000000,

        eHdrMetadataChanged = 0x04000000,

        eSurfaceDamageRegionChanged = 0x08000000,

        eApiChanged = 0x10000000,

        eSidebandStreamChanged = 0x20000000,

    };



    layer_state_t()
@@ -79,9 +90,16 @@ struct layer_state_t { 
            crop_legacy(Rect::INVALID_RECT),

            finalCrop_legacy(Rect::INVALID_RECT),

            frameNumber_legacy(0),

            overrideScalingMode(-1) {

            overrideScalingMode(-1),

            transform(0),

            transformToDisplayInverse(false),

            crop(Rect::INVALID_RECT),

            dataspace(ui::Dataspace::UNKNOWN),

            surfaceDamageRegion(),

            api(-1) {

        matrix.dsdx = matrix.dtdy = 1.0f;

        matrix.dsdy = matrix.dtdx = 0.0f;

        hdrMetadata.validTypes = 0;

    }



    void merge(const layer_state_t& other);
@@ -124,6 +142,17 @@ struct layer_state_t { 


    // non POD must be last. see write/read

    Region transparentRegion;



    uint32_t transform;

    bool transformToDisplayInverse;

    Rect crop;

    sp<GraphicBuffer> buffer;

    sp<Fence> acquireFence;

    ui::Dataspace dataspace;

    HdrMetadata hdrMetadata;

    Region surfaceDamageRegion;

    int32_t api;

    sp<NativeHandle> sidebandStream;

};



struct ComposerState {

libs/gui/include/gui/SurfaceComposerClient.h

+14 −0
Original line number Diff line number Diff line
@@ -227,6 +227,20 @@ public: 


        Transaction& setColor(const sp<SurfaceControl>& sc, const half3& color);



        Transaction& setTransform(const sp<SurfaceControl>& sc, uint32_t transform);

        Transaction& setTransformToDisplayInverse(const sp<SurfaceControl>& sc,

                                                  bool transformToDisplayInverse);

        Transaction& setCrop(const sp<SurfaceControl>& sc, const Rect& crop);

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

        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,

                                            const Region& surfaceDamageRegion);

        Transaction& setApi(const sp<SurfaceControl>& sc, int32_t api);

        Transaction& setSidebandStream(const sp<SurfaceControl>& sc,

                                       const sp<NativeHandle>& sidebandStream);



        // Detaches all child surfaces (and their children recursively)

        // from their SurfaceControl.

        // The child SurfaceControls will not throw exceptions or return errors,