xserver and mesa git update 28-12-2010

1 files changed, 720 insertions, 827 deletions

diff --git a/mesalib/src/mesa/swrast/s_copypix.c b/mesalib/src/mesa/swrast/s_copypix.c
index f4f0c8a33..e249e4ad5 100644
--- a/mesalib/src/mesa/swrast/s_copypix.c
+++ b/mesalib/src/mesa/swrast/s_copypix.c
@@ -1,827 +1,720 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.1
- *
- * Copyright (C) 1999-2007  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
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-
-#include "main/glheader.h"
-#include "main/context.h"
-#include "main/colormac.h"
-#include "main/condrender.h"
-#include "main/convolve.h"
-#include "main/image.h"
-#include "main/macros.h"
-#include "main/imports.h"
-
-#include "s_context.h"
-#include "s_depth.h"
-#include "s_span.h"
-#include "s_stencil.h"
-#include "s_zoom.h"
-
-
-
-/**
- * Determine if there's overlap in an image copy.
- * This test also compensates for the fact that copies are done from
- * bottom to top and overlaps can sometimes be handled correctly
- * without making a temporary image copy.
- * \return GL_TRUE if the regions overlap, GL_FALSE otherwise.
- */
-static GLboolean
-regions_overlap(GLint srcx, GLint srcy,
-                GLint dstx, GLint dsty,
-                GLint width, GLint height,
-                GLfloat zoomX, GLfloat zoomY)
-{
-   if (zoomX == 1.0 && zoomY == 1.0) {
-      /* no zoom */
-      if (srcx >= dstx + width || (srcx + width <= dstx)) {
-         return GL_FALSE;
-      }
-      else if (srcy < dsty) { /* this is OK */
-         return GL_FALSE;
-      }
-      else if (srcy > dsty + height) {
-         return GL_FALSE;
-      }
-      else {
-         return GL_TRUE;
-      }
-   }
-   else {
-      /* add one pixel of slop when zooming, just to be safe */
-      if (srcx > (dstx + ((zoomX > 0.0F) ? (width * zoomX + 1.0F) : 0.0F))) {
-         /* src is completely right of dest */
-         return GL_FALSE;
-      }
-      else if (srcx + width + 1.0F < dstx + ((zoomX > 0.0F) ? 0.0F : (width * zoomX))) {
-         /* src is completely left of dest */
-         return GL_FALSE;
-      }
-      else if ((srcy < dsty) && (srcy + height < dsty + (height * zoomY))) {
-         /* src is completely below dest */
-         return GL_FALSE;
-      }
-      else if ((srcy > dsty) && (srcy + height > dsty + (height * zoomY))) {
-         /* src is completely above dest */
-         return GL_FALSE;
-      }
-      else {
-         return GL_TRUE;
-      }
-   }
-}
-
-
-/**
- * RGBA copypixels with convolution.
- */
-static void
-copy_conv_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
-                      GLint width, GLint height, GLint destx, GLint desty)
-{
-   GLint row;
-   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
-   const GLbitfield transferOps = ctx->_ImageTransferState;
-   const GLboolean sink = (ctx->Pixel.MinMaxEnabled && ctx->MinMax.Sink)
-      || (ctx->Pixel.HistogramEnabled && ctx->Histogram.Sink);
-   GLfloat *dest, *tmpImage, *convImage;
-   SWspan span;
-
-   INIT_SPAN(span, GL_BITMAP);
-   _swrast_span_default_attribs(ctx, &span);
-   span.arrayMask = SPAN_RGBA;
-   span.arrayAttribs = FRAG_BIT_COL0;
-
-   /* allocate space for GLfloat image */
-   tmpImage = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
-   if (!tmpImage) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");
-      return;
-   }
-   convImage = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
-   if (!convImage) {
-      free(tmpImage);
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");
-      return;
-   }
-
-   /* read source image as float/RGBA */
-   dest = tmpImage;
-   for (row = 0; row < height; row++) {
-      _swrast_read_rgba_span(ctx, ctx->ReadBuffer->_ColorReadBuffer,
-                             width, srcx, srcy + row, GL_FLOAT, dest);
-      dest += 4 * width;
-   }
-
-   /* do the image transfer ops which preceed convolution */
-   for (row = 0; row < height; row++) {
-      GLfloat (*rgba)[4] = (GLfloat (*)[4]) (tmpImage + row * width * 4);
-      _mesa_apply_rgba_transfer_ops(ctx,
-                                    transferOps & IMAGE_PRE_CONVOLUTION_BITS,
-                                    width, rgba);
-   }
-
-   /* do convolution */
-   if (ctx->Pixel.Convolution2DEnabled) {
-      _mesa_convolve_2d_image(ctx, &width, &height, tmpImage, convImage);
-   }
-   else {
-      ASSERT(ctx->Pixel.Separable2DEnabled);
-      _mesa_convolve_sep_image(ctx, &width, &height, tmpImage, convImage);
-   }
-   free(tmpImage);
-
-   /* do remaining post-convolution image transfer ops */
-   for (row = 0; row < height; row++) {
-      GLfloat (*rgba)[4] = (GLfloat (*)[4]) (convImage + row * width * 4);
-      _mesa_apply_rgba_transfer_ops(ctx,
-                                    transferOps & IMAGE_POST_CONVOLUTION_BITS,
-                                    width, rgba);
-   }
-
-   if (!sink) {
-      /* write the new image */
-      for (row = 0; row < height; row++) {
-         const GLfloat *src = convImage + row * width * 4;
-         GLfloat *rgba = (GLfloat *) span.array->attribs[FRAG_ATTRIB_COL0];
-
-         /* copy convolved colors into span array */
-         memcpy(rgba, src, width * 4 * sizeof(GLfloat));
-
-         /* write span */
-         span.x = destx;
-         span.y = desty + row;
-         span.end = width;
-         span.array->ChanType = GL_FLOAT;
-         if (zoom) {
-            _swrast_write_zoomed_rgba_span(ctx, destx, desty, &span, rgba);
-         }
-         else {
-            _swrast_write_rgba_span(ctx, &span);
-         }
-      }
-      /* restore this */
-      span.array->ChanType = CHAN_TYPE;
-   }
-
-   free(convImage);
-}
-
-
-/**
- * RGBA copypixels
- */
-static void
-copy_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
-                 GLint width, GLint height, GLint destx, GLint desty)
-{
-   GLfloat *tmpImage, *p;
-   GLint sy, dy, stepy, row;
-   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
-   GLint overlapping;
-   GLuint transferOps = ctx->_ImageTransferState;
-   SWspan span;
-
-   if (!ctx->ReadBuffer->_ColorReadBuffer) {
-      /* no readbuffer - OK */
-      return;
-   }
-
-   if (ctx->Pixel.Convolution2DEnabled || ctx->Pixel.Separable2DEnabled) {
-      copy_conv_rgba_pixels(ctx, srcx, srcy, width, height, destx, desty);
-      return;
-   }
-   else if (ctx->Pixel.Convolution1DEnabled) {
-      /* make sure we don't apply 1D convolution */
-      transferOps &= ~(IMAGE_CONVOLUTION_BIT |
-                       IMAGE_POST_CONVOLUTION_SCALE_BIAS);
-   }
-
-   if (ctx->DrawBuffer == ctx->ReadBuffer) {
-      overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
-                                    ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
-   }
-   else {
-      overlapping = GL_FALSE;
-   }
-
-   /* Determine if copy should be done bottom-to-top or top-to-bottom */
-   if (!overlapping && srcy < desty) {
-      /* top-down  max-to-min */
-      sy = srcy + height - 1;
-      dy = desty + height - 1;
-      stepy = -1;
-   }
-   else {
-      /* bottom-up  min-to-max */
-      sy = srcy;
-      dy = desty;
-      stepy = 1;
-   }
-
-   INIT_SPAN(span, GL_BITMAP);
-   _swrast_span_default_attribs(ctx, &span);
-   span.arrayMask = SPAN_RGBA;
-   span.arrayAttribs = FRAG_BIT_COL0; /* we'll fill in COL0 attrib values */
-
-   if (overlapping) {
-      tmpImage = (GLfloat *) malloc(width * height * sizeof(GLfloat) * 4);
-      if (!tmpImage) {
-         _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
-         return;
-      }
-      /* read the source image as RGBA/float */
-      p = tmpImage;
-      for (row = 0; row < height; row++) {
-         _swrast_read_rgba_span( ctx, ctx->ReadBuffer->_ColorReadBuffer,
-                                 width, srcx, sy + row, GL_FLOAT, p );
-         p += width * 4;
-      }
-      p = tmpImage;
-   }
-   else {
-      tmpImage = NULL;  /* silence compiler warnings */
-      p = NULL;
-   }
-
-   ASSERT(width < MAX_WIDTH);
-
-   for (row = 0; row < height; row++, sy += stepy, dy += stepy) {
-      GLvoid *rgba = span.array->attribs[FRAG_ATTRIB_COL0];
-
-      /* Get row/span of source pixels */
-      if (overlapping) {
-         /* get from buffered image */
-         memcpy(rgba, p, width * sizeof(GLfloat) * 4);
-         p += width * 4;
-      }
-      else {
-         /* get from framebuffer */
-         _swrast_read_rgba_span( ctx, ctx->ReadBuffer->_ColorReadBuffer,
-                                 width, srcx, sy, GL_FLOAT, rgba );
-      }
-
-      if (transferOps) {
-         _mesa_apply_rgba_transfer_ops(ctx, transferOps, width,
-                                       (GLfloat (*)[4]) rgba);
-      }
-
-      /* Write color span */
-      span.x = destx;
-      span.y = dy;
-      span.end = width;
-      span.array->ChanType = GL_FLOAT;
-      if (zoom) {
-         _swrast_write_zoomed_rgba_span(ctx, destx, desty, &span, rgba);
-      }
-      else {
-         _swrast_write_rgba_span(ctx, &span);
-      }
-   }
-
-   span.array->ChanType = CHAN_TYPE; /* restore */
-
-   if (overlapping)
-      free(tmpImage);
-}
-
-
-/**
- * Convert floating point Z values to integer Z values with pixel transfer's
- * Z scale and bias.
- */
-static void
-scale_and_bias_z(GLcontext *ctx, GLuint width,
-                 const GLfloat depth[], GLuint z[])
-{
-   const GLuint depthMax = ctx->DrawBuffer->_DepthMax;
-   GLuint i;
-
-   if (depthMax <= 0xffffff &&
-       ctx->Pixel.DepthScale == 1.0 &&
-       ctx->Pixel.DepthBias == 0.0) {
-      /* no scale or bias and no clamping and no worry of overflow */
-      const GLfloat depthMaxF = ctx->DrawBuffer->_DepthMaxF;
-      for (i = 0; i < width; i++) {
-         z[i] = (GLuint) (depth[i] * depthMaxF);
-      }
-   }
-   else {
-      /* need to be careful with overflow */
-      const GLdouble depthMaxF = ctx->DrawBuffer->_DepthMaxF;
-      for (i = 0; i < width; i++) {
-         GLdouble d = depth[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
-         d = CLAMP(d, 0.0, 1.0) * depthMaxF;
-         if (d >= depthMaxF)
-            z[i] = depthMax;
-         else
-            z[i] = (GLuint) d;
-      }
-   }
-}
-
-
-
-/*
- * TODO: Optimize!!!!
- */
-static void
-copy_depth_pixels( GLcontext *ctx, GLint srcx, GLint srcy,
-                   GLint width, GLint height,
-                   GLint destx, GLint desty )
-{
-   struct gl_framebuffer *fb = ctx->ReadBuffer;
-   struct gl_renderbuffer *readRb = fb->_DepthBuffer;
-   GLfloat *p, *tmpImage;
-   GLint sy, dy, stepy;
-   GLint j;
-   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
-   GLint overlapping;
-   SWspan span;
-
-   if (!readRb) {
-      /* no readbuffer - OK */
-      return;
-   }
-
-   INIT_SPAN(span, GL_BITMAP);
-   _swrast_span_default_attribs(ctx, &span);
-   span.arrayMask = SPAN_Z;
-
-   if (ctx->DrawBuffer == ctx->ReadBuffer) {
-      overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
-                                    ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
-   }
-   else {
-      overlapping = GL_FALSE;
-   }
-
-   /* Determine if copy should be bottom-to-top or top-to-bottom */
-   if (!overlapping && srcy < desty) {
-      /* top-down  max-to-min */
-      sy = srcy + height - 1;
-      dy = desty + height - 1;
-      stepy = -1;
-   }
-   else {
-      /* bottom-up  min-to-max */
-      sy = srcy;
-      dy = desty;
-      stepy = 1;
-   }
-
-   if (overlapping) {
-      GLint ssy = sy;
-      tmpImage = (GLfloat *) malloc(width * height * sizeof(GLfloat));
-      if (!tmpImage) {
-         _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
-         return;
-      }
-      p = tmpImage;
-      for (j = 0; j < height; j++, ssy += stepy) {
-         _swrast_read_depth_span_float(ctx, readRb, width, srcx, ssy, p);
-         p += width;
-      }
-      p = tmpImage;
-   }
-   else {
-      tmpImage = NULL;  /* silence compiler warning */
-      p = NULL;
-   }
-
-   for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
-      GLfloat depth[MAX_WIDTH];
-      /* get depth values */
-      if (overlapping) {
-         memcpy(depth, p, width * sizeof(GLfloat));
-         p += width;
-      }
-      else {
-         _swrast_read_depth_span_float(ctx, readRb, width, srcx, sy, depth);
-      }
-
-      /* apply scale and bias */
-      scale_and_bias_z(ctx, width, depth, span.array->z);
-
-      /* write depth values */
-      span.x = destx;
-      span.y = dy;
-      span.end = width;
-      if (zoom)
-         _swrast_write_zoomed_depth_span(ctx, destx, desty, &span);
-      else
-         _swrast_write_rgba_span(ctx, &span);
-   }
-
-   if (overlapping)
-      free(tmpImage);
-}
-
-
-
-static void
-copy_stencil_pixels( GLcontext *ctx, GLint srcx, GLint srcy,
-                     GLint width, GLint height,
-                     GLint destx, GLint desty )
-{
-   struct gl_framebuffer *fb = ctx->ReadBuffer;
-   struct gl_renderbuffer *rb = fb->_StencilBuffer;
-   GLint sy, dy, stepy;
-   GLint j;
-   GLstencil *p, *tmpImage;
-   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
-   GLint overlapping;
-
-   if (!rb) {
-      /* no readbuffer - OK */
-      return;
-   }
-
-   if (ctx->DrawBuffer == ctx->ReadBuffer) {
-      overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
-                                    ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
-   }
-   else {
-      overlapping = GL_FALSE;
-   }
-
-   /* Determine if copy should be bottom-to-top or top-to-bottom */
-   if (!overlapping && srcy < desty) {
-      /* top-down  max-to-min */
-      sy = srcy + height - 1;
-      dy = desty + height - 1;
-      stepy = -1;
-   }
-   else {
-      /* bottom-up  min-to-max */
-      sy = srcy;
-      dy = desty;
-      stepy = 1;
-   }
-
-   if (overlapping) {
-      GLint ssy = sy;
-      tmpImage = (GLstencil *) malloc(width * height * sizeof(GLstencil));
-      if (!tmpImage) {
-         _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
-         return;
-      }
-      p = tmpImage;
-      for (j = 0; j < height; j++, ssy += stepy) {
-         _swrast_read_stencil_span( ctx, rb, width, srcx, ssy, p );
-         p += width;
-      }
-      p = tmpImage;
-   }
-   else {
-      tmpImage = NULL;  /* silence compiler warning */
-      p = NULL;
-   }
-
-   for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
-      GLstencil stencil[MAX_WIDTH];
-
-      /* Get stencil values */
-      if (overlapping) {
-         memcpy(stencil, p, width * sizeof(GLstencil));
-         p += width;
-      }
-      else {
-         _swrast_read_stencil_span( ctx, rb, width, srcx, sy, stencil );
-      }
-
-      _mesa_apply_stencil_transfer_ops(ctx, width, stencil);
-
-      /* Write stencil values */
-      if (zoom) {
-         _swrast_write_zoomed_stencil_span(ctx, destx, desty, width,
-                                           destx, dy, stencil);
-      }
-      else {
-         _swrast_write_stencil_span( ctx, width, destx, dy, stencil );
-      }
-   }
-
-   if (overlapping)
-      free(tmpImage);
-}
-
-
-/**
- * This isn't terribly efficient.  If a driver really has combined
- * depth/stencil buffers the driver should implement an optimized
- * CopyPixels function.
- */
-static void
-copy_depth_stencil_pixels(GLcontext *ctx,
-                          const GLint srcX, const GLint srcY,
-                          const GLint width, const GLint height,
-                          const GLint destX, const GLint destY)
-{
-   struct gl_renderbuffer *stencilReadRb, *depthReadRb, *depthDrawRb;
-   GLint sy, dy, stepy;
-   GLint j;
-   GLstencil *tempStencilImage = NULL, *stencilPtr = NULL;
-   GLfloat *tempDepthImage = NULL, *depthPtr = NULL;
-   const GLfloat depthScale = ctx->DrawBuffer->_DepthMaxF;
-   const GLuint stencilMask = ctx->Stencil.WriteMask[0];
-   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
-   const GLboolean scaleOrBias
-      = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;
-   GLint overlapping;
-
-   depthDrawRb = ctx->DrawBuffer->_DepthBuffer;
-   depthReadRb = ctx->ReadBuffer->_DepthBuffer;
-   stencilReadRb = ctx->ReadBuffer->_StencilBuffer;
-
-   ASSERT(depthDrawRb);
-   ASSERT(depthReadRb);
-   ASSERT(stencilReadRb);
-
-   if (ctx->DrawBuffer == ctx->ReadBuffer) {
-      overlapping = regions_overlap(srcX, srcY, destX, destY, width, height,
-                                    ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
-   }
-   else {
-      overlapping = GL_FALSE;
-   }
-
-   /* Determine if copy should be bottom-to-top or top-to-bottom */
-   if (!overlapping && srcY < destY) {
-      /* top-down  max-to-min */
-      sy = srcY + height - 1;
-      dy = destY + height - 1;
-      stepy = -1;
-   }
-   else {
-      /* bottom-up  min-to-max */
-      sy = srcY;
-      dy = destY;
-      stepy = 1;
-   }
-
-   if (overlapping) {
-      GLint ssy = sy;
-
-      if (stencilMask != 0x0) {
-         tempStencilImage
-            = (GLstencil *) malloc(width * height * sizeof(GLstencil));
-         if (!tempStencilImage) {
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");
-            return;
-         }
-
-         /* get copy of stencil pixels */
-         stencilPtr = tempStencilImage;
-         for (j = 0; j < height; j++, ssy += stepy) {
-            _swrast_read_stencil_span(ctx, stencilReadRb,
-                                      width, srcX, ssy, stencilPtr);
-            stencilPtr += width;
-         }
-         stencilPtr = tempStencilImage;
-      }
-
-      if (ctx->Depth.Mask) {
-         tempDepthImage
-            = (GLfloat *) malloc(width * height * sizeof(GLfloat));
-         if (!tempDepthImage) {
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");
-            free(tempStencilImage);
-            return;
-         }
-
-         /* get copy of depth pixels */
-         depthPtr = tempDepthImage;
-         for (j = 0; j < height; j++, ssy += stepy) {
-            _swrast_read_depth_span_float(ctx, depthReadRb,
-                                          width, srcX, ssy, depthPtr);
-            depthPtr += width;
-         }
-         depthPtr = tempDepthImage;
-      }
-   }
-
-   for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
-      if (stencilMask != 0x0) {
-         GLstencil stencil[MAX_WIDTH];
-
-         /* Get stencil values */
-         if (overlapping) {
-            memcpy(stencil, stencilPtr, width * sizeof(GLstencil));
-            stencilPtr += width;
-         }
-         else {
-            _swrast_read_stencil_span(ctx, stencilReadRb,
-                                      width, srcX, sy, stencil);
-         }
-
-         _mesa_apply_stencil_transfer_ops(ctx, width, stencil);
-
-         /* Write values */
-         if (zoom) {
-            _swrast_write_zoomed_stencil_span(ctx, destX, destY, width,
-                                              destX, dy, stencil);
-         }
-         else {
-            _swrast_write_stencil_span( ctx, width, destX, dy, stencil );
-         }
-      }
-
-      if (ctx->Depth.Mask) {
-         GLfloat depth[MAX_WIDTH];
-         GLuint zVals32[MAX_WIDTH];
-         GLushort zVals16[MAX_WIDTH];
-         GLvoid *zVals;
-         GLuint zBytes;
-
-         /* get depth values */
-         if (overlapping) {
-            memcpy(depth, depthPtr, width * sizeof(GLfloat));
-            depthPtr += width;
-         }
-         else {
-            _swrast_read_depth_span_float(ctx, depthReadRb,
-                                          width, srcX, sy, depth);
-         }
-
-         /* scale & bias */
-         if (scaleOrBias) {
-            _mesa_scale_and_bias_depth(ctx, width, depth);
-         }
-         /* convert to integer Z values */
-         if (depthDrawRb->DataType == GL_UNSIGNED_SHORT) {
-            GLint k;
-            for (k = 0; k < width; k++)
-               zVals16[k] = (GLushort) (depth[k] * depthScale);
-            zVals = zVals16;
-            zBytes = 2;
-         }
-         else {
-            GLint k;
-            for (k = 0; k < width; k++)
-               zVals32[k] = (GLuint) (depth[k] * depthScale);
-            zVals = zVals32;
-            zBytes = 4;
-         }
-
-         /* Write values */
-         if (zoom) {
-            _swrast_write_zoomed_z_span(ctx, destX, destY, width,
-                                        destX, dy, zVals);
-         }
-         else {
-            _swrast_put_row(ctx, depthDrawRb, width, destX, dy, zVals, zBytes);
-         }
-      }
-   }
-
-   if (tempStencilImage)
-      free(tempStencilImage);
-
-   if (tempDepthImage)
-      free(tempDepthImage);
-}
-
-
-
-/**
- * Try to do a fast copy pixels.
- */
-static GLboolean
-fast_copy_pixels(GLcontext *ctx,
-                 GLint srcX, GLint srcY, GLsizei width, GLsizei height,
-                 GLint dstX, GLint dstY, GLenum type)
-{
-   struct gl_framebuffer *srcFb = ctx->ReadBuffer;
-   struct gl_framebuffer *dstFb = ctx->DrawBuffer;
-   struct gl_renderbuffer *srcRb, *dstRb;
-   GLint row, yStep;
-
-   if (SWRAST_CONTEXT(ctx)->_RasterMask != 0x0 ||
-       ctx->Pixel.ZoomX != 1.0F ||
-       ctx->Pixel.ZoomY != 1.0F ||
-       ctx->_ImageTransferState) {
-      /* can't handle these */
-      return GL_FALSE;
-   }
-
-   if (type == GL_COLOR) {
-      if (dstFb->_NumColorDrawBuffers != 1)
-         return GL_FALSE;
-      srcRb = srcFb->_ColorReadBuffer;
-      dstRb = dstFb->_ColorDrawBuffers[0];
-   }
-   else if (type == GL_STENCIL) {
-      srcRb = srcFb->_StencilBuffer;
-      dstRb = dstFb->_StencilBuffer;
-   }
-   else if (type == GL_DEPTH) {
-      srcRb = srcFb->_DepthBuffer;
-      dstRb = dstFb->_DepthBuffer;
-   }
-   else {
-      ASSERT(type == GL_DEPTH_STENCIL_EXT);
-      /* XXX correct? */
-      srcRb = srcFb->Attachment[BUFFER_DEPTH].Renderbuffer;
-      dstRb = dstFb->Attachment[BUFFER_DEPTH].Renderbuffer;
-   }
-
-   /* src and dst renderbuffers must be same format and type */
-   if (!srcRb || !dstRb ||
-       srcRb->DataType != dstRb->DataType ||
-       srcRb->_BaseFormat != dstRb->_BaseFormat) {
-      return GL_FALSE;
-   }
-
-   /* clipping not supported */
-   if (srcX < 0 || srcX + width > (GLint) srcFb->Width ||
-       srcY < 0 || srcY + height > (GLint) srcFb->Height ||
-       dstX < dstFb->_Xmin || dstX + width > dstFb->_Xmax ||
-       dstY < dstFb->_Ymin || dstY + height > dstFb->_Ymax) {
-      return GL_FALSE;
-   }
-
-   /* overlapping src/dst doesn't matter, just determine Y direction */
-   if (srcY < dstY) {
-      /* top-down  max-to-min */
-      srcY = srcY + height - 1;
-      dstY = dstY + height - 1;
-      yStep = -1;
-   }
-   else {
-      /* bottom-up  min-to-max */
-      yStep = 1;
-   }
-
-   for (row = 0; row < height; row++) {
-      GLuint temp[MAX_WIDTH][4];
-      srcRb->GetRow(ctx, srcRb, width, srcX, srcY, temp);
-      dstRb->PutRow(ctx, dstRb, width, dstX, dstY, temp, NULL);
-      srcY += yStep;
-      dstY += yStep;
-   }
-
-   return GL_TRUE;
-}
-
-
-/**
- * Do software-based glCopyPixels.
- * By time we get here, all parameters will have been error-checked.
- */
-void
-_swrast_CopyPixels( GLcontext *ctx,
-		    GLint srcx, GLint srcy, GLsizei width, GLsizei height,
-		    GLint destx, GLint desty, GLenum type )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   swrast_render_start(ctx);
-      
-   if (!_mesa_check_conditional_render(ctx))
-      return; /* don't copy */
-
-   if (swrast->NewState)
-      _swrast_validate_derived( ctx );
-
-   if (!fast_copy_pixels(ctx, srcx, srcy, width, height, destx, desty, type)) {
-      switch (type) {
-      case GL_COLOR:
-         copy_rgba_pixels( ctx, srcx, srcy, width, height, destx, desty );
-         break;
-      case GL_DEPTH:
-         copy_depth_pixels( ctx, srcx, srcy, width, height, destx, desty );
-         break;
-      case GL_STENCIL:
-         copy_stencil_pixels( ctx, srcx, srcy, width, height, destx, desty );
-         break;
-      case GL_DEPTH_STENCIL_EXT:
-         copy_depth_stencil_pixels(ctx, srcx, srcy, width, height, destx, desty);
-         break;
-      default:
-         _mesa_problem(ctx, "unexpected type in _swrast_CopyPixels");
-      }
-   }
-
-   swrast_render_finish(ctx);
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.1

