X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fintel%2Fvulkan%2Fanv_private.h;h=e17a52a4a70399f10cfc50c44659926851643614;hb=6720abf292e77d44467419a82af40d63572c6e5a;hp=141712232dafe6654302d39ae1b773b8a7dadca7;hpb=73638be11f4fbb016f6c6d2934134c0d2455d798;p=mesa.git diff --git a/src/intel/vulkan/anv_private.h b/src/intel/vulkan/anv_private.h index 141712232da..e17a52a4a70 100644 --- a/src/intel/vulkan/anv_private.h +++ b/src/intel/vulkan/anv_private.h @@ -69,11 +69,13 @@ struct gen_l3_config; #include #include #include +#include #include "anv_entrypoints.h" #include "isl/isl.h" #include "common/gen_debug.h" +#include "common/intel_log.h" #include "wsi_common.h" /* Allowing different clear colors requires us to perform a depth resolve at @@ -303,16 +305,20 @@ vk_to_isl_color(VkClearColorValue color) * propagating errors. Might be useful to plug in a stack trace here. */ -VkResult __vk_errorf(VkResult error, const char *file, int line, const char *format, ...); +VkResult __vk_errorf(struct anv_instance *instance, const void *object, + VkDebugReportObjectTypeEXT type, VkResult error, + const char *file, int line, const char *format, ...); #ifdef DEBUG -#define vk_error(error) __vk_errorf(error, __FILE__, __LINE__, NULL); -#define vk_errorf(error, format, ...) __vk_errorf(error, __FILE__, __LINE__, format, ## __VA_ARGS__); -#define anv_debug(format, ...) fprintf(stderr, "debug: " format, ##__VA_ARGS__) +#define vk_error(error) __vk_errorf(NULL, NULL,\ + VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,\ + error, __FILE__, __LINE__, NULL); +#define vk_errorf(instance, obj, error, format, ...)\ + __vk_errorf(instance, obj, REPORT_OBJECT_TYPE(obj), error,\ + __FILE__, __LINE__, format, ## __VA_ARGS__); #else #define vk_error(error) error -#define vk_errorf(error, format, ...) error -#define anv_debug(format, ...) +#define vk_errorf(instance, obj, error, format, ...) error #endif /** @@ -331,10 +337,8 @@ VkResult __vk_errorf(VkResult error, const char *file, int line, const char *for * defined by extensions supported by that component. */ #define anv_debug_ignored_stype(sType) \ - anv_debug("debug: %s: ignored VkStructureType %u\n", __func__, (sType)) + intel_logd("%s: ignored VkStructureType %u\n", __func__, (sType)) -void __anv_finishme(const char *file, int line, const char *format, ...) - anv_printflike(3, 4); void __anv_perf_warn(struct anv_instance *instance, const void *object, VkDebugReportObjectTypeEXT type, const char *file, int line, const char *format, ...) @@ -358,7 +362,8 @@ void anv_debug_report(struct anv_instance *instance, do { \ static bool reported = false; \ if (!reported) { \ - __anv_finishme(__FILE__, __LINE__, format, ##__VA_ARGS__); \ + intel_logw("%s:%d: FINISHME: " format, __FILE__, __LINE__, \ + ##__VA_ARGS__); \ reported = true; \ } \ } while (0) @@ -380,7 +385,7 @@ void anv_debug_report(struct anv_instance *instance, #ifdef DEBUG #define anv_assert(x) ({ \ if (unlikely(!(x))) \ - fprintf(stderr, "%s:%d ASSERT: %s\n", __FILE__, __LINE__, #x); \ + intel_loge("%s:%d ASSERT: %s", __FILE__, __LINE__, #x); \ }) #else #define anv_assert(x) @@ -432,9 +437,11 @@ _anv_multialloc_add(struct anv_multialloc *ma, ma->ptrs[ma->ptr_count++] = ptr; } +#define anv_multialloc_add_size(_ma, _ptr, _size) \ + _anv_multialloc_add((_ma), (void **)(_ptr), (_size), __alignof__(**(_ptr))) + #define anv_multialloc_add(_ma, _ptr, _count) \ - _anv_multialloc_add((_ma), (void **)(_ptr), \ - (_count) * sizeof(**(_ptr)), __alignof__(**(_ptr))) + anv_multialloc_add_size(_ma, _ptr, (_count) * sizeof(**(_ptr))); __attribute__((always_inline)) static inline void * @@ -712,7 +719,7 @@ VkResult anv_bo_cache_alloc(struct anv_device *device, uint64_t size, struct anv_bo **bo); VkResult anv_bo_cache_import(struct anv_device *device, struct anv_bo_cache *cache, - int fd, uint64_t size, struct anv_bo **bo); + int fd, struct anv_bo **bo); VkResult anv_bo_cache_export(struct anv_device *device, struct anv_bo_cache *cache, struct anv_bo *bo_in, int *fd_out); @@ -923,6 +930,7 @@ int anv_gem_destroy_context(struct anv_device *device, int context); int anv_gem_get_context_param(int fd, int context, uint32_t param, uint64_t *value); int anv_gem_get_param(int fd, uint32_t param); +int anv_gem_get_tiling(struct anv_device *device, uint32_t gem_handle); bool anv_gem_get_bit6_swizzle(int fd, uint32_t tiling); int anv_gem_get_aperture(int fd, uint64_t *size); bool anv_gem_supports_48b_addresses(int fd); @@ -1262,7 +1270,6 @@ struct anv_push_descriptor_set { /* Put this field right behind anv_descriptor_set so it fills up the * descriptors[0] field. */ struct anv_descriptor descriptors[MAX_PUSH_DESCRIPTORS]; - struct anv_buffer_view buffer_views[MAX_PUSH_DESCRIPTORS]; }; @@ -1317,6 +1324,9 @@ struct anv_descriptor_update_template { struct anv_descriptor_template_entry entries[0]; }; +size_t +anv_descriptor_set_binding_layout_get_hw_size(const struct anv_descriptor_set_binding_layout *binding); + size_t anv_descriptor_set_layout_size(const struct anv_descriptor_set_layout *layout); @@ -1379,6 +1389,9 @@ struct anv_pipeline_binding { /* Index in the binding */ uint32_t index; + /* Plane in the binding index */ + uint8_t plane; + /* Input attachment index (relative to the subpass) */ uint8_t input_attachment_index; @@ -1539,11 +1552,24 @@ anv_pipe_invalidate_bits_for_access_flags(VkAccessFlags flags) return pipe_bits; } +#define VK_IMAGE_ASPECT_ANY_COLOR_BIT_ANV ( \ + VK_IMAGE_ASPECT_COLOR_BIT | \ + VK_IMAGE_ASPECT_PLANE_0_BIT_KHR | \ + VK_IMAGE_ASPECT_PLANE_1_BIT_KHR | \ + VK_IMAGE_ASPECT_PLANE_2_BIT_KHR) +#define VK_IMAGE_ASPECT_PLANES_BITS_ANV ( \ + VK_IMAGE_ASPECT_PLANE_0_BIT_KHR | \ + VK_IMAGE_ASPECT_PLANE_1_BIT_KHR | \ + VK_IMAGE_ASPECT_PLANE_2_BIT_KHR) + struct anv_vertex_binding { struct anv_buffer * buffer; VkDeviceSize offset; }; +#define ANV_PARAM_PUSH(offset) ((1 << 16) | (uint32_t)(offset)) +#define ANV_PARAM_PUSH_OFFSET(param) ((param) & 0xffff) + struct anv_push_constants { /* Current allocated size of this push constants data structure. * Because a decent chunk of it may not be used (images on SKL, for @@ -1554,13 +1580,6 @@ struct anv_push_constants { /* Push constant data provided by the client through vkPushConstants */ uint8_t client_data[MAX_PUSH_CONSTANTS_SIZE]; - /* Our hardware only provides zero-based vertex and instance id so, in - * order to satisfy the vulkan requirements, we may have to push one or - * both of these into the shader. - */ - uint32_t base_vertex; - uint32_t base_instance; - /* Image data for image_load_store on pre-SKL */ struct brw_image_param images[MAX_IMAGES]; }; @@ -1613,6 +1632,23 @@ void anv_dynamic_state_copy(struct anv_dynamic_state *dest, const struct anv_dynamic_state *src, uint32_t copy_mask); +struct anv_surface_state { + struct anv_state state; + /** Address of the surface referred to by this state + * + * This address is relative to the start of the BO. + */ + uint64_t address; + /* Address of the aux surface, if any + * + * This field is 0 if and only if no aux surface exists. + * + * This address is relative to the start of the BO. On gen7, the bottom 12 + * bits of this address include extra aux information. + */ + uint64_t aux_address; +}; + /** * Attachment state when recording a renderpass instance. * @@ -1621,8 +1657,8 @@ void anv_dynamic_state_copy(struct anv_dynamic_state *dest, struct anv_attachment_state { enum isl_aux_usage aux_usage; enum isl_aux_usage input_aux_usage; - struct anv_state color_rt_state; - struct anv_state input_att_state; + struct anv_surface_state color; + struct anv_surface_state input; VkImageLayout current_layout; VkImageAspectFlags pending_clear_aspects; @@ -1663,7 +1699,7 @@ struct anv_cmd_state { struct anv_dynamic_state dynamic; bool need_query_wa; - struct anv_push_descriptor_set push_descriptor; + struct anv_push_descriptor_set * push_descriptors[MAX_SETS]; /** * Whether or not the gen8 PMA fix is enabled. We ensure that, at the top @@ -1889,7 +1925,7 @@ struct anv_fence_impl { struct anv_fence { /* Permanent fence state. Every fence has some form of permanent state * (type != ANV_SEMAPHORE_TYPE_NONE). This may be a BO to fence on (for - * cross-process fences0 or it could just be a dummy for use internally. + * cross-process fences) or it could just be a dummy for use internally. */ struct anv_fence_impl permanent; @@ -1927,13 +1963,13 @@ struct anv_semaphore_impl { */ struct anv_bo *bo; - /* The sync file descriptor when type == AKV_SEMAPHORE_TYPE_SYNC_FILE. + /* The sync file descriptor when type == ANV_SEMAPHORE_TYPE_SYNC_FILE. * If the semaphore is in the unsignaled state due to either just being * created or because it has been used for a wait, fd will be -1. */ int fd; - /* Sync object handle when type == AKV_SEMAPHORE_TYPE_DRM_SYNCOBJ. + /* Sync object handle when type == ANV_SEMAPHORE_TYPE_DRM_SYNCOBJ. * Unlike GEM BOs, DRM sync objects aren't deduplicated by the kernel on * import so we don't need to bother with a userspace cache. */ @@ -2015,8 +2051,6 @@ struct anv_shader_bin { uint32_t prog_data_size; struct anv_pipeline_bind_map bind_map; - - /* Prog data follows, then params, then the key, all aligned to 8-bytes */ }; struct anv_shader_bin * @@ -2153,20 +2187,106 @@ anv_pipeline_compile_cs(struct anv_pipeline *pipeline, const char *entrypoint, const VkSpecializationInfo *spec_info); -struct anv_format { +struct anv_format_plane { enum isl_format isl_format:16; struct isl_swizzle swizzle; + + /* Whether this plane contains chroma channels */ + bool has_chroma; + + /* For downscaling of YUV planes */ + uint8_t denominator_scales[2]; + + /* How to map sampled ycbcr planes to a single 4 component element. */ + struct isl_swizzle ycbcr_swizzle; }; -struct anv_format -anv_get_format(const struct gen_device_info *devinfo, VkFormat format, - VkImageAspectFlags aspect, VkImageTiling tiling); + +struct anv_format { + struct anv_format_plane planes[3]; + uint8_t n_planes; + bool can_ycbcr; +}; + +static inline uint32_t +anv_image_aspect_to_plane(VkImageAspectFlags image_aspects, + VkImageAspectFlags aspect_mask) +{ + switch (aspect_mask) { + case VK_IMAGE_ASPECT_COLOR_BIT: + case VK_IMAGE_ASPECT_DEPTH_BIT: + case VK_IMAGE_ASPECT_PLANE_0_BIT_KHR: + return 0; + case VK_IMAGE_ASPECT_STENCIL_BIT: + if ((image_aspects & VK_IMAGE_ASPECT_DEPTH_BIT) == 0) + return 0; + /* Fall-through */ + case VK_IMAGE_ASPECT_PLANE_1_BIT_KHR: + return 1; + case VK_IMAGE_ASPECT_PLANE_2_BIT_KHR: + return 2; + default: + /* Purposefully assert with depth/stencil aspects. */ + unreachable("invalid image aspect"); + } +} + +static inline uint32_t +anv_image_aspect_get_planes(VkImageAspectFlags aspect_mask) +{ + uint32_t planes = 0; + + if (aspect_mask & (VK_IMAGE_ASPECT_COLOR_BIT | + VK_IMAGE_ASPECT_DEPTH_BIT | + VK_IMAGE_ASPECT_STENCIL_BIT | + VK_IMAGE_ASPECT_PLANE_0_BIT_KHR)) + planes++; + if (aspect_mask & VK_IMAGE_ASPECT_PLANE_1_BIT_KHR) + planes++; + if (aspect_mask & VK_IMAGE_ASPECT_PLANE_2_BIT_KHR) + planes++; + + return planes; +} + +static inline VkImageAspectFlags +anv_plane_to_aspect(VkImageAspectFlags image_aspects, + uint32_t plane) +{ + if (image_aspects & VK_IMAGE_ASPECT_ANY_COLOR_BIT_ANV) { + if (_mesa_bitcount(image_aspects) > 1) + return VK_IMAGE_ASPECT_PLANE_0_BIT_KHR << plane; + return VK_IMAGE_ASPECT_COLOR_BIT; + } + if (image_aspects & VK_IMAGE_ASPECT_DEPTH_BIT) + return VK_IMAGE_ASPECT_DEPTH_BIT << plane; + assert(image_aspects == VK_IMAGE_ASPECT_STENCIL_BIT); + return VK_IMAGE_ASPECT_STENCIL_BIT; +} + +#define anv_foreach_image_aspect_bit(b, image, aspects) \ + for_each_bit(b, anv_image_expand_aspects(image, aspects)) + +const struct anv_format * +anv_get_format(VkFormat format); + +static inline uint32_t +anv_get_format_planes(VkFormat vk_format) +{ + const struct anv_format *format = anv_get_format(vk_format); + + return format != NULL ? format->n_planes : 0; +} + +struct anv_format_plane +anv_get_format_plane(const struct gen_device_info *devinfo, VkFormat vk_format, + VkImageAspectFlagBits aspect, VkImageTiling tiling); static inline enum isl_format anv_get_isl_format(const struct gen_device_info *devinfo, VkFormat vk_format, VkImageAspectFlags aspect, VkImageTiling tiling) { - return anv_get_format(devinfo, vk_format, aspect, tiling).isl_format; + return anv_get_format_plane(devinfo, vk_format, aspect, tiling).isl_format; } static inline struct isl_swizzle @@ -2206,65 +2326,124 @@ struct anv_image { * of the actual surface formats. */ VkFormat vk_format; + const struct anv_format *format; + VkImageAspectFlags aspects; VkExtent3D extent; uint32_t levels; uint32_t array_size; uint32_t samples; /**< VkImageCreateInfo::samples */ + uint32_t n_planes; VkImageUsageFlags usage; /**< Superset of VkImageCreateInfo::usage. */ VkImageTiling tiling; /** VkImageCreateInfo::tiling */ VkDeviceSize size; uint32_t alignment; - /* Set when bound */ - struct anv_bo *bo; - VkDeviceSize offset; + /* Whether the image is made of several underlying buffer objects rather a + * single one with different offsets. + */ + bool disjoint; /** * Image subsurfaces * - * For each foo, anv_image::foo_surface is valid if and only if - * anv_image::aspects has a foo aspect. + * For each foo, anv_image::planes[x].surface is valid if and only if + * anv_image::aspects has a x aspect. Refer to anv_image_aspect_to_plane() + * to figure the number associated with a given aspect. * * The hardware requires that the depth buffer and stencil buffer be * separate surfaces. From Vulkan's perspective, though, depth and stencil * reside in the same VkImage. To satisfy both the hardware and Vulkan, we * allocate the depth and stencil buffers as separate surfaces in the same * bo. + * + * Memory layout : + * + * ----------------------- + * | surface0 | /|\ + * ----------------------- | + * | shadow surface0 | | + * ----------------------- | Plane 0 + * | aux surface0 | | + * ----------------------- | + * | fast clear colors0 | \|/ + * ----------------------- + * | surface1 | /|\ + * ----------------------- | + * | shadow surface1 | | + * ----------------------- | Plane 1 + * | aux surface1 | | + * ----------------------- | + * | fast clear colors1 | \|/ + * ----------------------- + * | ... | + * | | + * ----------------------- */ - union { - struct anv_surface color_surface; + struct { + /** + * Offset of the entire plane (whenever the image is disjoint this is + * set to 0). + */ + uint32_t offset; - struct { - struct anv_surface depth_surface; - struct anv_surface stencil_surface; - }; - }; + VkDeviceSize size; + uint32_t alignment; - /** - * For color images, this is the aux usage for this image when not used as a - * color attachment. - * - * For depth/stencil images, this is set to ISL_AUX_USAGE_HIZ if the image - * has a HiZ buffer. - */ - enum isl_aux_usage aux_usage; + struct anv_surface surface; + + /** + * A surface which shadows the main surface and may have different + * tiling. This is used for sampling using a tiling that isn't supported + * for other operations. + */ + struct anv_surface shadow_surface; + + /** + * For color images, this is the aux usage for this image when not used + * as a color attachment. + * + * For depth/stencil images, this is set to ISL_AUX_USAGE_HIZ if the + * image has a HiZ buffer. + */ + enum isl_aux_usage aux_usage; - struct anv_surface aux_surface; + struct anv_surface aux_surface; + + /** + * Offset of the fast clear state (used to compute the + * fast_clear_state_offset of the following planes). + */ + uint32_t fast_clear_state_offset; + + /** + * BO associated with this plane, set when bound. + */ + struct anv_bo *bo; + VkDeviceSize bo_offset; + + /** + * When destroying the image, also free the bo. + * */ + bool bo_is_owned; + } planes[3]; }; /* Returns the number of auxiliary buffer levels attached to an image. */ static inline uint8_t -anv_image_aux_levels(const struct anv_image * const image) +anv_image_aux_levels(const struct anv_image * const image, + VkImageAspectFlagBits aspect) { - assert(image); - return image->aux_surface.isl.size > 0 ? image->aux_surface.isl.levels : 0; + uint32_t plane = anv_image_aspect_to_plane(image->aspects, aspect); + return image->planes[plane].aux_surface.isl.size > 0 ? + image->planes[plane].aux_surface.isl.levels : 0; } /* Returns the number of auxiliary buffer layers attached to an image. */ static inline uint32_t anv_image_aux_layers(const struct anv_image * const image, + VkImageAspectFlagBits aspect, const uint8_t miplevel) { assert(image); @@ -2272,14 +2451,15 @@ anv_image_aux_layers(const struct anv_image * const image, /* The miplevel must exist in the main buffer. */ assert(miplevel < image->levels); - if (miplevel >= anv_image_aux_levels(image)) { + if (miplevel >= anv_image_aux_levels(image, aspect)) { /* There are no layers with auxiliary data because the miplevel has no * auxiliary data. */ return 0; } else { - return MAX2(image->aux_surface.isl.logical_level0_px.array_len, - image->aux_surface.isl.logical_level0_px.depth >> miplevel); + uint32_t plane = anv_image_aspect_to_plane(image->aspects, aspect); + return MAX2(image->planes[plane].aux_surface.isl.logical_level0_px.array_len, + image->planes[plane].aux_surface.isl.logical_level0_px.depth >> miplevel); } } @@ -2303,13 +2483,15 @@ anv_fast_clear_state_entry_size(const struct anv_device *device) /* Returns true if a HiZ-enabled depth buffer can be sampled from. */ static inline bool anv_can_sample_with_hiz(const struct gen_device_info * const devinfo, - const VkImageAspectFlags aspect_mask, - const uint32_t samples) + const struct anv_image *image) { - /* Validate the inputs. */ - assert(devinfo && aspect_mask && samples); - return devinfo->gen >= 8 && (aspect_mask & VK_IMAGE_ASPECT_DEPTH_BIT) && - samples == 1; + if (!(image->aspects & VK_IMAGE_ASPECT_DEPTH_BIT)) + return false; + + if (devinfo->gen < 8) + return false; + + return image->samples == 1; } void @@ -2320,19 +2502,27 @@ void anv_ccs_resolve(struct anv_cmd_buffer * const cmd_buffer, const struct anv_state surface_state, const struct anv_image * const image, + VkImageAspectFlagBits aspect, const uint8_t level, const uint32_t layer_count, const enum blorp_fast_clear_op op); void anv_image_fast_clear(struct anv_cmd_buffer *cmd_buffer, const struct anv_image *image, + VkImageAspectFlagBits aspect, const uint32_t base_level, const uint32_t level_count, const uint32_t base_layer, uint32_t layer_count); +void +anv_image_copy_to_shadow(struct anv_cmd_buffer *cmd_buffer, + const struct anv_image *image, + uint32_t base_level, uint32_t level_count, + uint32_t base_layer, uint32_t layer_count); + enum isl_aux_usage anv_layout_to_aux_usage(const struct gen_device_info * const devinfo, const struct anv_image *image, - const VkImageAspectFlags aspects, + const VkImageAspectFlagBits aspect, const VkImageLayout layout); /* This is defined as a macro so that it works for both @@ -2350,49 +2540,99 @@ anv_get_levelCount(const struct anv_image *image, image->levels - range->baseMipLevel : range->levelCount; } +static inline VkImageAspectFlags +anv_image_expand_aspects(const struct anv_image *image, + VkImageAspectFlags aspects) +{ + /* If the underlying image has color plane aspects and + * VK_IMAGE_ASPECT_COLOR_BIT has been requested, then return the aspects of + * the underlying image. */ + if ((image->aspects & VK_IMAGE_ASPECT_PLANES_BITS_ANV) != 0 && + aspects == VK_IMAGE_ASPECT_COLOR_BIT) + return image->aspects; + + return aspects; +} + +static inline bool +anv_image_aspects_compatible(VkImageAspectFlags aspects1, + VkImageAspectFlags aspects2) +{ + if (aspects1 == aspects2) + return true; + + /* Only 1 color aspects are compatibles. */ + if ((aspects1 & VK_IMAGE_ASPECT_ANY_COLOR_BIT_ANV) != 0 && + (aspects2 & VK_IMAGE_ASPECT_ANY_COLOR_BIT_ANV) != 0 && + _mesa_bitcount(aspects1) == _mesa_bitcount(aspects2)) + return true; + + return false; +} struct anv_image_view { const struct anv_image *image; /**< VkImageViewCreateInfo::image */ - struct anv_bo *bo; - uint32_t offset; /**< Offset into bo. */ - - struct isl_view isl; VkImageAspectFlags aspect_mask; VkFormat vk_format; VkExtent3D extent; /**< Extent of VkImageViewCreateInfo::baseMipLevel. */ - /** - * RENDER_SURFACE_STATE when using image as a sampler surface with an image - * layout of SHADER_READ_ONLY_OPTIMAL or DEPTH_STENCIL_READ_ONLY_OPTIMAL. - */ - enum isl_aux_usage optimal_sampler_aux_usage; - struct anv_state optimal_sampler_surface_state; + unsigned n_planes; + struct { + uint32_t image_plane; - /** - * RENDER_SURFACE_STATE when using image as a sampler surface with an image - * layout of GENERAL. - */ - enum isl_aux_usage general_sampler_aux_usage; - struct anv_state general_sampler_surface_state; + struct isl_view isl; - /** - * RENDER_SURFACE_STATE when using image as a storage image. Separate states - * for write-only and readable, using the real format for write-only and the - * lowered format for readable. - */ - struct anv_state storage_surface_state; - struct anv_state writeonly_storage_surface_state; + /** + * RENDER_SURFACE_STATE when using image as a sampler surface with an + * image layout of SHADER_READ_ONLY_OPTIMAL or + * DEPTH_STENCIL_READ_ONLY_OPTIMAL. + */ + struct anv_surface_state optimal_sampler_surface_state; - struct brw_image_param storage_image_param; + /** + * RENDER_SURFACE_STATE when using image as a sampler surface with an + * image layout of GENERAL. + */ + struct anv_surface_state general_sampler_surface_state; + + /** + * RENDER_SURFACE_STATE when using image as a storage image. Separate + * states for write-only and readable, using the real format for + * write-only and the lowered format for readable. + */ + struct anv_surface_state storage_surface_state; + struct anv_surface_state writeonly_storage_surface_state; + + struct brw_image_param storage_image_param; + } planes[3]; +}; + +enum anv_image_view_state_flags { + ANV_IMAGE_VIEW_STATE_STORAGE_WRITE_ONLY = (1 << 0), + ANV_IMAGE_VIEW_STATE_TEXTURE_OPTIMAL = (1 << 1), }; +void anv_image_fill_surface_state(struct anv_device *device, + const struct anv_image *image, + VkImageAspectFlagBits aspect, + const struct isl_view *view, + isl_surf_usage_flags_t view_usage, + enum isl_aux_usage aux_usage, + const union isl_color_value *clear_color, + enum anv_image_view_state_flags flags, + struct anv_surface_state *state_inout, + struct brw_image_param *image_param_out); + struct anv_image_create_info { const VkImageCreateInfo *vk_info; /** An opt-in bitmask which filters an ISL-mapping of the Vulkan tiling. */ isl_tiling_flags_t isl_tiling_flags; + /** These flags will be added to any derived from VkImageCreateInfo. */ + isl_surf_usage_flags_t isl_extra_usage_flags; + uint32_t stride; }; @@ -2401,6 +2641,14 @@ VkResult anv_image_create(VkDevice _device, const VkAllocationCallbacks* alloc, VkImage *pImage); +#ifdef ANDROID +VkResult anv_image_from_gralloc(VkDevice device_h, + const VkImageCreateInfo *base_info, + const VkNativeBufferANDROID *gralloc_info, + const VkAllocationCallbacks *alloc, + VkImage *pImage); +#endif + const struct anv_surface * anv_image_get_surface_for_aspect_mask(const struct anv_image *image, VkImageAspectFlags aspect_mask); @@ -2447,8 +2695,21 @@ void anv_fill_buffer_surface_state(struct anv_device *device, uint32_t offset, uint32_t range, uint32_t stride); + +struct anv_ycbcr_conversion { + const struct anv_format * format; + VkSamplerYcbcrModelConversionKHR ycbcr_model; + VkSamplerYcbcrRangeKHR ycbcr_range; + VkComponentSwizzle mapping[4]; + VkChromaLocationKHR chroma_offsets[2]; + VkFilter chroma_filter; + bool chroma_reconstruction; +}; + struct anv_sampler { - uint32_t state[4]; + uint32_t state[3][4]; + uint32_t n_planes; + struct anv_ycbcr_conversion *conversion; }; struct anv_framebuffer { @@ -2622,6 +2883,7 @@ ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_sampler, VkSampler) ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_semaphore, VkSemaphore) ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_shader_module, VkShaderModule) ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_debug_report_callback, VkDebugReportCallbackEXT) +ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_ycbcr_conversion, VkSamplerYcbcrConversionKHR) /* Gen-specific function declarations */ #ifdef genX