← Back to branch summary

~mmach/netext73/mesa-haswell

« back to all changes in this revision

Viewing changes to src/gallium/frontends/lavapipe/lvp_formats.c

  • Committer: mmach
  • Date: 2022-09-22 19:56:13 UTC
  • Revision ID: netbit73@gmail.com-20220922195613-wtik9mmy20tmor0i
2022-09-22 21:17:09

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/frontends/lavapipe/lvp_formats.c
1
 
/*
2
 
 * Copyright © 2019 Red Hat.
3
 
 *
4
 
 * Permission is hereby granted, free of charge, to any person obtaining a
5
 
 * copy of this software and associated documentation files (the "Software"),
6
 
 * to deal in the Software without restriction, including without limitation
7
 
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8
 
 * and/or sell copies of the Software, and to permit persons to whom the
9
 
 * Software is furnished to do so, subject to the following conditions:
10
 
 *
11
 
 * The above copyright notice and this permission notice (including the next
12
 
 * paragraph) shall be included in all copies or substantial portions of the
13
 
 * Software.
14
 
 *
15
 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
 
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
 
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18
 
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
 
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20
 
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21
 
 * IN THE SOFTWARE.
22
 
 */
23
 
 
24
 
#include "lvp_private.h"
25
 
#include "pipe/p_config.h"
26
 
#include "pipe/p_defines.h"
27
 
#include "util/format/u_format.h"
28
 
#include "util/u_math.h"
29
 
#include "vk_util.h"
30
 
#include "vk_enum_defines.h"
31
 
 
32
 
static bool lvp_is_filter_minmax_format_supported(VkFormat format)
33
 
{
34
 
   /* From the Vulkan spec 1.1.71:
35
 
    *
36
 
    * "The following formats must support the
37
 
    *  VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT feature with
38
 
    *  VK_IMAGE_TILING_OPTIMAL, if they support
39
 
    *  VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT."
40
 
    */
41
 
   /* TODO: enable more formats. */
42
 
   switch (format) {
43
 
   case VK_FORMAT_R8_UNORM:
44
 
   case VK_FORMAT_R8_SNORM:
45
 
   case VK_FORMAT_R16_UNORM:
46
 
   case VK_FORMAT_R16_SNORM:
47
 
   case VK_FORMAT_R16_SFLOAT:
48
 
   case VK_FORMAT_R32_SFLOAT:
49
 
   case VK_FORMAT_D16_UNORM:
50
 
   case VK_FORMAT_X8_D24_UNORM_PACK32:
51
 
   case VK_FORMAT_D32_SFLOAT:
52
 
   case VK_FORMAT_D16_UNORM_S8_UINT:
53
 
   case VK_FORMAT_D24_UNORM_S8_UINT:
54
 
   case VK_FORMAT_D32_SFLOAT_S8_UINT:
55
 
      return true;
56
 
   default:
57
 
      return false;
58
 
   }
59
 
}
60
 
 
61
 
static void
62
 
lvp_physical_device_get_format_properties(struct lvp_physical_device *physical_device,
63
 
                                          VkFormat format,
64
 
                                          VkFormatProperties3 *out_properties)
65
 
