am faf77cce: SurfaceFlinger: SW-based vsync events (790b6d09) · Commits · e / os / platform_frameworks_native

services/surfaceflinger/Android.mk

+18 −0

Original line number	Original line	Diff line number	Diff line
	@@ -4,6 +4,7 @@ include $(CLEAR_VARS)
	LOCAL_SRC_FILES:= \		LOCAL_SRC_FILES:= \
	Client.cpp \		Client.cpp \
	DisplayDevice.cpp \		DisplayDevice.cpp \
			DispSync.cpp \
	EventThread.cpp \		EventThread.cpp \
	FrameTracker.cpp \		FrameTracker.cpp \
	Layer.cpp \		Layer.cpp \
	@@ -53,6 +54,23 @@ ifneq ($(NUM_FRAMEBUFFER_SURFACE_BUFFERS),)
	LOCAL_CFLAGS += -DNUM_FRAMEBUFFER_SURFACE_BUFFERS=$(NUM_FRAMEBUFFER_SURFACE_BUFFERS)		LOCAL_CFLAGS += -DNUM_FRAMEBUFFER_SURFACE_BUFFERS=$(NUM_FRAMEBUFFER_SURFACE_BUFFERS)
	endif		endif

			ifeq ($(TARGET_RUNNING_WITHOUT_SYNC_FRAMEWORK),true)
			LOCAL_CFLAGS += -DRUNNING_WITHOUT_SYNC_FRAMEWORK
			endif

			# See build/target/board/generic/BoardConfig.mk for a description of this setting.
			ifneq ($(VSYNC_EVENT_PHASE_OFFSET_NS),)
			LOCAL_CFLAGS += -DVSYNC_EVENT_PHASE_OFFSET_NS=$(VSYNC_EVENT_PHASE_OFFSET_NS)
			else
			LOCAL_CFLAGS += -DVSYNC_EVENT_PHASE_OFFSET_NS=0
			endif

			ifneq ($(PRESENT_TIME_OFFSET_FROM_VSYNC_NS),)
			LOCAL_CFLAGS += -DPRESENT_TIME_OFFSET_FROM_VSYNC_NS=$(PRESENT_TIME_OFFSET_FROM_VSYNC_NS)
			else
			LOCAL_CFLAGS += -DPRESENT_TIME_OFFSET_FROM_VSYNC_NS=0
			endif

	LOCAL_CFLAGS += -fvisibility=hidden		LOCAL_CFLAGS += -fvisibility=hidden

	LOCAL_SHARED_LIBRARIES := \		LOCAL_SHARED_LIBRARIES := \

services/surfaceflinger/DispSync.cpp

0 → 100644

