| /* |
| * Copyright (C) 2011 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define ATRACE_TAG ATRACE_TAG_GRAPHICS |
| |
| #include <stdint.h> |
| #include <sys/types.h> |
| |
| #include <cutils/compiler.h> |
| |
| #include <gui/BitTube.h> |
| #include <gui/IDisplayEventConnection.h> |
| #include <gui/DisplayEventReceiver.h> |
| |
| #include <utils/Errors.h> |
| #include <utils/String8.h> |
| #include <utils/Trace.h> |
| |
| #include "EventThread.h" |
| #include "SurfaceFlinger.h" |
| |
| // --------------------------------------------------------------------------- |
| namespace android { |
| // --------------------------------------------------------------------------- |
| // time to wait between VSYNC requests before sending a VSYNC OFF power hint: 40msec. |
| const long vsyncHintOffDelay = 40000000; |
| |
| static void vsyncOffCallback(union sigval val) { |
| EventThread *ev = (EventThread *)val.sival_ptr; |
| ev->sendVsyncHintOff(); |
| return; |
| } |
| |
| EventThread::EventThread(const sp<VSyncSource>& src, SurfaceFlinger& flinger) |
| : mVSyncSource(src), |
| mFlinger(flinger), |
| mUseSoftwareVSync(false), |
| mVsyncEnabled(false), |
| mDebugVsyncEnabled(false), |
| mVsyncHintSent(false) { |
| |
| for (int32_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) { |
| mVSyncEvent[i].header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC; |
| mVSyncEvent[i].header.id = 0; |
| mVSyncEvent[i].header.timestamp = 0; |
| mVSyncEvent[i].vsync.count = 0; |
| } |
| struct sigevent se; |
| se.sigev_notify = SIGEV_THREAD; |
| se.sigev_value.sival_ptr = this; |
| se.sigev_notify_function = vsyncOffCallback; |
| se.sigev_notify_attributes = NULL; |
| timer_create(CLOCK_MONOTONIC, &se, &mTimerId); |
| } |
| |
| void EventThread::sendVsyncHintOff() { |
| Mutex::Autolock _l(mLock); |
| mPowerHAL.vsyncHint(false); |
| mVsyncHintSent = false; |
| } |
| |
| void EventThread::setPhaseOffset(nsecs_t phaseOffset) { |
| Mutex::Autolock _l(mLock); |
| mVSyncSource->setPhaseOffset(phaseOffset); |
| } |
| |
| void EventThread::sendVsyncHintOnLocked() { |
| struct itimerspec ts; |
| if(!mVsyncHintSent) { |
| mPowerHAL.vsyncHint(true); |
| mVsyncHintSent = true; |
| } |
| ts.it_value.tv_sec = 0; |
| ts.it_value.tv_nsec = vsyncHintOffDelay; |
| ts.it_interval.tv_sec = 0; |
| ts.it_interval.tv_nsec = 0; |
| timer_settime(mTimerId, 0, &ts, NULL); |
| } |
| |
| void EventThread::onFirstRef() { |
| run("EventThread", PRIORITY_URGENT_DISPLAY + PRIORITY_MORE_FAVORABLE); |
| } |
| |
| sp<EventThread::Connection> EventThread::createEventConnection() const { |
| return new Connection(const_cast<EventThread*>(this)); |
| } |
| |
| status_t EventThread::registerDisplayEventConnection( |
| const sp<EventThread::Connection>& connection) { |
| Mutex::Autolock _l(mLock); |
| mDisplayEventConnections.add(connection); |
| mCondition.broadcast(); |
| return NO_ERROR; |
| } |
| |
| void EventThread::removeDisplayEventConnection( |
| const wp<EventThread::Connection>& connection) { |
| Mutex::Autolock _l(mLock); |
| mDisplayEventConnections.remove(connection); |
| } |
| |
| void EventThread::setVsyncRate(uint32_t count, |
| const sp<EventThread::Connection>& connection) { |
| if (int32_t(count) >= 0) { // server must protect against bad params |
| Mutex::Autolock _l(mLock); |
| const int32_t new_count = (count == 0) ? -1 : count; |
| if (connection->count != new_count) { |
| connection->count = new_count; |
| mCondition.broadcast(); |
| } |
| } |
| } |
| |
| void EventThread::requestNextVsync( |
| const sp<EventThread::Connection>& connection) { |
| Mutex::Autolock _l(mLock); |
| |
| mFlinger.resyncWithRateLimit(); |
| |
| if (connection->count < 0) { |
| connection->count = 0; |
| mCondition.broadcast(); |
| } |
| } |
| |
| void EventThread::onScreenReleased() { |
| Mutex::Autolock _l(mLock); |
| if (!mUseSoftwareVSync) { |
| // disable reliance on h/w vsync |
| mUseSoftwareVSync = true; |
| mCondition.broadcast(); |
| } |
| } |
| |
| void EventThread::onScreenAcquired() { |
| Mutex::Autolock _l(mLock); |
| if (mUseSoftwareVSync) { |
| // resume use of h/w vsync |
| mUseSoftwareVSync = false; |
| mCondition.broadcast(); |
| } |
| } |
| |
| void EventThread::onVSyncEvent(nsecs_t timestamp) { |
| Mutex::Autolock _l(mLock); |
| mVSyncEvent[0].header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC; |
| mVSyncEvent[0].header.id = 0; |
| mVSyncEvent[0].header.timestamp = timestamp; |
| mVSyncEvent[0].vsync.count++; |
| mCondition.broadcast(); |
| } |
| |
| void EventThread::onHotplugReceived(int type, bool connected) { |
| ALOGE_IF(type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES, |
| "received hotplug event for an invalid display (id=%d)", type); |
| |
| Mutex::Autolock _l(mLock); |
| if (type < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) { |
| DisplayEventReceiver::Event event; |
| event.header.type = DisplayEventReceiver::DISPLAY_EVENT_HOTPLUG; |
| event.header.id = type; |
| event.header.timestamp = systemTime(); |
| event.hotplug.connected = connected; |
| mPendingEvents.add(event); |
| mCondition.broadcast(); |
| } |
| } |
| |
| bool EventThread::threadLoop() { |
| DisplayEventReceiver::Event event; |
| Vector< sp<EventThread::Connection> > signalConnections; |
| signalConnections = waitForEvent(&event); |
| |
| // dispatch events to listeners... |
| const size_t count = signalConnections.size(); |
| for (size_t i=0 ; i<count ; i++) { |
| const sp<Connection>& conn(signalConnections[i]); |
| // now see if we still need to report this event |
| status_t err = conn->postEvent(event); |
| if (err == -EAGAIN || err == -EWOULDBLOCK) { |
| // The destination doesn't accept events anymore, it's probably |
| // full. For now, we just drop the events on the floor. |
| // FIXME: Note that some events cannot be dropped and would have |
| // to be re-sent later. |
| // Right-now we don't have the ability to do this. |
| ALOGW("EventThread: dropping event (%08x) for connection %p", |
| event.header.type, conn.get()); |
| } else if (err < 0) { |
| // handle any other error on the pipe as fatal. the only |
| // reasonable thing to do is to clean-up this connection. |
| // The most common error we'll get here is -EPIPE. |
| removeDisplayEventConnection(signalConnections[i]); |
| } |
| } |
| return true; |
| } |
| |
| // This will return when (1) a vsync event has been received, and (2) there was |
| // at least one connection interested in receiving it when we started waiting. |
| Vector< sp<EventThread::Connection> > EventThread::waitForEvent( |
| DisplayEventReceiver::Event* event) |
| { |
| Mutex::Autolock _l(mLock); |
| Vector< sp<EventThread::Connection> > signalConnections; |
| |
| do { |
| bool eventPending = false; |
| bool waitForVSync = false; |
| |
| size_t vsyncCount = 0; |
| nsecs_t timestamp = 0; |
| for (int32_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) { |
| timestamp = mVSyncEvent[i].header.timestamp; |
| if (timestamp) { |
| // we have a vsync event to dispatch |
| *event = mVSyncEvent[i]; |
| mVSyncEvent[i].header.timestamp = 0; |
| vsyncCount = mVSyncEvent[i].vsync.count; |
| break; |
| } |
| } |
| |
| if (!timestamp) { |
| // no vsync event, see if there are some other event |
| eventPending = !mPendingEvents.isEmpty(); |
| if (eventPending) { |
| // we have some other event to dispatch |
| *event = mPendingEvents[0]; |
| mPendingEvents.removeAt(0); |
| } |
| } |
| |
| // find out connections waiting for events |
| size_t count = mDisplayEventConnections.size(); |
| for (size_t i=0 ; i<count ; i++) { |
| sp<Connection> connection(mDisplayEventConnections[i].promote()); |
| if (connection != NULL) { |
| bool added = false; |
| if (connection->count >= 0) { |
| // we need vsync events because at least |
| // one connection is waiting for it |
| waitForVSync = true; |
| if (timestamp) { |
| // we consume the event only if it's time |
| // (ie: we received a vsync event) |
| if (connection->count == 0) { |
| // fired this time around |
| connection->count = -1; |
| signalConnections.add(connection); |
| added = true; |
| } else if (connection->count == 1 || |
| (vsyncCount % connection->count) == 0) { |
| // continuous event, and time to report it |
| signalConnections.add(connection); |
| added = true; |
| } |
| } |
| } |
| |
| if (eventPending && !timestamp && !added) { |
| // we don't have a vsync event to process |
| // (timestamp==0), but we have some pending |
| // messages. |
| signalConnections.add(connection); |
| } |
| } else { |
| // we couldn't promote this reference, the connection has |
| // died, so clean-up! |
| mDisplayEventConnections.removeAt(i); |
| --i; --count; |
| } |
| } |
| |
| // Here we figure out if we need to enable or disable vsyncs |
| if (timestamp && !waitForVSync) { |
| // we received a VSYNC but we have no clients |
| // don't report it, and disable VSYNC events |
| disableVSyncLocked(); |
| } else if (!timestamp && waitForVSync) { |
| // we have at least one client, so we want vsync enabled |
| // (TODO: this function is called right after we finish |
| // notifying clients of a vsync, so this call will be made |
| // at the vsync rate, e.g. 60fps. If we can accurately |
| // track the current state we could avoid making this call |
| // so often.) |
| enableVSyncLocked(); |
| } |
| |
| // note: !timestamp implies signalConnections.isEmpty(), because we |
| // don't populate signalConnections if there's no vsync pending |
| if (!timestamp && !eventPending) { |
| // wait for something to happen |
| if (waitForVSync) { |
| // This is where we spend most of our time, waiting |
| // for vsync events and new client registrations. |
| // |
| // If the screen is off, we can't use h/w vsync, so we |
| // use a 16ms timeout instead. It doesn't need to be |
| // precise, we just need to keep feeding our clients. |
| // |
| // We don't want to stall if there's a driver bug, so we |
| // use a (long) timeout when waiting for h/w vsync, and |
| // generate fake events when necessary. |
| bool softwareSync = mUseSoftwareVSync; |
| nsecs_t timeout = softwareSync ? ms2ns(16) : ms2ns(1000); |
| if (mCondition.waitRelative(mLock, timeout) == TIMED_OUT) { |
| if (!softwareSync) { |
| ALOGW("Timed out waiting for hw vsync; faking it"); |
| } |
| // FIXME: how do we decide which display id the fake |
| // vsync came from ? |
| mVSyncEvent[0].header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC; |
| mVSyncEvent[0].header.id = DisplayDevice::DISPLAY_PRIMARY; |
| mVSyncEvent[0].header.timestamp = systemTime(SYSTEM_TIME_MONOTONIC); |
| mVSyncEvent[0].vsync.count++; |
| } |
| } else { |
| // Nobody is interested in vsync, so we just want to sleep. |
| // h/w vsync should be disabled, so this will wait until we |
| // get a new connection, or an existing connection becomes |
| // interested in receiving vsync again. |
| mCondition.wait(mLock); |
| } |
| } |
| } while (signalConnections.isEmpty()); |
| |
| // here we're guaranteed to have a timestamp and some connections to signal |
| // (The connections might have dropped out of mDisplayEventConnections |
| // while we were asleep, but we'll still have strong references to them.) |
| return signalConnections; |
| } |
| |
| void EventThread::enableVSyncLocked() { |
| if (!mUseSoftwareVSync) { |
| // never enable h/w VSYNC when screen is off |
| if (!mVsyncEnabled) { |
| mVsyncEnabled = true; |
| mVSyncSource->setCallback(static_cast<VSyncSource::Callback*>(this)); |
| mVSyncSource->setVSyncEnabled(true); |
| } |
| } |
| mDebugVsyncEnabled = true; |
| sendVsyncHintOnLocked(); |
| } |
| |
| void EventThread::disableVSyncLocked() { |
| if (mVsyncEnabled) { |
| mVsyncEnabled = false; |
| mVSyncSource->setVSyncEnabled(false); |
| mDebugVsyncEnabled = false; |
| } |
| } |
| |
| void EventThread::dump(String8& result) const { |
| Mutex::Autolock _l(mLock); |
| result.appendFormat("VSYNC state: %s\n", |
| mDebugVsyncEnabled?"enabled":"disabled"); |
| result.appendFormat(" soft-vsync: %s\n", |
| mUseSoftwareVSync?"enabled":"disabled"); |
| result.appendFormat(" numListeners=%zu,\n events-delivered: %u\n", |
| mDisplayEventConnections.size(), |
| mVSyncEvent[DisplayDevice::DISPLAY_PRIMARY].vsync.count); |
| for (size_t i=0 ; i<mDisplayEventConnections.size() ; i++) { |
| sp<Connection> connection = |
| mDisplayEventConnections.itemAt(i).promote(); |
| result.appendFormat(" %p: count=%d\n", |
| connection.get(), connection!=NULL ? connection->count : 0); |
| } |
| } |
| |
| // --------------------------------------------------------------------------- |
| |
| EventThread::Connection::Connection( |
| const sp<EventThread>& eventThread) |
| : count(-1), mEventThread(eventThread), mChannel(new BitTube()) |
| { |
| } |
| |
| EventThread::Connection::~Connection() { |
| // do nothing here -- clean-up will happen automatically |
| // when the main thread wakes up |
| } |
| |
| void EventThread::Connection::onFirstRef() { |
| // NOTE: mEventThread doesn't hold a strong reference on us |
| mEventThread->registerDisplayEventConnection(this); |
| } |
| |
| sp<BitTube> EventThread::Connection::getDataChannel() const { |
| return mChannel; |
| } |
| |
| void EventThread::Connection::setVsyncRate(uint32_t count) { |
| mEventThread->setVsyncRate(count, this); |
| } |
| |
| void EventThread::Connection::requestNextVsync() { |
| mEventThread->requestNextVsync(this); |
| } |
| |
| status_t EventThread::Connection::postEvent( |
| const DisplayEventReceiver::Event& event) { |
| ssize_t size = DisplayEventReceiver::sendEvents(mChannel, &event, 1); |
| return size < 0 ? status_t(size) : status_t(NO_ERROR); |
| } |
| |
| // --------------------------------------------------------------------------- |
| |
| }; // namespace android |