{
66
 
   enum pipe_format pformat = lvp_vk_format_to_pipe_format(format);
67
 
   VkFormatFeatureFlags2 features = 0, buffer_features = 0;
68
 
   if (pformat == PIPE_FORMAT_NONE) {
69
 
     out_properties->linearTilingFeatures = 0;
70
 
     out_properties->optimalTilingFeatures = 0;
71
 
     out_properties->bufferFeatures = 0;
72
 
     return;
73
 
   }
74
 
 
75
 
   if (physical_device->pscreen->is_format_supported(physical_device->pscreen, pformat,
76
 
                                                     PIPE_TEXTURE_2D, 0, 0, PIPE_BIND_DEPTH_STENCIL)) {
77
 
      out_properties->linearTilingFeatures = 0;
78
 
      out_properties->optimalTilingFeatures = VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT |
79
 
         VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT |
80
 
         VK_FORMAT_FEATURE_2_BLIT_SRC_BIT | VK_FORMAT_FEATURE_2_BLIT_DST_BIT |
81
 
         VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT;
82
 
 
83
 
      if (lvp_is_filter_minmax_format_supported(format))
84
 
         out_properties->optimalTilingFeatures |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT;
85
 
      out_properties->bufferFeatures = 0;
86
 
      return;
87
 
   }
88
 
 
89
 
   if (util_format_is_compressed(pformat)) {
90
 
      if (physical_device->pscreen->is_format_supported(physical_device->pscreen, pformat,
91
 
                                                        PIPE_TEXTURE_2D, 0, 0, PIPE_BIND_SAMPLER_VIEW)) {
92
 
         features |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT;
93
 
         features |= VK_FORMAT_FEATURE_2_BLIT_SRC_BIT;
94
 
         features |= VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT;
95
 
         features |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
96
 
      }
97
 
      out_properties->linearTilingFeatures = features;
98
 
      out_properties->optimalTilingFeatures = features;
99
 
      out_properties->bufferFeatures = buffer_features;
100
 
      return;
101
 
   }
102
 
 
103
 
   if (!util_format_is_srgb(pformat) &&
104
 
       physical_device->pscreen->is_format_supported(physical_device->pscreen, pformat,
105
 
                                                     PIPE_BUFFER, 0, 0, PIPE_BIND_VERTEX_BUFFER)) {
106
 
      buffer_features |= VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT;
107
 
   }
108
 
 
109
 
   if (physical_device->pscreen->is_format_supported(physical_device->pscreen, pformat,
110
 
                                                     PIPE_BUFFER, 0, 0, PIPE_BIND_CONSTANT_BUFFER)) {
111
 
      buffer_features |= VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT;
112
 
   }
113
 
 
114
 
   if (physical_device->pscreen->is_format_supported(physical_device->pscreen, pformat,
115
 
                                                     PIPE_BUFFER, 0, 0, PIPE_BIND_SHADER_IMAGE)) {
116
 
      buffer_features |= VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT;
117
 
      if (physical_device->pscreen->get_param(physical_device->pscreen, PIPE_CAP_IMAGE_LOAD_FORMATTED))
118
 
         buffer_features |= VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR;
119
 
      if (physical_device->pscreen->get_param(physical_device->pscreen, PIPE_CAP_IMAGE_STORE_FORMATTED))
120
 
         buffer_features |= VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT;
121
 
   }
122
 
 
123
 
   if (physical_device->pscreen->is_format_supported(physical_device->pscreen, pformat,
124
 
                                                     PIPE_TEXTURE_2D, 0, 0, PIPE_BIND_SAMPLER_VIEW)) {
125
 
      features |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT;
126
 
      if (util_format_has_depth(util_format_description(pformat)))
127
 
         features |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT;
128
 
      if (!util_format_is_pure_integer(pformat))
129
 
         features |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
130
 
      if (lvp_is_filter_minmax_format_supported(format))
131
 
         features |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT;
132
 
   }
133
 
 
134
 
   if (physical_device->pscreen->is_format_supported(physical_device->pscreen, pformat,
135
 
                                                     PIPE_TEXTURE_2D, 0, 0, PIPE_BIND_RENDER_TARGET)) {
136
 
      features |= VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT;
137
 
      /* SNORM blending on llvmpipe fails CTS - disable for now */
138
 
      if (!util_format_is_snorm(pformat))
139
 
         features |= VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT;
140
 
   }
141
 
 
142
 
   if (physical_device->pscreen->is_format_supported(physical_device->pscreen, pformat,
143
 
                                                     PIPE_TEXTURE_2D, 0, 0, PIPE_BIND_SHADER_IMAGE)) {
144
 
      features |= VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT;
145
 
      if (physical_device->pscreen->get_param(physical_device->pscreen, PIPE_CAP_IMAGE_LOAD_FORMATTED))
146
 
         features |= VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR;
147
 
      if (physical_device->pscreen->get_param(physical_device->pscreen, PIPE_CAP_IMAGE_STORE_FORMATTED))
148
 
         features |= VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT;
149
 
   }
150
 
 
151
 
   if (pformat == PIPE_FORMAT_R32_UINT || pformat == PIPE_FORMAT_R32_SINT) {
152
 
      features |= VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT;
153
 
      buffer_features |= VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT;
154
 
   }
155
 
 
156
 
   if (pformat == PIPE_FORMAT_R11G11B10_FLOAT || pformat == PIPE_FORMAT_R9G9B9E5_FLOAT)
157
 
     features |= VK_FORMAT_FEATURE_2_BLIT_SRC_BIT;
158
 
 
159
 
   if (features && buffer_features != VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT)
160
 
      features |= VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT;
161
 
   if (pformat == PIPE_FORMAT_B5G6R5_UNORM)
162
 
     features |= VK_FORMAT_FEATURE_2_BLIT_SRC_BIT | VK_FORMAT_FEATURE_2_BLIT_DST_BIT;
163
 
   if ((pformat != PIPE_FORMAT_R9G9B9E5_FLOAT) && util_format_get_nr_components(pformat) != 3 &&
164
 
       pformat != PIPE_FORMAT_R10G10B10A2_SNORM && pformat != PIPE_FORMAT_B10G10R10A2_SNORM &&
165
 
       pformat != PIPE_FORMAT_B10G10R10A2_UNORM) {
166
 
      features |= VK_FORMAT_FEATURE_2_BLIT_SRC_BIT | VK_FORMAT_FEATURE_2_BLIT_DST_BIT;
167
 
   }
168
 
 
169
 
   out_properties->linearTilingFeatures = features;
170
 
   out_properties->optimalTilingFeatures = features;
171
 
   out_properties->bufferFeatures = buffer_features;
172
 
   return;
173
 
}
174
 
 
175
 
