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

Commit 3bdef86d authored by Huihong Luo's avatar Huihong Luo
Browse files

Migrate and clean up methods of ISurfaceComposer 

Convert FrameTimelineInfo to aidl parcelable. Add Color, DisplayDecorationSupport and DisplayedFrameStats parcelables. Remove the following methods: authenticateSurfaceTexture, setFrameRate and setFrameTimelineInfo, which alway retrun errors for BLAST. Ramp up error handling.

Bug: 222537482
Bug: 222763616
Test: atest libgui_test libsurfaceflinger_unittest SurfaceFlinger_test
Change-Id: I3b46bae068ac3d482881dac96972a40e46581d34
parent 4b567aee

libs/gui/Android.bp

+0 −1
Original line number Diff line number Diff line
@@ -198,7 +198,6 @@ cc_library_shared { 
        "DebugEGLImageTracker.cpp",

        "DisplayEventDispatcher.cpp",

        "DisplayEventReceiver.cpp",

        "FrameTimelineInfo.cpp",

        "GLConsumer.cpp",

        "IConsumerListener.cpp",

        "IGraphicBufferConsumer.cpp",

libs/gui/FrameTimelineInfo.cpp

deleted100644 → 0
+0 −68
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2021 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#define LOG_TAG "FrameTimelineInfo"



#include <inttypes.h>



#include <android/os/IInputConstants.h>

#include <gui/FrameTimelineInfo.h>

#include <gui/LayerState.h>

#include <private/gui/ParcelUtils.h>

#include <utils/Errors.h>



#include <cmath>



using android::os::IInputConstants;



namespace android {



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

    SAFE_PARCEL(output.writeInt64, vsyncId);

    SAFE_PARCEL(output.writeInt32, inputEventId);

    SAFE_PARCEL(output.writeInt64, startTimeNanos);

    return NO_ERROR;

}



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

    SAFE_PARCEL(input.readInt64, &vsyncId);

    SAFE_PARCEL(input.readInt32, &inputEventId);

    SAFE_PARCEL(input.readInt64, &startTimeNanos);

    return NO_ERROR;

}



void FrameTimelineInfo::merge(const FrameTimelineInfo& other) {

    // When merging vsync Ids we take the oldest valid one

    if (vsyncId != INVALID_VSYNC_ID && other.vsyncId != INVALID_VSYNC_ID) {

        if (other.vsyncId > vsyncId) {

            vsyncId = other.vsyncId;

            inputEventId = other.inputEventId;

            startTimeNanos = other.startTimeNanos;

        }

    } else if (vsyncId == INVALID_VSYNC_ID) {

        vsyncId = other.vsyncId;

        inputEventId = other.inputEventId;

        startTimeNanos = other.startTimeNanos;

    }

}



void FrameTimelineInfo::clear() {

    vsyncId = INVALID_VSYNC_ID;

    inputEventId = IInputConstants::INVALID_INPUT_EVENT_ID;

    startTimeNanos = 0;

}



}; // namespace android

libs/gui/ISurfaceComposer.cpp

