Snap for 5681502 from 769ab6f949369468ee6355d00e490ad14a2f3721 to qt-qpr1-release (e017ec05) · Commits · e / os / platform_frameworks_native

services/surfaceflinger/Android.bp

+2 −1

Original line number	Diff line number	Diff line
		@@ -149,9 +149,10 @@ filegroup {
		"Scheduler/LayerHistory.cpp",
		"Scheduler/LayerInfo.cpp",
		"Scheduler/MessageQueue.cpp",
		"Scheduler/PhaseOffsets.cpp",
		"Scheduler/Scheduler.cpp",
		"Scheduler/SchedulerUtils.cpp",
		"Scheduler/PhaseOffsets.cpp",
		"Scheduler/VSyncModulator.cpp",
		"StartPropertySetThread.cpp",
		"SurfaceFlinger.cpp",
		"SurfaceInterceptor.cpp",

services/surfaceflinger/RegionSamplingThread.cpp

+13 −3

Original line number	Diff line number	Diff line
		@@ -342,9 +342,19 @@ void RegionSamplingThread::captureSample() {
		}

		const auto device = mFlinger.getDefaultDisplayDevice();
		const auto display = device->getCompositionDisplay();
		const auto state = display->getState();
		const auto orientation = static_cast<ui::Transform::orientation_flags>(state.orientation);
		const auto orientation = [](uint32_t orientation) {
		switch (orientation) {
		default:
		case DisplayState::eOrientationDefault:
		return ui::Transform::ROT_0;
		case DisplayState::eOrientation90:
		return ui::Transform::ROT_90;
		case DisplayState::eOrientation180:
		return ui::Transform::ROT_180;
		case DisplayState::eOrientation270:
		return ui::Transform::ROT_270;
		}
		}(device->getOrientation());

		std::vector<RegionSamplingThread::Descriptor> descriptors;
		Region sampleRegion;

services/surfaceflinger/Scheduler/DispSyncSource.cpp

+19 −5

Original line number	Diff line number	Diff line
		@@ -34,6 +34,8 @@ DispSyncSource::DispSyncSource(DispSync* dispSync, nsecs_t phaseOffset,
		mTraceVsync(traceVsync),
		mVsyncOnLabel(base::StringPrintf("VsyncOn-%s", name)),
		mVsyncEventLabel(base::StringPrintf("VSYNC-%s", name)),
		mVsyncOffsetLabel(base::StringPrintf("VsyncOffset-%s", name)),
		mVsyncNegativeOffsetLabel(base::StringPrintf("VsyncNegativeOffset-%s", name)),
		mDispSync(dispSync),
		mPhaseOffset(phaseOffset),
		mOffsetThresholdForNextVsync(offsetThresholdForNextVsync) {}
		@@ -41,6 +43,7 @@ DispSyncSource::DispSyncSource(DispSync* dispSync, nsecs_t phaseOffset,
		void DispSyncSource::setVSyncEnabled(bool enable) {
		std::lock_guard lock(mVsyncMutex);
		if (enable) {
		tracePhaseOffset();
		status_t err = mDispSync->addEventListener(mName, mPhaseOffset,
		static_cast<DispSync::Callback*>(this),
		mLastCallbackTime);
		@@ -76,6 +79,7 @@ void DispSyncSource::setPhaseOffset(nsecs_t phaseOffset) {
		const int numPeriods = phaseOffset / period;
		phaseOffset -= numPeriods * period;
		mPhaseOffset = phaseOffset;
		tracePhaseOffset();

		// If we're not enabled, we don't need to mess with the listeners
		if (!mEnabled) {
		@@ -94,16 +98,26 @@ void DispSyncSource::onDispSyncEvent(nsecs_t when) {
		{
		std::lock_guard lock(mCallbackMutex);
		callback = mCallback;
		}

		if (mTraceVsync) {
		mValue = (mValue + 1) % 2;
		ATRACE_INT(mVsyncEventLabel.c_str(), mValue);
		}
		}

		if (callback != nullptr) {
		callback->onVSyncEvent(when);
		}
		}

		void DispSyncSource::tracePhaseOffset() {
		if (mPhaseOffset > 0) {
		ATRACE_INT(mVsyncOffsetLabel.c_str(), mPhaseOffset);
		ATRACE_INT(mVsyncNegativeOffsetLabel.c_str(), 0);
		} else {
		ATRACE_INT(mVsyncOffsetLabel.c_str(), 0);
		ATRACE_INT(mVsyncNegativeOffsetLabel.c_str(), -mPhaseOffset);
		}
		}

		} // namespace android

services/surfaceflinger/Scheduler/DispSyncSource.h

+5 −1

Original line number	Diff line number	Diff line
		@@ -39,12 +39,16 @@ private:
		// The following method is the implementation of the DispSync::Callback.
		virtual void onDispSyncEvent(nsecs_t when);

		void tracePhaseOffset() REQUIRES(mVsyncMutex);

		const char* const mName;
		int mValue = 0;

		const bool mTraceVsync;
		const std::string mVsyncOnLabel;
		const std::string mVsyncEventLabel;
		const std::string mVsyncOffsetLabel;
		const std::string mVsyncNegativeOffsetLabel;
		nsecs_t mLastCallbackTime GUARDED_BY(mVsyncMutex) = 0;

		DispSync* mDispSync;

services/surfaceflinger/Scheduler/PhaseOffsets.cpp

+28 −25

Original line number	Diff line number	Diff line
		@@ -25,6 +25,7 @@ using namespace android::sysprop;

		namespace scheduler {

		using RefreshRateType = RefreshRateConfigs::RefreshRateType;
		PhaseOffsets::~PhaseOffsets() = default;

		namespace impl {
		@@ -72,25 +73,32 @@ PhaseOffsets::PhaseOffsets() {
		property_get("debug.sf.phase_offset_threshold_for_next_vsync_ns", value, "-1");
		const int phaseOffsetThresholdForNextVsyncNs = atoi(value);

		mDefaultRefreshRateOffsets.early = {earlySfOffsetNs != -1 ? earlySfOffsetNs
		: sfVsyncPhaseOffsetNs,
		earlyAppOffsetNs != -1 ? earlyAppOffsetNs
		: vsyncPhaseOffsetNs};
		mDefaultRefreshRateOffsets.earlyGl = {earlyGlSfOffsetNs != -1 ? earlyGlSfOffsetNs
		: sfVsyncPhaseOffsetNs,
		earlyGlAppOffsetNs != -1 ? earlyGlAppOffsetNs
		: vsyncPhaseOffsetNs};
		mDefaultRefreshRateOffsets.late = {sfVsyncPhaseOffsetNs, vsyncPhaseOffsetNs};

		mHighRefreshRateOffsets.early = {highFpsEarlySfOffsetNs != -1 ? highFpsEarlySfOffsetNs
		Offsets defaultOffsets;
		Offsets highFpsOffsets;
		defaultOffsets.early = {RefreshRateType::DEFAULT,
		earlySfOffsetNs != -1 ? earlySfOffsetNs : sfVsyncPhaseOffsetNs,
		earlyAppOffsetNs != -1 ? earlyAppOffsetNs : vsyncPhaseOffsetNs};
		defaultOffsets.earlyGl = {RefreshRateType::DEFAULT,
		earlyGlSfOffsetNs != -1 ? earlyGlSfOffsetNs : sfVsyncPhaseOffsetNs,
		earlyGlAppOffsetNs != -1 ? earlyGlAppOffsetNs : vsyncPhaseOffsetNs};
		defaultOffsets.late = {RefreshRateType::DEFAULT, sfVsyncPhaseOffsetNs, vsyncPhaseOffsetNs};

		highFpsOffsets.early = {RefreshRateType::PERFORMANCE,
		highFpsEarlySfOffsetNs != -1 ? highFpsEarlySfOffsetNs
		: highFpsLateSfOffsetNs,
		highFpsEarlyAppOffsetNs != -1 ? highFpsEarlyAppOffsetNs
		: highFpsLateAppOffsetNs};
		mHighRefreshRateOffsets.earlyGl = {highFpsEarlyGlSfOffsetNs != -1 ? highFpsEarlyGlSfOffsetNs
		highFpsOffsets.earlyGl = {RefreshRateType::PERFORMANCE,
		highFpsEarlyGlSfOffsetNs != -1 ? highFpsEarlyGlSfOffsetNs
		: highFpsLateSfOffsetNs,
		highFpsEarlyGlAppOffsetNs != -1 ? highFpsEarlyGlAppOffsetNs
		: highFpsLateAppOffsetNs};
		mHighRefreshRateOffsets.late = {highFpsLateSfOffsetNs, highFpsLateAppOffsetNs};
		highFpsOffsets.late = {RefreshRateType::PERFORMANCE, highFpsLateSfOffsetNs,
		highFpsLateAppOffsetNs};

		mOffsets.insert({RefreshRateType::POWER_SAVING, defaultOffsets});
		mOffsets.insert({RefreshRateType::DEFAULT, defaultOffsets});
		mOffsets.insert({RefreshRateType::PERFORMANCE, highFpsOffsets});

		mOffsetThresholdForNextVsync = phaseOffsetThresholdForNextVsyncNs != -1
		? phaseOffsetThresholdForNextVsyncNs
		@@ -99,12 +107,7 @@ PhaseOffsets::PhaseOffsets() {

		PhaseOffsets::Offsets PhaseOffsets::getOffsetsForRefreshRate(
		android::scheduler::RefreshRateConfigs::RefreshRateType refreshRateType) const {
		switch (refreshRateType) {
		case RefreshRateConfigs::RefreshRateType::PERFORMANCE:
		return mHighRefreshRateOffsets;
		default:
		return mDefaultRefreshRateOffsets;
		}
		return mOffsets.at(refreshRateType);
		}

		void PhaseOffsets::dump(std::string& result) const {