/* $Id: readpix.c,v 3.8 1998/08/04 02:47:49 brianp Exp $ */ /* * Mesa 3-D graphics library * Version: 3.0 * Copyright (C) 1995-1998 Brian Paul * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the Free * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* * $Log: readpix.c,v $ * Revision 3.8 1998/08/04 02:47:49 brianp * clipping in read_fast_rgba_pixels() off by one (Randy Frank) * * Revision 3.7 1998/07/18 03:34:24 brianp * GL_ALPHA format was missing * * Revision 3.6 1998/07/17 03:24:16 brianp * added Pixel.ScaleOrBiasRGBA field * * Revision 3.5 1998/03/27 04:17:52 brianp * fixed G++ warnings * * Revision 3.4 1998/03/15 18:50:25 brianp * added GL_EXT_abgr extension * * Revision 3.3 1998/02/08 20:22:14 brianp * LOTS of clean-up and rewriting * * Revision 3.2 1998/02/01 22:29:09 brianp * added support for packed pixel formats * * Revision 3.1 1998/02/01 20:47:42 brianp * added GL_BGR and GL_BGRA pixel formats * * Revision 3.0 1998/01/31 21:02:29 brianp * initial rev * */ #ifdef PC_HEADER #include "all.h" #else #include #include #include #include "context.h" #include "depth.h" #include "feedback.h" #include "macros.h" #include "image.h" #include "pixel.h" #include "readpix.h" #include "span.h" #include "stencil.h" #include "types.h" #endif /* * Read a block of color index pixels. */ static void read_index_pixels( GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height, GLenum type, GLvoid *pixels ) { GLint i, j; /* error checking */ if (ctx->Visual->RGBAflag) { gl_error( ctx, GL_INVALID_OPERATION, "glReadPixels" ); return; } /* process image row by row */ for (j=0;jDriver.ReadCI32Span)( ctx, width, x, y, index ); if (ctx->Pixel.IndexShift!=0 || ctx->Pixel.IndexOffset!=0) { gl_shift_and_offset_ci( ctx, width, index); } if (ctx->Pixel.MapColorFlag) { gl_map_ci(ctx, width, index); } dest = gl_pixel_addr_in_image(&ctx->Pack, pixels, width, height, GL_COLOR_INDEX, type, 0, j, 0); switch (type) { case GL_UNSIGNED_BYTE: { GLubyte *dst = (GLubyte *) dest; for (i=0;iPack.SwapBytes) { gl_swap2( (GLushort *) dst, width ); } } break; case GL_SHORT: { GLshort *dst = (GLshort *) dest; for (i=0;iPack.SwapBytes) { gl_swap2( (GLushort *) dst, width ); } } break; case GL_UNSIGNED_INT: { GLuint *dst = (GLuint *) dest; for (i=0;iPack.SwapBytes) { gl_swap4( (GLuint *) dst, width ); } } break; case GL_INT: { GLint *dst = (GLint *) dest; for (i=0;iPack.SwapBytes) { gl_swap4( (GLuint *) dst, width ); } } break; case GL_FLOAT: { GLfloat *dst = (GLfloat *) dest; for (i=0;iPack.SwapBytes) { gl_swap4( (GLuint *) dst, width ); } } break; default: gl_error( ctx, GL_INVALID_ENUM, "glReadPixels(type)" ); } } } static void read_depth_pixels( GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height, GLenum type, GLvoid *pixels ) { GLint i, j; GLboolean bias_or_scale; /* Error checking */ if (ctx->Visual->DepthBits <= 0) { /* No depth buffer */ gl_error( ctx, GL_INVALID_OPERATION, "glReadPixels" ); return; } bias_or_scale = ctx->Pixel.DepthBias!=0.0 || ctx->Pixel.DepthScale!=1.0; if (type==GL_UNSIGNED_SHORT && sizeof(GLdepth)==sizeof(GLushort) && !bias_or_scale && !ctx->Pack.SwapBytes) { /* Special case: directly read 16-bit unsigned depth values. */ for (j=0;jPack, pixels, width, height, GL_DEPTH_COMPONENT, type, 0, j, 0); (*ctx->Driver.ReadDepthSpanInt)( ctx, width, x, y, (GLdepth*) dst); } } else if (type==GL_UNSIGNED_INT && sizeof(GLdepth)==sizeof(GLuint) && !bias_or_scale && !ctx->Pack.SwapBytes) { /* Special case: directly read 32-bit unsigned depth values. */ /* Compute shift value to scale depth values up to 32-bit uints. */ GLuint shift = 0; GLuint max = MAX_DEPTH; while ((max&0x80000000)==0) { max = max << 1; shift++; } for (j=0;jPack, pixels, width, height, GL_DEPTH_COMPONENT, type, 0, j, 0); (*ctx->Driver.ReadDepthSpanInt)( ctx, width, x, y, (GLdepth*) dst); for (i=0;iDriver.ReadDepthSpanFloat)( ctx, width, x, y, depth ); if (bias_or_scale) { for (i=0;iPixel.DepthScale + ctx->Pixel.DepthBias; depth[i] = CLAMP( d, 0.0F, 1.0F ); } } dest = gl_pixel_addr_in_image(&ctx->Pack, pixels, width, height, GL_DEPTH_COMPONENT, type, 0, j, 0); switch (type) { case GL_UNSIGNED_BYTE: { GLubyte *dst = (GLubyte *) dest; for (i=0;iPack.SwapBytes) { gl_swap2( (GLushort *) dst, width ); } } break; case GL_SHORT: { GLshort *dst = (GLshort *) dest; for (i=0;iPack.SwapBytes) { gl_swap2( (GLushort *) dst, width ); } } break; case GL_UNSIGNED_INT: { GLuint *dst = (GLuint *) dest; for (i=0;iPack.SwapBytes) { gl_swap4( (GLuint *) dst, width ); } } break; case GL_INT: { GLint *dst = (GLint *) dest; for (i=0;iPack.SwapBytes) { gl_swap4( (GLuint *) dst, width ); } } break; case GL_FLOAT: { GLfloat *dst = (GLfloat *) dest; for (i=0;iPack.SwapBytes) { gl_swap4( (GLuint *) dst, width ); } } break; default: gl_error( ctx, GL_INVALID_ENUM, "glReadPixels(type)" ); } } } } static void read_stencil_pixels( GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height, GLenum type, GLvoid *pixels ) { GLboolean shift_or_offset; GLint i, j; if (ctx->Visual->StencilBits<=0) { /* No stencil buffer */ gl_error( ctx, GL_INVALID_OPERATION, "glReadPixels" ); return; } shift_or_offset = ctx->Pixel.IndexShift!=0 || ctx->Pixel.IndexOffset!=0; /* process image row by row */ for (j=0;jPixel.MapStencilFlag) { gl_map_stencil( ctx, width, stencil ); } dest = gl_pixel_addr_in_image(&ctx->Pack, pixels, width, height, GL_STENCIL_INDEX, type, 0, j, 0); switch (type) { case GL_UNSIGNED_BYTE: MEMCPY( dest, stencil, width ); break; case GL_BYTE: MEMCPY( dest, stencil, width ); break; case GL_UNSIGNED_SHORT: { GLushort *dst = (GLushort *) dest; for (i=0;iPack.SwapBytes) { gl_swap2( (GLushort *) dst, width ); } } break; case GL_SHORT: { GLshort *dst = (GLshort *) dest; for (i=0;iPack.SwapBytes) { gl_swap2( (GLushort *) dst, width ); } } break; case GL_UNSIGNED_INT: { GLuint *dst = (GLuint *) dest; for (i=0;iPack.SwapBytes) { gl_swap4( (GLuint *) dst, width ); } } break; case GL_INT: { GLint *dst = (GLint *) dest; for (i=0;iPack.SwapBytes) { gl_swap4( (GLuint *) dst, width ); } } break; case GL_FLOAT: { GLfloat *dst = (GLfloat *) dest; for (i=0;iPack.SwapBytes) { gl_swap4( (GLuint *) dst, width ); } } break; default: gl_error( ctx, GL_INVALID_ENUM, "glReadPixels(type)" ); } } } /* * Optimized glReadPixels for particular pixel formats: * GL_UNSIGNED_BYTE, GL_RGBA * when pixel scaling, biasing and mapping are disabled. */ static GLboolean read_fast_rgba_pixels( GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels ) { /* can't do scale, bias or mapping */ if (ctx->Pixel.ScaleOrBiasRGBA || ctx->Pixel.MapColorFlag) return GL_FALSE; /* can't do fancy pixel packing */ if (ctx->Pack.Alignment != 1 || ctx->Pack.SwapBytes || ctx->Pack.LsbFirst) return GL_FALSE; { GLint srcX = x; GLint srcY = y; GLint readWidth = width; /* actual width read */ GLint readHeight = height; /* actual height read */ GLint skipPixels = ctx->Pack.SkipPixels; GLint skipRows = ctx->Pack.SkipRows; GLint rowLength; if (ctx->Pack.RowLength > 0) rowLength = ctx->Pack.RowLength; else rowLength = width; /* horizontal clipping */ if (srcX < ctx->Buffer->Xmin) { skipPixels += (ctx->Buffer->Xmin - srcX); readWidth -= (ctx->Buffer->Xmin - srcX); srcX = ctx->Buffer->Xmin; } if (srcX + readWidth > ctx->Buffer->Xmax) readWidth -= (srcX + readWidth - ctx->Buffer->Xmax - 1); if (readWidth <= 0) return GL_TRUE; /* vertical clipping */ if (srcY < ctx->Buffer->Ymin) { skipRows += (ctx->Buffer->Ymin - srcY); readHeight -= (ctx->Buffer->Ymin - srcY); srcY = ctx->Buffer->Ymin; } if (srcY + readHeight > ctx->Buffer->Ymax) readHeight -= (srcY + readHeight - ctx->Buffer->Ymax - 1); if (readHeight <= 0) return GL_TRUE; /* * Ready to read! * The window region at (destX, destY) of size (drawWidth, drawHeight) * will be read back. * We'll write pixel data to buffer pointed to by "pixels" but we'll * skip "skipRows" rows and skip "skipPixels" pixels/row. */ if (format==GL_RGBA && type==GL_UNSIGNED_BYTE) { GLubyte *dest = (GLubyte *) pixels + (skipRows * rowLength + skipPixels) * 4; GLint row; for (row=0; rowDriver.ReadRGBASpan)(ctx, readWidth, srcX, srcY, (void *) dest); dest += rowLength * 4; srcY++; } return GL_TRUE; } else { /* can't do this format/type combination */ return GL_FALSE; } } } /* * Read R, G, B, A, RGB, L, or LA pixels. */ static void read_rgba_pixels( GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels ) { GLint i, j, n, s; DEFARRAY(GLfloat, red, MAX_WIDTH); DEFARRAY(GLfloat, green, MAX_WIDTH); DEFARRAY(GLfloat, blue, MAX_WIDTH); DEFARRAY(GLfloat, alpha, MAX_WIDTH); DEFARRAY(GLfloat, luminance, MAX_WIDTH); /* number of components */ n = gl_components_in_format(format); if (n <= 0) { gl_error(ctx, GL_INVALID_ENUM, "glReadPixels(format)"); UNDEFARRAY( red ); UNDEFARRAY( green ); UNDEFARRAY( blue ); UNDEFARRAY( alpha ); UNDEFARRAY( luminance ); return; } /* Size of each component */ s = gl_sizeof_type( type ); if (s <= 0) { gl_error( ctx, GL_INVALID_ENUM, "glReadPixels(type)" ); UNDEFARRAY( red ); UNDEFARRAY( green ); UNDEFARRAY( blue ); UNDEFARRAY( alpha ); UNDEFARRAY( luminance ); return; } /* process image row by row */ for (j=0;jVisual->RGBAflag) { GLubyte rgba[MAX_WIDTH][4]; GLfloat rscale = (1.0F / 255.0F); GLfloat gscale = (1.0F / 255.0F); GLfloat bscale = (1.0F / 255.0F); GLfloat ascale = (1.0F / 255.0F); /* read colors and convert to floats */ gl_read_rgba_span(ctx, width, x, y, rgba ); for (i=0;iPixel.ScaleOrBiasRGBA) { gl_scale_and_bias_color( ctx, width, red, green, blue, alpha ); } if (ctx->Pixel.MapColorFlag) { gl_map_color( ctx, width, red, green, blue, alpha ); } } else { /* convert CI values to RGBA */ GLuint index[MAX_WIDTH]; (*ctx->Driver.ReadCI32Span)( ctx, width, x, y, index ); if (ctx->Pixel.IndexShift!=0 || ctx->Pixel.IndexOffset!=0) { gl_map_ci( ctx, width, index ); } gl_map_ci_to_color(ctx, width, index, red, green, blue, alpha); } if (format==GL_LUMINANCE || format==GL_LUMINANCE_ALPHA) { for (i=0;iPack, pixels, width, height, format, type, 0, j, 0); switch (format) { case GL_RED: for (i=0;iPack, pixels, width, height, format, type, 0, j, 0); switch (format) { case GL_RED: for (i=0;iPack, pixels, width, height, format, type, 0, j, 0); switch (format) { case GL_RED: for (i=0;iPack.SwapBytes) { gl_swap2( (GLushort *) dst, width*n ); } } break; case GL_SHORT: { GLshort *dst = (GLshort *) gl_pixel_addr_in_image(&ctx->Pack, pixels, width, height, format, type, 0, j, 0); switch (format) { case GL_RED: for (i=0;iPack.SwapBytes) { gl_swap2( (GLushort *) dst, width*n ); } } break; case GL_UNSIGNED_INT: { GLuint *dst = (GLuint *) gl_pixel_addr_in_image(&ctx->Pack, pixels, width, height, format, type, 0, j, 0); switch (format) { case GL_RED: for (i=0;iPack.SwapBytes) { gl_swap4( (GLuint *) dst, width*n ); } } break; case GL_INT: { GLint *dst = (GLint *) gl_pixel_addr_in_image(&ctx->Pack, pixels, width, height, format, type, 0, j, 0); switch (format) { case GL_RED: for (i=0;iPack.SwapBytes) { gl_swap4( (GLuint *) dst, width*n ); } } break; case GL_FLOAT: { GLfloat *dst = (GLfloat *) gl_pixel_addr_in_image(&ctx->Pack, pixels, width, height, format, type, 0, j, 0); switch (format) { case GL_RED: for (i=0;iPack.SwapBytes) { gl_swap4( (GLuint *) dst, width*n ); } } break; case GL_UNSIGNED_BYTE_3_3_2: if (format == GL_RGB) { GLubyte *dst = (GLubyte *) gl_pixel_addr_in_image(&ctx->Pack, pixels, width, height, format, type, 0, j, 0); for (i=0;iPack, pixels, width, height, format, type, 0, j, 0); for (i=0;iPack, pixels, width, height, format, type, 0, j, 0); for (i=0;iPack, pixels, width, height, format, type, 0, j, 0); for (i=0;iPack, pixels, width, height, format, type, 0, j, 0); for (i=0;iPack, pixels, width, height, format, type, 0, j, 0); for (i=0;iPack, pixels, width, height, format, type, 0, j, 0); for (i=0;iPack, pixels, width, height, format, type, 0, j, 0); for (i=0;iPack, pixels, width, height, format, type, 0, j, 0); for (i=0;iPack, pixels, width, height, format, type, 0, j, 0); for (i=0;iPack, pixels, width, height, format, type, 0, j, 0); for (i=0;iPack, pixels, width, height, format, type, 0, j, 0); for (i=0;iPack, pixels, width, height, format, type, 0, j, 0); for (i=0;iPack, pixels, width, height, format, type, 0, j, 0); for (i=0;iPack, pixels, width, height, format, type, 0, j, 0); for (i=0;iPack, pixels, width, height, format, type, 0, j, 0); for (i=0;iPack, pixels, width, height, format, type, 0, j, 0); for (i=0;iPack, pixels, width, height, format, type, 0, j, 0); for (i=0;iPack, pixels, width, height, format, type, 0, j, 0); for (i=0;iPack, pixels, width, height, format, type, 0, j, 0); for (i=0;iDriver.SetBuffer)( ctx, ctx->Pixel.ReadBuffer ); switch (format) { case GL_COLOR_INDEX: read_index_pixels( ctx, x, y, width, height, type, pixels ); break; case GL_STENCIL_INDEX: read_stencil_pixels( ctx, x, y, width, height, type, pixels ); break; case GL_DEPTH_COMPONENT: read_depth_pixels( ctx, x, y, width, height, type, pixels ); break; case GL_RED: case GL_GREEN: case GL_BLUE: case GL_ALPHA: case GL_RGB: case GL_LUMINANCE: case GL_LUMINANCE_ALPHA: case GL_RGBA: case GL_BGR: case GL_BGRA: case GL_ABGR_EXT: if (!read_fast_rgba_pixels( ctx, x, y, width, height, format, type, pixels)) read_rgba_pixels( ctx, x, y, width, height, format, type, pixels ); break; default: gl_error( ctx, GL_INVALID_ENUM, "glReadPixels(format)" ); } (void) (*ctx->Driver.SetBuffer)( ctx, ctx->Color.DrawBuffer ); }