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

Commit 9312aa2b authored by Dominik Laskowski's avatar Dominik Laskowski Committed by Android (Google) Code Review
Browse files

Merge changes I2eb6fe92,Ifa1a1f67 into main 

* changes:
  SF: Dispatch frame rate overrides to pacesetter
  SF: Remove fallback for outdated active display
parents 46a7a619 1d7be06c

services/surfaceflinger/Scheduler/ISchedulerCallback.h

+0 −1
Original line number Diff line number Diff line
@@ -28,7 +28,6 @@ struct ISchedulerCallback { 
    virtual void requestHardwareVsync(PhysicalDisplayId, bool enabled) = 0;

    virtual void requestDisplayModes(std::vector<display::DisplayModeRequest>) = 0;

    virtual void kernelTimerChanged(bool expired) = 0;

    virtual void triggerOnFrameRateOverridesChanged() = 0;

    virtual void onChoreographerAttached() = 0;

    virtual void onExpectedPresentTimePosted(TimePoint, ftl::NonNull<DisplayModePtr>,

                                             Fps renderRate) = 0;

services/surfaceflinger/Scheduler/Scheduler.cpp

+21 −8
Original line number Diff line number Diff line
@@ -403,14 +403,20 @@ void Scheduler::enableSyntheticVsync(bool enable) { 
    eventThreadFor(Cycle::Render).enableSyntheticVsync(enable);

}



void Scheduler::onFrameRateOverridesChanged(Cycle cycle, PhysicalDisplayId displayId) {

    const bool supportsFrameRateOverrideByContent =

            pacesetterSelectorPtr()->supportsAppFrameRateOverrideByContent();

void Scheduler::onFrameRateOverridesChanged() {

    const auto [pacesetterId, supportsFrameRateOverrideByContent] = [this] {

        std::scoped_lock lock(mDisplayLock);

        const auto pacesetterOpt = pacesetterDisplayLocked();

        LOG_ALWAYS_FATAL_IF(!pacesetterOpt);

        const Display& pacesetter = *pacesetterOpt;

        return std::make_pair(FTL_FAKE_GUARD(kMainThreadContext, *mPacesetterDisplayId),

                              pacesetter.selectorPtr->supportsAppFrameRateOverrideByContent());

    }();



    std::vector<FrameRateOverride> overrides =

            mFrameRateOverrideMappings.getAllFrameRateOverrides(supportsFrameRateOverrideByContent);



    eventThreadFor(cycle).onFrameRateOverridesChanged(displayId, std::move(overrides));

    eventThreadFor(Cycle::Render).onFrameRateOverridesChanged(pacesetterId, std::move(overrides));

}



void Scheduler::onHdcpLevelsChanged(Cycle cycle, PhysicalDisplayId displayId,
@@ -907,9 +913,13 @@ void Scheduler::dumpVsync(std::string& out) const { 
    }

}



bool Scheduler::updateFrameRateOverrides(GlobalSignals consideredSignals, Fps displayRefreshRate) {

    std::scoped_lock lock(mPolicyLock);

    return updateFrameRateOverridesLocked(consideredSignals, displayRefreshRate);

void Scheduler::updateFrameRateOverrides(GlobalSignals consideredSignals, Fps displayRefreshRate) {

    const bool changed = (std::scoped_lock(mPolicyLock),

                          updateFrameRateOverridesLocked(consideredSignals, displayRefreshRate));



    if (changed) {

        onFrameRateOverridesChanged();

    }

}



bool Scheduler::updateFrameRateOverridesLocked(GlobalSignals consideredSignals,
@@ -1157,7 +1167,7 @@ auto Scheduler::applyPolicy(S Policy::*statePtr, T&& newState) -> GlobalSignals 
                updateFrameRateOverridesLocked(consideredSignals, mPolicy.modeOpt->fps);

    }

    if (frameRateOverridesChanged) {

        mSchedulerCallback.triggerOnFrameRateOverridesChanged();

        onFrameRateOverridesChanged();

    }

    return consideredSignals;

}
@@ -1257,6 +1267,8 @@ void Scheduler::setGameModeFrameRateForUid(FrameRateOverride frameRateOverride) 
    } else {

        mFrameRateOverrideMappings.setGameModeRefreshRateForUid(frameRateOverride);

    }



    onFrameRateOverridesChanged();

}



