Merge "remove vr/libeds" into oc-dev am: db768fd8e5 (cfa1f2c0) · Commits · e / os / android_frameworks_native-old

libs/vr/libeds/Android.bp

deleted100644 → 0

+0 −85

Original line number	Diff line number	Diff line
		// Copyright (C) 2015 The Android Open Source Project
		//
		// Licensed under the Apache License, Version 2.0 (the "License");
		// you may not use this file except in compliance with the License.
		// You may obtain a copy of the License at
		//
		// http://www.apache.org/licenses/LICENSE-2.0
		//
		// Unless required by applicable law or agreed to in writing, software
		// distributed under the License is distributed on an "AS IS" BASIS,
		// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		// See the License for the specific language governing permissions and
		// limitations under the License.

		sourceFiles = [
		"eds.cpp",
		"eds_mesh.cpp",
		"composite_hmd.cpp",
		"display_metrics.cpp",
		"distortion_renderer.cpp",
		"device_metrics.cpp",
		"polynomial_radial_distortion.cpp",
		]

		localIncludeFiles = [
		"include",
		]

		sharedLibraries = [
		"libbase",
		"libcutils",
		"liblog",
		"libEGL",
		"libGLESv1_CM",
		"libGLESv2",
		"libui",
		"libutils",
		"libvulkan",
		]

		staticLibraries = [
		"libdisplay",
		"libdvrcommon",
		"libdvrgraphics",
		"libvrsensor",
		"libpdx_default_transport",
		]

		cc_library_static {
		srcs: sourceFiles,
		cflags: [
		"-DGL_GLEXT_PROTOTYPES",
		"-DEGL_EGLEXT_PROTOTYPES",
		"-Wno-unused-parameter"],
		// Enable debug options below to show GL errors and use gdb.
		// + ["-UNDEBUG", "-DDEBUG", "-O0", "-g", ]
		export_include_dirs: localIncludeFiles,
		shared_libs: sharedLibraries,
		static_libs: staticLibraries,
		name: "libeds",
		}

		testFiles = ["tests/eds_app_tests.cpp"]

		cc_test {
		name: "eds_app_tests",
		tags: ["optional"],

		srcs: testFiles,

		shared_libs: [
		"libhardware",
		"libsync",
		] + sharedLibraries,

		static_libs: [
		"libgmock_main",
		"libgmock",
		"libeds",
		] + staticLibraries + [
		"libbufferhub",
		"libbufferhubqueue",
		],

		}

libs/vr/libeds/composite_hmd.cpp

deleted100644 → 0

+0 −257

