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,gui::ISurfaceComposer::VsyncSource vsyncSource,EventRegistrationFlags eventRegistration,const sp<IBinder> & layerHandle)38 DisplayEventDispatcher::DisplayEventDispatcher(const sp<Looper>& looper,
39 gui::ISurfaceComposer::VsyncSource vsyncSource,
40 EventRegistrationFlags eventRegistration,
41 const sp<IBinder>& layerHandle)
42 : mLooper(looper),
43 mReceiver(vsyncSource, eventRegistration, layerHandle),
44 mWaitingForVsync(false),
45 mLastVsyncCount(0),
46 mLastScheduleVsyncTime(0) {
47 ALOGV("dispatcher %p ~ Initializing display event dispatcher.", this);
48 }
49
initialize()50 status_t DisplayEventDispatcher::initialize() {
51 status_t result = mReceiver.initCheck();
52 if (result) {
53 ALOGW("Failed to initialize display event receiver, status=%d", result);
54 return result;
55 }
56
57 if (mLooper != nullptr) {
58 int rc = mLooper->addFd(mReceiver.getFd(), 0, Looper::EVENT_INPUT, this, NULL);
59 if (rc < 0) {
60 return UNKNOWN_ERROR;
61 }
62 }
63
64 return OK;
65 }
66
dispose()67 void DisplayEventDispatcher::dispose() {
68 ALOGV("dispatcher %p ~ Disposing display event dispatcher.", this);
69
70 if (!mReceiver.initCheck() && mLooper != nullptr) {
71 mLooper->removeFd(mReceiver.getFd());
72 }
73 }
74
scheduleVsync()75 status_t DisplayEventDispatcher::scheduleVsync() {
76 if (!mWaitingForVsync) {
77 ALOGV("dispatcher %p ~ Scheduling vsync.", this);
78
79 // Drain all pending events.
80 nsecs_t vsyncTimestamp;
81 PhysicalDisplayId vsyncDisplayId;
82 uint32_t vsyncCount;
83 VsyncEventData vsyncEventData;
84 if (processPendingEvents(&vsyncTimestamp, &vsyncDisplayId, &vsyncCount, &vsyncEventData)) {
85 ALOGE("dispatcher %p ~ last event processed while scheduling was for %" PRId64 "", this,
86 ns2ms(static_cast<nsecs_t>(vsyncTimestamp)));
87 }
88
89 status_t status = mReceiver.requestNextVsync();
90 if (status) {
91 ALOGW("Failed to request next vsync, status=%d", status);
92 return status;
93 }
94
95 mWaitingForVsync = true;
96 mLastScheduleVsyncTime = systemTime(SYSTEM_TIME_MONOTONIC);
97 }
98 return OK;
99 }
100
injectEvent(const DisplayEventReceiver::Event & event)101 void DisplayEventDispatcher::injectEvent(const DisplayEventReceiver::Event& event) {
102 mReceiver.sendEvents(&event, 1);
103 }
104
getFd() const105 int DisplayEventDispatcher::getFd() const {
106 return mReceiver.getFd();
107 }
108
handleEvent(int,int events,void *)109 int DisplayEventDispatcher::handleEvent(int, int events, void*) {
110 if (events & (Looper::EVENT_ERROR | Looper::EVENT_HANGUP)) {
111 ALOGE("Display event receiver pipe was closed or an error occurred. "
112 "events=0x%x",
113 events);
114 return 0; // remove the callback
115 }
116
117 if (!(events & Looper::EVENT_INPUT)) {
118 ALOGW("Received spurious callback for unhandled poll event. "
119 "events=0x%x",
120 events);
121 return 1; // keep the callback
122 }
123
124 // Drain all pending events, keep the last vsync.
125 nsecs_t vsyncTimestamp;
126 PhysicalDisplayId vsyncDisplayId;
127 uint32_t vsyncCount;
128 VsyncEventData vsyncEventData;
129 if (processPendingEvents(&vsyncTimestamp, &vsyncDisplayId, &vsyncCount, &vsyncEventData)) {
130 ALOGV("dispatcher %p ~ Vsync pulse: timestamp=%" PRId64
131 ", displayId=%s, count=%d, vsyncId=%" PRId64,
132 this, ns2ms(vsyncTimestamp), to_string(vsyncDisplayId).c_str(), vsyncCount,
133 vsyncEventData.preferredVsyncId());
134 mWaitingForVsync = false;
135 mLastVsyncCount = vsyncCount;
136 dispatchVsync(vsyncTimestamp, vsyncDisplayId, vsyncCount, vsyncEventData);
137 }
138
139 if (mWaitingForVsync) {
140 const nsecs_t currentTime = systemTime(SYSTEM_TIME_MONOTONIC);
141 const nsecs_t vsyncScheduleDelay = currentTime - mLastScheduleVsyncTime;
142 if (vsyncScheduleDelay > WAITING_FOR_VSYNC_TIMEOUT) {
143 ALOGW("Vsync time out! vsyncScheduleDelay=%" PRId64 "ms", ns2ms(vsyncScheduleDelay));
144 mWaitingForVsync = false;
145 dispatchVsync(currentTime, vsyncDisplayId /* displayId is not used */,
146 ++mLastVsyncCount, vsyncEventData /* empty data */);
147 }
148 }
149
150 return 1; // keep the callback
151 }
152
processPendingEvents(nsecs_t * outTimestamp,PhysicalDisplayId * outDisplayId,uint32_t * outCount,VsyncEventData * outVsyncEventData)153 bool DisplayEventDispatcher::processPendingEvents(nsecs_t* outTimestamp,
154 PhysicalDisplayId* outDisplayId,
155 uint32_t* outCount,
156 VsyncEventData* outVsyncEventData) {
157 bool gotVsync = false;
158 DisplayEventReceiver::Event buf[EVENT_BUFFER_SIZE];
159 ssize_t n;
160 while ((n = mReceiver.getEvents(buf, EVENT_BUFFER_SIZE)) > 0) {
161 ALOGV("dispatcher %p ~ Read %d events.", this, int(n));
162 mFrameRateOverrides.reserve(n);
163 for (ssize_t i = 0; i < n; i++) {
164 const DisplayEventReceiver::Event& ev = buf[i];
165 switch (ev.header.type) {
166 case DisplayEventReceiver::DISPLAY_EVENT_VSYNC:
167 // Later vsync events will just overwrite the info from earlier
168 // ones. That's fine, we only care about the most recent.
169 gotVsync = true;
170 *outTimestamp = ev.header.timestamp;
171 *outDisplayId = ev.header.displayId;
172 *outCount = ev.vsync.count;
173 *outVsyncEventData = ev.vsync.vsyncData;
174 break;
175 case DisplayEventReceiver::DISPLAY_EVENT_HOTPLUG:
176 dispatchHotplug(ev.header.timestamp, ev.header.displayId, ev.hotplug.connected);
177 break;
178 case DisplayEventReceiver::DISPLAY_EVENT_MODE_CHANGE:
179 dispatchModeChanged(ev.header.timestamp, ev.header.displayId,
180 ev.modeChange.modeId, ev.modeChange.vsyncPeriod);
181 break;
182 case DisplayEventReceiver::DISPLAY_EVENT_NULL:
183 dispatchNullEvent(ev.header.timestamp, ev.header.displayId);
184 break;
185 case DisplayEventReceiver::DISPLAY_EVENT_FRAME_RATE_OVERRIDE:
186 mFrameRateOverrides.emplace_back(ev.frameRateOverride);
187 break;
188 case DisplayEventReceiver::DISPLAY_EVENT_FRAME_RATE_OVERRIDE_FLUSH:
189 dispatchFrameRateOverrides(ev.header.timestamp, ev.header.displayId,
190 std::move(mFrameRateOverrides));
191 break;
192 default:
193 ALOGW("dispatcher %p ~ ignoring unknown event type %#x", this, ev.header.type);
194 break;
195 }
196 }
197 }
198 if (n < 0) {
199 ALOGW("Failed to get events from display event dispatcher, status=%d", status_t(n));
200 }
201 return gotVsync;
202 }
203
getLatestVsyncEventData(ParcelableVsyncEventData * outVsyncEventData) const204 status_t DisplayEventDispatcher::getLatestVsyncEventData(
205 ParcelableVsyncEventData* outVsyncEventData) const {
206 return mReceiver.getLatestVsyncEventData(outVsyncEventData);
207 }
208
209 } // namespace android
210