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

Commit b8df034c authored by Galia Peycheva's avatar Galia Peycheva
Browse files

Add Auto Low Latency Mode to native framework 

Bug: 132731049

Test: m
Test: atest libsurfaceflinger_unittest
Test: atest libcompositionengine_test
Test: atest libgui_test

Change-Id: Ic79f7456c68d3cb2ddfec2b1cfcf6ec25c1c0a71
parent f39cef4e

libs/gui/ISurfaceComposer.cpp

+151 −0
Original line number Diff line number Diff line
@@ -525,6 +525,88 @@ public: 
        return static_cast<status_t>(reply.readInt32());

    }



    virtual status_t getAutoLowLatencyModeSupport(const sp<IBinder>& display,

                                                  bool* outSupport) const {

        Parcel data, reply;

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

        status_t result = data.writeStrongBinder(display);

        if (result != NO_ERROR) {

            ALOGE("getAutoLowLatencyModeSupport failed to writeStrongBinder: %d", result);

            return result;

        }

        result = remote()->transact(BnSurfaceComposer::GET_AUTO_LOW_LATENCY_MODE_SUPPORT, data,

                                    &reply);

        if (result != NO_ERROR) {

            ALOGE("getAutoLowLatencyModeSupport failed to transact: %d", result);

            return result;

        }

        return reply.readBool(outSupport);

    }



    virtual void setAutoLowLatencyMode(const sp<IBinder>& display, bool on) {

        Parcel data, reply;

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

        if (result != NO_ERROR) {

            ALOGE("setAutoLowLatencyMode failed to writeInterfaceToken: %d", result);

            return;

        }



        result = data.writeStrongBinder(display);

        if (result != NO_ERROR) {

            ALOGE("setAutoLowLatencyMode failed to writeStrongBinder: %d", result);

            return;

        }

        result = data.writeBool(on);

        if (result != NO_ERROR) {

            ALOGE("setAutoLowLatencyMode failed to writeBool: %d", result);

            return;

        }

        result = remote()->transact(BnSurfaceComposer::SET_AUTO_LOW_LATENCY_MODE, data, &reply);

        if (result != NO_ERROR) {

            ALOGE("setAutoLowLatencyMode failed to transact: %d", result);

            return;

        }

    }



    virtual status_t getGameContentTypeSupport(const sp<IBinder>& display, bool* outSupport) const {

        Parcel data, reply;

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

        status_t result = data.writeStrongBinder(display);

        if (result != NO_ERROR) {

            ALOGE("getGameContentTypeSupport failed to writeStrongBinder: %d", result);

            return result;

        }

        result = remote()->transact(BnSurfaceComposer::GET_GAME_CONTENT_TYPE_SUPPORT, data, &reply);

        if (result != NO_ERROR) {

            ALOGE("getGameContentTypeSupport failed to transact: %d", result);

            return result;

        }

        return reply.readBool(outSupport);

    }



    virtual void setGameContentType(const sp<IBinder>& display, bool on) {

        Parcel data, reply;

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

        if (result != NO_ERROR) {

            ALOGE("setGameContentType failed to writeInterfaceToken: %d", result);

            return;

        }

        result = data.writeStrongBinder(display);

        if (result != NO_ERROR) {

            ALOGE("setGameContentType failed to writeStrongBinder: %d", result);

            return;

        }

        result = data.writeBool(on);

        if (result != NO_ERROR) {

            ALOGE("setGameContentType failed to writeBool: %d", result);

            return;

        }

        result = remote()->transact(BnSurfaceComposer::SET_GAME_CONTENT_TYPE, data, &reply);

        if (result != NO_ERROR) {

            ALOGE("setGameContentType failed to transact: %d", result);

        }

    }



    virtual status_t clearAnimationFrameStats() {

        Parcel data, reply;

        status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
@@ -1407,6 +1489,75 @@ status_t BnSurfaceComposer::onTransact( 
            result = reply->writeInt32(result);

            return result;

        }



        case GET_AUTO_LOW_LATENCY_MODE_SUPPORT: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            sp<IBinder> display = nullptr;

            status_t result = data.readStrongBinder(&display);

            if (result != NO_ERROR) {

                ALOGE("getAutoLowLatencyModeSupport failed to readStrongBinder: %d", result);

                return result;

            }

            bool supported = false;

            result = getAutoLowLatencyModeSupport(display, &supported);

            if (result == NO_ERROR) {

                result = reply->writeBool(supported);

            }

            return result;

        }



        case SET_AUTO_LOW_LATENCY_MODE: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            sp<IBinder> display = nullptr;

            status_t result = data.readStrongBinder(&display);

            if (result != NO_ERROR) {

                ALOGE("setAutoLowLatencyMode failed to readStrongBinder: %d", result);

                return result;

            }

            bool setAllm = false;

            result = data.readBool(&setAllm);

            if (result != NO_ERROR) {

                ALOGE("setAutoLowLatencyMode failed to readBool: %d", result);

                return result;

            }

            setAutoLowLatencyMode(display, setAllm);

            return result;

        }



        case GET_GAME_CONTENT_TYPE_SUPPORT: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            sp<IBinder> display = nullptr;

            status_t result = data.readStrongBinder(&display);

            if (result != NO_ERROR) {

                ALOGE("getGameContentTypeSupport failed to readStrongBinder: %d", result);

                return result;

            }

            bool supported = false;

            result = getGameContentTypeSupport(display, &supported);

            if (result == NO_ERROR) {

                result = reply->writeBool(supported);

            }

            return result;

        }



        case SET_GAME_CONTENT_TYPE: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            sp<IBinder> display = nullptr;

            status_t result = data.readStrongBinder(&display);

            if (result != NO_ERROR) {

                ALOGE("setGameContentType failed to readStrongBinder: %d", result);

                return result;

            }

            bool setGameContentTypeOn = false;

            result = data.readBool(&setGameContentTypeOn);

            if (result != NO_ERROR) {

                ALOGE("setGameContentType failed to readBool: %d", result);

                return result;

            }

            setGameContentType(display, setGameContentTypeOn);

            return result;

        }



        case CLEAR_ANIMATION_FRAME_STATS: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            status_t result = clearAnimationFrameStats();

