projects / mesa.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
radeonsi: use storage_samples instead of color_samples in most places
[mesa.git] / src / amd / vulkan / radv_image.c
diff --git a/src/amd/vulkan/radv_image.c b/src/amd/vulkan/radv_image.c
index 5cdffe1627f1106feb168d738655470609ca5d08..f1c78e8115d98549f4cf5ca9bd9e1be3f050d1e8 100644 (file)
--- a/src/amd/vulkan/radv_image.c
+++ b/src/amd/vulkan/radv_image.c
@@ -110,6 +110,8 @@ radv_use_dcc_for_image(struct radv_device *device,
 {
        bool dcc_compatible_formats;
        bool blendable;
+       bool shareable = vk_find_struct_const(pCreateInfo->pNext,
+                                             EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR) != NULL;
 
        /* DCC (Delta Color Compression) is only available for GFX8+. */
        if (device->physical_device->rad_info.chip_class < VI)
@@ -118,6 +120,11 @@ radv_use_dcc_for_image(struct radv_device *device,
        if (device->instance->debug_flags & RADV_DEBUG_NO_DCC)
                return false;
 
+       /* FIXME: DCC is broken for shareable images starting with GFX9 */
+       if (device->physical_device->rad_info.chip_class >= GFX9 &&
+           shareable)
+               return false;
+
        /* TODO: Enable DCC for storage images. */
        if ((pCreateInfo->usage & VK_IMAGE_USAGE_STORAGE_BIT) ||
            (pCreateInfo->flags & VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR))
@@ -726,58 +733,20 @@ radv_image_get_fmask_info(struct radv_device *device,
                          unsigned nr_samples,
                          struct radv_fmask_info *out)
 {
-       /* FMASK is allocated like an ordinary texture. */
-       struct radeon_surf fmask = {};
-       struct ac_surf_info info = image->info;
-       memset(out, 0, sizeof(*out));
-
        if (device->physical_device->rad_info.chip_class >= GFX9) {
-               out->alignment = image->surface.u.gfx9.fmask_alignment;
-               out->size = image->surface.u.gfx9.fmask_size;
+               out->alignment = image->surface.fmask_alignment;
+               out->size = image->surface.fmask_size;
+               out->tile_swizzle = image->surface.fmask_tile_swizzle;
                return;
        }
 
-       fmask.blk_w = image->surface.blk_w;
-       fmask.blk_h = image->surface.blk_h;
-       info.samples = 1;
-       fmask.flags = image->surface.flags | RADEON_SURF_FMASK;
-
-       if (!image->shareable) {
-               info.fmask_surf_index = &device->fmask_mrt_offset_counter;
-               info.surf_index = &device->fmask_mrt_offset_counter;
-       }
-
-       /* Force 2D tiling if it wasn't set. This may occur when creating
-        * FMASK for MSAA resolve on R6xx. On R6xx, the single-sample
-        * destination buffer must have an FMASK too. */
-       fmask.flags = RADEON_SURF_CLR(fmask.flags, MODE);
-       fmask.flags |= RADEON_SURF_SET(RADEON_SURF_MODE_2D, MODE);
-
-       switch (nr_samples) {
-       case 2:
-       case 4:
-               fmask.bpe = 1;
-               break;
-       case 8:
-               fmask.bpe = 4;
-               break;
-       default:
-               return;
-       }
-
-       device->ws->surface_init(device->ws, &info, &fmask);
-       assert(fmask.u.legacy.level[0].mode == RADEON_SURF_MODE_2D);
-
-       out->slice_tile_max = (fmask.u.legacy.level[0].nblk_x * fmask.u.legacy.level[0].nblk_y) / 64;
-       if (out->slice_tile_max)
-               out->slice_tile_max -= 1;
-
-       out->tile_mode_index = fmask.u.legacy.tiling_index[0];
-       out->pitch_in_pixels = fmask.u.legacy.level[0].nblk_x;
-       out->bank_height = fmask.u.legacy.bankh;
-       out->tile_swizzle = fmask.tile_swizzle;
-       out->alignment = MAX2(256, fmask.surf_alignment);
-       out->size = fmask.surf_size;
+       out->slice_tile_max = image->surface.u.legacy.fmask.slice_tile_max;
+       out->tile_mode_index = image->surface.u.legacy.fmask.tiling_index;
+       out->pitch_in_pixels = image->surface.u.legacy.fmask.pitch_in_pixels;
+       out->bank_height = image->surface.u.legacy.fmask.bankh;
+       out->tile_swizzle = image->surface.fmask_tile_swizzle;
+       out->alignment = image->surface.fmask_alignment;
+       out->size = image->surface.fmask_size;
 
        assert(!out->tile_swizzle || !image->shareable);
 }
@@ -803,8 +772,8 @@ radv_image_get_cmask_info(struct radv_device *device,
        unsigned cl_width, cl_height;
 
        if (device->physical_device->rad_info.chip_class >= GFX9) {
-               out->alignment = image->surface.u.gfx9.cmask_alignment;
-               out->size = image->surface.u.gfx9.cmask_size;
+               out->alignment = image->surface.cmask_alignment;
+               out->size = image->surface.cmask_size;
                return;
        }
 
@@ -961,13 +930,14 @@ radv_image_create(VkDevice _device,
        image = vk_zalloc2(&device->alloc, alloc, sizeof(*image), 8,
                           VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
        if (!image)
-               return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
+               return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
 
        image->type = pCreateInfo->imageType;
        image->info.width = pCreateInfo->extent.width;
        image->info.height = pCreateInfo->extent.height;
        image->info.depth = pCreateInfo->extent.depth;
        image->info.samples = pCreateInfo->samples;
+       image->info.storage_samples = pCreateInfo->samples;
        image->info.array_size = pCreateInfo->arrayLayers;
        image->info.levels = pCreateInfo->mipLevels;
        image->info.num_channels = vk_format_get_nr_components(pCreateInfo->format);
@@ -1045,7 +1015,7 @@ radv_image_create(VkDevice _device,
                                                      0, RADEON_FLAG_VIRTUAL);
                if (!image->bo) {
                        vk_free2(&device->alloc, alloc, image);
-                       return vk_error(VK_ERROR_OUT_OF_DEVICE_MEMORY);
+                       return vk_error(device->instance, VK_ERROR_OUT_OF_DEVICE_MEMORY);
                }
        }
 
@@ -1360,7 +1330,7 @@ radv_CreateImageView(VkDevice _device,
        view = vk_alloc2(&device->alloc, pAllocator, sizeof(*view), 8,
                           VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
        if (view == NULL)
-               return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
+               return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
 
        radv_image_view_init(view, device, pCreateInfo);
 
@@ -1408,7 +1378,7 @@ radv_CreateBufferView(VkDevice _device,
        view = vk_alloc2(&device->alloc, pAllocator, sizeof(*view), 8,
                           VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
        if (!view)
-               return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
+               return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
 
        radv_buffer_view_init(view, device, pCreateInfo);