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

Commit 4cdc58f6 authored by Robert Carr's avatar Robert Carr
Browse files

SurfaceFlinger Transactions as distinct objects. 

Essentially a process global singleton for transactions is not so useful once
we make surface control public API as process isn't something an app developer
is really thinking about. It's also nice that we get to delete two of the plumbing layers.

Test: Boots
Change-Id: I8864bd7e2f5865e3c0a425cf82f9928211911774
parent 049c1147

cmds/flatland/GLHelper.cpp

+4 −18
Original line number Diff line number Diff line
@@ -269,24 +269,10 @@ bool GLHelper::createWindowSurface(uint32_t w, uint32_t h, 
        return false;

    }



    SurfaceComposerClient::openGlobalTransaction();

    err = sc->setLayer(0x7FFFFFFF);

    if (err != NO_ERROR) {

        fprintf(stderr, "SurfaceComposer::setLayer error: %#x\n", err);

        return false;

    }

    err = sc->setMatrix(scale, 0.0f, 0.0f, scale);

    if (err != NO_ERROR) {

        fprintf(stderr, "SurfaceComposer::setMatrix error: %#x\n", err);

        return false;

    }



    err = sc->show();

    if (err != NO_ERROR) {

        fprintf(stderr, "SurfaceComposer::show error: %#x\n", err);

        return false;

    }

    SurfaceComposerClient::closeGlobalTransaction();

    SurfaceComposerClient::Transaction{}.setLayer(sc, 0x7FFFFFFF)

            .setMatrix(sc, scale, 0.0f, 0.0f, scale)

            .show(sc)

            .apply();



    sp<ANativeWindow> anw = sc->getSurface();

    EGLSurface s = eglCreateWindowSurface(mDisplay, mConfig, anw.get(), NULL);

cmds/surfacereplayer/replayer/Replayer.cpp

+89 −65
Original line number Diff line number Diff line
@@ -24,9 +24,9 @@ 


#include <gui/BufferQueue.h>

#include <gui/ISurfaceComposer.h>

#include <gui/LayerState.h>

#include <gui/Surface.h>

#include <private/gui/ComposerService.h>

#include <private/gui/LayerState.h>



#include <ui/DisplayInfo.h>

