* @author Jose Fonseca <jfonseca@vmware.com>
*/
-#include "u_math.h"
-#include "u_memory.h"
+#include "util/u_memory.h"
#include "u_format.h"
#include "u_format_s3tc.h"
#include "u_surface.h"
+#include "util/u_math.h"
#include "pipe/p_defines.h"
util_format_is_float(enum pipe_format format)
{
const struct util_format_description *desc = util_format_description(format);
- unsigned i;
+ int i;
assert(desc);
if (!desc) {
}
i = util_format_get_first_non_void_channel(format);
- if (i == -1) {
+ if (i < 0) {
return FALSE;
}
return (desc->colorspace == UTIL_FORMAT_COLORSPACE_RGB ||
desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) &&
- desc->swizzle[3] != UTIL_FORMAT_SWIZZLE_1;
+ desc->swizzle[3] != PIPE_SWIZZLE_1;
}
if ((desc->colorspace == UTIL_FORMAT_COLORSPACE_RGB ||
desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) &&
- desc->swizzle[0] == UTIL_FORMAT_SWIZZLE_X &&
- desc->swizzle[1] == UTIL_FORMAT_SWIZZLE_X &&
- desc->swizzle[2] == UTIL_FORMAT_SWIZZLE_X &&
- desc->swizzle[3] == UTIL_FORMAT_SWIZZLE_1) {
+ desc->swizzle[0] == PIPE_SWIZZLE_X &&
+ desc->swizzle[1] == PIPE_SWIZZLE_X &&
+ desc->swizzle[2] == PIPE_SWIZZLE_X &&
+ desc->swizzle[3] == PIPE_SWIZZLE_1) {
+ return TRUE;
+ }
+ return FALSE;
+}
+
+boolean
+util_format_is_alpha(enum pipe_format format)
+{
+ const struct util_format_description *desc =
+ util_format_description(format);
+
+ if ((desc->colorspace == UTIL_FORMAT_COLORSPACE_RGB ||
+ desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) &&
+ desc->swizzle[0] == PIPE_SWIZZLE_0 &&
+ desc->swizzle[1] == PIPE_SWIZZLE_0 &&
+ desc->swizzle[2] == PIPE_SWIZZLE_0 &&
+ desc->swizzle[3] == PIPE_SWIZZLE_X) {
return TRUE;
}
return FALSE;
desc->channel[i].normalized;
}
+boolean
+util_format_is_snorm8(enum pipe_format format)
+{
+ const struct util_format_description *desc = util_format_description(format);
+ int i;
+
+ if (desc->is_mixed)
+ return FALSE;
+
+ i = util_format_get_first_non_void_channel(format);
+ if (i == -1)
+ return FALSE;
+
+ return desc->channel[i].type == UTIL_FORMAT_TYPE_SIGNED &&
+ !desc->channel[i].pure_integer &&
+ desc->channel[i].normalized &&
+ desc->channel[i].size == 8;
+}
+
boolean
util_format_is_luminance_alpha(enum pipe_format format)
{
if ((desc->colorspace == UTIL_FORMAT_COLORSPACE_RGB ||
desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) &&
- desc->swizzle[0] == UTIL_FORMAT_SWIZZLE_X &&
- desc->swizzle[1] == UTIL_FORMAT_SWIZZLE_X &&
- desc->swizzle[2] == UTIL_FORMAT_SWIZZLE_X &&
- desc->swizzle[3] == UTIL_FORMAT_SWIZZLE_Y) {
+ desc->swizzle[0] == PIPE_SWIZZLE_X &&
+ desc->swizzle[1] == PIPE_SWIZZLE_X &&
+ desc->swizzle[2] == PIPE_SWIZZLE_X &&
+ desc->swizzle[3] == PIPE_SWIZZLE_Y) {
return TRUE;
}
return FALSE;
if ((desc->colorspace == UTIL_FORMAT_COLORSPACE_RGB ||
desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) &&
- desc->swizzle[0] == UTIL_FORMAT_SWIZZLE_X &&
- desc->swizzle[1] == UTIL_FORMAT_SWIZZLE_X &&
- desc->swizzle[2] == UTIL_FORMAT_SWIZZLE_X &&
- desc->swizzle[3] == UTIL_FORMAT_SWIZZLE_X) {
+ desc->swizzle[0] == PIPE_SWIZZLE_X &&
+ desc->swizzle[1] == PIPE_SWIZZLE_X &&
+ desc->swizzle[2] == PIPE_SWIZZLE_X &&
+ desc->swizzle[3] == PIPE_SWIZZLE_X) {
return TRUE;
}
return FALSE;
desc->block.bits == 32;
}
-boolean
-util_format_is_supported(enum pipe_format format, unsigned bind)
-{
- if (util_format_is_s3tc(format) && !util_format_s3tc_enabled) {
- return FALSE;
- }
-
-#ifndef TEXTURE_FLOAT_ENABLED
- if ((bind & PIPE_BIND_RENDER_TARGET) &&
- format != PIPE_FORMAT_R9G9B9E5_FLOAT &&
- format != PIPE_FORMAT_R11G11B10_FLOAT &&
- util_format_is_float(format)) {
- return FALSE;
- }
-#endif
-
- return TRUE;
-}
-
-
/**
* Calculates the MRD for the depth format. MRD is used in depth bias
* for UNORM and unbound depth buffers. When the depth buffer is floating
format_desc->pack_rgba_sint(dst_row, dst_stride, src_row, src_stride, w, h);
}
+/**
+ * Check if we can safely memcopy from the source format to the dest format.
+ * This basically covers the cases of a "used" channel copied to a typeless
+ * channel, plus some 1-channel cases.
+ * Examples of compatible copy formats include:
+ * b8g8r8a8_unorm -> b8g8r8x8_unorm
+ * a8r8g8b8_unorm -> x8r8g8b8_unorm
+ * b5g5r5a1_unorm -> b5g5r5x1_unorm
+ * b4g4r4a4_unorm -> b4g4r4x4_unorm
+ * l8_unorm -> r8_unorm
+ * i8_unorm -> l8_unorm
+ * i8_unorm -> a8_unorm
+ * i8_unorm -> r8_unorm
+ * l16_unorm -> r16_unorm
+ * z24_unorm_s8_uint -> z24x8_unorm
+ * s8_uint_z24_unorm -> x8z24_unorm
+ * r8g8b8a8_unorm -> r8g8b8x8_unorm
+ * a8b8g8r8_srgb -> x8b8g8r8_srgb
+ * b8g8r8a8_srgb -> b8g8r8x8_srgb
+ * a8r8g8b8_srgb -> x8r8g8b8_srgb
+ * a8b8g8r8_unorm -> x8b8g8r8_unorm
+ * r10g10b10a2_uscaled -> r10g10b10x2_uscaled
+ * r10sg10sb10sa2u_norm -> r10g10b10x2_snorm
+ */
boolean
util_is_format_compatible(const struct util_format_description *src_desc,
const struct util_format_description *dst_desc)
}
for (chan = 0; chan < 4; ++chan) {
- enum util_format_swizzle swizzle = dst_desc->swizzle[chan];
+ enum pipe_swizzle swizzle = dst_desc->swizzle[chan];
if (swizzle < 4) {
if (src_desc->swizzle[chan] != swizzle) {
format_desc->format == PIPE_FORMAT_LATC2_SNORM)
return FALSE;
return TRUE;
+ case UTIL_FORMAT_LAYOUT_BPTC:
+ if (format_desc->format == PIPE_FORMAT_BPTC_RGBA_UNORM)
+ return TRUE;
+ return FALSE;
+
+ case UTIL_FORMAT_LAYOUT_ETC:
+ if (format_desc->format == PIPE_FORMAT_ETC1_RGB8)
+ return TRUE;
+ return FALSE;
case UTIL_FORMAT_LAYOUT_PLAIN:
/*
return TRUE;
}
+boolean
+util_format_translate_3d(enum pipe_format dst_format,
+ void *dst, unsigned dst_stride,
+ unsigned dst_slice_stride,
+ unsigned dst_x, unsigned dst_y,
+ unsigned dst_z,
+ enum pipe_format src_format,
+ const void *src, unsigned src_stride,
+ unsigned src_slice_stride,
+ unsigned src_x, unsigned src_y,
+ unsigned src_z, unsigned width,
+ unsigned height, unsigned depth)
+{
+ uint8_t *dst_layer;
+ const uint8_t *src_layer;
+ unsigned z;
+ dst_layer = dst;
+ src_layer = src;
+ dst_layer += dst_z * dst_slice_stride;
+ src_layer += src_z * src_slice_stride;
+ for (z = 0; z < depth; ++z) {
+ if (!util_format_translate(dst_format, dst_layer, dst_stride,
+ dst_x, dst_y,
+ src_format, src_layer, src_stride,
+ src_x, src_y,
+ width, height))
+ return FALSE;
+
+ dst_layer += dst_slice_stride;
+ src_layer += src_slice_stride;
+ }
+ return TRUE;
+}
+
void util_format_compose_swizzles(const unsigned char swz1[4],
const unsigned char swz2[4],
unsigned char dst[4])
unsigned i;
for (i = 0; i < 4; i++) {
- dst[i] = swz2[i] <= UTIL_FORMAT_SWIZZLE_W ?
+ dst[i] = swz2[i] <= PIPE_SWIZZLE_W ?
swz1[swz2[i]] : swz2[i];
}
}
if (is_integer) {
for (c = 0; c < 4; ++c) {
switch (swz[c]) {
- case PIPE_SWIZZLE_RED: dst->ui[c] = src->ui[0]; break;
- case PIPE_SWIZZLE_GREEN: dst->ui[c] = src->ui[1]; break;
- case PIPE_SWIZZLE_BLUE: dst->ui[c] = src->ui[2]; break;
- case PIPE_SWIZZLE_ALPHA: dst->ui[c] = src->ui[3]; break;
+ case PIPE_SWIZZLE_X: dst->ui[c] = src->ui[0]; break;
+ case PIPE_SWIZZLE_Y: dst->ui[c] = src->ui[1]; break;
+ case PIPE_SWIZZLE_Z: dst->ui[c] = src->ui[2]; break;
+ case PIPE_SWIZZLE_W: dst->ui[c] = src->ui[3]; break;
default:
- dst->ui[c] = (swz[c] == PIPE_SWIZZLE_ONE) ? 1 : 0;
+ dst->ui[c] = (swz[c] == PIPE_SWIZZLE_1) ? 1 : 0;
break;
}
}
} else {
for (c = 0; c < 4; ++c) {
switch (swz[c]) {
- case PIPE_SWIZZLE_RED: dst->f[c] = src->f[0]; break;
- case PIPE_SWIZZLE_GREEN: dst->f[c] = src->f[1]; break;
- case PIPE_SWIZZLE_BLUE: dst->f[c] = src->f[2]; break;
- case PIPE_SWIZZLE_ALPHA: dst->f[c] = src->f[3]; break;
+ case PIPE_SWIZZLE_X: dst->f[c] = src->f[0]; break;
+ case PIPE_SWIZZLE_Y: dst->f[c] = src->f[1]; break;
+ case PIPE_SWIZZLE_Z: dst->f[c] = src->f[2]; break;
+ case PIPE_SWIZZLE_W: dst->f[c] = src->f[3]; break;
default:
- dst->f[c] = (swz[c] == PIPE_SWIZZLE_ONE) ? 1.0f : 0.0f;
+ dst->f[c] = (swz[c] == PIPE_SWIZZLE_1) ? 1.0f : 0.0f;
break;
}
}
}
}
-void util_format_swizzle_4f(float *dst, const float *src,
+void pipe_swizzle_4f(float *dst, const float *src,
const unsigned char swz[4])
{
unsigned i;
for (i = 0; i < 4; i++) {
- if (swz[i] <= UTIL_FORMAT_SWIZZLE_W)
+ if (swz[i] <= PIPE_SWIZZLE_W)
dst[i] = src[swz[i]];
- else if (swz[i] == UTIL_FORMAT_SWIZZLE_0)
+ else if (swz[i] == PIPE_SWIZZLE_0)
dst[i] = 0;
- else if (swz[i] == UTIL_FORMAT_SWIZZLE_1)
+ else if (swz[i] == PIPE_SWIZZLE_1)
dst[i] = 1;
}
}
for (i = 0; i < 4; i++) {
switch (swz[i]) {
- case UTIL_FORMAT_SWIZZLE_X:
+ case PIPE_SWIZZLE_X:
dst[0] = src[i];
break;
- case UTIL_FORMAT_SWIZZLE_Y:
+ case PIPE_SWIZZLE_Y:
dst[1] = src[i];
break;
- case UTIL_FORMAT_SWIZZLE_Z:
+ case PIPE_SWIZZLE_Z:
dst[2] = src[i];
break;
- case UTIL_FORMAT_SWIZZLE_W:
+ case PIPE_SWIZZLE_W:
dst[3] = src[i];
break;
}