Merge "EGL: Add eglGetCompositorTimingANDROID." (9f02435f) · Commits · e / os / android_frameworks_native-old

include/gui/FrameTimestamps.h

+24 −3

Original line number	Original line	Diff line number	Diff line
	@@ -95,6 +95,11 @@ struct FrameEvents {
	std::shared_ptr<FenceTime> releaseFence{FenceTime::NO_FENCE};		std::shared_ptr<FenceTime> releaseFence{FenceTime::NO_FENCE};
	};		};

			struct CompositorTiming {
			nsecs_t deadline{0};
			nsecs_t interval{16666667};
			nsecs_t presentLatency{0};
			};

	// A short history of frames that are synchronized between the consumer and		// A short history of frames that are synchronized between the consumer and
	// producer via deltas.		// producer via deltas.
	@@ -111,6 +116,8 @@ public:

	protected:		protected:
	std::array<FrameEvents, MAX_FRAME_HISTORY> mFrames;		std::array<FrameEvents, MAX_FRAME_HISTORY> mFrames;

			CompositorTiming mCompositorTiming;
	};		};


	@@ -119,6 +126,16 @@ class ProducerFrameEventHistory : public FrameEventHistory {
	public:		public:
	~ProducerFrameEventHistory() override;		~ProducerFrameEventHistory() override;

			// Public for testing.
			static nsecs_t snapToNextTick(
			nsecs_t timestamp, nsecs_t tickPhase, nsecs_t tickInterval);

			nsecs_t getNextCompositeDeadline(const nsecs_t now) const;
			nsecs_t getCompositeInterval() const { return mCompositorTiming.interval; }
			nsecs_t getCompositeToPresentLatency() const {
			return mCompositorTiming.presentLatency;
			}

	// virtual for testing.		// virtual for testing.
	virtual void updateAcquireFence(		virtual void updateAcquireFence(
	uint64_t frameNumber, std::shared_ptr<FenceTime>&& acquire);		uint64_t frameNumber, std::shared_ptr<FenceTime>&& acquire);
	@@ -189,12 +206,15 @@ class ConsumerFrameEventHistory : public FrameEventHistory {
	public:		public:
	~ConsumerFrameEventHistory() override;		~ConsumerFrameEventHistory() override;

			void initializeCompositorTiming(const CompositorTiming& compositorTiming);

	void addQueue(const NewFrameEventsEntry& newEntry);		void addQueue(const NewFrameEventsEntry& newEntry);
	void addLatch(uint64_t frameNumber, nsecs_t latchTime);		void addLatch(uint64_t frameNumber, nsecs_t latchTime);
	void addPreComposition(uint64_t frameNumber, nsecs_t refreshStartTime);		void addPreComposition(uint64_t frameNumber, nsecs_t refreshStartTime);
	void addPostComposition(uint64_t frameNumber,		void addPostComposition(uint64_t frameNumber,
	const std::shared_ptr<FenceTime>& gpuCompositionDone,		const std::shared_ptr<FenceTime>& gpuCompositionDone,
	const std::shared_ptr<FenceTime>& displayPresent);		const std::shared_ptr<FenceTime>& displayPresent,
			const CompositorTiming& compositorTiming);
	void addRetire(uint64_t frameNumber,		void addRetire(uint64_t frameNumber,
	const std::shared_ptr<FenceTime>& displayRetire);		const std::shared_ptr<FenceTime>& displayRetire);
	void addRelease(uint64_t frameNumber, nsecs_t dequeueReadyTime,		void addRelease(uint64_t frameNumber, nsecs_t dequeueReadyTime,
	@@ -244,7 +264,7 @@ public:
	size_t& count);		size_t& count);

	private:		private:
	static size_t minFlattenedSize();		static constexpr size_t minFlattenedSize();

	size_t mIndex{0};		size_t mIndex{0};
	uint64_t mFrameNumber{0};		uint64_t mFrameNumber{0};
	@@ -306,9 +326,10 @@ public:
	size_t& count);		size_t& count);

	private:		private:
	static size_t minFlattenedSize();		static constexpr size_t minFlattenedSize();

	std::vector<FrameEventsDelta> mDeltas;		std::vector<FrameEventsDelta> mDeltas;
			CompositorTiming mCompositorTiming;
	};		};

