src/amd/vulkan/radv_meta_resolve.c

   1 /*
   2  * Copyright © 2016 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
  27 #include "radv_meta.h"
  28 #include "radv_private.h"
  29 #include "vk_format.h"
  30 #include "nir/nir_builder.h"
  31 #include "sid.h"
  32
  33 /* emit 0, 0, 0, 1 */
  34 static nir_shader *
  35 build_nir_fs(void)
  36 {
  37         const struct glsl_type *vec4 = glsl_vec4_type();
  38         nir_builder b;
  39         nir_variable *f_color; /* vec4, fragment output color */
  40
  41         nir_builder_init_simple_shader(&b, NULL, MESA_SHADER_FRAGMENT, NULL);
  42         b.shader->info.name = ralloc_asprintf(b.shader,
  43                                                "meta_resolve_fs");
  44
  45         f_color = nir_variable_create(b.shader, nir_var_shader_out, vec4,
  46                                       "f_color");
  47         f_color->data.location = FRAG_RESULT_DATA0;
  48         nir_store_var(&b, f_color, nir_imm_vec4(&b, 0.0, 0.0, 0.0, 1.0), 0xf);
  49
  50         return b.shader;
  51 }
  52
  53 static VkResult
  54 create_pass(struct radv_device *device, VkFormat vk_format, VkRenderPass *pass)
  55 {
  56         VkResult result;
  57         VkDevice device_h = radv_device_to_handle(device);
  58         const VkAllocationCallbacks *alloc = &device->meta_state.alloc;
  59         VkAttachmentDescription attachments[2];
  60         int i;
  61
  62         for (i = 0; i < 2; i++) {
  63                 attachments[i].format = vk_format;
  64                 attachments[i].samples = 1;
  65                 attachments[i].loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
  66                 attachments[i].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
  67         }
  68         attachments[0].initialLayout = VK_IMAGE_LAYOUT_GENERAL;
  69         attachments[0].finalLayout = VK_IMAGE_LAYOUT_GENERAL;
  70         attachments[1].initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
  71         attachments[1].finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
  72
  73         result = radv_CreateRenderPass(device_h,
  74                                        &(VkRenderPassCreateInfo) {
  75                                                .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
  76                                                        .attachmentCount = 2,
  77                                                        .pAttachments = attachments,
  78                                                        .subpassCount = 1,
  79                                                                 .pSubpasses = &(VkSubpassDescription) {
  80                                                        .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
  81                                                        .inputAttachmentCount = 0,
  82                                                        .colorAttachmentCount = 2,
  83                                                        .pColorAttachments = (VkAttachmentReference[]) {
  84                                                                {
  85                                                                        .attachment = 0,
  86                                                                        .layout = VK_IMAGE_LAYOUT_GENERAL,
  87                                                                },
  88                                                                {
  89                                                                        .attachment = 1,
  90                                                                        .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
  91                                                                },
  92                                                        },
  93                                                        .pResolveAttachments = NULL,
  94                                                        .pDepthStencilAttachment = &(VkAttachmentReference) {
  95                                                                .attachment = VK_ATTACHMENT_UNUSED,
  96                                                        },
  97                                                        .preserveAttachmentCount = 0,
  98                                                        .pPreserveAttachments = NULL,
  99                                                },
 100                                                                 .dependencyCount = 0,
 101                                                                          },
 102                                        alloc,
 103                                        pass);
 104
 105         return result;
 106 }
 107
 108 static VkResult
 109 create_pipeline(struct radv_device *device,
 110                  VkShaderModule vs_module_h,
 111                  VkPipeline *pipeline,
 112                  VkRenderPass pass)
 113 {
 114         VkResult result;
 115         VkDevice device_h = radv_device_to_handle(device);
 116
 117         struct radv_shader_module fs_module = {
 118                 .nir = build_nir_fs(),
 119         };
 120
 121         if (!fs_module.nir) {
 122                 /* XXX: Need more accurate error */
 123                 result = VK_ERROR_OUT_OF_HOST_MEMORY;
 124                 goto cleanup;
 125         }
 126
 127         VkPipelineLayoutCreateInfo pl_create_info = {
 128                 .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
 129                 .setLayoutCount = 0,
 130                 .pSetLayouts = NULL,
 131                 .pushConstantRangeCount = 0,
 132                 .pPushConstantRanges = NULL,
 133         };
 134
 135         if (!device->meta_state.resolve.p_layout) {
 136                 result = radv_CreatePipelineLayout(radv_device_to_handle(device),
 137                                                    &pl_create_info,
 138                                                    &device->meta_state.alloc,
 139                                                    &device->meta_state.resolve.p_layout);
 140                 if (result != VK_SUCCESS)
 141                         goto cleanup;
 142         }
 143
 144         result = radv_graphics_pipeline_create(device_h,
 145                                                radv_pipeline_cache_to_handle(&device->meta_state.cache),
 146                                                &(VkGraphicsPipelineCreateInfo) {
 147                                                        .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
 148                                                        .stageCount = 2,
 149                                                        .pStages = (VkPipelineShaderStageCreateInfo[]) {
 150                                                        {
 151                                                                .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
 152                                                                .stage = VK_SHADER_STAGE_VERTEX_BIT,
 153                                                                .module = vs_module_h,
 154                                                                .pName = "main",
 155                                                        },
 156                                                        {
 157                                                                .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
 158                                                                .stage = VK_SHADER_STAGE_FRAGMENT_BIT,
 159                                                                .module = radv_shader_module_to_handle(&fs_module),
 160                                                                .pName = "main",
 161                                                        },
 162                                                },
 163                                                .pVertexInputState = &(VkPipelineVertexInputStateCreateInfo) {
 164                                                        .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
 165                                                        .vertexBindingDescriptionCount = 0,
 166                                                        .vertexAttributeDescriptionCount = 0,
 167                                                },
 168                                                .pInputAssemblyState = &(VkPipelineInputAssemblyStateCreateInfo) {
 169                                                        .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
 170                                                        .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
 171                                                        .primitiveRestartEnable = false,
 172                                                },
 173                                                .pViewportState = &(VkPipelineViewportStateCreateInfo) {
 174                                                        .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
 175                                                        .viewportCount = 1,
 176                                                        .scissorCount = 1,
 177                                                },
 178                                                .pRasterizationState = &(VkPipelineRasterizationStateCreateInfo) {
 179                                                        .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
 180                                                        .depthClampEnable = false,
 181                                                        .rasterizerDiscardEnable = false,
 182                                                        .polygonMode = VK_POLYGON_MODE_FILL,
 183                                                        .cullMode = VK_CULL_MODE_NONE,
 184                                                        .frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE,
 185                                                },
 186                                                .pMultisampleState = &(VkPipelineMultisampleStateCreateInfo) {
 187                                                        .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
 188                                                        .rasterizationSamples = 1,
 189                                                        .sampleShadingEnable = false,
 190                                                        .pSampleMask = NULL,
 191                                                        .alphaToCoverageEnable = false,
 192                                                        .alphaToOneEnable = false,
 193                                                },
 194                                                .pColorBlendState = &(VkPipelineColorBlendStateCreateInfo) {
 195                                                        .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
 196                                                        .logicOpEnable = false,
 197                                                        .attachmentCount = 2,
 198                                                        .pAttachments = (VkPipelineColorBlendAttachmentState []) {
 199                                                                {
 200                                                                .colorWriteMask = VK_COLOR_COMPONENT_R_BIT |
 201                                                                                VK_COLOR_COMPONENT_G_BIT |
 202                                                                                VK_COLOR_COMPONENT_B_BIT |
 203                                                                                VK_COLOR_COMPONENT_A_BIT,
 204                                                                },
 205                                                                {
 206                                                                .colorWriteMask = 0,
 207
 208                                                                }
 209                                                        },
 210                                                 },
 211                                                 .pDynamicState = &(VkPipelineDynamicStateCreateInfo) {
 212                                                         .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
 213                                                         .dynamicStateCount = 2,
 214                                                         .pDynamicStates = (VkDynamicState[]) {
 215                                                                 VK_DYNAMIC_STATE_VIEWPORT,
 216                                                                 VK_DYNAMIC_STATE_SCISSOR,
 217                                                         },
 218                                                 },
 219                                                 .layout = device->meta_state.resolve.p_layout,
 220                                                 .renderPass = pass,
 221                                                                                                                                        .subpass = 0,
 222                                                                                                                                        },
 223                                                &(struct radv_graphics_pipeline_create_info) {
 224                                                        .use_rectlist = true,
 225                                                        .custom_blend_mode = V_028808_CB_RESOLVE,
 226                                                                },
 227                                                &device->meta_state.alloc, pipeline);
 228         if (result != VK_SUCCESS)
 229                 goto cleanup;
 230
 231         goto cleanup;
 232
 233 cleanup:
 234         ralloc_free(fs_module.nir);
 235         return result;
 236 }
 237
 238 void
 239 radv_device_finish_meta_resolve_state(struct radv_device *device)
 240 {
 241         struct radv_meta_state *state = &device->meta_state;
 242
 243         for (uint32_t j = 0; j < NUM_META_FS_KEYS; j++) {
 244                 radv_DestroyRenderPass(radv_device_to_handle(device),
 245                                        state->resolve.pass[j], &state->alloc);
 246                 radv_DestroyPipeline(radv_device_to_handle(device),
 247                                      state->resolve.pipeline[j], &state->alloc);
 248         }
 249         radv_DestroyPipelineLayout(radv_device_to_handle(device),
 250                                    state->resolve.p_layout, &state->alloc);
 251
 252 }
 253
 254 VkResult
 255 radv_device_init_meta_resolve_state(struct radv_device *device, bool on_demand)
 256 {
 257         if (on_demand)
 258                 return VK_SUCCESS;
 259
 260         VkResult res = VK_SUCCESS;
 261         struct radv_meta_state *state = &device->meta_state;
 262         struct radv_shader_module vs_module = { .nir = radv_meta_build_nir_vs_generate_vertices() };
 263         if (!vs_module.nir) {
 264                 /* XXX: Need more accurate error */
 265                 res = VK_ERROR_OUT_OF_HOST_MEMORY;
 266                 goto fail;
 267         }
 268
 269         for (uint32_t i = 0; i < NUM_META_FS_KEYS; ++i) {
 270                 VkFormat format = radv_fs_key_format_exemplars[i];
 271                 unsigned fs_key = radv_format_meta_fs_key(format);
 272                 res = create_pass(device, format, &state->resolve.pass[fs_key]);
 273                 if (res != VK_SUCCESS)
 274                         goto fail;
 275
 276                 VkShaderModule vs_module_h = radv_shader_module_to_handle(&vs_module);
 277                 res = create_pipeline(device, vs_module_h,
 278                                       &state->resolve.pipeline[fs_key], state->resolve.pass[fs_key]);
 279                 if (res != VK_SUCCESS)
 280                         goto fail;
 281         }
 282
 283         goto cleanup;
 284
 285 fail:
 286         radv_device_finish_meta_resolve_state(device);
 287
 288 cleanup:
 289         ralloc_free(vs_module.nir);
 290
 291         return res;
 292 }
 293
 294 static void
 295 emit_resolve(struct radv_cmd_buffer *cmd_buffer,
 296              VkFormat vk_format,
 297              const VkOffset2D *dest_offset,
 298              const VkExtent2D *resolve_extent)
 299 {
 300         struct radv_device *device = cmd_buffer->device;
 301         VkCommandBuffer cmd_buffer_h = radv_cmd_buffer_to_handle(cmd_buffer);
 302         unsigned fs_key = radv_format_meta_fs_key(vk_format);
 303
 304         cmd_buffer->state.flush_bits |= RADV_CMD_FLAG_FLUSH_AND_INV_CB;
 305
 306         radv_CmdBindPipeline(cmd_buffer_h, VK_PIPELINE_BIND_POINT_GRAPHICS,
 307                              device->meta_state.resolve.pipeline[fs_key]);
 308
 309         radv_CmdSetViewport(radv_cmd_buffer_to_handle(cmd_buffer), 0, 1, &(VkViewport) {
 310                 .x = dest_offset->x,
 311                 .y = dest_offset->y,
 312                 .width = resolve_extent->width,
 313                 .height = resolve_extent->height,
 314                 .minDepth = 0.0f,
 315                 .maxDepth = 1.0f
 316         });
 317
 318         radv_CmdSetScissor(radv_cmd_buffer_to_handle(cmd_buffer), 0, 1, &(VkRect2D) {
 319                 .offset = *dest_offset,
 320                 .extent = *resolve_extent,
 321         });
 322
 323         radv_CmdDraw(cmd_buffer_h, 3, 1, 0, 0);
 324         cmd_buffer->state.flush_bits |= RADV_CMD_FLAG_FLUSH_AND_INV_CB;
 325 }
 326
 327 enum radv_resolve_method {
 328         RESOLVE_HW,
 329         RESOLVE_COMPUTE,
 330         RESOLVE_FRAGMENT,
 331 };
 332
 333 static void radv_pick_resolve_method_images(struct radv_image *src_image,
 334                                             VkFormat src_format,
 335                                             struct radv_image *dest_image,
 336                                             VkImageLayout dest_image_layout,
 337                                             struct radv_cmd_buffer *cmd_buffer,
 338                                             enum radv_resolve_method *method)
 339
 340 {
 341         uint32_t queue_mask = radv_image_queue_family_mask(dest_image,
 342                                                            cmd_buffer->queue_family_index,
 343                                                            cmd_buffer->queue_family_index);
 344
 345         if (src_format == VK_FORMAT_R16G16_UNORM ||
 346             src_format == VK_FORMAT_R16G16_SNORM)
 347                 *method = RESOLVE_COMPUTE;
 348         else if (vk_format_is_int(src_format))
 349                 *method = RESOLVE_COMPUTE;
 350         else if (src_image->info.array_size > 1 ||
 351                  dest_image->info.array_size > 1)
 352                 *method = RESOLVE_COMPUTE;
 353
 354         if (radv_layout_dcc_compressed(dest_image, dest_image_layout, queue_mask)) {
 355                 *method = RESOLVE_FRAGMENT;
 356         } else if (dest_image->planes[0].surface.micro_tile_mode !=
 357                    src_image->planes[0].surface.micro_tile_mode) {
 358                 *method = RESOLVE_COMPUTE;
 359         }
 360 }
 361
 362 static VkResult
 363 build_resolve_pipeline(struct radv_device *device,
 364                        unsigned fs_key)
 365 {
 366         VkResult result = VK_SUCCESS;
 367
 368         if (device->meta_state.resolve.pipeline[fs_key])
 369                 return result;
 370
 371         mtx_lock(&device->meta_state.mtx);
 372         if (device->meta_state.resolve.pipeline[fs_key]) {
 373                 mtx_unlock(&device->meta_state.mtx);
 374                 return result;
 375         }
 376
 377         struct radv_shader_module vs_module = { .nir = radv_meta_build_nir_vs_generate_vertices() };
 378
 379         result = create_pass(device, radv_fs_key_format_exemplars[fs_key], &device->meta_state.resolve.pass[fs_key]);
 380         if (result != VK_SUCCESS)
 381                 goto fail;
 382
 383         VkShaderModule vs_module_h = radv_shader_module_to_handle(&vs_module);
 384         result = create_pipeline(device, vs_module_h, &device->meta_state.resolve.pipeline[fs_key], device->meta_state.resolve.pass[fs_key]);
 385
 386 fail:
 387         ralloc_free(vs_module.nir);
 388         mtx_unlock(&device->meta_state.mtx);
 389         return result;
 390 }
 391
 392 void radv_CmdResolveImage(
 393         VkCommandBuffer                             cmd_buffer_h,
 394         VkImage                                     src_image_h,
 395         VkImageLayout                               src_image_layout,
 396         VkImage                                     dest_image_h,
 397         VkImageLayout                               dest_image_layout,
 398         uint32_t                                    region_count,
 399         const VkImageResolve*                       regions)
 400 {
 401         RADV_FROM_HANDLE(radv_cmd_buffer, cmd_buffer, cmd_buffer_h);
 402         RADV_FROM_HANDLE(radv_image, src_image, src_image_h);
 403         RADV_FROM_HANDLE(radv_image, dest_image, dest_image_h);
 404         struct radv_device *device = cmd_buffer->device;
 405         struct radv_meta_saved_state saved_state;
 406         VkDevice device_h = radv_device_to_handle(device);
 407         enum radv_resolve_method resolve_method = RESOLVE_HW;
 408         /* we can use the hw resolve only for single full resolves */
 409         if (region_count == 1) {
 410                 if (regions[0].srcOffset.x ||
 411                     regions[0].srcOffset.y ||
 412                     regions[0].srcOffset.z)
 413                         resolve_method = RESOLVE_COMPUTE;
 414                 if (regions[0].dstOffset.x ||
 415                     regions[0].dstOffset.y ||
 416                     regions[0].dstOffset.z)
 417                         resolve_method = RESOLVE_COMPUTE;
 418
 419                 if (regions[0].extent.width != src_image->info.width ||
 420                     regions[0].extent.height != src_image->info.height ||
 421                     regions[0].extent.depth != src_image->info.depth)
 422                         resolve_method = RESOLVE_COMPUTE;
 423         } else
 424                 resolve_method = RESOLVE_COMPUTE;
 425
 426         radv_pick_resolve_method_images(src_image, src_image->vk_format,
 427                                         dest_image, dest_image_layout,
 428                                         cmd_buffer, &resolve_method);
 429
 430         if (resolve_method == RESOLVE_FRAGMENT) {
 431                 radv_meta_resolve_fragment_image(cmd_buffer,
 432                                                  src_image,
 433                                                  src_image_layout,
 434                                                  dest_image,
 435                                                  dest_image_layout,
 436                                                  region_count, regions);
 437                 return;
 438         }
 439
 440         if (resolve_method == RESOLVE_COMPUTE) {
 441                 radv_meta_resolve_compute_image(cmd_buffer,
 442                                                 src_image,
 443                                                 src_image->vk_format,
 444                                                 src_image_layout,
 445                                                 dest_image,
 446                                                 dest_image->vk_format,
 447                                                 dest_image_layout,
 448                                                 region_count, regions);
 449                 return;
 450         }
 451
 452         radv_meta_save(&saved_state, cmd_buffer,
 453                        RADV_META_SAVE_GRAPHICS_PIPELINE);
 454
 455         assert(src_image->info.samples > 1);
 456         if (src_image->info.samples <= 1) {
 457                 /* this causes GPU hangs if we get past here */
 458                 fprintf(stderr, "radv: Illegal resolve operation (src not multisampled), will hang GPU.");
 459                 return;
 460         }
 461         assert(dest_image->info.samples == 1);
 462
 463         if (src_image->info.array_size > 1)
 464                 radv_finishme("vkCmdResolveImage: multisample array images");
 465
 466         if (radv_image_has_dcc(dest_image)) {
 467                 radv_initialize_dcc(cmd_buffer, dest_image, 0xffffffff);
 468         }
 469         unsigned fs_key = radv_format_meta_fs_key(dest_image->vk_format);
 470         for (uint32_t r = 0; r < region_count; ++r) {
 471                 const VkImageResolve *region = &regions[r];
 472
 473                 /* From the Vulkan 1.0 spec:
 474                  *
 475                  *    - The aspectMask member of srcSubresource and dstSubresource must
 476                  *      only contain VK_IMAGE_ASPECT_COLOR_BIT
 477                  *
 478                  *    - The layerCount member of srcSubresource and dstSubresource must
 479                  *      match
 480                  */
 481                 assert(region->srcSubresource.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT);
 482                 assert(region->dstSubresource.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT);
 483                 assert(region->srcSubresource.layerCount ==
 484                        region->dstSubresource.layerCount);
 485
 486                 const uint32_t src_base_layer =
 487                         radv_meta_get_iview_layer(src_image, &region->srcSubresource,
 488                                                   &region->srcOffset);
 489
 490                 const uint32_t dest_base_layer =
 491                         radv_meta_get_iview_layer(dest_image, &region->dstSubresource,
 492                                                   &region->dstOffset);
 493
 494                 /**
 495                  * From Vulkan 1.0.6 spec: 18.6 Resolving Multisample Images
 496                  *
 497                  *    extent is the size in texels of the source image to resolve in width,
 498                  *    height and depth. 1D images use only x and width. 2D images use x, y,
 499                  *    width and height. 3D images use x, y, z, width, height and depth.
 500                  *
 501                  *    srcOffset and dstOffset select the initial x, y, and z offsets in
 502                  *    texels of the sub-regions of the source and destination image data.
 503                  *    extent is the size in texels of the source image to resolve in width,
 504                  *    height and depth. 1D images use only x and width. 2D images use x, y,
 505                  *    width and height. 3D images use x, y, z, width, height and depth.
 506                  */
 507                 const struct VkExtent3D extent =
 508                         radv_sanitize_image_extent(src_image->type, region->extent);
 509                 const struct VkOffset3D dstOffset =
 510                         radv_sanitize_image_offset(dest_image->type, region->dstOffset);
 511
 512
 513                 for (uint32_t layer = 0; layer < region->srcSubresource.layerCount;
 514                      ++layer) {
 515
 516                         VkResult ret = build_resolve_pipeline(device, fs_key);
 517                         if (ret != VK_SUCCESS) {
 518                                 cmd_buffer->record_result = ret;
 519                                 break;
 520                         }
 521
 522                         struct radv_image_view src_iview;
 523                         radv_image_view_init(&src_iview, cmd_buffer->device,
 524                                              &(VkImageViewCreateInfo) {
 525                                                      .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
 526                                                              .image = src_image_h,
 527                                                              .viewType = radv_meta_get_view_type(src_image),
 528                                                              .format = src_image->vk_format,
 529                                                              .subresourceRange = {
 530                                                              .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
 531                                                              .baseMipLevel = region->srcSubresource.mipLevel,
 532                                                              .levelCount = 1,
 533                                                              .baseArrayLayer = src_base_layer + layer,
 534                                                              .layerCount = 1,
 535                                                      },
 536                                              });
 537
 538                         struct radv_image_view dest_iview;
 539                         radv_image_view_init(&dest_iview, cmd_buffer->device,
 540                                              &(VkImageViewCreateInfo) {
 541                                                      .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
 542                                                              .image = dest_image_h,
 543                                                              .viewType = radv_meta_get_view_type(dest_image),
 544                                                              .format = dest_image->vk_format,
 545                                                              .subresourceRange = {
 546                                                              .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
 547                                                              .baseMipLevel = region->dstSubresource.mipLevel,
 548                                                              .levelCount = 1,
 549                                                              .baseArrayLayer = dest_base_layer + layer,
 550                                                              .layerCount = 1,
 551                                                      },
 552                                               });
 553
 554                         VkFramebuffer fb_h;
 555                         radv_CreateFramebuffer(device_h,
 556                                                &(VkFramebufferCreateInfo) {
 557                                                        .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
 558                                                                .attachmentCount = 2,
 559                                                                .pAttachments = (VkImageView[]) {
 560                                                                radv_image_view_to_handle(&src_iview),
 561                                                                radv_image_view_to_handle(&dest_iview),
 562                                                        },
 563                                                        .width = radv_minify(dest_image->info.width,
 564                                                                             region->dstSubresource.mipLevel),
 565                                                        .height = radv_minify(dest_image->info.height,
 566                                                                               region->dstSubresource.mipLevel),
 567                                                        .layers = 1
 568                                                },
 569                                                &cmd_buffer->pool->alloc,
 570                                                &fb_h);
 571
 572                         radv_CmdBeginRenderPass(cmd_buffer_h,
 573                                                       &(VkRenderPassBeginInfo) {
 574                                                               .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
 575                                                                       .renderPass = device->meta_state.resolve.pass[fs_key],
 576                                                                       .framebuffer = fb_h,
 577                                                                       .renderArea = {
 578                                                                       .offset = {
 579                                                                               dstOffset.x,
 580                                                                               dstOffset.y,
 581                                                                       },
 582                                                                       .extent = {
 583                                                                               extent.width,
 584                                                                               extent.height,
 585                                                                       }
 586                                                               },
 587                                                               .clearValueCount = 0,
 588                                                               .pClearValues = NULL,
 589                                                       },
 590                                                       VK_SUBPASS_CONTENTS_INLINE);
 591
 592                         emit_resolve(cmd_buffer,
 593                                      dest_iview.vk_format,
 594                                      &(VkOffset2D) {
 595                                              .x = dstOffset.x,
 596                                              .y = dstOffset.y,
 597                                      },
 598                                      &(VkExtent2D) {
 599                                              .width = extent.width,
 600                                              .height = extent.height,
 601                                      });
 602
 603                         radv_CmdEndRenderPass(cmd_buffer_h);
 604
 605                         radv_DestroyFramebuffer(device_h, fb_h,
 606                                                 &cmd_buffer->pool->alloc);
 607                 }
 608         }
 609
 610         radv_meta_restore(&saved_state, cmd_buffer);
 611 }
 612
 613 /**
 614  * Emit any needed resolves for the current subpass.
 615  */
 616 void
 617 radv_cmd_buffer_resolve_subpass(struct radv_cmd_buffer *cmd_buffer)
 618 {
 619         struct radv_framebuffer *fb = cmd_buffer->state.framebuffer;
 620         const struct radv_subpass *subpass = cmd_buffer->state.subpass;
 621         struct radv_meta_saved_state saved_state;
 622         enum radv_resolve_method resolve_method = RESOLVE_HW;
 623
 624         if (!subpass->has_resolve)
 625                 return;
 626
 627         for (uint32_t i = 0; i < subpass->color_count; ++i) {
 628                 struct radv_subpass_attachment src_att = subpass->color_attachments[i];
 629                 struct radv_subpass_attachment dest_att = subpass->resolve_attachments[i];
 630
 631                 if (dest_att.attachment == VK_ATTACHMENT_UNUSED)
 632                         continue;
 633
 634                 /* Make sure to not clear color attachments after resolves. */
 635                 cmd_buffer->state.attachments[dest_att.attachment].pending_clear_aspects = 0;
 636
 637                 struct radv_image *dst_img = cmd_buffer->state.framebuffer->attachments[dest_att.attachment].attachment->image;
 638                 struct radv_image_view *src_iview= cmd_buffer->state.framebuffer->attachments[src_att.attachment].attachment;
 639                 struct radv_image *src_img = src_iview->image;
 640
 641                 radv_pick_resolve_method_images(src_img, src_iview->vk_format,
 642                                                 dst_img, dest_att.layout,
 643                                                 cmd_buffer, &resolve_method);
 644
 645                 if (resolve_method == RESOLVE_FRAGMENT) {
 646                         break;
 647                 }
 648         }
 649
 650         if (resolve_method == RESOLVE_COMPUTE) {
 651                 radv_cmd_buffer_resolve_subpass_cs(cmd_buffer);
 652                 return;
 653         } else if (resolve_method == RESOLVE_FRAGMENT) {
 654                 radv_cmd_buffer_resolve_subpass_fs(cmd_buffer);
 655                 return;
 656         }
 657
 658         radv_meta_save(&saved_state, cmd_buffer,
 659                        RADV_META_SAVE_GRAPHICS_PIPELINE);
 660
 661         for (uint32_t i = 0; i < subpass->color_count; ++i) {
 662                 struct radv_subpass_attachment src_att = subpass->color_attachments[i];
 663                 struct radv_subpass_attachment dest_att = subpass->resolve_attachments[i];
 664
 665                 if (dest_att.attachment == VK_ATTACHMENT_UNUSED)
 666                         continue;
 667
 668                 struct radv_image_view *dest_iview = cmd_buffer->state.framebuffer->attachments[dest_att.attachment].attachment;
 669                 struct radv_image *dst_img = dest_iview->image;
 670
 671                 if (radv_image_has_dcc(dst_img)) {
 672                         radv_initialize_dcc(cmd_buffer, dst_img, 0xffffffff);
 673                         cmd_buffer->state.attachments[dest_att.attachment].current_layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 674                 }
 675
 676                 struct radv_subpass resolve_subpass = {
 677                         .color_count = 2,
 678                         .color_attachments = (struct radv_subpass_attachment[]) { src_att, dest_att },
 679                         .depth_stencil_attachment = NULL,
 680                 };
 681
 682                 radv_cmd_buffer_set_subpass(cmd_buffer, &resolve_subpass);
 683
 684                 VkResult ret = build_resolve_pipeline(cmd_buffer->device, radv_format_meta_fs_key(dest_iview->vk_format));
 685                 if (ret != VK_SUCCESS) {
 686                         cmd_buffer->record_result = ret;
 687                         continue;
 688                 }
 689
 690                 emit_resolve(cmd_buffer,
 691                              dest_iview->vk_format,
 692                              &(VkOffset2D) { 0, 0 },
 693                              &(VkExtent2D) { fb->width, fb->height });
 694         }
 695
 696         radv_cmd_buffer_set_subpass(cmd_buffer, subpass);
 697
 698         radv_meta_restore(&saved_state, cmd_buffer);
 699 }
 700
 701 /**
 702  * Decompress CMask/FMask before resolving a multisampled source image inside a
 703  * subpass.
 704  */
 705 void
 706 radv_decompress_resolve_subpass_src(struct radv_cmd_buffer *cmd_buffer)
 707 {
 708         const struct radv_subpass *subpass = cmd_buffer->state.subpass;
 709         struct radv_framebuffer *fb = cmd_buffer->state.framebuffer;
 710         uint32_t layer_count = fb->layers;
 711
 712         if (subpass->view_mask)
 713                 layer_count = util_last_bit(subpass->view_mask);
 714
 715         for (uint32_t i = 0; i < subpass->color_count; ++i) {
 716                 struct radv_subpass_attachment src_att = subpass->color_attachments[i];
 717                 struct radv_subpass_attachment dest_att = subpass->resolve_attachments[i];
 718
 719                 if (dest_att.attachment == VK_ATTACHMENT_UNUSED)
 720                         continue;
 721
 722                 struct radv_image_view *src_iview =
 723                         fb->attachments[src_att.attachment].attachment;
 724                 struct radv_image *src_image = src_iview->image;
 725
 726                 VkImageResolve region = {};
 727                 region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
 728                 region.srcSubresource.mipLevel = 0;
 729                 region.srcSubresource.baseArrayLayer = src_iview->base_layer;
 730                 region.srcSubresource.layerCount = layer_count;
 731
 732                 radv_decompress_resolve_src(cmd_buffer, src_image,
 733                                             src_att.layout, 1, &region);
 734         }
 735 }
 736
 737 /**
 738  * Decompress CMask/FMask before resolving a multisampled source image.
 739  */
 740 void
 741 radv_decompress_resolve_src(struct radv_cmd_buffer *cmd_buffer,
 742                             struct radv_image *src_image,
 743                             VkImageLayout src_image_layout,
 744                             uint32_t region_count,
 745                             const VkImageResolve *regions)
 746 {
 747         for (uint32_t r = 0; r < region_count; ++r) {
 748                 const VkImageResolve *region = &regions[r];
 749                 const uint32_t src_base_layer =
 750                         radv_meta_get_iview_layer(src_image, &region->srcSubresource,
 751                                                   &region->srcOffset);
 752
 753                 VkImageMemoryBarrier barrier = {};
 754                 barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
 755                 barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
 756                 barrier.oldLayout = src_image_layout;
 757                 barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
 758                 barrier.image = radv_image_to_handle(src_image);
 759                 barrier.subresourceRange = (VkImageSubresourceRange) {
 760                         .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
 761                         .baseMipLevel = region->srcSubresource.mipLevel,
 762                         .levelCount = 1,
 763                         .baseArrayLayer = src_base_layer,
 764                         .layerCount = region->srcSubresource.layerCount,
 765                 };
 766
 767                 radv_CmdPipelineBarrier(radv_cmd_buffer_to_handle(cmd_buffer),
 768                                         VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
 769                                         VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
 770                                         false, 0, NULL, 0, NULL, 1, &barrier);
 771         }
 772 }