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

Commit 79397846 authored by Nikita Gupta's avatar Nikita Gupta Committed by Android (Google) Code Review
Browse files

Merge changes from topic "format_codegen" into main 

* changes:
  Handle all VK_FORMAT(s) in vkjson (generated output)
  Handle all VK_FORMAT(s) in vkjson
parents 6b3382ff 5b57ba67

vulkan/scripts/vkjson_gen_util.py

+101 −0
Original line number Diff line number Diff line
@@ -47,6 +47,8 @@ COPYRIGHT_WARNINGS = """//////////////////////////////////////////////////////// 
///////////////////////////////////////////////////////////////////////////////

"""



VK_FORMAT_RANGE_MAPPING = {}



def get_copyright_warnings():

    return COPYRIGHT_WARNINGS
@@ -537,3 +539,102 @@ def generate_vk_version_structs_initialization(version_data, struct_type_keyword 
                )



    return "\n".join(struct_initialization_code)





def find_contiguous_ranges(format_data):

  """Finds contiguous ranges of format values from a list of enums for a given extension or Vulkan API version.

    For example, for the format data for the below extension:

        "VK_EXT_ycbcr_2plane_444_formats": [

            ("VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT", 1000330000),

            ("VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT", 1000330001),

            ("VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT", 1000330002),

            ("VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT", 1000330003),

        ]



    The range of formats is:

    [(VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT,VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT)]

    """

  sorted_data = sorted(format_data, key=lambda x: x[1])

  contiguous_ranges = []

  start_name, start_val = sorted_data[0]

  prev_name, prev_val = start_name, start_val

  for name, val in sorted_data[1:]:

    if val != prev_val + 1:

      # Range break

      contiguous_ranges.append((start_name, prev_name))

      start_name = name

    prev_name, prev_val = name, val



  # Append the final range

  contiguous_ranges.append((start_name, prev_name))

  return contiguous_ranges





def generate_format_range_map():

  """Returns a map from Vulkan API versions and extensions to their contiguous ranges of format enums.



    For example, for 'VK_VERSION_1_3', the map contains:

    'VK_VERSION_1_3': [

        ('VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK', 'VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK'),

        ('VK_FORMAT_G8_B8R8_2PLANE_444_UNORM', 'VK_FORMAT_G16_B16R16_2PLANE_444_UNORM'),

        ('VK_FORMAT_A4R4G4B4_UNORM_PACK16', 'VK_FORMAT_A4B4G4R4_UNORM_PACK16')

    ]

    """

  for key, format_data in VK.VK_FORMAT_MAPPING.items():

    VK_FORMAT_RANGE_MAPPING[key] = find_contiguous_ranges(format_data)





def generate_vk_format_init_code(vk_version_api: str = None):

    """

    Generates C++ code to initialize Vulkan format enums based on either a Vulkan API version

    or an extension name.



    If `vk_version_api` is None, the function processes all extensions in `VK_FORMAT_RANGE_MAPPING`.

    Otherwise, it generates code for the specified Vulkan version.



    Example output for an extension:

        if (HasExtension("VK_EXT_texture_compression_astc_hdr", device.extensions)) {

          ...

        }

    """

    generated_code = []



    def generate_format_block(start_format: str, end_format: str):

        if start_format != end_format:

            return [

                f"  for (VkFormat format = {start_format};",

                f"       format <= {end_format};",

                f"       format = static_cast<VkFormat>(format + 1)) {{",

                f"    vkGetPhysicalDeviceFormatProperties(physical_device, format,",

                f"                                       &format_properties);",

                f"    device.formats.insert(std::make_pair(format, format_properties));",

                f"  }}"

            ]

        else:

            return [

                f"  VkFormat format = {start_format};",

                f"  vkGetPhysicalDeviceFormatProperties(physical_device, format,",

                f"                                       &format_properties);",

                f"  device.formats.insert(std::make_pair(format, format_properties));"

            ]



    if not vk_version_api:

        # Process all extensions

        for key, format_ranges in VK_FORMAT_RANGE_MAPPING.items():

            if key.startswith("VK_VERSION_"):

                continue

            for start_format, end_format in format_ranges:

                format_code = [f'if (HasExtension("{key}", device.extensions)) {{']

                format_code.extend(generate_format_block(start_format, end_format))

                format_code.append("}\n")

                generated_code.extend(format_code)

    else:

        # Process a specific Vulkan version

        if vk_version_api not in VK_FORMAT_RANGE_MAPPING:

            return ""

        for start_format, end_format in VK_FORMAT_RANGE_MAPPING[vk_version_api]:

            format_code = generate_format_block(start_format, end_format)

            format_code.append("")  # Add newline after each block

            generated_code.extend(format_code)



    return "\n".join(generated_code + [""])
 
 No newline at end of file

