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