+482 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2013 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

			// This is needed for stdint.h to define INT64_MAX in C++
			#define __STDC_LIMIT_MACROS

			#include <math.h>

			#include <cutils/log.h>

			#include <ui/Fence.h>

			#include <utils/String8.h>
			#include <utils/Thread.h>
			#include <utils/Trace.h>
			#include <utils/Vector.h>

			#include "DispSync.h"
			#include "EventLog/EventLog.h"

			namespace android {

			// Setting this to true enables verbose tracing that can be used to debug
			// vsync event model or phase issues.
			static const bool traceDetailedInfo = false;

			// This is the threshold used to determine when hardware vsync events are
			// needed to re-synchronize the software vsync model with the hardware. The
			// error metric used is the mean of the squared difference between each
			// present time and the nearest software-predicted vsync.
			static const nsecs_t errorThreshold = 160000000000;

			// This works around the lack of support for the sync framework on some
			// devices.
			#ifdef RUNNING_WITHOUT_SYNC_FRAMEWORK
			static const bool runningWithoutSyncFramework = true;
			#else
			static const bool runningWithoutSyncFramework = false;
			#endif

			// This is the offset from the present fence timestamps to the corresponding
			// vsync event.
			static const int64_t presentTimeOffset = PRESENT_TIME_OFFSET_FROM_VSYNC_NS;

			class DispSyncThread: public Thread {
			public:

			DispSyncThread():
			mStop(false),
			mPeriod(0),
			mPhase(0),
			mWakeupLatency(0) {
			}

			virtual ~DispSyncThread() {}

			void updateModel(nsecs_t period, nsecs_t phase) {
			Mutex::Autolock lock(mMutex);
			mPeriod = period;
			mPhase = phase;
			mCond.signal();
			}

			void stop() {
			Mutex::Autolock lock(mMutex);
			mStop = true;
			mCond.signal();
			}

			virtual bool threadLoop() {
			status_t err;
			nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
			nsecs_t nextEventTime = 0;

			while (true) {
			Vector<CallbackInvocation> callbackInvocations;

			nsecs_t targetTime = 0;

			{ // Scope for lock
			Mutex::Autolock lock(mMutex);

			if (mStop) {
			return false;
			}

			if (mPeriod == 0) {
			err = mCond.wait(mMutex);
			if (err != NO_ERROR) {
			ALOGE("error waiting for new events: %s (%d)",
			strerror(-err), err);
			return false;
			}
			continue;
			}

			nextEventTime = computeNextEventTimeLocked(now);
			targetTime = nextEventTime - mWakeupLatency;

			bool isWakeup = false;

			if (now < targetTime) {
			err = mCond.waitRelative(mMutex, targetTime - now);

			if (err == TIMED_OUT) {
			isWakeup = true;
			} else if (err != NO_ERROR) {
			ALOGE("error waiting for next event: %s (%d)",
			strerror(-err), err);
			return false;
			}
			}

			now = systemTime(SYSTEM_TIME_MONOTONIC);

			if (isWakeup) {
			mWakeupLatency = ((mWakeupLatency * 63) +
			(now - targetTime)) / 64;
			if (mWakeupLatency > 500000) {
			// Don't correct by more than 500 us
			mWakeupLatency = 500000;
			}
			if (traceDetailedInfo) {
			ATRACE_INT64("DispSync:WakeupLat", now - nextEventTime);
			ATRACE_INT64("DispSync:AvgWakeupLat", mWakeupLatency);
			}
			}

			callbackInvocations = gatherCallbackInvocationsLocked(now);
			}

			if (callbackInvocations.size() > 0) {
			fireCallbackInvocations(callbackInvocations);
			}
			}

			return false;
			}

			status_t addEventListener(nsecs_t phase, const sp<DispSync::Callback>& callback) {
			Mutex::Autolock lock(mMutex);

			for (size_t i = 0; i < mEventListeners.size(); i++) {
			if (mEventListeners[i].mCallback == callback) {
			return BAD_VALUE;
			}
			}

			EventListener listener;
			listener.mPhase = phase;
			listener.mCallback = callback;
			listener.mLastEventTime = systemTime(SYSTEM_TIME_MONOTONIC);
			mEventListeners.push(listener);

			mCond.signal();

			return NO_ERROR;
			}

			status_t removeEventListener(const sp<DispSync::Callback>& callback) {
			Mutex::Autolock lock(mMutex);

			for (size_t i = 0; i < mEventListeners.size(); i++) {
			if (mEventListeners[i].mCallback == callback) {
			mEventListeners.removeAt(i);
			mCond.signal();
			return NO_ERROR;
			}
			}

			return BAD_VALUE;
			}

			// This method is only here to handle the runningWithoutSyncFramework
			// case.
			bool hasAnyEventListeners() {
			Mutex::Autolock lock(mMutex);
			return !mEventListeners.empty();
			}

			private:

			struct EventListener {
			nsecs_t mPhase;
			nsecs_t mLastEventTime;
			sp<DispSync::Callback> mCallback;
			};

			struct CallbackInvocation {
			sp<DispSync::Callback> mCallback;
			nsecs_t mEventTime;
			};

			nsecs_t computeNextEventTimeLocked(nsecs_t now) {
			nsecs_t nextEventTime = INT64_MAX;
			for (size_t i = 0; i < mEventListeners.size(); i++) {
			nsecs_t t = computeListenerNextEventTimeLocked(mEventListeners[i],
			now);

			if (t < nextEventTime) {
			nextEventTime = t;
			}
			}

			return nextEventTime;
			}

			Vector<CallbackInvocation> gatherCallbackInvocationsLocked(nsecs_t now) {
			Vector<CallbackInvocation> callbackInvocations;
			nsecs_t ref = now - mPeriod;

			for (size_t i = 0; i < mEventListeners.size(); i++) {
			nsecs_t t = computeListenerNextEventTimeLocked(mEventListeners[i],
			ref);

			if (t - mWakeupLatency < now) {
			CallbackInvocation ci;
			ci.mCallback = mEventListeners[i].mCallback;
			ci.mEventTime = t;
			callbackInvocations.push(ci);
			mEventListeners.editItemAt(i).mLastEventTime = t;
			}
			}

			return callbackInvocations;
			}

			nsecs_t computeListenerNextEventTimeLocked(const EventListener& listener,
			nsecs_t ref) {

			nsecs_t lastEventTime = listener.mLastEventTime;
			if (ref < lastEventTime) {
			ref = lastEventTime;
			}

			nsecs_t phase = mPhase + listener.mPhase;
			nsecs_t t = (((ref - phase) / mPeriod) + 1) * mPeriod + phase;

			if (t - listener.mLastEventTime < mPeriod / 2) {
			t += mPeriod;
			}

			return t;
			}

			void fireCallbackInvocations(const Vector<CallbackInvocation>& callbacks) {
			for (size_t i = 0; i < callbacks.size(); i++) {
			callbacks[i].mCallback->onDispSyncEvent(callbacks[i].mEventTime);
			}
			}

			bool mStop;

			nsecs_t mPeriod;
			nsecs_t mPhase;
			nsecs_t mWakeupLatency;

			Vector<EventListener> mEventListeners;

			Mutex mMutex;
			Condition mCond;
			};

			class ZeroPhaseTracer : public DispSync::Callback {
			public:
			ZeroPhaseTracer() : mParity(false) {}

			virtual void onDispSyncEvent(nsecs_t when) {
			mParity = !mParity;
			ATRACE_INT("ZERO_PHASE_VSYNC", mParity ? 1 : 0);
			}

			private:
			bool mParity;
			};

			DispSync::DispSync() {
			mThread = new DispSyncThread();
			mThread->run("DispSync", PRIORITY_URGENT_DISPLAY + PRIORITY_MORE_FAVORABLE);

			reset();
			beginResync();

			if (traceDetailedInfo) {
			// If runningWithoutSyncFramework is true then the ZeroPhaseTracer
			// would prevent HW vsync event from ever being turned off.
			// Furthermore the zero-phase tracing is not needed because any time
			// there is an event registered we will turn on the HW vsync events.
			if (!runningWithoutSyncFramework) {
			addEventListener(0, new ZeroPhaseTracer());
			}
			}
			}

			DispSync::~DispSync() {}

			void DispSync::reset() {
			Mutex::Autolock lock(mMutex);

			mNumResyncSamples = 0;
			mFirstResyncSample = 0;
			mNumResyncSamplesSincePresent = 0;
			resetErrorLocked();
			}

			bool DispSync::addPresentFence(const sp<Fence>& fence) {
			Mutex::Autolock lock(mMutex);

			mPresentFences[mPresentSampleOffset] = fence;
			mPresentTimes[mPresentSampleOffset] = 0;
			mPresentSampleOffset = (mPresentSampleOffset + 1) % NUM_PRESENT_SAMPLES;
			mNumResyncSamplesSincePresent = 0;

			for (size_t i = 0; i < NUM_PRESENT_SAMPLES; i++) {
			const sp<Fence>& f(mPresentFences[i]);
			if (f != NULL) {
			nsecs_t t = f->getSignalTime();
			if (t < INT64_MAX) {
			mPresentFences[i].clear();
			mPresentTimes[i] = t + presentTimeOffset;
			}
			}
			}

			updateErrorLocked();

			return mPeriod == 0 \|\| mError > errorThreshold;
			}

			void DispSync::beginResync() {
			Mutex::Autolock lock(mMutex);

			mNumResyncSamples = 0;
			}

			bool DispSync::addResyncSample(nsecs_t timestamp) {
			Mutex::Autolock lock(mMutex);

			size_t idx = (mFirstResyncSample + mNumResyncSamples) % MAX_RESYNC_SAMPLES;
			mResyncSamples[idx] = timestamp;

			if (mNumResyncSamples < MAX_RESYNC_SAMPLES) {
			mNumResyncSamples++;
			} else {
			mFirstResyncSample = (mFirstResyncSample + 1) % MAX_RESYNC_SAMPLES;
			}

			updateModelLocked();

			if (mNumResyncSamplesSincePresent++ > MAX_RESYNC_SAMPLES_WITHOUT_PRESENT) {
			resetErrorLocked();
			}

			if (runningWithoutSyncFramework) {
			// If we don't have the sync framework we will never have
			// addPresentFence called. This means we have no way to know whether
			// or not we're synchronized with the HW vsyncs, so we just request
			// that the HW vsync events be turned on whenever we need to generate
			// SW vsync events.
			return mThread->hasAnyEventListeners();
			}

			return mPeriod == 0 \|\| mError > errorThreshold;
			}

			void DispSync::endResync() {
			}

			status_t DispSync::addEventListener(nsecs_t phase,
			const sp<Callback>& callback) {

			Mutex::Autolock lock(mMutex);
			return mThread->addEventListener(phase, callback);
			}

			status_t DispSync::removeEventListener(const sp<Callback>& callback) {
			Mutex::Autolock lock(mMutex);
			return mThread->removeEventListener(callback);
			}

			void DispSync::setPeriod(nsecs_t period) {
			Mutex::Autolock lock(mMutex);
			mPeriod = period;
			mPhase = 0;
			}

			void DispSync::updateModelLocked() {
			if (mNumResyncSamples >= MIN_RESYNC_SAMPLES_FOR_UPDATE) {
			nsecs_t durationSum = 0;
			for (size_t i = 1; i < mNumResyncSamples; i++) {
			size_t idx = (mFirstResyncSample + i) % MAX_RESYNC_SAMPLES;
			size_t prev = (idx + MAX_RESYNC_SAMPLES - 1) % MAX_RESYNC_SAMPLES;
			durationSum += mResyncSamples[idx] - mResyncSamples[prev];
			}

			mPeriod = durationSum / (mNumResyncSamples - 1);

			double sampleAvgX = 0;
			double sampleAvgY = 0;
			double scale = 2.0 * M_PI / double(mPeriod);
			for (size_t i = 0; i < mNumResyncSamples; i++) {
			size_t idx = (mFirstResyncSample + i) % MAX_RESYNC_SAMPLES;
			nsecs_t sample = mResyncSamples[idx];
			double samplePhase = double(sample % mPeriod) * scale;
			sampleAvgX += cos(samplePhase);
			sampleAvgY += sin(samplePhase);
			}

			sampleAvgX /= double(mNumResyncSamples);
			sampleAvgY /= double(mNumResyncSamples);

			mPhase = nsecs_t(atan2(sampleAvgY, sampleAvgX) / scale);

			if (mPhase < 0) {
			mPhase += mPeriod;
			}

			if (traceDetailedInfo) {
			ATRACE_INT64("DispSync:Period", mPeriod);
			ATRACE_INT64("DispSync:Phase", mPhase);
			}

			mThread->updateModel(mPeriod, mPhase);
			}
			}

			void DispSync::updateErrorLocked() {
			if (mPeriod == 0) {
			return;
			}

			int numErrSamples = 0;
			nsecs_t sqErrSum = 0;

			for (size_t i = 0; i < NUM_PRESENT_SAMPLES; i++) {
			nsecs_t sample = mPresentTimes[i];
			if (sample > mPhase) {
			nsecs_t sampleErr = (sample - mPhase) % mPeriod;
			if (sampleErr > mPeriod / 2) {
			sampleErr -= mPeriod;
			}
			sqErrSum += sampleErr * sampleErr;
			numErrSamples++;
			}
			}

			if (numErrSamples > 0) {
			mError = sqErrSum / numErrSamples;
			} else {
			mError = 0;
			}

			if (traceDetailedInfo) {
			ATRACE_INT64("DispSync:Error", mError);
			}
			}

			void DispSync::resetErrorLocked() {
			mPresentSampleOffset = 0;
			mError = 0;
			for (size_t i = 0; i < NUM_PRESENT_SAMPLES; i++) {
			mPresentFences[i].clear();
			mPresentTimes[i] = 0;
			}
			}

			} // namespace android

