Snap for 5706813 from 5bb9322330b5ba75876aa804ade536654093557b to qt-qpr1-release (e46171ca) · Commits · e / os / platform_frameworks_native

services/surfaceflinger/RegionSamplingThread.cpp

+19 −4

Original line number	Diff line number	Diff line
		@@ -44,11 +44,14 @@ constexpr auto lumaSamplingStepTag = "LumaSamplingStep";
		enum class samplingStep {
		noWorkNeeded,
		idleTimerWaiting,
		waitForQuietFrame,
		waitForZeroPhase,
		waitForSamplePhase,
		sample
		};

		constexpr auto timeForRegionSampling = 5000000ns;
		constexpr auto maxRegionSamplingSkips = 10;
		constexpr auto defaultRegionSamplingOffset = -3ms;
		constexpr auto defaultRegionSamplingPeriod = 100ms;
		constexpr auto defaultRegionSamplingTimerTimeout = 100ms;
		@@ -215,9 +218,9 @@ void RegionSamplingThread::removeListener(const sp<IRegionSamplingListener>& lis
		void RegionSamplingThread::checkForStaleLuma() {
		std::lock_guard lock(mThreadControlMutex);

		if (mDiscardedFrames) {
		if (mDiscardedFrames > 0) {
		ATRACE_INT(lumaSamplingStepTag, static_cast<int>(samplingStep::waitForZeroPhase));
		mDiscardedFrames = false;
		mDiscardedFrames = 0;
		mPhaseCallback->startVsyncListener();
		}
		}
		@@ -235,13 +238,25 @@ void RegionSamplingThread::doSample() {
		auto now = std::chrono::nanoseconds(systemTime(SYSTEM_TIME_MONOTONIC));
		if (lastSampleTime + mTunables.mSamplingPeriod > now) {
		ATRACE_INT(lumaSamplingStepTag, static_cast<int>(samplingStep::idleTimerWaiting));
		mDiscardedFrames = true;
		if (mDiscardedFrames == 0) mDiscardedFrames++;
		return;
		}
		if (mDiscardedFrames < maxRegionSamplingSkips) {
		// If there is relatively little time left for surfaceflinger
		// until the next vsync deadline, defer this sampling work
		// to a later frame, when hopefully there will be more time.
		DisplayStatInfo stats;
		mScheduler.getDisplayStatInfo(&stats);
		if (std::chrono::nanoseconds(stats.vsyncTime) - now < timeForRegionSampling) {
		ATRACE_INT(lumaSamplingStepTag, static_cast<int>(samplingStep::waitForQuietFrame));
		mDiscardedFrames++;
		return;
		}
		}

		ATRACE_INT(lumaSamplingStepTag, static_cast<int>(samplingStep::sample));

		mDiscardedFrames = false;
		mDiscardedFrames = 0;
		lastSampleTime = now;

		mIdleTimer.reset();

services/surfaceflinger/RegionSamplingThread.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -117,7 +117,7 @@ private:
		std::condition_variable_any mCondition;
		bool mRunning GUARDED_BY(mThreadControlMutex) = true;
		bool mSampleRequested GUARDED_BY(mThreadControlMutex) = false;
		bool mDiscardedFrames GUARDED_BY(mThreadControlMutex) = false;
		uint32_t mDiscardedFrames GUARDED_BY(mThreadControlMutex) = 0;
		std::chrono::nanoseconds lastSampleTime GUARDED_BY(mThreadControlMutex);

		std::mutex mSamplingMutex;

services/surfaceflinger/Scheduler/Scheduler.cpp

+9 −12

Original line number	Diff line number	Diff line
		@@ -523,22 +523,19 @@ Scheduler::RefreshRateType Scheduler::calculateRefreshRateType() {
		return RefreshRateType::PERFORMANCE;
		}

		// Content detection is on, find the appropriate refresh rate
		// Start with the smallest refresh rate which is within a margin of the content
		RefreshRateType currRefreshRateType = RefreshRateType::PERFORMANCE;
		constexpr float MARGIN = 0.05f;
		auto iter = mRefreshRateConfigs.getRefreshRates().cbegin();
		while (iter != mRefreshRateConfigs.getRefreshRates().cend()) {
		if (iter->second->fps >= mContentRefreshRate * (1 - MARGIN)) {
		currRefreshRateType = iter->first;
		break;
		}
		++iter;
		}
		// Content detection is on, find the appropriate refresh rate with minimal error
		auto iter = min_element(mRefreshRateConfigs.getRefreshRates().cbegin(),
		mRefreshRateConfigs.getRefreshRates().cend(),
		[rate = mContentRefreshRate](const auto& l, const auto& r) -> bool {
		return std::abs(l.second->fps - static_cast<float>(rate)) <
		std::abs(r.second->fps - static_cast<float>(rate));
		});
		RefreshRateType currRefreshRateType = iter->first;

		// Some content aligns better on higher refresh rate. For example for 45fps we should choose
		// 90Hz config. However we should still prefer a lower refresh rate if the content doesn't
		// align well with both
		constexpr float MARGIN = 0.05f;
		float ratio = mRefreshRateConfigs.getRefreshRate(currRefreshRateType)->fps /
		float(mContentRefreshRate);
		if (std::abs(std::round(ratio) - ratio) > MARGIN) {