Merge changes from topics "presubmit-am-2cdd826ba79049868e8caf3315eb6c80",... (f9d386d1) · Commits · e / os / platform_frameworks_native

vulkan/libvulkan/driver.cpp

+9 −0

Original line number	Diff line number	Diff line
		@@ -632,8 +632,10 @@ void CreateInfoWrapper::FilterExtension(const char* name) {
		switch (ext_bit) {
		case ProcHook::KHR_android_surface:
		case ProcHook::KHR_surface:
		case ProcHook::KHR_surface_protected_capabilities:
		case ProcHook::EXT_swapchain_colorspace:
		case ProcHook::KHR_get_surface_capabilities2:
		case ProcHook::GOOGLE_surfaceless_query:
		hook_extensions_.set(ext_bit);
		// return now as these extensions do not require HAL support
		return;
		@@ -710,8 +712,10 @@ void CreateInfoWrapper::FilterExtension(const char* name) {
		case ProcHook::KHR_external_fence_capabilities:
		case ProcHook::KHR_get_surface_capabilities2:
		case ProcHook::KHR_surface:
		case ProcHook::KHR_surface_protected_capabilities:
		case ProcHook::EXT_debug_report:
		case ProcHook::EXT_swapchain_colorspace:
		case ProcHook::GOOGLE_surfaceless_query:
		case ProcHook::ANDROID_native_buffer:
		case ProcHook::EXTENSION_CORE_1_0:
		case ProcHook::EXTENSION_CORE_1_1:
		@@ -923,6 +927,9 @@ VkResult EnumerateInstanceExtensionProperties(
		loader_extensions.push_back({
		VK_KHR_SURFACE_EXTENSION_NAME,
		VK_KHR_SURFACE_SPEC_VERSION});
		loader_extensions.push_back(
		{VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME,
		VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION});
		loader_extensions.push_back({
		VK_KHR_ANDROID_SURFACE_EXTENSION_NAME,
		VK_KHR_ANDROID_SURFACE_SPEC_VERSION});
		@@ -932,6 +939,8 @@ VkResult EnumerateInstanceExtensionProperties(
		loader_extensions.push_back({
		VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME,
		VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION});
		loader_extensions.push_back({VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME,
		VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION});

		static const VkExtensionProperties loader_debug_report_extension = {
		VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION,

vulkan/libvulkan/driver_gen.cpp

+2 −0

Original line number	Diff line number	Diff line
		@@ -565,11 +565,13 @@ ProcHook::Extension GetProcHookExtension(const char* name) {
		if (strcmp(name, "VK_EXT_hdr_metadata") == 0) return ProcHook::EXT_hdr_metadata;
		if (strcmp(name, "VK_EXT_swapchain_colorspace") == 0) return ProcHook::EXT_swapchain_colorspace;
		if (strcmp(name, "VK_GOOGLE_display_timing") == 0) return ProcHook::GOOGLE_display_timing;
		if (strcmp(name, "VK_GOOGLE_surfaceless_query") == 0) return ProcHook::GOOGLE_surfaceless_query;
		if (strcmp(name, "VK_KHR_android_surface") == 0) return ProcHook::KHR_android_surface;
		if (strcmp(name, "VK_KHR_get_surface_capabilities2") == 0) return ProcHook::KHR_get_surface_capabilities2;
		if (strcmp(name, "VK_KHR_incremental_present") == 0) return ProcHook::KHR_incremental_present;
		if (strcmp(name, "VK_KHR_shared_presentable_image") == 0) return ProcHook::KHR_shared_presentable_image;
		if (strcmp(name, "VK_KHR_surface") == 0) return ProcHook::KHR_surface;
		if (strcmp(name, "VK_KHR_surface_protected_capabilities") == 0) return ProcHook::KHR_surface_protected_capabilities;
		if (strcmp(name, "VK_KHR_swapchain") == 0) return ProcHook::KHR_swapchain;
		if (strcmp(name, "VK_ANDROID_external_memory_android_hardware_buffer") == 0) return ProcHook::ANDROID_external_memory_android_hardware_buffer;
		if (strcmp(name, "VK_KHR_bind_memory2") == 0) return ProcHook::KHR_bind_memory2;

vulkan/libvulkan/driver_gen.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -41,11 +41,13 @@ struct ProcHook {
		EXT_hdr_metadata,
		EXT_swapchain_colorspace,
		GOOGLE_display_timing,
		GOOGLE_surfaceless_query,
		KHR_android_surface,
		KHR_get_surface_capabilities2,
		KHR_incremental_present,
		KHR_shared_presentable_image,
		KHR_surface,
		KHR_surface_protected_capabilities,
		KHR_swapchain,
		ANDROID_external_memory_android_hardware_buffer,
		KHR_bind_memory2,

vulkan/libvulkan/swapchain.cpp

+136 −59

Original line number	Diff line number	Diff line
		@@ -619,15 +619,37 @@ VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /pdev/,

		VKAPI_ATTR
		VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
		VkPhysicalDevice /pdev/,
		VkPhysicalDevice pdev,
		VkSurfaceKHR surface,
		VkSurfaceCapabilitiesKHR* capabilities) {
		ATRACE_CALL();

		int err;
		int width, height;
		int transform_hint;
		int max_buffer_count;
		if (surface == VK_NULL_HANDLE) {
		const InstanceData& instance_data = GetData(pdev);
		ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query;
		bool surfaceless_enabled =
		instance_data.hook_extensions.test(surfaceless);
		if (!surfaceless_enabled) {
		// It is an error to pass a surface==VK_NULL_HANDLE unless the
		// VK_GOOGLE_surfaceless_query extension is enabled
		return VK_ERROR_SURFACE_LOST_KHR;
		}
		// Support for VK_GOOGLE_surfaceless_query. The primary purpose of this
		// extension for this function is for
		// VkSurfaceProtectedCapabilitiesKHR::supportsProtected. The following
		// four values cannot be known without a surface. Default values will
		// be supplied anyway, but cannot be relied upon.
		width = 1000;
		height = 1000;
		transform_hint = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
		max_buffer_count = 10;
		} else {
		ANativeWindow* window = SurfaceFromHandle(surface)->window.get();

		int width, height;
		err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width);
		if (err != android::OK) {
		ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
		@@ -641,21 +663,22 @@ VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
		return VK_ERROR_SURFACE_LOST_KHR;
		}

		int transform_hint;
		err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, &transform_hint);
		err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT,
		&transform_hint);
		if (err != android::OK) {
		ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)",
		strerror(-err), err);
		return VK_ERROR_SURFACE_LOST_KHR;
		}

		int max_buffer_count;
		err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &max_buffer_count);
		err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT,
		&max_buffer_count);
		if (err != android::OK) {
		ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d)",
		strerror(-err), err);
		return VK_ERROR_SURFACE_LOST_KHR;
		}
		}
		capabilities->minImageCount = std::min(max_buffer_count, 3);
		capabilities->maxImageCount = static_cast<uint32_t>(max_buffer_count);

		@@ -695,23 +718,43 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev,
		const InstanceData& instance_data = GetData(pdev);

		bool wide_color_support = false;
		uint64_t consumer_usage = 0;
		bool swapchain_ext =
		instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace);
		if (surface_handle == VK_NULL_HANDLE) {
		ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query;
		bool surfaceless_enabled =
		instance_data.hook_extensions.test(surfaceless);
		if (!surfaceless_enabled) {
		return VK_ERROR_SURFACE_LOST_KHR;
		}
		// Support for VK_GOOGLE_surfaceless_query. The EGL loader
		// unconditionally supports wide color formats, even if they will cause
		// a SurfaceFlinger fallback. Based on that, wide_color_support will be
		// set to true in this case.
		wide_color_support = true;

		// TODO(b/203826952): research proper value; temporarily use the
		// values seen on Pixel
		consumer_usage = AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY;
		} else {
		Surface& surface = *SurfaceFromHandle(surface_handle);
		int err = native_window_get_wide_color_support(surface.window.get(),
		&wide_color_support);
		if (err) {
		return VK_ERROR_SURFACE_LOST_KHR;
		}
		bool swapchain_ext =
		instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace);
		ALOGV("wide_color_support is: %d", wide_color_support);

		consumer_usage = surface.consumer_usage;
		}
		wide_color_support = wide_color_support && swapchain_ext;

		AHardwareBuffer_Desc desc = {};
		desc.width = 1;
		desc.height = 1;
		desc.layers = 1;
		desc.usage = surface.consumer_usage \|
		AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE \|
		desc.usage = consumer_usage \| AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE \|
		AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER;

		// We must support R8G8B8A8
		@@ -731,6 +774,10 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev,
		VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT});
		}

		// NOTE: Any new formats that are added must be coordinated across different
		// Android users. This includes the ANGLE team (a layered implementation of
		// OpenGL-ES).

		desc.format = AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM;
		if (AHardwareBuffer_isSupported(&desc)) {
		all_formats.emplace_back(VkSurfaceFormatKHR{
		@@ -770,6 +817,10 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev,
		VK_COLOR_SPACE_PASS_THROUGH_EXT});
		}

		// NOTE: Any new formats that are added must be coordinated across different
		// Android users. This includes the ANGLE team (a layered implementation of
		// OpenGL-ES).

		VkResult result = VK_SUCCESS;
		if (formats) {
		uint32_t transfer_count = all_formats.size();
		@@ -814,6 +865,12 @@ VkResult GetPhysicalDeviceSurfaceCapabilities2KHR(
		.supportedUsageFlags;
		} break;

		case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: {
		VkSurfaceProtectedCapabilitiesKHR* protected_caps =
		reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(caps);
		protected_caps->supportsProtected = VK_TRUE;
		} break;

		default:
		// Ignore all other extension structs
		break;
		@@ -865,6 +922,24 @@ VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev,

		int err;
		int query_value;
		std::vector<VkPresentModeKHR> present_modes;
		if (surface == VK_NULL_HANDLE) {
		const InstanceData& instance_data = GetData(pdev);
		ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query;
		bool surfaceless_enabled =
		instance_data.hook_extensions.test(surfaceless);
		if (!surfaceless_enabled) {
		return VK_ERROR_SURFACE_LOST_KHR;
		}
		// Support for VK_GOOGLE_surfaceless_query. The primary purpose of this
		// extension for this function is for
		// VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR and
		// VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR. We technically cannot
		// know if VK_PRESENT_MODE_SHARED_MAILBOX_KHR is supported without a
		// surface, and that cannot be relied upon.
		present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR);
		present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR);
		} else {
		ANativeWindow* window = SurfaceFromHandle(surface)->window.get();

		err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS,
		@@ -878,18 +953,20 @@ VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev,
		}
		uint32_t min_undequeued_buffers = static_cast<uint32_t>(query_value);

		err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &query_value);
		err =
		window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &query_value);
		if (err != android::OK \|\| query_value < 0) {
		ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d) value=%d",
		ALOGE(
		"NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d) value=%d",
		strerror(-err), err, query_value);
		return VK_ERROR_SURFACE_LOST_KHR;
		}
		uint32_t max_buffer_count = static_cast<uint32_t>(query_value);

		std::vector<VkPresentModeKHR> present_modes;
		if (min_undequeued_buffers + 1 < max_buffer_count)
		present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR);
		present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR);
		}

		VkPhysicalDevicePresentationPropertiesANDROID present_properties;
		QueryPresentationProperties(pdev, &present_properties);

vulkan/scripts/driver_generator.py

+2 −0

Original line number	Diff line number	Diff line
		@@ -27,11 +27,13 @@ _INTERCEPTED_EXTENSIONS = [
		'VK_EXT_hdr_metadata',
		'VK_EXT_swapchain_colorspace',
		'VK_GOOGLE_display_timing',
		'VK_GOOGLE_surfaceless_query',
		'VK_KHR_android_surface',
		'VK_KHR_get_surface_capabilities2',
		'VK_KHR_incremental_present',
		'VK_KHR_shared_presentable_image',
		'VK_KHR_surface',
		'VK_KHR_surface_protected_capabilities',
		'VK_KHR_swapchain',
		]