+ *

+ * Copyright (C) 1999-2007  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

+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ */

+

+

+#include "main/glheader.h"

+#include "main/context.h"

+#include "main/colormac.h"

+#include "main/condrender.h"

+#include "main/macros.h"

+#include "main/pixeltransfer.h"

+#include "main/imports.h"

+

+#include "s_context.h"

+#include "s_depth.h"

+#include "s_span.h"

+#include "s_stencil.h"

+#include "s_zoom.h"

+

+

+

+/**

+ * Determine if there's overlap in an image copy.

+ * This test also compensates for the fact that copies are done from

+ * bottom to top and overlaps can sometimes be handled correctly

+ * without making a temporary image copy.

+ * \return GL_TRUE if the regions overlap, GL_FALSE otherwise.

+ */

+static GLboolean

+regions_overlap(GLint srcx, GLint srcy,

+                GLint dstx, GLint dsty,

+                GLint width, GLint height,

+                GLfloat zoomX, GLfloat zoomY)

+{

+   if (zoomX == 1.0 && zoomY == 1.0) {

+      /* no zoom */

+      if (srcx >= dstx + width || (srcx + width <= dstx)) {

+         return GL_FALSE;

+      }

+      else if (srcy < dsty) { /* this is OK */

+         return GL_FALSE;

+      }

+      else if (srcy > dsty + height) {

+         return GL_FALSE;

+      }

+      else {

+         return GL_TRUE;

+      }

+   }

+   else {

+      /* add one pixel of slop when zooming, just to be safe */

+      if (srcx > (dstx + ((zoomX > 0.0F) ? (width * zoomX + 1.0F) : 0.0F))) {

+         /* src is completely right of dest */

+         return GL_FALSE;

+      }

+      else if (srcx + width + 1.0F < dstx + ((zoomX > 0.0F) ? 0.0F : (width * zoomX))) {

+         /* src is completely left of dest */

+         return GL_FALSE;

+      }

+      else if ((srcy < dsty) && (srcy + height < dsty + (height * zoomY))) {

+         /* src is completely below dest */

+         return GL_FALSE;

+      }

+      else if ((srcy > dsty) && (srcy + height > dsty + (height * zoomY))) {

+         /* src is completely above dest */

+         return GL_FALSE;

+      }

+      else {

+         return GL_TRUE;

+      }

+   }

+}

