Subversion Repositories Kolibri OS

/**************************************************************************

 *

 * Copyright 2009-2010 Vmware, Inc.

 * All Rights Reserved.

 *

 * 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, sub license, 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 NON-INFRINGEMENT.

 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS 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.

 *

 **************************************************************************/

#ifndef U_FORMAT_H

#define U_FORMAT_H

#include "pipe/p_format.h"

#include "pipe/p_defines.h"

#include "util/u_debug.h"

union pipe_color_union;

#ifdef __cplusplus

extern "C" {

#endif

/**

 * Describe how to pack/unpack pixels into/from the prescribed format.

 *

 * XXX: This could be renamed to something like util_format_pack, or broke down

 * in flags inside util_format_block that said exactly what we want.

 */

enum util_format_layout {

   /**

    * Formats with util_format_block::width == util_format_block::height == 1

    * that can be described as an ordinary data structure.

    */

   UTIL_FORMAT_LAYOUT_PLAIN = 0,

   /**

    * Formats with sub-sampled channels.

    *

    * This is for formats like YVYU where there is less than one sample per

    * pixel.

    */

   UTIL_FORMAT_LAYOUT_SUBSAMPLED = 3,

   /**

    * S3 Texture Compression formats.

    */

   UTIL_FORMAT_LAYOUT_S3TC = 4,

   /**

    * Red-Green Texture Compression formats.

    */

   UTIL_FORMAT_LAYOUT_RGTC = 5,

   /**

    * Ericsson Texture Compression

    */

   UTIL_FORMAT_LAYOUT_ETC = 6,

   /**

    * BC6/7 Texture Compression

    */

   UTIL_FORMAT_LAYOUT_BPTC = 7,

   /**

    * Everything else that doesn't fit in any of the above layouts.

    */

   UTIL_FORMAT_LAYOUT_OTHER = 8

};

struct util_format_block

{

   /** Block width in pixels */

   unsigned width;

   /** Block height in pixels */

   unsigned height;

   /** Block size in bits */

   unsigned bits;

};

enum util_format_type {

   UTIL_FORMAT_TYPE_VOID = 0,

   UTIL_FORMAT_TYPE_UNSIGNED = 1,

   UTIL_FORMAT_TYPE_SIGNED = 2,

   UTIL_FORMAT_TYPE_FIXED = 3,

   UTIL_FORMAT_TYPE_FLOAT = 4

};

enum util_format_swizzle {

   UTIL_FORMAT_SWIZZLE_X = 0,

   UTIL_FORMAT_SWIZZLE_Y = 1,

   UTIL_FORMAT_SWIZZLE_Z = 2,

   UTIL_FORMAT_SWIZZLE_W = 3,

   UTIL_FORMAT_SWIZZLE_0 = 4,

   UTIL_FORMAT_SWIZZLE_1 = 5,

   UTIL_FORMAT_SWIZZLE_NONE = 6,

   UTIL_FORMAT_SWIZZLE_MAX = 7  /**< Number of enums counter (must be last) */

};

enum util_format_colorspace {

   UTIL_FORMAT_COLORSPACE_RGB = 0,

   UTIL_FORMAT_COLORSPACE_SRGB = 1,

   UTIL_FORMAT_COLORSPACE_YUV = 2,

   UTIL_FORMAT_COLORSPACE_ZS = 3

};

struct util_format_channel_description

{

   unsigned type:5;        /**< UTIL_FORMAT_TYPE_x */

   unsigned normalized:1;

   unsigned pure_integer:1;

   unsigned size:9;        /**< bits per channel */

   unsigned shift:16;      /** number of bits from lsb */

};

struct util_format_description

{

   enum pipe_format format;

   const char *name;

   /**

    * Short name, striped of the prefix, lower case.

    */

   const char *short_name;

   /**

    * Pixel block dimensions.

    */

   struct util_format_block block;

   enum util_format_layout layout;

   /**

    * The number of channels.

    */

   unsigned nr_channels:3;

   /**

    * Whether all channels have the same number of (whole) bytes and type.

    */

   unsigned is_array:1;

   /**

    * Whether the pixel format can be described as a bitfield structure.

    *

    * In particular:

    * - pixel depth must be 8, 16, or 32 bits;

    * - all channels must be unsigned, signed, or void

    */

   unsigned is_bitmask:1;

   /**

    * Whether channels have mixed types (ignoring UTIL_FORMAT_TYPE_VOID).

    */

   unsigned is_mixed:1;

   /**

    * Input channel description, in the order XYZW.

    *

    * Only valid for UTIL_FORMAT_LAYOUT_PLAIN formats.

    *

    * If each channel is accessed as an individual N-byte value, X is always

    * at the lowest address in memory, Y is always next, and so on.  For all

    * currently-defined formats, the N-byte value has native endianness.

    *

    * If instead a group of channels is accessed as a single N-byte value,

    * the order of the channels within that value depends on endianness.

    * For big-endian targets, X is the most significant subvalue,

    * otherwise it is the least significant one.

    *

    * For example, if X is 8 bits and Y is 24 bits, the memory order is:

    *

    *                 0  1  2  3

    *  little-endian: X  Yl Ym Yu    (l = lower, m = middle, u = upper)

    *  big-endian:    X  Yu Ym Yl

    *

    * If X is 5 bits, Y is 5 bits, Z is 5 bits and W is 1 bit, the layout is:

    *

    *                        0        1

    *                 msb  lsb msb  lsb

    *  little-endian: YYYXXXXX WZZZZZYY

    *  big-endian:    XXXXXYYY YYZZZZZW

    */

   struct util_format_channel_description channel[4];

   /**

    * Output channel swizzle.

    *

    * The order is either:

    * - RGBA

    * - YUV(A)

    * - ZS

    * depending on the colorspace.

    */

   unsigned char swizzle[4];

   /**

    * Colorspace transformation.

    */

   enum util_format_colorspace colorspace;

   /**

    * Unpack pixel blocks to R8G8B8A8_UNORM.

    * Note: strides are in bytes.

    *

    * Only defined for non-depth-stencil formats.

    */

   void

   (*unpack_rgba_8unorm)(uint8_t *dst, unsigned dst_stride,

                         const uint8_t *src, unsigned src_stride,

                         unsigned width, unsigned height);

   /**

    * Pack pixel blocks from R8G8B8A8_UNORM.

    * Note: strides are in bytes.

    *

    * Only defined for non-depth-stencil formats.

    */

   void

   (*pack_rgba_8unorm)(uint8_t *dst, unsigned dst_stride,

                       const uint8_t *src, unsigned src_stride,

                       unsigned width, unsigned height);

   /**

    * Fetch a single pixel (i, j) from a block.

    *

    * XXX: Only defined for a very few select formats.

    */

   void

   (*fetch_rgba_8unorm)(uint8_t *dst,

                        const uint8_t *src,

                        unsigned i, unsigned j);

   /**

    * Unpack pixel blocks to R32G32B32A32_FLOAT.

    * Note: strides are in bytes.

    *

    * Only defined for non-depth-stencil formats.

    */

   void

   (*unpack_rgba_float)(float *dst, unsigned dst_stride,

                        const uint8_t *src, unsigned src_stride,

                        unsigned width, unsigned height);

   /**

    * Pack pixel blocks from R32G32B32A32_FLOAT.

    * Note: strides are in bytes.

    *

    * Only defined for non-depth-stencil formats.

    */

   void

   (*pack_rgba_float)(uint8_t *dst, unsigned dst_stride,

                      const float *src, unsigned src_stride,

                      unsigned width, unsigned height);

   /**

    * Fetch a single pixel (i, j) from a block.

    *

    * Only defined for non-depth-stencil and non-integer formats.

    */

   void

   (*fetch_rgba_float)(float *dst,

                       const uint8_t *src,

                       unsigned i, unsigned j);

   /**

    * Unpack pixels to Z32_UNORM.

    * Note: strides are in bytes.

    *

    * Only defined for depth formats.

    */

   void

   (*unpack_z_32unorm)(uint32_t *dst, unsigned dst_stride,

                       const uint8_t *src, unsigned src_stride,

                       unsigned width, unsigned height);

   /**

    * Pack pixels from Z32_FLOAT.

    * Note: strides are in bytes.

    *

    * Only defined for depth formats.

    */

   void

   (*pack_z_32unorm)(uint8_t *dst, unsigned dst_stride,

                     const uint32_t *src, unsigned src_stride,

                     unsigned width, unsigned height);

   /**

    * Unpack pixels to Z32_FLOAT.

    * Note: strides are in bytes.

    *

    * Only defined for depth formats.

    */

   void

   (*unpack_z_float)(float *dst, unsigned dst_stride,

                     const uint8_t *src, unsigned src_stride,

                     unsigned width, unsigned height);

   /**

    * Pack pixels from Z32_FLOAT.

    * Note: strides are in bytes.

    *

    * Only defined for depth formats.

    */

   void

   (*pack_z_float)(uint8_t *dst, unsigned dst_stride,

                   const float *src, unsigned src_stride,

                   unsigned width, unsigned height);

   /**

    * Unpack pixels to S8_UINT.

    * Note: strides are in bytes.

    *

    * Only defined for stencil formats.

    */

   void

   (*unpack_s_8uint)(uint8_t *dst, unsigned dst_stride,

                     const uint8_t *src, unsigned src_stride,

                     unsigned width, unsigned height);

   /**

    * Pack pixels from S8_UINT.

    * Note: strides are in bytes.

    *

    * Only defined for stencil formats.

    */

   void

   (*pack_s_8uint)(uint8_t *dst, unsigned dst_stride,

                   const uint8_t *src, unsigned src_stride,

                   unsigned width, unsigned height);

  /**

    * Unpack pixel blocks to R32G32B32A32_UINT.

    * Note: strides are in bytes.

    *

    * Only defined for INT formats.

    */

   void

   (*unpack_rgba_uint)(uint32_t *dst, unsigned dst_stride,

                       const uint8_t *src, unsigned src_stride,

                       unsigned width, unsigned height);

   void

   (*pack_rgba_uint)(uint8_t *dst, unsigned dst_stride,

                     const uint32_t *src, unsigned src_stride,

                     unsigned width, unsigned height);

  /**

    * Unpack pixel blocks to R32G32B32A32_SINT.

    * Note: strides are in bytes.

    *

    * Only defined for INT formats.

    */

   void

   (*unpack_rgba_sint)(int32_t *dst, unsigned dst_stride,

                       const uint8_t *src, unsigned src_stride,

                       unsigned width, unsigned height);

   void

   (*pack_rgba_sint)(uint8_t *dst, unsigned dst_stride,

                     const int32_t *src, unsigned src_stride,

                     unsigned width, unsigned height);

   /**

    * Fetch a single pixel (i, j) from a block.

    *

    * Only defined for unsigned (pure) integer formats.

    */

   void

   (*fetch_rgba_uint)(uint32_t *dst,

                      const uint8_t *src,

                      unsigned i, unsigned j);

   /**

    * Fetch a single pixel (i, j) from a block.

    *

    * Only defined for signed (pure) integer formats.

    */

   void

   (*fetch_rgba_sint)(int32_t *dst,

                      const uint8_t *src,

                      unsigned i, unsigned j);

};

extern const struct util_format_description

util_format_description_table[];

const struct util_format_description *

util_format_description(enum pipe_format format);

/*

 * Format query functions.

 */

static INLINE const char *

util_format_name(enum pipe_format format)

{

   const struct util_format_description *desc = util_format_description(format);

   assert(desc);

   if (!desc) {

      return "PIPE_FORMAT_???";

   }

   return desc->name;

}

static INLINE const char *

util_format_short_name(enum pipe_format format)

{

   const struct util_format_description *desc = util_format_description(format);

   assert(desc);

   if (!desc) {

      return "???";

   }

   return desc->short_name;

}

/**

 * Whether this format is plain, see UTIL_FORMAT_LAYOUT_PLAIN for more info.

 */

static INLINE boolean

util_format_is_plain(enum pipe_format format)

{

   const struct util_format_description *desc = util_format_description(format);

   if (!format) {

      return FALSE;

   }

   return desc->layout == UTIL_FORMAT_LAYOUT_PLAIN ? TRUE : FALSE;

}

static INLINE boolean

util_format_is_compressed(enum pipe_format format)

{

   const struct util_format_description *desc = util_format_description(format);

   assert(desc);

   if (!desc) {

      return FALSE;

   }

   switch (desc->layout) {

   case UTIL_FORMAT_LAYOUT_S3TC:

   case UTIL_FORMAT_LAYOUT_RGTC:

   case UTIL_FORMAT_LAYOUT_ETC:

   case UTIL_FORMAT_LAYOUT_BPTC:

      /* XXX add other formats in the future */

      return TRUE;

   default:

      return FALSE;

   }

}

static INLINE boolean

util_format_is_s3tc(enum pipe_format format)

{

   const struct util_format_description *desc = util_format_description(format);

   assert(desc);

   if (!desc) {

      return FALSE;

   }

   return desc->layout == UTIL_FORMAT_LAYOUT_S3TC ? TRUE : FALSE;

}

static INLINE boolean

util_format_is_srgb(enum pipe_format format)

{

   const struct util_format_description *desc = util_format_description(format);

   return desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB;

}

static INLINE boolean

util_format_has_depth(const struct util_format_description *desc)

{

   return desc->colorspace == UTIL_FORMAT_COLORSPACE_ZS &&

          desc->swizzle[0] != UTIL_FORMAT_SWIZZLE_NONE;

}

static INLINE boolean

util_format_has_stencil(const struct util_format_description *desc)

{

   return desc->colorspace == UTIL_FORMAT_COLORSPACE_ZS &&

          desc->swizzle[1] != UTIL_FORMAT_SWIZZLE_NONE;

}

static INLINE boolean

util_format_is_depth_or_stencil(enum pipe_format format)

{

   const struct util_format_description *desc = util_format_description(format);

   assert(desc);

   if (!desc) {

      return FALSE;

   }

   return util_format_has_depth(desc) ||

          util_format_has_stencil(desc);

}

static INLINE boolean

util_format_is_depth_and_stencil(enum pipe_format format)

{

   const struct util_format_description *desc = util_format_description(format);

   assert(desc);

   if (!desc) {

      return FALSE;

   }

   return util_format_has_depth(desc) &&

          util_format_has_stencil(desc);

}

/**

 * Calculates the depth format type based upon the incoming format description.

 */

static INLINE unsigned

util_get_depth_format_type(const struct util_format_description *desc)

{

   unsigned depth_channel = desc->swizzle[0];

   if (desc->colorspace == UTIL_FORMAT_COLORSPACE_ZS &&

       depth_channel != UTIL_FORMAT_SWIZZLE_NONE) {

      return desc->channel[depth_channel].type;

   } else {

      return UTIL_FORMAT_TYPE_VOID;

   }

}

/**

 * 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

 * point, the depth bias calculation does not use the MRD. However, the

 * default MRD will be 1.0 / ((1 << 24) - 1).

 */

double

util_get_depth_format_mrd(const struct util_format_description *desc);

/**

 * Return whether this is an RGBA, Z, S, or combined ZS format.

 * Useful for initializing pipe_blit_info::mask.

 */

static INLINE unsigned

util_format_get_mask(enum pipe_format format)

{

   const struct util_format_description *desc =

      util_format_description(format);

   if (!desc)

      return 0;

   if (util_format_has_depth(desc)) {

      if (util_format_has_stencil(desc)) {

         return PIPE_MASK_ZS;

      } else {

         return PIPE_MASK_Z;

      }

   } else {

      if (util_format_has_stencil(desc)) {

         return PIPE_MASK_S;

      } else {

         return PIPE_MASK_RGBA;

      }

   }

}

/**

 * Give the RGBA colormask of the channels that can be represented in this

 * format.

 *

 * That is, the channels whose values are preserved.

 */

static INLINE unsigned

util_format_colormask(const struct util_format_description *desc)

{

   unsigned colormask;

   unsigned chan;

   switch (desc->colorspace) {

   case UTIL_FORMAT_COLORSPACE_RGB:

   case UTIL_FORMAT_COLORSPACE_SRGB:

   case UTIL_FORMAT_COLORSPACE_YUV:

      colormask = 0;

      for (chan = 0; chan < 4; ++chan) {

         if (desc->swizzle[chan] < 4) {

            colormask |= (1 << chan);

         }

      }

      return colormask;

   case UTIL_FORMAT_COLORSPACE_ZS:

      return 0;

   default:

      assert(0);

      return 0;

   }

}

/**

 * Checks if color mask covers every channel for the specified format

 *

 * @param desc       a format description to check colormask with

 * @param colormask  a bit mask for channels, matches format of PIPE_MASK_RGBA

 */

static INLINE boolean

util_format_colormask_full(const struct util_format_description *desc, unsigned colormask)

{

   return (~colormask & util_format_colormask(desc)) == 0;

}

boolean

util_format_is_float(enum pipe_format format);

boolean

util_format_has_alpha(enum pipe_format format);

boolean

util_format_is_luminance(enum pipe_format format);

boolean

util_format_is_alpha(enum pipe_format format);

boolean

util_format_is_luminance_alpha(enum pipe_format format);

boolean

util_format_is_intensity(enum pipe_format format);

boolean

util_format_is_subsampled_422(enum pipe_format format);

boolean

util_format_is_pure_integer(enum pipe_format format);

boolean

util_format_is_pure_sint(enum pipe_format format);

boolean

util_format_is_pure_uint(enum pipe_format format);

boolean

util_format_is_snorm(enum pipe_format format);

/**

 * Check if the src format can be blitted to the destination format with

 * a simple memcpy.  For example, blitting from RGBA to RGBx is OK, but not

 * the reverse.

 */

boolean

util_is_format_compatible(const struct util_format_description *src_desc,

                          const struct util_format_description *dst_desc);

/**

 * Whether the format is supported by Gallium for the given bindings.

 * This covers S3TC textures and floating-point render targets.

 */

boolean

util_format_is_supported(enum pipe_format format, unsigned bind);

/**

 * Whether this format is a rgab8 variant.

 *

 * That is, any format that matches the

 *

 *   PIPE_FORMAT_?8?8?8?8_UNORM

 */

static INLINE boolean

util_format_is_rgba8_variant(const struct util_format_description *desc)

{

   unsigned chan;

   if(desc->block.width != 1 ||

      desc->block.height != 1 ||

      desc->block.bits != 32)

      return FALSE;

   for(chan = 0; chan < 4; ++chan) {

      if(desc->channel[chan].type != UTIL_FORMAT_TYPE_UNSIGNED &&

         desc->channel[chan].type != UTIL_FORMAT_TYPE_VOID)

         return FALSE;

      if(desc->channel[chan].type == UTIL_FORMAT_TYPE_UNSIGNED &&

         !desc->channel[chan].normalized)

         return FALSE;

      if(desc->channel[chan].size != 8)

         return FALSE;

   }

   return TRUE;

}

/**

 * Return total bits needed for the pixel format per block.

 */

static INLINE uint

util_format_get_blocksizebits(enum pipe_format format)

{

   const struct util_format_description *desc = util_format_description(format);

   assert(desc);

   if (!desc) {

      return 0;

   }

   return desc->block.bits;

}

/**

 * Return bytes per block (not pixel) for the given format.

 */

static INLINE uint

util_format_get_blocksize(enum pipe_format format)

{

   uint bits = util_format_get_blocksizebits(format);

   uint bytes = bits / 8;

   assert(bits % 8 == 0);

   assert(bytes > 0);

   if (bytes == 0) {

      bytes = 1;

   }

   return bytes;

}

static INLINE uint

util_format_get_blockwidth(enum pipe_format format)

{

   const struct util_format_description *desc = util_format_description(format);

   assert(desc);

   if (!desc) {

      return 1;

   }

   return desc->block.width;

}

static INLINE uint

util_format_get_blockheight(enum pipe_format format)

{

   const struct util_format_description *desc = util_format_description(format);

   assert(desc);

   if (!desc) {

      return 1;

   }

   return desc->block.height;

}

static INLINE unsigned

util_format_get_nblocksx(enum pipe_format format,

                         unsigned x)

{

   unsigned blockwidth = util_format_get_blockwidth(format);

   return (x + blockwidth - 1) / blockwidth;

}

static INLINE unsigned

util_format_get_nblocksy(enum pipe_format format,

                         unsigned y)

{

   unsigned blockheight = util_format_get_blockheight(format);

   return (y + blockheight - 1) / blockheight;

}

static INLINE unsigned

util_format_get_nblocks(enum pipe_format format,

                        unsigned width,

                        unsigned height)

{

   return util_format_get_nblocksx(format, width) * util_format_get_nblocksy(format, height);

}

static INLINE size_t

util_format_get_stride(enum pipe_format format,

                       unsigned width)

{

   return util_format_get_nblocksx(format, width) * util_format_get_blocksize(format);

}

static INLINE size_t

util_format_get_2d_size(enum pipe_format format,

                        size_t stride,

                        unsigned height)

{

   return util_format_get_nblocksy(format, height) * stride;

}

static INLINE uint

util_format_get_component_bits(enum pipe_format format,

                               enum util_format_colorspace colorspace,

                               uint component)

{

   const struct util_format_description *desc = util_format_description(format);

   enum util_format_colorspace desc_colorspace;

   assert(format);

   if (!format) {

      return 0;

   }

   assert(component < 4);

   /* Treat RGB and SRGB as equivalent. */

   if (colorspace == UTIL_FORMAT_COLORSPACE_SRGB) {

      colorspace = UTIL_FORMAT_COLORSPACE_RGB;

   }

   if (desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) {

      desc_colorspace = UTIL_FORMAT_COLORSPACE_RGB;

   } else {

      desc_colorspace = desc->colorspace;

   }

   if (desc_colorspace != colorspace) {

      return 0;

   }

   switch (desc->swizzle[component]) {

   case UTIL_FORMAT_SWIZZLE_X:

      return desc->channel[0].size;

   case UTIL_FORMAT_SWIZZLE_Y:

      return desc->channel[1].size;

   case UTIL_FORMAT_SWIZZLE_Z:

      return desc->channel[2].size;

   case UTIL_FORMAT_SWIZZLE_W:

      return desc->channel[3].size;

   default:

      return 0;

   }

}

/**

 * Given a linear RGB colorspace format, return the corresponding SRGB

 * format, or PIPE_FORMAT_NONE if none.

 */

static INLINE enum pipe_format

util_format_srgb(enum pipe_format format)

{

   if (util_format_is_srgb(format))

      return format;

   switch (format) {

   case PIPE_FORMAT_L8_UNORM:

      return PIPE_FORMAT_L8_SRGB;

   case PIPE_FORMAT_L8A8_UNORM:

      return PIPE_FORMAT_L8A8_SRGB;

   case PIPE_FORMAT_R8G8B8_UNORM:

      return PIPE_FORMAT_R8G8B8_SRGB;

   case PIPE_FORMAT_A8B8G8R8_UNORM:

      return PIPE_FORMAT_A8B8G8R8_SRGB;

   case PIPE_FORMAT_X8B8G8R8_UNORM:

      return PIPE_FORMAT_X8B8G8R8_SRGB;

   case PIPE_FORMAT_B8G8R8A8_UNORM:

      return PIPE_FORMAT_B8G8R8A8_SRGB;

   case PIPE_FORMAT_B8G8R8X8_UNORM:

      return PIPE_FORMAT_B8G8R8X8_SRGB;

   case PIPE_FORMAT_A8R8G8B8_UNORM:

      return PIPE_FORMAT_A8R8G8B8_SRGB;

   case PIPE_FORMAT_X8R8G8B8_UNORM:

      return PIPE_FORMAT_X8R8G8B8_SRGB;

   case PIPE_FORMAT_R8G8B8A8_UNORM:

      return PIPE_FORMAT_R8G8B8A8_SRGB;

   case PIPE_FORMAT_R8G8B8X8_UNORM:

      return PIPE_FORMAT_R8G8B8X8_SRGB;

   case PIPE_FORMAT_DXT1_RGB:

      return PIPE_FORMAT_DXT1_SRGB;

   case PIPE_FORMAT_DXT1_RGBA:

      return PIPE_FORMAT_DXT1_SRGBA;

   case PIPE_FORMAT_DXT3_RGBA:

      return PIPE_FORMAT_DXT3_SRGBA;

   case PIPE_FORMAT_DXT5_RGBA:

      return PIPE_FORMAT_DXT5_SRGBA;

   case PIPE_FORMAT_B5G6R5_UNORM:

      return PIPE_FORMAT_B5G6R5_SRGB;

   case PIPE_FORMAT_BPTC_RGBA_UNORM:

      return PIPE_FORMAT_BPTC_SRGBA;

   default:

      return PIPE_FORMAT_NONE;

   }

}

/**

 * Given an sRGB format, return the corresponding linear colorspace format.

 * For non sRGB formats, return the format unchanged.

 */

static INLINE enum pipe_format

util_format_linear(enum pipe_format format)

{

   switch (format) {

   case PIPE_FORMAT_L8_SRGB:

      return PIPE_FORMAT_L8_UNORM;

   case PIPE_FORMAT_L8A8_SRGB:

      return PIPE_FORMAT_L8A8_UNORM;

   case PIPE_FORMAT_R8G8B8_SRGB:

      return PIPE_FORMAT_R8G8B8_UNORM;

   case PIPE_FORMAT_A8B8G8R8_SRGB:

      return PIPE_FORMAT_A8B8G8R8_UNORM;

   case PIPE_FORMAT_X8B8G8R8_SRGB:

      return PIPE_FORMAT_X8B8G8R8_UNORM;

   case PIPE_FORMAT_B8G8R8A8_SRGB:

      return PIPE_FORMAT_B8G8R8A8_UNORM;

   case PIPE_FORMAT_B8G8R8X8_SRGB:

      return PIPE_FORMAT_B8G8R8X8_UNORM;

   case PIPE_FORMAT_A8R8G8B8_SRGB:

      return PIPE_FORMAT_A8R8G8B8_UNORM;

   case PIPE_FORMAT_X8R8G8B8_SRGB:

      return PIPE_FORMAT_X8R8G8B8_UNORM;

   case PIPE_FORMAT_R8G8B8A8_SRGB:

      return PIPE_FORMAT_R8G8B8A8_UNORM;

   case PIPE_FORMAT_R8G8B8X8_SRGB:

      return PIPE_FORMAT_R8G8B8X8_UNORM;

   case PIPE_FORMAT_DXT1_SRGB:

      return PIPE_FORMAT_DXT1_RGB;

   case PIPE_FORMAT_DXT1_SRGBA:

      return PIPE_FORMAT_DXT1_RGBA;

   case PIPE_FORMAT_DXT3_SRGBA:

      return PIPE_FORMAT_DXT3_RGBA;

   case PIPE_FORMAT_DXT5_SRGBA:

      return PIPE_FORMAT_DXT5_RGBA;

   case PIPE_FORMAT_B5G6R5_SRGB:

      return PIPE_FORMAT_B5G6R5_UNORM;

   case PIPE_FORMAT_BPTC_SRGBA:

      return PIPE_FORMAT_BPTC_RGBA_UNORM;

   default:

      return format;

   }

}

/**

 * Given a depth-stencil format, return the corresponding stencil-only format.

 * For stencil-only formats, return the format unchanged.

 */

static INLINE enum pipe_format

util_format_stencil_only(enum pipe_format format)

{

   switch (format) {

   /* mask out the depth component */

   case PIPE_FORMAT_Z24_UNORM_S8_UINT:

      return PIPE_FORMAT_X24S8_UINT;

   case PIPE_FORMAT_S8_UINT_Z24_UNORM:

      return PIPE_FORMAT_S8X24_UINT;

   case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:

      return PIPE_FORMAT_X32_S8X24_UINT;

   /* stencil only formats */

   case PIPE_FORMAT_X24S8_UINT:

   case PIPE_FORMAT_S8X24_UINT:

   case PIPE_FORMAT_X32_S8X24_UINT:

   case PIPE_FORMAT_S8_UINT:

      return format;

   default:

      assert(0);

      return PIPE_FORMAT_NONE;

   }

}

/**

 * Converts PIPE_FORMAT_*I* to PIPE_FORMAT_*R*.

 * This is identity for non-intensity formats.

 */

static INLINE enum pipe_format

util_format_intensity_to_red(enum pipe_format format)

{

   switch (format) {

   case PIPE_FORMAT_I8_UNORM:

      return PIPE_FORMAT_R8_UNORM;

   case PIPE_FORMAT_I8_SNORM:

      return PIPE_FORMAT_R8_SNORM;

   case PIPE_FORMAT_I16_UNORM:

      return PIPE_FORMAT_R16_UNORM;

   case PIPE_FORMAT_I16_SNORM:

      return PIPE_FORMAT_R16_SNORM;

   case PIPE_FORMAT_I16_FLOAT:

      return PIPE_FORMAT_R16_FLOAT;

   case PIPE_FORMAT_I32_FLOAT:

      return PIPE_FORMAT_R32_FLOAT;

   case PIPE_FORMAT_I8_UINT:

      return PIPE_FORMAT_R8_UINT;

   case PIPE_FORMAT_I8_SINT:

      return PIPE_FORMAT_R8_SINT;

   case PIPE_FORMAT_I16_UINT:

      return PIPE_FORMAT_R16_UINT;

   case PIPE_FORMAT_I16_SINT:

      return PIPE_FORMAT_R16_SINT;

   case PIPE_FORMAT_I32_UINT:

      return PIPE_FORMAT_R32_UINT;

   case PIPE_FORMAT_I32_SINT:

      return PIPE_FORMAT_R32_SINT;

   default:

      assert(!util_format_is_intensity(format));

      return format;

   }

}

/**

 * Converts PIPE_FORMAT_*L* to PIPE_FORMAT_*R*.

 * This is identity for non-luminance formats.

 */

static INLINE enum pipe_format

util_format_luminance_to_red(enum pipe_format format)

{

   switch (format) {

   case PIPE_FORMAT_L8_UNORM:

      return PIPE_FORMAT_R8_UNORM;

   case PIPE_FORMAT_L8_SNORM:

      return PIPE_FORMAT_R8_SNORM;

   case PIPE_FORMAT_L16_UNORM:

      return PIPE_FORMAT_R16_UNORM;

   case PIPE_FORMAT_L16_SNORM:

      return PIPE_FORMAT_R16_SNORM;

   case PIPE_FORMAT_L16_FLOAT:

      return PIPE_FORMAT_R16_FLOAT;

   case PIPE_FORMAT_L32_FLOAT:

      return PIPE_FORMAT_R32_FLOAT;

   case PIPE_FORMAT_L8_UINT:

      return PIPE_FORMAT_R8_UINT;

   case PIPE_FORMAT_L8_SINT:

      return PIPE_FORMAT_R8_SINT;

   case PIPE_FORMAT_L16_UINT:

      return PIPE_FORMAT_R16_UINT;

   case PIPE_FORMAT_L16_SINT:

      return PIPE_FORMAT_R16_SINT;

   case PIPE_FORMAT_L32_UINT:

      return PIPE_FORMAT_R32_UINT;

   case PIPE_FORMAT_L32_SINT:

      return PIPE_FORMAT_R32_SINT;

   case PIPE_FORMAT_LATC1_UNORM:

      return PIPE_FORMAT_RGTC1_UNORM;

   case PIPE_FORMAT_LATC1_SNORM:

      return PIPE_FORMAT_RGTC1_SNORM;

   case PIPE_FORMAT_L4A4_UNORM:

      return PIPE_FORMAT_R4A4_UNORM;

   case PIPE_FORMAT_L8A8_UNORM:

      return PIPE_FORMAT_R8A8_UNORM;

   case PIPE_FORMAT_L8A8_SNORM:

      return PIPE_FORMAT_R8A8_SNORM;

   case PIPE_FORMAT_L16A16_UNORM:

      return PIPE_FORMAT_R16A16_UNORM;

   case PIPE_FORMAT_L16A16_SNORM:

      return PIPE_FORMAT_R16A16_SNORM;

   case PIPE_FORMAT_L16A16_FLOAT:

      return PIPE_FORMAT_R16A16_FLOAT;

   case PIPE_FORMAT_L32A32_FLOAT:

      return PIPE_FORMAT_R32A32_FLOAT;

   case PIPE_FORMAT_L8A8_UINT:

      return PIPE_FORMAT_R8A8_UINT;

   case PIPE_FORMAT_L8A8_SINT:

      return PIPE_FORMAT_R8A8_SINT;

   case PIPE_FORMAT_L16A16_UINT:

      return PIPE_FORMAT_R16A16_UINT;

   case PIPE_FORMAT_L16A16_SINT:

      return PIPE_FORMAT_R16A16_SINT;

   case PIPE_FORMAT_L32A32_UINT:

      return PIPE_FORMAT_R32A32_UINT;

   case PIPE_FORMAT_L32A32_SINT:

      return PIPE_FORMAT_R32A32_SINT;

   /* We don't have compressed red-alpha variants for these. */

   case PIPE_FORMAT_LATC2_UNORM:

   case PIPE_FORMAT_LATC2_SNORM:

      return PIPE_FORMAT_NONE;

   default:

      assert(!util_format_is_luminance(format) &&

	     !util_format_is_luminance_alpha(format));

      return format;

   }

}

/**

 * Return the number of components stored.

 * Formats with block size != 1x1 will always have 1 component (the block).

 */

static INLINE unsigned

util_format_get_nr_components(enum pipe_format format)

{

   const struct util_format_description *desc = util_format_description(format);

   return desc->nr_channels;