src/vulkan/runtime/vk_sampler.c - third_party/mesa - Git at Google

 /*
  * Copyright © 2022 Collabora, LTD
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice (including the next
  * paragraph) shall be included in all copies or substantial portions of the
  * Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  * IN THE SOFTWARE.
  */

 #include "vk_alloc.h"
 #include "vk_sampler.h"
 #include "vk_device.h"
 #include "vk_format.h"
 #include "vk_util.h"
 #include "vk_ycbcr_conversion.h"

 VkClearColorValue
 vk_border_color_value(VkBorderColor color)
 {
    switch (color) {
    case VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK:
       return (VkClearColorValue) { .float32 = { 0, 0, 0, 0 } };
    case VK_BORDER_COLOR_INT_TRANSPARENT_BLACK:
       return (VkClearColorValue) { .int32 = { 0, 0, 0, 0 } };
    case VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK:
       return (VkClearColorValue) { .float32 = { 0, 0, 0, 1 } };
    case VK_BORDER_COLOR_INT_OPAQUE_BLACK:
       return (VkClearColorValue) { .int32 = { 0, 0, 0, 1 } };
    case VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE:
       return (VkClearColorValue) { .float32 = { 1, 1, 1, 1 } };
    case VK_BORDER_COLOR_INT_OPAQUE_WHITE:
       return (VkClearColorValue) { .int32 = { 1, 1, 1, 1 } };
    default:
       unreachable("Invalid or custom border color enum");
    }
 }

 bool
 vk_border_color_is_int(VkBorderColor color)
 {
    switch (color) {
    case VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK:
    case VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK:
    case VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE:
    case VK_BORDER_COLOR_FLOAT_CUSTOM_EXT:
       return false;
    case VK_BORDER_COLOR_INT_TRANSPARENT_BLACK:
    case VK_BORDER_COLOR_INT_OPAQUE_BLACK:
    case VK_BORDER_COLOR_INT_OPAQUE_WHITE:
    case VK_BORDER_COLOR_INT_CUSTOM_EXT:
       return true;
    default:
       unreachable("Invalid border color enum");
    }
 }

 VkClearColorValue
 vk_sampler_border_color_value(const VkSamplerCreateInfo *pCreateInfo,
                               VkFormat *format_out)
 {
    if (vk_border_color_is_custom(pCreateInfo->borderColor)) {
       const VkSamplerCustomBorderColorCreateInfoEXT *border_color_info =
          vk_find_struct_const(pCreateInfo->pNext,
                               SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT);
       if (format_out)
          *format_out = border_color_info->format;

       return border_color_info->customBorderColor;
    } else {
       if (format_out)
          *format_out = VK_FORMAT_UNDEFINED;

       return vk_border_color_value(pCreateInfo->borderColor);
    }
 }

 void
 vk_sampler_state_init(struct vk_sampler_state *state,
                       const VkSamplerCreateInfo *pCreateInfo)
 {
    memset(state, 0, sizeof(*state));

    assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO);

    /* Copy all the pCreateInfo fields */
    state->flags = pCreateInfo->flags;
    state->mag_filter = pCreateInfo->magFilter;
    state->min_filter = pCreateInfo->minFilter;
    state->mipmap_mode = pCreateInfo->mipmapMode;
    state->address_mode_u = pCreateInfo->addressModeU;
    state->address_mode_v = pCreateInfo->addressModeV;
    state->address_mode_w = pCreateInfo->addressModeW;
    state->mip_lod_bias = pCreateInfo->mipLodBias;
    state->anisotropy_enable = pCreateInfo->anisotropyEnable;
    state->max_anisotropy = pCreateInfo->anisotropyEnable ?
                            pCreateInfo->maxAnisotropy : 1.0;
    state->compare_enable = pCreateInfo->compareEnable;
    if (pCreateInfo->compareEnable)
       state->compare_op = pCreateInfo->compareOp;
    state->min_lod = pCreateInfo->minLod;
    state->max_lod = pCreateInfo->maxLod;
    state->border_color = pCreateInfo->borderColor;
    state->unnormalized_coordinates = pCreateInfo->unnormalizedCoordinates;

    /* Defaults for if we don't find extensions */
    state->format = VK_FORMAT_UNDEFINED;
    if (!vk_border_color_is_custom(pCreateInfo->borderColor))
       state->border_color_value = vk_border_color_value(pCreateInfo->borderColor);
    state->reduction_mode = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE;

    vk_foreach_struct_const(ext, pCreateInfo->pNext) {
       switch (ext->sType) {
       case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: {
          const VkSamplerBorderColorComponentMappingCreateInfoEXT *bccm_info = (void *)ext;
          state->border_color_component_mapping = bccm_info->components;
          state->image_view_is_srgb = bccm_info->srgb;
          break;
       }

       case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: {
          const VkSamplerCustomBorderColorCreateInfoEXT *cbc_info = (void *)ext;
          if (!vk_border_color_is_custom(pCreateInfo->borderColor))
             break;

          state->border_color_value = cbc_info->customBorderColor;
          if (cbc_info->format != VK_FORMAT_UNDEFINED)
             state->format = cbc_info->format;
          break;
       }

       case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: {
          const VkSamplerReductionModeCreateInfo *rm_info = (void *)ext;
          state->reduction_mode = rm_info->reductionMode;
          break;
       }

       case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: {
          const VkSamplerYcbcrConversionInfo *yc_info = (void *)ext;
          VK_FROM_HANDLE(vk_ycbcr_conversion, conversion, yc_info->conversion);

          /* From the Vulkan 1.2.259 spec:
           *
           *    "A VkSamplerYcbcrConversionInfo must be provided for samplers
           *    to be used with image views that access
           *    VK_IMAGE_ASPECT_COLOR_BIT if the format is one of the formats
           *    that require a sampler YCbCr conversion, or if the image view
           *    has an external format."
           *
           * This means that on Android we can end up with one of these even if
           * YCbCr isn't being used at all. Leave sampler->ycbcr_conversion NULL
           * if it isn't a YCbCr format.
           */
          if (vk_format_get_ycbcr_info(conversion->state.format) == NULL)
             break;

          state->has_ycbcr_conversion = true;
          state->ycbcr_conversion = conversion->state;
          state->format = conversion->state.format;
          break;
       }

       default:
          break;
       }
    }
 }

 void
 vk_sampler_init(struct vk_device *device,
                 struct vk_sampler *sampler,
                 const VkSamplerCreateInfo *pCreateInfo)
 {
    struct vk_sampler_state state;

    vk_object_base_init(device, &sampler->base, VK_OBJECT_TYPE_SAMPLER);

    vk_sampler_state_init(&state, pCreateInfo);

    sampler->format = state.format;
    sampler->border_color = state.border_color;
    sampler->border_color_value = state.border_color_value;
    sampler->reduction_mode = state.reduction_mode;

    sampler->ycbcr_conversion = NULL;
    if (state.has_ycbcr_conversion) {
       /* The vk_sampler has an object pointer. */
       const VkSamplerYcbcrConversionInfo *yc_info =
          vk_find_struct_const(pCreateInfo->pNext,
                               SAMPLER_YCBCR_CONVERSION_INFO);
       VK_FROM_HANDLE(vk_ycbcr_conversion, conversion, yc_info->conversion);

       assert(state.format == conversion->state.format);
       sampler->ycbcr_conversion = conversion;
    }
 }

 void
 vk_sampler_finish(struct vk_sampler *sampler)
 {
    vk_object_base_finish(&sampler->base);
 }

 void *
 vk_sampler_create(struct vk_device *device,
                   const VkSamplerCreateInfo *pCreateInfo,
                   const VkAllocationCallbacks *alloc,
                   size_t size)
 {
    struct vk_sampler *sampler =
       vk_zalloc2(&device->alloc, alloc, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
    if (!sampler)
       return NULL;

    vk_sampler_init(device, sampler, pCreateInfo);

    return sampler;
 }

 void
 vk_sampler_destroy(struct vk_device *device,
                    const VkAllocationCallbacks *alloc,
                    struct vk_sampler *sampler)
 {
    vk_sampler_finish(sampler);
    vk_free2(&device->alloc, alloc, sampler);
 }
	/*
	* Copyright © 2022 Collabora, LTD
	*
	* Permission is hereby granted, free of charge, to any person obtaining a
	* copy of this software and associated documentation files (the "Software"),
	* to deal in the Software without restriction, including without limitation
	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	* and/or sell copies of the Software, and to permit persons to whom the
	* Software is furnished to do so, subject to the following conditions:
	*
	* The above copyright notice and this permission notice (including the next
	* paragraph) shall be included in all copies or substantial portions of the
	* Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
	* IN THE SOFTWARE.
	*/

	#include "vk_alloc.h"
	#include "vk_sampler.h"
	#include "vk_device.h"
	#include "vk_format.h"
	#include "vk_util.h"
	#include "vk_ycbcr_conversion.h"

	VkClearColorValue
	vk_border_color_value(VkBorderColor color)
	{
	switch (color) {
	case VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK:
	return (VkClearColorValue) { .float32 = { 0, 0, 0, 0 } };
	case VK_BORDER_COLOR_INT_TRANSPARENT_BLACK:
	return (VkClearColorValue) { .int32 = { 0, 0, 0, 0 } };
	case VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK:
	return (VkClearColorValue) { .float32 = { 0, 0, 0, 1 } };
	case VK_BORDER_COLOR_INT_OPAQUE_BLACK:
	return (VkClearColorValue) { .int32 = { 0, 0, 0, 1 } };
	case VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE:
	return (VkClearColorValue) { .float32 = { 1, 1, 1, 1 } };
	case VK_BORDER_COLOR_INT_OPAQUE_WHITE:
	return (VkClearColorValue) { .int32 = { 1, 1, 1, 1 } };
	default:
	unreachable("Invalid or custom border color enum");
	}
	}

	bool
	vk_border_color_is_int(VkBorderColor color)
	{
	switch (color) {
	case VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK:
	case VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK:
	case VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE:
	case VK_BORDER_COLOR_FLOAT_CUSTOM_EXT:
	return false;
	case VK_BORDER_COLOR_INT_TRANSPARENT_BLACK:
	case VK_BORDER_COLOR_INT_OPAQUE_BLACK:
	case VK_BORDER_COLOR_INT_OPAQUE_WHITE:
	case VK_BORDER_COLOR_INT_CUSTOM_EXT:
	return true;
	default:
	unreachable("Invalid border color enum");
	}
	}

	VkClearColorValue
	vk_sampler_border_color_value(const VkSamplerCreateInfo *pCreateInfo,
	VkFormat *format_out)
	{
	if (vk_border_color_is_custom(pCreateInfo->borderColor)) {
	const VkSamplerCustomBorderColorCreateInfoEXT *border_color_info =
	vk_find_struct_const(pCreateInfo->pNext,
	SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT);
	if (format_out)
	*format_out = border_color_info->format;

	return border_color_info->customBorderColor;
	} else {
	if (format_out)
	*format_out = VK_FORMAT_UNDEFINED;

	return vk_border_color_value(pCreateInfo->borderColor);
	}
	}

	void
	vk_sampler_state_init(struct vk_sampler_state *state,
	const VkSamplerCreateInfo *pCreateInfo)
	{
	memset(state, 0, sizeof(*state));

	assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO);

	/* Copy all the pCreateInfo fields */
	state->flags = pCreateInfo->flags;
	state->mag_filter = pCreateInfo->magFilter;
	state->min_filter = pCreateInfo->minFilter;
	state->mipmap_mode = pCreateInfo->mipmapMode;
	state->address_mode_u = pCreateInfo->addressModeU;
	state->address_mode_v = pCreateInfo->addressModeV;
	state->address_mode_w = pCreateInfo->addressModeW;
	state->mip_lod_bias = pCreateInfo->mipLodBias;
	state->anisotropy_enable = pCreateInfo->anisotropyEnable;
	state->max_anisotropy = pCreateInfo->anisotropyEnable ?
	pCreateInfo->maxAnisotropy : 1.0;
	state->compare_enable = pCreateInfo->compareEnable;
	if (pCreateInfo->compareEnable)
	state->compare_op = pCreateInfo->compareOp;
	state->min_lod = pCreateInfo->minLod;
	state->max_lod = pCreateInfo->maxLod;
	state->border_color = pCreateInfo->borderColor;
	state->unnormalized_coordinates = pCreateInfo->unnormalizedCoordinates;

	/* Defaults for if we don't find extensions */
	state->format = VK_FORMAT_UNDEFINED;
	if (!vk_border_color_is_custom(pCreateInfo->borderColor))
	state->border_color_value = vk_border_color_value(pCreateInfo->borderColor);
	state->reduction_mode = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE;

	vk_foreach_struct_const(ext, pCreateInfo->pNext) {
	switch (ext->sType) {
	case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: {
	const VkSamplerBorderColorComponentMappingCreateInfoEXT bccm_info = (void )ext;
	state->border_color_component_mapping = bccm_info->components;
	state->image_view_is_srgb = bccm_info->srgb;
	break;
	}

	case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: {
	const VkSamplerCustomBorderColorCreateInfoEXT cbc_info = (void )ext;
	if (!vk_border_color_is_custom(pCreateInfo->borderColor))
	break;

	state->border_color_value = cbc_info->customBorderColor;
	if (cbc_info->format != VK_FORMAT_UNDEFINED)
	state->format = cbc_info->format;
	break;
	}

	case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: {
	const VkSamplerReductionModeCreateInfo rm_info = (void )ext;
	state->reduction_mode = rm_info->reductionMode;
	break;
	}

	case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: {
	const VkSamplerYcbcrConversionInfo yc_info = (void )ext;
	VK_FROM_HANDLE(vk_ycbcr_conversion, conversion, yc_info->conversion);

	/* From the Vulkan 1.2.259 spec:
	*
	* "A VkSamplerYcbcrConversionInfo must be provided for samplers
	* to be used with image views that access
	* VK_IMAGE_ASPECT_COLOR_BIT if the format is one of the formats
	* that require a sampler YCbCr conversion, or if the image view
	* has an external format."
	*
	* This means that on Android we can end up with one of these even if
	* YCbCr isn't being used at all. Leave sampler->ycbcr_conversion NULL
	* if it isn't a YCbCr format.
	*/
	if (vk_format_get_ycbcr_info(conversion->state.format) == NULL)
	break;

	state->has_ycbcr_conversion = true;
	state->ycbcr_conversion = conversion->state;
	state->format = conversion->state.format;
	break;
	}

	default:
	break;
	}
	}
	}

	void
	vk_sampler_init(struct vk_device *device,
	struct vk_sampler *sampler,
	const VkSamplerCreateInfo *pCreateInfo)
	{
	struct vk_sampler_state state;

	vk_object_base_init(device, &sampler->base, VK_OBJECT_TYPE_SAMPLER);

	vk_sampler_state_init(&state, pCreateInfo);

	sampler->format = state.format;
	sampler->border_color = state.border_color;
	sampler->border_color_value = state.border_color_value;
	sampler->reduction_mode = state.reduction_mode;

	sampler->ycbcr_conversion = NULL;
	if (state.has_ycbcr_conversion) {
	/* The vk_sampler has an object pointer. */
	const VkSamplerYcbcrConversionInfo *yc_info =
	vk_find_struct_const(pCreateInfo->pNext,
	SAMPLER_YCBCR_CONVERSION_INFO);
	VK_FROM_HANDLE(vk_ycbcr_conversion, conversion, yc_info->conversion);

	assert(state.format == conversion->state.format);
	sampler->ycbcr_conversion = conversion;
	}
	}

	void
	vk_sampler_finish(struct vk_sampler *sampler)
	{
	vk_object_base_finish(&sampler->base);
	}

	void *
	vk_sampler_create(struct vk_device *device,
	const VkSamplerCreateInfo *pCreateInfo,
	const VkAllocationCallbacks *alloc,
	size_t size)
	{
	struct vk_sampler *sampler =
	vk_zalloc2(&device->alloc, alloc, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
	if (!sampler)
	return NULL;

	vk_sampler_init(device, sampler, pCreateInfo);

	return sampler;
	}

	void
	vk_sampler_destroy(struct vk_device *device,
	const VkAllocationCallbacks *alloc,
	struct vk_sampler *sampler)
	{
	vk_sampler_finish(sampler);
	vk_free2(&device->alloc, alloc, sampler);
	}