Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  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_EXCHANGE;
  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 unsigned
  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.    unsigned num_added = 0;
  225.  
  226.    if (!extended) {
  227.       bind_flags |= PIPE_BIND_DISPLAY_TARGET;
  228.    }
  229.  
  230.    if (!screen->is_format_supported(screen, color->format,
  231.                                     PIPE_TEXTURE_2D, 0, bind_flags)) {
  232.       return 0;
  233.    }
  234.  
  235.    for (ms = 0; ms < Elements(stw_pf_multisample); ms++) {
  236.       unsigned samples = stw_pf_multisample[ms];
  237.  
  238.       /* FIXME: re-enabled MSAA when we can query it */
  239.       if (samples)
  240.          continue;
  241.  
  242.       for (db = 0; db < Elements(stw_pf_doublebuffer); db++) {
  243.          unsigned doublebuffer = stw_pf_doublebuffer[db];
  244.  
  245.          for (ds = 0; ds < Elements(stw_pf_depth_stencil); ds++) {
  246.             const struct stw_pf_depth_info *depth = &stw_pf_depth_stencil[ds];
  247.  
  248.             if (!screen->is_format_supported(screen, depth->format,
  249.                                              PIPE_TEXTURE_2D, 0,
  250.                                              PIPE_BIND_DEPTH_STENCIL)) {
  251.                continue;
  252.             }
  253.  
  254.             for (acc = 0; acc < 2; acc++) {
  255.                stw_pixelformat_add(stw_dev, extended, color, depth,
  256.                                    acc * 16, doublebuffer, samples);
  257.                num_added++;
  258.             }
  259.          }
  260.       }
  261.    }
  262.  
  263.    return num_added;
  264. }
  265.  
  266.  
  267. void
  268. stw_pixelformat_init( void )
  269. {
  270.    unsigned i;
  271.    unsigned num_formats = 0;
  272.  
  273.    assert( !stw_dev->pixelformat_count );
  274.    assert( !stw_dev->pixelformat_extended_count );
  275.  
  276.    /* normal, displayable formats */
  277.    for (i = 0; i < Elements(stw_pf_color); i++) {
  278.       num_formats += add_color_format_variants(&stw_pf_color[i], FALSE);
  279.    }
  280.    assert(num_formats > 0);
  281.  
  282.    /* extended, pbuffer-only formats */
  283.    for (i = 0; i < Elements(stw_pf_color_extended); i++) {
  284.       add_color_format_variants(&stw_pf_color_extended[i], TRUE);
  285.    }
  286.  
  287.    assert( stw_dev->pixelformat_count <= stw_dev->pixelformat_extended_count );
  288.    assert( stw_dev->pixelformat_extended_count <= STW_MAX_PIXELFORMATS );
  289. }
  290.  
  291. uint
  292. stw_pixelformat_get_count( void )
  293. {
  294.    return stw_dev->pixelformat_count;
  295. }
  296.  
  297. uint
  298. stw_pixelformat_get_extended_count( void )
  299. {
  300.    return stw_dev->pixelformat_extended_count;
  301. }
  302.  
  303. const struct stw_pixelformat_info *
  304. stw_pixelformat_get_info( int iPixelFormat )
  305. {
  306.    unsigned index;
  307.  
  308.    if (iPixelFormat <= 0) {
  309.       return NULL;
  310.    }
  311.  
  312.    index = iPixelFormat - 1;
  313.    if (index >= stw_dev->pixelformat_extended_count) {
  314.       return NULL;
  315.    }
  316.  
  317.    return &stw_dev->pixelformats[index];
  318. }
  319.  
  320.  
  321. LONG APIENTRY
  322. DrvDescribePixelFormat(
  323.    HDC hdc,
  324.    INT iPixelFormat,
  325.    ULONG cjpfd,
  326.    PIXELFORMATDESCRIPTOR *ppfd )
  327. {
  328.    uint count;
  329.    const struct stw_pixelformat_info *pfi;
  330.  
  331.    (void) hdc;
  332.  
  333.    if (!stw_dev)
  334.       return 0;
  335.  
  336.    count = stw_pixelformat_get_count();
  337.  
  338.    if (ppfd == NULL)
  339.       return count;
  340.    if (cjpfd != sizeof( PIXELFORMATDESCRIPTOR ))
  341.       return 0;
  342.  
  343.    pfi = stw_pixelformat_get_info( iPixelFormat );
  344.    if (!pfi) {
  345.       return 0;
  346.    }
  347.    
  348.    memcpy(ppfd, &pfi->pfd, sizeof( PIXELFORMATDESCRIPTOR ));
  349.  
  350.    return count;
  351. }
  352.  
  353. BOOL APIENTRY
  354. DrvDescribeLayerPlane(
  355.    HDC hdc,
  356.    INT iPixelFormat,
  357.    INT iLayerPlane,
  358.    UINT nBytes,
  359.    LPLAYERPLANEDESCRIPTOR plpd )
  360. {
  361.    assert(0);
  362.    return FALSE;
  363. }
  364.  
  365. int APIENTRY
  366. DrvGetLayerPaletteEntries(
  367.    HDC hdc,
  368.    INT iLayerPlane,
  369.    INT iStart,
  370.    INT cEntries,
  371.    COLORREF *pcr )
  372. {
  373.    assert(0);
  374.    return 0;
  375. }
  376.  
  377. int APIENTRY
  378. DrvSetLayerPaletteEntries(
  379.    HDC hdc,
  380.    INT iLayerPlane,
  381.    INT iStart,
  382.    INT cEntries,
  383.    CONST COLORREF *pcr )
  384. {
  385.    assert(0);
  386.    return 0;
  387. }
  388.  
  389. BOOL APIENTRY
  390. DrvRealizeLayerPalette(
  391.    HDC hdc,
  392.    INT iLayerPlane,
  393.    BOOL bRealize )
  394. {
  395.    assert(0);
  396.    return FALSE;
  397. }
  398.  
  399. /* Only used by the wgl code, but have it here to avoid exporting the
  400.  * pixelformat.h functionality.
  401.  */
  402. int stw_pixelformat_choose( HDC hdc,
  403.                             CONST PIXELFORMATDESCRIPTOR *ppfd )
  404. {
  405.    uint count;
  406.    uint index;
  407.    uint bestindex;
  408.    uint bestdelta;
  409.  
  410.    (void) hdc;
  411.  
  412.    count = stw_pixelformat_get_extended_count();
  413.    bestindex = 0;
  414.    bestdelta = ~0U;
  415.  
  416.    for (index = 1; index <= count; index++) {
  417.       uint delta = 0;
  418.       const struct stw_pixelformat_info *pfi = stw_pixelformat_get_info( index );
  419.  
  420.       if (!(ppfd->dwFlags & PFD_DOUBLEBUFFER_DONTCARE) &&
  421.           !!(ppfd->dwFlags & PFD_DOUBLEBUFFER) !=
  422.           !!(pfi->pfd.dwFlags & PFD_DOUBLEBUFFER))
  423.          continue;
  424.  
  425.       /* FIXME: Take in account individual channel bits */
  426.       if (ppfd->cColorBits != pfi->pfd.cColorBits)
  427.          delta += 8;
  428.  
  429.       if (ppfd->cDepthBits != pfi->pfd.cDepthBits)
  430.          delta += 4;
  431.  
  432.       if (ppfd->cStencilBits != pfi->pfd.cStencilBits)
  433.          delta += 2;
  434.  
  435.       if (ppfd->cAlphaBits != pfi->pfd.cAlphaBits)
  436.          delta++;
  437.  
  438.       if (delta < bestdelta) {
  439.          bestindex = index;
  440.          bestdelta = delta;
  441.          if (bestdelta == 0)
  442.             break;
  443.       }
  444.    }
  445.  
  446.    return bestindex;
  447. }
  448.