Merge "[SF] Update onModeChanged to send appVsyncOffset [SF] Update onModeChanged to send presentationDeadline" into main

Author: RamIndani

libs/gui/Choreographer.cpp

@@ -349,7 +349,8 @@ void Choreographer::dispatchHotplugConnectionError(nsecs_t, int32_t connectionEr
           this, connectionError);
 }
 
-void Choreographer::dispatchModeChanged(nsecs_t, PhysicalDisplayId, int32_t, nsecs_t) {
+void Choreographer::dispatchModeChanged(nsecs_t, PhysicalDisplayId, int32_t, nsecs_t, nsecs_t,
+                                        nsecs_t) {
     LOG_ALWAYS_FATAL("dispatchModeChanged was called but was never registered");
 }
 

libs/gui/DisplayEventDispatcher.cpp

@@ -194,7 +194,9 @@ bool DisplayEventDispatcher::processPendingEvents(nsecs_t* outTimestamp,
                     break;
                 case DisplayEventType::DISPLAY_EVENT_MODE_CHANGE:
                     dispatchModeChanged(ev.header.timestamp, ev.header.displayId,
-                                        ev.modeChange.modeId, ev.modeChange.vsyncPeriod);
+                                        ev.modeChange.modeId, ev.modeChange.vsyncPeriod,
+                                        ev.modeChange.appVsyncOffset,
+                                        ev.modeChange.presentationDeadline);
                     break;
                 case DisplayEventType::DISPLAY_EVENT_NULL:
                     dispatchNullEvent(ev.header.timestamp, ev.header.displayId);

libs/gui/include/gui/Choreographer.h

@@ -123,7 +123,8 @@ class Choreographer : public DisplayEventDispatcher, public MessageHandler {
     void dispatchHotplug(nsecs_t timestamp, PhysicalDisplayId displayId, bool connected) override;
     void dispatchHotplugConnectionError(nsecs_t timestamp, int32_t connectionError) override;
     void dispatchModeChanged(nsecs_t timestamp, PhysicalDisplayId displayId, int32_t modeId,
-                             nsecs_t vsyncPeriod) override;
+                             nsecs_t vsyncPeriod, nsecs_t appVsyncOffset,
+                             nsecs_t presentationDeadline) override;
     void dispatchNullEvent(nsecs_t, PhysicalDisplayId) override;
     void dispatchFrameRateOverrides(nsecs_t timestamp, PhysicalDisplayId displayId,
                                     std::vector<FrameRateOverride> overrides) override;

libs/gui/include/gui/DisplayEventDispatcher.h

@@ -59,7 +59,8 @@ class DisplayEventDispatcher : public LooperCallback {
     virtual void dispatchHotplugConnectionError(nsecs_t timestamp, int32_t connectionError) = 0;
 
     virtual void dispatchModeChanged(nsecs_t timestamp, PhysicalDisplayId displayId, int32_t modeId,
-                                     nsecs_t vsyncPeriod) = 0;
+                                     nsecs_t vsyncPeriod, nsecs_t appVsyncOffset,
+                                     nsecs_t presentationDeadline) = 0;
     // AChoreographer-specific hook for processing null-events so that looper
     // can be properly poked.
     virtual void dispatchNullEvent(nsecs_t timestamp, PhysicalDisplayId displayId) = 0;

libs/gui/include/gui/DisplayEventReceiver.h

@@ -95,6 +95,8 @@ class DisplayEventReceiver {
         struct ModeChange {
             int32_t modeId;
             nsecs_t vsyncPeriod __attribute__((aligned(8)));
+            nsecs_t appVsyncOffset __attribute__((aligned(8)));
+            nsecs_t presentationDeadline __attribute__((aligned(8)));
         };
 
         struct ModeRejection {

libs/gui/tests/DisplayEventStructLayout_test.cpp

@@ -64,6 +64,8 @@ TEST(DisplayEventStructLayoutTest, TestEventAlignment) {
 
     CHECK_OFFSET(DisplayEventReceiver::Event::ModeChange, modeId, 0);
     CHECK_OFFSET(DisplayEventReceiver::Event::ModeChange, vsyncPeriod, 8);
+    CHECK_OFFSET(DisplayEventReceiver::Event::ModeChange, appVsyncOffset, 16);
+    CHECK_OFFSET(DisplayEventReceiver::Event::ModeChange, presentationDeadline, 24);
 
     CHECK_OFFSET(DisplayEventReceiver::Event::FrameRateOverride, uid, 0);
     CHECK_OFFSET(DisplayEventReceiver::Event::FrameRateOverride, frameRateHz, 8);

services/surfaceflinger/Scheduler/EventThread.cpp

@@ -42,6 +42,7 @@
 
 #include <utils/Errors.h>
 
+#include <Scheduler/Scheduler.h>
 #include <common/FlagManager.h>
 #include <scheduler/FrameRateMode.h>
 #include <scheduler/VsyncConfig.h>
@@ -96,8 +97,11 @@ std::string toString(const DisplayEventReceiver::Event& event) {
                                 to_string(event.header.displayId).c_str(), event.vsync.count,
                                 event.vsync.vsyncData.preferredExpectedPresentationTime());
         case DisplayEventType::DISPLAY_EVENT_MODE_CHANGE:
-            return StringPrintf("ModeChanged{displayId=%s, modeId=%u}",
-                                to_string(event.header.displayId).c_str(), event.modeChange.modeId);
+            return StringPrintf("ModeChanged{displayId=%s, modeId=%u, appVsyncOffset=%" PRId64
+                                ", presentationDeadline=%" PRId64 "}",
+                                to_string(event.header.displayId).c_str(), event.modeChange.modeId,
+                                event.modeChange.appVsyncOffset,
+                                event.modeChange.presentationDeadline);
         case DisplayEventType::DISPLAY_EVENT_HDCP_LEVELS_CHANGE:
             return StringPrintf("HdcpLevelsChange{displayId=%s, connectedLevel=%d, maxLevel=%d}",
                                 to_string(event.header.displayId).c_str(),
@@ -153,12 +157,17 @@ DisplayEventReceiver::Event makeVSync(PhysicalDisplayId displayId, nsecs_t times
     return event;
 }
 
-DisplayEventReceiver::Event makeModeChanged(const scheduler::FrameRateMode& mode) {
+DisplayEventReceiver::Event makeModeChanged(const scheduler::FrameRateMode& mode,
+                                            scheduler::VsyncConfigSet config) {
     DisplayEventReceiver::Event event;
     event.header = {DisplayEventType::DISPLAY_EVENT_MODE_CHANGE,
                     mode.modePtr->getPhysicalDisplayId(), systemTime()};
     event.modeChange.modeId = ftl::to_underlying(mode.modePtr->getId());
     event.modeChange.vsyncPeriod = mode.fps.getPeriodNsecs();
+    event.modeChange.appVsyncOffset = config.late.appOffset;
+    event.modeChange.presentationDeadline =
+            scheduler::Scheduler::getPresentationDeadline(mode.fps,
+                                                          Duration::fromNs(config.late.sfOffset));
     return event;
 }
 
@@ -478,10 +487,11 @@ void EventThread::onHotplugConnectionError(int32_t errorCode) {
     mCondition.notify_all();
 }
 
-void EventThread::onModeChanged(const scheduler::FrameRateMode& mode) {
+void EventThread::onModeChanged(const scheduler::FrameRateMode& mode,
+                                scheduler::VsyncConfigSet config) {
     std::lock_guard<std::mutex> lock(mMutex);
 
-    mPendingEvents.push_back(makeModeChanged(mode));
+    mPendingEvents.push_back(makeModeChanged(mode, config));
     mCondition.notify_all();
 }
 

services/surfaceflinger/Scheduler/EventThread.h

@@ -25,6 +25,7 @@
 #include <utils/Errors.h>
 
 #include <scheduler/FrameRateMode.h>
+#include <scheduler/VsyncConfig.h>
 #include <condition_variable>
 #include <cstdint>
 #include <deque>
@@ -113,8 +114,9 @@ class EventThread {
 
     virtual void onHotplugConnectionError(int32_t connectionError) = 0;
 
-    // called when SF changes the active mode and apps needs to be notified about the change
-    virtual void onModeChanged(const scheduler::FrameRateMode&) = 0;
+    // called when SF changes the active mode or updates the WorkDuration
+    // and apps needs to be notified about the change
+    virtual void onModeChanged(const scheduler::FrameRateMode&, scheduler::VsyncConfigSet) = 0;
 
     // called when SF rejects the mode change request
     virtual void onModeRejected(PhysicalDisplayId displayId, DisplayModeId modeId) = 0;
@@ -177,7 +179,7 @@ class EventThread : public android::EventThread {
 
     void onHotplugConnectionError(int32_t connectionError) override;
 
-    void onModeChanged(const scheduler::FrameRateMode&) override;
+    void onModeChanged(const scheduler::FrameRateMode&, scheduler::VsyncConfigSet) override;
 
     void onModeRejected(PhysicalDisplayId displayId, DisplayModeId modeId) override;
 

services/surfaceflinger/Scheduler/Scheduler.cpp

@@ -461,7 +461,8 @@ bool Scheduler::onDisplayModeChanged(PhysicalDisplayId displayId, const FrameRat
     }
 
     if (hasEventThreads()) {
-        eventThreadFor(Cycle::Render).onModeChanged(mode);
+        const auto vsyncConfigSet = getVsyncConfigsForRefreshRate(mode.fps);
+        eventThreadFor(Cycle::Render).onModeChanged(mode, vsyncConfigSet);
     }
 
     return isPacesetter;
@@ -495,7 +496,8 @@ void Scheduler::emitModeChangeIfNeeded() {
     mPolicy.emittedModeOpt = mode;
 
     if (hasEventThreads()) {
-        eventThreadFor(Cycle::Render).onModeChanged(mode);
+        const auto vsyncConfigSet = getVsyncConfigsForRefreshRate(mode.fps);
+        eventThreadFor(Cycle::Render).onModeChanged(mode, vsyncConfigSet);
     }
 }
 
@@ -528,15 +530,19 @@ void Scheduler::updatePhaseConfiguration(PhysicalDisplayId displayId, Fps refres
 }
 #pragma clang diagnostic pop
 
-void Scheduler::reloadPhaseConfiguration(Fps refreshRate, Duration minSfDuration,
+void Scheduler::reloadPhaseConfiguration(const FrameRateMode& mode, Duration minSfDuration,
                                          Duration maxSfDuration, Duration appDuration) {
     const auto currentConfigs = [=, this] {
         std::scoped_lock lock{mVsyncConfigLock};
-        mVsyncConfiguration = std::make_unique<impl::WorkDuration>(refreshRate, minSfDuration,
+        mVsyncConfiguration = std::make_unique<impl::WorkDuration>(mode.fps, minSfDuration,
                                                                    maxSfDuration, appDuration);
         return mVsyncConfiguration->getCurrentConfigs();
     }();
-    setVsyncConfig(mVsyncModulator->setVsyncConfigSet(currentConfigs), refreshRate.getPeriod());
+    setVsyncConfig(mVsyncModulator->setVsyncConfigSet(currentConfigs), mode.fps.getPeriod());
+    if (hasEventThreads()) {
+        const auto vsyncConfigSet = getVsyncConfigsForRefreshRate(mode.fps);
+        eventThreadFor(Cycle::Render).onModeChanged(mode, vsyncConfigSet);
+    }
 }
 
 void Scheduler::setActiveDisplayPowerModeForRefreshRateStats(hal::PowerMode powerMode) {

services/surfaceflinger/Scheduler/Scheduler.h

@@ -190,8 +190,9 @@ class Scheduler : public IEventThreadCallback, android::impl::MessageQueue {
     }
 
     void updatePhaseConfiguration(PhysicalDisplayId, Fps) EXCLUDES(mVsyncConfigLock);
-    void reloadPhaseConfiguration(Fps, Duration minSfDuration, Duration maxSfDuration,
-                                  Duration appDuration) EXCLUDES(mVsyncConfigLock);
+    void reloadPhaseConfiguration(const FrameRateMode&, Duration minSfDuration,
+                                  Duration maxSfDuration, Duration appDuration)
+            EXCLUDES(mVsyncConfigLock);
 
     VsyncConfigSet getCurrentVsyncConfigs() const EXCLUDES(mVsyncConfigLock) {
         std::scoped_lock lock{mVsyncConfigLock};
@@ -203,6 +204,12 @@ class Scheduler : public IEventThreadCallback, android::impl::MessageQueue {
         return mVsyncConfiguration->getConfigsForRefreshRate(refreshRate);
     }
 
+    static nsecs_t getPresentationDeadline(Fps refreshRate, Duration sfVsyncOffset) {
+        // We add an additional 1ms to allow for processing time and
+        // differences between the ideal and actual refresh rate.
+        return refreshRate.getPeriodNsecs() - sfVsyncOffset.ns() + 1000000;
+    }
+
     // Sets the render rate for the scheduler to run at.
     void setRenderRate(PhysicalDisplayId, Fps, bool applyImmediately);