vulkan: Automatically generate helpers to retrieve format information

In Vulkan, formats are classified in compatible groups, allowing
formats to be cast to other formats in the same group. Some drivers
might need to have access to the full compatible format list, so let's
auto-generate helpers to allow that.

Acked-by: Jesse Natalie <jenatali@microsoft.com>
Reviewed-by: Jason Ekstrand <jason.ekstrand@collabora.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/17339>

src/vulkan/runtime/meson.build

@@ -165,11 +165,22 @@ vk_physical_device_features = custom_target(
   depend_files : vk_physical_device_features_gen_depend_files,
 )
 
+vk_format_info = custom_target(
+  'vk_format_info',
+  input : ['vk_format_info_gen.py', vk_api_xml],
+  output : ['vk_format_info.c', 'vk_format_info.h'],
+  command : [
+    prog_python, '@INPUT0@', '--xml', '@INPUT1@',
+    '--out-c', '@OUTPUT0@', '--out-h', '@OUTPUT1@'
+  ],
+)
+
 libvulkan_runtime = static_library(
   'vulkan_runtime',
   [vulkan_runtime_files, vk_common_entrypoints,
    vk_cmd_queue, vk_cmd_enqueue_entrypoints,
-   vk_dispatch_trampolines, vk_physical_device_features],
+   vk_dispatch_trampolines, vk_physical_device_features,
+   vk_format_info],
   include_directories : [inc_include, inc_src, inc_gallium],
   dependencies : vulkan_runtime_deps,
   # For glsl_type_singleton

src/vulkan/runtime/vk_format_info_gen.py