+2 −343
Original line number Diff line number Diff line
@@ -80,7 +80,7 @@ public: 
        Parcel data, reply;

        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());



        SAFE_PARCEL(frameTimelineInfo.write, data);

        frameTimelineInfo.writeToParcel(&data);



        SAFE_PARCEL(data.writeUint32, static_cast<uint32_t>(state.size()));

        for (const auto& s : state) {
@@ -124,40 +124,6 @@ public: 
        remote()->transact(BnSurfaceComposer::BOOT_FINISHED, data, &reply);

    }



    bool authenticateSurfaceTexture(

            const sp<IGraphicBufferProducer>& bufferProducer) const override {

        Parcel data, reply;

        int err = NO_ERROR;

        err = data.writeInterfaceToken(

                ISurfaceComposer::getInterfaceDescriptor());

        if (err != NO_ERROR) {

            ALOGE("ISurfaceComposer::authenticateSurfaceTexture: error writing "

                    "interface descriptor: %s (%d)", strerror(-err), -err);

            return false;

        }

        err = data.writeStrongBinder(IInterface::asBinder(bufferProducer));

        if (err != NO_ERROR) {

            ALOGE("ISurfaceComposer::authenticateSurfaceTexture: error writing "

                    "strong binder to parcel: %s (%d)", strerror(-err), -err);

            return false;

        }

        err = remote()->transact(BnSurfaceComposer::AUTHENTICATE_SURFACE, data,

                &reply);

        if (err != NO_ERROR) {

            ALOGE("ISurfaceComposer::authenticateSurfaceTexture: error "

                    "performing transaction: %s (%d)", strerror(-err), -err);

            return false;

        }

        int32_t result = 0;

        err = reply.readInt32(&result);

        if (err != NO_ERROR) {

            ALOGE("ISurfaceComposer::authenticateSurfaceTexture: error "

                    "retrieving result: %s (%d)", strerror(-err), -err);

            return false;

        }

        return result != 0;

    }



    sp<IDisplayEventConnection> createDisplayEventConnection(

            VsyncSource vsyncSource, EventRegistrationFlags eventRegistration) override {

        Parcel data, reply;
@@ -180,181 +146,6 @@ public: 
        result = interface_cast<IDisplayEventConnection>(reply.readStrongBinder());

        return result;

    }



    status_t getDisplayedContentSample(const sp<IBinder>& display, uint64_t maxFrames,

                                       uint64_t timestamp,

                                       DisplayedFrameStats* outStats) const override {

        if (!outStats) return BAD_VALUE;



        Parcel data, reply;

        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());

        data.writeStrongBinder(display);

        data.writeUint64(maxFrames);

        data.writeUint64(timestamp);



        status_t result =

                remote()->transact(BnSurfaceComposer::GET_DISPLAYED_CONTENT_SAMPLE, data, &reply);



        if (result != NO_ERROR) {

            return result;

        }



        result = reply.readUint64(&outStats->numFrames);

        if (result != NO_ERROR) {

            return result;

        }



        result = reply.readUint64Vector(&outStats->component_0_sample);

        if (result != NO_ERROR) {

            return result;

        }

        result = reply.readUint64Vector(&outStats->component_1_sample);

        if (result != NO_ERROR) {

            return result;

        }

        result = reply.readUint64Vector(&outStats->component_2_sample);

        if (result != NO_ERROR) {

            return result;

        }

        result = reply.readUint64Vector(&outStats->component_3_sample);

        return result;

    }



    status_t setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,

                                     float lightPosY, float lightPosZ, float lightRadius) override {

        Parcel data, reply;

        status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());

        if (error != NO_ERROR) {

            ALOGE("setGlobalShadowSettings: failed to write interface token: %d", error);

            return error;

        }



        std::vector<float> shadowConfig = {ambientColor.r, ambientColor.g, ambientColor.b,

                                           ambientColor.a, spotColor.r,    spotColor.g,

                                           spotColor.b,    spotColor.a,    lightPosY,

                                           lightPosZ,      lightRadius};



        error = data.writeFloatVector(shadowConfig);

        if (error != NO_ERROR) {

            ALOGE("setGlobalShadowSettings: failed to write shadowConfig: %d", error);

            return error;

        }



        error = remote()->transact(BnSurfaceComposer::SET_GLOBAL_SHADOW_SETTINGS, data, &reply,

                                   IBinder::FLAG_ONEWAY);

        if (error != NO_ERROR) {

            ALOGE("setGlobalShadowSettings: failed to transact: %d", error);

            return error;

        }

        return NO_ERROR;

    }



    status_t getDisplayDecorationSupport(

            const sp<IBinder>& displayToken,

            std::optional<common::DisplayDecorationSupport>* outSupport) const override {

        Parcel data, reply;

        status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());

        if (error != NO_ERROR) {

            ALOGE("getDisplayDecorationSupport: failed to write interface token: %d", error);

            return error;

        }

        error = data.writeStrongBinder(displayToken);

        if (error != NO_ERROR) {

            ALOGE("getDisplayDecorationSupport: failed to write display token: %d", error);

            return error;

        }

        error = remote()->transact(BnSurfaceComposer::GET_DISPLAY_DECORATION_SUPPORT, data, &reply);

        if (error != NO_ERROR) {

            ALOGE("getDisplayDecorationSupport: failed to transact: %d", error);

            return error;

        }

        bool support;

        error = reply.readBool(&support);

        if (error != NO_ERROR) {

            ALOGE("getDisplayDecorationSupport: failed to read support: %d", error);

            return error;

        }



        if (support) {

            int32_t format, alphaInterpretation;

            error = reply.readInt32(&format);

            if (error != NO_ERROR) {

                ALOGE("getDisplayDecorationSupport: failed to read format: %d", error);

                return error;

            }

            error = reply.readInt32(&alphaInterpretation);

            if (error != NO_ERROR) {

                ALOGE("getDisplayDecorationSupport: failed to read alphaInterpretation: %d", error);

                return error;

            }

            outSupport->emplace();

            outSupport->value().format = static_cast<common::PixelFormat>(format);

            outSupport->value().alphaInterpretation =

                    static_cast<common::AlphaInterpretation>(alphaInterpretation);

        } else {

            outSupport->reset();

        }

        return NO_ERROR;

    }



    status_t setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate,

                          int8_t compatibility, int8_t changeFrameRateStrategy) override {

        Parcel data, reply;

        SAFE_PARCEL(data.writeInterfaceToken, ISurfaceComposer::getInterfaceDescriptor());

        SAFE_PARCEL(data.writeStrongBinder, IInterface::asBinder(surface));

        SAFE_PARCEL(data.writeFloat, frameRate);

        SAFE_PARCEL(data.writeByte, compatibility);

        SAFE_PARCEL(data.writeByte, changeFrameRateStrategy);



        status_t err = remote()->transact(BnSurfaceComposer::SET_FRAME_RATE, data, &reply);

        if (err != NO_ERROR) {

            ALOGE("setFrameRate: failed to transact: %s (%d)", strerror(-err), err);

            return err;

        }



        return reply.readInt32();

    }



    status_t setFrameTimelineInfo(const sp<IGraphicBufferProducer>& surface,

                                  const FrameTimelineInfo& frameTimelineInfo) override {

        Parcel data, reply;

        status_t err = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());

        if (err != NO_ERROR) {

            ALOGE("%s: failed writing interface token: %s (%d)", __func__, strerror(-err), -err);

            return err;

        }



        err = data.writeStrongBinder(IInterface::asBinder(surface));

        if (err != NO_ERROR) {

            ALOGE("%s: failed writing strong binder: %s (%d)", __func__, strerror(-err), -err);

            return err;

        }



        SAFE_PARCEL(frameTimelineInfo.write, data);



        err = remote()->transact(BnSurfaceComposer::SET_FRAME_TIMELINE_INFO, data, &reply);

        if (err != NO_ERROR) {

            ALOGE("%s: failed to transact: %s (%d)", __func__, strerror(-err), err);

            return err;

        }



        return reply.readInt32();

    }



    status_t setOverrideFrameRate(uid_t uid, float frameRate) override {

        Parcel data, reply;

        SAFE_PARCEL(data.writeInterfaceToken, ISurfaceComposer::getInterfaceDescriptor());

        SAFE_PARCEL(data.writeUint32, uid);

        SAFE_PARCEL(data.writeFloat, frameRate);



        status_t err = remote()->transact(BnSurfaceComposer::SET_OVERRIDE_FRAME_RATE, data, &reply);

        if (err != NO_ERROR) {

            ALOGE("setOverrideFrameRate: failed to transact %s (%d)", strerror(-err), err);

            return err;

        }



        return NO_ERROR;

    }

};



