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

Commit e2946321 authored by Ady Abraham's avatar Ady Abraham Committed by Android Build Coastguard Worker
Browse files

SF: add a new behaviour for idle timer on VRR 

When idle timer times out on VRR, change the refresh rate
indicator to show "- -". The render rate doesn't cange as a result
of idleness.

Bug: 333443503
Test: manual
Flag: EXEMPT bugfix
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:eba039c2d28646c5064a9a952faaba0cff6350cb)
Merged-In: Ie4f51a2a9da1a5e229b3504881117b12f1fd1b6a
Change-Id: Ie4f51a2a9da1a5e229b3504881117b12f1fd1b6a
parent f8cc08fa

services/surfaceflinger/DisplayDevice.cpp

+6 −0
Original line number Diff line number Diff line
@@ -467,6 +467,12 @@ bool DisplayDevice::onKernelTimerChanged(std::optional<DisplayModeId> desiredMod 
    return false;

}



void DisplayDevice::onVrrIdle(bool idle) {

    if (mRefreshRateOverlay) {

        mRefreshRateOverlay->onVrrIdle(idle);

    }

}



void DisplayDevice::animateOverlay() {

    if (mRefreshRateOverlay) {

        mRefreshRateOverlay->animate();

services/surfaceflinger/DisplayDevice.h

+1 −0
Original line number Diff line number Diff line
@@ -196,6 +196,7 @@ public: 
    bool isRefreshRateOverlayEnabled() const { return mRefreshRateOverlay != nullptr; }

    void animateOverlay();

    bool onKernelTimerChanged(std::optional<DisplayModeId>, bool timerExpired);

    void onVrrIdle(bool idle);



    // Enables an overlay to be display with the hdr/sdr ratio

    void enableHdrSdrRatioOverlay(bool enable) REQUIRES(kMainThreadContext);

services/surfaceflinger/RefreshRateOverlay.cpp

+38 −12
Original line number Diff line number Diff line
@@ -28,10 +28,11 @@ 


namespace android {



auto RefreshRateOverlay::draw(int refreshRate, int renderFps, SkColor color,

auto RefreshRateOverlay::draw(int refreshRate, int renderFps, bool idle, SkColor color,

                              ui::Transform::RotationFlags rotation, ftl::Flags<Features> features)

        -> Buffers {

    const size_t loopCount = features.test(Features::Spinner) ? 6 : 1;

    const bool isSetByHwc = features.test(Features::SetByHwc);



    Buffers buffers;

    buffers.reserve(loopCount);
@@ -71,7 +72,11 @@ auto RefreshRateOverlay::draw(int refreshRate, int renderFps, SkColor color, 
        canvas->setMatrix(canvasTransform);



        int left = 0;

        if (idle && !isSetByHwc) {

            drawDash(left, *canvas);

        } else {

            drawNumber(refreshRate, left, color, *canvas);

        }

        left += 3 * (kDigitWidth + kDigitSpace);

        if (features.test(Features::Spinner)) {

            switch (i) {
@@ -104,8 +109,12 @@ auto RefreshRateOverlay::draw(int refreshRate, int renderFps, SkColor color, 
        left += kDigitWidth + kDigitSpace;



        if (features.test(Features::RenderRate)) {

            if (idle) {

                drawDash(left, *canvas);

            } else {

                drawNumber(renderFps, left, color, *canvas);

            }

        }

        left += 3 * (kDigitWidth + kDigitSpace);



        void* pixels = nullptr;
@@ -138,6 +147,14 @@ void RefreshRateOverlay::drawNumber(int number, int left, SkColor color, SkCanva 
    SegmentDrawer::drawDigit(number % 10, left, color, canvas);

}



void RefreshRateOverlay::drawDash(int left, SkCanvas& canvas) {

    left += kDigitWidth + kDigitSpace;

    SegmentDrawer::drawSegment(SegmentDrawer::Segment::Middle, left, SK_ColorRED, canvas);



    left += kDigitWidth + kDigitSpace;

    SegmentDrawer::drawSegment(SegmentDrawer::Segment::Middle, left, SK_ColorRED, canvas);

}



std::unique_ptr<RefreshRateOverlay> RefreshRateOverlay::create(FpsRange range,

                                                               ftl::Flags<Features> features) {

    std::unique_ptr<RefreshRateOverlay> overlay =
@@ -171,7 +188,8 @@ bool RefreshRateOverlay::initCheck() const { 
    return mSurfaceControl != nullptr;

}



auto RefreshRateOverlay::getOrCreateBuffers(Fps refreshRate, Fps renderFps) -> const Buffers& {

auto RefreshRateOverlay::getOrCreateBuffers(Fps refreshRate, Fps renderFps, bool idle)

        -> const Buffers& {

    static const Buffers kNoBuffers;

    if (!mSurfaceControl) return kNoBuffers;
@@ -197,8 +215,8 @@ auto RefreshRateOverlay::getOrCreateBuffers(Fps refreshRate, Fps renderFps) -> c 


    createTransaction().setTransform(mSurfaceControl->get(), transform).apply();



    BufferCache::const_iterator it =

            mBufferCache.find({refreshRate.getIntValue(), renderFps.getIntValue(), transformHint});

    BufferCache::const_iterator it = mBufferCache.find(

            {refreshRate.getIntValue(), renderFps.getIntValue(), transformHint, idle});

    if (it == mBufferCache.end()) {

        const int maxFps = mFpsRange.max.getIntValue();
@@ -222,10 +240,10 @@ auto RefreshRateOverlay::getOrCreateBuffers(Fps refreshRate, Fps renderFps) -> c 


        const SkColor color = colorBase.toSkColor();



        auto buffers = draw(refreshIntFps, renderIntFps, color, transformHint, mFeatures);

        auto buffers = draw(refreshIntFps, renderIntFps, idle, color, transformHint, mFeatures);

        it = mBufferCache

                     .try_emplace({refreshIntFps, renderIntFps, transformHint}, std::move(buffers))

                     .first;

                     .try_emplace({refreshIntFps, renderIntFps, transformHint, idle},

                     std::move(buffers)).first;

    }



    return it->second;
@@ -257,7 +275,15 @@ void RefreshRateOverlay::setLayerStack(ui::LayerStack stack) { 
void RefreshRateOverlay::changeRefreshRate(Fps refreshRate, Fps renderFps) {

    mRefreshRate = refreshRate;

    mRenderFps = renderFps;

    const auto buffer = getOrCreateBuffers(refreshRate, renderFps)[mFrame];

    const auto buffer = getOrCreateBuffers(refreshRate, renderFps, mIsVrrIdle)[mFrame];

    createTransaction().setBuffer(mSurfaceControl->get(), buffer).apply();

}



void RefreshRateOverlay::onVrrIdle(bool idle) {

    mIsVrrIdle = idle;

    if (!mRefreshRate || !mRenderFps) return;



    const auto buffer = getOrCreateBuffers(*mRefreshRate, *mRenderFps, mIsVrrIdle)[mFrame];

    createTransaction().setBuffer(mSurfaceControl->get(), buffer).apply();

}
@@ -265,7 +291,7 @@ void RefreshRateOverlay::changeRenderRate(Fps renderFps) { 
    if (mFeatures.test(Features::RenderRate) && mRefreshRate &&

        FlagManager::getInstance().misc1()) {

        mRenderFps = renderFps;

        const auto buffer = getOrCreateBuffers(*mRefreshRate, renderFps)[mFrame];

        const auto buffer = getOrCreateBuffers(*mRefreshRate, renderFps, mIsVrrIdle)[mFrame];

        createTransaction().setBuffer(mSurfaceControl->get(), buffer).apply();

    }

}
@@ -273,7 +299,7 @@ void RefreshRateOverlay::changeRenderRate(Fps renderFps) { 
void RefreshRateOverlay::animate() {

    if (!mFeatures.test(Features::Spinner) || !mRefreshRate) return;



    const auto& buffers = getOrCreateBuffers(*mRefreshRate, *mRenderFps);

    const auto& buffers = getOrCreateBuffers(*mRefreshRate, *mRenderFps, mIsVrrIdle);

    mFrame = (mFrame + 1) % buffers.size();

    const auto buffer = buffers[mFrame];

    createTransaction().setBuffer(mSurfaceControl->get(), buffer).apply();

services/surfaceflinger/RefreshRateOverlay.h

+8 −4
Original line number Diff line number Diff line
@@ -57,6 +57,7 @@ public: 
    void changeRenderRate(Fps);

    void animate();

    bool isSetByHwc() const { return mFeatures.test(RefreshRateOverlay::Features::SetByHwc); }

    void onVrrIdle(bool idle);



    RefreshRateOverlay(ConstructorTag, FpsRange, ftl::Flags<Features>);
@@ -65,11 +66,12 @@ private: 


    using Buffers = std::vector<sp<GraphicBuffer>>;



    static Buffers draw(int refreshRate, int renderFps, SkColor, ui::Transform::RotationFlags,

                        ftl::Flags<Features>);

    static Buffers draw(int refreshRate, int renderFps, bool idle, SkColor,

                        ui::Transform::RotationFlags, ftl::Flags<Features>);

    static void drawNumber(int number, int left, SkColor, SkCanvas&);

    static void drawDash(int left, SkCanvas&);



    const Buffers& getOrCreateBuffers(Fps, Fps);

    const Buffers& getOrCreateBuffers(Fps, Fps, bool);



    SurfaceComposerClient::Transaction createTransaction() const;
@@ -77,10 +79,11 @@ private: 
        int refreshRate;

        int renderFps;

        ui::Transform::RotationFlags flags;

        bool idle;



        bool operator==(Key other) const {

            return refreshRate == other.refreshRate && renderFps == other.renderFps &&

                    flags == other.flags;

                    flags == other.flags && idle == other.idle;

        }

    };
@@ -89,6 +92,7 @@ private: 


    std::optional<Fps> mRefreshRate;

    std::optional<Fps> mRenderFps;

    bool mIsVrrIdle = false;

    size_t mFrame = 0;



    const FpsRange mFpsRange; // For color interpolation.

services/surfaceflinger/Scheduler/ISchedulerCallback.h

+1 −0
Original line number Diff line number Diff line
@@ -33,6 +33,7 @@ struct ISchedulerCallback { 
    virtual void onExpectedPresentTimePosted(TimePoint, ftl::NonNull<DisplayModePtr>,

                                             Fps renderRate) = 0;

    virtual void onCommitNotComposited(PhysicalDisplayId pacesetterDisplayId) = 0;

    virtual void vrrDisplayIdle(bool idle) = 0;



protected:

    ~ISchedulerCallback() = default;