src/gallium/include/pipe/p_format.h

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * Copyright (c) 2008 VMware, Inc.
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the
   9  * "Software"), to deal in the Software without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sub license, and/or sell copies of the Software, and to
  12  * permit persons to whom the Software is furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial portions
  17  * of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  22  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  23  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  24  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  25  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  *
  27  **************************************************************************/
  28
  29 #ifndef PIPE_FORMAT_H
  30 #define PIPE_FORMAT_H
  31
  32 #include "p_compiler.h"
  33
  34 /* FIXME: remove these header dependencies */
  35 #include "util/u_debug.h"
  36 #include "util/u_string.h"
  37
  38 #ifdef __cplusplus
  39 extern "C" {
  40 #endif
  41
  42 /**
  43  * Texture/surface image formats (preliminary)
  44  */
  45
  46 /* KW: Added lots of surface formats to support vertex element layout
  47  * definitions, and eventually render-to-vertex-buffer.
  48  */
  49
  50 enum pipe_format {
  51    PIPE_FORMAT_NONE                  = 0,
  52    PIPE_FORMAT_A8R8G8B8_UNORM        = 1,
  53    PIPE_FORMAT_X8R8G8B8_UNORM        = 2,
  54    PIPE_FORMAT_B8G8R8A8_UNORM        = 3,
  55    PIPE_FORMAT_B8G8R8X8_UNORM        = 4,
  56    PIPE_FORMAT_A1R5G5B5_UNORM        = 5,
  57    PIPE_FORMAT_A4R4G4B4_UNORM        = 6,
  58    PIPE_FORMAT_R5G6B5_UNORM          = 7,
  59    PIPE_FORMAT_A2B10G10R10_UNORM     = 8,
  60    PIPE_FORMAT_L8_UNORM              = 9,    /**< ubyte luminance */
  61    PIPE_FORMAT_A8_UNORM              = 10,   /**< ubyte alpha */
  62    PIPE_FORMAT_I8_UNORM              = 11,   /**< ubyte intensity */
  63    PIPE_FORMAT_A8L8_UNORM            = 12,   /**< ubyte alpha, luminance */
  64    PIPE_FORMAT_L16_UNORM             = 13,   /**< ushort luminance */
  65    PIPE_FORMAT_YCBCR                 = 14,
  66    PIPE_FORMAT_YCBCR_REV             = 15,
  67    PIPE_FORMAT_Z16_UNORM             = 16,
  68    PIPE_FORMAT_Z32_UNORM             = 17,
  69    PIPE_FORMAT_Z32_FLOAT             = 18,
  70    PIPE_FORMAT_S8Z24_UNORM           = 19,
  71    PIPE_FORMAT_Z24S8_UNORM           = 20,
  72    PIPE_FORMAT_X8Z24_UNORM           = 21,
  73    PIPE_FORMAT_Z24X8_UNORM           = 22,
  74    PIPE_FORMAT_S8_UNORM              = 23,   /**< ubyte stencil */
  75    PIPE_FORMAT_R64_FLOAT             = 24,
  76    PIPE_FORMAT_R64G64_FLOAT          = 25,
  77    PIPE_FORMAT_R64G64B64_FLOAT       = 26,
  78    PIPE_FORMAT_R64G64B64A64_FLOAT    = 27,
  79    PIPE_FORMAT_R32_FLOAT             = 28,
  80    PIPE_FORMAT_R32G32_FLOAT          = 29,
  81    PIPE_FORMAT_R32G32B32_FLOAT       = 30,
  82    PIPE_FORMAT_R32G32B32A32_FLOAT    = 31,
  83    PIPE_FORMAT_R32_UNORM             = 32,
  84    PIPE_FORMAT_R32G32_UNORM          = 33,
  85    PIPE_FORMAT_R32G32B32_UNORM       = 34,
  86    PIPE_FORMAT_R32G32B32A32_UNORM    = 35,
  87    PIPE_FORMAT_R32_USCALED           = 36,
  88    PIPE_FORMAT_R32G32_USCALED        = 37,
  89    PIPE_FORMAT_R32G32B32_USCALED     = 38,
  90    PIPE_FORMAT_R32G32B32A32_USCALED  = 39,
  91    PIPE_FORMAT_R32_SNORM             = 40,
  92    PIPE_FORMAT_R32G32_SNORM          = 41,
  93    PIPE_FORMAT_R32G32B32_SNORM       = 42,
  94    PIPE_FORMAT_R32G32B32A32_SNORM    = 43,
  95    PIPE_FORMAT_R32_SSCALED           = 44,
  96    PIPE_FORMAT_R32G32_SSCALED        = 45,
  97    PIPE_FORMAT_R32G32B32_SSCALED     = 46,
  98    PIPE_FORMAT_R32G32B32A32_SSCALED  = 47,
  99    PIPE_FORMAT_R16_UNORM             = 48,
 100    PIPE_FORMAT_R16G16_UNORM          = 49,
 101    PIPE_FORMAT_R16G16B16_UNORM       = 50,
 102    PIPE_FORMAT_R16G16B16A16_UNORM    = 51,
 103    PIPE_FORMAT_R16_USCALED           = 52,
 104    PIPE_FORMAT_R16G16_USCALED        = 53,
 105    PIPE_FORMAT_R16G16B16_USCALED     = 54,
 106    PIPE_FORMAT_R16G16B16A16_USCALED  = 55,
 107    PIPE_FORMAT_R16_SNORM             = 56,
 108    PIPE_FORMAT_R16G16_SNORM          = 57,
 109    PIPE_FORMAT_R16G16B16_SNORM       = 58,
 110    PIPE_FORMAT_R16G16B16A16_SNORM    = 59,
 111    PIPE_FORMAT_R16_SSCALED           = 60,
 112    PIPE_FORMAT_R16G16_SSCALED        = 61,
 113    PIPE_FORMAT_R16G16B16_SSCALED     = 62,
 114    PIPE_FORMAT_R16G16B16A16_SSCALED  = 63,
 115    PIPE_FORMAT_R8_UNORM              = 64,
 116    PIPE_FORMAT_R8G8_UNORM            = 65,
 117    PIPE_FORMAT_R8G8B8_UNORM          = 66,
 118    PIPE_FORMAT_R8G8B8A8_UNORM        = 67,
 119    PIPE_FORMAT_R8G8B8X8_UNORM        = 68,
 120    PIPE_FORMAT_R8_USCALED            = 69,
 121    PIPE_FORMAT_R8G8_USCALED          = 70,
 122    PIPE_FORMAT_R8G8B8_USCALED        = 71,
 123    PIPE_FORMAT_R8G8B8A8_USCALED      = 72,
 124    PIPE_FORMAT_R8G8B8X8_USCALED      = 73,
 125    PIPE_FORMAT_R8_SNORM              = 74,
 126    PIPE_FORMAT_R8G8_SNORM            = 75,
 127    PIPE_FORMAT_R8G8B8_SNORM          = 76,
 128    PIPE_FORMAT_R8G8B8A8_SNORM        = 77,
 129    PIPE_FORMAT_R8G8B8X8_SNORM        = 78,
 130    PIPE_FORMAT_B6G5R5_SNORM          = 79,
 131    PIPE_FORMAT_A8B8G8R8_SNORM        = 80,
 132    PIPE_FORMAT_X8B8G8R8_SNORM        = 81,
 133    PIPE_FORMAT_R8_SSCALED            = 82,
 134    PIPE_FORMAT_R8G8_SSCALED          = 83,
 135    PIPE_FORMAT_R8G8B8_SSCALED        = 84,
 136    PIPE_FORMAT_R8G8B8A8_SSCALED      = 85,
 137    PIPE_FORMAT_R8G8B8X8_SSCALED      = 86,
 138    PIPE_FORMAT_R32_FIXED             = 87,
 139    PIPE_FORMAT_R32G32_FIXED          = 88,
 140    PIPE_FORMAT_R32G32B32_FIXED       = 89,
 141    PIPE_FORMAT_R32G32B32A32_FIXED    = 90,
 142    /* sRGB formats */
 143    PIPE_FORMAT_L8_SRGB               = 91,
 144    PIPE_FORMAT_A8L8_SRGB             = 92,
 145    PIPE_FORMAT_R8G8B8_SRGB           = 93,
 146    PIPE_FORMAT_R8G8B8A8_SRGB         = 94,
 147    PIPE_FORMAT_R8G8B8X8_SRGB         = 95,
 148    PIPE_FORMAT_A8R8G8B8_SRGB         = 96,
 149    PIPE_FORMAT_X8R8G8B8_SRGB         = 97,
 150    PIPE_FORMAT_B8G8R8A8_SRGB         = 98,
 151    PIPE_FORMAT_B8G8R8X8_SRGB         = 99,
 152
 153    /* mixed formats */
 154    PIPE_FORMAT_X8UB8UG8SR8S_NORM     = 100,
 155    PIPE_FORMAT_B6UG5SR5S_NORM        = 101,
 156
 157    /* compressed formats */
 158    PIPE_FORMAT_DXT1_RGB              = 102,
 159    PIPE_FORMAT_DXT1_RGBA             = 103,
 160    PIPE_FORMAT_DXT3_RGBA             = 104,
 161    PIPE_FORMAT_DXT5_RGBA             = 105,
 162
 163    /* sRGB, compressed */
 164    PIPE_FORMAT_DXT1_SRGB             = 106,
 165    PIPE_FORMAT_DXT1_SRGBA            = 107,
 166    PIPE_FORMAT_DXT3_SRGBA            = 108,
 167    PIPE_FORMAT_DXT5_SRGBA            = 109,
 168
 169    PIPE_FORMAT_COUNT
 170 };
 171
 172 /**
 173  * Builds pipe format name from format token.
 174  */
 175 extern const char *pf_name( enum pipe_format format );
 176
 177 /**
 178  * Return bits for a particular component.
 179  * \param comp  component index, starting at 0
 180  */
 181 static INLINE uint pf_get_component_bits( enum pipe_format format, uint comp )
 182 {
 183    uint size;
 184
 185    if (pf_swizzle_x(format) == comp) {
 186       size = pf_size_x(format);
 187    }
 188    else if (pf_swizzle_y(format) == comp) {
 189       size = pf_size_y(format);
 190    }
 191    else if (pf_swizzle_z(format) == comp) {
 192       size = pf_size_z(format);
 193    }
 194    else if (pf_swizzle_w(format) == comp) {
 195       size = pf_size_w(format);
 196    }
 197    else {
 198       size = 0;
 199    }
 200    if (pf_layout( format ) == PIPE_FORMAT_LAYOUT_RGBAZS)
 201       return size << pf_exp2( format );
 202    return size << (pf_mixed_scale8( format ) * 3);
 203 }
 204
 205
 206 /**
 207  * Return total bits needed for the pixel format per block.
 208  */
 209 static INLINE uint pf_get_blocksizebits( enum pipe_format format )
 210 {
 211    switch (pf_layout(format)) {
 212    case PIPE_FORMAT_LAYOUT_RGBAZS:
 213    case PIPE_FORMAT_LAYOUT_MIXED:
 214       return
 215          pf_get_component_bits( format, PIPE_FORMAT_COMP_0 ) +
 216          pf_get_component_bits( format, PIPE_FORMAT_COMP_1 ) +
 217          pf_get_component_bits( format, PIPE_FORMAT_COMP_R ) +
 218          pf_get_component_bits( format, PIPE_FORMAT_COMP_G ) +
 219          pf_get_component_bits( format, PIPE_FORMAT_COMP_B ) +
 220          pf_get_component_bits( format, PIPE_FORMAT_COMP_A ) +
 221          pf_get_component_bits( format, PIPE_FORMAT_COMP_Z ) +
 222          pf_get_component_bits( format, PIPE_FORMAT_COMP_S );
 223    case PIPE_FORMAT_LAYOUT_YCBCR:
 224       assert( format == PIPE_FORMAT_YCBCR || format == PIPE_FORMAT_YCBCR_REV );
 225       return 32;
 226    case PIPE_FORMAT_LAYOUT_DXT:
 227         switch(format) {
 228         case PIPE_FORMAT_DXT1_RGBA:
 229         case PIPE_FORMAT_DXT1_RGB:
 230         case PIPE_FORMAT_DXT1_SRGBA:
 231         case PIPE_FORMAT_DXT1_SRGB:
 232            return 64;
 233         case PIPE_FORMAT_DXT3_RGBA:
 234         case PIPE_FORMAT_DXT5_RGBA:
 235         case PIPE_FORMAT_DXT3_SRGBA:
 236         case PIPE_FORMAT_DXT5_SRGBA:
 237            return 128;
 238         default:
 239            assert( 0 );
 240            return 0;
 241         }
 242
 243    default:
 244       assert( 0 );
 245       return 0;
 246    }
 247 }
 248
 249 /**
 250  * Return bytes per element for the given format.
 251  */
 252 static INLINE uint pf_get_blocksize( enum pipe_format format )
 253 {
 254    assert(pf_get_blocksizebits(format) % 8 == 0);
 255    return pf_get_blocksizebits(format) / 8;
 256 }
 257
 258 static INLINE uint pf_get_blockwidth( enum pipe_format format )
 259 {
 260    switch (pf_layout(format)) {
 261    case PIPE_FORMAT_LAYOUT_YCBCR:
 262       return 2;
 263    case PIPE_FORMAT_LAYOUT_DXT:
 264       return 4;
 265    default:
 266       return 1;
 267    }
 268 }
 269
 270 static INLINE uint pf_get_blockheight( enum pipe_format format )
 271 {
 272    switch (pf_layout(format)) {
 273    case PIPE_FORMAT_LAYOUT_DXT:
 274       return 4;
 275    default:
 276       return 1;
 277    }
 278 }
 279
 280 static INLINE unsigned
 281 pf_get_nblocksx(enum pipe_format format, unsigned x)
 282 {
 283    unsigned blockwidth = pf_get_blockwidth(format);
 284    return (x + blockwidth - 1) / blockwidth;
 285 }
 286
 287 static INLINE unsigned
 288 pf_get_nblocksy(enum pipe_format format, unsigned y)
 289 {
 290    unsigned blockheight = pf_get_blockheight(format);
 291    return (y + blockheight - 1) / blockheight;
 292 }
 293
 294 static INLINE unsigned
 295 pf_get_nblocks(enum pipe_format format, unsigned width, unsigned height)
 296 {
 297    return pf_get_nblocksx(format, width) * pf_get_nblocksy(format, height);
 298 }
 299
 300 static INLINE size_t
 301 pf_get_stride(enum pipe_format format, unsigned width)
 302 {
 303    return pf_get_nblocksx(format, width) * pf_get_blocksize(format);
 304 }
 305
 306 static INLINE size_t
 307 pf_get_2d_size(enum pipe_format format, size_t stride, unsigned height)
 308 {
 309    return pf_get_nblocksy(format, height) * stride;
 310 }
 311
 312 enum pipe_video_chroma_format
 313 {
 314    PIPE_VIDEO_CHROMA_FORMAT_420,
 315    PIPE_VIDEO_CHROMA_FORMAT_422,
 316    PIPE_VIDEO_CHROMA_FORMAT_444
 317 };
 318
 319 #if 0
 320 enum pipe_video_surface_format
 321 {
 322    PIPE_VIDEO_SURFACE_FORMAT_NV12,  /**< Planar; Y plane, UV plane */
 323    PIPE_VIDEO_SURFACE_FORMAT_YV12,  /**< Planar; Y plane, U plane, V plane */
 324    PIPE_VIDEO_SURFACE_FORMAT_YUYV,  /**< Interleaved; Y,U,Y,V,Y,U,Y,V */
 325    PIPE_VIDEO_SURFACE_FORMAT_UYVY,  /**< Interleaved; U,Y,V,Y,U,Y,V,Y */
 326    PIPE_VIDEO_SURFACE_FORMAT_VUYA   /**< Packed; A31-24|Y23-16|U15-8|V7-0 */
 327 };
 328 #endif
 329
 330 #ifdef __cplusplus
 331 }
 332 #endif
 333
 334 #endif