home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 5 / MA_Cover_5.iso / ppc / mesa / src / image.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-31  |  21.4 KB  |  720 lines
  1. /* $Id: image.c,v 1.19 1997/11/07 03:49:04 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  2.5
  6.  * Copyright (C) 1995-1997  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * $Log: image.c,v $
  26.  * Revision 1.19  1997/11/07 03:49:04  brianp
  27.  * more error checking work (but more to be done)
  28.  *
  29.  * Revision 1.18  1997/11/02 20:19:47  brianp
  30.  * added more error checking to gl_unpack_image3D()
  31.  *
  32.  * Revision 1.17  1997/10/16 01:04:51  brianp
  33.  * added code to normalize color, depth values in gl_unpack_image3d()
  34.  *
  35.  * Revision 1.16  1997/09/27 00:15:39  brianp
  36.  * changed parameters to gl_unpack_image()
  37.  *
  38.  * Revision 1.15  1997/08/11 01:23:10  brianp
  39.  * added a pointer cast
  40.  *
  41.  * Revision 1.14  1997/07/24 01:25:18  brianp
  42.  * changed precompiled header symbol from PCH to PC_HEADER
  43.  *
  44.  * Revision 1.13  1997/05/28 03:25:26  brianp
  45.  * added precompiled header (PCH) support
  46.  *
  47.  * Revision 1.12  1997/04/29 01:26:25  brianp
  48.  * added #include "context.h"
  49.  *
  50.  * Revision 1.11  1997/04/20 20:28:49  brianp
  51.  * replaced abort() with gl_problem()
  52.  *
  53.  * Revision 1.10  1997/04/06 17:49:32  brianp
  54.  * image reference count wasn't always initialized to zero (Christopher Lloyd)
  55.  *
  56.  * Revision 1.9  1997/02/09 20:05:03  brianp
  57.  * new arguments for gl_pixel_addr_in_image()
  58.  *
  59.  * Revision 1.8  1997/02/09 18:52:53  brianp
  60.  * added GL_EXT_texture3D support
  61.  *
  62.  * Revision 1.7  1997/01/09 21:25:54  brianp
  63.  * initialize image reference count to zero
  64.  *
  65.  * Revision 1.6  1996/11/13 03:58:31  brianp
  66.  * fixed undefined "format" variable in gl_unpack_image()
  67.  *
  68.  * Revision 1.5  1996/11/10 17:48:03  brianp
  69.  * check if format is GL_DEPTH_COMPONENT or GL_STENCIL_COMPONENT
  70.  *
  71.  * Revision 1.4  1996/11/06 04:23:01  brianp
  72.  * changed gl_unpack_image() components argument to srcFormat
  73.  *
  74.  * Revision 1.3  1996/09/27 01:27:10  brianp
  75.  * removed unused variables
  76.  *
  77.  * Revision 1.2  1996/09/26 22:35:10  brianp
  78.  * fixed a few compiler warnings from IRIX 6 -n32 and -64 compiler
  79.  *
  80.  * Revision 1.1  1996/09/13 01:38:16  brianp
  81.  * Initial revision
  82.  *
  83.  */
  84.  
  85.  
  86. #ifdef PC_HEADER
  87. #include "all.h"
  88. #else
  89. #include <assert.h>
  90. #include <stdio.h>
  91. #include <stdlib.h>
  92. #include <string.h>
  93. #include "context.h"
  94. #include "image.h"
  95. #include "macros.h"
  96. #include "pixel.h"
  97. #include "types.h"
  98. #endif
  99.  
  100.  
  101.  
  102. /*
  103.  * Flip the 8 bits in each byte of the given array.
  104.  */
  105. void gl_flip_bytes( GLubyte *p, GLuint n )
  106. {
  107.    register GLuint i, a, b;
  108.  
  109.    for (i=0;i<n;i++) {
  110.       b = (GLuint) p[i];
  111.       a = ((b & 0x01) << 7) |
  112.       ((b & 0x02) << 5) |
  113.       ((b & 0x04) << 3) |
  114.       ((b & 0x08) << 1) |
  115.       ((b & 0x10) >> 1) |
  116.       ((b & 0x20) >> 3) |
  117.       ((b & 0x40) >> 5) |
  118.       ((b & 0x80) >> 7);
  119.       p[i] = (GLubyte) a;
  120.    }
  121. }
  122.  
  123.  
  124. /*
  125.  * Flip the order of the 2 bytes in each word in the given array.
  126.  */
  127. void gl_swap2( GLushort *p, GLuint n )
  128. {
  129.    register GLuint i;
  130.  
  131.    for (i=0;i<n;i++) {
  132.       p[i] = (p[i] >> 8) | ((p[i] << 8) & 0xff00);
  133.    }
  134. }
  135.  
  136.  
  137.  
  138. /*
  139.  * Flip the order of the 4 bytes in each word in the given array.
  140.  */
  141. void gl_swap4( GLuint *p, GLuint n )
  142. {
  143.    register GLuint i, a, b;
  144.  
  145.    for (i=0;i<n;i++) {
  146.       b = p[i];
  147.       a =  (b >> 24)
  148.     | ((b >> 8) & 0xff00)
  149.     | ((b << 8) & 0xff0000)
  150.     | ((b << 24) & 0xff000000);
  151.       p[i] = a;
  152.    }
  153. }
  154.  
  155.  
  156.  
  157.  
  158. /*
  159.  * Return the size, in bytes, of the given GL datatype.
  160.  * Return 0 if GL_BITMAP.
  161.  * Return -1 if invalid type enum.
  162.  */
  163. GLint gl_sizeof_type( GLenum type )
  164. {
  165.    switch (type) {
  166.       case GL_BITMAP:
  167.      return 0;
  168.       case GL_UNSIGNED_BYTE:
  169.          return sizeof(GLubyte);
  170.       case GL_BYTE:
  171.      return sizeof(GLbyte);
  172.       case GL_UNSIGNED_SHORT:
  173.      return sizeof(GLushort);
  174.       case GL_SHORT:
  175.      return sizeof(GLshort);
  176.       case GL_UNSIGNED_INT:
  177.      return sizeof(GLuint);
  178.       case GL_INT:
  179.      return sizeof(GLint);
  180.       case GL_FLOAT:
  181.      return sizeof(GLfloat);
  182.       default:
  183.          return -1;
  184.    }
  185. }
  186.  
  187.  
  188.  
  189. /*
  190.  * Return the number of components in a GL enum pixel type.
  191.  * Return -1 if bad format.
  192.  */
  193. GLint gl_components_in_format( GLenum format )
  194. {
  195.    switch (format) {
  196.       case GL_COLOR_INDEX:
  197.       case GL_STENCIL_INDEX:
  198.       case GL_DEPTH_COMPONENT:
  199.       case GL_RED:
  200.       case GL_GREEN:
  201.       case GL_BLUE:
  202.       case GL_ALPHA:
  203.       case GL_LUMINANCE:
  204.          return 1;
  205.       case GL_LUMINANCE_ALPHA:
  206.      return 2;
  207.       case GL_RGB:
  208.      return 3;
  209.       case GL_RGBA:
  210.      return 4;
  211.       default:
  212.          return -1;
  213.    }
  214. }
  215.  
  216.  
  217. /*
  218.  * Return the address of a pixel in an image (actually a volume).
  219.  * Pixel unpacking/packing parameters are observed according to 'packing'.
  220.  * Input:  image - start of image data
  221.  *         width, height - size of image
  222.  *         format - image format
  223.  *         type - pixel component type
  224.  *         packing - GL_TRUE = use packing params
  225.  *                   GL_FALSE = use unpacking params.
  226.  *         img - which image in the volume (0 for 2-D images)
  227.  *         row, column - location of pixel in the image
  228.  * Return:  address of pixel at (image,row,column) in image or NULL if error.
  229.  */
  230. GLvoid *gl_pixel_addr_in_image( struct gl_pixelstore_attrib *packing,
  231.                                 const GLvoid *image, GLsizei width,
  232.                                 GLsizei height, GLenum format, GLenum type,
  233.                                 GLint img, GLint row, GLint column )
  234. {
  235.    GLint bytes_per_comp;   /* bytes per component */
  236.    GLint comp_per_pixel;   /* components per pixel */
  237.    GLint comps_per_row;    /* components per row */
  238.    GLint pixels_per_row;   /* pixels per row */
  239.    GLint bytes_per_image;
  240.    GLint rows_per_image;
  241.    GLint alignment;        /* 1, 2 or 4 */
  242.    GLint skiprows;
  243.    GLint skippixels;
  244.    GLint skipimages;       /* for 3-D */
  245.    GLubyte *pixel_addr;
  246.  
  247.    /* Compute bytes per component */
  248.    bytes_per_comp = gl_sizeof_type( type );
  249.    if (bytes_per_comp<0) {
  250.       return NULL;
  251.    }
  252.  
  253.    /* Compute number of components per pixel */
  254.    comp_per_pixel = gl_components_in_format( format );
  255.    if (comp_per_pixel<0) {
  256.       return NULL;
  257.    }
  258.  
  259.    alignment = packing->Alignment;
  260.    if (packing->RowLength>0) {
  261.       pixels_per_row = packing->RowLength;
  262.    }
  263.    else {
  264.       pixels_per_row = width;
  265.    }
  266.    if (packing->ImageHeight>0) {
  267.       rows_per_image = packing->ImageHeight;
  268.    }
  269.    else {
  270.       rows_per_image = height;
  271.    }
  272.    skiprows = packing->SkipRows;
  273.    skippixels = packing->SkipPixels;
  274.    skipimages = packing->SkipImages;
  275.  
  276.    if (type==GL_BITMAP) {
  277.       /* BITMAP data */
  278.       GLint bytes_per_row;
  279.  
  280.       bytes_per_row = alignment
  281.                     * CEILING( comp_per_pixel*pixels_per_row, 8*alignment );
  282.  
  283.       bytes_per_image = bytes_per_row * rows_per_image;
  284.  
  285.       pixel_addr = (GLubyte *) image
  286.                  + (skipimages + img) * bytes_per_image
  287.                  + (skiprows + row) * bytes_per_row
  288.                  + (skippixels + column) / 8;
  289.    }
  290.    else {
  291.       /* Non-BITMAP data */
  292.  
  293.       if (bytes_per_comp>=alignment) {
  294.      comps_per_row = comp_per_pixel * pixels_per_row;
  295.       }
  296.       else {
  297.          GLint bytes_per_row = bytes_per_comp * comp_per_pixel
  298.                              * pixels_per_row;
  299.  
  300.      comps_per_row = alignment / bytes_per_comp
  301.                        * CEILING( bytes_per_row, alignment );
  302.       }
  303.  
  304.       bytes_per_image = bytes_per_comp * comps_per_row * rows_per_image;
  305.  
  306.       /* Copy/unpack pixel data to buffer */
  307.       pixel_addr = (GLubyte *) image
  308.                  + (skipimages + img) * bytes_per_image
  309.                  + (skiprows + row) * bytes_per_comp * comps_per_row
  310.                  + (skippixels + column) * bytes_per_comp * comp_per_pixel;
  311.    }
  312.  
  313.    return (GLvoid *) pixel_addr;
  314. }
  315.  
  316.  
  317.  
  318. /*
  319.  * Unpack a 2-D image from user-supplied address, returning a pointer to
  320.  * a new gl_image struct.
  321.  *
  322.  * Input:  width, height - size in pixels
  323.  *         srcFormat - format of incoming pixel data, ignored if
  324.  *                     srcType BITMAP.
  325.  *         srcType - GL_UNSIGNED_BYTE .. GL_FLOAT
  326.  *         pixels - pointer to unpacked image in client memory space.
  327.  */
  328. struct gl_image *gl_unpack_image( GLcontext *ctx,
  329.                                   GLint width, GLint height,
  330.                                   GLenum srcFormat, GLenum srcType,
  331.                                   const GLvoid *pixels )
  332. { 
  333.    return gl_unpack_image3D( ctx, width, height, 1,
  334.                              srcFormat, srcType, pixels );
  335. }
  336.  
  337.  
  338. /*
  339.  *         destType - store image as GL_UNSIGNED_BYTE, GL_FLOAT, or GL_BITMAP.
  340.  *                    if GL_UNSIGNED_BYTE, srctype must be GL_UNSIGNED_BYTE.
  341.  *                    if GL_BITMAP, srctype must be GL_BITMAP.
  342.  */
  343.  
  344. /* 
  345.  * Unpack a 2-D/3-D image from user-supplied address, returning a pointer to
  346.  * a new gl_image struct.
  347.  * Return NULL if there's an error during unpacking.
  348.  * This function is often called by a higher-level unpack function such
  349.  * as gl_unpack_texsubimage() or gl_unpack_bitmap().
  350.  *
  351.  * Input:  width, height, depth - size in pixels
  352.  *         srcFormat - format of incoming pixel data, ignored
  353.  *                      if srcType and destType is BITMAP.
  354.  *         srcType - GL_UNSIGNED_BYTE .. GL_FLOAT
  355.  *         pixels - pointer to unpacked image.
  356.  */
  357. struct gl_image *gl_unpack_image3D( GLcontext *ctx,
  358.                                     GLint width, GLint height, GLint depth,
  359.                                     GLenum srcFormat, GLenum srcType,
  360.                                     const GLvoid *pixels )
  361. {
  362.    GLint components;
  363.    GLenum destType;
  364.  
  365.    if (srcType==GL_UNSIGNED_BYTE) {
  366.       destType = GL_UNSIGNED_BYTE;
  367.    }
  368.    else if (srcType==GL_BITMAP) {
  369.       destType = GL_BITMAP;
  370.    }
  371.    else {
  372.       destType = GL_FLOAT;
  373.    }
  374.  
  375.    components = gl_components_in_format( srcFormat );
  376.  
  377.    if (components < 0)
  378.       return NULL;
  379.  
  380.    if (srcType==GL_BITMAP || destType==GL_BITMAP) {
  381.       struct gl_image *image;
  382.       GLint bytes, i, width_in_bytes, d;
  383.       GLubyte *buffer, *dst;
  384.       assert( srcType==GL_BITMAP );
  385.       assert( destType==GL_BITMAP );
  386.  
  387.       /* Alloc dest storage */
  388.       if (width > 0 && height > 0 && depth > 0)
  389.          bytes = ((width+7)/8 * height) * depth;
  390.       else
  391.          bytes = 0;
  392.       if (bytes>0 && pixels!=NULL) {
  393.          buffer = (GLubyte *) malloc( bytes );
  394.          if (!buffer) {
  395.             return NULL;
  396.          }
  397.          /* Copy/unpack pixel data to buffer */
  398.          width_in_bytes = CEILING( width, 8 );
  399.          dst = buffer;
  400.          for (d=0; d<depth; d++) {
  401.             for (i=0; i<height; i++) {
  402.                GLvoid *src = gl_pixel_addr_in_image( &ctx->Unpack, pixels,
  403.                                                      width, height,
  404.                                                      GL_COLOR_INDEX, srcType,
  405.                                                      d, i, 0 );
  406.                if (!src) {
  407.                   free(buffer);
  408.                   return NULL;
  409.                }
  410.                MEMCPY( dst, src, width_in_bytes );
  411.                dst += width_in_bytes;
  412.             }
  413.          }
  414.          /* Bit flipping */
  415.          if (ctx->Unpack.LsbFirst) {
  416.             gl_flip_bytes( buffer, bytes );
  417.          }
  418.       }
  419.       else {
  420.          /* a 'null' bitmap */
  421.          buffer = NULL;
  422.       }
  423.  
  424.       image = (struct gl_image *) malloc( sizeof(struct gl_image) );
  425.       if (image) {
  426.          image->Width = width;
  427.          image->Height = height;
  428.          image->Depth = depth;
  429.          image->Components = 0;
  430.          image->Format = GL_COLOR_INDEX;
  431.          image->Type = GL_BITMAP;
  432.          image->Data = buffer;
  433.          image->RefCount = 0;
  434.       }
  435.       else {
  436.          if (buffer)
  437.             free( buffer );
  438.          return NULL;
  439.       }
  440.       return image;
  441.    }
  442.    else if (srcFormat==GL_DEPTH_COMPONENT) {
  443.       /* TODO: pack as GLdepth values (GLushort or GLuint) */
  444.  
  445.    }
  446.    else if (srcFormat==GL_STENCIL_INDEX) {
  447.       /* TODO: pack as GLstencil (GLubyte or GLushort) */
  448.  
  449.    }
  450.    else if (destType==GL_UNSIGNED_BYTE) {
  451.       struct gl_image *image;
  452.       GLint width_in_bytes;
  453.       GLubyte *buffer, *dst;
  454.       GLint i, d;
  455.       assert( srcType==GL_UNSIGNED_BYTE );
  456.  
  457.       width_in_bytes = width * components * sizeof(GLubyte);
  458.       buffer = (GLubyte *) malloc( height * width_in_bytes * depth );
  459.       if (!buffer) {
  460.          return NULL;
  461.       }
  462.       /* Copy/unpack pixel data to buffer */
  463.       dst = buffer;
  464.       for (d=0; d<depth; d++ ) {
  465.          for (i=0;i<height;i++) {
  466.             GLubyte *src = (GLubyte *) gl_pixel_addr_in_image( &ctx->Unpack,
  467.                            pixels, width, height, srcFormat, srcType, d, i, 0 );
  468.             if (!src) {
  469.                free(buffer);
  470.                return NULL;
  471.             }
  472.             MEMCPY( dst, src, width_in_bytes );
  473.             dst += width_in_bytes;
  474.          }
  475.       }
  476.  
  477.       if (ctx->Unpack.LsbFirst) {
  478.          gl_flip_bytes( buffer, height * width_in_bytes * depth );
  479.       }
  480.  
  481.       image = (struct gl_image *) malloc( sizeof(struct gl_image) );
  482.       if (image) {
  483.          image->Width = width;
  484.          image->Height = height;
  485.          image->Depth = depth; 
  486.          image->Components = components;
  487.          image->Format = srcFormat;
  488.          image->Type = GL_UNSIGNED_BYTE;
  489.          image->Data = buffer;
  490.          image->RefCount = 0;
  491.       }
  492.       else {
  493.          free( buffer );
  494.          return NULL;
  495.       }
  496.       return image;
  497.    }
  498.    else if (destType==GL_FLOAT) {
  499.       struct gl_image *image;
  500.       GLfloat *buffer, *dst;
  501.       GLint elems_per_row;
  502.       GLint i, j, d;
  503.       GLboolean normalize;
  504.       elems_per_row = width * components;
  505.       buffer = (GLfloat *) malloc( height * elems_per_row * sizeof(GLfloat) * depth);
  506.       if (!buffer) {
  507.          return NULL;
  508.       }
  509.  
  510.       normalize = (srcFormat != GL_COLOR_INDEX)
  511.                && (srcFormat != GL_STENCIL_INDEX);
  512.  
  513.       dst = buffer;
  514.       /**      img_pixels= pixels;*/
  515.       for (d=0; d<depth; d++) {
  516.          for (i=0;i<height;i++) {
  517.             GLvoid *src = gl_pixel_addr_in_image( &ctx->Unpack, pixels,
  518.                                                   width, height,
  519.                                                   srcFormat, srcType,
  520.                                                   d, i, 0 );
  521.             if (!src) {
  522.                free(buffer);
  523.                return NULL;
  524.             }
  525.  
  526.             switch (srcType) {
  527.                case GL_UNSIGNED_BYTE:
  528.                   if (normalize) {
  529.                      for (j=0;j<elems_per_row;j++) {
  530.                         *dst++ = UBYTE_TO_FLOAT(((GLubyte*)src)[j]);
  531.                      }
  532.                   }
  533.                   else {
  534.                      for (j=0;j<elems_per_row;j++) {
  535.                         *dst++ = (GLfloat) ((GLubyte*)src)[j];
  536.                      }
  537.                   }
  538.                   break;
  539.                case GL_BYTE:
  540.                   if (normalize) {
  541.                      for (j=0;j<elems_per_row;j++) {
  542.                         *dst++ = BYTE_TO_FLOAT(((GLbyte*)src)[j]);
  543.                      }
  544.                   }
  545.                   else {
  546.                      for (j=0;j<elems_per_row;j++) {
  547.                         *dst++ = (GLfloat) ((GLbyte*)src)[j];
  548.                      }
  549.                   }
  550.                   break;
  551.                case GL_UNSIGNED_SHORT:
  552.                   if (ctx->Unpack.SwapBytes) {
  553.                      for (j=0;j<elems_per_row;j++) {
  554.                         GLushort value = ((GLushort*)src)[j];
  555.                         value = ((value >> 8) & 0xff) | ((value&0xff) << 8);
  556.                         if (normalize) {
  557.                            *dst++ = USHORT_TO_FLOAT(value);
  558.                         }
  559.                         else {
  560.                            *dst++ = (GLfloat) value;
  561.                         }
  562.                      }
  563.                   }
  564.                   else {
  565.                      if (normalize) {
  566.                         for (j=0;j<elems_per_row;j++) {
  567.                            *dst++ = USHORT_TO_FLOAT(((GLushort*)src)[j]);
  568.                         }
  569.                      }
  570.                      else {
  571.                         for (j=0;j<elems_per_row;j++) {
  572.                            *dst++ = (GLfloat) ((GLushort*)src)[j];
  573.                         }
  574.                      }
  575.                   }
  576.                   break;
  577.                case GL_SHORT:
  578.                   if (ctx->Unpack.SwapBytes) {
  579.                      for (j=0;j<elems_per_row;j++) {
  580.                         GLshort value = ((GLshort*)src)[j];
  581.                         value = ((value >> 8) & 0xff) | ((value&0xff) << 8);
  582.                         if (normalize) {
  583.                            *dst++ = SHORT_TO_FLOAT(value);
  584.                         }
  585.                         else {
  586.                            *dst++ = (GLfloat) value;
  587.                         }
  588.                      }
  589.                   }
  590.                   else {
  591.                      if (normalize) {
  592.                         for (j=0;j<elems_per_row;j++) {
  593.                            *dst++ = SHORT_TO_FLOAT(((GLshort*)src)[j]);
  594.                         }
  595.                      }
  596.                      else {
  597.                         for (j=0;j<elems_per_row;j++) {
  598.                            *dst++ = (GLfloat) ((GLshort*)src)[j];
  599.                         }
  600.                      }
  601.                   }
  602.                   break;
  603.                case GL_UNSIGNED_INT:
  604.                   if (ctx->Unpack.SwapBytes) {
  605.                      GLuint value;
  606.                      for (j=0;j<elems_per_row;j++) {
  607.                         value = ((GLuint*)src)[j];
  608.                         value = ((value & 0xff000000) >> 24)
  609.                               | ((value & 0x00ff0000) >> 8)
  610.                               | ((value & 0x0000ff00) << 8)
  611.                               | ((value & 0x000000ff) << 24);
  612.                         if (normalize) {
  613.                            *dst++ = UINT_TO_FLOAT(value);
  614.                         }
  615.                         else {
  616.                            *dst++ = (GLfloat) value;
  617.                         }
  618.                      }
  619.                   }
  620.                   else {
  621.                      if (normalize) {
  622.                         for (j=0;j<elems_per_row;j++) {
  623.                            *dst++ = UINT_TO_FLOAT(((GLuint*)src)[j]);
  624.                         }
  625.                      }
  626.                      else {
  627.                         for (j=0;j<elems_per_row;j++) {
  628.                            *dst++ = (GLfloat) ((GLuint*)src)[j];
  629.                         }
  630.                      }
  631.                   }
  632.                   break;
  633.                case GL_INT:
  634.                   if (ctx->Unpack.SwapBytes) {
  635.                      GLint value;
  636.                      for (j=0;j<elems_per_row;j++) {
  637.                         value = ((GLint*)src)[j];
  638.                         value = ((value & 0xff000000) >> 24)
  639.                               | ((value & 0x00ff0000) >> 8)
  640.                               | ((value & 0x0000ff00) << 8)
  641.                               | ((value & 0x000000ff) << 24);
  642.                         if (normalize) {
  643.                            *dst++ = INT_TO_FLOAT(value);
  644.                         }
  645.                         else {
  646.                            *dst++ = (GLfloat) value;
  647.                         }
  648.                      }
  649.                   }
  650.                   else {
  651.                      if (normalize) {
  652.                         for (j=0;j<elems_per_row;j++) {
  653.                            *dst++ = INT_TO_FLOAT(((GLint*)src)[j]);
  654.                         }
  655.                      }
  656.                      else {
  657.                         for (j=0;j<elems_per_row;j++) {
  658.                            *dst++ = (GLfloat) ((GLint*)src)[j];
  659.                         }
  660.                      }
  661.                   }
  662.                   break;
  663.                case GL_FLOAT:
  664.                   if (ctx->Unpack.SwapBytes) {
  665.                      GLint value;
  666.                      for (j=0;j<elems_per_row;j++) {
  667.                         value = ((GLuint*)src)[j];
  668.                         value = ((value & 0xff000000) >> 24)
  669.                               | ((value & 0x00ff0000) >> 8)
  670.                               | ((value & 0x0000ff00) << 8)
  671.                               | ((value & 0x000000ff) << 24);
  672.                         *dst++ = *((GLfloat*) &value);
  673.                      }
  674.                   }
  675.                   else {
  676.                      MEMCPY( dst, src, elems_per_row*sizeof(GLfloat) );
  677.                      dst += elems_per_row;
  678.                   }
  679.                   break;
  680.                default:
  681.                   gl_problem(ctx, "Bad type in gl_unpack_image3D");
  682.                   return NULL;
  683.             } /*switch*/
  684.          } /* for height */
  685.       } /*for*/
  686.  
  687.       image = (struct gl_image *) malloc( sizeof(struct gl_image) );
  688.       if (image) {
  689.          image->Width = width;
  690.          image->Height = height;
  691.          image->Depth = depth;  
  692.          image->Components = components;
  693.          image->Format = srcFormat;
  694.          image->Type = GL_FLOAT;
  695.          image->Data = buffer;
  696.          image->RefCount = 0;
  697.       }
  698.       else {
  699.          free( buffer );
  700.          return NULL;
  701.       }
  702.       return image;
  703.    }
  704.    else {
  705.       gl_problem(ctx, "Bad dest type in gl_unpack_image3D");
  706.       return NULL;
  707.    }
  708.    return NULL;  /* never get here */
  709. }
  710.  
  711.  
  712.  
  713. void gl_free_image( struct gl_image *image )
  714. {
  715.    if (image->Data) {
  716.       free(image->Data);
  717.    }
  718.    free(image);
  719. }
  720.