fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-21 04:38:09 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1
mesa/src/imagination/vulkan/pvr_border.c
Matt Coster c23f81cd11 pvr: Cleanup compressed border colour support 
To clear up the ambiguity of uncompressed/compressed formats:
  - Always use the correct enum type to refer to them, and
  - Split the border colour table into two halves so the compressed tex
    format enum can be used as an index directly without applying an
    offset.

Signed-off-by: Matt Coster <matt.coster@imgtec.com>
Acked-by: Erik Faye-Lund <erik.faye-lund@collabora.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/36412>
2025-09-16 18:26:10 +00:00

244 lines
8.5 KiB
C
Raw Blame History

/*
* Copyright © 2023 Imagination Technologies 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 <assert.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <vulkan/vulkan_core.h>
#include "hwdef/rogue_hw_utils.h"
#include "pvr_bo.h"
#include "pvr_border.h"
#include "pvr_device_info.h"
#include "pvr_formats.h"
#include "pvr_private.h"
#include "util/bitset.h"
#include "util/format/u_format.h"
#include "util/format/u_formats.h"
#include "util/log.h"
#include "util/macros.h"
#include "vk_format.h"
#include "vk_log.h"
#include "vk_sampler.h"
struct pvr_border_color_table_value {
uint8_t value[16];
} PACKED;
static_assert(sizeof(struct pvr_border_color_table_value) ==
4 * sizeof(uint32_t),
"struct pvr_border_color_table_value must be 4 x u32");
struct pvr_border_color_table_entry {
struct pvr_border_color_table_value values[PVR_TEX_FORMAT_COUNT];
struct pvr_border_color_table_value compressed_values[PVR_TEX_FORMAT_COUNT];
} PACKED;
static inline void pvr_border_color_table_pack_single(
struct pvr_border_color_table_value *const dst,
const union pipe_color_union *const color,
const struct pvr_tex_format_description *const pvr_tex_fmt_desc,
const bool is_int,
const struct pvr_device_info *const dev_info)
{
enum pipe_format pipe_format = is_int ? pvr_tex_fmt_desc->pipe_format_int
: pvr_tex_fmt_desc->pipe_format_float;
if (pipe_format == PIPE_FORMAT_NONE)
return;
memset(dst->value, 0, sizeof(dst->value));
if (util_format_is_depth_or_stencil(pipe_format)) {
if (is_int) {
const uint8_t s_color[4] = {
color->ui[0],
color->ui[1],
color->ui[2],
color->ui[3],
};
util_format_pack_s_8uint(pipe_format, dst->value, s_color, 1);
} else {
util_format_pack_z_float(pipe_format, dst->value, color->f, 1);
}
} else {
if (PVR_HAS_FEATURE(dev_info, tpu_border_colour_enhanced)) {
if (pipe_format == PIPE_FORMAT_R9G9B9E5_FLOAT)
pipe_format = PIPE_FORMAT_R16G16B16A16_FLOAT;
}
util_format_pack_rgba(pipe_format, dst->value, color, 1);
}
}
static inline void pvr_border_color_table_pack_single_compressed(
struct pvr_border_color_table_value *const dst,
const union pipe_color_union *const color,
const struct pvr_tex_format_compressed_description *const pvr_tex_fmt_desc,
const bool is_int,
const struct pvr_device_info *const dev_info)
{
if (PVR_HAS_FEATURE(dev_info, tpu_border_colour_enhanced)) {
const struct pvr_tex_format_description *pvr_tex_fmt_desc_simple =
pvr_get_tex_format_description(pvr_tex_fmt_desc->tex_format_simple);
pvr_border_color_table_pack_single(dst,
color,
pvr_tex_fmt_desc_simple,
is_int,
dev_info);
return;
}
memset(dst->value, 0, sizeof(dst->value));
pvr_finishme("Devices without tpu_border_colour_enhanced require entries "
"for compressed formats to be stored in the table "
"pre-compressed.");
}
static int32_t
pvr_border_color_table_alloc_entry(struct pvr_border_color_table *const table)
{
/* BITSET_FFS() returns a 1-indexed position or 0 if no bits are set. */
int32_t index = BITSET_FFS(table->unused_entries);
if (!index--)
return -1;
BITSET_CLEAR(table->unused_entries, index);
return index;
}
static void
pvr_border_color_table_free_entry(struct pvr_border_color_table *const table,
const uint32_t index)
{
assert(pvr_border_color_table_is_index_valid(table, index));
BITSET_SET(table->unused_entries, index);
}
static void
pvr_border_color_table_fill_entry(struct pvr_border_color_table *const table,
const uint32_t index,
const union pipe_color_union *const color,
const bool is_int,
const struct pvr_device_info *const dev_info)
{
struct pvr_border_color_table_entry *const entries = table->table->bo->map;
struct pvr_border_color_table_entry *const entry = &entries[index];
pvr_foreach_supported_tex_format (tex_format, desc) {
pvr_border_color_table_pack_single(&entry->values[tex_format],
color,
desc,
is_int,
dev_info);
}
pvr_foreach_supported_tex_format_compressed (tex_format, desc) {
pvr_border_color_table_pack_single_compressed(
&entry->compressed_values[tex_format],
color,
desc,
is_int,
dev_info);
}
}
VkResult pvr_border_color_table_init(struct pvr_border_color_table *const table,
struct pvr_device *const device)
{
const struct pvr_device_info *const dev_info = &device->pdevice->dev_info;
const uint32_t cache_line_size = rogue_get_slc_cache_line_size(dev_info);
const uint32_t table_size = sizeof(struct pvr_border_color_table_entry) *
PVR_BORDER_COLOR_TABLE_NR_ENTRIES;
VkResult result;
/* Initialize to ones so ffs can be used to find unused entries. */
BITSET_ONES(table->unused_entries);
result = pvr_bo_alloc(device,
device->heaps.general_heap,
table_size,
cache_line_size,
PVR_BO_ALLOC_FLAG_CPU_MAPPED,
&table->table);
if (result != VK_SUCCESS)
goto err_out;
BITSET_CLEAR_RANGE_INSIDE_WORD(table->unused_entries,
0,
PVR_BORDER_COLOR_TABLE_NR_BUILTIN_ENTRIES -
1);
for (uint32_t i = 0; i < PVR_BORDER_COLOR_TABLE_NR_BUILTIN_ENTRIES; i++) {
const VkClearColorValue color = vk_border_color_value(i);
const bool is_int = vk_border_color_is_int(i);
pvr_border_color_table_fill_entry(table,
i,
(const union pipe_color_union *)&color,
is_int,
dev_info);
}
pvr_bo_cpu_unmap(device, table->table);
return VK_SUCCESS;
err_out:
return result;
}
void pvr_border_color_table_finish(struct pvr_border_color_table *const table,
struct pvr_device *const device)
{
#if MESA_DEBUG
BITSET_SET_RANGE_INSIDE_WORD(table->unused_entries,
0,
PVR_BORDER_COLOR_TABLE_NR_BUILTIN_ENTRIES - 1);
BITSET_NOT(table->unused_entries);
assert(BITSET_IS_EMPTY(table->unused_entries));
#endif
pvr_bo_free(device, table->table);
}
VkResult pvr_border_color_table_get_or_create_entry(
UNUSED struct pvr_border_color_table *const table,
const struct pvr_sampler *const sampler,
uint32_t *const index_out)
{
const VkBorderColor vk_type = sampler->vk.border_color;
if (vk_type <= PVR_BORDER_COLOR_TABLE_NR_BUILTIN_ENTRIES) {
*index_out = vk_type;
return VK_SUCCESS;
}
pvr_finishme("VK_EXT_custom_border_color is currently unsupported.");
return vk_error(sampler, VK_ERROR_EXTENSION_NOT_PRESENT);
}
Reference in a new issue View git blame Copy permalink