src/gallium/state_trackers/wgl/stw_pixelformat.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 #include "pipe/p_format.h"
  29 #include "pipe/p_defines.h"
  30 #include "pipe/p_screen.h"
  31
  32 #include "util/u_format.h"
  33 #include "util/u_debug.h"
  34 #include "util/u_memory.h"
  35
  36 #include "stw_icd.h"
  37 #include "stw_device.h"
  38 #include "stw_pixelformat.h"
  39 #include "stw_tls.h"
  40
  41
  42 struct stw_pf_color_info
  43 {
  44    enum pipe_format format;
  45    struct {
  46       unsigned char red;
  47       unsigned char green;
  48       unsigned char blue;
  49       unsigned char alpha;
  50    } bits;
  51    struct {
  52       unsigned char red;
  53       unsigned char green;
  54       unsigned char blue;
  55       unsigned char alpha;
  56    } shift;
  57 };
  58
  59 struct stw_pf_depth_info
  60 {
  61    enum pipe_format format;
  62    struct {
  63       unsigned char depth;
  64       unsigned char stencil;
  65    } bits;
  66 };
  67
  68
  69 /* NOTE: order matters, since in otherwise equal circumstances the first
  70  * format listed will get chosen */
  71
  72 static const struct stw_pf_color_info
  73 stw_pf_color[] = {
  74    /* no-alpha */
  75    { PIPE_FORMAT_B8G8R8X8_UNORM,    { 8,  8,  8,  0}, {16,  8,  0,  0} },
  76    { PIPE_FORMAT_X8R8G8B8_UNORM,    { 8,  8,  8,  0}, { 8, 16, 24,  0} },
  77    { PIPE_FORMAT_B5G6R5_UNORM,      { 5,  6,  5,  0}, {11,  5,  0,  0} },
  78    /* alpha */
  79    { PIPE_FORMAT_B8G8R8A8_UNORM,    { 8,  8,  8,  8}, {16,  8,  0, 24} },
  80    { PIPE_FORMAT_A8R8G8B8_UNORM,    { 8,  8,  8,  8}, { 8, 16, 24,  0} },
  81 #if 0
  82    { PIPE_FORMAT_R10G10B10A2_UNORM, {10, 10, 10,  2}, { 0, 10, 20, 30} },
  83 #endif
  84    { PIPE_FORMAT_B5G5R5A1_UNORM,    { 5,  5,  5,  1}, {10,  5,  0, 15} },
  85    { PIPE_FORMAT_B4G4R4A4_UNORM,    { 4,  4,  4,  4}, {16,  4,  0, 12} }
  86 };
  87
  88 static const struct stw_pf_color_info
  89 stw_pf_color_extended[] = {
  90     { PIPE_FORMAT_R32G32B32A32_FLOAT, { 32,  32, 32,  32}, { 0,  32, 64, 96} }
  91 };
  92
  93 static const struct stw_pf_depth_info
  94 stw_pf_depth_stencil[] = {
  95    /* pure depth */
  96    { PIPE_FORMAT_Z32_UNORM,   {32, 0} },
  97    { PIPE_FORMAT_X8Z24_UNORM, {24, 0} },
  98    { PIPE_FORMAT_Z24X8_UNORM, {24, 0} },
  99    { PIPE_FORMAT_Z16_UNORM,   {16, 0} },
 100    /* combined depth-stencil */
 101    { PIPE_FORMAT_Z24_UNORM_S8_UINT, {24, 8} },
 102    { PIPE_FORMAT_S8_UINT_Z24_UNORM, {24, 8} }
 103 };
 104
 105
 106 static const boolean
 107 stw_pf_doublebuffer[] = {
 108    FALSE,
 109    TRUE,
 110 };
 111
 112
 113 const unsigned
 114 stw_pf_multisample[] = {
 115    0,
 116    4
 117 };
 118
 119
 120 static void
 121 stw_pixelformat_add(
 122    struct stw_device *stw_dev,
 123    boolean extended,
 124    const struct stw_pf_color_info *color,
 125    const struct stw_pf_depth_info *depth,
 126    unsigned accum,
 127    boolean doublebuffer,
 128    unsigned samples )
 129 {
 130    struct stw_pixelformat_info *pfi;
 131
 132    assert(stw_dev->pixelformat_extended_count < STW_MAX_PIXELFORMATS);
 133    if(stw_dev->pixelformat_extended_count >= STW_MAX_PIXELFORMATS)
 134       return;
 135
 136    assert(util_format_get_component_bits(color->format, UTIL_FORMAT_COLORSPACE_RGB, 0) == color->bits.red);
 137    assert(util_format_get_component_bits(color->format, UTIL_FORMAT_COLORSPACE_RGB, 1) == color->bits.green);
 138    assert(util_format_get_component_bits(color->format, UTIL_FORMAT_COLORSPACE_RGB, 2) == color->bits.blue);
 139    assert(util_format_get_component_bits(color->format, UTIL_FORMAT_COLORSPACE_RGB, 3) == color->bits.alpha);
 140    assert(util_format_get_component_bits(depth->format, UTIL_FORMAT_COLORSPACE_ZS, 0) == depth->bits.depth);
 141    assert(util_format_get_component_bits(depth->format, UTIL_FORMAT_COLORSPACE_ZS, 1) == depth->bits.stencil);
 142
 143    pfi = &stw_dev->pixelformats[stw_dev->pixelformat_extended_count];
 144
 145    memset(pfi, 0, sizeof *pfi);
 146
 147    pfi->pfd.nSize = sizeof pfi->pfd;
 148    pfi->pfd.nVersion = 1;
 149
 150    pfi->pfd.dwFlags = PFD_SUPPORT_OPENGL;
 151
 152    /* TODO: also support non-native pixel formats */
 153    if (!extended) {
 154       pfi->pfd.dwFlags |= PFD_DRAW_TO_WINDOW;
 155    }
 156
 157    /* See http://www.opengl.org/pipeline/article/vol003_7/ */
 158    pfi->pfd.dwFlags |= PFD_SUPPORT_COMPOSITION;
 159
 160    if (doublebuffer)
 161       pfi->pfd.dwFlags |= PFD_DOUBLEBUFFER | PFD_SWAP_COPY;
 162
 163    pfi->pfd.iPixelType = PFD_TYPE_RGBA;
 164
 165    pfi->pfd.cColorBits = color->bits.red + color->bits.green + color->bits.blue + color->bits.alpha;
 166    pfi->pfd.cRedBits = color->bits.red;
 167    pfi->pfd.cRedShift = color->shift.red;
 168    pfi->pfd.cGreenBits = color->bits.green;
 169    pfi->pfd.cGreenShift = color->shift.green;
 170    pfi->pfd.cBlueBits = color->bits.blue;
 171    pfi->pfd.cBlueShift = color->shift.blue;
 172    pfi->pfd.cAlphaBits = color->bits.alpha;
 173    pfi->pfd.cAlphaShift = color->shift.alpha;
 174    pfi->pfd.cAccumBits = 4*accum;
 175    pfi->pfd.cAccumRedBits = accum;
 176    pfi->pfd.cAccumGreenBits = accum;
 177    pfi->pfd.cAccumBlueBits = accum;
 178    pfi->pfd.cAccumAlphaBits = accum;
 179    pfi->pfd.cDepthBits = depth->bits.depth;
 180    pfi->pfd.cStencilBits = depth->bits.stencil;
 181    pfi->pfd.cAuxBuffers = 0;
 182    pfi->pfd.iLayerType = 0;
 183    pfi->pfd.bReserved = 0;
 184    pfi->pfd.dwLayerMask = 0;
 185    pfi->pfd.dwVisibleMask = 0;
 186    pfi->pfd.dwDamageMask = 0;
 187
 188    /*
 189     * since state trackers can allocate depth/stencil/accum buffers, we provide
 190     * only color buffers here
 191     */
 192    pfi->stvis.buffer_mask = ST_ATTACHMENT_FRONT_LEFT_MASK;
 193    if (doublebuffer)
 194       pfi->stvis.buffer_mask |= ST_ATTACHMENT_BACK_LEFT_MASK;
 195
 196    pfi->stvis.color_format = color->format;
 197    pfi->stvis.depth_stencil_format = depth->format;
 198
 199    pfi->stvis.accum_format = (accum) ?
 200       PIPE_FORMAT_R16G16B16A16_SNORM : PIPE_FORMAT_NONE;
 201
 202    pfi->stvis.samples = samples;
 203    pfi->stvis.render_buffer = ST_ATTACHMENT_INVALID;
 204
 205    ++stw_dev->pixelformat_extended_count;
 206
 207    if(!extended) {
 208       ++stw_dev->pixelformat_count;
 209       assert(stw_dev->pixelformat_count == stw_dev->pixelformat_extended_count);
 210    }
 211 }
 212
 213
 214 /**
 215  * Add the depth/stencil/accum/ms variants for a particular color format.
 216  */
 217 static void
 218 add_color_format_variants(const struct stw_pf_color_info *color,
 219                           boolean extended)
 220 {
 221    struct pipe_screen *screen = stw_dev->screen;
 222    unsigned ms, db, ds, acc;
 223    unsigned bind_flags = PIPE_BIND_RENDER_TARGET;
 224
 225    if (!extended) {
 226       bind_flags |= PIPE_BIND_DISPLAY_TARGET;
 227    }
 228
 229    if (!screen->is_format_supported(screen, color->format,
 230                                     PIPE_TEXTURE_2D, 0, bind_flags)) {
 231       return;
 232    }
 233
 234    for (ms = 0; ms < Elements(stw_pf_multisample); ms++) {
 235       unsigned samples = stw_pf_multisample[ms];
 236
 237       /* FIXME: re-enabled MSAA when we can query it */
 238       if (samples)
 239          continue;
 240
 241       for (db = 0; db < Elements(stw_pf_doublebuffer); db++) {
 242          unsigned doublebuffer = stw_pf_doublebuffer[db];
 243
 244          for (ds = 0; ds < Elements(stw_pf_depth_stencil); ds++) {
 245             const struct stw_pf_depth_info *depth = &stw_pf_depth_stencil[ds];
 246
 247             if (!screen->is_format_supported(screen, depth->format,
 248                                              PIPE_TEXTURE_2D, 0,
 249                                              PIPE_BIND_DEPTH_STENCIL)) {
 250                continue;
 251             }
 252
 253             for (acc = 0; acc < 2; acc++) {
 254                stw_pixelformat_add(stw_dev, extended, color, depth,
 255                                    acc * 16, doublebuffer, samples);
 256             }
 257          }
 258       }
 259    }
 260 }
 261
 262
 263 void
 264 stw_pixelformat_init( void )
 265 {
 266    unsigned i;
 267
 268    assert( !stw_dev->pixelformat_count );
 269    assert( !stw_dev->pixelformat_extended_count );
 270
 271    /* normal, displayable formats */
 272    for (i = 0; i < Elements(stw_pf_color); i++) {
 273       add_color_format_variants(&stw_pf_color[i], FALSE);
 274    }
 275
 276    /* extended, pbuffer-only formats */
 277    for (i = 0; i < Elements(stw_pf_color_extended); i++) {
 278       add_color_format_variants(&stw_pf_color_extended[i], TRUE);
 279    }
 280
 281    assert( stw_dev->pixelformat_count <= stw_dev->pixelformat_extended_count );
 282    assert( stw_dev->pixelformat_extended_count <= STW_MAX_PIXELFORMATS );
 283 }
 284
 285 uint
 286 stw_pixelformat_get_count( void )
 287 {
 288    return stw_dev->pixelformat_count;
 289 }
 290
 291 uint
 292 stw_pixelformat_get_extended_count( void )
 293 {
 294    return stw_dev->pixelformat_extended_count;
 295 }
 296
 297 const struct stw_pixelformat_info *
 298 stw_pixelformat_get_info( int iPixelFormat )
 299 {
 300    int index;
 301
 302    if (iPixelFormat <= 0) {
 303       return NULL;
 304    }
 305
 306    index = iPixelFormat - 1;
 307    if (index >= stw_dev->pixelformat_extended_count) {
 308       return NULL;
 309    }
 310
 311    return &stw_dev->pixelformats[index];
 312 }
 313
 314
 315 LONG APIENTRY
 316 DrvDescribePixelFormat(
 317    HDC hdc,
 318    INT iPixelFormat,
 319    ULONG cjpfd,
 320    PIXELFORMATDESCRIPTOR *ppfd )
 321 {
 322    uint count;
 323    const struct stw_pixelformat_info *pfi;
 324
 325    (void) hdc;
 326
 327    if (!stw_dev)
 328       return 0;
 329
 330    count = stw_pixelformat_get_count();
 331
 332    if (ppfd == NULL)
 333       return count;
 334    if (cjpfd != sizeof( PIXELFORMATDESCRIPTOR ))
 335       return 0;
 336
 337    pfi = stw_pixelformat_get_info( iPixelFormat );
 338    if (!pfi) {
 339       return 0;
 340    }
 341
 342    memcpy(ppfd, &pfi->pfd, sizeof( PIXELFORMATDESCRIPTOR ));
 343
 344    return count;
 345 }
 346
 347 BOOL APIENTRY
 348 DrvDescribeLayerPlane(
 349    HDC hdc,
 350    INT iPixelFormat,
 351    INT iLayerPlane,
 352    UINT nBytes,
 353    LPLAYERPLANEDESCRIPTOR plpd )
 354 {
 355    assert(0);
 356    return FALSE;
 357 }
 358
 359 int APIENTRY
 360 DrvGetLayerPaletteEntries(
 361    HDC hdc,
 362    INT iLayerPlane,
 363    INT iStart,
 364    INT cEntries,
 365    COLORREF *pcr )
 366 {
 367    assert(0);
 368    return 0;
 369 }
 370
 371 int APIENTRY
 372 DrvSetLayerPaletteEntries(
 373    HDC hdc,
 374    INT iLayerPlane,
 375    INT iStart,
 376    INT cEntries,
 377    CONST COLORREF *pcr )
 378 {
 379    assert(0);
 380    return 0;
 381 }
 382
 383 BOOL APIENTRY
 384 DrvRealizeLayerPalette(
 385    HDC hdc,
 386    INT iLayerPlane,
 387    BOOL bRealize )
 388 {
 389    assert(0);
 390    return FALSE;
 391 }
 392
 393 /* Only used by the wgl code, but have it here to avoid exporting the
 394  * pixelformat.h functionality.
 395  */
 396 int stw_pixelformat_choose( HDC hdc,
 397                             CONST PIXELFORMATDESCRIPTOR *ppfd )
 398 {
 399    uint count;
 400    uint index;
 401    uint bestindex;
 402    uint bestdelta;
 403
 404    (void) hdc;
 405
 406    count = stw_pixelformat_get_extended_count();
 407    bestindex = 0;
 408    bestdelta = ~0U;
 409
 410    for (index = 1; index <= count; index++) {
 411       uint delta = 0;
 412       const struct stw_pixelformat_info *pfi = stw_pixelformat_get_info( index );
 413
 414       if (!(ppfd->dwFlags & PFD_DOUBLEBUFFER_DONTCARE) &&
 415           !!(ppfd->dwFlags & PFD_DOUBLEBUFFER) !=
 416           !!(pfi->pfd.dwFlags & PFD_DOUBLEBUFFER))
 417          continue;
 418
 419       /* FIXME: Take in account individual channel bits */
 420       if (ppfd->cColorBits != pfi->pfd.cColorBits)
 421          delta += 8;
 422
 423       if (ppfd->cDepthBits != pfi->pfd.cDepthBits)
 424          delta += 4;
 425
 426       if (ppfd->cStencilBits != pfi->pfd.cStencilBits)
 427          delta += 2;
 428
 429       if (ppfd->cAlphaBits != pfi->pfd.cAlphaBits)
 430          delta++;
 431
 432       if (delta < bestdelta) {
 433          bestindex = index;
 434          bestdelta = delta;
 435          if (bestdelta == 0)
 436             break;
 437       }
 438    }
 439
 440    return bestindex;
 441 }