fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-01-19 04:30:25 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

v3dv: refactor meta copy/clear code

Browse source 
This change does the following:

- Moves image clearing code from v3dv_meta_copy.c to v3dv_meta_clear.c
  where it belongs.
- Renames v3dv_meta_copy.h to v3dv_meta_common.h since now it is required
  by the copy and clear code.
- Renames 'struct framebuffer_data' type.
- Merges v3dvx_meta_clear.c and v3dvx_meta_copy.c into v3dvx_meta_common.c.
- Prefixes all "public" meta functions with the 'meta' prefix.

Reviewed-by: Alejandro Piñeiro <apinheiro@igalia.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/11902>
This commit is contained in:
Iago Toral Quiroga 2021-07-15 08:51:55 +02:00
parent 18642987fd
commit f481c290b0
8 changed files with 509 additions and 533 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
src/broadcom/vulkan/meson.build
View file

@ -61,8 +61,7 @@ files_per_version = files(
'v3dvx_formats.c',
'v3dvx_image.c',
'v3dvx_pipeline.c',
'v3dvx_meta_clear.c',
'v3dvx_meta_copy.c',
'v3dvx_meta_common.c',
'v3dvx_pipeline.c',
'v3dvx_queue.c',
)

168
src/broadcom/vulkan/v3dv_meta_clear.c
View file