+

+

+/**

+ * RGBA copypixels

+ */

+static void

+copy_rgba_pixels(struct gl_context *ctx, GLint srcx, GLint srcy,

+                 GLint width, GLint height, GLint destx, GLint desty)

+{

+   GLfloat *tmpImage, *p;

+   GLint sy, dy, stepy, row;

+   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;

+   GLint overlapping;

+   GLuint transferOps = ctx->_ImageTransferState;

+   SWspan span;

+

+   if (!ctx->ReadBuffer->_ColorReadBuffer) {

+      /* no readbuffer - OK */

+      return;

+   }

+

+   if (ctx->DrawBuffer == ctx->ReadBuffer) {

+      overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,

+                                    ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);

+   }

+   else {

+      overlapping = GL_FALSE;

+   }

+

+   /* Determine if copy should be done bottom-to-top or top-to-bottom */

+   if (!overlapping && srcy < desty) {

+      /* top-down  max-to-min */

+      sy = srcy + height - 1;

+      dy = desty + height - 1;

+      stepy = -1;

+   }

+   else {

+      /* bottom-up  min-to-max */

+      sy = srcy;

+      dy = desty;

+      stepy = 1;

+   }

+

+   INIT_SPAN(span, GL_BITMAP);

+   _swrast_span_default_attribs(ctx, &span);