@@ -0,0 +1,245 @@
+COPYRIGHT=u"""
+/* Copyright © 2022 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+"""
+
+import argparse
+import os
+import re
+from collections import namedtuple
+import xml.etree.ElementTree as et
+
+from mako.template import Template
+
+TEMPLATE_H = Template(COPYRIGHT + """\
+/* This file generated from ${filename}, don't edit directly. */
+
+#ifndef VK_FORMAT_INFO_H
+#define VK_FORMAT_INFO_H
+
+#include <vulkan/vulkan.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum vk_format_class {
+   MESA_VK_FORMAT_CLASS_UNKNOWN,
+% for name in format_classes:
+   ${to_enum_name('MESA_VK_FORMAT_CLASS_', name)},
+% endfor
+};
+
+struct vk_format_class_info {
+   const VkFormat *formats;
+   uint32_t format_count;
+};
+
+const struct vk_format_class_info *
+vk_format_class_get_info(enum vk_format_class class);
+
+const struct vk_format_class_info *
+vk_format_get_class_info(VkFormat format);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+""", output_encoding='utf-8')
+
+TEMPLATE_C = Template(COPYRIGHT + """
+/* This file generated from ${filename}, don't edit directly. */
+
+#include "${header}"
+
+#include "util/macros.h"
+
+#include "vk_format.h"
+
+struct vk_format_info {
+   enum vk_format_class class;
+};
+
+% for id, ext in extensions.items():
+static const struct vk_format_info ext${id}_format_infos[] = {
+%   for name, format in ext.formats.items():
+   [${format.offset}] = {
+      .class = ${to_enum_name('MESA_VK_FORMAT_CLASS_', format.cls)},
+   },
+%   endfor
+};
+
+% endfor
+static const struct vk_format_info *
+vk_format_get_info(VkFormat format)
+{
+   uint32_t extnumber =
+      format < 1000000000 ? 0 : (((format % 1000000000) / 1000) + 1);
+   uint32_t offset = format % 1000;
+
+   switch (extnumber) {
+% for id, ext in extensions.items():
+   case ${id}:
+      assert(offset < ARRAY_SIZE(ext${id}_format_infos));
+      return &ext${id}_format_infos[offset];
+% endfor
+   default:
+      unreachable("Invalid extension");
+   }
+}
+
+% for clsname, cls in format_classes.items():
+%   if len(cls.formats) > 0:
+static const VkFormat ${to_enum_name('MESA_VK_FORMAT_CLASS_', clsname).lower() + '_formats'}[] = {
+%     for fname in cls.formats:
+   ${fname},
+%     endfor
+%   endif
+};
+
+% endfor
+static const struct vk_format_class_info class_infos[] = {
+% for clsname, cls in format_classes.items():
+   [${to_enum_name('MESA_VK_FORMAT_CLASS_', clsname)}] = {
+%   if len(cls.formats) > 0:
+      .formats = ${to_enum_name('MESA_VK_FORMAT_CLASS_', clsname).lower() + '_formats'},
+      .format_count = ARRAY_SIZE(${to_enum_name('MESA_VK_FORMAT_CLASS_', clsname).lower() + '_formats'}),
+%   else:
+      0
+%   endif
+   },
+% endfor
+};
+
+const struct vk_format_class_info *
+vk_format_class_get_info(enum vk_format_class class)
+{
+   assert(class < ARRAY_SIZE(class_infos));
+   return &class_infos[class];
+}
+
+const struct vk_format_class_info *
+vk_format_get_class_info(VkFormat format)
+{
+    const struct vk_format_info *format_info = vk_format_get_info(format);
+    return &class_infos[format_info->class];
+}
+""", output_encoding='utf-8')
+
+def to_enum_name(prefix, name):
+    return "%s" % prefix + re.sub('([^A-Za-z0-9_])', '_', name).upper()
+
+Format = namedtuple('Format', ['name', 'cls', 'ext', 'offset'])
+FormatClass = namedtuple('FormatClass', ['name', 'formats'])
+Extension = namedtuple('Extension', ['id', 'formats'])
+
+def get_formats(doc):
+    """Extract the formats from the registry."""
+    formats = {}
+
+    for fmt in doc.findall('./formats/format'):
+        xpath = './/enum[@name="{}"]'.format(fmt.attrib['name'])
+        enum = doc.find(xpath)
+        ext = None
+        if 'extends' in enum.attrib:
+            assert(enum.attrib['extends'] == 'VkFormat')
+            if 'extnumber' in enum.attrib:
+                ext = int(enum.attrib['extnumber'])
+            else:
+                xpath = xpath + '/..'
+                parent = doc.find(xpath)
+                while parent != None and ext == None:
+                    if parent.tag == 'extension':
+                        assert('number' in parent.attrib)
+                        ext = parent.attrib['number']
+                    xpath = xpath + '/..'
+                    parent = doc.find(xpath)
+            offset = int(enum.attrib['offset'])
+        else:
+            ext = 0
+            offset = int(enum.attrib['value'])
+
+        assert(ext != None)
+        format = Format(fmt.attrib['name'], fmt.attrib['class'], ext, offset)
+        formats[format.name] = format
+
+    return formats
+
+def get_formats_from_xml(xml_files):
+    formats = {}
+
+    for filename in xml_files:
+        doc = et.parse(filename)
+        formats.update(get_formats(doc))
+
+    return formats
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-c', required=True, help='Output C file.')
+    parser.add_argument('--out-h', required=True, help='Output H file.')
+    parser.add_argument('--xml',
+                        help='Vulkan API XML file.',
+                        required=True, action='append', dest='xml_files')
+    args = parser.parse_args()
+
+    formats = get_formats_from_xml(args.xml_files)
+    classes = {}
+    extensions = {}
+    for n, f in formats.items():
+        if f.cls not in classes:
+            classes[f.cls] = FormatClass(f.cls, {})
+        classes[f.cls].formats[f.name] = f
+        if f.ext not in extensions:
+            extensions[f.ext] = Extension(f.cls, {})
+        extensions[f.ext].formats[f.name] = f
+
+    assert os.path.dirname(args.out_c) == os.path.dirname(args.out_h)
+
+    environment = {
+        'header': os.path.basename(args.out_h),
+        'formats': formats,
+        'format_classes': classes,
+        'extensions': extensions,
+        'filename': os.path.basename(__file__),
+        'to_enum_name': to_enum_name,
+    }
+
+    try:
+        with open(args.out_h, 'wb') as f:
+            guard = os.path.basename(args.out_h).replace('.', '_').upper()
+            f.write(TEMPLATE_H.render(guard=guard, **environment))
+        with open(args.out_c, 'wb') as f:
+            f.write(TEMPLATE_C.render(**environment))
+    except Exception:
+        # In the event there's an error, this imports some helpers from mako
+        # to print a useful stack trace and prints it, then exits with
+        # status 1, if python is run with debug; otherwise it just raises
+        # the exception
+        import sys
+        from mako import exceptions
+        print(exceptions.text_error_template().render(), file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == '__main__':
+    main()