#include <utils/Log.h>
@@ -338,27 +338,29 @@ status_t Replayer::dispatchEvent(int index) { 
status_t Replayer::doTransaction(const Transaction& t, const std::shared_ptr<Event>& event) {

    ALOGV("Started Transaction");



    SurfaceComposerClient::openGlobalTransaction();

    SurfaceComposerClient::Transaction liveTransaction;



    status_t status = NO_ERROR;



    status = doSurfaceTransaction(t.surface_change());

    doDisplayTransaction(t.display_change());

    status = doSurfaceTransaction(liveTransaction, t.surface_change());

    doDisplayTransaction(liveTransaction, t.display_change());



    if (t.animation()) {

        SurfaceComposerClient::setAnimationTransaction();

        liveTransaction.setAnimationTransaction();

    }



    event->readyToExecute();



    SurfaceComposerClient::closeGlobalTransaction(t.synchronous());

    liveTransaction.apply(t.synchronous());



    ALOGV("Ended Transaction");



    return status;

}



status_t Replayer::doSurfaceTransaction(const SurfaceChanges& surfaceChanges) {

status_t Replayer::doSurfaceTransaction(

        SurfaceComposerClient::Transaction& transaction,

        const SurfaceChanges& surfaceChanges) {

    status_t status = NO_ERROR;



    for (const SurfaceChange& change : surfaceChanges) {
@@ -369,62 +371,66 @@ status_t Replayer::doSurfaceTransaction(const SurfaceChanges& surfaceChanges) { 


        switch (change.SurfaceChange_case()) {

            case SurfaceChange::SurfaceChangeCase::kPosition:

                status = setPosition(change.id(), change.position());

                setPosition(transaction, change.id(), change.position());

                break;

            case SurfaceChange::SurfaceChangeCase::kSize:

                status = setSize(change.id(), change.size());

                setSize(transaction, change.id(), change.size());

                break;

            case SurfaceChange::SurfaceChangeCase::kAlpha:

                status = setAlpha(change.id(), change.alpha());

                setAlpha(transaction, change.id(), change.alpha());

                break;

            case SurfaceChange::SurfaceChangeCase::kLayer:

                status = setLayer(change.id(), change.layer());

                setLayer(transaction, change.id(), change.layer());

                break;

            case SurfaceChange::SurfaceChangeCase::kCrop:

                status = setCrop(change.id(), change.crop());

                setCrop(transaction, change.id(), change.crop());

                break;

            case SurfaceChange::SurfaceChangeCase::kMatrix:

                status = setMatrix(change.id(), change.matrix());

                setMatrix(transaction, change.id(), change.matrix());

                break;

            case SurfaceChange::SurfaceChangeCase::kFinalCrop:

                status = setFinalCrop(change.id(), change.final_crop());

                setFinalCrop(transaction, change.id(), change.final_crop());

                break;

            case SurfaceChange::SurfaceChangeCase::kOverrideScalingMode:

                status = setOverrideScalingMode(change.id(), change.override_scaling_mode());

                setOverrideScalingMode(transaction, change.id(),

                        change.override_scaling_mode());

                break;

            case SurfaceChange::SurfaceChangeCase::kTransparentRegionHint:

                status = setTransparentRegionHint(change.id(), change.transparent_region_hint());

                setTransparentRegionHint(transaction, change.id(),

                        change.transparent_region_hint());

                break;

            case SurfaceChange::SurfaceChangeCase::kLayerStack:

                status = setLayerStack(change.id(), change.layer_stack());

                setLayerStack(transaction, change.id(), change.layer_stack());

                break;

            case SurfaceChange::SurfaceChangeCase::kHiddenFlag:

                status = setHiddenFlag(change.id(), change.hidden_flag());

                setHiddenFlag(transaction, change.id(), change.hidden_flag());

                break;

            case SurfaceChange::SurfaceChangeCase::kOpaqueFlag:

                status = setOpaqueFlag(change.id(), change.opaque_flag());

                setOpaqueFlag(transaction, change.id(), change.opaque_flag());

                break;

            case SurfaceChange::SurfaceChangeCase::kSecureFlag:

                status = setSecureFlag(change.id(), change.secure_flag());

                setSecureFlag(transaction, change.id(), change.secure_flag());

                break;

            case SurfaceChange::SurfaceChangeCase::kDeferredTransaction:

                waitUntilDeferredTransactionLayerExists(change.deferred_transaction(), lock);

                status = setDeferredTransaction(change.id(), change.deferred_transaction());

                setDeferredTransaction(transaction, change.id(),

                        change.deferred_transaction());

                break;

            default:

                status = NO_ERROR;

                status = 1;

                break;

        }



        if (status != NO_ERROR) {

            ALOGE("SET TRANSACTION FAILED");

            ALOGE("Unknown Transaction Code");

            return status;

        }

    }

    return status;

}



void Replayer::doDisplayTransaction(const DisplayChanges& displayChanges) {

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

        const DisplayChanges& displayChanges) {

    for (const DisplayChange& change : displayChanges) {

        ALOGV("Doing display transaction");

        std::unique_lock<std::mutex> lock(mDisplayLock);
@@ -434,16 +440,16 @@ void Replayer::doDisplayTransaction(const DisplayChanges& displayChanges) { 


        switch (change.DisplayChange_case()) {

            case DisplayChange::DisplayChangeCase::kSurface:

                setDisplaySurface(change.id(), change.surface());

                setDisplaySurface(t, change.id(), change.surface());

                break;

            case DisplayChange::DisplayChangeCase::kLayerStack:

                setDisplayLayerStack(change.id(), change.layer_stack());

                setDisplayLayerStack(t, change.id(), change.layer_stack());

                break;

            case DisplayChange::DisplayChangeCase::kSize:

                setDisplaySize(change.id(), change.size());

                setDisplaySize(t, change.id(), change.size());

                break;

            case DisplayChange::DisplayChangeCase::kProjection:

                setDisplayProjection(change.id(), change.projection());

                setDisplayProjection(t, change.id(), change.projection());

                break;

            default:

                break;
@@ -451,57 +457,66 @@ void Replayer::doDisplayTransaction(const DisplayChanges& displayChanges) { 
    }

}



status_t Replayer::setPosition(layer_id id, const PositionChange& pc) {

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

        layer_id id, const PositionChange& pc) {

    ALOGV("Layer %d: Setting Position -- x=%f, y=%f", id, pc.x(), pc.y());

    return mLayers[id]->setPosition(pc.x(), pc.y());

    t.setPosition(mLayers[id], pc.x(), pc.y());

}



status_t Replayer::setSize(layer_id id, const SizeChange& sc) {

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

        layer_id id, const SizeChange& sc) {

    ALOGV("Layer %d: Setting Size -- w=%u, h=%u", id, sc.w(), sc.h());

    return mLayers[id]->setSize(sc.w(), sc.h());

    t.setSize(mLayers[id], sc.w(), sc.h());

}



status_t Replayer::setLayer(layer_id id, const LayerChange& lc) {

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

        layer_id id, const LayerChange& lc) {

    ALOGV("Layer %d: Setting Layer -- layer=%d", id, lc.layer());

    return mLayers[id]->setLayer(lc.layer());

    t.setLayer(mLayers[id], lc.layer());

}



status_t Replayer::setAlpha(layer_id id, const AlphaChange& ac) {

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

        layer_id id, const AlphaChange& ac) {

    ALOGV("Layer %d: Setting Alpha -- alpha=%f", id, ac.alpha());

    return mLayers[id]->setAlpha(ac.alpha());

    t.setAlpha(mLayers[id], ac.alpha());

}



status_t Replayer::setCrop(layer_id id, const CropChange& cc) {

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

        layer_id id, const CropChange& cc) {

    ALOGV("Layer %d: Setting Crop -- left=%d, top=%d, right=%d, bottom=%d", id,

            cc.rectangle().left(), cc.rectangle().top(), cc.rectangle().right(),

            cc.rectangle().bottom());



    Rect r = Rect(cc.rectangle().left(), cc.rectangle().top(), cc.rectangle().right(),

            cc.rectangle().bottom());

    return mLayers[id]->setCrop(r);

    t.setCrop(mLayers[id], r);

}



status_t Replayer::setFinalCrop(layer_id id, const FinalCropChange& fcc) {

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

        layer_id id, const FinalCropChange& fcc) {

    ALOGV("Layer %d: Setting Final Crop -- left=%d, top=%d, right=%d, bottom=%d", id,

            fcc.rectangle().left(), fcc.rectangle().top(), fcc.rectangle().right(),

            fcc.rectangle().bottom());

    Rect r = Rect(fcc.rectangle().left(), fcc.rectangle().top(), fcc.rectangle().right(),

            fcc.rectangle().bottom());

    return mLayers[id]->setFinalCrop(r);

    t.setFinalCrop(mLayers[id], r);

}



status_t Replayer::setMatrix(layer_id id, const MatrixChange& mc) {

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

        layer_id id, const MatrixChange& mc) {

    ALOGV("Layer %d: Setting Matrix -- dsdx=%f, dtdx=%f, dsdy=%f, dtdy=%f", id, mc.dsdx(),

            mc.dtdx(), mc.dsdy(), mc.dtdy());

    return mLayers[id]->setMatrix(mc.dsdx(), mc.dtdx(), mc.dsdy(), mc.dtdy());

    t.setMatrix(mLayers[id], mc.dsdx(), mc.dtdx(), mc.dsdy(), mc.dtdy());

}



status_t Replayer::setOverrideScalingMode(layer_id id, const OverrideScalingModeChange& osmc) {

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

        layer_id id, const OverrideScalingModeChange& osmc) {

    ALOGV("Layer %d: Setting Override Scaling Mode -- mode=%d", id, osmc.override_scaling_mode());

    return mLayers[id]->setOverrideScalingMode(osmc.override_scaling_mode());

    t.setOverrideScalingMode(mLayers[id], osmc.override_scaling_mode());

}



status_t Replayer::setTransparentRegionHint(layer_id id, const TransparentRegionHintChange& trhc) {

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

        layer_id id, const TransparentRegionHintChange& trhc) {

    ALOGV("Setting Transparent Region Hint");

    Region re = Region();
@@ -510,71 +525,80 @@ status_t Replayer::setTransparentRegionHint(layer_id id, const TransparentRegion 
        re.merge(rect);

    }



    return mLayers[id]->setTransparentRegionHint(re);

    t.setTransparentRegionHint(mLayers[id], re);

}



status_t Replayer::setLayerStack(layer_id id, const LayerStackChange& lsc) {

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

        layer_id id, const LayerStackChange& lsc) {

    ALOGV("Layer %d: Setting LayerStack -- layer_stack=%d", id, lsc.layer_stack());

    return mLayers[id]->setLayerStack(lsc.layer_stack());

    t.setLayerStack(mLayers[id], lsc.layer_stack());

}



status_t Replayer::setHiddenFlag(layer_id id, const HiddenFlagChange& hfc) {

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

        layer_id id, const HiddenFlagChange& hfc) {

    ALOGV("Layer %d: Setting Hidden Flag -- hidden_flag=%d", id, hfc.hidden_flag());

    layer_id flag = hfc.hidden_flag() ? layer_state_t::eLayerHidden : 0;



    return mLayers[id]->setFlags(flag, layer_state_t::eLayerHidden);

    t.setFlags(mLayers[id], flag, layer_state_t::eLayerHidden);

}



status_t Replayer::setOpaqueFlag(layer_id id, const OpaqueFlagChange& ofc) {

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

        layer_id id, const OpaqueFlagChange& ofc) {

    ALOGV("Layer %d: Setting Opaque Flag -- opaque_flag=%d", id, ofc.opaque_flag());

    layer_id flag = ofc.opaque_flag() ? layer_state_t::eLayerOpaque : 0;



    return mLayers[id]->setFlags(flag, layer_state_t::eLayerOpaque);

    t.setFlags(mLayers[id], flag, layer_state_t::eLayerOpaque);

}



status_t Replayer::setSecureFlag(layer_id id, const SecureFlagChange& sfc) {

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

        layer_id id, const SecureFlagChange& sfc) {

    ALOGV("Layer %d: Setting Secure Flag -- secure_flag=%d", id, sfc.secure_flag());

    layer_id flag = sfc.secure_flag() ? layer_state_t::eLayerSecure : 0;



    return mLayers[id]->setFlags(flag, layer_state_t::eLayerSecure);

    t.setFlags(mLayers[id], flag, layer_state_t::eLayerSecure);

}



status_t Replayer::setDeferredTransaction(layer_id id, const DeferredTransactionChange& dtc) {

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

        layer_id id, const DeferredTransactionChange& dtc) {

    ALOGV("Layer %d: Setting Deferred Transaction -- layer_id=%d, "

          "frame_number=%llu",

            id, dtc.layer_id(), dtc.frame_number());

    if (mLayers.count(dtc.layer_id()) == 0 || mLayers[dtc.layer_id()] == nullptr) {

        ALOGE("Layer %d not found in Deferred Transaction", dtc.layer_id());

        return BAD_VALUE;

        return;

    }



    auto handle = mLayers[dtc.layer_id()]->getHandle();



    return mLayers[id]->deferTransactionUntil(handle, dtc.frame_number());

    t.deferTransactionUntil(mLayers[id], handle, dtc.frame_number());

}



void Replayer::setDisplaySurface(display_id id, const DispSurfaceChange& /*dsc*/) {

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

        display_id id, const DispSurfaceChange& /*dsc*/) {

    sp<IGraphicBufferProducer> outProducer;

    sp<IGraphicBufferConsumer> outConsumer;

    BufferQueue::createBufferQueue(&outProducer, &outConsumer);



    SurfaceComposerClient::setDisplaySurface(mDisplays[id], outProducer);

    t.setDisplaySurface(mDisplays[id], outProducer);

}



void Replayer::setDisplayLayerStack(display_id id, const LayerStackChange& lsc) {

    SurfaceComposerClient::setDisplayLayerStack(mDisplays[id], lsc.layer_stack());

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

        display_id id, const LayerStackChange& lsc) {

    t.setDisplayLayerStack(mDisplays[id], lsc.layer_stack());

}



void Replayer::setDisplaySize(display_id id, const SizeChange& sc) {

    SurfaceComposerClient::setDisplaySize(mDisplays[id], sc.w(), sc.h());

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

        display_id id, const SizeChange& sc) {

    t.setDisplaySize(mDisplays[id], sc.w(), sc.h());

}



void Replayer::setDisplayProjection(display_id id, const ProjectionChange& pc) {

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

        display_id id, const ProjectionChange& pc) {

    Rect viewport = Rect(pc.viewport().left(), pc.viewport().top(), pc.viewport().right(),

            pc.viewport().bottom());

    Rect frame = Rect(pc.frame().left(), pc.frame().top(), pc.frame().right(), pc.frame().bottom());



    SurfaceComposerClient::setDisplayProjection(mDisplays[id], pc.orientation(), viewport, frame);

    t.setDisplayProjection(mDisplays[id], pc.orientation(), viewport, frame);

}



status_t Replayer::createSurfaceControl(

cmds/surfacereplayer/replayer/Replayer.h

+42 −22
Original line number Diff line number Diff line
@@ -77,28 +77,48 @@ class Replayer { 
    void deleteDisplay(const DisplayDeletion& delete_, const std::shared_ptr<Event>& event);

    void updatePowerMode(const PowerModeUpdate& update, const std::shared_ptr<Event>& event);



    status_t doSurfaceTransaction(const SurfaceChanges& surfaceChange);

    void doDisplayTransaction(const DisplayChanges& displayChange);



    status_t setPosition(layer_id id, const PositionChange& pc);

    status_t setSize(layer_id id, const SizeChange& sc);

    status_t setAlpha(layer_id id, const AlphaChange& ac);

    status_t setLayer(layer_id id, const LayerChange& lc);

    status_t setCrop(layer_id id, const CropChange& cc);

    status_t setFinalCrop(layer_id id, const FinalCropChange& fcc);

    status_t setMatrix(layer_id id, const MatrixChange& mc);

    status_t setOverrideScalingMode(layer_id id, const OverrideScalingModeChange& osmc);

    status_t setTransparentRegionHint(layer_id id, const TransparentRegionHintChange& trgc);

    status_t setLayerStack(layer_id id, const LayerStackChange& lsc);

    status_t setHiddenFlag(layer_id id, const HiddenFlagChange& hfc);

    status_t setOpaqueFlag(layer_id id, const OpaqueFlagChange& ofc);

    status_t setSecureFlag(layer_id id, const SecureFlagChange& sfc);

    status_t setDeferredTransaction(layer_id id, const DeferredTransactionChange& dtc);



    void setDisplaySurface(display_id id, const DispSurfaceChange& dsc);

    void setDisplayLayerStack(display_id id, const LayerStackChange& lsc);

    void setDisplaySize(display_id id, const SizeChange& sc);

    void setDisplayProjection(display_id id, const ProjectionChange& pc);

    status_t doSurfaceTransaction(SurfaceComposerClient::Transaction& transaction,

            const SurfaceChanges& surfaceChange);

    void doDisplayTransaction(SurfaceComposerClient::Transaction& transaction,

            const DisplayChanges& displayChange);



    void setPosition(SurfaceComposerClient::Transaction& t,

            layer_id id, const PositionChange& pc);

    void setSize(SurfaceComposerClient::Transaction& t,

            layer_id id, const SizeChange& sc);

    void setAlpha(SurfaceComposerClient::Transaction& t,

            layer_id id, const AlphaChange& ac);

    void setLayer(SurfaceComposerClient::Transaction& t,

            layer_id id, const LayerChange& lc);

    void setCrop(SurfaceComposerClient::Transaction& t,

            layer_id id, const CropChange& cc);

    void setFinalCrop(SurfaceComposerClient::Transaction& t,

            layer_id id, const FinalCropChange& fcc);

    void setMatrix(SurfaceComposerClient::Transaction& t,

            layer_id id, const MatrixChange& mc);

    void setOverrideScalingMode(SurfaceComposerClient::Transaction& t,

            layer_id id, const OverrideScalingModeChange& osmc);

    void setTransparentRegionHint(SurfaceComposerClient::Transaction& t,

            layer_id id, const TransparentRegionHintChange& trgc);

    void setLayerStack(SurfaceComposerClient::Transaction& t,

            layer_id id, const LayerStackChange& lsc);

    void setHiddenFlag(SurfaceComposerClient::Transaction& t,

            layer_id id, const HiddenFlagChange& hfc);

    void setOpaqueFlag(SurfaceComposerClient::Transaction& t,

            layer_id id, const OpaqueFlagChange& ofc);

    void setSecureFlag(SurfaceComposerClient::Transaction& t,

            layer_id id, const SecureFlagChange& sfc);

    void setDeferredTransaction(SurfaceComposerClient::Transaction& t,

            layer_id id, const DeferredTransactionChange& dtc);



    void setDisplaySurface(SurfaceComposerClient::Transaction& t,

            display_id id, const DispSurfaceChange& dsc);

    void setDisplayLayerStack(SurfaceComposerClient::Transaction& t,

            display_id id, const LayerStackChange& lsc);

    void setDisplaySize(SurfaceComposerClient::Transaction& t,

            display_id id, const SizeChange& sc);

    void setDisplayProjection(SurfaceComposerClient::Transaction& t,

            display_id id, const ProjectionChange& pc);



    void doDeleteSurfaceControls();

    void waitUntilTimestamp(int64_t timestamp);

libs/gui/ISurfaceComposer.cpp

+1 −2
Original line number Diff line number Diff line
@@ -29,8 +29,7 @@ 
#include <gui/ISurfaceComposer.h>

#include <gui/ISurfaceComposerClient.h>

#include <gui/LayerDebugInfo.h>



#include <private/gui/LayerState.h>

#include <gui/LayerState.h>



#include <system/graphics.h>

libs/gui/LayerState.cpp

+1 −1
Original line number Diff line number Diff line
@@ -18,7 +18,7 @@ 
#include <binder/Parcel.h>

#include <gui/ISurfaceComposerClient.h>

#include <gui/IGraphicBufferProducer.h>

#include <private/gui/LayerState.h>

#include <gui/LayerState.h>



namespace android {