Merge changes Ib6b6da1d,I6d9a466a (84386164) · Commits · e / os / android_frameworks_native-old

opengl/libs/EGL/eglApi.cpp

+20 −0

Original line number	Diff line number	Diff line
		@@ -477,6 +477,26 @@ EGLBoolean eglQuerySurface( EGLDisplay dpy, EGLSurface surface,
		return result;
		}

		void EGLAPI eglBeginFrame(EGLDisplay dpy, EGLSurface surface) {
		clearError();

		egl_display_t const * const dp = validate_display(dpy);
		if (!dp) {
		return;
		}

		SurfaceRef _s(dp, surface);
		if (!_s.get()) {
		setError(EGL_BAD_SURFACE, EGL_FALSE);
		return;
		}

		int64_t timestamp = systemTime(SYSTEM_TIME_MONOTONIC);

		egl_surface_t const * const s = get_surface(surface);
		native_window_set_buffers_timestamp(s->win.get(), timestamp);
		}

		// ----------------------------------------------------------------------------
		// Contexts
		// ----------------------------------------------------------------------------

services/surfaceflinger/DisplayHardware/DisplayHardware.cpp

+14 −1

Original line number	Diff line number	Diff line
		@@ -350,15 +350,28 @@ uint32_t DisplayHardware::getPageFlipCount() const {
		}

		// this needs to be thread safe
		nsecs_t DisplayHardware::waitForVSync() const {
		nsecs_t DisplayHardware::waitForRefresh() const {
		nsecs_t timestamp;
		if (mVSync.wait(&timestamp) < 0) {
		// vsync not supported!
		usleep( getDelayToNextVSyncUs(&timestamp) );
		}
		mLastHwVSync = timestamp; // FIXME: Not thread safe
		return timestamp;
		}

		nsecs_t DisplayHardware::getRefreshTimestamp() const {
		// this returns the last refresh timestamp.
		// if the last one is not available, we estimate it based on
		// the refresh period and whatever closest timestamp we have.
		nsecs_t now = systemTime();
		return now - ((now - mLastHwVSync) % mRefreshPeriod);
		}

		nsecs_t DisplayHardware::getRefreshPeriod() const {
		return mRefreshPeriod;
		}

		int32_t DisplayHardware::getDelayToNextVSyncUs(nsecs_t* timestamp) const {
		Mutex::Autolock _l(mFakeVSyncMutex);
		const nsecs_t period = mRefreshPeriod;

services/surfaceflinger/DisplayHardware/DisplayHardware.h

+4 −1

Original line number	Diff line number	Diff line
		@@ -76,7 +76,9 @@ public:
		uint32_t getMaxViewportDims() const;

		// waits for the next vsync and returns the timestamp of when it happened
		nsecs_t waitForVSync() const;
		nsecs_t waitForRefresh() const;
		nsecs_t getRefreshPeriod() const;
		nsecs_t getRefreshTimestamp() const;

		uint32_t getPageFlipCount() const;
		EGLDisplay getEGLDisplay() const { return mDisplay; }
		@@ -119,6 +121,7 @@ private:
		mutable Mutex mFakeVSyncMutex;
		mutable nsecs_t mNextFakeVSync;
		nsecs_t mRefreshPeriod;
		mutable nsecs_t mLastHwVSync;

		HWComposer* mHwc;

services/surfaceflinger/EventThread.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -129,7 +129,7 @@ bool EventThread::threadLoop() {

		// at least one listener requested VSYNC
		mLock.unlock();
		timestamp = mHw.waitForVSync();
		timestamp = mHw.waitForRefresh();
		mLock.lock();
		mDeliveredEvents++;

services/surfaceflinger/Layer.cpp

+37 −0

Original line number	Diff line number	Diff line
		@@ -38,6 +38,7 @@
		#include "Layer.h"
		#include "SurfaceFlinger.h"
		#include "SurfaceTextureLayer.h"
		#include <math.h>

		#define DEBUG_RESIZE 0

		@@ -54,6 +55,8 @@ Layer::Layer(SurfaceFlinger* flinger,
		mCurrentTransform(0),
		mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE),
		mCurrentOpacity(true),
		mFrameLatencyNeeded(false),
		mFrameLatencyOffset(0),
		mFormat(PIXEL_FORMAT_NONE),
		mGLExtensions(GLExtensions::getInstance()),
		mOpaqueLayer(true),
		@@ -65,6 +68,17 @@ Layer::Layer(SurfaceFlinger* flinger,
		glGenTextures(1, &mTextureName);
		}

		void Layer::onLayerDisplayed() {
		if (mFrameLatencyNeeded) {
		const DisplayHardware& hw(graphicPlane(0).displayHardware());
		mFrameStats[mFrameLatencyOffset].timestamp = mSurfaceTexture->getTimestamp();
		mFrameStats[mFrameLatencyOffset].set = systemTime();
		mFrameStats[mFrameLatencyOffset].vsync = hw.getRefreshTimestamp();
		mFrameLatencyOffset = (mFrameLatencyOffset + 1) % 128;
		mFrameLatencyNeeded = false;
		}
		}

		void Layer::onFirstRef()
		{
		LayerBaseClient::onFirstRef();
		@@ -408,6 +422,7 @@ void Layer::lockPageFlip(bool& recomputeVisibleRegions)

		// update the active buffer
		mActiveBuffer = mSurfaceTexture->getCurrentBuffer();
		mFrameLatencyNeeded = true;

		const Rect crop(mSurfaceTexture->getCurrentCrop());
		const uint32_t transform(mSurfaceTexture->getCurrentTransform());
		@@ -538,11 +553,33 @@ void Layer::dump(String8& result, char* buffer, size_t SIZE) const

		result.append(buffer);

		LayerBase::dumpStats(result, buffer, SIZE);

		if (mSurfaceTexture != 0) {
		mSurfaceTexture->dump(result, " ", buffer, SIZE);
		}
		}

		void Layer::dumpStats(String8& result, char* buffer, size_t SIZE) const
		{
		LayerBaseClient::dumpStats(result, buffer, SIZE);
		const size_t o = mFrameLatencyOffset;
		const DisplayHardware& hw(graphicPlane(0).displayHardware());
		const nsecs_t period = hw.getRefreshPeriod();
		result.appendFormat("%lld\n", period);
		for (size_t i=0 ; i<128 ; i++) {
		const size_t index = (o+i) % 128;
		const nsecs_t time_app = mFrameStats[index].timestamp;
		const nsecs_t time_set = mFrameStats[index].set;
		const nsecs_t time_vsync = mFrameStats[index].vsync;
		result.appendFormat("%lld\t%lld\t%lld\n",
		time_app,
		time_vsync,
		time_set);
		}
		result.append("\n");
		}

		uint32_t Layer::getEffectiveUsage(uint32_t usage) const
		{
		// TODO: should we do something special if mSecure is set?