@ -22,11 +22,179 @@
*/
#include "v3dv_private.h"
#include "v3dv_meta_common.h"
#include "compiler/nir/nir_builder.h"
#include "vk_format_info.h"
#include "util/u_pack_color.h"
static void
get_hw_clear_color(struct v3dv_device *device,
const VkClearColorValue *color,
VkFormat fb_format,
VkFormat image_format,
uint32_t internal_type,
uint32_t internal_bpp,
uint32_t *hw_color)
{
const uint32_t internal_size = 4 << internal_bpp;
/* If the image format doesn't match the framebuffer format, then we are
* trying to clear an unsupported tlb format using a compatible
* format for the framebuffer. In this case, we want to make sure that
* we pack the clear value according to the original format semantics,
* not the compatible format.
*/
if (fb_format == image_format) {
v3dv_X(device, get_hw_clear_color)(color, internal_type, internal_size,
hw_color);
} else {
union util_color uc;
enum pipe_format pipe_image_format =
vk_format_to_pipe_format(image_format);
util_pack_color(color->float32, pipe_image_format, &uc);
memcpy(hw_color, uc.ui, internal_size);
}
}
/* Returns true if the implementation is able to handle the case, false
* otherwise.
*/
static bool
clear_image_tlb(struct v3dv_cmd_buffer *cmd_buffer,
struct v3dv_image *image,
const VkClearValue *clear_value,
const VkImageSubresourceRange *range)
{
const VkOffset3D origin = { 0, 0, 0 };
VkFormat fb_format;
if (!v3dv_meta_can_use_tlb(image, &origin, &fb_format))
return false;
uint32_t internal_type, internal_bpp;
v3dv_X(cmd_buffer->device, get_internal_type_bpp_for_image_aspects)
(fb_format, range->aspectMask,
&internal_type, &internal_bpp);
union v3dv_clear_value hw_clear_value = { 0 };
if (range->aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) {
get_hw_clear_color(cmd_buffer->device, &clear_value->color, fb_format,
image->vk_format, internal_type, internal_bpp,
&hw_clear_value.color[0]);
} else {
assert((range->aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) ||
(range->aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT));
hw_clear_value.z = clear_value->depthStencil.depth;
hw_clear_value.s = clear_value->depthStencil.stencil;
}
uint32_t level_count = range->levelCount == VK_REMAINING_MIP_LEVELS ?
image->levels - range->baseMipLevel :
range->levelCount;
uint32_t min_level = range->baseMipLevel;
uint32_t max_level = range->baseMipLevel + level_count;
/* For 3D images baseArrayLayer and layerCount must be 0 and 1 respectively.
* Instead, we need to consider the full depth dimension of the image, which
* goes from 0 up to the level's depth extent.
*/
uint32_t min_layer;
uint32_t max_layer;
if (image->type != VK_IMAGE_TYPE_3D) {
uint32_t layer_count = range->layerCount == VK_REMAINING_ARRAY_LAYERS ?
image->array_size - range->baseArrayLayer :
range->layerCount;
min_layer = range->baseArrayLayer;
max_layer = range->baseArrayLayer + layer_count;
} else {
min_layer = 0;
max_layer = 0;
}
for (uint32_t level = min_level; level < max_level; level++) {
if (image->type == VK_IMAGE_TYPE_3D)
max_layer = u_minify(image->extent.depth, level);
for (uint32_t layer = min_layer; layer < max_layer; layer++) {
uint32_t width = u_minify(image->extent.width, level);
uint32_t height = u_minify(image->extent.height, level);
struct v3dv_job *job =
v3dv_cmd_buffer_start_job(cmd_buffer, -1, V3DV_JOB_TYPE_GPU_CL);
if (!job)
return true;
/* We start a a new job for each layer so the frame "depth" is 1 */
v3dv_job_start_frame(job, width, height, 1, 1, internal_bpp,
image->samples > VK_SAMPLE_COUNT_1_BIT);
struct v3dv_meta_framebuffer framebuffer;
v3dv_X(job->device, meta_framebuffer_init)(&framebuffer, fb_format,
internal_type,
&job->frame_tiling);
v3dv_X(job->device, job_emit_binning_flush)(job);
/* If this triggers it is an application bug: the spec requires
* that any aspects to clear are present in the image.
*/
assert(range->aspectMask & image->aspects);
v3dv_X(job->device, meta_emit_clear_image_rcl)
(job, image, &framebuffer, &hw_clear_value,
range->aspectMask, layer, level);
v3dv_cmd_buffer_finish_job(cmd_buffer);
}
}
return true;
}
VKAPI_ATTR void VKAPI_CALL
v3dv_CmdClearColorImage(VkCommandBuffer commandBuffer,
VkImage _image,
VkImageLayout imageLayout,
const VkClearColorValue *pColor,
uint32_t rangeCount,
const VkImageSubresourceRange *pRanges)
{
V3DV_FROM_HANDLE(v3dv_cmd_buffer, cmd_buffer, commandBuffer);
V3DV_FROM_HANDLE(v3dv_image, image, _image);
const VkClearValue clear_value = {
.color = *pColor,
};
for (uint32_t i = 0; i < rangeCount; i++) {
if (clear_image_tlb(cmd_buffer, image, &clear_value, &pRanges[i]))
continue;
unreachable("Unsupported color clear.");
}
}
VKAPI_ATTR void VKAPI_CALL
v3dv_CmdClearDepthStencilImage(VkCommandBuffer commandBuffer,
VkImage _image,
VkImageLayout imageLayout,
const VkClearDepthStencilValue *pDepthStencil,
uint32_t rangeCount,
const VkImageSubresourceRange *pRanges)
{
V3DV_FROM_HANDLE(v3dv_cmd_buffer, cmd_buffer, commandBuffer);
V3DV_FROM_HANDLE(v3dv_image, image, _image);
const VkClearValue clear_value = {
.depthStencil = *pDepthStencil,
};
for (uint32_t i = 0; i < rangeCount; i++) {
if (clear_image_tlb(cmd_buffer, image, &clear_value, &pRanges[i]))
continue;
unreachable("Unsupported depth/stencil clear.");
}
}
static void
destroy_color_clear_pipeline(VkDevice _device,
uint64_t pipeline,

19
src/broadcom/vulkan/v3dv_meta_copy.h → src/broadcom/vulkan/v3dv_meta_common.h
View file

@ -20,8 +20,8 @@
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
#ifndef V3DV_META_COPY_H
#define V3DV_META_COPY_H
#ifndef V3DV_META_COMMON_H
#define V3DV_META_COMMON_H
/* Disable level 0 write, just write following mipmaps */
#define V3D_TFU_IOA_DIMTW (1 << 0)
@ -48,15 +48,14 @@
#define V3D_TFU_ICFG_FORMAT_UIF_XOR 15
/**
* Copy operations implemented in this file don't operate on a framebuffer
* object provided by the user, however, since most use the TLB for this,
* we still need to have some representation of the framebuffer. For the most
* part, the job's frame tiling information is enough for this, however we
* still need additional information such us the internal type of our single
* render target, so we use this auxiliary struct to pass that information
* around.
* Copy/Clear operations implemented in v3dv_meta_*.c that use the TLB hardware
* need to figure out TLB programming from the target image data instead of an
* actual Vulkan framebuffer object. For the most part, the job's frame tiling
* information is enough for this, however we still need additional information
* such us the internal type of our single render target, so we use this
* auxiliary struct to pass that information around.
*/
struct framebuffer_data {
struct v3dv_meta_framebuffer {
/* The internal type of the single render target */
uint32_t internal_type;

466
src/broadcom/vulkan/v3dv_meta_copy.c
View file

@ -22,7 +22,7 @@
*/
#include "v3dv_private.h"
#include "v3dv_meta_copy.h"
#include "v3dv_meta_common.h"
#include "compiler/nir/nir_builder.h"
#include "vk_format_info.h"
@ -242,10 +242,128 @@ v3dv_meta_texel_buffer_copy_finish(struct v3dv_device *device)
}
}
static inline bool
can_use_tlb(struct v3dv_image *image,
const VkOffset3D *offset,
VkFormat *compat_format);
static VkFormat
get_compatible_tlb_format(VkFormat format)
{
switch (format) {
case VK_FORMAT_R8G8B8A8_SNORM:
return VK_FORMAT_R8G8B8A8_UINT;
case VK_FORMAT_R8G8_SNORM:
return VK_FORMAT_R8G8_UINT;
case VK_FORMAT_R8_SNORM:
return VK_FORMAT_R8_UINT;
case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
return VK_FORMAT_A8B8G8R8_UINT_PACK32;
case VK_FORMAT_R16_UNORM:
case VK_FORMAT_R16_SNORM:
return VK_FORMAT_R16_UINT;
case VK_FORMAT_R16G16_UNORM:
case VK_FORMAT_R16G16_SNORM:
return VK_FORMAT_R16G16_UINT;
case VK_FORMAT_R16G16B16A16_UNORM:
case VK_FORMAT_R16G16B16A16_SNORM:
return VK_FORMAT_R16G16B16A16_UINT;
case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
return VK_FORMAT_R32_SFLOAT;
/* We can't render to compressed formats using the TLB so instead we use
* a compatible format with the same bpp as the compressed format. Because
* the compressed format's bpp is for a full block (i.e. 4x4 pixels in the
* case of ETC), when we implement copies with the compatible format we
* will have to divide offsets and dimensions on the compressed image by
* the compressed block size.
*/
case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
case VK_FORMAT_BC2_UNORM_BLOCK:
case VK_FORMAT_BC2_SRGB_BLOCK:
case VK_FORMAT_BC3_SRGB_BLOCK:
case VK_FORMAT_BC3_UNORM_BLOCK:
case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
return VK_FORMAT_R32G32B32A32_UINT;
case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
case VK_FORMAT_EAC_R11_UNORM_BLOCK:
case VK_FORMAT_EAC_R11_SNORM_BLOCK:
case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
return VK_FORMAT_R16G16B16A16_UINT;
default:
return VK_FORMAT_UNDEFINED;
}
}
/**
* Checks if we can implement an image copy or clear operation using the TLB
* hardware.
*/
bool
v3dv_meta_can_use_tlb(struct v3dv_image *image,
const VkOffset3D *offset,
VkFormat *compat_format)
{
if (offset->x != 0 || offset->y != 0)
return false;
if (image->format->rt_type != V3D_OUTPUT_IMAGE_FORMAT_NO) {
if (compat_format)
*compat_format = image->vk_format;
return true;
}
/* If the image format is not TLB-supported, then check if we can use
* a compatible format instead.
*/
if (compat_format) {
*compat_format = get_compatible_tlb_format(image->vk_format);
if (*compat_format != VK_FORMAT_UNDEFINED)
return true;
}
return false;
}
/* Implements a copy using the TLB.
*
@ -264,7 +382,7 @@ copy_image_to_buffer_tlb(struct v3dv_cmd_buffer *cmd_buffer,
const VkBufferImageCopy2KHR *region)
{
VkFormat fb_format;
if (!can_use_tlb(image, &region->imageOffset, &fb_format))
if (!v3dv_meta_can_use_tlb(image, &region->imageOffset, &fb_format))
return false;
uint32_t internal_type, internal_bpp;
@ -292,12 +410,12 @@ copy_image_to_buffer_tlb(struct v3dv_cmd_buffer *cmd_buffer,
v3dv_job_start_frame(job, width, height, num_layers, 1, internal_bpp, false);
struct framebuffer_data framebuffer;
v3dv_X(job->device, setup_framebuffer_data)(&framebuffer, fb_format, internal_type,
&job->frame_tiling);
struct v3dv_meta_framebuffer framebuffer;
v3dv_X(job->device, meta_framebuffer_init)(&framebuffer, fb_format,
internal_type, &job->frame_tiling);
v3dv_X(job->device, job_emit_binning_flush)(job);
v3dv_X(job->device, job_emit_copy_image_to_buffer_rcl)
v3dv_X(job->device, meta_emit_copy_image_to_buffer_rcl)
(job, buffer, image, &framebuffer, region);
v3dv_cmd_buffer_finish_job(cmd_buffer);
@ -611,125 +729,6 @@ copy_image_to_buffer_blit(struct v3dv_cmd_buffer *cmd_buffer,
return true;
}
static VkFormat
get_compatible_tlb_format(VkFormat format)
{
switch (format) {
case VK_FORMAT_R8G8B8A8_SNORM:
return VK_FORMAT_R8G8B8A8_UINT;
case VK_FORMAT_R8G8_SNORM:
return VK_FORMAT_R8G8_UINT;
case VK_FORMAT_R8_SNORM:
return VK_FORMAT_R8_UINT;
case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
return VK_FORMAT_A8B8G8R8_UINT_PACK32;
case VK_FORMAT_R16_UNORM:
case VK_FORMAT_R16_SNORM:
return VK_FORMAT_R16_UINT;
case VK_FORMAT_R16G16_UNORM:
case VK_FORMAT_R16G16_SNORM:
return VK_FORMAT_R16G16_UINT;
case VK_FORMAT_R16G16B16A16_UNORM:
case VK_FORMAT_R16G16B16A16_SNORM:
return VK_FORMAT_R16G16B16A16_UINT;
case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
return VK_FORMAT_R32_SFLOAT;
/* We can't render to compressed formats using the TLB so instead we use
* a compatible format with the same bpp as the compressed format. Because
* the compressed format's bpp is for a full block (i.e. 4x4 pixels in the
* case of ETC), when we implement copies with the compatible format we
* will have to divide offsets and dimensions on the compressed image by
* the compressed block size.
*/
case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
case VK_FORMAT_BC2_UNORM_BLOCK:
case VK_FORMAT_BC2_SRGB_BLOCK:
case VK_FORMAT_BC3_SRGB_BLOCK:
case VK_FORMAT_BC3_UNORM_BLOCK:
case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
return VK_FORMAT_R32G32B32A32_UINT;
case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
case VK_FORMAT_EAC_R11_UNORM_BLOCK:
case VK_FORMAT_EAC_R11_SNORM_BLOCK:
case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
return VK_FORMAT_R16G16B16A16_UINT;
default:
return VK_FORMAT_UNDEFINED;
}
}
static inline bool
can_use_tlb(struct v3dv_image *image,
const VkOffset3D *offset,
VkFormat *compat_format)
{
if (offset->x != 0 || offset->y != 0)
return false;
if (image->format->rt_type != V3D_OUTPUT_IMAGE_FORMAT_NO) {
if (compat_format)
*compat_format = image->vk_format;
return true;
}
/* If the image format is not TLB-supported, then check if we can use
* a compatible format instead.
*/
if (compat_format) {
*compat_format = get_compatible_tlb_format(image->vk_format);
if (*compat_format != VK_FORMAT_UNDEFINED)
return true;
}
return false;
}
VKAPI_ATTR void VKAPI_CALL
v3dv_CmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer,
const VkCopyImageToBufferInfo2KHR *info)
@ -850,7 +849,7 @@ copy_image_tfu(struct v3dv_cmd_buffer *cmd_buffer,
const uint32_t base_dst_layer = dst->type != VK_IMAGE_TYPE_3D ?
region->dstSubresource.baseArrayLayer : region->dstOffset.z;
for (uint32_t i = 0; i < layer_count; i++) {
v3dv_X(cmd_buffer->device, cmd_buffer_emit_tfu_job)
v3dv_X(cmd_buffer->device, meta_emit_tfu_job)
(cmd_buffer, dst, dst_mip_level, base_dst_layer + i,
src, src_mip_level, base_src_layer + i,
width, height, format);
@ -870,8 +869,8 @@ copy_image_tlb(struct v3dv_cmd_buffer *cmd_buffer,
const VkImageCopy2KHR *region)
{
VkFormat fb_format;
if (!can_use_tlb(src, &region->srcOffset, &fb_format) ||
!can_use_tlb(dst, &region->dstOffset, &fb_format)) {
if (!v3dv_meta_can_use_tlb(src, &region->srcOffset, &fb_format) ||
!v3dv_meta_can_use_tlb(dst, &region->dstOffset, &fb_format)) {
return false;
}
@ -919,12 +918,12 @@ copy_image_tlb(struct v3dv_cmd_buffer *cmd_buffer,
v3dv_job_start_frame(job, width, height, num_layers, 1, internal_bpp,
src->samples > VK_SAMPLE_COUNT_1_BIT);
struct framebuffer_data framebuffer;
v3dv_X(job->device, setup_framebuffer_data)(&framebuffer, fb_format, internal_type,
&job->frame_tiling);
struct v3dv_meta_framebuffer framebuffer;
v3dv_X(job->device, meta_framebuffer_init)(&framebuffer, fb_format,
internal_type, &job->frame_tiling);
v3dv_X(job->device, job_emit_binning_flush)(job);
v3dv_X(job->device, job_emit_copy_image_rcl)(job, dst, src, &framebuffer, region);
v3dv_X(job->device, meta_emit_copy_image_rcl)(job, dst, src, &framebuffer, region);
v3dv_cmd_buffer_finish_job(cmd_buffer);
@ -1152,171 +1151,6 @@ v3dv_CmdCopyImage2KHR(VkCommandBuffer commandBuffer,
}
}
static void
get_hw_clear_color(struct v3dv_device *device,
const VkClearColorValue *color,
VkFormat fb_format,
VkFormat image_format,
uint32_t internal_type,
uint32_t internal_bpp,
uint32_t *hw_color)
{
const uint32_t internal_size = 4 << internal_bpp;
/* If the image format doesn't match the framebuffer format, then we are
* trying to clear an unsupported tlb format using a compatible
* format for the framebuffer. In this case, we want to make sure that
* we pack the clear value according to the original format semantics,
* not the compatible format.
*/
if (fb_format == image_format) {
v3dv_X(device, get_hw_clear_color)(color, internal_type, internal_size, hw_color);
} else {
union util_color uc;
enum pipe_format pipe_image_format =
vk_format_to_pipe_format(image_format);
util_pack_color(color->float32, pipe_image_format, &uc);
memcpy(hw_color, uc.ui, internal_size);
}
}
/* Returns true if the implementation is able to handle the case, false
* otherwise.
*/
static bool
clear_image_tlb(struct v3dv_cmd_buffer *cmd_buffer,
struct v3dv_image *image,
const VkClearValue *clear_value,
const VkImageSubresourceRange *range)
{
const VkOffset3D origin = { 0, 0, 0 };
VkFormat fb_format;
if (!can_use_tlb(image, &origin, &fb_format))
return false;
uint32_t internal_type, internal_bpp;
v3dv_X(cmd_buffer->device, get_internal_type_bpp_for_image_aspects)
(fb_format, range->aspectMask,
&internal_type, &internal_bpp);
union v3dv_clear_value hw_clear_value = { 0 };
if (range->aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) {
get_hw_clear_color(cmd_buffer->device, &clear_value->color, fb_format,
image->vk_format, internal_type, internal_bpp,
&hw_clear_value.color[0]);
} else {
assert((range->aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) ||
(range->aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT));
hw_clear_value.z = clear_value->depthStencil.depth;
hw_clear_value.s = clear_value->depthStencil.stencil;
}
uint32_t level_count = range->levelCount == VK_REMAINING_MIP_LEVELS ?
image->levels - range->baseMipLevel :
range->levelCount;
uint32_t min_level = range->baseMipLevel;
uint32_t max_level = range->baseMipLevel + level_count;
/* For 3D images baseArrayLayer and layerCount must be 0 and 1 respectively.
* Instead, we need to consider the full depth dimension of the image, which
* goes from 0 up to the level's depth extent.
*/
uint32_t min_layer;
uint32_t max_layer;
if (image->type != VK_IMAGE_TYPE_3D) {
uint32_t layer_count = range->layerCount == VK_REMAINING_ARRAY_LAYERS ?
image->array_size - range->baseArrayLayer :
range->layerCount;
min_layer = range->baseArrayLayer;
max_layer = range->baseArrayLayer + layer_count;
} else {
min_layer = 0;
max_layer = 0;
}
for (uint32_t level = min_level; level < max_level; level++) {
if (image->type == VK_IMAGE_TYPE_3D)
max_layer = u_minify(image->extent.depth, level);
for (uint32_t layer = min_layer; layer < max_layer; layer++) {
uint32_t width = u_minify(image->extent.width, level);
uint32_t height = u_minify(image->extent.height, level);
struct v3dv_job *job =
v3dv_cmd_buffer_start_job(cmd_buffer, -1, V3DV_JOB_TYPE_GPU_CL);
if (!job)
return true;
/* We start a a new job for each layer so the frame "depth" is 1 */
v3dv_job_start_frame(job, width, height, 1, 1, internal_bpp,
image->samples > VK_SAMPLE_COUNT_1_BIT);
struct framebuffer_data framebuffer;
v3dv_X(job->device, setup_framebuffer_data)(&framebuffer, fb_format, internal_type,
&job->frame_tiling);
v3dv_X(job->device, job_emit_binning_flush)(job);
/* If this triggers it is an application bug: the spec requires
* that any aspects to clear are present in the image.
*/
assert(range->aspectMask & image->aspects);
v3dv_X(job->device, job_emit_clear_image_rcl)
(job, image, &framebuffer, &hw_clear_value,
range->aspectMask, layer, level);
v3dv_cmd_buffer_finish_job(cmd_buffer);
}
}
return true;
}
VKAPI_ATTR void VKAPI_CALL
v3dv_CmdClearColorImage(VkCommandBuffer commandBuffer,
VkImage _image,
VkImageLayout imageLayout,
const VkClearColorValue *pColor,
uint32_t rangeCount,
const VkImageSubresourceRange *pRanges)
{
V3DV_FROM_HANDLE(v3dv_cmd_buffer, cmd_buffer, commandBuffer);
V3DV_FROM_HANDLE(v3dv_image, image, _image);
const VkClearValue clear_value = {
.color = *pColor,
};
for (uint32_t i = 0; i < rangeCount; i++) {
if (clear_image_tlb(cmd_buffer, image, &clear_value, &pRanges[i]))
continue;
unreachable("Unsupported color clear.");
}
}
VKAPI_ATTR void VKAPI_CALL
v3dv_CmdClearDepthStencilImage(VkCommandBuffer commandBuffer,
VkImage _image,
VkImageLayout imageLayout,
const VkClearDepthStencilValue *pDepthStencil,
uint32_t rangeCount,
const VkImageSubresourceRange *pRanges)
{
V3DV_FROM_HANDLE(v3dv_cmd_buffer, cmd_buffer, commandBuffer);
V3DV_FROM_HANDLE(v3dv_image, image, _image);
const VkClearValue clear_value = {
.depthStencil = *pDepthStencil,
};
for (uint32_t i = 0; i < rangeCount; i++) {
if (clear_image_tlb(cmd_buffer, image, &clear_value, &pRanges[i]))
continue;
unreachable("Unsupported depth/stencil clear.");
}
}
VKAPI_ATTR void VKAPI_CALL
v3dv_CmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
const VkCopyBufferInfo2KHR *pCopyBufferInfo)
@ -1326,7 +1160,7 @@ v3dv_CmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
V3DV_FROM_HANDLE(v3dv_buffer, dst_buffer, pCopyBufferInfo->dstBuffer);
for (uint32_t i = 0; i < pCopyBufferInfo->regionCount; i++) {
v3dv_X(cmd_buffer->device, cmd_buffer_copy_buffer)
v3dv_X(cmd_buffer->device, meta_copy_buffer)
(cmd_buffer,
dst_buffer->mem->bo, dst_buffer->mem_offset,
src_buffer->mem->bo, src_buffer->mem_offset,
@ -1378,7 +1212,7 @@ v3dv_CmdUpdateBuffer(VkCommandBuffer commandBuffer,
.size = dataSize,
};
struct v3dv_job *copy_job =
v3dv_X(cmd_buffer->device, cmd_buffer_copy_buffer)
v3dv_X(cmd_buffer->device, meta_copy_buffer)
(cmd_buffer, dst_buffer->mem->bo, dst_buffer->mem_offset,
src_bo, 0, &region);
@ -1411,7 +1245,7 @@ v3dv_CmdFillBuffer(VkCommandBuffer commandBuffer,
size -= size % 4;
}
v3dv_X(cmd_buffer->device, cmd_buffer_fill_buffer)
v3dv_X(cmd_buffer->device, meta_fill_buffer)
(cmd_buffer, bo, dstOffset, size, data);
}
@ -1559,7 +1393,7 @@ copy_buffer_to_image_tlb(struct v3dv_cmd_buffer *cmd_buffer,
const VkBufferImageCopy2KHR *region)
{
VkFormat fb_format;
if (!can_use_tlb(image, &region->imageOffset, &fb_format))
if (!v3dv_meta_can_use_tlb(image, &region->imageOffset, &fb_format))
return false;
uint32_t internal_type, internal_bpp;
@ -1587,12 +1421,12 @@ copy_buffer_to_image_tlb(struct v3dv_cmd_buffer *cmd_buffer,
v3dv_job_start_frame(job, width, height, num_layers, 1, internal_bpp, false);
struct framebuffer_data framebuffer;
v3dv_X(job->device, setup_framebuffer_data)(&framebuffer, fb_format, internal_type,
&job->frame_tiling);
struct v3dv_meta_framebuffer framebuffer;
v3dv_X(job->device, meta_framebuffer_init)(&framebuffer, fb_format,
internal_type, &job->frame_tiling);
v3dv_X(job->device, job_emit_binning_flush)(job);
v3dv_X(job->device, job_emit_copy_buffer_to_image_rcl)
v3dv_X(job->device, meta_emit_copy_buffer_to_image_rcl)
(job, image, buffer, &framebuffer, region);
v3dv_cmd_buffer_finish_job(cmd_buffer);
@ -3035,7 +2869,7 @@ blit_tfu(struct v3dv_cmd_buffer *cmd_buffer,
dst_mirror_z ? max_dst_layer - i - 1: min_dst_layer + i;
const uint32_t src_layer =
src_mirror_z ? max_src_layer - i - 1: min_src_layer + i;
v3dv_X(cmd_buffer->device, cmd_buffer_emit_tfu_job)
v3dv_X(cmd_buffer->device, meta_emit_tfu_job)
(cmd_buffer, dst, dst_mip_level, dst_layer,
src, src_mip_level, src_layer,
dst_width, dst_height, format);
@ -4384,8 +4218,8 @@ resolve_image_tlb(struct v3dv_cmd_buffer *cmd_buffer,
struct v3dv_image *src,
const VkImageResolve2KHR *region)
{
if (!can_use_tlb(src, &region->srcOffset, NULL) ||
!can_use_tlb(dst, &region->dstOffset, NULL)) {
if (!v3dv_meta_can_use_tlb(src, &region->srcOffset, NULL) ||
!v3dv_meta_can_use_tlb(dst, &region->dstOffset, NULL)) {
return false;
}
@ -4418,12 +4252,12 @@ resolve_image_tlb(struct v3dv_cmd_buffer *cmd_buffer,
v3dv_job_start_frame(job, width, height, num_layers, 1, internal_bpp, true);
struct framebuffer_data framebuffer;
v3dv_X(job->device, setup_framebuffer_data)(&framebuffer, fb_format, internal_type,
&job->frame_tiling);
struct v3dv_meta_framebuffer framebuffer;
v3dv_X(job->device, meta_framebuffer_init)(&framebuffer, fb_format,
internal_type, &job->frame_tiling);
v3dv_X(job->device, job_emit_binning_flush)(job);
v3dv_X(job->device, job_emit_resolve_image_rcl)(job, dst, src, &framebuffer, region);
v3dv_X(job->device, meta_emit_resolve_image_rcl)(job, dst, src, &framebuffer, region);
v3dv_cmd_buffer_finish_job(cmd_buffer);
return true;

4
src/broadcom/vulkan/v3dv_private.h
View file

@ -161,6 +161,10 @@ void v3dv_meta_blit_finish(struct v3dv_device *device);
void v3dv_meta_texel_buffer_copy_init(struct v3dv_device *device);
void v3dv_meta_texel_buffer_copy_finish(struct v3dv_device *device);
bool v3dv_meta_can_use_tlb(struct v3dv_image *image,
const VkOffset3D *offset,
VkFormat *compat_format);
struct v3dv_instance {
struct vk_instance vk;

28
src/broadcom/vulkan/v3dvx_meta_clear.c
View file

@ -1,28 +0,0 @@
/*
* Copyright © 2021 Raspberry Pi
*
* 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 "v3dv_private.h"
#include "broadcom/common/v3d_macros.h"
#include "broadcom/cle/v3dx_pack.h"
#include "broadcom/compiler/v3d_compiler.h"

203
src/broadcom/vulkan/v3dvx_meta_copy.c → src/broadcom/vulkan/v3dvx_meta_common.c
View file

@ -22,7 +22,8 @@
*/
#include "v3dv_private.h"
#include "v3dv_meta_copy.h"
#include "v3dv_meta_common.h"
#include "broadcom/common/v3d_macros.h"
#include "broadcom/cle/v3dx_pack.h"
#include "broadcom/compiler/v3d_compiler.h"
@ -39,7 +40,7 @@ struct rcl_clear_info {
static struct v3dv_cl *
emit_rcl_prologue(struct v3dv_job *job,
struct framebuffer_data *fb,
struct v3dv_meta_framebuffer *fb,
const struct rcl_clear_info *clear_info)
{
const struct v3dv_frame_tiling *tiling = &job->frame_tiling;
@ -181,7 +182,7 @@ emit_frame_setup(struct v3dv_job *job,
static void
emit_supertile_coordinates(struct v3dv_job *job,
struct framebuffer_data *framebuffer)
struct v3dv_meta_framebuffer *framebuffer)
{
v3dv_return_if_oom(NULL, job);
@ -248,7 +249,7 @@ emit_linear_store(struct v3dv_cl *cl,
* color format.
*/
static uint32_t
choose_tlb_format(struct framebuffer_data *framebuffer,
choose_tlb_format(struct v3dv_meta_framebuffer *framebuffer,
VkImageAspectFlags aspect,
bool for_store,
bool is_copy_to_buffer,
@ -314,7 +315,7 @@ format_needs_rb_swap(struct v3dv_device *device,
static void
emit_image_load(struct v3dv_device *device,
struct v3dv_cl *cl,
struct framebuffer_data *framebuffer,
struct v3dv_meta_framebuffer *framebuffer,
struct v3dv_image *image,
VkImageAspectFlags aspect,
uint32_t layer,
@ -397,7 +398,7 @@ emit_image_load(struct v3dv_device *device,
static void
emit_image_store(struct v3dv_device *device,
struct v3dv_cl *cl,
struct framebuffer_data *framebuffer,
struct v3dv_meta_framebuffer *framebuffer,
struct v3dv_image *image,
VkImageAspectFlags aspect,
uint32_t layer,
@ -459,7 +460,7 @@ emit_image_store(struct v3dv_device *device,
static void
emit_copy_layer_to_buffer_per_tile_list(struct v3dv_job *job,
struct framebuffer_data *framebuffer,
struct v3dv_meta_framebuffer *framebuffer,
struct v3dv_buffer *buffer,
struct v3dv_image *image,
uint32_t layer_offset,
@ -541,7 +542,7 @@ static void
emit_copy_layer_to_buffer(struct v3dv_job *job,
struct v3dv_buffer *buffer,
struct v3dv_image *image,
struct framebuffer_data *framebuffer,
struct v3dv_meta_framebuffer *framebuffer,
uint32_t layer,
const VkBufferImageCopy2KHR *region)
{
@ -552,11 +553,11 @@ emit_copy_layer_to_buffer(struct v3dv_job *job,
}
void
v3dX(job_emit_copy_image_to_buffer_rcl)(struct v3dv_job *job,
struct v3dv_buffer *buffer,
struct v3dv_image *image,
struct framebuffer_data *framebuffer,
const VkBufferImageCopy2KHR *region)
v3dX(meta_emit_copy_image_to_buffer_rcl)(struct v3dv_job *job,
struct v3dv_buffer *buffer,
struct v3dv_image *image,
struct v3dv_meta_framebuffer *framebuffer,
const VkBufferImageCopy2KHR *region)
{
struct v3dv_cl *rcl = emit_rcl_prologue(job, framebuffer, NULL);
v3dv_return_if_oom(NULL, job);
@ -568,7 +569,7 @@ v3dX(job_emit_copy_image_to_buffer_rcl)(struct v3dv_job *job,
static void
emit_resolve_image_layer_per_tile_list(struct v3dv_job *job,
struct framebuffer_data *framebuffer,
struct v3dv_meta_framebuffer *framebuffer,
struct v3dv_image *dst,
struct v3dv_image *src,
uint32_t layer_offset,
@ -628,7 +629,7 @@ static void
emit_resolve_image_layer(struct v3dv_job *job,
struct v3dv_image *dst,
struct v3dv_image *src,
struct framebuffer_data *framebuffer,
struct v3dv_meta_framebuffer *framebuffer,
uint32_t layer,
const VkImageResolve2KHR *region)
{
@ -639,11 +640,11 @@ emit_resolve_image_layer(struct v3dv_job *job,
}
void
v3dX(job_emit_resolve_image_rcl)(struct v3dv_job *job,
struct v3dv_image *dst,
struct v3dv_image *src,
struct framebuffer_data *framebuffer,
const VkImageResolve2KHR *region)
v3dX(meta_emit_resolve_image_rcl)(struct v3dv_job *job,
struct v3dv_image *dst,
struct v3dv_image *src,
struct v3dv_meta_framebuffer *framebuffer,
const VkImageResolve2KHR *region)
{
struct v3dv_cl *rcl = emit_rcl_prologue(job, framebuffer, NULL);
v3dv_return_if_oom(NULL, job);
@ -690,14 +691,14 @@ emit_copy_buffer_per_tile_list(struct v3dv_job *job,
}
void
v3dX(job_emit_copy_buffer)(struct v3dv_job *job,
struct v3dv_bo *dst,
struct v3dv_bo *src,
uint32_t dst_offset,
uint32_t src_offset,
struct framebuffer_data *framebuffer,
uint32_t format,
uint32_t item_size)
v3dX(meta_emit_copy_buffer)(struct v3dv_job *job,
struct v3dv_bo *dst,
struct v3dv_bo *src,
uint32_t dst_offset,
uint32_t src_offset,
struct v3dv_meta_framebuffer *framebuffer,
uint32_t format,
uint32_t item_size)
{
const uint32_t stride = job->frame_tiling.width * item_size;
emit_copy_buffer_per_tile_list(job, dst, src,
@ -707,29 +708,29 @@ v3dX(job_emit_copy_buffer)(struct v3dv_job *job,
}
void
v3dX(job_emit_copy_buffer_rcl)(struct v3dv_job *job,
struct v3dv_bo *dst,
struct v3dv_bo *src,
uint32_t dst_offset,
uint32_t src_offset,
struct framebuffer_data *framebuffer,
uint32_t format,
uint32_t item_size)
v3dX(meta_emit_copy_buffer_rcl)(struct v3dv_job *job,
struct v3dv_bo *dst,
struct v3dv_bo *src,
uint32_t dst_offset,
uint32_t src_offset,
struct v3dv_meta_framebuffer *framebuffer,
uint32_t format,
uint32_t item_size)
{
struct v3dv_cl *rcl = emit_rcl_prologue(job, framebuffer, NULL);
v3dv_return_if_oom(NULL, job);
emit_frame_setup(job, 0, NULL);
v3dX(job_emit_copy_buffer)(job, dst, src, dst_offset, src_offset,
framebuffer, format, item_size);
v3dX(meta_emit_copy_buffer)(job, dst, src, dst_offset, src_offset,
framebuffer, format, item_size);
cl_emit(rcl, END_OF_RENDERING, end);
}
static void
emit_copy_image_layer_per_tile_list(struct v3dv_job *job,
struct framebuffer_data *framebuffer,
struct v3dv_meta_framebuffer *framebuffer,
struct v3dv_image *dst,
struct v3dv_image *src,
uint32_t layer_offset,
@ -789,7 +790,7 @@ static void
emit_copy_image_layer(struct v3dv_job *job,
struct v3dv_image *dst,
struct v3dv_image *src,
struct framebuffer_data *framebuffer,
struct v3dv_meta_framebuffer *framebuffer,
uint32_t layer,
const VkImageCopy2KHR *region)
{
@ -799,11 +800,11 @@ emit_copy_image_layer(struct v3dv_job *job,
}
void
v3dX(job_emit_copy_image_rcl)(struct v3dv_job *job,
struct v3dv_image *dst,
struct v3dv_image *src,
struct framebuffer_data *framebuffer,
const VkImageCopy2KHR *region)
v3dX(meta_emit_copy_image_rcl)(struct v3dv_job *job,
struct v3dv_image *dst,
struct v3dv_image *src,
struct v3dv_meta_framebuffer *framebuffer,
const VkImageCopy2KHR *region)
{
struct v3dv_cl *rcl = emit_rcl_prologue(job, framebuffer, NULL);
v3dv_return_if_oom(NULL, job);
@ -814,16 +815,16 @@ v3dX(job_emit_copy_image_rcl)(struct v3dv_job *job,
}
void
v3dX(cmd_buffer_emit_tfu_job)(struct v3dv_cmd_buffer *cmd_buffer,
struct v3dv_image *dst,
uint32_t dst_mip_level,
uint32_t dst_layer,
struct v3dv_image *src,
uint32_t src_mip_level,
uint32_t src_layer,
uint32_t width,
uint32_t height,
const struct v3dv_format *format)
v3dX(meta_emit_tfu_job)(struct v3dv_cmd_buffer *cmd_buffer,
struct v3dv_image *dst,
uint32_t dst_mip_level,
uint32_t dst_layer,
struct v3dv_image *src,
uint32_t src_mip_level,
uint32_t src_layer,
uint32_t width,
uint32_t height,
const struct v3dv_format *format)
{
const struct v3d_resource_slice *src_slice = &src->slices[src_mip_level];
const struct v3d_resource_slice *dst_slice = &dst->slices[dst_mip_level];
@ -894,7 +895,7 @@ v3dX(cmd_buffer_emit_tfu_job)(struct v3dv_cmd_buffer *cmd_buffer,
static void
emit_clear_image_per_tile_list(struct v3dv_job *job,
struct framebuffer_data *framebuffer,
struct v3dv_meta_framebuffer *framebuffer,
struct v3dv_image *image,
VkImageAspectFlags aspects,
uint32_t layer,
@ -928,7 +929,7 @@ emit_clear_image_per_tile_list(struct v3dv_job *job,
static void
emit_clear_image(struct v3dv_job *job,
struct v3dv_image *image,
struct framebuffer_data *framebuffer,
struct v3dv_meta_framebuffer *framebuffer,
VkImageAspectFlags aspects,
uint32_t layer,
uint32_t level)
@ -938,13 +939,13 @@ emit_clear_image(struct v3dv_job *job,
}
void
v3dX(job_emit_clear_image_rcl)(struct v3dv_job *job,
struct v3dv_image *image,
struct framebuffer_data *framebuffer,
const union v3dv_clear_value *clear_value,
VkImageAspectFlags aspects,
uint32_t layer,
uint32_t level)
v3dX(meta_emit_clear_image_rcl)(struct v3dv_job *job,
struct v3dv_image *image,
struct v3dv_meta_framebuffer *framebuffer,
const union v3dv_clear_value *clear_value,
VkImageAspectFlags aspects,
uint32_t layer,
uint32_t level)
{
const struct rcl_clear_info clear_info = {
.clear_value = clear_value,
@ -997,7 +998,7 @@ static void
emit_fill_buffer(struct v3dv_job *job,
struct v3dv_bo *bo,
uint32_t offset,
struct framebuffer_data *framebuffer)
struct v3dv_meta_framebuffer *framebuffer)
{
const uint32_t stride = job->frame_tiling.width * 4;
emit_fill_buffer_per_tile_list(job, bo, offset, stride);
@ -1005,11 +1006,11 @@ emit_fill_buffer(struct v3dv_job *job,
}
void
v3dX(job_emit_fill_buffer_rcl)(struct v3dv_job *job,
struct v3dv_bo *bo,
uint32_t offset,
struct framebuffer_data *framebuffer,
uint32_t data)
v3dX(meta_emit_fill_buffer_rcl)(struct v3dv_job *job,
struct v3dv_bo *bo,
uint32_t offset,
struct v3dv_meta_framebuffer *framebuffer,
uint32_t data)
{
const union v3dv_clear_value clear_value = {
.color = { data, 0, 0, 0 },
@ -1034,7 +1035,7 @@ v3dX(job_emit_fill_buffer_rcl)(struct v3dv_job *job,
static void
emit_copy_buffer_to_layer_per_tile_list(struct v3dv_job *job,
struct framebuffer_data *framebuffer,
struct v3dv_meta_framebuffer *framebuffer,
struct v3dv_image *image,
struct v3dv_buffer *buffer,
uint32_t layer,
@ -1145,7 +1146,7 @@ static void
emit_copy_buffer_to_layer(struct v3dv_job *job,
struct v3dv_image *image,
struct v3dv_buffer *buffer,
struct framebuffer_data *framebuffer,
struct v3dv_meta_framebuffer *framebuffer,
uint32_t layer,
const VkBufferImageCopy2KHR *region)
{
@ -1156,11 +1157,11 @@ emit_copy_buffer_to_layer(struct v3dv_job *job,
}
void
v3dX(job_emit_copy_buffer_to_image_rcl)(struct v3dv_job *job,
struct v3dv_image *image,
struct v3dv_buffer *buffer,
struct framebuffer_data *framebuffer,
const VkBufferImageCopy2KHR *region)
v3dX(meta_emit_copy_buffer_to_image_rcl)(struct v3dv_job *job,
struct v3dv_image *image,
struct v3dv_buffer *buffer,
struct v3dv_meta_framebuffer *framebuffer,
const VkBufferImageCopy2KHR *region)
{
struct v3dv_cl *rcl = emit_rcl_prologue(job, framebuffer, NULL);
v3dv_return_if_oom(NULL, job);
@ -1206,12 +1207,12 @@ framebuffer_size_for_pixel_count(uint32_t num_pixels,
}
struct v3dv_job *
v3dX(cmd_buffer_copy_buffer)(struct v3dv_cmd_buffer *cmd_buffer,
struct v3dv_bo *dst,
uint32_t dst_offset,
struct v3dv_bo *src,
uint32_t src_offset,
const VkBufferCopy2KHR *region)
v3dX(meta_copy_buffer)(struct v3dv_cmd_buffer *cmd_buffer,
struct v3dv_bo *dst,
uint32_t dst_offset,
struct v3dv_bo *src,
uint32_t src_offset,
const VkBufferCopy2KHR *region)
{
const uint32_t internal_bpp = V3D_INTERNAL_BPP_32;
const uint32_t internal_type = V3D_INTERNAL_TYPE_8UI;
@ -1262,14 +1263,14 @@ v3dX(cmd_buffer_copy_buffer)(struct v3dv_cmd_buffer *cmd_buffer,
v3dv_job_start_frame(job, width, height, 1, 1, internal_bpp, false);
struct framebuffer_data framebuffer;
v3dX(setup_framebuffer_data)(&framebuffer, vk_format, internal_type,
&job->frame_tiling);
struct v3dv_meta_framebuffer framebuffer;
v3dX(meta_framebuffer_init)(&framebuffer, vk_format, internal_type,
&job->frame_tiling);
v3dX(job_emit_binning_flush)(job);
v3dX(job_emit_copy_buffer_rcl)(job, dst, src, dst_offset, src_offset,
&framebuffer, format, item_size);
v3dX(meta_emit_copy_buffer_rcl)(job, dst, src, dst_offset, src_offset,
&framebuffer, format, item_size);
v3dv_cmd_buffer_finish_job(cmd_buffer);
@ -1284,11 +1285,11 @@ v3dX(cmd_buffer_copy_buffer)(struct v3dv_cmd_buffer *cmd_buffer,
}
void
v3dX(cmd_buffer_fill_buffer)(struct v3dv_cmd_buffer *cmd_buffer,
struct v3dv_bo *bo,
uint32_t offset,
uint32_t size,
uint32_t data)
v3dX(meta_fill_buffer)(struct v3dv_cmd_buffer *cmd_buffer,
struct v3dv_bo *bo,
uint32_t offset,
uint32_t size,
uint32_t data)
{
assert(size > 0 && size % 4 == 0);
assert(offset + size <= bo->size);
@ -1308,13 +1309,13 @@ v3dX(cmd_buffer_fill_buffer)(struct v3dv_cmd_buffer *cmd_buffer,
v3dv_job_start_frame(job, width, height, 1, 1, internal_bpp, false);
struct framebuffer_data framebuffer;
v3dX(setup_framebuffer_data)(&framebuffer, VK_FORMAT_R8G8B8A8_UINT,
internal_type, &job->frame_tiling);
struct v3dv_meta_framebuffer framebuffer;
v3dX(meta_framebuffer_init)(&framebuffer, VK_FORMAT_R8G8B8A8_UINT,
internal_type, &job->frame_tiling);
v3dX(job_emit_binning_flush)(job);
v3dX(job_emit_fill_buffer_rcl)(job, bo, offset, &framebuffer, data);
v3dX(meta_emit_fill_buffer_rcl)(job, bo, offset, &framebuffer, data);
v3dv_cmd_buffer_finish_job(cmd_buffer);
@ -1326,10 +1327,10 @@ v3dX(cmd_buffer_fill_buffer)(struct v3dv_cmd_buffer *cmd_buffer,
}
void
v3dX(setup_framebuffer_data)(struct framebuffer_data *fb,
VkFormat vk_format,
uint32_t internal_type,
const struct v3dv_frame_tiling *tiling)
v3dX(meta_framebuffer_init)(struct v3dv_meta_framebuffer *fb,
VkFormat vk_format,
uint32_t internal_type,
const struct v3dv_frame_tiling *tiling)
{
fb->internal_type = internal_type;

151
src/broadcom/vulkan/v3dvx_private.h
View file

@ -170,7 +170,7 @@ void
v3dX(pack_texture_shader_state_from_buffer_view)(struct v3dv_device *device,
struct v3dv_buffer_view *buffer_view);
/* Used at v3dv_meta_copy */
/* Used at v3dv_meta_* */
uint32_t
v3dX(zs_buffer_from_aspect_bits)(VkImageAspectFlags aspects);
@ -178,84 +178,83 @@ v3dX(zs_buffer_from_aspect_bits)(VkImageAspectFlags aspects);
uint8_t
v3dX(get_internal_depth_type)(VkFormat format);
struct framebuffer_data;
struct v3dv_meta_framebuffer;
void
v3dX(job_emit_copy_image_to_buffer_rcl)(struct v3dv_job *job,
struct v3dv_buffer *buffer,
struct v3dv_image *image,
struct framebuffer_data *framebuffer,
const VkBufferImageCopy2KHR *region);
v3dX(meta_emit_copy_image_to_buffer_rcl)(struct v3dv_job *job,
struct v3dv_buffer *buffer,
struct v3dv_image *image,
struct v3dv_meta_framebuffer *framebuffer,
const VkBufferImageCopy2KHR *region);
void
v3dX(job_emit_resolve_image_rcl)(struct v3dv_job *job,
struct v3dv_image *dst,
struct v3dv_image *src,
struct framebuffer_data *framebuffer,
const VkImageResolve2KHR *region);
v3dX(meta_emit_resolve_image_rcl)(struct v3dv_job *job,
struct v3dv_image *dst,
struct v3dv_image *src,
struct v3dv_meta_framebuffer *framebuffer,
const VkImageResolve2KHR *region);
void
v3dX(job_emit_copy_buffer)(struct v3dv_job *job,
struct v3dv_bo *dst,
struct v3dv_bo *src,
uint32_t dst_offset,
uint32_t src_offset,
struct framebuffer_data *framebuffer,
uint32_t format,
uint32_t item_size);
v3dX(meta_emit_copy_buffer)(struct v3dv_job *job,
struct v3dv_bo *dst,
struct v3dv_bo *src,
uint32_t dst_offset,
uint32_t src_offset,
struct v3dv_meta_framebuffer *framebuffer,
uint32_t format,
uint32_t item_size);
void
v3dX(job_emit_copy_buffer_rcl)(struct v3dv_job *job,
struct v3dv_bo *dst,
struct v3dv_bo *src,
uint32_t dst_offset,
uint32_t src_offset,
struct framebuffer_data *framebuffer,
uint32_t format,
uint32_t item_size);
v3dX(meta_emit_copy_buffer_rcl)(struct v3dv_job *job,
struct v3dv_bo *dst,
struct v3dv_bo *src,
uint32_t dst_offset,
uint32_t src_offset,
struct v3dv_meta_framebuffer *framebuffer,
uint32_t format,
uint32_t item_size);
void
v3dX(job_emit_copy_image_rcl)(struct v3dv_job *job,
struct v3dv_image *dst,
struct v3dv_image *src,
struct framebuffer_data *framebuffer,
const VkImageCopy2KHR *region);
v3dX(meta_emit_copy_image_rcl)(struct v3dv_job *job,
struct v3dv_image *dst,
struct v3dv_image *src,
struct v3dv_meta_framebuffer *framebuffer,
const VkImageCopy2KHR *region);
void
v3dX(cmd_buffer_emit_tfu_job)(struct v3dv_cmd_buffer *cmd_buffer,
struct v3dv_image *dst,
uint32_t dst_mip_level,
uint32_t dst_layer,
struct v3dv_image *src,
uint32_t src_mip_level,
uint32_t src_layer,
uint32_t width,
uint32_t height,
const struct v3dv_format *format);
v3dX(meta_emit_tfu_job)(struct v3dv_cmd_buffer *cmd_buffer,
struct v3dv_image *dst,
uint32_t dst_mip_level,
uint32_t dst_layer,
struct v3dv_image *src,
uint32_t src_mip_level,
uint32_t src_layer,
uint32_t width,
uint32_t height,
const struct v3dv_format *format);
void
v3dX(job_emit_clear_image_rcl)(struct v3dv_job *job,
struct v3dv_image *image,
struct framebuffer_data *framebuffer,
const union v3dv_clear_value *clear_value,
VkImageAspectFlags aspects,
uint32_t layer,
uint32_t level);
v3dX(meta_emit_clear_image_rcl)(struct v3dv_job *job,
struct v3dv_image *image,
struct v3dv_meta_framebuffer *framebuffer,
const union v3dv_clear_value *clear_value,
VkImageAspectFlags aspects,
uint32_t layer,
uint32_t level);
void
v3dX(job_emit_fill_buffer_rcl)(struct v3dv_job *job,
struct v3dv_bo *bo,
uint32_t offset,
struct framebuffer_data *framebuffer,
uint32_t data);
v3dX(meta_emit_fill_buffer_rcl)(struct v3dv_job *job,
struct v3dv_bo *bo,
uint32_t offset,
struct v3dv_meta_framebuffer *framebuffer,
uint32_t data);
void
v3dX(job_emit_copy_buffer_to_image_rcl)(struct v3dv_job *job,
struct v3dv_image *image,
struct v3dv_buffer *buffer,
struct framebuffer_data *framebuffer,
const VkBufferImageCopy2KHR *region);
v3dX(meta_emit_copy_buffer_to_image_rcl)(struct v3dv_job *job,
struct v3dv_image *image,
struct v3dv_buffer *buffer,
struct v3dv_meta_framebuffer *framebuffer,
const VkBufferImageCopy2KHR *region);
void
v3dX(get_internal_type_bpp_for_image_aspects)(VkFormat vk_format,
@ -264,25 +263,25 @@ v3dX(get_internal_type_bpp_for_image_aspects)(VkFormat vk_format,
uint32_t *internal_bpp);
struct v3dv_job *
v3dX(cmd_buffer_copy_buffer)(struct v3dv_cmd_buffer *cmd_buffer,
struct v3dv_bo *dst,
uint32_t dst_offset,
struct v3dv_bo *src,
uint32_t src_offset,
const VkBufferCopy2KHR *region);
v3dX(meta_copy_buffer)(struct v3dv_cmd_buffer *cmd_buffer,
struct v3dv_bo *dst,
uint32_t dst_offset,
struct v3dv_bo *src,
uint32_t src_offset,
const VkBufferCopy2KHR *region);
void
v3dX(cmd_buffer_fill_buffer)(struct v3dv_cmd_buffer *cmd_buffer,
struct v3dv_bo *bo,
uint32_t offset,
uint32_t size,
uint32_t data);
v3dX(meta_fill_buffer)(struct v3dv_cmd_buffer *cmd_buffer,
struct v3dv_bo *bo,
uint32_t offset,
uint32_t size,
uint32_t data);
void
v3dX(setup_framebuffer_data)(struct framebuffer_data *fb,
VkFormat vk_format,
uint32_t internal_type,
const struct v3dv_frame_tiling *tiling);
v3dX(meta_framebuffer_init)(struct v3dv_meta_framebuffer *fb,
VkFormat vk_format,
uint32_t internal_type,
const struct v3dv_frame_tiling *tiling);
/* Used at v3dv_pipeline */
void