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

Commit c3800b88 authored by Lucas Dupin's avatar Lucas Dupin
Browse files

Implement blur region in RenderEngine 

Blur regions should be be piped through SurfaceFlinger
all the way down to the compositor, in order to render
blurs.

It's also necessary to cache them if multiple regions require
the same blur radius.

Test: manual
Test: atest SurfaceInterceptor_test
Test: atest OutputUpdateAndWriteCompositionStateTest
Bug: 159712515
Change-Id: Id4759f65eb2522a80e9328062fe641fe29786a30
parent 29ef5598

cmds/surfacereplayer/proto/src/trace.proto

+18 −0
Original line number Diff line number Diff line
@@ -54,6 +54,7 @@ message SurfaceChange { 
        ReparentChildrenChange      reparent_children       = 20;

        BackgroundBlurRadiusChange  background_blur_radius  = 21;

        ShadowRadiusChange          shadow_radius           = 22;

        BlurRegionsChange           blur_regions            = 23;

    }

}
@@ -207,6 +208,23 @@ message ShadowRadiusChange { 
    required float radius = 1;

}



message BlurRegionsChange {

    repeated BlurRegionChange blur_regions = 1;

}



message BlurRegionChange {

    required uint32 blur_radius = 1;

    required float corner_radius_tl = 2;

    required float corner_radius_tr = 3;

    required float corner_radius_bl = 4;

    required float corner_radius_br = 5;

    required float alpha = 6;

    required int32 left = 7;

    required int32 top = 8;

    required int32 right = 9;

    required int32 bottom = 10;

}



