image.c File Reference

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "context.h"
#include "image.h"
#include "macros.h"
#include "pixel.h"
#include "types.h"

Include dependency graph for image.c:

Go to the source code of this file.

Functions
void	gl_flip_bytes (GLubyte *p, GLuint n)
void	gl_swap2 (GLushort *p, GLuint n)
void	gl_swap4 (GLuint *p, GLuint n)
GLint	gl_sizeof_type (GLenum type)
GLint	gl_components_in_format (GLenum format)
GLvoid *	gl_pixel_addr_in_image (struct gl_pixelstore_attrib *packing, const GLvoid *image, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint row)
struct gl_image *	gl_unpack_image (GLcontext *ctx, GLint width, GLint height, GLenum srcFormat, GLenum srcType, const GLvoid *pixels)
void	gl_free_image (struct gl_image *image)

Function Documentation

gl_components_in_format()

GLint gl_components_in_format

(

GLenum

format

)

Definition at line 193 of file image.c.

{
   switch (format) {
      case GL_COLOR_INDEX:
      case GL_STENCIL_INDEX:
      case GL_DEPTH_COMPONENT:
      case GL_RED:
      case GL_GREEN:
      case GL_BLUE:
      case GL_ALPHA:
      case GL_LUMINANCE:
         return 1;
      case GL_LUMINANCE_ALPHA:
     return 2;
      case GL_RGB:
      case GL_BGR_EXT:
     return 3;
      case GL_RGBA:
      case GL_BGRA_EXT:
     return 4;
      default:
         return -1;
   }
}

Referenced by gl_pixel_addr_in_image(), gl_TexSubImage2D(), gl_unpack_image(), and gl_unpack_pixels().

gl_flip_bytes()

void gl_flip_bytes	(	GLubyte *	p,
		GLuint	n
	)

Definition at line 105 of file image.c.

{
   register GLuint i, a, b;

   for (i=0;i<n;i++) {
      b = (GLuint) p[i];
      a = ((b & 0x01) << 7) |
      ((b & 0x02) << 5) |
      ((b & 0x04) << 3) |
      ((b & 0x08) << 1) |
      ((b & 0x10) >> 1) |
      ((b & 0x20) >> 3) |
      ((b & 0x40) >> 5) |
      ((b & 0x80) >> 7);
      p[i] = (GLubyte) a;
   }
}

Referenced by gl_unpack_image(), and gl_unpack_pixels().

gl_free_image()

void gl_free_image

(

struct gl_image *

image

)

Definition at line 661 of file image.c.

{
   if (image->Data) {
      free(image->Data);
   }
   free(image);
}

Referenced by _mesa_Bitmap(), _mesa_ColorSubTableEXT(), _mesa_ColorTableEXT(), gl_destroy_list(), gl_TexImage1D(), gl_TexImage2D(), gl_TexSubImage1D(), and gl_TexSubImage2D().

gl_pixel_addr_in_image()

GLvoid* gl_pixel_addr_in_image	(	struct gl_pixelstore_attrib *	packing,
		const GLvoid *	image,
		GLsizei	width,
		GLsizei	height,
		GLenum	format,
		GLenum	type,
		GLint	row
	)

Definition at line 232 of file image.c.

{
   GLint bytes_per_comp;   /* bytes per component */
   GLint comp_per_pixel;   /* components per pixel */
   GLint comps_per_row;    /* components per row */
   GLint pixels_per_row;   /* pixels per row */
   GLint alignment;        /* 1, 2 or 4 */
   GLint skiprows;
   GLint skippixels;
   GLubyte *pixel_addr;

   /* Compute bytes per component */
   bytes_per_comp = gl_sizeof_type( type );
   if (bytes_per_comp<0) {
      return NULL;
   }

   /* Compute number of components per pixel */
   comp_per_pixel = gl_components_in_format( format );
   if (comp_per_pixel<0) {
      return NULL;
   }

   alignment = packing->Alignment;
   if (packing->RowLength>0) {
      pixels_per_row = packing->RowLength;
   }
   else {
      pixels_per_row = width;
   }
   skiprows = packing->SkipRows;
   skippixels = packing->SkipPixels;

   if (type==GL_BITMAP) {
      /* BITMAP data */
      GLint bytes_per_row;

      bytes_per_row = alignment
                    * CEILING( comp_per_pixel*pixels_per_row, 8*alignment );

      pixel_addr = (GLubyte *) image
                 + (skiprows + row) * bytes_per_row
                 + (skippixels) / 8;
   }
   else {
      /* Non-BITMAP data */

      if (bytes_per_comp>=alignment) {
     comps_per_row = comp_per_pixel * pixels_per_row;
      }
      else {
         GLint bytes_per_row = bytes_per_comp * comp_per_pixel
                             * pixels_per_row;

     comps_per_row = alignment / bytes_per_comp
                       * CEILING( bytes_per_row, alignment );
      }

      /* Copy/unpack pixel data to buffer */
      pixel_addr = (GLubyte *) image
                 + (skiprows + row) * bytes_per_comp * comps_per_row
                 + (skippixels) * bytes_per_comp * comp_per_pixel;
   }

   return (GLvoid *) pixel_addr;
}

