src/vulkan/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 "private.h"
  31 #include "meta-spirv.h"
  32
  33 static void
  34 anv_device_init_meta_clear_state(struct anv_device *device)
  35 {
  36    VkPipelineIaStateCreateInfo ia_create_info = {
  37       .sType = VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO,
  38       .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
  39       .primitiveRestartEnable = false,
  40    };
  41
  42    /* We don't use a vertex shader for clearing, but instead build and pass
  43     * the VUEs directly to the rasterization backend.
  44     */
  45    VkShader fs = GLSL_VK_SHADER(device, FRAGMENT,
  46       out vec4 f_color;
  47       flat in vec4 v_color;
  48       void main()
  49       {
  50          f_color = v_color;
  51       }
  52    );
  53
  54    VkPipelineShaderStageCreateInfo fs_create_info = {
  55       .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
  56       .pNext = &ia_create_info,
  57       .shader = {
  58          .stage = VK_SHADER_STAGE_FRAGMENT,
  59          .shader = fs,
  60          .linkConstBufferCount = 0,
  61          .pLinkConstBufferInfo = NULL,
  62          .pSpecializationInfo = NULL
  63       }
  64    };
  65
  66    /* We use instanced rendering to clear multiple render targets. We have two
  67     * vertex buffers: the first vertex buffer holds per-vertex data and
  68     * provides the vertices for the clear rectangle. The second one holds
  69     * per-instance data, which consists of the VUE header (which selects the
  70     * layer) and the color (Vulkan supports per-RT clear colors).
  71     */
  72    VkPipelineVertexInputStateCreateInfo vi_create_info = {
  73       .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
  74       .pNext = &fs_create_info,
  75       .bindingCount = 2,
  76       .pVertexBindingDescriptions = (VkVertexInputBindingDescription[]) {
  77          {
  78             .binding = 0,
  79             .strideInBytes = 8,
  80             .stepRate = VK_VERTEX_INPUT_STEP_RATE_VERTEX
  81          },
  82          {
  83             .binding = 1,
  84             .strideInBytes = 32,
  85             .stepRate = VK_VERTEX_INPUT_STEP_RATE_INSTANCE
  86          },
  87       },
  88       .attributeCount = 3,
  89       .pVertexAttributeDescriptions = (VkVertexInputAttributeDescription[]) {
  90          {
  91             /* VUE Header */
  92             .location = 0,
  93             .binding = 1,
  94             .format = VK_FORMAT_R32G32B32A32_UINT,
  95             .offsetInBytes = 0
  96          },
  97          {
  98             /* Position */
  99             .location = 1,
 100             .binding = 0,
 101             .format = VK_FORMAT_R32G32_SFLOAT,
 102             .offsetInBytes = 0
 103          },
 104          {
 105             /* Color */
 106             .location = 2,
 107             .binding = 1,
 108             .format = VK_FORMAT_R32G32B32A32_SFLOAT,
 109             .offsetInBytes = 16
 110          }
 111       }
 112    };
 113
 114    VkPipelineRsStateCreateInfo rs_create_info = {
 115       .sType = VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO,
 116       .pNext = &vi_create_info,
 117       .depthClipEnable = true,
 118       .rasterizerDiscardEnable = false,
 119       .fillMode = VK_FILL_MODE_SOLID,
 120       .cullMode = VK_CULL_MODE_NONE,
 121       .frontFace = VK_FRONT_FACE_CCW
 122    };
 123
 124    VkPipelineCbStateCreateInfo cb_create_info = {
 125       .sType = VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO,
 126       .pNext = &rs_create_info,
 127       .attachmentCount = 1,
 128       .pAttachments = (VkPipelineCbAttachmentState []) {
 129          { .channelWriteMask = VK_CHANNEL_A_BIT |
 130               VK_CHANNEL_R_BIT | VK_CHANNEL_G_BIT | VK_CHANNEL_B_BIT },
 131       }
 132    };
 133
 134    anv_pipeline_create((VkDevice) device,
 135       &(VkGraphicsPipelineCreateInfo) {
 136          .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
 137          .pNext = &cb_create_info,
 138          .flags = 0,
 139          .layout = 0
 140       },
 141       &(struct anv_pipeline_create_info) {
 142          .use_repclear = true,
 143          .disable_viewport = true,
 144          .use_rectlist = true
 145       },
 146       &device->meta_state.clear.pipeline);
 147
 148    anv_DestroyObject((VkDevice) device, VK_OBJECT_TYPE_SHADER, fs);
 149 }
 150
 151 #define NUM_VB_USED 2
 152 struct anv_saved_state {
 153    struct anv_vertex_binding old_vertex_bindings[NUM_VB_USED];
 154    struct anv_descriptor_set *old_descriptor_set0;
 155    struct anv_pipeline *old_pipeline;
 156    VkDynamicCbState cb_state;
 157 };
 158
 159 static void
 160 anv_cmd_buffer_save(struct anv_cmd_buffer *cmd_buffer,
 161                     struct anv_saved_state *state)
 162 {
 163    state->old_pipeline = cmd_buffer->pipeline;
 164    state->old_descriptor_set0 = cmd_buffer->descriptors[0].set;
 165    memcpy(state->old_vertex_bindings, cmd_buffer->vertex_bindings,
 166           sizeof(state->old_vertex_bindings));
 167 }
 168
 169 static void
 170 anv_cmd_buffer_restore(struct anv_cmd_buffer *cmd_buffer,
 171                        const struct anv_saved_state *state)
 172 {
 173    cmd_buffer->pipeline = state->old_pipeline;
 174    cmd_buffer->descriptors[0].set = state->old_descriptor_set0;
 175    memcpy(cmd_buffer->vertex_bindings, state->old_vertex_bindings,
 176           sizeof(state->old_vertex_bindings));
 177
 178    cmd_buffer->vb_dirty |= (1 << NUM_VB_USED) - 1;
 179    cmd_buffer->dirty |= ANV_CMD_BUFFER_PIPELINE_DIRTY;
 180    cmd_buffer->descriptors_dirty |= VK_SHADER_STAGE_VERTEX_BIT;
 181 }
 182
 183 struct vue_header {
 184    uint32_t Reserved;
 185    uint32_t RTAIndex;
 186    uint32_t ViewportIndex;
 187    float PointWidth;
 188 };
 189
 190 struct clear_instance_data {
 191    struct vue_header vue_header;
 192    VkClearColorValue color;
 193 };
 194
 195 static void
 196 meta_emit_clear(struct anv_cmd_buffer *cmd_buffer,
 197                 int num_instances,
 198                 struct clear_instance_data *instance_data)
 199 {
 200    struct anv_device *device = cmd_buffer->device;
 201    struct anv_framebuffer *fb = cmd_buffer->framebuffer;
 202    struct anv_state state;
 203    uint32_t size;
 204
 205    const float vertex_data[] = {
 206       /* Rect-list coordinates */
 207             0.0,        0.0,
 208       fb->width,        0.0,
 209       fb->width, fb->height,
 210
 211       /* Align to 16 bytes */
 212             0.0,        0.0,
 213    };
 214
 215    size = sizeof(vertex_data) + num_instances * sizeof(*instance_data);
 216    state = anv_state_stream_alloc(&cmd_buffer->surface_state_stream, size, 16);
 217
 218    /* Copy in the vertex and instance data */
 219    memcpy(state.map, vertex_data, sizeof(vertex_data));
 220    memcpy(state.map + sizeof(vertex_data), instance_data,
 221           num_instances * sizeof(*instance_data));
 222
 223    struct anv_buffer vertex_buffer = {
 224       .device = cmd_buffer->device,
 225       .size = size,
 226       .bo = &device->surface_state_block_pool.bo,
 227       .offset = state.offset
 228    };
 229
 230    anv_CmdBindVertexBuffers((VkCmdBuffer) cmd_buffer, 0, 2,
 231       (VkBuffer[]) {
 232          (VkBuffer) &vertex_buffer,
 233          (VkBuffer) &vertex_buffer
 234       },
 235       (VkDeviceSize[]) {
 236          0,
 237          sizeof(vertex_data)
 238       });
 239
 240    if ((VkPipeline) cmd_buffer->pipeline != device->meta_state.clear.pipeline)
 241       anv_CmdBindPipeline((VkCmdBuffer) cmd_buffer,
 242                           VK_PIPELINE_BIND_POINT_GRAPHICS,
 243                           device->meta_state.clear.pipeline);
 244
 245    /* We don't need anything here, only set if not already set. */
 246    if (cmd_buffer->rs_state == NULL)
 247       anv_CmdBindDynamicStateObject((VkCmdBuffer) cmd_buffer,
 248                                     VK_STATE_BIND_POINT_RASTER,
 249                                     device->meta_state.shared.rs_state);
 250
 251    if (cmd_buffer->vp_state == NULL)
 252       anv_CmdBindDynamicStateObject((VkCmdBuffer) cmd_buffer,
 253                                     VK_STATE_BIND_POINT_VIEWPORT,
 254                                     cmd_buffer->framebuffer->vp_state);
 255
 256    if (cmd_buffer->ds_state == NULL)
 257       anv_CmdBindDynamicStateObject((VkCmdBuffer) cmd_buffer,
 258                                     VK_STATE_BIND_POINT_DEPTH_STENCIL,
 259                                     device->meta_state.shared.ds_state);
 260
 261    if (cmd_buffer->cb_state == NULL)
 262       anv_CmdBindDynamicStateObject((VkCmdBuffer) cmd_buffer,
 263                                     VK_STATE_BIND_POINT_COLOR_BLEND,
 264                                     device->meta_state.shared.cb_state);
 265
 266    anv_CmdDraw((VkCmdBuffer) cmd_buffer, 0, 3, 0, num_instances);
 267 }
 268
 269 void
 270 anv_cmd_buffer_clear(struct anv_cmd_buffer *cmd_buffer,
 271                      struct anv_render_pass *pass)
 272 {
 273    struct anv_saved_state saved_state;
 274
 275    int num_clear_layers = 0;
 276    struct clear_instance_data instance_data[MAX_RTS];
 277
 278    for (uint32_t i = 0; i < pass->num_layers; i++) {
 279       if (pass->layers[i].color_load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) {
 280          instance_data[num_clear_layers++] = (struct clear_instance_data) {
 281             .vue_header = {
 282                .RTAIndex = i,
 283                .ViewportIndex = 0,
 284                .PointWidth = 0.0
 285             },
 286             .color = pass->layers[i].clear_color,
 287          };
 288       }
 289    }
 290
 291    if (num_clear_layers == 0)
 292       return;
 293
 294    anv_cmd_buffer_save(cmd_buffer, &saved_state);
 295
 296    meta_emit_clear(cmd_buffer, num_clear_layers, instance_data);
 297
 298    /* Restore API state */
 299    anv_cmd_buffer_restore(cmd_buffer, &saved_state);
 300 }
 301
 302 static void
 303 anv_device_init_meta_blit_state(struct anv_device *device)
 304 {
 305    VkPipelineIaStateCreateInfo ia_create_info = {
 306       .sType = VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO,
 307       .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
 308       .primitiveRestartEnable = false,
 309    };
 310
 311    /* We don't use a vertex shader for clearing, but instead build and pass
 312     * the VUEs directly to the rasterization backend.  However, we do need
 313     * to provide GLSL source for the vertex shader so that the compiler
 314     * does not dead-code our inputs.
 315     */
 316    VkShader vs = GLSL_VK_SHADER(device, VERTEX,
 317       in vec2 a_pos;
 318       in vec2 a_tex_coord;
 319       out vec4 v_tex_coord;
 320       void main()
 321       {
 322          v_tex_coord = vec4(a_tex_coord, 0, 1);
 323          gl_Position = vec4(a_pos, 0, 1);
 324       }
 325    );
 326
 327    VkShader fs = GLSL_VK_SHADER(device, FRAGMENT,
 328       out vec4 f_color;
 329       in vec4 v_tex_coord;
 330       layout(set = 0, binding = 0) uniform sampler2D u_tex;
 331       void main()
 332       {
 333          f_color = texture(u_tex, v_tex_coord.xy);
 334       }
 335    );
 336
 337    VkPipelineShaderStageCreateInfo vs_create_info = {
 338       .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
 339       .pNext = &ia_create_info,
 340       .shader = {
 341          .stage = VK_SHADER_STAGE_VERTEX,
 342          .shader = vs,
 343          .linkConstBufferCount = 0,
 344          .pLinkConstBufferInfo = NULL,
 345          .pSpecializationInfo = NULL
 346       }
 347    };
 348
 349    VkPipelineShaderStageCreateInfo fs_create_info = {
 350       .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
 351       .pNext = &vs_create_info,
 352       .shader = {
 353          .stage = VK_SHADER_STAGE_FRAGMENT,
 354          .shader = fs,
 355          .linkConstBufferCount = 0,
 356          .pLinkConstBufferInfo = NULL,
 357          .pSpecializationInfo = NULL
 358       }
 359    };
 360
 361    VkPipelineVertexInputStateCreateInfo vi_create_info = {
 362       .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
 363       .pNext = &fs_create_info,
 364       .bindingCount = 2,
 365       .pVertexBindingDescriptions = (VkVertexInputBindingDescription[]) {
 366          {
 367             .binding = 0,
 368             .strideInBytes = 0,
 369             .stepRate = VK_VERTEX_INPUT_STEP_RATE_VERTEX
 370          },
 371          {
 372             .binding = 1,
 373             .strideInBytes = 16,
 374             .stepRate = VK_VERTEX_INPUT_STEP_RATE_VERTEX
 375          },
 376       },
 377       .attributeCount = 3,
 378       .pVertexAttributeDescriptions = (VkVertexInputAttributeDescription[]) {
 379          {
 380             /* VUE Header */
 381             .location = 0,
 382             .binding = 0,
 383             .format = VK_FORMAT_R32G32B32A32_UINT,
 384             .offsetInBytes = 0
 385          },
 386          {
 387             /* Position */
 388             .location = 1,
 389             .binding = 1,
 390             .format = VK_FORMAT_R32G32_SFLOAT,
 391             .offsetInBytes = 0
 392          },
 393          {
 394             /* Texture Coordinate */
 395             .location = 2,
 396             .binding = 1,
 397             .format = VK_FORMAT_R32G32_SFLOAT,
 398             .offsetInBytes = 8
 399          }
 400       }
 401    };
 402
 403    VkDescriptorSetLayoutCreateInfo ds_layout_info = {
 404       .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
 405       .count = 1,
 406       .pBinding = (VkDescriptorSetLayoutBinding[]) {
 407          {
 408             .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
 409             .arraySize = 1,
 410             .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
 411             .pImmutableSamplers = NULL
 412          },
 413       }
 414    };
 415    anv_CreateDescriptorSetLayout((VkDevice) device, &ds_layout_info,
 416                                  &device->meta_state.blit.ds_layout);
 417
 418    anv_CreatePipelineLayout((VkDevice) device,
 419       &(VkPipelineLayoutCreateInfo) {
 420          .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
 421          .descriptorSetCount = 1,
 422          .pSetLayouts = &device->meta_state.blit.ds_layout,
 423       },
 424       &device->meta_state.blit.pipeline_layout);
 425
 426    VkPipelineRsStateCreateInfo rs_create_info = {
 427       .sType = VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO,
 428       .pNext = &vi_create_info,
 429       .depthClipEnable = true,
 430       .rasterizerDiscardEnable = false,
 431       .fillMode = VK_FILL_MODE_SOLID,
 432       .cullMode = VK_CULL_MODE_NONE,
 433       .frontFace = VK_FRONT_FACE_CCW
 434    };
 435
 436    VkPipelineCbStateCreateInfo cb_create_info = {
 437       .sType = VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO,
 438       .pNext = &rs_create_info,
 439       .attachmentCount = 1,
 440       .pAttachments = (VkPipelineCbAttachmentState []) {
 441          { .channelWriteMask = VK_CHANNEL_A_BIT |
 442               VK_CHANNEL_R_BIT | VK_CHANNEL_G_BIT | VK_CHANNEL_B_BIT },
 443       }
 444    };
 445
 446    VkGraphicsPipelineCreateInfo pipeline_info = {
 447       .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
 448       .pNext = &cb_create_info,
 449       .flags = 0,
 450       .layout = device->meta_state.blit.pipeline_layout,
 451    };
 452
 453    anv_pipeline_create((VkDevice) device, &pipeline_info,
 454                        &(struct anv_pipeline_create_info) {
 455                           .use_repclear = false,
 456                           .disable_viewport = true,
 457                           .disable_scissor = true,
 458                           .disable_vs = true,
 459                           .use_rectlist = true
 460                        },
 461                        &device->meta_state.blit.pipeline);
 462
 463    anv_DestroyObject((VkDevice) device, VK_OBJECT_TYPE_SHADER, vs);
 464    anv_DestroyObject((VkDevice) device, VK_OBJECT_TYPE_SHADER, fs);
 465 }
 466
 467 static void
 468 meta_prepare_blit(struct anv_cmd_buffer *cmd_buffer,
 469                   struct anv_saved_state *saved_state)
 470 {
 471    struct anv_device *device = cmd_buffer->device;
 472
 473    anv_cmd_buffer_save(cmd_buffer, saved_state);
 474
 475    if ((VkPipeline) cmd_buffer->pipeline != device->meta_state.blit.pipeline)
 476       anv_CmdBindPipeline((VkCmdBuffer) cmd_buffer,
 477                           VK_PIPELINE_BIND_POINT_GRAPHICS,
 478                           device->meta_state.blit.pipeline);
 479
 480    /* We don't need anything here, only set if not already set. */
 481    if (cmd_buffer->rs_state == NULL)
 482       anv_CmdBindDynamicStateObject((VkCmdBuffer) cmd_buffer,
 483                                     VK_STATE_BIND_POINT_RASTER,
 484                                     device->meta_state.shared.rs_state);
 485    if (cmd_buffer->ds_state == NULL)
 486       anv_CmdBindDynamicStateObject((VkCmdBuffer) cmd_buffer,
 487                                     VK_STATE_BIND_POINT_DEPTH_STENCIL,
 488                                     device->meta_state.shared.ds_state);
 489
 490    saved_state->cb_state = (VkDynamicCbState) cmd_buffer->cb_state;
 491    anv_CmdBindDynamicStateObject((VkCmdBuffer) cmd_buffer,
 492                                  VK_STATE_BIND_POINT_COLOR_BLEND,
 493                                  device->meta_state.shared.cb_state);
 494 }
 495
 496 struct blit_region {
 497    VkOffset3D src_offset;
 498    VkExtent3D src_extent;
 499    VkOffset3D dest_offset;
 500    VkExtent3D dest_extent;
 501 };
 502
 503 static void
 504 meta_emit_blit(struct anv_cmd_buffer *cmd_buffer,
 505                struct anv_surface_view *src,
 506                VkOffset3D src_offset,
 507                VkExtent3D src_extent,
 508                struct anv_surface_view *dest,
 509                VkOffset3D dest_offset,
 510                VkExtent3D dest_extent)
 511 {
 512    struct anv_device *device = cmd_buffer->device;
 513
 514    struct blit_vb_data {
 515       float pos[2];
 516       float tex_coord[2];
 517    } *vb_data;
 518
 519    unsigned vb_size = sizeof(struct vue_header) + 3 * sizeof(*vb_data);
 520
 521    struct anv_state vb_state =
 522       anv_state_stream_alloc(&cmd_buffer->surface_state_stream, vb_size, 16);
 523    memset(vb_state.map, 0, sizeof(struct vue_header));
 524    vb_data = vb_state.map + sizeof(struct vue_header);
 525
 526    vb_data[0] = (struct blit_vb_data) {
 527       .pos = {
 528          dest_offset.x + dest_extent.width,
 529          dest_offset.y + dest_extent.height,
 530       },
 531       .tex_coord = {
 532          (float)(src_offset.x + src_extent.width) / (float)src->extent.width,
 533          (float)(src_offset.y + src_extent.height) / (float)src->extent.height,
 534       },
 535    };
 536
 537    vb_data[1] = (struct blit_vb_data) {
 538       .pos = {
 539          dest_offset.x,
 540          dest_offset.y + dest_extent.height,
 541       },
 542       .tex_coord = {
 543          (float)src_offset.x / (float)src->extent.width,
 544          (float)(src_offset.y + src_extent.height) / (float)src->extent.height,
 545       },
 546    };
 547
 548    vb_data[2] = (struct blit_vb_data) {
 549       .pos = {
 550          dest_offset.x,
 551          dest_offset.y,
 552       },
 553       .tex_coord = {
 554          (float)src_offset.x / (float)src->extent.width,
 555          (float)src_offset.y / (float)src->extent.height,
 556       },
 557    };
 558
 559    struct anv_buffer vertex_buffer = {
 560       .device = device,
 561       .size = vb_size,
 562       .bo = &device->surface_state_block_pool.bo,
 563       .offset = vb_state.offset,
 564    };
 565
 566    anv_CmdBindVertexBuffers((VkCmdBuffer) cmd_buffer, 0, 2,
 567       (VkBuffer[]) {
 568          (VkBuffer) &vertex_buffer,
 569          (VkBuffer) &vertex_buffer
 570       },
 571       (VkDeviceSize[]) {
 572          0,
 573          sizeof(struct vue_header),
 574       });
 575
 576    uint32_t count;
 577    VkDescriptorSet set;
 578    anv_AllocDescriptorSets((VkDevice) device, 0 /* pool */,
 579                            VK_DESCRIPTOR_SET_USAGE_ONE_SHOT,
 580                            1, &device->meta_state.blit.ds_layout, &set, &count);
 581    anv_UpdateDescriptors((VkDevice) device, set, 1,
 582       (const void * []) {
 583          &(VkUpdateImages) {
 584             .sType = VK_STRUCTURE_TYPE_UPDATE_IMAGES,
 585             .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
 586             .binding = 0,
 587             .count = 1,
 588             .pImageViews = (VkImageViewAttachInfo[]) {
 589                {
 590                   .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO,
 591                   .view = (VkImageView) src,
 592                   .layout = VK_IMAGE_LAYOUT_GENERAL,
 593                }
 594             }
 595          }
 596       });
 597
 598    struct anv_framebuffer *fb;
 599    anv_CreateFramebuffer((VkDevice) device,
 600       &(VkFramebufferCreateInfo) {
 601          .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
 602          .colorAttachmentCount = 1,
 603          .pColorAttachments = (VkColorAttachmentBindInfo[]) {
 604             {
 605                .view = (VkColorAttachmentView) dest,
 606                .layout = VK_IMAGE_LAYOUT_GENERAL
 607             }
 608          },
 609          .pDepthStencilAttachment = NULL,
 610          .sampleCount = 1,
 611          .width = dest->extent.width,
 612          .height = dest->extent.height,
 613          .layers = 1
 614       }, (VkFramebuffer *)&fb);
 615
 616
 617    VkRenderPass pass;
 618    anv_CreateRenderPass((VkDevice )device,
 619       &(VkRenderPassCreateInfo) {
 620          .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
 621          .renderArea = { { 0, 0 }, { dest->extent.width, dest->extent.height } },
 622          .colorAttachmentCount = 1,
 623          .extent = { 0, },
 624          .sampleCount = 1,
 625          .layers = 1,
 626          .pColorFormats = (VkFormat[]) { dest->format },
 627          .pColorLayouts = (VkImageLayout[]) { VK_IMAGE_LAYOUT_GENERAL },
 628          .pColorLoadOps = (VkAttachmentLoadOp[]) { VK_ATTACHMENT_LOAD_OP_LOAD },
 629          .pColorStoreOps = (VkAttachmentStoreOp[]) { VK_ATTACHMENT_STORE_OP_STORE },
 630          .pColorLoadClearValues = (VkClearColorValue[]) {
 631             { .f32 = { 1.0, 0.0, 0.0, 1.0 } }
 632          },
 633          .depthStencilFormat = VK_FORMAT_UNDEFINED,
 634       }, &pass);
 635
 636    anv_CmdBeginRenderPass((VkCmdBuffer) cmd_buffer,
 637       &(VkRenderPassBegin) {
 638          .renderPass = pass,
 639          .framebuffer = (VkFramebuffer) fb,
 640       });
 641
 642    anv_CmdBindDynamicStateObject((VkCmdBuffer) cmd_buffer,
 643                                  VK_STATE_BIND_POINT_VIEWPORT, fb->vp_state);
 644
 645    anv_CmdBindDescriptorSets((VkCmdBuffer) cmd_buffer,
 646                              VK_PIPELINE_BIND_POINT_GRAPHICS,
 647                              device->meta_state.blit.pipeline_layout, 0, 1,
 648                              &set, 0, NULL);
 649
 650    anv_CmdDraw((VkCmdBuffer) cmd_buffer, 0, 3, 0, 1);
 651
 652    anv_CmdEndRenderPass((VkCmdBuffer) cmd_buffer);
 653
 654    /* At the point where we emit the draw call, all data from the
 655     * descriptor sets, etc. has been used.  We are free to delete it.
 656     */
 657    anv_DestroyObject((VkDevice) device, VK_OBJECT_TYPE_DESCRIPTOR_SET, set);
 658    anv_DestroyObject((VkDevice) device, VK_OBJECT_TYPE_FRAMEBUFFER,
 659                      (VkFramebuffer) fb);
 660    anv_DestroyObject((VkDevice) device, VK_OBJECT_TYPE_RENDER_PASS, pass);
 661 }
 662
 663 static void
 664 meta_finish_blit(struct anv_cmd_buffer *cmd_buffer,
 665                  const struct anv_saved_state *saved_state)
 666 {
 667    anv_cmd_buffer_restore(cmd_buffer, saved_state);
 668    anv_CmdBindDynamicStateObject((VkCmdBuffer) cmd_buffer,
 669                                  VK_STATE_BIND_POINT_COLOR_BLEND,
 670                                  saved_state->cb_state);
 671 }
 672
 673 static VkFormat
 674 vk_format_for_cpp(int cpp)
 675 {
 676    switch (cpp) {
 677    case 1: return VK_FORMAT_R8_UINT;
 678    case 2: return VK_FORMAT_R8G8_UINT;
 679    case 3: return VK_FORMAT_R8G8B8_UINT;
 680    case 4: return VK_FORMAT_R8G8B8A8_UINT;
 681    case 6: return VK_FORMAT_R16G16B16_UINT;
 682    case 8: return VK_FORMAT_R16G16B16A16_UINT;
 683    case 12: return VK_FORMAT_R32G32B32_UINT;
 684    case 16: return VK_FORMAT_R32G32B32A32_UINT;
 685    default:
 686       unreachable("Invalid format cpp");
 687    }
 688 }
 689
 690 static void
 691 do_buffer_copy(struct anv_cmd_buffer *cmd_buffer,
 692                struct anv_bo *src, uint64_t src_offset,
 693                struct anv_bo *dest, uint64_t dest_offset,
 694                int width, int height, VkFormat copy_format)
 695 {
 696    VkDevice vk_device = (VkDevice)cmd_buffer->device;
 697
 698    VkImageCreateInfo image_info = {
 699       .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
 700       .imageType = VK_IMAGE_TYPE_2D,
 701       .format = copy_format,
 702       .extent = {
 703          .width = width,
 704          .height = height,
 705          .depth = 1,
 706       },
 707       .mipLevels = 1,
 708       .arraySize = 1,
 709       .samples = 1,
 710       .tiling = VK_IMAGE_TILING_LINEAR,
 711       .usage = VK_IMAGE_USAGE_SAMPLED_BIT,
 712       .flags = 0,
 713    };
 714
 715    struct anv_image *src_image, *dest_image;
 716    anv_CreateImage(vk_device, &image_info, (VkImage *)&src_image);
 717    anv_CreateImage(vk_device, &image_info, (VkImage *)&dest_image);
 718
 719    /* We could use a vk call to bind memory, but that would require
 720     * creating a dummy memory object etc. so there's really no point.
 721     */
 722    src_image->bo = src;
 723    src_image->offset = src_offset;
 724    dest_image->bo = dest;
 725    dest_image->offset = dest_offset;
 726
 727    struct anv_surface_view src_view;
 728    anv_image_view_init(&src_view, cmd_buffer->device,
 729       &(VkImageViewCreateInfo) {
 730          .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
 731          .image = (VkImage)src_image,
 732          .viewType = VK_IMAGE_VIEW_TYPE_2D,
 733          .format = copy_format,
 734          .channels = {
 735             VK_CHANNEL_SWIZZLE_R,
 736             VK_CHANNEL_SWIZZLE_G,
 737             VK_CHANNEL_SWIZZLE_B,
 738             VK_CHANNEL_SWIZZLE_A
 739          },
 740          .subresourceRange = {
 741             .aspect = VK_IMAGE_ASPECT_COLOR,
 742             .baseMipLevel = 0,
 743             .mipLevels = 1,
 744             .baseArraySlice = 0,
 745             .arraySize = 1
 746          },
 747          .minLod = 0
 748       },
 749       cmd_buffer);
 750
 751    struct anv_surface_view dest_view;
 752    anv_color_attachment_view_init(&dest_view, cmd_buffer->device,
 753       &(VkColorAttachmentViewCreateInfo) {
 754          .sType = VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO,
 755          .image = (VkImage)dest_image,
 756          .format = copy_format,
 757          .mipLevel = 0,
 758          .baseArraySlice = 0,
 759          .arraySize = 1,
 760       },
 761       cmd_buffer);
 762
 763    meta_emit_blit(cmd_buffer,
 764                   &src_view,
 765                   (VkOffset3D) { 0, 0, 0 },
 766                   (VkExtent3D) { width, height, 1 },
 767                   &dest_view,
 768                   (VkOffset3D) { 0, 0, 0 },
 769                   (VkExtent3D) { width, height, 1 });
 770
 771    anv_DestroyObject(vk_device, VK_OBJECT_TYPE_IMAGE, (VkImage) src_image);
 772    anv_DestroyObject(vk_device, VK_OBJECT_TYPE_IMAGE, (VkImage) dest_image);
 773 }
 774
 775 void anv_CmdCopyBuffer(
 776     VkCmdBuffer                                 cmdBuffer,
 777     VkBuffer                                    srcBuffer,
 778     VkBuffer                                    destBuffer,
 779     uint32_t                                    regionCount,
 780     const VkBufferCopy*                         pRegions)
 781 {
 782    struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *)cmdBuffer;
 783    struct anv_buffer *src_buffer = (struct anv_buffer *)srcBuffer;
 784    struct anv_buffer *dest_buffer = (struct anv_buffer *)destBuffer;
 785    struct anv_saved_state saved_state;
 786
 787    meta_prepare_blit(cmd_buffer, &saved_state);
 788
 789    for (unsigned r = 0; r < regionCount; r++) {
 790       uint64_t src_offset = src_buffer->offset + pRegions[r].srcOffset;
 791       uint64_t dest_offset = dest_buffer->offset + pRegions[r].destOffset;
 792       uint64_t copy_size = pRegions[r].copySize;
 793
 794       /* First, we compute the biggest format that can be used with the
 795        * given offsets and size.
 796        */
 797       int cpp = 16;
 798
 799       int fs = ffs(src_offset) - 1;
 800       if (fs != -1)
 801          cpp = MIN2(cpp, 1 << fs);
 802       assert(src_offset % cpp == 0);
 803
 804       fs = ffs(dest_offset) - 1;
 805       if (fs != -1)
 806          cpp = MIN2(cpp, 1 << fs);
 807       assert(dest_offset % cpp == 0);
 808
 809       fs = ffs(pRegions[r].copySize) - 1;
 810       if (fs != -1)
 811          cpp = MIN2(cpp, 1 << fs);
 812       assert(pRegions[r].copySize % cpp == 0);
 813
 814       VkFormat copy_format = vk_format_for_cpp(cpp);
 815
 816       /* This is maximum possible width/height our HW can handle */
 817       uint64_t max_surface_dim = 1 << 14;
 818
 819       /* First, we make a bunch of max-sized copies */
 820       uint64_t max_copy_size = max_surface_dim * max_surface_dim * cpp;
 821       while (copy_size > max_copy_size) {
 822          do_buffer_copy(cmd_buffer, src_buffer->bo, src_offset,
 823                         dest_buffer->bo, dest_offset,
 824                         max_surface_dim, max_surface_dim, copy_format);
 825          copy_size -= max_copy_size;
 826          src_offset += max_copy_size;
 827          dest_offset += max_copy_size;
 828       }
 829
 830       uint64_t height = copy_size / (max_surface_dim * cpp);
 831       assert(height < max_surface_dim);
 832       if (height != 0) {
 833          uint64_t rect_copy_size = height * max_surface_dim * cpp;
 834          do_buffer_copy(cmd_buffer, src_buffer->bo, src_offset,
 835                         dest_buffer->bo, dest_offset,
 836                         max_surface_dim, height, copy_format);
 837          copy_size -= rect_copy_size;
 838          src_offset += rect_copy_size;
 839          dest_offset += rect_copy_size;
 840       }
 841
 842       if (copy_size != 0) {
 843          do_buffer_copy(cmd_buffer, src_buffer->bo, src_offset,
 844                         dest_buffer->bo, dest_offset,
 845                         copy_size / cpp, 1, copy_format);
 846       }
 847    }
 848
 849    meta_finish_blit(cmd_buffer, &saved_state);
 850 }
 851
 852 void anv_CmdCopyImage(
 853     VkCmdBuffer                                 cmdBuffer,
 854     VkImage                                     srcImage,
 855     VkImageLayout                               srcImageLayout,
 856     VkImage                                     destImage,
 857     VkImageLayout                               destImageLayout,
 858     uint32_t                                    regionCount,
 859     const VkImageCopy*                          pRegions)
 860 {
 861    struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *)cmdBuffer;
 862    struct anv_image *src_image = (struct anv_image *)srcImage;
 863    struct anv_saved_state saved_state;
 864
 865    meta_prepare_blit(cmd_buffer, &saved_state);
 866
 867    for (unsigned r = 0; r < regionCount; r++) {
 868       struct anv_surface_view src_view;
 869       anv_image_view_init(&src_view, cmd_buffer->device,
 870          &(VkImageViewCreateInfo) {
 871             .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
 872             .image = srcImage,
 873             .viewType = VK_IMAGE_VIEW_TYPE_2D,
 874             .format = src_image->format,
 875             .channels = {
 876                VK_CHANNEL_SWIZZLE_R,
 877                VK_CHANNEL_SWIZZLE_G,
 878                VK_CHANNEL_SWIZZLE_B,
 879                VK_CHANNEL_SWIZZLE_A
 880             },
 881             .subresourceRange = {
 882                .aspect = pRegions[r].srcSubresource.aspect,
 883                .baseMipLevel = pRegions[r].srcSubresource.mipLevel,
 884                .mipLevels = 1,
 885                .baseArraySlice = pRegions[r].srcSubresource.arraySlice,
 886                .arraySize = 1
 887             },
 888             .minLod = 0
 889          },
 890          cmd_buffer);
 891
 892       struct anv_surface_view dest_view;
 893       anv_color_attachment_view_init(&dest_view, cmd_buffer->device,
 894          &(VkColorAttachmentViewCreateInfo) {
 895             .sType = VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO,
 896             .image = destImage,
 897             .format = src_image->format,
 898             .mipLevel = pRegions[r].destSubresource.mipLevel,
 899             .baseArraySlice = pRegions[r].destSubresource.arraySlice,
 900             .arraySize = 1,
 901          },
 902          cmd_buffer);
 903
 904       meta_emit_blit(cmd_buffer,
 905                      &src_view,
 906                      pRegions[r].srcOffset,
 907                      pRegions[r].extent,
 908                      &dest_view,
 909                      pRegions[r].destOffset,
 910                      pRegions[r].extent);
 911    }
 912
 913    meta_finish_blit(cmd_buffer, &saved_state);
 914 }
 915
 916 void anv_CmdBlitImage(
 917     VkCmdBuffer                                 cmdBuffer,
 918     VkImage                                     srcImage,
 919     VkImageLayout                               srcImageLayout,
 920     VkImage                                     destImage,
 921     VkImageLayout                               destImageLayout,
 922     uint32_t                                    regionCount,
 923     const VkImageBlit*                          pRegions)
 924 {
 925    struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *)cmdBuffer;
 926    struct anv_image *src_image = (struct anv_image *)srcImage;
 927    struct anv_image *dest_image = (struct anv_image *)destImage;
 928    struct anv_saved_state saved_state;
 929
 930    meta_prepare_blit(cmd_buffer, &saved_state);
 931
 932    for (unsigned r = 0; r < regionCount; r++) {
 933       struct anv_surface_view src_view;
 934       anv_image_view_init(&src_view, cmd_buffer->device,
 935          &(VkImageViewCreateInfo) {
 936             .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
 937             .image = srcImage,
 938             .viewType = VK_IMAGE_VIEW_TYPE_2D,
 939             .format = src_image->format,
 940             .channels = {
 941                VK_CHANNEL_SWIZZLE_R,
 942                VK_CHANNEL_SWIZZLE_G,
 943                VK_CHANNEL_SWIZZLE_B,
 944                VK_CHANNEL_SWIZZLE_A
 945             },
 946             .subresourceRange = {
 947                .aspect = pRegions[r].srcSubresource.aspect,
 948                .baseMipLevel = pRegions[r].srcSubresource.mipLevel,
 949                .mipLevels = 1,
 950                .baseArraySlice = pRegions[r].srcSubresource.arraySlice,
 951                .arraySize = 1
 952             },
 953             .minLod = 0
 954          },
 955          cmd_buffer);
 956
 957       struct anv_surface_view dest_view;
 958       anv_color_attachment_view_init(&dest_view, cmd_buffer->device,
 959          &(VkColorAttachmentViewCreateInfo) {
 960             .sType = VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO,
 961             .image = destImage,
 962             .format = dest_image->format,
 963             .mipLevel = pRegions[r].destSubresource.mipLevel,
 964             .baseArraySlice = pRegions[r].destSubresource.arraySlice,
 965             .arraySize = 1,
 966          },
 967          cmd_buffer);
 968
 969       meta_emit_blit(cmd_buffer,
 970                      &src_view,
 971                      pRegions[r].srcOffset,
 972                      pRegions[r].srcExtent,
 973                      &dest_view,
 974                      pRegions[r].destOffset,
 975                      pRegions[r].destExtent);
 976    }
 977
 978    meta_finish_blit(cmd_buffer, &saved_state);
 979 }
 980
 981 void anv_CmdCopyBufferToImage(
 982     VkCmdBuffer                                 cmdBuffer,
 983     VkBuffer                                    srcBuffer,
 984     VkImage                                     destImage,
 985     VkImageLayout                               destImageLayout,
 986     uint32_t                                    regionCount,
 987     const VkBufferImageCopy*                    pRegions)
 988 {
 989    struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *)cmdBuffer;
 990    VkDevice vk_device = (VkDevice) cmd_buffer->device;
 991    struct anv_buffer *src_buffer = (struct anv_buffer *)srcBuffer;
 992    struct anv_image *dest_image = (struct anv_image *)destImage;
 993    struct anv_saved_state saved_state;
 994
 995    meta_prepare_blit(cmd_buffer, &saved_state);
 996
 997    for (unsigned r = 0; r < regionCount; r++) {
 998       struct anv_image *src_image;
 999       anv_CreateImage(vk_device,
1000          &(VkImageCreateInfo) {
1001             .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
1002             .imageType = VK_IMAGE_TYPE_2D,
1003             .format = dest_image->format,
1004             .extent = {
1005                .width = pRegions[r].imageExtent.width,
1006                .height = pRegions[r].imageExtent.height,
1007                .depth = 1,
1008             },
1009             .mipLevels = 1,
1010             .arraySize = 1,
1011             .samples = 1,
1012             .tiling = VK_IMAGE_TILING_LINEAR,
1013             .usage = VK_IMAGE_USAGE_SAMPLED_BIT,
1014             .flags = 0,
1015          }, (VkImage *)&src_image);
1016
1017       /* We could use a vk call to bind memory, but that would require
1018        * creating a dummy memory object etc. so there's really no point.
1019        */
1020       src_image->bo = src_buffer->bo;
1021       src_image->offset = src_buffer->offset + pRegions[r].bufferOffset;
1022
1023       struct anv_surface_view src_view;
1024       anv_image_view_init(&src_view, cmd_buffer->device,
1025          &(VkImageViewCreateInfo) {
1026             .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1027             .image = (VkImage)src_image,
1028             .viewType = VK_IMAGE_VIEW_TYPE_2D,
1029             .format = dest_image->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                .aspect = pRegions[r].imageSubresource.aspect,
1038                .baseMipLevel = 0,
1039                .mipLevels = 1,
1040                .baseArraySlice = 0,
1041                .arraySize = 1
1042             },
1043             .minLod = 0
1044          },
1045          cmd_buffer);
1046
1047       struct anv_surface_view dest_view;
1048       anv_color_attachment_view_init(&dest_view, cmd_buffer->device,
1049          &(VkColorAttachmentViewCreateInfo) {
1050             .sType = VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO,
1051             .image = (VkImage)dest_image,
1052             .format = dest_image->format,
1053             .mipLevel = pRegions[r].imageSubresource.mipLevel,
1054             .baseArraySlice = pRegions[r].imageSubresource.arraySlice,
1055             .arraySize = 1,
1056          },
1057          cmd_buffer);
1058
1059       meta_emit_blit(cmd_buffer,
1060                      &src_view,
1061                      (VkOffset3D) { 0, 0, 0 },
1062                      pRegions[r].imageExtent,
1063                      &dest_view,
1064                      pRegions[r].imageOffset,
1065                      pRegions[r].imageExtent);
1066
1067       anv_DestroyObject(vk_device, VK_OBJECT_TYPE_IMAGE, (VkImage) src_image);
1068    }
1069
1070    meta_finish_blit(cmd_buffer, &saved_state);
1071 }
1072
1073 void anv_CmdCopyImageToBuffer(
1074     VkCmdBuffer                                 cmdBuffer,
1075     VkImage                                     srcImage,
1076     VkImageLayout                               srcImageLayout,
1077     VkBuffer                                    destBuffer,
1078     uint32_t                                    regionCount,
1079     const VkBufferImageCopy*                    pRegions)
1080 {
1081    struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *)cmdBuffer;
1082    VkDevice vk_device = (VkDevice) cmd_buffer->device;
1083    struct anv_image *src_image = (struct anv_image *)srcImage;
1084    struct anv_buffer *dest_buffer = (struct anv_buffer *)destBuffer;
1085    struct anv_saved_state saved_state;
1086
1087    meta_prepare_blit(cmd_buffer, &saved_state);
1088
1089    for (unsigned r = 0; r < regionCount; r++) {
1090       struct anv_surface_view src_view;
1091       anv_image_view_init(&src_view, cmd_buffer->device,
1092          &(VkImageViewCreateInfo) {
1093             .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1094             .image = srcImage,
1095             .viewType = VK_IMAGE_VIEW_TYPE_2D,
1096             .format = src_image->format,
1097             .channels = {
1098                VK_CHANNEL_SWIZZLE_R,
1099                VK_CHANNEL_SWIZZLE_G,
1100                VK_CHANNEL_SWIZZLE_B,
1101                VK_CHANNEL_SWIZZLE_A
1102             },
1103             .subresourceRange = {
1104                .aspect = pRegions[r].imageSubresource.aspect,
1105                .baseMipLevel = pRegions[r].imageSubresource.mipLevel,
1106                .mipLevels = 1,
1107                .baseArraySlice = pRegions[r].imageSubresource.arraySlice,
1108                .arraySize = 1
1109             },
1110             .minLod = 0
1111          },
1112          cmd_buffer);
1113
1114       struct anv_image *dest_image;
1115       anv_CreateImage(vk_device,
1116          &(VkImageCreateInfo) {
1117             .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
1118             .imageType = VK_IMAGE_TYPE_2D,
1119             .format = src_image->format,
1120             .extent = {
1121                .width = pRegions[r].imageExtent.width,
1122                .height = pRegions[r].imageExtent.height,
1123                .depth = 1,
1124             },
1125             .mipLevels = 1,
1126             .arraySize = 1,
1127             .samples = 1,
1128             .tiling = VK_IMAGE_TILING_LINEAR,
1129             .usage = VK_IMAGE_USAGE_SAMPLED_BIT,
1130             .flags = 0,
1131          }, (VkImage *)&dest_image);
1132
1133       /* We could use a vk call to bind memory, but that would require
1134        * creating a dummy memory object etc. so there's really no point.
1135        */
1136       dest_image->bo = dest_buffer->bo;
1137       dest_image->offset = dest_buffer->offset + pRegions[r].bufferOffset;
1138
1139       struct anv_surface_view dest_view;
1140       anv_color_attachment_view_init(&dest_view, cmd_buffer->device,
1141          &(VkColorAttachmentViewCreateInfo) {
1142             .sType = VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO,
1143             .image = (VkImage)dest_image,
1144             .format = src_image->format,
1145             .mipLevel = 0,
1146             .baseArraySlice = 0,
1147             .arraySize = 1,
1148          },
1149          cmd_buffer);
1150
1151       meta_emit_blit(cmd_buffer,
1152                      &src_view,
1153                      pRegions[r].imageOffset,
1154                      pRegions[r].imageExtent,
1155                      &dest_view,
1156                      (VkOffset3D) { 0, 0, 0 },
1157                      pRegions[r].imageExtent);
1158
1159       anv_DestroyObject(vk_device, VK_OBJECT_TYPE_IMAGE, (VkImage) dest_image);
1160    }
1161
1162    meta_finish_blit(cmd_buffer, &saved_state);
1163 }
1164
1165 void anv_CmdUpdateBuffer(
1166     VkCmdBuffer                                 cmdBuffer,
1167     VkBuffer                                    destBuffer,
1168     VkDeviceSize                                destOffset,
1169     VkDeviceSize                                dataSize,
1170     const uint32_t*                             pData)
1171 {
1172    stub();
1173 }
1174
1175 void anv_CmdFillBuffer(
1176     VkCmdBuffer                                 cmdBuffer,
1177     VkBuffer                                    destBuffer,
1178     VkDeviceSize                                destOffset,
1179     VkDeviceSize                                fillSize,
1180     uint32_t                                    data)
1181 {
1182    stub();
1183 }
1184
1185 void anv_CmdClearColorImage(
1186     VkCmdBuffer                                 cmdBuffer,
1187     VkImage                                     _image,
1188     VkImageLayout                               imageLayout,
1189     const VkClearColorValue*                    pColor,
1190     uint32_t                                    rangeCount,
1191     const VkImageSubresourceRange*              pRanges)
1192 {
1193    struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *)cmdBuffer;
1194    struct anv_image *image = (struct anv_image *)_image;
1195    struct anv_saved_state saved_state;
1196
1197    anv_cmd_buffer_save(cmd_buffer, &saved_state);
1198
1199    for (uint32_t r = 0; r < rangeCount; r++) {
1200       for (uint32_t l = 0; l < pRanges[r].mipLevels; l++) {
1201          for (uint32_t s = 0; s < pRanges[r].arraySize; s++) {
1202             struct anv_surface_view view;
1203             anv_color_attachment_view_init(&view, cmd_buffer->device,
1204                &(VkColorAttachmentViewCreateInfo) {
1205                   .sType = VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO,
1206                   .image = _image,
1207                   .format = image->format,
1208                   .mipLevel = pRanges[r].baseMipLevel + l,
1209                   .baseArraySlice = pRanges[r].baseArraySlice + s,
1210                   .arraySize = 1,
1211                },
1212                cmd_buffer);
1213
1214             VkFramebuffer fb;
1215             anv_CreateFramebuffer((VkDevice) cmd_buffer->device,
1216                &(VkFramebufferCreateInfo) {
1217                   .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
1218                   .colorAttachmentCount = 1,
1219                   .pColorAttachments = (VkColorAttachmentBindInfo[]) {
1220                      {
1221                         .view = (VkColorAttachmentView) &view,
1222                         .layout = VK_IMAGE_LAYOUT_GENERAL
1223                      }
1224                   },
1225                   .pDepthStencilAttachment = NULL,
1226                   .sampleCount = 1,
1227                   .width = view.extent.width,
1228                   .height = view.extent.height,
1229                   .layers = 1
1230                }, &fb);
1231
1232             VkRenderPass pass;
1233             anv_CreateRenderPass((VkDevice) cmd_buffer->device,
1234                &(VkRenderPassCreateInfo) {
1235                   .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
1236                   .renderArea = { { 0, 0 }, { view.extent.width, view.extent.height } },
1237                   .colorAttachmentCount = 1,
1238                   .extent = { 0, },
1239                   .sampleCount = 1,
1240                   .layers = 1,
1241                   .pColorFormats = (VkFormat[]) { image->format },
1242                   .pColorLayouts = (VkImageLayout[]) { imageLayout },
1243                   .pColorLoadOps = (VkAttachmentLoadOp[]) { VK_ATTACHMENT_LOAD_OP_DONT_CARE },
1244                   .pColorStoreOps = (VkAttachmentStoreOp[]) { VK_ATTACHMENT_STORE_OP_STORE },
1245                   .pColorLoadClearValues = pColor,
1246                   .depthStencilFormat = VK_FORMAT_UNDEFINED,
1247                }, &pass);
1248
1249             anv_CmdBeginRenderPass((VkCmdBuffer) cmd_buffer,
1250                &(VkRenderPassBegin) {
1251                   .renderPass = pass,
1252                   .framebuffer = (VkFramebuffer) fb,
1253                });
1254
1255             struct clear_instance_data instance_data = {
1256                .vue_header = {
1257                   .RTAIndex = 0,
1258                   .ViewportIndex = 0,
1259                   .PointWidth = 0.0
1260                },
1261                .color = *pColor,
1262             };
1263
1264             meta_emit_clear(cmd_buffer, 1, &instance_data);
1265
1266             anv_CmdEndRenderPass((VkCmdBuffer) cmd_buffer);
1267          }
1268       }
1269    }
1270
1271    /* Restore API state */
1272    anv_cmd_buffer_restore(cmd_buffer, &saved_state);
1273 }
1274
1275 void anv_CmdClearDepthStencilImage(
1276     VkCmdBuffer                                 cmdBuffer,
1277     VkImage                                     image,
1278     VkImageLayout                               imageLayout,
1279     float                                       depth,
1280     uint32_t                                    stencil,
1281     uint32_t                                    rangeCount,
1282     const VkImageSubresourceRange*              pRanges)
1283 {
1284    stub();
1285 }
1286
1287 void anv_CmdClearColorAttachment(
1288     VkCmdBuffer                                 cmdBuffer,
1289     uint32_t                                    colorAttachment,
1290     VkImageLayout                               imageLayout,
1291     const VkClearColorValue*                    pColor,
1292     uint32_t                                    rectCount,
1293     const VkRect3D*                             pRects)
1294 {
1295    stub();
1296 }
1297
1298 void anv_CmdClearDepthStencilAttachment(
1299     VkCmdBuffer                                 cmdBuffer,
1300     VkImageAspectFlags                          imageAspectMask,
1301     VkImageLayout                               imageLayout,
1302     float                                       depth,
1303     uint32_t                                    stencil,
1304     uint32_t                                    rectCount,
1305     const VkRect3D*                             pRects)
1306 {
1307    stub();
1308 }
1309
1310 void anv_CmdResolveImage(
1311     VkCmdBuffer                                 cmdBuffer,
1312     VkImage                                     srcImage,
1313     VkImageLayout                               srcImageLayout,
1314     VkImage                                     destImage,
1315     VkImageLayout                               destImageLayout,
1316     uint32_t                                    regionCount,
1317     const VkImageResolve*                       pRegions)
1318 {
1319    stub();
1320 }
1321
1322 void
1323 anv_device_init_meta(struct anv_device *device)
1324 {
1325    anv_device_init_meta_clear_state(device);
1326    anv_device_init_meta_blit_state(device);
1327
1328    anv_CreateDynamicRasterState((VkDevice) device,
1329       &(VkDynamicRsStateCreateInfo) {
1330          .sType = VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO,
1331       },
1332       &device->meta_state.shared.rs_state);
1333
1334    anv_CreateDynamicColorBlendState((VkDevice) device,
1335       &(VkDynamicCbStateCreateInfo) {
1336          .sType = VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO
1337       },
1338       &device->meta_state.shared.cb_state);
1339
1340    anv_CreateDynamicDepthStencilState((VkDevice) device,
1341       &(VkDynamicDsStateCreateInfo) {
1342          .sType = VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO
1343       },
1344       &device->meta_state.shared.ds_state);
1345 }
1346
1347 void
1348 anv_device_finish_meta(struct anv_device *device)
1349 {
1350    /* Clear */
1351    anv_DestroyObject((VkDevice) device, VK_OBJECT_TYPE_PIPELINE,
1352                      device->meta_state.clear.pipeline);
1353
1354    /* Blit */
1355    anv_DestroyObject((VkDevice) device, VK_OBJECT_TYPE_PIPELINE,
1356                      device->meta_state.blit.pipeline);
1357    anv_DestroyObject((VkDevice) device, VK_OBJECT_TYPE_PIPELINE_LAYOUT,
1358                      device->meta_state.blit.pipeline_layout);
1359    anv_DestroyObject((VkDevice) device, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
1360                      device->meta_state.blit.ds_layout);
1361
1362    /* Shared */
1363    anv_DestroyObject((VkDevice) device, VK_OBJECT_TYPE_DYNAMIC_RS_STATE,
1364                      device->meta_state.shared.rs_state);
1365    anv_DestroyObject((VkDevice) device, VK_OBJECT_TYPE_DYNAMIC_CB_STATE,
1366                      device->meta_state.shared.cb_state);
1367    anv_DestroyObject((VkDevice) device, VK_OBJECT_TYPE_DYNAMIC_DS_STATE,
1368                      device->meta_state.shared.ds_state);
1369 }