Subversion Repositories Kolibri OS

Rev

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