// Out-of-line virtual method definition to trigger vtable emission in this
@@ -379,7 +170,7 @@ status_t BnSurfaceComposer::onTransact( 
            CHECK_INTERFACE(ISurfaceComposer, data, reply);



            FrameTimelineInfo frameTimelineInfo;

            SAFE_PARCEL(frameTimelineInfo.read, data);

            frameTimelineInfo.readFromParcel(&data);



            uint32_t count = 0;

            SAFE_PARCEL_READ_SIZE(data.readUint32, &count, data.dataSize());
@@ -444,14 +235,6 @@ status_t BnSurfaceComposer::onTransact( 
            bootFinished();

            return NO_ERROR;

        }

        case AUTHENTICATE_SURFACE: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            sp<IGraphicBufferProducer> bufferProducer =

                    interface_cast<IGraphicBufferProducer>(data.readStrongBinder());

            int32_t result = authenticateSurfaceTexture(bufferProducer) ? 1 : 0;

            reply->writeInt32(result);

            return NO_ERROR;

        }

        case CREATE_DISPLAY_EVENT_CONNECTION: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            auto vsyncSource = static_cast<ISurfaceComposer::VsyncSource>(data.readInt32());
@@ -463,130 +246,6 @@ status_t BnSurfaceComposer::onTransact( 
            reply->writeStrongBinder(IInterface::asBinder(connection));

            return NO_ERROR;

        }

        case GET_DISPLAYED_CONTENT_SAMPLE: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);



            sp<IBinder> display = data.readStrongBinder();

            uint64_t maxFrames = 0;

            uint64_t timestamp = 0;



            status_t result = data.readUint64(&maxFrames);

            if (result != NO_ERROR) {

                ALOGE("getDisplayedContentSample failure in reading max frames: %d", result);

                return result;

            }



            result = data.readUint64(&timestamp);

            if (result != NO_ERROR) {

                ALOGE("getDisplayedContentSample failure in reading timestamp: %d", result);

                return result;

            }



            DisplayedFrameStats stats;

            result = getDisplayedContentSample(display, maxFrames, timestamp, &stats);

            if (result == NO_ERROR) {

                reply->writeUint64(stats.numFrames);

                reply->writeUint64Vector(stats.component_0_sample);

                reply->writeUint64Vector(stats.component_1_sample);

                reply->writeUint64Vector(stats.component_2_sample);

                reply->writeUint64Vector(stats.component_3_sample);

            }

            return result;

        }

        case SET_GLOBAL_SHADOW_SETTINGS: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);



            std::vector<float> shadowConfig;

            status_t error = data.readFloatVector(&shadowConfig);

            if (error != NO_ERROR || shadowConfig.size() != 11) {

                ALOGE("setGlobalShadowSettings: failed to read shadowConfig: %d", error);

                return error;

            }



            half4 ambientColor = {shadowConfig[0], shadowConfig[1], shadowConfig[2],

                                  shadowConfig[3]};

            half4 spotColor = {shadowConfig[4], shadowConfig[5], shadowConfig[6], shadowConfig[7]};

            float lightPosY = shadowConfig[8];

            float lightPosZ = shadowConfig[9];

            float lightRadius = shadowConfig[10];

            return setGlobalShadowSettings(ambientColor, spotColor, lightPosY, lightPosZ,

                                           lightRadius);

        }

        case GET_DISPLAY_DECORATION_SUPPORT: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            sp<IBinder> displayToken;

            SAFE_PARCEL(data.readNullableStrongBinder, &displayToken);

            std::optional<common::DisplayDecorationSupport> support;

            auto error = getDisplayDecorationSupport(displayToken, &support);

            if (error != NO_ERROR) {

                ALOGE("getDisplayDecorationSupport failed with error %d", error);

                return error;

            }

            reply->writeBool(support.has_value());

            if (support) {

                reply->writeInt32(static_cast<int32_t>(support.value().format));

                reply->writeInt32(static_cast<int32_t>(support.value().alphaInterpretation));

            }

            return error;

        }

        case SET_FRAME_RATE: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            sp<IBinder> binder;

            SAFE_PARCEL(data.readStrongBinder, &binder);



            sp<IGraphicBufferProducer> surface = interface_cast<IGraphicBufferProducer>(binder);

            if (!surface) {

                ALOGE("setFrameRate: failed to cast to IGraphicBufferProducer");

                return BAD_VALUE;

            }

            float frameRate;

            SAFE_PARCEL(data.readFloat, &frameRate);



            int8_t compatibility;

            SAFE_PARCEL(data.readByte, &compatibility);



            int8_t changeFrameRateStrategy;

            SAFE_PARCEL(data.readByte, &changeFrameRateStrategy);



            status_t result =

                    setFrameRate(surface, frameRate, compatibility, changeFrameRateStrategy);

            reply->writeInt32(result);

            return NO_ERROR;

        }

        case SET_FRAME_TIMELINE_INFO: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            sp<IBinder> binder;

            status_t err = data.readStrongBinder(&binder);

            if (err != NO_ERROR) {

                ALOGE("setFrameTimelineInfo: failed to read strong binder: %s (%d)", strerror(-err),

                      -err);

                return err;

            }

            sp<IGraphicBufferProducer> surface = interface_cast<IGraphicBufferProducer>(binder);

            if (!surface) {

                ALOGE("setFrameTimelineInfo: failed to cast to IGraphicBufferProducer: %s (%d)",

                      strerror(-err), -err);

                return err;

            }



            FrameTimelineInfo frameTimelineInfo;

            SAFE_PARCEL(frameTimelineInfo.read, data);



            status_t result = setFrameTimelineInfo(surface, frameTimelineInfo);

            reply->writeInt32(result);

            return NO_ERROR;

        }

        case SET_OVERRIDE_FRAME_RATE: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);



            uid_t uid;

            SAFE_PARCEL(data.readUint32, &uid);



            float frameRate;

            SAFE_PARCEL(data.readFloat, &frameRate);



            return setOverrideFrameRate(uid, frameRate);

        }

        default: {

            return BBinder::onTransact(code, data, reply, flags);

        }

