X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fswrast%2Fs_drawpix.c;h=205022a89d63035595f0fa1eeb76983a60651b47;hb=0aa0343fb00eb1058e07d8c17bda77d73be1d71a;hp=63281b2f7309af41afa4f9504babe02db09d07ed;hpb=6532db986883ea1a431c043126de4947465834a1;p=mesa.git diff --git a/src/mesa/swrast/s_drawpix.c b/src/mesa/swrast/s_drawpix.c index 63281b2f730..205022a89d6 100644 --- a/src/mesa/swrast/s_drawpix.c +++ b/src/mesa/swrast/s_drawpix.c @@ -1,21 +1,19 @@ -/* $Id: s_drawpix.c,v 1.6 2001/01/03 15:59:30 brianp Exp $ */ - /* * Mesa 3-D graphics library - * Version: 3.5 - * - * Copyright (C) 1999-2000 Brian Paul All Rights Reserved. - * + * Version: 6.2 + * + * Copyright (C) 1999-2004 Brian Paul All Rights Reserved. + * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. - * + * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL @@ -26,13 +24,11 @@ #include "glheader.h" -#include "colormac.h" #include "context.h" #include "convolve.h" #include "image.h" #include "macros.h" -#include "mem.h" -#include "mmath.h" +#include "imports.h" #include "pixel.h" #include "s_context.h" @@ -40,7 +36,6 @@ #include "s_pixeltex.h" #include "s_span.h" #include "s_stencil.h" -#include "s_texture.h" #include "s_zoom.h" @@ -53,7 +48,7 @@ * GL_FALSE if image was completely clipped away (draw nothing) */ GLboolean -_mesa_clip_pixelrect(const GLcontext *ctx, +_swrast_clip_pixelrect(const GLcontext *ctx, GLint *destX, GLint *destY, GLsizei *width, GLsizei *height, GLint *skipPixels, GLint *skipRows) @@ -98,18 +93,28 @@ _mesa_clip_pixelrect(const GLcontext *ctx, static GLboolean fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height, - GLenum format, GLenum type, const GLvoid *pixels) + GLenum format, GLenum type, + const struct gl_pixelstore_attrib *unpack, + const GLvoid *pixels) { - const struct gl_pixelstore_attrib *unpack = &ctx->Unpack; - GLchan rgb[MAX_WIDTH][3]; - GLchan rgba[MAX_WIDTH][4]; + SWcontext *swrast = SWRAST_CONTEXT(ctx); + struct sw_span span; + + INIT_SPAN(span, GL_BITMAP, 0, 0, SPAN_RGBA); if (!ctx->Current.RasterPosValid) { return GL_TRUE; /* no-op */ } - if ((SWRAST_CONTEXT(ctx)->_RasterMask&(~(SCISSOR_BIT|WINCLIP_BIT)))==0 - && ctx->Texture._ReallyEnabled == 0 + if (ctx->Depth.Test) + _swrast_span_default_z(ctx, &span); + if (ctx->Fog.Enabled) + _swrast_span_default_fog(ctx, &span); + if (ctx->Texture._EnabledCoordUnits) + _swrast_span_default_texcoords(ctx, &span); + + if ((SWRAST_CONTEXT(ctx)->_RasterMask & ~CLIP_BIT) == 0 + && ctx->Texture._EnabledCoordUnits == 0 && unpack->Alignment == 1 && !unpack->SwapBytes && !unpack->LsbFirst) { @@ -121,7 +126,6 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, GLint skipPixels = unpack->SkipPixels; GLint skipRows = unpack->SkipRows; GLint rowLength; - GLdepth zSpan[MAX_WIDTH]; /* only used when zooming */ GLint zoomY0 = 0; if (unpack->RowLength > 0) @@ -130,7 +134,7 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, rowLength = width; /* If we're not using pixel zoom then do all clipping calculations - * now. Otherwise, we'll let the gl_write_zoomed_*_span() functions + * now. Otherwise, we'll let the _swrast_write_zoomed_*_span() functions * handle the clipping. */ if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) { @@ -181,15 +185,11 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, return GL_TRUE; } else { - /* setup array of fragment Z value to pass to zoom function */ - GLdepth z = (GLdepth) (ctx->Current.RasterPos[2] * ctx->Visual.DepthMaxF); - GLint i; - ASSERT(drawWidth < MAX_WIDTH); - for (i=0; i MAX_WIDTH) + return GL_FALSE; /* fall back to general case path */ /* save Y value of first row */ - zoomY0 = (GLint) (ctx->Current.RasterPos[1] + 0.5F); + zoomY0 = IROUND(ctx->Current.RasterPos[1]); } @@ -203,15 +203,15 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, if (format == GL_RGBA && type == CHAN_TYPE && ctx->_ImageTransferState==0) { - if (ctx->Visual.RGBAflag) { + if (ctx->Visual.rgbMode) { GLchan *src = (GLchan *) pixels + (skipRows * rowLength + skipPixels) * 4; if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) { /* no zooming */ GLint row; for (row=0; rowDriver.WriteRGBASpan)(ctx, drawWidth, destX, destY, - (void *) src, NULL); + (*swrast->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY, + (CONST GLchan (*)[4]) src, NULL); src += rowLength * 4; destY++; } @@ -221,8 +221,8 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, GLint row; for (row=0; rowDriver.WriteRGBASpan)(ctx, drawWidth, destX, destY, - (void *) src, NULL); + (*swrast->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY, + (CONST GLchan (*)[4]) src, NULL); src += rowLength * 4; } } @@ -230,8 +230,11 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, /* with zooming */ GLint row; for (row=0; row_ImageTransferState == 0) { - if (ctx->Visual.RGBAflag) { + if (ctx->Visual.rgbMode) { GLchan *src = (GLchan *) pixels + (skipRows * rowLength + skipPixels) * 3; if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) { GLint row; for (row=0; rowDriver.WriteRGBSpan)(ctx, drawWidth, destX, destY, - (void *) src, NULL); + (*swrast->Driver.WriteRGBSpan)(ctx, drawWidth, destX, destY, + (CONST GLchan (*)[3]) src, NULL); src += rowLength * 3; destY++; } @@ -258,8 +261,8 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, GLint row; for (row=0; rowDriver.WriteRGBSpan)(ctx, drawWidth, destX, destY, - (void *) src, NULL); + (*swrast->Driver.WriteRGBSpan)(ctx, drawWidth, destX, destY, + (CONST GLchan (*)[3]) src, NULL); src += rowLength * 3; } } @@ -267,8 +270,11 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, /* with zooming */ GLint row; for (row=0; row_ImageTransferState==0) { - if (ctx->Visual.RGBAflag) { + if (ctx->Visual.rgbMode) { GLchan *src = (GLchan *) pixels + (skipRows * rowLength + skipPixels); if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) { /* no zooming */ GLint row; - ASSERT(drawWidth < MAX_WIDTH); + ASSERT(drawWidth <= MAX_WIDTH); for (row=0; rowrgb[i][0] = src[i]; + span.array->rgb[i][1] = src[i]; + span.array->rgb[i][2] = src[i]; } - (*ctx->Driver.WriteRGBSpan)(ctx, drawWidth, destX, destY, - (void *) rgb, NULL); + (*swrast->Driver.WriteRGBSpan)(ctx, drawWidth, destX, destY, + (CONST GLchan (*)[3]) span.array->rgb, NULL); src += rowLength; destY++; } @@ -301,33 +307,36 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) { /* upside-down */ GLint row; - ASSERT(drawWidth < MAX_WIDTH); + ASSERT(drawWidth <= MAX_WIDTH); for (row=0; rowrgb[i][0] = src[i]; + span.array->rgb[i][1] = src[i]; + span.array->rgb[i][2] = src[i]; } destY--; - (*ctx->Driver.WriteRGBSpan)(ctx, drawWidth, destX, destY, - (void *) rgb, NULL); + (*swrast->Driver.WriteRGBSpan)(ctx, drawWidth, destX, destY, + (CONST GLchan (*)[3]) span.array->rgb, NULL); src += rowLength; } } else { /* with zooming */ GLint row; - ASSERT(drawWidth < MAX_WIDTH); + ASSERT(drawWidth <= MAX_WIDTH); for (row=0; rowrgb[i][0] = src[i]; + span.array->rgb[i][1] = src[i]; + span.array->rgb[i][2] = src[i]; } - gl_write_zoomed_rgb_span(ctx, drawWidth, destX, destY, - zSpan, 0, (void *) rgb, zoomY0); + span.x = destX; + span.y = destY; + span.end = drawWidth; + _swrast_write_zoomed_rgb_span(ctx, &span, + (CONST GLchan (*)[3]) span.array->rgb, zoomY0, 0); src += rowLength; destY++; } @@ -337,24 +346,24 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, } else if (format == GL_LUMINANCE_ALPHA && type == CHAN_TYPE && ctx->_ImageTransferState == 0) { - if (ctx->Visual.RGBAflag) { + if (ctx->Visual.rgbMode) { GLchan *src = (GLchan *) pixels + (skipRows * rowLength + skipPixels)*2; if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) { /* no zooming */ GLint row; - ASSERT(drawWidth < MAX_WIDTH); + ASSERT(drawWidth <= MAX_WIDTH); for (row=0; rowrgba[i][0] = *ptr; + span.array->rgba[i][1] = *ptr; + span.array->rgba[i][2] = *ptr++; + span.array->rgba[i][3] = *ptr++; } - (*ctx->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY, - (void *) rgba, NULL); + (*swrast->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY, + (CONST GLchan (*)[4]) span.array->rgba, NULL); src += rowLength*2; destY++; } @@ -362,37 +371,40 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) { /* upside-down */ GLint row; - ASSERT(drawWidth < MAX_WIDTH); + ASSERT(drawWidth <= MAX_WIDTH); for (row=0; rowrgba[i][0] = *ptr; + span.array->rgba[i][1] = *ptr; + span.array->rgba[i][2] = *ptr++; + span.array->rgba[i][3] = *ptr++; } destY--; - (*ctx->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY, - (void *) rgba, NULL); + (*swrast->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY, + (CONST GLchan (*)[4]) span.array->rgba, NULL); src += rowLength*2; } } else { /* with zooming */ GLint row; - ASSERT(drawWidth < MAX_WIDTH); + ASSERT(drawWidth <= MAX_WIDTH); for (row=0; rowrgba[i][0] = *ptr; + span.array->rgba[i][1] = *ptr; + span.array->rgba[i][2] = *ptr++; + span.array->rgba[i][3] = *ptr++; } - gl_write_zoomed_rgba_span(ctx, drawWidth, destX, destY, - zSpan, 0, (void *) rgba, zoomY0); + span.x = destX; + span.y = destY; + span.end = drawWidth; + _swrast_write_zoomed_rgba_span(ctx, &span, + (CONST GLchan (*)[4]) span.array->rgba, zoomY0, 0); src += rowLength*2; destY++; } @@ -402,17 +414,16 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, } else if (format==GL_COLOR_INDEX && type==GL_UNSIGNED_BYTE) { GLubyte *src = (GLubyte *) pixels + skipRows * rowLength + skipPixels; - if (ctx->Visual.RGBAflag) { + if (ctx->Visual.rgbMode) { /* convert CI data to RGBA */ if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) { /* no zooming */ GLint row; for (row=0; rowDriver.WriteRGBASpan)(ctx, drawWidth, destX, destY, - (const GLchan (*)[4]) rgba, - NULL); + ASSERT(drawWidth <= MAX_WIDTH); + _mesa_map_ci8_to_rgba(ctx, drawWidth, src, span.array->rgba); + (*swrast->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY, + (const GLchan (*)[4]) span.array->rgba, NULL); src += rowLength; destY++; } @@ -422,12 +433,11 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, /* upside-down */ GLint row; for (row=0; rowrgba); destY--; - (*ctx->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY, - (const GLchan (*)[4]) rgba, - NULL); + (*swrast->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY, + (CONST GLchan (*)[4]) span.array->rgba, NULL); src += rowLength; } return GL_TRUE; @@ -436,10 +446,13 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, /* with zooming */ GLint row; for (row=0; rowrgba); + span.x = destX; + span.y = destY; + span.end = drawWidth; + _swrast_write_zoomed_rgba_span(ctx, &span, + (CONST GLchan (*)[4]) span.array->rgba, zoomY0, 0); src += rowLength; destY++; } @@ -452,7 +465,7 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) { /* no zooming */ for (row=0; rowDriver.WriteCI8Span)(ctx, drawWidth, destX, destY, + (*swrast->Driver.WriteCI8Span)(ctx, drawWidth, destX, destY, src, NULL); src += rowLength; destY++; @@ -478,62 +491,74 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, /* - * Do glDrawPixels of index pixels. + * Draw color index image. */ static void draw_index_pixels( GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height, - GLenum type, const GLvoid *pixels ) + GLenum type, + const struct gl_pixelstore_attrib *unpack, + const GLvoid *pixels ) { const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0; - const GLint desty = y; - GLint row, drawWidth; - GLdepth zspan[MAX_WIDTH]; + GLint row, skipPixels; + struct sw_span span; - drawWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width; + INIT_SPAN(span, GL_BITMAP, 0, 0, SPAN_INDEX); - /* Fragment depth values */ - if (ctx->Depth.Test || ctx->Fog.Enabled) { - GLdepth zval = (GLdepth) (ctx->Current.RasterPos[2] * ctx->Visual.DepthMaxF); - GLint i; - for (i = 0; i < drawWidth; i++) { - zspan[i] = zval; - } - } + if (ctx->Depth.Test) + _swrast_span_default_z(ctx, &span); + if (ctx->Fog.Enabled) + _swrast_span_default_fog(ctx, &span); /* * General solution */ - for (row = 0; row < height; row++, y++) { - GLuint indexes[MAX_WIDTH]; - const GLvoid *source = _mesa_image_address(&ctx->Unpack, - pixels, width, height, GL_COLOR_INDEX, type, 0, row, 0); - _mesa_unpack_index_span(ctx, drawWidth, GL_UNSIGNED_INT, indexes, - type, source, &ctx->Unpack, - ctx->_ImageTransferState); - if (zoom) { - gl_write_zoomed_index_span(ctx, drawWidth, x, y, zspan, 0, indexes, desty); - } - else { - gl_write_index_span(ctx, drawWidth, x, y, zspan, 0, indexes, GL_BITMAP); + skipPixels = 0; + while (skipPixels < width) { + const GLint spanX = x + (zoom ? 0 : skipPixels); + GLint spanY = y; + const GLint spanEnd = (width - skipPixels > MAX_WIDTH) + ? MAX_WIDTH : (width - skipPixels); + ASSERT(spanEnd <= MAX_WIDTH); + for (row = 0; row < height; row++, spanY++) { + const GLvoid *source = _mesa_image_address(unpack, pixels, + width, height, + GL_COLOR_INDEX, type, + 0, row, skipPixels); + _mesa_unpack_index_span(ctx, spanEnd, GL_UNSIGNED_INT, + span.array->index, type, source, unpack, + ctx->_ImageTransferState); + + /* These may get changed during writing/clipping */ + span.x = spanX; + span.y = spanY; + span.end = spanEnd; + + if (zoom) + _swrast_write_zoomed_index_span(ctx, &span, y, skipPixels); + else + _swrast_write_index_span(ctx, &span); } + skipPixels += spanEnd; } } /* - * Do glDrawPixels of stencil image. The image datatype may either - * be GLubyte or GLbitmap. + * Draw stencil image. */ -static void +static void draw_stencil_pixels( GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height, - GLenum type, const GLvoid *pixels ) + GLenum type, + const struct gl_pixelstore_attrib *unpack, + const GLvoid *pixels ) { const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0; const GLint desty = y; - GLint row, drawWidth; + GLint row, skipPixels; if (type != GL_BYTE && type != GL_UNSIGNED_BYTE && @@ -543,54 +568,71 @@ draw_stencil_pixels( GLcontext *ctx, GLint x, GLint y, type != GL_UNSIGNED_INT && type != GL_FLOAT && type != GL_BITMAP) { - gl_error( ctx, GL_INVALID_ENUM, "glDrawPixels(stencil type)"); + _mesa_error( ctx, GL_INVALID_ENUM, "glDrawPixels(stencil type)"); return; } - drawWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width; - - for (row = 0; row < height; row++, y++) { - GLstencil values[MAX_WIDTH]; - GLenum destType = (sizeof(GLstencil) == sizeof(GLubyte)) - ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT; - const GLvoid *source = _mesa_image_address(&ctx->Unpack, - pixels, width, height, GL_COLOR_INDEX, type, 0, row, 0); - _mesa_unpack_index_span(ctx, drawWidth, destType, values, - type, source, &ctx->Unpack, - ctx->_ImageTransferState); - if (ctx->_ImageTransferState & IMAGE_SHIFT_OFFSET_BIT) { - _mesa_shift_and_offset_stencil( ctx, drawWidth, values ); - } - if (ctx->Pixel.MapStencilFlag) { - _mesa_map_stencil( ctx, drawWidth, values ); - } + if (ctx->Visual.stencilBits == 0) { + _mesa_error( ctx, GL_INVALID_OPERATION, "glDrawPixels(no stencil buffer)"); + return; + } - if (zoom) { - gl_write_zoomed_stencil_span( ctx, (GLuint) drawWidth, x, y, - values, desty ); - } - else { - _mesa_write_stencil_span( ctx, (GLuint) drawWidth, x, y, values ); + /* if width > MAX_WIDTH, have to process image in chunks */ + skipPixels = 0; + while (skipPixels < width) { + const GLint spanX = x; + GLint spanY = y; + const GLint spanWidth = (width - skipPixels > MAX_WIDTH) + ? MAX_WIDTH : (width - skipPixels); + + for (row = 0; row < height; row++, spanY++) { + GLstencil values[MAX_WIDTH]; + GLenum destType = (sizeof(GLstencil) == sizeof(GLubyte)) + ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT; + const GLvoid *source = _mesa_image_address(unpack, pixels, + width, height, + GL_COLOR_INDEX, type, + 0, row, skipPixels); + _mesa_unpack_index_span(ctx, spanWidth, destType, values, + type, source, unpack, + ctx->_ImageTransferState); + if (ctx->_ImageTransferState & IMAGE_SHIFT_OFFSET_BIT) { + _mesa_shift_and_offset_stencil(ctx, spanWidth, values); + } + if (ctx->Pixel.MapStencilFlag) { + _mesa_map_stencil(ctx, spanWidth, values); + } + + if (zoom) { + _swrast_write_zoomed_stencil_span(ctx, (GLuint) spanWidth, + spanX, spanY, values, desty, 0); + } + else { + _swrast_write_stencil_span(ctx, (GLuint) spanWidth, + spanX, spanY, values); + } } + skipPixels += spanWidth; } } - /* - * Do a glDrawPixels of depth values. + * Draw depth image. */ static void draw_depth_pixels( GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height, - GLenum type, const GLvoid *pixels ) + GLenum type, + const struct gl_pixelstore_attrib *unpack, + const GLvoid *pixels ) { const GLboolean bias_or_scale = ctx->Pixel.DepthBias!=0.0 || ctx->Pixel.DepthScale!=1.0; - const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0; + const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0; const GLint desty = y; - GLchan rgba[MAX_WIDTH][4]; - GLuint ispan[MAX_WIDTH]; - GLint drawWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width; + struct sw_span span; + + INIT_SPAN(span, GL_BITMAP, 0, 0, SPAN_Z); if (type != GL_BYTE && type != GL_UNSIGNED_BYTE @@ -599,129 +641,156 @@ draw_depth_pixels( GLcontext *ctx, GLint x, GLint y, && type != GL_INT && type != GL_UNSIGNED_INT && type != GL_FLOAT) { - gl_error(ctx, GL_INVALID_ENUM, "glDrawPixels(type)"); + _mesa_error(ctx, GL_INVALID_ENUM, "glDrawPixels(type)"); return; } - /* Colors or indexes */ - if (ctx->Visual.RGBAflag) { - GLint i; - GLint r, g, b, a; - UNCLAMPED_FLOAT_TO_CHAN(r, ctx->Current.RasterColor[0]); - UNCLAMPED_FLOAT_TO_CHAN(g, ctx->Current.RasterColor[1]); - UNCLAMPED_FLOAT_TO_CHAN(b, ctx->Current.RasterColor[2]); - UNCLAMPED_FLOAT_TO_CHAN(a, ctx->Current.RasterColor[3]); - for (i = 0; i < drawWidth; i++) { - rgba[i][RCOMP] = r; - rgba[i][GCOMP] = g; - rgba[i][BCOMP] = b; - rgba[i][ACOMP] = a; - } - } - else { - GLint i; - for (i = 0; i < drawWidth; i++) { - ispan[i] = ctx->Current.RasterIndex; - } - } + _swrast_span_default_color(ctx, &span); - if (type==GL_UNSIGNED_SHORT && sizeof(GLdepth)==sizeof(GLushort) - && !bias_or_scale && !zoom && ctx->Visual.RGBAflag) { + if (ctx->Fog.Enabled) + _swrast_span_default_fog(ctx, &span); + if (ctx->Texture._EnabledCoordUnits) + _swrast_span_default_texcoords(ctx, &span); + + if (type == GL_UNSIGNED_SHORT + && ctx->Visual.depthBits == 16 + && !bias_or_scale + && !zoom + && ctx->Visual.rgbMode + && width <= MAX_WIDTH) { /* Special case: directly write 16-bit depth values */ - GLint row; - for (row = 0; row < height; row++, y++) { - GLdepth zspan[MAX_WIDTH]; - const GLushort *zptr = _mesa_image_address(&ctx->Unpack, - pixels, width, height, GL_DEPTH_COMPONENT, type, 0, row, 0); + GLint row, spanY = y; + for (row = 0; row < height; row++, spanY++) { + const GLushort *zSrc = (const GLushort *) + _mesa_image_address(unpack, pixels, width, height, + GL_DEPTH_COMPONENT, type, 0, row, 0); GLint i; for (i = 0; i < width; i++) - zspan[i] = zptr[i]; - gl_write_rgba_span( ctx, width, x, y, zspan, 0, rgba, GL_BITMAP ); + span.array->z[i] = zSrc[i]; + span.x = x; + span.y = spanY; + span.end = width; + _swrast_write_rgba_span(ctx, &span); } } - else if (type==GL_UNSIGNED_INT && ctx->Visual.DepthBits == 32 - && !bias_or_scale && !zoom && ctx->Visual.RGBAflag) { - /* Special case: directly write 32-bit depth values */ - GLint row; - for (row = 0; row < height; row++, y++) { - const GLuint *zptr = _mesa_image_address(&ctx->Unpack, - pixels, width, height, GL_DEPTH_COMPONENT, type, 0, row, 0); - gl_write_rgba_span( ctx, width, x, y, zptr, 0, rgba, GL_BITMAP ); + else if (type == GL_UNSIGNED_INT + && sizeof(GLdepth) == 4 + && !bias_or_scale + && !zoom + && ctx->Visual.rgbMode + && width <= MAX_WIDTH) { + /* Special case: shift 32-bit values down to ctx->Visual.depthBits */ + const GLint shift = 32 - ctx->Visual.depthBits; + GLint row, spanY = y; + for (row = 0; row < height; row++, spanY++) { + const GLuint *zSrc = (const GLuint *) + _mesa_image_address(unpack, pixels, width, height, + GL_DEPTH_COMPONENT, type, 0, row, 0); + if (shift == 0) { + MEMCPY(span.array->z, zSrc, width * sizeof(GLdepth)); + } + else { + GLint col; + for (col = 0; col < width; col++) + span.array->z[col] = zSrc[col] >> shift; + } + span.x = x; + span.y = spanY; + span.end = width; + _swrast_write_rgba_span(ctx, &span); } } else { /* General case */ - GLint row; - for (row = 0; row < height; row++, y++) { - GLdepth zspan[MAX_WIDTH]; - const GLvoid *src = _mesa_image_address(&ctx->Unpack, - pixels, width, height, GL_DEPTH_COMPONENT, type, 0, row, 0); - _mesa_unpack_depth_span( ctx, drawWidth, zspan, type, src, - &ctx->Unpack, ctx->_ImageTransferState ); - if (ctx->Visual.RGBAflag) { - if (zoom) { - gl_write_zoomed_rgba_span(ctx, width, x, y, zspan, 0, - (const GLchan (*)[4]) rgba, desty); - } - else { - gl_write_rgba_span(ctx, width, x, y, zspan, 0, rgba, GL_BITMAP); + GLint row, skipPixels = 0; + + /* in case width > MAX_WIDTH do the copy in chunks */ + while (skipPixels < width) { + const GLint spanX = x + (zoom ? 0 : skipPixels); + GLint spanY = y; + const GLint spanEnd = (width - skipPixels > MAX_WIDTH) + ? MAX_WIDTH : (width - skipPixels); + ASSERT(span.end <= MAX_WIDTH); + for (row = 0; row < height; row++, spanY++) { + GLfloat floatSpan[MAX_WIDTH]; + const GLvoid *zSrc = _mesa_image_address(unpack, + pixels, width, height, + GL_DEPTH_COMPONENT, type, + 0, row, skipPixels); + + /* Set these for each row since the _swrast_write_* function may + * change them while clipping. + */ + span.x = spanX; + span.y = spanY; + span.end = spanEnd; + + _mesa_unpack_depth_span(ctx, span.end, floatSpan, type, + zSrc, unpack); + /* clamp depth values to [0,1] and convert from floats to ints */ + { + const GLfloat zScale = ctx->DepthMaxF; + GLuint i; + for (i = 0; i < span.end; i++) { + span.array->z[i] = (GLdepth) (floatSpan[i] * zScale); + } } - } - else { if (zoom) { - gl_write_zoomed_index_span(ctx, width, x, y, zspan, 0, - ispan, GL_BITMAP); + _swrast_write_zoomed_depth_span(ctx, &span, desty, skipPixels); + } + else if (ctx->Visual.rgbMode) { + _swrast_write_rgba_span(ctx, &span); } else { - gl_write_index_span(ctx, width, x, y, zspan, 0, - ispan, GL_BITMAP); + _swrast_write_index_span(ctx, &span); } } - + skipPixels += spanEnd; } } } + /* - * Do glDrawPixels of RGBA pixels. + * Draw RGBA image. */ static void draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height, - GLenum format, GLenum type, const GLvoid *pixels ) + GLenum format, GLenum type, + const struct gl_pixelstore_attrib *unpack, + const GLvoid *pixels ) { - const struct gl_pixelstore_attrib *unpack = &ctx->Unpack; + SWcontext *swrast = SWRAST_CONTEXT(ctx); const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0; const GLint desty = y; - GLdepth zspan[MAX_WIDTH]; GLboolean quickDraw; GLfloat *convImage = NULL; GLuint transferOps = ctx->_ImageTransferState; + struct sw_span span; + + INIT_SPAN(span, GL_BITMAP, 0, 0, SPAN_RGBA); - if (!_mesa_is_legal_format_and_type(format, type)) { - gl_error(ctx, GL_INVALID_ENUM, "glDrawPixels(format or type)"); + if (!_mesa_is_legal_format_and_type(ctx, format, type)) { + _mesa_error(ctx, GL_INVALID_ENUM, "glDrawPixels(format or type)"); return; } /* Try an optimized glDrawPixels first */ - if (fast_draw_pixels(ctx, x, y, width, height, format, type, pixels)) + if (fast_draw_pixels(ctx, x, y, width, height, format, type, unpack, pixels)) return; - /* Fragment depth values */ - if (ctx->Depth.Test || ctx->Fog.Enabled) { - /* fill in array of z values */ - GLdepth z = (GLdepth) (ctx->Current.RasterPos[2] * ctx->Visual.DepthMaxF); - GLint i; - for (i=0;iDepth.Test) + _swrast_span_default_z(ctx, &span); + if (ctx->Fog.Enabled) + _swrast_span_default_fog(ctx, &span); + if (ctx->Texture._EnabledCoordUnits) + _swrast_span_default_texcoords(ctx, &span); if (SWRAST_CONTEXT(ctx)->_RasterMask == 0 && !zoom && x >= 0 && y >= 0 - && x + width <= ctx->DrawBuffer->Width - && y + height <= ctx->DrawBuffer->Height) { + && x + width <= (GLint) ctx->DrawBuffer->Width + && y + height <= (GLint) ctx->DrawBuffer->Height) { quickDraw = GL_TRUE; } else { @@ -738,15 +807,15 @@ draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y, GLint row; GLfloat *dest, *tmpImage; - tmpImage = (GLfloat *) MALLOC(width * height * 4 * sizeof(GLfloat)); + tmpImage = (GLfloat *) _mesa_malloc(width * height * 4 * sizeof(GLfloat)); if (!tmpImage) { - gl_error(ctx, GL_OUT_OF_MEMORY, "glDrawPixels"); + _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDrawPixels"); return; } - convImage = (GLfloat *) MALLOC(width * height * 4 * sizeof(GLfloat)); + convImage = (GLfloat *) _mesa_malloc(width * height * 4 * sizeof(GLfloat)); if (!convImage) { - FREE(tmpImage); - gl_error(ctx, GL_OUT_OF_MEMORY, "glDrawPixels"); + _mesa_free(tmpImage); + _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDrawPixels"); return; } @@ -755,10 +824,9 @@ draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y, for (row = 0; row < height; row++) { const GLvoid *source = _mesa_image_address(unpack, pixels, width, height, format, type, 0, row, 0); - _mesa_unpack_float_color_span(ctx, width, GL_RGBA, (void *) dest, - format, type, source, unpack, - transferOps & IMAGE_PRE_CONVOLUTION_BITS, - GL_FALSE); + _mesa_unpack_color_span_float(ctx, width, GL_RGBA, (GLfloat *) dest, + format, type, source, unpack, + transferOps & IMAGE_PRE_CONVOLUTION_BITS); dest += width * 4; } @@ -770,10 +838,10 @@ draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y, ASSERT(ctx->Pixel.Separable2DEnabled); _mesa_convolve_sep_image(ctx, &width, &height, tmpImage, convImage); } - FREE(tmpImage); + _mesa_free(tmpImage); /* continue transfer ops and draw the convolved image */ - unpack = &_mesa_native_packing; + unpack = &ctx->DefaultPacking; pixels = convImage; format = GL_RGBA; type = GL_FLOAT; @@ -784,55 +852,64 @@ draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y, * General solution */ { - GLchan rgba[MAX_WIDTH][4]; - GLint row; - if (width > MAX_WIDTH) - width = MAX_WIDTH; - for (row = 0; row < height; row++, y++) { - const GLvoid *source = _mesa_image_address(unpack, - pixels, width, height, format, type, 0, row, 0); - _mesa_unpack_chan_color_span(ctx, width, GL_RGBA, (void*) rgba, - format, type, source, unpack, - transferOps); - if ((ctx->Pixel.MinMaxEnabled && ctx->MinMax.Sink) || - (ctx->Pixel.HistogramEnabled && ctx->Histogram.Sink)) - continue; - - if (ctx->Texture._ReallyEnabled && ctx->Pixel.PixelTextureEnabled) { - GLfloat s[MAX_WIDTH], t[MAX_WIDTH], r[MAX_WIDTH], q[MAX_WIDTH]; - GLchan primary_rgba[MAX_WIDTH][4]; - GLuint unit; - /* XXX not sure how multitexture is supposed to work here */ - - MEMCPY(primary_rgba, rgba, 4 * width * sizeof(GLchan)); - - for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { - if (ctx->Texture.Unit[unit]._ReallyEnabled) { - _mesa_pixeltexgen(ctx, width, (const GLchan (*)[4]) rgba, - s, t, r, q); - gl_texture_pixels(ctx, unit, width, s, t, r, NULL, - primary_rgba, rgba); - } + const GLuint interpMask = span.interpMask; + const GLuint arrayMask = span.arrayMask; + GLint row, skipPixels = 0; + + /* if the span is wider than MAX_WIDTH we have to do it in chunks */ + while (skipPixels < width) { + const GLint spanX = x + (zoom ? 0 : skipPixels); + GLint spanY = y; + const GLint spanEnd = (width - skipPixels > MAX_WIDTH) + ? MAX_WIDTH : (width - skipPixels); + ASSERT(span.end <= MAX_WIDTH); + + for (row = 0; row < height; row++, spanY++) { + const GLvoid *source = _mesa_image_address(unpack, + pixels, width, height, format, type, 0, row, skipPixels); + + /* Set these for each row since the _swrast_write_* function may + * change them while clipping. + */ + span.x = spanX; + span.y = spanY; + span.end = spanEnd; + span.arrayMask = arrayMask; + span.interpMask = interpMask; + + _mesa_unpack_color_span_chan(ctx, span.end, GL_RGBA, + (GLchan *) span.array->rgba, + format, type, source, unpack, + transferOps); + + if ((ctx->Pixel.MinMaxEnabled && ctx->MinMax.Sink) || + (ctx->Pixel.HistogramEnabled && ctx->Histogram.Sink)) + continue; + + if (ctx->Pixel.PixelTextureEnabled && ctx->Texture._EnabledUnits) { + _swrast_pixel_texture(ctx, &span); } - } - if (quickDraw) { - (*ctx->Driver.WriteRGBASpan)( ctx, width, x, y, - (CONST GLchan (*)[]) rgba, NULL); - } - else if (zoom) { - gl_write_zoomed_rgba_span( ctx, width, x, y, zspan, 0, - (CONST GLchan (*)[]) rgba, desty ); - } - else { - gl_write_rgba_span( ctx, (GLuint) width, x, y, zspan, 0, - rgba, GL_BITMAP); + /* draw the span */ + if (quickDraw) { + (*swrast->Driver.WriteRGBASpan)(ctx, span.end, span.x, span.y, + (CONST GLchan (*)[4]) span.array->rgba, NULL); + } + else if (zoom) { + _swrast_write_zoomed_rgba_span(ctx, &span, + (CONST GLchan (*)[4]) span.array->rgba, desty, skipPixels); + } + else { + _swrast_write_rgba_span(ctx, &span); + } } + + skipPixels += spanEnd; } } if (convImage) { - FREE(convImage); + _mesa_free(convImage); } } @@ -842,30 +919,37 @@ draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y, * Execute glDrawPixels */ void -_swrast_DrawPixels( GLcontext *ctx, +_swrast_DrawPixels( GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height, - GLenum format, GLenum type, + GLenum format, GLenum type, const struct gl_pixelstore_attrib *unpack, const GLvoid *pixels ) { - (void) unpack; + SWcontext *swrast = SWRAST_CONTEXT(ctx); - if (SWRAST_CONTEXT(ctx)->NewState) + if (swrast->NewState) _swrast_validate_derived( ctx ); + pixels = _swrast_validate_pbo_access(unpack, width, height, 1, + format, type, (GLvoid *) pixels); + if (!pixels) + return; + + RENDER_START(swrast,ctx); + switch (format) { case GL_STENCIL_INDEX: - draw_stencil_pixels( ctx, x, y, width, height, type, pixels ); + draw_stencil_pixels( ctx, x, y, width, height, type, unpack, pixels ); break; case GL_DEPTH_COMPONENT: - draw_depth_pixels( ctx, x, y, width, height, type, pixels ); + draw_depth_pixels( ctx, x, y, width, height, type, unpack, pixels ); break; case GL_COLOR_INDEX: - if (ctx->Visual.RGBAflag) - draw_rgba_pixels(ctx, x,y, width, height, format, type, pixels); + if (ctx->Visual.rgbMode) + draw_rgba_pixels(ctx, x,y, width, height, format, type, unpack, pixels); else - draw_index_pixels(ctx, x, y, width, height, type, pixels); + draw_index_pixels(ctx, x, y, width, height, type, unpack, pixels); break; case GL_RED: case GL_GREEN: @@ -878,10 +962,62 @@ _swrast_DrawPixels( GLcontext *ctx, case GL_RGBA: case GL_BGRA: case GL_ABGR_EXT: - draw_rgba_pixels(ctx, x, y, width, height, format, type, pixels); + draw_rgba_pixels(ctx, x, y, width, height, format, type, unpack, pixels); break; default: - gl_error( ctx, GL_INVALID_ENUM, "glDrawPixels(format)" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glDrawPixels(format)" ); } + + RENDER_FINISH(swrast,ctx); } + + +#if 0 /* experimental */ +/* + * Execute glDrawDepthPixelsMESA(). + */ +void +_swrast_DrawDepthPixelsMESA( GLcontext *ctx, + GLint x, GLint y, + GLsizei width, GLsizei height, + GLenum colorFormat, GLenum colorType, + const GLvoid *colors, + GLenum depthType, const GLvoid *depths, + const struct gl_pixelstore_attrib *unpack ) +{ + SWcontext *swrast = SWRAST_CONTEXT(ctx); + + if (swrast->NewState) + _swrast_validate_derived( ctx ); + + RENDER_START(swrast,ctx); + + switch (colorFormat) { + case GL_COLOR_INDEX: + if (ctx->Visual.rgbMode) + draw_rgba_pixels(ctx, x,y, width, height, colorFormat, colorType, unpack, colors); + else + draw_index_pixels(ctx, x, y, width, height, colorType, unpack, colors); + break; + case GL_RED: + case GL_GREEN: + case GL_BLUE: + case GL_ALPHA: + case GL_LUMINANCE: + case GL_LUMINANCE_ALPHA: + case GL_RGB: + case GL_BGR: + case GL_RGBA: + case GL_BGRA: + case GL_ABGR_EXT: + draw_rgba_pixels(ctx, x, y, width, height, colorFormat, colorType, unpack, colors); + break; + default: + _mesa_error( ctx, GL_INVALID_ENUM, + "glDrawDepthPixelsMESA(colorFormat)" ); + } + + RENDER_FINISH(swrast,ctx); +} +#endif