+   span.arrayMask = SPAN_RGBA;

+   span.arrayAttribs = FRAG_BIT_COL0; /* we'll fill in COL0 attrib values */

+

+   if (overlapping) {

+      tmpImage = (GLfloat *) malloc(width * height * sizeof(GLfloat) * 4);

+      if (!tmpImage) {

+         _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );

+         return;

+      }

+      /* read the source image as RGBA/float */

+      p = tmpImage;

+      for (row = 0; row < height; row++) {

+         _swrast_read_rgba_span( ctx, ctx->ReadBuffer->_ColorReadBuffer,

+                                 width, srcx, sy + row, GL_FLOAT, p );

+         p += width * 4;

+      }

+      p = tmpImage;

+   }

+   else {

+      tmpImage = NULL;  /* silence compiler warnings */

+      p = NULL;

+   }

+

+   ASSERT(width < MAX_WIDTH);

+

+   for (row = 0; row < height; row++, sy += stepy, dy += stepy) {

+      GLvoid *rgba = span.array->attribs[FRAG_ATTRIB_COL0];

+

+      /* Get row/span of source pixels */

+      if (overlapping) {

+         /* get from buffered image */

+         memcpy(rgba, p, width * sizeof(GLfloat) * 4);

+         p += width * 4;

+      }

+      else {

+         /* get from framebuffer */

+         _swrast_read_rgba_span( ctx, ctx->ReadBuffer->_ColorReadBuffer,

+                                 width, srcx, sy, GL_FLOAT, rgba );

+      }

+

+      if (transferOps) {

+         _mesa_apply_rgba_transfer_ops(ctx, transferOps, width,

+                                       (GLfloat (*)[4]) rgba);

+      }

+

+      /* Write color span */

+      span.x = destx;

+      span.y = dy;

+      span.end = width;

+      span.array->ChanType = GL_FLOAT;

+      if (zoom) {

+         _swrast_write_zoomed_rgba_span(ctx, destx, desty, &span, rgba);

+      }

+      else {

+         _swrast_write_rgba_span(ctx, &span);

+      }

+   }