vulkan/scripts/vkjson_generator.py

+12 −119
Original line number Diff line number Diff line
@@ -908,67 +908,13 @@ VkJsonDevice VkJsonGetDevice(VkPhysicalDevice physical_device) { 
        physical_device, &queue_family_count, device.queues.data());

  }



  VkFormatProperties format_properties = {};

  for (VkFormat format = VK_FORMAT_R4G4_UNORM_PACK8;

       // TODO(http://b/171403054): avoid hard-coding last value in the

       // contiguous range

       format <= VK_FORMAT_ASTC_12x12_SRGB_BLOCK;

       format = static_cast<VkFormat>(format + 1)) {

    vkGetPhysicalDeviceFormatProperties(physical_device, format,

                                        &format_properties);

    if (format_properties.linearTilingFeatures ||

        format_properties.optimalTilingFeatures ||

        format_properties.bufferFeatures) {

      device.formats.insert(std::make_pair(format, format_properties));

    }

  }



  if (HasExtension("VK_IMG_format_pvrtc", device.extensions)) {

    for (VkFormat format = VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG;

         // TODO(http://b/171403054): avoid hard-coding last value in the

         // contiguous range

         format <= VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG;

         format = static_cast<VkFormat>(format + 1)) {

      vkGetPhysicalDeviceFormatProperties(physical_device, format,

                                          &format_properties);

      if (format_properties.linearTilingFeatures ||

          format_properties.optimalTilingFeatures ||

          format_properties.bufferFeatures) {

        device.formats.insert(std::make_pair(format, format_properties));

      }

    }

  }



  if (HasExtension("VK_NV_optical_flow", device.extensions)) {

    for (VkFormat format = VK_FORMAT_R16G16_SFIXED5_NV;

         // TODO(http://b/171403054): avoid hard-coding last value in the

         // contiguous range

         format <= VK_FORMAT_R16G16_SFIXED5_NV;

         format = static_cast<VkFormat>(format + 1)) {

      vkGetPhysicalDeviceFormatProperties(physical_device, format,

                                          &format_properties);

      if (format_properties.linearTilingFeatures ||

          format_properties.optimalTilingFeatures ||

          format_properties.bufferFeatures) {

        device.formats.insert(std::make_pair(format, format_properties));

      }

    }

  }



  if (device.properties.apiVersion >= VK_API_VERSION_1_1) {

    for (VkFormat format = VK_FORMAT_G8B8G8R8_422_UNORM;

         // TODO(http://b/171403054): avoid hard-coding last value in the

         // contiguous range

         format <= VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM;

         format = static_cast<VkFormat>(format + 1)) {

      vkGetPhysicalDeviceFormatProperties(physical_device, format,

                                          &format_properties);

      if (format_properties.linearTilingFeatures ||

          format_properties.optimalTilingFeatures ||

          format_properties.bufferFeatures) {

        device.formats.insert(std::make_pair(format, format_properties));

      }

    }\n\n""")

  VkFormatProperties format_properties = {};\n""")

    util.generate_format_range_map()

    f.write(util.generate_vk_format_init_code("VK_VERSION_1_0"))

    f.write(util.generate_vk_format_init_code())

    f.write("""\

    if (device.properties.apiVersion >= VK_API_VERSION_1_1) {\n""")

    f.write(util.generate_vk_format_init_code("VK_VERSION_1_1"))



    # Vulkan version data for VK_VERSION_1_1

    vk_version_data = VK.VULKAN_VERSIONS_AND_STRUCTS_MAPPING["VK_VERSION_1_1"]
