Merge "Keep standalone devices in VrFlinger mode." into oc-mr1-dev (4b58ec86) · Commits · e / os / android_frameworks_native-old

libs/vr/libvrflinger/hardware_composer.cpp

+37 −73

Original line number	Original line	Diff line number	Diff line
	@@ -44,9 +44,8 @@ namespace {
	const char kBacklightBrightnessSysFile[] =		const char kBacklightBrightnessSysFile[] =
	"/sys/class/leds/lcd-backlight/brightness";		"/sys/class/leds/lcd-backlight/brightness";

	const char kPrimaryDisplayWaitPPEventFile[] = "/sys/class/graphics/fb0/wait_pp";

	const char kDvrPerformanceProperty[] = "sys.dvr.performance";		const char kDvrPerformanceProperty[] = "sys.dvr.performance";
			const char kDvrStandaloneProperty[] = "ro.boot.vr";

	const char kRightEyeOffsetProperty[] = "dvr.right_eye_offset_ns";		const char kRightEyeOffsetProperty[] = "dvr.right_eye_offset_ns";

	@@ -101,6 +100,8 @@ bool HardwareComposer::Initialize(
	return false;		return false;
	}		}

			is_standalone_device_ = property_get_bool(kDvrStandaloneProperty, false);

	request_display_callback_ = request_display_callback;		request_display_callback_ = request_display_callback;

	HWC::Error error = HWC::Error::None;		HWC::Error error = HWC::Error::None;
	@@ -198,10 +199,17 @@ void HardwareComposer::UpdatePostThreadState(PostThreadStateType state,
	}		}

	void HardwareComposer::OnPostThreadResumed() {		void HardwareComposer::OnPostThreadResumed() {
			// Phones create a new composer client on resume and destroy it on pause.
			// Standalones only create the composer client once and then use SetPowerMode
			// to control the screen on pause/resume.
			if (!is_standalone_device_ \|\| !composer_) {
	composer_.reset(new Hwc2::Composer(false));		composer_.reset(new Hwc2::Composer(false));
	composer_callback_ = new ComposerCallback;		composer_callback_ = new ComposerCallback;
	composer_->registerCallback(composer_callback_);		composer_->registerCallback(composer_callback_);
	Layer::SetComposer(composer_.get());		Layer::SetComposer(composer_.get());
			} else {
			SetPowerMode(true);
			}

	EnableVsync(true);		EnableVsync(true);

	@@ -224,9 +232,13 @@ void HardwareComposer::OnPostThreadPaused() {
	EnableVsync(false);		EnableVsync(false);
	}		}

			if (!is_standalone_device_) {
	composer_callback_ = nullptr;		composer_callback_ = nullptr;
	composer_.reset(nullptr);		composer_.reset(nullptr);
	Layer::SetComposer(nullptr);		Layer::SetComposer(nullptr);
			} else {
			SetPowerMode(false);
			}

	// Trigger target-specific performance mode change.		// Trigger target-specific performance mode change.
	property_set(kDvrPerformanceProperty, "idle");		property_set(kDvrPerformanceProperty, "idle");
	@@ -256,6 +268,12 @@ HWC::Error HardwareComposer::EnableVsync(bool enabled) {
	: HWC2_VSYNC_DISABLE));		: HWC2_VSYNC_DISABLE));
	}		}

			HWC::Error HardwareComposer::SetPowerMode(bool active) {
			HWC::PowerMode power_mode = active ? HWC::PowerMode::On : HWC::PowerMode::Off;
			return composer_->setPowerMode(
			HWC_DISPLAY_PRIMARY, power_mode.cast<Hwc2::IComposerClient::PowerMode>());
			}

	HWC::Error HardwareComposer::Present(hwc2_display_t display) {		HWC::Error HardwareComposer::Present(hwc2_display_t display) {
	int32_t present_fence;		int32_t present_fence;
	HWC::Error error = composer_->presentDisplay(display, &present_fence);		HWC::Error error = composer_->presentDisplay(display, &present_fence);
	@@ -459,7 +477,7 @@ void HardwareComposer::SetDisplaySurfaces(
	pending_surfaces_ = std::move(surfaces);		pending_surfaces_ = std::move(surfaces);
	}		}

	if (request_display_callback_)		if (request_display_callback_ && (!is_standalone_device_ \|\| !composer_))
	request_display_callback_(!display_idle);		request_display_callback_(!display_idle);

	// Set idle state based on whether there are any surfaces to handle.		// Set idle state based on whether there are any surfaces to handle.
	@@ -569,48 +587,6 @@ int HardwareComposer::PostThreadPollInterruptible(
	}		}
	}		}

	// Reads the value of the display driver wait_pingpong state. Returns 0 or 1
	// (the value of the state) on success or a negative error otherwise.
	// TODO(eieio): This is pretty driver specific, this should be moved to a
	// separate class eventually.
	int HardwareComposer::ReadWaitPPState() {
	// Gracefully handle when the kernel does not support this feature.
	if (!primary_display_wait_pp_fd_)
	return 0;

	const int wait_pp_fd = primary_display_wait_pp_fd_.Get();
	int ret, error;

	ret = lseek(wait_pp_fd, 0, SEEK_SET);
	if (ret < 0) {
	error = errno;
	ALOGE("HardwareComposer::ReadWaitPPState: Failed to seek wait_pp fd: %s",
	strerror(error));
	return -error;
	}

	char data = -1;
	ret = read(wait_pp_fd, &data, sizeof(data));
	if (ret < 0) {
	error = errno;
	ALOGE("HardwareComposer::ReadWaitPPState: Failed to read wait_pp state: %s",
	strerror(error));
	return -error;
	}

	switch (data) {
	case '0':
	return 0;
	case '1':
	return 1;
	default:
	ALOGE(
	"HardwareComposer::ReadWaitPPState: Unexpected value for wait_pp: %d",
	data);
	return -EINVAL;
	}
	}

	// Waits for the next vsync and returns the timestamp of the vsync event. If		// Waits for the next vsync and returns the timestamp of the vsync event. If
	// vsync already passed since the last call, returns the latest vsync timestamp		// vsync already passed since the last call, returns the latest vsync timestamp
	// instead of blocking.		// instead of blocking.
	@@ -640,8 +616,8 @@ int HardwareComposer::SleepUntil(int64_t wakeup_timestamp) {
	return -error;		return -error;
	}		}

	return PostThreadPollInterruptible(		return PostThreadPollInterruptible(vsync_sleep_timer_fd_, POLLIN,
	vsync_sleep_timer_fd_, POLLIN, /timeout_ms/ -1);		/timeout_ms/ -1);
	}		}

	void HardwareComposer::PostThread() {		void HardwareComposer::PostThread() {
	@@ -664,15 +640,6 @@ void HardwareComposer::PostThread() {
	strerror(errno));		strerror(errno));
	#endif // ENABLE_BACKLIGHT_BRIGHTNESS		#endif // ENABLE_BACKLIGHT_BRIGHTNESS

	// Open the wait pingpong status node for the primary display.
	// TODO(eieio): Move this into a platform-specific class.
	primary_display_wait_pp_fd_ =
	LocalHandle(kPrimaryDisplayWaitPPEventFile, O_RDONLY);
	ALOGW_IF(
	!primary_display_wait_pp_fd_,
	"HardwareComposer: Failed to open wait_pp node for primary display: %s",
	strerror(errno));

	// Create a timerfd based on CLOCK_MONOTINIC.		// Create a timerfd based on CLOCK_MONOTINIC.
	vsync_sleep_timer_fd_.Reset(timerfd_create(CLOCK_MONOTONIC, 0));		vsync_sleep_timer_fd_.Reset(timerfd_create(CLOCK_MONOTONIC, 0));
	LOG_ALWAYS_FATAL_IF(		LOG_ALWAYS_FATAL_IF(
	@@ -895,15 +862,12 @@ void HardwareComposer::SetBacklightBrightness(int brightness) {

	HardwareComposer::ComposerCallback::ComposerCallback() {		HardwareComposer::ComposerCallback::ComposerCallback() {
	vsync_event_fd_.Reset(eventfd(0, EFD_CLOEXEC \| EFD_NONBLOCK));		vsync_event_fd_.Reset(eventfd(0, EFD_CLOEXEC \| EFD_NONBLOCK));
	LOG_ALWAYS_FATAL_IF(		LOG_ALWAYS_FATAL_IF(!vsync_event_fd_, "Failed to create vsync event fd : %s",
	!vsync_event_fd_,
	"Failed to create vsync event fd : %s",
	strerror(errno));		strerror(errno));
	}		}

	Return<void> HardwareComposer::ComposerCallback::onHotplug(		Return<void> HardwareComposer::ComposerCallback::onHotplug(
	Hwc2::Display /display/,		Hwc2::Display /display/, IComposerCallback::Connection /conn/) {
	IComposerCallback::Connection /conn/) {
	return Void();		return Void();
	}		}

	@@ -912,8 +876,8 @@ Return<void> HardwareComposer::ComposerCallback::onRefresh(
	return hardware::Void();		return hardware::Void();
	}		}

	Return<void> HardwareComposer::ComposerCallback::onVsync(		Return<void> HardwareComposer::ComposerCallback::onVsync(Hwc2::Display display,
	Hwc2::Display display, int64_t timestamp) {		int64_t timestamp) {
	if (display == HWC_DISPLAY_PRIMARY) {		if (display == HWC_DISPLAY_PRIMARY) {
	std::lock_guard<std::mutex> lock(vsync_mutex_);		std::lock_guard<std::mutex> lock(vsync_mutex_);
	vsync_time_ = timestamp;		vsync_time_ = timestamp;
	@@ -923,8 +887,8 @@ Return<void> HardwareComposer::ComposerCallback::onVsync(
	return Void();		return Void();
	}		}

	const pdx::LocalHandle&		const pdx::LocalHandle& HardwareComposer::ComposerCallback::GetVsyncEventFd()
	HardwareComposer::ComposerCallback::GetVsyncEventFd() const {		const {
	return vsync_event_fd_;		return vsync_event_fd_;
	}		}

libs/vr/libvrflinger/hardware_composer.h

+3 −4

Original line number	Original line	Diff line number	Diff line
	@@ -336,6 +336,7 @@ class HardwareComposer {
	HWCDisplayMetrics* out_metrics) const;		HWCDisplayMetrics* out_metrics) const;

	HWC::Error EnableVsync(bool enabled);		HWC::Error EnableVsync(bool enabled);
			HWC::Error SetPowerMode(bool active);

	class ComposerCallback : public Hwc2::IComposerCallback {		class ComposerCallback : public Hwc2::IComposerCallback {
	public:		public:
	@@ -394,7 +395,7 @@ class HardwareComposer {
	int WaitForVSync(int64_t* timestamp);		int WaitForVSync(int64_t* timestamp);
	int SleepUntil(int64_t wakeup_timestamp);		int SleepUntil(int64_t wakeup_timestamp);

	bool IsFramePendingInDriver() { return ReadWaitPPState() == 1; }		bool IsFramePendingInDriver() { return false; }

	// Reconfigures the layer stack if the display surfaces changed since the last		// Reconfigures the layer stack if the display surfaces changed since the last
	// frame. Called only from the post thread.		// frame. Called only from the post thread.
	@@ -413,6 +414,7 @@ class HardwareComposer {
	void UpdateConfigBuffer();		void UpdateConfigBuffer();

	bool initialized_;		bool initialized_;
			bool is_standalone_device_;

	std::unique_ptr<Hwc2::Composer> composer_;		std::unique_ptr<Hwc2::Composer> composer_;
	sp<ComposerCallback> composer_callback_;		sp<ComposerCallback> composer_callback_;
	@@ -455,9 +457,6 @@ class HardwareComposer {
	// Backlight LED brightness sysfs node.		// Backlight LED brightness sysfs node.
	pdx::LocalHandle backlight_brightness_fd_;		pdx::LocalHandle backlight_brightness_fd_;

	// Primary display wait_pingpong state sysfs node.
	pdx::LocalHandle primary_display_wait_pp_fd_;

	// VSync sleep timerfd.		// VSync sleep timerfd.
	pdx::LocalHandle vsync_sleep_timer_fd_;		pdx::LocalHandle vsync_sleep_timer_fd_;