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