1 /* 2 * Copyright (C) 2011 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 ATRACE_TAG ATRACE_TAG_GRAPHICS 18 19 #include <stdint.h> 20 #include <sys/types.h> 21 22 #include <cutils/compiler.h> 23 24 #include <gui/BitTube.h> 25 #include <gui/IDisplayEventConnection.h> 26 #include <gui/DisplayEventReceiver.h> 27 28 #include <utils/Errors.h> 29 #include <utils/String8.h> 30 #include <utils/Trace.h> 31 32 #include "EventThread.h" 33 #include "SurfaceFlinger.h" 34 35 // --------------------------------------------------------------------------- 36 namespace android { 37 // --------------------------------------------------------------------------- 38 // time to wait between VSYNC requests before sending a VSYNC OFF power hint: 40msec. 39 const long vsyncHintOffDelay = 40000000; 40 41 static void vsyncOffCallback(union sigval val) { 42 EventThread *ev = (EventThread *)val.sival_ptr; 43 ev->sendVsyncHintOff(); 44 return; 45 } 46 47 EventThread::EventThread(const sp<VSyncSource>& src) 48 : mVSyncSource(src), 49 mUseSoftwareVSync(false), 50 mVsyncEnabled(false), 51 mDebugVsyncEnabled(false), 52 mVsyncHintSent(false) { 53 54 for (int32_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) { 55 mVSyncEvent[i].header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC; 56 mVSyncEvent[i].header.id = 0; 57 mVSyncEvent[i].header.timestamp = 0; 58 mVSyncEvent[i].vsync.count = 0; 59 } 60 struct sigevent se; 61 se.sigev_notify = SIGEV_THREAD; 62 se.sigev_value.sival_ptr = this; 63 se.sigev_notify_function = vsyncOffCallback; 64 se.sigev_notify_attributes = NULL; 65 timer_create(CLOCK_MONOTONIC, &se, &mTimerId); 66 } 67 68 void EventThread::sendVsyncHintOff() { 69 Mutex::Autolock _l(mLock); 70 mPowerHAL.vsyncHint(false); 71 mVsyncHintSent = false; 72 } 73 74 void EventThread::sendVsyncHintOnLocked() { 75 struct itimerspec ts; 76 if(!mVsyncHintSent) { 77 mPowerHAL.vsyncHint(true); 78 mVsyncHintSent = true; 79 } 80 ts.it_value.tv_sec = 0; 81 ts.it_value.tv_nsec = vsyncHintOffDelay; 82 ts.it_interval.tv_sec = 0; 83 ts.it_interval.tv_nsec = 0; 84 timer_settime(mTimerId, 0, &ts, NULL); 85 } 86 87 void EventThread::onFirstRef() { 88 run("EventThread", PRIORITY_URGENT_DISPLAY + PRIORITY_MORE_FAVORABLE); 89 } 90 91 sp<EventThread::Connection> EventThread::createEventConnection() const { 92 return new Connection(const_cast<EventThread*>(this)); 93 } 94 95 status_t EventThread::registerDisplayEventConnection( 96 const sp<EventThread::Connection>& connection) { 97 Mutex::Autolock _l(mLock); 98 mDisplayEventConnections.add(connection); 99 mCondition.broadcast(); 100 return NO_ERROR; 101 } 102 103 void EventThread::removeDisplayEventConnection( 104 const wp<EventThread::Connection>& connection) { 105 Mutex::Autolock _l(mLock); 106 mDisplayEventConnections.remove(connection); 107 } 108 109 void EventThread::setVsyncRate(uint32_t count, 110 const sp<EventThread::Connection>& connection) { 111 if (int32_t(count) >= 0) { // server must protect against bad params 112 Mutex::Autolock _l(mLock); 113 const int32_t new_count = (count == 0) ? -1 : count; 114 if (connection->count != new_count) { 115 connection->count = new_count; 116 mCondition.broadcast(); 117 } 118 } 119 } 120 121 void EventThread::requestNextVsync( 122 const sp<EventThread::Connection>& connection) { 123 Mutex::Autolock _l(mLock); 124 if (connection->count < 0) { 125 connection->count = 0; 126 mCondition.broadcast(); 127 } 128 } 129 130 void EventThread::onScreenReleased() { 131 Mutex::Autolock _l(mLock); 132 if (!mUseSoftwareVSync) { 133 // disable reliance on h/w vsync 134 mUseSoftwareVSync = true; 135 mCondition.broadcast(); 136 } 137 } 138 139 void EventThread::onScreenAcquired() { 140 Mutex::Autolock _l(mLock); 141 if (mUseSoftwareVSync) { 142 // resume use of h/w vsync 143 mUseSoftwareVSync = false; 144 mCondition.broadcast(); 145 } 146 } 147 148 void EventThread::onVSyncEvent(nsecs_t timestamp) { 149 Mutex::Autolock _l(mLock); 150 mVSyncEvent[0].header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC; 151 mVSyncEvent[0].header.id = 0; 152 mVSyncEvent[0].header.timestamp = timestamp; 153 mVSyncEvent[0].vsync.count++; 154 mCondition.broadcast(); 155 } 156 157 void EventThread::onHotplugReceived(int type, bool connected) { 158 ALOGE_IF(type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES, 159 "received hotplug event for an invalid display (id=%d)", type); 160 161 Mutex::Autolock _l(mLock); 162 if (type < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) { 163 DisplayEventReceiver::Event event; 164 event.header.type = DisplayEventReceiver::DISPLAY_EVENT_HOTPLUG; 165 event.header.id = type; 166 event.header.timestamp = systemTime(); 167 event.hotplug.connected = connected; 168 mPendingEvents.add(event); 169 mCondition.broadcast(); 170 } 171 } 172 173 bool EventThread::threadLoop() { 174 DisplayEventReceiver::Event event; 175 Vector< sp<EventThread::Connection> > signalConnections; 176 signalConnections = waitForEvent(&event); 177 178 // dispatch events to listeners... 179 const size_t count = signalConnections.size(); 180 for (size_t i=0 ; i<count ; i++) { 181 const sp<Connection>& conn(signalConnections[i]); 182 // now see if we still need to report this event 183 status_t err = conn->postEvent(event); 184 if (err == -EAGAIN || err == -EWOULDBLOCK) { 185 // The destination doesn't accept events anymore, it's probably 186 // full. For now, we just drop the events on the floor. 187 // FIXME: Note that some events cannot be dropped and would have 188 // to be re-sent later. 189 // Right-now we don't have the ability to do this. 190 ALOGW("EventThread: dropping event (%08x) for connection %p", 191 event.header.type, conn.get()); 192 } else if (err < 0) { 193 // handle any other error on the pipe as fatal. the only 194 // reasonable thing to do is to clean-up this connection. 195 // The most common error we'll get here is -EPIPE. 196 removeDisplayEventConnection(signalConnections[i]); 197 } 198 } 199 return true; 200 } 201 202 // This will return when (1) a vsync event has been received, and (2) there was 203 // at least one connection interested in receiving it when we started waiting. 204 Vector< sp<EventThread::Connection> > EventThread::waitForEvent( 205 DisplayEventReceiver::Event* event) 206 { 207 Mutex::Autolock _l(mLock); 208 Vector< sp<EventThread::Connection> > signalConnections; 209 210 do { 211 bool eventPending = false; 212 bool waitForVSync = false; 213 214 size_t vsyncCount = 0; 215 nsecs_t timestamp = 0; 216 for (int32_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) { 217 timestamp = mVSyncEvent[i].header.timestamp; 218 if (timestamp) { 219 // we have a vsync event to dispatch 220 *event = mVSyncEvent[i]; 221 mVSyncEvent[i].header.timestamp = 0; 222 vsyncCount = mVSyncEvent[i].vsync.count; 223 break; 224 } 225 } 226 227 if (!timestamp) { 228 // no vsync event, see if there are some other event 229 eventPending = !mPendingEvents.isEmpty(); 230 if (eventPending) { 231 // we have some other event to dispatch 232 *event = mPendingEvents[0]; 233 mPendingEvents.removeAt(0); 234 } 235 } 236 237 // find out connections waiting for events 238 size_t count = mDisplayEventConnections.size(); 239 for (size_t i=0 ; i<count ; i++) { 240 sp<Connection> connection(mDisplayEventConnections[i].promote()); 241 if (connection != NULL) { 242 bool added = false; 243 if (connection->count >= 0) { 244 // we need vsync events because at least 245 // one connection is waiting for it 246 waitForVSync = true; 247 if (timestamp) { 248 // we consume the event only if it's time 249 // (ie: we received a vsync event) 250 if (connection->count == 0) { 251 // fired this time around 252 connection->count = -1; 253 signalConnections.add(connection); 254 added = true; 255 } else if (connection->count == 1 || 256 (vsyncCount % connection->count) == 0) { 257 // continuous event, and time to report it 258 signalConnections.add(connection); 259 added = true; 260 } 261 } 262 } 263 264 if (eventPending && !timestamp && !added) { 265 // we don't have a vsync event to process 266 // (timestamp==0), but we have some pending 267 // messages. 268 signalConnections.add(connection); 269 } 270 } else { 271 // we couldn't promote this reference, the connection has 272 // died, so clean-up! 273 mDisplayEventConnections.removeAt(i); 274 --i; --count; 275 } 276 } 277 278 // Here we figure out if we need to enable or disable vsyncs 279 if (timestamp && !waitForVSync) { 280 // we received a VSYNC but we have no clients 281 // don't report it, and disable VSYNC events 282 disableVSyncLocked(); 283 } else if (!timestamp && waitForVSync) { 284 // we have at least one client, so we want vsync enabled 285 // (TODO: this function is called right after we finish 286 // notifying clients of a vsync, so this call will be made 287 // at the vsync rate, e.g. 60fps. If we can accurately 288 // track the current state we could avoid making this call 289 // so often.) 290 enableVSyncLocked(); 291 } 292 293 // note: !timestamp implies signalConnections.isEmpty(), because we 294 // don't populate signalConnections if there's no vsync pending 295 if (!timestamp && !eventPending) { 296 // wait for something to happen 297 if (waitForVSync) { 298 // This is where we spend most of our time, waiting 299 // for vsync events and new client registrations. 300 // 301 // If the screen is off, we can't use h/w vsync, so we 302 // use a 16ms timeout instead. It doesn't need to be 303 // precise, we just need to keep feeding our clients. 304 // 305 // We don't want to stall if there's a driver bug, so we 306 // use a (long) timeout when waiting for h/w vsync, and 307 // generate fake events when necessary. 308 bool softwareSync = mUseSoftwareVSync; 309 nsecs_t timeout = softwareSync ? ms2ns(16) : ms2ns(1000); 310 if (mCondition.waitRelative(mLock, timeout) == TIMED_OUT) { 311 if (!softwareSync) { 312 ALOGW("Timed out waiting for hw vsync; faking it"); 313 } 314 // FIXME: how do we decide which display id the fake 315 // vsync came from ? 316 mVSyncEvent[0].header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC; 317 mVSyncEvent[0].header.id = DisplayDevice::DISPLAY_PRIMARY; 318 mVSyncEvent[0].header.timestamp = systemTime(SYSTEM_TIME_MONOTONIC); 319 mVSyncEvent[0].vsync.count++; 320 } 321 } else { 322 // Nobody is interested in vsync, so we just want to sleep. 323 // h/w vsync should be disabled, so this will wait until we 324 // get a new connection, or an existing connection becomes 325 // interested in receiving vsync again. 326 mCondition.wait(mLock); 327 } 328 } 329 } while (signalConnections.isEmpty()); 330 331 // here we're guaranteed to have a timestamp and some connections to signal 332 // (The connections might have dropped out of mDisplayEventConnections 333 // while we were asleep, but we'll still have strong references to them.) 334 return signalConnections; 335 } 336 337 void EventThread::enableVSyncLocked() { 338 if (!mUseSoftwareVSync) { 339 // never enable h/w VSYNC when screen is off 340 if (!mVsyncEnabled) { 341 mVsyncEnabled = true; 342 mVSyncSource->setCallback(static_cast<VSyncSource::Callback*>(this)); 343 mVSyncSource->setVSyncEnabled(true); 344 } 345 } 346 mDebugVsyncEnabled = true; 347 sendVsyncHintOnLocked(); 348 } 349 350 void EventThread::disableVSyncLocked() { 351 if (mVsyncEnabled) { 352 mVsyncEnabled = false; 353 mVSyncSource->setVSyncEnabled(false); 354 mDebugVsyncEnabled = false; 355 } 356 } 357 358 void EventThread::dump(String8& result) const { 359 Mutex::Autolock _l(mLock); 360 result.appendFormat("VSYNC state: %s\n", 361 mDebugVsyncEnabled?"enabled":"disabled"); 362 result.appendFormat(" soft-vsync: %s\n", 363 mUseSoftwareVSync?"enabled":"disabled"); 364 result.appendFormat(" numListeners=%zu,\n events-delivered: %u\n", 365 mDisplayEventConnections.size(), 366 mVSyncEvent[DisplayDevice::DISPLAY_PRIMARY].vsync.count); 367 for (size_t i=0 ; i<mDisplayEventConnections.size() ; i++) { 368 sp<Connection> connection = 369 mDisplayEventConnections.itemAt(i).promote(); 370 result.appendFormat(" %p: count=%d\n", 371 connection.get(), connection!=NULL ? connection->count : 0); 372 } 373 } 374 375 // --------------------------------------------------------------------------- 376 377 EventThread::Connection::Connection( 378 const sp<EventThread>& eventThread) 379 : count(-1), mEventThread(eventThread), mChannel(new BitTube()) 380 { 381 } 382 383 EventThread::Connection::~Connection() { 384 // do nothing here -- clean-up will happen automatically 385 // when the main thread wakes up 386 } 387 388 void EventThread::Connection::onFirstRef() { 389 // NOTE: mEventThread doesn't hold a strong reference on us 390 mEventThread->registerDisplayEventConnection(this); 391 } 392 393 sp<BitTube> EventThread::Connection::getDataChannel() const { 394 return mChannel; 395 } 396 397 void EventThread::Connection::setVsyncRate(uint32_t count) { 398 mEventThread->setVsyncRate(count, this); 399 } 400 401 void EventThread::Connection::requestNextVsync() { 402 mEventThread->requestNextVsync(this); 403 } 404 405 status_t EventThread::Connection::postEvent( 406 const DisplayEventReceiver::Event& event) { 407 ssize_t size = DisplayEventReceiver::sendEvents(mChannel, &event, 1); 408 return size < 0 ? status_t(size) : status_t(NO_ERROR); 409 } 410 411 // --------------------------------------------------------------------------- 412 413 }; // namespace android 414