@@ -1029,7 +975,7 @@ VkJsonDevice VkJsonGetDevice(VkPhysicalDevice physical_device) { 
  }



  if (device.properties.apiVersion >= VK_API_VERSION_1_2) {\n""")



    f.write(util.generate_vk_format_init_code("VK_VERSION_1_2"))

    cc_code_properties_11, cc_code_features_11 = util.generate_vk_core_structs_init_code("Core11")

    cc_code_properties_12, cc_code_features_12 = util.generate_vk_core_structs_init_code("Core12")

    # Vulkan version data for VK_VERSION_1_2
@@ -1049,48 +995,8 @@ VkJsonDevice VkJsonGetDevice(VkPhysicalDevice physical_device) { 
    f.write("""\

  }



  if (device.properties.apiVersion >= VK_API_VERSION_1_3) {

      for (VkFormat format = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM;

         // TODO(http://b/171403054): avoid hard-coding last value in the

         // contiguous range

         format <= VK_FORMAT_G16_B16R16_2PLANE_444_UNORM;

         format = static_cast<VkFormat>(format + 1)) {

      vkGetPhysicalDeviceFormatProperties(physical_device, format,

                                          &format_properties);

      if (format_properties.linearTilingFeatures ||

          format_properties.optimalTilingFeatures ||

          format_properties.bufferFeatures) {

        device.formats.insert(std::make_pair(format, format_properties));

      }

    }



    for (VkFormat format = VK_FORMAT_A4R4G4B4_UNORM_PACK16;

         // TODO(http://b/171403054): avoid hard-coding last value in the

         // contiguous range

         format <= VK_FORMAT_A4B4G4R4_UNORM_PACK16;

         format = static_cast<VkFormat>(format + 1)) {

      vkGetPhysicalDeviceFormatProperties(physical_device, format,

                                          &format_properties);

      if (format_properties.linearTilingFeatures ||

          format_properties.optimalTilingFeatures ||

          format_properties.bufferFeatures) {

        device.formats.insert(std::make_pair(format, format_properties));

      }

    }



    for (VkFormat format = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK;

         // TODO(http://b/171403054): avoid hard-coding last value in the

         // contiguous range

         format <= VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK;

         format = static_cast<VkFormat>(format + 1)) {

      vkGetPhysicalDeviceFormatProperties(physical_device, format,

                                          &format_properties);

      if (format_properties.linearTilingFeatures ||

          format_properties.optimalTilingFeatures ||

          format_properties.bufferFeatures) {

        device.formats.insert(std::make_pair(format, format_properties));

      }

    }\n""")

  if (device.properties.apiVersion >= VK_API_VERSION_1_3) {\n""")

    f.write(util.generate_vk_format_init_code("VK_VERSION_1_3"))

    cc_code_properties_13, cc_code_features_13 = util.generate_vk_core_structs_init_code("Core13")

    cc_code_properties_14, cc_code_features_14 = util.generate_vk_core_structs_init_code("Core14")