services/surfaceflinger/DispSync.h

0 → 100644

+149 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2012 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.
			*/

			#ifndef ANDROID_DISPSYNC_H
			#define ANDROID_DISPSYNC_H

			#include <stddef.h>

			#include <utils/Mutex.h>
			#include <utils/Timers.h>
			#include <utils/RefBase.h>

			namespace android {

			class String8;
			class Fence;
			class DispSyncThread;

			// DispSync maintains a model of the periodic hardware-based vsync events of a
			// display and uses that model to execute period callbacks at specific phase
			// offsets from the hardware vsync events. The model is constructed by
			// feeding consecutive hardware event timestamps to the DispSync object via
			// the addResyncSample method.
			//
			// The model is validated using timestamps from Fence objects that are passed
			// to the DispSync object via the addPresentFence method. These fence
			// timestamps should correspond to a hardware vsync event, but they need not
			// be consecutive hardware vsync times. If this method determines that the
			// current model accurately represents the hardware event times it will return
			// false to indicate that a resynchronization (via addResyncSample) is not
			// needed.
			class DispSync {

			public:

			class Callback: public virtual RefBase {
			public:
			virtual ~Callback() {};
			virtual void onDispSyncEvent(nsecs_t when) = 0;
			};

			DispSync();
			~DispSync();

			void reset();

			// addPresentFence adds a fence for use in validating the current vsync
			// event model. The fence need not be signaled at the time
			// addPresentFence is called. When the fence does signal, its timestamp
			// should correspond to a hardware vsync event. Unlike the
			// addResyncSample method, the timestamps of consecutive fences need not
			// correspond to consecutive hardware vsync events.
			//
			// This method should be called with the retire fence from each HWComposer
			// set call that affects the display.
			bool addPresentFence(const sp<Fence>& fence);

			// The beginResync, addResyncSample, and endResync methods are used to re-
			// synchronize the DispSync's model to the hardware vsync events. The re-
			// synchronization process involves first calling beginResync, then
			// calling addResyncSample with a sequence of consecutive hardware vsync
			// event timestamps, and finally calling endResync when addResyncSample
			// indicates that no more samples are needed by returning false.
			//
			// This resynchronization process should be performed whenever the display
			// is turned on (i.e. once immediately after it's turned on) and whenever
			// addPresentFence returns true indicating that the model has drifted away
			// from the hardware vsync events.
			void beginResync();
			bool addResyncSample(nsecs_t timestamp);
			void endResync();

			// The setPreiod method sets the vsync event model's period to a specific
			// value. This should be used to prime the model when a display is first
			// turned on. It should NOT be used after that.
			void setPeriod(nsecs_t period);

			// addEventListener registers a callback to be called repeatedly at the
			// given phase offset from the hardware vsync events. The callback is
			// called from a separate thread and it should return reasonably quickly
			// (i.e. within a few hundred microseconds).
			status_t addEventListener(nsecs_t phase, const sp<Callback>& callback);

			// removeEventListener removes an already-registered event callback. Once
			// this method returns that callback will no longer be called by the
			// DispSync object.
			status_t removeEventListener(const sp<Callback>& callback);

			private:

			void updateModelLocked();
			void updateErrorLocked();
			void resetErrorLocked();

			enum { MAX_RESYNC_SAMPLES = 32 };
			enum { MIN_RESYNC_SAMPLES_FOR_UPDATE = 3 };
			enum { NUM_PRESENT_SAMPLES = 8 };
			enum { MAX_RESYNC_SAMPLES_WITHOUT_PRESENT = 12 };

			// mPeriod is the computed period of the modeled vsync events in
			// nanoseconds.
			nsecs_t mPeriod;

			// mPhase is the phase offset of the modeled vsync events. It is the
			// number of nanoseconds from time 0 to the first vsync event.
			nsecs_t mPhase;

			// mError is the computed model error. It is based on the difference
			// between the estimated vsync event times and those observed in the
			// mPresentTimes array.
			nsecs_t mError;

			// These member variables are the state used during the resynchronization
			// process to store information about the hardware vsync event times used
			// to compute the model.
			nsecs_t mResyncSamples[MAX_RESYNC_SAMPLES];
			size_t mFirstResyncSample;
			size_t mNumResyncSamples;
			int mNumResyncSamplesSincePresent;

			// These member variables store information about the present fences used
			// to validate the currently computed model.
			sp<Fence> mPresentFences[NUM_PRESENT_SAMPLES];
			nsecs_t mPresentTimes[NUM_PRESENT_SAMPLES];
			size_t mPresentSampleOffset;

			// mThread is the thread from which all the callbacks are called.
			sp<DispSyncThread> mThread;

			// mMutex is used to protect access to all member variables.
			mutable Mutex mMutex;
			};

			}

			#endif // ANDROID_DISPSYNC_H