Referenced by gl_unpack_image(), and gl_unpack_pixels().

gl_sizeof_type()

GLint gl_sizeof_type

(

GLenum

type

)

Definition at line 163 of file image.c.

{
   switch (type) {
      case GL_BITMAP:
     return 0;
      case GL_UNSIGNED_BYTE:
         return sizeof(GLubyte);
      case GL_BYTE:
     return sizeof(GLbyte);
      case GL_UNSIGNED_SHORT:
     return sizeof(GLushort);
      case GL_SHORT:
     return sizeof(GLshort);
      case GL_UNSIGNED_INT:
     return sizeof(GLuint);
      case GL_INT:
     return sizeof(GLint);
      case GL_FLOAT:
     return sizeof(GLfloat);
      default:
         return -1;
   }
}

Referenced by gl_pixel_addr_in_image(), gl_TexSubImage1D(), gl_TexSubImage2D(), gl_unpack_pixels(), gl_unpack_texsubimage(), read_color_pixels(), read_depth_pixels(), read_index_pixels(), and read_stencil_pixels().

gl_swap2()

void gl_swap2	(	GLushort *	p,
		GLuint	n
	)

Definition at line 127 of file image.c.

{
   register GLuint i;

   for (i=0;i<n;i++) {
      p[i] = (p[i] >> 8) | ((p[i] << 8) & 0xff00);
   }
}

Referenced by gl_unpack_pixels(), read_color_pixels(), read_depth_pixels(), read_index_pixels(), and read_stencil_pixels().

gl_swap4()

void gl_swap4	(	GLuint *	p,
		GLuint	n
	)

Definition at line 141 of file image.c.

{
   register GLuint i, a, b;

   for (i=0;i<n;i++) {
      b = p[i];
      a =  (b >> 24)
    | ((b >> 8) & 0xff00)
    | ((b << 8) & 0xff0000)
    | ((b << 24) & 0xff000000);
      p[i] = a;
   }
}

Referenced by gl_unpack_pixels(), read_color_pixels(), read_depth_pixels(), read_index_pixels(), and read_stencil_pixels().

gl_unpack_image()

struct gl_image* gl_unpack_image	(	GLcontext *	ctx,
		GLint	width,
		GLint	height,
		GLenum	srcFormat,
		GLenum	srcType,
		const GLvoid *	pixels
	)

img_pixels= pixels;

Definition at line 314 of file image.c.

