Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d47c603a authored by Treehugger Robot's avatar Treehugger Robot Committed by Android (Google) Code Review
Browse files

Merge changes I82a7ac74,Iab875a90 into main 

* changes:
  swapchain: support RGBX backed opaque swapchain for offscreen
  swapchain: pass VkFormat to GetNativeDataspace directly
parents eba59ded d5b1690f

vulkan/libvulkan/swapchain.cpp

+66 −63
Original line number Diff line number Diff line
@@ -526,12 +526,15 @@ void copy_ready_timings(Swapchain& swapchain, 
    *count = num_copied;

}



PixelFormat GetNativePixelFormat(VkFormat format) {

PixelFormat GetNativePixelFormat(VkFormat format,

                                 VkCompositeAlphaFlagBitsKHR alpha) {

    PixelFormat native_format = PixelFormat::RGBA_8888;

    switch (format) {

        case VK_FORMAT_R8G8B8A8_UNORM:

        case VK_FORMAT_R8G8B8A8_SRGB:

            native_format = PixelFormat::RGBA_8888;

            native_format = alpha == VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR

                                ? PixelFormat::RGBX_8888

                                : PixelFormat::RGBA_8888;

            break;

        case VK_FORMAT_R5G6B5_UNORM_PACK16:

            native_format = PixelFormat::RGB_565;
@@ -555,8 +558,7 @@ PixelFormat GetNativePixelFormat(VkFormat format) { 
    return native_format;

}



DataSpace GetNativeDataspace(VkColorSpaceKHR colorspace,

                             PixelFormat pixelFormat) {

DataSpace GetNativeDataspace(VkColorSpaceKHR colorspace, VkFormat format) {

    switch (colorspace) {

        case VK_COLOR_SPACE_SRGB_NONLINEAR_KHR:

            return DataSpace::SRGB;
@@ -575,7 +577,7 @@ DataSpace GetNativeDataspace(VkColorSpaceKHR colorspace, 
        case VK_COLOR_SPACE_BT709_NONLINEAR_EXT:

            return DataSpace::SRGB;

        case VK_COLOR_SPACE_BT2020_LINEAR_EXT:

            if (pixelFormat == PixelFormat::RGBA_FP16) {

            if (format == VK_FORMAT_R16G16B16A16_SFLOAT) {

                return DataSpace::BT2020_LINEAR_EXTENDED;

            } else {

                return DataSpace::BT2020_LINEAR;
@@ -764,21 +766,20 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, 
        {VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR},

    };



    VkFormat format = VK_FORMAT_UNDEFINED;

    if (colorspace_ext) {

        for (VkColorSpaceKHR colorSpace :

             colorSpaceSupportedByVkEXTSwapchainColorspace) {

            if (GetNativeDataspace(colorSpace, GetNativePixelFormat(

                                                   VK_FORMAT_R8G8B8A8_UNORM)) !=

                DataSpace::UNKNOWN) {

            format = VK_FORMAT_R8G8B8A8_UNORM;

            if (GetNativeDataspace(colorSpace, format) != DataSpace::UNKNOWN) {

                all_formats.emplace_back(

                    VkSurfaceFormatKHR{VK_FORMAT_R8G8B8A8_UNORM, colorSpace});

                    VkSurfaceFormatKHR{format, colorSpace});

            }



            if (GetNativeDataspace(colorSpace, GetNativePixelFormat(

                                                   VK_FORMAT_R8G8B8A8_SRGB)) !=

                DataSpace::UNKNOWN) {

            format = VK_FORMAT_R8G8B8A8_SRGB;

            if (GetNativeDataspace(colorSpace, format) != DataSpace::UNKNOWN) {

                all_formats.emplace_back(

                    VkSurfaceFormatKHR{VK_FORMAT_R8G8B8A8_SRGB, colorSpace});

                    VkSurfaceFormatKHR{format, colorSpace});

            }

        }

    }
@@ -787,78 +788,73 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, 
    // Android users.  This includes the ANGLE team (a layered implementation of

    // OpenGL-ES).



    format = VK_FORMAT_R5G6B5_UNORM_PACK16;

    desc.format = AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM;

    if (AHardwareBuffer_isSupported(&desc)) {

        all_formats.emplace_back(VkSurfaceFormatKHR{

            VK_FORMAT_R5G6B5_UNORM_PACK16, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR});

        all_formats.emplace_back(

            VkSurfaceFormatKHR{format, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR});

        if (colorspace_ext) {

            for (VkColorSpaceKHR colorSpace :

                 colorSpaceSupportedByVkEXTSwapchainColorspace) {

                if (GetNativeDataspace(

                        colorSpace,

                        GetNativePixelFormat(VK_FORMAT_R5G6B5_UNORM_PACK16)) !=

                if (GetNativeDataspace(colorSpace, format) !=

                    DataSpace::UNKNOWN) {

                    all_formats.emplace_back(VkSurfaceFormatKHR{

                        VK_FORMAT_R5G6B5_UNORM_PACK16, colorSpace});

                    all_formats.emplace_back(

                        VkSurfaceFormatKHR{format, colorSpace});

                }

            }

        }

    }



    format = VK_FORMAT_R16G16B16A16_SFLOAT;

    desc.format = AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT;

    if (AHardwareBuffer_isSupported(&desc)) {

        all_formats.emplace_back(VkSurfaceFormatKHR{

            VK_FORMAT_R16G16B16A16_SFLOAT, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR});

        all_formats.emplace_back(

            VkSurfaceFormatKHR{format, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR});

        if (colorspace_ext) {

            for (VkColorSpaceKHR colorSpace :

                 colorSpaceSupportedByVkEXTSwapchainColorspace) {

                if (GetNativeDataspace(

                        colorSpace,

                        GetNativePixelFormat(VK_FORMAT_R16G16B16A16_SFLOAT)) !=

                if (GetNativeDataspace(colorSpace, format) !=

                    DataSpace::UNKNOWN) {

                    all_formats.emplace_back(VkSurfaceFormatKHR{

                        VK_FORMAT_R16G16B16A16_SFLOAT, colorSpace});

                    all_formats.emplace_back(

                        VkSurfaceFormatKHR{format, colorSpace});

                }

            }



            for (

                VkColorSpaceKHR colorSpace :

                colorSpaceSupportedByVkEXTSwapchainColorspaceOnFP16SurfaceOnly) {

                if (GetNativeDataspace(

                        colorSpace,

                        GetNativePixelFormat(VK_FORMAT_R16G16B16A16_SFLOAT)) !=

                if (GetNativeDataspace(colorSpace, format) !=

                    DataSpace::UNKNOWN) {

                    all_formats.emplace_back(VkSurfaceFormatKHR{

                        VK_FORMAT_R16G16B16A16_SFLOAT, colorSpace});

                    all_formats.emplace_back(

                        VkSurfaceFormatKHR{format, colorSpace});

                }

            }

        }

    }



    format = VK_FORMAT_A2B10G10R10_UNORM_PACK32;

    desc.format = AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM;

    if (AHardwareBuffer_isSupported(&desc)) {

        all_formats.emplace_back(

            VkSurfaceFormatKHR{VK_FORMAT_A2B10G10R10_UNORM_PACK32,

                               VK_COLOR_SPACE_SRGB_NONLINEAR_KHR});

            VkSurfaceFormatKHR{format, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR});

        if (colorspace_ext) {

            for (VkColorSpaceKHR colorSpace :

                 colorSpaceSupportedByVkEXTSwapchainColorspace) {

                if (GetNativeDataspace(

                        colorSpace, GetNativePixelFormat(

                                        VK_FORMAT_A2B10G10R10_UNORM_PACK32)) !=

                if (GetNativeDataspace(colorSpace, format) !=

                    DataSpace::UNKNOWN) {

                    all_formats.emplace_back(VkSurfaceFormatKHR{

                        VK_FORMAT_A2B10G10R10_UNORM_PACK32, colorSpace});

                    all_formats.emplace_back(

                        VkSurfaceFormatKHR{format, colorSpace});

                }

            }

        }

    }



    format = VK_FORMAT_R8_UNORM;

    desc.format = AHARDWAREBUFFER_FORMAT_R8_UNORM;

    if (AHardwareBuffer_isSupported(&desc)) {

        if (colorspace_ext) {

            all_formats.emplace_back(VkSurfaceFormatKHR{

                VK_FORMAT_R8_UNORM, VK_COLOR_SPACE_PASS_THROUGH_EXT});

            all_formats.emplace_back(

                VkSurfaceFormatKHR{format, VK_COLOR_SPACE_PASS_THROUGH_EXT});

        }

    }
@@ -877,22 +873,18 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, 
            rgba10x6_formats_ext = true;

        }

    }

    format = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16;

    desc.format = AHARDWAREBUFFER_FORMAT_R10G10B10A10_UNORM;

    if (AHardwareBuffer_isSupported(&desc) && rgba10x6_formats_ext) {

        all_formats.emplace_back(

            VkSurfaceFormatKHR{VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,

                               VK_COLOR_SPACE_SRGB_NONLINEAR_KHR});

            VkSurfaceFormatKHR{format, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR});

        if (colorspace_ext) {

            for (VkColorSpaceKHR colorSpace :

                 colorSpaceSupportedByVkEXTSwapchainColorspace) {

                if (GetNativeDataspace(

                        colorSpace,

                        GetNativePixelFormat(

                            VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16)) !=

                if (GetNativeDataspace(colorSpace, format) !=

                    DataSpace::UNKNOWN) {

                    all_formats.emplace_back(VkSurfaceFormatKHR{

                        VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,

                        colorSpace});

                    all_formats.emplace_back(

                        VkSurfaceFormatKHR{format, colorSpace});

                }

            }

        }
@@ -912,7 +904,7 @@ VkResult GetPhysicalDeviceSurfaceCapabilities2KHR( 
    VkSurfaceCapabilities2KHR* pSurfaceCapabilities) {

    ATRACE_CALL();



    auto surface = pSurfaceInfo->surface;

    auto surface_handle = pSurfaceInfo->surface;

    auto capabilities = &pSurfaceCapabilities->surfaceCapabilities;



    VkSurfacePresentModeEXT const *pPresentMode = nullptr;
@@ -933,7 +925,13 @@ VkResult GetPhysicalDeviceSurfaceCapabilities2KHR( 
    int transform_hint;

    int max_buffer_count;

    int min_undequeued_buffers;

    if (surface == VK_NULL_HANDLE) {

    // On Android, window composition is a WindowManager property, not something

    // associated with the bufferqueue. It can't be changed from here for a

    // swapchain connected with SurfaceFlinger. For offscreen surfaces, it's

    // allowed to report opaque being supported for RGBX preference.

    VkCompositeAlphaFlagsKHR composite_alpha =

        VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;

    if (surface_handle == VK_NULL_HANDLE) {

        const InstanceData& instance_data = GetData(physicalDevice);

        ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query;

        bool surfaceless_enabled =
@@ -954,7 +952,8 @@ VkResult GetPhysicalDeviceSurfaceCapabilities2KHR( 
        capabilities->minImageCount = 0xFFFFFFFF;

        capabilities->maxImageCount = 0xFFFFFFFF;

    } else {

        ANativeWindow* window = SurfaceFromHandle(surface)->window.get();

        Surface& surface = *SurfaceFromHandle(surface_handle);

        ANativeWindow* window = surface.window.get();



        err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width);

        if (err != android::OK) {
@@ -1029,6 +1028,11 @@ VkResult GetPhysicalDeviceSurfaceCapabilities2KHR( 
                    min_undequeued_buffers + default_additional_buffers);

            capabilities->maxImageCount = static_cast<uint32_t>(max_buffer_count);

        }



        if (!(surface.consumer_usage &

              AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY)) {

            composite_alpha |= VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;

        }

    }



    capabilities->currentExtent =
@@ -1055,9 +1059,7 @@ VkResult GetPhysicalDeviceSurfaceCapabilities2KHR( 
    capabilities->currentTransform =

        TranslateNativeToVulkanTransform(transform_hint);



    // On Android, window composition is a WindowManager property, not something

    // associated with the bufferqueue. It can't be changed from here.

    capabilities->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;

    capabilities->supportedCompositeAlpha = composite_alpha;



    capabilities->supportedUsageFlags =

        VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
@@ -1656,22 +1658,23 @@ VkResult CreateSwapchainKHR(VkDevice device, 


    ALOGV("vkCreateSwapchainKHR: surface=0x%" PRIx64

          " minImageCount=%u imageFormat=%u imageColorSpace=%u"

          " imageExtent=%ux%u imageUsage=%#x preTransform=%u presentMode=%u"

          " oldSwapchain=0x%" PRIx64,

          " imageExtent=%ux%u imageUsage=%#x preTransform=%u compositeAlpha=%u"

          " presentMode=%u oldSwapchain=0x%" PRIx64,

          reinterpret_cast<uint64_t>(create_info->surface),

          create_info->minImageCount, create_info->imageFormat,

          create_info->imageColorSpace, create_info->imageExtent.width,

          create_info->imageExtent.height, create_info->imageUsage,

          create_info->preTransform, create_info->presentMode,

          create_info->preTransform, create_info->compositeAlpha,

          create_info->presentMode,

          reinterpret_cast<uint64_t>(create_info->oldSwapchain));



    if (!allocator)

        allocator = &GetData(device).allocator;



    PixelFormat native_pixel_format =

        GetNativePixelFormat(create_info->imageFormat);

    DataSpace native_dataspace =

        GetNativeDataspace(create_info->imageColorSpace, native_pixel_format);

    PixelFormat native_pixel_format = GetNativePixelFormat(

        create_info->imageFormat, create_info->compositeAlpha);

    DataSpace native_dataspace = GetNativeDataspace(

        create_info->imageColorSpace, create_info->imageFormat);

    if (native_dataspace == DataSpace::UNKNOWN) {

        ALOGE(

            "CreateSwapchainKHR(VkSwapchainCreateInfoKHR.imageColorSpace = %d) "