Subversion Repositories Kolibri OS

Rev

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

  1. /**************************************************************************
  2.  *
  3.  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
  4.  * Copyright (c) 2008-2010 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.  
  30. /**
  31.  * Mesa / Gallium format conversion and format selection code.
  32.  * \author Brian Paul
  33.  */
  34.  
  35. #include "main/imports.h"
  36. #include "main/context.h"
  37. #include "main/texstore.h"
  38. #include "main/image.h"
  39. #include "main/macros.h"
  40.  
  41. #include "pipe/p_context.h"
  42. #include "pipe/p_defines.h"
  43. #include "pipe/p_screen.h"
  44. #include "util/u_format.h"
  45. #include "st_context.h"
  46. #include "st_format.h"
  47.  
  48.  
  49. static GLuint
  50. format_max_bits(enum pipe_format format)
  51. {
  52.    GLuint size = util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 0);
  53.  
  54.    size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 1));
  55.    size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 2));
  56.    size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 3));
  57.    size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 0));
  58.    size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 1));
  59.    return size;
  60. }
  61.  
  62.  
  63. /**
  64.  * Return basic GL datatype for the given gallium format.
  65.  */
  66. GLenum
  67. st_format_datatype(enum pipe_format format)
  68. {
  69.    const struct util_format_description *desc;
  70.  
  71.    desc = util_format_description(format);
  72.    assert(desc);
  73.  
  74.    if (desc->layout == UTIL_FORMAT_LAYOUT_PLAIN) {
  75.       if (format == PIPE_FORMAT_B5G5R5A1_UNORM ||
  76.           format == PIPE_FORMAT_B5G6R5_UNORM) {
  77.          return GL_UNSIGNED_SHORT;
  78.       }
  79.       else if (format == PIPE_FORMAT_Z24_UNORM_S8_USCALED ||
  80.                format == PIPE_FORMAT_S8_USCALED_Z24_UNORM ||
  81.                format == PIPE_FORMAT_Z24X8_UNORM ||
  82.                format == PIPE_FORMAT_X8Z24_UNORM) {
  83.          return GL_UNSIGNED_INT_24_8;
  84.       }
  85.       else {
  86.          const GLuint size = format_max_bits(format);
  87.          if (size == 8) {
  88.             if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED)
  89.                return GL_UNSIGNED_BYTE;
  90.             else
  91.                return GL_BYTE;
  92.          }
  93.          else if (size == 16) {
  94.             if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED)
  95.                return GL_UNSIGNED_SHORT;
  96.             else
  97.                return GL_SHORT;
  98.          }
  99.          else {
  100.             assert( size <= 32 );
  101.             if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED)
  102.                return GL_UNSIGNED_INT;
  103.             else
  104.                return GL_INT;
  105.          }
  106.       }
  107.    }
  108.    else if (format == PIPE_FORMAT_UYVY) {
  109.       return GL_UNSIGNED_SHORT;
  110.    }
  111.    else if (format == PIPE_FORMAT_YUYV) {
  112.       return GL_UNSIGNED_SHORT;
  113.    }
  114.    else {
  115.       /* probably a compressed format, unsupported anyway */
  116.       return GL_NONE;
  117.    }
  118. }
  119.  
  120.  
  121. /**
  122.  * Translate Mesa format to Gallium format.
  123.  */
  124. enum pipe_format
  125. st_mesa_format_to_pipe_format(gl_format mesaFormat)
  126. {
  127.    switch (mesaFormat) {
  128.    case MESA_FORMAT_RGBA8888:
  129.       return PIPE_FORMAT_A8B8G8R8_UNORM;
  130.    case MESA_FORMAT_RGBA8888_REV:
  131.       return PIPE_FORMAT_R8G8B8A8_UNORM;
  132.    case MESA_FORMAT_ARGB8888:
  133.       return PIPE_FORMAT_B8G8R8A8_UNORM;
  134.    case MESA_FORMAT_ARGB8888_REV:
  135.       return PIPE_FORMAT_A8R8G8B8_UNORM;
  136.    case MESA_FORMAT_XRGB8888:
  137.       return PIPE_FORMAT_B8G8R8X8_UNORM;
  138.    case MESA_FORMAT_XRGB8888_REV:
  139.       return PIPE_FORMAT_X8R8G8B8_UNORM;
  140.    case MESA_FORMAT_ARGB1555:
  141.       return PIPE_FORMAT_B5G5R5A1_UNORM;
  142.    case MESA_FORMAT_ARGB4444:
  143.       return PIPE_FORMAT_B4G4R4A4_UNORM;
  144.    case MESA_FORMAT_RGB565:
  145.       return PIPE_FORMAT_B5G6R5_UNORM;
  146.    case MESA_FORMAT_AL88:
  147.       return PIPE_FORMAT_L8A8_UNORM;
  148.    case MESA_FORMAT_A8:
  149.       return PIPE_FORMAT_A8_UNORM;
  150.    case MESA_FORMAT_L8:
  151.       return PIPE_FORMAT_L8_UNORM;
  152.    case MESA_FORMAT_I8:
  153.       return PIPE_FORMAT_I8_UNORM;
  154.    case MESA_FORMAT_Z16:
  155.       return PIPE_FORMAT_Z16_UNORM;
  156.    case MESA_FORMAT_Z32:
  157.       return PIPE_FORMAT_Z32_UNORM;
  158.    case MESA_FORMAT_Z24_S8:
  159.       return PIPE_FORMAT_S8_USCALED_Z24_UNORM;
  160.    case MESA_FORMAT_S8_Z24:
  161.       return PIPE_FORMAT_Z24_UNORM_S8_USCALED;
  162.    case MESA_FORMAT_Z24_X8:
  163.       return PIPE_FORMAT_X8Z24_UNORM;
  164.    case MESA_FORMAT_X8_Z24:
  165.       return PIPE_FORMAT_Z24X8_UNORM;
  166.    case MESA_FORMAT_S8:
  167.       return PIPE_FORMAT_S8_USCALED;
  168.    case MESA_FORMAT_YCBCR:
  169.       return PIPE_FORMAT_UYVY;
  170. #if FEATURE_texture_s3tc
  171.    case MESA_FORMAT_RGB_DXT1:
  172.       return PIPE_FORMAT_DXT1_RGB;
  173.    case MESA_FORMAT_RGBA_DXT1:
  174.       return PIPE_FORMAT_DXT1_RGBA;
  175.    case MESA_FORMAT_RGBA_DXT3:
  176.       return PIPE_FORMAT_DXT3_RGBA;
  177.    case MESA_FORMAT_RGBA_DXT5:
  178.       return PIPE_FORMAT_DXT5_RGBA;
  179. #if FEATURE_EXT_texture_sRGB
  180.    case MESA_FORMAT_SRGB_DXT1:
  181.       return PIPE_FORMAT_DXT1_SRGB;
  182.    case MESA_FORMAT_SRGBA_DXT1:
  183.       return PIPE_FORMAT_DXT1_SRGBA;
  184.    case MESA_FORMAT_SRGBA_DXT3:
  185.       return PIPE_FORMAT_DXT3_SRGBA;
  186.    case MESA_FORMAT_SRGBA_DXT5:
  187.       return PIPE_FORMAT_DXT5_SRGBA;
  188. #endif
  189. #endif
  190. #if FEATURE_EXT_texture_sRGB
  191.    case MESA_FORMAT_SLA8:
  192.       return PIPE_FORMAT_L8A8_SRGB;
  193.    case MESA_FORMAT_SL8:
  194.       return PIPE_FORMAT_L8_SRGB;
  195.    case MESA_FORMAT_SRGB8:
  196.       return PIPE_FORMAT_R8G8B8_SRGB;
  197.    case MESA_FORMAT_SRGBA8:
  198.       return PIPE_FORMAT_A8B8G8R8_SRGB;
  199.    case MESA_FORMAT_SARGB8:
  200.       return PIPE_FORMAT_B8G8R8A8_SRGB;
  201. #endif
  202.    case MESA_FORMAT_R8:
  203.       return PIPE_FORMAT_R8_UNORM;
  204.    case MESA_FORMAT_R16:
  205.       return PIPE_FORMAT_R16_UNORM;
  206.    case MESA_FORMAT_RG88:
  207.       return PIPE_FORMAT_R8G8_UNORM;
  208.    case MESA_FORMAT_RG1616:
  209.       return PIPE_FORMAT_R16G16_UNORM;
  210.    case MESA_FORMAT_RGBA_16:
  211.       return PIPE_FORMAT_R16G16B16A16_UNORM;
  212.  
  213.    /* signed int formats */
  214.    case MESA_FORMAT_RGBA_INT8:
  215.       return PIPE_FORMAT_R8G8B8A8_SSCALED;
  216.    case MESA_FORMAT_RGBA_INT16:
  217.       return PIPE_FORMAT_R16G16B16A16_SSCALED;
  218.    case MESA_FORMAT_RGBA_INT32:
  219.       return PIPE_FORMAT_R32G32B32A32_SSCALED;
  220.  
  221.    /* unsigned int formats */
  222.    case MESA_FORMAT_RGBA_UINT8:
  223.       return PIPE_FORMAT_R8G8B8A8_USCALED;
  224.    case MESA_FORMAT_RGBA_UINT16:
  225.       return PIPE_FORMAT_R16G16B16A16_USCALED;
  226.    case MESA_FORMAT_RGBA_UINT32:
  227.       return PIPE_FORMAT_R32G32B32A32_USCALED;
  228.  
  229.    default:
  230.       assert(0);
  231.       return PIPE_FORMAT_NONE;
  232.    }
  233. }
  234.  
  235.  
  236. /**
  237.  * Translate Gallium format to Mesa format.
  238.  */
  239. gl_format
  240. st_pipe_format_to_mesa_format(enum pipe_format format)
  241. {
  242.    switch (format) {
  243.    case PIPE_FORMAT_A8B8G8R8_UNORM:
  244.       return MESA_FORMAT_RGBA8888;
  245.    case PIPE_FORMAT_R8G8B8A8_UNORM:
  246.       return MESA_FORMAT_RGBA8888_REV;
  247.    case PIPE_FORMAT_B8G8R8A8_UNORM:
  248.       return MESA_FORMAT_ARGB8888;
  249.    case PIPE_FORMAT_A8R8G8B8_UNORM:
  250.       return MESA_FORMAT_ARGB8888_REV;
  251.    case PIPE_FORMAT_B8G8R8X8_UNORM:
  252.       return MESA_FORMAT_XRGB8888;
  253.    case PIPE_FORMAT_X8R8G8B8_UNORM:
  254.       return MESA_FORMAT_XRGB8888_REV;
  255.    case PIPE_FORMAT_B5G5R5A1_UNORM:
  256.       return MESA_FORMAT_ARGB1555;
  257.    case PIPE_FORMAT_B4G4R4A4_UNORM:
  258.       return MESA_FORMAT_ARGB4444;
  259.    case PIPE_FORMAT_B5G6R5_UNORM:
  260.       return MESA_FORMAT_RGB565;
  261.    case PIPE_FORMAT_L8A8_UNORM:
  262.       return MESA_FORMAT_AL88;
  263.    case PIPE_FORMAT_A8_UNORM:
  264.       return MESA_FORMAT_A8;
  265.    case PIPE_FORMAT_L8_UNORM:
  266.       return MESA_FORMAT_L8;
  267.    case PIPE_FORMAT_I8_UNORM:
  268.       return MESA_FORMAT_I8;
  269.    case PIPE_FORMAT_S8_USCALED:
  270.       return MESA_FORMAT_S8;
  271.  
  272.    case PIPE_FORMAT_R16G16B16A16_UNORM:
  273.       return MESA_FORMAT_RGBA_16;
  274.    case PIPE_FORMAT_R16G16B16A16_SNORM:
  275.       return MESA_FORMAT_SIGNED_RGBA_16;
  276.  
  277.    case PIPE_FORMAT_Z16_UNORM:
  278.       return MESA_FORMAT_Z16;
  279.    case PIPE_FORMAT_Z32_UNORM:
  280.       return MESA_FORMAT_Z32;
  281.    case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
  282.       return MESA_FORMAT_Z24_S8;
  283.    case PIPE_FORMAT_X8Z24_UNORM:
  284.       return MESA_FORMAT_Z24_X8;
  285.    case PIPE_FORMAT_Z24X8_UNORM:
  286.       return MESA_FORMAT_X8_Z24;
  287.    case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
  288.       return MESA_FORMAT_S8_Z24;
  289.  
  290.    case PIPE_FORMAT_UYVY:
  291.       return MESA_FORMAT_YCBCR;
  292.    case PIPE_FORMAT_YUYV:
  293.       return MESA_FORMAT_YCBCR_REV;
  294.  
  295. #if FEATURE_texture_s3tc
  296.    case PIPE_FORMAT_DXT1_RGB:
  297.       return MESA_FORMAT_RGB_DXT1;
  298.    case PIPE_FORMAT_DXT1_RGBA:
  299.       return MESA_FORMAT_RGBA_DXT1;
  300.    case PIPE_FORMAT_DXT3_RGBA:
  301.       return MESA_FORMAT_RGBA_DXT3;
  302.    case PIPE_FORMAT_DXT5_RGBA:
  303.       return MESA_FORMAT_RGBA_DXT5;
  304. #if FEATURE_EXT_texture_sRGB
  305.    case PIPE_FORMAT_DXT1_SRGB:
  306.       return MESA_FORMAT_SRGB_DXT1;
  307.    case PIPE_FORMAT_DXT1_SRGBA:
  308.       return MESA_FORMAT_SRGBA_DXT1;
  309.    case PIPE_FORMAT_DXT3_SRGBA:
  310.       return MESA_FORMAT_SRGBA_DXT3;
  311.    case PIPE_FORMAT_DXT5_SRGBA:
  312.       return MESA_FORMAT_SRGBA_DXT5;
  313. #endif
  314. #endif
  315.  
  316. #if FEATURE_EXT_texture_sRGB
  317.    case PIPE_FORMAT_L8A8_SRGB:
  318.       return MESA_FORMAT_SLA8;
  319.    case PIPE_FORMAT_L8_SRGB:
  320.       return MESA_FORMAT_SL8;
  321.    case PIPE_FORMAT_R8G8B8_SRGB:
  322.       return MESA_FORMAT_SRGB8;
  323.    case PIPE_FORMAT_A8B8G8R8_SRGB:
  324.       return MESA_FORMAT_SRGBA8;
  325.    case PIPE_FORMAT_B8G8R8A8_SRGB:
  326.       return MESA_FORMAT_SARGB8;
  327. #endif
  328.  
  329.    case PIPE_FORMAT_R8_UNORM:
  330.       return MESA_FORMAT_R8;
  331.    case PIPE_FORMAT_R16_UNORM:
  332.       return MESA_FORMAT_R16;
  333.    case PIPE_FORMAT_R8G8_UNORM:
  334.       return MESA_FORMAT_RG88;
  335.    case PIPE_FORMAT_R16G16_UNORM:
  336.       return MESA_FORMAT_RG1616;
  337.  
  338.    /* signed int formats */
  339.    case PIPE_FORMAT_R8G8B8A8_SSCALED:
  340.       return MESA_FORMAT_RGBA_INT8;
  341.    case PIPE_FORMAT_R16G16B16A16_SSCALED:
  342.       return MESA_FORMAT_RGBA_INT16;
  343.    case PIPE_FORMAT_R32G32B32A32_SSCALED:
  344.       return MESA_FORMAT_RGBA_INT32;
  345.  
  346.    /* unsigned int formats */
  347.    case PIPE_FORMAT_R8G8B8A8_USCALED:
  348.       return MESA_FORMAT_RGBA_UINT8;
  349.    case PIPE_FORMAT_R16G16B16A16_USCALED:
  350.       return MESA_FORMAT_RGBA_UINT16;
  351.    case PIPE_FORMAT_R32G32B32A32_USCALED:
  352.       return MESA_FORMAT_RGBA_UINT32;
  353.  
  354.    default:
  355.       assert(0);
  356.       return MESA_FORMAT_NONE;
  357.    }
  358. }
  359.  
  360.  
  361. /**
  362.  * Return first supported format from the given list.
  363.  */
  364. static enum pipe_format
  365. find_supported_format(struct pipe_screen *screen,
  366.                       const enum pipe_format formats[],
  367.                       uint num_formats,
  368.                       enum pipe_texture_target target,
  369.                       unsigned sample_count,
  370.                       unsigned tex_usage,
  371.                       unsigned geom_flags)
  372. {
  373.    uint i;
  374.    for (i = 0; i < num_formats; i++) {
  375.       if (screen->is_format_supported(screen, formats[i], target,
  376.                                       sample_count, tex_usage, geom_flags)) {
  377.          return formats[i];
  378.       }
  379.    }
  380.    return PIPE_FORMAT_NONE;
  381. }
  382.  
  383.  
  384. /**
  385.  * Find an RGBA format supported by the context/winsys.
  386.  */
  387. static enum pipe_format
  388. default_rgba_format(struct pipe_screen *screen,
  389.                     enum pipe_texture_target target,
  390.                     unsigned sample_count,
  391.                     unsigned tex_usage,
  392.                     unsigned geom_flags)
  393. {
  394.    static const enum pipe_format colorFormats[] = {
  395.       PIPE_FORMAT_B8G8R8A8_UNORM,
  396.       PIPE_FORMAT_A8R8G8B8_UNORM,
  397.       PIPE_FORMAT_A8B8G8R8_UNORM,
  398.       PIPE_FORMAT_B5G6R5_UNORM
  399.    };
  400.    return find_supported_format(screen, colorFormats, Elements(colorFormats),
  401.                                 target, sample_count, tex_usage, geom_flags);
  402. }
  403.  
  404.  
  405. /**
  406.  * Find an RGB format supported by the context/winsys.
  407.  */
  408. static enum pipe_format
  409. default_rgb_format(struct pipe_screen *screen,
  410.                    enum pipe_texture_target target,
  411.                    unsigned sample_count,
  412.                    unsigned tex_usage,
  413.                    unsigned geom_flags)
  414. {
  415.    static const enum pipe_format colorFormats[] = {
  416.       PIPE_FORMAT_B8G8R8X8_UNORM,
  417.       PIPE_FORMAT_X8R8G8B8_UNORM,
  418.       PIPE_FORMAT_X8B8G8R8_UNORM,
  419.       PIPE_FORMAT_B8G8R8A8_UNORM,
  420.       PIPE_FORMAT_A8R8G8B8_UNORM,
  421.       PIPE_FORMAT_A8B8G8R8_UNORM,
  422.       PIPE_FORMAT_B5G6R5_UNORM
  423.    };
  424.    return find_supported_format(screen, colorFormats, Elements(colorFormats),
  425.                                 target, sample_count, tex_usage, geom_flags);
  426. }
  427.  
  428. /**
  429.  * Find an sRGBA format supported by the context/winsys.
  430.  */
  431. static enum pipe_format
  432. default_srgba_format(struct pipe_screen *screen,
  433.                     enum pipe_texture_target target,
  434.                     unsigned sample_count,
  435.                     unsigned tex_usage,
  436.                     unsigned geom_flags)
  437. {
  438.    static const enum pipe_format colorFormats[] = {
  439.       PIPE_FORMAT_B8G8R8A8_SRGB,
  440.       PIPE_FORMAT_A8R8G8B8_SRGB,
  441.       PIPE_FORMAT_A8B8G8R8_SRGB,
  442.    };
  443.    return find_supported_format(screen, colorFormats, Elements(colorFormats),
  444.                                 target, sample_count, tex_usage, geom_flags);
  445. }
  446.  
  447.  
  448. /**
  449.  * Given an OpenGL internalFormat value for a texture or surface, return
  450.  * the best matching PIPE_FORMAT_x, or PIPE_FORMAT_NONE if there's no match.
  451.  * This is called during glTexImage2D, for example.
  452.  *
  453.  * The bindings parameter typically has PIPE_BIND_SAMPLER_VIEW set, plus
  454.  * either PIPE_BINDING_RENDER_TARGET or PIPE_BINDING_DEPTH_STENCIL if
  455.  * we want render-to-texture ability.
  456.  *
  457.  * \param internalFormat  the user value passed to glTexImage2D
  458.  * \param target  one of PIPE_TEXTURE_x
  459.  * \param bindings  bitmask of PIPE_BIND_x flags.
  460.  */
  461. enum pipe_format
  462. st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
  463.                  enum pipe_texture_target target, unsigned sample_count,
  464.                  unsigned bindings)
  465. {
  466.    unsigned geom_flags = 0; /* we don't care about POT vs. NPOT here, yet */
  467.  
  468.    switch (internalFormat) {
  469.    case 4:
  470.    case GL_RGBA:
  471.    case GL_RGBA8:
  472.    case GL_RGB10_A2:
  473.       return default_rgba_format( screen, target, sample_count, bindings,
  474.                                   geom_flags );
  475.  
  476.    case 3:
  477.    case GL_RGB:
  478.       return default_rgb_format( screen, target, sample_count, bindings,
  479.                                  geom_flags );
  480.    case GL_RGBA12:
  481.    case GL_RGBA16:
  482.       if (screen->is_format_supported( screen, PIPE_FORMAT_R16G16B16A16_UNORM,
  483.                                              target, sample_count, bindings,
  484.                                              geom_flags ))
  485.          return PIPE_FORMAT_R16G16B16A16_UNORM;
  486.       return default_rgba_format( screen, target, sample_count, bindings,
  487.                                   geom_flags );
  488.  
  489.    case GL_RGBA4:
  490.    case GL_RGBA2:
  491.       if (screen->is_format_supported( screen, PIPE_FORMAT_B4G4R4A4_UNORM,
  492.                                        target, sample_count, bindings,
  493.                                        geom_flags ))
  494.          return PIPE_FORMAT_B4G4R4A4_UNORM;
  495.       return default_rgba_format( screen, target, sample_count, bindings,
  496.                                   geom_flags );
  497.  
  498.    case GL_RGB5_A1:
  499.       if (screen->is_format_supported( screen, PIPE_FORMAT_B5G5R5A1_UNORM,
  500.                                        target, sample_count, bindings,
  501.                                        geom_flags ))
  502.          return PIPE_FORMAT_B5G5R5A1_UNORM;
  503.       return default_rgba_format( screen, target, sample_count, bindings,
  504.                                   geom_flags );
  505.  
  506.    case GL_RGB8:
  507.    case GL_RGB10:
  508.    case GL_RGB12:
  509.    case GL_RGB16:
  510.       return default_rgb_format( screen, target, sample_count, bindings,
  511.                                  geom_flags );
  512.  
  513.    case GL_RGB5:
  514.    case GL_RGB4:
  515.    case GL_R3_G3_B2:
  516.       if (screen->is_format_supported( screen, PIPE_FORMAT_B5G6R5_UNORM,
  517.                                        target, sample_count, bindings,
  518.                                        geom_flags ))
  519.          return PIPE_FORMAT_B5G6R5_UNORM;
  520.       if (screen->is_format_supported( screen, PIPE_FORMAT_B5G5R5A1_UNORM,
  521.                                        target, sample_count, bindings,
  522.                                        geom_flags ))
  523.          return PIPE_FORMAT_B5G5R5A1_UNORM;
  524.       return default_rgba_format( screen, target, sample_count, bindings,
  525.                                   geom_flags );
  526.  
  527.    case GL_ALPHA:
  528.    case GL_ALPHA4:
  529.    case GL_ALPHA8:
  530.    case GL_ALPHA12:
  531.    case GL_ALPHA16:
  532.    case GL_COMPRESSED_ALPHA:
  533.       if (screen->is_format_supported( screen, PIPE_FORMAT_A8_UNORM, target,
  534.                                        sample_count, bindings, geom_flags ))
  535.          return PIPE_FORMAT_A8_UNORM;
  536.       return default_rgba_format( screen, target, sample_count, bindings,
  537.                                   geom_flags );
  538.  
  539.    case 1:
  540.    case GL_LUMINANCE:
  541.    case GL_LUMINANCE4:
  542.    case GL_LUMINANCE8:
  543.    case GL_LUMINANCE12:
  544.    case GL_LUMINANCE16:
  545.    case GL_COMPRESSED_LUMINANCE:
  546.       if (screen->is_format_supported( screen, PIPE_FORMAT_L8_UNORM, target,
  547.                                        sample_count, bindings, geom_flags ))
  548.          return PIPE_FORMAT_L8_UNORM;
  549.       return default_rgba_format( screen, target, sample_count, bindings,
  550.                                   geom_flags );
  551.  
  552.    case 2:
  553.    case GL_LUMINANCE_ALPHA:
  554.    case GL_LUMINANCE4_ALPHA4:
  555.    case GL_LUMINANCE6_ALPHA2:
  556.    case GL_LUMINANCE8_ALPHA8:
  557.    case GL_LUMINANCE12_ALPHA4:
  558.    case GL_LUMINANCE12_ALPHA12:
  559.    case GL_LUMINANCE16_ALPHA16:
  560.    case GL_COMPRESSED_LUMINANCE_ALPHA:
  561.       if (screen->is_format_supported( screen, PIPE_FORMAT_L8A8_UNORM, target,
  562.                                        sample_count, bindings, geom_flags ))
  563.          return PIPE_FORMAT_L8A8_UNORM;
  564.       return default_rgba_format( screen, target, sample_count, bindings,
  565.                                   geom_flags );
  566.  
  567.    case GL_INTENSITY:
  568.    case GL_INTENSITY4:
  569.    case GL_INTENSITY8:
  570.    case GL_INTENSITY12:
  571.    case GL_INTENSITY16:
  572.    case GL_COMPRESSED_INTENSITY:
  573.       if (screen->is_format_supported( screen, PIPE_FORMAT_I8_UNORM, target,
  574.                                        sample_count, bindings, geom_flags ))
  575.          return PIPE_FORMAT_I8_UNORM;
  576.       return default_rgba_format( screen, target, sample_count, bindings,
  577.                                   geom_flags );
  578.  
  579.    case GL_YCBCR_MESA:
  580.       if (screen->is_format_supported(screen, PIPE_FORMAT_UYVY, target,
  581.                                       sample_count, bindings, geom_flags)) {
  582.          return PIPE_FORMAT_UYVY;
  583.       }
  584.       if (screen->is_format_supported(screen, PIPE_FORMAT_YUYV, target,
  585.                                       sample_count, bindings, geom_flags)) {
  586.          return PIPE_FORMAT_YUYV;
  587.       }
  588.       return PIPE_FORMAT_NONE;
  589.  
  590.    case GL_COMPRESSED_RED:
  591.    case GL_COMPRESSED_RG:
  592.    case GL_COMPRESSED_RGB:
  593.       /* can only sample from compressed formats */
  594.       if (bindings & ~PIPE_BIND_SAMPLER_VIEW)
  595.          return PIPE_FORMAT_NONE;
  596.       else if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGB,
  597.                                            target, sample_count, bindings,
  598.                                            geom_flags))
  599.          return PIPE_FORMAT_DXT1_RGB;
  600.       else
  601.          return default_rgb_format(screen, target, sample_count, bindings,
  602.                                    geom_flags);
  603.  
  604.    case GL_COMPRESSED_RGBA:
  605.       /* can only sample from compressed formats */
  606.       if (bindings & ~PIPE_BIND_SAMPLER_VIEW)
  607.          return PIPE_FORMAT_NONE;
  608.       else if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_RGBA,
  609.                                            target, sample_count, bindings,
  610.                                            geom_flags))
  611.          return PIPE_FORMAT_DXT3_RGBA;
  612.       else
  613.          return default_rgba_format(screen, target, sample_count, bindings,
  614.                                     geom_flags);
  615.  
  616.    case GL_RGB_S3TC:
  617.    case GL_RGB4_S3TC:
  618.    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
  619.       if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGB,
  620.                                       target, sample_count, bindings,
  621.                                       geom_flags))
  622.          return PIPE_FORMAT_DXT1_RGB;
  623.       else
  624.          return PIPE_FORMAT_NONE;
  625.  
  626.    case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
  627.       if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGBA,
  628.                                       target, sample_count, bindings,
  629.                                       geom_flags))
  630.          return PIPE_FORMAT_DXT1_RGBA;
  631.       else
  632.          return PIPE_FORMAT_NONE;
  633.  
  634.    case GL_RGBA_S3TC:
  635.    case GL_RGBA4_S3TC:
  636.    case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
  637.       if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_RGBA,
  638.                                       target, sample_count, bindings,
  639.                                       geom_flags))
  640.          return PIPE_FORMAT_DXT3_RGBA;
  641.       else
  642.          return PIPE_FORMAT_NONE;
  643.  
  644.    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
  645.       if (screen->is_format_supported(screen, PIPE_FORMAT_DXT5_RGBA,
  646.                                       target, sample_count, bindings,
  647.                                       geom_flags))
  648.          return PIPE_FORMAT_DXT5_RGBA;
  649.       else
  650.          return PIPE_FORMAT_NONE;
  651.  
  652. #if 0
  653.    case GL_COMPRESSED_RGB_FXT1_3DFX:
  654.       return PIPE_FORMAT_RGB_FXT1;
  655.    case GL_COMPRESSED_RGBA_FXT1_3DFX:
  656.       return PIPE_FORMAT_RGB_FXT1;
  657. #endif
  658.  
  659.    case GL_DEPTH_COMPONENT16:
  660.       if (screen->is_format_supported(screen, PIPE_FORMAT_Z16_UNORM, target,
  661.                                       sample_count, bindings, geom_flags))
  662.          return PIPE_FORMAT_Z16_UNORM;
  663.       /* fall-through */
  664.    case GL_DEPTH_COMPONENT24:
  665.       if (screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
  666.                                       target, sample_count, bindings, geom_flags))
  667.          return PIPE_FORMAT_Z24_UNORM_S8_USCALED;
  668.       if (screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
  669.                                       target, sample_count, bindings, geom_flags))
  670.          return PIPE_FORMAT_S8_USCALED_Z24_UNORM;
  671.       /* fall-through */
  672.    case GL_DEPTH_COMPONENT32:
  673.       if (screen->is_format_supported(screen, PIPE_FORMAT_Z32_UNORM, target,
  674.                                       sample_count, bindings, geom_flags))
  675.          return PIPE_FORMAT_Z32_UNORM;
  676.       /* fall-through */
  677.    case GL_DEPTH_COMPONENT:
  678.       {
  679.          static const enum pipe_format formats[] = {
  680.             PIPE_FORMAT_Z16_UNORM,
  681.             PIPE_FORMAT_Z32_UNORM,
  682.             PIPE_FORMAT_Z24_UNORM_S8_USCALED,
  683.             PIPE_FORMAT_S8_USCALED_Z24_UNORM
  684.          };
  685.          return find_supported_format(screen, formats, Elements(formats),
  686.                                       target, sample_count, bindings, geom_flags);
  687.       }
  688.  
  689.    case GL_STENCIL_INDEX:
  690.    case GL_STENCIL_INDEX1_EXT:
  691.    case GL_STENCIL_INDEX4_EXT:
  692.    case GL_STENCIL_INDEX8_EXT:
  693.    case GL_STENCIL_INDEX16_EXT:
  694.       {
  695.          static const enum pipe_format formats[] = {
  696.             PIPE_FORMAT_S8_USCALED,
  697.             PIPE_FORMAT_Z24_UNORM_S8_USCALED,
  698.             PIPE_FORMAT_S8_USCALED_Z24_UNORM
  699.          };
  700.          return find_supported_format(screen, formats, Elements(formats),
  701.                                       target, sample_count, bindings, geom_flags);
  702.       }
  703.  
  704.    case GL_DEPTH_STENCIL_EXT:
  705.    case GL_DEPTH24_STENCIL8_EXT:
  706.       {
  707.          static const enum pipe_format formats[] = {
  708.             PIPE_FORMAT_Z24_UNORM_S8_USCALED,
  709.             PIPE_FORMAT_S8_USCALED_Z24_UNORM
  710.          };
  711.          return find_supported_format(screen, formats, Elements(formats),
  712.                                       target, sample_count, bindings, geom_flags);
  713.       }
  714.  
  715.    case GL_SRGB_EXT:
  716.    case GL_SRGB8_EXT:
  717.    case GL_COMPRESSED_SRGB_EXT:
  718.    case GL_COMPRESSED_SRGB_ALPHA_EXT:
  719.    case GL_SRGB_ALPHA_EXT:
  720.    case GL_SRGB8_ALPHA8_EXT:
  721.       return default_srgba_format( screen, target, sample_count, bindings,
  722.                                    geom_flags );
  723.    case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
  724.       return PIPE_FORMAT_DXT1_SRGB;
  725.    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
  726.       return PIPE_FORMAT_DXT1_SRGBA;
  727.    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
  728.       return PIPE_FORMAT_DXT3_SRGBA;
  729.    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
  730.       return PIPE_FORMAT_DXT5_SRGBA;
  731.  
  732.    case GL_SLUMINANCE_ALPHA_EXT:
  733.    case GL_SLUMINANCE8_ALPHA8_EXT:
  734.    case GL_COMPRESSED_SLUMINANCE_EXT:
  735.    case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
  736.       if (screen->is_format_supported(screen, PIPE_FORMAT_L8A8_SRGB, target,
  737.                                       sample_count, bindings, geom_flags))
  738.          return PIPE_FORMAT_L8A8_SRGB;
  739.       return default_srgba_format( screen, target, sample_count, bindings,
  740.                                    geom_flags );
  741.  
  742.    case GL_SLUMINANCE_EXT:
  743.    case GL_SLUMINANCE8_EXT:
  744.       if (screen->is_format_supported(screen, PIPE_FORMAT_L8_SRGB, target,
  745.                                       sample_count, bindings, geom_flags))
  746.          return PIPE_FORMAT_L8_SRGB;
  747.       return default_srgba_format( screen, target, sample_count, bindings,
  748.                                    geom_flags );
  749.  
  750.    case GL_RED:
  751.    case GL_R8:
  752.       if (screen->is_format_supported(screen, PIPE_FORMAT_R8_UNORM, target,
  753.                                       sample_count, bindings, geom_flags))
  754.               return PIPE_FORMAT_R8_UNORM;
  755.       return PIPE_FORMAT_NONE;
  756.    case GL_RG:
  757.    case GL_RG8:
  758.       if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM, target,
  759.                                       sample_count, bindings, geom_flags))
  760.               return PIPE_FORMAT_R8G8_UNORM;
  761.       return PIPE_FORMAT_NONE;
  762.  
  763.    case GL_R16:
  764.       if (screen->is_format_supported(screen, PIPE_FORMAT_R16_UNORM, target,
  765.                                       sample_count, bindings, geom_flags))
  766.               return PIPE_FORMAT_R16_UNORM;
  767.       return PIPE_FORMAT_NONE;
  768.  
  769.    case GL_RG16:
  770.       if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16_UNORM, target,
  771.                                       sample_count, bindings, geom_flags))
  772.               return PIPE_FORMAT_R16G16_UNORM;
  773.       return PIPE_FORMAT_NONE;
  774.  
  775.    case GL_COMPRESSED_RED_RGTC1:
  776.       if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_UNORM, target,
  777.                                       sample_count, bindings, geom_flags))
  778.               return PIPE_FORMAT_RGTC1_UNORM;
  779.       return PIPE_FORMAT_NONE;
  780.  
  781.    case GL_COMPRESSED_SIGNED_RED_RGTC1:
  782.       if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_SNORM, target,
  783.                                       sample_count, bindings, geom_flags))
  784.               return PIPE_FORMAT_RGTC1_SNORM;
  785.       return PIPE_FORMAT_NONE;
  786.  
  787.    case GL_COMPRESSED_RG_RGTC2:
  788.       if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_UNORM, target,
  789.                                       sample_count, bindings, geom_flags))
  790.               return PIPE_FORMAT_RGTC2_UNORM;
  791.       return PIPE_FORMAT_NONE;
  792.  
  793.    case GL_COMPRESSED_SIGNED_RG_RGTC2:
  794.       if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_SNORM, target,
  795.                                       sample_count, bindings, geom_flags))
  796.               return PIPE_FORMAT_RGTC2_SNORM;
  797.       return PIPE_FORMAT_NONE;
  798.  
  799.    /* signed/unsigned integer formats.
  800.     * XXX Mesa only has formats for RGBA signed/unsigned integer formats.
  801.     * If/when new formats are added this code should be updated.
  802.     */
  803.    case GL_RED_INTEGER_EXT:
  804.    case GL_GREEN_INTEGER_EXT:
  805.    case GL_BLUE_INTEGER_EXT:
  806.    case GL_ALPHA_INTEGER_EXT:
  807.    case GL_RGB_INTEGER_EXT:
  808.    case GL_RGBA_INTEGER_EXT:
  809.    case GL_BGR_INTEGER_EXT:
  810.    case GL_BGRA_INTEGER_EXT:
  811.    case GL_LUMINANCE_INTEGER_EXT:
  812.    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
  813.       /* fall-through */
  814.    case GL_RGBA8I_EXT:
  815.    case GL_RGB8I_EXT:
  816.    case GL_ALPHA8I_EXT:
  817.    case GL_INTENSITY8I_EXT:
  818.    case GL_LUMINANCE8I_EXT:
  819.    case GL_LUMINANCE_ALPHA8I_EXT:
  820.       if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_SSCALED,
  821.                                       target,
  822.                                       sample_count, bindings, geom_flags))
  823.          return PIPE_FORMAT_R8G8B8A8_SSCALED;
  824.       return PIPE_FORMAT_NONE;
  825.    case GL_RGBA16I_EXT:
  826.    case GL_RGB16I_EXT:
  827.    case GL_ALPHA16I_EXT:
  828.    case GL_INTENSITY16I_EXT:
  829.    case GL_LUMINANCE16I_EXT:
  830.    case GL_LUMINANCE_ALPHA16I_EXT:
  831.       if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_SSCALED,
  832.                                       target,
  833.                                       sample_count, bindings, geom_flags))
  834.          return PIPE_FORMAT_R16G16B16A16_SSCALED;
  835.       return PIPE_FORMAT_NONE;
  836.    case GL_RGBA32I_EXT:
  837.    case GL_RGB32I_EXT:
  838.    case GL_ALPHA32I_EXT:
  839.    case GL_INTENSITY32I_EXT:
  840.    case GL_LUMINANCE32I_EXT:
  841.    case GL_LUMINANCE_ALPHA32I_EXT:
  842.       /* xxx */
  843.       if (screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_SSCALED,
  844.                                       target,
  845.                                       sample_count, bindings, geom_flags))
  846.          return PIPE_FORMAT_R32G32B32A32_SSCALED;
  847.       return PIPE_FORMAT_NONE;
  848.  
  849.    case GL_RGBA8UI_EXT:
  850.    case GL_RGB8UI_EXT:
  851.    case GL_ALPHA8UI_EXT:
  852.    case GL_INTENSITY8UI_EXT:
  853.    case GL_LUMINANCE8UI_EXT:
  854.    case GL_LUMINANCE_ALPHA8UI_EXT:
  855.       if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_USCALED,
  856.                                       target,
  857.                                       sample_count, bindings, geom_flags))
  858.          return PIPE_FORMAT_R8G8B8A8_USCALED;
  859.       return PIPE_FORMAT_NONE;
  860.  
  861.    case GL_RGBA16UI_EXT:
  862.    case GL_RGB16UI_EXT:
  863.    case GL_ALPHA16UI_EXT:
  864.    case GL_INTENSITY16UI_EXT:
  865.    case GL_LUMINANCE16UI_EXT:
  866.    case GL_LUMINANCE_ALPHA16UI_EXT:
  867.       if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_USCALED,
  868.                                       target,
  869.                                       sample_count, bindings, geom_flags))
  870.          return PIPE_FORMAT_R16G16B16A16_USCALED;
  871.       return PIPE_FORMAT_NONE;
  872.  
  873.    case GL_RGBA32UI_EXT:
  874.    case GL_RGB32UI_EXT:
  875.    case GL_ALPHA32UI_EXT:
  876.    case GL_INTENSITY32UI_EXT:
  877.    case GL_LUMINANCE32UI_EXT:
  878.    case GL_LUMINANCE_ALPHA32UI_EXT:
  879.       if (screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_USCALED,
  880.                                       target,
  881.                                       sample_count, bindings, geom_flags))
  882.          return PIPE_FORMAT_R32G32B32A32_USCALED;
  883.       return PIPE_FORMAT_NONE;
  884.  
  885.    default:
  886.       return PIPE_FORMAT_NONE;
  887.    }
  888. }
  889.  
  890.  
  891. /**
  892.  * Called by FBO code to choose a PIPE_FORMAT_ for drawing surfaces.
  893.  */
  894. enum pipe_format
  895. st_choose_renderbuffer_format(struct pipe_screen *screen,
  896.                               GLenum internalFormat, unsigned sample_count)
  897. {
  898.    uint usage;
  899.    if (_mesa_is_depth_or_stencil_format(internalFormat))
  900.       usage = PIPE_BIND_DEPTH_STENCIL;
  901.    else
  902.       usage = PIPE_BIND_RENDER_TARGET;
  903.    return st_choose_format(screen, internalFormat, PIPE_TEXTURE_2D,
  904.                            sample_count, usage);
  905. }
  906.  
  907.  
  908. /**
  909.  * Called via ctx->Driver.chooseTextureFormat().
  910.  */
  911. gl_format
  912. st_ChooseTextureFormat_renderable(struct gl_context *ctx, GLint internalFormat,
  913.                                   GLenum format, GLenum type, GLboolean renderable)
  914. {
  915.    struct pipe_screen *screen = st_context(ctx)->pipe->screen;
  916.    enum pipe_format pFormat;
  917.    uint bindings;
  918.  
  919.    (void) format;
  920.    (void) type;
  921.  
  922.    /* GL textures may wind up being render targets, but we don't know
  923.     * that in advance.  Specify potential render target flags now.
  924.     */
  925.    bindings = PIPE_BIND_SAMPLER_VIEW;
  926.    if (renderable == GL_TRUE) {
  927.       if (_mesa_is_depth_format(internalFormat) ||
  928.           _mesa_is_depth_or_stencil_format(internalFormat))
  929.          bindings |= PIPE_BIND_DEPTH_STENCIL;
  930.       else
  931.          bindings |= PIPE_BIND_RENDER_TARGET;
  932.    }
  933.  
  934.    pFormat = st_choose_format(screen, internalFormat,
  935.                               PIPE_TEXTURE_2D, 0, bindings);
  936.  
  937.    if (pFormat == PIPE_FORMAT_NONE) {
  938.       /* try choosing format again, this time without render target bindings */
  939.       pFormat = st_choose_format(screen, internalFormat,
  940.                                  PIPE_TEXTURE_2D, 0, PIPE_BIND_SAMPLER_VIEW);
  941.    }
  942.  
  943.    if (pFormat == PIPE_FORMAT_NONE) {
  944.       /* no luck at all */
  945.       return MESA_FORMAT_NONE;
  946.    }
  947.  
  948.    return st_pipe_format_to_mesa_format(pFormat);
  949. }
  950.  
  951. gl_format
  952. st_ChooseTextureFormat(struct gl_context *ctx, GLint internalFormat,
  953.                        GLenum format, GLenum type)
  954. {
  955.    return st_ChooseTextureFormat_renderable(ctx, internalFormat,
  956.                                             format, type, GL_TRUE);
  957. }
  958.  
  959. /**
  960.  * Test if a gallium format is equivalent to a GL format/type.
  961.  */
  962. GLboolean
  963. st_equal_formats(enum pipe_format pFormat, GLenum format, GLenum type)
  964. {
  965.    switch (pFormat) {
  966.    case PIPE_FORMAT_A8B8G8R8_UNORM:
  967.       return format == GL_RGBA && type == GL_UNSIGNED_BYTE;
  968.    case PIPE_FORMAT_A8R8G8B8_UNORM:
  969.       return format == GL_BGRA && type == GL_UNSIGNED_BYTE;
  970.    case PIPE_FORMAT_B5G6R5_UNORM:
  971.       return format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5;
  972.    /* XXX more combos... */
  973.    default:
  974.       return GL_FALSE;
  975.    }
  976. }
  977.  
  978. GLboolean
  979. st_sampler_compat_formats(enum pipe_format format1, enum pipe_format format2)
  980. {
  981.    if (format1 == format2)
  982.       return GL_TRUE;
  983.  
  984.    if (format1 == PIPE_FORMAT_B8G8R8A8_UNORM &&
  985.        format2 == PIPE_FORMAT_B8G8R8X8_UNORM)
  986.       return GL_TRUE;
  987.  
  988.    if (format1 == PIPE_FORMAT_B8G8R8X8_UNORM &&
  989.        format2 == PIPE_FORMAT_B8G8R8A8_UNORM)
  990.       return GL_TRUE;
  991.  
  992.    if (format1 == PIPE_FORMAT_A8B8G8R8_UNORM &&
  993.        format2 == PIPE_FORMAT_X8B8G8R8_UNORM)
  994.       return GL_TRUE;
  995.  
  996.    if (format1 == PIPE_FORMAT_X8B8G8R8_UNORM &&
  997.        format2 == PIPE_FORMAT_A8B8G8R8_UNORM)
  998.       return GL_TRUE;
  999.  
  1000.    if (format1 == PIPE_FORMAT_A8R8G8B8_UNORM &&
  1001.        format2 == PIPE_FORMAT_X8R8G8B8_UNORM)
  1002.       return GL_TRUE;
  1003.  
  1004.    if (format1 == PIPE_FORMAT_X8R8G8B8_UNORM &&
  1005.        format2 == PIPE_FORMAT_A8R8G8B8_UNORM)
  1006.       return GL_TRUE;
  1007.  
  1008.    return GL_FALSE;
  1009. }
  1010.  
  1011.  
  1012.  
  1013. /**
  1014.  * This is used for translating texture border color and the clear
  1015.  * color.  For example, the clear color is interpreted according to
  1016.  * the renderbuffer's base format.  For example, if clearing a
  1017.  * GL_LUMINANCE buffer, ClearColor[0] = luminance and ClearColor[1] =
  1018.  * alpha.  Similarly for texture border colors.
  1019.  */
  1020. void
  1021. st_translate_color(const GLfloat colorIn[4], GLenum baseFormat,
  1022.                    GLfloat colorOut[4])
  1023. {
  1024.    switch (baseFormat) {
  1025.    case GL_RED:
  1026.       colorOut[0] = colorIn[0];
  1027.       colorOut[1] = 0.0F;
  1028.       colorOut[2] = 0.0F;
  1029.       colorOut[3] = 1.0F;
  1030.       break;
  1031.    case GL_RG:
  1032.       colorOut[0] = colorIn[0];
  1033.       colorOut[1] = colorIn[1];
  1034.       colorOut[2] = 0.0F;
  1035.       colorOut[3] = 1.0F;
  1036.       break;
  1037.    case GL_RGB:
  1038.       colorOut[0] = colorIn[0];
  1039.       colorOut[1] = colorIn[1];
  1040.       colorOut[2] = colorIn[2];
  1041.       colorOut[3] = 1.0F;
  1042.       break;
  1043.    case GL_ALPHA:
  1044.       colorOut[0] = colorOut[1] = colorOut[2] = 0.0;
  1045.       colorOut[3] = colorIn[3];
  1046.       break;
  1047.    case GL_LUMINANCE:
  1048.       colorOut[0] = colorOut[1] = colorOut[2] = colorIn[0];
  1049.       colorOut[3] = 1.0;
  1050.       break;
  1051.    case GL_LUMINANCE_ALPHA:
  1052.       colorOut[0] = colorOut[1] = colorOut[2] = colorIn[0];
  1053.       colorOut[3] = colorIn[3];
  1054.       break;
  1055.    case GL_INTENSITY:
  1056.       colorOut[0] = colorOut[1] = colorOut[2] = colorOut[3] = colorIn[0];
  1057.       break;
  1058.    default:
  1059.       COPY_4V(colorOut, colorIn);
  1060.    }
  1061. }
  1062.