Use VsyncEventData in DisplayEventReceiver::Event.
Clean-up that re-uses VsyncEventData so it's easier to maintain.
The ParcelableVsyncEventData is used in AIDL. It is separated from
VsyncEventData because of the union in
DisplayEventReceiver::Event and Parcelable has non-trivial
constructors.
Bug: 218563993
Test: atest ChoreographerNativeTest
Test: atest libsurfaceflinger_unittest
Test: atest libgui_test
Change-Id: I3ebeb1c7826300c27c4a12d4dba6fbd16305e9e1
diff --git a/services/surfaceflinger/Scheduler/EventThread.cpp b/services/surfaceflinger/Scheduler/EventThread.cpp
index 2d0da46..5ba8a1b 100644
--- a/services/surfaceflinger/Scheduler/EventThread.cpp
+++ b/services/surfaceflinger/Scheduler/EventThread.cpp
@@ -87,9 +87,10 @@
to_string(event.header.displayId).c_str(),
event.hotplug.connected ? "connected" : "disconnected");
case DisplayEventReceiver::DISPLAY_EVENT_VSYNC:
- return StringPrintf("VSync{displayId=%s, count=%u, expectedVSyncTimestamp=%" PRId64 "}",
+ return StringPrintf("VSync{displayId=%s, count=%u, expectedPresentationTime=%" PRId64
+ "}",
to_string(event.header.displayId).c_str(), event.vsync.count,
- event.vsync.expectedVSyncTimestamp);
+ event.vsync.vsyncData.preferredExpectedPresentationTime());
case DisplayEventReceiver::DISPLAY_EVENT_MODE_CHANGE:
return StringPrintf("ModeChanged{displayId=%s, modeId=%u}",
to_string(event.header.displayId).c_str(), event.modeChange.modeId);
@@ -107,13 +108,19 @@
}
DisplayEventReceiver::Event makeVSync(PhysicalDisplayId displayId, nsecs_t timestamp,
- uint32_t count, nsecs_t expectedVSyncTimestamp,
+ uint32_t count, nsecs_t expectedPresentationTime,
nsecs_t deadlineTimestamp) {
DisplayEventReceiver::Event event;
event.header = {DisplayEventReceiver::DISPLAY_EVENT_VSYNC, displayId, timestamp};
event.vsync.count = count;
- event.vsync.expectedVSyncTimestamp = expectedVSyncTimestamp;
- event.vsync.deadlineTimestamp = deadlineTimestamp;
+ event.vsync.vsyncData.preferredFrameTimelineIndex = 0;
+ // Temporarily store the current vsync information in frameTimelines[0], marked as
+ // platform-preferred. When the event is dispatched later, the frame interval at that time is
+ // used with this information to generate multiple frame timeline choices.
+ event.vsync.vsyncData.frameTimelines[0] = {.vsyncId = FrameTimelineInfo::INVALID_VSYNC_ID,
+ .deadlineTimestamp = deadlineTimestamp,
+ .expectedPresentationTime =
+ expectedPresentationTime};
return event;
}
@@ -186,9 +193,10 @@
return binder::Status::ok();
}
-binder::Status EventThreadConnection::getLatestVsyncEventData(VsyncEventData* outVsyncEventData) {
+binder::Status EventThreadConnection::getLatestVsyncEventData(
+ ParcelableVsyncEventData* outVsyncEventData) {
ATRACE_CALL();
- *outVsyncEventData = mEventThread->getLatestVsyncEventData(this);
+ outVsyncEventData->vsync = mEventThread->getLatestVsyncEventData(this);
return binder::Status::ok();
}
@@ -338,10 +346,16 @@
VsyncEventData EventThread::getLatestVsyncEventData(
const sp<EventThreadConnection>& connection) const {
- nsecs_t frameInterval = mGetVsyncPeriodFunction(connection->mOwnerUid);
VsyncEventData vsyncEventData;
+ nsecs_t frameInterval = mGetVsyncPeriodFunction(connection->mOwnerUid);
vsyncEventData.frameInterval = frameInterval;
- generateFrameTimeline(vsyncEventData, frameInterval, systemTime(SYSTEM_TIME_MONOTONIC));
+ VSyncSource::VSyncData vsyncData;
+ {
+ std::lock_guard<std::mutex> lock(mMutex);
+ vsyncData = mVSyncSource->getLatestVSyncData();
+ }
+ generateFrameTimeline(vsyncEventData, frameInterval, systemTime(SYSTEM_TIME_MONOTONIC),
+ vsyncData.expectedPresentationTime, vsyncData.deadlineTimestamp);
return vsyncEventData;
}
@@ -370,7 +384,7 @@
LOG_FATAL_IF(!mVSyncState);
mPendingEvents.push_back(makeVSync(mVSyncState->displayId, timestamp, ++mVSyncState->count,
- vsyncData.expectedVSyncTimestamp,
+ vsyncData.expectedPresentationTime,
vsyncData.deadlineTimestamp));
mCondition.notify_all();
}
@@ -518,7 +532,8 @@
const sp<EventThreadConnection>& connection) const {
const auto throttleVsync = [&] {
return mThrottleVsyncCallback &&
- mThrottleVsyncCallback(event.vsync.expectedVSyncTimestamp, connection->mOwnerUid);
+ mThrottleVsyncCallback(event.vsync.vsyncData.preferredExpectedPresentationTime(),
+ connection->mOwnerUid);
};
switch (event.header.type) {
@@ -568,79 +583,49 @@
}
int64_t EventThread::generateToken(nsecs_t timestamp, nsecs_t deadlineTimestamp,
- nsecs_t expectedVSyncTimestamp) const {
+ nsecs_t expectedPresentationTime) const {
if (mTokenManager != nullptr) {
return mTokenManager->generateTokenForPredictions(
- {timestamp, deadlineTimestamp, expectedVSyncTimestamp});
+ {timestamp, deadlineTimestamp, expectedPresentationTime});
}
return FrameTimelineInfo::INVALID_VSYNC_ID;
}
-void EventThread::generateFrameTimeline(
- nsecs_t frameInterval, nsecs_t timestamp, nsecs_t preferredExpectedVSyncTimestamp,
- nsecs_t preferredDeadlineTimestamp,
- std::function<void(int64_t index)> setPreferredFrameTimelineIndex,
- std::function<void(int64_t index, int64_t vsyncId, nsecs_t expectedVSyncTimestamp,
- nsecs_t deadlineTimestamp)>
- setFrameTimeline) const {
+void EventThread::generateFrameTimeline(VsyncEventData& outVsyncEventData, nsecs_t frameInterval,
+ nsecs_t timestamp,
+ nsecs_t preferredExpectedPresentationTime,
+ nsecs_t preferredDeadlineTimestamp) const {
// Add 1 to ensure the preferredFrameTimelineIndex entry (when multiplier == 0) is included.
for (int64_t multiplier = -VsyncEventData::kFrameTimelinesLength + 1, currentIndex = 0;
currentIndex < VsyncEventData::kFrameTimelinesLength; multiplier++) {
- nsecs_t deadline = preferredDeadlineTimestamp + multiplier * frameInterval;
+ nsecs_t deadlineTimestamp = preferredDeadlineTimestamp + multiplier * frameInterval;
// Valid possible frame timelines must have future values.
- if (deadline > timestamp) {
+ if (deadlineTimestamp > timestamp) {
if (multiplier == 0) {
- setPreferredFrameTimelineIndex(currentIndex);
+ outVsyncEventData.preferredFrameTimelineIndex = currentIndex;
}
- nsecs_t expectedVSyncTimestamp =
- preferredExpectedVSyncTimestamp + multiplier * frameInterval;
- setFrameTimeline(currentIndex,
- generateToken(timestamp, deadline, expectedVSyncTimestamp),
- expectedVSyncTimestamp, deadline);
+ nsecs_t expectedPresentationTime =
+ preferredExpectedPresentationTime + multiplier * frameInterval;
+ outVsyncEventData.frameTimelines[currentIndex] =
+ {.vsyncId =
+ generateToken(timestamp, deadlineTimestamp, expectedPresentationTime),
+ .deadlineTimestamp = deadlineTimestamp,
+ .expectedPresentationTime = expectedPresentationTime};
currentIndex++;
}
}
}
-void EventThread::generateFrameTimeline(DisplayEventReceiver::Event& event) const {
- generateFrameTimeline(
- event.vsync.frameInterval, event.header.timestamp, event.vsync.expectedVSyncTimestamp,
- event.vsync.deadlineTimestamp,
- [&](int index) { event.vsync.preferredFrameTimelineIndex = index; },
- [&](int64_t index, int64_t vsyncId, nsecs_t expectedVSyncTimestamp,
- nsecs_t deadlineTimestamp) {
- event.vsync.frameTimelines[index] = {.vsyncId = vsyncId,
- .deadlineTimestamp = deadlineTimestamp,
- .expectedVSyncTimestamp =
- expectedVSyncTimestamp};
- });
-}
-
-void EventThread::generateFrameTimeline(VsyncEventData& out, const nsecs_t frameInterval,
- const nsecs_t timestamp) const {
- VSyncSource::VSyncData vsyncData;
- {
- std::lock_guard<std::mutex> lock(mMutex);
- vsyncData = mVSyncSource->getLatestVSyncData();
- }
- generateFrameTimeline(
- frameInterval, timestamp, vsyncData.expectedVSyncTimestamp, vsyncData.deadlineTimestamp,
- [&](int index) { out.preferredFrameTimelineIndex = index; },
- [&](int64_t index, int64_t vsyncId, nsecs_t expectedVSyncTimestamp,
- nsecs_t deadlineTimestamp) {
- out.frameTimelines[index] =
- VsyncEventData::FrameTimeline(vsyncId, deadlineTimestamp,
- expectedVSyncTimestamp);
- });
-}
-
void EventThread::dispatchEvent(const DisplayEventReceiver::Event& event,
const DisplayEventConsumers& consumers) {
for (const auto& consumer : consumers) {
DisplayEventReceiver::Event copy = event;
if (event.header.type == DisplayEventReceiver::DISPLAY_EVENT_VSYNC) {
- copy.vsync.frameInterval = mGetVsyncPeriodFunction(consumer->mOwnerUid);
- generateFrameTimeline(copy);
+ const int64_t frameInterval = mGetVsyncPeriodFunction(consumer->mOwnerUid);
+ copy.vsync.vsyncData.frameInterval = frameInterval;
+ generateFrameTimeline(copy.vsync.vsyncData, frameInterval, copy.header.timestamp,
+ event.vsync.vsyncData.preferredExpectedPresentationTime(),
+ event.vsync.vsyncData.preferredDeadlineTimestamp());
}
switch (consumer->postEvent(copy)) {
case NO_ERROR:
diff --git a/services/surfaceflinger/Scheduler/EventThread.h b/services/surfaceflinger/Scheduler/EventThread.h
index a858169..c406478 100644
--- a/services/surfaceflinger/Scheduler/EventThread.h
+++ b/services/surfaceflinger/Scheduler/EventThread.h
@@ -45,6 +45,7 @@
class TokenManager;
} // namespace frametimeline
+using gui::ParcelableVsyncEventData;
using gui::VsyncEventData;
// ---------------------------------------------------------------------------
@@ -66,7 +67,7 @@
public:
class VSyncData {
public:
- nsecs_t expectedVSyncTimestamp;
+ nsecs_t expectedPresentationTime;
nsecs_t deadlineTimestamp;
};
@@ -99,7 +100,7 @@
binder::Status stealReceiveChannel(gui::BitTube* outChannel) override;
binder::Status setVsyncRate(int rate) override;
binder::Status requestNextVsync() override; // asynchronous
- binder::Status getLatestVsyncEventData(VsyncEventData* outVsyncEventData) override;
+ binder::Status getLatestVsyncEventData(ParcelableVsyncEventData* outVsyncEventData) override;
// Called in response to requestNextVsync.
const ResyncCallback resyncCallback;
@@ -217,17 +218,10 @@
void onVSyncEvent(nsecs_t timestamp, VSyncSource::VSyncData vsyncData) override;
int64_t generateToken(nsecs_t timestamp, nsecs_t deadlineTimestamp,
- nsecs_t expectedVSyncTimestamp) const;
- void generateFrameTimeline(DisplayEventReceiver::Event& event) const;
- void generateFrameTimeline(VsyncEventData& out, const nsecs_t frameInterval,
- const nsecs_t timestamp) const;
- void generateFrameTimeline(
- nsecs_t frameInterval, nsecs_t timestamp, nsecs_t preferredExpectedVSyncTimestamp,
- nsecs_t preferredDeadlineTimestamp,
- std::function<void(int64_t index)> setPreferredFrameTimelineIndex,
- std::function<void(int64_t index, int64_t vsyncId, nsecs_t expectedVSyncTimestamp,
- nsecs_t deadlineTimestamp)>
- setFrameTimeline) const;
+ nsecs_t expectedPresentationTime) const;
+ void generateFrameTimeline(VsyncEventData& outVsyncEventData, nsecs_t frameInterval,
+ nsecs_t timestamp, nsecs_t preferredExpectedPresentationTime,
+ nsecs_t preferredDeadlineTimestamp) const;
const std::unique_ptr<VSyncSource> mVSyncSource GUARDED_BY(mMutex);
frametimeline::TokenManager* const mTokenManager;
diff --git a/services/surfaceflinger/Scheduler/MessageQueue.cpp b/services/surfaceflinger/Scheduler/MessageQueue.cpp
index a020e2c..712cd5b 100644
--- a/services/surfaceflinger/Scheduler/MessageQueue.cpp
+++ b/services/surfaceflinger/Scheduler/MessageQueue.cpp
@@ -191,7 +191,8 @@
for (int i = 0; i < n; i++) {
if (buffer[i].header.type == DisplayEventReceiver::DISPLAY_EVENT_VSYNC) {
auto& vsync = buffer[i].vsync;
- mHandler->dispatchFrame(vsync.vsyncId, vsync.expectedVSyncTimestamp);
+ mHandler->dispatchFrame(vsync.vsyncData.preferredVsyncId(),
+ vsync.vsyncData.preferredExpectedPresentationTime());
break;
}
}