VKAPI_ATTR void VKAPI_CALL lvp_GetPhysicalDeviceFormatProperties2(
176
 
        VkPhysicalDevice                            physicalDevice,
177
 
        VkFormat                                    format,
178
 
        VkFormatProperties2*                        pFormatProperties)
179
 
{
180
 
   LVP_FROM_HANDLE(lvp_physical_device, physical_device, physicalDevice);
181
 
 
182
 
   VkFormatProperties3 format_props;
183
 
   lvp_physical_device_get_format_properties(physical_device,
184
 
                                             format,
185
 
                                             &format_props);
186
 
   pFormatProperties->formatProperties.linearTilingFeatures = format_props.linearTilingFeatures & VK_ALL_FORMAT_FEATURE_FLAG_BITS;
187
 
   pFormatProperties->formatProperties.optimalTilingFeatures = format_props.optimalTilingFeatures & VK_ALL_FORMAT_FEATURE_FLAG_BITS;
188
 
   pFormatProperties->formatProperties.bufferFeatures = format_props.bufferFeatures & VK_ALL_FORMAT_FEATURE_FLAG_BITS;
189
 
   VkFormatProperties3 *prop3 = (void*)vk_find_struct_const(pFormatProperties->pNext, FORMAT_PROPERTIES_3);
190
 
   if (prop3)
191
 
      *prop3 = format_props;
192
 
}
193
 
static VkResult lvp_get_image_format_properties(struct lvp_physical_device *physical_device,
194
 
                                                 const VkPhysicalDeviceImageFormatInfo2 *info,
195
 
                                                 VkImageFormatProperties *pImageFormatProperties)
196
 