libs/gui/Surface.cpp

+20 −22
Original line number Diff line number Diff line
@@ -39,6 +39,7 @@ 
#include <ui/GraphicBuffer.h>

#include <ui/Region.h>



#include <gui/AidlStatusUtil.h>

#include <gui/BufferItem.h>

#include <gui/IProducerListener.h>
@@ -49,6 +50,7 @@ 


namespace android {



using gui::aidl_utils::statusTFromBinderStatus;

using ui::Dataspace;



namespace {
@@ -182,7 +184,7 @@ status_t Surface::getDisplayRefreshCycleDuration(nsecs_t* outRefreshDuration) { 
    gui::DisplayStatInfo stats;

    binder::Status status = composerServiceAIDL()->getDisplayStats(nullptr, &stats);

    if (!status.isOk()) {

        return status.transactionError();

        return statusTFromBinderStatus(status);

    }



    *outRefreshDuration = stats.vsyncPeriod;
@@ -355,7 +357,7 @@ status_t Surface::getWideColorSupport(bool* supported) { 


    *supported = false;

    binder::Status status = composerServiceAIDL()->isWideColorDisplay(display, supported);

    return status.transactionError();

    return statusTFromBinderStatus(status);

}



status_t Surface::getHdrSupport(bool* supported) {
@@ -369,7 +371,7 @@ status_t Surface::getHdrSupport(bool* supported) { 
    gui::DynamicDisplayInfo info;

    if (binder::Status status = composerServiceAIDL()->getDynamicDisplayInfo(display, &info);

        !status.isOk()) {

        return status.transactionError();

        return statusTFromBinderStatus(status);

    }



    *supported = !info.hdrCapabilities.supportedHdrTypes.empty();
@@ -1288,15 +1290,12 @@ int Surface::query(int what, int* value) const { 
                if (err == NO_ERROR) {

                    return NO_ERROR;

                }

                sp<ISurfaceComposer> surfaceComposer = composerService();

                sp<gui::ISurfaceComposer> surfaceComposer = composerServiceAIDL();

                if (surfaceComposer == nullptr) {

                    return -EPERM; // likely permissions error

                }

                if (surfaceComposer->authenticateSurfaceTexture(mGraphicBufferProducer)) {

                    *value = 1;

                } else {

                // ISurfaceComposer no longer supports authenticateSurfaceTexture

                *value = 0;

                }

                return NO_ERROR;

            }

            case NATIVE_WINDOW_CONCRETE_TYPE:
@@ -1868,7 +1867,11 @@ int Surface::dispatchSetFrameTimelineInfo(va_list args) { 
    auto startTimeNanos = static_cast<int64_t>(va_arg(args, int64_t));



    ALOGV("Surface::%s", __func__);

    return setFrameTimelineInfo({frameTimelineVsyncId, inputEventId, startTimeNanos});

    FrameTimelineInfo ftlInfo;

    ftlInfo.vsyncId = frameTimelineVsyncId;

    ftlInfo.inputEventId = inputEventId;

    ftlInfo.startTimeNanos = startTimeNanos;

    return setFrameTimelineInfo(ftlInfo);

}



bool Surface::transformToDisplayInverse() const {
@@ -2624,22 +2627,17 @@ void Surface::ProducerListenerProxy::onBuffersDiscarded(const std::vector<int32_ 
    mSurfaceListener->onBuffersDiscarded(discardedBufs);

}



status_t Surface::setFrameRate(float frameRate, int8_t compatibility,

                               int8_t changeFrameRateStrategy) {

status_t Surface::setFrameRate(float /*frameRate*/, int8_t /*compatibility*/,

                               int8_t /*changeFrameRateStrategy*/) {

    ATRACE_CALL();

    ALOGV("Surface::setFrameRate");



    if (!ValidateFrameRate(frameRate, compatibility, changeFrameRateStrategy,

                           "Surface::setFrameRate")) {

    // ISurfaceComposer no longer supports setFrameRate

    return BAD_VALUE;

}



    return composerService()->setFrameRate(mGraphicBufferProducer, frameRate, compatibility,

                                           changeFrameRateStrategy);

}



status_t Surface::setFrameTimelineInfo(const FrameTimelineInfo& frameTimelineInfo) {

    return composerService()->setFrameTimelineInfo(mGraphicBufferProducer, frameTimelineInfo);

status_t Surface::setFrameTimelineInfo(const FrameTimelineInfo& /*frameTimelineInfo*/) {

    // ISurfaceComposer no longer supports setFrameTimelineInfo

    return BAD_VALUE;

}



sp<IBinder> Surface::getSurfaceControlHandle() const {

libs/gui/SurfaceComposerClient.cpp

+126 −47

File changed.

Preview size limit exceeded, changes collapsed.