Lines Matching refs:image
60 image_aspect_to_binding(struct anv_image *image, VkImageAspectFlags aspect)
64 assert(image->disjoint);
66 if (image->vk.tiling == VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT) {
74 assert(!isl_drm_modifier_has_aux(image->vk.drm_format_mod));
78 plane = anv_image_aspect_to_plane(image, aspect);
81 return &image->bindings[ANV_IMAGE_MEMORY_BINDING_PLANE_0 + plane];
95 struct anv_image *image,
115 if (!image->disjoint)
126 &image->bindings[binding].memory_range;
246 /* blorp implements transfers by sampling from the source image. */
252 /* blorp implements transfers by rendering into the destination image.
310 struct anv_image *image,
318 return image_binding_grow(device, image, binding, offset,
325 * Do hardware limitations require the image plane to use a shadow surface?
331 * If the image plane is a separate stencil plane and if the user provided
374 const struct anv_image *image,
381 if (!isl_aux_usage_has_fast_clears(image->planes[plane].aux_usage))
392 image->planes[plane].aux_usage == ISL_AUX_USAGE_CCS_E)
395 /* Non mutable image, we can fast clear with any color supported by HW.
397 if (!(image->vk.create_flags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT))
400 /* Mutable image with no format list, we have to assume all formats */
404 enum isl_format img_format = image->planes[plane].primary_surface.isl.format;
410 plane, image->vk.tiling);
443 * Return true if the storage image could be used with atomics.
445 * If the image was created with an explicit format, we check it for typed
449 * make an image view with a format that does use atomics.
592 * allows us to access the image's subresources while being aware of their
597 * image (hence a single RENDER_SURFACE_STATE), we only allow fast-clears on
602 * The fast clear portion of the image is laid out in the following order:
606 * * On gfx9+, 1 dword per level and layer of the image (3D levels count
613 * all of the values in the fast clear portion of the image are initialized
626 * from the image layouts. The command streamer inspects the fast clear
645 struct anv_image *image,
648 assert(image && device);
649 assert(image->planes[plane].aux_usage != ISL_AUX_USAGE_NONE &&
650 image->vk.aspects & (VK_IMAGE_ASPECT_ANY_COLOR_BIT_ANV |
661 if (image->planes[plane].aux_usage == ISL_AUX_USAGE_CCS_E) {
662 if (image->vk.image_type == VK_IMAGE_TYPE_3D) {
663 for (uint32_t l = 0; l < image->vk.mip_levels; l++)
664 state_size += anv_minify(image->vk.extent.depth, l) * 4;
666 state_size += image->vk.mip_levels * image->vk.array_layers * 4;
673 /* If an auxiliary surface is used for an externally-shareable image,
674 * we have to hide this from the memory of the image since other
679 if (anv_image_is_externally_shared(image)) {
686 return image_binding_grow(device, image, binding,
688 &image->planes[plane].fast_clear_memory_range);
702 struct anv_image *image,
715 assert(!anv_surface_is_valid(&image->planes[plane].aux_surface));
724 assert(!(image->vk.usage & VK_IMAGE_USAGE_STORAGE_BIT));
729 if (!(image->vk.usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
735 anv_perf_warn(VK_LOG_OBJS(&image->vk.base), "Implement gfx7 HiZ");
739 if (image->vk.mip_levels > 1) {
740 anv_perf_warn(VK_LOG_OBJS(&image->vk.base), "Enable multi-LOD HiZ");
744 if (device->info.ver == 8 && image->vk.samples > 1) {
745 anv_perf_warn(VK_LOG_OBJS(&image->vk.base),
754 &image->planes[plane].primary_surface.isl,
755 &image->planes[plane].aux_surface.isl);
760 &image->planes[plane].primary_surface.isl,
761 &image->planes[plane].aux_surface.isl)) {
762 image->planes[plane].aux_usage = ISL_AUX_USAGE_HIZ;
763 } else if (image->vk.usage & (VK_IMAGE_USAGE_SAMPLED_BIT |
765 image->vk.samples == 1) {
775 image->planes[plane].aux_usage = ISL_AUX_USAGE_HIZ_CCS_WT;
778 image->planes[plane].aux_usage = ISL_AUX_USAGE_HIZ_CCS;
781 result = add_surface(device, image, &image->planes[plane].aux_surface,
787 if (image->planes[plane].aux_usage == ISL_AUX_USAGE_HIZ_CCS_WT)
788 return add_aux_state_tracking_buffer(device, image, plane);
795 &image->planes[plane].primary_surface.isl,
799 image->planes[plane].aux_usage = ISL_AUX_USAGE_STC_CCS;
800 } else if ((aspect & VK_IMAGE_ASPECT_ANY_COLOR_BIT_ANV) && image->vk.samples == 1) {
801 if (image->n_planes != 1) {
809 if ((image->vk.create_flags & VK_IMAGE_CREATE_ALIAS_BIT)) {
810 /* The image may alias a plane of a multiplanar image. Above we ban
813 * We must also reject aliasing of any image that uses
815 * aliasing here, there's no need to further analyze if the image needs
825 &image->planes[plane].primary_surface.isl,
827 &image->planes[plane].aux_surface.isl,
833 if (anv_formats_ccs_e_compatible(&device->info, image->vk.create_flags,
834 image->vk.format, image->vk.tiling,
835 image->vk.usage, fmt_list)) {
836 image->planes[plane].aux_usage = ISL_AUX_USAGE_CCS_E;
838 anv_perf_warn(VK_LOG_OBJS(&image->vk.base),
841 image->planes[plane].aux_surface.isl.size_B = 0;
844 image->planes[plane].aux_usage = ISL_AUX_USAGE_CCS_D;
851 if (image->vk.drm_format_mod != DRM_FORMAT_MOD_INVALID &&
852 !isl_drm_modifier_has_aux(image->vk.drm_format_mod))
855 result = add_surface(device, image, &image->planes[plane].aux_surface,
861 return add_aux_state_tracking_buffer(device, image, plane);
862 } else if ((aspect & VK_IMAGE_ASPECT_ANY_COLOR_BIT_ANV) && image->vk.samples > 1) {
863 assert(!(image->vk.usage & VK_IMAGE_USAGE_STORAGE_BIT));
865 &image->planes[plane].primary_surface.isl,
866 &image->planes[plane].aux_surface.isl);
870 image->planes[plane].aux_usage = ISL_AUX_USAGE_MCS;
872 result = add_surface(device, image, &image->planes[plane].aux_surface,
878 return add_aux_state_tracking_buffer(device, image, plane);
886 struct anv_image *image,
895 &image->planes[plane].shadow_surface.isl,
896 .dim = vk_to_isl_surf_dim[image->vk.image_type],
898 .width = image->vk.extent.width,
899 .height = image->vk.extent.height,
900 .depth = image->vk.extent.depth,
901 .levels = image->vk.mip_levels,
902 .array_len = image->vk.array_layers,
903 .samples = image->vk.samples,
915 return add_surface(device, image, &image->planes[plane].shadow_surface,
922 * image's memory requirements (that is, the image's size and alignment).
928 struct anv_image *image,
936 struct anv_surface *anv_surf = &image->planes[plane].primary_surface;
940 .dim = vk_to_isl_surf_dim[image->vk.image_type],
942 .width = image->vk.extent.width / plane_format.denominator_scales[0],
943 .height = image->vk.extent.height / plane_format.denominator_scales[1],
944 .depth = image->vk.extent.depth,
945 .levels = image->vk.mip_levels,
946 .array_len = image->vk.array_layers,
947 .samples = image->vk.samples,
960 image->planes[plane].aux_usage = ISL_AUX_USAGE_NONE;
962 return add_surface(device, image, anv_surf,
1019 * Validate the image's memory bindings *after* all its surfaces and memory
1022 * For simplicity's sake, we do not validate free-form layout of the image's
1028 const struct anv_image *image)
1031 /* As we inspect each part of the image, we merge the part's memory range
1041 for (uint32_t p = 0; p < image->n_planes; ++p) {
1042 const struct anv_image_plane *plane = &image->planes[p];
1045 const enum anv_image_memory_binding primary_binding = image->disjoint
1052 assert(!(image->vk.create_flags & VK_IMAGE_CREATE_ALIAS_BIT) ||
1053 image->bindings[ANV_IMAGE_MEMORY_BINDING_PRIVATE].memory_range.size == 0);
1071 /* If an auxiliary surface is used for an externally-shareable image,
1072 * we have to hide this from the memory of the image since other
1077 if (anv_image_is_externally_shared(image) &&
1078 !isl_drm_modifier_has_aux(image->vk.drm_format_mod)) {
1085 * the image is sent to display.
1096 /* If an auxiliary surface is used for an externally-shareable image,
1097 * we have to hide this from the memory of the image since other
1102 if (anv_image_is_externally_shared(image)) {
1123 * Checking compatibility at the end of image creation is prudent, not
1125 * throughout queries and image creation, and because
1133 * modifier, then vkCreateImage() produces an image that is compatible with the
1136 * unexpectedly fail in vkCreateImage(), eliminating the image's aux surface
1142 const struct anv_image *image)
1145 assert((image->vk.drm_format_mod != DRM_FORMAT_MOD_INVALID) ==
1146 (image->vk.tiling == VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT));
1148 if (image->vk.drm_format_mod == DRM_FORMAT_MOD_INVALID)
1152 isl_drm_modifier_get_info(image->vk.drm_format_mod);
1158 assert(image->vk.image_type == VK_IMAGE_TYPE_2D);
1159 assert(!(image->vk.aspects & VK_IMAGE_ASPECT_DEPTH_BIT));
1160 assert(!(image->vk.aspects & VK_IMAGE_ASPECT_STENCIL_BIT));
1161 assert(image->vk.mip_levels == 1);
1162 assert(image->vk.array_layers == 1);
1163 assert(image->vk.samples == 1);
1165 for (int i = 0; i < image->n_planes; ++i) {
1166 const struct anv_image_plane *plane = &image->planes[i];
1178 assert(!image->disjoint);
1180 /* The modifier's required aux usage mandates the image's aux usage.
1186 "image with modifier unexpectedly has wrong aux "
1202 struct anv_image *image,
1211 u_foreach_bit(b, image->vk.aspects) {
1213 const uint32_t plane = anv_image_aspect_to_plane(image, aspect);
1215 anv_get_format_plane(devinfo, image->vk.format, plane, image->vk.tiling);
1217 VkImageUsageFlags vk_usage = vk_image_usage(&image->vk, aspect);
1219 choose_isl_surf_usage(image->vk.create_flags, vk_usage,
1227 image->vk.tiling, vk_usage,
1228 image->vk.create_flags,
1231 result = add_primary_surface(device, image, plane, plane_format,
1238 result = add_shadow_surface(device, image, plane, plane_format,
1244 /* Disable aux if image supports export without modifiers. */
1245 if (image->vk.external_handle_types != 0 &&
1246 image->vk.tiling != VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT)
1249 result = add_aux_surface_if_supported(device, image, plane, plane_format,
1266 struct anv_image *image,
1301 if (image->n_planes == 1)
1302 assert(image->vk.aspects == VK_IMAGE_ASPECT_COLOR_BIT);
1304 assert(!(image->vk.aspects & ~VK_IMAGE_ASPECT_PLANES_BITS_ANV));
1307 assert(image->n_planes == 1 && mod_plane_count == 2);
1309 assert(image->n_planes == mod_plane_count);
1329 u_foreach_bit(b, image->vk.aspects) {
1331 const uint32_t plane = anv_image_aspect_to_plane(image, aspect);
1333 anv_get_format_plane(devinfo, image->vk.format, plane, image->vk.tiling);
1336 result = add_primary_surface(device, image, plane,
1347 result = add_aux_surface_if_supported(device, image, plane,
1403 struct anv_image *image,
1407 &image->bindings[ANV_IMAGE_MEMORY_BINDING_PRIVATE];
1416 /* The image will be bound to swapchain memory. */
1420 return anv_device_alloc_bo(device, "image-binding-private",
1426 anv_image_init(struct anv_device *device, struct anv_image *image,
1434 vk_image_init(&device->vk, &image->vk, pCreateInfo);
1436 image->vk.usage = anv_image_create_usage(pCreateInfo, image->vk.usage);
1437 image->vk.stencil_usage =
1438 anv_image_create_usage(pCreateInfo, image->vk.stencil_usage);
1441 assert(!image->vk.wsi_legacy_scanout);
1457 assert(image->vk.drm_format_mod == DRM_FORMAT_MOD_INVALID);
1458 image->vk.drm_format_mod = isl_mod_info->modifier;
1462 image->bindings[i] = (struct anv_image_binding) {
1468 if (image->vk.external_handle_types &
1470 image->from_ahb = true;
1474 image->n_planes = anv_get_format_planes(image->vk.format);
1478 * A disjoint image consists of multiple disjoint planes, and is created
1481 image->disjoint = image->n_planes > 1 &&
1486 image->vk.wsi_legacy_scanout);
1493 r = add_all_surfaces_explicit_layout(device, image, fmt_list,
1497 r = add_all_surfaces_implicit_layout(device, image, fmt_list, 0,
1505 r = alloc_private_binding(device, image, pCreateInfo);
1509 check_memory_bindings(device, image);
1511 r = check_drm_format_mod(device, image);
1518 for (uint32_t p = 0; p < image->n_planes; p++) {
1519 image->planes[p].can_non_zero_fast_clear =
1520 can_fast_clear_with_non_zero_color(&device->info, image, p, fmt_list);
1526 vk_image_finish(&image->vk);
1531 anv_image_finish(struct anv_image *image)
1534 container_of(image->vk.base.device, struct anv_device, vk);
1536 if (image->from_gralloc) {
1537 assert(!image->disjoint);
1538 assert(image->n_planes == 1);
1539 assert(image->planes[0].primary_surface.memory_range.binding ==
1541 assert(image->bindings[ANV_IMAGE_MEMORY_BINDING_MAIN].address.bo != NULL);
1542 anv_device_release_bo(device, image->bindings[ANV_IMAGE_MEMORY_BINDING_MAIN].address.bo);
1545 struct anv_bo *private_bo = image->bindings[ANV_IMAGE_MEMORY_BINDING_PRIVATE].address.bo;
1549 vk_image_finish(&image->vk);
1556 VkImage image = wsi_common_get_image(swapchain, index);
1557 return anv_image_from_handle(image);
1562 struct anv_image *image,
1568 return anv_image_init_from_gralloc(device, image, pCreateInfo,
1587 return anv_image_init(device, image, &create_info);
1613 struct anv_image *image =
1614 vk_object_zalloc(&device->vk, pAllocator, sizeof(*image),
1616 if (!image)
1619 VkResult result = anv_image_init_from_create_info(device, image,
1622 vk_object_free(&device->vk, pAllocator, image);
1626 *pImage = anv_image_to_handle(image);
1636 ANV_FROM_HANDLE(anv_image, image, _image);
1638 if (!image)
1641 assert(&device->vk == image->vk.base.device);
1642 anv_image_finish(image);
1644 vk_free2(&device->vk.alloc, pAllocator, image);
1652 struct anv_image *image,
1691 vk_image_set_format(&image->vk, vk_format);
1692 image->n_planes = anv_get_format_planes(image->vk.format);
1697 result = add_all_surfaces_implicit_layout(device, image, NULL, stride,
1706 struct anv_image *image,
1725 if (image->vk.wsi_legacy_scanout || image->from_ahb) {
1746 /* If the image is disjoint, then we must return the memory requirements for
1749 * whole image.
1753 * and only if the image is disjoint (that is, multi-planar format and
1757 if (image->disjoint) {
1759 assert(aspects & image->vk.aspects);
1760 binding = image_aspect_to_binding(image, aspects);
1762 assert(aspects == image->vk.aspects);
1763 binding = &image->bindings[ANV_IMAGE_MEMORY_BINDING_MAIN];
1779 ANV_FROM_HANDLE(anv_image, image, pInfo->image);
1781 VkImageAspectFlags aspects = image->vk.aspects;
1786 assert(image->disjoint);
1799 anv_image_get_memory_requirements(device, image, aspects,
1809 struct anv_image image = { 0 };
1812 anv_image_init_from_create_info(device, &image, pInfo->pCreateInfo);
1816 image.disjoint ? pInfo->planeAspect : image.vk.aspects;
1818 anv_image_get_memory_requirements(device, &image, aspects,
1824 VkImage image,
1859 ANV_FROM_HANDLE(anv_image, image, bind_info->image);
1862 /* Resolve will alter the image's aspects, do this first. */
1864 resolve_ahw_image(device, image, mem);
1875 * the image be disjoint (that is, multi-planar format and
1877 * the image to be non-disjoint and requires only that the image
1882 if (!image->disjoint)
1886 image_aspect_to_binding(image, plane_info->planeAspect);
1907 assert(image->vk.aspects == swapchain_image->vk.aspects);
1910 for (int j = 0; j < ARRAY_SIZE(image->bindings); ++j) {
1911 assert(memory_ranges_equal(image->bindings[j].memory_range,
1913 image->bindings[j].address = swapchain_image->bindings[j].address;
1920 image->bindings[ANV_IMAGE_MEMORY_BINDING_PRIVATE].address.bo;
1933 VkResult result = anv_image_bind_from_gralloc(device, image,
1948 assert(!image->disjoint);
1950 image->bindings[ANV_IMAGE_MEMORY_BINDING_MAIN].address =
1962 for (int p = 0; p < image->n_planes; ++p) {
1964 image->planes[p].primary_surface.memory_range.binding;
1966 image->bindings[binding].address.bo;
1974 if (!isl_aux_usage_has_ccs(image->planes[p].aux_usage))
1977 anv_perf_warn(VK_LOG_OBJS(&image->vk.base),
1980 if (image->planes[p].aux_surface.memory_range.size > 0) {
1981 assert(image->planes[p].aux_usage == ISL_AUX_USAGE_HIZ_CCS ||
1982 image->planes[p].aux_usage == ISL_AUX_USAGE_HIZ_CCS_WT);
1983 image->planes[p].aux_usage = ISL_AUX_USAGE_HIZ;
1985 assert(image->planes[p].aux_usage == ISL_AUX_USAGE_CCS_E ||
1986 image->planes[p].aux_usage == ISL_AUX_USAGE_STC_CCS);
1987 image->planes[p].aux_usage = ISL_AUX_USAGE_NONE;
2001 ANV_FROM_HANDLE(anv_image, image, _image);
2010 * For swapchain images, the Vulkan spec says that every swapchain image has
2015 * image. The WSI code, however, knows when it has internally created
2016 * a swapchain image with VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT,
2021 if (image->vk.tiling == VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT) {
2041 if (mem_plane == 1 && isl_drm_modifier_has_aux(image->vk.drm_format_mod)) {
2042 assert(image->n_planes == 1);
2046 assert(image->planes[0].aux_surface.memory_range.binding ==
2047 image->planes[0].primary_surface.memory_range.binding);
2048 surface = &image->planes[0].aux_surface;
2050 assert(mem_plane < image->n_planes);
2051 surface = &image->planes[mem_plane].primary_surface;
2055 anv_image_aspect_to_plane(image, subresource->aspectMask);
2056 surface = &image->planes[plane].primary_surface;
2074 layout->size = layout->rowPitch * anv_minify(image->vk.extent.height,
2076 image->vk.extent.depth;
2084 * Because Vulkan image layouts don't map directly to isl_aux_state enums, the
2088 * @param image The image that may contain a collection of buffers.
2089 * @param aspect The aspect of the image to be accessed.
2090 * @param layout The current layout of the image aspect(s).
2096 const struct anv_image * const image,
2105 /* The layout of a NULL image is not properly defined. */
2106 assert(image != NULL);
2108 /* The aspect must be exactly one of the image aspects. */
2109 assert(util_bitcount(aspect) == 1 && (aspect & image->vk.aspects));
2113 const uint32_t plane = anv_image_aspect_to_plane(image, aspect);
2116 const enum isl_aux_usage aux_usage = image->planes[plane].aux_usage;
2120 assert(image->planes[plane].primary_surface.isl.tiling != ISL_TILING_LINEAR);
2126 unreachable("Invalid image layout.");
2139 assert(image->vk.aspects == VK_IMAGE_ASPECT_COLOR_BIT);
2142 isl_drm_modifier_get_default_aux_state(image->vk.drm_format_mod);
2174 vk_image_usage(&image->vk, aspect);
2182 /* This image could be used as both an input attachment and a render
2202 if (!anv_can_sample_with_hiz(devinfo, image)) {
2222 if (!anv_can_sample_mcs_with_clear(devinfo, image))
2291 * @param image The image that may contain a collection of buffers.
2292 * @param aspect The aspect of the image to be accessed.
2293 * @param usage The usage which describes how the image will be accessed.
2294 * @param layout The current layout of the image aspect(s).
2300 const struct anv_image * const image,
2305 const uint32_t plane = anv_image_aspect_to_plane(image, aspect);
2310 if (image->planes[plane].aux_usage == ISL_AUX_USAGE_NONE)
2314 anv_layout_to_aux_state(devinfo, image, aspect, layout);
2321 assert(image->vk.aspects & VK_IMAGE_ASPECT_ANY_COLOR_BIT_ANV);
2322 assert(image->planes[plane].aux_usage == ISL_AUX_USAGE_CCS_D);
2323 assert(image->vk.samples == 1);
2328 return image->planes[plane].aux_usage;
2338 /* If we have valid HiZ data and are using the image as a read-only
2342 return image->planes[plane].aux_usage;
2357 * given image in the given VkImageLayout.
2360 * @param image The image that may contain a collection of buffers.
2361 * @param aspect The aspect of the image to be accessed.
2362 * @param usage The usage which describes how the image will be accessed.
2363 * @param layout The current layout of the image aspect(s).
2367 const struct anv_image * const image,
2374 const uint32_t plane = anv_image_aspect_to_plane(image, aspect);
2377 if (image->planes[plane].aux_usage == ISL_AUX_USAGE_NONE)
2383 if (devinfo->verx10 == 70 && image->vk.samples > 1)
2387 anv_layout_to_aux_state(devinfo, image, aspect, layout);
2398 /* The image might not support non zero fast clears when mutable. */
2399 if (!image->planes[plane].can_non_zero_fast_clear)
2407 } else if (image->planes[plane].aux_usage == ISL_AUX_USAGE_MCS ||
2408 image->planes[plane].aux_usage == ISL_AUX_USAGE_CCS_E) {
2410 /* The image might not support non zero fast clears when mutable. */
2411 if (!image->planes[plane].can_non_zero_fast_clear)
2420 /* If the image has MCS or CCS_E enabled all the time then we can
2466 const struct anv_image *image,
2476 const uint32_t plane = anv_image_aspect_to_plane(image, aspect);
2478 const struct anv_surface *surface = &image->planes[plane].primary_surface,
2479 *aux_surface = &image->planes[plane].aux_surface;
2489 if (anv_surface_is_valid(&image->planes[plane].shadow_surface) &&
2494 assert(image->planes[plane].shadow_surface.isl.tiling != ISL_TILING_LINEAR);
2495 surface = &image->planes[plane].shadow_surface;
2501 if (anv_surface_is_valid(&image->planes[plane].shadow_surface) &&
2505 surface = &image->planes[plane].shadow_surface;
2525 anv_image_address(image, &surface->memory_range);
2550 * image formats. Translate it into the closest format the hardware
2606 aux_address = anv_image_address(image, &aux_surface->memory_range);
2611 clear_address = anv_image_get_clear_color_addr(device, image, aspect);
2670 ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image);
2678 iview->image = image;
2687 /* If image has an external format, the pNext chain must contain an
2689 * created with the same external format as image."
2691 assert(!image->vk.android_external_format || conv_info);
2700 /* "If image has an external format, format must be VK_FORMAT_UNDEFINED." */
2701 assert(!image->vk.android_external_format ||
2711 /* Now go through the underlying image selected planes and map them to
2712 * planes in the image view.
2714 anv_foreach_image_aspect_bit(iaspect_bit, image, iview->vk.aspects) {
2716 anv_aspect_to_plane(image->vk.aspects, 1UL << iaspect_bit);
2721 vplane, image->vk.tiling);
2758 anv_layout_to_aux_usage(&device->info, image, 1UL << iaspect_bit,
2762 anv_layout_to_aux_usage(&device->info, image, 1UL << iaspect_bit,
2766 anv_image_fill_surface_state(device, image, 1ULL << iaspect_bit,
2774 anv_image_fill_surface_state(device, image, 1ULL << iaspect_bit,
2786 anv_layout_to_aux_usage(&device->info, image, 1UL << iaspect_bit,
2790 anv_image_fill_surface_state(device, image, 1ULL << iaspect_bit,
2802 anv_image_fill_surface_state(device, image, 1ULL << iaspect_bit,