1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "DisplayEventDispatcher"
18
19 #include <cinttypes>
20 #include <cstdint>
21
22 #include <gui/DisplayEventDispatcher.h>
23 #include <gui/DisplayEventReceiver.h>
24 #include <utils/Log.h>
25 #include <utils/Looper.h>
26
27 #include <utils/Timers.h>
28
29 namespace android {
30
31 // Number of events to read at a time from the DisplayEventDispatcher pipe.
32 // The value should be large enough that we can quickly drain the pipe
33 // using just a few large reads.
34 static const size_t EVENT_BUFFER_SIZE = 100;
35
36 static constexpr nsecs_t WAITING_FOR_VSYNC_TIMEOUT = ms2ns(300);
37
DisplayEventDispatcher(const sp<Looper> & looper,ISurfaceComposer::VsyncSource vsyncSource,ISurfaceComposer::EventRegistrationFlags eventRegistration)38 DisplayEventDispatcher::DisplayEventDispatcher(
39 const sp<Looper>& looper, ISurfaceComposer::VsyncSource vsyncSource,
40 ISurfaceComposer::EventRegistrationFlags eventRegistration)
41 : mLooper(looper), mReceiver(vsyncSource, eventRegistration), mWaitingForVsync(false),
42 mLastVsyncCount(0), mLastScheduleVsyncTime(0) {
43 ALOGV("dispatcher %p ~ Initializing display event dispatcher.", this);
44 }
45
initialize()46 status_t DisplayEventDispatcher::initialize() {
47 status_t result = mReceiver.initCheck();
48 if (result) {
49 ALOGW("Failed to initialize display event receiver, status=%d", result);
50 return result;
51 }
52
53 if (mLooper != nullptr) {
54 int rc = mLooper->addFd(mReceiver.getFd(), 0, Looper::EVENT_INPUT, this, NULL);
55 if (rc < 0) {
56 return UNKNOWN_ERROR;
57 }
58 }
59
60 return OK;
61 }
62
dispose()63 void DisplayEventDispatcher::dispose() {
64 ALOGV("dispatcher %p ~ Disposing display event dispatcher.", this);
65
66 if (!mReceiver.initCheck() && mLooper != nullptr) {
67 mLooper->removeFd(mReceiver.getFd());
68 }
69 }
70
scheduleVsync()71 status_t DisplayEventDispatcher::scheduleVsync() {
72 if (!mWaitingForVsync) {
73 ALOGV("dispatcher %p ~ Scheduling vsync.", this);
74
75 // Drain all pending events.
76 nsecs_t vsyncTimestamp;
77 PhysicalDisplayId vsyncDisplayId;
78 uint32_t vsyncCount;
79 VsyncEventData vsyncEventData;
80 if (processPendingEvents(&vsyncTimestamp, &vsyncDisplayId, &vsyncCount, &vsyncEventData)) {
81 ALOGE("dispatcher %p ~ last event processed while scheduling was for %" PRId64 "", this,
82 ns2ms(static_cast<nsecs_t>(vsyncTimestamp)));
83 }
84
85 status_t status = mReceiver.requestNextVsync();
86 if (status) {
87 ALOGW("Failed to request next vsync, status=%d", status);
88 return status;
89 }
90
91 mWaitingForVsync = true;
92 mLastScheduleVsyncTime = systemTime(SYSTEM_TIME_MONOTONIC);
93 }
94 return OK;
95 }
96
injectEvent(const DisplayEventReceiver::Event & event)97 void DisplayEventDispatcher::injectEvent(const DisplayEventReceiver::Event& event) {
98 mReceiver.sendEvents(&event, 1);
99 }
100
getFd() const101 int DisplayEventDispatcher::getFd() const {
102 return mReceiver.getFd();
103 }
104
handleEvent(int,int events,void *)105 int DisplayEventDispatcher::handleEvent(int, int events, void*) {
106 if (events & (Looper::EVENT_ERROR | Looper::EVENT_HANGUP)) {
107 ALOGE("Display event receiver pipe was closed or an error occurred. "
108 "events=0x%x",
109 events);
110 return 0; // remove the callback
111 }
112
113 if (!(events & Looper::EVENT_INPUT)) {
114 ALOGW("Received spurious callback for unhandled poll event. "
115 "events=0x%x",
116 events);
117 return 1; // keep the callback
118 }
119
120 // Drain all pending events, keep the last vsync.
121 nsecs_t vsyncTimestamp;
122 PhysicalDisplayId vsyncDisplayId;
123 uint32_t vsyncCount;
124 VsyncEventData vsyncEventData;
125 if (processPendingEvents(&vsyncTimestamp, &vsyncDisplayId, &vsyncCount, &vsyncEventData)) {
126 ALOGV("dispatcher %p ~ Vsync pulse: timestamp=%" PRId64
127 ", displayId=%s, count=%d, vsyncId=%" PRId64,
128 this, ns2ms(vsyncTimestamp), to_string(vsyncDisplayId).c_str(), vsyncCount,
129 vsyncEventData.preferredVsyncId());
130 mWaitingForVsync = false;
131 mLastVsyncCount = vsyncCount;
132 dispatchVsync(vsyncTimestamp, vsyncDisplayId, vsyncCount, vsyncEventData);
133 }
134
135 if (mWaitingForVsync) {
136 const nsecs_t currentTime = systemTime(SYSTEM_TIME_MONOTONIC);
137 const nsecs_t vsyncScheduleDelay = currentTime - mLastScheduleVsyncTime;
138 if (vsyncScheduleDelay > WAITING_FOR_VSYNC_TIMEOUT) {
139 ALOGW("Vsync time out! vsyncScheduleDelay=%" PRId64 "ms", ns2ms(vsyncScheduleDelay));
140 mWaitingForVsync = false;
141 dispatchVsync(currentTime, vsyncDisplayId /* displayId is not used */,
142 ++mLastVsyncCount, vsyncEventData /* empty data */);
143 }
144 }
145
146 return 1; // keep the callback
147 }
148
processPendingEvents(nsecs_t * outTimestamp,PhysicalDisplayId * outDisplayId,uint32_t * outCount,VsyncEventData * outVsyncEventData)149 bool DisplayEventDispatcher::processPendingEvents(nsecs_t* outTimestamp,
150 PhysicalDisplayId* outDisplayId,
151 uint32_t* outCount,
152 VsyncEventData* outVsyncEventData) {
153 bool gotVsync = false;
154 DisplayEventReceiver::Event buf[EVENT_BUFFER_SIZE];
155 ssize_t n;
156 while ((n = mReceiver.getEvents(buf, EVENT_BUFFER_SIZE)) > 0) {
157 ALOGV("dispatcher %p ~ Read %d events.", this, int(n));
158 mFrameRateOverrides.reserve(n);
159 for (ssize_t i = 0; i < n; i++) {
160 const DisplayEventReceiver::Event& ev = buf[i];
161 switch (ev.header.type) {
162 case DisplayEventReceiver::DISPLAY_EVENT_VSYNC:
163 // Later vsync events will just overwrite the info from earlier
164 // ones. That's fine, we only care about the most recent.
165 gotVsync = true;
166 *outTimestamp = ev.header.timestamp;
167 *outDisplayId = ev.header.displayId;
168 *outCount = ev.vsync.count;
169 *outVsyncEventData = ev.vsync.vsyncData;
170 break;
171 case DisplayEventReceiver::DISPLAY_EVENT_HOTPLUG:
172 dispatchHotplug(ev.header.timestamp, ev.header.displayId, ev.hotplug.connected);
173 break;
174 case DisplayEventReceiver::DISPLAY_EVENT_MODE_CHANGE:
175 dispatchModeChanged(ev.header.timestamp, ev.header.displayId,
176 ev.modeChange.modeId, ev.modeChange.vsyncPeriod);
177 break;
178 case DisplayEventReceiver::DISPLAY_EVENT_NULL:
179 dispatchNullEvent(ev.header.timestamp, ev.header.displayId);
180 break;
181 case DisplayEventReceiver::DISPLAY_EVENT_FRAME_RATE_OVERRIDE:
182 mFrameRateOverrides.emplace_back(ev.frameRateOverride);
183 break;
184 case DisplayEventReceiver::DISPLAY_EVENT_FRAME_RATE_OVERRIDE_FLUSH:
185 dispatchFrameRateOverrides(ev.header.timestamp, ev.header.displayId,
186 std::move(mFrameRateOverrides));
187 break;
188 default:
189 ALOGW("dispatcher %p ~ ignoring unknown event type %#x", this, ev.header.type);
190 break;
191 }
192 }
193 }
194 if (n < 0) {
195 ALOGW("Failed to get events from display event dispatcher, status=%d", status_t(n));
196 }
197 return gotVsync;
198 }
199
getLatestVsyncEventData(ParcelableVsyncEventData * outVsyncEventData) const200 status_t DisplayEventDispatcher::getLatestVsyncEventData(
201 ParcelableVsyncEventData* outVsyncEventData) const {
202 return mReceiver.getLatestVsyncEventData(outVsyncEventData);
203 }
204
205 } // namespace android
206