← Back to branch summary

~mmach/netext73/mesa-ryzen

« back to all changes in this revision

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

  • Committer: mmach
  • Date: 2023-11-02 21:31:35 UTC
  • Revision ID: netbit73@gmail.com-20231102213135-18d4tzh7tj0uz752
2023-11-02 22:11:57

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/frontends/lavapipe/lvp_formats.c
58
58
   }
59
59
}
60
60
 
 
61
 
61
62
static void
62
63
lvp_physical_device_get_format_properties(struct lvp_physical_device *physical_device,
63
64
                                          VkFormat format,
64
65
                                          VkFormatProperties3 *out_properties)
65
66
{
66
 
   enum pipe_format pformat = lvp_vk_format_to_pipe_format(format);
 
67
   const enum pipe_format pformat = lvp_vk_format_to_pipe_format(format);
 
68
   struct pipe_screen *pscreen = physical_device->pscreen;
67
69
   VkFormatFeatureFlags2 features = 0, buffer_features = 0;
 
70
 
68
71
   if (pformat == PIPE_FORMAT_NONE) {
69
72
     out_properties->linearTilingFeatures = 0;
70
73
     out_properties->optimalTilingFeatures = 0;
72
75
     return;
73
76
   }
74
77
 
75
 
   if (physical_device->pscreen->is_format_supported(physical_device->pscreen, pformat,
76
 
                                                     PIPE_TEXTURE_2D, 0, 0, PIPE_BIND_DEPTH_STENCIL)) {
 
78
   if (pscreen->is_format_supported(pscreen, pformat, PIPE_TEXTURE_2D, 0, 0,
 
79
                                    PIPE_BIND_DEPTH_STENCIL)) {
77
80
      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
 
         VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
 
81
      out_properties->optimalTilingFeatures =
 
82
         (VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT |
 
83
          VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT |
 
84
          VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT |
 
85
          VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT |
 
86
          VK_FORMAT_FEATURE_2_BLIT_SRC_BIT | VK_FORMAT_FEATURE_2_BLIT_DST_BIT |
 
87
          VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT |
 
88
          VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT);
83
89
 
84
90
      if (lvp_is_filter_minmax_format_supported(format))
85
 
         out_properties->optimalTilingFeatures |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT;
 
91
         out_properties->optimalTilingFeatures |=
 
92
            VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT;
86
93
      out_properties->bufferFeatures = 0;
87
94
      return;
88
95
   }
89
96
 
90
97
   if (util_format_is_compressed(pformat)) {
91
 
      if (physical_device->pscreen->is_format_supported(physical_device->pscreen, pformat,
92
 
                                                        PIPE_TEXTURE_2D, 0, 0, PIPE_BIND_SAMPLER_VIEW)) {
93
 
         features |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT;
94
 
         features |= VK_FORMAT_FEATURE_2_BLIT_SRC_BIT;
95
 
         features |= VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT;
96
 
         features |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
 
98
      if (pscreen->is_format_supported(pscreen, pformat, PIPE_TEXTURE_2D, 0, 0,
 
99
                                       PIPE_BIND_SAMPLER_VIEW)) {
 
100
         features |= (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT |
 
101
                      VK_FORMAT_FEATURE_2_BLIT_SRC_BIT |
 
102
                      VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT |
 
103
                      VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT |
 
104
                      VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT);
97
105
      }
98
106
      out_properties->linearTilingFeatures = features;
99
107
      out_properties->optimalTilingFeatures = features;
102
110
   }
103
111
 
104
112
   if (!util_format_is_srgb(pformat) &&
105
 
       physical_device->pscreen->is_format_supported(physical_device->pscreen, pformat,
106
 
                                                     PIPE_BUFFER, 0, 0, PIPE_BIND_VERTEX_BUFFER)) {
 
113
       pscreen->is_format_supported(pscreen, pformat, PIPE_BUFFER, 0, 0,
 
114
                                    PIPE_BIND_VERTEX_BUFFER)) {
107
115
      buffer_features |= VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT;
108
116
   }
109
117
 
110
 
   if (physical_device->pscreen->is_format_supported(physical_device->pscreen, pformat,
111
 
                                                     PIPE_BUFFER, 0, 0, PIPE_BIND_CONSTANT_BUFFER)) {
 
118
   if (pscreen->is_format_supported(pscreen, pformat, PIPE_BUFFER, 0, 0,
 
119
                                    PIPE_BIND_CONSTANT_BUFFER)) {
112
120
      buffer_features |= VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT;
113
121
   }
114
122
 
115
 
   if (physical_device->pscreen->is_format_supported(physical_device->pscreen, pformat,
116
 
                                                     PIPE_BUFFER, 0, 0, PIPE_BIND_SHADER_IMAGE)) {
117
 
      buffer_features |= VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT;
118
 
      if (physical_device->pscreen->get_param(physical_device->pscreen, PIPE_CAP_IMAGE_LOAD_FORMATTED))
119
 
         buffer_features |= VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT;
120
 
      if (physical_device->pscreen->get_param(physical_device->pscreen, PIPE_CAP_IMAGE_STORE_FORMATTED))
121
 
         buffer_features |= VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT;
 
123
   if (pscreen->is_format_supported(pscreen, pformat, PIPE_BUFFER, 0, 0,
 
124
                                    PIPE_BIND_SHADER_IMAGE)) {
 
125
      buffer_features |= VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT |
 
126
                         VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT |
 
127
                         VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT;
122
128
   }
123
129
 
124
 
   if (physical_device->pscreen->is_format_supported(physical_device->pscreen, pformat,
125
 
                                                     PIPE_TEXTURE_2D, 0, 0, PIPE_BIND_SAMPLER_VIEW)) {
 
130
   if (pscreen->is_format_supported(pscreen, pformat, PIPE_TEXTURE_2D, 0, 0,
 
131
                                    PIPE_BIND_SAMPLER_VIEW)) {
126
132
      features |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT;
127
133
      if (util_format_has_depth(util_format_description(pformat)))
128
134
         features |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT;
132
138
         features |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT;
133
139
   }
134
140
 
135
 
   if (physical_device->pscreen->is_format_supported(physical_device->pscreen, pformat,
136
 
                                                     PIPE_TEXTURE_2D, 0, 0, PIPE_BIND_RENDER_TARGET)) {
 
141
   if (pscreen->is_format_supported(pscreen, pformat, PIPE_TEXTURE_2D, 0, 0,
 
142
                                    PIPE_BIND_RENDER_TARGET)) {
137
143
      features |= VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT;
138
144
      /* SNORM blending on llvmpipe fails CTS - disable for now */
139
 
      if (!util_format_is_snorm(pformat) && !util_format_is_pure_integer(pformat))
 
145
      if (!util_format_is_snorm(pformat) &&
 
146
          !util_format_is_pure_integer(pformat))
140
147
         features |= VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT;
141
148
   }
142
149
 
143
 
   if (physical_device->pscreen->is_format_supported(physical_device->pscreen, pformat,
144
 
                                                     PIPE_TEXTURE_2D, 0, 0, PIPE_BIND_SHADER_IMAGE)) {
145
 
      features |= VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT;
146
 
      if (physical_device->pscreen->get_param(physical_device->pscreen, PIPE_CAP_IMAGE_LOAD_FORMATTED))
147
 
         features |= VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT;
148
 
      if (physical_device->pscreen->get_param(physical_device->pscreen, PIPE_CAP_IMAGE_STORE_FORMATTED))
149
 
         features |= VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT;
 
150
   if (pscreen->is_format_supported(pscreen, pformat, PIPE_TEXTURE_2D, 0, 0,
 
151
                                    PIPE_BIND_SHADER_IMAGE)) {
 
152
      features |= VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT |
 
153
                  VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT |
 
154
                  VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT;
150
155
   }
151
156
 
152
 
   if (pformat == PIPE_FORMAT_R32_UINT || pformat == PIPE_FORMAT_R32_SINT || pformat == PIPE_FORMAT_R32_FLOAT) {
 
157
   if (pformat == PIPE_FORMAT_R32_UINT ||
 
158
       pformat == PIPE_FORMAT_R32_SINT ||
 
159
       pformat == PIPE_FORMAT_R32_FLOAT) {
153
160
      features |= VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT;
154
161
      buffer_features |= VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT;
155
 
   }
156
 
 
157
 
   if (pformat == PIPE_FORMAT_R11G11B10_FLOAT || pformat == PIPE_FORMAT_R9G9B9E5_FLOAT)
158
 
     features |= VK_FORMAT_FEATURE_2_BLIT_SRC_BIT;
159
 
 
160
 
   if (features && buffer_features != VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT)
161
 
      features |= VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT;
162
 
   if (pformat == PIPE_FORMAT_B5G6R5_UNORM)
163
 
     features |= VK_FORMAT_FEATURE_2_BLIT_SRC_BIT | VK_FORMAT_FEATURE_2_BLIT_DST_BIT;
164
 
   if ((pformat != PIPE_FORMAT_R9G9B9E5_FLOAT) && util_format_get_nr_components(pformat) != 3 &&
165
 
       pformat != PIPE_FORMAT_R10G10B10A2_SNORM && pformat != PIPE_FORMAT_B10G10R10A2_SNORM &&
 
162
   } else if (pformat == PIPE_FORMAT_R11G11B10_FLOAT ||
 
163
              pformat == PIPE_FORMAT_R9G9B9E5_FLOAT) {
 
164
      features |= VK_FORMAT_FEATURE_2_BLIT_SRC_BIT;
 
165
   }
 
166
 
 
167
   if (features && buffer_features != VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT) {
 
168
      features |= (VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT |
 
169
                   VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT);
 
170
   }
 
171
   if (pformat == PIPE_FORMAT_B5G6R5_UNORM) {
 
172
      features |= (VK_FORMAT_FEATURE_2_BLIT_SRC_BIT |
 
173
                   VK_FORMAT_FEATURE_2_BLIT_DST_BIT);
 
174
   }
 
175
   if ((pformat != PIPE_FORMAT_R9G9B9E5_FLOAT) &&
 
176
       util_format_get_nr_components(pformat) != 3 &&
 
177
       !util_format_is_yuv(pformat) &&
 
178
       pformat != PIPE_FORMAT_R10G10B10A2_SNORM &&
 
179
       pformat != PIPE_FORMAT_B10G10R10A2_SNORM &&
166
180
       pformat != PIPE_FORMAT_B10G10R10A2_UNORM) {
167
 
      features |= VK_FORMAT_FEATURE_2_BLIT_SRC_BIT | VK_FORMAT_FEATURE_2_BLIT_DST_BIT;
 
181
      features |= (VK_FORMAT_FEATURE_2_BLIT_SRC_BIT |
 
182
                   VK_FORMAT_FEATURE_2_BLIT_DST_BIT);
168
183
   }
169
184
 
170
185
   out_properties->linearTilingFeatures = features;
171
186
   out_properties->optimalTilingFeatures = features;
172
187
   out_properties->bufferFeatures = buffer_features;
173
 
   return;
174
188
}
175
189
 
 
190
 
176
191
VKAPI_ATTR void VKAPI_CALL lvp_GetPhysicalDeviceFormatProperties2(
177
192
        VkPhysicalDevice                            physicalDevice,
178
193
        VkFormat                                    format,