+

+   span.array->ChanType = CHAN_TYPE; /* restore */

+

+   if (overlapping)

+      free(tmpImage);

+}

+

+

+/**

+ * Convert floating point Z values to integer Z values with pixel transfer's

+ * Z scale and bias.

+ */

+static void

+scale_and_bias_z(struct gl_context *ctx, GLuint width,

+                 const GLfloat depth[], GLuint z[])

+{

+   const GLuint depthMax = ctx->DrawBuffer->_DepthMax;

+   GLuint i;

+

+   if (depthMax <= 0xffffff &&

+       ctx->Pixel.DepthScale == 1.0 &&

+       ctx->Pixel.DepthBias == 0.0) {

+      /* no scale or bias and no clamping and no worry of overflow */

+      const GLfloat depthMaxF = ctx->DrawBuffer->_DepthMaxF;

+      for (i = 0; i < width; i++) {

+         z[i] = (GLuint) (depth[i] * depthMaxF);

+      }

+   }

+   else {

+      /* need to be careful with overflow */

+      const GLdouble depthMaxF = ctx->DrawBuffer->_DepthMaxF;

+      for (i = 0; i < width; i++) {

+         GLdouble d = depth[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;

+         d = CLAMP(d, 0.0, 1.0) * depthMaxF;

+         if (d >= depthMaxF)

+            z[i] = depthMax;

+         else

+            z[i] = (GLuint) d;

+      }

+   }

+}

+

+

+

+/*

+ * TODO: Optimize!!!!

+ */

+static void

+copy_depth_pixels( struct gl_context *ctx, GLint srcx, GLint srcy,

+                   GLint width, GLint height,

+                   GLint destx, GLint desty )

+{

+   struct gl_framebuffer *fb = ctx->ReadBuffer;

+   struct gl_renderbuffer *readRb = fb->_DepthBuffer;

+   GLfloat *p, *tmpImage;

+   GLint sy, dy, stepy;

+   GLint j;

+   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;

+   GLint overlapping;

+   SWspan span;

+

+   if (!readRb) {

+      /* no readbuffer - OK */

+      return;

+   }

+

+   INIT_SPAN(span, GL_BITMAP);

+   _swrast_span_default_attribs(ctx, &span);

+   span.arrayMask = SPAN_Z;

+

+   if (ctx->DrawBuffer == ctx->ReadBuffer) {

+      overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,

+                                    ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);

+   }

+   else {

+      overlapping = GL_FALSE;

+   }

+

+   /* Determine if copy should be bottom-to-top or top-to-bottom */

+   if (!overlapping && srcy < desty) {

+      /* top-down  max-to-min */

+      sy = srcy + height - 1;

+      dy = desty + height - 1;

+      stepy = -1;

+   }

+   else {

+      /* bottom-up  min-to-max */

+      sy = srcy;

+      dy = desty;

+      stepy = 1;

+   }

+

+   if (overlapping) {

+      GLint ssy = sy;

+      tmpImage = (GLfloat *) malloc(width * height * sizeof(GLfloat));

+      if (!tmpImage) {

+         _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );

+         return;

+      }

+      p = tmpImage;

+      for (j = 0; j < height; j++, ssy += stepy) {

+         _swrast_read_depth_span_float(ctx, readRb, width, srcx, ssy, p);

+         p += width;

+      }

+      p = tmpImage;

+   }