{
   GLint components;
   GLenum destType;

   if (srcType==GL_UNSIGNED_BYTE) {
      destType = GL_UNSIGNED_BYTE;
   }
   else if (srcType==GL_BITMAP) {
      destType = GL_BITMAP;
   }
   else {
      destType = GL_FLOAT;
   }

   components = gl_components_in_format( srcFormat );

   if (components < 0)
      return NULL;

   if (srcType==GL_BITMAP || destType==GL_BITMAP) {
      struct gl_image *image;
      GLint bytes, i, width_in_bytes;
      GLubyte *buffer, *dst;
      assert( srcType==GL_BITMAP );
      assert( destType==GL_BITMAP );

      /* Alloc dest storage */
      if (width > 0 && height > 0)
         bytes = ((width+7)/8 * height);
      else
         bytes = 0;
      if (bytes>0 && pixels!=NULL) {
         buffer = (GLubyte *) malloc( bytes );
         if (!buffer) {
            return NULL;
         }
         /* Copy/unpack pixel data to buffer */
         width_in_bytes = CEILING( width, 8 );
         dst = buffer;
         for (i=0; i<height; i++) {
            GLvoid *src = gl_pixel_addr_in_image( &ctx->Unpack, pixels,
                                                  width, height,
                                                  GL_COLOR_INDEX, srcType,
                                                  i);
            if (!src) {
               free(buffer);
               return NULL;
            }
            MEMCPY( dst, src, width_in_bytes );
            dst += width_in_bytes;
         }
         /* Bit flipping */
         if (ctx->Unpack.LsbFirst) {
            gl_flip_bytes( buffer, bytes );
         }
      }
      else {
         /* a 'null' bitmap */
         buffer = NULL;
      }

      image = (struct gl_image *) malloc( sizeof(struct gl_image) );
      if (image) {
         image->Width = width;
         image->Height = height;
         image->Components = 0;
         image->Format = GL_COLOR_INDEX;
         image->Type = GL_BITMAP;
         image->Data = buffer;
         image->RefCount = 0;
      }
      else {
         if (buffer)
            free( buffer );
         return NULL;
      }
      return image;
   }
   else if (srcFormat==GL_DEPTH_COMPONENT) {
      /* TODO: pack as GLdepth values (GLushort or GLuint) */

   }
   else if (srcFormat==GL_STENCIL_INDEX) {
      /* TODO: pack as GLstencil (GLubyte or GLushort) */

   }
   else if (destType==GL_UNSIGNED_BYTE) {
      struct gl_image *image;
      GLint width_in_bytes;
      GLubyte *buffer, *dst;
      GLint i;
      assert( srcType==GL_UNSIGNED_BYTE );

      width_in_bytes = width * components * sizeof(GLubyte);
      buffer = (GLubyte *) malloc( height * width_in_bytes );
      if (!buffer) {
         return NULL;
      }
      /* Copy/unpack pixel data to buffer */
      dst = buffer;
      for (i=0;i<height;i++) {
         GLubyte *src = (GLubyte *) gl_pixel_addr_in_image( &ctx->Unpack,
                        pixels, width, height, srcFormat, srcType, i);
         if (!src) {
            free(buffer);
            return NULL;
         }
         MEMCPY( dst, src, width_in_bytes );
         dst += width_in_bytes;
      }

      if (ctx->Unpack.LsbFirst) {
         gl_flip_bytes( buffer, height * width_in_bytes );
      }

      image = (struct gl_image *) malloc( sizeof(struct gl_image) );
      if (image) {
         image->Width = width;
         image->Height = height;
         image->Components = components;
         image->Format = srcFormat;
         image->Type = GL_UNSIGNED_BYTE;
         image->Data = buffer;
         image->RefCount = 0;
      }
      else {
         free( buffer );
         return NULL;
      }
      return image;
   }
   else if (destType==GL_FLOAT) {
      struct gl_image *image;
      GLfloat *buffer, *dst;
      GLint elems_per_row;
      GLint i, j;
      GLboolean normalize;
      elems_per_row = width * components;
      buffer = (GLfloat *) malloc( height * elems_per_row * sizeof(GLfloat));
      if (!buffer) {
         return NULL;
      }

      normalize = (srcFormat != GL_COLOR_INDEX)
               && (srcFormat != GL_STENCIL_INDEX);

      dst = buffer;
      for (i=0;i<height;i++) {
         GLvoid *src = gl_pixel_addr_in_image( &ctx->Unpack, pixels,
                                               width, height,
                                               srcFormat, srcType,
                                               i);
         if (!src) {
            free(buffer);
            return NULL;
         }

         switch (srcType) {
            case GL_UNSIGNED_BYTE:
               if (normalize) {
                  for (j=0;j<elems_per_row;j++) {
                     *dst++ = UBYTE_TO_FLOAT(((GLubyte*)src)[j]);
                  }
               }
               else {
                  for (j=0;j<elems_per_row;j++) {
                     *dst++ = (GLfloat) ((GLubyte*)src)[j];
                  }
               }
               break;
            case GL_BYTE:
               if (normalize) {
                  for (j=0;j<elems_per_row;j++) {
                     *dst++ = BYTE_TO_FLOAT(((GLbyte*)src)[j]);
                  }
               }
               else {
                  for (j=0;j<elems_per_row;j++) {
                     *dst++ = (GLfloat) ((GLbyte*)src)[j];
                  }
               }
               break;
            case GL_UNSIGNED_SHORT:
               if (ctx->Unpack.SwapBytes) {
                  for (j=0;j<elems_per_row;j++) {
                     GLushort value = ((GLushort*)src)[j];
                     value = ((value >> 8) & 0xff) | ((value&0xff) << 8);
                     if (normalize) {
                        *dst++ = USHORT_TO_FLOAT(value);
                     }
                     else {
                        *dst++ = (GLfloat) value;
                     }
                  }
               }
               else {
                  if (normalize) {
                     for (j=0;j<elems_per_row;j++) {
                        *dst++ = USHORT_TO_FLOAT(((GLushort*)src)[j]);
                     }
                  }
                  else {
                     for (j=0;j<elems_per_row;j++) {
                        *dst++ = (GLfloat) ((GLushort*)src)[j];
                     }
                  }
               }
               break;
            case GL_SHORT:
               if (ctx->Unpack.SwapBytes) {
                  for (j=0;j<elems_per_row;j++) {
                     GLshort value = ((GLshort*)src)[j];
                     value = ((value >> 8) & 0xff) | ((value&0xff) << 8);
                     if (normalize) {
                        *dst++ = SHORT_TO_FLOAT(value);
                     }
                     else {
                        *dst++ = (GLfloat) value;
                     }
                  }
               }
               else {
                  if (normalize) {
                     for (j=0;j<elems_per_row;j++) {
                        *dst++ = SHORT_TO_FLOAT(((GLshort*)src)[j]);
                     }
                  }
                  else {
                     for (j=0;j<elems_per_row;j++) {
                        *dst++ = (GLfloat) ((GLshort*)src)[j];
                     }
                  }
               }
               break;
            case GL_UNSIGNED_INT:
               if (ctx->Unpack.SwapBytes) {
                  GLuint value;
                  for (j=0;j<elems_per_row;j++) {
                     value = ((GLuint*)src)[j];
                     value = ((value & 0xff000000) >> 24)
                           | ((value & 0x00ff0000) >> 8)
                           | ((value & 0x0000ff00) << 8)
                           | ((value & 0x000000ff) << 24);
                     if (normalize) {
                        *dst++ = UINT_TO_FLOAT(value);
                     }
                     else {
                        *dst++ = (GLfloat) value;
                     }
                  }
               }
               else {
                  if (normalize) {
                     for (j=0;j<elems_per_row;j++) {
                        *dst++ = UINT_TO_FLOAT(((GLuint*)src)[j]);
                     }
                  }
                  else {
                     for (j=0;j<elems_per_row;j++) {
                        *dst++ = (GLfloat) ((GLuint*)src)[j];
                     }
                  }
               }
               break;
            case GL_INT:
               if (ctx->Unpack.SwapBytes) {
                  GLint value;
                  for (j=0;j<elems_per_row;j++) {
                     value = ((GLint*)src)[j];
                     value = ((value & 0xff000000) >> 24)
                           | ((value & 0x00ff0000) >> 8)
                           | ((value & 0x0000ff00) << 8)
                           | ((value & 0x000000ff) << 24);
                     if (normalize) {
                        *dst++ = INT_TO_FLOAT(value);
                     }
                     else {
                        *dst++ = (GLfloat) value;
                     }
                  }
               }
               else {
                  if (normalize) {
                     for (j=0;j<elems_per_row;j++) {
                        *dst++ = INT_TO_FLOAT(((GLint*)src)[j]);
                     }
                  }
                  else {
                     for (j=0;j<elems_per_row;j++) {
                        *dst++ = (GLfloat) ((GLint*)src)[j];
                     }
                  }
               }
               break;
            case GL_FLOAT:
               if (ctx->Unpack.SwapBytes) {
                  GLint value;
                  for (j=0;j<elems_per_row;j++) {
                     value = ((GLuint*)src)[j];
                     value = ((value & 0xff000000) >> 24)
                           | ((value & 0x00ff0000) >> 8)
                           | ((value & 0x0000ff00) << 8)
                           | ((value & 0x000000ff) << 24);
                     *dst++ = *((GLfloat*) &value);
                  }
               }
               else {
                  MEMCPY( dst, src, elems_per_row*sizeof(GLfloat) );
                  dst += elems_per_row;
               }
               break;
            default:
               gl_problem(ctx, "Bad type in gl_unpack_image3D");
               return NULL;
         } /*switch*/
      } /* for height */

      image = (struct gl_image *) malloc( sizeof(struct gl_image) );
      if (image) {
         image->Width = width;
         image->Height = height;
         image->Components = components;
         image->Format = srcFormat;
         image->Type = GL_FLOAT;
         image->Data = buffer;
         image->RefCount = 0;
      }
      else {
         free( buffer );
         return NULL;
      }
      return image;
   }
   else {
      gl_problem(ctx, "Bad dest type in gl_unpack_image3D");
      return NULL;
   }
   return NULL;  /* never get here */
}

Referenced by _mesa_ColorSubTableEXT(), _mesa_ColorTableEXT(), _mesa_TexImage1D(), _mesa_TexImage2D(), gl_unpack_bitmap(), and gl_unpack_texsubimage().