services/surfaceflinger/EventThread.cpp - platform/frameworks/native - Gitiles

 /*
  * 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 <gui/BitTube.h>
 #include <gui/IDisplayEventConnection.h>
 #include <gui/DisplayEventReceiver.h>

 #include <utils/Errors.h>
 #include <utils/Trace.h>

 #include "DisplayHardware/DisplayHardware.h"
 #include "EventThread.h"
 #include "SurfaceFlinger.h"

 // ---------------------------------------------------------------------------

 namespace android {

 // ---------------------------------------------------------------------------

 EventThread::EventThread(const sp<SurfaceFlinger>& flinger)
     : mFlinger(flinger),
       mHw(flinger->graphicPlane(0).editDisplayHardware()),
       mLastVSyncTimestamp(0),
       mVSyncTimestamp(0),
       mUseSoftwareVSync(false),
       mDeliveredEvents(0),
       mDebugVsyncEnabled(false)
 {
 }

 void EventThread::onFirstRef() {
     mHw.setVSyncHandler(this);
     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.signal();
     return NO_ERROR;
 }

 status_t EventThread::unregisterDisplayEventConnection(
         const wp<EventThread::Connection>& connection) {
     Mutex::Autolock _l(mLock);
     mDisplayEventConnections.remove(connection);
     mCondition.signal();
     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.signal();
         }
     }
 }

 void EventThread::requestNextVsync(
         const sp<EventThread::Connection>& connection) {
     Mutex::Autolock _l(mLock);
     if (connection->count < 0) {
         connection->count = 0;
         mCondition.signal();
     }
 }

 void EventThread::onScreenReleased() {
     Mutex::Autolock _l(mLock);
     // wait for an eventual pending vsync to be serviced
     if (!mUseSoftwareVSync) {
         while (mVSyncTimestamp) {
             mCondition.wait(mLock);
         }
     }
     // disable reliance on h/w vsync
     mUseSoftwareVSync = true;
 }

 void EventThread::onScreenAcquired() {
     Mutex::Autolock _l(mLock);
     mUseSoftwareVSync = false;
 }


 void EventThread::onVSyncReceived(int, nsecs_t timestamp) {
     Mutex::Autolock _l(mLock);
     mVSyncTimestamp = timestamp;
     mCondition.signal();
 }

 bool EventThread::threadLoop() {

     nsecs_t timestamp;
     DisplayEventReceiver::Event vsync;
     Vector< wp<EventThread::Connection> > displayEventConnections;

     do {
         Mutex::Autolock _l(mLock);
         do {
             // latch VSYNC event if any
             timestamp = mVSyncTimestamp;
             mVSyncTimestamp = 0;

             // check if we should be waiting for VSYNC events
             bool waitForNextVsync = false;
             size_t count = mDisplayEventConnections.size();
             for (size_t i=0 ; i<count ; i++) {
                 sp<Connection> connection =
                         mDisplayEventConnections.itemAt(i).promote();
                 if (connection!=0 && connection->count >= 0) {
                     // at least one continuous mode or active one-shot event
                     waitForNextVsync = true;
                     break;
                 }
             }

             if (timestamp) {
                 if (!waitForNextVsync) {
                     // we received a VSYNC but we have no clients
                     // don't report it, and disable VSYNC events
                     disableVSyncLocked();
                 } else {
                     // report VSYNC event
                     break;
                 }
             } else {
                 // never disable VSYNC events immediately, instead
                 // we'll wait to receive the event and we'll
                 // reevaluate whether we need to dispatch it and/or
                 // disable VSYNC events then.
                 if (waitForNextVsync) {
                     // enable
                     enableVSyncLocked();
                 }
             }

             // wait for something to happen
             if (mUseSoftwareVSync && waitForNextVsync) {
                 // h/w vsync cannot be used (screen is off), so we use
                 // a  timeout instead. it doesn't matter how imprecise this
                 // is, we just need to make sure to serve the clients
                 if (mCondition.waitRelative(mLock, ms2ns(16)) == TIMED_OUT) {
                     mVSyncTimestamp = systemTime(SYSTEM_TIME_MONOTONIC);
                 }
             } else {
                 mCondition.wait(mLock);
             }
         } while(true);

         // process vsync event
         mDeliveredEvents++;
         mLastVSyncTimestamp = timestamp;

         // now see if we still need to report this VSYNC event
         const size_t count = mDisplayEventConnections.size();
         for (size_t i=0 ; i<count ; i++) {
             bool reportVsync = false;
             sp<Connection> connection =
                     mDisplayEventConnections.itemAt(i).promote();
             if (connection == 0)
                 continue;

             const int32_t count = connection->count;
             if (count >= 1) {
                 if (count==1 || (mDeliveredEvents % count) == 0) {
                     // continuous event, and time to report it
                     reportVsync = true;
                 }
             } else if (count >= -1) {
                 if (count == 0) {
                     // fired this time around
                     reportVsync = true;
                 }
                 connection->count--;
             }
             if (reportVsync) {
                 displayEventConnections.add(connection);
             }
         }
     } while (!displayEventConnections.size());

     // dispatch vsync events to listeners...
     vsync.header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC;
     vsync.header.timestamp = timestamp;
     vsync.vsync.count = mDeliveredEvents;

     const size_t count = displayEventConnections.size();
     for (size_t i=0 ; i<count ; i++) {
         sp<Connection> conn(displayEventConnections[i].promote());
         // make sure the connection didn't die
         if (conn != NULL) {
             status_t err = conn->postEvent(vsync);
             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.
                 // 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, but it doesn't matter for VSYNC.
             } 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(displayEventConnections[i]);
             }
         } else {
             // somehow the connection is dead, but we still have it in our list
             // just clean the list.
             removeDisplayEventConnection(displayEventConnections[i]);
         }
     }

     // clear all our references without holding mLock
     displayEventConnections.clear();

     return true;
 }

 void EventThread::enableVSyncLocked() {
     if (!mUseSoftwareVSync) {
         // never enable h/w VSYNC when screen is off
         mHw.eventControl(DisplayHardware::EVENT_VSYNC, true);
     }
     mDebugVsyncEnabled = true;
 }

 void EventThread::disableVSyncLocked() {
     mHw.eventControl(DisplayHardware::EVENT_VSYNC, false);
     mDebugVsyncEnabled = false;
 }

 status_t EventThread::readyToRun() {
     ALOGI("EventThread ready to run.");
     return NO_ERROR;
 }

 void EventThread::dump(String8& result, char* buffer, size_t SIZE) 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=%u,\n  events-delivered: %u\n",
             mDisplayEventConnections.size(), mDeliveredEvents);
     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() {
     mEventThread->unregisterDisplayEventConnection(this);
 }

 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
	/*
	* 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 <gui/BitTube.h>
	#include <gui/IDisplayEventConnection.h>
	#include <gui/DisplayEventReceiver.h>

	#include <utils/Errors.h>
	#include <utils/Trace.h>

	#include "DisplayHardware/DisplayHardware.h"
	#include "EventThread.h"
	#include "SurfaceFlinger.h"

	// ---------------------------------------------------------------------------

	namespace android {

	// ---------------------------------------------------------------------------

	EventThread::EventThread(const sp<SurfaceFlinger>& flinger)
	: mFlinger(flinger),
	mHw(flinger->graphicPlane(0).editDisplayHardware()),
	mLastVSyncTimestamp(0),
	mVSyncTimestamp(0),
	mUseSoftwareVSync(false),
	mDeliveredEvents(0),
	mDebugVsyncEnabled(false)
	{
	}

	void EventThread::onFirstRef() {
	mHw.setVSyncHandler(this);
	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.signal();
	return NO_ERROR;
	}

	status_t EventThread::unregisterDisplayEventConnection(
	const wp<EventThread::Connection>& connection) {
	Mutex::Autolock _l(mLock);
	mDisplayEventConnections.remove(connection);
	mCondition.signal();
	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.signal();
	}
	}
	}

	void EventThread::requestNextVsync(
	const sp<EventThread::Connection>& connection) {
	Mutex::Autolock _l(mLock);
	if (connection->count < 0) {
	connection->count = 0;
	mCondition.signal();
	}
	}

	void EventThread::onScreenReleased() {
	Mutex::Autolock _l(mLock);
	// wait for an eventual pending vsync to be serviced
	if (!mUseSoftwareVSync) {
	while (mVSyncTimestamp) {
	mCondition.wait(mLock);
	}
	}
	// disable reliance on h/w vsync
	mUseSoftwareVSync = true;
	}

	void EventThread::onScreenAcquired() {
	Mutex::Autolock _l(mLock);
	mUseSoftwareVSync = false;
	}


	void EventThread::onVSyncReceived(int, nsecs_t timestamp) {
	Mutex::Autolock _l(mLock);
	mVSyncTimestamp = timestamp;
	mCondition.signal();
	}

	bool EventThread::threadLoop() {

	nsecs_t timestamp;
	DisplayEventReceiver::Event vsync;
	Vector< wp<EventThread::Connection> > displayEventConnections;

	do {
	Mutex::Autolock _l(mLock);
	do {
	// latch VSYNC event if any
	timestamp = mVSyncTimestamp;
	mVSyncTimestamp = 0;

	// check if we should be waiting for VSYNC events
	bool waitForNextVsync = false;
	size_t count = mDisplayEventConnections.size();
	for (size_t i=0 ; i<count ; i++) {
	sp<Connection> connection =
	mDisplayEventConnections.itemAt(i).promote();
	if (connection!=0 && connection->count >= 0) {
	// at least one continuous mode or active one-shot event
	waitForNextVsync = true;
	break;
	}
	}

	if (timestamp) {
	if (!waitForNextVsync) {
	// we received a VSYNC but we have no clients
	// don't report it, and disable VSYNC events
	disableVSyncLocked();
	} else {
	// report VSYNC event
	break;
	}
	} else {
	// never disable VSYNC events immediately, instead
	// we'll wait to receive the event and we'll
	// reevaluate whether we need to dispatch it and/or
	// disable VSYNC events then.
	if (waitForNextVsync) {
	// enable
	enableVSyncLocked();
	}
	}

	// wait for something to happen
	if (mUseSoftwareVSync && waitForNextVsync) {
	// h/w vsync cannot be used (screen is off), so we use
	// a timeout instead. it doesn't matter how imprecise this
	// is, we just need to make sure to serve the clients
	if (mCondition.waitRelative(mLock, ms2ns(16)) == TIMED_OUT) {
	mVSyncTimestamp = systemTime(SYSTEM_TIME_MONOTONIC);
	}
	} else {
	mCondition.wait(mLock);
	}
	} while(true);

	// process vsync event
	mDeliveredEvents++;
	mLastVSyncTimestamp = timestamp;

	// now see if we still need to report this VSYNC event
	const size_t count = mDisplayEventConnections.size();
	for (size_t i=0 ; i<count ; i++) {
	bool reportVsync = false;
	sp<Connection> connection =
	mDisplayEventConnections.itemAt(i).promote();
	if (connection == 0)
	continue;

	const int32_t count = connection->count;
	if (count >= 1) {
	if (count==1 \|\| (mDeliveredEvents % count) == 0) {
	// continuous event, and time to report it
	reportVsync = true;
	}
	} else if (count >= -1) {
	if (count == 0) {
	// fired this time around
	reportVsync = true;
	}
	connection->count--;
	}
	if (reportVsync) {
	displayEventConnections.add(connection);
	}
	}
	} while (!displayEventConnections.size());

	// dispatch vsync events to listeners...
	vsync.header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC;
	vsync.header.timestamp = timestamp;
	vsync.vsync.count = mDeliveredEvents;

	const size_t count = displayEventConnections.size();
	for (size_t i=0 ; i<count ; i++) {
	sp<Connection> conn(displayEventConnections[i].promote());
	// make sure the connection didn't die
	if (conn != NULL) {
	status_t err = conn->postEvent(vsync);
	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.
	// 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, but it doesn't matter for VSYNC.
	} 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(displayEventConnections[i]);
	}
	} else {
	// somehow the connection is dead, but we still have it in our list
	// just clean the list.
	removeDisplayEventConnection(displayEventConnections[i]);
	}
	}

	// clear all our references without holding mLock
	displayEventConnections.clear();

	return true;
	}

	void EventThread::enableVSyncLocked() {
	if (!mUseSoftwareVSync) {
	// never enable h/w VSYNC when screen is off
	mHw.eventControl(DisplayHardware::EVENT_VSYNC, true);
	}
	mDebugVsyncEnabled = true;
	}

	void EventThread::disableVSyncLocked() {
	mHw.eventControl(DisplayHardware::EVENT_VSYNC, false);
	mDebugVsyncEnabled = false;
	}

	status_t EventThread::readyToRun() {
	ALOGI("EventThread ready to run.");
	return NO_ERROR;
	}

	void EventThread::dump(String8& result, char* buffer, size_t SIZE) 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=%u,\n events-delivered: %u\n",
	mDisplayEventConnections.size(), mDeliveredEvents);
	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() {
	mEventThread->unregisterDisplayEventConnection(this);
	}

	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