+   else {

+      tmpImage = NULL;  /* silence compiler warning */

+      p = NULL;

+   }

+

+   for (j = 0; j < height; j++, sy += stepy, dy += stepy) {

+      GLfloat depth[MAX_WIDTH];

+      /* get depth values */

+      if (overlapping) {

+         memcpy(depth, p, width * sizeof(GLfloat));

+         p += width;

+      }

+      else {

+         _swrast_read_depth_span_float(ctx, readRb, width, srcx, sy, depth);

+      }

+

+      /* apply scale and bias */

+      scale_and_bias_z(ctx, width, depth, span.array->z);

+

+      /* write depth values */

+      span.x = destx;

+      span.y = dy;

+      span.end = width;

+      if (zoom)

+         _swrast_write_zoomed_depth_span(ctx, destx, desty, &span);

+      else

+         _swrast_write_rgba_span(ctx, &span);

+   }

+

+   if (overlapping)

+      free(tmpImage);

+}

+

+

+

+static void

+copy_stencil_pixels( struct gl_context *ctx, GLint srcx, GLint srcy,

+                     GLint width, GLint height,

+                     GLint destx, GLint desty )

+{

+   struct gl_framebuffer *fb = ctx->ReadBuffer;

+   struct gl_renderbuffer *rb = fb->_StencilBuffer;

+   GLint sy, dy, stepy;

+   GLint j;

+   GLstencil *p, *tmpImage;

+   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;

+   GLint overlapping;

+

+   if (!rb) {

+      /* no readbuffer - OK */

+      return;

+   }

+

+   if (ctx->DrawBuffer == ctx->ReadBuffer) {

+      overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,

+                                    ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);

+   }

