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

Commit 8c7e6db0 authored by Ian Elliott's avatar Ian Elliott
Browse files

swapchain: Implement VK_GOOGLE_surfaceless_query 

This extension allows ANGLE to call Vulkan WSI queries before it has a
VkSurfaceKHR.

Bug: 203826952
Test: Test with ANGLE EGLConfig-generation code
Change-Id: I7e53a8a28157023658baac0778033159bdd22800
Merged-In: I7eb013efbaa5dd19ebed045583616238cea57023
parent add26de1

vulkan/libvulkan/driver.cpp

+4 −0
Original line number Diff line number Diff line
@@ -626,6 +626,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { 
            case ProcHook::KHR_surface:

            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;
@@ -703,6 +704,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { 
            case ProcHook::KHR_surface:

            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:
@@ -922,6 +924,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

+1 −0
Original line number Diff line number Diff line
@@ -565,6 +565,7 @@ 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;

vulkan/libvulkan/driver_gen.h

+1 −0
Original line number Diff line number Diff line
@@ -41,6 +41,7 @@ struct ProcHook { 
        EXT_hdr_metadata,

        EXT_swapchain_colorspace,

        GOOGLE_display_timing,

        GOOGLE_surfaceless_query,

        KHR_android_surface,

        KHR_get_surface_capabilities2,

        KHR_incremental_present,

vulkan/libvulkan/swapchain.cpp

+128 −61
Original line number Diff line number Diff line
@@ -614,15 +614,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)",
@@ -636,21 +658,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);
@@ -690,6 +713,26 @@ 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);
@@ -697,16 +740,16 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, 
            return VK_ERROR_SURFACE_LOST_KHR;

        }

        ALOGV("wide_color_support is: %d", wide_color_support);

    wide_color_support =

        wide_color_support &&

        instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace);



        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
@@ -721,6 +764,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{
@@ -848,6 +895,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,
@@ -861,18 +926,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

+1 −0
Original line number Diff line number Diff line
@@ -27,6 +27,7 @@ _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',