void Scheduler::setGameDefaultFrameRateForUid(FrameRateOverride frameRateOverride) {
@@ -1275,6 +1287,7 @@ void Scheduler::setPreferredRefreshRateForUid(FrameRateOverride frameRateOverrid 
    }



    mFrameRateOverrideMappings.setPreferredRefreshRateForUid(frameRateOverride);

    onFrameRateOverridesChanged();

}



void Scheduler::updateSmallAreaDetection(

services/surfaceflinger/Scheduler/Scheduler.h

+4 −3
Original line number Diff line number Diff line
@@ -159,8 +159,6 @@ public: 


    void enableSyntheticVsync(bool = true) REQUIRES(kMainThreadContext);



    void onFrameRateOverridesChanged(Cycle, PhysicalDisplayId);



    void onHdcpLevelsChanged(Cycle, PhysicalDisplayId, int32_t, int32_t);



    // Modifies work duration in the event thread.
@@ -326,7 +324,7 @@ public: 
        return mLayerHistory.getLayerFramerate(now, id);

    }



    bool updateFrameRateOverrides(GlobalSignals, Fps displayRefreshRate) EXCLUDES(mPolicyLock);

    void updateFrameRateOverrides(GlobalSignals, Fps displayRefreshRate) EXCLUDES(mPolicyLock);



    // Returns true if the small dirty detection is enabled for the appId.

    bool supportSmallDirtyDetection(int32_t appId) {
@@ -450,6 +448,9 @@ private: 


    bool updateFrameRateOverridesLocked(GlobalSignals, Fps displayRefreshRate)

            REQUIRES(mPolicyLock);



    void onFrameRateOverridesChanged();



    void updateAttachedChoreographers(const surfaceflinger::frontend::LayerHierarchy&,

                                      Fps displayRefreshRate);

    int updateAttachedChoreographersInternal(const surfaceflinger::frontend::LayerHierarchy&,

services/surfaceflinger/SurfaceFlinger.cpp

+7 −29
Original line number Diff line number Diff line
@@ -911,9 +911,11 @@ void SurfaceFlinger::init() FTL_FAKE_GUARD(kMainThreadContext) { 
    LOG_ALWAYS_FATAL_IF(!configureLocked(),

                        "Initial display configuration failed: HWC did not hotplug");



    mActiveDisplayId = getPrimaryDisplayIdLocked();



    // Commit primary display.

    sp<const DisplayDevice> display;

    if (const auto indexOpt = mCurrentState.getDisplayIndex(getPrimaryDisplayIdLocked())) {

    if (const auto indexOpt = mCurrentState.getDisplayIndex(mActiveDisplayId)) {

        const auto& displays = mCurrentState.displays;



        const auto& token = displays.keyAt(*indexOpt);
@@ -4178,15 +4180,6 @@ void SurfaceFlinger::requestDisplayModes(std::vector<display::DisplayModeRequest 
    }

}



void SurfaceFlinger::triggerOnFrameRateOverridesChanged() {

    PhysicalDisplayId displayId = [&]() {

        ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);

        return getDefaultDisplayDeviceLocked()->getPhysicalId();

    }();



    mScheduler->onFrameRateOverridesChanged(scheduler::Cycle::Render, displayId);

}



void SurfaceFlinger::notifyCpuLoadUp() {

    mPowerAdvisor->notifyCpuLoadUp();

}
@@ -6769,15 +6762,9 @@ status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* r 
                return NO_ERROR;

            }

            case 1039: {

                PhysicalDisplayId displayId = [&]() {

                    Mutex::Autolock lock(mStateLock);

                    return getDefaultDisplayDeviceLocked()->getPhysicalId();

                }();



                auto inUid = static_cast<uid_t>(data.readInt32());

                const auto uid = static_cast<uid_t>(data.readInt32());

                const auto refreshRate = data.readFloat();

                mScheduler->setPreferredRefreshRateForUid(FrameRateOverride{inUid, refreshRate});

                mScheduler->onFrameRateOverridesChanged(scheduler::Cycle::Render, displayId);

                mScheduler->setPreferredRefreshRateForUid(FrameRateOverride{uid, refreshRate});

                return NO_ERROR;

            }

            // Toggle caching feature
@@ -8000,10 +7987,7 @@ status_t SurfaceFlinger::applyRefreshRateSelectorPolicy( 
    setDesiredMode({std::move(preferredMode), .emitEvent = true});



    // Update the frameRateOverride list as the display render rate might have changed

    if (mScheduler->updateFrameRateOverrides(scheduler::GlobalSignals{}, preferredFps)) {

        triggerOnFrameRateOverridesChanged();

    }



    mScheduler->updateFrameRateOverrides(scheduler::GlobalSignals{}, preferredFps);

    return NO_ERROR;

}
@@ -8163,13 +8147,7 @@ const std::unordered_map<std::string, uint32_t>& SurfaceFlinger::getGenericLayer 
}



status_t SurfaceFlinger::setGameModeFrameRateOverride(uid_t uid, float frameRate) {

    PhysicalDisplayId displayId = [&]() {

        Mutex::Autolock lock(mStateLock);

        return getDefaultDisplayDeviceLocked()->getPhysicalId();

    }();



    mScheduler->setGameModeFrameRateForUid(FrameRateOverride{static_cast<uid_t>(uid), frameRate});

    mScheduler->onFrameRateOverridesChanged(scheduler::Cycle::Render, displayId);

    mScheduler->setGameModeFrameRateForUid(FrameRateOverride{uid, frameRate});

    return NO_ERROR;

}

services/surfaceflinger/SurfaceFlinger.h

+2 −9
Original line number Diff line number Diff line
@@ -697,7 +697,6 @@ private: 
    void requestHardwareVsync(PhysicalDisplayId, bool) override;

    void requestDisplayModes(std::vector<display::DisplayModeRequest>) override;

    void kernelTimerChanged(bool expired) override;

    void triggerOnFrameRateOverridesChanged() override;

    void onChoreographerAttached() override;

    void onExpectedPresentTimePosted(TimePoint expectedPresentTime, ftl::NonNull<DisplayModePtr>,

                                     Fps renderRate) override;
@@ -963,18 +962,12 @@ private: 
        return nullptr;

    }



    // Returns the primary display or (for foldables) the active display, assuming that the inner

    // and outer displays have mutually exclusive power states.

    // Returns the primary display or (for foldables) the active display.

    sp<const DisplayDevice> getDefaultDisplayDeviceLocked() const REQUIRES(mStateLock) {

        return const_cast<SurfaceFlinger*>(this)->getDefaultDisplayDeviceLocked();

    }



    sp<DisplayDevice> getDefaultDisplayDeviceLocked() REQUIRES(mStateLock) {

        if (const auto display = getDisplayDeviceLocked(mActiveDisplayId)) {

            return display;

        }

        // The active display is outdated, so fall back to the primary display.

        mActiveDisplayId = getPrimaryDisplayIdLocked();

        return getDisplayDeviceLocked(mActiveDisplayId);

    }
@@ -1315,7 +1308,7 @@ private: 


    display::PhysicalDisplays mPhysicalDisplays GUARDED_BY(mStateLock);



    // The inner or outer display for foldables, assuming they have mutually exclusive power states.

    // The inner or outer display for foldables, while unfolded or folded, respectively.

    std::atomic<PhysicalDisplayId> mActiveDisplayId;



    display::DisplayModeController mDisplayModeController;