Original line number	Diff line number	Diff line
		#include "include/private/dvr/composite_hmd.h"

		#include <log/log.h>

		#include <private/dvr/numeric.h>

		namespace android {
		namespace dvr {

		CompositeHmd::CompositeHmd(const HeadMountMetrics& head_mount_metrics,
		const DisplayMetrics& display_metrics)
		: head_mount_metrics_(head_mount_metrics),
		display_metrics_(display_metrics) {
		MetricsChanged();
		}

		float CompositeHmd::GetTargetFrameDuration() const {
		return display_metrics_.GetFrameDurationSeconds();
		}

		vec2 CompositeHmd::ComputeDistortedPoint(EyeType eye, vec2 position,
		RgbColorChannel channel) const {
		position = TransformPoint(eye_tan_angle_from_norm_screen_matrix_[eye], position);
		vec2 distorted =
		head_mount_metrics_.GetColorChannelDistortion(channel).Distort(position);
		return TransformPoint(eye_norm_texture_from_tan_angle_matrix_[eye], distorted);
		}

		vec2 CompositeHmd::ComputeInverseDistortedPoint(EyeType eye, vec2 position,
		RgbColorChannel channel) const {
		position = TransformPoint(eye_norm_texture_from_tan_angle_inv_matrix_[eye], position);
		vec2 distorted =
		head_mount_metrics_.GetColorChannelDistortion(channel).DistortInverse(
		position);
		return TransformPoint(eye_tan_angle_from_norm_screen_inv_matrix_[eye], distorted);
		}

		void CompositeHmd::ComputeDistortedVertex(EyeType eye, vec2 uv_in,
		vec2* vertex_out,
		vec2* uv_out) const {
		// The mesh vertices holds the shape of the distortion.
		vec2 vertex_position = ComputeInverseDistortedPoint(eye, uv_in, kRed);
		*vertex_out = vec2(vertex_position.x() - 0.5f, vertex_position.y() - 0.5f);

		if (uv_out) {
		// Compute the texture coordinate for each vertex coordinate.
		// Red's is the inverse of the inverse, skip the calculation and use uv_in.
		uv_out[kRed] = uv_in;
		uv_out[kGreen] = ComputeDistortedPoint(eye, vertex_position, kGreen);
		uv_out[kBlue] = ComputeDistortedPoint(eye, vertex_position, kBlue);
		}
		}

		vec2i CompositeHmd::GetRecommendedRenderTargetSize() const {
		return recommended_render_target_size_;
		}

		Range2i CompositeHmd::GetDisplayRange() const { return display_range_; }

		mat4 CompositeHmd::GetEyeFromHeadMatrix(EyeType eye) const {
		return eye_from_head_matrix_[eye];
		}

		FieldOfView CompositeHmd::GetEyeFov(EyeType eye) const { return eye_fov_[eye]; }

		Range2i CompositeHmd::GetEyeViewportBounds(EyeType eye) const {
		return eye_viewport_range_[eye];
		}

		void CompositeHmd::SetHeadMountMetrics(
		const HeadMountMetrics& head_mount_metrics) {
		// Use the assignement operator to do memberwise copy.
		head_mount_metrics_ = head_mount_metrics;
		MetricsChanged();
		}

		const HeadMountMetrics& CompositeHmd::GetHeadMountMetrics() const {
		return head_mount_metrics_;
		}

		void CompositeHmd::SetDisplayMetrics(const DisplayMetrics& display_metrics) {
		// Use the assignment operator to do memberwise copy.
		display_metrics_ = display_metrics;
		MetricsChanged();
		}

		const DisplayMetrics& CompositeHmd::GetDisplayMetrics() const {
		return display_metrics_;
		}

		void CompositeHmd::MetricsChanged() {
		// Abbreviations in variable names:
		// "vp": viewport
		// "ta": tan-angle
		const HeadMountMetrics& mount = head_mount_metrics_;
		DisplayMetrics display = display_metrics_;

		if (display.IsPortrait()) {
		// If we're in portrait mode, toggle the orientation so that all
		// calculations are done in landscape mode.
		display.ToggleOrientation();
		}

		float display_width_meters = display.GetSizeMeters()[0];
		float display_height_meters = display.GetSizeMeters()[1];

		vec2 pixels_per_meter = vec2(1.0f / display.GetMetersPerPixel()[0],
		1.0f / display.GetMetersPerPixel()[1]);

		// virtual_eye_to_screen_dist is the distance from the screen to the eye
		// after it has been projected through the lens. This would normally be
		// slightly different from the distance to the actual eye.
		float virtual_eye_to_screen_dist = mount.GetVirtualEyeToScreenDistance();
		float meters_per_tan_angle = virtual_eye_to_screen_dist;
		vec2 pixels_per_tan_angle = pixels_per_meter * meters_per_tan_angle;

		LOG_ALWAYS_FATAL_IF(0.0f == display_width_meters);
		LOG_ALWAYS_FATAL_IF(0.0f == display_height_meters);
		LOG_ALWAYS_FATAL_IF(0.0f == virtual_eye_to_screen_dist);

		// Height of lenses from the bottom of the screen.
		float lens_y_center = 0;
		float bottom_dist = 0;
		float top_dist = 0;

		// bottom_display_dist and top_display_dist represent the distance from the
		// lens center to the edge of the display.
		float bottom_display_dist = 0;
		float top_display_dist = 0;
		switch (mount.GetVerticalAlignment()) {
		case HeadMountMetrics::kBottom:
		lens_y_center =
		mount.GetTrayToLensDistance() - display.GetBorderSizeMeters();
		bottom_dist = lens_y_center;
		top_dist = lens_y_center;
		bottom_display_dist = lens_y_center;
		top_display_dist = display_height_meters - lens_y_center;
		break;
		case HeadMountMetrics::kCenter:
		// TODO(hendrikw): This should respect the border size, but since we
		// currently hard code the border size, it would break
		// the distortion on some devices. Revisit when border
		// size is fixed.
		lens_y_center = display_height_meters * 0.5f;
		bottom_dist = lens_y_center;
		top_dist = lens_y_center;
		bottom_display_dist = lens_y_center;
		top_display_dist = lens_y_center;
		break;
		case HeadMountMetrics::kTop:
		lens_y_center = display_height_meters - (mount.GetTrayToLensDistance() -
		display.GetBorderSizeMeters());
		bottom_dist =
		mount.GetTrayToLensDistance() - display.GetBorderSizeMeters();
		top_dist = bottom_dist;
		bottom_display_dist = lens_y_center;
		top_display_dist = display_height_meters - lens_y_center;
		break;
		}

		float inner_dist = mount.GetScreenCenterToLensDistance();
		float outer_dist = display_width_meters * 0.5f - inner_dist;

		// We don't take chromatic aberration into account yet for computing FOV,
		// viewport, etc, so we only use the green channel for now. Note the actual
		// Distort function does implement chromatic aberration.
		const ColorChannelDistortion& distortion =
		mount.GetColorChannelDistortion(kGreen);

		vec2 outer_point(outer_dist / virtual_eye_to_screen_dist, 0.0f);
		vec2 inner_point(inner_dist / virtual_eye_to_screen_dist, 0.0f);
		vec2 bottom_point(0.0f, bottom_dist / virtual_eye_to_screen_dist);
		vec2 top_point(0.0f, top_dist / virtual_eye_to_screen_dist);

		float outer_angle = atanf(distortion.Distort(outer_point)[0]);
		float inner_angle = atanf(distortion.Distort(inner_point)[0]);
		float bottom_angle = atanf(distortion.Distort(bottom_point)[1]);
		float top_angle = atanf(distortion.Distort(top_point)[1]);

		for (EyeType eye : {kLeftEye, kRightEye}) {
		const FieldOfView max_fov = mount.GetEyeMaxFov(eye);
		float left_angle = (eye == kLeftEye) ? outer_angle : inner_angle;
		float right_angle = (eye == kLeftEye) ? inner_angle : outer_angle;

		eye_fov_[eye] = FieldOfView(std::min(left_angle, max_fov.GetLeft()),
		std::min(right_angle, max_fov.GetRight()),
		std::min(bottom_angle, max_fov.GetBottom()),
		std::min(top_angle, max_fov.GetTop()));

		vec2 texture_vp_ta_p1 =
		vec2(-tanf(eye_fov_[eye].GetLeft()), -tanf(eye_fov_[eye].GetBottom()));
		vec2 texture_vp_ta_p2 =
		vec2(tanf(eye_fov_[eye].GetRight()), tanf(eye_fov_[eye].GetTop()));
		vec2 texture_vp_size_ta = texture_vp_ta_p2 - texture_vp_ta_p1;

		vec2 texture_vp_sizef_pixels =
		texture_vp_size_ta.array() * pixels_per_tan_angle.array();

		vec2i texture_vp_size_pixels =
		vec2i(static_cast<int32_t>(roundf(texture_vp_sizef_pixels[0])),
		static_cast<int32_t>(roundf(texture_vp_sizef_pixels[1])));
		int vp_start_x =
		(eye == kLeftEye) ? 0 : eye_viewport_range_[kLeftEye].p2[0];

		eye_viewport_range_[eye] =
		Range2i::FromSize(vec2i(vp_start_x, 0), texture_vp_size_pixels);
		float left_dist = (eye == kLeftEye) ? outer_dist : inner_dist;
		float right_dist = (eye == kLeftEye) ? inner_dist : outer_dist;
		vec2 screen_ta_p1(-left_dist / virtual_eye_to_screen_dist,
		-bottom_display_dist / virtual_eye_to_screen_dist);
		vec2 screen_ta_p2(right_dist / virtual_eye_to_screen_dist,
		top_display_dist / virtual_eye_to_screen_dist);
		vec2 screen_ta_size = screen_ta_p2 - screen_ta_p1;

		// Align the tan angle coordinates to the nearest pixel. This will ensure
		// that the optical center doesn't straddle multiple pixels.
		// TODO(hendrikw): verify that this works correctly for Daydream View.
		vec2 tan_angle_per_pixel(screen_ta_size.array() /
		texture_vp_size_pixels.cast<float>().array());
		vec2 pixel_p1(screen_ta_p1.array() / tan_angle_per_pixel.array());
		vec2 pixel_shift(roundf(pixel_p1.x()) - pixel_p1.x(),
		roundf(pixel_p1.y()) - pixel_p1.y());
		screen_ta_p1 +=
		(tan_angle_per_pixel.array() * pixel_shift.array()).matrix();
		screen_ta_p2 +=
		(tan_angle_per_pixel.array() * pixel_shift.array()).matrix();

		// Calculate the transformations needed for the distortions.
		eye_tan_angle_from_norm_screen_matrix_[eye] =
		TranslationMatrix(vec2(screen_ta_p1)) *
		ScaleMatrix(screen_ta_size);
		eye_tan_angle_from_norm_screen_inv_matrix_[eye] =
		eye_tan_angle_from_norm_screen_matrix_[eye].inverse();

		eye_norm_texture_from_tan_angle_inv_matrix_[eye] =
		TranslationMatrix(texture_vp_ta_p1) *
		ScaleMatrix(texture_vp_size_ta);
		eye_norm_texture_from_tan_angle_matrix_[eye] =
		eye_norm_texture_from_tan_angle_inv_matrix_[eye].inverse();
		}
		vec2i left_vp_size = eye_viewport_range_[kLeftEye].GetSize();
		vec2i right_vp_size = eye_viewport_range_[kRightEye].GetSize();

		recommended_render_target_size_ =
		vec2i(left_vp_size[0] + right_vp_size[0],
		std::max(left_vp_size[1], right_vp_size[1]));

		display_range_ = Range2i::FromSize(vec2i(0, 0), display.GetSizePixels());

		eye_from_head_matrix_[kLeftEye] = Eigen::Translation3f(
		vec3(mount.GetScreenCenterToLensDistance(), 0.0f, 0.0f));
		eye_from_head_matrix_[kRightEye] = Eigen::Translation3f(
		vec3(-mount.GetScreenCenterToLensDistance(), 0.0f, 0.0f));
		}

		} // namespace dvr
		} // namespace android

