Merged vr window manager and vr composer (4af37959) · Commits · e / os / android_frameworks_native

services/vr/vr_window_manager/Android.mk

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -86,6 +86,7 @@ shared_libs := \
	libbinder \		libbinder \
	libinput \		libinput \
	libhardware \		libhardware \
			libhwbinder \
	libsync \		libsync \
	libutils \		libutils \
	libgui \		libgui \

services/vr/vr_window_manager/application.cpp

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -162,8 +162,8 @@ void Application::ProcessTasks(const std::vector<MainThreadTask>& tasks) {
	break;		break;
	case MainThreadTask::EnteringVrMode:		case MainThreadTask::EnteringVrMode:
	if (!initialized_) {		if (!initialized_) {
	if (AllocateResources())		LOG_ALWAYS_FATAL_IF(AllocateResources(),
	ALOGE("Failed to allocate resources");		"Failed to allocate resources");
	}		}
	break;		break;
	case MainThreadTask::ExitingVrMode:		case MainThreadTask::ExitingVrMode:

services/vr/vr_window_manager/composer/impl/vr_composer_view.cpp

+8 −53

Original line number	Original line	Diff line number	Diff line
	@@ -3,7 +3,9 @@
	namespace android {		namespace android {
	namespace dvr {		namespace dvr {

	VrComposerView::VrComposerView() : composer_view_(nullptr) {}		VrComposerView::VrComposerView(
			std::unique_ptr<VrComposerView::Callback> callback)
			: composer_view_(nullptr), callback_(std::move(callback)) {}

	VrComposerView::~VrComposerView() {		VrComposerView::~VrComposerView() {
	composer_view_->UnregisterObserver(this);		composer_view_->UnregisterObserver(this);
	@@ -14,66 +16,19 @@ void VrComposerView::Initialize(ComposerView* composer_view) {
	composer_view_->RegisterObserver(this);		composer_view_->RegisterObserver(this);
	}		}

	Return<void> VrComposerView::registerCallback(		void VrComposerView::ReleaseFrame() {
	const sp<IVrComposerCallback>& callback) {		LOG_ALWAYS_FATAL_IF(!composer_view_, "VrComposerView not initialized");
	callback_ = callback;
	return Void();
	}

	Return<void> VrComposerView::releaseFrame() {
	composer_view_->ReleaseFrame();		composer_view_->ReleaseFrame();
	return Void();
	}		}

	void VrComposerView::OnNewFrame(const ComposerView::Frame& frame) {		void VrComposerView::OnNewFrame(const ComposerView::Frame& frame) {
			std::lock_guard<std::mutex> guard(mutex_);
	if (!callback_.get()) {		if (!callback_.get()) {
	releaseFrame();		ReleaseFrame();
	return;		return;
	}		}

	std::vector<IVrComposerCallback::Layer> layers;		callback_->OnNewFrame(frame);
	std::vector<native_handle_t*> fences;
	for (size_t i = 0; i < frame.size(); ++i) {
	native_handle_t* fence;
	if (frame[i].fence->isValid()) {
	fence = native_handle_create(1, 0);
	fence->data[0] = frame[i].fence->dup();
	} else {
	fence = native_handle_create(0, 0);
	}
	fences.push_back(fence);

	layers.push_back(IVrComposerCallback::Layer{
	.buffer = hidl_handle(frame[i].buffer->getNativeBuffer()->handle),
	.fence = hidl_handle(fence),
	.display_frame = frame[i].display_frame,
	.crop = frame[i].crop,
	.blend_mode= frame[i].blend_mode,
	.alpha = frame[i].alpha,
	.type = frame[i].type,
	.app_id = frame[i].app_id,
	});
	}

	auto status =
	callback_->onNewFrame(hidl_vec<IVrComposerCallback::Layer>(layers));
	if (!status.isOk()) {
	ALOGE("Failed to send onNewFrame: %s", status.description().c_str());
	releaseFrame();
	}

	for (size_t i = 0; i < fences.size(); ++i) {
	native_handle_close(fences[i]);
	native_handle_delete(fences[i]);
	}
	}

	VrComposerView* GetVrComposerViewFromIVrComposerView(IVrComposerView* view) {
	return static_cast<VrComposerView*>(view);
	}

	IVrComposerView* HIDL_FETCH_IVrComposerView(const char* name) {
	return new VrComposerView();
	}		}

	} // namespace dvr		} // namespace dvr

services/vr/vr_window_manager/composer/impl/vr_composer_view.h

+12 −16

Original line number	Original line	Diff line number	Diff line
	#ifndef VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_COMPOSER_VIEW_H_		#ifndef VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_COMPOSER_VIEW_H_
	#define VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_COMPOSER_VIEW_H_		#define VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_COMPOSER_VIEW_H_

	#include <android/dvr/composer/1.0/IVrComposerCallback.h>		#include <memory>
	#include <android/dvr/composer/1.0/IVrComposerView.h>

	#include "vr_hwc.h"		#include "vr_hwc.h"

	namespace android {		namespace android {
	namespace dvr {		namespace dvr {

	using composer::V1_0::IVrComposerView;		class VrComposerView : public ComposerView::Observer {
	using composer::V1_0::IVrComposerCallback;		public:
			class Callback {
	class VrComposerView : public IVrComposerView, public ComposerView::Observer {
	public:		public:
	VrComposerView();		virtual ~Callback() = default;
			virtual void OnNewFrame(const ComposerView::Frame& frame) = 0;
			};

			VrComposerView(std::unique_ptr<Callback> callback);
	~VrComposerView() override;		~VrComposerView() override;

	void Initialize(ComposerView* composer_view);		void Initialize(ComposerView* composer_view);

	// IVrComposerView		void ReleaseFrame();
	Return<void> registerCallback(const sp<IVrComposerCallback>& callback)
	override;
	Return<void> releaseFrame() override;

	// ComposerView::Observer		// ComposerView::Observer
	void OnNewFrame(const ComposerView::Frame& frame) override;		void OnNewFrame(const ComposerView::Frame& frame) override;

	private:		private:
	ComposerView* composer_view_;		ComposerView* composer_view_;
	sp<IVrComposerCallback> callback_;		std::unique_ptr<Callback> callback_;
			std::mutex mutex_;
	};		};

	VrComposerView* GetVrComposerViewFromIVrComposerView(IVrComposerView* view);

	IVrComposerView* HIDL_FETCH_IVrComposerView(const char* name);

	} // namespace dvr		} // namespace dvr
	} // namespace android		} // namespace android

services/vr/vr_window_manager/hwc_callback.cpp

+4 −16

Original line number	Original line	Diff line number	Diff line
	@@ -62,27 +62,18 @@ HwcCallback::FrameStatus GetFrameStatus(const HwcCallback::Frame& frame) {

	} // namespace		} // namespace

	HwcCallback::HwcCallback(IVrComposerView* composer_view, Client* client)		HwcCallback::HwcCallback(Client* client) : client_(client) {
	: composer_view_(composer_view),
	client_(client) {
	composer_view_->registerCallback(this);
	}		}

	HwcCallback::~HwcCallback() {		HwcCallback::~HwcCallback() {
	composer_view_->registerCallback(nullptr);
	}		}

	Return<void> HwcCallback::onNewFrame(		void HwcCallback::OnNewFrame(const ComposerView::Frame& frame) {
	const hidl_vec<IVrComposerCallback::Layer>& frame) {

	std::vector<HwcLayer> hwc_frame(frame.size());		std::vector<HwcLayer> hwc_frame(frame.size());
	for (size_t i = 0; i < frame.size(); ++i) {		for (size_t i = 0; i < frame.size(); ++i) {
	int fence = frame[i].fence.getNativeHandle()->numFds ?
	dup(frame[i].fence.getNativeHandle()->data[0]) : -1;

	hwc_frame[i] = HwcLayer{		hwc_frame[i] = HwcLayer{
	.fence = new Fence(fence),		.fence = frame[i].fence,
	.buffer = GetBufferFromHandle(frame[i].buffer.getNativeHandle()),		.buffer = frame[i].buffer,
	.crop = frame[i].crop,		.crop = frame[i].crop,
	.display_frame = frame[i].display_frame,		.display_frame = frame[i].display_frame,
	.blending = static_cast<int32_t>(frame[i].blend_mode),		.blending = static_cast<int32_t>(frame[i].blend_mode),
	@@ -92,10 +83,7 @@ Return<void> HwcCallback::onNewFrame(
	};		};
	}		}

	std::lock_guard<std::mutex> guard(mutex_);
	client_->OnFrame(std::make_unique<Frame>(std::move(hwc_frame)));		client_->OnFrame(std::make_unique<Frame>(std::move(hwc_frame)));

	return Void();
	}		}

	HwcCallback::Frame::Frame(std::vector<HwcLayer>&& layers)		HwcCallback::Frame::Frame(std::vector<HwcLayer>&& layers)