+   else {

+      overlapping = GL_FALSE;

+   }

+

+   /* Determine if copy should be bottom-to-top or top-to-bottom */

+   if (!overlapping && srcy < desty) {

+      /* top-down  max-to-min */

+      sy = srcy + height - 1;

+      dy = desty + height - 1;

+      stepy = -1;

+   }

+   else {

+      /* bottom-up  min-to-max */

+      sy = srcy;

+      dy = desty;

+      stepy = 1;

+   }

+

+   if (overlapping) {

+      GLint ssy = sy;

+      tmpImage = (GLstencil *) malloc(width * height * sizeof(GLstencil));

+      if (!tmpImage) {

+         _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );

+         return;

+      }

+      p = tmpImage;

+      for (j = 0; j < height; j++, ssy += stepy) {

+         _swrast_read_stencil_span( ctx, rb, width, srcx, ssy, p );

+         p += width;

+      }

+      p = tmpImage;

+   }

+   else {

+      tmpImage = NULL;  /* silence compiler warning */

+      p = NULL;

+   }

+

+   for (j = 0; j < height; j++, sy += stepy, dy += stepy) {

+      GLstencil stencil[MAX_WIDTH];

+

+      /* Get stencil values */

+      if (overlapping) {

+         memcpy(stencil, p, width * sizeof(GLstencil));

+         p += width;

+      }

+      else {

+         _swrast_read_stencil_span( ctx, rb, width, srcx, sy, stencil );

+      }

+

+      _mesa_apply_stencil_transfer_ops(ctx, width, stencil);

+

+      /* Write stencil values */

+      if (zoom) {

+         _swrast_write_zoomed_stencil_span(ctx, destx, desty, width,

+                                           destx, dy, stencil);

+      }

+      else {

+         _swrast_write_stencil_span( ctx, width, destx, dy, stencil );

+      }

+   }

+

+   if (overlapping)

+      free(tmpImage);

+}

+

+

+/**

+ * This isn't terribly efficient.  If a driver really has combined

+ * depth/stencil buffers the driver should implement an optimized

+ * CopyPixels function.

+ */

+static void

+copy_depth_stencil_pixels(struct gl_context *ctx,

+                          const GLint srcX, const GLint srcY,

+                          const GLint width, const GLint height,

+                          const GLint destX, const GLint destY)

+{

+   struct gl_renderbuffer *stencilReadRb, *depthReadRb, *depthDrawRb;

+   GLint sy, dy, stepy;

+   GLint j;

+   GLstencil *tempStencilImage = NULL, *stencilPtr = NULL;

+   GLfloat *tempDepthImage = NULL, *depthPtr = NULL;

+   const GLfloat depthScale = ctx->DrawBuffer->_DepthMaxF;

+   const GLuint stencilMask = ctx->Stencil.WriteMask[0];

+   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;

+   const GLboolean scaleOrBias

+      = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;

+   GLint overlapping;

+

+   depthDrawRb = ctx->DrawBuffer->_DepthBuffer;

+   depthReadRb = ctx->ReadBuffer->_DepthBuffer;

+   stencilReadRb = ctx->ReadBuffer->_StencilBuffer;

+

+   ASSERT(depthDrawRb);

+   ASSERT(depthReadRb);

+   ASSERT(stencilReadRb);

+

+   if (ctx->DrawBuffer == ctx->ReadBuffer) {

+      overlapping = regions_overlap(srcX, srcY, destX, destY, width, height,

+                                    ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);

+   }

+   else {

+      overlapping = GL_FALSE;

+   }

+

+   /* Determine if copy should be bottom-to-top or top-to-bottom */

+   if (!overlapping && srcY < destY) {

+      /* top-down  max-to-min */

+      sy = srcY + height - 1;

+      dy = destY + height - 1;

+      stepy = -1;

+   }

+   else {

+      /* bottom-up  min-to-max */

+      sy = srcY;

+      dy = destY;

+      stepy = 1;

+   }

+

+   if (overlapping) {

+      GLint ssy = sy;

+

+      if (stencilMask != 0x0) {

+         tempStencilImage

+            = (GLstencil *) malloc(width * height * sizeof(GLstencil));

+         if (!tempStencilImage) {

+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");

+            return;

+         }

+

+         /* get copy of stencil pixels */

+         stencilPtr = tempStencilImage;

+         for (j = 0; j < height; j++, ssy += stepy) {

+            _swrast_read_stencil_span(ctx, stencilReadRb,

+                                      width, srcX, ssy, stencilPtr);

+            stencilPtr += width;

+         }

+         stencilPtr = tempStencilImage;

+      }

+

+      if (ctx->Depth.Mask) {

+         tempDepthImage

+            = (GLfloat *) malloc(width * height * sizeof(GLfloat));

+         if (!tempDepthImage) {

+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");

+            free(tempStencilImage);

+            return;

+         }

+

+         /* get copy of depth pixels */

+         depthPtr = tempDepthImage;

+         for (j = 0; j < height; j++, ssy += stepy) {

+            _swrast_read_depth_span_float(ctx, depthReadRb,

+                                          width, srcX, ssy, depthPtr);

+            depthPtr += width;

+         }

+         depthPtr = tempDepthImage;

+      }

+   }

+

+   for (j = 0; j < height; j++, sy += stepy, dy += stepy) {

+      if (stencilMask != 0x0) {

+         GLstencil stencil[MAX_WIDTH];

+

+         /* Get stencil values */

+         if (overlapping) {

+            memcpy(stencil, stencilPtr, width * sizeof(GLstencil));

+            stencilPtr += width;

+         }

+         else {

+            _swrast_read_stencil_span(ctx, stencilReadRb,

+                                      width, srcX, sy, stencil);

+         }

+

+         _mesa_apply_stencil_transfer_ops(ctx, width, stencil);

+

+         /* Write values */

+         if (zoom) {

+            _swrast_write_zoomed_stencil_span(ctx, destX, destY, width,

+                                              destX, dy, stencil);

+         }

+         else {

+            _swrast_write_stencil_span( ctx, width, destX, dy, stencil );

+         }

+      }

+

+      if (ctx->Depth.Mask) {

+         GLfloat depth[MAX_WIDTH];

+         GLuint zVals32[MAX_WIDTH];

+         GLushort zVals16[MAX_WIDTH];

+         GLvoid *zVals;

+         GLuint zBytes;

+

+         /* get depth values */

+         if (overlapping) {

+            memcpy(depth, depthPtr, width * sizeof(GLfloat));

+            depthPtr += width;

+         }

+         else {

+            _swrast_read_depth_span_float(ctx, depthReadRb,

+                                          width, srcX, sy, depth);

+         }

+

+         /* scale & bias */

+         if (scaleOrBias) {

+            _mesa_scale_and_bias_depth(ctx, width, depth);

+         }

+         /* convert to integer Z values */

+         if (depthDrawRb->DataType == GL_UNSIGNED_SHORT) {

+            GLint k;

+            for (k = 0; k < width; k++)

+               zVals16[k] = (GLushort) (depth[k] * depthScale);

+            zVals = zVals16;

+            zBytes = 2;

+         }

+         else {

+            GLint k;

+            for (k = 0; k < width; k++)

+               zVals32[k] = (GLuint) (depth[k] * depthScale);

+            zVals = zVals32;

+            zBytes = 4;

+         }

+

+         /* Write values */

+         if (zoom) {

+            _swrast_write_zoomed_z_span(ctx, destX, destY, width,

+                                        destX, dy, zVals);

+         }

+         else {

+            _swrast_put_row(ctx, depthDrawRb, width, destX, dy, zVals, zBytes);

+         }

+      }

+   }

+

+   if (tempStencilImage)

+      free(tempStencilImage);

+

+   if (tempDepthImage)

+      free(tempDepthImage);

+}