libs/vr/libeds/device_metrics.cpp

deleted100644 → 0

+0 −172

Original line number	Diff line number	Diff line
		#include <private/dvr/device_metrics.h>

		#include <cutils/properties.h>
		#include <private/dvr/head_mount_metrics.h>
		#include <private/dvr/identity_distortion.h>
		#include <private/dvr/polynomial_radial_distortion.h>
		#include <private/dvr/types.h>
		#include "include/private/dvr/display_metrics.h"

		namespace {

		static constexpr char kRPolynomial[] = "persist.dvr.r_poly";
		static constexpr char kGPolynomial[] = "persist.dvr.g_poly";
		static constexpr char kBPolynomial[] = "persist.dvr.b_poly";
		static constexpr char kLensDistance[] = "persist.dvr.lens_distance";
		static constexpr char kDisplayGap[] = "persist.dvr.display_gap";
		static constexpr char kVEyeToDisplay[] = "persist.dvr.v_eye_to_display";
		static constexpr char kFovIOBT[] = "persist.dvr.fov_iobt";
		static constexpr char kScreenSize[] = "persist.dvr.screen_size";

		bool StringToFloat(const char* str, float* result) {
		char* endptr = nullptr;
		*result = std::strtof(str, &endptr);
		return !(str == endptr \|\| !endptr);
		}

		std::vector<std::string> SplitString(const std::string& string_to_split,
		char deliminator) {
		std::vector<std::string> result;
		std::string sub_string;
		std::stringstream ss(string_to_split);
		while (std::getline(ss, sub_string, deliminator))
		result.push_back(sub_string);
		return result;
		}

		std::vector<float> GetProperty(const char* name,
		const std::vector<float>& default_values) {
		char prop[PROPERTY_VALUE_MAX + 1] = {};
		property_get(name, prop, "");
		std::vector<std::string> values = SplitString(prop, ',');
		std::vector<float> results;
		for (const auto& value : values) {
		float result = 0.0f;
		if (StringToFloat(value.c_str(), &result)) {
		results.push_back(static_cast<float>(result));
		}
		}
		if (results.empty()) {
		return default_values;
		}
		return results;
		}

		float GetProperty(const char* name, float default_value) {
		char prop[PROPERTY_VALUE_MAX + 1] = {};
		property_get(name, prop, "");
		float result = 0.0f;
		if (StringToFloat(prop, &result)) {
		return static_cast<float>(result);
		}
		return default_value;
		}

		float GetInterLensDistance() { return GetProperty(kLensDistance, 0.064f); }

		float GetDisplayGap() { return GetProperty(kDisplayGap, 0.0f); }

		float GetTrayToLensDistance() { return 0.035f; }

		float GetVEyeToDisplay() { return GetProperty(kVEyeToDisplay, 0.042f); }

		android::dvr::vec2 GetDisplaySize() {
		static const std::vector<float> default_size = {0.0742177f, 0.131943f};
		std::vector<float> sizes = GetProperty(kScreenSize, default_size);
		if (sizes.size() != 0)
		sizes = default_size;
		return android::dvr::vec2(sizes[0], sizes[1]);
		}

		std::vector<float> GetMaxFOVs() {
		static const std::vector<float> defaults = {43.7f, 47.8f, 54.2f, 54.2f};
		std::vector<float> fovs = GetProperty(kFovIOBT, defaults);
		if (fovs.size() != 4)
		fovs = defaults;
		for (auto& value : fovs) {
		value = value * M_PI / 180.0f;
		}
		return fovs;
		}

		static const android::dvr::HeadMountMetrics::VerticalAlignment
		kDefaultVerticalAlignment = android::dvr::HeadMountMetrics::kCenter;

		// Default border size in meters.
		static const float kScreenBorderSize = 0.004f;

		// Refresh rate.
		static const float kScreenRefreshRate = 60.0f;

		// Default display orientation is portrait.
		static const android::dvr::DisplayOrientation kDisplayOrientation =
		android::dvr::DisplayOrientation::kPortrait;

		} // anonymous namespace

		namespace android {
		namespace dvr {

		HeadMountMetrics CreateHeadMountMetrics(const FieldOfView& l_fov,
		const FieldOfView& r_fov) {
		static const std::vector<float> default_r = {
		0.00103f, 2.63917f, -7.14427f, 8.98036f, -4.10586f, 0.83705f, 0.00130f};
		static const std::vector<float> default_g = {
		0.08944f, 2.26005f, -6.30924f, 7.94561f, -3.22788f, 0.45577f, 0.07300f};
		static const std::vector<float> default_b = {
		0.16364f, 1.94083f, -5.55033f, 6.89578f, -2.19053f, -0.04050f, 0.17380f};
		std::vector<float> poly_r = GetProperty(kRPolynomial, default_r);
		std::vector<float> poly_g = GetProperty(kGPolynomial, default_g);
		std::vector<float> poly_b = GetProperty(kBPolynomial, default_b);

		std::shared_ptr<ColorChannelDistortion> distortion_r(
		new PolynomialRadialDistortion(poly_r));
		std::shared_ptr<ColorChannelDistortion> distortion_g(
		new PolynomialRadialDistortion(poly_g));
		std::shared_ptr<ColorChannelDistortion> distortion_b(
		new PolynomialRadialDistortion(poly_b));

		return HeadMountMetrics(GetInterLensDistance(), GetTrayToLensDistance(),
		GetVEyeToDisplay(), kDefaultVerticalAlignment, l_fov,
		r_fov, distortion_r, distortion_g, distortion_b,
		HeadMountMetrics::EyeOrientation::kCCW0Degrees,
		HeadMountMetrics::EyeOrientation::kCCW0Degrees,
		(GetInterLensDistance() - GetDisplayGap()) / 2.0f);
		}

		HeadMountMetrics CreateHeadMountMetrics() {
		std::vector<float> fovs = GetMaxFOVs();
		FieldOfView l_fov(fovs[1], fovs[0], fovs[2], fovs[3]);
		FieldOfView r_fov(fovs[0], fovs[1], fovs[2], fovs[3]);
		return CreateHeadMountMetrics(l_fov, r_fov);
		}

		DisplayMetrics CreateDisplayMetrics(vec2i screen_size) {
		android::dvr::vec2 size_in_meters = GetDisplaySize();
		vec2 meters_per_pixel(size_in_meters[0] / static_cast<float>(screen_size[0]),
		size_in_meters[1] / static_cast<float>(screen_size[1]));
		return DisplayMetrics(screen_size, meters_per_pixel, kScreenBorderSize,
		1000.0f / kScreenRefreshRate, kDisplayOrientation);
		}

		HeadMountMetrics CreateUndistortedHeadMountMetrics() {
		std::vector<float> fovs = GetMaxFOVs();
		FieldOfView l_fov(fovs[1], fovs[0], fovs[2], fovs[3]);
		FieldOfView r_fov(fovs[0], fovs[1], fovs[2], fovs[3]);
		return CreateUndistortedHeadMountMetrics(l_fov, r_fov);
		}

		HeadMountMetrics CreateUndistortedHeadMountMetrics(const FieldOfView& l_fov,
		const FieldOfView& r_fov) {
		auto distortion_all = std::make_shared<IdentityDistortion>();

		return HeadMountMetrics(GetInterLensDistance(), GetVEyeToDisplay(),
		GetVEyeToDisplay(), kDefaultVerticalAlignment, l_fov,
		r_fov, distortion_all, distortion_all, distortion_all,
		HeadMountMetrics::EyeOrientation::kCCW0Degrees,
		HeadMountMetrics::EyeOrientation::kCCW0Degrees,
		(GetInterLensDistance() - GetDisplayGap()) / 2.0f);
		}

		} // namespace dvr
		} // namespace android