services/surfaceflinger/DisplayHardware/HWComposer.cpp

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -285,7 +285,7 @@ void HWComposer::invalidate() {
	void HWComposer::vsync(int disp, int64_t timestamp) {		void HWComposer::vsync(int disp, int64_t timestamp) {
	if (uint32_t(disp) < HWC_NUM_PHYSICAL_DISPLAY_TYPES) {		if (uint32_t(disp) < HWC_NUM_PHYSICAL_DISPLAY_TYPES) {
	char tag[16];		char tag[16];
	snprintf(tag, sizeof(tag), "VSYNC_%1u", disp);		snprintf(tag, sizeof(tag), "HW_VSYNC_%1u", disp);
	ATRACE_INT(tag, ++mVSyncCounts[disp] & 1);		ATRACE_INT(tag, ++mVSyncCounts[disp] & 1);

	mEventHandler.onVSyncReceived(disp, timestamp);		mEventHandler.onVSyncReceived(disp, timestamp);

services/surfaceflinger/EventThread.cpp

+21 −21

Original line number	Original line	Diff line number	Diff line
	@@ -36,9 +36,10 @@
	namespace android {		namespace android {
	// ---------------------------------------------------------------------------		// ---------------------------------------------------------------------------

	EventThread::EventThread(const sp<SurfaceFlinger>& flinger)		EventThread::EventThread(const sp<VSyncSource>& src)
	: mFlinger(flinger),		: mVSyncSource(src),
	mUseSoftwareVSync(false),		mUseSoftwareVSync(false),
			mVsyncEnabled(false),
	mDebugVsyncEnabled(false) {		mDebugVsyncEnabled(false) {

	for (int32_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {		for (int32_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {
	@@ -110,20 +111,14 @@ void EventThread::onScreenAcquired() {
	}		}
	}		}

			void EventThread::onVSyncEvent(nsecs_t timestamp) {
	void EventThread::onVSyncReceived(int type, nsecs_t timestamp) {
	ALOGE_IF(type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES,
	"received vsync event for an invalid display (id=%d)", type);

	Mutex::Autolock _l(mLock);		Mutex::Autolock _l(mLock);
	if (type < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {		mVSyncEvent[0].header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC;
	mVSyncEvent[type].header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC;		mVSyncEvent[0].header.id = 0;
	mVSyncEvent[type].header.id = type;		mVSyncEvent[0].header.timestamp = timestamp;
	mVSyncEvent[type].header.timestamp = timestamp;		mVSyncEvent[0].vsync.count++;
	mVSyncEvent[type].vsync.count++;
	mCondition.broadcast();		mCondition.broadcast();
	}		}
	}

	void EventThread::onHotplugReceived(int type, bool connected) {		void EventThread::onHotplugReceived(int type, bool connected) {
	ALOGE_IF(type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES,		ALOGE_IF(type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES,
	@@ -308,19 +303,24 @@ Vector< sp<EventThread::Connection> > EventThread::waitForEvent(
	void EventThread::enableVSyncLocked() {		void EventThread::enableVSyncLocked() {
	if (!mUseSoftwareVSync) {		if (!mUseSoftwareVSync) {
	// never enable h/w VSYNC when screen is off		// never enable h/w VSYNC when screen is off
	mFlinger->eventControl(DisplayDevice::DISPLAY_PRIMARY,		if (!mVsyncEnabled) {
	SurfaceFlinger::EVENT_VSYNC, true);		mVsyncEnabled = true;
			mVSyncSource->setCallback(static_cast<VSyncSource::Callback*>(this));
			mVSyncSource->setVSyncEnabled(true);
	mPowerHAL.vsyncHint(true);		mPowerHAL.vsyncHint(true);
	}		}
			}
	mDebugVsyncEnabled = true;		mDebugVsyncEnabled = true;
	}		}

	void EventThread::disableVSyncLocked() {		void EventThread::disableVSyncLocked() {
	mFlinger->eventControl(DisplayDevice::DISPLAY_PRIMARY,		if (mVsyncEnabled) {
	SurfaceFlinger::EVENT_VSYNC, false);		mVsyncEnabled = false;
			mVSyncSource->setVSyncEnabled(false);
	mPowerHAL.vsyncHint(false);		mPowerHAL.vsyncHint(false);
	mDebugVsyncEnabled = false;		mDebugVsyncEnabled = false;
	}		}
			}

	void EventThread::dump(String8& result) const {		void EventThread::dump(String8& result) const {
	Mutex::Autolock _l(mLock);		Mutex::Autolock _l(mLock);