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