libs/vr/libeds/display_metrics.cpp

deleted100644 → 0

+0 −30

Original line number	Diff line number	Diff line
		#include "include/private/dvr/display_metrics.h"

		namespace android {
		namespace dvr {

		DisplayMetrics::DisplayMetrics(vec2i size_pixels, vec2 meters_per_pixel,
		float border_size_meters,
		float frame_duration_seconds,
		DisplayOrientation orientation)
		: size_pixels_(size_pixels),
		meters_per_pixel_(meters_per_pixel),
		border_size_meters_(border_size_meters),
		frame_duration_seconds_(frame_duration_seconds),
		orientation_(orientation) {}

		void DisplayMetrics::ToggleOrientation() {
		std::swap(size_pixels_[0], size_pixels_[1]);
		std::swap(meters_per_pixel_[0], meters_per_pixel_[1]);
		if (orientation_ == DisplayOrientation::kPortrait)
		orientation_ = DisplayOrientation::kLandscape;
		else
		orientation_ = DisplayOrientation::kPortrait;
		}

		DisplayMetrics::DisplayMetrics()
		: DisplayMetrics(vec2i(0, 0), vec2(0.0f, 0.0f), 0.0f, 0.0f,
		DisplayOrientation::kLandscape) {}

		} // namespace dvr
		} // namespace android

libs/vr/libeds/distortion_renderer.cpp

deleted100644 → 0

+0 −792

File deleted.

Preview size limit exceeded, changes collapsed.