Home | History | Annotate | Download | only in vulkan 
      1 COPYRIGHT = """\
      2 /*
      3  * Copyright 2017 Intel Corporation
      4  *
      5  * Permission is hereby granted, free of charge, to any person obtaining a
      6  * copy of this software and associated documentation files (the
      7  * "Software"), to deal in the Software without restriction, including
      8  * without limitation the rights to use, copy, modify, merge, publish,
      9  * distribute, sub license, and/or sell copies of the Software, and to
     10  * permit persons to whom the Software is furnished to do so, subject to
     11  * the following conditions:
     12  *
     13  * The above copyright notice and this permission notice (including the
     14  * next paragraph) shall be included in all copies or substantial portions
     15  * of the Software.
     16  *
     17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
     18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
     19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
     20  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
     21  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
     22  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
     23  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
     24  */
     25 """
     26 
     27 import argparse
     28 import xml.etree.cElementTree as et
     29 
     30 from mako.template import Template
     31 
     32 from anv_extensions import *
     33 
     34 def _init_exts_from_xml(xml):
     35     """ Walk the Vulkan XML and fill out extra extension information. """
     36 
     37     xml = et.parse(xml)
     38 
     39     ext_name_map = {}
     40     for ext in EXTENSIONS:
     41         ext_name_map[ext.name] = ext
     42 
     43     for ext_elem in xml.findall('.extensions/extension'):
     44         ext_name = ext_elem.attrib['name']
     45         if ext_name not in ext_name_map:
     46             continue
     47 
     48         # Workaround for VK_ANDROID_native_buffer. Its <extension> element in
     49         # vk.xml lists it as supported="disabled" and provides only a stub
     50         # definition.  Its <extension> element in Mesa's custom
     51         # vk_android_native_buffer.xml, though, lists it as
     52         # supported='android-vendor' and fully defines the extension. We want
     53         # to skip the <extension> element in vk.xml.
     54         if ext_elem.attrib['supported'] == 'disabled':
     55             assert ext_name == 'VK_ANDROID_native_buffer'
     56             continue
     57 
     58         ext = ext_name_map[ext_name]
     59         ext.type = ext_elem.attrib['type']
     60 
     61 _TEMPLATE_H = Template(COPYRIGHT + """
     62 
     63 #ifndef ANV_EXTENSIONS_H
     64 #define ANV_EXTENSIONS_H
     65 
     66 #include "stdbool.h"
     67 
     68 #define ANV_INSTANCE_EXTENSION_COUNT ${len(instance_extensions)}
     69 
     70 extern const VkExtensionProperties anv_instance_extensions[];
     71 
     72 struct anv_instance_extension_table {
     73    union {
     74       bool extensions[ANV_INSTANCE_EXTENSION_COUNT];
     75       struct {
     76 %for ext in instance_extensions:
     77          bool ${ext.name[3:]};
     78 %endfor
     79       };
     80    };
     81 };
     82 
     83 extern const struct anv_instance_extension_table anv_instance_extensions_supported;
     84 
     85 
     86 #define ANV_DEVICE_EXTENSION_COUNT ${len(device_extensions)}
     87 
     88 extern const VkExtensionProperties anv_device_extensions[];
     89 
     90 struct anv_device_extension_table {
     91    union {
     92       bool extensions[ANV_DEVICE_EXTENSION_COUNT];
     93       struct {
     94 %for ext in device_extensions:
     95         bool ${ext.name[3:]};
     96 %endfor
     97       };
     98    };
     99 };
    100 
    101 struct anv_physical_device;
    102 
    103 void
    104 anv_physical_device_get_supported_extensions(const struct anv_physical_device *device,
    105                                              struct anv_device_extension_table *extensions);
    106 
    107 #endif /* ANV_EXTENSIONS_H */
    108 """)
    109 
    110 _TEMPLATE_C = Template(COPYRIGHT + """
    111 #include "anv_private.h"
    112 
    113 #include "vk_util.h"
    114 
    115 /* Convert the VK_USE_PLATFORM_* defines to booleans */
    116 %for platform in ['ANDROID', 'WAYLAND', 'XCB', 'XLIB']:
    117 #ifdef VK_USE_PLATFORM_${platform}_KHR
    118 #   undef VK_USE_PLATFORM_${platform}_KHR
    119 #   define VK_USE_PLATFORM_${platform}_KHR true
    120 #else
    121 #   define VK_USE_PLATFORM_${platform}_KHR false
    122 #endif
    123 %endfor
    124 
    125 /* And ANDROID too */
    126 #ifdef ANDROID
    127 #   undef ANDROID
    128 #   define ANDROID true
    129 #else
    130 #   define ANDROID false
    131 #endif
    132 
    133 #define ANV_HAS_SURFACE (VK_USE_PLATFORM_WAYLAND_KHR || \\
    134                          VK_USE_PLATFORM_XCB_KHR || \\
    135                          VK_USE_PLATFORM_XLIB_KHR)
    136 
    137 const VkExtensionProperties anv_instance_extensions[ANV_INSTANCE_EXTENSION_COUNT] = {
    138 %for ext in instance_extensions:
    139    {"${ext.name}", ${ext.ext_version}},
    140 %endfor
    141 };
    142 
    143 const struct anv_instance_extension_table anv_instance_extensions_supported = {
    144 %for ext in instance_extensions:
    145    .${ext.name[3:]} = ${ext.enable},
    146 %endfor
    147 };
    148 
    149 uint32_t
    150 anv_physical_device_api_version(struct anv_physical_device *dev)
    151 {
    152     return ${MAX_API_VERSION.c_vk_version()};
    153 }
    154 
    155 const VkExtensionProperties anv_device_extensions[ANV_DEVICE_EXTENSION_COUNT] = {
    156 %for ext in device_extensions:
    157    {"${ext.name}", ${ext.ext_version}},
    158 %endfor
    159 };
    160 
    161 void
    162 anv_physical_device_get_supported_extensions(const struct anv_physical_device *device,
    163                                              struct anv_device_extension_table *extensions)
    164 {
    165    *extensions = (struct anv_device_extension_table) {
    166 %for ext in device_extensions:
    167       .${ext.name[3:]} = ${ext.enable},
    168 %endfor
    169    };
    170 }
    171 """)
    172 
    173 if __name__ == '__main__':
    174     parser = argparse.ArgumentParser()
    175     parser.add_argument('--out-c', help='Output C file.')
    176     parser.add_argument('--out-h', help='Output H file.')
    177     parser.add_argument('--xml',
    178                         help='Vulkan API XML file.',
    179                         required=True,
    180                         action='append',
    181                         dest='xml_files')
    182     args = parser.parse_args()
    183 
    184     for filename in args.xml_files:
    185         _init_exts_from_xml(filename)
    186 
    187     for ext in EXTENSIONS:
    188         assert ext.type == 'instance' or ext.type == 'device'
    189 
    190     template_env = {
    191         'MAX_API_VERSION': MAX_API_VERSION,
    192         'instance_extensions': [e for e in EXTENSIONS if e.type == 'instance'],
    193         'device_extensions': [e for e in EXTENSIONS if e.type == 'device'],
    194     }
    195 
    196     if args.out_h:
    197         with open(args.out_h, 'w') as f:
    198             f.write(_TEMPLATE_H.render(**template_env))
    199 
    200     if args.out_c:
    201         with open(args.out_c, 'w') as f:
    202             f.write(_TEMPLATE_C.render(**template_env))
    203