libs/gui/SurfaceComposerClient.cpp

+20 −0
Original line number Diff line number Diff line
@@ -1656,6 +1656,26 @@ status_t SurfaceComposerClient::setActiveColorMode(const sp<IBinder>& display, 
    return ComposerService::getComposerService()->setActiveColorMode(display, colorMode);

}



bool SurfaceComposerClient::getAutoLowLatencyModeSupport(const sp<IBinder>& display) {

    bool supported = false;

    ComposerService::getComposerService()->getAutoLowLatencyModeSupport(display, &supported);

    return supported;

}



void SurfaceComposerClient::setAutoLowLatencyMode(const sp<IBinder>& display, bool on) {

    ComposerService::getComposerService()->setAutoLowLatencyMode(display, on);

}



bool SurfaceComposerClient::getGameContentTypeSupport(const sp<IBinder>& display) {

    bool supported = false;

    ComposerService::getComposerService()->getGameContentTypeSupport(display, &supported);

    return supported;

}



void SurfaceComposerClient::setGameContentType(const sp<IBinder>& display, bool on) {

    ComposerService::getComposerService()->setGameContentType(display, on);

}



void SurfaceComposerClient::setDisplayPowerMode(const sp<IBinder>& token,

        int mode) {

    ComposerService::getComposerService()->setPowerMode(token, mode);

libs/gui/include/gui/ISurfaceComposer.h

+35 −0
Original line number Diff line number Diff line
@@ -194,6 +194,37 @@ public: 
    virtual status_t setActiveColorMode(const sp<IBinder>& display,

            ui::ColorMode colorMode) = 0;



    /**

     * Returns true if the connected display reports support for HDMI 2.1 Auto

     * Low Latency Mode.

     * For more information, see the HDMI 2.1 specification.

     */

    virtual status_t getAutoLowLatencyModeSupport(const sp<IBinder>& display,

                                                  bool* outSupport) const = 0;



    /**

     * Switches Auto Low Latency Mode on/off on the connected display, if it is

     * available. This should only be called if #getAutoLowLatencyMode returns

     * true.

     * For more information, see the HDMI 2.1 specification.

     */

    virtual void setAutoLowLatencyMode(const sp<IBinder>& display, bool on) = 0;



    /**

     * Returns true if the connected display reports support for Game Content Type.

     * For more information, see the HDMI 1.4 specification.

     */

    virtual status_t getGameContentTypeSupport(const sp<IBinder>& display,

                                               bool* outSupport) const = 0;



    /**

     * This will start sending infoframes to the connected display with

     * ContentType=Game (if on=true). This will switch the disply to Game mode.

     * This should only be called if #getGameContentTypeSupport returns true.

     * For more information, see the HDMI 1.4 specification.

     */

    virtual void setGameContentType(const sp<IBinder>& display, bool on) = 0;



    /**

     * Capture the specified screen. This requires READ_FRAME_BUFFER

     * permission.  This function will fail if there is a secure window on
@@ -532,6 +563,10 @@ public: 
        CAPTURE_SCREEN_BY_ID,

        NOTIFY_POWER_HINT,

        SET_GLOBAL_SHADOW_SETTINGS,

        GET_AUTO_LOW_LATENCY_MODE_SUPPORT,

        SET_AUTO_LOW_LATENCY_MODE,

        GET_GAME_CONTENT_TYPE_SUPPORT,

        SET_GAME_CONTENT_TYPE,

        // Always append new enum to the end.

    };

libs/gui/include/gui/SurfaceComposerClient.h

+15 −0
Original line number Diff line number Diff line
@@ -160,6 +160,21 @@ public: 
    static status_t setActiveColorMode(const sp<IBinder>& display,

            ui::ColorMode colorMode);



    // Reports whether the connected display supports Auto Low Latency Mode

    static bool getAutoLowLatencyModeSupport(const sp<IBinder>& display);



    // Switches on/off Auto Low Latency Mode on the connected display. This should only be

    // called if the connected display supports Auto Low Latency Mode as reported by

    // #getAutoLowLatencyModeSupport

    static void setAutoLowLatencyMode(const sp<IBinder>& display, bool on);



    // Reports whether the connected display supports Game content type

    static bool getGameContentTypeSupport(const sp<IBinder>& display);



    // Turns Game mode on/off on the connected display. This should only be called

    // if the display supports Game content type, as reported by #getGameContentTypeSupport

    static void setGameContentType(const sp<IBinder>& display, bool on);



    /* Triggers screen on/off or low power mode and waits for it to complete */

    static void setDisplayPowerMode(const sp<IBinder>& display, int mode);

libs/gui/tests/Surface_test.cpp

+10 −0
Original line number Diff line number Diff line
@@ -750,6 +750,16 @@ public: 
                           bool /*captureSecureLayers*/) override {

        return NO_ERROR;

    }

    status_t getAutoLowLatencyModeSupport(const sp<IBinder>& /*display*/,

                                          bool* /*outSupport*/) const override {

        return NO_ERROR;

    }

    void setAutoLowLatencyMode(const sp<IBinder>& /*display*/, bool /*on*/) override {}

    status_t getGameContentTypeSupport(const sp<IBinder>& /*display*/,

                                       bool* /*outSupport*/) const override {

        return NO_ERROR;

    }

    void setGameContentType(const sp<IBinder>& /*display*/, bool /*on*/) override {}

    status_t captureScreen(uint64_t /*displayOrLayerStack*/, ui::Dataspace* /*outDataspace*/,

                           sp<GraphicBuffer>* /*outBuffer*/) override {

        return NO_ERROR;