include/gui/Surface.h

+9 −2

Original line number	Original line	Diff line number	Diff line
	@@ -135,12 +135,18 @@ public:
	status_t getLastQueuedBuffer(sp<GraphicBuffer>* outBuffer,		status_t getLastQueuedBuffer(sp<GraphicBuffer>* outBuffer,
	sp<Fence>* outFence, float outTransformMatrix[16]);		sp<Fence>* outFence, float outTransformMatrix[16]);

			status_t getDisplayRefreshCycleDuration(nsecs_t* outRefreshDuration);

	/* Enables or disables frame timestamp tracking. It is disabled by default		/* Enables or disables frame timestamp tracking. It is disabled by default
	* to avoid overhead during queue and dequeue for applications that don't		* to avoid overhead during queue and dequeue for applications that don't
	* need the feature. If disabled, calls to getFrameTimestamps will fail.		* need the feature. If disabled, calls to getFrameTimestamps will fail.
	*/		*/
	void enableFrameTimestamps(bool enable);		void enableFrameTimestamps(bool enable);

			status_t getCompositorTiming(
			nsecs_t* compositeDeadline, nsecs_t* compositeInterval,
			nsecs_t* compositeToPresentLatency);

	// See IGraphicBufferProducer::getFrameTimestamps		// See IGraphicBufferProducer::getFrameTimestamps
	status_t getFrameTimestamps(uint64_t frameNumber,		status_t getFrameTimestamps(uint64_t frameNumber,
	nsecs_t* outRequestedPresentTime, nsecs_t* outAcquireTime,		nsecs_t* outRequestedPresentTime, nsecs_t* outAcquireTime,
	@@ -148,7 +154,6 @@ public:
	nsecs_t* outLastRefreshStartTime, nsecs_t* outGlCompositionDoneTime,		nsecs_t* outLastRefreshStartTime, nsecs_t* outGlCompositionDoneTime,
	nsecs_t* outDisplayPresentTime, nsecs_t* outDisplayRetireTime,		nsecs_t* outDisplayPresentTime, nsecs_t* outDisplayRetireTime,
	nsecs_t* outDequeueReadyTime, nsecs_t* outReleaseTime);		nsecs_t* outDequeueReadyTime, nsecs_t* outReleaseTime);
	status_t getDisplayRefreshCycleDuration(nsecs_t* outRefreshDuration);

	status_t getUniqueId(uint64_t* outId) const;		status_t getUniqueId(uint64_t* outId) const;

	@@ -157,6 +162,7 @@ protected:

	// Virtual for testing.		// Virtual for testing.
	virtual sp<ISurfaceComposer> composerService() const;		virtual sp<ISurfaceComposer> composerService() const;
			virtual nsecs_t now() const;

	private:		private:
	// can't be copied		// can't be copied
	@@ -204,10 +210,11 @@ private:
	int dispatchSetSurfaceDamage(va_list args);		int dispatchSetSurfaceDamage(va_list args);
	int dispatchSetSharedBufferMode(va_list args);		int dispatchSetSharedBufferMode(va_list args);
	int dispatchSetAutoRefresh(va_list args);		int dispatchSetAutoRefresh(va_list args);
			int dispatchGetDisplayRefreshCycleDuration(va_list args);
	int dispatchGetNextFrameId(va_list args);		int dispatchGetNextFrameId(va_list args);
	int dispatchEnableFrameTimestamps(va_list args);		int dispatchEnableFrameTimestamps(va_list args);
			int dispatchGetCompositorTiming(va_list args);
	int dispatchGetFrameTimestamps(va_list args);		int dispatchGetFrameTimestamps(va_list args);
	int dispatchGetDisplayRefreshCycleDuration(va_list args);

	protected:		protected:
	virtual int dequeueBuffer(ANativeWindowBuffer** buffer, int* fenceFd);		virtual int dequeueBuffer(ANativeWindowBuffer** buffer, int* fenceFd);

libs/gui/FrameTimestamps.cpp

+41 −7

