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