home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / mesa5.zip / mesa5src.zip / MesaDLL / image.cpp < prev    next >
C/C++ Source or Header  |  2002-12-28  |  138KB  |  3,944 lines
  1. /* $Id: image.c,v 1.69 2002/10/24 23:57:21 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  4.1
  6.  *
  7.  * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  8.  *
  9.  * Permission is hereby granted, free of charge, to any person obtaining a
  10.  * copy of this software and associated documentation files (the "Software"),
  11.  * to deal in the Software without restriction, including without limitation
  12.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13.  * and/or sell copies of the Software, and to permit persons to whom the
  14.  * Software is furnished to do so, subject to the following conditions:
  15.  *
  16.  * The above copyright notice and this permission notice shall be included
  17.  * in all copies or substantial portions of the Software.
  18.  *
  19.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22.  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23.  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25.  */
  26.  
  27. #include "glheader.h"
  28. #include "colormac.h"
  29. #include "context.h"
  30. #include "image.h"
  31. #include "imports.h"
  32. #include "histogram.h"
  33. #include "macros.h"
  34. #include "mmath.h"
  35. #include "pixel.h"
  36. #include "mtypes.h"
  37.  
  38.  
  39. /*
  40.  * These are the image packing parameters for Mesa's internal images.
  41.  * That is, _mesa_unpack_image() returns image data in this format.
  42.  * When we execute image commands (glDrawPixels, glTexImage, etc)
  43.  * from within display lists we have to be sure to set the current
  44.  * unpacking params to these values!
  45.  */
  46. const struct gl_pixelstore_attrib _mesa_native_packing = {
  47.    1,            /* Alignment */
  48.    0,            /* RowLength */
  49.    0,            /* SkipPixels */
  50.    0,            /* SkipRows */
  51.    0,            /* ImageHeight */
  52.    0,            /* SkipImages */
  53.    GL_FALSE,     /* SwapBytes */
  54.    GL_FALSE,     /* LsbFirst */
  55.    GL_FALSE,     /* ClientStorage */
  56.    GL_FALSE      /* Invert */
  57. };
  58.  
  59.  
  60.  
  61. /*
  62.  * Flip the 8 bits in each byte of the given array.
  63.  *
  64.  * XXX try this trick to flip bytes someday:
  65.  *  v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555);
  66.  *  v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333);
  67.  *  v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f);
  68.  */
  69. static void
  70. flip_bytes( GLubyte *p, GLuint n )
  71. {
  72.    register GLuint i, a, b;
  73.  
  74.    for (i=0;i<n;i++) {
  75.       b = (GLuint) p[i];        /* words are often faster than bytes */
  76.       a = ((b & 0x01) << 7) |
  77.          ((b & 0x02) << 5) |
  78.          ((b & 0x04) << 3) |
  79.          ((b & 0x08) << 1) |
  80.          ((b & 0x10) >> 1) |
  81.          ((b & 0x20) >> 3) |
  82.          ((b & 0x40) >> 5) |
  83.          ((b & 0x80) >> 7);
  84.       p[i] = (GLubyte) a;
  85.    }
  86. }
  87.  
  88.  
  89. /*
  90.  * Flip the order of the 2 bytes in each word in the given array.
  91.  */
  92. void
  93. _mesa_swap2( GLushort *p, GLuint n )
  94. {
  95.    register GLuint i;
  96.  
  97.    for (i=0;i<n;i++) {
  98.       p[i] = (p[i] >> 8) | ((p[i] << 8) & 0xff00);
  99.    }
  100. }
  101.  
  102.  
  103.  
  104. /*
  105.  * Flip the order of the 4 bytes in each word in the given array.
  106.  */
  107. void
  108. _mesa_swap4( GLuint *p, GLuint n )
  109. {
  110.    register GLuint i, a, b;
  111.  
  112.    for (i=0;i<n;i++) {
  113.       b = p[i];
  114.       a =  (b >> 24)
  115.        | ((b >> 8) & 0xff00)
  116.        | ((b << 8) & 0xff0000)
  117.        | ((b << 24) & 0xff000000);
  118.       p[i] = a;
  119.    }
  120. }
  121.  
  122.  
  123.  
  124.  
  125. /*
  126.  * Return the size, in bytes, of the given GL datatype.
  127.  * Return 0 if GL_BITMAP.
  128.  * Return -1 if invalid type enum.
  129.  */
  130. GLint _mesa_sizeof_type( GLenum type )
  131. {
  132.    switch (type) {
  133.       case GL_BITMAP:
  134.         return 0;
  135.       case GL_UNSIGNED_BYTE:
  136.          return sizeof(GLubyte);
  137.       case GL_BYTE:
  138.         return sizeof(GLbyte);
  139.       case GL_UNSIGNED_SHORT:
  140.         return sizeof(GLushort);
  141.       case GL_SHORT:
  142.         return sizeof(GLshort);
  143.       case GL_UNSIGNED_INT:
  144.         return sizeof(GLuint);
  145.       case GL_INT:
  146.         return sizeof(GLint);
  147.       case GL_FLOAT:
  148.         return sizeof(GLfloat);
  149.       default:
  150.          return -1;
  151.    }
  152. }
  153.  
  154.  
  155. /*
  156.  * Same as _mesa_sizeof_packed_type() but we also accept the
  157.  * packed pixel format datatypes.
  158.  */
  159. GLint _mesa_sizeof_packed_type( GLenum type )
  160. {
  161.    switch (type) {
  162.       case GL_BITMAP:
  163.         return 0;
  164.       case GL_UNSIGNED_BYTE:
  165.          return sizeof(GLubyte);
  166.       case GL_BYTE:
  167.         return sizeof(GLbyte);
  168.       case GL_UNSIGNED_SHORT:
  169.         return sizeof(GLushort);
  170.       case GL_SHORT:
  171.         return sizeof(GLshort);
  172.       case GL_UNSIGNED_INT:
  173.         return sizeof(GLuint);
  174.       case GL_INT:
  175.         return sizeof(GLint);
  176.       case GL_FLOAT:
  177.         return sizeof(GLfloat);
  178.       case GL_UNSIGNED_BYTE_3_3_2:
  179.          return sizeof(GLubyte);
  180.       case GL_UNSIGNED_BYTE_2_3_3_REV:
  181.          return sizeof(GLubyte);
  182.       case GL_UNSIGNED_SHORT_5_6_5:
  183.          return sizeof(GLushort);
  184.       case GL_UNSIGNED_SHORT_5_6_5_REV:
  185.          return sizeof(GLushort);
  186.       case GL_UNSIGNED_SHORT_4_4_4_4:
  187.          return sizeof(GLushort);
  188.       case GL_UNSIGNED_SHORT_4_4_4_4_REV:
  189.          return sizeof(GLushort);
  190.       case GL_UNSIGNED_SHORT_5_5_5_1:
  191.          return sizeof(GLushort);
  192.       case GL_UNSIGNED_SHORT_1_5_5_5_REV:
  193.          return sizeof(GLushort);
  194.       case GL_UNSIGNED_INT_8_8_8_8:
  195.          return sizeof(GLuint);
  196.       case GL_UNSIGNED_INT_8_8_8_8_REV:
  197.          return sizeof(GLuint);
  198.       case GL_UNSIGNED_INT_10_10_10_2:
  199.          return sizeof(GLuint);
  200.       case GL_UNSIGNED_INT_2_10_10_10_REV:
  201.          return sizeof(GLuint);
  202.       case GL_UNSIGNED_SHORT_8_8_MESA:
  203.       case GL_UNSIGNED_SHORT_8_8_REV_MESA:
  204.           return sizeof(GLushort);
  205.       default:
  206.          return -1;
  207.    }
  208. }
  209.  
  210.  
  211.  
  212. /*
  213.  * Return the number of components in a GL enum pixel type.
  214.  * Return -1 if bad format.
  215.  */
  216. GLint _mesa_components_in_format( GLenum format )
  217. {
  218.    switch (format) {
  219.       case GL_COLOR_INDEX:
  220.       case GL_COLOR_INDEX1_EXT:
  221.       case GL_COLOR_INDEX2_EXT:
  222.       case GL_COLOR_INDEX4_EXT:
  223.       case GL_COLOR_INDEX8_EXT:
  224.       case GL_COLOR_INDEX12_EXT:
  225.       case GL_COLOR_INDEX16_EXT:
  226.       case GL_STENCIL_INDEX:
  227.       case GL_DEPTH_COMPONENT:
  228.       case GL_RED:
  229.       case GL_GREEN:
  230.       case GL_BLUE:
  231.       case GL_ALPHA:
  232.       case GL_LUMINANCE:
  233.       case GL_INTENSITY:
  234.          return 1;
  235.       case GL_LUMINANCE_ALPHA:
  236.         return 2;
  237.       case GL_RGB:
  238.         return 3;
  239.       case GL_RGBA:
  240.         return 4;
  241.       case GL_BGR:
  242.         return 3;
  243.       case GL_BGRA:
  244.         return 4;
  245.       case GL_ABGR_EXT:
  246.          return 4;
  247.       case GL_YCBCR_MESA:
  248.          return 2;
  249.       default:
  250.          return -1;
  251.    }
  252. }
  253.  
  254.  
  255. /*
  256.  * Return bytes per pixel for given format and type
  257.  * Return -1 if bad format or type.
  258.  */
  259. GLint _mesa_bytes_per_pixel( GLenum format, GLenum type )
  260. {
  261.    GLint comps = _mesa_components_in_format( format );
  262.    if (comps < 0)
  263.       return -1;
  264.  
  265.    switch (type) {
  266.       case GL_BITMAP:
  267.          return 0;  /* special case */
  268.       case GL_BYTE:
  269.       case GL_UNSIGNED_BYTE:
  270.          return comps * sizeof(GLubyte);
  271.       case GL_SHORT:
  272.       case GL_UNSIGNED_SHORT:
  273.          return comps * sizeof(GLshort);
  274.       case GL_INT:
  275.       case GL_UNSIGNED_INT:
  276.          return comps * sizeof(GLint);
  277.       case GL_FLOAT:
  278.          return comps * sizeof(GLfloat);
  279.       case GL_UNSIGNED_BYTE_3_3_2:
  280.       case GL_UNSIGNED_BYTE_2_3_3_REV:
  281.          if (format == GL_RGB || format == GL_BGR)
  282.             return sizeof(GLubyte);
  283.          else
  284.             return -1;  /* error */
  285.       case GL_UNSIGNED_SHORT_5_6_5:
  286.       case GL_UNSIGNED_SHORT_5_6_5_REV:
  287.          if (format == GL_RGB || format == GL_BGR)
  288.             return sizeof(GLushort);
  289.          else
  290.             return -1;  /* error */
  291.       case GL_UNSIGNED_SHORT_4_4_4_4:
  292.       case GL_UNSIGNED_SHORT_4_4_4_4_REV:
  293.       case GL_UNSIGNED_SHORT_5_5_5_1:
  294.       case GL_UNSIGNED_SHORT_1_5_5_5_REV:
  295.          if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT)
  296.             return sizeof(GLushort);
  297.          else
  298.             return -1;
  299.       case GL_UNSIGNED_INT_8_8_8_8:
  300.       case GL_UNSIGNED_INT_8_8_8_8_REV:
  301.       case GL_UNSIGNED_INT_10_10_10_2:
  302.       case GL_UNSIGNED_INT_2_10_10_10_REV:
  303.          if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT)
  304.             return sizeof(GLuint);
  305.          else
  306.             return -1;
  307.       case GL_UNSIGNED_SHORT_8_8_MESA:
  308.       case GL_UNSIGNED_SHORT_8_8_REV_MESA:
  309.          if (format == GL_YCBCR_MESA)
  310.             return sizeof(GLushort);
  311.          else
  312.             return -1;
  313.       default:
  314.          return -1;
  315.    }
  316. }
  317.  
  318.  
  319. /*
  320.  * Test if the given pixel format and type are legal.
  321.  * Return GL_TRUE for legal, GL_FALSE for illegal.
  322.  */
  323. GLboolean
  324. _mesa_is_legal_format_and_type( GLenum format, GLenum type )
  325. {
  326.    switch (format) {
  327.       case GL_COLOR_INDEX:
  328.       case GL_STENCIL_INDEX:
  329.          switch (type) {
  330.             case GL_BITMAP:
  331.             case GL_BYTE:
  332.             case GL_UNSIGNED_BYTE:
  333.             case GL_SHORT:
  334.             case GL_UNSIGNED_SHORT:
  335.             case GL_INT:
  336.             case GL_UNSIGNED_INT:
  337.             case GL_FLOAT:
  338.                return GL_TRUE;
  339.             default:
  340.                return GL_FALSE;
  341.          }
  342.       case GL_RED:
  343.       case GL_GREEN:
  344.       case GL_BLUE:
  345.       case GL_ALPHA:
  346.       case GL_INTENSITY:
  347.       case GL_LUMINANCE:
  348.       case GL_LUMINANCE_ALPHA:
  349.       case GL_DEPTH_COMPONENT:
  350.          switch (type) {
  351.             case GL_BYTE:
  352.             case GL_UNSIGNED_BYTE:
  353.             case GL_SHORT:
  354.             case GL_UNSIGNED_SHORT:
  355.             case GL_INT:
  356.             case GL_UNSIGNED_INT:
  357.             case GL_FLOAT:
  358.                return GL_TRUE;
  359.             default:
  360.                return GL_FALSE;
  361.          }
  362.       case GL_RGB:
  363.       case GL_BGR:
  364.          switch (type) {
  365.             case GL_BYTE:
  366.             case GL_UNSIGNED_BYTE:
  367.             case GL_SHORT:
  368.             case GL_UNSIGNED_SHORT:
  369.             case GL_INT:
  370.             case GL_UNSIGNED_INT:
  371.             case GL_FLOAT:
  372.             case GL_UNSIGNED_BYTE_3_3_2:
  373.             case GL_UNSIGNED_BYTE_2_3_3_REV:
  374.             case GL_UNSIGNED_SHORT_5_6_5:
  375.             case GL_UNSIGNED_SHORT_5_6_5_REV:
  376.                return GL_TRUE;
  377.             default:
  378.                return GL_FALSE;
  379.          }
  380.       case GL_RGBA:
  381.       case GL_BGRA:
  382.       case GL_ABGR_EXT:
  383.          switch (type) {
  384.             case GL_BYTE:
  385.             case GL_UNSIGNED_BYTE:
  386.             case GL_SHORT:
  387.             case GL_UNSIGNED_SHORT:
  388.             case GL_INT:
  389.             case GL_UNSIGNED_INT:
  390.             case GL_FLOAT:
  391.             case GL_UNSIGNED_SHORT_4_4_4_4:
  392.             case GL_UNSIGNED_SHORT_4_4_4_4_REV:
  393.             case GL_UNSIGNED_SHORT_5_5_5_1:
  394.             case GL_UNSIGNED_SHORT_1_5_5_5_REV:
  395.             case GL_UNSIGNED_INT_8_8_8_8:
  396.             case GL_UNSIGNED_INT_8_8_8_8_REV:
  397.             case GL_UNSIGNED_INT_10_10_10_2:
  398.             case GL_UNSIGNED_INT_2_10_10_10_REV:
  399.                return GL_TRUE;
  400.             default:
  401.                return GL_FALSE;
  402.          }
  403.       case GL_YCBCR_MESA:
  404.          if (type == GL_UNSIGNED_SHORT_8_8_MESA ||
  405.              type == GL_UNSIGNED_SHORT_8_8_REV_MESA)
  406.             return GL_TRUE;
  407.          else
  408.             return GL_FALSE;
  409.       default:
  410.          ; /* fall-through */
  411.    }
  412.    return GL_FALSE;
  413. }
  414.  
  415.  
  416.  
  417. /*
  418.  * Return the address of a pixel in an image (actually a volume).
  419.  * Pixel unpacking/packing parameters are observed according to 'packing'.
  420.  * Input:  image - start of image data
  421.  *         width, height - size of image
  422.  *         format - image format
  423.  *         type - pixel component type
  424.  *         packing - the pixelstore attributes
  425.  *         img - which image in the volume (0 for 1D or 2D images)
  426.  *         row, column - location of pixel in the image
  427.  * Return:  address of pixel at (image,row,column) in image or NULL if error.
  428.  */
  429. GLvoid *
  430. _mesa_image_address( const struct gl_pixelstore_attrib *packing,
  431.                      const GLvoid *image, GLsizei width,
  432.                      GLsizei height, GLenum format, GLenum type,
  433.                      GLint img, GLint row, GLint column )
  434. {
  435.    GLint alignment;        /* 1, 2 or 4 */
  436.    GLint pixels_per_row;
  437.    GLint rows_per_image;
  438.    GLint skiprows;
  439.    GLint skippixels;
  440.    GLint skipimages;       /* for 3-D volume images */
  441.    GLubyte *pixel_addr;
  442.  
  443.    alignment = packing->Alignment;
  444.    if (packing->RowLength > 0) {
  445.       pixels_per_row = packing->RowLength;
  446.    }
  447.    else {
  448.       pixels_per_row = width;
  449.    }
  450.    if (packing->ImageHeight > 0) {
  451.       rows_per_image = packing->ImageHeight;
  452.    }
  453.    else {
  454.       rows_per_image = height;
  455.    }
  456.    skiprows = packing->SkipRows;
  457.    skippixels = packing->SkipPixels;
  458.    skipimages = packing->SkipImages;
  459.  
  460.    if (type==GL_BITMAP) {
  461.       /* BITMAP data */
  462.       GLint comp_per_pixel;   /* components per pixel */
  463.       GLint bytes_per_comp;   /* bytes per component */
  464.       GLint bytes_per_row;
  465.       GLint bytes_per_image;
  466.  
  467.       /* Compute bytes per component */
  468.       bytes_per_comp = _mesa_sizeof_packed_type( type );
  469.       if (bytes_per_comp<0) {
  470.          return NULL;
  471.       }
  472.  
  473.       /* Compute number of components per pixel */
  474.       comp_per_pixel = _mesa_components_in_format( format );
  475.       if (comp_per_pixel<0 && type != GL_BITMAP) {
  476.          return NULL;
  477.       }
  478.  
  479.       bytes_per_row = alignment
  480.                     * CEILING( comp_per_pixel*pixels_per_row, 8*alignment );
  481.  
  482.       bytes_per_image = bytes_per_row * rows_per_image;
  483.  
  484.       pixel_addr = (GLubyte *) image
  485.                  + (skipimages + img) * bytes_per_image
  486.                  + (skiprows + row) * bytes_per_row
  487.                  + (skippixels + column) / 8;
  488.    }
  489.    else {
  490.       /* Non-BITMAP data */
  491.       GLint bytes_per_pixel, bytes_per_row, remainder, bytes_per_image;
  492.       GLint topOfImage;
  493.  
  494.       bytes_per_pixel = _mesa_bytes_per_pixel( format, type );
  495.  
  496.       /* The pixel type and format should have been error checked earlier */
  497.       assert(bytes_per_pixel > 0);
  498.  
  499.       bytes_per_row = pixels_per_row * bytes_per_pixel;
  500.       remainder = bytes_per_row % alignment;
  501.       if (remainder > 0)
  502.          bytes_per_row += (alignment - remainder);
  503.  
  504.       ASSERT(bytes_per_row % alignment == 0);
  505.  
  506.       bytes_per_image = bytes_per_row * rows_per_image;
  507.  
  508.       if (packing->Invert) {
  509.          /* set pixel_addr to the last row */
  510.          topOfImage = bytes_per_row * (height - 1);
  511.          bytes_per_row = -bytes_per_row;
  512.       }
  513.       else {
  514.          topOfImage = 0;
  515.       }
  516.  
  517.       /* compute final pixel address */
  518.       pixel_addr = (GLubyte *) image
  519.                  + (skipimages + img) * bytes_per_image
  520.                  + topOfImage
  521.                  + (skiprows + row) * bytes_per_row
  522.                  + (skippixels + column) * bytes_per_pixel;
  523.    }
  524.  
  525.    return (GLvoid *) pixel_addr;
  526. }
  527.  
  528.  
  529.  
  530. /*
  531.  * Compute the stride between image rows (in bytes) for the given
  532.  * pixel packing parameters and image width, format and type.
  533.  */
  534. GLint
  535. _mesa_image_row_stride( const struct gl_pixelstore_attrib *packing,
  536.                         GLint width, GLenum format, GLenum type )
  537. {
  538.    ASSERT(packing);
  539.    if (type == GL_BITMAP) {
  540.       /* BITMAP data */
  541.       GLint bytes;
  542.       if (packing->RowLength == 0) {
  543.          bytes = (width + 7) / 8;
  544.       }
  545.       else {
  546.          bytes = (packing->RowLength + 7) / 8;
  547.       }
  548.       if (packing->Invert) {
  549.          /* negate the bytes per row (negative row stride) */
  550.          bytes = -bytes;
  551.       }
  552.       return bytes;
  553.    }
  554.    else {
  555.       /* Non-BITMAP data */
  556.       const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
  557.       GLint bytesPerRow, remainder;
  558.       if (bytesPerPixel <= 0)
  559.          return -1;  /* error */
  560.       if (packing->RowLength == 0) {
  561.          bytesPerRow = bytesPerPixel * width;
  562.       }
  563.       else {
  564.          bytesPerRow = bytesPerPixel * packing->RowLength;
  565.       }
  566.       remainder = bytesPerRow % packing->Alignment;
  567.       if (remainder > 0)
  568.          bytesPerRow += (packing->Alignment - remainder);
  569.       if (packing->Invert)
  570.          bytesPerRow = -bytesPerRow;
  571.       return bytesPerRow;
  572.    }
  573. }
  574.  
  575.  
  576.  
  577. /*
  578.  * Compute the stride between images in a 3D texture (in bytes) for the given
  579.  * pixel packing parameters and image width, format and type.
  580.  */
  581. GLint
  582. _mesa_image_image_stride( const struct gl_pixelstore_attrib *packing,
  583.                           GLint width, GLint height,
  584.                           GLenum format, GLenum type )
  585. {
  586.    ASSERT(packing);
  587.    ASSERT(type != GL_BITMAP);
  588.  
  589.    {
  590.       const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
  591.       GLint bytesPerRow, bytesPerImage, remainder;
  592.  
  593.       if (bytesPerPixel <= 0)
  594.          return -1;  /* error */
  595.       if (packing->RowLength == 0) {
  596.          bytesPerRow = bytesPerPixel * width;
  597.       }
  598.       else {
  599.          bytesPerRow = bytesPerPixel * packing->RowLength;
  600.       }
  601.       remainder = bytesPerRow % packing->Alignment;
  602.       if (remainder > 0)
  603.          bytesPerRow += (packing->Alignment - remainder);
  604.  
  605.       if (packing->ImageHeight == 0)
  606.          bytesPerImage = bytesPerRow * height;
  607.       else
  608.          bytesPerImage = bytesPerRow * packing->ImageHeight;
  609.  
  610.       return bytesPerImage;
  611.    }
  612. }
  613.  
  614.  
  615.  
  616.  
  617. /*
  618.  * Unpack a 32x32 pixel polygon stipple from user memory using the
  619.  * current pixel unpack settings.
  620.  */
  621. void
  622. _mesa_unpack_polygon_stipple( const GLubyte *pattern, GLuint dest[32],
  623.                               const struct gl_pixelstore_attrib *unpacking )
  624. {
  625.    GLubyte *ptrn = (GLubyte *) _mesa_unpack_bitmap( 32, 32, pattern, unpacking );
  626.    if (ptrn) {
  627.       /* Convert pattern from GLubytes to GLuints and handle big/little
  628.        * endian differences
  629.        */
  630.       GLubyte *p = ptrn;
  631.       GLint i;
  632.       for (i = 0; i < 32; i++) {
  633.          dest[i] = (p[0] << 24)
  634.                  | (p[1] << 16)
  635.                  | (p[2] <<  8)
  636.                  | (p[3]      );
  637.          p += 4;
  638.       }
  639.       FREE(ptrn);
  640.    }
  641. }
  642.  
  643.  
  644.  
  645. /*
  646.  * Pack polygon stipple into user memory given current pixel packing
  647.  * settings.
  648.  */
  649. void
  650. _mesa_pack_polygon_stipple( const GLuint pattern[32], GLubyte *dest,
  651.                             const struct gl_pixelstore_attrib *packing )
  652. {
  653.    /* Convert pattern from GLuints to GLubytes to handle big/little
  654.     * endian differences.
  655.     */
  656.    GLubyte ptrn[32*4];
  657.    GLint i;
  658.    for (i = 0; i < 32; i++) {
  659.       ptrn[i * 4 + 0] = (GLubyte) ((pattern[i] >> 24) & 0xff);
  660.       ptrn[i * 4 + 1] = (GLubyte) ((pattern[i] >> 16) & 0xff);
  661.       ptrn[i * 4 + 2] = (GLubyte) ((pattern[i] >> 8 ) & 0xff);
  662.       ptrn[i * 4 + 3] = (GLubyte) ((pattern[i]      ) & 0xff);
  663.    }
  664.  
  665.    _mesa_pack_bitmap(32, 32, ptrn, dest, packing);
  666. }
  667.  
  668.  
  669. /*
  670.  * Unpack bitmap data.  Resulting data will be in most-significant-bit-first
  671.  * order with row alignment = 1 byte.
  672.  */
  673. GLvoid *
  674. _mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels,
  675.                      const struct gl_pixelstore_attrib *packing )
  676. {
  677.    GLint bytes, row, width_in_bytes;
  678.    GLubyte *buffer, *dst;
  679.  
  680.    if (!pixels)
  681.       return NULL;
  682.  
  683.    /* Alloc dest storage */
  684.    bytes = ((width + 7) / 8 * height);
  685.    buffer = (GLubyte *) MALLOC( bytes );
  686.    if (!buffer)
  687.       return NULL;
  688.  
  689.  
  690.    width_in_bytes = CEILING( width, 8 );
  691.    dst = buffer;
  692.    for (row = 0; row < height; row++) {
  693.       const GLubyte *src = (const GLubyte *)
  694.          _mesa_image_address(packing, pixels, width, height,
  695.                              GL_COLOR_INDEX, GL_BITMAP, 0, row, 0);
  696.       if (!src) {
  697.          FREE(buffer);
  698.          return NULL;
  699.       }
  700.  
  701.       if (packing->SkipPixels == 0) {
  702.          MEMCPY( dst, src, width_in_bytes );
  703.          if (packing->LsbFirst) {
  704.             flip_bytes( dst, width_in_bytes );
  705.          }
  706.       }
  707.       else {
  708.          /* handling SkipPixels is a bit tricky (no pun intended!) */
  709.          GLint i;
  710.          if (packing->LsbFirst) {
  711.             GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
  712.             GLubyte dstMask = 128;
  713.             const GLubyte *s = src;
  714.             GLubyte *d = dst;
  715.             *d = 0;
  716.             for (i = 0; i < width; i++) {
  717.                if (*s & srcMask) {
  718.                   *d |= dstMask;
  719.                }
  720.                if (srcMask == 128) {
  721.                   srcMask = 1;
  722.                   s++;
  723.                }
  724.                else {
  725.                   srcMask = srcMask << 1;
  726.                }
  727.                if (dstMask == 1) {
  728.                   dstMask = 128;
  729.                   d++;
  730.                   *d = 0;
  731.                }
  732.                else {
  733.                   dstMask = dstMask >> 1;
  734.                }
  735.             }
  736.          }
  737.          else {
  738.             GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
  739.             GLubyte dstMask = 128;
  740.             const GLubyte *s = src;
  741.             GLubyte *d = dst;
  742.             *d = 0;
  743.             for (i = 0; i < width; i++) {
  744.                if (*s & srcMask) {
  745.                   *d |= dstMask;
  746.                }
  747.                if (srcMask == 1) {
  748.                   srcMask = 128;
  749.                   s++;
  750.                }
  751.                else {
  752.                   srcMask = srcMask >> 1;
  753.                }
  754.                if (dstMask == 1) {
  755.                   dstMask = 128;
  756.                   d++;
  757.                   *d = 0;
  758.                }
  759.                else {
  760.                   dstMask = dstMask >> 1;
  761.                }
  762.             }
  763.          }
  764.       }
  765.       dst += width_in_bytes;
  766.    }
  767.  
  768.    return buffer;
  769. }
  770.  
  771.  
  772. /*
  773.  * Pack bitmap data.
  774.  */
  775. void
  776. _mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,
  777.                    GLubyte *dest, const struct gl_pixelstore_attrib *packing )
  778. {
  779.    GLint row, width_in_bytes;
  780.    const GLubyte *src;
  781.  
  782.    if (!source)
  783.       return;
  784.  
  785.    width_in_bytes = CEILING( width, 8 );
  786.    src = source;
  787.    for (row = 0; row < height; row++) {
  788.       GLubyte *dst = (GLubyte *) _mesa_image_address( packing, dest,
  789.                        width, height, GL_COLOR_INDEX, GL_BITMAP, 0, row, 0 );
  790.       if (!dst)
  791.          return;
  792.  
  793.       if (packing->SkipPixels == 0) {
  794.          MEMCPY( dst, src, width_in_bytes );
  795.          if (packing->LsbFirst) {
  796.             flip_bytes( dst, width_in_bytes );
  797.          }
  798.       }
  799.       else {
  800.          /* handling SkipPixels is a bit tricky (no pun intended!) */
  801.          GLint i;
  802.          if (packing->LsbFirst) {
  803.             GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
  804.             GLubyte dstMask = 128;
  805.             const GLubyte *s = src;
  806.             GLubyte *d = dst;
  807.             *d = 0;
  808.             for (i = 0; i < width; i++) {
  809.                if (*s & srcMask) {
  810.                   *d |= dstMask;
  811.                }
  812.                if (srcMask == 128) {
  813.                   srcMask = 1;
  814.                   s++;
  815.                }
  816.                else {
  817.                   srcMask = srcMask << 1;
  818.                }
  819.                if (dstMask == 1) {
  820.                   dstMask = 128;
  821.                   d++;
  822.                   *d = 0;
  823.                }
  824.                else {
  825.                   dstMask = dstMask >> 1;
  826.                }
  827.             }
  828.          }
  829.          else {
  830.             GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
  831.             GLubyte dstMask = 128;
  832.             const GLubyte *s = src;
  833.             GLubyte *d = dst;
  834.             *d = 0;
  835.             for (i = 0; i < width; i++) {
  836.                if (*s & srcMask) {
  837.                   *d |= dstMask;
  838.                }
  839.                if (srcMask == 1) {
  840.                   srcMask = 128;
  841.                   s++;
  842.                }
  843.                else {
  844.                   srcMask = srcMask >> 1;
  845.                }
  846.                if (dstMask == 1) {
  847.                   dstMask = 128;
  848.                   d++;
  849.                   *d = 0;
  850.                }
  851.                else {
  852.                   dstMask = dstMask >> 1;
  853.                }
  854.             }
  855.          }
  856.       }
  857.       src += width_in_bytes;
  858.    }
  859. }
  860.  
  861.  
  862.  
  863. /*
  864.  * Used to pack an array [][4] of RGBA GLchan colors as specified
  865.  * by the dstFormat, dstType and dstPacking.  Used by glReadPixels,
  866.  * glGetConvolutionFilter(), etc.
  867.  */
  868. void
  869. _mesa_pack_float_rgba_span( GLcontext *ctx,
  870.                             GLuint n, CONST GLfloat rgbaIn[][4],
  871.                             GLenum dstFormat, GLenum dstType,
  872.                             GLvoid *dstAddr,
  873.                             const struct gl_pixelstore_attrib *dstPacking,
  874.                             GLuint transferOps )
  875. {
  876.    const GLint comps = _mesa_components_in_format(dstFormat);
  877.    GLfloat luminance[MAX_WIDTH];
  878.    GLfloat (*rgba)[4];
  879.    GLuint i;
  880.  
  881.    if (transferOps) {
  882.       /* make copy of incoming data */
  883.       DEFMARRAY(GLfloat, rgbaCopy, MAX_WIDTH, 4);  /* mac 32k limitation */
  884.       CHECKARRAY(rgbaCopy, return);  /* mac 32k limitation */
  885.  
  886.       for (i = 0; i < n; i++) {
  887.          rgbaCopy[i][0] = rgbaIn[i][0];
  888.          rgbaCopy[i][1] = rgbaIn[i][1];
  889.          rgbaCopy[i][2] = rgbaIn[i][2];
  890.          rgbaCopy[i][3] = rgbaIn[i][3];
  891.       }
  892.  
  893.       rgba = (GLfloat (*)[4]) rgbaCopy;
  894.  
  895.       /* scale & bias */
  896.       if (transferOps & IMAGE_SCALE_BIAS_BIT) {
  897.          _mesa_scale_and_bias_rgba(ctx, n, rgba,
  898.                                    ctx->Pixel.RedScale, ctx->Pixel.GreenScale,
  899.                                    ctx->Pixel.BlueScale, ctx->Pixel.AlphaScale,
  900.                                    ctx->Pixel.RedBias, ctx->Pixel.GreenBias,
  901.                                    ctx->Pixel.BlueBias, ctx->Pixel.AlphaBias);
  902.       }
  903.       /* color map lookup */
  904.       if (transferOps & IMAGE_MAP_COLOR_BIT) {
  905.          _mesa_map_rgba( ctx, n, rgba );
  906.       }
  907.       /* GL_COLOR_TABLE lookup */
  908.       if (transferOps & IMAGE_COLOR_TABLE_BIT) {
  909.          _mesa_lookup_rgba(&ctx->ColorTable, n, rgba);
  910.       }
  911.       /* convolution */
  912.       if (transferOps & IMAGE_CONVOLUTION_BIT) {
  913.          /* this has to be done in the calling code */
  914.       }
  915.       /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */
  916.       if (transferOps & IMAGE_POST_CONVOLUTION_SCALE_BIAS) {
  917.          _mesa_scale_and_bias_rgba(ctx, n, rgba,
  918.                                    ctx->Pixel.PostConvolutionScale[RCOMP],
  919.                                    ctx->Pixel.PostConvolutionScale[GCOMP],
  920.                                    ctx->Pixel.PostConvolutionScale[BCOMP],
  921.                                    ctx->Pixel.PostConvolutionScale[ACOMP],
  922.                                    ctx->Pixel.PostConvolutionBias[RCOMP],
  923.                                    ctx->Pixel.PostConvolutionBias[GCOMP],
  924.                                    ctx->Pixel.PostConvolutionBias[BCOMP],
  925.                                    ctx->Pixel.PostConvolutionBias[ACOMP]);
  926.       }
  927.       /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
  928.       if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
  929.          _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba);
  930.       }
  931.       /* color matrix transform */
  932.       if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
  933.          _mesa_transform_rgba(ctx, n, rgba);
  934.       }
  935.       /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
  936.       if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
  937.          _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba);
  938.       }
  939.       /* update histogram count */
  940.       if (transferOps & IMAGE_HISTOGRAM_BIT) {
  941.          _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba);
  942.       }
  943.       /* min/max here */
  944.       if (transferOps & IMAGE_MIN_MAX_BIT) {
  945.          _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba);
  946.          if (ctx->MinMax.Sink) {
  947.             UNDEFARRAY(rgbaCopy);  /* mac 32k limitation */
  948.             return;
  949.          }
  950.       }
  951.       UNDEFARRAY(rgbaCopy);  /* mac 32k limitation */
  952.    }
  953.    else {
  954.       /* use incoming data, not a copy */
  955.       rgba = (GLfloat (*)[4]) rgbaIn;
  956.    }
  957.  
  958.    /* XXX clamp rgba to [0,1]? */
  959.  
  960.  
  961.    if (dstFormat == GL_LUMINANCE || dstFormat == GL_LUMINANCE_ALPHA) {
  962.       for (i = 0; i < n; i++) {
  963.          GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
  964. #if CHAN_TYPE == GL_FLOAT
  965.          luminance[i] = sum;
  966. #else
  967.          luminance[i] = CLAMP(sum, 0.0F, 1.0F);
  968. #endif
  969.       }
  970.    }
  971.  
  972.    /*
  973.     * Pack/store the pixels.  Ugh!  Lots of cases!!!
  974.     */
  975.    switch (dstType) {
  976.       case GL_UNSIGNED_BYTE:
  977.          {
  978.             GLubyte *dst = (GLubyte *) dstAddr;
  979.             switch (dstFormat) {
  980.                case GL_RED:
  981.                   for (i=0;i<n;i++)
  982.                      dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
  983.                   break;
  984.                case GL_GREEN:
  985.                   for (i=0;i<n;i++)
  986.                      dst[i] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
  987.                   break;
  988.                case GL_BLUE:
  989.                   for (i=0;i<n;i++)
  990.                      dst[i] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
  991.                   break;
  992.                case GL_ALPHA:
  993.                   for (i=0;i<n;i++)
  994.                      dst[i] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
  995.                   break;
  996.                case GL_LUMINANCE:
  997.                   for (i=0;i<n;i++)
  998.                      dst[i] = FLOAT_TO_UBYTE(luminance[i]);
  999.                   break;
  1000.                case GL_LUMINANCE_ALPHA:
  1001.                   for (i=0;i<n;i++) {
  1002.                      dst[i*2+0] = FLOAT_TO_UBYTE(luminance[i]);
  1003.                      dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
  1004.                   }
  1005.                   break;
  1006.                case GL_RGB:
  1007.                   for (i=0;i<n;i++) {
  1008.                      dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
  1009.                      dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
  1010.                      dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
  1011.                   }
  1012.                   break;
  1013.                case GL_RGBA:
  1014.                   for (i=0;i<n;i++) {
  1015.                      dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
  1016.                      dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
  1017.                      dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
  1018.                      dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
  1019.                   }
  1020.                   break;
  1021.                case GL_BGR:
  1022.                   for (i=0;i<n;i++) {
  1023.                      dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
  1024.                      dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
  1025.                      dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
  1026.                   }
  1027.                   break;
  1028.                case GL_BGRA:
  1029.                   for (i=0;i<n;i++) {
  1030.                      dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
  1031.                      dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
  1032.                      dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
  1033.                      dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
  1034.                   }
  1035.                   break;
  1036.                case GL_ABGR_EXT:
  1037.                   for (i=0;i<n;i++) {
  1038.                      dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
  1039.                      dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
  1040.                      dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
  1041.                      dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
  1042.                   }
  1043.                   break;
  1044.                default:
  1045.                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
  1046.             }
  1047.          }
  1048.          break;
  1049.       case GL_BYTE:
  1050.          {
  1051.             GLbyte *dst = (GLbyte *) dstAddr;
  1052.             switch (dstFormat) {
  1053.                case GL_RED:
  1054.                   for (i=0;i<n;i++)
  1055.                      dst[i] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
  1056.                   break;
  1057.                case GL_GREEN:
  1058.                   for (i=0;i<n;i++)
  1059.                      dst[i] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
  1060.                   break;
  1061.                case GL_BLUE:
  1062.                   for (i=0;i<n;i++)
  1063.                      dst[i] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
  1064.                   break;
  1065.                case GL_ALPHA:
  1066.                   for (i=0;i<n;i++)
  1067.                      dst[i] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
  1068.                   break;
  1069.                case GL_LUMINANCE:
  1070.                   for (i=0;i<n;i++)
  1071.                      dst[i] = FLOAT_TO_BYTE(luminance[i]);
  1072.                   break;
  1073.                case GL_LUMINANCE_ALPHA:
  1074.                   for (i=0;i<n;i++) {
  1075.                      dst[i*2+0] = FLOAT_TO_BYTE(luminance[i]);
  1076.                      dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
  1077.                   }
  1078.                   break;
  1079.                case GL_RGB:
  1080.                   for (i=0;i<n;i++) {
  1081.                      dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
  1082.                      dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
  1083.                      dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
  1084.                   }
  1085.                   break;
  1086.                case GL_RGBA:
  1087.                   for (i=0;i<n;i++) {
  1088.                      dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
  1089.                      dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
  1090.                      dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
  1091.                      dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
  1092.                   }
  1093.                   break;
  1094.                case GL_BGR:
  1095.                   for (i=0;i<n;i++) {
  1096.                      dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
  1097.                      dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
  1098.                      dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
  1099.                   }
  1100.                   break;
  1101.                case GL_BGRA:
  1102.                   for (i=0;i<n;i++) {
  1103.                      dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
  1104.                      dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
  1105.                      dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
  1106.                      dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
  1107.                   }
  1108.                case GL_ABGR_EXT:
  1109.                   for (i=0;i<n;i++) {
  1110.                      dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
  1111.                      dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
  1112.                      dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
  1113.                      dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
  1114.                   }
  1115.                   break;
  1116.                default:
  1117.                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
  1118.             }
  1119.          }
  1120.          break;
  1121.       case GL_UNSIGNED_SHORT:
  1122.          {
  1123.             GLushort *dst = (GLushort *) dstAddr;
  1124.             switch (dstFormat) {
  1125.                case GL_RED:
  1126.                   for (i=0;i<n;i++)
  1127.                      dst[i] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
  1128.                   break;
  1129.                case GL_GREEN:
  1130.                   for (i=0;i<n;i++)
  1131.                      dst[i] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
  1132.                   break;
  1133.                case GL_BLUE:
  1134.                   for (i=0;i<n;i++)
  1135.                      dst[i] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
  1136.                   break;
  1137.                case GL_ALPHA:
  1138.                   for (i=0;i<n;i++)
  1139.                      dst[i] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
  1140.                   break;
  1141.                case GL_LUMINANCE:
  1142.                   for (i=0;i<n;i++)
  1143.                      dst[i] = FLOAT_TO_USHORT(luminance[i]);
  1144.                   break;
  1145.                case GL_LUMINANCE_ALPHA:
  1146.                   for (i=0;i<n;i++) {
  1147.                      dst[i*2+0] = FLOAT_TO_USHORT(luminance[i]);
  1148.                      dst[i*2+1] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
  1149.                   }
  1150.                   break;
  1151.                case GL_RGB:
  1152.                   for (i=0;i<n;i++) {
  1153.                      dst[i*3+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
  1154.                      dst[i*3+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
  1155.                      dst[i*3+2] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
  1156.                   }
  1157.                   break;
  1158.                case GL_RGBA:
  1159.                   for (i=0;i<n;i++) {
  1160.                      dst[i*4+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
  1161.                      dst[i*4+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
  1162.                      dst[i*4+2] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
  1163.                      dst[i*4+3] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
  1164.                   }
  1165.                   break;
  1166.                case GL_BGR:
  1167.                   for (i=0;i<n;i++) {
  1168.                      dst[i*3+0] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
  1169.                      dst[i*3+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
  1170.                      dst[i*3+2] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
  1171.                   }
  1172.                   break;
  1173.                case GL_BGRA:
  1174.                   for (i=0;i<n;i++) {
  1175.                      dst[i*4+0] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
  1176.                      dst[i*4+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
  1177.                      dst[i*4+2] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
  1178.                      dst[i*4+3] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
  1179.                   }
  1180.                   break;
  1181.                case GL_ABGR_EXT:
  1182.                   for (i=0;i<n;i++) {
  1183.                      dst[i*4+0] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
  1184.                      dst[i*4+1] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
  1185.                      dst[i*4+2] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
  1186.                      dst[i*4+3] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
  1187.                   }
  1188.                   break;
  1189.                default:
  1190.                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
  1191.             }
  1192.             if (dstPacking->SwapBytes) {
  1193.                _mesa_swap2( (GLushort *) dst, n * comps);
  1194.             }
  1195.          }
  1196.          break;
  1197.       case GL_SHORT:
  1198.          {
  1199.             GLshort *dst = (GLshort *) dstAddr;
  1200.             switch (dstFormat) {
  1201.                case GL_RED:
  1202.                   for (i=0;i<n;i++)
  1203.                      dst[i] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
  1204.                   break;
  1205.                case GL_GREEN:
  1206.                   for (i=0;i<n;i++)
  1207.                      dst[i] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
  1208.                   break;
  1209.                case GL_BLUE:
  1210.                   for (i=0;i<n;i++)
  1211.                      dst[i] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
  1212.                   break;
  1213.                case GL_ALPHA:
  1214.                   for (i=0;i<n;i++)
  1215.                      dst[i] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
  1216.                   break;
  1217.                case GL_LUMINANCE:
  1218.                   for (i=0;i<n;i++)
  1219.                      dst[i] = FLOAT_TO_SHORT(luminance[i]);
  1220.                   break;
  1221.                case GL_LUMINANCE_ALPHA:
  1222.                   for (i=0;i<n;i++) {
  1223.                      dst[i*2+0] = FLOAT_TO_SHORT(luminance[i]);
  1224.                      dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
  1225.                   }
  1226.                   break;
  1227.                case GL_RGB:
  1228.                   for (i=0;i<n;i++) {
  1229.                      dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
  1230.                      dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
  1231.                      dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
  1232.                   }
  1233.                   break;
  1234.                case GL_RGBA:
  1235.                   for (i=0;i<n;i++) {
  1236.                      dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
  1237.                      dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
  1238.                      dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
  1239.                      dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
  1240.                   }
  1241.                   break;
  1242.                case GL_BGR:
  1243.                   for (i=0;i<n;i++) {
  1244.                      dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
  1245.                      dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
  1246.                      dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
  1247.                   }
  1248.                   break;
  1249.                case GL_BGRA:
  1250.                   for (i=0;i<n;i++) {
  1251.                      dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
  1252.                      dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
  1253.                      dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
  1254.                      dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
  1255.                   }
  1256.                case GL_ABGR_EXT:
  1257.                   for (i=0;i<n;i++) {
  1258.                      dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
  1259.                      dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
  1260.                      dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
  1261.                      dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
  1262.                   }
  1263.                   break;
  1264.                default:
  1265.                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
  1266.             }
  1267.             if (dstPacking->SwapBytes) {
  1268.                _mesa_swap2( (GLushort *) dst, n * comps );
  1269.             }
  1270.          }
  1271.          break;
  1272.       case GL_UNSIGNED_INT:
  1273.          {
  1274.             GLuint *dst = (GLuint *) dstAddr;
  1275.             switch (dstFormat) {
  1276.                case GL_RED:
  1277.                   for (i=0;i<n;i++)
  1278.                      dst[i] = FLOAT_TO_UINT(rgba[i][RCOMP]);
  1279.                   break;
  1280.                case GL_GREEN:
  1281.                   for (i=0;i<n;i++)
  1282.                      dst[i] = FLOAT_TO_UINT(rgba[i][GCOMP]);
  1283.                   break;
  1284.                case GL_BLUE:
  1285.                   for (i=0;i<n;i++)
  1286.                      dst[i] = FLOAT_TO_UINT(rgba[i][BCOMP]);
  1287.                   break;
  1288.                case GL_ALPHA:
  1289.                   for (i=0;i<n;i++)
  1290.                      dst[i] = FLOAT_TO_UINT(rgba[i][ACOMP]);
  1291.                   break;
  1292.                case GL_LUMINANCE:
  1293.                   for (i=0;i<n;i++)
  1294.                      dst[i] = FLOAT_TO_UINT(luminance[i]);
  1295.                   break;
  1296.                case GL_LUMINANCE_ALPHA:
  1297.                   for (i=0;i<n;i++) {
  1298.                      dst[i*2+0] = FLOAT_TO_UINT(luminance[i]);
  1299.                      dst[i*2+1] = FLOAT_TO_UINT(rgba[i][ACOMP]);
  1300.                   }
  1301.                   break;
  1302.                case GL_RGB:
  1303.                   for (i=0;i<n;i++) {
  1304.                      dst[i*3+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
  1305.                      dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
  1306.                      dst[i*3+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
  1307.                   }
  1308.                   break;
  1309.                case GL_RGBA:
  1310.                   for (i=0;i<n;i++) {
  1311.                      dst[i*4+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
  1312.                      dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
  1313.                      dst[i*4+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
  1314.                      dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
  1315.                   }
  1316.                   break;
  1317.                case GL_BGR:
  1318.                   for (i=0;i<n;i++) {
  1319.                      dst[i*3+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
  1320.                      dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
  1321.                      dst[i*3+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
  1322.                   }
  1323.                   break;
  1324.                case GL_BGRA:
  1325.                   for (i=0;i<n;i++) {
  1326.                      dst[i*4+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
  1327.                      dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
  1328.                      dst[i*4+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
  1329.                      dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
  1330.                   }
  1331.                   break;
  1332.                case GL_ABGR_EXT:
  1333.                   for (i=0;i<n;i++) {
  1334.                      dst[i*4+0] = FLOAT_TO_UINT(rgba[i][ACOMP]);
  1335.                      dst[i*4+1] = FLOAT_TO_UINT(rgba[i][BCOMP]);
  1336.                      dst[i*4+2] = FLOAT_TO_UINT(rgba[i][GCOMP]);
  1337.                      dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]);
  1338.                   }
  1339.                   break;
  1340.                default:
  1341.                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
  1342.             }
  1343.             if (dstPacking->SwapBytes) {
  1344.                _mesa_swap4( (GLuint *) dst, n * comps );
  1345.             }
  1346.          }
  1347.          break;
  1348.       case GL_INT:
  1349.          {
  1350.             GLint *dst = (GLint *) dstAddr;
  1351.             switch (dstFormat) {
  1352.                case GL_RED:
  1353.                   for (i=0;i<n;i++)
  1354.                      dst[i] = FLOAT_TO_INT(rgba[i][RCOMP]);
  1355.                   break;
  1356.                case GL_GREEN:
  1357.                   for (i=0;i<n;i++)
  1358.                      dst[i] = FLOAT_TO_INT(rgba[i][GCOMP]);
  1359.                   break;
  1360.                case GL_BLUE:
  1361.                   for (i=0;i<n;i++)
  1362.                      dst[i] = FLOAT_TO_INT(rgba[i][BCOMP]);
  1363.                   break;
  1364.                case GL_ALPHA:
  1365.                   for (i=0;i<n;i++)
  1366.                      dst[i] = FLOAT_TO_INT(rgba[i][ACOMP]);
  1367.                   break;
  1368.                case GL_LUMINANCE:
  1369.                   for (i=0;i<n;i++)
  1370.                      dst[i] = FLOAT_TO_INT(luminance[i]);
  1371.                   break;
  1372.                case GL_LUMINANCE_ALPHA:
  1373.                   for (i=0;i<n;i++) {
  1374.                      dst[i*2+0] = FLOAT_TO_INT(luminance[i]);
  1375.                      dst[i*2+1] = FLOAT_TO_INT(rgba[i][ACOMP]);
  1376.                   }
  1377.                   break;
  1378.                case GL_RGB:
  1379.                   for (i=0;i<n;i++) {
  1380.                      dst[i*3+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
  1381.                      dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
  1382.                      dst[i*3+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
  1383.                   }
  1384.                   break;
  1385.                case GL_RGBA:
  1386.                   for (i=0;i<n;i++) {
  1387.                      dst[i*4+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
  1388.                      dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
  1389.                      dst[i*4+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
  1390.                      dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
  1391.                   }
  1392.                   break;
  1393.                case GL_BGR:
  1394.                   for (i=0;i<n;i++) {
  1395.                      dst[i*3+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
  1396.                      dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
  1397.                      dst[i*3+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
  1398.                   }
  1399.                   break;
  1400.                case GL_BGRA:
  1401.                   for (i=0;i<n;i++) {
  1402.                      dst[i*4+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
  1403.                      dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
  1404.                      dst[i*4+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
  1405.                      dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
  1406.                   }
  1407.                   break;
  1408.                case GL_ABGR_EXT:
  1409.                   for (i=0;i<n;i++) {
  1410.                      dst[i*4+0] = FLOAT_TO_INT(rgba[i][ACOMP]);
  1411.                      dst[i*4+1] = FLOAT_TO_INT(rgba[i][BCOMP]);
  1412.                      dst[i*4+2] = FLOAT_TO_INT(rgba[i][GCOMP]);
  1413.                      dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]);
  1414.                   }
  1415.                   break;
  1416.                default:
  1417.                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
  1418.             }
  1419.             if (dstPacking->SwapBytes) {
  1420.                _mesa_swap4( (GLuint *) dst, n * comps );
  1421.             }
  1422.          }
  1423.          break;
  1424.       case GL_FLOAT:
  1425.          {
  1426.             GLfloat *dst = (GLfloat *) dstAddr;
  1427.             switch (dstFormat) {
  1428.                case GL_RED:
  1429.                   for (i=0;i<n;i++)
  1430.                      dst[i] = rgba[i][RCOMP];
  1431.                   break;
  1432.                case GL_GREEN:
  1433.                   for (i=0;i<n;i++)
  1434.                      dst[i] = rgba[i][GCOMP];
  1435.                   break;
  1436.                case GL_BLUE:
  1437.                   for (i=0;i<n;i++)
  1438.                      dst[i] = rgba[i][BCOMP];
  1439.                   break;
  1440.                case GL_ALPHA:
  1441.                   for (i=0;i<n;i++)
  1442.                      dst[i] = rgba[i][ACOMP];
  1443.                   break;
  1444.                case GL_LUMINANCE:
  1445.                   for (i=0;i<n;i++)
  1446.                      dst[i] = luminance[i];
  1447.                   break;
  1448.                case GL_LUMINANCE_ALPHA:
  1449.                   for (i=0;i<n;i++) {
  1450.                      dst[i*2+0] = luminance[i];
  1451.                      dst[i*2+1] = rgba[i][ACOMP];
  1452.                   }
  1453.                   break;
  1454.                case GL_RGB:
  1455.                   for (i=0;i<n;i++) {
  1456.                      dst[i*3+0] = rgba[i][RCOMP];
  1457.                      dst[i*3+1] = rgba[i][GCOMP];
  1458.                      dst[i*3+2] = rgba[i][BCOMP];
  1459.                   }
  1460.                   break;
  1461.                case GL_RGBA:
  1462.                   for (i=0;i<n;i++) {
  1463.                      dst[i*4+0] = rgba[i][RCOMP];
  1464.                      dst[i*4+1] = rgba[i][GCOMP];
  1465.                      dst[i*4+2] = rgba[i][BCOMP];
  1466.                      dst[i*4+3] = rgba[i][ACOMP];
  1467.                   }
  1468.                   break;
  1469.                case GL_BGR:
  1470.                   for (i=0;i<n;i++) {
  1471.                      dst[i*3+0] = rgba[i][BCOMP];
  1472.                      dst[i*3+1] = rgba[i][GCOMP];
  1473.                      dst[i*3+2] = rgba[i][RCOMP];
  1474.                   }
  1475.                   break;
  1476.                case GL_BGRA:
  1477.                   for (i=0;i<n;i++) {
  1478.                      dst[i*4+0] = rgba[i][BCOMP];
  1479.                      dst[i*4+1] = rgba[i][GCOMP];
  1480.                      dst[i*4+2] = rgba[i][RCOMP];
  1481.                      dst[i*4+3] = rgba[i][ACOMP];
  1482.                   }
  1483.                   break;
  1484.                case GL_ABGR_EXT:
  1485.                   for (i=0;i<n;i++) {
  1486.                      dst[i*4+0] = rgba[i][ACOMP];
  1487.                      dst[i*4+1] = rgba[i][BCOMP];
  1488.                      dst[i*4+2] = rgba[i][GCOMP];
  1489.                      dst[i*4+3] = rgba[i][RCOMP];
  1490.                   }
  1491.                   break;
  1492.                default:
  1493.                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
  1494.             }
  1495.             if (dstPacking->SwapBytes) {
  1496.                _mesa_swap4( (GLuint *) dst, n * comps );
  1497.             }
  1498.          }
  1499.          break;
  1500.       case GL_UNSIGNED_BYTE_3_3_2:
  1501.          if (dstFormat == GL_RGB) {
  1502.             GLubyte *dst = (GLubyte *) dstAddr;
  1503.             for (i=0;i<n;i++) {
  1504.                dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F)) << 5)
  1505.                       | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 2)
  1506.                       | (((GLint) (rgba[i][BCOMP] * 3.0F))     );
  1507.             }
  1508.          }
  1509.          break;
  1510.       case GL_UNSIGNED_BYTE_2_3_3_REV:
  1511.          if (dstFormat == GL_RGB) {
  1512.             GLubyte *dst = (GLubyte *) dstAddr;
  1513.             for (i=0;i<n;i++) {
  1514.                dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F))     )
  1515.                       | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 3)
  1516.                       | (((GLint) (rgba[i][BCOMP] * 3.0F)) << 5);
  1517.             }
  1518.          }
  1519.          break;
  1520.       case GL_UNSIGNED_SHORT_5_6_5:
  1521.          if (dstFormat == GL_RGB) {
  1522.             GLushort *dst = (GLushort *) dstAddr;
  1523.             for (i=0;i<n;i++) {
  1524.                dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11)
  1525.                       | (((GLint) (rgba[i][GCOMP] * 63.0F)) <<  5)
  1526.                       | (((GLint) (rgba[i][BCOMP] * 31.0F))      );
  1527.             }
  1528.          }
  1529.          break;
  1530.       case GL_UNSIGNED_SHORT_5_6_5_REV:
  1531.          if (dstFormat == GL_RGB) {
  1532.             GLushort *dst = (GLushort *) dstAddr;
  1533.             for (i=0;i<n;i++) {
  1534.                dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F))      )
  1535.                       | (((GLint) (rgba[i][GCOMP] * 63.0F)) <<  5)
  1536.                       | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11);
  1537.             }
  1538.          }
  1539.          break;
  1540.       case GL_UNSIGNED_SHORT_4_4_4_4:
  1541.          if (dstFormat == GL_RGBA) {
  1542.             GLushort *dst = (GLushort *) dstAddr;
  1543.             for (i=0;i<n;i++) {
  1544.                dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12)
  1545.                       | (((GLint) (rgba[i][GCOMP] * 15.0F)) <<  8)
  1546.                       | (((GLint) (rgba[i][BCOMP] * 15.0F)) <<  4)
  1547.                       | (((GLint) (rgba[i][ACOMP] * 15.0F))      );
  1548.             }
  1549.          }
  1550.          else if (dstFormat == GL_BGRA) {
  1551.             GLushort *dst = (GLushort *) dstAddr;
  1552.             for (i=0;i<n;i++) {
  1553.                dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F)) << 12)
  1554.                       | (((GLint) (rgba[i][GCOMP] * 15.0F)) <<  8)
  1555.                       | (((GLint) (rgba[i][RCOMP] * 15.0F)) <<  4)
  1556.                       | (((GLint) (rgba[i][ACOMP] * 15.0F))      );
  1557.             }
  1558.          }
  1559.          else if (dstFormat == GL_ABGR_EXT) {
  1560.             GLushort *dst = (GLushort *) dstAddr;
  1561.             for (i=0;i<n;i++) {
  1562.                dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F)) <<  4)
  1563.                       | (((GLint) (rgba[i][BCOMP] * 15.0F)) <<  8)
  1564.                       | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 12)
  1565.                       | (((GLint) (rgba[i][RCOMP] * 15.0F))      );
  1566.             }
  1567.          }
  1568.          break;
  1569.       case GL_UNSIGNED_SHORT_4_4_4_4_REV:
  1570.          if (dstFormat == GL_RGBA) {
  1571.             GLushort *dst = (GLushort *) dstAddr;
  1572.             for (i=0;i<n;i++) {
  1573.                dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F))      )
  1574.                       | (((GLint) (rgba[i][GCOMP] * 15.0F)) <<  4)
  1575.                       | (((GLint) (rgba[i][BCOMP] * 15.0F)) <<  8)
  1576.                       | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12);
  1577.             }
  1578.          }
  1579.          else if (dstFormat == GL_BGRA) {
  1580.             GLushort *dst = (GLushort *) dstAddr;
  1581.             for (i=0;i<n;i++) {
  1582.                dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F))      )
  1583.                       | (((GLint) (rgba[i][GCOMP] * 15.0F)) <<  4)
  1584.                       | (((GLint) (rgba[i][RCOMP] * 15.0F)) <<  8)
  1585.                       | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12);
  1586.             }
  1587.          }
  1588.          else if (dstFormat == GL_ABGR_EXT) {
  1589.             GLushort *dst = (GLushort *) dstAddr;
  1590.             for (i=0;i<n;i++) {
  1591.                dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F))      )
  1592.                       | (((GLint) (rgba[i][BCOMP] * 15.0F)) <<  4)
  1593.                       | (((GLint) (rgba[i][GCOMP] * 15.0F)) <<  8)
  1594.                       | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12);
  1595.             }
  1596.          }
  1597.          break;
  1598.       case GL_UNSIGNED_SHORT_5_5_5_1:
  1599.          if (dstFormat == GL_RGBA) {
  1600.             GLushort *dst = (GLushort *) dstAddr;
  1601.             for (i=0;i<n;i++) {
  1602.                dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11)
  1603.                       | (((GLint) (rgba[i][GCOMP] * 31.0F)) <<  6)
  1604.                       | (((GLint) (rgba[i][BCOMP] * 31.0F)) <<  1)
  1605.                       | (((GLint) (rgba[i][ACOMP] *  1.0F))      );
  1606.             }
  1607.          }
  1608.          else if (dstFormat == GL_BGRA) {
  1609.             GLushort *dst = (GLushort *) dstAddr;
  1610.             for (i=0;i<n;i++) {
  1611.                dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11)
  1612.                       | (((GLint) (rgba[i][GCOMP] * 31.0F)) <<  6)
  1613.                       | (((GLint) (rgba[i][RCOMP] * 31.0F)) <<  1)
  1614.                       | (((GLint) (rgba[i][ACOMP] *  1.0F))      );
  1615.             }
  1616.          }
  1617.          else if (dstFormat == GL_ABGR_EXT) {
  1618.             GLushort *dst = (GLushort *) dstAddr;
  1619.             for (i=0;i<n;i++) {
  1620.                dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F)) << 11)
  1621.                       | (((GLint) (rgba[i][BCOMP] * 31.0F)) <<  6)
  1622.                       | (((GLint) (rgba[i][GCOMP] * 31.0F)) <<  1)
  1623.                       | (((GLint) (rgba[i][RCOMP] *  1.0F))      );
  1624.             }
  1625.          }
  1626.          break;
  1627.       case GL_UNSIGNED_SHORT_1_5_5_5_REV:
  1628.          if (dstFormat == GL_RGBA) {
  1629.             GLushort *dst = (GLushort *) dstAddr;
  1630.             for (i=0;i<n;i++) {
  1631.                dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F))      )
  1632.                       | (((GLint) (rgba[i][GCOMP] * 31.0F)) <<  5)
  1633.                       | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 10)
  1634.                       | (((GLint) (rgba[i][ACOMP] *  1.0F)) << 15);
  1635.             }
  1636.          }
  1637.          else if (dstFormat == GL_BGRA) {
  1638.             GLushort *dst = (GLushort *) dstAddr;
  1639.             for (i=0;i<n;i++) {
  1640.                dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F))      )
  1641.                       | (((GLint) (rgba[i][GCOMP] * 31.0F)) <<  5)
  1642.                       | (((GLint) (rgba[i][RCOMP] * 31.0F)) << 10)
  1643.                       | (((GLint) (rgba[i][ACOMP] *  1.0F)) << 15);
  1644.             }
  1645.          }
  1646.          else if (dstFormat == GL_ABGR_EXT) {
  1647.             GLushort *dst = (GLushort *) dstAddr;
  1648.             for (i=0;i<n;i++) {
  1649.                dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F))      )
  1650.                       | (((GLint) (rgba[i][BCOMP] * 31.0F)) <<  5)
  1651.                       | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 10)
  1652.                       | (((GLint) (rgba[i][RCOMP] *  1.0F)) << 15);
  1653.             }
  1654.          }
  1655.          break;
  1656.       case GL_UNSIGNED_INT_8_8_8_8:
  1657.          if (dstFormat == GL_RGBA) {
  1658.             GLuint *dst = (GLuint *) dstAddr;
  1659.             for (i=0;i<n;i++) {
  1660.                dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24)
  1661.                       | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
  1662.                       | (((GLuint) (rgba[i][BCOMP] * 255.0F)) <<  8)
  1663.                       | (((GLuint) (rgba[i][ACOMP] * 255.0F))      );
  1664.             }
  1665.          }
  1666.          else if (dstFormat == GL_BGRA) {
  1667.             GLuint *dst = (GLuint *) dstAddr;
  1668.             for (i=0;i<n;i++) {
  1669.                dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 24)
  1670.                       | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
  1671.                       | (((GLuint) (rgba[i][RCOMP] * 255.0F)) <<  8)
  1672.                       | (((GLuint) (rgba[i][ACOMP] * 255.0F))      );
  1673.             }
  1674.          }
  1675.          else if (dstFormat == GL_ABGR_EXT) {
  1676.             GLuint *dst = (GLuint *) dstAddr;
  1677.             for (i=0;i<n;i++) {
  1678.                dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24)
  1679.                       | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16)
  1680.                       | (((GLuint) (rgba[i][GCOMP] * 255.0F)) <<  8)
  1681.                       | (((GLuint) (rgba[i][RCOMP] * 255.0F))      );
  1682.             }
  1683.          }
  1684.          break;
  1685.       case GL_UNSIGNED_INT_8_8_8_8_REV:
  1686.          if (dstFormat == GL_RGBA) {
  1687.             GLuint *dst = (GLuint *) dstAddr;
  1688.             for (i=0;i<n;i++) {
  1689.                dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F))      )
  1690.                       | (((GLuint) (rgba[i][GCOMP] * 255.0F)) <<  8)
  1691.                       | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16)
  1692.                       | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24);
  1693.             }
  1694.          }
  1695.          else if (dstFormat == GL_BGRA) {
  1696.             GLuint *dst = (GLuint *) dstAddr;
  1697.             for (i=0;i<n;i++) {
  1698.                dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F))      )
  1699.                       | (((GLuint) (rgba[i][GCOMP] * 255.0F)) <<  8)
  1700.                       | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 16)
  1701.                       | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24);
  1702.             }
  1703.          }
  1704.          else if (dstFormat == GL_ABGR_EXT) {
  1705.             GLuint *dst = (GLuint *) dstAddr;
  1706.             for (i=0;i<n;i++) {
  1707.                dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F))      )
  1708.                       | (((GLuint) (rgba[i][BCOMP] * 255.0F)) <<  8)
  1709.                       | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
  1710.                       | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24);
  1711.             }
  1712.          }
  1713.          break;
  1714.       case GL_UNSIGNED_INT_10_10_10_2:
  1715.          if (dstFormat == GL_RGBA) {
  1716.             GLuint *dst = (GLuint *) dstAddr;
  1717.             for (i=0;i<n;i++) {
  1718.                dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 22)
  1719.                       | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12)
  1720.                       | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) <<  2)
  1721.                       | (((GLuint) (rgba[i][ACOMP] *    3.0F))      );
  1722.             }
  1723.          }
  1724.          else if (dstFormat == GL_BGRA) {
  1725.             GLuint *dst = (GLuint *) dstAddr;
  1726.             for (i=0;i<n;i++) {
  1727.                dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 22)
  1728.                       | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12)
  1729.                       | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) <<  2)
  1730.                       | (((GLuint) (rgba[i][ACOMP] *    3.0F))      );
  1731.             }
  1732.          }
  1733.          else if (dstFormat == GL_ABGR_EXT) {
  1734.             GLuint *dst = (GLuint *) dstAddr;
  1735.             for (i=0;i<n;i++) {
  1736.                dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F)) << 22)
  1737.                       | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 12)
  1738.                       | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) <<  2)
  1739.                       | (((GLuint) (rgba[i][RCOMP] *    3.0F))      );
  1740.             }
  1741.          }
  1742.          break;
  1743.       case GL_UNSIGNED_INT_2_10_10_10_REV:
  1744.          if (dstFormat == GL_RGBA) {
  1745.             GLuint *dst = (GLuint *) dstAddr;
  1746.             for (i=0;i<n;i++) {
  1747.                dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F))      )
  1748.                       | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10)
  1749.                       | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 20)
  1750.                       | (((GLuint) (rgba[i][ACOMP] *    3.0F)) << 30);
  1751.             }
  1752.          }
  1753.          else if (dstFormat == GL_BGRA) {
  1754.             GLuint *dst = (GLuint *) dstAddr;
  1755.             for (i=0;i<n;i++) {
  1756.                dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F))      )
  1757.                       | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10)
  1758.                       | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 20)
  1759.                       | (((GLuint) (rgba[i][ACOMP] *    3.0F)) << 30);
  1760.             }
  1761.          }
  1762.          else if (dstFormat == GL_ABGR_EXT) {
  1763.             GLuint *dst = (GLuint *) dstAddr;
  1764.             for (i=0;i<n;i++) {
  1765.                dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F))      )
  1766.                       | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 10)
  1767.                       | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 20)
  1768.                       | (((GLuint) (rgba[i][RCOMP] *    3.0F)) << 30);
  1769.             }
  1770.          }
  1771.          break;
  1772.       default:
  1773.          _mesa_problem(ctx, "bad type in _mesa_pack_float_rgba_span");
  1774.    }
  1775. }
  1776.  
  1777.  
  1778.  
  1779. /*
  1780.  * Pack the given RGBA span into client memory at 'dest' address
  1781.  * in the given pixel format and type.
  1782.  * Optionally apply the enabled pixel transfer ops.
  1783.  * Pack into memory using the given packing params struct.
  1784.  * This is used by glReadPixels and glGetTexImage?D()
  1785.  * Input:  ctx - the context
  1786.  *         n - number of pixels in the span
  1787.  *         rgba - the pixels
  1788.  *         format - dest packing format
  1789.  *         type - dest packing datatype
  1790.  *         destination - destination packing address
  1791.  *         packing - pixel packing parameters
  1792.  *         transferOps - bitmask of IMAGE_*_BIT operations to apply
  1793.  */
  1794. void
  1795. _mesa_pack_rgba_span( GLcontext *ctx,
  1796.                       GLuint n, CONST GLchan srcRgba[][4],
  1797.                       GLenum dstFormat, GLenum dstType,
  1798.                       GLvoid *dstAddr,
  1799.                       const struct gl_pixelstore_attrib *dstPacking,
  1800.                       GLuint transferOps)
  1801. {
  1802.    ASSERT((ctx->NewState & _NEW_PIXEL) == 0 || transferOps == 0);
  1803.  
  1804.    /* Test for optimized case first */
  1805.    if (transferOps == 0 && dstFormat == GL_RGBA && dstType == CHAN_TYPE) {
  1806.       /* common simple case */
  1807.       MEMCPY(dstAddr, srcRgba, n * 4 * sizeof(GLchan));
  1808.    }
  1809.    else if (transferOps == 0 && dstFormat == GL_RGB && dstType == CHAN_TYPE) {
  1810.       /* common simple case */
  1811.       GLuint i;
  1812.       GLchan *dest = (GLchan *) dstAddr;
  1813.       for (i = 0; i < n; i++) {
  1814.          dest[0] = srcRgba[i][RCOMP];
  1815.          dest[1] = srcRgba[i][GCOMP];
  1816.          dest[2] = srcRgba[i][BCOMP];
  1817.          dest += 3;
  1818.       }
  1819.    }
  1820.    else if (transferOps == 0 && dstFormat == GL_RGBA && dstType == GL_UNSIGNED_BYTE) {
  1821.       /* common simple case */
  1822.       GLuint i;
  1823.       GLubyte *dest = (GLubyte *) dstAddr;
  1824.       for (i = 0; i < n; i++) {
  1825.          dest[0] = CHAN_TO_UBYTE(srcRgba[i][RCOMP]);
  1826.          dest[1] = CHAN_TO_UBYTE(srcRgba[i][GCOMP]);
  1827.          dest[2] = CHAN_TO_UBYTE(srcRgba[i][BCOMP]);
  1828.          dest[3] = CHAN_TO_UBYTE(srcRgba[i][ACOMP]);
  1829.          dest += 4;
  1830.       }
  1831.    }
  1832.    else {
  1833.       /* general solution */
  1834.       GLuint i;
  1835.       DEFMARRAY(GLfloat, rgba, MAX_WIDTH, 4);  /* mac 32k limitation */
  1836.       CHECKARRAY(rgba, return);  /* mac 32k limitation */
  1837.  
  1838.       assert(n <= MAX_WIDTH);
  1839.       /* convert color components to floating point */
  1840.       for (i=0;i<n;i++) {
  1841.          rgba[i][RCOMP] = CHAN_TO_FLOAT(srcRgba[i][RCOMP]);
  1842.          rgba[i][GCOMP] = CHAN_TO_FLOAT(srcRgba[i][GCOMP]);
  1843.          rgba[i][BCOMP] = CHAN_TO_FLOAT(srcRgba[i][BCOMP]);
  1844.          rgba[i][ACOMP] = CHAN_TO_FLOAT(srcRgba[i][ACOMP]);
  1845.       }
  1846.       _mesa_pack_float_rgba_span(ctx, n, (const GLfloat (*)[4]) rgba,
  1847.                                  dstFormat, dstType, dstAddr,
  1848.                                  dstPacking, transferOps);
  1849.       UNDEFARRAY(rgba);  /* mac 32k limitation */
  1850.    }
  1851. }
  1852.  
  1853.  
  1854. #define SWAP2BYTE(VALUE)                       \
  1855.    {                                           \
  1856.       GLubyte *bytes = (GLubyte *) &(VALUE);   \
  1857.       GLubyte tmp = bytes[0];                  \
  1858.       bytes[0] = bytes[1];                     \
  1859.       bytes[1] = tmp;                          \
  1860.    }
  1861.  
  1862. #define SWAP4BYTE(VALUE)                       \
  1863.    {                                           \
  1864.       GLubyte *bytes = (GLubyte *) &(VALUE);   \
  1865.       GLubyte tmp = bytes[0];                  \
  1866.       bytes[0] = bytes[3];                     \
  1867.       bytes[3] = tmp;                          \
  1868.       tmp = bytes[1];                          \
  1869.       bytes[1] = bytes[2];                     \
  1870.       bytes[2] = tmp;                          \
  1871.    }
  1872.  
  1873.  
  1874. static void
  1875. extract_uint_indexes(GLuint n, GLuint indexes[],
  1876.                      GLenum srcFormat, GLenum srcType, const GLvoid *src,
  1877.                      const struct gl_pixelstore_attrib *unpack )
  1878. {
  1879.    assert(srcFormat == GL_COLOR_INDEX);
  1880.  
  1881.    ASSERT(srcType == GL_BITMAP ||
  1882.           srcType == GL_UNSIGNED_BYTE ||
  1883.           srcType == GL_BYTE ||
  1884.           srcType == GL_UNSIGNED_SHORT ||
  1885.           srcType == GL_SHORT ||
  1886.           srcType == GL_UNSIGNED_INT ||
  1887.           srcType == GL_INT ||
  1888.           srcType == GL_FLOAT);
  1889.  
  1890.    switch (srcType) {
  1891.       case GL_BITMAP:
  1892.          {
  1893.             GLubyte *ubsrc = (GLubyte *) src;
  1894.             if (unpack->LsbFirst) {
  1895.                GLubyte mask = 1 << (unpack->SkipPixels & 0x7);
  1896.                GLuint i;
  1897.                for (i = 0; i < n; i++) {
  1898.                   indexes[i] = (*ubsrc & mask) ? 1 : 0;
  1899.                   if (mask == 128) {
  1900.                      mask = 1;
  1901.                      ubsrc++;
  1902.                   }
  1903.                   else {
  1904.                      mask = mask << 1;
  1905.                   }
  1906.                }
  1907.             }
  1908.             else {
  1909.                GLubyte mask = 128 >> (unpack->SkipPixels & 0x7);
  1910.                GLuint i;
  1911.                for (i = 0; i < n; i++) {
  1912.                   indexes[i] = (*ubsrc & mask) ? 1 : 0;
  1913.                   if (mask == 1) {
  1914.                      mask = 128;
  1915.                      ubsrc++;
  1916.                   }
  1917.                   else {
  1918.                      mask = mask >> 1;
  1919.                   }
  1920.                }
  1921.             }
  1922.          }
  1923.          break;
  1924.       case GL_UNSIGNED_BYTE:
  1925.          {
  1926.             GLuint i;
  1927.             const GLubyte *s = (const GLubyte *) src;
  1928.             for (i = 0; i < n; i++)
  1929.                indexes[i] = s[i];
  1930.          }
  1931.          break;
  1932.       case GL_BYTE:
  1933.          {
  1934.             GLuint i;
  1935.             const GLbyte *s = (const GLbyte *) src;
  1936.             for (i = 0; i < n; i++)
  1937.                indexes[i] = s[i];
  1938.          }
  1939.          break;
  1940.       case GL_UNSIGNED_SHORT:
  1941.          {
  1942.             GLuint i;
  1943.             const GLushort *s = (const GLushort *) src;
  1944.             if (unpack->SwapBytes) {
  1945.                for (i = 0; i < n; i++) {
  1946.                   GLushort value = s[i];
  1947.                   SWAP2BYTE(value);
  1948.                   indexes[i] = value;
  1949.                }
  1950.             }
  1951.             else {
  1952.                for (i = 0; i < n; i++)
  1953.                   indexes[i] = s[i];
  1954.             }
  1955.          }
  1956.          break;
  1957.       case GL_SHORT:
  1958.          {
  1959.             GLuint i;
  1960.             const GLshort *s = (const GLshort *) src;
  1961.             if (unpack->SwapBytes) {
  1962.                for (i = 0; i < n; i++) {
  1963.                   GLshort value = s[i];
  1964.                   SWAP2BYTE(value);
  1965.                   indexes[i] = value;
  1966.                }
  1967.             }
  1968.             else {
  1969.                for (i = 0; i < n; i++)
  1970.                   indexes[i] = s[i];
  1971.             }
  1972.          }
  1973.          break;
  1974.       case GL_UNSIGNED_INT:
  1975.          {
  1976.             GLuint i;
  1977.             const GLuint *s = (const GLuint *) src;
  1978.             if (unpack->SwapBytes) {
  1979.                for (i = 0; i < n; i++) {
  1980.                   GLuint value = s[i];
  1981.                   SWAP4BYTE(value);
  1982.                   indexes[i] = value;
  1983.                }
  1984.             }
  1985.             else {
  1986.                for (i = 0; i < n; i++)
  1987.                   indexes[i] = s[i];
  1988.             }
  1989.          }
  1990.          break;
  1991.       case GL_INT:
  1992.          {
  1993.             GLuint i;
  1994.             const GLint *s = (const GLint *) src;
  1995.             if (unpack->SwapBytes) {
  1996.                for (i = 0; i < n; i++) {
  1997.                   GLint value = s[i];
  1998.                   SWAP4BYTE(value);
  1999.                   indexes[i] = value;
  2000.                }
  2001.             }
  2002.             else {
  2003.                for (i = 0; i < n; i++)
  2004.                   indexes[i] = s[i];
  2005.             }
  2006.          }
  2007.          break;
  2008.       case GL_FLOAT:
  2009.          {
  2010.             GLuint i;
  2011.             const GLfloat *s = (const GLfloat *) src;
  2012.             if (unpack->SwapBytes) {
  2013.                for (i = 0; i < n; i++) {
  2014.                   GLfloat value = s[i];
  2015.                   SWAP4BYTE(value);
  2016.                   indexes[i] = (GLuint) value;
  2017.                }
  2018.             }
  2019.             else {
  2020.                for (i = 0; i < n; i++)
  2021.                   indexes[i] = (GLuint) s[i];
  2022.             }
  2023.          }
  2024.          break;
  2025.       default:
  2026.          _mesa_problem(NULL, "bad srcType in extract_uint_indexes");
  2027.          return;
  2028.    }
  2029. }
  2030.  
  2031.  
  2032.  
  2033. /*
  2034.  * This function extracts floating point RGBA values from arbitrary
  2035.  * image data.  srcFormat and srcType are the format and type parameters
  2036.  * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
  2037.  *
  2038.  * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
  2039.  * implements the "Conversion to floating point", "Conversion to RGB",
  2040.  * and "Final Expansion to RGBA" operations.
  2041.  *
  2042.  * Args:  n - number of pixels
  2043.  *        rgba - output colors
  2044.  *        srcFormat - format of incoming data
  2045.  *        srcType - datatype of incoming data
  2046.  *        src - source data pointer
  2047.  *        swapBytes - perform byteswapping of incoming data?
  2048.  */
  2049. static void
  2050. extract_float_rgba(GLuint n, GLfloat rgba[][4],
  2051.                    GLenum srcFormat, GLenum srcType, const GLvoid *src,
  2052.                    GLboolean swapBytes)
  2053. {
  2054.    GLint redIndex, greenIndex, blueIndex, alphaIndex;
  2055.    GLint stride;
  2056.    GLint rComp, bComp, gComp, aComp;
  2057.  
  2058.    ASSERT(srcFormat == GL_RED ||
  2059.           srcFormat == GL_GREEN ||
  2060.           srcFormat == GL_BLUE ||
  2061.           srcFormat == GL_ALPHA ||
  2062.           srcFormat == GL_LUMINANCE ||
  2063.           srcFormat == GL_LUMINANCE_ALPHA ||
  2064.           srcFormat == GL_INTENSITY ||
  2065.           srcFormat == GL_RGB ||
  2066.           srcFormat == GL_BGR ||
  2067.           srcFormat == GL_RGBA ||
  2068.           srcFormat == GL_BGRA ||
  2069.           srcFormat == GL_ABGR_EXT);
  2070.  
  2071.    ASSERT(srcType == GL_UNSIGNED_BYTE ||
  2072.           srcType == GL_BYTE ||
  2073.           srcType == GL_UNSIGNED_SHORT ||
  2074.           srcType == GL_SHORT ||
  2075.           srcType == GL_UNSIGNED_INT ||
  2076.           srcType == GL_INT ||
  2077.           srcType == GL_FLOAT ||
  2078.           srcType == GL_UNSIGNED_BYTE_3_3_2 ||
  2079.           srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
  2080.           srcType == GL_UNSIGNED_SHORT_5_6_5 ||
  2081.           srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
  2082.           srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
  2083.           srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
  2084.           srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
  2085.           srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
  2086.           srcType == GL_UNSIGNED_INT_8_8_8_8 ||
  2087.           srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
  2088.           srcType == GL_UNSIGNED_INT_10_10_10_2 ||
  2089.           srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
  2090.  
  2091.    rComp = gComp = bComp = aComp = -1;
  2092.  
  2093.    switch (srcFormat) {
  2094.       case GL_RED:
  2095.          redIndex = 0;
  2096.          greenIndex = blueIndex = alphaIndex = -1;
  2097.          stride = 1;
  2098.          break;
  2099.       case GL_GREEN:
  2100.          greenIndex = 0;
  2101.          redIndex = blueIndex = alphaIndex = -1;
  2102.          stride = 1;
  2103.          break;
  2104.       case GL_BLUE:
  2105.          blueIndex = 0;
  2106.          redIndex = greenIndex = alphaIndex = -1;
  2107.          stride = 1;
  2108.          break;
  2109.       case GL_ALPHA:
  2110.          redIndex = greenIndex = blueIndex = -1;
  2111.          alphaIndex = 0;
  2112.          stride = 1;
  2113.          break;
  2114.       case GL_LUMINANCE:
  2115.          redIndex = greenIndex = blueIndex = 0;
  2116.          alphaIndex = -1;
  2117.          stride = 1;
  2118.          break;
  2119.       case GL_LUMINANCE_ALPHA:
  2120.          redIndex = greenIndex = blueIndex = 0;
  2121.          alphaIndex = 1;
  2122.          stride = 2;
  2123.          break;
  2124.       case GL_INTENSITY:
  2125.          redIndex = greenIndex = blueIndex = alphaIndex = 0;
  2126.          stride = 1;
  2127.          break;
  2128.       case GL_RGB:
  2129.          redIndex = 0;
  2130.          greenIndex = 1;
  2131.          blueIndex = 2;
  2132.          alphaIndex = -1;
  2133.          stride = 3;
  2134.          break;
  2135.       case GL_BGR:
  2136.          redIndex = 2;
  2137.          greenIndex = 1;
  2138.          blueIndex = 0;
  2139.          alphaIndex = -1;
  2140.          stride = 3;
  2141.          break;
  2142.       case GL_RGBA:
  2143.          redIndex = 0;
  2144.          greenIndex = 1;
  2145.          blueIndex = 2;
  2146.          alphaIndex = 3;
  2147.          rComp = 0;
  2148.          gComp = 1;
  2149.          bComp = 2;
  2150.          aComp = 3;
  2151.          stride = 4;
  2152.          break;
  2153.       case GL_BGRA:
  2154.          redIndex = 2;
  2155.          greenIndex = 1;
  2156.          blueIndex = 0;
  2157.          alphaIndex = 3;
  2158.          rComp = 2;
  2159.          gComp = 1;
  2160.          bComp = 0;
  2161.          aComp = 3;
  2162.          stride = 4;
  2163.          break;
  2164.       case GL_ABGR_EXT:
  2165.          redIndex = 3;
  2166.          greenIndex = 2;
  2167.          blueIndex = 1;
  2168.          alphaIndex = 0;
  2169.          rComp = 3;
  2170.          gComp = 2;
  2171.          bComp = 1;
  2172.          aComp = 0;
  2173.          stride = 4;
  2174.          break;
  2175.       default:
  2176.          _mesa_problem(NULL, "bad srcFormat in extract float data");
  2177.          return;
  2178.    }
  2179.  
  2180.  
  2181. #define PROCESS(INDEX, CHANNEL, DEFAULT, TYPE, CONVERSION)             \
  2182.    if ((INDEX) < 0) {                                                  \
  2183.       GLuint i;                                                                \
  2184.       for (i = 0; i < n; i++) {                                                \
  2185.          rgba[i][CHANNEL] = DEFAULT;                                   \
  2186.       }                                                                        \
  2187.    }                                                                   \
  2188.    else if (swapBytes) {                                               \
  2189.       const TYPE *s = (const TYPE *) src;                              \
  2190.       GLuint i;                                                                \
  2191.       for (i = 0; i < n; i++) {                                                \
  2192.          TYPE value = s[INDEX];                                                \
  2193.          if (sizeof(TYPE) == 2) {                                      \
  2194.             SWAP2BYTE(value);                                          \
  2195.          }                                                             \
  2196.          else if (sizeof(TYPE) == 4) {                                 \
  2197.             SWAP4BYTE(value);                                          \
  2198.          }                                                             \
  2199.          rgba[i][CHANNEL] = (GLfloat) CONVERSION(value);               \
  2200.          s += stride;                                                  \
  2201.       }                                                                        \
  2202.    }                                                                   \
  2203.    else {                                                              \
  2204.       const TYPE *s = (const TYPE *) src;                              \
  2205.       GLuint i;                                                                \
  2206.       for (i = 0; i < n; i++) {                                                \
  2207.          rgba[i][CHANNEL] = (GLfloat) CONVERSION(s[INDEX]);            \
  2208.          s += stride;                                                  \
  2209.       }                                                                        \
  2210.    }
  2211.  
  2212.    switch (srcType) {
  2213.       case GL_UNSIGNED_BYTE:
  2214.          PROCESS(redIndex,   RCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
  2215.          PROCESS(greenIndex, GCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
  2216.          PROCESS(blueIndex,  BCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
  2217.          PROCESS(alphaIndex, ACOMP, 1.0F, GLubyte, UBYTE_TO_FLOAT);
  2218.          break;
  2219.       case GL_BYTE:
  2220.          PROCESS(redIndex,   RCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
  2221.          PROCESS(greenIndex, GCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
  2222.          PROCESS(blueIndex,  BCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
  2223.          PROCESS(alphaIndex, ACOMP, 1.0F, GLbyte, BYTE_TO_FLOAT);
  2224.          break;
  2225.       case GL_UNSIGNED_SHORT:
  2226.          PROCESS(redIndex,   RCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
  2227.          PROCESS(greenIndex, GCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
  2228.          PROCESS(blueIndex,  BCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
  2229.          PROCESS(alphaIndex, ACOMP, 1.0F, GLushort, USHORT_TO_FLOAT);
  2230.          break;
  2231.       case GL_SHORT:
  2232.          PROCESS(redIndex,   RCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
  2233.          PROCESS(greenIndex, GCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
  2234.          PROCESS(blueIndex,  BCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
  2235.          PROCESS(alphaIndex, ACOMP, 1.0F, GLshort, SHORT_TO_FLOAT);
  2236.          break;
  2237.       case GL_UNSIGNED_INT:
  2238.          PROCESS(redIndex,   RCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
  2239.          PROCESS(greenIndex, GCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
  2240.          PROCESS(blueIndex,  BCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
  2241.          PROCESS(alphaIndex, ACOMP, 1.0F, GLuint, UINT_TO_FLOAT);
  2242.          break;
  2243.       case GL_INT:
  2244.          PROCESS(redIndex,   RCOMP, 0.0F, GLint, INT_TO_FLOAT);
  2245.          PROCESS(greenIndex, GCOMP, 0.0F, GLint, INT_TO_FLOAT);
  2246.          PROCESS(blueIndex,  BCOMP, 0.0F, GLint, INT_TO_FLOAT);
  2247.          PROCESS(alphaIndex, ACOMP, 1.0F, GLint, INT_TO_FLOAT);
  2248.          break;
  2249.       case GL_FLOAT:
  2250.          PROCESS(redIndex,   RCOMP, 0.0F, GLfloat, (GLfloat));
  2251.          PROCESS(greenIndex, GCOMP, 0.0F, GLfloat, (GLfloat));
  2252.          PROCESS(blueIndex,  BCOMP, 0.0F, GLfloat, (GLfloat));
  2253.          PROCESS(alphaIndex, ACOMP, 1.0F, GLfloat, (GLfloat));
  2254.          break;
  2255.       case GL_UNSIGNED_BYTE_3_3_2:
  2256.          {
  2257.             const GLubyte *ubsrc = (const GLubyte *) src;
  2258.             GLuint i;
  2259.             for (i = 0; i < n; i ++) {
  2260.                GLubyte p = ubsrc[i];
  2261.                rgba[i][RCOMP] = ((p >> 5)      ) * (1.0F / 7.0F);
  2262.                rgba[i][GCOMP] = ((p >> 2) & 0x7) * (1.0F / 7.0F);
  2263.                rgba[i][BCOMP] = ((p     ) & 0x3) * (1.0F / 3.0F);
  2264.                rgba[i][ACOMP] = 1.0F;
  2265.             }
  2266.          }
  2267.          break;
  2268.       case GL_UNSIGNED_BYTE_2_3_3_REV:
  2269.          {
  2270.             const GLubyte *ubsrc = (const GLubyte *) src;
  2271.             GLuint i;
  2272.             for (i = 0; i < n; i ++) {
  2273.                GLubyte p = ubsrc[i];
  2274.                rgba[i][RCOMP] = ((p     ) & 0x7) * (1.0F / 7.0F);
  2275.                rgba[i][GCOMP] = ((p >> 3) & 0x7) * (1.0F / 7.0F);
  2276.                rgba[i][BCOMP] = ((p >> 6)      ) * (1.0F / 3.0F);
  2277.                rgba[i][ACOMP] = 1.0F;
  2278.             }
  2279.          }
  2280.          break;
  2281.       case GL_UNSIGNED_SHORT_5_6_5:
  2282.          if (swapBytes) {
  2283.             const GLushort *ussrc = (const GLushort *) src;
  2284.             GLuint i;
  2285.             for (i = 0; i < n; i ++) {
  2286.                GLushort p = ussrc[i];
  2287.                SWAP2BYTE(p);
  2288.                rgba[i][RCOMP] = ((p >> 11)       ) * (1.0F / 31.0F);
  2289.                rgba[i][GCOMP] = ((p >>  5) & 0x3f) * (1.0F / 63.0F);
  2290.                rgba[i][BCOMP] = ((p      ) & 0x1f) * (1.0F / 31.0F);
  2291.                rgba[i][ACOMP] = 1.0F;
  2292.             }
  2293.          }
  2294.          else {
  2295.             const GLushort *ussrc = (const GLushort *) src;
  2296.             GLuint i;
  2297.             for (i = 0; i < n; i ++) {
  2298.                GLushort p = ussrc[i];
  2299.                rgba[i][RCOMP] = ((p >> 11)       ) * (1.0F / 31.0F);
  2300.                rgba[i][GCOMP] = ((p >>  5) & 0x3f) * (1.0F / 63.0F);
  2301.                rgba[i][BCOMP] = ((p      ) & 0x1f) * (1.0F / 31.0F);
  2302.                rgba[i][ACOMP] = 1.0F;
  2303.             }
  2304.          }
  2305.          break;
  2306.       case GL_UNSIGNED_SHORT_5_6_5_REV:
  2307.          if (swapBytes) {
  2308.             const GLushort *ussrc = (const GLushort *) src;
  2309.             GLuint i;
  2310.             for (i = 0; i < n; i ++) {
  2311.                GLushort p = ussrc[i];
  2312.                SWAP2BYTE(p);
  2313.                rgba[i][RCOMP] = ((p      ) & 0x1f) * (1.0F / 31.0F);
  2314.                rgba[i][GCOMP] = ((p >>  5) & 0x3f) * (1.0F / 63.0F);
  2315.                rgba[i][BCOMP] = ((p >> 11)       ) * (1.0F / 31.0F);
  2316.                rgba[i][ACOMP] = 1.0F;
  2317.             }
  2318.          }
  2319.          else {
  2320.             const GLushort *ussrc = (const GLushort *) src;
  2321.             GLuint i;
  2322.             for (i = 0; i < n; i ++) {
  2323.                GLushort p = ussrc[i];
  2324.                rgba[i][RCOMP] = ((p      ) & 0x1f) * (1.0F / 31.0F);
  2325.                rgba[i][GCOMP] = ((p >>  5) & 0x3f) * (1.0F / 63.0F);
  2326.                rgba[i][BCOMP] = ((p >> 11)       ) * (1.0F / 31.0F);
  2327.                rgba[i][ACOMP] = 1.0F;
  2328.             }
  2329.          }
  2330.          break;
  2331.       case GL_UNSIGNED_SHORT_4_4_4_4:
  2332.          if (swapBytes) {
  2333.             const GLushort *ussrc = (const GLushort *) src;
  2334.             GLuint i;
  2335.             for (i = 0; i < n; i ++) {
  2336.                GLushort p = ussrc[i];
  2337.                SWAP2BYTE(p);
  2338.                rgba[i][rComp] = ((p >> 12)      ) * (1.0F / 15.0F);
  2339.                rgba[i][gComp] = ((p >>  8) & 0xf) * (1.0F / 15.0F);
  2340.                rgba[i][bComp] = ((p >>  4) & 0xf) * (1.0F / 15.0F);
  2341.                rgba[i][aComp] = ((p      ) & 0xf) * (1.0F / 15.0F);
  2342.             }
  2343.          }
  2344.          else {
  2345.             const GLushort *ussrc = (const GLushort *) src;
  2346.             GLuint i;
  2347.             for (i = 0; i < n; i ++) {
  2348.                GLushort p = ussrc[i];
  2349.                rgba[i][rComp] = ((p >> 12)      ) * (1.0F / 15.0F);
  2350.                rgba[i][gComp] = ((p >>  8) & 0xf) * (1.0F / 15.0F);
  2351.                rgba[i][bComp] = ((p >>  4) & 0xf) * (1.0F / 15.0F);
  2352.                rgba[i][aComp] = ((p      ) & 0xf) * (1.0F / 15.0F);
  2353.             }
  2354.          }
  2355.          break;
  2356.       case GL_UNSIGNED_SHORT_4_4_4_4_REV:
  2357.          if (swapBytes) {
  2358.             const GLushort *ussrc = (const GLushort *) src;
  2359.             GLuint i;
  2360.             for (i = 0; i < n; i ++) {
  2361.                GLushort p = ussrc[i];
  2362.                SWAP2BYTE(p);
  2363.                rgba[i][rComp] = ((p      ) & 0xf) * (1.0F / 15.0F);
  2364.                rgba[i][gComp] = ((p >>  4) & 0xf) * (1.0F / 15.0F);
  2365.                rgba[i][bComp] = ((p >>  8) & 0xf) * (1.0F / 15.0F);
  2366.                rgba[i][aComp] = ((p >> 12)      ) * (1.0F / 15.0F);
  2367.             }
  2368.          }
  2369.          else {
  2370.             const GLushort *ussrc = (const GLushort *) src;
  2371.             GLuint i;
  2372.             for (i = 0; i < n; i ++) {
  2373.                GLushort p = ussrc[i];
  2374.                rgba[i][rComp] = ((p      ) & 0xf) * (1.0F / 15.0F);
  2375.                rgba[i][gComp] = ((p >>  4) & 0xf) * (1.0F / 15.0F);
  2376.                rgba[i][bComp] = ((p >>  8) & 0xf) * (1.0F / 15.0F);
  2377.                rgba[i][aComp] = ((p >> 12)      ) * (1.0F / 15.0F);
  2378.             }
  2379.          }
  2380.          break;
  2381.       case GL_UNSIGNED_SHORT_5_5_5_1:
  2382.          if (swapBytes) {
  2383.             const GLushort *ussrc = (const GLushort *) src;
  2384.             GLuint i;
  2385.             for (i = 0; i < n; i ++) {
  2386.                GLushort p = ussrc[i];
  2387.                SWAP2BYTE(p);
  2388.                rgba[i][rComp] = ((p >> 11)       ) * (1.0F / 31.0F);
  2389.                rgba[i][gComp] = ((p >>  6) & 0x1f) * (1.0F / 31.0F);
  2390.                rgba[i][bComp] = ((p >>  1) & 0x1f) * (1.0F / 31.0F);
  2391.                rgba[i][aComp] = ((p      ) & 0x1)  * (1.0F /  1.0F);
  2392.             }
  2393.          }
  2394.          else {
  2395.             const GLushort *ussrc = (const GLushort *) src;
  2396.             GLuint i;
  2397.             for (i = 0; i < n; i ++) {
  2398.                GLushort p = ussrc[i];
  2399.                rgba[i][rComp] = ((p >> 11)       ) * (1.0F / 31.0F);
  2400.                rgba[i][gComp] = ((p >>  6) & 0x1f) * (1.0F / 31.0F);
  2401.                rgba[i][bComp] = ((p >>  1) & 0x1f) * (1.0F / 31.0F);
  2402.                rgba[i][aComp] = ((p      ) & 0x1)  * (1.0F /  1.0F);
  2403.             }
  2404.          }
  2405.          break;
  2406.       case GL_UNSIGNED_SHORT_1_5_5_5_REV:
  2407.          if (swapBytes) {
  2408.             const GLushort *ussrc = (const GLushort *) src;
  2409.             GLuint i;
  2410.             for (i = 0; i < n; i ++) {
  2411.                GLushort p = ussrc[i];
  2412.                SWAP2BYTE(p);
  2413.                rgba[i][rComp] = ((p      ) & 0x1f) * (1.0F / 31.0F);
  2414.                rgba[i][gComp] = ((p >>  5) & 0x1f) * (1.0F / 31.0F);
  2415.                rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F);
  2416.                rgba[i][aComp] = ((p >> 15)       ) * (1.0F /  1.0F);
  2417.             }
  2418.          }
  2419.          else {
  2420.             const GLushort *ussrc = (const GLushort *) src;
  2421.             GLuint i;
  2422.             for (i = 0; i < n; i ++) {
  2423.                GLushort p = ussrc[i];
  2424.                rgba[i][rComp] = ((p      ) & 0x1f) * (1.0F / 31.0F);
  2425.                rgba[i][gComp] = ((p >>  5) & 0x1f) * (1.0F / 31.0F);
  2426.                rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F);
  2427.                rgba[i][aComp] = ((p >> 15)       ) * (1.0F /  1.0F);
  2428.             }
  2429.          }
  2430.          break;
  2431.       case GL_UNSIGNED_INT_8_8_8_8:
  2432.          if (swapBytes) {
  2433.             const GLuint *uisrc = (const GLuint *) src;
  2434.             GLuint i;
  2435.             for (i = 0; i < n; i ++) {
  2436.                GLuint p = uisrc[i];
  2437.                rgba[i][rComp] = UBYTE_TO_FLOAT((p      ) & 0xff);
  2438.                rgba[i][gComp] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
  2439.                rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
  2440.                rgba[i][aComp] = UBYTE_TO_FLOAT((p >> 24)       );
  2441.             }
  2442.          }
  2443.          else {
  2444.             const GLuint *uisrc = (const GLuint *) src;
  2445.             GLuint i;
  2446.             for (i = 0; i < n; i ++) {
  2447.                GLuint p = uisrc[i];
  2448.                rgba[i][rComp] = UBYTE_TO_FLOAT((p >> 24)       );
  2449.                rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
  2450.                rgba[i][bComp] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
  2451.                rgba[i][aComp] = UBYTE_TO_FLOAT((p      ) & 0xff);
  2452.             }
  2453.          }
  2454.          break;
  2455.       case GL_UNSIGNED_INT_8_8_8_8_REV:
  2456.          if (swapBytes) {
  2457.             const GLuint *uisrc = (const GLuint *) src;
  2458.             GLuint i;
  2459.             for (i = 0; i < n; i ++) {
  2460.                GLuint p = uisrc[i];
  2461.                rgba[i][rComp] = UBYTE_TO_FLOAT((p >> 24)       );
  2462.                rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
  2463.                rgba[i][bComp] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
  2464.                rgba[i][aComp] = UBYTE_TO_FLOAT((p      ) & 0xff);
  2465.             }
  2466.          }
  2467.          else {
  2468.             const GLuint *uisrc = (const GLuint *) src;
  2469.             GLuint i;
  2470.             for (i = 0; i < n; i ++) {
  2471.                GLuint p = uisrc[i];
  2472.                rgba[i][rComp] = UBYTE_TO_FLOAT((p      ) & 0xff);
  2473.                rgba[i][gComp] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
  2474.                rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
  2475.                rgba[i][aComp] = UBYTE_TO_FLOAT((p >> 24)       );
  2476.             }
  2477.          }
  2478.          break;
  2479.       case GL_UNSIGNED_INT_10_10_10_2:
  2480.          if (swapBytes) {
  2481.             const GLuint *uisrc = (const GLuint *) src;
  2482.             GLuint i;
  2483.             for (i = 0; i < n; i ++) {
  2484.                GLuint p = uisrc[i];
  2485.                SWAP4BYTE(p);
  2486.                rgba[i][rComp] = ((p >> 22)        ) * (1.0F / 1023.0F);
  2487.                rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F);
  2488.                rgba[i][bComp] = ((p >>  2) & 0x3ff) * (1.0F / 1023.0F);
  2489.                rgba[i][aComp] = ((p      ) & 0x3  ) * (1.0F /    3.0F);
  2490.             }
  2491.          }
  2492.          else {
  2493.             const GLuint *uisrc = (const GLuint *) src;
  2494.             GLuint i;
  2495.             for (i = 0; i < n; i ++) {
  2496.                GLuint p = uisrc[i];
  2497.                rgba[i][rComp] = ((p >> 22)        ) * (1.0F / 1023.0F);
  2498.                rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F);
  2499.                rgba[i][bComp] = ((p >>  2) & 0x3ff) * (1.0F / 1023.0F);
  2500.                rgba[i][aComp] = ((p      ) & 0x3  ) * (1.0F /    3.0F);
  2501.             }
  2502.          }
  2503.          break;
  2504.       case GL_UNSIGNED_INT_2_10_10_10_REV:
  2505.          if (swapBytes) {
  2506.             const GLuint *uisrc = (const GLuint *) src;
  2507.             GLuint i;
  2508.             for (i = 0; i < n; i ++) {
  2509.                GLuint p = uisrc[i];
  2510.                SWAP4BYTE(p);
  2511.                rgba[i][rComp] = ((p      ) & 0x3ff) * (1.0F / 1023.0F);
  2512.                rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F);
  2513.                rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F);
  2514.                rgba[i][aComp] = ((p >> 30)        ) * (1.0F /    3.0F);
  2515.             }
  2516.          }
  2517.          else {
  2518.             const GLuint *uisrc = (const GLuint *) src;
  2519.             GLuint i;
  2520.             for (i = 0; i < n; i ++) {
  2521.                GLuint p = uisrc[i];
  2522.                rgba[i][rComp] = ((p      ) & 0x3ff) * (1.0F / 1023.0F);
  2523.                rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F);
  2524.                rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F);
  2525.                rgba[i][aComp] = ((p >> 30)        ) * (1.0F /    3.0F);
  2526.             }
  2527.          }
  2528.          break;
  2529.       default:
  2530.          _mesa_problem(NULL, "bad srcType in extract float data");
  2531.          break;
  2532.    }
  2533. }
  2534.  
  2535.  
  2536.  
  2537. /*
  2538.  * Unpack a row of color image data from a client buffer according to
  2539.  * the pixel unpacking parameters.
  2540.  * Return GLubyte values in the specified dest image format.
  2541.  * This is (or will be) used by glDrawPixels and glTexImage?D().
  2542.  * Input:  ctx - the context
  2543.  *         n - number of pixels in the span
  2544.  *         dstFormat - format of destination color array
  2545.  *         dest - the destination color array
  2546.  *         srcFormat - source image format
  2547.  *         srcType - source image  datatype
  2548.  *         source - source image pointer
  2549.  *         srcPacking - pixel unpacking parameters
  2550.  *         transferOps - bitmask of IMAGE_*_BIT values of operations to apply
  2551.  *
  2552.  * XXX perhaps expand this to process whole images someday.
  2553.  */
  2554. void
  2555. _mesa_unpack_chan_color_span( GLcontext *ctx,
  2556.                               GLuint n, GLenum dstFormat, GLchan dest[],
  2557.                               GLenum srcFormat, GLenum srcType,
  2558.                               const GLvoid *source,
  2559.                               const struct gl_pixelstore_attrib *srcPacking,
  2560.                               GLuint transferOps )
  2561. {
  2562.    ASSERT(dstFormat == GL_ALPHA ||
  2563.           dstFormat == GL_LUMINANCE ||
  2564.           dstFormat == GL_LUMINANCE_ALPHA ||
  2565.           dstFormat == GL_INTENSITY ||
  2566.           dstFormat == GL_RGB ||
  2567.           dstFormat == GL_RGBA ||
  2568.           dstFormat == GL_COLOR_INDEX);
  2569.  
  2570.    ASSERT(srcFormat == GL_RED ||
  2571.           srcFormat == GL_GREEN ||
  2572.           srcFormat == GL_BLUE ||
  2573.           srcFormat == GL_ALPHA ||
  2574.           srcFormat == GL_LUMINANCE ||
  2575.           srcFormat == GL_LUMINANCE_ALPHA ||
  2576.           srcFormat == GL_INTENSITY ||
  2577.           srcFormat == GL_RGB ||
  2578.           srcFormat == GL_BGR ||
  2579.           srcFormat == GL_RGBA ||
  2580.           srcFormat == GL_BGRA ||
  2581.           srcFormat == GL_ABGR_EXT ||
  2582.           srcFormat == GL_COLOR_INDEX);
  2583.  
  2584.    ASSERT(srcType == GL_BITMAP ||
  2585.           srcType == GL_UNSIGNED_BYTE ||
  2586.           srcType == GL_BYTE ||
  2587.           srcType == GL_UNSIGNED_SHORT ||
  2588.           srcType == GL_SHORT ||
  2589.           srcType == GL_UNSIGNED_INT ||
  2590.           srcType == GL_INT ||
  2591.           srcType == GL_FLOAT ||
  2592.           srcType == GL_UNSIGNED_BYTE_3_3_2 ||
  2593.           srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
  2594.           srcType == GL_UNSIGNED_SHORT_5_6_5 ||
  2595.           srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
  2596.           srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
  2597.           srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
  2598.           srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
  2599.           srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
  2600.           srcType == GL_UNSIGNED_INT_8_8_8_8 ||
  2601.           srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
  2602.           srcType == GL_UNSIGNED_INT_10_10_10_2 ||
  2603.           srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
  2604.  
  2605.    /* Try simple cases first */
  2606.    if (transferOps == 0 ){
  2607.       if (srcType == CHAN_TYPE) {
  2608.          if (dstFormat == GL_RGBA) {
  2609.             if (srcFormat == GL_RGBA) {
  2610.                MEMCPY( dest, source, n * 4 * sizeof(GLchan) );
  2611.                return;
  2612.             }
  2613.             else if (srcFormat == GL_RGB) {
  2614.                GLuint i;
  2615.                const GLchan *src = (const GLchan *) source;
  2616.                GLchan *dst = dest;
  2617.                for (i = 0; i < n; i++) {
  2618.                   dst[RCOMP] = src[RCOMP];
  2619.                   dst[GCOMP] = src[GCOMP];
  2620.                   dst[BCOMP] = src[BCOMP];
  2621.                   dst[ACOMP] = CHAN_MAX;
  2622.                   src += 3;
  2623.                   dst += 4;
  2624.                }
  2625.                return;
  2626.             }
  2627.          }
  2628.          else if (dstFormat == GL_RGB) {
  2629.             if (srcFormat == GL_RGB) {
  2630.                MEMCPY( dest, source, n * 3 * sizeof(GLchan) );
  2631.                return;
  2632.             }
  2633.             else if (srcFormat == GL_RGBA) {
  2634.                GLuint i;
  2635.                const GLchan *src = (const GLchan *) source;
  2636.                GLchan *dst = dest;
  2637.                for (i = 0; i < n; i++) {
  2638.                   dst[RCOMP] = src[RCOMP];
  2639.                   dst[GCOMP] = src[GCOMP];
  2640.                   dst[BCOMP] = src[BCOMP];
  2641.                   src += 4;
  2642.                   dst += 3;
  2643.                }
  2644.                return;
  2645.             }
  2646.          }
  2647.          else if (dstFormat == srcFormat) {
  2648.             GLint comps = _mesa_components_in_format(srcFormat);
  2649.             assert(comps > 0);
  2650.             MEMCPY( dest, source, n * comps * sizeof(GLchan) );
  2651.             return;
  2652.          }
  2653.       }
  2654.       /*
  2655.        * Common situation, loading 8bit RGBA/RGB source images
  2656.        * into 16/32 bit destination. (OSMesa16/32)
  2657.        */
  2658.       else if (srcType == GL_UNSIGNED_BYTE) {
  2659.          if (dstFormat == GL_RGBA) {
  2660.             if (srcFormat == GL_RGB) {
  2661.                GLuint i;
  2662.                const GLubyte *src = (const GLubyte *) source;
  2663.                GLchan *dst = dest;
  2664.                for (i = 0; i < n; i++) {
  2665.                   dst[RCOMP] = UBYTE_TO_CHAN(src[RCOMP]);
  2666.                   dst[GCOMP] = UBYTE_TO_CHAN(src[GCOMP]);
  2667.                   dst[BCOMP] = UBYTE_TO_CHAN(src[BCOMP]);
  2668.                   dst[ACOMP] = CHAN_MAX;
  2669.                   src += 3;
  2670.                   dst += 4;
  2671.                }
  2672.                return;
  2673.             }
  2674.             else if (srcFormat == GL_RGBA) {
  2675.                GLuint i;
  2676.                const GLubyte *src = (const GLubyte *) source;
  2677.                GLchan *dst = dest;
  2678.                for (i = 0; i < n; i++) {
  2679.                   dst[0] = UBYTE_TO_CHAN(src[0]);
  2680.                   dst[1] = UBYTE_TO_CHAN(src[1]);
  2681.                   dst[2] = UBYTE_TO_CHAN(src[2]);
  2682.                   dst[3] = UBYTE_TO_CHAN(src[3]);
  2683.                   src += 4;
  2684.                   dst += 4;
  2685.                }
  2686.                return;
  2687.              }
  2688.          }
  2689.          else if (dstFormat == GL_RGB) {
  2690.             if (srcFormat == GL_RGB) {
  2691.                GLuint i;
  2692.                const GLubyte *src = (const GLubyte *) source;
  2693.                GLchan *dst = dest;
  2694.                for (i = 0; i < n; i++) {
  2695.                   dst[RCOMP] = UBYTE_TO_CHAN(src[RCOMP]);
  2696.                   dst[GCOMP] = UBYTE_TO_CHAN(src[GCOMP]);
  2697.                   dst[BCOMP] = UBYTE_TO_CHAN(src[BCOMP]);
  2698.                   src += 3;
  2699.                   dst += 3;
  2700.                }
  2701.                return;
  2702.             }
  2703.             else if (srcFormat == GL_RGBA) {
  2704.                GLuint i;
  2705.                const GLubyte *src = (const GLubyte *) source;
  2706.                GLchan *dst = dest;
  2707.                for (i = 0; i < n; i++) {
  2708.                   dst[RCOMP] = UBYTE_TO_CHAN(src[RCOMP]);
  2709.                   dst[GCOMP] = UBYTE_TO_CHAN(src[GCOMP]);
  2710.                   dst[BCOMP] = UBYTE_TO_CHAN(src[BCOMP]);
  2711.                   src += 4;
  2712.                   dst += 3;
  2713.                }
  2714.                return;
  2715.             }
  2716.          }
  2717.       }
  2718.    }
  2719.  
  2720.  
  2721.    /* general solution begins here */
  2722.    {
  2723.       GLint dstComponents;
  2724.       GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex;
  2725.       GLint dstLuminanceIndex, dstIntensityIndex;
  2726.       DEFMARRAY(GLfloat, rgba, MAX_WIDTH, 4);  /* mac 32k limitation */
  2727.       CHECKARRAY(rgba, return);  /* mac 32k limitation */
  2728.  
  2729.       dstComponents = _mesa_components_in_format( dstFormat );
  2730.       /* source & dest image formats should have been error checked by now */
  2731.       assert(dstComponents > 0);
  2732.  
  2733.       /*
  2734.        * Extract image data and convert to RGBA floats
  2735.        */
  2736.       assert(n <= MAX_WIDTH);
  2737.       if (srcFormat == GL_COLOR_INDEX) {
  2738.          GLuint indexes[MAX_WIDTH];
  2739.          extract_uint_indexes(n, indexes, srcFormat, srcType, source,
  2740.                               srcPacking);
  2741.  
  2742.          if (dstFormat == GL_COLOR_INDEX
  2743.              && (transferOps & IMAGE_MAP_COLOR_BIT)) {
  2744.             _mesa_map_ci(ctx, n, indexes);
  2745.          }
  2746.          if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
  2747.             _mesa_shift_and_offset_ci(ctx, n, indexes);
  2748.          }
  2749.  
  2750.          if (dstFormat == GL_COLOR_INDEX) {
  2751.             /* convert to GLchan and return */
  2752.             GLuint i;
  2753.             for (i = 0; i < n; i++) {
  2754.                dest[i] = (GLchan) (indexes[i] & 0xff);
  2755.             }
  2756.             UNDEFARRAY(rgba);  /* mac 32k limitation */
  2757.             return;
  2758.          }
  2759.          else {
  2760.             /* Convert indexes to RGBA */
  2761.             _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
  2762.          }
  2763.       }
  2764.       else {
  2765.          extract_float_rgba(n, rgba, srcFormat, srcType, source,
  2766.                             srcPacking->SwapBytes);
  2767.  
  2768.          /* scale and bias colors */
  2769.          if (transferOps & IMAGE_SCALE_BIAS_BIT) {
  2770.             _mesa_scale_and_bias_rgba(ctx, n, rgba,
  2771.                                    ctx->Pixel.RedScale, ctx->Pixel.GreenScale,
  2772.                                    ctx->Pixel.BlueScale, ctx->Pixel.AlphaScale,
  2773.                                    ctx->Pixel.RedBias, ctx->Pixel.GreenBias,
  2774.                                    ctx->Pixel.BlueBias, ctx->Pixel.AlphaBias);
  2775.          }
  2776.          /* color map lookup */
  2777.          if (transferOps & IMAGE_MAP_COLOR_BIT) {
  2778.             _mesa_map_rgba(ctx, n, rgba);
  2779.          }
  2780.       }
  2781.  
  2782.       if (transferOps) {
  2783.          /* GL_COLOR_TABLE lookup */
  2784.          if (transferOps & IMAGE_COLOR_TABLE_BIT) {
  2785.             _mesa_lookup_rgba(&ctx->ColorTable, n, rgba);
  2786.          }
  2787.          /* convolution */
  2788.          if (transferOps & IMAGE_CONVOLUTION_BIT) {
  2789.             /* this has to be done in the calling code */
  2790.          }
  2791.          /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */
  2792.          if (transferOps & IMAGE_POST_CONVOLUTION_SCALE_BIAS) {
  2793.             _mesa_scale_and_bias_rgba(ctx, n, rgba,
  2794.                                       ctx->Pixel.PostConvolutionScale[RCOMP],
  2795.                                       ctx->Pixel.PostConvolutionScale[GCOMP],
  2796.                                       ctx->Pixel.PostConvolutionScale[BCOMP],
  2797.                                       ctx->Pixel.PostConvolutionScale[ACOMP],
  2798.                                       ctx->Pixel.PostConvolutionBias[RCOMP],
  2799.                                       ctx->Pixel.PostConvolutionBias[GCOMP],
  2800.                                       ctx->Pixel.PostConvolutionBias[BCOMP],
  2801.                                       ctx->Pixel.PostConvolutionBias[ACOMP]);
  2802.          }
  2803.          /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
  2804.          if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
  2805.             _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba);
  2806.          }
  2807.          /* color matrix transform */
  2808.          if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
  2809.             _mesa_transform_rgba(ctx, n, rgba);
  2810.          }
  2811.          /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
  2812.          if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
  2813.             _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba);
  2814.          }
  2815.          /* update histogram count */
  2816.          if (transferOps & IMAGE_HISTOGRAM_BIT) {
  2817.             _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba);
  2818.          }
  2819.          /* min/max here */
  2820.          if (transferOps & IMAGE_MIN_MAX_BIT) {
  2821.             _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba);
  2822.          }
  2823.       }
  2824.  
  2825.       /* clamp to [0,1] */
  2826. #if CHAN_TYPE != GL_FLOAT
  2827.       {
  2828.          GLuint i;
  2829.          for (i = 0; i < n; i++) {
  2830.             rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
  2831.             rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
  2832.             rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
  2833.             rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
  2834.          }
  2835.       }
  2836. #endif
  2837.  
  2838.       /* Now determine which color channels we need to produce.
  2839.        * And determine the dest index (offset) within each color tuple.
  2840.        */
  2841.       switch (dstFormat) {
  2842.          case GL_ALPHA:
  2843.             dstAlphaIndex = 0;
  2844.             dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
  2845.             dstLuminanceIndex = dstIntensityIndex = -1;
  2846.             break;
  2847.          case GL_LUMINANCE:
  2848.             dstLuminanceIndex = 0;
  2849.             dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
  2850.             dstIntensityIndex = -1;
  2851.             break;
  2852.          case GL_LUMINANCE_ALPHA:
  2853.             dstLuminanceIndex = 0;
  2854.             dstAlphaIndex = 1;
  2855.             dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
  2856.             dstIntensityIndex = -1;
  2857.             break;
  2858.          case GL_INTENSITY:
  2859.             dstIntensityIndex = 0;
  2860.             dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
  2861.             dstLuminanceIndex = -1;
  2862.             break;
  2863.          case GL_RGB:
  2864.             dstRedIndex = 0;
  2865.             dstGreenIndex = 1;
  2866.             dstBlueIndex = 2;
  2867.             dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1;
  2868.             break;
  2869.          case GL_RGBA:
  2870.             dstRedIndex = 0;
  2871.             dstGreenIndex = 1;
  2872.             dstBlueIndex = 2;
  2873.             dstAlphaIndex = 3;
  2874.             dstLuminanceIndex = dstIntensityIndex = -1;
  2875.             break;
  2876.          default:
  2877.             _mesa_problem(ctx, "bad dstFormat in _mesa_unpack_chan_span()");
  2878.             UNDEFARRAY(rgba);  /* mac 32k limitation */
  2879.             return;
  2880.       }
  2881.  
  2882.  
  2883.       /* Now return the GLchan data in the requested dstFormat */
  2884.  
  2885.       if (dstRedIndex >= 0) {
  2886.          GLchan *dst = dest;
  2887.          GLuint i;
  2888.          for (i = 0; i < n; i++) {
  2889.             CLAMPED_FLOAT_TO_CHAN(dst[dstRedIndex], rgba[i][RCOMP]);
  2890.             dst += dstComponents;
  2891.          }
  2892.       }
  2893.  
  2894.       if (dstGreenIndex >= 0) {
  2895.          GLchan *dst = dest;
  2896.          GLuint i;
  2897.          for (i = 0; i < n; i++) {
  2898.             CLAMPED_FLOAT_TO_CHAN(dst[dstGreenIndex], rgba[i][GCOMP]);
  2899.             dst += dstComponents;
  2900.          }
  2901.       }
  2902.  
  2903.       if (dstBlueIndex >= 0) {
  2904.          GLchan *dst = dest;
  2905.          GLuint i;
  2906.          for (i = 0; i < n; i++) {
  2907.             CLAMPED_FLOAT_TO_CHAN(dst[dstBlueIndex], rgba[i][BCOMP]);
  2908.             dst += dstComponents;
  2909.          }
  2910.       }
  2911.  
  2912.       if (dstAlphaIndex >= 0) {
  2913.          GLchan *dst = dest;
  2914.          GLuint i;
  2915.          for (i = 0; i < n; i++) {
  2916.             CLAMPED_FLOAT_TO_CHAN(dst[dstAlphaIndex], rgba[i][ACOMP]);
  2917.             dst += dstComponents;
  2918.          }
  2919.       }
  2920.  
  2921.       if (dstIntensityIndex >= 0) {
  2922.          GLchan *dst = dest;
  2923.          GLuint i;
  2924.          assert(dstIntensityIndex == 0);
  2925.          assert(dstComponents == 1);
  2926.          for (i = 0; i < n; i++) {
  2927.             /* Intensity comes from red channel */
  2928.             CLAMPED_FLOAT_TO_CHAN(dst[i], rgba[i][RCOMP]);
  2929.          }
  2930.       }
  2931.  
  2932.       if (dstLuminanceIndex >= 0) {
  2933.          GLchan *dst = dest;
  2934.          GLuint i;
  2935.          assert(dstLuminanceIndex == 0);
  2936.          for (i = 0; i < n; i++) {
  2937.             /* Luminance comes from red channel */
  2938.             CLAMPED_FLOAT_TO_CHAN(dst[0], rgba[i][RCOMP]);
  2939.             dst += dstComponents;
  2940.          }
  2941.       }
  2942.       UNDEFARRAY(rgba);  /* mac 32k limitation */
  2943.    }
  2944. }
  2945.  
  2946.  
  2947. void
  2948. _mesa_unpack_float_color_span( GLcontext *ctx,
  2949.                                GLuint n, GLenum dstFormat, GLfloat dest[],
  2950.                                GLenum srcFormat, GLenum srcType,
  2951.                                const GLvoid *source,
  2952.                                const struct gl_pixelstore_attrib *srcPacking,
  2953.                                GLuint transferOps, GLboolean clamp )
  2954. {
  2955.    ASSERT(dstFormat == GL_ALPHA ||
  2956.           dstFormat == GL_LUMINANCE ||
  2957.           dstFormat == GL_LUMINANCE_ALPHA ||
  2958.           dstFormat == GL_INTENSITY ||
  2959.           dstFormat == GL_RGB ||
  2960.           dstFormat == GL_RGBA ||
  2961.           dstFormat == GL_COLOR_INDEX);
  2962.  
  2963.    ASSERT(srcFormat == GL_RED ||
  2964.           srcFormat == GL_GREEN ||
  2965.           srcFormat == GL_BLUE ||
  2966.           srcFormat == GL_ALPHA ||
  2967.           srcFormat == GL_LUMINANCE ||
  2968.           srcFormat == GL_LUMINANCE_ALPHA ||
  2969.           srcFormat == GL_INTENSITY ||
  2970.           srcFormat == GL_RGB ||
  2971.           srcFormat == GL_BGR ||
  2972.           srcFormat == GL_RGBA ||
  2973.           srcFormat == GL_BGRA ||
  2974.           srcFormat == GL_ABGR_EXT ||
  2975.           srcFormat == GL_COLOR_INDEX);
  2976.  
  2977.    ASSERT(srcType == GL_BITMAP ||
  2978.           srcType == GL_UNSIGNED_BYTE ||
  2979.           srcType == GL_BYTE ||
  2980.           srcType == GL_UNSIGNED_SHORT ||
  2981.           srcType == GL_SHORT ||
  2982.           srcType == GL_UNSIGNED_INT ||
  2983.           srcType == GL_INT ||
  2984.           srcType == GL_FLOAT ||
  2985.           srcType == GL_UNSIGNED_BYTE_3_3_2 ||
  2986.           srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
  2987.           srcType == GL_UNSIGNED_SHORT_5_6_5 ||
  2988.           srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
  2989.           srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
  2990.           srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
  2991.           srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
  2992.           srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
  2993.           srcType == GL_UNSIGNED_INT_8_8_8_8 ||
  2994.           srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
  2995.           srcType == GL_UNSIGNED_INT_10_10_10_2 ||
  2996.           srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
  2997.  
  2998.    /* general solution, no special cases, yet */
  2999.    {
  3000.       GLint dstComponents;
  3001.       GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex;
  3002.       GLint dstLuminanceIndex, dstIntensityIndex;
  3003.       DEFMARRAY(GLfloat, rgba, MAX_WIDTH, 4);  /* mac 32k limitation */
  3004.       CHECKARRAY(rgba, return);  /* mac 32k limitation */
  3005.  
  3006.       dstComponents = _mesa_components_in_format( dstFormat );
  3007.       /* source & dest image formats should have been error checked by now */
  3008.       assert(dstComponents > 0);
  3009.  
  3010.       /*
  3011.        * Extract image data and convert to RGBA floats
  3012.        */
  3013.       assert(n <= MAX_WIDTH);
  3014.       if (srcFormat == GL_COLOR_INDEX) {
  3015.          GLuint indexes[MAX_WIDTH];
  3016.          extract_uint_indexes(n, indexes, srcFormat, srcType, source,
  3017.                               srcPacking);
  3018.  
  3019.          if (dstFormat == GL_COLOR_INDEX
  3020.              && (transferOps & IMAGE_MAP_COLOR_BIT)) {
  3021.             _mesa_map_ci(ctx, n, indexes);
  3022.          }
  3023.          if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
  3024.             _mesa_shift_and_offset_ci(ctx, n, indexes);
  3025.          }
  3026.  
  3027.          if (dstFormat == GL_COLOR_INDEX) {
  3028.             /* convert to GLchan and return */
  3029.             GLuint i;
  3030.             for (i = 0; i < n; i++) {
  3031.                dest[i] = (GLchan) (indexes[i] & 0xff);
  3032.             }
  3033.             UNDEFARRAY(rgba);  /* mac 32k limitation */
  3034.             return;
  3035.          }
  3036.          else {
  3037.             /* Convert indexes to RGBA */
  3038.             _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
  3039.          }
  3040.       }
  3041.       else {
  3042.          extract_float_rgba(n, rgba, srcFormat, srcType, source,
  3043.                             srcPacking->SwapBytes);
  3044.  
  3045.          /* scale and bias colors */
  3046.          if (transferOps & IMAGE_SCALE_BIAS_BIT) {
  3047.             _mesa_scale_and_bias_rgba(ctx, n, rgba,
  3048.                                    ctx->Pixel.RedScale, ctx->Pixel.GreenScale,
  3049.                                    ctx->Pixel.BlueScale, ctx->Pixel.AlphaScale,
  3050.                                    ctx->Pixel.RedBias, ctx->Pixel.GreenBias,
  3051.                                    ctx->Pixel.BlueBias, ctx->Pixel.AlphaBias);
  3052.          }
  3053.          /* color map lookup */
  3054.          if (transferOps & IMAGE_MAP_COLOR_BIT) {
  3055.             _mesa_map_rgba(ctx, n, rgba);
  3056.          }
  3057.       }
  3058.  
  3059.       if (transferOps) {
  3060.          /* GL_COLOR_TABLE lookup */
  3061.          if (transferOps & IMAGE_COLOR_TABLE_BIT) {
  3062.             _mesa_lookup_rgba(&ctx->ColorTable, n, rgba);
  3063.          }
  3064.          /* convolution */
  3065.          if (transferOps & IMAGE_CONVOLUTION_BIT) {
  3066.             /* XXX to do */
  3067.          }
  3068.          /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */
  3069.          if (transferOps & IMAGE_POST_CONVOLUTION_SCALE_BIAS) {
  3070.             _mesa_scale_and_bias_rgba(ctx, n, rgba,
  3071.                                       ctx->Pixel.PostConvolutionScale[RCOMP],
  3072.                                       ctx->Pixel.PostConvolutionScale[GCOMP],
  3073.                                       ctx->Pixel.PostConvolutionScale[BCOMP],
  3074.                                       ctx->Pixel.PostConvolutionScale[ACOMP],
  3075.                                       ctx->Pixel.PostConvolutionBias[RCOMP],
  3076.                                       ctx->Pixel.PostConvolutionBias[GCOMP],
  3077.                                       ctx->Pixel.PostConvolutionBias[BCOMP],
  3078.                                       ctx->Pixel.PostConvolutionBias[ACOMP]);
  3079.          }
  3080.          /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
  3081.          if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
  3082.             _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba);
  3083.          }
  3084.          /* color matrix transform */
  3085.          if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
  3086.             _mesa_transform_rgba(ctx, n, rgba);
  3087.          }
  3088.          /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
  3089.          if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
  3090.             _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba);
  3091.          }
  3092.          /* update histogram count */
  3093.          if (transferOps & IMAGE_HISTOGRAM_BIT) {
  3094.             _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba);
  3095.          }
  3096.          /* min/max here */
  3097.          if (transferOps & IMAGE_MIN_MAX_BIT) {
  3098.             _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba);
  3099.          }
  3100.       }
  3101.  
  3102.       /* clamp to [0,1] */
  3103. #if CHAN_TYPE != GL_FLOAT
  3104.       if (clamp) {
  3105.          GLuint i;
  3106.          for (i = 0; i < n; i++) {
  3107.             rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
  3108.             rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
  3109.             rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
  3110.             rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
  3111.          }
  3112.       }
  3113. #endif
  3114.  
  3115.       /* Now determine which color channels we need to produce.
  3116.        * And determine the dest index (offset) within each color tuple.
  3117.        */
  3118.       switch (dstFormat) {
  3119.          case GL_ALPHA:
  3120.             dstAlphaIndex = 0;
  3121.             dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
  3122.             dstLuminanceIndex = dstIntensityIndex = -1;
  3123.             break;
  3124.          case GL_LUMINANCE:
  3125.             dstLuminanceIndex = 0;
  3126.             dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
  3127.             dstIntensityIndex = -1;
  3128.             break;
  3129.          case GL_LUMINANCE_ALPHA:
  3130.             dstLuminanceIndex = 0;
  3131.             dstAlphaIndex = 1;
  3132.             dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
  3133.             dstIntensityIndex = -1;
  3134.             break;
  3135.          case GL_INTENSITY:
  3136.             dstIntensityIndex = 0;
  3137.             dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
  3138.             dstLuminanceIndex = -1;
  3139.             break;
  3140.          case GL_RGB:
  3141.             dstRedIndex = 0;
  3142.             dstGreenIndex = 1;
  3143.             dstBlueIndex = 2;
  3144.             dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1;
  3145.             break;
  3146.          case GL_RGBA:
  3147.             dstRedIndex = 0;
  3148.             dstGreenIndex = 1;
  3149.             dstBlueIndex = 2;
  3150.             dstAlphaIndex = 3;
  3151.             dstLuminanceIndex = dstIntensityIndex = -1;
  3152.             break;
  3153.          default:
  3154.             _mesa_problem(ctx, "bad dstFormat in _mesa_unpack_float_color_span()");
  3155.             UNDEFARRAY(rgba);  /* mac 32k limitation */
  3156.             return;
  3157.       }
  3158.  
  3159.       /* Now pack results in the requested dstFormat */
  3160.       if (dstRedIndex >= 0) {
  3161.          GLfloat *dst = dest;
  3162.          GLuint i;
  3163.          for (i = 0; i < n; i++) {
  3164.             dst[dstRedIndex] = rgba[i][RCOMP];
  3165.             dst += dstComponents;
  3166.          }
  3167.       }
  3168.  
  3169.       if (dstGreenIndex >= 0) {
  3170.          GLfloat *dst = dest;
  3171.          GLuint i;
  3172.          for (i = 0; i < n; i++) {
  3173.             dst[dstGreenIndex] = rgba[i][GCOMP];
  3174.             dst += dstComponents;
  3175.          }
  3176.       }
  3177.  
  3178.       if (dstBlueIndex >= 0) {
  3179.          GLfloat *dst = dest;
  3180.          GLuint i;
  3181.          for (i = 0; i < n; i++) {
  3182.             dst[dstBlueIndex] = rgba[i][BCOMP];
  3183.             dst += dstComponents;
  3184.          }
  3185.       }
  3186.  
  3187.       if (dstAlphaIndex >= 0) {
  3188.          GLfloat *dst = dest;
  3189.          GLuint i;
  3190.          for (i = 0; i < n; i++) {
  3191.             dst[dstAlphaIndex] = rgba[i][ACOMP];
  3192.             dst += dstComponents;
  3193.          }
  3194.       }
  3195.  
  3196.       if (dstIntensityIndex >= 0) {
  3197.          GLfloat *dst = dest;
  3198.          GLuint i;
  3199.          assert(dstIntensityIndex == 0);
  3200.          assert(dstComponents == 1);
  3201.          for (i = 0; i < n; i++) {
  3202.             /* Intensity comes from red channel */
  3203.             dst[i] = rgba[i][RCOMP];
  3204.          }
  3205.       }
  3206.  
  3207.       if (dstLuminanceIndex >= 0) {
  3208.          GLfloat *dst = dest;
  3209.          GLuint i;
  3210.          assert(dstLuminanceIndex == 0);
  3211.          for (i = 0; i < n; i++) {
  3212.             /* Luminance comes from red channel */
  3213.             dst[0] = rgba[i][RCOMP];
  3214.             dst += dstComponents;
  3215.          }
  3216.       }
  3217.       UNDEFARRAY(rgba);  /* mac 32k limitation */
  3218.    }
  3219. }
  3220.  
  3221.  
  3222.  
  3223.  
  3224. /*
  3225.  * Unpack a row of color index data from a client buffer according to
  3226.  * the pixel unpacking parameters.
  3227.  * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
  3228.  *
  3229.  * Args:  ctx - the context
  3230.  *        n - number of pixels
  3231.  *        dstType - destination datatype
  3232.  *        dest - destination array
  3233.  *        srcType - source pixel type
  3234.  *        source - source data pointer
  3235.  *        srcPacking - pixel unpacking parameters
  3236.  *        transferOps - the pixel transfer operations to apply
  3237.  */
  3238. void
  3239. _mesa_unpack_index_span( const GLcontext *ctx, GLuint n,
  3240.                          GLenum dstType, GLvoid *dest,
  3241.                          GLenum srcType, const GLvoid *source,
  3242.                          const struct gl_pixelstore_attrib *srcPacking,
  3243.                          GLuint transferOps )
  3244. {
  3245.    ASSERT(srcType == GL_BITMAP ||
  3246.           srcType == GL_UNSIGNED_BYTE ||
  3247.           srcType == GL_BYTE ||
  3248.           srcType == GL_UNSIGNED_SHORT ||
  3249.           srcType == GL_SHORT ||
  3250.           srcType == GL_UNSIGNED_INT ||
  3251.           srcType == GL_INT ||
  3252.           srcType == GL_FLOAT);
  3253.  
  3254.    ASSERT(dstType == GL_UNSIGNED_BYTE ||
  3255.           dstType == GL_UNSIGNED_SHORT ||
  3256.           dstType == GL_UNSIGNED_INT);
  3257.  
  3258.  
  3259.    transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
  3260.  
  3261.    /*
  3262.     * Try simple cases first
  3263.     */
  3264.    if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
  3265.        && dstType == GL_UNSIGNED_BYTE) {
  3266.       MEMCPY(dest, source, n * sizeof(GLubyte));
  3267.    }
  3268.    else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
  3269.             && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
  3270.       MEMCPY(dest, source, n * sizeof(GLuint));
  3271.    }
  3272.    else {
  3273.       /*
  3274.        * general solution
  3275.        */
  3276.       GLuint indexes[MAX_WIDTH];
  3277.       assert(n <= MAX_WIDTH);
  3278.  
  3279.       extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
  3280.                            srcPacking);
  3281.  
  3282.       if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
  3283.          /* shift and offset indexes */
  3284.          _mesa_shift_and_offset_ci(ctx, n, indexes);
  3285.       }
  3286.       if (transferOps & IMAGE_MAP_COLOR_BIT) {
  3287.          /* Apply lookup table */
  3288.          _mesa_map_ci(ctx, n, indexes);
  3289.       }
  3290.  
  3291.       /* convert to dest type */
  3292.       switch (dstType) {
  3293.          case GL_UNSIGNED_BYTE:
  3294.             {
  3295.                GLubyte *dst = (GLubyte *) dest;
  3296.                GLuint i;
  3297.                for (i = 0; i < n; i++) {
  3298.                   dst[i] = (GLubyte) (indexes[i] & 0xff);
  3299.                }
  3300.             }
  3301.             break;
  3302.          case GL_UNSIGNED_SHORT:
  3303.             {
  3304.                GLuint *dst = (GLuint *) dest;
  3305.                GLuint i;
  3306.                for (i = 0; i < n; i++) {
  3307.                   dst[i] = (GLushort) (indexes[i] & 0xffff);
  3308.                }
  3309.             }
  3310.             break;
  3311.          case GL_UNSIGNED_INT:
  3312.             MEMCPY(dest, indexes, n * sizeof(GLuint));
  3313.             break;
  3314.          default:
  3315.             _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");
  3316.       }
  3317.    }
  3318. }
  3319.  
  3320.  
  3321. void
  3322. _mesa_pack_index_span( const GLcontext *ctx, GLuint n,
  3323.                        GLenum dstType, GLvoid *dest, const GLuint *source,
  3324.                        const struct gl_pixelstore_attrib *dstPacking,
  3325.                        GLuint transferOps )
  3326. {
  3327.    GLuint indexes[MAX_WIDTH];
  3328.  
  3329.    ASSERT(n <= MAX_WIDTH);
  3330.  
  3331.    transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
  3332.  
  3333.    if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) {
  3334.       /* make a copy of input */
  3335.       MEMCPY(indexes, source, n * sizeof(GLuint));
  3336.       if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
  3337.          _mesa_shift_and_offset_ci( ctx, n, indexes);
  3338.       }
  3339.       if (transferOps & IMAGE_MAP_COLOR_BIT) {
  3340.          _mesa_map_ci(ctx, n, indexes);
  3341.       }
  3342.       source = indexes;
  3343.    }
  3344.  
  3345.    switch (dstType) {
  3346.    case GL_UNSIGNED_BYTE:
  3347.       {
  3348.          GLubyte *dst = (GLubyte *) dest;
  3349.          GLuint i;
  3350.          for (i = 0; i < n; i++) {
  3351.             *dst++ = (GLubyte) source[i];
  3352.          }
  3353.       }
  3354.       break;
  3355.    case GL_BYTE:
  3356.       {
  3357.          GLbyte *dst = (GLbyte *) dest;
  3358.          GLuint i;
  3359.          for (i = 0; i < n; i++) {
  3360.             dst[i] = (GLbyte) source[i];
  3361.          }
  3362.       }
  3363.       break;
  3364.    case GL_UNSIGNED_SHORT:
  3365.       {
  3366.          GLushort *dst = (GLushort *) dest;
  3367.          GLuint i;
  3368.          for (i = 0; i < n; i++) {
  3369.             dst[i] = (GLushort) source[i];
  3370.          }
  3371.          if (dstPacking->SwapBytes) {
  3372.             _mesa_swap2( (GLushort *) dst, n );
  3373.          }
  3374.       }
  3375.       break;
  3376.    case GL_SHORT:
  3377.       {
  3378.          GLshort *dst = (GLshort *) dest;
  3379.          GLuint i;
  3380.          for (i = 0; i < n; i++) {
  3381.             dst[i] = (GLshort) source[i];
  3382.          }
  3383.          if (dstPacking->SwapBytes) {
  3384.             _mesa_swap2( (GLushort *) dst, n );
  3385.          }
  3386.       }
  3387.       break;
  3388.    case GL_UNSIGNED_INT:
  3389.       {
  3390.          GLuint *dst = (GLuint *) dest;
  3391.          GLuint i;
  3392.          for (i = 0; i < n; i++) {
  3393.             dst[i] = (GLuint) source[i];
  3394.          }
  3395.          if (dstPacking->SwapBytes) {
  3396.             _mesa_swap4( (GLuint *) dst, n );
  3397.          }
  3398.       }
  3399.       break;
  3400.    case GL_INT:
  3401.       {
  3402.          GLint *dst = (GLint *) dest;
  3403.          GLuint i;
  3404.          for (i = 0; i < n; i++) {
  3405.             dst[i] = (GLint) source[i];
  3406.          }
  3407.          if (dstPacking->SwapBytes) {
  3408.             _mesa_swap4( (GLuint *) dst, n );
  3409.          }
  3410.       }
  3411.       break;
  3412.    case GL_FLOAT:
  3413.       {
  3414.          GLfloat *dst = (GLfloat *) dest;
  3415.          GLuint i;
  3416.          for (i = 0; i < n; i++) {
  3417.             dst[i] = (GLfloat) source[i];
  3418.          }
  3419.          if (dstPacking->SwapBytes) {
  3420.             _mesa_swap4( (GLuint *) dst, n );
  3421.          }
  3422.       }
  3423.       break;
  3424.    default:
  3425.       _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
  3426.    }
  3427. }
  3428.  
  3429.  
  3430.  
  3431. /*
  3432.  * Unpack a row of stencil data from a client buffer according to
  3433.  * the pixel unpacking parameters.
  3434.  * This is (or will be) used by glDrawPixels
  3435.  *
  3436.  * Args:  ctx - the context
  3437.  *        n - number of pixels
  3438.  *        dstType - destination datatype
  3439.  *        dest - destination array
  3440.  *        srcType - source pixel type
  3441.  *        source - source data pointer
  3442.  *        srcPacking - pixel unpacking parameters
  3443.  *        transferOps - apply offset/bias/lookup ops?
  3444.  */
  3445. void
  3446. _mesa_unpack_stencil_span( const GLcontext *ctx, GLuint n,
  3447.                            GLenum dstType, GLvoid *dest,
  3448.                            GLenum srcType, const GLvoid *source,
  3449.                            const struct gl_pixelstore_attrib *srcPacking,
  3450.                            GLuint transferOps )
  3451. {
  3452.    ASSERT(srcType == GL_BITMAP ||
  3453.           srcType == GL_UNSIGNED_BYTE ||
  3454.           srcType == GL_BYTE ||
  3455.           srcType == GL_UNSIGNED_SHORT ||
  3456.           srcType == GL_SHORT ||
  3457.           srcType == GL_UNSIGNED_INT ||
  3458.           srcType == GL_INT ||
  3459.           srcType == GL_FLOAT);
  3460.  
  3461.    ASSERT(dstType == GL_UNSIGNED_BYTE ||
  3462.           dstType == GL_UNSIGNED_SHORT ||
  3463.           dstType == GL_UNSIGNED_INT);
  3464.  
  3465.    /* only shift and offset apply to stencil */
  3466.    transferOps &= IMAGE_SHIFT_OFFSET_BIT;
  3467.  
  3468.    /*
  3469.     * Try simple cases first
  3470.     */
  3471.    if (transferOps == 0 &&
  3472.        srcType == GL_UNSIGNED_BYTE &&
  3473.        dstType == GL_UNSIGNED_BYTE) {
  3474.       MEMCPY(dest, source, n * sizeof(GLubyte));
  3475.    }
  3476.    else if (transferOps == 0 &&
  3477.             srcType == GL_UNSIGNED_INT &&
  3478.             dstType == GL_UNSIGNED_INT &&
  3479.             !srcPacking->SwapBytes) {
  3480.       MEMCPY(dest, source, n * sizeof(GLuint));
  3481.    }
  3482.    else {
  3483.       /*
  3484.        * general solution
  3485.        */
  3486.       GLuint indexes[MAX_WIDTH];
  3487.       assert(n <= MAX_WIDTH);
  3488.  
  3489.       extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
  3490.                            srcPacking);
  3491.  
  3492.       if (transferOps) {
  3493.          if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
  3494.             /* shift and offset indexes */
  3495.             _mesa_shift_and_offset_ci(ctx, n, indexes);
  3496.          }
  3497.  
  3498.          if (ctx->Pixel.MapStencilFlag) {
  3499.             /* Apply stencil lookup table */
  3500.             GLuint mask = ctx->Pixel.MapStoSsize - 1;
  3501.             GLuint i;
  3502.             for (i=0;i<n;i++) {
  3503.                indexes[i] = ctx->Pixel.MapStoS[ indexes[i] & mask ];
  3504.             }
  3505.          }
  3506.       }
  3507.  
  3508.       /* convert to dest type */
  3509.       switch (dstType) {
  3510.          case GL_UNSIGNED_BYTE:
  3511.             {
  3512.                GLubyte *dst = (GLubyte *) dest;
  3513.                GLuint i;
  3514.                for (i = 0; i < n; i++) {
  3515.                   dst[i] = (GLubyte) (indexes[i] & 0xff);
  3516.                }
  3517.             }
  3518.             break;
  3519.          case GL_UNSIGNED_SHORT:
  3520.             {
  3521.                GLuint *dst = (GLuint *) dest;
  3522.                GLuint i;
  3523.                for (i = 0; i < n; i++) {
  3524.                   dst[i] = (GLushort) (indexes[i] & 0xffff);
  3525.                }
  3526.             }
  3527.             break;
  3528.          case GL_UNSIGNED_INT:
  3529.             MEMCPY(dest, indexes, n * sizeof(GLuint));
  3530.             break;
  3531.          default:
  3532.             _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
  3533.       }
  3534.    }
  3535. }
  3536.  
  3537.  
  3538. void
  3539. _mesa_pack_stencil_span( const GLcontext *ctx, GLuint n,
  3540.                          GLenum dstType, GLvoid *dest, const GLstencil *source,
  3541.                          const struct gl_pixelstore_attrib *dstPacking )
  3542. {
  3543.    GLstencil stencil[MAX_WIDTH];
  3544.  
  3545.    ASSERT(n <= MAX_WIDTH);
  3546.  
  3547.    if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||
  3548.        ctx->Pixel.MapStencilFlag) {
  3549.       /* make a copy of input */
  3550.       MEMCPY(stencil, source, n * sizeof(GLstencil));
  3551.       if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset) {
  3552.          _mesa_shift_and_offset_stencil( ctx, n, stencil );
  3553.       }
  3554.       if (ctx->Pixel.MapStencilFlag) {
  3555.          _mesa_map_stencil( ctx, n, stencil );
  3556.       }
  3557.       source = stencil;
  3558.    }
  3559.  
  3560.    switch (dstType) {
  3561.    case GL_UNSIGNED_BYTE:
  3562.       if (sizeof(GLstencil) == 8) {
  3563.          MEMCPY( dest, source, n );
  3564.       }
  3565.       else {
  3566.          GLubyte *dst = (GLubyte *) dest;
  3567.          GLuint i;
  3568.          for (i=0;i<n;i++) {
  3569.             dst[i] = (GLubyte) source[i];
  3570.          }
  3571.       }
  3572.       break;
  3573.    case GL_BYTE:
  3574.       if (sizeof(GLstencil) == 8) {
  3575.          MEMCPY( dest, source, n );
  3576.       }
  3577.       else {
  3578.          GLbyte *dst = (GLbyte *) dest;
  3579.          GLuint i;
  3580.          for (i=0;i<n;i++) {
  3581.             dst[i] = (GLbyte) source[i];
  3582.          }
  3583.       }
  3584.       break;
  3585.    case GL_UNSIGNED_SHORT:
  3586.       {
  3587.          GLushort *dst = (GLushort *) dest;
  3588.          GLuint i;
  3589.          for (i=0;i<n;i++) {
  3590.             dst[i] = (GLushort) source[i];
  3591.          }
  3592.          if (dstPacking->SwapBytes) {
  3593.             _mesa_swap2( (GLushort *) dst, n );
  3594.          }
  3595.       }
  3596.       break;
  3597.    case GL_SHORT:
  3598.       {
  3599.          GLshort *dst = (GLshort *) dest;
  3600.          GLuint i;
  3601.          for (i=0;i<n;i++) {
  3602.             dst[i] = (GLshort) source[i];
  3603.          }
  3604.          if (dstPacking->SwapBytes) {
  3605.             _mesa_swap2( (GLushort *) dst, n );
  3606.          }
  3607.       }
  3608.       break;
  3609.    case GL_UNSIGNED_INT:
  3610.       {
  3611.          GLuint *dst = (GLuint *) dest;
  3612.          GLuint i;
  3613.          for (i=0;i<n;i++) {
  3614.             dst[i] = (GLuint) source[i];
  3615.          }
  3616.          if (dstPacking->SwapBytes) {
  3617.             _mesa_swap4( (GLuint *) dst, n );
  3618.          }
  3619.       }
  3620.       break;
  3621.    case GL_INT:
  3622.       {
  3623.          GLint *dst = (GLint *) dest;
  3624.          GLuint i;
  3625.          for (i=0;i<n;i++) {
  3626.             *dst++ = (GLint) source[i];
  3627.          }
  3628.          if (dstPacking->SwapBytes) {
  3629.             _mesa_swap4( (GLuint *) dst, n );
  3630.          }
  3631.       }
  3632.       break;
  3633.    case GL_FLOAT:
  3634.       {
  3635.          GLfloat *dst = (GLfloat *) dest;
  3636.          GLuint i;
  3637.          for (i=0;i<n;i++) {
  3638.             dst[i] = (GLfloat) source[i];
  3639.          }
  3640.          if (dstPacking->SwapBytes) {
  3641.             _mesa_swap4( (GLuint *) dst, n );
  3642.          }
  3643.       }
  3644.       break;
  3645.    case GL_BITMAP:
  3646.       if (dstPacking->LsbFirst) {
  3647.          GLubyte *dst = (GLubyte *) dest;
  3648.          GLint shift = 0;
  3649.          GLuint i;
  3650.          for (i = 0; i < n; i++) {
  3651.             if (shift == 0)
  3652.                *dst = 0;
  3653.             *dst |= ((source[i] != 0) << shift);
  3654.             shift++;
  3655.             if (shift == 8) {
  3656.                shift = 0;
  3657.                dst++;
  3658.             }
  3659.          }
  3660.       }
  3661.       else {
  3662.          GLubyte *dst = (GLubyte *) dest;
  3663.          GLint shift = 7;
  3664.          GLuint i;
  3665.          for (i = 0; i < n; i++) {
  3666.             if (shift == 7)
  3667.                *dst = 0;
  3668.             *dst |= ((source[i] != 0) << shift);
  3669.             shift--;
  3670.             if (shift < 0) {
  3671.                shift = 7;
  3672.                dst++;
  3673.             }
  3674.          }
  3675.       }
  3676.       break;
  3677.    default:
  3678.       _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
  3679.    }
  3680. }
  3681.  
  3682.  
  3683.  
  3684. void
  3685. _mesa_unpack_depth_span( const GLcontext *ctx, GLuint n, GLfloat *dest,
  3686.                          GLenum srcType, const GLvoid *source,
  3687.                          const struct gl_pixelstore_attrib *srcPacking )
  3688. {
  3689.    switch (srcType) {
  3690.       case GL_BYTE:
  3691.          {
  3692.             GLuint i;
  3693.             const GLubyte *src = (const GLubyte *) source;
  3694.             for (i = 0; i < n; i++) {
  3695.                dest[i] = BYTE_TO_FLOAT(src[i]);
  3696.             }
  3697.          }
  3698.          break;
  3699.       case GL_UNSIGNED_BYTE:
  3700.          {
  3701.             GLuint i;
  3702.             const GLubyte *src = (const GLubyte *) source;
  3703.             for (i = 0; i < n; i++) {
  3704.                dest[i] = UBYTE_TO_FLOAT(src[i]);
  3705.             }
  3706.          }
  3707.          break;
  3708.       case GL_SHORT:
  3709.          {
  3710.             GLuint i;
  3711.             const GLshort *src = (const GLshort *) source;
  3712.             for (i = 0; i < n; i++) {
  3713.                dest[i] = SHORT_TO_FLOAT(src[i]);
  3714.             }
  3715.          }
  3716.          break;
  3717.       case GL_UNSIGNED_SHORT:
  3718.          {
  3719.             GLuint i;
  3720.             const GLushort *src = (const GLushort *) source;
  3721.             for (i = 0; i < n; i++) {
  3722.                dest[i] = USHORT_TO_FLOAT(src[i]);
  3723.             }
  3724.          }
  3725.          break;
  3726.       case GL_INT:
  3727.          {
  3728.             GLuint i;
  3729.             const GLint *src = (const GLint *) source;
  3730.             for (i = 0; i < n; i++) {
  3731.                dest[i] = INT_TO_FLOAT(src[i]);
  3732.             }
  3733.          }
  3734.          break;
  3735.       case GL_UNSIGNED_INT:
  3736.          {
  3737.             GLuint i;
  3738.             const GLuint *src = (const GLuint *) source;
  3739.             for (i = 0; i < n; i++) {
  3740.                dest[i] = UINT_TO_FLOAT(src[i]);
  3741.             }
  3742.          }
  3743.          break;
  3744.       case GL_FLOAT:
  3745.          MEMCPY(dest, source, n * sizeof(GLfloat));
  3746.          break;
  3747.       default:
  3748.          _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()");
  3749.          return;
  3750.    }
  3751.  
  3752.  
  3753.    /* apply depth scale and bias and clamp to [0,1] */
  3754.    if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
  3755.       GLuint i;
  3756.       for (i = 0; i < n; i++) {
  3757.          GLfloat d = dest[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
  3758.          dest[i] = CLAMP(d, 0.0F, 1.0F);
  3759.       }
  3760.    }
  3761. }
  3762.  
  3763.  
  3764.  
  3765. /*
  3766.  * Pack an array of depth values.  The values are floats in [0,1].
  3767.  */
  3768. void
  3769. _mesa_pack_depth_span( const GLcontext *ctx, GLuint n, GLvoid *dest,
  3770.                        GLenum dstType, const GLfloat *depthSpan,
  3771.                        const struct gl_pixelstore_attrib *dstPacking )
  3772. {
  3773.    GLfloat depthCopy[MAX_WIDTH];
  3774.    const GLboolean bias_or_scale = ctx->Pixel.DepthBias != 0.0 ||
  3775.                                    ctx->Pixel.DepthScale != 1.0;
  3776.  
  3777.    ASSERT(n <= MAX_WIDTH);
  3778.  
  3779.    if (bias_or_scale) {
  3780.       GLuint i;
  3781.       for (i = 0; i < n; i++) {
  3782.          GLfloat d;
  3783.          d = depthSpan[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
  3784.          depthCopy[i] = CLAMP(d, 0.0F, 1.0F);
  3785.       }
  3786.       depthSpan = depthCopy;
  3787.    }
  3788.  
  3789.    switch (dstType) {
  3790.    case GL_UNSIGNED_BYTE:
  3791.       {
  3792.          GLubyte *dst = (GLubyte *) dest;
  3793.          GLuint i;
  3794.          for (i = 0; i < n; i++) {
  3795.             dst[i] = FLOAT_TO_UBYTE( depthSpan[i] );
  3796.          }
  3797.       }
  3798.       break;
  3799.    case GL_BYTE:
  3800.       {
  3801.          GLbyte *dst = (GLbyte *) dest;
  3802.          GLuint i;
  3803.          for (i = 0; i < n; i++) {
  3804.             dst[i] = FLOAT_TO_BYTE( depthSpan[i] );
  3805.          }
  3806.       }
  3807.       break;
  3808.    case GL_UNSIGNED_SHORT:
  3809.       {
  3810.          GLushort *dst = (GLushort *) dest;
  3811.          GLuint i;
  3812.          for (i = 0; i < n; i++) {
  3813.             dst[i] = FLOAT_TO_USHORT( depthSpan[i] );
  3814.          }
  3815.          if (dstPacking->SwapBytes) {
  3816.             _mesa_swap2( (GLushort *) dst, n );
  3817.          }
  3818.       }
  3819.       break;
  3820.    case GL_SHORT:
  3821.       {
  3822.          GLshort *dst = (GLshort *) dest;
  3823.          GLuint i;
  3824.          for (i = 0; i < n; i++) {
  3825.             dst[i] = FLOAT_TO_SHORT( depthSpan[i] );
  3826.          }
  3827.          if (dstPacking->SwapBytes) {
  3828.             _mesa_swap2( (GLushort *) dst, n );
  3829.          }
  3830.       }
  3831.       break;
  3832.    case GL_UNSIGNED_INT:
  3833.       {
  3834.          GLuint *dst = (GLuint *) dest;
  3835.          GLuint i;
  3836.          for (i = 0; i < n; i++) {
  3837.             dst[i] = FLOAT_TO_UINT( depthSpan[i] );
  3838.          }
  3839.          if (dstPacking->SwapBytes) {
  3840.             _mesa_swap4( (GLuint *) dst, n );
  3841.          }
  3842.       }
  3843.       break;
  3844.    case GL_INT:
  3845.       {
  3846.          GLint *dst = (GLint *) dest;
  3847.          GLuint i;
  3848.          for (i = 0; i < n; i++) {
  3849.             dst[i] = FLOAT_TO_INT( depthSpan[i] );
  3850.          }
  3851.          if (dstPacking->SwapBytes) {
  3852.             _mesa_swap4( (GLuint *) dst, n );
  3853.          }
  3854.       }
  3855.       break;
  3856.    case GL_FLOAT:
  3857.       {
  3858.          GLfloat *dst = (GLfloat *) dest;
  3859.          GLuint i;
  3860.          for (i = 0; i < n; i++) {
  3861.             dst[i] = depthSpan[i];
  3862.          }
  3863.          if (dstPacking->SwapBytes) {
  3864.             _mesa_swap4( (GLuint *) dst, n );
  3865.          }
  3866.       }
  3867.       break;
  3868.    default:
  3869.       _mesa_problem(ctx, "bad type in _mesa_pack_depth_span");
  3870.    }
  3871. }
  3872.  
  3873.  
  3874.  
  3875.  
  3876. /*
  3877.  * Unpack image data.  Apply byteswapping, byte flipping (bitmap).
  3878.  * Return all image data in a contiguous block.
  3879.  */
  3880. void *
  3881. _mesa_unpack_image( GLsizei width, GLsizei height, GLsizei depth,
  3882.                     GLenum format, GLenum type, const GLvoid *pixels,
  3883.                     const struct gl_pixelstore_attrib *unpack )
  3884. {
  3885.    GLint bytesPerRow, compsPerRow;
  3886.    GLboolean flipBytes, swap2, swap4;
  3887.  
  3888.    if (!pixels)
  3889.       return NULL;  /* not necessarily an error */
  3890.  
  3891.    if (width <= 0 || height <= 0 || depth <= 0)
  3892.       return NULL;  /* generate error later */
  3893.  
  3894.    if (format == GL_BITMAP) {
  3895.       bytesPerRow = (width + 7) >> 3;
  3896.       flipBytes = !unpack->LsbFirst;
  3897.       swap2 = swap4 = GL_FALSE;
  3898.       compsPerRow = 0;
  3899.    }
  3900.    else {
  3901.       const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
  3902.       const GLint components = _mesa_components_in_format(format);
  3903.       GLint bytesPerComp;
  3904.       if (bytesPerPixel <= 0 || components <= 0)
  3905.          return NULL;   /* bad format or type.  generate error later */
  3906.       bytesPerRow = bytesPerPixel * width;
  3907.       bytesPerComp = bytesPerPixel / components;
  3908.       flipBytes = GL_FALSE;
  3909.       swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
  3910.       swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
  3911.       compsPerRow = components * width;
  3912.       assert(compsPerRow >= width);
  3913.    }
  3914.  
  3915.    {
  3916.       GLubyte *destBuffer = (GLubyte *) MALLOC(bytesPerRow * height * depth);
  3917.       GLubyte *dst;
  3918.       GLint img, row;
  3919.       if (!destBuffer)
  3920.          return NULL;   /* generate GL_OUT_OF_MEMORY later */
  3921.  
  3922.       dst = destBuffer;
  3923.       for (img = 0; img < depth; img++) {
  3924.          for (row = 0; row < height; row++) {
  3925.             const GLvoid *src = _mesa_image_address(unpack, pixels,
  3926.                                width, height, format, type, img, row, 0);
  3927.             MEMCPY(dst, src, bytesPerRow);
  3928.             /* byte flipping/swapping */
  3929.             if (flipBytes) {
  3930.                flip_bytes((GLubyte *) dst, bytesPerRow);
  3931.             }
  3932.             else if (swap2) {
  3933.                _mesa_swap2((GLushort*) dst, compsPerRow);
  3934.             }
  3935.             else if (swap4) {
  3936.                _mesa_swap4((GLuint*) dst, compsPerRow);
  3937.             }
  3938.             dst += bytesPerRow;
  3939.          }
  3940.       }
  3941.       return destBuffer;
  3942.    }
  3943. }
  3944.