services/surfaceflinger/EventThread.cpp

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