#include <assert.h>
#include "isl.h"
-#include "common/gen_device_info.h"
+#include "isl_priv.h"
+#include "dev/gen_device_info.h"
+
+#include "main/macros.h" /* Needed for MAX3 and MAX2 for format_rgb9e5 */
+#include "util/format_srgb.h"
+#include "util/format_rgb9e5.h"
+#include "util/format_r11g11b10f.h"
+
+/* Header-only format conversion include */
+#include "main/format_utils.h"
struct surface_format_info {
bool exists;
SF( x, x, x, x, x, x, Y, x, x, x, x, x, R32G32B32_SSCALED)
SF( x, x, x, x, x, x, Y, x, x, x, x, x, R32G32B32_USCALED)
SF( x, x, x, x, x, x, 75, x, x, x, x, x, R32G32B32_SFIXED)
- SF( Y, Y, x, x, Y, 45, Y, x, 60, 70, x, 90, R16G16B16A16_UNORM)
- SF( Y, Y, x, x, Y, 60, Y, x, x, 70, x, 90, R16G16B16A16_SNORM)
+ SF( Y, Y, x, x, Y, 45, Y, x, 60, 70, 110, 90, R16G16B16A16_UNORM)
+ SF( Y, Y, x, x, Y, 60, Y, x, x, 70, 110, 90, R16G16B16A16_SNORM)
SF( Y, x, x, x, Y, x, Y, x, x, 70, 90, 90, R16G16B16A16_SINT)
SF( Y, x, x, x, Y, x, Y, x, x, 70, 75, 90, R16G16B16A16_UINT)
SF( Y, Y, x, x, Y, Y, Y, x, x, 70, 90, 90, R16G16B16A16_FLOAT)
SF( Y, Y, x, x, Y, Y, x, x, x, x, x, 100, B8G8R8A8_UNORM_SRGB)
/* smpl filt shad CK RT AB VB SO color TW TR ccs_e */
SF( Y, Y, x, x, Y, Y, Y, x, 60, 70, x, 100, R10G10B10A2_UNORM)
- SF( Y, Y, x, x, x, x, x, x, 60, x, x, x, R10G10B10A2_UNORM_SRGB)
+ SF( Y, Y, x, x, x, x, x, x, 60, x, x, 120, R10G10B10A2_UNORM_SRGB)
SF( Y, x, x, x, Y, x, Y, x, x, 70, x, 100, R10G10B10A2_UINT)
SF( Y, Y, x, x, x, x, Y, x, x, x, x, x, R10G10B10_SNORM_A2_UNORM)
- SF( Y, Y, x, x, Y, Y, Y, x, 60, 70, x, 90, R8G8B8A8_UNORM)
+ SF( Y, Y, x, x, Y, Y, Y, x, 60, 70, 110, 90, R8G8B8A8_UNORM)
SF( Y, Y, x, x, Y, Y, x, x, 60, x, x, 100, R8G8B8A8_UNORM_SRGB)
- SF( Y, Y, x, x, Y, 60, Y, x, x, 70, x, 90, R8G8B8A8_SNORM)
+ SF( Y, Y, x, x, Y, 60, Y, x, x, 70, 110, 90, R8G8B8A8_SNORM)
SF( Y, x, x, x, Y, x, Y, x, x, 70, 90, 90, R8G8B8A8_SINT)
SF( Y, x, x, x, Y, x, Y, x, x, 70, 75, 90, R8G8B8A8_UINT)
- SF( Y, Y, x, x, Y, 45, Y, x, x, 70, x, 90, R16G16_UNORM)
- SF( Y, Y, x, x, Y, 60, Y, x, x, 70, x, 90, R16G16_SNORM)
+ SF( Y, Y, x, x, Y, 45, Y, x, x, 70, 110, 90, R16G16_UNORM)
+ SF( Y, Y, x, x, Y, 60, Y, x, x, 70, 110, 90, R16G16_SNORM)
SF( Y, x, x, x, Y, x, Y, x, x, 70, 90, 90, R16G16_SINT)
SF( Y, x, x, x, Y, x, Y, x, x, 70, 75, 90, R16G16_UINT)
SF( Y, Y, x, x, Y, Y, Y, x, x, 70, 90, 90, R16G16_FLOAT)
SF( Y, Y, x, x, Y, Y, 75, x, 60, 70, x, 100, B10G10R10A2_UNORM)
SF( Y, Y, x, x, Y, Y, x, x, 60, x, x, 100, B10G10R10A2_UNORM_SRGB)
SF( Y, Y, x, x, Y, Y, Y, x, x, 70, x, 100, R11G11B10_FLOAT)
+ SF(120, 120, x, x, 120, 120, x, x, x, x, x, 120, R10G10B10_FLOAT_A2_UNORM)
SF( Y, x, x, x, Y, x, Y, Y, x, 70, 70, 90, R32_SINT)
SF( Y, x, x, x, Y, x, Y, Y, x, 70, 70, 90, R32_UINT)
SF( Y, 50, Y, x, Y, Y, Y, Y, x, 70, 70, 90, R32_FLOAT)
- SF( Y, 50, Y, x, x, x, x, x, x, x, x, x, R24_UNORM_X8_TYPELESS)
+ SF( Y, 50, Y, x, x, x, x, x, x, x, x, 120, R24_UNORM_X8_TYPELESS)
SF( Y, x, x, x, x, x, x, x, x, x, x, x, X24_TYPELESS_G8_UINT)
SF( Y, Y, x, x, x, x, x, x, x, x, x, x, L16A16_UNORM)
SF( Y, 50, Y, x, x, x, x, x, x, x, x, x, I24X8_UNORM)
SF( x, x, x, x, x, x, Y, x, x, x, x, x, R16G16_USCALED)
SF( x, x, x, x, x, x, Y, x, x, x, x, x, R32_SSCALED)
SF( x, x, x, x, x, x, Y, x, x, x, x, x, R32_USCALED)
- SF( Y, Y, x, Y, Y, Y, x, x, x, 70, x, x, B5G6R5_UNORM)
- SF( Y, Y, x, x, Y, Y, x, x, x, x, x, x, B5G6R5_UNORM_SRGB)
- SF( Y, Y, x, Y, Y, Y, x, x, x, 70, x, x, B5G5R5A1_UNORM)
- SF( Y, Y, x, x, Y, Y, x, x, x, x, x, x, B5G5R5A1_UNORM_SRGB)
- SF( Y, Y, x, Y, Y, Y, x, x, x, 70, x, x, B4G4R4A4_UNORM)
- SF( Y, Y, x, x, Y, Y, x, x, x, x, x, x, B4G4R4A4_UNORM_SRGB)
- SF( Y, Y, x, x, Y, Y, Y, x, x, 70, x, x, R8G8_UNORM)
- SF( Y, Y, x, Y, Y, 60, Y, x, x, 70, x, x, R8G8_SNORM)
- SF( Y, x, x, x, Y, x, Y, x, x, 70, 90, x, R8G8_SINT)
- SF( Y, x, x, x, Y, x, Y, x, x, 70, 75, x, R8G8_UINT)
- SF( Y, Y, Y, x, Y, 45, Y, x, 70, 70, x, x, R16_UNORM)
- SF( Y, Y, x, x, Y, 60, Y, x, x, 70, x, x, R16_SNORM)
- SF( Y, x, x, x, Y, x, Y, x, x, 70, 90, x, R16_SINT)
- SF( Y, x, x, x, Y, x, Y, x, x, 70, 75, x, R16_UINT)
- SF( Y, Y, x, x, Y, Y, Y, x, x, 70, 90, x, R16_FLOAT)
+ SF( Y, Y, x, Y, Y, Y, x, x, x, 70, x, 120, B5G6R5_UNORM)
+ SF( Y, Y, x, x, Y, Y, x, x, x, x, x, 120, B5G6R5_UNORM_SRGB)
+ SF( Y, Y, x, Y, Y, Y, x, x, x, 70, x, 120, B5G5R5A1_UNORM)
+ SF( Y, Y, x, x, Y, Y, x, x, x, x, x, 120, B5G5R5A1_UNORM_SRGB)
+ SF( Y, Y, x, Y, Y, Y, x, x, x, 70, x, 120, B4G4R4A4_UNORM)
+ SF( Y, Y, x, x, Y, Y, x, x, x, x, x, 120, B4G4R4A4_UNORM_SRGB)
+ SF( Y, Y, x, x, Y, Y, Y, x, x, 70, 110, 120, R8G8_UNORM)
+ SF( Y, Y, x, Y, Y, 60, Y, x, x, 70, 110, 120, R8G8_SNORM)
+ SF( Y, x, x, x, Y, x, Y, x, x, 70, 90, 120, R8G8_SINT)
+ SF( Y, x, x, x, Y, x, Y, x, x, 70, 75, 120, R8G8_UINT)
+ SF( Y, Y, Y, x, Y, 45, Y, x, 70, 70, 110, 120, R16_UNORM)
+ SF( Y, Y, x, x, Y, 60, Y, x, x, 70, 110, 120, R16_SNORM)
+ SF( Y, x, x, x, Y, x, Y, x, x, 70, 90, 120, R16_SINT)
+ SF( Y, x, x, x, Y, x, Y, x, x, 70, 75, 120, R16_UINT)
+ SF( Y, Y, x, x, Y, Y, Y, x, x, 70, 90, 120, R16_FLOAT)
SF( 50, 50, x, x, x, x, x, x, x, x, x, x, A8P8_UNORM_PALETTE0)
SF( 50, 50, x, x, x, x, x, x, x, x, x, x, A8P8_UNORM_PALETTE1)
SF( Y, Y, Y, x, x, x, x, x, x, x, x, x, I16_UNORM)
SF( Y, Y, Y, x, x, x, x, x, x, x, x, x, A16_FLOAT)
SF( 45, 45, x, x, x, x, x, x, x, x, x, x, L8A8_UNORM_SRGB)
SF( Y, Y, x, Y, x, x, x, x, x, x, x, x, R5G5_SNORM_B6_UNORM)
- SF( x, x, x, x, Y, Y, x, x, x, 70, x, x, B5G5R5X1_UNORM)
- SF( x, x, x, x, Y, Y, x, x, x, x, x, x, B5G5R5X1_UNORM_SRGB)
+ SF( x, x, x, x, Y, Y, x, x, x, 70, x, 120, B5G5R5X1_UNORM)
+ SF( x, x, x, x, Y, Y, x, x, x, x, x, 120, B5G5R5X1_UNORM_SRGB)
SF( x, x, x, x, x, x, Y, x, x, x, x, x, R8G8_SSCALED)
SF( x, x, x, x, x, x, Y, x, x, x, x, x, R8G8_USCALED)
/* smpl filt shad CK RT AB VB SO color TW TR ccs_e */
SF( x, x, x, x, x, x, Y, x, x, x, x, x, R16_USCALED)
SF( 50, 50, x, x, x, x, x, x, x, x, x, x, P8A8_UNORM_PALETTE0)
SF( 50, 50, x, x, x, x, x, x, x, x, x, x, P8A8_UNORM_PALETTE1)
- SF( x, x, x, x, x, x, x, x, x, x, x, x, A1B5G5R5_UNORM)
+ SF(120, 120, x, x, 120, 120, x, x, x, x, x, 120, A1B5G5R5_UNORM)
/* According to the PRM, A4B4G4R4_UNORM isn't supported until Sky Lake
* but empirical testing indicates that at least sampling works just fine
* on Broadwell.
*/
- SF( 80, 80, x, x, 90, x, x, x, x, x, x, x, A4B4G4R4_UNORM)
+ SF( 80, 80, x, x, 90, 120, x, x, x, x, x, 120, A4B4G4R4_UNORM)
SF( 90, x, x, x, x, x, x, x, x, x, x, x, L8A8_UINT)
SF( 90, x, x, x, x, x, x, x, x, x, x, x, L8A8_SINT)
- SF( Y, Y, x, 45, Y, Y, Y, x, x, 70, x, x, R8_UNORM)
- SF( Y, Y, x, x, Y, 60, Y, x, x, 70, x, x, R8_SNORM)
- SF( Y, x, x, x, Y, x, Y, x, x, 70, 90, x, R8_SINT)
- SF( Y, x, x, x, Y, x, Y, x, x, 70, 75, x, R8_UINT)
- SF( Y, Y, x, Y, Y, Y, x, x, x, 70, x, x, A8_UNORM)
+ SF( Y, Y, x, 45, Y, Y, Y, x, x, 70, 110, 120, R8_UNORM)
+ SF( Y, Y, x, x, Y, 60, Y, x, x, 70, 110, 120, R8_SNORM)
+ SF( Y, x, x, x, Y, x, Y, x, x, 70, 90, 120, R8_SINT)
+ SF( Y, x, x, x, Y, x, Y, x, x, 70, 75, 120, R8_UINT)
+ SF( Y, Y, x, Y, Y, Y, x, x, x, 70, 110, 120, A8_UNORM)
SF( Y, Y, x, x, x, x, x, x, x, x, x, x, I8_UNORM)
SF( Y, Y, x, Y, x, x, x, x, x, x, x, x, L8_UNORM)
SF( Y, Y, x, x, x, x, x, x, x, x, x, x, P4A4_UNORM_PALETTE0)
SF( 70, 70, x, x, x, x, x, x, x, x, x, x, BC7_UNORM_SRGB)
SF( 70, 70, x, x, x, x, x, x, x, x, x, x, BC6H_UF16)
SF( x, x, x, x, x, x, x, x, x, x, x, x, PLANAR_420_8)
- SF( 75, 75, x, x, x, x, x, x, x, x, x, x, R8G8B8_UNORM_SRGB)
+ /* The format enum for R8G8B8_UNORM_SRGB first shows up in the HSW PRM but
+ * empirical testing indicates that it doesn't actually sRGB decode and
+ * acts identical to R8G8B8_UNORM. It does work on gen8+.
+ */
+ SF( 80, 80, x, x, x, x, x, x, x, x, x, x, R8G8B8_UNORM_SRGB)
SF( 80, 80, x, x, x, x, x, x, x, x, x, x, ETC1_RGB8)
SF( 80, 80, x, x, x, x, x, x, x, x, x, x, ETC2_RGB8)
SF( 80, 80, x, x, x, x, x, x, x, x, x, x, EAC_R11)
return devinfo->gen * 10 + (devinfo->is_g4x || devinfo->is_haswell) * 5;
}
+static bool
+format_info_exists(enum isl_format format)
+{
+ assert(format != ISL_FORMAT_UNSUPPORTED);
+ assert(format < ISL_NUM_FORMATS);
+ return format < ARRAY_SIZE(format_info) && format_info[format].exists;
+}
+
bool
isl_format_supports_rendering(const struct gen_device_info *devinfo,
enum isl_format format)
{
- if (!format_info[format].exists)
+ if (!format_info_exists(format))
return false;
return format_gen(devinfo) >= format_info[format].render_target;
isl_format_supports_alpha_blending(const struct gen_device_info *devinfo,
enum isl_format format)
{
- if (!format_info[format].exists)
+ if (!format_info_exists(format))
return false;
return format_gen(devinfo) >= format_info[format].alpha_blend;
isl_format_supports_sampling(const struct gen_device_info *devinfo,
enum isl_format format)
{
- if (!format_info[format].exists)
+ if (!format_info_exists(format))
return false;
if (devinfo->is_baytrail) {
isl_format_supports_filtering(const struct gen_device_info *devinfo,
enum isl_format format)
{
- if (!format_info[format].exists)
+ if (!format_info_exists(format))
return false;
if (devinfo->is_baytrail) {
isl_format_supports_vertex_fetch(const struct gen_device_info *devinfo,
enum isl_format format)
{
- if (!format_info[format].exists)
+ if (!format_info_exists(format))
return false;
/* For vertex fetch, Bay Trail supports the same set of formats as Haswell
isl_format_supports_typed_writes(const struct gen_device_info *devinfo,
enum isl_format format)
{
- if (!format_info[format].exists)
+ if (!format_info_exists(format))
return false;
return format_gen(devinfo) >= format_info[format].typed_write;
isl_format_supports_typed_reads(const struct gen_device_info *devinfo,
enum isl_format format)
{
- if (!format_info[format].exists)
+ if (!format_info_exists(format))
return false;
return format_gen(devinfo) >= format_info[format].typed_read;
isl_format_supports_ccs_d(const struct gen_device_info *devinfo,
enum isl_format format)
{
- /* Fast clears were first added on Ivy Bridge */
- if (devinfo->gen < 7)
+ /* Clear-only compression was first added on Ivy Bridge and was last
+ * implemented on Ice lake (see BSpec: 43862).
+ */
+ if (devinfo->gen < 7 || devinfo->gen > 11)
return false;
if (!isl_format_supports_rendering(devinfo, format))
isl_format_supports_ccs_e(const struct gen_device_info *devinfo,
enum isl_format format)
{
- if (!format_info[format].exists)
+ if (!format_info_exists(format))
+ return false;
+
+ /* For simplicity, only report that a format supports CCS_E if blorp can
+ * perform bit-for-bit copies with an image of that format while compressed.
+ * Unfortunately, R11G11B10_FLOAT is in a compression class of its own and
+ * there is no way to copy to/from it which doesn't potentially loose data
+ * if one of the bit patterns being copied isn't valid finite floats.
+ */
+ if (format == ISL_FORMAT_R11G11B10_FLOAT)
return false;
return format_gen(devinfo) >= format_info[format].ccs_e;
fmtl1->channels.a.bits == fmtl2->channels.a.bits;
}
-static inline bool
+static bool
isl_format_has_channel_type(enum isl_format fmt, enum isl_base_type type)
{
const struct isl_format_layout *fmtl = isl_format_get_layout(fmt);
return isl_format_has_channel_type(fmt, ISL_SINT);
}
+bool
+isl_format_has_color_component(enum isl_format fmt, int component)
+{
+ const struct isl_format_layout *fmtl = isl_format_get_layout(fmt);
+ const uint8_t intensity = fmtl->channels.i.bits;
+ const uint8_t luminance = fmtl->channels.l.bits;
+
+ switch (component) {
+ case 0:
+ return (fmtl->channels.r.bits + intensity + luminance) > 0;
+ case 1:
+ return (fmtl->channels.g.bits + intensity + luminance) > 0;
+ case 2:
+ return (fmtl->channels.b.bits + intensity + luminance) > 0;
+ case 3:
+ return (fmtl->channels.a.bits + intensity) > 0;
+ default:
+ assert(!"Invalid color component: must be 0..3");
+ return false;
+ }
+}
+
unsigned
isl_format_get_num_channels(enum isl_format fmt)
{
return ISL_FORMAT_UNSUPPORTED;
}
}
+
+enum isl_format
+isl_format_rgbx_to_rgba(enum isl_format rgbx)
+{
+ assert(isl_format_is_rgbx(rgbx));
+
+ switch (rgbx) {
+ case ISL_FORMAT_R32G32B32X32_FLOAT:
+ return ISL_FORMAT_R32G32B32A32_FLOAT;
+ case ISL_FORMAT_R16G16B16X16_UNORM:
+ return ISL_FORMAT_R16G16B16A16_UNORM;
+ case ISL_FORMAT_R16G16B16X16_FLOAT:
+ return ISL_FORMAT_R16G16B16A16_FLOAT;
+ case ISL_FORMAT_B8G8R8X8_UNORM:
+ return ISL_FORMAT_B8G8R8A8_UNORM;
+ case ISL_FORMAT_B8G8R8X8_UNORM_SRGB:
+ return ISL_FORMAT_B8G8R8A8_UNORM_SRGB;
+ case ISL_FORMAT_R8G8B8X8_UNORM:
+ return ISL_FORMAT_R8G8B8A8_UNORM;
+ case ISL_FORMAT_R8G8B8X8_UNORM_SRGB:
+ return ISL_FORMAT_R8G8B8A8_UNORM_SRGB;
+ case ISL_FORMAT_B10G10R10X2_UNORM:
+ return ISL_FORMAT_B10G10R10A2_UNORM;
+ case ISL_FORMAT_B5G5R5X1_UNORM:
+ return ISL_FORMAT_B5G5R5A1_UNORM;
+ case ISL_FORMAT_B5G5R5X1_UNORM_SRGB:
+ return ISL_FORMAT_B5G5R5A1_UNORM_SRGB;
+ default:
+ assert(!"Invalid RGBX format");
+ return rgbx;
+ }
+}
+
+static inline void
+pack_channel(const union isl_color_value *value, unsigned i,
+ const struct isl_channel_layout *layout,
+ enum isl_colorspace colorspace,
+ uint32_t data_out[4])
+{
+ if (layout->type == ISL_VOID)
+ return;
+
+ if (colorspace == ISL_COLORSPACE_SRGB)
+ assert(layout->type == ISL_UNORM);
+
+ uint32_t packed;
+ switch (layout->type) {
+ case ISL_UNORM:
+ if (colorspace == ISL_COLORSPACE_SRGB) {
+ if (layout->bits == 8) {
+ packed = util_format_linear_float_to_srgb_8unorm(value->f32[i]);
+ } else {
+ float srgb = util_format_linear_to_srgb_float(value->f32[i]);
+ packed = _mesa_float_to_unorm(srgb, layout->bits);
+ }
+ } else {
+ packed = _mesa_float_to_unorm(value->f32[i], layout->bits);
+ }
+ break;
+ case ISL_SNORM:
+ packed = _mesa_float_to_snorm(value->f32[i], layout->bits);
+ break;
+ case ISL_SFLOAT:
+ assert(layout->bits == 16 || layout->bits == 32);
+ if (layout->bits == 16) {
+ packed = _mesa_float_to_half(value->f32[i]);
+ } else {
+ packed = value->u32[i];
+ }
+ break;
+ case ISL_UINT:
+ packed = MIN(value->u32[i], MAX_UINT(layout->bits));
+ break;
+ case ISL_SINT:
+ packed = MIN(MAX(value->u32[i], MIN_INT(layout->bits)),
+ MAX_INT(layout->bits));
+ break;
+
+ default:
+ unreachable("Invalid channel type");
+ }
+
+ unsigned dword = layout->start_bit / 32;
+ unsigned bit = layout->start_bit % 32;
+ assert(bit + layout->bits <= 32);
+ data_out[dword] |= (packed & MAX_UINT(layout->bits)) << bit;
+}
+
+/**
+ * Take an isl_color_value and pack it into the actual bits as specified by
+ * the isl_format. This function is very slow for a format conversion
+ * function but should be fine for a single pixel worth of data.
+ */
+void
+isl_color_value_pack(const union isl_color_value *value,
+ enum isl_format format,
+ uint32_t *data_out)
+{
+ const struct isl_format_layout *fmtl = isl_format_get_layout(format);
+ assert(fmtl->colorspace == ISL_COLORSPACE_LINEAR ||
+ fmtl->colorspace == ISL_COLORSPACE_SRGB);
+ assert(!isl_format_is_compressed(format));
+
+ memset(data_out, 0, isl_align(fmtl->bpb, 32) / 8);
+
+ if (format == ISL_FORMAT_R9G9B9E5_SHAREDEXP) {
+ data_out[0] = float3_to_rgb9e5(value->f32);
+ return;
+ } else if (format == ISL_FORMAT_R11G11B10_FLOAT) {
+ data_out[0] = float3_to_r11g11b10f(value->f32);
+ return;
+ }
+
+ pack_channel(value, 0, &fmtl->channels.r, fmtl->colorspace, data_out);
+ pack_channel(value, 1, &fmtl->channels.g, fmtl->colorspace, data_out);
+ pack_channel(value, 2, &fmtl->channels.b, fmtl->colorspace, data_out);
+ pack_channel(value, 3, &fmtl->channels.a, ISL_COLORSPACE_LINEAR, data_out);
+ pack_channel(value, 0, &fmtl->channels.l, fmtl->colorspace, data_out);
+ pack_channel(value, 0, &fmtl->channels.i, ISL_COLORSPACE_LINEAR, data_out);
+ assert(fmtl->channels.p.bits == 0);
+}
+
+/** Extend an N-bit signed integer to 32 bits */
+static inline int32_t
+sign_extend(int32_t x, unsigned bits)
+{
+ if (bits < 32) {
+ unsigned shift = 32 - bits;
+ return (x << shift) >> shift;
+ } else {
+ return x;
+ }
+}
+
+static inline void
+unpack_channel(union isl_color_value *value,
+ unsigned start, unsigned count,
+ const struct isl_channel_layout *layout,
+ enum isl_colorspace colorspace,
+ const uint32_t *data_in)
+{
+ if (layout->type == ISL_VOID)
+ return;
+
+ unsigned dword = layout->start_bit / 32;
+ unsigned bit = layout->start_bit % 32;
+ assert(bit + layout->bits <= 32);
+ uint32_t packed = (data_in[dword] >> bit) & MAX_UINT(layout->bits);
+
+ union {
+ uint32_t u32;
+ float f32;
+ } unpacked;
+
+ if (colorspace == ISL_COLORSPACE_SRGB)
+ assert(layout->type == ISL_UNORM);
+
+ switch (layout->type) {
+ case ISL_UNORM:
+ unpacked.f32 = _mesa_unorm_to_float(packed, layout->bits);
+ if (colorspace == ISL_COLORSPACE_SRGB) {
+ if (layout->bits == 8) {
+ unpacked.f32 = util_format_srgb_8unorm_to_linear_float(packed);
+ } else {
+ float srgb = _mesa_unorm_to_float(packed, layout->bits);
+ unpacked.f32 = util_format_srgb_to_linear_float(srgb);
+ }
+ } else {
+ unpacked.f32 = _mesa_unorm_to_float(packed, layout->bits);
+ }
+ break;
+ case ISL_SNORM:
+ unpacked.f32 = _mesa_snorm_to_float(sign_extend(packed, layout->bits),
+ layout->bits);
+ break;
+ case ISL_SFLOAT:
+ assert(layout->bits == 16 || layout->bits == 32);
+ if (layout->bits == 16) {
+ unpacked.f32 = _mesa_half_to_float(packed);
+ } else {
+ unpacked.u32 = packed;
+ }
+ break;
+ case ISL_UINT:
+ unpacked.u32 = packed;
+ break;
+ case ISL_SINT:
+ unpacked.u32 = sign_extend(packed, layout->bits);
+ break;
+
+ default:
+ unreachable("Invalid channel type");
+ }
+
+ for (unsigned i = 0; i < count; i++)
+ value->u32[start + i] = unpacked.u32;
+}
+
+/**
+ * Take unpack an isl_color_value from the actual bits as specified by
+ * the isl_format. This function is very slow for a format conversion
+ * function but should be fine for a single pixel worth of data.
+ */
+void
+isl_color_value_unpack(union isl_color_value *value,
+ enum isl_format format,
+ const uint32_t data_in[4])
+{
+ const struct isl_format_layout *fmtl = isl_format_get_layout(format);
+ assert(fmtl->colorspace == ISL_COLORSPACE_LINEAR ||
+ fmtl->colorspace == ISL_COLORSPACE_SRGB);
+ assert(!isl_format_is_compressed(format));
+
+ /* Default to opaque black. */
+ memset(value, 0, sizeof(*value));
+ if (isl_format_has_int_channel(format)) {
+ value->u32[3] = 1u;
+ } else {
+ value->f32[3] = 1.0f;
+ }
+
+ if (format == ISL_FORMAT_R9G9B9E5_SHAREDEXP) {
+ rgb9e5_to_float3(data_in[0], value->f32);
+ return;
+ } else if (format == ISL_FORMAT_R11G11B10_FLOAT) {
+ r11g11b10f_to_float3(data_in[0], value->f32);
+ return;
+ }
+
+ unpack_channel(value, 0, 1, &fmtl->channels.r, fmtl->colorspace, data_in);
+ unpack_channel(value, 1, 1, &fmtl->channels.g, fmtl->colorspace, data_in);
+ unpack_channel(value, 2, 1, &fmtl->channels.b, fmtl->colorspace, data_in);
+ unpack_channel(value, 3, 1, &fmtl->channels.a, ISL_COLORSPACE_LINEAR, data_in);
+ unpack_channel(value, 0, 3, &fmtl->channels.l, fmtl->colorspace, data_in);
+ unpack_channel(value, 0, 4, &fmtl->channels.i, ISL_COLORSPACE_LINEAR, data_in);
+ assert(fmtl->channels.p.bits == 0);
+}
projects / mesa.git / blobdiff