@@ -1107,21 +1013,8 @@ VkJsonDevice VkJsonGetDevice(VkPhysicalDevice physical_device) { 
    f.write("""\

  }



  if (device.properties.apiVersion >= VK_API_VERSION_1_4) {

    for (VkFormat format = VK_FORMAT_A1B5G5R5_UNORM_PACK16;

         // TODO(http://b/171403054): avoid hard-coding last value in the

         // contiguous range

         format <= VK_FORMAT_A8_UNORM;

         format = static_cast<VkFormat>(format + 1)) {

      vkGetPhysicalDeviceFormatProperties(physical_device, format,

                                          &format_properties);

      if (format_properties.linearTilingFeatures ||

          format_properties.optimalTilingFeatures ||

          format_properties.bufferFeatures) {

        device.formats.insert(std::make_pair(format, format_properties));

      }

    }

    \n""")

  if (device.properties.apiVersion >= VK_API_VERSION_1_4) {\n""")

    f.write(util.generate_vk_format_init_code("VK_VERSION_1_4"))



    # Vulkan version data for VK_VERSION_1_4

    vk_version_data = VK.VULKAN_VERSIONS_AND_STRUCTS_MAPPING["VK_VERSION_1_4"]

vulkan/vkjson/vkjson_instance.cc

+71 −64
Original line number Diff line number Diff line
@@ -2949,65 +2949,95 @@ VkJsonDevice VkJsonGetDevice(VkPhysicalDevice physical_device) { 


  VkFormatProperties format_properties = {};

  for (VkFormat format = VK_FORMAT_R4G4_UNORM_PACK8;

       // TODO(http://b/171403054): avoid hard-coding last value in the

       // contiguous range

       format <= VK_FORMAT_ASTC_12x12_SRGB_BLOCK;

       format = static_cast<VkFormat>(format + 1)) {

    vkGetPhysicalDeviceFormatProperties(physical_device, format,

                                        &format_properties);

    if (format_properties.linearTilingFeatures ||

        format_properties.optimalTilingFeatures ||

        format_properties.bufferFeatures) {

    device.formats.insert(std::make_pair(format, format_properties));

  }

  }



  if (HasExtension("VK_IMG_format_pvrtc", device.extensions)) {

    for (VkFormat format = VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG;

         // TODO(http://b/171403054): avoid hard-coding last value in the

         // contiguous range

         format <= VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG;

         format = static_cast<VkFormat>(format + 1)) {

      vkGetPhysicalDeviceFormatProperties(physical_device, format,

                                          &format_properties);

      if (format_properties.linearTilingFeatures ||

          format_properties.optimalTilingFeatures ||

          format_properties.bufferFeatures) {

      device.formats.insert(std::make_pair(format, format_properties));

    }

  }



  if (HasExtension("VK_EXT_texture_compression_astc_hdr", device.extensions)) {

    for (VkFormat format = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT;

         format <= VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT;

         format = static_cast<VkFormat>(format + 1)) {

      vkGetPhysicalDeviceFormatProperties(physical_device, format,

                                          &format_properties);

      device.formats.insert(std::make_pair(format, format_properties));

    }

  }



  if (HasExtension("VK_NV_optical_flow", device.extensions)) {

    for (VkFormat format = VK_FORMAT_R16G16_SFIXED5_NV;

         // TODO(http://b/171403054): avoid hard-coding last value in the

         // contiguous range

         format <= VK_FORMAT_R16G16_SFIXED5_NV;

  if (HasExtension("VK_KHR_sampler_ycbcr_conversion", device.extensions)) {

    for (VkFormat format = VK_FORMAT_G8B8G8R8_422_UNORM_KHR;

         format <= VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR;

         format = static_cast<VkFormat>(format + 1)) {

      vkGetPhysicalDeviceFormatProperties(physical_device, format,

                                          &format_properties);

      device.formats.insert(std::make_pair(format, format_properties));

    }

  }



  if (HasExtension("VK_EXT_ycbcr_2plane_444_formats", device.extensions)) {

    for (VkFormat format = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT;

         format <= VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT;

         format = static_cast<VkFormat>(format + 1)) {

      vkGetPhysicalDeviceFormatProperties(physical_device, format,

                                          &format_properties);

      device.formats.insert(std::make_pair(format, format_properties));

    }

  }



  if (HasExtension("VK_EXT_4444_formats", device.extensions)) {

    for (VkFormat format = VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT;

         format <= VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT;

         format = static_cast<VkFormat>(format + 1)) {

      vkGetPhysicalDeviceFormatProperties(physical_device, format,

                                          &format_properties);

      if (format_properties.linearTilingFeatures ||

          format_properties.optimalTilingFeatures ||

          format_properties.bufferFeatures) {

      device.formats.insert(std::make_pair(format, format_properties));

    }

  }



  if (HasExtension("VK_NV_optical_flow", device.extensions)) {

    VkFormat format = VK_FORMAT_R16G16_SFIXED5_NV;

    vkGetPhysicalDeviceFormatProperties(physical_device, format,

                                        &format_properties);

    device.formats.insert(std::make_pair(format, format_properties));

  }



  if (HasExtension("VK_NV_optical_flow", device.extensions)) {

    VkFormat format = VK_FORMAT_R16G16_S10_5_NV;

    vkGetPhysicalDeviceFormatProperties(physical_device, format,

                                        &format_properties);

    device.formats.insert(std::make_pair(format, format_properties));

  }



  if (HasExtension("VK_KHR_maintenance5", device.extensions)) {

    for (VkFormat format = VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR;

         format <= VK_FORMAT_A8_UNORM_KHR;

         format = static_cast<VkFormat>(format + 1)) {

      vkGetPhysicalDeviceFormatProperties(physical_device, format,

                                          &format_properties);

      device.formats.insert(std::make_pair(format, format_properties));

    }

  }



  if (device.properties.apiVersion >= VK_API_VERSION_1_1) {

    for (VkFormat format = VK_FORMAT_G8B8G8R8_422_UNORM;

         // TODO(http://b/171403054): avoid hard-coding last value in the

         // contiguous range

         format <= VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM;

         format = static_cast<VkFormat>(format + 1)) {

      vkGetPhysicalDeviceFormatProperties(physical_device, format,

                                          &format_properties);

      if (format_properties.linearTilingFeatures ||

          format_properties.optimalTilingFeatures ||

          format_properties.bufferFeatures) {

      device.formats.insert(std::make_pair(format, format_properties));

    }

    }



    device.subgroup_properties.sType =

        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
@@ -3248,47 +3278,30 @@ VkJsonDevice VkJsonGetDevice(VkPhysicalDevice physical_device) { 
  }



  if (device.properties.apiVersion >= VK_API_VERSION_1_3) {

    for (VkFormat format = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM;

         // TODO(http://b/171403054): avoid hard-coding last value in the

         // contiguous range

         format <= VK_FORMAT_G16_B16R16_2PLANE_444_UNORM;

    for (VkFormat format = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK;

         format <= VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK;

         format = static_cast<VkFormat>(format + 1)) {

      vkGetPhysicalDeviceFormatProperties(physical_device, format,

                                          &format_properties);

      if (format_properties.linearTilingFeatures ||

          format_properties.optimalTilingFeatures ||

          format_properties.bufferFeatures) {

      device.formats.insert(std::make_pair(format, format_properties));

    }

    }



    for (VkFormat format = VK_FORMAT_A4R4G4B4_UNORM_PACK16;

         // TODO(http://b/171403054): avoid hard-coding last value in the

         // contiguous range

         format <= VK_FORMAT_A4B4G4R4_UNORM_PACK16;

    for (VkFormat format = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM;

         format <= VK_FORMAT_G16_B16R16_2PLANE_444_UNORM;

         format = static_cast<VkFormat>(format + 1)) {

      vkGetPhysicalDeviceFormatProperties(physical_device, format,

                                          &format_properties);

      if (format_properties.linearTilingFeatures ||

          format_properties.optimalTilingFeatures ||

          format_properties.bufferFeatures) {

      device.formats.insert(std::make_pair(format, format_properties));

    }

    }



    for (VkFormat format = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK;

         // TODO(http://b/171403054): avoid hard-coding last value in the

         // contiguous range

         format <= VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK;

    for (VkFormat format = VK_FORMAT_A4R4G4B4_UNORM_PACK16;

         format <= VK_FORMAT_A4B4G4R4_UNORM_PACK16;

         format = static_cast<VkFormat>(format + 1)) {

      vkGetPhysicalDeviceFormatProperties(physical_device, format,

                                          &format_properties);

      if (format_properties.linearTilingFeatures ||

          format_properties.optimalTilingFeatures ||

          format_properties.bufferFeatures) {

      device.formats.insert(std::make_pair(format, format_properties));

    }

    }



    device.subgroup_size_control_properties.sType =

        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;

    device.subgroup_size_control_properties.pNext = properties.pNext;
@@ -3396,18 +3409,12 @@ VkJsonDevice VkJsonGetDevice(VkPhysicalDevice physical_device) { 


  if (device.properties.apiVersion >= VK_API_VERSION_1_4) {

    for (VkFormat format = VK_FORMAT_A1B5G5R5_UNORM_PACK16;

         // TODO(http://b/171403054): avoid hard-coding last value in the

         // contiguous range

         format <= VK_FORMAT_A8_UNORM;

         format = static_cast<VkFormat>(format + 1)) {

      vkGetPhysicalDeviceFormatProperties(physical_device, format,

                                          &format_properties);

      if (format_properties.linearTilingFeatures ||

          format_properties.optimalTilingFeatures ||

          format_properties.bufferFeatures) {

      device.formats.insert(std::make_pair(format, format_properties));

    }

    }



    device.line_rasterization_properties.sType =

        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES;