Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /**************************************************************************
  2.  *
  3.  * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
  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 TUNGSTEN GRAPHICS 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. }
  442.