message Origin {

    required int32 pid = 1;

    required int32 uid = 2;

cmds/surfacereplayer/replayer/Replayer.cpp

+24 −0
Original line number Diff line number Diff line
@@ -423,6 +423,9 @@ status_t Replayer::doSurfaceTransaction( 
            case SurfaceChange::SurfaceChangeCase::kShadowRadius:

                setShadowRadiusChange(transaction, change.id(), change.shadow_radius());

                break;

            case SurfaceChange::SurfaceChangeCase::kBlurRegions:

                setBlurRegionsChange(transaction, change.id(), change.blur_regions());

                break;

            default:

                status = 1;

                break;
@@ -728,3 +731,24 @@ void Replayer::setShadowRadiusChange(SurfaceComposerClient::Transaction& t, 
        layer_id id, const ShadowRadiusChange& c) {

    t.setShadowRadius(mLayers[id], c.radius());

}



void Replayer::setBlurRegionsChange(SurfaceComposerClient::Transaction& t,

        layer_id id, const BlurRegionsChange& c) {

    std::vector<BlurRegion> regions;

    for(size_t i=0; i < c.blur_regions_size(); i++) {

        auto protoRegion = c.blur_regions(i);

        regions.push_back(BlurRegion{

            .blurRadius = protoRegion.blur_radius(),

            .alpha = protoRegion.alpha(),

            .cornerRadiusTL = protoRegion.corner_radius_tl(),

            .cornerRadiusTR = protoRegion.corner_radius_tr(),

            .cornerRadiusBL = protoRegion.corner_radius_bl(),

            .cornerRadiusBR = protoRegion.corner_radius_br(),

            .left = protoRegion.left(),

            .top = protoRegion.top(),

            .right = protoRegion.right(),

            .bottom = protoRegion.bottom()

        });

    }

    t.setBlurRegions(mLayers[id], regions);

}

cmds/surfacereplayer/replayer/Replayer.h

+4 −0
Original line number Diff line number Diff line
@@ -96,6 +96,8 @@ class Replayer { 
            layer_id id, const CornerRadiusChange& cc);

    void setBackgroundBlurRadius(SurfaceComposerClient::Transaction& t,

            layer_id id, const BackgroundBlurRadiusChange& cc);

    void setBlurRegions(SurfaceComposerClient::Transaction& t,

            layer_id id, const BlurRegionsChange& cc);

    void setMatrix(SurfaceComposerClient::Transaction& t,

            layer_id id, const MatrixChange& mc);

    void setTransparentRegionHint(SurfaceComposerClient::Transaction& t,
@@ -120,6 +122,8 @@ class Replayer { 
            layer_id id, const ReparentChildrenChange& c);

    void setShadowRadiusChange(SurfaceComposerClient::Transaction& t,

            layer_id id, const ShadowRadiusChange& c);

    void setBlurRegionsChange(SurfaceComposerClient::Transaction& t,

            layer_id id, const BlurRegionsChange& c);



    void setDisplaySurface(SurfaceComposerClient::Transaction& t,

            display_id id, const DispSurfaceChange& dsc);

libs/gui/LayerState.cpp

+36 −0
Original line number Diff line number Diff line
@@ -147,6 +147,20 @@ status_t layer_state_t::write(Parcel& output) const 
    SAFE_PARCEL(output.writeUint32, fixedTransformHint);

    SAFE_PARCEL(output.writeUint64, frameNumber);

    SAFE_PARCEL(output.writeInt64, frameTimelineVsyncId);



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

    for (auto region : blurRegions) {

        SAFE_PARCEL(output.writeUint32, region.blurRadius);

        SAFE_PARCEL(output.writeFloat, region.cornerRadiusTL);

        SAFE_PARCEL(output.writeFloat, region.cornerRadiusTR);

        SAFE_PARCEL(output.writeFloat, region.cornerRadiusBL);

        SAFE_PARCEL(output.writeFloat, region.cornerRadiusBR);

        SAFE_PARCEL(output.writeFloat, region.alpha);

        SAFE_PARCEL(output.writeInt32, region.left);

        SAFE_PARCEL(output.writeInt32, region.top);

        SAFE_PARCEL(output.writeInt32, region.right);

        SAFE_PARCEL(output.writeInt32, region.bottom);

    }

    return NO_ERROR;

}
@@ -252,6 +266,24 @@ status_t layer_state_t::read(const Parcel& input) 
    fixedTransformHint = static_cast<ui::Transform::RotationFlags>(tmpUint32);

    SAFE_PARCEL(input.readUint64, &frameNumber);

    SAFE_PARCEL(input.readInt64, &frameTimelineVsyncId);



    uint32_t numRegions = 0;

    SAFE_PARCEL(input.readUint32, &numRegions);

    blurRegions.clear();

    for (uint32_t i = 0; i < numRegions; i++) {

        BlurRegion region;

        SAFE_PARCEL(input.readUint32, &region.blurRadius);

        SAFE_PARCEL(input.readFloat, &region.cornerRadiusTL);

        SAFE_PARCEL(input.readFloat, &region.cornerRadiusTR);

        SAFE_PARCEL(input.readFloat, &region.cornerRadiusBL);

        SAFE_PARCEL(input.readFloat, &region.cornerRadiusBR);

        SAFE_PARCEL(input.readFloat, &region.alpha);

        SAFE_PARCEL(input.readInt32, &region.left);

        SAFE_PARCEL(input.readInt32, &region.top);

        SAFE_PARCEL(input.readInt32, &region.right);

        SAFE_PARCEL(input.readInt32, &region.bottom);

        blurRegions.push_back(region);

    }

    return NO_ERROR;

}
@@ -375,6 +407,10 @@ void layer_state_t::merge(const layer_state_t& other) { 
        what |= eBackgroundBlurRadiusChanged;

        backgroundBlurRadius = other.backgroundBlurRadius;

    }

    if (other.what & eBlurRegionsChanged) {

        what |= eBlurRegionsChanged;

        blurRegions = other.blurRegions;

    }

    if (other.what & eDeferTransaction_legacy) {

        what |= eDeferTransaction_legacy;

        barrierSurfaceControl_legacy = other.barrierSurfaceControl_legacy;

libs/gui/SurfaceComposerClient.cpp

+12 −0
Original line number Diff line number Diff line
@@ -1017,6 +1017,18 @@ SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setBackg 
    return *this;

}



SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setBlurRegions(

        const sp<SurfaceControl>& sc, const std::vector<BlurRegion>& blurRegions) {

    layer_state_t* s = getLayerState(sc);

    if (!s) {

        mStatus = BAD_INDEX;

        return *this;

    }

    s->what |= layer_state_t::eBlurRegionsChanged;

    s->blurRegions = blurRegions;

    return *this;

}



SurfaceComposerClient::Transaction&

SurfaceComposerClient::Transaction::deferTransactionUntil_legacy(

        const sp<SurfaceControl>& sc, const sp<SurfaceControl>& barrierSurfaceControl,