{
197
 
   VkFormatProperties3 format_props;
198
 
   VkFormatFeatureFlags2 format_feature_flags;
199
 
   VkExtent3D maxExtent;
200
 
   uint32_t maxMipLevels;
201
 
   uint32_t maxArraySize;
202
 
   VkSampleCountFlags sampleCounts = VK_SAMPLE_COUNT_1_BIT;
203
 
   enum pipe_format pformat = lvp_vk_format_to_pipe_format(info->format);
204
 
   lvp_physical_device_get_format_properties(physical_device, info->format,
205
 
                                             &format_props);
206
 
   if (info->tiling == VK_IMAGE_TILING_LINEAR) {
207
 
      format_feature_flags = format_props.linearTilingFeatures;
208
 
   } else if (info->tiling == VK_IMAGE_TILING_OPTIMAL) {
209
 
      format_feature_flags = format_props.optimalTilingFeatures;
210
 
   } else {
211
 
      unreachable("bad VkImageTiling");
212
 
   }
213
 
 
214
 
   if (format_feature_flags == 0)
215
 
      goto unsupported;
216
 
 
217
 
   uint32_t max_2d_ext = physical_device->pscreen->get_param(physical_device->pscreen, PIPE_CAP_MAX_TEXTURE_2D_SIZE);
218
 
   uint32_t max_layers = physical_device->pscreen->get_param(physical_device->pscreen, PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS);
219
 
   switch (info->type) {
220
 
   default:
221
 
      unreachable("bad vkimage type\n");
222
 
   case VK_IMAGE_TYPE_1D:
223
 
      if (util_format_is_compressed(pformat))
224
 
         goto unsupported;
225
 
 
226
 
      maxExtent.width = max_2d_ext;
227
 
      maxExtent.height = 1;
228
 
      maxExtent.depth = 1;
229
 
      maxMipLevels = util_logbase2(max_2d_ext) + 1;
230
 
      maxArraySize = max_layers;
231
 
      break;
232
 
   case VK_IMAGE_TYPE_2D:
233
 
      maxExtent.width = max_2d_ext;
234
 
      maxExtent.height = max_2d_ext;
235
 
      maxExtent.depth = 1;
236
 
      maxMipLevels = util_logbase2(max_2d_ext) + 1;
237
 
      maxArraySize = max_layers;
238
 
      if (info->tiling == VK_IMAGE_TILING_OPTIMAL &&
239
 
          !(info->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) &&
240
 
          !util_format_is_compressed(pformat) &&
241
 
          (format_feature_flags & (VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT)))
242
 
         sampleCounts |= VK_SAMPLE_COUNT_4_BIT;
243
 
      break;
244
 
   case VK_IMAGE_TYPE_3D:
245
 
      maxExtent.width = max_2d_ext;
246
 
      maxExtent.height = max_2d_ext;
247
 
      maxExtent.depth = (1 << physical_device->pscreen->get_param(physical_device->pscreen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS));
248
 
      maxMipLevels = util_logbase2(max_2d_ext) + 1;
249
 
      maxArraySize = 1;
250
 
      break;
251
 
   }
252
 
 
253
 
   if (info->flags & VK_IMAGE_CREATE_EXTENDED_USAGE_BIT)
254
 
      goto skip_checks;
255
 
 
256
 
   if (info->usage & VK_IMAGE_USAGE_SAMPLED_BIT) {
257
 
      if (!(format_feature_flags & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT)) {
258
 
         goto unsupported;
259
 
      }
260
 
   }
261
 
 
262
 
   if (info->usage & VK_IMAGE_USAGE_STORAGE_BIT) {
263
 
      if (!(format_feature_flags & VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT)) {
264
 
         goto unsupported;
265
 
      }
266
 
   }
267
 
 
268
 
   if (info->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) {
269
 
      if (!(format_feature_flags & VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT)) {
270
 
         goto unsupported;
271
 
      }
272
 
   }
273
 
 
274
 
   if (info->usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {
275
 
      if (!(format_feature_flags & VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT)) {
276
 
         goto unsupported;
277
 
      }
278
 
   }
279
 
 
280
 
   if (info->usage & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) {
281
 
      if (!(format_feature_flags & VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT)) {
282
 
         goto unsupported;
283
 
      }
284
 
   }
285
 
 
286
 
   if (info->usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT) {
287
 
      if (!(format_feature_flags & VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT)) {
288
 
         goto unsupported;
289
 
      }
290
 
   }
291
 
 
292
 
   if (info->usage & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT) {
293
 
      if (!(format_feature_flags & (VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT |
294
 
                                    VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT))) {
295
 
         goto unsupported;
296
 
      }
297
 
   }
298
 
 
299
 
skip_checks:
300
 
   *pImageFormatProperties = (VkImageFormatProperties) {
301
 
      .maxExtent = maxExtent,
302
 
      .maxMipLevels = maxMipLevels,
303
 
      .maxArrayLayers = maxArraySize,
304
 
      .sampleCounts = sampleCounts,
305
 
 
306
 
      /* FINISHME: Accurately calculate
307
 
       * VkImageFormatProperties::maxResourceSize.
308
 
       */
309
 
      .maxResourceSize = UINT32_MAX,
310
 
   };
311
 
   return VK_SUCCESS;
312
 
 unsupported:
313
 
   *pImageFormatProperties = (VkImageFormatProperties) {
314
 
      .maxExtent = { 0, 0, 0 },
315
 
      .maxMipLevels = 0,
316
 
      .maxArrayLayers = 0,
317
 
      .sampleCounts = 0,
318
 
      .maxResourceSize = 0,
319
 
   };
320
 
 
321
 
   return VK_ERROR_FORMAT_NOT_SUPPORTED;
322
 
}
323
 
 
324
 
VKAPI_ATTR VkResult VKAPI_CALL lvp_GetPhysicalDeviceImageFormatProperties2(
325
 
        VkPhysicalDevice                            physicalDevice,
326
 
        const VkPhysicalDeviceImageFormatInfo2     *base_info,
327
 
        VkImageFormatProperties2                   *base_props)
328
 
{
329
 
   LVP_FROM_HANDLE(lvp_physical_device, physical_device, physicalDevice);
330
 
   const VkPhysicalDeviceExternalImageFormatInfo *external_info = NULL;
331
 
   VkExternalImageFormatProperties *external_props = NULL;
332
 
   VkSamplerYcbcrConversionImageFormatProperties *ycbcr_props = NULL;
333
 
   VkResult result;
334
 
   result = lvp_get_image_format_properties(physical_device, base_info,
335
 
                                             &base_props->imageFormatProperties);
336
 
   if (result != VK_SUCCESS)
337
 
      return result;
338
 
 
339
 
   vk_foreach_struct_const(s, base_info->pNext) {
340
 
      switch (s->sType) {
341
 
      case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
342
 
         external_info = (const void *) s;
343
 
         break;
344
 
      default:
345
 
         break;
346
 
      }
347
 
   }
348
 
 
349
 
   /* Extract output structs */
350
 
   vk_foreach_struct(s, base_props->pNext) {
351
 
      switch (s->sType) {
352
 
      case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
353
 
         external_props = (void *) s;
354
 
         break;
355
 
      case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
356
 
         ycbcr_props = (void *) s;
357
 
         break;
358
 
      default:
359
 
         break;
360
 
      }
361
 
   }
362
 
 
363
 
   if (external_info && external_info->handleType != 0) {
364
 
      VkExternalMemoryFeatureFlagBits flags = 0;
365
 
      VkExternalMemoryHandleTypeFlags export_flags = 0;
366
 
      VkExternalMemoryHandleTypeFlags compat_flags = 0;
367
 
 
368
 
      switch (external_info->handleType) {
369
 
#ifdef PIPE_MEMORY_FD
370
 
      case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT:
371
 
         flags = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
372
 
         export_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
373
 
         compat_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
374
 
         break;
375
 
#endif
376
 
      case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
377
 
         flags = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
378
 
         compat_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT;
379
 
         break;
380
 
      default:
381
 
         break;
382
 
      }
383
 
      external_props->externalMemoryProperties = (VkExternalMemoryProperties) {
384
 
         .externalMemoryFeatures = flags,
385
 
         .exportFromImportedHandleTypes = export_flags,
386
 
         .compatibleHandleTypes = compat_flags,
387
 
      };
388
 
   }
389
 
   if (ycbcr_props)
390
 
      ycbcr_props->combinedImageSamplerDescriptorCount = 0;
391
 
   return VK_SUCCESS;
392
 
}
393
 
 
394
 
VKAPI_ATTR void VKAPI_CALL lvp_GetPhysicalDeviceSparseImageFormatProperties(
395
 
    VkPhysicalDevice                            physicalDevice,
396
 
    VkFormat                                    format,
397
 
    VkImageType                                 type,
398
 
    uint32_t                                    samples,
399
 
    VkImageUsageFlags                           usage,
400
 
    VkImageTiling                               tiling,
401
 
    uint32_t*                                   pNumProperties,
402
 
    VkSparseImageFormatProperties*              pProperties)
403
 
{
404
 
   /* Sparse images are not yet supported. */
405
 
   *pNumProperties = 0;
406
 
}
407
 
 
408
 
VKAPI_ATTR void VKAPI_CALL lvp_GetPhysicalDeviceSparseImageFormatProperties2(
409
 
        VkPhysicalDevice                            physicalDevice,
410
 
        const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo,
411
 
        uint32_t                                   *pPropertyCount,
412
 
        VkSparseImageFormatProperties2             *pProperties)
413
 
{
414
 
        /* Sparse images are not yet supported. */
415
 
        *pPropertyCount = 0;
416
 
}
417
 
 
418
 
VKAPI_ATTR void VKAPI_CALL lvp_GetPhysicalDeviceExternalBufferProperties(
419
 
   VkPhysicalDevice                            physicalDevice,
420
 
   const VkPhysicalDeviceExternalBufferInfo    *pExternalBufferInfo,
421
 
   VkExternalBufferProperties                  *pExternalBufferProperties)
422
 
{
423
 
   VkExternalMemoryFeatureFlagBits flags = 0;
424
 
   VkExternalMemoryHandleTypeFlags export_flags = 0;
425
 
   VkExternalMemoryHandleTypeFlags compat_flags = 0;
426
 
   switch (pExternalBufferInfo->handleType) {
427
 
#ifdef PIPE_MEMORY_FD
428
 
   case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT:
429
 
      flags = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
430
 
      export_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
431
 
      compat_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
432
 
      break;
433
 
#endif
434
 
   case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
435
 
      flags = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
436
 
      compat_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT;
437
 
      break;
438
 
   default:
439
 
      break;
440
 
   }
441
 
 
442
 
   pExternalBufferProperties->externalMemoryProperties = (VkExternalMemoryProperties) {
443
 
      .externalMemoryFeatures = flags,
444
 
      .exportFromImportedHandleTypes = export_flags,
445
 
      .compatibleHandleTypes = compat_flags,
446
 
   };
447
 
}