Subversion Repositories Kolibri OS

Rev

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

  1. /*
  2.  * Mesa 3-D graphics library
  3.  *
  4.  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
  5.  * Copyright (C) 2009-2010  VMware, Inc.  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 "Software"),
  9.  * to deal in the Software without restriction, including without limitation
  10.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11.  * and/or sell copies of the Software, and to permit persons to whom the
  12.  * Software is furnished to do so, subject to the following conditions:
  13.  *
  14.  * The above copyright notice and this permission notice shall be included
  15.  * in all copies or substantial portions of the Software.
  16.  *
  17.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20.  * THEA AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21.  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23.  */
  24.  
  25.  
  26. /**
  27.  * \file pack.c
  28.  * Image and pixel span packing and unpacking.
  29.  */
  30.  
  31.  
  32. /*
  33.  * XXX: MSVC takes forever to compile this module for x86_64 unless we disable
  34.  * this global optimization.
  35.  *
  36.  * See also:
  37.  * - http://msdn.microsoft.com/en-us/library/1yk3ydd7.aspx
  38.  * - http://msdn.microsoft.com/en-us/library/chh3fb0k.aspx
  39.  */
  40. #if defined(_MSC_VER) && defined(_M_X64)
  41. #  pragma optimize( "g", off )
  42. #endif
  43.  
  44.  
  45. #include "glheader.h"
  46. #include "colormac.h"
  47. #include "enums.h"
  48. #include "image.h"
  49. #include "imports.h"
  50. #include "macros.h"
  51. #include "mtypes.h"
  52. #include "pack.h"
  53. #include "pixeltransfer.h"
  54. #include "imports.h"
  55. #include "glformats.h"
  56. #include "../../gallium/auxiliary/util/u_format_rgb9e5.h"
  57. #include "../../gallium/auxiliary/util/u_format_r11g11b10f.h"
  58.  
  59.  
  60. /**
  61.  * Flip the 8 bits in each byte of the given array.
  62.  *
  63.  * \param p array.
  64.  * \param n number of bytes.
  65.  *
  66.  * \todo try this trick to flip bytes someday:
  67.  * \code
  68.  *  v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555);
  69.  *  v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333);
  70.  *  v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f);
  71.  * \endcode
  72.  */
  73. static void
  74. flip_bytes( GLubyte *p, GLuint n )
  75. {
  76.    GLuint i, a, b;
  77.    for (i = 0; i < n; i++) {
  78.       b = (GLuint) p[i];        /* words are often faster than bytes */
  79.       a = ((b & 0x01) << 7) |
  80.           ((b & 0x02) << 5) |
  81.           ((b & 0x04) << 3) |
  82.           ((b & 0x08) << 1) |
  83.           ((b & 0x10) >> 1) |
  84.           ((b & 0x20) >> 3) |
  85.           ((b & 0x40) >> 5) |
  86.           ((b & 0x80) >> 7);
  87.       p[i] = (GLubyte) a;
  88.    }
  89. }
  90.  
  91.  
  92.  
  93. /*
  94.  * Unpack a 32x32 pixel polygon stipple from user memory using the
  95.  * current pixel unpack settings.
  96.  */
  97. void
  98. _mesa_unpack_polygon_stipple( const GLubyte *pattern, GLuint dest[32],
  99.                               const struct gl_pixelstore_attrib *unpacking )
  100. {
  101.    GLubyte *ptrn = (GLubyte *) _mesa_unpack_bitmap(32, 32, pattern, unpacking);
  102.    if (ptrn) {
  103.       /* Convert pattern from GLubytes to GLuints and handle big/little
  104.        * endian differences
  105.        */
  106.       GLubyte *p = ptrn;
  107.       GLint i;
  108.       for (i = 0; i < 32; i++) {
  109.          dest[i] = (p[0] << 24)
  110.                  | (p[1] << 16)
  111.                  | (p[2] <<  8)
  112.                  | (p[3]      );
  113.          p += 4;
  114.       }
  115.       free(ptrn);
  116.    }
  117. }
  118.  
  119.  
  120. /*
  121.  * Pack polygon stipple into user memory given current pixel packing
  122.  * settings.
  123.  */
  124. void
  125. _mesa_pack_polygon_stipple( const GLuint pattern[32], GLubyte *dest,
  126.                             const struct gl_pixelstore_attrib *packing )
  127. {
  128.    /* Convert pattern from GLuints to GLubytes to handle big/little
  129.     * endian differences.
  130.     */
  131.    GLubyte ptrn[32*4];
  132.    GLint i;
  133.    for (i = 0; i < 32; i++) {
  134.       ptrn[i * 4 + 0] = (GLubyte) ((pattern[i] >> 24) & 0xff);
  135.       ptrn[i * 4 + 1] = (GLubyte) ((pattern[i] >> 16) & 0xff);
  136.       ptrn[i * 4 + 2] = (GLubyte) ((pattern[i] >> 8 ) & 0xff);
  137.       ptrn[i * 4 + 3] = (GLubyte) ((pattern[i]      ) & 0xff);
  138.    }
  139.  
  140.    _mesa_pack_bitmap(32, 32, ptrn, dest, packing);
  141. }
  142.  
  143.  
  144. /*
  145.  * Unpack bitmap data.  Resulting data will be in most-significant-bit-first
  146.  * order with row alignment = 1 byte.
  147.  */
  148. GLvoid *
  149. _mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels,
  150.                      const struct gl_pixelstore_attrib *packing )
  151. {
  152.    GLint bytes, row, width_in_bytes;
  153.    GLubyte *buffer, *dst;
  154.  
  155.    if (!pixels)
  156.       return NULL;
  157.  
  158.    /* Alloc dest storage */
  159.    bytes = ((width + 7) / 8 * height);
  160.    buffer = malloc( bytes );
  161.    if (!buffer)
  162.       return NULL;
  163.  
  164.    width_in_bytes = CEILING( width, 8 );
  165.    dst = buffer;
  166.    for (row = 0; row < height; row++) {
  167.       const GLubyte *src = (const GLubyte *)
  168.          _mesa_image_address2d(packing, pixels, width, height,
  169.                                GL_COLOR_INDEX, GL_BITMAP, row, 0);
  170.       if (!src) {
  171.          free(buffer);
  172.          return NULL;
  173.       }
  174.  
  175.       if ((packing->SkipPixels & 7) == 0) {
  176.          memcpy( dst, src, width_in_bytes );
  177.          if (packing->LsbFirst) {
  178.             flip_bytes( dst, width_in_bytes );
  179.          }
  180.       }
  181.       else {
  182.          /* handling SkipPixels is a bit tricky (no pun intended!) */
  183.          GLint i;
  184.          if (packing->LsbFirst) {
  185.             GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
  186.             GLubyte dstMask = 128;
  187.             const GLubyte *s = src;
  188.             GLubyte *d = dst;
  189.             *d = 0;
  190.             for (i = 0; i < width; i++) {
  191.                if (*s & srcMask) {
  192.                   *d |= dstMask;
  193.                }
  194.                if (srcMask == 128) {
  195.                   srcMask = 1;
  196.                   s++;
  197.                }
  198.                else {
  199.                   srcMask = srcMask << 1;
  200.                }
  201.                if (dstMask == 1) {
  202.                   dstMask = 128;
  203.                   d++;
  204.                   *d = 0;
  205.                }
  206.                else {
  207.                   dstMask = dstMask >> 1;
  208.                }
  209.             }
  210.          }
  211.          else {
  212.             GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
  213.             GLubyte dstMask = 128;
  214.             const GLubyte *s = src;
  215.             GLubyte *d = dst;
  216.             *d = 0;
  217.             for (i = 0; i < width; i++) {
  218.                if (*s & srcMask) {
  219.                   *d |= dstMask;
  220.                }
  221.                if (srcMask == 1) {
  222.                   srcMask = 128;
  223.                   s++;
  224.                }
  225.                else {
  226.                   srcMask = srcMask >> 1;
  227.                }
  228.                if (dstMask == 1) {
  229.                   dstMask = 128;
  230.                   d++;
  231.                   *d = 0;
  232.                }
  233.                else {
  234.                   dstMask = dstMask >> 1;
  235.                }
  236.             }
  237.          }
  238.       }
  239.       dst += width_in_bytes;
  240.    }
  241.  
  242.    return buffer;
  243. }
  244.  
  245.  
  246. /*
  247.  * Pack bitmap data.
  248.  */
  249. void
  250. _mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,
  251.                    GLubyte *dest, const struct gl_pixelstore_attrib *packing )
  252. {
  253.    GLint row, width_in_bytes;
  254.    const GLubyte *src;
  255.  
  256.    if (!source)
  257.       return;
  258.  
  259.    width_in_bytes = CEILING( width, 8 );
  260.    src = source;
  261.    for (row = 0; row < height; row++) {
  262.       GLubyte *dst = (GLubyte *) _mesa_image_address2d(packing, dest,
  263.                        width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);
  264.       if (!dst)
  265.          return;
  266.  
  267.       if ((packing->SkipPixels & 7) == 0) {
  268.          memcpy( dst, src, width_in_bytes );
  269.          if (packing->LsbFirst) {
  270.             flip_bytes( dst, width_in_bytes );
  271.          }
  272.       }
  273.       else {
  274.          /* handling SkipPixels is a bit tricky (no pun intended!) */
  275.          GLint i;
  276.          if (packing->LsbFirst) {
  277.             GLubyte srcMask = 128;
  278.             GLubyte dstMask = 1 << (packing->SkipPixels & 0x7);
  279.             const GLubyte *s = src;
  280.             GLubyte *d = dst;
  281.             *d = 0;
  282.             for (i = 0; i < width; i++) {
  283.                if (*s & srcMask) {
  284.                   *d |= dstMask;
  285.                }
  286.                if (srcMask == 1) {
  287.                   srcMask = 128;
  288.                   s++;
  289.                }
  290.                else {
  291.                   srcMask = srcMask >> 1;
  292.                }
  293.                if (dstMask == 128) {
  294.                   dstMask = 1;
  295.                   d++;
  296.                   *d = 0;
  297.                }
  298.                else {
  299.                   dstMask = dstMask << 1;
  300.                }
  301.             }
  302.          }
  303.          else {
  304.             GLubyte srcMask = 128;
  305.             GLubyte dstMask = 128 >> (packing->SkipPixels & 0x7);
  306.             const GLubyte *s = src;
  307.             GLubyte *d = dst;
  308.             *d = 0;
  309.             for (i = 0; i < width; i++) {
  310.                if (*s & srcMask) {
  311.                   *d |= dstMask;
  312.                }
  313.                if (srcMask == 1) {
  314.                   srcMask = 128;
  315.                   s++;
  316.                }
  317.                else {
  318.                   srcMask = srcMask >> 1;
  319.                }
  320.                if (dstMask == 1) {
  321.                   dstMask = 128;
  322.                   d++;
  323.                   *d = 0;
  324.                }
  325.                else {
  326.                   dstMask = dstMask >> 1;
  327.                }
  328.             }
  329.          }
  330.       }
  331.       src += width_in_bytes;
  332.    }
  333. }
  334.  
  335.  
  336. /**
  337.  * Get indexes of color components for a basic color format, such as
  338.  * GL_RGBA, GL_RED, GL_LUMINANCE_ALPHA, etc.  Return -1 for indexes
  339.  * that do not apply.
  340.  */
  341. static void
  342. get_component_indexes(GLenum format,
  343.                       GLint *redIndex,
  344.                       GLint *greenIndex,
  345.                       GLint *blueIndex,
  346.                       GLint *alphaIndex,
  347.                       GLint *luminanceIndex,
  348.                       GLint *intensityIndex)
  349. {
  350.    *redIndex = -1;
  351.    *greenIndex = -1;
  352.    *blueIndex = -1;
  353.    *alphaIndex = -1;
  354.    *luminanceIndex = -1;
  355.    *intensityIndex = -1;
  356.  
  357.    switch (format) {
  358.    case GL_LUMINANCE:
  359.    case GL_LUMINANCE_INTEGER_EXT:
  360.       *luminanceIndex = 0;
  361.       break;
  362.    case GL_LUMINANCE_ALPHA:
  363.    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
  364.       *luminanceIndex = 0;
  365.       *alphaIndex = 1;
  366.       break;
  367.    case GL_INTENSITY:
  368.       *intensityIndex = 0;
  369.       break;
  370.    case GL_RED:
  371.    case GL_RED_INTEGER_EXT:
  372.       *redIndex = 0;
  373.       break;
  374.    case GL_GREEN:
  375.    case GL_GREEN_INTEGER_EXT:
  376.       *greenIndex = 0;
  377.       break;
  378.    case GL_BLUE:
  379.    case GL_BLUE_INTEGER_EXT:
  380.       *blueIndex = 0;
  381.       break;
  382.    case GL_ALPHA:
  383.    case GL_ALPHA_INTEGER_EXT:
  384.       *alphaIndex = 0;
  385.       break;
  386.    case GL_RG:
  387.    case GL_RG_INTEGER:
  388.       *redIndex = 0;
  389.       *greenIndex = 1;
  390.       break;
  391.    case GL_RGB:
  392.    case GL_RGB_INTEGER_EXT:
  393.       *redIndex = 0;
  394.       *greenIndex = 1;
  395.       *blueIndex = 2;
  396.       break;
  397.    case GL_BGR:
  398.    case GL_BGR_INTEGER_EXT:
  399.       *blueIndex = 0;
  400.       *greenIndex = 1;
  401.       *redIndex = 2;
  402.       break;
  403.    case GL_RGBA:
  404.    case GL_RGBA_INTEGER_EXT:
  405.       *redIndex = 0;
  406.       *greenIndex = 1;
  407.       *blueIndex = 2;
  408.       *alphaIndex = 3;
  409.       break;
  410.    case GL_BGRA:
  411.    case GL_BGRA_INTEGER:
  412.       *redIndex = 2;
  413.       *greenIndex = 1;
  414.       *blueIndex = 0;
  415.       *alphaIndex = 3;
  416.       break;
  417.    case GL_ABGR_EXT:
  418.       *redIndex = 3;
  419.       *greenIndex = 2;
  420.       *blueIndex = 1;
  421.       *alphaIndex = 0;
  422.       break;
  423.    case GL_DU8DV8_ATI:
  424.    case GL_DUDV_ATI:
  425.       *redIndex = 0;
  426.       *greenIndex = 1;
  427.       break;
  428.    default:
  429.       assert(0 && "bad format in get_component_indexes()");
  430.    }
  431. }
  432.  
  433.  
  434.  
  435. /**
  436.  * For small integer types, return the min and max possible values.
  437.  * Used for clamping floats to unscaled integer types.
  438.  * \return GL_TRUE if type is handled, GL_FALSE otherwise.
  439.  */
  440. static GLboolean
  441. get_type_min_max(GLenum type, GLfloat *min, GLfloat *max)
  442. {
  443.    switch (type) {
  444.    case GL_BYTE:
  445.       *min = -128.0;
  446.       *max = 127.0;
  447.       return GL_TRUE;
  448.    case GL_UNSIGNED_BYTE:
  449.       *min = 0.0;
  450.       *max = 255.0;
  451.       return GL_TRUE;
  452.    case GL_SHORT:
  453.       *min = -32768.0;
  454.       *max = 32767.0;
  455.       return GL_TRUE;
  456.    case GL_UNSIGNED_SHORT:
  457.       *min = 0.0;
  458.       *max = 65535.0;
  459.       return GL_TRUE;
  460.    default:
  461.       return GL_FALSE;
  462.    }
  463. }
  464.  
  465. /* Customization of unsigned integer packing.
  466.  */
  467. #define SRC_TYPE GLuint
  468.  
  469. #define DST_TYPE GLuint
  470. #define SRC_CONVERT(x) (x)
  471. #define FN_NAME pack_uint_from_uint_rgba
  472. #include "pack_tmp.h"
  473. #undef DST_TYPE
  474. #undef SRC_CONVERT
  475. #undef FN_NAME
  476.  
  477. #define DST_TYPE GLint
  478. #define SRC_CONVERT(x) MIN2(x, 0x7fffffff)
  479. #define FN_NAME pack_int_from_uint_rgba
  480. #include "pack_tmp.h"
  481. #undef DST_TYPE
  482. #undef SRC_CONVERT
  483. #undef FN_NAME
  484.  
  485. #define DST_TYPE GLushort
  486. #define SRC_CONVERT(x) MIN2(x, 0xffff)
  487. #define FN_NAME pack_ushort_from_uint_rgba
  488. #include "pack_tmp.h"
  489. #undef DST_TYPE
  490. #undef SRC_CONVERT
  491. #undef FN_NAME
  492.  
  493. #define DST_TYPE GLshort
  494. #define SRC_CONVERT(x) CLAMP((int)x, -32768, 32767)
  495. #define FN_NAME pack_short_from_uint_rgba
  496. #include "pack_tmp.h"
  497. #undef DST_TYPE
  498. #undef SRC_CONVERT
  499. #undef FN_NAME
  500.  
  501. #define DST_TYPE GLubyte
  502. #define SRC_CONVERT(x) MIN2(x, 0xff)
  503. #define FN_NAME pack_ubyte_from_uint_rgba
  504. #include "pack_tmp.h"
  505. #undef DST_TYPE
  506. #undef SRC_CONVERT
  507. #undef FN_NAME
  508.  
  509. #define DST_TYPE GLbyte
  510. #define SRC_CONVERT(x) CLAMP((int)x, -128, 127)
  511. #define FN_NAME pack_byte_from_uint_rgba
  512. #include "pack_tmp.h"
  513. #undef DST_TYPE
  514. #undef SRC_CONVERT
  515. #undef FN_NAME
  516.  
  517. #undef SRC_TYPE
  518.  
  519. static void
  520. _pack_rgba_span_from_uints_problem(struct gl_context *ctx,
  521.                                    GLenum dstFormat, GLenum dstType)
  522. {
  523.    _mesa_problem(ctx,
  524.                  "Unsupported type (%s) / format (%s) "
  525.                  "in _mesa_pack_rgba_span_from_uints",
  526.                  _mesa_lookup_enum_by_nr(dstType),
  527.                  _mesa_lookup_enum_by_nr(dstFormat));
  528. }
  529.  
  530. void
  531. _mesa_pack_rgba_span_from_uints(struct gl_context *ctx, GLuint n, GLuint rgba[][4],
  532.                                 GLenum dstFormat, GLenum dstType,
  533.                                 GLvoid *dstAddr)
  534. {
  535.    GLuint i;
  536.  
  537.    switch(dstType) {
  538.    case GL_UNSIGNED_INT:
  539.       pack_uint_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n);
  540.       break;
  541.    case GL_INT:
  542.       pack_int_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n);
  543.       break;
  544.    case GL_UNSIGNED_SHORT:
  545.       pack_ushort_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n);
  546.       break;
  547.    case GL_SHORT:
  548.       pack_short_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n);
  549.       break;
  550.    case GL_UNSIGNED_BYTE:
  551.       pack_ubyte_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n);
  552.       break;
  553.    case GL_BYTE:
  554.       pack_byte_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n);
  555.       break;
  556.    case GL_UNSIGNED_BYTE_3_3_2:
  557.       if ((dstFormat == GL_RGB) || (dstFormat == GL_RGB_INTEGER)) {
  558.          GLubyte *dst = (GLubyte *) dstAddr;
  559.          for (i=0;i<n;i++) {
  560.             dst[i] = (MIN2(rgba[i][RCOMP], 7) << 5)
  561.                    | (MIN2(rgba[i][GCOMP], 7) << 2)
  562.                    | (MIN2(rgba[i][BCOMP], 3)     );
  563.          }
  564.       } else {
  565.          _pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
  566.       }
  567.       break;
  568.    case GL_UNSIGNED_BYTE_2_3_3_REV:
  569.       if ((dstFormat == GL_RGB) || (dstFormat == GL_RGB_INTEGER)) {
  570.          GLubyte *dst = (GLubyte *) dstAddr;
  571.          for (i=0;i<n;i++) {
  572.             dst[i] = (MIN2(rgba[i][RCOMP], 7)     )
  573.                    | (MIN2(rgba[i][GCOMP], 7) << 3)
  574.                    | (MIN2(rgba[i][BCOMP], 3) << 6);
  575.          }
  576.       } else {
  577.          _pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
  578.       }
  579.       break;
  580.    case GL_UNSIGNED_SHORT_5_6_5:
  581.       if ((dstFormat == GL_RGB) || (dstFormat == GL_RGB_INTEGER)) {
  582.          GLushort *dst = (GLushort *) dstAddr;
  583.          for (i=0;i<n;i++) {
  584.             dst[i] = (MIN2(rgba[i][RCOMP], 31) << 11)
  585.                    | (MIN2(rgba[i][GCOMP], 63) <<  5)
  586.                    | (MIN2(rgba[i][BCOMP], 31)      );
  587.          }
  588.       } else {
  589.          _pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
  590.       }
  591.       break;
  592.    case GL_UNSIGNED_SHORT_5_6_5_REV:
  593.       if ((dstFormat == GL_RGB) || (dstFormat == GL_RGB_INTEGER)) {
  594.          GLushort *dst = (GLushort *) dstAddr;
  595.          for (i=0;i<n;i++) {
  596.             dst[i] = (MIN2(rgba[i][RCOMP], 31)      )
  597.                    | (MIN2(rgba[i][GCOMP], 63) <<  5)
  598.                    | (MIN2(rgba[i][BCOMP], 31) << 11);
  599.          }
  600.       } else {
  601.          _pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
  602.       }
  603.       break;
  604.    case GL_UNSIGNED_SHORT_4_4_4_4:
  605.       if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
  606.          GLushort *dst = (GLushort *) dstAddr;
  607.          for (i=0;i<n;i++) {
  608.             dst[i] = (MIN2(rgba[i][RCOMP], 15) << 12)
  609.                    | (MIN2(rgba[i][GCOMP], 15) <<  8)
  610.                    | (MIN2(rgba[i][BCOMP], 15) <<  4)
  611.                    | (MIN2(rgba[i][ACOMP], 15)      );
  612.          }
  613.       }
  614.       else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
  615.          GLushort *dst = (GLushort *) dstAddr;
  616.          for (i=0;i<n;i++) {
  617.             dst[i] = (MIN2(rgba[i][BCOMP], 15) << 12)
  618.                    | (MIN2(rgba[i][GCOMP], 15) <<  8)
  619.                    | (MIN2(rgba[i][RCOMP], 15) <<  4)
  620.                    | (MIN2(rgba[i][ACOMP], 15)      );
  621.          }
  622.       }
  623.       else if (dstFormat == GL_ABGR_EXT) {
  624.          GLushort *dst = (GLushort *) dstAddr;
  625.          for (i=0;i<n;i++) {
  626.             dst[i] = (MIN2(rgba[i][ACOMP], 15) << 12)
  627.                    | (MIN2(rgba[i][BCOMP], 15) <<  8)
  628.                    | (MIN2(rgba[i][GCOMP], 15) <<  4)
  629.                    | (MIN2(rgba[i][RCOMP], 15)      );
  630.          }
  631.       } else {
  632.          _pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
  633.       }
  634.       break;
  635.    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
  636.       if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
  637.          GLushort *dst = (GLushort *) dstAddr;
  638.          for (i=0;i<n;i++) {
  639.             dst[i] = (MIN2(rgba[i][RCOMP], 15)      )
  640.                    | (MIN2(rgba[i][GCOMP], 15) <<  4)
  641.                    | (MIN2(rgba[i][BCOMP], 15) <<  8)
  642.                    | (MIN2(rgba[i][ACOMP], 15) << 12);
  643.          }
  644.       }
  645.       else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
  646.          GLushort *dst = (GLushort *) dstAddr;
  647.          for (i=0;i<n;i++) {
  648.             dst[i] = (MIN2(rgba[i][BCOMP], 15)      )
  649.                    | (MIN2(rgba[i][GCOMP], 15) <<  4)
  650.                    | (MIN2(rgba[i][RCOMP], 15) <<  8)
  651.                    | (MIN2(rgba[i][ACOMP], 15) << 12);
  652.          }
  653.       }
  654.       else if (dstFormat == GL_ABGR_EXT) {
  655.          GLushort *dst = (GLushort *) dstAddr;
  656.          for (i=0;i<n;i++) {
  657.             dst[i] = (MIN2(rgba[i][ACOMP], 15)      )
  658.                    | (MIN2(rgba[i][BCOMP], 15) <<  4)
  659.                    | (MIN2(rgba[i][GCOMP], 15) <<  8)
  660.                    | (MIN2(rgba[i][RCOMP], 15) << 12);
  661.          }
  662.       } else {
  663.          _pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
  664.       }
  665.       break;
  666.    case GL_UNSIGNED_SHORT_5_5_5_1:
  667.       if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
  668.          GLushort *dst = (GLushort *) dstAddr;
  669.          for (i=0;i<n;i++) {
  670.             dst[i] = (MIN2(rgba[i][RCOMP], 31) << 11)
  671.                    | (MIN2(rgba[i][GCOMP], 31) <<  6)
  672.                    | (MIN2(rgba[i][BCOMP], 31) <<  1)
  673.                    | (MIN2(rgba[i][ACOMP],  1)      );
  674.          }
  675.       }
  676.       else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
  677.          GLushort *dst = (GLushort *) dstAddr;
  678.          for (i=0;i<n;i++) {
  679.             dst[i] = (MIN2(rgba[i][BCOMP], 31) << 11)
  680.                    | (MIN2(rgba[i][GCOMP], 31) <<  6)
  681.                    | (MIN2(rgba[i][RCOMP], 31) <<  1)
  682.                    | (MIN2(rgba[i][ACOMP],  1)      );
  683.          }
  684.       }
  685.       else if (dstFormat == GL_ABGR_EXT) {
  686.          GLushort *dst = (GLushort *) dstAddr;
  687.          for (i=0;i<n;i++) {
  688.             dst[i] = (MIN2(rgba[i][ACOMP], 31) << 11)
  689.                    | (MIN2(rgba[i][BCOMP], 31) <<  6)
  690.                    | (MIN2(rgba[i][GCOMP], 31) <<  1)
  691.                    | (MIN2(rgba[i][RCOMP],  1)      );
  692.          }
  693.       } else {
  694.          _pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
  695.       }
  696.       break;
  697.    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
  698.       if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
  699.          GLushort *dst = (GLushort *) dstAddr;
  700.          for (i=0;i<n;i++) {
  701.             dst[i] = (MIN2(rgba[i][RCOMP], 31)      )
  702.                    | (MIN2(rgba[i][GCOMP], 31) <<  5)
  703.                    | (MIN2(rgba[i][BCOMP], 31) << 10)
  704.                    | (MIN2(rgba[i][ACOMP],  1) << 15);
  705.          }
  706.       }
  707.       else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
  708.          GLushort *dst = (GLushort *) dstAddr;
  709.          for (i=0;i<n;i++) {
  710.             dst[i] = (MIN2(rgba[i][BCOMP], 31)      )
  711.                    | (MIN2(rgba[i][GCOMP], 31) <<  5)
  712.                    | (MIN2(rgba[i][RCOMP], 31) << 10)
  713.                    | (MIN2(rgba[i][ACOMP],  1) << 15);
  714.          }
  715.       }
  716.       else if (dstFormat == GL_ABGR_EXT) {
  717.          GLushort *dst = (GLushort *) dstAddr;
  718.          for (i=0;i<n;i++) {
  719.             dst[i] = (MIN2(rgba[i][ACOMP], 31)      )
  720.                    | (MIN2(rgba[i][BCOMP], 31) <<  5)
  721.                    | (MIN2(rgba[i][GCOMP], 31) << 10)
  722.                    | (MIN2(rgba[i][RCOMP],  1) << 15);
  723.          }
  724.       } else {
  725.          _pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
  726.       }
  727.       break;
  728.    case GL_UNSIGNED_INT_8_8_8_8:
  729.       if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
  730.          GLuint *dst = (GLuint *) dstAddr;
  731.          for (i=0;i<n;i++) {
  732.             dst[i] = (MIN2(rgba[i][RCOMP], 255) << 24)
  733.                    | (MIN2(rgba[i][GCOMP], 255) << 16)
  734.                    | (MIN2(rgba[i][BCOMP], 255) <<  8)
  735.                    | (MIN2(rgba[i][ACOMP], 255)      );
  736.          }
  737.       }
  738.       else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
  739.          GLuint *dst = (GLuint *) dstAddr;
  740.          for (i=0;i<n;i++) {
  741.             dst[i] = (MIN2(rgba[i][BCOMP], 255) << 24)
  742.                    | (MIN2(rgba[i][GCOMP], 255) << 16)
  743.                    | (MIN2(rgba[i][RCOMP], 255) <<  8)
  744.                    | (MIN2(rgba[i][ACOMP], 255)      );
  745.          }
  746.       }
  747.       else if (dstFormat == GL_ABGR_EXT) {
  748.          GLuint *dst = (GLuint *) dstAddr;
  749.          for (i=0;i<n;i++) {
  750.             dst[i] = (MIN2(rgba[i][ACOMP], 255) << 24)
  751.                    | (MIN2(rgba[i][BCOMP], 255) << 16)
  752.                    | (MIN2(rgba[i][GCOMP], 255) <<  8)
  753.                    | (MIN2(rgba[i][RCOMP], 255)      );
  754.          }
  755.       } else {
  756.          _pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
  757.       }
  758.       break;
  759.    case GL_UNSIGNED_INT_8_8_8_8_REV:
  760.       if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
  761.          GLuint *dst = (GLuint *) dstAddr;
  762.          for (i=0;i<n;i++) {
  763.             dst[i] = (MIN2(rgba[i][RCOMP], 255)      )
  764.                    | (MIN2(rgba[i][GCOMP], 255) <<  8)
  765.                    | (MIN2(rgba[i][BCOMP], 255) << 16)
  766.                    | (MIN2(rgba[i][ACOMP], 255) << 24);
  767.          }
  768.       }
  769.       else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
  770.          GLuint *dst = (GLuint *) dstAddr;
  771.          for (i=0;i<n;i++) {
  772.             dst[i] = (MIN2(rgba[i][BCOMP], 255)      )
  773.                    | (MIN2(rgba[i][GCOMP], 255) <<  8)
  774.                    | (MIN2(rgba[i][RCOMP], 255) << 16)
  775.                    | (MIN2(rgba[i][ACOMP], 255) << 24);
  776.          }
  777.       }
  778.       else if (dstFormat == GL_ABGR_EXT) {
  779.          GLuint *dst = (GLuint *) dstAddr;
  780.          for (i=0;i<n;i++) {
  781.             dst[i] = (MIN2(rgba[i][ACOMP], 255)      )
  782.                    | (MIN2(rgba[i][BCOMP], 255) <<  8)
  783.                    | (MIN2(rgba[i][GCOMP], 255) << 16)
  784.                    | (MIN2(rgba[i][RCOMP], 255) << 24);
  785.          }
  786.       } else {
  787.          _pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
  788.       }
  789.       break;
  790.    case GL_UNSIGNED_INT_10_10_10_2:
  791.       if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
  792.          GLuint *dst = (GLuint *) dstAddr;
  793.          for (i=0;i<n;i++) {
  794.             dst[i] = (MIN2(rgba[i][RCOMP], 1023) << 22)
  795.                    | (MIN2(rgba[i][GCOMP], 1023) << 12)
  796.                    | (MIN2(rgba[i][BCOMP], 1023) <<  2)
  797.                    | (MIN2(rgba[i][ACOMP],    3)      );
  798.          }
  799.       }
  800.       else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
  801.          GLuint *dst = (GLuint *) dstAddr;
  802.          for (i=0;i<n;i++) {
  803.             dst[i] = (MIN2(rgba[i][BCOMP], 1023) << 22)
  804.                    | (MIN2(rgba[i][GCOMP], 1023) << 12)
  805.                    | (MIN2(rgba[i][RCOMP], 1023) <<  2)
  806.                    | (MIN2(rgba[i][ACOMP],    3)      );
  807.          }
  808.       }
  809.       else if (dstFormat == GL_ABGR_EXT) {
  810.          GLuint *dst = (GLuint *) dstAddr;
  811.          for (i=0;i<n;i++) {
  812.             dst[i] = (MIN2(rgba[i][ACOMP], 1023) << 22)
  813.                    | (MIN2(rgba[i][BCOMP], 1023) << 12)
  814.                    | (MIN2(rgba[i][GCOMP], 1023) <<  2)
  815.                    | (MIN2(rgba[i][RCOMP],    3)      );
  816.          }
  817.       } else {
  818.          _pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
  819.       }
  820.       break;
  821.    case GL_UNSIGNED_INT_2_10_10_10_REV:
  822.       if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
  823.          GLuint *dst = (GLuint *) dstAddr;
  824.          for (i=0;i<n;i++) {
  825.             dst[i] = (MIN2(rgba[i][RCOMP], 1023)      )
  826.                    | (MIN2(rgba[i][GCOMP], 1023) << 10)
  827.                    | (MIN2(rgba[i][BCOMP], 1023) << 20)
  828.                    | (MIN2(rgba[i][ACOMP],    3) << 30);
  829.          }
  830.       }
  831.       else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
  832.          GLuint *dst = (GLuint *) dstAddr;
  833.          for (i=0;i<n;i++) {
  834.             dst[i] = (MIN2(rgba[i][BCOMP], 1023)      )
  835.                    | (MIN2(rgba[i][GCOMP], 1023) << 10)
  836.                    | (MIN2(rgba[i][RCOMP], 1023) << 20)
  837.                    | (MIN2(rgba[i][ACOMP],    3) << 30);
  838.          }
  839.       }
  840.       else if (dstFormat == GL_ABGR_EXT) {
  841.          GLuint *dst = (GLuint *) dstAddr;
  842.          for (i=0;i<n;i++) {
  843.             dst[i] = (MIN2(rgba[i][ACOMP], 1023)      )
  844.                    | (MIN2(rgba[i][BCOMP], 1023) << 10)
  845.                    | (MIN2(rgba[i][GCOMP], 1023) << 20)
  846.                    | (MIN2(rgba[i][RCOMP],    3) << 30);
  847.          }
  848.       } else {
  849.          _pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
  850.       }
  851.       break;
  852.    default:
  853.       _pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
  854.       return;
  855.    }
  856. }
  857.  
  858.  
  859. /* Customization of signed integer packing.
  860.  */
  861. #define SRC_TYPE GLint
  862.  
  863. #define DST_TYPE GLuint
  864. #define SRC_CONVERT(x) MAX2(x, 0)
  865. #define FN_NAME pack_uint_from_int_rgba
  866. #include "pack_tmp.h"
  867. #undef DST_TYPE
  868. #undef SRC_CONVERT
  869. #undef FN_NAME
  870.  
  871. #define DST_TYPE GLushort
  872. #define SRC_CONVERT(x) MAX2(x, 0)
  873. #define FN_NAME pack_ushort_from_int_rgba
  874. #include "pack_tmp.h"
  875. #undef DST_TYPE
  876. #undef SRC_CONVERT
  877. #undef FN_NAME
  878.  
  879. #define DST_TYPE GLshort
  880. #define SRC_CONVERT(x) CLAMP(x, -0x8000, 0x7fff)
  881. #define FN_NAME pack_short_from_int_rgba
  882. #include "pack_tmp.h"
  883. #undef DST_TYPE
  884. #undef SRC_CONVERT
  885. #undef FN_NAME
  886.  
  887. #define DST_TYPE GLubyte
  888. #define SRC_CONVERT(x) MAX2(x, 0)
  889. #define FN_NAME pack_ubyte_from_int_rgba
  890. #include "pack_tmp.h"
  891. #undef DST_TYPE
  892. #undef SRC_CONVERT
  893. #undef FN_NAME
  894.  
  895. #define DST_TYPE GLbyte
  896. #define SRC_CONVERT(x) CLAMP(x, -0x80, 0x7f)
  897. #define FN_NAME pack_byte_from_int_rgba
  898. #include "pack_tmp.h"
  899. #undef DST_TYPE
  900. #undef SRC_CONVERT
  901. #undef FN_NAME
  902.  
  903. #undef SRC_TYPE
  904.  
  905. static void
  906. _pack_rgba_span_from_ints_problem(struct gl_context *ctx,
  907.                                    GLenum dstFormat, GLenum dstType)
  908. {
  909.    _mesa_problem(ctx,
  910.                  "Unsupported type (%s) / format (%s) "
  911.                  "in _mesa_pack_rgba_span_from_ints",
  912.                  _mesa_lookup_enum_by_nr(dstType),
  913.                  _mesa_lookup_enum_by_nr(dstFormat));
  914. }
  915.  
  916. void
  917. _mesa_pack_rgba_span_from_ints(struct gl_context *ctx, GLuint n, GLint rgba[][4],
  918.                                GLenum dstFormat, GLenum dstType,
  919.                                GLvoid *dstAddr)
  920. {
  921.    GLuint i;
  922.  
  923.    switch(dstType) {
  924.    case GL_UNSIGNED_INT:
  925.       pack_uint_from_int_rgba(ctx, dstAddr, dstFormat, rgba, n);
  926.       break;
  927.    case GL_INT:
  928.       /* No conversion necessary. */
  929.       pack_uint_from_uint_rgba(ctx, dstAddr, dstFormat, (GLuint (*)[4]) rgba, n);
  930.       break;
  931.    case GL_UNSIGNED_SHORT:
  932.       pack_ushort_from_int_rgba(ctx, dstAddr, dstFormat, rgba, n);
  933.       break;
  934.    case GL_SHORT:
  935.       pack_short_from_int_rgba(ctx, dstAddr, dstFormat, rgba, n);
  936.       break;
  937.    case GL_UNSIGNED_BYTE:
  938.       pack_ubyte_from_int_rgba(ctx, dstAddr, dstFormat, rgba, n);
  939.       break;
  940.    case GL_BYTE:
  941.       pack_byte_from_int_rgba(ctx, dstAddr, dstFormat, rgba, n);
  942.       break;
  943.    case GL_UNSIGNED_BYTE_3_3_2:
  944.       if ((dstFormat == GL_RGB) || (dstFormat == GL_RGB_INTEGER)) {
  945.          GLubyte *dst = (GLubyte *) dstAddr;
  946.          for (i=0;i<n;i++) {
  947.             dst[i] = (CLAMP(rgba[i][RCOMP], 0, 7) << 5)
  948.                    | (CLAMP(rgba[i][GCOMP], 0, 7) << 2)
  949.                    | (CLAMP(rgba[i][BCOMP], 0, 3)     );
  950.          }
  951.       } else {
  952.          _pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
  953.       }
  954.       break;
  955.    case GL_UNSIGNED_BYTE_2_3_3_REV:
  956.       if ((dstFormat == GL_RGB) || (dstFormat == GL_RGB_INTEGER)) {
  957.          GLubyte *dst = (GLubyte *) dstAddr;
  958.          for (i=0;i<n;i++) {
  959.             dst[i] = (CLAMP(rgba[i][RCOMP], 0, 7)     )
  960.                    | (CLAMP(rgba[i][GCOMP], 0, 7) << 3)
  961.                    | (CLAMP(rgba[i][BCOMP], 0, 3) << 6);
  962.          }
  963.       } else {
  964.          _pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
  965.       }
  966.       break;
  967.    case GL_UNSIGNED_SHORT_5_6_5:
  968.       if ((dstFormat == GL_RGB) || (dstFormat == GL_RGB_INTEGER)) {
  969.          GLushort *dst = (GLushort *) dstAddr;
  970.          for (i=0;i<n;i++) {
  971.             dst[i] = (CLAMP(rgba[i][RCOMP], 0, 31) << 11)
  972.                    | (CLAMP(rgba[i][GCOMP], 0, 63) <<  5)
  973.                    | (CLAMP(rgba[i][BCOMP], 0, 31)      );
  974.          }
  975.       } else {
  976.          _pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
  977.       }
  978.       break;
  979.    case GL_UNSIGNED_SHORT_5_6_5_REV:
  980.       if ((dstFormat == GL_RGB) || (dstFormat == GL_RGB_INTEGER)) {
  981.          GLushort *dst = (GLushort *) dstAddr;
  982.          for (i=0;i<n;i++) {
  983.             dst[i] = (CLAMP(rgba[i][RCOMP], 0, 31)      )
  984.                    | (CLAMP(rgba[i][GCOMP], 0, 63) <<  5)
  985.                    | (CLAMP(rgba[i][BCOMP], 0, 31) << 11);
  986.          }
  987.       } else {
  988.          _pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
  989.       }
  990.       break;
  991.    case GL_UNSIGNED_SHORT_4_4_4_4:
  992.       if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
  993.          GLushort *dst = (GLushort *) dstAddr;
  994.          for (i=0;i<n;i++) {
  995.             dst[i] = (CLAMP(rgba[i][RCOMP], 0, 15) << 12)
  996.                    | (CLAMP(rgba[i][GCOMP], 0, 15) <<  8)
  997.                    | (CLAMP(rgba[i][BCOMP], 0, 15) <<  4)
  998.                    | (CLAMP(rgba[i][ACOMP], 0, 15)      );
  999.          }
  1000.       }
  1001.       else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
  1002.          GLushort *dst = (GLushort *) dstAddr;
  1003.          for (i=0;i<n;i++) {
  1004.             dst[i] = (CLAMP(rgba[i][BCOMP], 0, 15) << 12)
  1005.                    | (CLAMP(rgba[i][GCOMP], 0, 15) <<  8)
  1006.                    | (CLAMP(rgba[i][RCOMP], 0, 15) <<  4)
  1007.                    | (CLAMP(rgba[i][ACOMP], 0, 15)      );
  1008.          }
  1009.       }
  1010.       else if (dstFormat == GL_ABGR_EXT) {
  1011.          GLushort *dst = (GLushort *) dstAddr;
  1012.          for (i=0;i<n;i++) {
  1013.             dst[i] = (CLAMP(rgba[i][ACOMP], 0, 15) << 12)
  1014.                    | (CLAMP(rgba[i][BCOMP], 0, 15) <<  8)
  1015.                    | (CLAMP(rgba[i][GCOMP], 0, 15) <<  4)
  1016.                    | (CLAMP(rgba[i][RCOMP], 0, 15)      );
  1017.          }
  1018.       } else {
  1019.          _pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
  1020.       }
  1021.       break;
  1022.    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
  1023.       if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
  1024.          GLushort *dst = (GLushort *) dstAddr;
  1025.          for (i=0;i<n;i++) {
  1026.             dst[i] = (CLAMP(rgba[i][RCOMP], 0, 15)      )
  1027.                    | (CLAMP(rgba[i][GCOMP], 0, 15) <<  4)
  1028.                    | (CLAMP(rgba[i][BCOMP], 0, 15) <<  8)
  1029.                    | (CLAMP(rgba[i][ACOMP], 0, 15) << 12);
  1030.          }
  1031.       }
  1032.       else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
  1033.          GLushort *dst = (GLushort *) dstAddr;
  1034.          for (i=0;i<n;i++) {
  1035.             dst[i] = (CLAMP(rgba[i][BCOMP], 0, 15)      )
  1036.                    | (CLAMP(rgba[i][GCOMP], 0, 15) <<  4)
  1037.                    | (CLAMP(rgba[i][RCOMP], 0, 15) <<  8)
  1038.                    | (CLAMP(rgba[i][ACOMP], 0, 15) << 12);
  1039.          }
  1040.       }
  1041.       else if (dstFormat == GL_ABGR_EXT) {
  1042.          GLushort *dst = (GLushort *) dstAddr;
  1043.          for (i=0;i<n;i++) {
  1044.             dst[i] = (CLAMP(rgba[i][ACOMP], 0, 15)      )
  1045.                    | (CLAMP(rgba[i][BCOMP], 0, 15) <<  4)
  1046.                    | (CLAMP(rgba[i][GCOMP], 0, 15) <<  8)
  1047.                    | (CLAMP(rgba[i][RCOMP], 0, 15) << 12);
  1048.          }
  1049.       } else {
  1050.          _pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
  1051.       }
  1052.       break;
  1053.    case GL_UNSIGNED_SHORT_5_5_5_1:
  1054.       if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
  1055.          GLushort *dst = (GLushort *) dstAddr;
  1056.          for (i=0;i<n;i++) {
  1057.             dst[i] = (CLAMP(rgba[i][RCOMP], 0, 31) << 11)
  1058.                    | (CLAMP(rgba[i][GCOMP], 0, 31) <<  6)
  1059.                    | (CLAMP(rgba[i][BCOMP], 0, 31) <<  1)
  1060.                    | (CLAMP(rgba[i][ACOMP], 0,  1)      );
  1061.          }
  1062.       }
  1063.       else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
  1064.          GLushort *dst = (GLushort *) dstAddr;
  1065.          for (i=0;i<n;i++) {
  1066.             dst[i] = (CLAMP(rgba[i][BCOMP], 0, 31) << 11)
  1067.                    | (CLAMP(rgba[i][GCOMP], 0, 31) <<  6)
  1068.                    | (CLAMP(rgba[i][RCOMP], 0, 31) <<  1)
  1069.                    | (CLAMP(rgba[i][ACOMP], 0,  1)      );
  1070.          }
  1071.       }
  1072.       else if (dstFormat == GL_ABGR_EXT) {
  1073.          GLushort *dst = (GLushort *) dstAddr;
  1074.          for (i=0;i<n;i++) {
  1075.             dst[i] = (CLAMP(rgba[i][ACOMP], 0, 31) << 11)
  1076.                    | (CLAMP(rgba[i][BCOMP], 0, 31) <<  6)
  1077.                    | (CLAMP(rgba[i][GCOMP], 0, 31) <<  1)
  1078.                    | (CLAMP(rgba[i][RCOMP], 0,  1)      );
  1079.          }
  1080.       } else {
  1081.          _pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
  1082.       }
  1083.       break;
  1084.    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
  1085.       if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
  1086.          GLushort *dst = (GLushort *) dstAddr;
  1087.          for (i=0;i<n;i++) {
  1088.             dst[i] = (CLAMP(rgba[i][RCOMP], 0, 31)      )
  1089.                    | (CLAMP(rgba[i][GCOMP], 0, 31) <<  5)
  1090.                    | (CLAMP(rgba[i][BCOMP], 0, 31) << 10)
  1091.                    | (CLAMP(rgba[i][ACOMP], 0,  1) << 15);
  1092.          }
  1093.       }
  1094.       else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
  1095.          GLushort *dst = (GLushort *) dstAddr;
  1096.          for (i=0;i<n;i++) {
  1097.             dst[i] = (CLAMP(rgba[i][BCOMP], 0, 31)      )
  1098.                    | (CLAMP(rgba[i][GCOMP], 0, 31) <<  5)
  1099.                    | (CLAMP(rgba[i][RCOMP], 0, 31) << 10)
  1100.                    | (CLAMP(rgba[i][ACOMP], 0,  1) << 15);
  1101.          }
  1102.       }
  1103.       else if (dstFormat == GL_ABGR_EXT) {
  1104.          GLushort *dst = (GLushort *) dstAddr;
  1105.          for (i=0;i<n;i++) {
  1106.             dst[i] = (CLAMP(rgba[i][ACOMP], 0, 31)      )
  1107.                    | (CLAMP(rgba[i][BCOMP], 0, 31) <<  5)
  1108.                    | (CLAMP(rgba[i][GCOMP], 0, 31) << 10)
  1109.                    | (CLAMP(rgba[i][RCOMP], 0,  1) << 15);
  1110.          }
  1111.       } else {
  1112.          _pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
  1113.       }
  1114.       break;
  1115.    case GL_UNSIGNED_INT_8_8_8_8:
  1116.       if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
  1117.          GLuint *dst = (GLuint *) dstAddr;
  1118.          for (i=0;i<n;i++) {
  1119.             dst[i] = (CLAMP(rgba[i][RCOMP], 0, 255) << 24)
  1120.                    | (CLAMP(rgba[i][GCOMP], 0, 255) << 16)
  1121.                    | (CLAMP(rgba[i][BCOMP], 0, 255) <<  8)
  1122.                    | (CLAMP(rgba[i][ACOMP], 0, 255)      );
  1123.          }
  1124.       }
  1125.       else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
  1126.          GLuint *dst = (GLuint *) dstAddr;
  1127.          for (i=0;i<n;i++) {
  1128.             dst[i] = (CLAMP(rgba[i][BCOMP], 0, 255) << 24)
  1129.                    | (CLAMP(rgba[i][GCOMP], 0, 255) << 16)
  1130.                    | (CLAMP(rgba[i][RCOMP], 0, 255) <<  8)
  1131.                    | (CLAMP(rgba[i][ACOMP], 0, 255)      );
  1132.          }
  1133.       }
  1134.       else if (dstFormat == GL_ABGR_EXT) {
  1135.          GLuint *dst = (GLuint *) dstAddr;
  1136.          for (i=0;i<n;i++) {
  1137.             dst[i] = (CLAMP(rgba[i][ACOMP], 0, 255) << 24)
  1138.                    | (CLAMP(rgba[i][BCOMP], 0, 255) << 16)
  1139.                    | (CLAMP(rgba[i][GCOMP], 0, 255) <<  8)
  1140.                    | (CLAMP(rgba[i][RCOMP], 0, 255)      );
  1141.          }
  1142.       } else {
  1143.          _pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
  1144.       }
  1145.       break;
  1146.    case GL_UNSIGNED_INT_8_8_8_8_REV:
  1147.       if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
  1148.          GLuint *dst = (GLuint *) dstAddr;
  1149.          for (i=0;i<n;i++) {
  1150.             dst[i] = (CLAMP(rgba[i][RCOMP], 0, 255)      )
  1151.                    | (CLAMP(rgba[i][GCOMP], 0, 255) <<  8)
  1152.                    | (CLAMP(rgba[i][BCOMP], 0, 255) << 16)
  1153.                    | (CLAMP(rgba[i][ACOMP], 0, 255) << 24);
  1154.          }
  1155.       }
  1156.       else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
  1157.          GLuint *dst = (GLuint *) dstAddr;
  1158.          for (i=0;i<n;i++) {
  1159.             dst[i] = (CLAMP(rgba[i][BCOMP], 0, 255)      )
  1160.                    | (CLAMP(rgba[i][GCOMP], 0, 255) <<  8)
  1161.                    | (CLAMP(rgba[i][RCOMP], 0, 255) << 16)
  1162.                    | (CLAMP(rgba[i][ACOMP], 0, 255) << 24);
  1163.          }
  1164.       }
  1165.       else if (dstFormat == GL_ABGR_EXT) {
  1166.          GLuint *dst = (GLuint *) dstAddr;
  1167.          for (i=0;i<n;i++) {
  1168.             dst[i] = (CLAMP(rgba[i][ACOMP], 0, 255)      )
  1169.                    | (CLAMP(rgba[i][BCOMP], 0, 255) <<  8)
  1170.                    | (CLAMP(rgba[i][GCOMP], 0, 255) << 16)
  1171.                    | (CLAMP(rgba[i][RCOMP], 0, 255) << 24);
  1172.          }
  1173.       } else {
  1174.          _pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
  1175.       }
  1176.       break;
  1177.    case GL_UNSIGNED_INT_10_10_10_2:
  1178.       if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
  1179.          GLuint *dst = (GLuint *) dstAddr;
  1180.          for (i=0;i<n;i++) {
  1181.             dst[i] = (CLAMP(rgba[i][RCOMP], 0, 1023) << 22)
  1182.                    | (CLAMP(rgba[i][GCOMP], 0, 1023) << 12)
  1183.                    | (CLAMP(rgba[i][BCOMP], 0, 1023) <<  2)
  1184.                    | (CLAMP(rgba[i][ACOMP], 0,    3)      );
  1185.          }
  1186.       }
  1187.       else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
  1188.          GLuint *dst = (GLuint *) dstAddr;
  1189.          for (i=0;i<n;i++) {
  1190.             dst[i] = (CLAMP(rgba[i][BCOMP], 0, 1023) << 22)
  1191.                    | (CLAMP(rgba[i][GCOMP], 0, 1023) << 12)
  1192.                    | (CLAMP(rgba[i][RCOMP], 0, 1023) <<  2)
  1193.                    | (CLAMP(rgba[i][ACOMP], 0,    3)      );
  1194.          }
  1195.       }
  1196.       else if (dstFormat == GL_ABGR_EXT) {
  1197.          GLuint *dst = (GLuint *) dstAddr;
  1198.          for (i=0;i<n;i++) {
  1199.             dst[i] = (CLAMP(rgba[i][ACOMP], 0, 1023) << 22)
  1200.                    | (CLAMP(rgba[i][BCOMP], 0, 1023) << 12)
  1201.                    | (CLAMP(rgba[i][GCOMP], 0, 1023) <<  2)
  1202.                    | (CLAMP(rgba[i][RCOMP], 0,    3)      );
  1203.          }
  1204.       } else {
  1205.          _pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
  1206.       }
  1207.       break;
  1208.    case GL_UNSIGNED_INT_2_10_10_10_REV:
  1209.       if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
  1210.          GLuint *dst = (GLuint *) dstAddr;
  1211.          for (i=0;i<n;i++) {
  1212.             dst[i] = (CLAMP(rgba[i][RCOMP], 0, 1023)      )
  1213.                    | (CLAMP(rgba[i][GCOMP], 0, 1023) << 10)
  1214.                    | (CLAMP(rgba[i][BCOMP], 0, 1023) << 20)
  1215.                    | (CLAMP(rgba[i][ACOMP], 0,    3) << 30);
  1216.          }
  1217.       }
  1218.       else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
  1219.          GLuint *dst = (GLuint *) dstAddr;
  1220.          for (i=0;i<n;i++) {
  1221.             dst[i] = (CLAMP(rgba[i][BCOMP], 0, 1023)      )
  1222.                    | (CLAMP(rgba[i][GCOMP], 0, 1023) << 10)
  1223.                    | (CLAMP(rgba[i][RCOMP], 0, 1023) << 20)
  1224.                    | (CLAMP(rgba[i][ACOMP], 0,    3) << 30);
  1225.          }
  1226.       }
  1227.       else if (dstFormat == GL_ABGR_EXT) {
  1228.          GLuint *dst = (GLuint *) dstAddr;
  1229.          for (i=0;i<n;i++) {
  1230.             dst[i] = (CLAMP(rgba[i][ACOMP], 0, 1023)      )
  1231.                    | (CLAMP(rgba[i][BCOMP], 0, 1023) << 10)
  1232.                    | (CLAMP(rgba[i][GCOMP], 0, 1023) << 20)
  1233.                    | (CLAMP(rgba[i][RCOMP], 0,    3) << 30);
  1234.          }
  1235.       } else {
  1236.          _pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
  1237.       }
  1238.       break;
  1239.    default:
  1240.       _pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
  1241.       return;
  1242.    }
  1243. }
  1244.  
  1245.  
  1246. /**
  1247.  * Used to pack an array [][4] of RGBA float colors as specified
  1248.  * by the dstFormat, dstType and dstPacking.  Used by glReadPixels.
  1249.  * Historically, the RGBA values were in [0,1] and rescaled to fit
  1250.  * into GLubytes, etc.  But with new integer formats, the RGBA values
  1251.  * may have any value and we don't always rescale when converting to
  1252.  * integers.
  1253.  *
  1254.  * Note: the rgba values will be modified by this function when any pixel
  1255.  * transfer ops are enabled.
  1256.  */
  1257. void
  1258. _mesa_pack_rgba_span_float(struct gl_context *ctx, GLuint n, GLfloat rgba[][4],
  1259.                            GLenum dstFormat, GLenum dstType,
  1260.                            GLvoid *dstAddr,
  1261.                            const struct gl_pixelstore_attrib *dstPacking,
  1262.                            GLbitfield transferOps)
  1263. {
  1264.    GLfloat *luminance;
  1265.    const GLint comps = _mesa_components_in_format(dstFormat);
  1266.    const GLboolean intDstFormat = _mesa_is_enum_format_integer(dstFormat);
  1267.    GLuint i;
  1268.  
  1269.    if (dstFormat == GL_LUMINANCE ||
  1270.        dstFormat == GL_LUMINANCE_ALPHA ||
  1271.        dstFormat == GL_LUMINANCE_INTEGER_EXT ||
  1272.        dstFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT) {
  1273.       luminance = malloc(n * sizeof(GLfloat));
  1274.       if (!luminance) {
  1275.          _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
  1276.          return;
  1277.       }
  1278.    }
  1279.    else {
  1280.       luminance = NULL;
  1281.    }
  1282.  
  1283.    /* EXT_texture_integer specifies no transfer ops on integer
  1284.     * types in the resolved issues section. Just set them to 0
  1285.     * for integer surfaces.
  1286.     */
  1287.    if (intDstFormat)
  1288.       transferOps = 0;
  1289.  
  1290.    if (transferOps) {
  1291.       _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
  1292.    }
  1293.  
  1294.    /*
  1295.     * Component clamping (besides clamping to [0,1] in
  1296.     * _mesa_apply_rgba_transfer_ops()).
  1297.     */
  1298.    if (intDstFormat) {
  1299.       /* clamping to dest type's min/max values */
  1300.       GLfloat min, max;
  1301.       if (get_type_min_max(dstType, &min, &max)) {
  1302.          for (i = 0; i < n; i++) {
  1303.             rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], min, max);
  1304.             rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], min, max);
  1305.             rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], min, max);
  1306.             rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], min, max);
  1307.          }
  1308.       }
  1309.    }
  1310.    else if (dstFormat == GL_LUMINANCE || dstFormat == GL_LUMINANCE_ALPHA) {
  1311.       /* compute luminance values */
  1312.       if (transferOps & IMAGE_CLAMP_BIT) {
  1313.          for (i = 0; i < n; i++) {
  1314.             GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
  1315.             luminance[i] = CLAMP(sum, 0.0F, 1.0F);
  1316.          }
  1317.       }
  1318.       else {
  1319.          for (i = 0; i < n; i++) {
  1320.             luminance[i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
  1321.          }
  1322.       }
  1323.    }
  1324.  
  1325.    /*
  1326.     * Pack/store the pixels.  Ugh!  Lots of cases!!!
  1327.     */
  1328.    switch (dstType) {
  1329.       case GL_UNSIGNED_BYTE:
  1330.          {
  1331.             GLubyte *dst = (GLubyte *) dstAddr;
  1332.             switch (dstFormat) {
  1333.                case GL_RED:
  1334.                   for (i=0;i<n;i++)
  1335.                      dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
  1336.                   break;
  1337.                case GL_GREEN:
  1338.                   for (i=0;i<n;i++)
  1339.                      dst[i] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
  1340.                   break;
  1341.                case GL_BLUE:
  1342.                   for (i=0;i<n;i++)
  1343.                      dst[i] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
  1344.                   break;
  1345.                case GL_ALPHA:
  1346.                   for (i=0;i<n;i++)
  1347.                      dst[i] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
  1348.                   break;
  1349.                case GL_LUMINANCE:
  1350.                   for (i=0;i<n;i++)
  1351.                      dst[i] = FLOAT_TO_UBYTE(luminance[i]);
  1352.                   break;
  1353.                case GL_LUMINANCE_ALPHA:
  1354.                   for (i=0;i<n;i++) {
  1355.                      dst[i*2+0] = FLOAT_TO_UBYTE(luminance[i]);
  1356.                      dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
  1357.                   }
  1358.                   break;
  1359.                case GL_RG:
  1360.                   for (i=0;i<n;i++) {
  1361.                      dst[i*2+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
  1362.                      dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
  1363.                   }
  1364.                   break;
  1365.                case GL_RGB:
  1366.                   for (i=0;i<n;i++) {
  1367.                      dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
  1368.                      dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
  1369.                      dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
  1370.                   }
  1371.                   break;
  1372.                case GL_RGBA:
  1373.                   for (i=0;i<n;i++) {
  1374.                      dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
  1375.                      dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
  1376.                      dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
  1377.                      dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
  1378.                   }
  1379.                   break;
  1380.                case GL_BGR:
  1381.                   for (i=0;i<n;i++) {
  1382.                      dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
  1383.                      dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
  1384.                      dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
  1385.                   }
  1386.                   break;
  1387.                case GL_BGRA:
  1388.                   for (i=0;i<n;i++) {
  1389.                      dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
  1390.                      dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
  1391.                      dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
  1392.                      dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
  1393.                   }
  1394.                   break;
  1395.                case GL_ABGR_EXT:
  1396.                   for (i=0;i<n;i++) {
  1397.                      dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
  1398.                      dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
  1399.                      dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
  1400.                      dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
  1401.                   }
  1402.                   break;
  1403.                case GL_RED_INTEGER_EXT:
  1404.                   for (i=0;i<n;i++) {
  1405.                      dst[i] = (GLubyte) rgba[i][RCOMP];
  1406.                   }
  1407.                   break;
  1408.                case GL_GREEN_INTEGER_EXT:
  1409.                   for (i=0;i<n;i++) {
  1410.                      dst[i] = (GLubyte) rgba[i][GCOMP];
  1411.                   }
  1412.                   break;
  1413.                case GL_BLUE_INTEGER_EXT:
  1414.                   for (i=0;i<n;i++) {
  1415.                      dst[i] = (GLubyte) rgba[i][BCOMP];
  1416.                   }
  1417.                   break;
  1418.                case GL_ALPHA_INTEGER_EXT:
  1419.                   for (i=0;i<n;i++) {
  1420.                      dst[i] = (GLubyte) rgba[i][ACOMP];
  1421.                   }
  1422.                   break;
  1423.                case GL_RG_INTEGER:
  1424.                   for (i=0;i<n;i++) {
  1425.                      dst[i*2+0] = (GLubyte) rgba[i][RCOMP];
  1426.                      dst[i*2+1] = (GLubyte) rgba[i][GCOMP];
  1427.                   }
  1428.                   break;
  1429.                case GL_RGB_INTEGER_EXT:
  1430.                   for (i=0;i<n;i++) {
  1431.                      dst[i*3+0] = (GLubyte) rgba[i][RCOMP];
  1432.                      dst[i*3+1] = (GLubyte) rgba[i][GCOMP];
  1433.                      dst[i*3+2] = (GLubyte) rgba[i][BCOMP];
  1434.                   }
  1435.                   break;
  1436.                case GL_RGBA_INTEGER_EXT:
  1437.                   for (i=0;i<n;i++) {
  1438.                      dst[i*4+0] = (GLubyte) rgba[i][RCOMP];
  1439.                      dst[i*4+1] = (GLubyte) rgba[i][GCOMP];
  1440.                      dst[i*4+2] = (GLubyte) rgba[i][BCOMP];
  1441.                      dst[i*4+3] = (GLubyte) rgba[i][ACOMP];
  1442.                   }
  1443.                   break;
  1444.                case GL_BGR_INTEGER_EXT:
  1445.                   for (i=0;i<n;i++) {
  1446.                      dst[i*3+0] = (GLubyte) rgba[i][BCOMP];
  1447.                      dst[i*3+1] = (GLubyte) rgba[i][GCOMP];
  1448.                      dst[i*3+2] = (GLubyte) rgba[i][RCOMP];
  1449.                   }
  1450.                   break;
  1451.                case GL_BGRA_INTEGER_EXT:
  1452.                   for (i=0;i<n;i++) {
  1453.                      dst[i*4+0] = (GLubyte) rgba[i][BCOMP];
  1454.                      dst[i*4+1] = (GLubyte) rgba[i][GCOMP];
  1455.                      dst[i*4+2] = (GLubyte) rgba[i][RCOMP];
  1456.                      dst[i*4+3] = (GLubyte) rgba[i][ACOMP];
  1457.                   }
  1458.                   break;
  1459.                case GL_LUMINANCE_INTEGER_EXT:
  1460.                   for (i=0;i<n;i++) {
  1461.                      dst[i*2+0] = (GLubyte) (rgba[i][RCOMP] +
  1462.                                              rgba[i][GCOMP] +
  1463.                                              rgba[i][BCOMP]);
  1464.                      dst[i*2+1] = (GLubyte) rgba[i][ACOMP];
  1465.                   }
  1466.                   break;
  1467.                case GL_LUMINANCE_ALPHA_INTEGER_EXT:
  1468.                   for (i=0;i<n;i++) {
  1469.                      dst[i] = (GLubyte) (rgba[i][RCOMP] +
  1470.                                          rgba[i][GCOMP] +
  1471.                                          rgba[i][BCOMP]);
  1472.                   }
  1473.                   break;
  1474.                case GL_DUDV_ATI:
  1475.                case GL_DU8DV8_ATI:
  1476.                   for (i=0;i<n;i++) {
  1477.                      dst[i*2+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
  1478.                      dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
  1479.                   }
  1480.                   break;
  1481.                default:
  1482.                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
  1483.             }
  1484.          }
  1485.          break;
  1486.       case GL_BYTE:
  1487.          {
  1488.             GLbyte *dst = (GLbyte *) dstAddr;
  1489.             switch (dstFormat) {
  1490.                case GL_RED:
  1491.                   for (i=0;i<n;i++)
  1492.                      dst[i] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
  1493.                   break;
  1494.                case GL_GREEN:
  1495.                   for (i=0;i<n;i++)
  1496.                      dst[i] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
  1497.                   break;
  1498.                case GL_BLUE:
  1499.                   for (i=0;i<n;i++)
  1500.                      dst[i] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
  1501.                   break;
  1502.                case GL_ALPHA:
  1503.                   for (i=0;i<n;i++)
  1504.                      dst[i] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
  1505.                   break;
  1506.                case GL_LUMINANCE:
  1507.                   for (i=0;i<n;i++)
  1508.                      dst[i] = FLOAT_TO_BYTE(luminance[i]);
  1509.                   break;
  1510.                case GL_LUMINANCE_ALPHA:
  1511.                   for (i=0;i<n;i++) {
  1512.                      dst[i*2+0] = FLOAT_TO_BYTE(luminance[i]);
  1513.                      dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
  1514.                   }
  1515.                   break;
  1516.                case GL_RG:
  1517.                   for (i=0;i<n;i++) {
  1518.                      dst[i*2+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
  1519.                      dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
  1520.                   }
  1521.                   break;
  1522.                case GL_RGB:
  1523.                   for (i=0;i<n;i++) {
  1524.                      dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
  1525.                      dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
  1526.                      dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
  1527.                   }
  1528.                   break;
  1529.                case GL_RGBA:
  1530.                   for (i=0;i<n;i++) {
  1531.                      dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
  1532.                      dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
  1533.                      dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
  1534.                      dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
  1535.                   }
  1536.                   break;
  1537.                case GL_BGR:
  1538.                   for (i=0;i<n;i++) {
  1539.                      dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
  1540.                      dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
  1541.                      dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
  1542.                   }
  1543.                   break;
  1544.                case GL_BGRA:
  1545.                   for (i=0;i<n;i++) {
  1546.                      dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
  1547.                      dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
  1548.                      dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
  1549.                      dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
  1550.                   }
  1551.                   break;
  1552.                case GL_ABGR_EXT:
  1553.                   for (i=0;i<n;i++) {
  1554.                      dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
  1555.                      dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
  1556.                      dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
  1557.                      dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
  1558.                   }
  1559.                   break;
  1560.                case GL_RED_INTEGER_EXT:
  1561.                   for (i=0;i<n;i++) {
  1562.                      dst[i] = (GLbyte) rgba[i][RCOMP];
  1563.                   }
  1564.                   break;
  1565.                case GL_GREEN_INTEGER_EXT:
  1566.                   for (i=0;i<n;i++) {
  1567.                      dst[i] = (GLbyte) rgba[i][GCOMP];
  1568.                   }
  1569.                   break;
  1570.                case GL_BLUE_INTEGER_EXT:
  1571.                   for (i=0;i<n;i++) {
  1572.                      dst[i] = (GLbyte) rgba[i][BCOMP];
  1573.                   }
  1574.                   break;
  1575.                case GL_ALPHA_INTEGER_EXT:
  1576.                   for (i=0;i<n;i++) {
  1577.                      dst[i] = (GLbyte) rgba[i][ACOMP];
  1578.                   }
  1579.                   break;
  1580.                case GL_RG_INTEGER:
  1581.                   for (i=0;i<n;i++) {
  1582.                      dst[i*2+0] = (GLbyte) rgba[i][RCOMP];
  1583.                      dst[i*2+1] = (GLbyte) rgba[i][GCOMP];
  1584.                   }
  1585.                   break;
  1586.                case GL_RGB_INTEGER_EXT:
  1587.                   for (i=0;i<n;i++) {
  1588.                      dst[i*3+0] = (GLbyte) rgba[i][RCOMP];
  1589.                      dst[i*3+1] = (GLbyte) rgba[i][GCOMP];
  1590.                      dst[i*3+2] = (GLbyte) rgba[i][BCOMP];
  1591.                   }
  1592.                   break;
  1593.                case GL_RGBA_INTEGER_EXT:
  1594.                   for (i=0;i<n;i++) {
  1595.                      dst[i*4+0] = (GLbyte) rgba[i][RCOMP];
  1596.                      dst[i*4+1] = (GLbyte) rgba[i][GCOMP];
  1597.                      dst[i*4+2] = (GLbyte) rgba[i][BCOMP];
  1598.                      dst[i*4+3] = (GLbyte) rgba[i][ACOMP];
  1599.                   }
  1600.                   break;
  1601.                case GL_BGR_INTEGER_EXT:
  1602.                   for (i=0;i<n;i++) {
  1603.                      dst[i*3+0] = (GLbyte) rgba[i][BCOMP];
  1604.                      dst[i*3+1] = (GLbyte) rgba[i][GCOMP];
  1605.                      dst[i*3+2] = (GLbyte) rgba[i][RCOMP];
  1606.                   }
  1607.                   break;
  1608.                case GL_BGRA_INTEGER_EXT:
  1609.                   for (i=0;i<n;i++) {
  1610.                      dst[i*4+0] = (GLbyte) rgba[i][BCOMP];
  1611.                      dst[i*4+1] = (GLbyte) rgba[i][GCOMP];
  1612.                      dst[i*4+2] = (GLbyte) rgba[i][RCOMP];
  1613.                      dst[i*4+3] = (GLbyte) rgba[i][ACOMP];
  1614.                   }
  1615.                   break;
  1616.                case GL_LUMINANCE_INTEGER_EXT:
  1617.                   for (i=0;i<n;i++) {
  1618.                      dst[i*2+0] = (GLbyte) (rgba[i][RCOMP] +
  1619.                                             rgba[i][GCOMP] +
  1620.                                             rgba[i][BCOMP]);
  1621.                      dst[i*2+1] = (GLbyte) rgba[i][ACOMP];
  1622.                   }
  1623.                   break;
  1624.                case GL_LUMINANCE_ALPHA_INTEGER_EXT:
  1625.                   for (i=0;i<n;i++) {
  1626.                      dst[i] = (GLbyte) (rgba[i][RCOMP] +
  1627.                                         rgba[i][GCOMP] +
  1628.                                         rgba[i][BCOMP]);
  1629.                   }
  1630.                   break;
  1631.                case GL_DUDV_ATI:
  1632.                case GL_DU8DV8_ATI:
  1633.                   for (i=0;i<n;i++) {
  1634.                      dst[i*2+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
  1635.                      dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
  1636.                   }
  1637.                   break;
  1638.                default:
  1639.                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
  1640.             }
  1641.          }
  1642.          break;
  1643.       case GL_UNSIGNED_SHORT:
  1644.          {
  1645.             GLushort *dst = (GLushort *) dstAddr;
  1646.             switch (dstFormat) {
  1647.                case GL_RED:
  1648.                   for (i=0;i<n;i++)
  1649.                      CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][RCOMP]);
  1650.                   break;
  1651.                case GL_GREEN:
  1652.                   for (i=0;i<n;i++)
  1653.                      CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][GCOMP]);
  1654.                   break;
  1655.                case GL_BLUE:
  1656.                   for (i=0;i<n;i++)
  1657.                      CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][BCOMP]);
  1658.                   break;
  1659.                case GL_ALPHA:
  1660.                   for (i=0;i<n;i++)
  1661.                      CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][ACOMP]);
  1662.                   break;
  1663.                case GL_LUMINANCE:
  1664.                   for (i=0;i<n;i++)
  1665.                      UNCLAMPED_FLOAT_TO_USHORT(dst[i], luminance[i]);
  1666.                   break;
  1667.                case GL_LUMINANCE_ALPHA:
  1668.                   for (i=0;i<n;i++) {
  1669.                      UNCLAMPED_FLOAT_TO_USHORT(dst[i*2+0], luminance[i]);
  1670.                      CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][ACOMP]);
  1671.                   }
  1672.                   break;
  1673.                case GL_RG:
  1674.                   for (i=0;i<n;i++) {
  1675.                      CLAMPED_FLOAT_TO_USHORT(dst[i*2+0], rgba[i][RCOMP]);
  1676.                      CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][GCOMP]);
  1677.                   }
  1678.                   break;
  1679.                case GL_RGB:
  1680.                   for (i=0;i<n;i++) {
  1681.                      CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][RCOMP]);
  1682.                      CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);
  1683.                      CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][BCOMP]);
  1684.                   }
  1685.                   break;
  1686.                case GL_RGBA:
  1687.                   for (i=0;i<n;i++) {
  1688.                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][RCOMP]);
  1689.                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);
  1690.                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][BCOMP]);
  1691.                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);
  1692.                   }
  1693.                   break;
  1694.                case GL_BGR:
  1695.                   for (i=0;i<n;i++) {
  1696.                      CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][BCOMP]);
  1697.                      CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);
  1698.                      CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][RCOMP]);
  1699.                   }
  1700.                   break;
  1701.                case GL_BGRA:
  1702.                   for (i=0;i<n;i++) {
  1703.                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][BCOMP]);
  1704.                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);
  1705.                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][RCOMP]);
  1706.                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);
  1707.                   }
  1708.                   break;
  1709.                case GL_ABGR_EXT:
  1710.                   for (i=0;i<n;i++) {
  1711.                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][ACOMP]);
  1712.                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][BCOMP]);
  1713.                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][GCOMP]);
  1714.                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][RCOMP]);
  1715.                   }
  1716.                   break;
  1717.                case GL_RED_INTEGER_EXT:
  1718.                   for (i=0;i<n;i++) {
  1719.                      dst[i] = (GLushort) rgba[i][RCOMP];
  1720.                   }
  1721.                   break;
  1722.                case GL_GREEN_INTEGER_EXT:
  1723.                   for (i=0;i<n;i++) {
  1724.                      dst[i] = (GLushort) rgba[i][GCOMP];
  1725.                   }
  1726.                   break;
  1727.                case GL_BLUE_INTEGER_EXT:
  1728.                   for (i=0;i<n;i++) {
  1729.                      dst[i] = (GLushort) rgba[i][BCOMP];
  1730.                   }
  1731.                   break;
  1732.                case GL_ALPHA_INTEGER_EXT:
  1733.                   for (i=0;i<n;i++) {
  1734.                      dst[i] = (GLushort) rgba[i][ACOMP];
  1735.                   }
  1736.                   break;
  1737.                case GL_RG_INTEGER:
  1738.                   for (i=0;i<n;i++) {
  1739.                      dst[i*2+0] = (GLushort) rgba[i][RCOMP];
  1740.                      dst[i*2+1] = (GLushort) rgba[i][GCOMP];
  1741.                   }
  1742.                   break;
  1743.                case GL_RGB_INTEGER_EXT:
  1744.                   for (i=0;i<n;i++) {
  1745.                      dst[i*3+0] = (GLushort) rgba[i][RCOMP];
  1746.                      dst[i*3+1] = (GLushort) rgba[i][GCOMP];
  1747.                      dst[i*3+2] = (GLushort) rgba[i][BCOMP];
  1748.                   }
  1749.                   break;
  1750.                case GL_RGBA_INTEGER_EXT:
  1751.                   for (i=0;i<n;i++) {
  1752.                      dst[i*4+0] = (GLushort) rgba[i][RCOMP];
  1753.                      dst[i*4+1] = (GLushort) rgba[i][GCOMP];
  1754.                      dst[i*4+2] = (GLushort) rgba[i][BCOMP];
  1755.                      dst[i*4+3] = (GLushort) rgba[i][ACOMP];
  1756.                   }
  1757.                   break;
  1758.                case GL_BGR_INTEGER_EXT:
  1759.                   for (i=0;i<n;i++) {
  1760.                      dst[i*3+0] = (GLushort) rgba[i][BCOMP];
  1761.                      dst[i*3+1] = (GLushort) rgba[i][GCOMP];
  1762.                      dst[i*3+2] = (GLushort) rgba[i][RCOMP];
  1763.                   }
  1764.                   break;
  1765.                case GL_BGRA_INTEGER_EXT:
  1766.                   for (i=0;i<n;i++) {
  1767.                      dst[i*4+0] = (GLushort) rgba[i][BCOMP];
  1768.                      dst[i*4+1] = (GLushort) rgba[i][GCOMP];
  1769.                      dst[i*4+2] = (GLushort) rgba[i][RCOMP];
  1770.                      dst[i*4+3] = (GLushort) rgba[i][ACOMP];
  1771.                   }
  1772.                   break;
  1773.                case GL_LUMINANCE_INTEGER_EXT:
  1774.                   for (i=0;i<n;i++) {
  1775.                      dst[i*2+0] = (GLushort) (rgba[i][RCOMP] +
  1776.                                               rgba[i][GCOMP] +
  1777.                                               rgba[i][BCOMP]);
  1778.                      dst[i*2+1] = (GLushort) rgba[i][ACOMP];
  1779.                   }
  1780.                   break;
  1781.                case GL_LUMINANCE_ALPHA_INTEGER_EXT:
  1782.                   for (i=0;i<n;i++) {
  1783.                      dst[i] = (GLushort) (rgba[i][RCOMP] +
  1784.                                           rgba[i][GCOMP] +
  1785.                                           rgba[i][BCOMP]);
  1786.                   }
  1787.                   break;
  1788.                case GL_DUDV_ATI:
  1789.                case GL_DU8DV8_ATI:
  1790.                   for (i=0;i<n;i++) {
  1791.                      dst[i*2+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
  1792.                      dst[i*2+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
  1793.                   }
  1794.                   break;
  1795.                default:
  1796.                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
  1797.             }
  1798.          }
  1799.          break;
  1800.       case GL_SHORT:
  1801.          {
  1802.             GLshort *dst = (GLshort *) dstAddr;
  1803.             switch (dstFormat) {
  1804.                case GL_RED:
  1805.                   for (i=0;i<n;i++)
  1806.                      dst[i] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
  1807.                   break;
  1808.                case GL_GREEN:
  1809.                   for (i=0;i<n;i++)
  1810.                      dst[i] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
  1811.                   break;
  1812.                case GL_BLUE:
  1813.                   for (i=0;i<n;i++)
  1814.                      dst[i] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
  1815.                   break;
  1816.                case GL_ALPHA:
  1817.                   for (i=0;i<n;i++)
  1818.                      dst[i] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
  1819.                   break;
  1820.                case GL_LUMINANCE:
  1821.                   for (i=0;i<n;i++)
  1822.                      dst[i] = FLOAT_TO_SHORT(luminance[i]);
  1823.                   break;
  1824.                case GL_LUMINANCE_ALPHA:
  1825.                   for (i=0;i<n;i++) {
  1826.                      dst[i*2+0] = FLOAT_TO_SHORT(luminance[i]);
  1827.                      dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
  1828.                   }
  1829.                   break;
  1830.                case GL_RG:
  1831.                   for (i=0;i<n;i++) {
  1832.                      dst[i*2+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
  1833.                      dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
  1834.                   }
  1835.                   break;
  1836.                case GL_RGB:
  1837.                   for (i=0;i<n;i++) {
  1838.                      dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
  1839.                      dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
  1840.                      dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
  1841.                   }
  1842.                   break;
  1843.                case GL_RGBA:
  1844.                   for (i=0;i<n;i++) {
  1845.                      dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
  1846.                      dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
  1847.                      dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
  1848.                      dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
  1849.                   }
  1850.                   break;
  1851.                case GL_BGR:
  1852.                   for (i=0;i<n;i++) {
  1853.                      dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
  1854.                      dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
  1855.                      dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
  1856.                   }
  1857.                   break;
  1858.                case GL_BGRA:
  1859.                   for (i=0;i<n;i++) {
  1860.                      dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
  1861.                      dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
  1862.                      dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
  1863.                      dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
  1864.                   }
  1865.                   break;
  1866.                case GL_ABGR_EXT:
  1867.                   for (i=0;i<n;i++) {
  1868.                      dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
  1869.                      dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
  1870.                      dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
  1871.                      dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
  1872.                   }
  1873.                   break;
  1874.                case GL_RED_INTEGER_EXT:
  1875.                   for (i=0;i<n;i++) {
  1876.                      dst[i] = (GLshort) rgba[i][RCOMP];
  1877.                   }
  1878.                   break;
  1879.                case GL_GREEN_INTEGER_EXT:
  1880.                   for (i=0;i<n;i++) {
  1881.                      dst[i] = (GLshort) rgba[i][GCOMP];
  1882.                   }
  1883.                   break;
  1884.                case GL_BLUE_INTEGER_EXT:
  1885.                   for (i=0;i<n;i++) {
  1886.                      dst[i] = (GLshort) rgba[i][BCOMP];
  1887.                   }
  1888.                   break;
  1889.                case GL_ALPHA_INTEGER_EXT:
  1890.                   for (i=0;i<n;i++) {
  1891.                      dst[i] = (GLshort) rgba[i][ACOMP];
  1892.                   }
  1893.                   break;
  1894.                case GL_RG_INTEGER:
  1895.                   for (i=0;i<n;i++) {
  1896.                      dst[i*2+0] = (GLshort) rgba[i][RCOMP];
  1897.                      dst[i*2+1] = (GLshort) rgba[i][GCOMP];
  1898.                   }
  1899.                   break;
  1900.                case GL_RGB_INTEGER_EXT:
  1901.                   for (i=0;i<n;i++) {
  1902.                      dst[i*3+0] = (GLshort) rgba[i][RCOMP];
  1903.                      dst[i*3+1] = (GLshort) rgba[i][GCOMP];
  1904.                      dst[i*3+2] = (GLshort) rgba[i][BCOMP];
  1905.                   }
  1906.                   break;
  1907.                case GL_RGBA_INTEGER_EXT:
  1908.                   for (i=0;i<n;i++) {
  1909.                      dst[i*4+0] = (GLshort) rgba[i][RCOMP];
  1910.                      dst[i*4+1] = (GLshort) rgba[i][GCOMP];
  1911.                      dst[i*4+2] = (GLshort) rgba[i][BCOMP];
  1912.                      dst[i*4+3] = (GLshort) rgba[i][ACOMP];
  1913.                   }
  1914.                   break;
  1915.                case GL_BGR_INTEGER_EXT:
  1916.                   for (i=0;i<n;i++) {
  1917.                      dst[i*3+0] = (GLshort) rgba[i][BCOMP];
  1918.                      dst[i*3+1] = (GLshort) rgba[i][GCOMP];
  1919.                      dst[i*3+2] = (GLshort) rgba[i][RCOMP];
  1920.                   }
  1921.                   break;
  1922.                case GL_BGRA_INTEGER_EXT:
  1923.                   for (i=0;i<n;i++) {
  1924.                      dst[i*4+0] = (GLshort) rgba[i][BCOMP];
  1925.                      dst[i*4+1] = (GLshort) rgba[i][GCOMP];
  1926.                      dst[i*4+2] = (GLshort) rgba[i][RCOMP];
  1927.                      dst[i*4+3] = (GLshort) rgba[i][ACOMP];
  1928.                   }
  1929.                   break;
  1930.                case GL_LUMINANCE_INTEGER_EXT:
  1931.                   for (i=0;i<n;i++) {
  1932.                      dst[i*2+0] = (GLshort) (rgba[i][RCOMP] +
  1933.                                              rgba[i][GCOMP] +
  1934.                                              rgba[i][BCOMP]);
  1935.                      dst[i*2+1] = (GLshort) rgba[i][ACOMP];
  1936.                   }
  1937.                   break;
  1938.                case GL_LUMINANCE_ALPHA_INTEGER_EXT:
  1939.                   for (i=0;i<n;i++) {
  1940.                      dst[i] = (GLshort) (rgba[i][RCOMP] +
  1941.                                          rgba[i][GCOMP] +
  1942.                                          rgba[i][BCOMP]);
  1943.                   }
  1944.                   break;
  1945.                case GL_DUDV_ATI:
  1946.                case GL_DU8DV8_ATI:
  1947.                   for (i=0;i<n;i++) {
  1948.                      dst[i*2+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
  1949.                      dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
  1950.                   }
  1951.                   break;
  1952.                default:
  1953.                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
  1954.             }
  1955.          }
  1956.          break;
  1957.       case GL_UNSIGNED_INT:
  1958.          {
  1959.             GLuint *dst = (GLuint *) dstAddr;
  1960.             switch (dstFormat) {
  1961.                case GL_RED:
  1962.                   for (i=0;i<n;i++)
  1963.                      dst[i] = FLOAT_TO_UINT(rgba[i][RCOMP]);
  1964.                   break;
  1965.                case GL_GREEN:
  1966.                   for (i=0;i<n;i++)
  1967.                      dst[i] = FLOAT_TO_UINT(rgba[i][GCOMP]);
  1968.                   break;
  1969.                case GL_BLUE:
  1970.                   for (i=0;i<n;i++)
  1971.                      dst[i] = FLOAT_TO_UINT(rgba[i][BCOMP]);
  1972.                   break;
  1973.                case GL_ALPHA:
  1974.                   for (i=0;i<n;i++)
  1975.                      dst[i] = FLOAT_TO_UINT(rgba[i][ACOMP]);
  1976.                   break;
  1977.                case GL_LUMINANCE:
  1978.                   for (i=0;i<n;i++)
  1979.                      dst[i] = FLOAT_TO_UINT(luminance[i]);
  1980.                   break;
  1981.                case GL_LUMINANCE_ALPHA:
  1982.                   for (i=0;i<n;i++) {
  1983.                      dst[i*2+0] = FLOAT_TO_UINT(luminance[i]);
  1984.                      dst[i*2+1] = FLOAT_TO_UINT(rgba[i][ACOMP]);
  1985.                   }
  1986.                   break;
  1987.                case GL_RG:
  1988.                   for (i=0;i<n;i++) {
  1989.                      dst[i*2+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
  1990.                      dst[i*2+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
  1991.                   }
  1992.                   break;
  1993.                case GL_RGB:
  1994.                   for (i=0;i<n;i++) {
  1995.                      dst[i*3+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
  1996.                      dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
  1997.                      dst[i*3+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
  1998.                   }
  1999.                   break;
  2000.                case GL_RGBA:
  2001.                   for (i=0;i<n;i++) {
  2002.                      dst[i*4+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
  2003.                      dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
  2004.                      dst[i*4+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
  2005.                      dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
  2006.                   }
  2007.                   break;
  2008.                case GL_BGR:
  2009.                   for (i=0;i<n;i++) {
  2010.                      dst[i*3+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
  2011.                      dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
  2012.                      dst[i*3+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
  2013.                   }
  2014.                   break;
  2015.                case GL_BGRA:
  2016.                   for (i=0;i<n;i++) {
  2017.                      dst[i*4+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
  2018.                      dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
  2019.                      dst[i*4+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
  2020.                      dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
  2021.                   }
  2022.                   break;
  2023.                case GL_ABGR_EXT:
  2024.                   for (i=0;i<n;i++) {
  2025.                      dst[i*4+0] = FLOAT_TO_UINT(rgba[i][ACOMP]);
  2026.                      dst[i*4+1] = FLOAT_TO_UINT(rgba[i][BCOMP]);
  2027.                      dst[i*4+2] = FLOAT_TO_UINT(rgba[i][GCOMP]);
  2028.                      dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]);
  2029.                   }
  2030.                   break;
  2031.                case GL_RED_INTEGER_EXT:
  2032.                   for (i=0;i<n;i++) {
  2033.                      dst[i] = (GLuint) rgba[i][RCOMP];
  2034.                   }
  2035.                   break;
  2036.                case GL_GREEN_INTEGER_EXT:
  2037.                   for (i=0;i<n;i++) {
  2038.                      dst[i] = (GLuint) rgba[i][GCOMP];
  2039.                   }
  2040.                   break;
  2041.                case GL_BLUE_INTEGER_EXT:
  2042.                   for (i=0;i<n;i++) {
  2043.                      dst[i] = (GLuint) rgba[i][BCOMP];
  2044.                   }
  2045.                   break;
  2046.                case GL_ALPHA_INTEGER_EXT:
  2047.                   for (i=0;i<n;i++) {
  2048.                      dst[i] = (GLuint) rgba[i][ACOMP];
  2049.                   }
  2050.                   break;
  2051.                case GL_RG_INTEGER:
  2052.                   for (i=0;i<n;i++) {
  2053.                      dst[i*2+0] = (GLuint) rgba[i][RCOMP];
  2054.                      dst[i*2+1] = (GLuint) rgba[i][GCOMP];
  2055.                   }
  2056.                   break;
  2057.                case GL_RGB_INTEGER_EXT:
  2058.                   for (i=0;i<n;i++) {
  2059.                      dst[i*3+0] = (GLuint) rgba[i][RCOMP];
  2060.                      dst[i*3+1] = (GLuint) rgba[i][GCOMP];
  2061.                      dst[i*3+2] = (GLuint) rgba[i][BCOMP];
  2062.                   }
  2063.                   break;
  2064.                case GL_RGBA_INTEGER_EXT:
  2065.                   for (i=0;i<n;i++) {
  2066.                      dst[i*4+0] = (GLuint) rgba[i][RCOMP];
  2067.                      dst[i*4+1] = (GLuint) rgba[i][GCOMP];
  2068.                      dst[i*4+2] = (GLuint) rgba[i][BCOMP];
  2069.                      dst[i*4+3] = (GLuint) rgba[i][ACOMP];
  2070.                   }
  2071.                   break;
  2072.                case GL_BGR_INTEGER_EXT:
  2073.                   for (i=0;i<n;i++) {
  2074.                      dst[i*3+0] = (GLuint) rgba[i][BCOMP];
  2075.                      dst[i*3+1] = (GLuint) rgba[i][GCOMP];
  2076.                      dst[i*3+2] = (GLuint) rgba[i][RCOMP];
  2077.                   }
  2078.                   break;
  2079.                case GL_BGRA_INTEGER_EXT:
  2080.                   for (i=0;i<n;i++) {
  2081.                      dst[i*4+0] = (GLuint) rgba[i][BCOMP];
  2082.                      dst[i*4+1] = (GLuint) rgba[i][GCOMP];
  2083.                      dst[i*4+2] = (GLuint) rgba[i][RCOMP];
  2084.                      dst[i*4+3] = (GLuint) rgba[i][ACOMP];
  2085.                   }
  2086.                   break;
  2087.                case GL_LUMINANCE_INTEGER_EXT:
  2088.                   for (i=0;i<n;i++) {
  2089.                      dst[i*2+0] = (GLuint) (rgba[i][RCOMP] +
  2090.                                             rgba[i][GCOMP] +
  2091.                                             rgba[i][BCOMP]);
  2092.                      dst[i*2+1] = (GLuint) rgba[i][ACOMP];
  2093.                   }
  2094.                   break;
  2095.                case GL_LUMINANCE_ALPHA_INTEGER_EXT:
  2096.                   for (i=0;i<n;i++) {
  2097.                      dst[i] = (GLuint) (rgba[i][RCOMP] +
  2098.                                         rgba[i][GCOMP] +
  2099.                                         rgba[i][BCOMP]);
  2100.                   }
  2101.                   break;
  2102.                case GL_DUDV_ATI:
  2103.                case GL_DU8DV8_ATI:
  2104.                   for (i=0;i<n;i++) {
  2105.                      dst[i*2+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
  2106.                      dst[i*2+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
  2107.                   }
  2108.                   break;
  2109.                default:
  2110.                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
  2111.             }
  2112.          }
  2113.          break;
  2114.       case GL_INT:
  2115.          {
  2116.             GLint *dst = (GLint *) dstAddr;
  2117.             switch (dstFormat) {
  2118.                case GL_RED:
  2119.                   for (i=0;i<n;i++)
  2120.                      dst[i] = FLOAT_TO_INT(rgba[i][RCOMP]);
  2121.                   break;
  2122.                case GL_GREEN:
  2123.                   for (i=0;i<n;i++)
  2124.                      dst[i] = FLOAT_TO_INT(rgba[i][GCOMP]);
  2125.                   break;
  2126.                case GL_BLUE:
  2127.                   for (i=0;i<n;i++)
  2128.                      dst[i] = FLOAT_TO_INT(rgba[i][BCOMP]);
  2129.                   break;
  2130.                case GL_ALPHA:
  2131.                   for (i=0;i<n;i++)
  2132.                      dst[i] = FLOAT_TO_INT(rgba[i][ACOMP]);
  2133.                   break;
  2134.                case GL_LUMINANCE:
  2135.                   for (i=0;i<n;i++)
  2136.                      dst[i] = FLOAT_TO_INT(luminance[i]);
  2137.                   break;
  2138.                case GL_LUMINANCE_ALPHA:
  2139.                   for (i=0;i<n;i++) {
  2140.                      dst[i*2+0] = FLOAT_TO_INT(luminance[i]);
  2141.                      dst[i*2+1] = FLOAT_TO_INT(rgba[i][ACOMP]);
  2142.                   }
  2143.                   break;
  2144.                case GL_RG:
  2145.                   for (i=0;i<n;i++) {
  2146.                      dst[i*2+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
  2147.                      dst[i*2+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
  2148.                   }
  2149.                   break;
  2150.                case GL_RGB:
  2151.                   for (i=0;i<n;i++) {
  2152.                      dst[i*3+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
  2153.                      dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
  2154.                      dst[i*3+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
  2155.                   }
  2156.                   break;
  2157.                case GL_RGBA:
  2158.                   for (i=0;i<n;i++) {
  2159.                      dst[i*4+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
  2160.                      dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
  2161.                      dst[i*4+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
  2162.                      dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
  2163.                   }
  2164.                   break;
  2165.                case GL_BGR:
  2166.                   for (i=0;i<n;i++) {
  2167.                      dst[i*3+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
  2168.                      dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
  2169.                      dst[i*3+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
  2170.                   }
  2171.                   break;
  2172.                case GL_BGRA:
  2173.                   for (i=0;i<n;i++) {
  2174.                      dst[i*4+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
  2175.                      dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
  2176.                      dst[i*4+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
  2177.                      dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
  2178.                   }
  2179.                   break;
  2180.                case GL_ABGR_EXT:
  2181.                   for (i=0;i<n;i++) {
  2182.                      dst[i*4+0] = FLOAT_TO_INT(rgba[i][ACOMP]);
  2183.                      dst[i*4+1] = FLOAT_TO_INT(rgba[i][BCOMP]);
  2184.                      dst[i*4+2] = FLOAT_TO_INT(rgba[i][GCOMP]);
  2185.                      dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]);
  2186.                   }
  2187.                   break;
  2188.                case GL_DUDV_ATI:
  2189.                case GL_DU8DV8_ATI:
  2190.                   for (i=0;i<n;i++) {
  2191.                      dst[i*2+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
  2192.                      dst[i*2+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
  2193.                   }
  2194.                   break;
  2195.                case GL_RED_INTEGER_EXT:
  2196.                   for (i=0;i<n;i++) {
  2197.                      dst[i] = (GLint) rgba[i][RCOMP];
  2198.                   }
  2199.                   break;
  2200.                case GL_GREEN_INTEGER_EXT:
  2201.                   for (i=0;i<n;i++) {
  2202.                      dst[i] = (GLint) rgba[i][GCOMP];
  2203.                   }
  2204.                   break;
  2205.                case GL_BLUE_INTEGER_EXT:
  2206.                   for (i=0;i<n;i++) {
  2207.                      dst[i] = (GLint) rgba[i][BCOMP];
  2208.                   }
  2209.                   break;
  2210.                case GL_ALPHA_INTEGER_EXT:
  2211.                   for (i=0;i<n;i++) {
  2212.                      dst[i] = (GLint) rgba[i][ACOMP];
  2213.                   }
  2214.                   break;
  2215.                case GL_RG_INTEGER:
  2216.                   for (i=0;i<n;i++) {
  2217.                      dst[i*2+0] = (GLint) rgba[i][RCOMP];
  2218.                      dst[i*2+1] = (GLint) rgba[i][GCOMP];
  2219.                   }
  2220.                   break;
  2221.                case GL_RGB_INTEGER_EXT:
  2222.                   for (i=0;i<n;i++) {
  2223.                      dst[i*3+0] = (GLint) rgba[i][RCOMP];
  2224.                      dst[i*3+1] = (GLint) rgba[i][GCOMP];
  2225.                      dst[i*3+2] = (GLint) rgba[i][BCOMP];
  2226.                   }
  2227.                   break;
  2228.                case GL_RGBA_INTEGER_EXT:
  2229.                   for (i=0;i<n;i++) {
  2230.                      dst[i*4+0] = (GLint) rgba[i][RCOMP];
  2231.                      dst[i*4+1] = (GLint) rgba[i][GCOMP];
  2232.                      dst[i*4+2] = (GLint) rgba[i][BCOMP];
  2233.                      dst[i*4+3] = (GLint) rgba[i][ACOMP];
  2234.                   }
  2235.                   break;
  2236.                case GL_BGR_INTEGER_EXT:
  2237.                   for (i=0;i<n;i++) {
  2238.                      dst[i*3+0] = (GLint) rgba[i][BCOMP];
  2239.                      dst[i*3+1] = (GLint) rgba[i][GCOMP];
  2240.                      dst[i*3+2] = (GLint) rgba[i][RCOMP];
  2241.                   }
  2242.                   break;
  2243.                case GL_BGRA_INTEGER_EXT:
  2244.                   for (i=0;i<n;i++) {
  2245.                      dst[i*4+0] = (GLint) rgba[i][BCOMP];
  2246.                      dst[i*4+1] = (GLint) rgba[i][GCOMP];
  2247.                      dst[i*4+2] = (GLint) rgba[i][RCOMP];
  2248.                      dst[i*4+3] = (GLint) rgba[i][ACOMP];
  2249.                   }
  2250.                   break;
  2251.                case GL_LUMINANCE_INTEGER_EXT:
  2252.                   for (i=0;i<n;i++) {
  2253.                      dst[i*2+0] = (GLint) (rgba[i][RCOMP] +
  2254.                                            rgba[i][GCOMP] +
  2255.                                            rgba[i][BCOMP]);
  2256.                      dst[i*2+1] = (GLint) rgba[i][ACOMP];
  2257.                   }
  2258.                   break;
  2259.                case GL_LUMINANCE_ALPHA_INTEGER_EXT:
  2260.                   for (i=0;i<n;i++) {
  2261.                      dst[i] = (GLint) (rgba[i][RCOMP] +
  2262.                                        rgba[i][GCOMP] +
  2263.                                        rgba[i][BCOMP]);
  2264.                   }
  2265.                   break;
  2266.                default:
  2267.                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
  2268.             }
  2269.          }
  2270.          break;
  2271.       case GL_FLOAT:
  2272.          {
  2273.             GLfloat *dst = (GLfloat *) dstAddr;
  2274.             switch (dstFormat) {
  2275.                case GL_RED:
  2276.                   for (i=0;i<n;i++)
  2277.                      dst[i] = rgba[i][RCOMP];
  2278.                   break;
  2279.                case GL_GREEN:
  2280.                   for (i=0;i<n;i++)
  2281.                      dst[i] = rgba[i][GCOMP];
  2282.                   break;
  2283.                case GL_BLUE:
  2284.                   for (i=0;i<n;i++)
  2285.                      dst[i] = rgba[i][BCOMP];
  2286.                   break;
  2287.                case GL_ALPHA:
  2288.                   for (i=0;i<n;i++)
  2289.                      dst[i] = rgba[i][ACOMP];
  2290.                   break;
  2291.                case GL_LUMINANCE:
  2292.                   for (i=0;i<n;i++)
  2293.                      dst[i] = luminance[i];
  2294.                   break;
  2295.                case GL_LUMINANCE_ALPHA:
  2296.                   for (i=0;i<n;i++) {
  2297.                      dst[i*2+0] = luminance[i];
  2298.                      dst[i*2+1] = rgba[i][ACOMP];
  2299.                   }
  2300.                   break;
  2301.                case GL_RG:
  2302.                   for (i=0;i<n;i++) {
  2303.                      dst[i*2+0] = rgba[i][RCOMP];
  2304.                      dst[i*2+1] = rgba[i][GCOMP];
  2305.                   }
  2306.                   break;
  2307.                case GL_RGB:
  2308.                   for (i=0;i<n;i++) {
  2309.                      dst[i*3+0] = rgba[i][RCOMP];
  2310.                      dst[i*3+1] = rgba[i][GCOMP];
  2311.                      dst[i*3+2] = rgba[i][BCOMP];
  2312.                   }
  2313.                   break;
  2314.                case GL_RGBA:
  2315.                   for (i=0;i<n;i++) {
  2316.                      dst[i*4+0] = rgba[i][RCOMP];
  2317.                      dst[i*4+1] = rgba[i][GCOMP];
  2318.                      dst[i*4+2] = rgba[i][BCOMP];
  2319.                      dst[i*4+3] = rgba[i][ACOMP];
  2320.                   }
  2321.                   break;
  2322.                case GL_BGR:
  2323.                   for (i=0;i<n;i++) {
  2324.                      dst[i*3+0] = rgba[i][BCOMP];
  2325.                      dst[i*3+1] = rgba[i][GCOMP];
  2326.                      dst[i*3+2] = rgba[i][RCOMP];
  2327.                   }
  2328.                   break;
  2329.                case GL_BGRA:
  2330.                   for (i=0;i<n;i++) {
  2331.                      dst[i*4+0] = rgba[i][BCOMP];
  2332.                      dst[i*4+1] = rgba[i][GCOMP];
  2333.                      dst[i*4+2] = rgba[i][RCOMP];
  2334.                      dst[i*4+3] = rgba[i][ACOMP];
  2335.                   }
  2336.                   break;
  2337.                case GL_ABGR_EXT:
  2338.                   for (i=0;i<n;i++) {
  2339.                      dst[i*4+0] = rgba[i][ACOMP];
  2340.                      dst[i*4+1] = rgba[i][BCOMP];
  2341.                      dst[i*4+2] = rgba[i][GCOMP];
  2342.                      dst[i*4+3] = rgba[i][RCOMP];
  2343.                   }
  2344.                   break;
  2345.                case GL_DUDV_ATI:
  2346.                case GL_DU8DV8_ATI:
  2347.                   for (i=0;i<n;i++) {
  2348.                      dst[i*2+0] = rgba[i][RCOMP];
  2349.                      dst[i*2+1] = rgba[i][GCOMP];
  2350.                   }
  2351.                   break;
  2352.                default:
  2353.                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
  2354.             }
  2355.          }
  2356.          break;
  2357.       case GL_HALF_FLOAT_ARB:
  2358.          {
  2359.             GLhalfARB *dst = (GLhalfARB *) dstAddr;
  2360.             switch (dstFormat) {
  2361.                case GL_RED:
  2362.                   for (i=0;i<n;i++)
  2363.                      dst[i] = _mesa_float_to_half(rgba[i][RCOMP]);
  2364.                   break;
  2365.                case GL_GREEN:
  2366.                   for (i=0;i<n;i++)
  2367.                      dst[i] = _mesa_float_to_half(rgba[i][GCOMP]);
  2368.                   break;
  2369.                case GL_BLUE:
  2370.                   for (i=0;i<n;i++)
  2371.                      dst[i] = _mesa_float_to_half(rgba[i][BCOMP]);
  2372.                   break;
  2373.                case GL_ALPHA:
  2374.                   for (i=0;i<n;i++)
  2375.                      dst[i] = _mesa_float_to_half(rgba[i][ACOMP]);
  2376.                   break;
  2377.                case GL_LUMINANCE:
  2378.                   for (i=0;i<n;i++)
  2379.                      dst[i] = _mesa_float_to_half(luminance[i]);
  2380.                   break;
  2381.                case GL_LUMINANCE_ALPHA:
  2382.                   for (i=0;i<n;i++) {
  2383.                      dst[i*2+0] = _mesa_float_to_half(luminance[i]);
  2384.                      dst[i*2+1] = _mesa_float_to_half(rgba[i][ACOMP]);
  2385.                   }
  2386.                   break;
  2387.                case GL_RG:
  2388.                   for (i=0;i<n;i++) {
  2389.                      dst[i*2+0] = _mesa_float_to_half(rgba[i][RCOMP]);
  2390.                      dst[i*2+1] = _mesa_float_to_half(rgba[i][GCOMP]);
  2391.                   }
  2392.                   break;
  2393.                case GL_RGB:
  2394.                   for (i=0;i<n;i++) {
  2395.                      dst[i*3+0] = _mesa_float_to_half(rgba[i][RCOMP]);
  2396.                      dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
  2397.                      dst[i*3+2] = _mesa_float_to_half(rgba[i][BCOMP]);
  2398.                   }
  2399.                   break;
  2400.                case GL_RGBA:
  2401.                   for (i=0;i<n;i++) {
  2402.                      dst[i*4+0] = _mesa_float_to_half(rgba[i][RCOMP]);
  2403.                      dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
  2404.                      dst[i*4+2] = _mesa_float_to_half(rgba[i][BCOMP]);
  2405.                      dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
  2406.                   }
  2407.                   break;
  2408.                case GL_BGR:
  2409.                   for (i=0;i<n;i++) {
  2410.                      dst[i*3+0] = _mesa_float_to_half(rgba[i][BCOMP]);
  2411.                      dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
  2412.                      dst[i*3+2] = _mesa_float_to_half(rgba[i][RCOMP]);
  2413.                   }
  2414.                   break;
  2415.                case GL_BGRA:
  2416.                   for (i=0;i<n;i++) {
  2417.                      dst[i*4+0] = _mesa_float_to_half(rgba[i][BCOMP]);
  2418.                      dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
  2419.                      dst[i*4+2] = _mesa_float_to_half(rgba[i][RCOMP]);
  2420.                      dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
  2421.                   }
  2422.                   break;
  2423.                case GL_ABGR_EXT:
  2424.                   for (i=0;i<n;i++) {
  2425.                      dst[i*4+0] = _mesa_float_to_half(rgba[i][ACOMP]);
  2426.                      dst[i*4+1] = _mesa_float_to_half(rgba[i][BCOMP]);
  2427.                      dst[i*4+2] = _mesa_float_to_half(rgba[i][GCOMP]);
  2428.                      dst[i*4+3] = _mesa_float_to_half(rgba[i][RCOMP]);
  2429.                   }
  2430.                   break;
  2431.                case GL_DUDV_ATI:
  2432.                case GL_DU8DV8_ATI:
  2433.                   for (i=0;i<n;i++) {
  2434.                      dst[i*2+0] = _mesa_float_to_half(rgba[i][RCOMP]);
  2435.                      dst[i*2+1] = _mesa_float_to_half(rgba[i][GCOMP]);
  2436.                   }
  2437.                   break;
  2438.                default:
  2439.                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
  2440.             }
  2441.          }
  2442.          break;
  2443.       case GL_UNSIGNED_BYTE_3_3_2:
  2444.          if (dstFormat == GL_RGB) {
  2445.             GLubyte *dst = (GLubyte *) dstAddr;
  2446.             for (i=0;i<n;i++) {
  2447.                dst[i] = (F_TO_I(rgba[i][RCOMP] * 7.0F) << 5)
  2448.                       | (F_TO_I(rgba[i][GCOMP] * 7.0F) << 2)
  2449.                       | (F_TO_I(rgba[i][BCOMP] * 3.0F)     );
  2450.             }
  2451.          }
  2452.          break;
  2453.       case GL_UNSIGNED_BYTE_2_3_3_REV:
  2454.          if (dstFormat == GL_RGB) {
  2455.             GLubyte *dst = (GLubyte *) dstAddr;
  2456.             for (i=0;i<n;i++) {
  2457.                dst[i] = (F_TO_I(rgba[i][RCOMP] * 7.0F)     )
  2458.                       | (F_TO_I(rgba[i][GCOMP] * 7.0F) << 3)
  2459.                       | (F_TO_I(rgba[i][BCOMP] * 3.0F) << 6);
  2460.             }
  2461.          }
  2462.          break;
  2463.       case GL_UNSIGNED_SHORT_5_6_5:
  2464.          if (dstFormat == GL_RGB) {
  2465.             GLushort *dst = (GLushort *) dstAddr;
  2466.             for (i=0;i<n;i++) {
  2467.                dst[i] = (F_TO_I(rgba[i][RCOMP] * 31.0F) << 11)
  2468.                       | (F_TO_I(rgba[i][GCOMP] * 63.0F) <<  5)
  2469.                       | (F_TO_I(rgba[i][BCOMP] * 31.0F)      );
  2470.             }
  2471.          }
  2472.          break;
  2473.       case GL_UNSIGNED_SHORT_5_6_5_REV:
  2474.          if (dstFormat == GL_RGB) {
  2475.             GLushort *dst = (GLushort *) dstAddr;
  2476.             for (i=0;i<n;i++) {
  2477.                dst[i] = (F_TO_I(rgba[i][RCOMP] * 31.0F)      )
  2478.                       | (F_TO_I(rgba[i][GCOMP] * 63.0F) <<  5)
  2479.                       | (F_TO_I(rgba[i][BCOMP] * 31.0F) << 11);
  2480.             }
  2481.          }
  2482.          break;
  2483.       case GL_UNSIGNED_SHORT_4_4_4_4:
  2484.          if (dstFormat == GL_RGBA) {
  2485.             GLushort *dst = (GLushort *) dstAddr;
  2486.             for (i=0;i<n;i++) {
  2487.                dst[i] = (F_TO_I(rgba[i][RCOMP] * 15.0F) << 12)
  2488.                       | (F_TO_I(rgba[i][GCOMP] * 15.0F) <<  8)
  2489.                       | (F_TO_I(rgba[i][BCOMP] * 15.0F) <<  4)
  2490.                       | (F_TO_I(rgba[i][ACOMP] * 15.0F)      );
  2491.             }
  2492.          }
  2493.          else if (dstFormat == GL_BGRA) {
  2494.             GLushort *dst = (GLushort *) dstAddr;
  2495.             for (i=0;i<n;i++) {
  2496.                dst[i] = (F_TO_I(rgba[i][BCOMP] * 15.0F) << 12)
  2497.                       | (F_TO_I(rgba[i][GCOMP] * 15.0F) <<  8)
  2498.                       | (F_TO_I(rgba[i][RCOMP] * 15.0F) <<  4)
  2499.                       | (F_TO_I(rgba[i][ACOMP] * 15.0F)      );
  2500.             }
  2501.          }
  2502.          else if (dstFormat == GL_ABGR_EXT) {
  2503.             GLushort *dst = (GLushort *) dstAddr;
  2504.             for (i=0;i<n;i++) {
  2505.                dst[i] = (F_TO_I(rgba[i][ACOMP] * 15.0F) << 12)
  2506.                       | (F_TO_I(rgba[i][BCOMP] * 15.0F) <<  8)
  2507.                       | (F_TO_I(rgba[i][GCOMP] * 15.0F) <<  4)
  2508.                       | (F_TO_I(rgba[i][RCOMP] * 15.0F)      );
  2509.             }
  2510.          }
  2511.          break;
  2512.       case GL_UNSIGNED_SHORT_4_4_4_4_REV:
  2513.          if (dstFormat == GL_RGBA) {
  2514.             GLushort *dst = (GLushort *) dstAddr;
  2515.             for (i=0;i<n;i++) {
  2516.                dst[i] = (F_TO_I(rgba[i][RCOMP] * 15.0F)      )
  2517.                       | (F_TO_I(rgba[i][GCOMP] * 15.0F) <<  4)
  2518.                       | (F_TO_I(rgba[i][BCOMP] * 15.0F) <<  8)
  2519.                       | (F_TO_I(rgba[i][ACOMP] * 15.0F) << 12);
  2520.             }
  2521.          }
  2522.          else if (dstFormat == GL_BGRA) {
  2523.             GLushort *dst = (GLushort *) dstAddr;
  2524.             for (i=0;i<n;i++) {
  2525.                dst[i] = (F_TO_I(rgba[i][BCOMP] * 15.0F)      )
  2526.                       | (F_TO_I(rgba[i][GCOMP] * 15.0F) <<  4)
  2527.                       | (F_TO_I(rgba[i][RCOMP] * 15.0F) <<  8)
  2528.                       | (F_TO_I(rgba[i][ACOMP] * 15.0F) << 12);
  2529.             }
  2530.          }
  2531.          else if (dstFormat == GL_ABGR_EXT) {
  2532.             GLushort *dst = (GLushort *) dstAddr;
  2533.             for (i=0;i<n;i++) {
  2534.                dst[i] = (F_TO_I(rgba[i][ACOMP] * 15.0F)      )
  2535.                       | (F_TO_I(rgba[i][BCOMP] * 15.0F) <<  4)
  2536.                       | (F_TO_I(rgba[i][GCOMP] * 15.0F) <<  8)
  2537.                       | (F_TO_I(rgba[i][RCOMP] * 15.0F) << 12);
  2538.             }
  2539.          }
  2540.          break;
  2541.       case GL_UNSIGNED_SHORT_5_5_5_1:
  2542.          if (dstFormat == GL_RGBA) {
  2543.             GLushort *dst = (GLushort *) dstAddr;
  2544.             for (i=0;i<n;i++) {
  2545.                dst[i] = (F_TO_I(rgba[i][RCOMP] * 31.0F) << 11)
  2546.                       | (F_TO_I(rgba[i][GCOMP] * 31.0F) <<  6)
  2547.                       | (F_TO_I(rgba[i][BCOMP] * 31.0F) <<  1)
  2548.                       | (F_TO_I(rgba[i][ACOMP] *  1.0F)      );
  2549.             }
  2550.          }
  2551.          else if (dstFormat == GL_BGRA) {
  2552.             GLushort *dst = (GLushort *) dstAddr;
  2553.             for (i=0;i<n;i++) {
  2554.                dst[i] = (F_TO_I(rgba[i][BCOMP] * 31.0F) << 11)
  2555.                       | (F_TO_I(rgba[i][GCOMP] * 31.0F) <<  6)
  2556.                       | (F_TO_I(rgba[i][RCOMP] * 31.0F) <<  1)
  2557.                       | (F_TO_I(rgba[i][ACOMP] *  1.0F)      );
  2558.             }
  2559.          }
  2560.          else if (dstFormat == GL_ABGR_EXT) {
  2561.             GLushort *dst = (GLushort *) dstAddr;
  2562.             for (i=0;i<n;i++) {
  2563.                dst[i] = (F_TO_I(rgba[i][ACOMP] * 31.0F) << 11)
  2564.                       | (F_TO_I(rgba[i][BCOMP] * 31.0F) <<  6)
  2565.                       | (F_TO_I(rgba[i][GCOMP] * 31.0F) <<  1)
  2566.                       | (F_TO_I(rgba[i][RCOMP] *  1.0F)      );
  2567.             }
  2568.          }
  2569.          break;
  2570.       case GL_UNSIGNED_SHORT_1_5_5_5_REV:
  2571.          if (dstFormat == GL_RGBA) {
  2572.             GLushort *dst = (GLushort *) dstAddr;
  2573.             for (i=0;i<n;i++) {
  2574.                dst[i] = (F_TO_I(rgba[i][RCOMP] * 31.0F)      )
  2575.                       | (F_TO_I(rgba[i][GCOMP] * 31.0F) <<  5)
  2576.                       | (F_TO_I(rgba[i][BCOMP] * 31.0F) << 10)
  2577.                       | (F_TO_I(rgba[i][ACOMP] *  1.0F) << 15);
  2578.             }
  2579.          }
  2580.          else if (dstFormat == GL_BGRA) {
  2581.             GLushort *dst = (GLushort *) dstAddr;
  2582.             for (i=0;i<n;i++) {
  2583.                dst[i] = (F_TO_I(rgba[i][BCOMP] * 31.0F)      )
  2584.                       | (F_TO_I(rgba[i][GCOMP] * 31.0F) <<  5)
  2585.                       | (F_TO_I(rgba[i][RCOMP] * 31.0F) << 10)
  2586.                       | (F_TO_I(rgba[i][ACOMP] *  1.0F) << 15);
  2587.             }
  2588.          }
  2589.          else if (dstFormat == GL_ABGR_EXT) {
  2590.             GLushort *dst = (GLushort *) dstAddr;
  2591.             for (i=0;i<n;i++) {
  2592.                dst[i] = (F_TO_I(rgba[i][ACOMP] * 31.0F)      )
  2593.                       | (F_TO_I(rgba[i][BCOMP] * 31.0F) <<  5)
  2594.                       | (F_TO_I(rgba[i][GCOMP] * 31.0F) << 10)
  2595.                       | (F_TO_I(rgba[i][RCOMP] *  1.0F) << 15);
  2596.             }
  2597.          }
  2598.          break;
  2599.       case GL_UNSIGNED_INT_8_8_8_8:
  2600.          if (dstFormat == GL_RGBA) {
  2601.             GLuint *dst = (GLuint *) dstAddr;
  2602.             for (i=0;i<n;i++) {
  2603.                dst[i] = (F_TO_I(rgba[i][RCOMP] * 255.F) << 24)
  2604.                       | (F_TO_I(rgba[i][GCOMP] * 255.F) << 16)
  2605.                       | (F_TO_I(rgba[i][BCOMP] * 255.F) <<  8)
  2606.                       | (F_TO_I(rgba[i][ACOMP] * 255.F)      );
  2607.             }
  2608.          }
  2609.          else if (dstFormat == GL_BGRA) {
  2610.             GLuint *dst = (GLuint *) dstAddr;
  2611.             for (i=0;i<n;i++) {
  2612.                dst[i] = (F_TO_I(rgba[i][BCOMP] * 255.F) << 24)
  2613.                       | (F_TO_I(rgba[i][GCOMP] * 255.F) << 16)
  2614.                       | (F_TO_I(rgba[i][RCOMP] * 255.F) <<  8)
  2615.                       | (F_TO_I(rgba[i][ACOMP] * 255.F)      );
  2616.             }
  2617.          }
  2618.          else if (dstFormat == GL_ABGR_EXT) {
  2619.             GLuint *dst = (GLuint *) dstAddr;
  2620.             for (i=0;i<n;i++) {
  2621.                dst[i] = (F_TO_I(rgba[i][ACOMP] * 255.F) << 24)
  2622.                       | (F_TO_I(rgba[i][BCOMP] * 255.F) << 16)
  2623.                       | (F_TO_I(rgba[i][GCOMP] * 255.F) <<  8)
  2624.                       | (F_TO_I(rgba[i][RCOMP] * 255.F)      );
  2625.             }
  2626.          }
  2627.          break;
  2628.       case GL_UNSIGNED_INT_8_8_8_8_REV:
  2629.          if (dstFormat == GL_RGBA) {
  2630.             GLuint *dst = (GLuint *) dstAddr;
  2631.             for (i=0;i<n;i++) {
  2632.                dst[i] = (F_TO_I(rgba[i][RCOMP] * 255.0F)      )
  2633.                       | (F_TO_I(rgba[i][GCOMP] * 255.0F) <<  8)
  2634.                       | (F_TO_I(rgba[i][BCOMP] * 255.0F) << 16)
  2635.                       | (F_TO_I(rgba[i][ACOMP] * 255.0F) << 24);
  2636.             }
  2637.          }
  2638.          else if (dstFormat == GL_BGRA) {
  2639.             GLuint *dst = (GLuint *) dstAddr;
  2640.             for (i=0;i<n;i++) {
  2641.                dst[i] = (F_TO_I(rgba[i][BCOMP] * 255.0F)      )
  2642.                       | (F_TO_I(rgba[i][GCOMP] * 255.0F) <<  8)
  2643.                       | (F_TO_I(rgba[i][RCOMP] * 255.0F) << 16)
  2644.                       | (F_TO_I(rgba[i][ACOMP] * 255.0F) << 24);
  2645.             }
  2646.          }
  2647.          else if (dstFormat == GL_ABGR_EXT) {
  2648.             GLuint *dst = (GLuint *) dstAddr;
  2649.             for (i=0;i<n;i++) {
  2650.                dst[i] = (F_TO_I(rgba[i][ACOMP] * 255.0F)      )
  2651.                       | (F_TO_I(rgba[i][BCOMP] * 255.0F) <<  8)
  2652.                       | (F_TO_I(rgba[i][GCOMP] * 255.0F) << 16)
  2653.                       | (F_TO_I(rgba[i][RCOMP] * 255.0F) << 24);
  2654.             }
  2655.          }
  2656.          break;
  2657.       case GL_UNSIGNED_INT_10_10_10_2:
  2658.          if (dstFormat == GL_RGBA) {
  2659.             GLuint *dst = (GLuint *) dstAddr;
  2660.             for (i=0;i<n;i++) {
  2661.                dst[i] = (F_TO_I(rgba[i][RCOMP] * 1023.0F) << 22)
  2662.                       | (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 12)
  2663.                       | (F_TO_I(rgba[i][BCOMP] * 1023.0F) <<  2)
  2664.                       | (F_TO_I(rgba[i][ACOMP] *    3.0F)      );
  2665.             }
  2666.          }
  2667.          else if (dstFormat == GL_BGRA) {
  2668.             GLuint *dst = (GLuint *) dstAddr;
  2669.             for (i=0;i<n;i++) {
  2670.                dst[i] = (F_TO_I(rgba[i][BCOMP] * 1023.0F) << 22)
  2671.                       | (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 12)
  2672.                       | (F_TO_I(rgba[i][RCOMP] * 1023.0F) <<  2)
  2673.                       | (F_TO_I(rgba[i][ACOMP] *    3.0F)      );
  2674.             }
  2675.          }
  2676.          else if (dstFormat == GL_ABGR_EXT) {
  2677.             GLuint *dst = (GLuint *) dstAddr;
  2678.             for (i=0;i<n;i++) {
  2679.                dst[i] = (F_TO_I(rgba[i][ACOMP] * 1023.0F) << 22)
  2680.                       | (F_TO_I(rgba[i][BCOMP] * 1023.0F) << 12)
  2681.                       | (F_TO_I(rgba[i][GCOMP] * 1023.0F) <<  2)
  2682.                       | (F_TO_I(rgba[i][RCOMP] *    3.0F)      );
  2683.             }
  2684.          }
  2685.          break;
  2686.       case GL_UNSIGNED_INT_2_10_10_10_REV:
  2687.          if (dstFormat == GL_RGBA) {
  2688.             GLuint *dst = (GLuint *) dstAddr;
  2689.             for (i=0;i<n;i++) {
  2690.                dst[i] = (F_TO_I(rgba[i][RCOMP] * 1023.0F)      )
  2691.                       | (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 10)
  2692.                       | (F_TO_I(rgba[i][BCOMP] * 1023.0F) << 20)
  2693.                       | (F_TO_I(rgba[i][ACOMP] *    3.0F) << 30);
  2694.             }
  2695.          }
  2696.          else if (dstFormat == GL_BGRA) {
  2697.             GLuint *dst = (GLuint *) dstAddr;
  2698.             for (i=0;i<n;i++) {
  2699.                dst[i] = (F_TO_I(rgba[i][BCOMP] * 1023.0F)      )
  2700.                       | (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 10)
  2701.                       | (F_TO_I(rgba[i][RCOMP] * 1023.0F) << 20)
  2702.                       | (F_TO_I(rgba[i][ACOMP] *    3.0F) << 30);
  2703.             }
  2704.          }
  2705.          else if (dstFormat == GL_ABGR_EXT) {
  2706.             GLuint *dst = (GLuint *) dstAddr;
  2707.             for (i=0;i<n;i++) {
  2708.                dst[i] = (F_TO_I(rgba[i][ACOMP] * 1023.0F)      )
  2709.                       | (F_TO_I(rgba[i][BCOMP] * 1023.0F) << 10)
  2710.                       | (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 20)
  2711.                       | (F_TO_I(rgba[i][RCOMP] *    3.0F) << 30);
  2712.             }
  2713.          }
  2714.          break;
  2715.       case GL_UNSIGNED_INT_5_9_9_9_REV:
  2716.          {
  2717.             GLuint *dst = (GLuint *) dstAddr;
  2718.             for (i = 0; i < n; i++) {
  2719.                dst[i] = float3_to_rgb9e5(rgba[i]);
  2720.             }
  2721.          }
  2722.          break;
  2723.       case GL_UNSIGNED_INT_10F_11F_11F_REV:
  2724.          {
  2725.             GLuint *dst = (GLuint *) dstAddr;
  2726.             for (i = 0; i < n; i++) {
  2727.                dst[i] = float3_to_r11g11b10f(rgba[i]);
  2728.             }
  2729.          }
  2730.          break;
  2731.       default:
  2732.          _mesa_problem(ctx, "bad type in _mesa_pack_rgba_span_float");
  2733.          free(luminance);
  2734.          return;
  2735.    }
  2736.  
  2737.    if (dstPacking->SwapBytes) {
  2738.       GLint swapSize = _mesa_sizeof_packed_type(dstType);
  2739.       if (swapSize == 2) {
  2740.          _mesa_swap2((GLushort *) dstAddr, n * comps);
  2741.       }
  2742.       else if (swapSize == 4) {
  2743.          _mesa_swap4((GLuint *) dstAddr, n * comps);
  2744.       }
  2745.    }
  2746.  
  2747.    free(luminance);
  2748. }
  2749.  
  2750.  
  2751.  
  2752. #define SWAP2BYTE(VALUE)                        \
  2753.    {                                            \
  2754.       GLubyte *bytes = (GLubyte *) &(VALUE);    \
  2755.       GLubyte tmp = bytes[0];                   \
  2756.       bytes[0] = bytes[1];                      \
  2757.       bytes[1] = tmp;                           \
  2758.    }
  2759.  
  2760. #define SWAP4BYTE(VALUE)                        \
  2761.    {                                            \
  2762.       GLubyte *bytes = (GLubyte *) &(VALUE);    \
  2763.       GLubyte tmp = bytes[0];                   \
  2764.       bytes[0] = bytes[3];                      \
  2765.       bytes[3] = tmp;                           \
  2766.       tmp = bytes[1];                           \
  2767.       bytes[1] = bytes[2];                      \
  2768.       bytes[2] = tmp;                           \
  2769.    }
  2770.  
  2771.  
  2772. static void
  2773. extract_uint_indexes(GLuint n, GLuint indexes[],
  2774.                      GLenum srcFormat, GLenum srcType, const GLvoid *src,
  2775.                      const struct gl_pixelstore_attrib *unpack )
  2776. {
  2777.    ASSERT(srcFormat == GL_COLOR_INDEX || srcFormat == GL_STENCIL_INDEX);
  2778.  
  2779.    ASSERT(srcType == GL_BITMAP ||
  2780.           srcType == GL_UNSIGNED_BYTE ||
  2781.           srcType == GL_BYTE ||
  2782.           srcType == GL_UNSIGNED_SHORT ||
  2783.           srcType == GL_SHORT ||
  2784.           srcType == GL_UNSIGNED_INT ||
  2785.           srcType == GL_INT ||
  2786.           srcType == GL_UNSIGNED_INT_24_8_EXT ||
  2787.           srcType == GL_HALF_FLOAT_ARB ||
  2788.           srcType == GL_FLOAT ||
  2789.           srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
  2790.  
  2791.    switch (srcType) {
  2792.       case GL_BITMAP:
  2793.          {
  2794.             GLubyte *ubsrc = (GLubyte *) src;
  2795.             if (unpack->LsbFirst) {
  2796.                GLubyte mask = 1 << (unpack->SkipPixels & 0x7);
  2797.                GLuint i;
  2798.                for (i = 0; i < n; i++) {
  2799.                   indexes[i] = (*ubsrc & mask) ? 1 : 0;
  2800.                   if (mask == 128) {
  2801.                      mask = 1;
  2802.                      ubsrc++;
  2803.                   }
  2804.                   else {
  2805.                      mask = mask << 1;
  2806.                   }
  2807.                }
  2808.             }
  2809.             else {
  2810.                GLubyte mask = 128 >> (unpack->SkipPixels & 0x7);
  2811.                GLuint i;
  2812.                for (i = 0; i < n; i++) {
  2813.                   indexes[i] = (*ubsrc & mask) ? 1 : 0;
  2814.                   if (mask == 1) {
  2815.                      mask = 128;
  2816.                      ubsrc++;
  2817.                   }
  2818.                   else {
  2819.                      mask = mask >> 1;
  2820.                   }
  2821.                }
  2822.             }
  2823.          }
  2824.          break;
  2825.       case GL_UNSIGNED_BYTE:
  2826.          {
  2827.             GLuint i;
  2828.             const GLubyte *s = (const GLubyte *) src;
  2829.             for (i = 0; i < n; i++)
  2830.                indexes[i] = s[i];
  2831.          }
  2832.          break;
  2833.       case GL_BYTE:
  2834.          {
  2835.             GLuint i;
  2836.             const GLbyte *s = (const GLbyte *) src;
  2837.             for (i = 0; i < n; i++)
  2838.                indexes[i] = s[i];
  2839.          }
  2840.          break;
  2841.       case GL_UNSIGNED_SHORT:
  2842.          {
  2843.             GLuint i;
  2844.             const GLushort *s = (const GLushort *) src;
  2845.             if (unpack->SwapBytes) {
  2846.                for (i = 0; i < n; i++) {
  2847.                   GLushort value = s[i];
  2848.                   SWAP2BYTE(value);
  2849.                   indexes[i] = value;
  2850.                }
  2851.             }
  2852.             else {
  2853.                for (i = 0; i < n; i++)
  2854.                   indexes[i] = s[i];
  2855.             }
  2856.          }
  2857.          break;
  2858.       case GL_SHORT:
  2859.          {
  2860.             GLuint i;
  2861.             const GLshort *s = (const GLshort *) src;
  2862.             if (unpack->SwapBytes) {
  2863.                for (i = 0; i < n; i++) {
  2864.                   GLshort value = s[i];
  2865.                   SWAP2BYTE(value);
  2866.                   indexes[i] = value;
  2867.                }
  2868.             }
  2869.             else {
  2870.                for (i = 0; i < n; i++)
  2871.                   indexes[i] = s[i];
  2872.             }
  2873.          }
  2874.          break;
  2875.       case GL_UNSIGNED_INT:
  2876.          {
  2877.             GLuint i;
  2878.             const GLuint *s = (const GLuint *) src;
  2879.             if (unpack->SwapBytes) {
  2880.                for (i = 0; i < n; i++) {
  2881.                   GLuint value = s[i];
  2882.                   SWAP4BYTE(value);
  2883.                   indexes[i] = value;
  2884.                }
  2885.             }
  2886.             else {
  2887.                for (i = 0; i < n; i++)
  2888.                   indexes[i] = s[i];
  2889.             }
  2890.          }
  2891.          break;
  2892.       case GL_INT:
  2893.          {
  2894.             GLuint i;
  2895.             const GLint *s = (const GLint *) src;
  2896.             if (unpack->SwapBytes) {
  2897.                for (i = 0; i < n; i++) {
  2898.                   GLint value = s[i];
  2899.                   SWAP4BYTE(value);
  2900.                   indexes[i] = value;
  2901.                }
  2902.             }
  2903.             else {
  2904.                for (i = 0; i < n; i++)
  2905.                   indexes[i] = s[i];
  2906.             }
  2907.          }
  2908.          break;
  2909.       case GL_FLOAT:
  2910.          {
  2911.             GLuint i;
  2912.             const GLfloat *s = (const GLfloat *) src;
  2913.             if (unpack->SwapBytes) {
  2914.                for (i = 0; i < n; i++) {
  2915.                   GLfloat value = s[i];
  2916.                   SWAP4BYTE(value);
  2917.                   indexes[i] = (GLuint) value;
  2918.                }
  2919.             }
  2920.             else {
  2921.                for (i = 0; i < n; i++)
  2922.                   indexes[i] = (GLuint) s[i];
  2923.             }
  2924.          }
  2925.          break;
  2926.       case GL_HALF_FLOAT_ARB:
  2927.          {
  2928.             GLuint i;
  2929.             const GLhalfARB *s = (const GLhalfARB *) src;
  2930.             if (unpack->SwapBytes) {
  2931.                for (i = 0; i < n; i++) {
  2932.                   GLhalfARB value = s[i];
  2933.                   SWAP2BYTE(value);
  2934.                   indexes[i] = (GLuint) _mesa_half_to_float(value);
  2935.                }
  2936.             }
  2937.             else {
  2938.                for (i = 0; i < n; i++)
  2939.                   indexes[i] = (GLuint) _mesa_half_to_float(s[i]);
  2940.             }
  2941.          }
  2942.          break;
  2943.       case GL_UNSIGNED_INT_24_8_EXT:
  2944.          {
  2945.             GLuint i;
  2946.             const GLuint *s = (const GLuint *) src;
  2947.             if (unpack->SwapBytes) {
  2948.                for (i = 0; i < n; i++) {
  2949.                   GLuint value = s[i];
  2950.                   SWAP4BYTE(value);
  2951.                   indexes[i] = value & 0xff;  /* lower 8 bits */
  2952.                }
  2953.             }
  2954.             else {
  2955.                for (i = 0; i < n; i++)
  2956.                   indexes[i] = s[i] & 0xff;  /* lower 8 bits */
  2957.             }
  2958.          }
  2959.          break;
  2960.       case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
  2961.          {
  2962.             GLuint i;
  2963.             const GLuint *s = (const GLuint *) src;
  2964.             if (unpack->SwapBytes) {
  2965.                for (i = 0; i < n; i++) {
  2966.                   GLuint value = s[i*2+1];
  2967.                   SWAP4BYTE(value);
  2968.                   indexes[i] = value & 0xff;  /* lower 8 bits */
  2969.                }
  2970.             }
  2971.             else {
  2972.                for (i = 0; i < n; i++)
  2973.                   indexes[i] = s[i*2+1] & 0xff;  /* lower 8 bits */
  2974.             }
  2975.          }
  2976.          break;
  2977.  
  2978.       default:
  2979.          _mesa_problem(NULL, "bad srcType in extract_uint_indexes");
  2980.          return;
  2981.    }
  2982. }
  2983.  
  2984.  
  2985. /**
  2986.  * Return source/dest RGBA indexes for unpacking pixels.
  2987.  */
  2988. static void
  2989. get_component_mapping(GLenum format,
  2990.                       GLint *rSrc,
  2991.                       GLint *gSrc,
  2992.                       GLint *bSrc,
  2993.                       GLint *aSrc,
  2994.                       GLint *rDst,
  2995.                       GLint *gDst,
  2996.                       GLint *bDst,
  2997.                       GLint *aDst)
  2998. {
  2999.    switch (format) {
  3000.    case GL_RED:
  3001.    case GL_RED_INTEGER_EXT:
  3002.       *rSrc = 0;
  3003.       *gSrc = *bSrc = *aSrc = -1;
  3004.       break;
  3005.    case GL_GREEN:
  3006.    case GL_GREEN_INTEGER_EXT:
  3007.       *gSrc = 0;
  3008.       *rSrc = *bSrc = *aSrc = -1;
  3009.       break;
  3010.    case GL_BLUE:
  3011.    case GL_BLUE_INTEGER_EXT:
  3012.       *bSrc = 0;
  3013.       *rSrc = *gSrc = *aSrc = -1;
  3014.       break;
  3015.    case GL_ALPHA:
  3016.    case GL_ALPHA_INTEGER_EXT:
  3017.       *rSrc = *gSrc = *bSrc = -1;
  3018.       *aSrc = 0;
  3019.       break;
  3020.    case GL_LUMINANCE:
  3021.    case GL_LUMINANCE_INTEGER_EXT:
  3022.       *rSrc = *gSrc = *bSrc = 0;
  3023.       *aSrc = -1;
  3024.       break;
  3025.    case GL_LUMINANCE_ALPHA:
  3026.    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
  3027.       *rSrc = *gSrc = *bSrc = 0;
  3028.       *aSrc = 1;
  3029.       break;
  3030.    case GL_INTENSITY:
  3031.       *rSrc = *gSrc = *bSrc = *aSrc = 0;
  3032.       break;
  3033.    case GL_RG:
  3034.    case GL_RG_INTEGER:
  3035.       *rSrc = 0;
  3036.       *gSrc = 1;
  3037.       *bSrc = -1;
  3038.       *aSrc = -1;
  3039.       *rDst = 0;
  3040.       *gDst = 1;
  3041.       *bDst = 2;
  3042.       *aDst = 3;
  3043.       break;
  3044.    case GL_RGB:
  3045.    case GL_RGB_INTEGER:
  3046.       *rSrc = 0;
  3047.       *gSrc = 1;
  3048.       *bSrc = 2;
  3049.       *aSrc = -1;
  3050.       *rDst = 0;
  3051.       *gDst = 1;
  3052.       *bDst = 2;
  3053.       *aDst = 3;
  3054.       break;
  3055.    case GL_BGR:
  3056.    case GL_BGR_INTEGER:
  3057.       *rSrc = 2;
  3058.       *gSrc = 1;
  3059.       *bSrc = 0;
  3060.       *aSrc = -1;
  3061.       *rDst = 2;
  3062.       *gDst = 1;
  3063.       *bDst = 0;
  3064.       *aDst = 3;
  3065.       break;
  3066.    case GL_RGBA:
  3067.    case GL_RGBA_INTEGER:
  3068.       *rSrc = 0;
  3069.       *gSrc = 1;
  3070.       *bSrc = 2;
  3071.       *aSrc = 3;
  3072.       *rDst = 0;
  3073.       *gDst = 1;
  3074.       *bDst = 2;
  3075.       *aDst = 3;
  3076.       break;
  3077.    case GL_BGRA:
  3078.    case GL_BGRA_INTEGER:
  3079.       *rSrc = 2;
  3080.       *gSrc = 1;
  3081.       *bSrc = 0;
  3082.       *aSrc = 3;
  3083.       *rDst = 2;
  3084.       *gDst = 1;
  3085.       *bDst = 0;
  3086.       *aDst = 3;
  3087.       break;
  3088.    case GL_ABGR_EXT:
  3089.       *rSrc = 3;
  3090.       *gSrc = 2;
  3091.       *bSrc = 1;
  3092.       *aSrc = 0;
  3093.       *rDst = 3;
  3094.       *gDst = 2;
  3095.       *bDst = 1;
  3096.       *aDst = 0;
  3097.       break;
  3098.    case GL_DU8DV8_ATI:
  3099.    case GL_DUDV_ATI:
  3100.       *rSrc = 0;
  3101.       *gSrc = 1;
  3102.       *bSrc = -1;
  3103.       *aSrc = -1;
  3104.       break;
  3105.    default:
  3106.       _mesa_problem(NULL, "bad srcFormat %s in get_component_mapping",
  3107.                     _mesa_lookup_enum_by_nr(format));
  3108.       return;
  3109.    }
  3110. }
  3111.  
  3112.  
  3113.  
  3114. /*
  3115.  * This function extracts floating point RGBA values from arbitrary
  3116.  * image data.  srcFormat and srcType are the format and type parameters
  3117.  * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
  3118.  *
  3119.  * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
  3120.  * implements the "Conversion to floating point", "Conversion to RGB",
  3121.  * and "Final Expansion to RGBA" operations.
  3122.  *
  3123.  * Args:  n - number of pixels
  3124.  *        rgba - output colors
  3125.  *        srcFormat - format of incoming data
  3126.  *        srcType - data type of incoming data
  3127.  *        src - source data pointer
  3128.  *        swapBytes - perform byteswapping of incoming data?
  3129.  */
  3130. static void
  3131. extract_float_rgba(GLuint n, GLfloat rgba[][4],
  3132.                    GLenum srcFormat, GLenum srcType, const GLvoid *src,
  3133.                    GLboolean swapBytes)
  3134. {
  3135.    GLint rSrc, gSrc, bSrc, aSrc;
  3136.    GLint stride;
  3137.    GLint rDst, bDst, gDst, aDst;
  3138.    GLboolean intFormat;
  3139.    GLfloat rs = 1.0f, gs = 1.0f, bs = 1.0f, as = 1.0f; /* scale factors */
  3140.  
  3141.    ASSERT(srcFormat == GL_RED ||
  3142.           srcFormat == GL_GREEN ||
  3143.           srcFormat == GL_BLUE ||
  3144.           srcFormat == GL_ALPHA ||
  3145.           srcFormat == GL_LUMINANCE ||
  3146.           srcFormat == GL_LUMINANCE_ALPHA ||
  3147.           srcFormat == GL_INTENSITY ||
  3148.           srcFormat == GL_RG ||
  3149.           srcFormat == GL_RGB ||
  3150.           srcFormat == GL_BGR ||
  3151.           srcFormat == GL_RGBA ||
  3152.           srcFormat == GL_BGRA ||
  3153.           srcFormat == GL_ABGR_EXT ||
  3154.           srcFormat == GL_DU8DV8_ATI ||
  3155.           srcFormat == GL_DUDV_ATI ||
  3156.           srcFormat == GL_RED_INTEGER_EXT ||
  3157.           srcFormat == GL_GREEN_INTEGER_EXT ||
  3158.           srcFormat == GL_BLUE_INTEGER_EXT ||
  3159.           srcFormat == GL_ALPHA_INTEGER_EXT ||
  3160.           srcFormat == GL_RG_INTEGER ||
  3161.           srcFormat == GL_RGB_INTEGER_EXT ||
  3162.           srcFormat == GL_RGBA_INTEGER_EXT ||
  3163.           srcFormat == GL_BGR_INTEGER_EXT ||
  3164.           srcFormat == GL_BGRA_INTEGER_EXT ||
  3165.           srcFormat == GL_LUMINANCE_INTEGER_EXT ||
  3166.           srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
  3167.  
  3168.    ASSERT(srcType == GL_UNSIGNED_BYTE ||
  3169.           srcType == GL_BYTE ||
  3170.           srcType == GL_UNSIGNED_SHORT ||
  3171.           srcType == GL_SHORT ||
  3172.           srcType == GL_UNSIGNED_INT ||
  3173.           srcType == GL_INT ||
  3174.           srcType == GL_HALF_FLOAT_ARB ||
  3175.           srcType == GL_FLOAT ||
  3176.           srcType == GL_UNSIGNED_BYTE_3_3_2 ||
  3177.           srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
  3178.           srcType == GL_UNSIGNED_SHORT_5_6_5 ||
  3179.           srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
  3180.           srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
  3181.           srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
  3182.           srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
  3183.           srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
  3184.           srcType == GL_UNSIGNED_INT_8_8_8_8 ||
  3185.           srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
  3186.           srcType == GL_UNSIGNED_INT_10_10_10_2 ||
  3187.           srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
  3188.           srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
  3189.           srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
  3190.  
  3191.    get_component_mapping(srcFormat,
  3192.                          &rSrc, &gSrc, &bSrc, &aSrc,
  3193.                          &rDst, &gDst, &bDst, &aDst);
  3194.  
  3195.    stride = _mesa_components_in_format(srcFormat);
  3196.  
  3197.    intFormat = _mesa_is_enum_format_integer(srcFormat);
  3198.  
  3199. #define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT_FLT, DEFAULT_INT, TYPE, CONVERSION) \
  3200.    if ((SRC_INDEX) < 0) {                                               \
  3201.       GLuint i;                                                         \
  3202.       if (intFormat) {                                                  \
  3203.          for (i = 0; i < n; i++) {                                      \
  3204.             rgba[i][DST_INDEX] = DEFAULT_INT;                           \
  3205.          }                                                              \
  3206.       }                                                                 \
  3207.       else {                                                            \
  3208.          for (i = 0; i < n; i++) {                                      \
  3209.             rgba[i][DST_INDEX] = DEFAULT_FLT;                           \
  3210.          }                                                              \
  3211.       }                                                                 \
  3212.    }                                                                    \
  3213.    else if (swapBytes) {                                                \
  3214.       const TYPE *s = (const TYPE *) src;                               \
  3215.       GLuint i;                                                         \
  3216.       for (i = 0; i < n; i++) {                                         \
  3217.          TYPE value = s[SRC_INDEX];                                     \
  3218.          if (sizeof(TYPE) == 2) {                                       \
  3219.             SWAP2BYTE(value);                                           \
  3220.          }                                                              \
  3221.          else if (sizeof(TYPE) == 4) {                                  \
  3222.             SWAP4BYTE(value);                                           \
  3223.          }                                                              \
  3224.          if (intFormat)                                                 \
  3225.             rgba[i][DST_INDEX] = (GLfloat) value;                       \
  3226.          else                                                           \
  3227.             rgba[i][DST_INDEX] = (GLfloat) CONVERSION(value);           \
  3228.          s += stride;                                                   \
  3229.       }                                                                 \
  3230.    }                                                                    \
  3231.    else {                                                               \
  3232.       const TYPE *s = (const TYPE *) src;                               \
  3233.       GLuint i;                                                         \
  3234.       if (intFormat) {                                                  \
  3235.          for (i = 0; i < n; i++) {                                      \
  3236.             rgba[i][DST_INDEX] = (GLfloat) s[SRC_INDEX];                \
  3237.             s += stride;                                                \
  3238.          }                                                              \
  3239.       }                                                                 \
  3240.       else {                                                            \
  3241.          for (i = 0; i < n; i++) {                                      \
  3242.             rgba[i][DST_INDEX] = (GLfloat) CONVERSION(s[SRC_INDEX]);    \
  3243.             s += stride;                                                \
  3244.          }                                                              \
  3245.       }                                                                 \
  3246.    }
  3247.  
  3248.    switch (srcType) {
  3249.       case GL_UNSIGNED_BYTE:
  3250.          PROCESS(rSrc, RCOMP, 0.0F,   0, GLubyte, UBYTE_TO_FLOAT);
  3251.          PROCESS(gSrc, GCOMP, 0.0F,   0, GLubyte, UBYTE_TO_FLOAT);
  3252.          PROCESS(bSrc, BCOMP, 0.0F,   0, GLubyte, UBYTE_TO_FLOAT);
  3253.          PROCESS(aSrc, ACOMP, 1.0F, 255, GLubyte, UBYTE_TO_FLOAT);
  3254.          break;
  3255.       case GL_BYTE:
  3256.          PROCESS(rSrc, RCOMP, 0.0F,   0, GLbyte, BYTE_TO_FLOATZ);
  3257.          PROCESS(gSrc, GCOMP, 0.0F,   0, GLbyte, BYTE_TO_FLOATZ);
  3258.          PROCESS(bSrc, BCOMP, 0.0F,   0, GLbyte, BYTE_TO_FLOATZ);
  3259.          PROCESS(aSrc, ACOMP, 1.0F, 127, GLbyte, BYTE_TO_FLOATZ);
  3260.          break;
  3261.       case GL_UNSIGNED_SHORT:
  3262.          PROCESS(rSrc, RCOMP, 0.0F,      0, GLushort, USHORT_TO_FLOAT);
  3263.          PROCESS(gSrc, GCOMP, 0.0F,      0, GLushort, USHORT_TO_FLOAT);
  3264.          PROCESS(bSrc, BCOMP, 0.0F,      0, GLushort, USHORT_TO_FLOAT);
  3265.          PROCESS(aSrc, ACOMP, 1.0F, 0xffff, GLushort, USHORT_TO_FLOAT);
  3266.          break;
  3267.       case GL_SHORT:
  3268.          PROCESS(rSrc, RCOMP, 0.0F,     0, GLshort, SHORT_TO_FLOATZ);
  3269.          PROCESS(gSrc, GCOMP, 0.0F,     0, GLshort, SHORT_TO_FLOATZ);
  3270.          PROCESS(bSrc, BCOMP, 0.0F,     0, GLshort, SHORT_TO_FLOATZ);
  3271.          PROCESS(aSrc, ACOMP, 1.0F, 32767, GLshort, SHORT_TO_FLOATZ);
  3272.          break;
  3273.       case GL_UNSIGNED_INT:
  3274.          PROCESS(rSrc, RCOMP, 0.0F,          0, GLuint, UINT_TO_FLOAT);
  3275.          PROCESS(gSrc, GCOMP, 0.0F,          0, GLuint, UINT_TO_FLOAT);
  3276.          PROCESS(bSrc, BCOMP, 0.0F,          0, GLuint, UINT_TO_FLOAT);
  3277.          PROCESS(aSrc, ACOMP, 1.0F, 0xffffffff, GLuint, UINT_TO_FLOAT);
  3278.          break;
  3279.       case GL_INT:
  3280.          PROCESS(rSrc, RCOMP, 0.0F,          0, GLint, INT_TO_FLOAT);
  3281.          PROCESS(gSrc, GCOMP, 0.0F,          0, GLint, INT_TO_FLOAT);
  3282.          PROCESS(bSrc, BCOMP, 0.0F,          0, GLint, INT_TO_FLOAT);
  3283.          PROCESS(aSrc, ACOMP, 1.0F, 2147483647, GLint, INT_TO_FLOAT);
  3284.          break;
  3285.       case GL_FLOAT:
  3286.          PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
  3287.          PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
  3288.          PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
  3289.          PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLfloat, (GLfloat));
  3290.          break;
  3291.       case GL_HALF_FLOAT_ARB:
  3292.          PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
  3293.          PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
  3294.          PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
  3295.          PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLhalfARB, _mesa_half_to_float);
  3296.          break;
  3297.       case GL_UNSIGNED_BYTE_3_3_2:
  3298.          {
  3299.             const GLubyte *ubsrc = (const GLubyte *) src;
  3300.             GLuint i;
  3301.             if (!intFormat) {
  3302.                rs = 1.0F / 7.0F;
  3303.                gs = 1.0F / 7.0F;
  3304.                bs = 1.0F / 3.0F;
  3305.             }
  3306.             for (i = 0; i < n; i ++) {
  3307.                GLubyte p = ubsrc[i];
  3308.                rgba[i][rDst] = ((p >> 5)      ) * rs;
  3309.                rgba[i][gDst] = ((p >> 2) & 0x7) * gs;
  3310.                rgba[i][bDst] = ((p     ) & 0x3) * bs;
  3311.                rgba[i][aDst] = 1.0F;
  3312.             }
  3313.          }
  3314.          break;
  3315.       case GL_UNSIGNED_BYTE_2_3_3_REV:
  3316.          {
  3317.             const GLubyte *ubsrc = (const GLubyte *) src;
  3318.             GLuint i;
  3319.             if (!intFormat) {
  3320.                rs = 1.0F / 7.0F;
  3321.                gs = 1.0F / 7.0F;
  3322.                bs = 1.0F / 3.0F;
  3323.             }
  3324.             for (i = 0; i < n; i ++) {
  3325.                GLubyte p = ubsrc[i];
  3326.                rgba[i][rDst] = ((p     ) & 0x7) * rs;
  3327.                rgba[i][gDst] = ((p >> 3) & 0x7) * gs;
  3328.                rgba[i][bDst] = ((p >> 6)      ) * bs;
  3329.                rgba[i][aDst] = 1.0F;
  3330.             }
  3331.          }
  3332.          break;
  3333.       case GL_UNSIGNED_SHORT_5_6_5:
  3334.          if (!intFormat) {
  3335.             rs = 1.0F / 31.0F;
  3336.             gs = 1.0F / 63.0F;
  3337.             bs = 1.0F / 31.0F;
  3338.          }
  3339.          if (swapBytes) {
  3340.             const GLushort *ussrc = (const GLushort *) src;
  3341.             GLuint i;
  3342.             for (i = 0; i < n; i ++) {
  3343.                GLushort p = ussrc[i];
  3344.                SWAP2BYTE(p);
  3345.                rgba[i][rDst] = ((p >> 11)       ) * rs;
  3346.                rgba[i][gDst] = ((p >>  5) & 0x3f) * gs;
  3347.                rgba[i][bDst] = ((p      ) & 0x1f) * bs;
  3348.                rgba[i][aDst] = 1.0F;
  3349.             }
  3350.          }
  3351.          else {
  3352.             const GLushort *ussrc = (const GLushort *) src;
  3353.             GLuint i;
  3354.             for (i = 0; i < n; i ++) {
  3355.                GLushort p = ussrc[i];
  3356.                rgba[i][rDst] = ((p >> 11)       ) * rs;
  3357.                rgba[i][gDst] = ((p >>  5) & 0x3f) * gs;
  3358.                rgba[i][bDst] = ((p      ) & 0x1f) * bs;
  3359.                rgba[i][aDst] = 1.0F;
  3360.             }
  3361.          }
  3362.          break;
  3363.       case GL_UNSIGNED_SHORT_5_6_5_REV:
  3364.          if (!intFormat) {
  3365.             rs = 1.0F / 31.0F;
  3366.             gs = 1.0F / 63.0F;
  3367.             bs = 1.0F / 31.0F;
  3368.          }
  3369.          if (swapBytes) {
  3370.             const GLushort *ussrc = (const GLushort *) src;
  3371.             GLuint i;
  3372.             for (i = 0; i < n; i ++) {
  3373.                GLushort p = ussrc[i];
  3374.                SWAP2BYTE(p);
  3375.                rgba[i][rDst] = ((p      ) & 0x1f) * rs;
  3376.                rgba[i][gDst] = ((p >>  5) & 0x3f) * gs;
  3377.                rgba[i][bDst] = ((p >> 11)       ) * bs;
  3378.                rgba[i][aDst] = 1.0F;
  3379.             }
  3380.          }
  3381.          else {
  3382.             const GLushort *ussrc = (const GLushort *) src;
  3383.             GLuint i;
  3384.             for (i = 0; i < n; i ++) {
  3385.                GLushort p = ussrc[i];
  3386.                rgba[i][rDst] = ((p      ) & 0x1f) * rs;
  3387.                rgba[i][gDst] = ((p >>  5) & 0x3f) * gs;
  3388.                rgba[i][bDst] = ((p >> 11)       ) * bs;
  3389.                rgba[i][aDst] = 1.0F;
  3390.             }
  3391.          }
  3392.          break;
  3393.       case GL_UNSIGNED_SHORT_4_4_4_4:
  3394.          if (!intFormat) {
  3395.             rs = gs = bs = as = 1.0F / 15.0F;
  3396.          }
  3397.          if (swapBytes) {
  3398.             const GLushort *ussrc = (const GLushort *) src;
  3399.             GLuint i;
  3400.             for (i = 0; i < n; i ++) {
  3401.                GLushort p = ussrc[i];
  3402.                SWAP2BYTE(p);
  3403.                rgba[i][rDst] = ((p >> 12)      ) * rs;
  3404.                rgba[i][gDst] = ((p >>  8) & 0xf) * gs;
  3405.                rgba[i][bDst] = ((p >>  4) & 0xf) * bs;
  3406.                rgba[i][aDst] = ((p      ) & 0xf) * as;
  3407.             }
  3408.          }
  3409.          else {
  3410.             const GLushort *ussrc = (const GLushort *) src;
  3411.             GLuint i;
  3412.             for (i = 0; i < n; i ++) {
  3413.                GLushort p = ussrc[i];
  3414.                rgba[i][rDst] = ((p >> 12)      ) * rs;
  3415.                rgba[i][gDst] = ((p >>  8) & 0xf) * gs;
  3416.                rgba[i][bDst] = ((p >>  4) & 0xf) * bs;
  3417.                rgba[i][aDst] = ((p      ) & 0xf) * as;
  3418.             }
  3419.          }
  3420.          break;
  3421.       case GL_UNSIGNED_SHORT_4_4_4_4_REV:
  3422.          if (!intFormat) {
  3423.             rs = gs = bs = as = 1.0F / 15.0F;
  3424.          }
  3425.          if (swapBytes) {
  3426.             const GLushort *ussrc = (const GLushort *) src;
  3427.             GLuint i;
  3428.             for (i = 0; i < n; i ++) {
  3429.                GLushort p = ussrc[i];
  3430.                SWAP2BYTE(p);
  3431.                rgba[i][rDst] = ((p      ) & 0xf) * rs;
  3432.                rgba[i][gDst] = ((p >>  4) & 0xf) * gs;
  3433.                rgba[i][bDst] = ((p >>  8) & 0xf) * bs;
  3434.                rgba[i][aDst] = ((p >> 12)      ) * as;
  3435.             }
  3436.          }
  3437.          else {
  3438.             const GLushort *ussrc = (const GLushort *) src;
  3439.             GLuint i;
  3440.             for (i = 0; i < n; i ++) {
  3441.                GLushort p = ussrc[i];
  3442.                rgba[i][rDst] = ((p      ) & 0xf) * rs;
  3443.                rgba[i][gDst] = ((p >>  4) & 0xf) * gs;
  3444.                rgba[i][bDst] = ((p >>  8) & 0xf) * bs;
  3445.                rgba[i][aDst] = ((p >> 12)      ) * as;
  3446.             }
  3447.          }
  3448.          break;
  3449.       case GL_UNSIGNED_SHORT_5_5_5_1:
  3450.          if (!intFormat) {
  3451.             rs = gs = bs = 1.0F / 31.0F;
  3452.          }
  3453.          if (swapBytes) {
  3454.             const GLushort *ussrc = (const GLushort *) src;
  3455.             GLuint i;
  3456.             for (i = 0; i < n; i ++) {
  3457.                GLushort p = ussrc[i];
  3458.                SWAP2BYTE(p);
  3459.                rgba[i][rDst] = ((p >> 11)       ) * rs;
  3460.                rgba[i][gDst] = ((p >>  6) & 0x1f) * gs;
  3461.                rgba[i][bDst] = ((p >>  1) & 0x1f) * bs;
  3462.                rgba[i][aDst] = ((p      ) & 0x1)  * as;
  3463.             }
  3464.          }
  3465.          else {
  3466.             const GLushort *ussrc = (const GLushort *) src;
  3467.             GLuint i;
  3468.             for (i = 0; i < n; i ++) {
  3469.                GLushort p = ussrc[i];
  3470.                rgba[i][rDst] = ((p >> 11)       ) * rs;
  3471.                rgba[i][gDst] = ((p >>  6) & 0x1f) * gs;
  3472.                rgba[i][bDst] = ((p >>  1) & 0x1f) * bs;
  3473.                rgba[i][aDst] = ((p      ) & 0x1)  * as;
  3474.             }
  3475.          }
  3476.          break;
  3477.       case GL_UNSIGNED_SHORT_1_5_5_5_REV:
  3478.          if (!intFormat) {
  3479.             rs = gs = bs = 1.0F / 31.0F;
  3480.          }
  3481.          if (swapBytes) {
  3482.             const GLushort *ussrc = (const GLushort *) src;
  3483.             GLuint i;
  3484.             for (i = 0; i < n; i ++) {
  3485.                GLushort p = ussrc[i];
  3486.                SWAP2BYTE(p);
  3487.                rgba[i][rDst] = ((p      ) & 0x1f) * rs;
  3488.                rgba[i][gDst] = ((p >>  5) & 0x1f) * gs;
  3489.                rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;
  3490.                rgba[i][aDst] = ((p >> 15)       ) * as;
  3491.             }
  3492.          }
  3493.          else {
  3494.             const GLushort *ussrc = (const GLushort *) src;
  3495.             GLuint i;
  3496.             for (i = 0; i < n; i ++) {
  3497.                GLushort p = ussrc[i];
  3498.                rgba[i][rDst] = ((p      ) & 0x1f) * rs;
  3499.                rgba[i][gDst] = ((p >>  5) & 0x1f) * gs;
  3500.                rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;
  3501.                rgba[i][aDst] = ((p >> 15)       ) * as;
  3502.             }
  3503.          }
  3504.          break;
  3505.       case GL_UNSIGNED_INT_8_8_8_8:
  3506.          if (swapBytes) {
  3507.             const GLuint *uisrc = (const GLuint *) src;
  3508.             GLuint i;
  3509.             if (intFormat) {
  3510.                for (i = 0; i < n; i ++) {
  3511.                   GLuint p = uisrc[i];
  3512.                   rgba[i][rDst] = (GLfloat) ((p      ) & 0xff);
  3513.                   rgba[i][gDst] = (GLfloat) ((p >>  8) & 0xff);
  3514.                   rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);
  3515.                   rgba[i][aDst] = (GLfloat) ((p >> 24)       );
  3516.                }
  3517.             }
  3518.             else {
  3519.                for (i = 0; i < n; i ++) {
  3520.                   GLuint p = uisrc[i];
  3521.                   rgba[i][rDst] = UBYTE_TO_FLOAT((p      ) & 0xff);
  3522.                   rgba[i][gDst] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
  3523.                   rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
  3524.                   rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24)       );
  3525.                }
  3526.             }
  3527.          }
  3528.          else {
  3529.             const GLuint *uisrc = (const GLuint *) src;
  3530.             GLuint i;
  3531.             if (intFormat) {
  3532.                for (i = 0; i < n; i ++) {
  3533.                   GLuint p = uisrc[i];
  3534.                   rgba[i][rDst] = (GLfloat) ((p >> 24)       );
  3535.                   rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);
  3536.                   rgba[i][bDst] = (GLfloat) ((p >>  8) & 0xff);
  3537.                   rgba[i][aDst] = (GLfloat) ((p      ) & 0xff);
  3538.                }
  3539.             }
  3540.             else {
  3541.                for (i = 0; i < n; i ++) {
  3542.                   GLuint p = uisrc[i];
  3543.                   rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24)       );
  3544.                   rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
  3545.                   rgba[i][bDst] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
  3546.                   rgba[i][aDst] = UBYTE_TO_FLOAT((p      ) & 0xff);
  3547.                }
  3548.             }
  3549.          }
  3550.          break;
  3551.       case GL_UNSIGNED_INT_8_8_8_8_REV:
  3552.          if (swapBytes) {
  3553.             const GLuint *uisrc = (const GLuint *) src;
  3554.             GLuint i;
  3555.             if (intFormat) {
  3556.                for (i = 0; i < n; i ++) {
  3557.                   GLuint p = uisrc[i];
  3558.                   rgba[i][rDst] = (GLfloat) ((p >> 24)       );
  3559.                   rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);
  3560.                   rgba[i][bDst] = (GLfloat) ((p >>  8) & 0xff);
  3561.                   rgba[i][aDst] = (GLfloat) ((p      ) & 0xff);
  3562.                }
  3563.             }
  3564.             else {
  3565.                for (i = 0; i < n; i ++) {
  3566.                   GLuint p = uisrc[i];
  3567.                   rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24)       );
  3568.                   rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
  3569.                   rgba[i][bDst] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
  3570.                   rgba[i][aDst] = UBYTE_TO_FLOAT((p      ) & 0xff);
  3571.                }
  3572.             }
  3573.          }
  3574.          else {
  3575.             const GLuint *uisrc = (const GLuint *) src;
  3576.             GLuint i;
  3577.             if (intFormat) {
  3578.                for (i = 0; i < n; i ++) {
  3579.                   GLuint p = uisrc[i];
  3580.                   rgba[i][rDst] = (GLfloat) ((p      ) & 0xff);
  3581.                   rgba[i][gDst] = (GLfloat) ((p >>  8) & 0xff);
  3582.                   rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);
  3583.                   rgba[i][aDst] = (GLfloat) ((p >> 24)       );
  3584.                }
  3585.             }
  3586.             else {
  3587.                for (i = 0; i < n; i ++) {
  3588.                   GLuint p = uisrc[i];
  3589.                   rgba[i][rDst] = UBYTE_TO_FLOAT((p      ) & 0xff);
  3590.                   rgba[i][gDst] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
  3591.                   rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
  3592.                   rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24)       );
  3593.                }
  3594.             }
  3595.          }
  3596.          break;
  3597.       case GL_UNSIGNED_INT_10_10_10_2:
  3598.          if (!intFormat) {
  3599.             rs = 1.0F / 1023.0F;
  3600.             gs = 1.0F / 1023.0F;
  3601.             bs = 1.0F / 1023.0F;
  3602.             as = 1.0F / 3.0F;
  3603.          }
  3604.          if (swapBytes) {
  3605.             const GLuint *uisrc = (const GLuint *) src;
  3606.             GLuint i;
  3607.             for (i = 0; i < n; i ++) {
  3608.                GLuint p = uisrc[i];
  3609.                SWAP4BYTE(p);
  3610.                rgba[i][rDst] = ((p >> 22)        ) * rs;
  3611.                rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;
  3612.                rgba[i][bDst] = ((p >>  2) & 0x3ff) * bs;
  3613.                rgba[i][aDst] = ((p      ) & 0x3  ) * as;
  3614.             }
  3615.          }
  3616.          else {
  3617.             const GLuint *uisrc = (const GLuint *) src;
  3618.             GLuint i;
  3619.             for (i = 0; i < n; i ++) {
  3620.                GLuint p = uisrc[i];
  3621.                rgba[i][rDst] = ((p >> 22)        ) * rs;
  3622.                rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;
  3623.                rgba[i][bDst] = ((p >>  2) & 0x3ff) * bs;
  3624.                rgba[i][aDst] = ((p      ) & 0x3  ) * as;
  3625.             }
  3626.          }
  3627.          break;
  3628.       case GL_UNSIGNED_INT_2_10_10_10_REV:
  3629.          if (!intFormat) {
  3630.             rs = 1.0F / 1023.0F;
  3631.             gs = 1.0F / 1023.0F;
  3632.             bs = 1.0F / 1023.0F;
  3633.             as = 1.0F / 3.0F;
  3634.          }
  3635.          if (swapBytes) {
  3636.             const GLuint *uisrc = (const GLuint *) src;
  3637.             GLuint i;
  3638.             for (i = 0; i < n; i ++) {
  3639.                GLuint p = uisrc[i];
  3640.                SWAP4BYTE(p);
  3641.                rgba[i][rDst] = ((p      ) & 0x3ff) * rs;
  3642.                rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;
  3643.                rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;
  3644.                if (aSrc < 0) {
  3645.                   rgba[i][aDst] = 1.0F;
  3646.                } else {
  3647.                   rgba[i][aDst] = (p >> 30) * as;
  3648.                }
  3649.             }
  3650.          }
  3651.          else {
  3652.             const GLuint *uisrc = (const GLuint *) src;
  3653.             GLuint i;
  3654.             for (i = 0; i < n; i ++) {
  3655.                GLuint p = uisrc[i];
  3656.                rgba[i][rDst] = ((p      ) & 0x3ff) * rs;
  3657.                rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;
  3658.                rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;
  3659.                if (aSrc < 0) {
  3660.                   rgba[i][aDst] = 1.0F;
  3661.                } else {
  3662.                   rgba[i][aDst] = (p >> 30) * as;
  3663.                }
  3664.             }
  3665.          }
  3666.          break;
  3667.       case GL_UNSIGNED_INT_5_9_9_9_REV:
  3668.          if (swapBytes) {
  3669.             const GLuint *uisrc = (const GLuint *) src;
  3670.             GLuint i;
  3671.             GLfloat f[3];
  3672.             for (i = 0; i < n; i ++) {
  3673.                GLuint p = uisrc[i];
  3674.                SWAP4BYTE(p);
  3675.                rgb9e5_to_float3(p, f);
  3676.                rgba[i][rDst] = f[0];
  3677.                rgba[i][gDst] = f[1];
  3678.                rgba[i][bDst] = f[2];
  3679.                rgba[i][aDst] = 1.0F;
  3680.             }
  3681.          }
  3682.          else {
  3683.             const GLuint *uisrc = (const GLuint *) src;
  3684.             GLuint i;
  3685.             GLfloat f[3];
  3686.             for (i = 0; i < n; i ++) {
  3687.                rgb9e5_to_float3(uisrc[i], f);
  3688.                rgba[i][rDst] = f[0];
  3689.                rgba[i][gDst] = f[1];
  3690.                rgba[i][bDst] = f[2];
  3691.                rgba[i][aDst] = 1.0F;
  3692.             }
  3693.          }
  3694.          break;
  3695.       case GL_UNSIGNED_INT_10F_11F_11F_REV:
  3696.          if (swapBytes) {
  3697.             const GLuint *uisrc = (const GLuint *) src;
  3698.             GLuint i;
  3699.             GLfloat f[3];
  3700.             for (i = 0; i < n; i ++) {
  3701.                GLuint p = uisrc[i];
  3702.                SWAP4BYTE(p);
  3703.                r11g11b10f_to_float3(p, f);
  3704.                rgba[i][rDst] = f[0];
  3705.                rgba[i][gDst] = f[1];
  3706.                rgba[i][bDst] = f[2];
  3707.                rgba[i][aDst] = 1.0F;
  3708.             }
  3709.          }
  3710.          else {
  3711.             const GLuint *uisrc = (const GLuint *) src;
  3712.             GLuint i;
  3713.             GLfloat f[3];
  3714.             for (i = 0; i < n; i ++) {
  3715.                r11g11b10f_to_float3(uisrc[i], f);
  3716.                rgba[i][rDst] = f[0];
  3717.                rgba[i][gDst] = f[1];
  3718.                rgba[i][bDst] = f[2];
  3719.                rgba[i][aDst] = 1.0F;
  3720.             }
  3721.          }
  3722.          break;
  3723.       default:
  3724.          _mesa_problem(NULL, "bad srcType in extract float data");
  3725.          break;
  3726.    }
  3727. #undef PROCESS
  3728. }
  3729.  
  3730.  
  3731. static inline GLuint
  3732. clamp_float_to_uint(GLfloat f)
  3733. {
  3734.    return f < 0.0F ? 0 : F_TO_I(f);
  3735. }
  3736.  
  3737.  
  3738. static inline GLuint
  3739. clamp_half_to_uint(GLhalfARB h)
  3740. {
  3741.    GLfloat f = _mesa_half_to_float(h);
  3742.    return f < 0.0F ? 0 : F_TO_I(f);
  3743. }
  3744.  
  3745.  
  3746. /**
  3747.  * \sa extract_float_rgba()
  3748.  */
  3749. static void
  3750. extract_uint_rgba(GLuint n, GLuint rgba[][4],
  3751.                   GLenum srcFormat, GLenum srcType, const GLvoid *src,
  3752.                   GLboolean swapBytes)
  3753. {
  3754.    GLint rSrc, gSrc, bSrc, aSrc;
  3755.    GLint stride;
  3756.    GLint rDst, bDst, gDst, aDst;
  3757.  
  3758.    ASSERT(srcFormat == GL_RED ||
  3759.           srcFormat == GL_GREEN ||
  3760.           srcFormat == GL_BLUE ||
  3761.           srcFormat == GL_ALPHA ||
  3762.           srcFormat == GL_LUMINANCE ||
  3763.           srcFormat == GL_LUMINANCE_ALPHA ||
  3764.           srcFormat == GL_INTENSITY ||
  3765.           srcFormat == GL_RG ||
  3766.           srcFormat == GL_RGB ||
  3767.           srcFormat == GL_BGR ||
  3768.           srcFormat == GL_RGBA ||
  3769.           srcFormat == GL_BGRA ||
  3770.           srcFormat == GL_ABGR_EXT ||
  3771.           srcFormat == GL_DU8DV8_ATI ||
  3772.           srcFormat == GL_DUDV_ATI ||
  3773.           srcFormat == GL_RED_INTEGER_EXT ||
  3774.           srcFormat == GL_RG_INTEGER ||
  3775.           srcFormat == GL_GREEN_INTEGER_EXT ||
  3776.           srcFormat == GL_BLUE_INTEGER_EXT ||
  3777.           srcFormat == GL_ALPHA_INTEGER_EXT ||
  3778.           srcFormat == GL_RGB_INTEGER_EXT ||
  3779.           srcFormat == GL_RGBA_INTEGER_EXT ||
  3780.           srcFormat == GL_BGR_INTEGER_EXT ||
  3781.           srcFormat == GL_BGRA_INTEGER_EXT ||
  3782.           srcFormat == GL_LUMINANCE_INTEGER_EXT ||
  3783.           srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
  3784.  
  3785.    ASSERT(srcType == GL_UNSIGNED_BYTE ||
  3786.           srcType == GL_BYTE ||
  3787.           srcType == GL_UNSIGNED_SHORT ||
  3788.           srcType == GL_SHORT ||
  3789.           srcType == GL_UNSIGNED_INT ||
  3790.           srcType == GL_INT ||
  3791.           srcType == GL_HALF_FLOAT_ARB ||
  3792.           srcType == GL_FLOAT ||
  3793.           srcType == GL_UNSIGNED_BYTE_3_3_2 ||
  3794.           srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
  3795.           srcType == GL_UNSIGNED_SHORT_5_6_5 ||
  3796.           srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
  3797.           srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
  3798.           srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
  3799.           srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
  3800.           srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
  3801.           srcType == GL_UNSIGNED_INT_8_8_8_8 ||
  3802.           srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
  3803.           srcType == GL_UNSIGNED_INT_10_10_10_2 ||
  3804.           srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
  3805.           srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
  3806.           srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
  3807.  
  3808.    get_component_mapping(srcFormat,
  3809.                          &rSrc, &gSrc, &bSrc, &aSrc,
  3810.                          &rDst, &gDst, &bDst, &aDst);
  3811.  
  3812.    stride = _mesa_components_in_format(srcFormat);
  3813.  
  3814. #define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT, TYPE, CONVERSION)        \
  3815.    if ((SRC_INDEX) < 0) {                                               \
  3816.       GLuint i;                                                         \
  3817.       for (i = 0; i < n; i++) {                                         \
  3818.          rgba[i][DST_INDEX] = DEFAULT;                                  \
  3819.       }                                                                 \
  3820.    }                                                                    \
  3821.    else if (swapBytes) {                                                \
  3822.       const TYPE *s = (const TYPE *) src;                               \
  3823.       GLuint i;                                                         \
  3824.       for (i = 0; i < n; i++) {                                         \
  3825.          TYPE value = s[SRC_INDEX];                                     \
  3826.          if (sizeof(TYPE) == 2) {                                       \
  3827.             SWAP2BYTE(value);                                           \
  3828.          }                                                              \
  3829.          else if (sizeof(TYPE) == 4) {                                  \
  3830.             SWAP4BYTE(value);                                           \
  3831.          }                                                              \
  3832.          rgba[i][DST_INDEX] = CONVERSION(value);                        \
  3833.          s += stride;                                                   \
  3834.       }                                                                 \
  3835.    }                                                                    \
  3836.    else {                                                               \
  3837.       const TYPE *s = (const TYPE *) src;                               \
  3838.       GLuint i;                                                         \
  3839.       for (i = 0; i < n; i++) {                                         \
  3840.          rgba[i][DST_INDEX] = CONVERSION(s[SRC_INDEX]);                 \
  3841.          s += stride;                                                   \
  3842.       }                                                                 \
  3843.    }
  3844.  
  3845.    switch (srcType) {
  3846.       case GL_UNSIGNED_BYTE:
  3847.          PROCESS(rSrc, RCOMP, 0, GLubyte, (GLuint));
  3848.          PROCESS(gSrc, GCOMP, 0, GLubyte, (GLuint));
  3849.          PROCESS(bSrc, BCOMP, 0, GLubyte, (GLuint));
  3850.          PROCESS(aSrc, ACOMP, 1, GLubyte, (GLuint));
  3851.          break;
  3852.       case GL_BYTE:
  3853.          PROCESS(rSrc, RCOMP, 0, GLbyte, (GLuint));
  3854.          PROCESS(gSrc, GCOMP, 0, GLbyte, (GLuint));
  3855.          PROCESS(bSrc, BCOMP, 0, GLbyte, (GLuint));
  3856.          PROCESS(aSrc, ACOMP, 1, GLbyte, (GLuint));
  3857.          break;
  3858.       case GL_UNSIGNED_SHORT:
  3859.          PROCESS(rSrc, RCOMP, 0, GLushort, (GLuint));
  3860.          PROCESS(gSrc, GCOMP, 0, GLushort, (GLuint));
  3861.          PROCESS(bSrc, BCOMP, 0, GLushort, (GLuint));
  3862.          PROCESS(aSrc, ACOMP, 1, GLushort, (GLuint));
  3863.          break;
  3864.       case GL_SHORT:
  3865.          PROCESS(rSrc, RCOMP, 0, GLshort, (GLuint));
  3866.          PROCESS(gSrc, GCOMP, 0, GLshort, (GLuint));
  3867.          PROCESS(bSrc, BCOMP, 0, GLshort, (GLuint));
  3868.          PROCESS(aSrc, ACOMP, 1, GLshort, (GLuint));
  3869.          break;
  3870.       case GL_UNSIGNED_INT:
  3871.          PROCESS(rSrc, RCOMP, 0, GLuint, (GLuint));
  3872.          PROCESS(gSrc, GCOMP, 0, GLuint, (GLuint));
  3873.          PROCESS(bSrc, BCOMP, 0, GLuint, (GLuint));
  3874.          PROCESS(aSrc, ACOMP, 1, GLuint, (GLuint));
  3875.          break;
  3876.       case GL_INT:
  3877.          PROCESS(rSrc, RCOMP, 0, GLint, (GLuint));
  3878.          PROCESS(gSrc, GCOMP, 0, GLint, (GLuint));
  3879.          PROCESS(bSrc, BCOMP, 0, GLint, (GLuint));
  3880.          PROCESS(aSrc, ACOMP, 1, GLint, (GLuint));
  3881.          break;
  3882.       case GL_FLOAT:
  3883.          PROCESS(rSrc, RCOMP, 0, GLfloat, clamp_float_to_uint);
  3884.          PROCESS(gSrc, GCOMP, 0, GLfloat, clamp_float_to_uint);
  3885.          PROCESS(bSrc, BCOMP, 0, GLfloat, clamp_float_to_uint);
  3886.          PROCESS(aSrc, ACOMP, 1, GLfloat, clamp_float_to_uint);
  3887.          break;
  3888.       case GL_HALF_FLOAT_ARB:
  3889.          PROCESS(rSrc, RCOMP, 0, GLhalfARB, clamp_half_to_uint);
  3890.          PROCESS(gSrc, GCOMP, 0, GLhalfARB, clamp_half_to_uint);
  3891.          PROCESS(bSrc, BCOMP, 0, GLhalfARB, clamp_half_to_uint);
  3892.          PROCESS(aSrc, ACOMP, 1, GLhalfARB, clamp_half_to_uint);
  3893.          break;
  3894.       case GL_UNSIGNED_BYTE_3_3_2:
  3895.          {
  3896.             const GLubyte *ubsrc = (const GLubyte *) src;
  3897.             GLuint i;
  3898.             for (i = 0; i < n; i ++) {
  3899.                GLubyte p = ubsrc[i];
  3900.                rgba[i][rDst] = ((p >> 5)      );
  3901.                rgba[i][gDst] = ((p >> 2) & 0x7);
  3902.                rgba[i][bDst] = ((p     ) & 0x3);
  3903.                rgba[i][aDst] = 1;
  3904.             }
  3905.          }
  3906.          break;
  3907.       case GL_UNSIGNED_BYTE_2_3_3_REV:
  3908.          {
  3909.             const GLubyte *ubsrc = (const GLubyte *) src;
  3910.             GLuint i;
  3911.             for (i = 0; i < n; i ++) {
  3912.                GLubyte p = ubsrc[i];
  3913.                rgba[i][rDst] = ((p     ) & 0x7);
  3914.                rgba[i][gDst] = ((p >> 3) & 0x7);
  3915.                rgba[i][bDst] = ((p >> 6)      );
  3916.                rgba[i][aDst] = 1;
  3917.             }
  3918.          }
  3919.          break;
  3920.       case GL_UNSIGNED_SHORT_5_6_5:
  3921.          if (swapBytes) {
  3922.             const GLushort *ussrc = (const GLushort *) src;
  3923.             GLuint i;
  3924.             for (i = 0; i < n; i ++) {
  3925.                GLushort p = ussrc[i];
  3926.                SWAP2BYTE(p);
  3927.                rgba[i][rDst] = ((p >> 11)       );
  3928.                rgba[i][gDst] = ((p >>  5) & 0x3f);
  3929.                rgba[i][bDst] = ((p      ) & 0x1f);
  3930.                rgba[i][aDst] = 1;
  3931.             }
  3932.          }
  3933.          else {
  3934.             const GLushort *ussrc = (const GLushort *) src;
  3935.             GLuint i;
  3936.             for (i = 0; i < n; i ++) {
  3937.                GLushort p = ussrc[i];
  3938.                rgba[i][rDst] = ((p >> 11)       );
  3939.                rgba[i][gDst] = ((p >>  5) & 0x3f);
  3940.                rgba[i][bDst] = ((p      ) & 0x1f);
  3941.                rgba[i][aDst] = 1;
  3942.             }
  3943.          }
  3944.          break;
  3945.       case GL_UNSIGNED_SHORT_5_6_5_REV:
  3946.          if (swapBytes) {
  3947.             const GLushort *ussrc = (const GLushort *) src;
  3948.             GLuint i;
  3949.             for (i = 0; i < n; i ++) {
  3950.                GLushort p = ussrc[i];
  3951.                SWAP2BYTE(p);
  3952.                rgba[i][rDst] = ((p      ) & 0x1f);
  3953.                rgba[i][gDst] = ((p >>  5) & 0x3f);
  3954.                rgba[i][bDst] = ((p >> 11)       );
  3955.                rgba[i][aDst] = 1;
  3956.             }
  3957.          }
  3958.          else {
  3959.             const GLushort *ussrc = (const GLushort *) src;
  3960.             GLuint i;
  3961.             for (i = 0; i < n; i ++) {
  3962.                GLushort p = ussrc[i];
  3963.                rgba[i][rDst] = ((p      ) & 0x1f);
  3964.                rgba[i][gDst] = ((p >>  5) & 0x3f);
  3965.                rgba[i][bDst] = ((p >> 11)       );
  3966.                rgba[i][aDst] = 1;
  3967.             }
  3968.          }
  3969.          break;
  3970.       case GL_UNSIGNED_SHORT_4_4_4_4:
  3971.          if (swapBytes) {
  3972.             const GLushort *ussrc = (const GLushort *) src;
  3973.             GLuint i;
  3974.             for (i = 0; i < n; i ++) {
  3975.                GLushort p = ussrc[i];
  3976.                SWAP2BYTE(p);
  3977.                rgba[i][rDst] = ((p >> 12)      );
  3978.                rgba[i][gDst] = ((p >>  8) & 0xf);
  3979.                rgba[i][bDst] = ((p >>  4) & 0xf);
  3980.                rgba[i][aDst] = ((p      ) & 0xf);
  3981.             }
  3982.          }
  3983.          else {
  3984.             const GLushort *ussrc = (const GLushort *) src;
  3985.             GLuint i;
  3986.             for (i = 0; i < n; i ++) {
  3987.                GLushort p = ussrc[i];
  3988.                rgba[i][rDst] = ((p >> 12)      );
  3989.                rgba[i][gDst] = ((p >>  8) & 0xf);
  3990.                rgba[i][bDst] = ((p >>  4) & 0xf);
  3991.                rgba[i][aDst] = ((p      ) & 0xf);
  3992.             }
  3993.          }
  3994.          break;
  3995.       case GL_UNSIGNED_SHORT_4_4_4_4_REV:
  3996.          if (swapBytes) {
  3997.             const GLushort *ussrc = (const GLushort *) src;
  3998.             GLuint i;
  3999.             for (i = 0; i < n; i ++) {
  4000.                GLushort p = ussrc[i];
  4001.                SWAP2BYTE(p);
  4002.                rgba[i][rDst] = ((p      ) & 0xf);
  4003.                rgba[i][gDst] = ((p >>  4) & 0xf);
  4004.                rgba[i][bDst] = ((p >>  8) & 0xf);
  4005.                rgba[i][aDst] = ((p >> 12)      );
  4006.             }
  4007.          }
  4008.          else {
  4009.             const GLushort *ussrc = (const GLushort *) src;
  4010.             GLuint i;
  4011.             for (i = 0; i < n; i ++) {
  4012.                GLushort p = ussrc[i];
  4013.                rgba[i][rDst] = ((p      ) & 0xf);
  4014.                rgba[i][gDst] = ((p >>  4) & 0xf);
  4015.                rgba[i][bDst] = ((p >>  8) & 0xf);
  4016.                rgba[i][aDst] = ((p >> 12)      );
  4017.             }
  4018.          }
  4019.          break;
  4020.       case GL_UNSIGNED_SHORT_5_5_5_1:
  4021.          if (swapBytes) {
  4022.             const GLushort *ussrc = (const GLushort *) src;
  4023.             GLuint i;
  4024.             for (i = 0; i < n; i ++) {
  4025.                GLushort p = ussrc[i];
  4026.                SWAP2BYTE(p);
  4027.                rgba[i][rDst] = ((p >> 11)       );
  4028.                rgba[i][gDst] = ((p >>  6) & 0x1f);
  4029.                rgba[i][bDst] = ((p >>  1) & 0x1f);
  4030.                rgba[i][aDst] = ((p      ) & 0x1 );
  4031.             }
  4032.          }
  4033.          else {
  4034.             const GLushort *ussrc = (const GLushort *) src;
  4035.             GLuint i;
  4036.             for (i = 0; i < n; i ++) {
  4037.                GLushort p = ussrc[i];
  4038.                rgba[i][rDst] = ((p >> 11)       );
  4039.                rgba[i][gDst] = ((p >>  6) & 0x1f);
  4040.                rgba[i][bDst] = ((p >>  1) & 0x1f);
  4041.                rgba[i][aDst] = ((p      ) & 0x1 );
  4042.             }
  4043.          }
  4044.          break;
  4045.       case GL_UNSIGNED_SHORT_1_5_5_5_REV:
  4046.          if (swapBytes) {
  4047.             const GLushort *ussrc = (const GLushort *) src;
  4048.             GLuint i;
  4049.             for (i = 0; i < n; i ++) {
  4050.                GLushort p = ussrc[i];
  4051.                SWAP2BYTE(p);
  4052.                rgba[i][rDst] = ((p      ) & 0x1f);
  4053.                rgba[i][gDst] = ((p >>  5) & 0x1f);
  4054.                rgba[i][bDst] = ((p >> 10) & 0x1f);
  4055.                rgba[i][aDst] = ((p >> 15)       );
  4056.             }
  4057.          }
  4058.          else {
  4059.             const GLushort *ussrc = (const GLushort *) src;
  4060.             GLuint i;
  4061.             for (i = 0; i < n; i ++) {
  4062.                GLushort p = ussrc[i];
  4063.                rgba[i][rDst] = ((p      ) & 0x1f);
  4064.                rgba[i][gDst] = ((p >>  5) & 0x1f);
  4065.                rgba[i][bDst] = ((p >> 10) & 0x1f);
  4066.                rgba[i][aDst] = ((p >> 15)       );
  4067.             }
  4068.          }
  4069.          break;
  4070.       case GL_UNSIGNED_INT_8_8_8_8:
  4071.          if (swapBytes) {
  4072.             const GLuint *uisrc = (const GLuint *) src;
  4073.             GLuint i;
  4074.             for (i = 0; i < n; i ++) {
  4075.                GLuint p = uisrc[i];
  4076.                rgba[i][rDst] = ((p      ) & 0xff);
  4077.                rgba[i][gDst] = ((p >>  8) & 0xff);
  4078.                rgba[i][bDst] = ((p >> 16) & 0xff);
  4079.                rgba[i][aDst] = ((p >> 24)       );
  4080.             }
  4081.          }
  4082.          else {
  4083.             const GLuint *uisrc = (const GLuint *) src;
  4084.             GLuint i;
  4085.             for (i = 0; i < n; i ++) {
  4086.                GLuint p = uisrc[i];
  4087.                rgba[i][rDst] = ((p >> 24)       );
  4088.                rgba[i][gDst] = ((p >> 16) & 0xff);
  4089.                rgba[i][bDst] = ((p >>  8) & 0xff);
  4090.                rgba[i][aDst] = ((p      ) & 0xff);
  4091.             }
  4092.          }
  4093.          break;
  4094.       case GL_UNSIGNED_INT_8_8_8_8_REV:
  4095.          if (swapBytes) {
  4096.             const GLuint *uisrc = (const GLuint *) src;
  4097.             GLuint i;
  4098.             for (i = 0; i < n; i ++) {
  4099.                GLuint p = uisrc[i];
  4100.                rgba[i][rDst] = ((p >> 24)       );
  4101.                rgba[i][gDst] = ((p >> 16) & 0xff);
  4102.                rgba[i][bDst] = ((p >>  8) & 0xff);
  4103.                rgba[i][aDst] = ((p      ) & 0xff);
  4104.             }
  4105.          }
  4106.          else {
  4107.             const GLuint *uisrc = (const GLuint *) src;
  4108.             GLuint i;
  4109.             for (i = 0; i < n; i ++) {
  4110.                GLuint p = uisrc[i];
  4111.                rgba[i][rDst] = ((p      ) & 0xff);
  4112.                rgba[i][gDst] = ((p >>  8) & 0xff);
  4113.                rgba[i][bDst] = ((p >> 16) & 0xff);
  4114.                rgba[i][aDst] = ((p >> 24)       );
  4115.             }
  4116.          }
  4117.          break;
  4118.       case GL_UNSIGNED_INT_10_10_10_2:
  4119.          if (swapBytes) {
  4120.             const GLuint *uisrc = (const GLuint *) src;
  4121.             GLuint i;
  4122.             for (i = 0; i < n; i ++) {
  4123.                GLuint p = uisrc[i];
  4124.                SWAP4BYTE(p);
  4125.                rgba[i][rDst] = ((p >> 22)        );
  4126.                rgba[i][gDst] = ((p >> 12) & 0x3ff);
  4127.                rgba[i][bDst] = ((p >>  2) & 0x3ff);
  4128.                rgba[i][aDst] = ((p      ) & 0x3  );
  4129.             }
  4130.          }
  4131.          else {
  4132.             const GLuint *uisrc = (const GLuint *) src;
  4133.             GLuint i;
  4134.             for (i = 0; i < n; i ++) {
  4135.                GLuint p = uisrc[i];
  4136.                rgba[i][rDst] = ((p >> 22)        );
  4137.                rgba[i][gDst] = ((p >> 12) & 0x3ff);
  4138.                rgba[i][bDst] = ((p >>  2) & 0x3ff);
  4139.                rgba[i][aDst] = ((p      ) & 0x3  );
  4140.             }
  4141.          }
  4142.          break;
  4143.       case GL_UNSIGNED_INT_2_10_10_10_REV:
  4144.          if (swapBytes) {
  4145.             const GLuint *uisrc = (const GLuint *) src;
  4146.             GLuint i;
  4147.             for (i = 0; i < n; i ++) {
  4148.                GLuint p = uisrc[i];
  4149.                SWAP4BYTE(p);
  4150.                rgba[i][rDst] = ((p      ) & 0x3ff);
  4151.                rgba[i][gDst] = ((p >> 10) & 0x3ff);
  4152.                rgba[i][bDst] = ((p >> 20) & 0x3ff);
  4153.                rgba[i][aDst] = ((p >> 30)        );
  4154.             }
  4155.          }
  4156.          else {
  4157.             const GLuint *uisrc = (const GLuint *) src;
  4158.             GLuint i;
  4159.             for (i = 0; i < n; i ++) {
  4160.                GLuint p = uisrc[i];
  4161.                rgba[i][rDst] = ((p      ) & 0x3ff);
  4162.                rgba[i][gDst] = ((p >> 10) & 0x3ff);
  4163.                rgba[i][bDst] = ((p >> 20) & 0x3ff);
  4164.                rgba[i][aDst] = ((p >> 30)        );
  4165.             }
  4166.          }
  4167.          break;
  4168.       case GL_UNSIGNED_INT_5_9_9_9_REV:
  4169.          if (swapBytes) {
  4170.             const GLuint *uisrc = (const GLuint *) src;
  4171.             GLuint i;
  4172.             float f[3];
  4173.             for (i = 0; i < n; i ++) {
  4174.                GLuint p = uisrc[i];
  4175.                SWAP4BYTE(p);
  4176.                rgb9e5_to_float3(p, f);
  4177.                rgba[i][rDst] = clamp_float_to_uint(f[0]);
  4178.                rgba[i][gDst] = clamp_float_to_uint(f[1]);
  4179.                rgba[i][bDst] = clamp_float_to_uint(f[2]);
  4180.                rgba[i][aDst] = 1;
  4181.             }
  4182.          }
  4183.          else {
  4184.             const GLuint *uisrc = (const GLuint *) src;
  4185.             GLuint i;
  4186.             float f[3];
  4187.             for (i = 0; i < n; i ++) {
  4188.                GLuint p = uisrc[i];
  4189.                rgb9e5_to_float3(p, f);
  4190.                rgba[i][rDst] = clamp_float_to_uint(f[0]);
  4191.                rgba[i][gDst] = clamp_float_to_uint(f[1]);
  4192.                rgba[i][bDst] = clamp_float_to_uint(f[2]);
  4193.                rgba[i][aDst] = 1;
  4194.             }
  4195.          }
  4196.          break;
  4197.       case GL_UNSIGNED_INT_10F_11F_11F_REV:
  4198.          if (swapBytes) {
  4199.             const GLuint *uisrc = (const GLuint *) src;
  4200.             GLuint i;
  4201.             float f[3];
  4202.             for (i = 0; i < n; i ++) {
  4203.                GLuint p = uisrc[i];
  4204.                SWAP4BYTE(p);
  4205.                r11g11b10f_to_float3(p, f);
  4206.                rgba[i][rDst] = clamp_float_to_uint(f[0]);
  4207.                rgba[i][gDst] = clamp_float_to_uint(f[1]);
  4208.                rgba[i][bDst] = clamp_float_to_uint(f[2]);
  4209.                rgba[i][aDst] = 1;
  4210.             }
  4211.          }
  4212.          else {
  4213.             const GLuint *uisrc = (const GLuint *) src;
  4214.             GLuint i;
  4215.             float f[3];
  4216.             for (i = 0; i < n; i ++) {
  4217.                GLuint p = uisrc[i];
  4218.                r11g11b10f_to_float3(p, f);
  4219.                rgba[i][rDst] = clamp_float_to_uint(f[0]);
  4220.                rgba[i][gDst] = clamp_float_to_uint(f[1]);
  4221.                rgba[i][bDst] = clamp_float_to_uint(f[2]);
  4222.                rgba[i][aDst] = 1;
  4223.             }
  4224.          }
  4225.          break;
  4226.       default:
  4227.          _mesa_problem(NULL, "bad srcType in extract uint data");
  4228.          break;
  4229.    }
  4230. #undef PROCESS
  4231. }
  4232.  
  4233.  
  4234.  
  4235. /*
  4236.  * Unpack a row of color image data from a client buffer according to
  4237.  * the pixel unpacking parameters.
  4238.  * Return GLubyte values in the specified dest image format.
  4239.  * This is used by glDrawPixels and glTexImage?D().
  4240.  * \param ctx - the context
  4241.  *         n - number of pixels in the span
  4242.  *         dstFormat - format of destination color array
  4243.  *         dest - the destination color array
  4244.  *         srcFormat - source image format
  4245.  *         srcType - source image  data type
  4246.  *         source - source image pointer
  4247.  *         srcPacking - pixel unpacking parameters
  4248.  *         transferOps - bitmask of IMAGE_*_BIT values of operations to apply
  4249.  *
  4250.  * XXX perhaps expand this to process whole images someday.
  4251.  */
  4252. void
  4253. _mesa_unpack_color_span_ubyte(struct gl_context *ctx,
  4254.                               GLuint n, GLenum dstFormat, GLubyte dest[],
  4255.                               GLenum srcFormat, GLenum srcType,
  4256.                               const GLvoid *source,
  4257.                               const struct gl_pixelstore_attrib *srcPacking,
  4258.                               GLbitfield transferOps )
  4259. {
  4260.    GLboolean intFormat = _mesa_is_enum_format_integer(srcFormat);
  4261.    ASSERT(dstFormat == GL_ALPHA ||
  4262.           dstFormat == GL_LUMINANCE ||
  4263.           dstFormat == GL_LUMINANCE_ALPHA ||
  4264.           dstFormat == GL_INTENSITY ||
  4265.           dstFormat == GL_RED ||
  4266.           dstFormat == GL_RG ||
  4267.           dstFormat == GL_RGB ||
  4268.           dstFormat == GL_RGBA);
  4269.  
  4270.    ASSERT(srcFormat == GL_RED ||
  4271.           srcFormat == GL_GREEN ||
  4272.           srcFormat == GL_BLUE ||
  4273.           srcFormat == GL_ALPHA ||
  4274.           srcFormat == GL_LUMINANCE ||
  4275.           srcFormat == GL_LUMINANCE_ALPHA ||
  4276.           srcFormat == GL_INTENSITY ||
  4277.           srcFormat == GL_RG ||
  4278.           srcFormat == GL_RGB ||
  4279.           srcFormat == GL_BGR ||
  4280.           srcFormat == GL_RGBA ||
  4281.           srcFormat == GL_BGRA ||
  4282.           srcFormat == GL_ABGR_EXT ||
  4283.           srcFormat == GL_COLOR_INDEX);
  4284.  
  4285.    ASSERT(srcType == GL_BITMAP ||
  4286.           srcType == GL_UNSIGNED_BYTE ||
  4287.           srcType == GL_BYTE ||
  4288.           srcType == GL_UNSIGNED_SHORT ||
  4289.           srcType == GL_SHORT ||
  4290.           srcType == GL_UNSIGNED_INT ||
  4291.           srcType == GL_INT ||
  4292.           srcType == GL_HALF_FLOAT_ARB ||
  4293.           srcType == GL_FLOAT ||
  4294.           srcType == GL_UNSIGNED_BYTE_3_3_2 ||
  4295.           srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
  4296.           srcType == GL_UNSIGNED_SHORT_5_6_5 ||
  4297.           srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
  4298.           srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
  4299.           srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
  4300.           srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
  4301.           srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
  4302.           srcType == GL_UNSIGNED_INT_8_8_8_8 ||
  4303.           srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
  4304.           srcType == GL_UNSIGNED_INT_10_10_10_2 ||
  4305.           srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
  4306.           srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
  4307.           srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
  4308.  
  4309.    /* EXT_texture_integer specifies no transfer ops on integer
  4310.     * types in the resolved issues section. Just set them to 0
  4311.     * for integer surfaces.
  4312.     */
  4313.    if (intFormat)
  4314.       transferOps = 0;
  4315.  
  4316.    /* Try simple cases first */
  4317.    if (transferOps == 0) {
  4318.       if (srcType == GL_UNSIGNED_BYTE) {
  4319.          if (dstFormat == GL_RGBA) {
  4320.             if (srcFormat == GL_RGBA) {
  4321.                memcpy( dest, source, n * 4 * sizeof(GLubyte) );
  4322.                return;
  4323.             }
  4324.             else if (srcFormat == GL_RGB) {
  4325.                GLuint i;
  4326.                const GLubyte *src = (const GLubyte *) source;
  4327.                GLubyte *dst = dest;
  4328.                for (i = 0; i < n; i++) {
  4329.                   dst[0] = src[0];
  4330.                   dst[1] = src[1];
  4331.                   dst[2] = src[2];
  4332.                   dst[3] = 255;
  4333.                   src += 3;
  4334.                   dst += 4;
  4335.                }
  4336.                return;
  4337.             }
  4338.          }
  4339.          else if (dstFormat == GL_RGB) {
  4340.             if (srcFormat == GL_RGB) {
  4341.                memcpy( dest, source, n * 3 * sizeof(GLubyte) );
  4342.                return;
  4343.             }
  4344.             else if (srcFormat == GL_RGBA) {
  4345.                GLuint i;
  4346.                const GLubyte *src = (const GLubyte *) source;
  4347.                GLubyte *dst = dest;
  4348.                for (i = 0; i < n; i++) {
  4349.                   dst[0] = src[0];
  4350.                   dst[1] = src[1];
  4351.                   dst[2] = src[2];
  4352.                   src += 4;
  4353.                   dst += 3;
  4354.                }
  4355.                return;
  4356.             }
  4357.          }
  4358.          else if (dstFormat == srcFormat) {
  4359.             GLint comps = _mesa_components_in_format(srcFormat);
  4360.             assert(comps > 0);
  4361.             memcpy( dest, source, n * comps * sizeof(GLubyte) );
  4362.             return;
  4363.          }
  4364.       }
  4365.    }
  4366.  
  4367.  
  4368.    /* general solution begins here */
  4369.    {
  4370.       GLint dstComponents;
  4371.       GLint rDst, gDst, bDst, aDst, lDst, iDst;
  4372.       GLfloat (*rgba)[4] = malloc(4 * n * sizeof(GLfloat));
  4373.  
  4374.       if (!rgba) {
  4375.          _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
  4376.          return;
  4377.       }
  4378.  
  4379.       dstComponents = _mesa_components_in_format( dstFormat );
  4380.       /* source & dest image formats should have been error checked by now */
  4381.       assert(dstComponents > 0);
  4382.  
  4383.       /*
  4384.        * Extract image data and convert to RGBA floats
  4385.        */
  4386.       if (srcFormat == GL_COLOR_INDEX) {
  4387.          GLuint *indexes = malloc(n * sizeof(GLuint));
  4388.  
  4389.          if (!indexes) {
  4390.             _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
  4391.             free(rgba);
  4392.             return;
  4393.          }
  4394.  
  4395.          extract_uint_indexes(n, indexes, srcFormat, srcType, source,
  4396.                               srcPacking);
  4397.  
  4398.          /* Convert indexes to RGBA */
  4399.          if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
  4400.             _mesa_shift_and_offset_ci(ctx, n, indexes);
  4401.          }
  4402.          _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
  4403.  
  4404.          /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
  4405.           * with color indexes.
  4406.           */
  4407.          transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
  4408.  
  4409.          free(indexes);
  4410.       }
  4411.       else {
  4412.          /* non-color index data */
  4413.          extract_float_rgba(n, rgba, srcFormat, srcType, source,
  4414.                             srcPacking->SwapBytes);
  4415.       }
  4416.  
  4417.       /* Need to clamp if returning GLubytes */
  4418.       transferOps |= IMAGE_CLAMP_BIT;
  4419.  
  4420.       if (transferOps) {
  4421.          _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
  4422.       }
  4423.  
  4424.       get_component_indexes(dstFormat,
  4425.                             &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
  4426.  
  4427.       /* Now return the GLubyte data in the requested dstFormat */
  4428.       if (rDst >= 0) {
  4429.          GLubyte *dst = dest;
  4430.          GLuint i;
  4431.          for (i = 0; i < n; i++) {
  4432.             CLAMPED_FLOAT_TO_UBYTE(dst[rDst], rgba[i][RCOMP]);
  4433.             dst += dstComponents;
  4434.          }
  4435.       }
  4436.  
  4437.       if (gDst >= 0) {
  4438.          GLubyte *dst = dest;
  4439.          GLuint i;
  4440.          for (i = 0; i < n; i++) {
  4441.             CLAMPED_FLOAT_TO_UBYTE(dst[gDst], rgba[i][GCOMP]);
  4442.             dst += dstComponents;
  4443.          }
  4444.       }
  4445.  
  4446.       if (bDst >= 0) {
  4447.          GLubyte *dst = dest;
  4448.          GLuint i;
  4449.          for (i = 0; i < n; i++) {
  4450.             CLAMPED_FLOAT_TO_UBYTE(dst[bDst], rgba[i][BCOMP]);
  4451.             dst += dstComponents;
  4452.          }
  4453.       }
  4454.  
  4455.       if (aDst >= 0) {
  4456.          GLubyte *dst = dest;
  4457.          GLuint i;
  4458.          for (i = 0; i < n; i++) {
  4459.             CLAMPED_FLOAT_TO_UBYTE(dst[aDst], rgba[i][ACOMP]);
  4460.             dst += dstComponents;
  4461.          }
  4462.       }
  4463.  
  4464.       if (iDst >= 0) {
  4465.          GLubyte *dst = dest;
  4466.          GLuint i;
  4467.          assert(iDst == 0);
  4468.          assert(dstComponents == 1);
  4469.          for (i = 0; i < n; i++) {
  4470.             /* Intensity comes from red channel */
  4471.             CLAMPED_FLOAT_TO_UBYTE(dst[i], rgba[i][RCOMP]);
  4472.          }
  4473.       }
  4474.  
  4475.       if (lDst >= 0) {
  4476.          GLubyte *dst = dest;
  4477.          GLuint i;
  4478.          assert(lDst == 0);
  4479.          for (i = 0; i < n; i++) {
  4480.             /* Luminance comes from red channel */
  4481.             CLAMPED_FLOAT_TO_UBYTE(dst[0], rgba[i][RCOMP]);
  4482.             dst += dstComponents;
  4483.          }
  4484.       }
  4485.  
  4486.       free(rgba);
  4487.    }
  4488. }
  4489.  
  4490.  
  4491. /**
  4492.  * Same as _mesa_unpack_color_span_ubyte(), but return GLfloat data
  4493.  * instead of GLubyte.
  4494.  */
  4495. void
  4496. _mesa_unpack_color_span_float( struct gl_context *ctx,
  4497.                                GLuint n, GLenum dstFormat, GLfloat dest[],
  4498.                                GLenum srcFormat, GLenum srcType,
  4499.                                const GLvoid *source,
  4500.                                const struct gl_pixelstore_attrib *srcPacking,
  4501.                                GLbitfield transferOps )
  4502. {
  4503.    ASSERT(dstFormat == GL_ALPHA ||
  4504.           dstFormat == GL_LUMINANCE ||
  4505.           dstFormat == GL_LUMINANCE_ALPHA ||
  4506.           dstFormat == GL_INTENSITY ||
  4507.           dstFormat == GL_RED ||
  4508.           dstFormat == GL_RG ||
  4509.           dstFormat == GL_RGB ||
  4510.           dstFormat == GL_RGBA);
  4511.  
  4512.    ASSERT(srcFormat == GL_RED ||
  4513.           srcFormat == GL_GREEN ||
  4514.           srcFormat == GL_BLUE ||
  4515.           srcFormat == GL_ALPHA ||
  4516.           srcFormat == GL_LUMINANCE ||
  4517.           srcFormat == GL_LUMINANCE_ALPHA ||
  4518.           srcFormat == GL_INTENSITY ||
  4519.           srcFormat == GL_RG ||
  4520.           srcFormat == GL_RGB ||
  4521.           srcFormat == GL_BGR ||
  4522.           srcFormat == GL_RGBA ||
  4523.           srcFormat == GL_BGRA ||
  4524.           srcFormat == GL_ABGR_EXT ||
  4525.           srcFormat == GL_RED_INTEGER_EXT ||
  4526.           srcFormat == GL_GREEN_INTEGER_EXT ||
  4527.           srcFormat == GL_BLUE_INTEGER_EXT ||
  4528.           srcFormat == GL_ALPHA_INTEGER_EXT ||
  4529.           srcFormat == GL_RG_INTEGER ||
  4530.           srcFormat == GL_RGB_INTEGER_EXT ||
  4531.           srcFormat == GL_RGBA_INTEGER_EXT ||
  4532.           srcFormat == GL_BGR_INTEGER_EXT ||
  4533.           srcFormat == GL_BGRA_INTEGER_EXT ||
  4534.           srcFormat == GL_LUMINANCE_INTEGER_EXT ||
  4535.           srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT ||
  4536.           srcFormat == GL_COLOR_INDEX);
  4537.  
  4538.    ASSERT(srcType == GL_BITMAP ||
  4539.           srcType == GL_UNSIGNED_BYTE ||
  4540.           srcType == GL_BYTE ||
  4541.           srcType == GL_UNSIGNED_SHORT ||
  4542.           srcType == GL_SHORT ||
  4543.           srcType == GL_UNSIGNED_INT ||
  4544.           srcType == GL_INT ||
  4545.           srcType == GL_HALF_FLOAT_ARB ||
  4546.           srcType == GL_FLOAT ||
  4547.           srcType == GL_UNSIGNED_BYTE_3_3_2 ||
  4548.           srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
  4549.           srcType == GL_UNSIGNED_SHORT_5_6_5 ||
  4550.           srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
  4551.           srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
  4552.           srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
  4553.           srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
  4554.           srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
  4555.           srcType == GL_UNSIGNED_INT_8_8_8_8 ||
  4556.           srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
  4557.           srcType == GL_UNSIGNED_INT_10_10_10_2 ||
  4558.           srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
  4559.           srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
  4560.           srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
  4561.  
  4562.    /* general solution, no special cases, yet */
  4563.    {
  4564.       GLint dstComponents;
  4565.       GLint rDst, gDst, bDst, aDst, lDst, iDst;
  4566.       GLfloat (*rgba)[4] = malloc(4 * n * sizeof(GLfloat));
  4567.       GLboolean intFormat = _mesa_is_enum_format_integer(srcFormat);
  4568.  
  4569.       if (!rgba) {
  4570.          _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
  4571.          return;
  4572.       }
  4573.  
  4574.       dstComponents = _mesa_components_in_format( dstFormat );
  4575.       /* source & dest image formats should have been error checked by now */
  4576.       assert(dstComponents > 0);
  4577.  
  4578.       /* EXT_texture_integer specifies no transfer ops on integer
  4579.        * types in the resolved issues section. Just set them to 0
  4580.        * for integer surfaces.
  4581.        */
  4582.       if (intFormat)
  4583.          transferOps = 0;
  4584.  
  4585.       /*
  4586.        * Extract image data and convert to RGBA floats
  4587.        */
  4588.       if (srcFormat == GL_COLOR_INDEX) {
  4589.          GLuint *indexes = malloc(n * sizeof(GLuint));
  4590.  
  4591.          if (!indexes) {
  4592.             _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
  4593.             free(rgba);
  4594.             return;
  4595.          }
  4596.  
  4597.          extract_uint_indexes(n, indexes, srcFormat, srcType, source,
  4598.                               srcPacking);
  4599.  
  4600.          /* Convert indexes to RGBA */
  4601.          if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
  4602.             _mesa_shift_and_offset_ci(ctx, n, indexes);
  4603.          }
  4604.          _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
  4605.  
  4606.          /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
  4607.           * with color indexes.
  4608.           */
  4609.          transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
  4610.  
  4611.          free(indexes);
  4612.       }
  4613.       else {
  4614.          /* non-color index data */
  4615.          extract_float_rgba(n, rgba, srcFormat, srcType, source,
  4616.                             srcPacking->SwapBytes);
  4617.       }
  4618.  
  4619.       if (transferOps) {
  4620.          _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
  4621.       }
  4622.  
  4623.       get_component_indexes(dstFormat,
  4624.                             &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
  4625.  
  4626.       /* Now pack results in the requested dstFormat */
  4627.       if (rDst >= 0) {
  4628.          GLfloat *dst = dest;
  4629.          GLuint i;
  4630.          for (i = 0; i < n; i++) {
  4631.             dst[rDst] = rgba[i][RCOMP];
  4632.             dst += dstComponents;
  4633.          }
  4634.       }
  4635.  
  4636.       if (gDst >= 0) {
  4637.          GLfloat *dst = dest;
  4638.          GLuint i;
  4639.          for (i = 0; i < n; i++) {
  4640.             dst[gDst] = rgba[i][GCOMP];
  4641.             dst += dstComponents;
  4642.          }
  4643.       }
  4644.  
  4645.       if (bDst >= 0) {
  4646.          GLfloat *dst = dest;
  4647.          GLuint i;
  4648.          for (i = 0; i < n; i++) {
  4649.             dst[bDst] = rgba[i][BCOMP];
  4650.             dst += dstComponents;
  4651.          }
  4652.       }
  4653.  
  4654.       if (aDst >= 0) {
  4655.          GLfloat *dst = dest;
  4656.          GLuint i;
  4657.          for (i = 0; i < n; i++) {
  4658.             dst[aDst] = rgba[i][ACOMP];
  4659.             dst += dstComponents;
  4660.          }
  4661.       }
  4662.  
  4663.       if (iDst >= 0) {
  4664.          GLfloat *dst = dest;
  4665.          GLuint i;
  4666.          assert(iDst == 0);
  4667.          assert(dstComponents == 1);
  4668.          for (i = 0; i < n; i++) {
  4669.             /* Intensity comes from red channel */
  4670.             dst[i] = rgba[i][RCOMP];
  4671.          }
  4672.       }
  4673.  
  4674.       if (lDst >= 0) {
  4675.          GLfloat *dst = dest;
  4676.          GLuint i;
  4677.          assert(lDst == 0);
  4678.          for (i = 0; i < n; i++) {
  4679.             /* Luminance comes from red channel */
  4680.             dst[0] = rgba[i][RCOMP];
  4681.             dst += dstComponents;
  4682.          }
  4683.       }
  4684.  
  4685.       free(rgba);
  4686.    }
  4687. }
  4688.  
  4689.  
  4690. /**
  4691.  * Same as _mesa_unpack_color_span_ubyte(), but return GLuint data
  4692.  * instead of GLubyte.
  4693.  * No pixel transfer ops are applied.
  4694.  */
  4695. void
  4696. _mesa_unpack_color_span_uint(struct gl_context *ctx,
  4697.                              GLuint n, GLenum dstFormat, GLuint *dest,
  4698.                              GLenum srcFormat, GLenum srcType,
  4699.                              const GLvoid *source,
  4700.                              const struct gl_pixelstore_attrib *srcPacking)
  4701. {
  4702.    GLuint (*rgba)[4] = malloc(n * 4 * sizeof(GLfloat));
  4703.  
  4704.    if (!rgba) {
  4705.       _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
  4706.       return;
  4707.    }
  4708.  
  4709.    ASSERT(dstFormat == GL_ALPHA ||
  4710.           dstFormat == GL_LUMINANCE ||
  4711.           dstFormat == GL_LUMINANCE_ALPHA ||
  4712.           dstFormat == GL_INTENSITY ||
  4713.           dstFormat == GL_RED ||
  4714.           dstFormat == GL_RG ||
  4715.           dstFormat == GL_RGB ||
  4716.           dstFormat == GL_RGBA);
  4717.  
  4718.    ASSERT(srcFormat == GL_RED ||
  4719.           srcFormat == GL_GREEN ||
  4720.           srcFormat == GL_BLUE ||
  4721.           srcFormat == GL_ALPHA ||
  4722.           srcFormat == GL_LUMINANCE ||
  4723.           srcFormat == GL_LUMINANCE_ALPHA ||
  4724.           srcFormat == GL_INTENSITY ||
  4725.           srcFormat == GL_RG ||
  4726.           srcFormat == GL_RGB ||
  4727.           srcFormat == GL_BGR ||
  4728.           srcFormat == GL_RGBA ||
  4729.           srcFormat == GL_BGRA ||
  4730.           srcFormat == GL_ABGR_EXT ||
  4731.           srcFormat == GL_RED_INTEGER_EXT ||
  4732.           srcFormat == GL_GREEN_INTEGER_EXT ||
  4733.           srcFormat == GL_BLUE_INTEGER_EXT ||
  4734.           srcFormat == GL_ALPHA_INTEGER_EXT ||
  4735.           srcFormat == GL_RG_INTEGER ||
  4736.           srcFormat == GL_RGB_INTEGER_EXT ||
  4737.           srcFormat == GL_RGBA_INTEGER_EXT ||
  4738.           srcFormat == GL_BGR_INTEGER_EXT ||
  4739.           srcFormat == GL_BGRA_INTEGER_EXT ||
  4740.           srcFormat == GL_LUMINANCE_INTEGER_EXT ||
  4741.           srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
  4742.  
  4743.    ASSERT(srcType == GL_UNSIGNED_BYTE ||
  4744.           srcType == GL_BYTE ||
  4745.           srcType == GL_UNSIGNED_SHORT ||
  4746.           srcType == GL_SHORT ||
  4747.           srcType == GL_UNSIGNED_INT ||
  4748.           srcType == GL_INT ||
  4749.           srcType == GL_HALF_FLOAT_ARB ||
  4750.           srcType == GL_FLOAT ||
  4751.           srcType == GL_UNSIGNED_BYTE_3_3_2 ||
  4752.           srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
  4753.           srcType == GL_UNSIGNED_SHORT_5_6_5 ||
  4754.           srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
  4755.           srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
  4756.           srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
  4757.           srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
  4758.           srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
  4759.           srcType == GL_UNSIGNED_INT_8_8_8_8 ||
  4760.           srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
  4761.           srcType == GL_UNSIGNED_INT_10_10_10_2 ||
  4762.           srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
  4763.           srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
  4764.           srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
  4765.  
  4766.  
  4767.    /* Extract image data as uint[4] pixels */
  4768.    extract_uint_rgba(n, rgba, srcFormat, srcType, source,
  4769.                      srcPacking->SwapBytes);
  4770.  
  4771.    if (dstFormat == GL_RGBA) {
  4772.       /* simple case */
  4773.       memcpy(dest, rgba, 4 * sizeof(GLuint) * n);
  4774.    }
  4775.    else {
  4776.       /* general case */
  4777.       GLint rDst, gDst, bDst, aDst, lDst, iDst;
  4778.       GLint dstComponents = _mesa_components_in_format( dstFormat );
  4779.  
  4780.       assert(dstComponents > 0);
  4781.  
  4782.       get_component_indexes(dstFormat,
  4783.                             &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
  4784.  
  4785.       /* Now pack values in the requested dest format */
  4786.       if (rDst >= 0) {
  4787.          GLuint *dst = dest;
  4788.          GLuint i;
  4789.          for (i = 0; i < n; i++) {
  4790.             dst[rDst] = rgba[i][RCOMP];
  4791.             dst += dstComponents;
  4792.          }
  4793.       }
  4794.  
  4795.       if (gDst >= 0) {
  4796.          GLuint *dst = dest;
  4797.          GLuint i;
  4798.          for (i = 0; i < n; i++) {
  4799.             dst[gDst] = rgba[i][GCOMP];
  4800.             dst += dstComponents;
  4801.          }
  4802.       }
  4803.  
  4804.       if (bDst >= 0) {
  4805.          GLuint *dst = dest;
  4806.          GLuint i;
  4807.          for (i = 0; i < n; i++) {
  4808.             dst[bDst] = rgba[i][BCOMP];
  4809.             dst += dstComponents;
  4810.          }
  4811.       }
  4812.  
  4813.       if (aDst >= 0) {
  4814.          GLuint *dst = dest;
  4815.          GLuint i;
  4816.          for (i = 0; i < n; i++) {
  4817.             dst[aDst] = rgba[i][ACOMP];
  4818.             dst += dstComponents;
  4819.          }
  4820.       }
  4821.  
  4822.       if (iDst >= 0) {
  4823.          GLuint *dst = dest;
  4824.          GLuint i;
  4825.          assert(iDst == 0);
  4826.          assert(dstComponents == 1);
  4827.          for (i = 0; i < n; i++) {
  4828.             /* Intensity comes from red channel */
  4829.             dst[i] = rgba[i][RCOMP];
  4830.          }
  4831.       }
  4832.  
  4833.       if (lDst >= 0) {
  4834.          GLuint *dst = dest;
  4835.          GLuint i;
  4836.          assert(lDst == 0);
  4837.          for (i = 0; i < n; i++) {
  4838.             /* Luminance comes from red channel */
  4839.             dst[0] = rgba[i][RCOMP];
  4840.             dst += dstComponents;
  4841.          }
  4842.       }
  4843.    }
  4844.  
  4845.    free(rgba);
  4846. }
  4847.  
  4848.  
  4849.  
  4850. /**
  4851.  * Similar to _mesa_unpack_color_span_float(), but for dudv data instead of rgba,
  4852.  * directly return GLbyte data, no transfer ops apply.
  4853.  */
  4854. void
  4855. _mesa_unpack_dudv_span_byte( struct gl_context *ctx,
  4856.                              GLuint n, GLenum dstFormat, GLbyte dest[],
  4857.                              GLenum srcFormat, GLenum srcType,
  4858.                              const GLvoid *source,
  4859.                              const struct gl_pixelstore_attrib *srcPacking,
  4860.                              GLbitfield transferOps )
  4861. {
  4862.    ASSERT(dstFormat == GL_DUDV_ATI);
  4863.    ASSERT(srcFormat == GL_DUDV_ATI ||
  4864.           srcFormat == GL_DU8DV8_ATI);
  4865.  
  4866.    ASSERT(srcType == GL_UNSIGNED_BYTE ||
  4867.           srcType == GL_BYTE ||
  4868.           srcType == GL_UNSIGNED_SHORT ||
  4869.           srcType == GL_SHORT ||
  4870.           srcType == GL_UNSIGNED_INT ||
  4871.           srcType == GL_INT ||
  4872.           srcType == GL_HALF_FLOAT_ARB ||
  4873.           srcType == GL_FLOAT);
  4874.  
  4875.    /* general solution */
  4876.    {
  4877.       GLint dstComponents;
  4878.       GLbyte *dst = dest;
  4879.       GLuint i;
  4880.       GLfloat (*rgba)[4] = malloc(4 * n * sizeof(GLfloat));
  4881.  
  4882.       if (!rgba) {
  4883.          _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
  4884.          return;
  4885.       }
  4886.  
  4887.       dstComponents = _mesa_components_in_format( dstFormat );
  4888.       /* source & dest image formats should have been error checked by now */
  4889.       assert(dstComponents > 0);
  4890.  
  4891.       /*
  4892.        * Extract image data and convert to RGBA floats
  4893.        */
  4894.       extract_float_rgba(n, rgba, srcFormat, srcType, source,
  4895.                          srcPacking->SwapBytes);
  4896.  
  4897.  
  4898.       /* Now determine which color channels we need to produce.
  4899.        * And determine the dest index (offset) within each color tuple.
  4900.        */
  4901.  
  4902.       /* Now pack results in the requested dstFormat */
  4903.       for (i = 0; i < n; i++) {
  4904.          /* not sure - need clamp[-1,1] here? */
  4905.          dst[0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
  4906.          dst[1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
  4907.          dst += dstComponents;
  4908.       }
  4909.  
  4910.       free(rgba);
  4911.    }
  4912. }
  4913.  
  4914. /*
  4915.  * Unpack a row of color index data from a client buffer according to
  4916.  * the pixel unpacking parameters.
  4917.  * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
  4918.  *
  4919.  * Args:  ctx - the context
  4920.  *        n - number of pixels
  4921.  *        dstType - destination data type
  4922.  *        dest - destination array
  4923.  *        srcType - source pixel type
  4924.  *        source - source data pointer
  4925.  *        srcPacking - pixel unpacking parameters
  4926.  *        transferOps - the pixel transfer operations to apply
  4927.  */
  4928. void
  4929. _mesa_unpack_index_span( struct gl_context *ctx, GLuint n,
  4930.                          GLenum dstType, GLvoid *dest,
  4931.                          GLenum srcType, const GLvoid *source,
  4932.                          const struct gl_pixelstore_attrib *srcPacking,
  4933.                          GLbitfield transferOps )
  4934. {
  4935.    ASSERT(srcType == GL_BITMAP ||
  4936.           srcType == GL_UNSIGNED_BYTE ||
  4937.           srcType == GL_BYTE ||
  4938.           srcType == GL_UNSIGNED_SHORT ||
  4939.           srcType == GL_SHORT ||
  4940.           srcType == GL_UNSIGNED_INT ||
  4941.           srcType == GL_INT ||
  4942.           srcType == GL_HALF_FLOAT_ARB ||
  4943.           srcType == GL_FLOAT);
  4944.  
  4945.    ASSERT(dstType == GL_UNSIGNED_BYTE ||
  4946.           dstType == GL_UNSIGNED_SHORT ||
  4947.           dstType == GL_UNSIGNED_INT);
  4948.  
  4949.  
  4950.    transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
  4951.  
  4952.    /*
  4953.     * Try simple cases first
  4954.     */
  4955.    if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
  4956.        && dstType == GL_UNSIGNED_BYTE) {
  4957.       memcpy(dest, source, n * sizeof(GLubyte));
  4958.    }
  4959.    else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
  4960.             && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
  4961.       memcpy(dest, source, n * sizeof(GLuint));
  4962.    }
  4963.    else {
  4964.       /*
  4965.        * general solution
  4966.        */
  4967.       GLuint *indexes = malloc(n * sizeof(GLuint));
  4968.  
  4969.       if (!indexes) {
  4970.          _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
  4971.          return;
  4972.       }
  4973.  
  4974.       extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
  4975.                            srcPacking);
  4976.  
  4977.       if (transferOps)
  4978.          _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
  4979.  
  4980.       /* convert to dest type */
  4981.       switch (dstType) {
  4982.          case GL_UNSIGNED_BYTE:
  4983.             {
  4984.                GLubyte *dst = (GLubyte *) dest;
  4985.                GLuint i;
  4986.                for (i = 0; i < n; i++) {
  4987.                   dst[i] = (GLubyte) (indexes[i] & 0xff);
  4988.                }
  4989.             }
  4990.             break;
  4991.          case GL_UNSIGNED_SHORT:
  4992.             {
  4993.                GLuint *dst = (GLuint *) dest;
  4994.                GLuint i;
  4995.                for (i = 0; i < n; i++) {
  4996.                   dst[i] = (GLushort) (indexes[i] & 0xffff);
  4997.                }
  4998.             }
  4999.             break;
  5000.          case GL_UNSIGNED_INT:
  5001.             memcpy(dest, indexes, n * sizeof(GLuint));
  5002.             break;
  5003.          default:
  5004.             _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");
  5005.       }
  5006.  
  5007.       free(indexes);
  5008.    }
  5009. }
  5010.  
  5011.  
  5012. void
  5013. _mesa_pack_index_span( struct gl_context *ctx, GLuint n,
  5014.                        GLenum dstType, GLvoid *dest, const GLuint *source,
  5015.                        const struct gl_pixelstore_attrib *dstPacking,
  5016.                        GLbitfield transferOps )
  5017. {
  5018.    GLuint *indexes = malloc(n * sizeof(GLuint));
  5019.  
  5020.    if (!indexes) {
  5021.       _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
  5022.       return;
  5023.    }
  5024.  
  5025.    transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
  5026.  
  5027.    if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) {
  5028.       /* make a copy of input */
  5029.       memcpy(indexes, source, n * sizeof(GLuint));
  5030.       _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
  5031.       source = indexes;
  5032.    }
  5033.  
  5034.    switch (dstType) {
  5035.    case GL_UNSIGNED_BYTE:
  5036.       {
  5037.          GLubyte *dst = (GLubyte *) dest;
  5038.          GLuint i;
  5039.          for (i = 0; i < n; i++) {
  5040.             *dst++ = (GLubyte) source[i];
  5041.          }
  5042.       }
  5043.       break;
  5044.    case GL_BYTE:
  5045.       {
  5046.          GLbyte *dst = (GLbyte *) dest;
  5047.          GLuint i;
  5048.          for (i = 0; i < n; i++) {
  5049.             dst[i] = (GLbyte) source[i];
  5050.          }
  5051.       }
  5052.       break;
  5053.    case GL_UNSIGNED_SHORT:
  5054.       {
  5055.          GLushort *dst = (GLushort *) dest;
  5056.          GLuint i;
  5057.          for (i = 0; i < n; i++) {
  5058.             dst[i] = (GLushort) source[i];
  5059.          }
  5060.          if (dstPacking->SwapBytes) {
  5061.             _mesa_swap2( (GLushort *) dst, n );
  5062.          }
  5063.       }
  5064.       break;
  5065.    case GL_SHORT:
  5066.       {
  5067.          GLshort *dst = (GLshort *) dest;
  5068.          GLuint i;
  5069.          for (i = 0; i < n; i++) {
  5070.             dst[i] = (GLshort) source[i];
  5071.          }
  5072.          if (dstPacking->SwapBytes) {
  5073.             _mesa_swap2( (GLushort *) dst, n );
  5074.          }
  5075.       }
  5076.       break;
  5077.    case GL_UNSIGNED_INT:
  5078.       {
  5079.          GLuint *dst = (GLuint *) dest;
  5080.          GLuint i;
  5081.          for (i = 0; i < n; i++) {
  5082.             dst[i] = (GLuint) source[i];
  5083.          }
  5084.          if (dstPacking->SwapBytes) {
  5085.             _mesa_swap4( (GLuint *) dst, n );
  5086.          }
  5087.       }
  5088.       break;
  5089.    case GL_INT:
  5090.       {
  5091.          GLint *dst = (GLint *) dest;
  5092.          GLuint i;
  5093.          for (i = 0; i < n; i++) {
  5094.             dst[i] = (GLint) source[i];
  5095.          }
  5096.          if (dstPacking->SwapBytes) {
  5097.             _mesa_swap4( (GLuint *) dst, n );
  5098.          }
  5099.       }
  5100.       break;
  5101.    case GL_FLOAT:
  5102.       {
  5103.          GLfloat *dst = (GLfloat *) dest;
  5104.          GLuint i;
  5105.          for (i = 0; i < n; i++) {
  5106.             dst[i] = (GLfloat) source[i];
  5107.          }
  5108.          if (dstPacking->SwapBytes) {
  5109.             _mesa_swap4( (GLuint *) dst, n );
  5110.          }
  5111.       }
  5112.       break;
  5113.    case GL_HALF_FLOAT_ARB:
  5114.       {
  5115.          GLhalfARB *dst = (GLhalfARB *) dest;
  5116.          GLuint i;
  5117.          for (i = 0; i < n; i++) {
  5118.             dst[i] = _mesa_float_to_half((GLfloat) source[i]);
  5119.          }
  5120.          if (dstPacking->SwapBytes) {
  5121.             _mesa_swap2( (GLushort *) dst, n );
  5122.          }
  5123.       }
  5124.       break;
  5125.    default:
  5126.       _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
  5127.    }
  5128.  
  5129.    free(indexes);
  5130. }
  5131.  
  5132.  
  5133. /*
  5134.  * Unpack a row of stencil data from a client buffer according to
  5135.  * the pixel unpacking parameters.
  5136.  * This is (or will be) used by glDrawPixels
  5137.  *
  5138.  * Args:  ctx - the context
  5139.  *        n - number of pixels
  5140.  *        dstType - destination data type
  5141.  *        dest - destination array
  5142.  *        srcType - source pixel type
  5143.  *        source - source data pointer
  5144.  *        srcPacking - pixel unpacking parameters
  5145.  *        transferOps - apply offset/bias/lookup ops?
  5146.  */
  5147. void
  5148. _mesa_unpack_stencil_span( struct gl_context *ctx, GLuint n,
  5149.                            GLenum dstType, GLvoid *dest,
  5150.                            GLenum srcType, const GLvoid *source,
  5151.                            const struct gl_pixelstore_attrib *srcPacking,
  5152.                            GLbitfield transferOps )
  5153. {
  5154.    ASSERT(srcType == GL_BITMAP ||
  5155.           srcType == GL_UNSIGNED_BYTE ||
  5156.           srcType == GL_BYTE ||
  5157.           srcType == GL_UNSIGNED_SHORT ||
  5158.           srcType == GL_SHORT ||
  5159.           srcType == GL_UNSIGNED_INT ||
  5160.           srcType == GL_INT ||
  5161.           srcType == GL_UNSIGNED_INT_24_8_EXT ||
  5162.           srcType == GL_HALF_FLOAT_ARB ||
  5163.           srcType == GL_FLOAT ||
  5164.           srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
  5165.  
  5166.    ASSERT(dstType == GL_UNSIGNED_BYTE ||
  5167.           dstType == GL_UNSIGNED_SHORT ||
  5168.           dstType == GL_UNSIGNED_INT ||
  5169.           dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
  5170.  
  5171.    /* only shift and offset apply to stencil */
  5172.    transferOps &= IMAGE_SHIFT_OFFSET_BIT;
  5173.  
  5174.    /*
  5175.     * Try simple cases first
  5176.     */
  5177.    if (transferOps == 0 &&
  5178.        !ctx->Pixel.MapStencilFlag &&
  5179.        srcType == GL_UNSIGNED_BYTE &&
  5180.        dstType == GL_UNSIGNED_BYTE) {
  5181.       memcpy(dest, source, n * sizeof(GLubyte));
  5182.    }
  5183.    else if (transferOps == 0 &&
  5184.             !ctx->Pixel.MapStencilFlag &&
  5185.             srcType == GL_UNSIGNED_INT &&
  5186.             dstType == GL_UNSIGNED_INT &&
  5187.             !srcPacking->SwapBytes) {
  5188.       memcpy(dest, source, n * sizeof(GLuint));
  5189.    }
  5190.    else {
  5191.       /*
  5192.        * general solution
  5193.        */
  5194.       GLuint *indexes = malloc(n * sizeof(GLuint));
  5195.  
  5196.       if (!indexes) {
  5197.          _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil unpacking");
  5198.          return;
  5199.       }
  5200.  
  5201.       extract_uint_indexes(n, indexes, GL_STENCIL_INDEX, srcType, source,
  5202.                            srcPacking);
  5203.  
  5204.       if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
  5205.          /* shift and offset indexes */
  5206.          _mesa_shift_and_offset_ci(ctx, n, indexes);
  5207.       }
  5208.  
  5209.       if (ctx->Pixel.MapStencilFlag) {
  5210.          /* Apply stencil lookup table */
  5211.          const GLuint mask = ctx->PixelMaps.StoS.Size - 1;
  5212.          GLuint i;
  5213.          for (i = 0; i < n; i++) {
  5214.             indexes[i] = (GLuint)ctx->PixelMaps.StoS.Map[ indexes[i] & mask ];
  5215.          }
  5216.       }
  5217.  
  5218.       /* convert to dest type */
  5219.       switch (dstType) {
  5220.          case GL_UNSIGNED_BYTE:
  5221.             {
  5222.                GLubyte *dst = (GLubyte *) dest;
  5223.                GLuint i;
  5224.                for (i = 0; i < n; i++) {
  5225.                   dst[i] = (GLubyte) (indexes[i] & 0xff);
  5226.                }
  5227.             }
  5228.             break;
  5229.          case GL_UNSIGNED_SHORT:
  5230.             {
  5231.                GLuint *dst = (GLuint *) dest;
  5232.                GLuint i;
  5233.                for (i = 0; i < n; i++) {
  5234.                   dst[i] = (GLushort) (indexes[i] & 0xffff);
  5235.                }
  5236.             }
  5237.             break;
  5238.          case GL_UNSIGNED_INT:
  5239.             memcpy(dest, indexes, n * sizeof(GLuint));
  5240.             break;
  5241.          case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
  5242.             {
  5243.                GLuint *dst = (GLuint *) dest;
  5244.                GLuint i;
  5245.                for (i = 0; i < n; i++) {
  5246.                   dst[i*2+1] = indexes[i] & 0xff; /* lower 8 bits */
  5247.                }
  5248.             }
  5249.             break;
  5250.          default:
  5251.             _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
  5252.       }
  5253.  
  5254.       free(indexes);
  5255.    }
  5256. }
  5257.  
  5258.  
  5259. void
  5260. _mesa_pack_stencil_span( struct gl_context *ctx, GLuint n,
  5261.                          GLenum dstType, GLvoid *dest, const GLubyte *source,
  5262.                          const struct gl_pixelstore_attrib *dstPacking )
  5263. {
  5264.    GLubyte *stencil = malloc(n * sizeof(GLubyte));
  5265.  
  5266.    if (!stencil) {
  5267.       _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil packing");
  5268.       return;
  5269.    }
  5270.  
  5271.    if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||
  5272.        ctx->Pixel.MapStencilFlag) {
  5273.       /* make a copy of input */
  5274.       memcpy(stencil, source, n * sizeof(GLubyte));
  5275.       _mesa_apply_stencil_transfer_ops(ctx, n, stencil);
  5276.       source = stencil;
  5277.    }
  5278.  
  5279.    switch (dstType) {
  5280.    case GL_UNSIGNED_BYTE:
  5281.       memcpy(dest, source, n);
  5282.       break;
  5283.    case GL_BYTE:
  5284.       {
  5285.          GLbyte *dst = (GLbyte *) dest;
  5286.          GLuint i;
  5287.          for (i=0;i<n;i++) {
  5288.             dst[i] = (GLbyte) (source[i] & 0x7f);
  5289.          }
  5290.       }
  5291.       break;
  5292.    case GL_UNSIGNED_SHORT:
  5293.       {
  5294.          GLushort *dst = (GLushort *) dest;
  5295.          GLuint i;
  5296.          for (i=0;i<n;i++) {
  5297.             dst[i] = (GLushort) source[i];
  5298.          }
  5299.          if (dstPacking->SwapBytes) {
  5300.             _mesa_swap2( (GLushort *) dst, n );
  5301.          }
  5302.       }
  5303.       break;
  5304.    case GL_SHORT:
  5305.       {
  5306.          GLshort *dst = (GLshort *) dest;
  5307.          GLuint i;
  5308.          for (i=0;i<n;i++) {
  5309.             dst[i] = (GLshort) source[i];
  5310.          }
  5311.          if (dstPacking->SwapBytes) {
  5312.             _mesa_swap2( (GLushort *) dst, n );
  5313.          }
  5314.       }
  5315.       break;
  5316.    case GL_UNSIGNED_INT:
  5317.       {
  5318.          GLuint *dst = (GLuint *) dest;
  5319.          GLuint i;
  5320.          for (i=0;i<n;i++) {
  5321.             dst[i] = (GLuint) source[i];
  5322.          }
  5323.          if (dstPacking->SwapBytes) {
  5324.             _mesa_swap4( (GLuint *) dst, n );
  5325.          }
  5326.       }
  5327.       break;
  5328.    case GL_INT:
  5329.       {
  5330.          GLint *dst = (GLint *) dest;
  5331.          GLuint i;
  5332.          for (i=0;i<n;i++) {
  5333.             dst[i] = (GLint) source[i];
  5334.          }
  5335.          if (dstPacking->SwapBytes) {
  5336.             _mesa_swap4( (GLuint *) dst, n );
  5337.          }
  5338.       }
  5339.       break;
  5340.    case GL_FLOAT:
  5341.       {
  5342.          GLfloat *dst = (GLfloat *) dest;
  5343.          GLuint i;
  5344.          for (i=0;i<n;i++) {
  5345.             dst[i] = (GLfloat) source[i];
  5346.          }
  5347.          if (dstPacking->SwapBytes) {
  5348.             _mesa_swap4( (GLuint *) dst, n );
  5349.          }
  5350.       }
  5351.       break;
  5352.    case GL_HALF_FLOAT_ARB:
  5353.       {
  5354.          GLhalfARB *dst = (GLhalfARB *) dest;
  5355.          GLuint i;
  5356.          for (i=0;i<n;i++) {
  5357.             dst[i] = _mesa_float_to_half( (float) source[i] );
  5358.          }
  5359.          if (dstPacking->SwapBytes) {
  5360.             _mesa_swap2( (GLushort *) dst, n );
  5361.          }
  5362.       }
  5363.       break;
  5364.    case GL_BITMAP:
  5365.       if (dstPacking->LsbFirst) {
  5366.          GLubyte *dst = (GLubyte *) dest;
  5367.          GLint shift = 0;
  5368.          GLuint i;
  5369.          for (i = 0; i < n; i++) {
  5370.             if (shift == 0)
  5371.                *dst = 0;
  5372.             *dst |= ((source[i] != 0) << shift);
  5373.             shift++;
  5374.             if (shift == 8) {
  5375.                shift = 0;
  5376.                dst++;
  5377.             }
  5378.          }
  5379.       }
  5380.       else {
  5381.          GLubyte *dst = (GLubyte *) dest;
  5382.          GLint shift = 7;
  5383.          GLuint i;
  5384.          for (i = 0; i < n; i++) {
  5385.             if (shift == 7)
  5386.                *dst = 0;
  5387.             *dst |= ((source[i] != 0) << shift);
  5388.             shift--;
  5389.             if (shift < 0) {
  5390.                shift = 7;
  5391.                dst++;
  5392.             }
  5393.          }
  5394.       }
  5395.       break;
  5396.    default:
  5397.       _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
  5398.    }
  5399.  
  5400.    free(stencil);
  5401. }
  5402.  
  5403. #define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT)                              \
  5404.     do {                                                                \
  5405.         GLuint i;                                                       \
  5406.         const GLTYPE *src = (const GLTYPE *)source;                     \
  5407.         for (i = 0; i < n; i++) {                                       \
  5408.             GLTYPE value = src[i];                                      \
  5409.             if (srcPacking->SwapBytes) {                                \
  5410.                 if (sizeof(GLTYPE) == 2) {                              \
  5411.                     SWAP2BYTE(value);                                   \
  5412.                 } else if (sizeof(GLTYPE) == 4) {                       \
  5413.                     SWAP4BYTE(value);                                   \
  5414.                 }                                                       \
  5415.             }                                                           \
  5416.             depthValues[i] = GLTYPE2FLOAT(value);                       \
  5417.         }                                                               \
  5418.     } while (0)
  5419.  
  5420.  
  5421. /**
  5422.  * Unpack a row of depth/z values from memory, returning GLushort, GLuint
  5423.  * or GLfloat values.
  5424.  * The glPixelTransfer (scale/bias) params will be applied.
  5425.  *
  5426.  * \param dstType  one of GL_UNSIGNED_SHORT, GL_UNSIGNED_INT, GL_FLOAT
  5427.  * \param depthMax  max value for returned GLushort or GLuint values
  5428.  *                  (ignored for GLfloat).
  5429.  */
  5430. void
  5431. _mesa_unpack_depth_span( struct gl_context *ctx, GLuint n,
  5432.                          GLenum dstType, GLvoid *dest, GLuint depthMax,
  5433.                          GLenum srcType, const GLvoid *source,
  5434.                          const struct gl_pixelstore_attrib *srcPacking )
  5435. {
  5436.    GLfloat *depthTemp = NULL, *depthValues;
  5437.    GLboolean needClamp = GL_FALSE;
  5438.  
  5439.    /* Look for special cases first.
  5440.     * Not only are these faster, they're less prone to numeric conversion
  5441.     * problems.  Otherwise, converting from an int type to a float then
  5442.     * back to an int type can introduce errors that will show up as
  5443.     * artifacts in things like depth peeling which uses glCopyTexImage.
  5444.     */
  5445.    if (ctx->Pixel.DepthScale == 1.0 && ctx->Pixel.DepthBias == 0.0) {
  5446.       if (srcType == GL_UNSIGNED_INT && dstType == GL_UNSIGNED_SHORT) {
  5447.          const GLuint *src = (const GLuint *) source;
  5448.          GLushort *dst = (GLushort *) dest;
  5449.          GLuint i;
  5450.          for (i = 0; i < n; i++) {
  5451.             dst[i] = src[i] >> 16;
  5452.          }
  5453.          return;
  5454.       }
  5455.       if (srcType == GL_UNSIGNED_SHORT
  5456.           && dstType == GL_UNSIGNED_INT
  5457.           && depthMax == 0xffffffff) {
  5458.          const GLushort *src = (const GLushort *) source;
  5459.          GLuint *dst = (GLuint *) dest;
  5460.          GLuint i;
  5461.          for (i = 0; i < n; i++) {
  5462.             dst[i] = src[i] | (src[i] << 16);
  5463.          }
  5464.          return;
  5465.       }
  5466.       if (srcType == GL_UNSIGNED_INT_24_8
  5467.           && dstType == GL_UNSIGNED_INT
  5468.           && depthMax == 0xffffff) {
  5469.          const GLuint *src = (const GLuint *) source;
  5470.          GLuint *dst = (GLuint *) dest;
  5471.          GLuint i;
  5472.          for (i = 0; i < n; i++) {
  5473.             dst[i] = src[i] >> 8;
  5474.          }
  5475.          return;
  5476.       }
  5477.       /* XXX may want to add additional cases here someday */
  5478.    }
  5479.  
  5480.    /* general case path follows */
  5481.  
  5482.    if (dstType == GL_FLOAT) {
  5483.       depthValues = (GLfloat *) dest;
  5484.    }
  5485.    else {
  5486.       depthTemp = malloc(n * sizeof(GLfloat));
  5487.       if (!depthTemp) {
  5488.          _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
  5489.          return;
  5490.       }
  5491.  
  5492.       depthValues = depthTemp;
  5493.    }
  5494.  
  5495.    /* Convert incoming values to GLfloat.  Some conversions will require
  5496.     * clamping, below.
  5497.     */
  5498.    switch (srcType) {
  5499.       case GL_BYTE:
  5500.          DEPTH_VALUES(GLbyte, BYTE_TO_FLOATZ);
  5501.          needClamp = GL_TRUE;
  5502.          break;
  5503.       case GL_UNSIGNED_BYTE:
  5504.          DEPTH_VALUES(GLubyte, UBYTE_TO_FLOAT);
  5505.          break;
  5506.       case GL_SHORT:
  5507.          DEPTH_VALUES(GLshort, SHORT_TO_FLOATZ);
  5508.          needClamp = GL_TRUE;
  5509.          break;
  5510.       case GL_UNSIGNED_SHORT:
  5511.          DEPTH_VALUES(GLushort, USHORT_TO_FLOAT);
  5512.          break;
  5513.       case GL_INT:
  5514.          DEPTH_VALUES(GLint, INT_TO_FLOAT);
  5515.          needClamp = GL_TRUE;
  5516.          break;
  5517.       case GL_UNSIGNED_INT:
  5518.          DEPTH_VALUES(GLuint, UINT_TO_FLOAT);
  5519.          break;
  5520.       case GL_UNSIGNED_INT_24_8_EXT: /* GL_EXT_packed_depth_stencil */
  5521.          if (dstType == GL_UNSIGNED_INT_24_8_EXT &&
  5522.              depthMax == 0xffffff &&
  5523.              ctx->Pixel.DepthScale == 1.0 &&
  5524.              ctx->Pixel.DepthBias == 0.0) {
  5525.             const GLuint *src = (const GLuint *) source;
  5526.             GLuint *zValues = (GLuint *) dest;
  5527.             GLuint i;
  5528.             for (i = 0; i < n; i++) {
  5529.                 GLuint value = src[i];
  5530.                 if (srcPacking->SwapBytes) {
  5531.                     SWAP4BYTE(value);
  5532.                 }
  5533.                 zValues[i] = value & 0xffffff00;
  5534.             }
  5535.             free(depthTemp);
  5536.             return;
  5537.          }
  5538.          else {
  5539.             const GLuint *src = (const GLuint *) source;
  5540.             const GLfloat scale = 1.0f / 0xffffff;
  5541.             GLuint i;
  5542.             for (i = 0; i < n; i++) {
  5543.                 GLuint value = src[i];
  5544.                 if (srcPacking->SwapBytes) {
  5545.                     SWAP4BYTE(value);
  5546.                 }
  5547.                 depthValues[i] = (value >> 8) * scale;
  5548.             }
  5549.          }
  5550.          break;
  5551.       case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
  5552.          {
  5553.             GLuint i;
  5554.             const GLfloat *src = (const GLfloat *)source;
  5555.             for (i = 0; i < n; i++) {
  5556.                GLfloat value = src[i * 2];
  5557.                if (srcPacking->SwapBytes) {
  5558.                   SWAP4BYTE(value);
  5559.                }
  5560.                depthValues[i] = value;
  5561.             }
  5562.             needClamp = GL_TRUE;
  5563.          }
  5564.          break;
  5565.       case GL_FLOAT:
  5566.          DEPTH_VALUES(GLfloat, 1*);
  5567.          needClamp = GL_TRUE;
  5568.          break;
  5569.       case GL_HALF_FLOAT_ARB:
  5570.          {
  5571.             GLuint i;
  5572.             const GLhalfARB *src = (const GLhalfARB *) source;
  5573.             for (i = 0; i < n; i++) {
  5574.                GLhalfARB value = src[i];
  5575.                if (srcPacking->SwapBytes) {
  5576.                   SWAP2BYTE(value);
  5577.                }
  5578.                depthValues[i] = _mesa_half_to_float(value);
  5579.             }
  5580.             needClamp = GL_TRUE;
  5581.          }
  5582.          break;
  5583.       default:
  5584.          _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()");
  5585.          free(depthTemp);
  5586.          return;
  5587.    }
  5588.  
  5589.    /* apply depth scale and bias */
  5590.    {
  5591.       const GLfloat scale = ctx->Pixel.DepthScale;
  5592.       const GLfloat bias = ctx->Pixel.DepthBias;
  5593.       if (scale != 1.0 || bias != 0.0) {
  5594.          GLuint i;
  5595.          for (i = 0; i < n; i++) {
  5596.             depthValues[i] = depthValues[i] * scale + bias;
  5597.          }
  5598.          needClamp = GL_TRUE;
  5599.       }
  5600.    }
  5601.  
  5602.    /* clamp to [0, 1] */
  5603.    if (needClamp) {
  5604.       GLuint i;
  5605.       for (i = 0; i < n; i++) {
  5606.          depthValues[i] = (GLfloat)CLAMP(depthValues[i], 0.0, 1.0);
  5607.       }
  5608.    }
  5609.  
  5610.    /*
  5611.     * Convert values to dstType
  5612.     */
  5613.    if (dstType == GL_UNSIGNED_INT) {
  5614.       GLuint *zValues = (GLuint *) dest;
  5615.       GLuint i;
  5616.       if (depthMax <= 0xffffff) {
  5617.          /* no overflow worries */
  5618.          for (i = 0; i < n; i++) {
  5619.             zValues[i] = (GLuint) (depthValues[i] * (GLfloat) depthMax);
  5620.          }
  5621.       }
  5622.       else {
  5623.          /* need to use double precision to prevent overflow problems */
  5624.          for (i = 0; i < n; i++) {
  5625.             GLdouble z = depthValues[i] * (GLdouble) depthMax;
  5626.             if (z >= (GLdouble) 0xffffffff)
  5627.                zValues[i] = 0xffffffff;
  5628.             else
  5629.                zValues[i] = (GLuint) z;
  5630.          }
  5631.       }
  5632.    }
  5633.    else if (dstType == GL_UNSIGNED_SHORT) {
  5634.       GLushort *zValues = (GLushort *) dest;
  5635.       GLuint i;
  5636.       ASSERT(depthMax <= 0xffff);
  5637.       for (i = 0; i < n; i++) {
  5638.          zValues[i] = (GLushort) (depthValues[i] * (GLfloat) depthMax);
  5639.       }
  5640.    }
  5641.    else if (dstType == GL_FLOAT) {
  5642.       /* Nothing to do. depthValues is pointing to dest. */
  5643.    }
  5644.    else if (dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV) {
  5645.       GLfloat *zValues = (GLfloat*) dest;
  5646.       GLuint i;
  5647.       for (i = 0; i < n; i++) {
  5648.          zValues[i*2] = depthValues[i];
  5649.       }
  5650.    }
  5651.    else {
  5652.       ASSERT(0);
  5653.    }
  5654.  
  5655.    free(depthTemp);
  5656. }
  5657.  
  5658.  
  5659. /*
  5660.  * Pack an array of depth values.  The values are floats in [0,1].
  5661.  */
  5662. void
  5663. _mesa_pack_depth_span( struct gl_context *ctx, GLuint n, GLvoid *dest,
  5664.                        GLenum dstType, const GLfloat *depthSpan,
  5665.                        const struct gl_pixelstore_attrib *dstPacking )
  5666. {
  5667.    GLfloat *depthCopy = malloc(n * sizeof(GLfloat));
  5668.    if (!depthCopy) {
  5669.       _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
  5670.       return;
  5671.    }
  5672.  
  5673.    if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
  5674.       memcpy(depthCopy, depthSpan, n * sizeof(GLfloat));
  5675.       _mesa_scale_and_bias_depth(ctx, n, depthCopy);
  5676.       depthSpan = depthCopy;
  5677.    }
  5678.  
  5679.    switch (dstType) {
  5680.    case GL_UNSIGNED_BYTE:
  5681.       {
  5682.          GLubyte *dst = (GLubyte *) dest;
  5683.          GLuint i;
  5684.          for (i = 0; i < n; i++) {
  5685.             dst[i] = FLOAT_TO_UBYTE( depthSpan[i] );
  5686.          }
  5687.       }
  5688.       break;
  5689.    case GL_BYTE:
  5690.       {
  5691.          GLbyte *dst = (GLbyte *) dest;
  5692.          GLuint i;
  5693.          for (i = 0; i < n; i++) {
  5694.             dst[i] = FLOAT_TO_BYTE( depthSpan[i] );
  5695.          }
  5696.       }
  5697.       break;
  5698.    case GL_UNSIGNED_SHORT:
  5699.       {
  5700.          GLushort *dst = (GLushort *) dest;
  5701.          GLuint i;
  5702.          for (i = 0; i < n; i++) {
  5703.             CLAMPED_FLOAT_TO_USHORT(dst[i], depthSpan[i]);
  5704.          }
  5705.          if (dstPacking->SwapBytes) {
  5706.             _mesa_swap2( (GLushort *) dst, n );
  5707.          }
  5708.       }
  5709.       break;
  5710.    case GL_SHORT:
  5711.       {
  5712.          GLshort *dst = (GLshort *) dest;
  5713.          GLuint i;
  5714.          for (i = 0; i < n; i++) {
  5715.             dst[i] = FLOAT_TO_SHORT( depthSpan[i] );
  5716.          }
  5717.          if (dstPacking->SwapBytes) {
  5718.             _mesa_swap2( (GLushort *) dst, n );
  5719.          }
  5720.       }
  5721.       break;
  5722.    case GL_UNSIGNED_INT:
  5723.       {
  5724.          GLuint *dst = (GLuint *) dest;
  5725.          GLuint i;
  5726.          for (i = 0; i < n; i++) {
  5727.             dst[i] = FLOAT_TO_UINT( depthSpan[i] );
  5728.          }
  5729.          if (dstPacking->SwapBytes) {
  5730.             _mesa_swap4( (GLuint *) dst, n );
  5731.          }
  5732.       }
  5733.       break;
  5734.    case GL_INT:
  5735.       {
  5736.          GLint *dst = (GLint *) dest;
  5737.          GLuint i;
  5738.          for (i = 0; i < n; i++) {
  5739.             dst[i] = FLOAT_TO_INT( depthSpan[i] );
  5740.          }
  5741.          if (dstPacking->SwapBytes) {
  5742.             _mesa_swap4( (GLuint *) dst, n );
  5743.          }
  5744.       }
  5745.       break;
  5746.    case GL_FLOAT:
  5747.       {
  5748.          GLfloat *dst = (GLfloat *) dest;
  5749.          GLuint i;
  5750.          for (i = 0; i < n; i++) {
  5751.             dst[i] = depthSpan[i];
  5752.          }
  5753.          if (dstPacking->SwapBytes) {
  5754.             _mesa_swap4( (GLuint *) dst, n );
  5755.          }
  5756.       }
  5757.       break;
  5758.    case GL_HALF_FLOAT_ARB:
  5759.       {
  5760.          GLhalfARB *dst = (GLhalfARB *) dest;
  5761.          GLuint i;
  5762.          for (i = 0; i < n; i++) {
  5763.             dst[i] = _mesa_float_to_half(depthSpan[i]);
  5764.          }
  5765.          if (dstPacking->SwapBytes) {
  5766.             _mesa_swap2( (GLushort *) dst, n );
  5767.          }
  5768.       }
  5769.       break;
  5770.    default:
  5771.       _mesa_problem(ctx, "bad type in _mesa_pack_depth_span");
  5772.    }
  5773.  
  5774.    free(depthCopy);
  5775. }
  5776.  
  5777.  
  5778.  
  5779. /**
  5780.  * Pack depth and stencil values as GL_DEPTH_STENCIL (GL_UNSIGNED_INT_24_8 etc)
  5781.  */
  5782. void
  5783. _mesa_pack_depth_stencil_span(struct gl_context *ctx,GLuint n,
  5784.                               GLenum dstType, GLuint *dest,
  5785.                               const GLfloat *depthVals,
  5786.                               const GLubyte *stencilVals,
  5787.                               const struct gl_pixelstore_attrib *dstPacking)
  5788. {
  5789.    GLfloat *depthCopy = malloc(n * sizeof(GLfloat));
  5790.    GLubyte *stencilCopy = malloc(n * sizeof(GLubyte));
  5791.    GLuint i;
  5792.  
  5793.    if (!depthCopy || !stencilCopy) {
  5794.       _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
  5795.       free(depthCopy);
  5796.       free(stencilCopy);
  5797.       return;
  5798.    }
  5799.  
  5800.    if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
  5801.       memcpy(depthCopy, depthVals, n * sizeof(GLfloat));
  5802.       _mesa_scale_and_bias_depth(ctx, n, depthCopy);
  5803.       depthVals = depthCopy;
  5804.    }
  5805.  
  5806.    if (ctx->Pixel.IndexShift ||
  5807.        ctx->Pixel.IndexOffset ||
  5808.        ctx->Pixel.MapStencilFlag) {
  5809.       memcpy(stencilCopy, stencilVals, n * sizeof(GLubyte));
  5810.       _mesa_apply_stencil_transfer_ops(ctx, n, stencilCopy);
  5811.       stencilVals = stencilCopy;
  5812.    }
  5813.  
  5814.    switch (dstType) {
  5815.    case GL_UNSIGNED_INT_24_8:
  5816.       for (i = 0; i < n; i++) {
  5817.          GLuint z = (GLuint) (depthVals[i] * 0xffffff);
  5818.          dest[i] = (z << 8) | (stencilVals[i] & 0xff);
  5819.       }
  5820.       break;
  5821.    case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
  5822.       for (i = 0; i < n; i++) {
  5823.          ((GLfloat*)dest)[i*2] = depthVals[i];
  5824.          dest[i*2+1] = stencilVals[i] & 0xff;
  5825.       }
  5826.       break;
  5827.    }
  5828.  
  5829.    if (dstPacking->SwapBytes) {
  5830.       _mesa_swap4(dest, n);
  5831.    }
  5832.  
  5833.    free(depthCopy);
  5834.    free(stencilCopy);
  5835. }
  5836.  
  5837.  
  5838.  
  5839.  
  5840. /**
  5841.  * Unpack image data.  Apply byte swapping, byte flipping (bitmap).
  5842.  * Return all image data in a contiguous block.  This is used when we
  5843.  * compile glDrawPixels, glTexImage, etc into a display list.  We
  5844.  * need a copy of the data in a standard format.
  5845.  */
  5846. void *
  5847. _mesa_unpack_image( GLuint dimensions,
  5848.                     GLsizei width, GLsizei height, GLsizei depth,
  5849.                     GLenum format, GLenum type, const GLvoid *pixels,
  5850.                     const struct gl_pixelstore_attrib *unpack )
  5851. {
  5852.    GLint bytesPerRow, compsPerRow;
  5853.    GLboolean flipBytes, swap2, swap4;
  5854.  
  5855.    if (!pixels)
  5856.       return NULL;  /* not necessarily an error */
  5857.  
  5858.    if (width <= 0 || height <= 0 || depth <= 0)
  5859.       return NULL;  /* generate error later */
  5860.  
  5861.    if (type == GL_BITMAP) {
  5862.       bytesPerRow = (width + 7) >> 3;
  5863.       flipBytes = unpack->LsbFirst;
  5864.       swap2 = swap4 = GL_FALSE;
  5865.       compsPerRow = 0;
  5866.    }
  5867.    else {
  5868.       const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
  5869.       GLint components = _mesa_components_in_format(format);
  5870.       GLint bytesPerComp;
  5871.  
  5872.       if (_mesa_type_is_packed(type))
  5873.           components = 1;
  5874.  
  5875.       if (bytesPerPixel <= 0 || components <= 0)
  5876.          return NULL;   /* bad format or type.  generate error later */
  5877.       bytesPerRow = bytesPerPixel * width;
  5878.       bytesPerComp = bytesPerPixel / components;
  5879.       flipBytes = GL_FALSE;
  5880.       swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
  5881.       swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
  5882.       compsPerRow = components * width;
  5883.       assert(compsPerRow >= width);
  5884.    }
  5885.  
  5886.    {
  5887.       GLubyte *destBuffer
  5888.          = malloc(bytesPerRow * height * depth);
  5889.       GLubyte *dst;
  5890.       GLint img, row;
  5891.       if (!destBuffer)
  5892.          return NULL;   /* generate GL_OUT_OF_MEMORY later */
  5893.  
  5894.       dst = destBuffer;
  5895.       for (img = 0; img < depth; img++) {
  5896.          for (row = 0; row < height; row++) {
  5897.             const GLvoid *src = _mesa_image_address(dimensions, unpack, pixels,
  5898.                                width, height, format, type, img, row, 0);
  5899.  
  5900.             if ((type == GL_BITMAP) && (unpack->SkipPixels & 0x7)) {
  5901.                GLint i;
  5902.                flipBytes = GL_FALSE;
  5903.                if (unpack->LsbFirst) {
  5904.                   GLubyte srcMask = 1 << (unpack->SkipPixels & 0x7);
  5905.                   GLubyte dstMask = 128;
  5906.                   const GLubyte *s = src;
  5907.                   GLubyte *d = dst;
  5908.                   *d = 0;
  5909.                   for (i = 0; i < width; i++) {
  5910.                      if (*s & srcMask) {
  5911.                         *d |= dstMask;
  5912.                      }      
  5913.                      if (srcMask == 128) {
  5914.                         srcMask = 1;
  5915.                         s++;
  5916.                      }
  5917.                      else {
  5918.                         srcMask = srcMask << 1;
  5919.                      }
  5920.                      if (dstMask == 1) {
  5921.                         dstMask = 128;
  5922.                         d++;
  5923.                         *d = 0;
  5924.                      }
  5925.                      else {
  5926.                         dstMask = dstMask >> 1;
  5927.                      }
  5928.                   }
  5929.                }
  5930.                else {
  5931.                   GLubyte srcMask = 128 >> (unpack->SkipPixels & 0x7);
  5932.                   GLubyte dstMask = 128;
  5933.                   const GLubyte *s = src;
  5934.                   GLubyte *d = dst;
  5935.                   *d = 0;
  5936.                   for (i = 0; i < width; i++) {
  5937.                      if (*s & srcMask) {
  5938.                         *d |= dstMask;
  5939.                      }
  5940.                      if (srcMask == 1) {
  5941.                         srcMask = 128;
  5942.                         s++;
  5943.                      }
  5944.                      else {
  5945.                         srcMask = srcMask >> 1;
  5946.                      }
  5947.                      if (dstMask == 1) {
  5948.                         dstMask = 128;
  5949.                         d++;
  5950.                         *d = 0;
  5951.                      }
  5952.                      else {
  5953.                         dstMask = dstMask >> 1;
  5954.                      }      
  5955.                   }
  5956.                }
  5957.             }
  5958.             else {
  5959.                memcpy(dst, src, bytesPerRow);
  5960.             }
  5961.  
  5962.             /* byte flipping/swapping */
  5963.             if (flipBytes) {
  5964.                flip_bytes((GLubyte *) dst, bytesPerRow);
  5965.             }
  5966.             else if (swap2) {
  5967.                _mesa_swap2((GLushort*) dst, compsPerRow);
  5968.             }
  5969.             else if (swap4) {
  5970.                _mesa_swap4((GLuint*) dst, compsPerRow);
  5971.             }
  5972.             dst += bytesPerRow;
  5973.          }
  5974.       }
  5975.       return destBuffer;
  5976.    }
  5977. }
  5978.  
  5979.  
  5980.  
  5981. /**
  5982.  * If we unpack colors from a luminance surface, we'll get pixel colors
  5983.  * such as (l, l, l, a).
  5984.  * When we call _mesa_pack_rgba_span_float(format=GL_LUMINANCE), that
  5985.  * function will compute L=R+G+B before packing.  The net effect is we'll
  5986.  * accidentally store luminance values = 3*l.
  5987.  * This function compensates for that by converting (aka rebasing) (l,l,l,a)
  5988.  * to be (l,0,0,a).
  5989.  * It's a similar story for other formats such as LUMINANCE_ALPHA, ALPHA
  5990.  * and INTENSITY.
  5991.  *
  5992.  * Finally, we also need to do this when the actual surface format does
  5993.  * not match the logical surface format.  For example, suppose the user
  5994.  * requests a GL_LUMINANCE texture but the driver stores it as RGBA.
  5995.  * Again, we'll get pixel values like (l,l,l,a).
  5996.  */
  5997. void
  5998. _mesa_rebase_rgba_float(GLuint n, GLfloat rgba[][4], GLenum baseFormat)
  5999. {
  6000.    GLuint i;
  6001.  
  6002.    switch (baseFormat) {
  6003.    case GL_ALPHA:
  6004.       for (i = 0; i < n; i++) {
  6005.          rgba[i][RCOMP] = 0.0F;
  6006.          rgba[i][GCOMP] = 0.0F;
  6007.          rgba[i][BCOMP] = 0.0F;
  6008.       }
  6009.       break;
  6010.    case GL_INTENSITY:
  6011.       /* fall-through */
  6012.    case GL_LUMINANCE:
  6013.       for (i = 0; i < n; i++) {
  6014.          rgba[i][GCOMP] = 0.0F;
  6015.          rgba[i][BCOMP] = 0.0F;
  6016.          rgba[i][ACOMP] = 1.0F;
  6017.       }
  6018.       break;
  6019.    case GL_LUMINANCE_ALPHA:
  6020.       for (i = 0; i < n; i++) {
  6021.          rgba[i][GCOMP] = 0.0F;
  6022.          rgba[i][BCOMP] = 0.0F;
  6023.       }
  6024.       break;
  6025.    case GL_RGB:
  6026.       for (i = 0; i < n; i++) {
  6027.          rgba[i][ACOMP] = 1.0F;
  6028.       }
  6029.       break;
  6030.    case GL_RG:
  6031.       for (i = 0; i < n; i++) {
  6032.          rgba[i][BCOMP] = 0.0F;
  6033.          rgba[i][ACOMP] = 1.0F;
  6034.       }
  6035.       break;
  6036.    case GL_RED:
  6037.       for (i = 0; i < n; i++) {
  6038.          rgba[i][GCOMP] = 0.0F;
  6039.          rgba[i][BCOMP] = 0.0F;
  6040.          rgba[i][ACOMP] = 1.0F;
  6041.       }
  6042.       break;
  6043.  
  6044.    default:
  6045.       /* no-op */
  6046.       ;
  6047.    }
  6048. }
  6049.  
  6050.  
  6051. /**
  6052.  * As above, but GLuint components.
  6053.  */
  6054. void
  6055. _mesa_rebase_rgba_uint(GLuint n, GLuint rgba[][4], GLenum baseFormat)
  6056. {
  6057.    GLuint i;
  6058.  
  6059.    switch (baseFormat) {
  6060.    case GL_ALPHA:
  6061.       for (i = 0; i < n; i++) {
  6062.          rgba[i][RCOMP] = 0;
  6063.          rgba[i][GCOMP] = 0;
  6064.          rgba[i][BCOMP] = 0;
  6065.       }
  6066.       break;
  6067.    case GL_INTENSITY:
  6068.       /* fall-through */
  6069.    case GL_LUMINANCE:
  6070.       for (i = 0; i < n; i++) {
  6071.          rgba[i][GCOMP] = 0;
  6072.          rgba[i][BCOMP] = 0;
  6073.          rgba[i][ACOMP] = 1;
  6074.       }
  6075.       break;
  6076.    case GL_LUMINANCE_ALPHA:
  6077.       for (i = 0; i < n; i++) {
  6078.          rgba[i][GCOMP] = 0;
  6079.          rgba[i][BCOMP] = 0;
  6080.       }
  6081.       break;
  6082.    case GL_RGB:
  6083.       for (i = 0; i < n; i++) {
  6084.          rgba[i][ACOMP] = 1;
  6085.       }
  6086.       break;
  6087.    case GL_RG:
  6088.       for (i = 0; i < n; i++) {
  6089.          rgba[i][BCOMP] = 0;
  6090.          rgba[i][ACOMP] = 1;
  6091.       }
  6092.       break;
  6093.    case GL_RED:
  6094.       for (i = 0; i < n; i++) {
  6095.          rgba[i][GCOMP] = 0;
  6096.          rgba[i][BCOMP] = 0;
  6097.          rgba[i][ACOMP] = 1;
  6098.       }
  6099.    default:
  6100.       /* no-op */
  6101.       ;
  6102.    }
  6103. }
  6104.  
  6105.  
  6106.