fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-01-03 07:10:15 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

i965/fs_surface_builder: Use isl instead of mesa for format info

Browse source 
Reviewed-by: Chad Versace <chad.versace@intel.com>
This commit is contained in:
Jason Ekstrand 2016-04-15 21:55:02 -07:00
parent 1831fa104c
commit e53cabe730
1 changed files with 52 additions and 66 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

118
src/mesa/drivers/dri/i965/brw_fs_surface_builder.cpp
View file

@ -22,7 +22,6 @@
*/
#include "isl/isl.h"
#include "main/shaderimage.h"
#include "brw_fs_surface_builder.h"
#include "brw_fs.h"
@ -248,19 +247,21 @@ namespace {
* Return the per-channel bitfield widths for a given image format.
*/
inline color_u
get_bit_widths(mesa_format format)
get_bit_widths(isl_format format)
{
return color_u(_mesa_get_format_bits(format, GL_RED_BITS),
_mesa_get_format_bits(format, GL_GREEN_BITS),
_mesa_get_format_bits(format, GL_BLUE_BITS),
_mesa_get_format_bits(format, GL_ALPHA_BITS));
const isl_format_layout *fmtl = isl_format_get_layout(format);
return color_u(fmtl->channels.r.bits,
fmtl->channels.g.bits,
fmtl->channels.b.bits,
fmtl->channels.a.bits);
}
/**
* Return the per-channel bitfield shifts for a given image format.
*/
inline color_u
get_bit_shifts(mesa_format format)
get_bit_shifts(isl_format format)
{
const color_u widths = get_bit_widths(format);
return color_u(0, widths.r, widths.r + widths.g,
@ -271,7 +272,7 @@ namespace {
* Return true if all present components have the same bit width.
*/
inline bool
is_homogeneous(mesa_format format)
is_homogeneous(isl_format format)
{
const color_u widths = get_bit_widths(format);
return ((widths.g == 0 || widths.g == widths.r) &&
@ -283,10 +284,10 @@ namespace {
* Return true if the format conversion boils down to a trivial copy.
*/
inline bool
is_conversion_trivial(const brw_device_info *devinfo, mesa_format format)
is_conversion_trivial(const brw_device_info *devinfo, isl_format format)
{
return (get_bit_widths(format).r == 32 && is_homogeneous(format)) ||
format == brw_lower_mesa_image_format(devinfo, format);
format == isl_lower_storage_image_format(devinfo, format);
}
/**
@ -295,11 +296,11 @@ namespace {
*/
inline bool
has_supported_bit_layout(const brw_device_info *devinfo,
mesa_format format)
isl_format format)
{
const color_u widths = get_bit_widths(format);
const color_u lower_widths = get_bit_widths(
brw_lower_mesa_image_format(devinfo, format));
isl_lower_storage_image_format(devinfo, format));
return (widths.r == lower_widths.r &&
widths.g == lower_widths.g &&
@ -313,27 +314,13 @@ namespace {
* friends implemented as RGBA16UI).
*/
inline bool
has_split_bit_layout(const brw_device_info *devinfo, mesa_format format)
has_split_bit_layout(const brw_device_info *devinfo, isl_format format)
{
const mesa_format lower_format =
brw_lower_mesa_image_format(devinfo, format);
const isl_format lower_format =
isl_lower_storage_image_format(devinfo, format);
return (_mesa_format_num_components(format) <
_mesa_format_num_components(lower_format));
}
/**
* Return true unless we have to fall back to untyped surface access.
* Fail!
*/
inline bool
has_matching_typed_format(const brw_device_info *devinfo,
mesa_format format)
{
return (_mesa_get_format_bytes(format) <= 4 ||
(_mesa_get_format_bytes(format) <= 8 &&
(devinfo->gen >= 8 || devinfo->is_haswell)) ||
devinfo->gen >= 9);
return (isl_format_get_num_channels(format) <
isl_format_get_num_channels(lower_format));
}
/**
@ -345,14 +332,14 @@ namespace {
*/
inline bool
has_undefined_high_bits(const brw_device_info *devinfo,
mesa_format format)
isl_format format)
{
const mesa_format lower_format =
brw_lower_mesa_image_format(devinfo, format);
const isl_format lower_format =
isl_lower_storage_image_format(devinfo, format);
return (devinfo->gen == 7 && !devinfo->is_haswell &&
(lower_format == MESA_FORMAT_R_UINT16 ||
lower_format == MESA_FORMAT_R_UINT8));
(lower_format == ISL_FORMAT_R16_UINT ||
lower_format == ISL_FORMAT_R8_UINT));
}
/**
@ -360,10 +347,10 @@ namespace {
* requiring sign extension when unpacking.
*/
inline bool
needs_sign_extension(mesa_format format)
needs_sign_extension(isl_format format)
{
return (_mesa_get_format_datatype(format) == GL_SIGNED_NORMALIZED ||
_mesa_get_format_datatype(format) == GL_INT);
return isl_format_has_snorm_channel(format) ||
isl_format_has_sint_channel(format);
}
}
@ -459,14 +446,14 @@ namespace {
unsigned
num_image_coordinates(const fs_builder &bld,
unsigned surf_dims, unsigned arr_dims,
mesa_format format)
isl_format format)
{
/* HSW in vec4 mode and our software coordinate handling for untyped
* reads want the array index to be at the Z component.
*/
const bool array_index_at_z =
format != MESA_FORMAT_NONE &&
!image_format_info::has_matching_typed_format(
format != ISL_FORMAT_UNSUPPORTED &&
!isl_has_matching_typed_storage_image_format(
bld.shader->devinfo, format);
const unsigned zero_dims =
((surf_dims == 1 && arr_dims == 1 && array_index_at_z) ? 1 : 0);
@ -481,7 +468,7 @@ namespace {
fs_reg
emit_image_coordinates(const fs_builder &bld, const fs_reg &addr,
unsigned surf_dims, unsigned arr_dims,
mesa_format format)
isl_format format)
{
const unsigned dims =
num_image_coordinates(bld, surf_dims, arr_dims, format);
@ -976,9 +963,9 @@ namespace brw {
using namespace image_coordinates;
using namespace surface_access;
const brw_device_info *devinfo = bld.shader->devinfo;
const mesa_format format = _mesa_get_shader_image_format(gl_format);
const mesa_format lower_format =
brw_lower_mesa_image_format(devinfo, format);
const isl_format format = isl_format_for_gl_format(gl_format);
const isl_format lower_format =
isl_lower_storage_image_format(devinfo, format);
fs_reg tmp;
/* Transform the image coordinates into actual surface coordinates. */
@ -987,16 +974,15 @@ namespace brw {
const unsigned dims =
num_image_coordinates(bld, surf_dims, arr_dims, format);
if (has_matching_typed_format(devinfo, format)) {
if (isl_has_matching_typed_storage_image_format(devinfo, format)) {
/* Hopefully we get here most of the time... */
tmp = emit_typed_read(bld, image, saddr, dims,
_mesa_format_num_components(lower_format));
isl_format_get_num_channels(lower_format));
} else {
/* Untyped surface reads return 32 bits of the surface per
* component, without any sort of unpacking or type conversion,
*/
const unsigned size = _mesa_get_format_bytes(format) / 4;
const unsigned size = isl_format_get_layout(format)->bs / 4;
/* they don't properly handle out of bounds access, so we have to
* check manually if the coordinates are valid and predicate the
* surface read on the result,
@ -1048,19 +1034,19 @@ namespace brw {
get_bit_widths(format));
}
if (!_mesa_is_format_integer(format)) {
if (!isl_format_has_int_channel(format)) {
if (is_conversion_trivial(devinfo, format)) {
/* Just need to cast the vector to the target type. */
tmp = retype(tmp, BRW_REGISTER_TYPE_F);
} else {
/* Do the right sort of type conversion to float. */
if (_mesa_get_format_datatype(format) == GL_FLOAT)
if (isl_format_has_float_channel(format))
tmp = emit_convert_from_float(
bld, tmp, get_bit_widths(format));
else
tmp = emit_convert_from_scaled(
bld, tmp, get_bit_widths(format),
_mesa_is_format_signed(format));
isl_format_has_snorm_channel(format));
}
}
@ -1084,7 +1070,7 @@ namespace brw {
using namespace image_validity;
using namespace image_coordinates;
using namespace surface_access;
const mesa_format format = _mesa_get_shader_image_format(gl_format);
const isl_format format = isl_format_for_gl_format(gl_format);
const brw_device_info *devinfo = bld.shader->devinfo;
/* Transform the image coordinates into actual surface coordinates. */
@ -1093,7 +1079,7 @@ namespace brw {
const unsigned dims =
num_image_coordinates(bld, surf_dims, arr_dims, format);
if (format == MESA_FORMAT_NONE) {
if (gl_format == GL_NONE) {
/* We don't know what the format is, but that's fine because it
* implies write-only access, and typed surface writes are always
* able to take care of type conversion and packing for us.
@ -1101,22 +1087,22 @@ namespace brw {
emit_typed_write(bld, image, saddr, src, dims, 4);
} else {
const mesa_format lower_format =
brw_lower_mesa_image_format(devinfo, format);
const isl_format lower_format =
isl_lower_storage_image_format(devinfo, format);
fs_reg tmp = src;
if (!is_conversion_trivial(devinfo, format)) {
/* Do the right sort of type conversion. */
if (_mesa_get_format_datatype(format) == GL_FLOAT)
if (isl_format_has_float_channel(format))
tmp = emit_convert_to_float(bld, tmp, get_bit_widths(format));
else if (_mesa_is_format_integer(format))
else if (isl_format_has_int_channel(format))
tmp = emit_convert_to_integer(bld, tmp, get_bit_widths(format),
_mesa_is_format_signed(format));
isl_format_has_sint_channel(format));
else
tmp = emit_convert_to_scaled(bld, tmp, get_bit_widths(format),
_mesa_is_format_signed(format));
isl_format_has_snorm_channel(format));
}
/* We're down to bit manipulation at this point. */
@ -1135,16 +1121,16 @@ namespace brw {
get_bit_widths(format));
}
if (has_matching_typed_format(devinfo, format)) {
if (isl_has_matching_typed_storage_image_format(devinfo, format)) {
/* Hopefully we get here most of the time... */
emit_typed_write(bld, image, saddr, tmp, dims,
_mesa_format_num_components(lower_format));
isl_format_get_num_channels(lower_format));
} else {
/* Untyped surface writes store 32 bits of the surface per
* component, without any sort of packing or type conversion,
*/
const unsigned size = _mesa_get_format_bytes(format) / 4;
const unsigned size = isl_format_get_layout(format)->bs / 4;
/* they don't properly handle out of bounds access, so we have
* to check manually if the coordinates are valid and predicate
@ -1189,10 +1175,10 @@ namespace brw {
/* Transform the image coordinates into actual surface coordinates. */
const fs_reg saddr =
emit_image_coordinates(bld, addr, surf_dims, arr_dims,
MESA_FORMAT_R_UINT32);
ISL_FORMAT_R32_UINT);
const unsigned dims =
num_image_coordinates(bld, surf_dims, arr_dims,
MESA_FORMAT_R_UINT32);
ISL_FORMAT_R32_UINT);
/* Thankfully we can do without untyped atomics here. */
const fs_reg tmp = emit_typed_atomic(bld, image, saddr, src0, src1,