+

+

+

+/**

+ * Try to do a fast copy pixels.

+ */

+static GLboolean

+fast_copy_pixels(struct gl_context *ctx,

+                 GLint srcX, GLint srcY, GLsizei width, GLsizei height,

+                 GLint dstX, GLint dstY, GLenum type)

+{

+   struct gl_framebuffer *srcFb = ctx->ReadBuffer;

+   struct gl_framebuffer *dstFb = ctx->DrawBuffer;

+   struct gl_renderbuffer *srcRb, *dstRb;

+   GLint row, yStep;

+

+   if (SWRAST_CONTEXT(ctx)->_RasterMask != 0x0 ||

+       ctx->Pixel.ZoomX != 1.0F ||

+       ctx->Pixel.ZoomY != 1.0F ||

+       ctx->_ImageTransferState) {

+      /* can't handle these */

+      return GL_FALSE;

+   }

+

+   if (type == GL_COLOR) {

+      if (dstFb->_NumColorDrawBuffers != 1)

+         return GL_FALSE;

+      srcRb = srcFb->_ColorReadBuffer;

+      dstRb = dstFb->_ColorDrawBuffers[0];

+   }

+   else if (type == GL_STENCIL) {

+      srcRb = srcFb->_StencilBuffer;

+      dstRb = dstFb->_StencilBuffer;

+   }

+   else if (type == GL_DEPTH) {

+      srcRb = srcFb->_DepthBuffer;

+      dstRb = dstFb->_DepthBuffer;

+   }

+   else {

+      ASSERT(type == GL_DEPTH_STENCIL_EXT);

+      /* XXX correct? */

+      srcRb = srcFb->Attachment[BUFFER_DEPTH].Renderbuffer;

+      dstRb = dstFb->Attachment[BUFFER_DEPTH].Renderbuffer;

+   }

+

+   /* src and dst renderbuffers must be same format and type */

+   if (!srcRb || !dstRb ||

+       srcRb->DataType != dstRb->DataType ||

+       srcRb->_BaseFormat != dstRb->_BaseFormat) {

+      return GL_FALSE;

+   }

+

+   /* clipping not supported */

+   if (srcX < 0 || srcX + width > (GLint) srcFb->Width ||

+       srcY < 0 || srcY + height > (GLint) srcFb->Height ||

+       dstX < dstFb->_Xmin || dstX + width > dstFb->_Xmax ||

+       dstY < dstFb->_Ymin || dstY + height > dstFb->_Ymax) {

+      return GL_FALSE;

+   }

+

+   /* overlapping src/dst doesn't matter, just determine Y direction */

+   if (srcY < dstY) {

+      /* top-down  max-to-min */

+      srcY = srcY + height - 1;

+      dstY = dstY + height - 1;

+      yStep = -1;

+   }

+   else {

+      /* bottom-up  min-to-max */

+      yStep = 1;

+   }

+

+   for (row = 0; row < height; row++) {

+      GLuint temp[MAX_WIDTH][4];

+      srcRb->GetRow(ctx, srcRb, width, srcX, srcY, temp);

+      dstRb->PutRow(ctx, dstRb, width, dstX, dstY, temp, NULL);

+      srcY += yStep;

+      dstY += yStep;

+   }

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Do software-based glCopyPixels.

+ * By time we get here, all parameters will have been error-checked.

+ */

+void

+_swrast_CopyPixels( struct gl_context *ctx,

+		    GLint srcx, GLint srcy, GLsizei width, GLsizei height,

+		    GLint destx, GLint desty, GLenum type )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   swrast_render_start(ctx);

+      

+   if (!_mesa_check_conditional_render(ctx))

+      return; /* don't copy */

+

+   if (swrast->NewState)

+      _swrast_validate_derived( ctx );

+

+   if (!fast_copy_pixels(ctx, srcx, srcy, width, height, destx, desty, type)) {

+      switch (type) {

+      case GL_COLOR:

+         copy_rgba_pixels( ctx, srcx, srcy, width, height, destx, desty );

+         break;

+      case GL_DEPTH:

+         copy_depth_pixels( ctx, srcx, srcy, width, height, destx, desty );

+         break;

+      case GL_STENCIL:

+         copy_stencil_pixels( ctx, srcx, srcy, width, height, destx, desty );

+         break;

+      case GL_DEPTH_STENCIL_EXT:

+         copy_depth_stencil_pixels(ctx, srcx, srcy, width, height, destx, desty);

+         break;

+      default:

+         _mesa_problem(ctx, "unexpected type in _swrast_CopyPixels");

+      }

+   }

+

+   swrast_render_finish(ctx);

+}