Original line number	Original line	Diff line number	Diff line
	@@ -235,6 +235,23 @@ void FrameEventHistory::dump(String8& outString) const {

	ProducerFrameEventHistory::~ProducerFrameEventHistory() = default;		ProducerFrameEventHistory::~ProducerFrameEventHistory() = default;

			nsecs_t ProducerFrameEventHistory::snapToNextTick(
			nsecs_t timestamp, nsecs_t tickPhase, nsecs_t tickInterval) {
			nsecs_t tickOffset = (tickPhase - timestamp) % tickInterval;
			// Integer modulo rounds towards 0 and not -inf before taking the remainder,
			// so adjust the offset if it is negative.
			if (tickOffset < 0) {
			tickOffset += tickInterval;
			}
			return timestamp + tickOffset;
			}

			nsecs_t ProducerFrameEventHistory::getNextCompositeDeadline(
			const nsecs_t now) const{
			return snapToNextTick(
			now, mCompositorTiming.deadline, mCompositorTiming.interval);
			}

	void ProducerFrameEventHistory::updateAcquireFence(		void ProducerFrameEventHistory::updateAcquireFence(
	uint64_t frameNumber, std::shared_ptr<FenceTime>&& acquire) {		uint64_t frameNumber, std::shared_ptr<FenceTime>&& acquire) {
	FrameEvents* frame = getFrame(frameNumber, &mAcquireOffset);		FrameEvents* frame = getFrame(frameNumber, &mAcquireOffset);
	@@ -256,6 +273,8 @@ void ProducerFrameEventHistory::updateAcquireFence(

	void ProducerFrameEventHistory::applyDelta(		void ProducerFrameEventHistory::applyDelta(
	const FrameEventHistoryDelta& delta) {		const FrameEventHistoryDelta& delta) {
			mCompositorTiming = delta.mCompositorTiming;

	for (auto& d : delta.mDeltas) {		for (auto& d : delta.mDeltas) {
	// Avoid out-of-bounds access.		// Avoid out-of-bounds access.
	if (d.mIndex >= mFrames.size()) {		if (d.mIndex >= mFrames.size()) {
	@@ -346,6 +365,11 @@ std::shared_ptr<FenceTime> ProducerFrameEventHistory::createFenceTime(

	ConsumerFrameEventHistory::~ConsumerFrameEventHistory() = default;		ConsumerFrameEventHistory::~ConsumerFrameEventHistory() = default;

			void ConsumerFrameEventHistory::initializeCompositorTiming(
			const CompositorTiming& compositorTiming) {
			mCompositorTiming = compositorTiming;
			}

	void ConsumerFrameEventHistory::addQueue(const NewFrameEventsEntry& newEntry) {		void ConsumerFrameEventHistory::addQueue(const NewFrameEventsEntry& newEntry) {
	// Overwrite all fields of the frame with default values unless set here.		// Overwrite all fields of the frame with default values unless set here.
	FrameEvents newTimestamps;		FrameEvents newTimestamps;
	@@ -393,7 +417,10 @@ void ConsumerFrameEventHistory::addPreComposition(

	void ConsumerFrameEventHistory::addPostComposition(uint64_t frameNumber,		void ConsumerFrameEventHistory::addPostComposition(uint64_t frameNumber,
	const std::shared_ptr<FenceTime>& gpuCompositionDone,		const std::shared_ptr<FenceTime>& gpuCompositionDone,
	const std::shared_ptr<FenceTime>& displayPresent) {		const std::shared_ptr<FenceTime>& displayPresent,
			const CompositorTiming& compositorTiming) {
			mCompositorTiming = compositorTiming;

	FrameEvents* frame = getFrame(frameNumber, &mCompositionOffset);		FrameEvents* frame = getFrame(frameNumber, &mCompositionOffset);
	if (frame == nullptr) {		if (frame == nullptr) {
	ALOGE_IF(mProducerWantsEvents,		ALOGE_IF(mProducerWantsEvents,
	@@ -450,6 +477,8 @@ void ConsumerFrameEventHistory::getFrameDelta(

	void ConsumerFrameEventHistory::getAndResetDelta(		void ConsumerFrameEventHistory::getAndResetDelta(
	FrameEventHistoryDelta* delta) {		FrameEventHistoryDelta* delta) {
			delta->mCompositorTiming = mCompositorTiming;

	// Write these in order of frame number so that it is easy to		// Write these in order of frame number so that it is easy to
	// add them to a FenceTimeline in the proper order producer side.		// add them to a FenceTimeline in the proper order producer side.
	delta->mDeltas.reserve(mFramesDirty.size());		delta->mDeltas.reserve(mFramesDirty.size());
	@@ -499,9 +528,8 @@ FrameEventsDelta::FrameEventsDelta(
	}		}
	}		}

	size_t FrameEventsDelta::minFlattenedSize() {		constexpr size_t FrameEventsDelta::minFlattenedSize() {
	constexpr size_t min =		return sizeof(FrameEventsDelta::mFrameNumber) +
	sizeof(FrameEventsDelta::mFrameNumber) +
	sizeof(uint8_t) + // mIndex		sizeof(uint8_t) + // mIndex
	sizeof(uint8_t) + // mAddPostCompositeCalled		sizeof(uint8_t) + // mAddPostCompositeCalled
	sizeof(uint8_t) + // mAddRetireCalled		sizeof(uint8_t) + // mAddRetireCalled
	@@ -512,7 +540,6 @@ size_t FrameEventsDelta::minFlattenedSize() {
	sizeof(FrameEventsDelta::mFirstRefreshStartTime) +		sizeof(FrameEventsDelta::mFirstRefreshStartTime) +
	sizeof(FrameEventsDelta::mLastRefreshStartTime) +		sizeof(FrameEventsDelta::mLastRefreshStartTime) +
	sizeof(FrameEventsDelta::mDequeueReadyTime);		sizeof(FrameEventsDelta::mDequeueReadyTime);
	return min;
	}		}

	// Flattenable implementation		// Flattenable implementation
	@@ -618,6 +645,8 @@ status_t FrameEventsDelta::unflatten(void const*& buffer, size_t& size,

	FrameEventHistoryDelta& FrameEventHistoryDelta::operator=(		FrameEventHistoryDelta& FrameEventHistoryDelta::operator=(
	FrameEventHistoryDelta&& src) {		FrameEventHistoryDelta&& src) {
			mCompositorTiming = src.mCompositorTiming;

	if (CC_UNLIKELY(!mDeltas.empty())) {		if (CC_UNLIKELY(!mDeltas.empty())) {
	ALOGE("FrameEventHistoryDelta: Clobbering history.");		ALOGE("FrameEventHistoryDelta: Clobbering history.");
	}		}
	@@ -626,8 +655,9 @@ FrameEventHistoryDelta& FrameEventHistoryDelta::operator=(
	return *this;		return *this;
	}		}

	size_t FrameEventHistoryDelta::minFlattenedSize() {		constexpr size_t FrameEventHistoryDelta::minFlattenedSize() {
	return sizeof(uint32_t);		return sizeof(uint32_t) + // mDeltas.size()
			sizeof(mCompositorTiming);
	}		}

	size_t FrameEventHistoryDelta::getFlattenedSize() const {		size_t FrameEventHistoryDelta::getFlattenedSize() const {
	@@ -654,6 +684,8 @@ status_t FrameEventHistoryDelta::flatten(
	return NO_MEMORY;		return NO_MEMORY;
	}		}

			FlattenableUtils::write(buffer, size, mCompositorTiming);

	FlattenableUtils::write(		FlattenableUtils::write(
	buffer, size, static_cast<uint32_t>(mDeltas.size()));		buffer, size, static_cast<uint32_t>(mDeltas.size()));
	for (auto& d : mDeltas) {		for (auto& d : mDeltas) {
	@@ -671,6 +703,8 @@ status_t FrameEventHistoryDelta::unflatten(
	return NO_MEMORY;		return NO_MEMORY;
	}		}

			FlattenableUtils::read(buffer, size, mCompositorTiming);

	uint32_t deltaCount = 0;		uint32_t deltaCount = 0;
	FlattenableUtils::read(buffer, size, deltaCount);		FlattenableUtils::read(buffer, size, deltaCount);
	if (deltaCount > FrameEventHistory::MAX_FRAME_HISTORY) {		if (deltaCount > FrameEventHistory::MAX_FRAME_HISTORY) {

libs/gui/Surface.cpp

+63 −18

Original line number	Original line	Diff line number	Diff line
	@@ -100,6 +100,10 @@ sp<ISurfaceComposer> Surface::composerService() const {
	return ComposerService::getComposerService();		return ComposerService::getComposerService();
	}		}

			nsecs_t Surface::now() const {
			return systemTime();
			}

	sp<IGraphicBufferProducer> Surface::getIGraphicBufferProducer() const {		sp<IGraphicBufferProducer> Surface::getIGraphicBufferProducer() const {
	return mGraphicBufferProducer;		return mGraphicBufferProducer;
	}		}
	@@ -142,11 +146,51 @@ status_t Surface::getLastQueuedBuffer(sp<GraphicBuffer>* outBuffer,
	outTransformMatrix);		outTransformMatrix);
	}		}

			status_t Surface::getDisplayRefreshCycleDuration(nsecs_t* outRefreshDuration) {
			ATRACE_CALL();

			DisplayStatInfo stats;
			status_t err = composerService()->getDisplayStats(NULL, &stats);

			*outRefreshDuration = stats.vsyncPeriod;

			return NO_ERROR;
			}

	void Surface::enableFrameTimestamps(bool enable) {		void Surface::enableFrameTimestamps(bool enable) {
	Mutex::Autolock lock(mMutex);		Mutex::Autolock lock(mMutex);
			// If going from disabled to enabled, get the initial values for
			// compositor and display timing.
			if (!mEnableFrameTimestamps && enable) {
			FrameEventHistoryDelta delta;
			mGraphicBufferProducer->getFrameTimestamps(&delta);
			mFrameEventHistory->applyDelta(delta);
			}
	mEnableFrameTimestamps = enable;		mEnableFrameTimestamps = enable;
	}		}

			status_t Surface::getCompositorTiming(
			nsecs_t* compositeDeadline, nsecs_t* compositeInterval,
			nsecs_t* compositeToPresentLatency) {
			Mutex::Autolock lock(mMutex);
			if (!mEnableFrameTimestamps) {
			return INVALID_OPERATION;
			}

			if (compositeDeadline != nullptr) {
			*compositeDeadline =
			mFrameEventHistory->getNextCompositeDeadline(now());
			}
			if (compositeInterval != nullptr) {
			*compositeInterval = mFrameEventHistory->getCompositeInterval();
			}
			if (compositeToPresentLatency != nullptr) {
			*compositeToPresentLatency =
			mFrameEventHistory->getCompositeToPresentLatency();
			}
			return NO_ERROR;
			}

	static bool checkConsumerForUpdates(		static bool checkConsumerForUpdates(
	const FrameEvents* e, const uint64_t lastFrameNumber,		const FrameEvents* e, const uint64_t lastFrameNumber,
	const nsecs_t* outLatchTime,		const nsecs_t* outLatchTime,
	@@ -260,16 +304,6 @@ status_t Surface::getFrameTimestamps(uint64_t frameNumber,

	return NO_ERROR;		return NO_ERROR;
	}		}
	status_t Surface::getDisplayRefreshCycleDuration(nsecs_t* outRefreshDuration) {
	ATRACE_CALL();

	DisplayStatInfo stats;
	status_t err = composerService()->getDisplayStats(NULL, &stats);

	*outRefreshDuration = stats.vsyncPeriod;

	return NO_ERROR;
	}

	int Surface::hook_setSwapInterval(ANativeWindow* window, int interval) {		int Surface::hook_setSwapInterval(ANativeWindow* window, int interval) {
	Surface* c = getSelf(window);		Surface* c = getSelf(window);
	@@ -831,18 +865,21 @@ int Surface::perform(int operation, va_list args)
	case NATIVE_WINDOW_SET_AUTO_REFRESH:		case NATIVE_WINDOW_SET_AUTO_REFRESH:
	res = dispatchSetAutoRefresh(args);		res = dispatchSetAutoRefresh(args);
	break;		break;
			case NATIVE_WINDOW_GET_REFRESH_CYCLE_DURATION:
			res = dispatchGetDisplayRefreshCycleDuration(args);
			break;
	case NATIVE_WINDOW_GET_NEXT_FRAME_ID:		case NATIVE_WINDOW_GET_NEXT_FRAME_ID:
	res = dispatchGetNextFrameId(args);		res = dispatchGetNextFrameId(args);
	break;		break;
	case NATIVE_WINDOW_ENABLE_FRAME_TIMESTAMPS:		case NATIVE_WINDOW_ENABLE_FRAME_TIMESTAMPS:
	res = dispatchEnableFrameTimestamps(args);		res = dispatchEnableFrameTimestamps(args);
	break;		break;
			case NATIVE_WINDOW_GET_COMPOSITOR_TIMING:
			res = dispatchGetCompositorTiming(args);
			break;
	case NATIVE_WINDOW_GET_FRAME_TIMESTAMPS:		case NATIVE_WINDOW_GET_FRAME_TIMESTAMPS:
	res = dispatchGetFrameTimestamps(args);		res = dispatchGetFrameTimestamps(args);
	break;		break;
	case NATIVE_WINDOW_GET_REFRESH_CYCLE_DURATION:
	res = dispatchGetDisplayRefreshCycleDuration(args);
	break;
	default:		default:
	res = NAME_NOT_FOUND;		res = NAME_NOT_FOUND;
	break;		break;
	@@ -963,6 +1000,11 @@ int Surface::dispatchSetAutoRefresh(va_list args) {
	return setAutoRefresh(autoRefresh);		return setAutoRefresh(autoRefresh);
	}		}

			int Surface::dispatchGetDisplayRefreshCycleDuration(va_list args) {
			nsecs_t* outRefreshDuration = va_arg(args, int64_t*);
			return getDisplayRefreshCycleDuration(outRefreshDuration);
			}

	int Surface::dispatchGetNextFrameId(va_list args) {		int Surface::dispatchGetNextFrameId(va_list args) {
	uint64_t* nextFrameId = va_arg(args, uint64_t*);		uint64_t* nextFrameId = va_arg(args, uint64_t*);
	*nextFrameId = getNextFrameNumber();		*nextFrameId = getNextFrameNumber();
	@@ -975,6 +1017,14 @@ int Surface::dispatchEnableFrameTimestamps(va_list args) {
	return NO_ERROR;		return NO_ERROR;
	}		}

			int Surface::dispatchGetCompositorTiming(va_list args) {
			nsecs_t* compositeDeadline = va_arg(args, int64_t*);
			nsecs_t* compositeInterval = va_arg(args, int64_t*);
			nsecs_t* compositeToPresentLatency = va_arg(args, int64_t*);
			return getCompositorTiming(compositeDeadline, compositeInterval,
			compositeToPresentLatency);
			}

	int Surface::dispatchGetFrameTimestamps(va_list args) {		int Surface::dispatchGetFrameTimestamps(va_list args) {
	uint64_t frameId = va_arg(args, uint64_t);		uint64_t frameId = va_arg(args, uint64_t);
	nsecs_t* outRequestedPresentTime = va_arg(args, int64_t*);		nsecs_t* outRequestedPresentTime = va_arg(args, int64_t*);
	@@ -994,11 +1044,6 @@ int Surface::dispatchGetFrameTimestamps(va_list args) {
	outDisplayRetireTime, outDequeueReadyTime, outReleaseTime);		outDisplayRetireTime, outDequeueReadyTime, outReleaseTime);
	}		}

	int Surface::dispatchGetDisplayRefreshCycleDuration(va_list args) {
	nsecs_t* outRefreshDuration = va_arg(args, int64_t*);
	return getDisplayRefreshCycleDuration(outRefreshDuration);
	}

	int Surface::connect(int api) {		int Surface::connect(int api) {
	static sp<IProducerListener> listener = new DummyProducerListener();		static sp<IProducerListener> listener = new DummyProducerListener();
	return connect(api, listener);		return connect(api, listener);

libs/gui/tests/Surface_test.cpp

+294 −13

File changed.

Preview size limit exceeded, changes collapsed.