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