projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
vk: Merge anv_attachment_view into anv_image_view
[mesa.git] / src / vulkan / anv_meta.c
1 /*
2 * Copyright © 2015 Intel Corporation
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 <assert.h>
25 #include <stdbool.h>
26 #include <string.h>
27 #include <unistd.h>
28 #include <fcntl.h>
29
30 #include "anv_private.h"
31 #include "anv_nir_builder.h"
32
33 static nir_shader *
34 build_nir_vertex_shader(bool attr_flat)
35 {
36 nir_builder b;
37
38 const struct glsl_type *vertex_type = glsl_vec4_type();
39
40 nir_builder_init_simple_shader(&b, MESA_SHADER_VERTEX);
41
42 nir_variable *pos_in = nir_variable_create(b.shader, "a_pos",
43 vertex_type,
44 nir_var_shader_in);
45 pos_in->data.location = VERT_ATTRIB_GENERIC0;
46 nir_variable *pos_out = nir_variable_create(b.shader, "gl_Position",
47 vertex_type,
48 nir_var_shader_out);
49 pos_in->data.location = VARYING_SLOT_POS;
50 nir_copy_var(&b, pos_out, pos_in);
51
52 /* Add one more pass-through attribute. For clear shaders, this is used
53 * to store the color and for blit shaders it's the texture coordinate.
54 */
55 const struct glsl_type *attr_type = glsl_vec4_type();
56 nir_variable *attr_in = nir_variable_create(b.shader, "a_attr", attr_type,
57 nir_var_shader_in);
58 attr_in->data.location = VERT_ATTRIB_GENERIC1;
59 nir_variable *attr_out = nir_variable_create(b.shader, "v_attr", attr_type,
60 nir_var_shader_out);
61 attr_out->data.location = VARYING_SLOT_VAR0;
62 attr_out->data.interpolation = attr_flat ? INTERP_QUALIFIER_FLAT :
63 INTERP_QUALIFIER_SMOOTH;
64 nir_copy_var(&b, attr_out, attr_in);
65
66 return b.shader;
67 }
68
69 static nir_shader *
70 build_nir_clear_fragment_shader()
71 {
72 nir_builder b;
73
74 const struct glsl_type *color_type = glsl_vec4_type();
75
76 nir_builder_init_simple_shader(&b, MESA_SHADER_FRAGMENT);
77
78 nir_variable *color_in = nir_variable_create(b.shader, "v_attr",
79 color_type,
80 nir_var_shader_in);
81 color_in->data.location = VARYING_SLOT_VAR0;
82 color_in->data.interpolation = INTERP_QUALIFIER_FLAT;
83 nir_variable *color_out = nir_variable_create(b.shader, "f_color",
84 color_type,
85 nir_var_shader_out);
86 color_out->data.location = FRAG_RESULT_DATA0;
87 nir_copy_var(&b, color_out, color_in);
88
89 return b.shader;
90 }
91
92 static nir_shader *
93 build_nir_copy_fragment_shader(enum glsl_sampler_dim tex_dim)
94 {
95 nir_builder b;
96
97 nir_builder_init_simple_shader(&b, MESA_SHADER_FRAGMENT);
98
99 const struct glsl_type *color_type = glsl_vec4_type();
100
101 nir_variable *tex_pos_in = nir_variable_create(b.shader, "v_attr",
102 glsl_vec4_type(),
103 nir_var_shader_in);
104 tex_pos_in->data.location = VARYING_SLOT_VAR0;
105
106 const struct glsl_type *sampler_type =
107 glsl_sampler_type(tex_dim, false, false, glsl_get_base_type(color_type));
108 nir_variable *sampler = nir_variable_create(b.shader, "s_tex", sampler_type,
109 nir_var_uniform);
110 sampler->data.descriptor_set = 0;
111 sampler->data.binding = 0;
112
113 nir_tex_instr *tex = nir_tex_instr_create(b.shader, 1);
114 tex->sampler_dim = tex_dim;
115 tex->op = nir_texop_tex;
116 tex->src[0].src_type = nir_tex_src_coord;
117 tex->src[0].src = nir_src_for_ssa(nir_load_var(&b, tex_pos_in));
118 tex->dest_type = nir_type_float; /* TODO */
119
120 switch (tex_dim) {
121 case GLSL_SAMPLER_DIM_2D:
122 tex->coord_components = 2;
123 break;
124 case GLSL_SAMPLER_DIM_3D:
125 tex->coord_components = 3;
126 break;
127 default:
128 assert(!"Unsupported texture dimension");
129 }
130
131 tex->sampler = nir_deref_var_create(tex, sampler);
132
133 nir_ssa_dest_init(&tex->instr, &tex->dest, 4, "tex");
134 nir_builder_instr_insert(&b, &tex->instr);
135
136 nir_variable *color_out = nir_variable_create(b.shader, "f_color",
137 color_type,
138 nir_var_shader_out);
139 color_out->data.location = FRAG_RESULT_DATA0;
140 nir_store_var(&b, color_out, &tex->dest.ssa);
141
142 return b.shader;
143 }
144
145 static void
146 anv_device_init_meta_clear_state(struct anv_device *device)
147 {
148 struct anv_shader_module vsm = {
149 .nir = build_nir_vertex_shader(true),
150 };
151
152 struct anv_shader_module fsm = {
153 .nir = build_nir_clear_fragment_shader(),
154 };
155
156 VkShader vs;
157 anv_CreateShader(anv_device_to_handle(device),
158 &(VkShaderCreateInfo) {
159 .sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO,
160 .module = anv_shader_module_to_handle(&vsm),
161 .pName = "main",
162 }, &vs);
163
164 VkShader fs;
165 anv_CreateShader(anv_device_to_handle(device),
166 &(VkShaderCreateInfo) {
167 .sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO,
168 .module = anv_shader_module_to_handle(&fsm),
169 .pName = "main",
170 }, &fs);
171
172 /* We use instanced rendering to clear multiple render targets. We have two
173 * vertex buffers: the first vertex buffer holds per-vertex data and
174 * provides the vertices for the clear rectangle. The second one holds
175 * per-instance data, which consists of the VUE header (which selects the
176 * layer) and the color (Vulkan supports per-RT clear colors).
177 */
178 VkPipelineVertexInputStateCreateInfo vi_create_info = {
179 .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
180 .bindingCount = 2,
181 .pVertexBindingDescriptions = (VkVertexInputBindingDescription[]) {
182 {
183 .binding = 0,
184 .strideInBytes = 12,
185 .stepRate = VK_VERTEX_INPUT_STEP_RATE_VERTEX
186 },
187 {
188 .binding = 1,
189 .strideInBytes = 32,
190 .stepRate = VK_VERTEX_INPUT_STEP_RATE_INSTANCE
191 },
192 },
193 .attributeCount = 3,
194 .pVertexAttributeDescriptions = (VkVertexInputAttributeDescription[]) {
195 {
196 /* VUE Header */
197 .location = 0,
198 .binding = 1,
199 .format = VK_FORMAT_R32G32B32A32_UINT,
200 .offsetInBytes = 0
201 },
202 {
203 /* Position */
204 .location = 1,
205 .binding = 0,
206 .format = VK_FORMAT_R32G32B32_SFLOAT,
207 .offsetInBytes = 0
208 },
209 {
210 /* Color */
211 .location = 2,
212 .binding = 1,
213 .format = VK_FORMAT_R32G32B32A32_SFLOAT,
214 .offsetInBytes = 16
215 }
216 }
217 };
218
219 anv_graphics_pipeline_create(anv_device_to_handle(device),
220 &(VkGraphicsPipelineCreateInfo) {
221 .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
222
223 .stageCount = 2,
224 .pStages = (VkPipelineShaderStageCreateInfo[]) {
225 {
226 .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
227 .stage = VK_SHADER_STAGE_VERTEX,
228 .shader = vs,
229 .pSpecializationInfo = NULL
230 }, {
231 .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
232 .stage = VK_SHADER_STAGE_FRAGMENT,
233 .shader = fs,
234 .pSpecializationInfo = NULL,
235 }
236 },
237 .pVertexInputState = &vi_create_info,
238 .pInputAssemblyState = &(VkPipelineInputAssemblyStateCreateInfo) {
239 .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
240 .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
241 .primitiveRestartEnable = false,
242 },
243 .pRasterState = &(VkPipelineRasterStateCreateInfo) {
244 .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO,
245 .depthClipEnable = true,
246 .rasterizerDiscardEnable = false,
247 .fillMode = VK_FILL_MODE_SOLID,
248 .cullMode = VK_CULL_MODE_NONE,
249 .frontFace = VK_FRONT_FACE_CCW
250 },
251 .pDepthStencilState = &(VkPipelineDepthStencilStateCreateInfo) {
252 .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
253 .depthTestEnable = true,
254 .depthWriteEnable = true,
255 .depthCompareOp = VK_COMPARE_OP_ALWAYS,
256 .depthBoundsTestEnable = false,
257 .stencilTestEnable = true,
258 .front = (VkStencilOpState) {
259 .stencilPassOp = VK_STENCIL_OP_REPLACE,
260 .stencilCompareOp = VK_COMPARE_OP_ALWAYS,
261 },
262 .back = (VkStencilOpState) {
263 .stencilPassOp = VK_STENCIL_OP_REPLACE,
264 .stencilCompareOp = VK_COMPARE_OP_ALWAYS,
265 },
266 },
267 .pColorBlendState = &(VkPipelineColorBlendStateCreateInfo) {
268 .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
269 .attachmentCount = 1,
270 .pAttachments = (VkPipelineColorBlendAttachmentState []) {
271 { .channelWriteMask = VK_CHANNEL_A_BIT |
272 VK_CHANNEL_R_BIT | VK_CHANNEL_G_BIT | VK_CHANNEL_B_BIT },
273 }
274 },
275 .flags = 0,
276 },
277 &(struct anv_graphics_pipeline_create_info) {
278 .use_repclear = true,
279 .disable_viewport = true,
280 .disable_vs = true,
281 .use_rectlist = true
282 },
283 &device->meta_state.clear.pipeline);
284
285 anv_DestroyShader(anv_device_to_handle(device), vs);
286 anv_DestroyShader(anv_device_to_handle(device), fs);
287 ralloc_free(vsm.nir);
288 ralloc_free(fsm.nir);
289 }
290
291 #define NUM_VB_USED 2
292 struct anv_saved_state {
293 struct anv_vertex_binding old_vertex_bindings[NUM_VB_USED];
294 struct anv_descriptor_set *old_descriptor_set0;
295 struct anv_pipeline *old_pipeline;
296 struct anv_dynamic_ds_state *old_ds_state;
297 struct anv_dynamic_cb_state *old_cb_state;
298 };
299
300 static void
301 anv_cmd_buffer_save(struct anv_cmd_buffer *cmd_buffer,
302 struct anv_saved_state *state)
303 {
304 state->old_pipeline = cmd_buffer->state.pipeline;
305 state->old_descriptor_set0 = cmd_buffer->state.descriptors[0].set;
306 memcpy(state->old_vertex_bindings, cmd_buffer->state.vertex_bindings,
307 sizeof(state->old_vertex_bindings));
308 state->old_ds_state = cmd_buffer->state.ds_state;
309 state->old_cb_state = cmd_buffer->state.cb_state;
310 }
311
312 static void
313 anv_cmd_buffer_restore(struct anv_cmd_buffer *cmd_buffer,
314 const struct anv_saved_state *state)
315 {
316 cmd_buffer->state.pipeline = state->old_pipeline;
317 cmd_buffer->state.descriptors[0].set = state->old_descriptor_set0;
318 memcpy(cmd_buffer->state.vertex_bindings, state->old_vertex_bindings,
319 sizeof(state->old_vertex_bindings));
320
321 cmd_buffer->state.vb_dirty |= (1 << NUM_VB_USED) - 1;
322 cmd_buffer->state.dirty |= ANV_CMD_BUFFER_PIPELINE_DIRTY;
323 cmd_buffer->state.descriptors_dirty |= VK_SHADER_STAGE_VERTEX_BIT;
324
325 if (cmd_buffer->state.ds_state != state->old_ds_state) {
326 cmd_buffer->state.ds_state = state->old_ds_state;
327 cmd_buffer->state.dirty |= ANV_CMD_BUFFER_DS_DIRTY;
328 }
329
330 if (cmd_buffer->state.cb_state != state->old_cb_state) {
331 cmd_buffer->state.cb_state = state->old_cb_state;
332 cmd_buffer->state.dirty |= ANV_CMD_BUFFER_CB_DIRTY;
333 }
334 }
335
336 struct vue_header {
337 uint32_t Reserved;
338 uint32_t RTAIndex;
339 uint32_t ViewportIndex;
340 float PointWidth;
341 };
342
343 struct clear_instance_data {
344 struct vue_header vue_header;
345 VkClearColorValue color;
346 };
347
348 static void
349 meta_emit_clear(struct anv_cmd_buffer *cmd_buffer,
350 int num_instances,
351 struct clear_instance_data *instance_data,
352 VkClearDepthStencilValue ds_clear_value)
353 {
354 struct anv_device *device = cmd_buffer->device;
355 struct anv_framebuffer *fb = cmd_buffer->state.framebuffer;
356 struct anv_state state;
357 uint32_t size;
358
359 const float vertex_data[] = {
360 /* Rect-list coordinates */
361 0.0, 0.0, ds_clear_value.depth,
362 fb->width, 0.0, ds_clear_value.depth,
363 fb->width, fb->height, ds_clear_value.depth,
364
365 /* Align to 16 bytes */
366 0.0, 0.0, 0.0,
367 };
368
369 size = sizeof(vertex_data) + num_instances * sizeof(*instance_data);
370 state = anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, size, 16);
371
372 /* Copy in the vertex and instance data */
373 memcpy(state.map, vertex_data, sizeof(vertex_data));
374 memcpy(state.map + sizeof(vertex_data), instance_data,
375 num_instances * sizeof(*instance_data));
376
377 struct anv_buffer vertex_buffer = {
378 .device = cmd_buffer->device,
379 .size = size,
380 .bo = &device->dynamic_state_block_pool.bo,
381 .offset = state.offset
382 };
383
384 anv_CmdBindVertexBuffers(anv_cmd_buffer_to_handle(cmd_buffer), 0, 2,
385 (VkBuffer[]) {
386 anv_buffer_to_handle(&vertex_buffer),
387 anv_buffer_to_handle(&vertex_buffer)
388 },
389 (VkDeviceSize[]) {
390 0,
391 sizeof(vertex_data)
392 });
393
394 if (cmd_buffer->state.pipeline != anv_pipeline_from_handle(device->meta_state.clear.pipeline))
395 anv_CmdBindPipeline(anv_cmd_buffer_to_handle(cmd_buffer),
396 VK_PIPELINE_BIND_POINT_GRAPHICS,
397 device->meta_state.clear.pipeline);
398
399 /* We don't need anything here, only set if not already set. */
400 if (cmd_buffer->state.rs_state == NULL)
401 anv_CmdBindDynamicRasterState(anv_cmd_buffer_to_handle(cmd_buffer),
402 device->meta_state.shared.rs_state);
403
404 if (cmd_buffer->state.vp_state == NULL)
405 anv_CmdBindDynamicViewportState(anv_cmd_buffer_to_handle(cmd_buffer),
406 cmd_buffer->state.framebuffer->vp_state);
407
408 if (cmd_buffer->state.ds_state == NULL)
409 anv_CmdBindDynamicDepthStencilState(anv_cmd_buffer_to_handle(cmd_buffer),
410 device->meta_state.shared.ds_state);
411
412 if (cmd_buffer->state.cb_state == NULL)
413 anv_CmdBindDynamicColorBlendState(anv_cmd_buffer_to_handle(cmd_buffer),
414 device->meta_state.shared.cb_state);
415
416 ANV_CALL(CmdDraw)(anv_cmd_buffer_to_handle(cmd_buffer),
417 3, num_instances, 0, 0);
418 }
419
420 void
421 anv_cmd_buffer_clear_attachments(struct anv_cmd_buffer *cmd_buffer,
422 struct anv_render_pass *pass,
423 const VkClearValue *clear_values)
424 {
425 struct anv_saved_state saved_state;
426
427 if (pass->has_stencil_clear_attachment)
428 anv_finishme("stencil clear");
429
430 /* FINISHME: Rethink how we count clear attachments in light of
431 * 0.138.2 -> 0.170.2 diff.
432 */
433 if (pass->num_color_clear_attachments == 0 &&
434 !pass->has_depth_clear_attachment)
435 return;
436
437 struct clear_instance_data instance_data[pass->num_color_clear_attachments];
438 uint32_t color_attachments[pass->num_color_clear_attachments];
439 uint32_t ds_attachment = VK_ATTACHMENT_UNUSED;
440 VkClearDepthStencilValue ds_clear_value = {0};
441
442 int layer = 0;
443 for (uint32_t i = 0; i < pass->attachment_count; i++) {
444 const struct anv_render_pass_attachment *att = &pass->attachments[i];
445
446 if (att->load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) {
447 if (anv_format_is_color(att->format)) {
448 instance_data[layer] = (struct clear_instance_data) {
449 .vue_header = {
450 .RTAIndex = i,
451 .ViewportIndex = 0,
452 .PointWidth = 0.0
453 },
454 .color = clear_values[i].color,
455 };
456 color_attachments[layer] = i;
457 layer++;
458 } else if (att->format->depth_format) {
459 assert(ds_attachment == VK_ATTACHMENT_UNUSED);
460 ds_attachment = i;
461 ds_clear_value = clear_values[ds_attachment].depthStencil;
462 }
463 } else if (att->stencil_load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) {
464 assert(att->format->has_stencil);
465 anv_finishme("stencil clear");
466 }
467 }
468
469 anv_cmd_buffer_save(cmd_buffer, &saved_state);
470
471 struct anv_subpass subpass = {
472 .input_count = 0,
473 .color_count = pass->num_color_clear_attachments,
474 .color_attachments = color_attachments,
475 .depth_stencil_attachment = ds_attachment,
476 };
477
478 anv_cmd_buffer_begin_subpass(cmd_buffer, &subpass);
479
480 meta_emit_clear(cmd_buffer, pass->num_color_clear_attachments,
481 instance_data, ds_clear_value);
482
483 /* Restore API state */
484 anv_cmd_buffer_restore(cmd_buffer, &saved_state);
485 }
486
487 static VkImageViewType
488 meta_blit_get_src_image_view_type(const struct anv_image *src_image)
489 {
490 switch (src_image->type) {
491 case VK_IMAGE_TYPE_1D:
492 return VK_IMAGE_VIEW_TYPE_1D;
493 case VK_IMAGE_TYPE_2D:
494 return VK_IMAGE_VIEW_TYPE_2D;
495 case VK_IMAGE_TYPE_3D:
496 return VK_IMAGE_VIEW_TYPE_3D;
497 default:
498 assert(!"bad VkImageType");
499 return 0;
500 }
501 }
502
503 static uint32_t
504 meta_blit_get_dest_view_base_array_slice(const struct anv_image *dest_image,
505 const VkImageSubresourceCopy *dest_subresource,
506 const VkOffset3D *dest_offset)
507 {
508 switch (dest_image->type) {
509 case VK_IMAGE_TYPE_1D:
510 case VK_IMAGE_TYPE_2D:
511 return dest_subresource->arrayLayer;
512 case VK_IMAGE_TYPE_3D:
513 /* HACK: Vulkan does not allow attaching a 3D image to a framebuffer,
514 * but meta does it anyway. When doing so, we translate the
515 * destination's z offset into an array offset.
516 */
517 return dest_offset->z;
518 default:
519 assert(!"bad VkImageType");
520 return 0;
521 }
522 }
523
524 static void
525 anv_device_init_meta_blit_state(struct anv_device *device)
526 {
527 /* We don't use a vertex shader for clearing, but instead build and pass
528 * the VUEs directly to the rasterization backend. However, we do need
529 * to provide GLSL source for the vertex shader so that the compiler
530 * does not dead-code our inputs.
531 */
532 struct anv_shader_module vsm = {
533 .nir = build_nir_vertex_shader(false),
534 };
535
536 struct anv_shader_module fsm_2d = {
537 .nir = build_nir_copy_fragment_shader(GLSL_SAMPLER_DIM_2D),
538 };
539
540 struct anv_shader_module fsm_3d = {
541 .nir = build_nir_copy_fragment_shader(GLSL_SAMPLER_DIM_3D),
542 };
543
544 VkShader vs;
545 anv_CreateShader(anv_device_to_handle(device),
546 &(VkShaderCreateInfo) {
547 .sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO,
548 .module = anv_shader_module_to_handle(&vsm),
549 .pName = "main",
550 }, &vs);
551
552 VkShader fs_2d;
553 anv_CreateShader(anv_device_to_handle(device),
554 &(VkShaderCreateInfo) {
555 .sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO,
556 .module = anv_shader_module_to_handle(&fsm_2d),
557 .pName = "main",
558 }, &fs_2d);
559
560 VkShader fs_3d;
561 anv_CreateShader(anv_device_to_handle(device),
562 &(VkShaderCreateInfo) {
563 .sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO,
564 .module = anv_shader_module_to_handle(&fsm_3d),
565 .pName = "main",
566 }, &fs_3d);
567
568 VkPipelineVertexInputStateCreateInfo vi_create_info = {
569 .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
570 .bindingCount = 2,
571 .pVertexBindingDescriptions = (VkVertexInputBindingDescription[]) {
572 {
573 .binding = 0,
574 .strideInBytes = 0,
575 .stepRate = VK_VERTEX_INPUT_STEP_RATE_VERTEX
576 },
577 {
578 .binding = 1,
579 .strideInBytes = 5 * sizeof(float),
580 .stepRate = VK_VERTEX_INPUT_STEP_RATE_VERTEX
581 },
582 },
583 .attributeCount = 3,
584 .pVertexAttributeDescriptions = (VkVertexInputAttributeDescription[]) {
585 {
586 /* VUE Header */
587 .location = 0,
588 .binding = 0,
589 .format = VK_FORMAT_R32G32B32A32_UINT,
590 .offsetInBytes = 0
591 },
592 {
593 /* Position */
594 .location = 1,
595 .binding = 1,
596 .format = VK_FORMAT_R32G32_SFLOAT,
597 .offsetInBytes = 0
598 },
599 {
600 /* Texture Coordinate */
601 .location = 2,
602 .binding = 1,
603 .format = VK_FORMAT_R32G32B32_SFLOAT,
604 .offsetInBytes = 8
605 }
606 }
607 };
608
609 VkDescriptorSetLayoutCreateInfo ds_layout_info = {
610 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
611 .count = 1,
612 .pBinding = (VkDescriptorSetLayoutBinding[]) {
613 {
614 .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
615 .arraySize = 1,
616 .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
617 .pImmutableSamplers = NULL
618 },
619 }
620 };
621 anv_CreateDescriptorSetLayout(anv_device_to_handle(device), &ds_layout_info,
622 &device->meta_state.blit.ds_layout);
623
624 anv_CreatePipelineLayout(anv_device_to_handle(device),
625 &(VkPipelineLayoutCreateInfo) {
626 .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
627 .descriptorSetCount = 1,
628 .pSetLayouts = &device->meta_state.blit.ds_layout,
629 },
630 &device->meta_state.blit.pipeline_layout);
631
632 VkPipelineShaderStageCreateInfo pipeline_shader_stages[] = {
633 {
634 .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
635 .stage = VK_SHADER_STAGE_VERTEX,
636 .shader = vs,
637 .pSpecializationInfo = NULL
638 }, {
639 .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
640 .stage = VK_SHADER_STAGE_FRAGMENT,
641 .shader = {0}, /* TEMPLATE VALUE! FILL ME IN! */
642 .pSpecializationInfo = NULL
643 },
644 };
645
646 const VkGraphicsPipelineCreateInfo vk_pipeline_info = {
647 .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
648 .stageCount = ARRAY_SIZE(pipeline_shader_stages),
649 .pStages = pipeline_shader_stages,
650 .pVertexInputState = &vi_create_info,
651 .pInputAssemblyState = &(VkPipelineInputAssemblyStateCreateInfo) {
652 .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
653 .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
654 .primitiveRestartEnable = false,
655 },
656 .pRasterState = &(VkPipelineRasterStateCreateInfo) {
657 .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO,
658 .depthClipEnable = true,
659 .rasterizerDiscardEnable = false,
660 .fillMode = VK_FILL_MODE_SOLID,
661 .cullMode = VK_CULL_MODE_NONE,
662 .frontFace = VK_FRONT_FACE_CCW
663 },
664 .pColorBlendState = &(VkPipelineColorBlendStateCreateInfo) {
665 .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
666 .attachmentCount = 1,
667 .pAttachments = (VkPipelineColorBlendAttachmentState []) {
668 { .channelWriteMask = VK_CHANNEL_A_BIT |
669 VK_CHANNEL_R_BIT | VK_CHANNEL_G_BIT | VK_CHANNEL_B_BIT },
670 }
671 },
672 .flags = 0,
673 .layout = device->meta_state.blit.pipeline_layout,
674 };
675
676 const struct anv_graphics_pipeline_create_info anv_pipeline_info = {
677 .use_repclear = false,
678 .disable_viewport = true,
679 .disable_scissor = true,
680 .disable_vs = true,
681 .use_rectlist = true
682 };
683
684 pipeline_shader_stages[1].shader = fs_2d;
685 anv_graphics_pipeline_create(anv_device_to_handle(device),
686 &vk_pipeline_info, &anv_pipeline_info,
687 &device->meta_state.blit.pipeline_2d_src);
688
689 pipeline_shader_stages[1].shader = fs_3d;
690 anv_graphics_pipeline_create(anv_device_to_handle(device),
691 &vk_pipeline_info, &anv_pipeline_info,
692 &device->meta_state.blit.pipeline_3d_src);
693
694 anv_DestroyShader(anv_device_to_handle(device), vs);
695 anv_DestroyShader(anv_device_to_handle(device), fs_2d);
696 anv_DestroyShader(anv_device_to_handle(device), fs_3d);
697 ralloc_free(vsm.nir);
698 ralloc_free(fsm_2d.nir);
699 ralloc_free(fsm_3d.nir);
700 }
701
702 static void
703 meta_prepare_blit(struct anv_cmd_buffer *cmd_buffer,
704 struct anv_saved_state *saved_state)
705 {
706 struct anv_device *device = cmd_buffer->device;
707
708 anv_cmd_buffer_save(cmd_buffer, saved_state);
709
710 /* We don't need anything here, only set if not already set. */
711 if (cmd_buffer->state.rs_state == NULL)
712 anv_CmdBindDynamicRasterState(anv_cmd_buffer_to_handle(cmd_buffer),
713 device->meta_state.shared.rs_state);
714 if (cmd_buffer->state.ds_state == NULL)
715 anv_CmdBindDynamicDepthStencilState(anv_cmd_buffer_to_handle(cmd_buffer),
716 device->meta_state.shared.ds_state);
717
718 anv_CmdBindDynamicColorBlendState(anv_cmd_buffer_to_handle(cmd_buffer),
719 device->meta_state.shared.cb_state);
720 }
721
722 struct blit_region {
723 VkOffset3D src_offset;
724 VkExtent3D src_extent;
725 VkOffset3D dest_offset;
726 VkExtent3D dest_extent;
727 };
728
729 static void
730 meta_emit_blit(struct anv_cmd_buffer *cmd_buffer,
731 struct anv_image *src_image,
732 struct anv_image_view *src_iview,
733 VkOffset3D src_offset,
734 VkExtent3D src_extent,
735 struct anv_image *dest_image,
736 struct anv_image_view *dest_iview,
737 VkOffset3D dest_offset,
738 VkExtent3D dest_extent)
739 {
740 struct anv_device *device = cmd_buffer->device;
741
742 VkImageView dest_iview_h = anv_image_view_to_handle(dest_iview);
743 VkAttachmentView dest_aview_h = { .handle = dest_iview_h.handle };
744
745 VkDescriptorPool dummy_desc_pool = { .handle = 1 };
746
747 struct blit_vb_data {
748 float pos[2];
749 float tex_coord[3];
750 } *vb_data;
751
752 unsigned vb_size = sizeof(struct vue_header) + 3 * sizeof(*vb_data);
753
754 struct anv_state vb_state =
755 anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, vb_size, 16);
756 memset(vb_state.map, 0, sizeof(struct vue_header));
757 vb_data = vb_state.map + sizeof(struct vue_header);
758
759 vb_data[0] = (struct blit_vb_data) {
760 .pos = {
761 dest_offset.x + dest_extent.width,
762 dest_offset.y + dest_extent.height,
763 },
764 .tex_coord = {
765 (float)(src_offset.x + src_extent.width) / (float)src_iview->extent.width,
766 (float)(src_offset.y + src_extent.height) / (float)src_iview->extent.height,
767 (float)(src_offset.z + src_extent.depth) / (float)src_iview->extent.depth,
768 },
769 };
770
771 vb_data[1] = (struct blit_vb_data) {
772 .pos = {
773 dest_offset.x,
774 dest_offset.y + dest_extent.height,
775 },
776 .tex_coord = {
777 (float)src_offset.x / (float)src_iview->extent.width,
778 (float)(src_offset.y + src_extent.height) / (float)src_iview->extent.height,
779 (float)(src_offset.z + src_extent.depth) / (float)src_iview->extent.depth,
780 },
781 };
782
783 vb_data[2] = (struct blit_vb_data) {
784 .pos = {
785 dest_offset.x,
786 dest_offset.y,
787 },
788 .tex_coord = {
789 (float)src_offset.x / (float)src_iview->extent.width,
790 (float)src_offset.y / (float)src_iview->extent.height,
791 (float)src_offset.z / (float)src_iview->extent.depth,
792 },
793 };
794
795 struct anv_buffer vertex_buffer = {
796 .device = device,
797 .size = vb_size,
798 .bo = &device->dynamic_state_block_pool.bo,
799 .offset = vb_state.offset,
800 };
801
802 anv_CmdBindVertexBuffers(anv_cmd_buffer_to_handle(cmd_buffer), 0, 2,
803 (VkBuffer[]) {
804 anv_buffer_to_handle(&vertex_buffer),
805 anv_buffer_to_handle(&vertex_buffer)
806 },
807 (VkDeviceSize[]) {
808 0,
809 sizeof(struct vue_header),
810 });
811
812 VkDescriptorSet set;
813 anv_AllocDescriptorSets(anv_device_to_handle(device), dummy_desc_pool,
814 VK_DESCRIPTOR_SET_USAGE_ONE_SHOT,
815 1, &device->meta_state.blit.ds_layout, &set);
816 anv_UpdateDescriptorSets(anv_device_to_handle(device),
817 1, /* writeCount */
818 (VkWriteDescriptorSet[]) {
819 {
820 .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
821 .destSet = set,
822 .destBinding = 0,
823 .destArrayElement = 0,
824 .count = 1,
825 .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
826 .pDescriptors = (VkDescriptorInfo[]) {
827 {
828 .imageView = anv_image_view_to_handle(src_iview),
829 .imageLayout = VK_IMAGE_LAYOUT_GENERAL
830 },
831 }
832 }
833 }, 0, NULL);
834
835 VkFramebuffer fb;
836 anv_CreateFramebuffer(anv_device_to_handle(device),
837 &(VkFramebufferCreateInfo) {
838 .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
839 .attachmentCount = 1,
840 .pAttachments = (VkAttachmentBindInfo[]) {
841 {
842 .view = dest_aview_h,
843 .layout = VK_IMAGE_LAYOUT_GENERAL
844 }
845 },
846 .width = dest_iview->extent.width,
847 .height = dest_iview->extent.height,
848 .layers = 1
849 }, &fb);
850
851 VkRenderPass pass;
852 anv_CreateRenderPass(anv_device_to_handle(device),
853 &(VkRenderPassCreateInfo) {
854 .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
855 .attachmentCount = 1,
856 .pAttachments = &(VkAttachmentDescription) {
857 .sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION,
858 .format = dest_iview->format->vk_format,
859 .loadOp = VK_ATTACHMENT_LOAD_OP_LOAD,
860 .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
861 .initialLayout = VK_IMAGE_LAYOUT_GENERAL,
862 .finalLayout = VK_IMAGE_LAYOUT_GENERAL,
863 },
864 .subpassCount = 1,
865 .pSubpasses = &(VkSubpassDescription) {
866 .sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION,
867 .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
868 .inputCount = 0,
869 .colorCount = 1,
870 .pColorAttachments = &(VkAttachmentReference) {
871 .attachment = 0,
872 .layout = VK_IMAGE_LAYOUT_GENERAL,
873 },
874 .pResolveAttachments = NULL,
875 .depthStencilAttachment = (VkAttachmentReference) {
876 .attachment = VK_ATTACHMENT_UNUSED,
877 .layout = VK_IMAGE_LAYOUT_GENERAL,
878 },
879 .preserveCount = 1,
880 .pPreserveAttachments = &(VkAttachmentReference) {
881 .attachment = 0,
882 .layout = VK_IMAGE_LAYOUT_GENERAL,
883 },
884 },
885 .dependencyCount = 0,
886 }, &pass);
887
888 ANV_CALL(CmdBeginRenderPass)(anv_cmd_buffer_to_handle(cmd_buffer),
889 &(VkRenderPassBeginInfo) {
890 .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
891 .renderPass = pass,
892 .framebuffer = fb,
893 .renderArea = {
894 .offset = { dest_offset.x, dest_offset.y },
895 .extent = { dest_extent.width, dest_extent.height },
896 },
897 .clearValueCount = 0,
898 .pClearValues = NULL,
899 }, VK_RENDER_PASS_CONTENTS_INLINE);
900
901 VkPipeline pipeline;
902
903 switch (src_image->type) {
904 case VK_IMAGE_TYPE_1D:
905 anv_finishme("VK_IMAGE_TYPE_1D");
906 pipeline = device->meta_state.blit.pipeline_2d_src;
907 break;
908 case VK_IMAGE_TYPE_2D:
909 pipeline = device->meta_state.blit.pipeline_2d_src;
910 break;
911 case VK_IMAGE_TYPE_3D:
912 pipeline = device->meta_state.blit.pipeline_3d_src;
913 break;
914 default:
915 unreachable(!"bad VkImageType");
916 }
917
918 if (cmd_buffer->state.pipeline != anv_pipeline_from_handle(pipeline)) {
919 anv_CmdBindPipeline(anv_cmd_buffer_to_handle(cmd_buffer),
920 VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
921 }
922
923 anv_CmdBindDynamicViewportState(anv_cmd_buffer_to_handle(cmd_buffer),
924 anv_framebuffer_from_handle(fb)->vp_state);
925
926 anv_CmdBindDescriptorSets(anv_cmd_buffer_to_handle(cmd_buffer),
927 VK_PIPELINE_BIND_POINT_GRAPHICS,
928 device->meta_state.blit.pipeline_layout, 0, 1,
929 &set, 0, NULL);
930
931 ANV_CALL(CmdDraw)(anv_cmd_buffer_to_handle(cmd_buffer), 3, 1, 0, 0);
932
933 ANV_CALL(CmdEndRenderPass)(anv_cmd_buffer_to_handle(cmd_buffer));
934
935 /* At the point where we emit the draw call, all data from the
936 * descriptor sets, etc. has been used. We are free to delete it.
937 */
938 anv_descriptor_set_destroy(device, anv_descriptor_set_from_handle(set));
939 anv_DestroyFramebuffer(anv_device_to_handle(device), fb);
940 anv_DestroyRenderPass(anv_device_to_handle(device), pass);
941 }
942
943 static void
944 meta_finish_blit(struct anv_cmd_buffer *cmd_buffer,
945 const struct anv_saved_state *saved_state)
946 {
947 anv_cmd_buffer_restore(cmd_buffer, saved_state);
948 }
949
950 static VkFormat
951 vk_format_for_cpp(int cpp)
952 {
953 switch (cpp) {
954 case 1: return VK_FORMAT_R8_UINT;
955 case 2: return VK_FORMAT_R8G8_UINT;
956 case 3: return VK_FORMAT_R8G8B8_UINT;
957 case 4: return VK_FORMAT_R8G8B8A8_UINT;
958 case 6: return VK_FORMAT_R16G16B16_UINT;
959 case 8: return VK_FORMAT_R16G16B16A16_UINT;
960 case 12: return VK_FORMAT_R32G32B32_UINT;
961 case 16: return VK_FORMAT_R32G32B32A32_UINT;
962 default:
963 unreachable("Invalid format cpp");
964 }
965 }
966
967 static void
968 do_buffer_copy(struct anv_cmd_buffer *cmd_buffer,
969 struct anv_bo *src, uint64_t src_offset,
970 struct anv_bo *dest, uint64_t dest_offset,
971 int width, int height, VkFormat copy_format)
972 {
973 VkDevice vk_device = anv_device_to_handle(cmd_buffer->device);
974
975 VkImageCreateInfo image_info = {
976 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
977 .imageType = VK_IMAGE_TYPE_2D,
978 .format = copy_format,
979 .extent = {
980 .width = width,
981 .height = height,
982 .depth = 1,
983 },
984 .mipLevels = 1,
985 .arraySize = 1,
986 .samples = 1,
987 .tiling = VK_IMAGE_TILING_LINEAR,
988 .usage = VK_IMAGE_USAGE_SAMPLED_BIT,
989 .flags = 0,
990 };
991
992 VkImage src_image, dest_image;
993 anv_CreateImage(vk_device, &image_info, &src_image);
994 anv_CreateImage(vk_device, &image_info, &dest_image);
995
996 /* We could use a vk call to bind memory, but that would require
997 * creating a dummy memory object etc. so there's really no point.
998 */
999 anv_image_from_handle(src_image)->bo = src;
1000 anv_image_from_handle(src_image)->offset = src_offset;
1001 anv_image_from_handle(dest_image)->bo = dest;
1002 anv_image_from_handle(dest_image)->offset = dest_offset;
1003
1004 struct anv_image_view src_iview;
1005 anv_image_view_init(&src_iview, cmd_buffer->device,
1006 &(VkImageViewCreateInfo) {
1007 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1008 .image = src_image,
1009 .viewType = VK_IMAGE_VIEW_TYPE_2D,
1010 .format = copy_format,
1011 .channels = {
1012 VK_CHANNEL_SWIZZLE_R,
1013 VK_CHANNEL_SWIZZLE_G,
1014 VK_CHANNEL_SWIZZLE_B,
1015 VK_CHANNEL_SWIZZLE_A
1016 },
1017 .subresourceRange = {
1018 .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
1019 .baseMipLevel = 0,
1020 .mipLevels = 1,
1021 .baseArraySlice = 0,
1022 .arraySize = 1
1023 },
1024 },
1025 cmd_buffer);
1026
1027 struct anv_image_view dest_iview;
1028 anv_color_attachment_view_init(&dest_iview, cmd_buffer->device,
1029 &(VkAttachmentViewCreateInfo) {
1030 .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO,
1031 .image = dest_image,
1032 .format = copy_format,
1033 .mipLevel = 0,
1034 .baseArraySlice = 0,
1035 .arraySize = 1,
1036 },
1037 cmd_buffer);
1038
1039 meta_emit_blit(cmd_buffer,
1040 anv_image_from_handle(src_image),
1041 &src_iview,
1042 (VkOffset3D) { 0, 0, 0 },
1043 (VkExtent3D) { width, height, 1 },
1044 anv_image_from_handle(dest_image),
1045 &dest_iview,
1046 (VkOffset3D) { 0, 0, 0 },
1047 (VkExtent3D) { width, height, 1 });
1048
1049 anv_DestroyImage(vk_device, src_image);
1050 anv_DestroyImage(vk_device, dest_image);
1051 }
1052
1053 void anv_CmdCopyBuffer(
1054 VkCmdBuffer cmdBuffer,
1055 VkBuffer srcBuffer,
1056 VkBuffer destBuffer,
1057 uint32_t regionCount,
1058 const VkBufferCopy* pRegions)
1059 {
1060 ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer);
1061 ANV_FROM_HANDLE(anv_buffer, src_buffer, srcBuffer);
1062 ANV_FROM_HANDLE(anv_buffer, dest_buffer, destBuffer);
1063
1064 struct anv_saved_state saved_state;
1065
1066 meta_prepare_blit(cmd_buffer, &saved_state);
1067
1068 for (unsigned r = 0; r < regionCount; r++) {
1069 uint64_t src_offset = src_buffer->offset + pRegions[r].srcOffset;
1070 uint64_t dest_offset = dest_buffer->offset + pRegions[r].destOffset;
1071 uint64_t copy_size = pRegions[r].copySize;
1072
1073 /* First, we compute the biggest format that can be used with the
1074 * given offsets and size.
1075 */
1076 int cpp = 16;
1077
1078 int fs = ffs(src_offset) - 1;
1079 if (fs != -1)
1080 cpp = MIN2(cpp, 1 << fs);
1081 assert(src_offset % cpp == 0);
1082
1083 fs = ffs(dest_offset) - 1;
1084 if (fs != -1)
1085 cpp = MIN2(cpp, 1 << fs);
1086 assert(dest_offset % cpp == 0);
1087
1088 fs = ffs(pRegions[r].copySize) - 1;
1089 if (fs != -1)
1090 cpp = MIN2(cpp, 1 << fs);
1091 assert(pRegions[r].copySize % cpp == 0);
1092
1093 VkFormat copy_format = vk_format_for_cpp(cpp);
1094
1095 /* This is maximum possible width/height our HW can handle */
1096 uint64_t max_surface_dim = 1 << 14;
1097
1098 /* First, we make a bunch of max-sized copies */
1099 uint64_t max_copy_size = max_surface_dim * max_surface_dim * cpp;
1100 while (copy_size > max_copy_size) {
1101 do_buffer_copy(cmd_buffer, src_buffer->bo, src_offset,
1102 dest_buffer->bo, dest_offset,
1103 max_surface_dim, max_surface_dim, copy_format);
1104 copy_size -= max_copy_size;
1105 src_offset += max_copy_size;
1106 dest_offset += max_copy_size;
1107 }
1108
1109 uint64_t height = copy_size / (max_surface_dim * cpp);
1110 assert(height < max_surface_dim);
1111 if (height != 0) {
1112 uint64_t rect_copy_size = height * max_surface_dim * cpp;
1113 do_buffer_copy(cmd_buffer, src_buffer->bo, src_offset,
1114 dest_buffer->bo, dest_offset,
1115 max_surface_dim, height, copy_format);
1116 copy_size -= rect_copy_size;
1117 src_offset += rect_copy_size;
1118 dest_offset += rect_copy_size;
1119 }
1120
1121 if (copy_size != 0) {
1122 do_buffer_copy(cmd_buffer, src_buffer->bo, src_offset,
1123 dest_buffer->bo, dest_offset,
1124 copy_size / cpp, 1, copy_format);
1125 }
1126 }
1127
1128 meta_finish_blit(cmd_buffer, &saved_state);
1129 }
1130
1131 void anv_CmdCopyImage(
1132 VkCmdBuffer cmdBuffer,
1133 VkImage srcImage,
1134 VkImageLayout srcImageLayout,
1135 VkImage destImage,
1136 VkImageLayout destImageLayout,
1137 uint32_t regionCount,
1138 const VkImageCopy* pRegions)
1139 {
1140 ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer);
1141 ANV_FROM_HANDLE(anv_image, src_image, srcImage);
1142 ANV_FROM_HANDLE(anv_image, dest_image, destImage);
1143
1144 const VkImageViewType src_iview_type =
1145 meta_blit_get_src_image_view_type(src_image);
1146
1147 struct anv_saved_state saved_state;
1148
1149 meta_prepare_blit(cmd_buffer, &saved_state);
1150
1151 for (unsigned r = 0; r < regionCount; r++) {
1152 struct anv_image_view src_iview;
1153 anv_image_view_init(&src_iview, cmd_buffer->device,
1154 &(VkImageViewCreateInfo) {
1155 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1156 .image = srcImage,
1157 .viewType = src_iview_type,
1158 .format = src_image->format->vk_format,
1159 .channels = {
1160 VK_CHANNEL_SWIZZLE_R,
1161 VK_CHANNEL_SWIZZLE_G,
1162 VK_CHANNEL_SWIZZLE_B,
1163 VK_CHANNEL_SWIZZLE_A
1164 },
1165 .subresourceRange = {
1166 .aspectMask = 1 << pRegions[r].srcSubresource.aspect,
1167 .baseMipLevel = pRegions[r].srcSubresource.mipLevel,
1168 .mipLevels = 1,
1169 .baseArraySlice = pRegions[r].srcSubresource.arrayLayer,
1170 .arraySize = 1
1171 },
1172 },
1173 cmd_buffer);
1174
1175 const VkOffset3D dest_offset = {
1176 .x = pRegions[r].destOffset.x,
1177 .y = pRegions[r].destOffset.y,
1178 .z = 0,
1179 };
1180
1181 const uint32_t dest_array_slice =
1182 meta_blit_get_dest_view_base_array_slice(dest_image,
1183 &pRegions[r].destSubresource,
1184 &pRegions[r].destOffset);
1185
1186 if (pRegions[r].srcSubresource.arraySize > 1)
1187 anv_finishme("FINISHME: copy multiple array layers");
1188
1189 if (pRegions[r].extent.depth > 1)
1190 anv_finishme("FINISHME: copy multiple depth layers");
1191
1192 struct anv_image_view dest_iview;
1193 anv_color_attachment_view_init(&dest_iview, cmd_buffer->device,
1194 &(VkAttachmentViewCreateInfo) {
1195 .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO,
1196 .image = destImage,
1197 .format = dest_image->format->vk_format,
1198 .mipLevel = pRegions[r].destSubresource.mipLevel,
1199 .baseArraySlice = dest_array_slice,
1200 .arraySize = 1,
1201 },
1202 cmd_buffer);
1203
1204 meta_emit_blit(cmd_buffer,
1205 src_image, &src_iview,
1206 pRegions[r].srcOffset,
1207 pRegions[r].extent,
1208 dest_image, &dest_iview,
1209 dest_offset,
1210 pRegions[r].extent);
1211 }
1212
1213 meta_finish_blit(cmd_buffer, &saved_state);
1214 }
1215
1216 void anv_CmdBlitImage(
1217 VkCmdBuffer cmdBuffer,
1218 VkImage srcImage,
1219 VkImageLayout srcImageLayout,
1220 VkImage destImage,
1221 VkImageLayout destImageLayout,
1222 uint32_t regionCount,
1223 const VkImageBlit* pRegions,
1224 VkTexFilter filter)
1225
1226 {
1227 ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer);
1228 ANV_FROM_HANDLE(anv_image, src_image, srcImage);
1229 ANV_FROM_HANDLE(anv_image, dest_image, destImage);
1230
1231 const VkImageViewType src_iview_type =
1232 meta_blit_get_src_image_view_type(src_image);
1233
1234 struct anv_saved_state saved_state;
1235
1236 anv_finishme("respect VkTexFilter");
1237
1238 meta_prepare_blit(cmd_buffer, &saved_state);
1239
1240 for (unsigned r = 0; r < regionCount; r++) {
1241 struct anv_image_view src_iview;
1242 anv_image_view_init(&src_iview, cmd_buffer->device,
1243 &(VkImageViewCreateInfo) {
1244 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1245 .image = srcImage,
1246 .viewType = src_iview_type,
1247 .format = src_image->format->vk_format,
1248 .channels = {
1249 VK_CHANNEL_SWIZZLE_R,
1250 VK_CHANNEL_SWIZZLE_G,
1251 VK_CHANNEL_SWIZZLE_B,
1252 VK_CHANNEL_SWIZZLE_A
1253 },
1254 .subresourceRange = {
1255 .aspectMask = 1 << pRegions[r].srcSubresource.aspect,
1256 .baseMipLevel = pRegions[r].srcSubresource.mipLevel,
1257 .mipLevels = 1,
1258 .baseArraySlice = pRegions[r].srcSubresource.arrayLayer,
1259 .arraySize = 1
1260 },
1261 },
1262 cmd_buffer);
1263
1264 const VkOffset3D dest_offset = {
1265 .x = pRegions[r].destOffset.x,
1266 .y = pRegions[r].destOffset.y,
1267 .z = 0,
1268 };
1269
1270 const uint32_t dest_array_slice =
1271 meta_blit_get_dest_view_base_array_slice(dest_image,
1272 &pRegions[r].destSubresource,
1273 &pRegions[r].destOffset);
1274
1275 if (pRegions[r].srcSubresource.arraySize > 1)
1276 anv_finishme("FINISHME: copy multiple array layers");
1277
1278 if (pRegions[r].destExtent.depth > 1)
1279 anv_finishme("FINISHME: copy multiple depth layers");
1280
1281 struct anv_image_view dest_iview;
1282 anv_color_attachment_view_init(&dest_iview, cmd_buffer->device,
1283 &(VkAttachmentViewCreateInfo) {
1284 .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO,
1285 .image = destImage,
1286 .format = dest_image->format->vk_format,
1287 .mipLevel = pRegions[r].destSubresource.mipLevel,
1288 .baseArraySlice = dest_array_slice,
1289 .arraySize = 1,
1290 },
1291 cmd_buffer);
1292
1293 meta_emit_blit(cmd_buffer,
1294 src_image, &src_iview,
1295 pRegions[r].srcOffset,
1296 pRegions[r].srcExtent,
1297 dest_image, &dest_iview,
1298 dest_offset,
1299 pRegions[r].destExtent);
1300 }
1301
1302 meta_finish_blit(cmd_buffer, &saved_state);
1303 }
1304
1305 static VkImage
1306 make_image_for_buffer(VkDevice vk_device, VkBuffer vk_buffer, VkFormat format,
1307 const VkBufferImageCopy *copy)
1308 {
1309 ANV_FROM_HANDLE(anv_buffer, buffer, vk_buffer);
1310
1311 VkExtent3D extent = copy->imageExtent;
1312 if (copy->bufferRowLength)
1313 extent.width = copy->bufferRowLength;
1314 if (copy->bufferImageHeight)
1315 extent.height = copy->bufferImageHeight;
1316 extent.depth = 1;
1317
1318 VkImage vk_image;
1319 VkResult result = anv_CreateImage(vk_device,
1320 &(VkImageCreateInfo) {
1321 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
1322 .imageType = VK_IMAGE_TYPE_2D,
1323 .format = format,
1324 .extent = extent,
1325 .mipLevels = 1,
1326 .arraySize = 1,
1327 .samples = 1,
1328 .tiling = VK_IMAGE_TILING_LINEAR,
1329 .usage = VK_IMAGE_USAGE_SAMPLED_BIT,
1330 .flags = 0,
1331 }, &vk_image);
1332 assert(result == VK_SUCCESS);
1333
1334 ANV_FROM_HANDLE(anv_image, image, vk_image);
1335
1336 /* We could use a vk call to bind memory, but that would require
1337 * creating a dummy memory object etc. so there's really no point.
1338 */
1339 image->bo = buffer->bo;
1340 image->offset = buffer->offset + copy->bufferOffset;
1341
1342 return anv_image_to_handle(image);
1343 }
1344
1345 void anv_CmdCopyBufferToImage(
1346 VkCmdBuffer cmdBuffer,
1347 VkBuffer srcBuffer,
1348 VkImage destImage,
1349 VkImageLayout destImageLayout,
1350 uint32_t regionCount,
1351 const VkBufferImageCopy* pRegions)
1352 {
1353 ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer);
1354 ANV_FROM_HANDLE(anv_image, dest_image, destImage);
1355 VkDevice vk_device = anv_device_to_handle(cmd_buffer->device);
1356 const VkFormat orig_format = dest_image->format->vk_format;
1357 struct anv_saved_state saved_state;
1358
1359 meta_prepare_blit(cmd_buffer, &saved_state);
1360
1361 for (unsigned r = 0; r < regionCount; r++) {
1362 VkFormat proxy_format = orig_format;
1363 VkImageAspect proxy_aspect = pRegions[r].imageSubresource.aspect;
1364
1365 if (orig_format == VK_FORMAT_S8_UINT) {
1366 proxy_format = VK_FORMAT_R8_UINT;
1367 proxy_aspect = VK_IMAGE_ASPECT_COLOR;
1368 }
1369
1370 VkImage srcImage = make_image_for_buffer(vk_device, srcBuffer,
1371 proxy_format,
1372 &pRegions[r]);
1373
1374 struct anv_image_view src_iview;
1375 anv_image_view_init(&src_iview, cmd_buffer->device,
1376 &(VkImageViewCreateInfo) {
1377 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1378 .image = srcImage,
1379 .viewType = VK_IMAGE_VIEW_TYPE_2D,
1380 .format = proxy_format,
1381 .channels = {
1382 VK_CHANNEL_SWIZZLE_R,
1383 VK_CHANNEL_SWIZZLE_G,
1384 VK_CHANNEL_SWIZZLE_B,
1385 VK_CHANNEL_SWIZZLE_A
1386 },
1387 .subresourceRange = {
1388 .aspectMask = 1 << proxy_aspect,
1389 .baseMipLevel = 0,
1390 .mipLevels = 1,
1391 .baseArraySlice = 0,
1392 .arraySize = 1
1393 },
1394 },
1395 cmd_buffer);
1396
1397 const VkOffset3D dest_offset = {
1398 .x = pRegions[r].imageOffset.x,
1399 .y = pRegions[r].imageOffset.y,
1400 .z = 0,
1401 };
1402
1403 const uint32_t dest_array_slice =
1404 meta_blit_get_dest_view_base_array_slice(dest_image,
1405 &pRegions[r].imageSubresource,
1406 &pRegions[r].imageOffset);
1407
1408 if (pRegions[r].imageExtent.depth > 1)
1409 anv_finishme("FINISHME: copy multiple depth layers");
1410
1411 struct anv_image_view dest_iview;
1412 anv_color_attachment_view_init(&dest_iview, cmd_buffer->device,
1413 &(VkAttachmentViewCreateInfo) {
1414 .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO,
1415 .image = anv_image_to_handle(dest_image),
1416 .format = proxy_format,
1417 .mipLevel = pRegions[r].imageSubresource.mipLevel,
1418 .baseArraySlice = dest_array_slice,
1419 .arraySize = 1,
1420 },
1421 cmd_buffer);
1422
1423 meta_emit_blit(cmd_buffer,
1424 anv_image_from_handle(srcImage),
1425 &src_iview,
1426 (VkOffset3D) { 0, 0, 0 },
1427 pRegions[r].imageExtent,
1428 dest_image,
1429 &dest_iview,
1430 dest_offset,
1431 pRegions[r].imageExtent);
1432
1433 anv_DestroyImage(vk_device, srcImage);
1434 }
1435
1436 meta_finish_blit(cmd_buffer, &saved_state);
1437 }
1438
1439 void anv_CmdCopyImageToBuffer(
1440 VkCmdBuffer cmdBuffer,
1441 VkImage srcImage,
1442 VkImageLayout srcImageLayout,
1443 VkBuffer destBuffer,
1444 uint32_t regionCount,
1445 const VkBufferImageCopy* pRegions)
1446 {
1447 ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer);
1448 ANV_FROM_HANDLE(anv_image, src_image, srcImage);
1449 VkDevice vk_device = anv_device_to_handle(cmd_buffer->device);
1450 struct anv_saved_state saved_state;
1451
1452 const VkImageViewType src_iview_type =
1453 meta_blit_get_src_image_view_type(src_image);
1454
1455 meta_prepare_blit(cmd_buffer, &saved_state);
1456
1457 for (unsigned r = 0; r < regionCount; r++) {
1458 if (pRegions[r].imageSubresource.arraySize > 1)
1459 anv_finishme("FINISHME: copy multiple array layers");
1460
1461 if (pRegions[r].imageExtent.depth > 1)
1462 anv_finishme("FINISHME: copy multiple depth layers");
1463
1464 struct anv_image_view src_iview;
1465 anv_image_view_init(&src_iview, cmd_buffer->device,
1466 &(VkImageViewCreateInfo) {
1467 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1468 .image = srcImage,
1469 .viewType = src_iview_type,
1470 .format = src_image->format->vk_format,
1471 .channels = {
1472 VK_CHANNEL_SWIZZLE_R,
1473 VK_CHANNEL_SWIZZLE_G,
1474 VK_CHANNEL_SWIZZLE_B,
1475 VK_CHANNEL_SWIZZLE_A
1476 },
1477 .subresourceRange = {
1478 .aspectMask = 1 << pRegions[r].imageSubresource.aspect,
1479 .baseMipLevel = pRegions[r].imageSubresource.mipLevel,
1480 .mipLevels = 1,
1481 .baseArraySlice = pRegions[r].imageSubresource.arrayLayer,
1482 .arraySize = 1
1483 },
1484 },
1485 cmd_buffer);
1486
1487 VkFormat dest_format = src_image->format->vk_format;
1488 if (dest_format == VK_FORMAT_S8_UINT) {
1489 dest_format = VK_FORMAT_R8_UINT;
1490 }
1491
1492 VkImage destImage = make_image_for_buffer(vk_device, destBuffer,
1493 dest_format,
1494 &pRegions[r]);
1495
1496 struct anv_image_view dest_iview;
1497 anv_color_attachment_view_init(&dest_iview, cmd_buffer->device,
1498 &(VkAttachmentViewCreateInfo) {
1499 .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO,
1500 .image = destImage,
1501 .format = dest_format,
1502 .mipLevel = 0,
1503 .baseArraySlice = 0,
1504 .arraySize = 1,
1505 },
1506 cmd_buffer);
1507
1508 meta_emit_blit(cmd_buffer,
1509 anv_image_from_handle(srcImage),
1510 &src_iview,
1511 pRegions[r].imageOffset,
1512 pRegions[r].imageExtent,
1513 anv_image_from_handle(destImage),
1514 &dest_iview,
1515 (VkOffset3D) { 0, 0, 0 },
1516 pRegions[r].imageExtent);
1517
1518 anv_DestroyImage(vk_device, destImage);
1519 }
1520
1521 meta_finish_blit(cmd_buffer, &saved_state);
1522 }
1523
1524 void anv_CmdUpdateBuffer(
1525 VkCmdBuffer cmdBuffer,
1526 VkBuffer destBuffer,
1527 VkDeviceSize destOffset,
1528 VkDeviceSize dataSize,
1529 const uint32_t* pData)
1530 {
1531 stub();
1532 }
1533
1534 void anv_CmdFillBuffer(
1535 VkCmdBuffer cmdBuffer,
1536 VkBuffer destBuffer,
1537 VkDeviceSize destOffset,
1538 VkDeviceSize fillSize,
1539 uint32_t data)
1540 {
1541 stub();
1542 }
1543
1544 void anv_CmdClearColorImage(
1545 VkCmdBuffer cmdBuffer,
1546 VkImage _image,
1547 VkImageLayout imageLayout,
1548 const VkClearColorValue* pColor,
1549 uint32_t rangeCount,
1550 const VkImageSubresourceRange* pRanges)
1551 {
1552 ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer);
1553 ANV_FROM_HANDLE(anv_image, image, _image);
1554 struct anv_saved_state saved_state;
1555
1556 anv_cmd_buffer_save(cmd_buffer, &saved_state);
1557
1558 for (uint32_t r = 0; r < rangeCount; r++) {
1559 for (uint32_t l = 0; l < pRanges[r].mipLevels; l++) {
1560 for (uint32_t s = 0; s < pRanges[r].arraySize; s++) {
1561 struct anv_image_view iview;
1562 anv_color_attachment_view_init(&iview, cmd_buffer->device,
1563 &(VkAttachmentViewCreateInfo) {
1564 .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO,
1565 .image = _image,
1566 .format = image->format->vk_format,
1567 .mipLevel = pRanges[r].baseMipLevel + l,
1568 .baseArraySlice = pRanges[r].baseArraySlice + s,
1569 .arraySize = 1,
1570 },
1571 cmd_buffer);
1572
1573 VkImageView iview_h = anv_image_view_to_handle(&iview);
1574 VkAttachmentView aview_h = { .handle = iview_h.handle };
1575
1576 VkFramebuffer fb;
1577 anv_CreateFramebuffer(anv_device_to_handle(cmd_buffer->device),
1578 &(VkFramebufferCreateInfo) {
1579 .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
1580 .attachmentCount = 1,
1581 .pAttachments = (VkAttachmentBindInfo[]) {
1582 {
1583 .view = aview_h,
1584 .layout = VK_IMAGE_LAYOUT_GENERAL
1585 }
1586 },
1587 .width = iview.extent.width,
1588 .height = iview.extent.height,
1589 .layers = 1
1590 }, &fb);
1591
1592 VkRenderPass pass;
1593 anv_CreateRenderPass(anv_device_to_handle(cmd_buffer->device),
1594 &(VkRenderPassCreateInfo) {
1595 .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
1596 .attachmentCount = 1,
1597 .pAttachments = &(VkAttachmentDescription) {
1598 .sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION,
1599 .format = iview.format->vk_format,
1600 .loadOp = VK_ATTACHMENT_LOAD_OP_LOAD,
1601 .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
1602 .initialLayout = VK_IMAGE_LAYOUT_GENERAL,
1603 .finalLayout = VK_IMAGE_LAYOUT_GENERAL,
1604 },
1605 .subpassCount = 1,
1606 .pSubpasses = &(VkSubpassDescription) {
1607 .sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION,
1608 .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
1609 .inputCount = 0,
1610 .colorCount = 1,
1611 .pColorAttachments = &(VkAttachmentReference) {
1612 .attachment = 0,
1613 .layout = VK_IMAGE_LAYOUT_GENERAL,
1614 },
1615 .pResolveAttachments = NULL,
1616 .depthStencilAttachment = (VkAttachmentReference) {
1617 .attachment = VK_ATTACHMENT_UNUSED,
1618 .layout = VK_IMAGE_LAYOUT_GENERAL,
1619 },
1620 .preserveCount = 1,
1621 .pPreserveAttachments = &(VkAttachmentReference) {
1622 .attachment = 0,
1623 .layout = VK_IMAGE_LAYOUT_GENERAL,
1624 },
1625 },
1626 .dependencyCount = 0,
1627 }, &pass);
1628
1629 ANV_CALL(CmdBeginRenderPass)(anv_cmd_buffer_to_handle(cmd_buffer),
1630 &(VkRenderPassBeginInfo) {
1631 .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
1632 .renderArea = {
1633 .offset = { 0, 0, },
1634 .extent = {
1635 .width = iview.extent.width,
1636 .height = iview.extent.height,
1637 },
1638 },
1639 .renderPass = pass,
1640 .framebuffer = fb,
1641 .clearValueCount = 1,
1642 .pClearValues = NULL,
1643 }, VK_RENDER_PASS_CONTENTS_INLINE);
1644
1645 struct clear_instance_data instance_data = {
1646 .vue_header = {
1647 .RTAIndex = 0,
1648 .ViewportIndex = 0,
1649 .PointWidth = 0.0
1650 },
1651 .color = *pColor,
1652 };
1653
1654 meta_emit_clear(cmd_buffer, 1, &instance_data,
1655 (VkClearDepthStencilValue) {0});
1656
1657 ANV_CALL(CmdEndRenderPass)(anv_cmd_buffer_to_handle(cmd_buffer));
1658 }
1659 }
1660 }
1661
1662 /* Restore API state */
1663 anv_cmd_buffer_restore(cmd_buffer, &saved_state);
1664 }
1665
1666 void anv_CmdClearDepthStencilImage(
1667 VkCmdBuffer cmdBuffer,
1668 VkImage image,
1669 VkImageLayout imageLayout,
1670 const VkClearDepthStencilValue* pDepthStencil,
1671 uint32_t rangeCount,
1672 const VkImageSubresourceRange* pRanges)
1673 {
1674 stub();
1675 }
1676
1677 void anv_CmdClearColorAttachment(
1678 VkCmdBuffer cmdBuffer,
1679 uint32_t colorAttachment,
1680 VkImageLayout imageLayout,
1681 const VkClearColorValue* pColor,
1682 uint32_t rectCount,
1683 const VkRect3D* pRects)
1684 {
1685 stub();
1686 }
1687
1688 void anv_CmdClearDepthStencilAttachment(
1689 VkCmdBuffer cmdBuffer,
1690 VkImageAspectFlags aspectMask,
1691 VkImageLayout imageLayout,
1692 const VkClearDepthStencilValue* pDepthStencil,
1693 uint32_t rectCount,
1694 const VkRect3D* pRects)
1695 {
1696 stub();
1697 }
1698
1699 void anv_CmdResolveImage(
1700 VkCmdBuffer cmdBuffer,
1701 VkImage srcImage,
1702 VkImageLayout srcImageLayout,
1703 VkImage destImage,
1704 VkImageLayout destImageLayout,
1705 uint32_t regionCount,
1706 const VkImageResolve* pRegions)
1707 {
1708 stub();
1709 }
1710
1711 void
1712 anv_device_init_meta(struct anv_device *device)
1713 {
1714 anv_device_init_meta_clear_state(device);
1715 anv_device_init_meta_blit_state(device);
1716
1717 ANV_CALL(CreateDynamicRasterState)(anv_device_to_handle(device),
1718 &(VkDynamicRasterStateCreateInfo) {
1719 .sType = VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO,
1720 },
1721 &device->meta_state.shared.rs_state);
1722
1723 ANV_CALL(CreateDynamicColorBlendState)(anv_device_to_handle(device),
1724 &(VkDynamicColorBlendStateCreateInfo) {
1725 .sType = VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO
1726 },
1727 &device->meta_state.shared.cb_state);
1728
1729 ANV_CALL(CreateDynamicDepthStencilState)(anv_device_to_handle(device),
1730 &(VkDynamicDepthStencilStateCreateInfo) {
1731 .sType = VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO
1732 },
1733 &device->meta_state.shared.ds_state);
1734 }
1735
1736 void
1737 anv_device_finish_meta(struct anv_device *device)
1738 {
1739 /* Clear */
1740 anv_DestroyPipeline(anv_device_to_handle(device),
1741 device->meta_state.clear.pipeline);
1742
1743 /* Blit */
1744 anv_DestroyPipeline(anv_device_to_handle(device),
1745 device->meta_state.blit.pipeline_2d_src);
1746 anv_DestroyPipeline(anv_device_to_handle(device),
1747 device->meta_state.blit.pipeline_3d_src);
1748 anv_DestroyPipelineLayout(anv_device_to_handle(device),
1749 device->meta_state.blit.pipeline_layout);
1750 anv_DestroyDescriptorSetLayout(anv_device_to_handle(device),
1751 device->meta_state.blit.ds_layout);
1752
1753 /* Shared */
1754 anv_DestroyDynamicRasterState(anv_device_to_handle(device),
1755 device->meta_state.shared.rs_state);
1756 anv_DestroyDynamicColorBlendState(anv_device_to_handle(device),
1757 device->meta_state.shared.cb_state);
1758 anv_DestroyDynamicDepthStencilState(anv_device_to_handle(device),
1759 device->meta_state.shared.ds_state);
1760 }