src/mesa/swrast/s_copypix.c

   1 /* $Id: s_copypix.c,v 1.32 2002/01/31 00:27:43 brianp Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  4.1
   6  *
   7  * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included
  17  * in all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  */
  26
  27
  28 #include "glheader.h"
  29 #include "colormac.h"
  30 #include "context.h"
  31 #include "convolve.h"
  32 #include "feedback.h"
  33 #include "macros.h"
  34 #include "mem.h"
  35 #include "mmath.h"
  36 #include "pixel.h"
  37
  38 #include "s_context.h"
  39 #include "s_depth.h"
  40 #include "s_fog.h"
  41 #include "s_histogram.h"
  42 #include "s_pixeltex.h"
  43 #include "s_span.h"
  44 #include "s_stencil.h"
  45 #include "s_texture.h"
  46 #include "s_zoom.h"
  47
  48
  49
  50 /*
  51  * Determine if there's overlap in an image copy.
  52  * This test also compensates for the fact that copies are done from
  53  * bottom to top and overlaps can sometimes be handled correctly
  54  * without making a temporary image copy.
  55  */
  56 static GLboolean
  57 regions_overlap(GLint srcx, GLint srcy,
  58                 GLint dstx, GLint dsty,
  59                 GLint width, GLint height,
  60                 GLfloat zoomX, GLfloat zoomY)
  61 {
  62    if (zoomX == 1.0 && zoomY == 1.0) {
  63       /* no zoom */
  64       if (srcx >= dstx + width || (srcx + width <= dstx)) {
  65          return GL_FALSE;
  66       }
  67       else if (srcy < dsty) { /* this is OK */
  68          return GL_FALSE;
  69       }
  70       else if (srcy > dsty + height) {
  71          return GL_FALSE;
  72       }
  73       else {
  74          return GL_TRUE;
  75       }
  76    }
  77    else {
  78       /* add one pixel of slop when zooming, just to be safe */
  79       if ((srcx > dstx + (width * zoomX) + 1) || (srcx + width + 1 < dstx)) {
  80          return GL_FALSE;
  81       }
  82       else if ((srcy < dsty) && (srcy + height < dsty + (height * zoomY))) {
  83          return GL_FALSE;
  84       }
  85       else if ((srcy > dsty) && (srcy + height > dsty + (height * zoomY))) {
  86          return GL_FALSE;
  87       }
  88       else {
  89          return GL_TRUE;
  90       }
  91    }
  92 }
  93
  94
  95
  96 /*
  97  * RGBA copypixels with convolution.
  98  */
  99 static void
 100 copy_conv_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
 101                       GLint width, GLint height, GLint destx, GLint desty)
 102 {
 103    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 104    GLboolean quick_draw;
 105    GLint row;
 106    GLboolean changeBuffer;
 107    GLchan *saveReadAlpha;
 108    const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
 109    const GLuint transferOps = ctx->_ImageTransferState;
 110    GLfloat *dest, *tmpImage, *convImage;
 111    struct sw_span span;
 112
 113    INIT_SPAN(span);
 114    span.arrayMask |= SPAN_RGBA;
 115
 116    if (ctx->Depth.Test)
 117       _mesa_span_default_z(ctx, &span);
 118    if (ctx->Fog.Enabled)
 119       _mesa_span_default_fog(ctx, &span);
 120
 121
 122    if (SWRAST_CONTEXT(ctx)->_RasterMask == 0
 123        && !zoom
 124        && destx >= 0
 125        && destx + width <= ctx->DrawBuffer->Width) {
 126       quick_draw = GL_TRUE;
 127    }
 128    else {
 129       quick_draw = GL_FALSE;
 130    }
 131
 132    /* If read and draw buffer are different we must do buffer switching */
 133    saveReadAlpha = ctx->ReadBuffer->Alpha;
 134    changeBuffer = ctx->Pixel.ReadBuffer != ctx->Color.DrawBuffer
 135                || ctx->DrawBuffer != ctx->ReadBuffer;
 136
 137
 138    /* allocate space for GLfloat image */
 139    tmpImage = (GLfloat *) MALLOC(width * height * 4 * sizeof(GLfloat));
 140    if (!tmpImage) {
 141       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");
 142       return;
 143    }
 144    convImage = (GLfloat *) MALLOC(width * height * 4 * sizeof(GLfloat));
 145    if (!convImage) {
 146       FREE(tmpImage);
 147       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");
 148       return;
 149    }
 150
 151    dest = tmpImage;
 152
 153    if (changeBuffer) {
 154       (*swrast->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
 155                                     ctx->Pixel.DriverReadBuffer );
 156       if (ctx->Pixel.DriverReadBuffer == GL_FRONT_LEFT)
 157          ctx->ReadBuffer->Alpha = ctx->ReadBuffer->FrontLeftAlpha;
 158       else if (ctx->Pixel.DriverReadBuffer == GL_BACK_LEFT)
 159          ctx->ReadBuffer->Alpha = ctx->ReadBuffer->BackLeftAlpha;
 160       else if (ctx->Pixel.DriverReadBuffer == GL_FRONT_RIGHT)
 161          ctx->ReadBuffer->Alpha = ctx->ReadBuffer->FrontRightAlpha;
 162       else
 163          ctx->ReadBuffer->Alpha = ctx->ReadBuffer->BackRightAlpha;
 164    }
 165
 166    /* read source image */
 167    dest = tmpImage;
 168    for (row = 0; row < height; row++) {
 169       GLchan rgba[MAX_WIDTH][4];
 170       GLint i;
 171       _mesa_read_rgba_span(ctx, ctx->ReadBuffer, width, srcx, srcy + row, rgba);
 172       /* convert GLchan to GLfloat */
 173       for (i = 0; i < width; i++) {
 174          *dest++ = (GLfloat) rgba[i][RCOMP] * (1.0F / CHAN_MAXF);
 175          *dest++ = (GLfloat) rgba[i][GCOMP] * (1.0F / CHAN_MAXF);
 176          *dest++ = (GLfloat) rgba[i][BCOMP] * (1.0F / CHAN_MAXF);
 177          *dest++ = (GLfloat) rgba[i][ACOMP] * (1.0F / CHAN_MAXF);
 178       }
 179    }
 180
 181    /* read from the draw buffer again (in case of blending) */
 182    if (changeBuffer) {
 183       (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
 184                                     ctx->Color.DriverDrawBuffer );
 185       ctx->ReadBuffer->Alpha = saveReadAlpha;
 186    }
 187
 188    /* do image transfer ops up until convolution */
 189    for (row = 0; row < height; row++) {
 190       GLfloat (*rgba)[4] = (GLfloat (*)[4]) (tmpImage + row * width * 4);
 191
 192       /* scale & bias */
 193       if (transferOps & IMAGE_SCALE_BIAS_BIT) {
 194          _mesa_scale_and_bias_rgba(ctx, width, rgba,
 195                                    ctx->Pixel.RedScale, ctx->Pixel.GreenScale,
 196                                    ctx->Pixel.BlueScale, ctx->Pixel.AlphaScale,
 197                                    ctx->Pixel.RedBias, ctx->Pixel.GreenBias,
 198                                    ctx->Pixel.BlueBias, ctx->Pixel.AlphaBias);
 199       }
 200       /* color map lookup */
 201       if (transferOps & IMAGE_MAP_COLOR_BIT) {
 202          _mesa_map_rgba(ctx, width, rgba);
 203       }
 204       /* GL_COLOR_TABLE lookup */
 205       if (transferOps & IMAGE_COLOR_TABLE_BIT) {
 206          _mesa_lookup_rgba(&ctx->ColorTable, width, rgba);
 207       }
 208    }
 209
 210    /* do convolution */
 211    if (ctx->Pixel.Convolution2DEnabled) {
 212       _mesa_convolve_2d_image(ctx, &width, &height, tmpImage, convImage);
 213    }
 214    else {
 215       ASSERT(ctx->Pixel.Separable2DEnabled);
 216       _mesa_convolve_sep_image(ctx, &width, &height, tmpImage, convImage);
 217    }
 218    FREE(tmpImage);
 219
 220    /* do remaining image transfer ops */
 221    for (row = 0; row < height; row++) {
 222       GLfloat (*rgba)[4] = (GLfloat (*)[4]) (convImage + row * width * 4);
 223
 224       /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
 225       if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
 226          _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, width, rgba);
 227       }
 228       /* color matrix */
 229       if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
 230          _mesa_transform_rgba(ctx, width, rgba);
 231       }
 232       /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
 233       if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
 234          _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, width, rgba);
 235       }
 236       /* update histogram count */
 237       if (transferOps & IMAGE_HISTOGRAM_BIT) {
 238          _mesa_update_histogram(ctx, width, (CONST GLfloat (*)[4]) rgba);
 239       }
 240       /* update min/max */
 241       if (transferOps & IMAGE_MIN_MAX_BIT) {
 242          _mesa_update_minmax(ctx, width, (CONST GLfloat (*)[4]) rgba);
 243       }
 244    }
 245
 246    for (row = 0; row < height; row++) {
 247       const GLfloat *src = convImage + row * width * 4;
 248       GLint i, dy;
 249
 250       /* clamp to [0,1] and convert float back to chan */
 251       for (i = 0; i < width; i++) {
 252          GLint r = (GLint) (src[i * 4 + RCOMP] * CHAN_MAXF);
 253          GLint g = (GLint) (src[i * 4 + GCOMP] * CHAN_MAXF);
 254          GLint b = (GLint) (src[i * 4 + BCOMP] * CHAN_MAXF);
 255          GLint a = (GLint) (src[i * 4 + ACOMP] * CHAN_MAXF);
 256          span.color.rgba[i][RCOMP] = (GLchan) CLAMP(r, 0, CHAN_MAX);
 257          span.color.rgba[i][GCOMP] = (GLchan) CLAMP(g, 0, CHAN_MAX);
 258          span.color.rgba[i][BCOMP] = (GLchan) CLAMP(b, 0, CHAN_MAX);
 259          span.color.rgba[i][ACOMP] = (GLchan) CLAMP(a, 0, CHAN_MAX);
 260       }
 261
 262       if (ctx->Pixel.PixelTextureEnabled && ctx->Texture._ReallyEnabled) {
 263          span.end = width;
 264          _swrast_pixel_texture(ctx, &span);
 265       }
 266
 267       /* write row to framebuffer */
 268
 269       dy = desty + row;
 270       if (quick_draw && dy >= 0 && dy < ctx->DrawBuffer->Height) {
 271          (*swrast->Driver.WriteRGBASpan)( ctx, width, destx, dy,
 272                        (const GLchan (*)[4])span.color.rgba, NULL );
 273       }
 274       else if (zoom) {
 275          span.x = destx;
 276          span.y = dy;
 277          span.end = width;
 278          _mesa_write_zoomed_rgba_span(ctx, &span,
 279                                      (CONST GLchan (*)[4])span.color.rgba,
 280                                      desty);
 281       }
 282       else {
 283          span.x = destx;
 284          span.y = dy;
 285          span.end = width;
 286          _mesa_write_rgba_span(ctx, &span, GL_BITMAP);
 287       }
 288    }
 289
 290    FREE(convImage);
 291 }
 292
 293
 294 /*
 295  * RGBA copypixels
 296  */
 297 static void
 298 copy_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
 299                  GLint width, GLint height, GLint destx, GLint desty)
 300 {
 301    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 302    GLchan *tmpImage,*p;
 303    GLboolean quick_draw;
 304    GLint sy, dy, stepy, j;
 305    GLboolean changeBuffer;
 306    GLchan *saveReadAlpha;
 307    const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
 308    GLint overlapping;
 309    const GLuint transferOps = ctx->_ImageTransferState;
 310    struct sw_span span;
 311
 312    INIT_SPAN(span);
 313    span.arrayMask |= SPAN_RGBA;
 314
 315    if (ctx->Pixel.Convolution2DEnabled || ctx->Pixel.Separable2DEnabled) {
 316       copy_conv_rgba_pixels(ctx, srcx, srcy, width, height, destx, desty);
 317       return;
 318    }
 319
 320    /* Determine if copy should be done bottom-to-top or top-to-bottom */
 321    if (srcy < desty) {
 322       /* top-down  max-to-min */
 323       sy = srcy + height - 1;
 324       dy = desty + height - 1;
 325       stepy = -1;
 326    }
 327    else {
 328       /* bottom-up  min-to-max */
 329       sy = srcy;
 330       dy = desty;
 331       stepy = 1;
 332    }
 333
 334    overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
 335                                  ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
 336
 337    if (ctx->Depth.Test)
 338       _mesa_span_default_z(ctx, &span);
 339    if (ctx->Fog.Enabled)
 340       _mesa_span_default_fog(ctx, &span);
 341
 342    if (SWRAST_CONTEXT(ctx)->_RasterMask == 0
 343        && !zoom
 344        && destx >= 0
 345        && destx + width <= ctx->DrawBuffer->Width) {
 346       quick_draw = GL_TRUE;
 347    }
 348    else {
 349       quick_draw = GL_FALSE;
 350    }
 351
 352    /* If read and draw buffer are different we must do buffer switching */
 353    saveReadAlpha = ctx->ReadBuffer->Alpha;
 354    changeBuffer = ctx->Pixel.ReadBuffer != ctx->Color.DrawBuffer
 355                   || ctx->DrawBuffer != ctx->ReadBuffer;
 356
 357    (*swrast->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
 358                                  ctx->Pixel.DriverReadBuffer );
 359
 360    if (overlapping) {
 361       GLint ssy = sy;
 362       tmpImage = (GLchan *) MALLOC(width * height * sizeof(GLchan) * 4);
 363       if (!tmpImage) {
 364          _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
 365          return;
 366       }
 367       p = tmpImage;
 368       if (changeBuffer) {
 369          (*swrast->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
 370                                        ctx->Pixel.DriverReadBuffer );
 371          if (ctx->Pixel.DriverReadBuffer == GL_FRONT_LEFT)
 372             ctx->ReadBuffer->Alpha = ctx->ReadBuffer->FrontLeftAlpha;
 373          else if (ctx->Pixel.DriverReadBuffer == GL_BACK_LEFT)
 374             ctx->ReadBuffer->Alpha = ctx->ReadBuffer->BackLeftAlpha;
 375          else if (ctx->Pixel.DriverReadBuffer == GL_FRONT_RIGHT)
 376             ctx->ReadBuffer->Alpha = ctx->ReadBuffer->FrontRightAlpha;
 377          else
 378             ctx->ReadBuffer->Alpha = ctx->ReadBuffer->BackRightAlpha;
 379       }
 380       for (j = 0; j < height; j++, ssy += stepy) {
 381          _mesa_read_rgba_span( ctx, ctx->ReadBuffer, width, srcx, ssy,
 382                             (GLchan (*)[4]) p );
 383          p += (width * sizeof(GLchan) * 4);
 384       }
 385       p = tmpImage;
 386    }
 387    else {
 388       tmpImage = NULL;  /* silence compiler warnings */
 389       p = NULL;
 390    }
 391
 392    for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
 393       /* Get source pixels */
 394       if (overlapping) {
 395          /* get from buffered image */
 396          MEMCPY(span.color.rgba, p, width * sizeof(GLchan) * 4);
 397          p += (width * sizeof(GLchan) * 4);
 398       }
 399       else {
 400          /* get from framebuffer */
 401          if (changeBuffer) {
 402             (*swrast->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
 403                                           ctx->Pixel.DriverReadBuffer );
 404             if (ctx->Pixel.DriverReadBuffer == GL_FRONT_LEFT) {
 405                ctx->ReadBuffer->Alpha = ctx->ReadBuffer->FrontLeftAlpha;
 406             }
 407             else if (ctx->Pixel.DriverReadBuffer == GL_BACK_LEFT) {
 408                ctx->ReadBuffer->Alpha = ctx->ReadBuffer->BackLeftAlpha;
 409             }
 410             else if (ctx->Pixel.DriverReadBuffer == GL_FRONT_RIGHT) {
 411                ctx->ReadBuffer->Alpha = ctx->ReadBuffer->FrontRightAlpha;
 412             }
 413             else {
 414                ctx->ReadBuffer->Alpha = ctx->ReadBuffer->BackRightAlpha;
 415             }
 416          }
 417          _mesa_read_rgba_span( ctx, ctx->ReadBuffer, width, srcx, sy, span.color.rgba );
 418       }
 419
 420       if (changeBuffer) {
 421          /* read from the draw buffer again (in case of blending) */
 422          (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
 423                                        ctx->Color.DriverDrawBuffer );
 424          ctx->ReadBuffer->Alpha = saveReadAlpha;
 425       }
 426
 427       if (transferOps) {
 428          const GLfloat scale = (1.0F / CHAN_MAXF);
 429          GLint k;
 430          DEFMARRAY(GLfloat, rgbaFloat, MAX_WIDTH, 4);  /* mac 32k limitation */
 431          CHECKARRAY(rgbaFloat, return);
 432
 433          /* convert chan to float */
 434          for (k = 0; k < width; k++) {
 435             rgbaFloat[k][RCOMP] = (GLfloat) span.color.rgba[k][RCOMP] * scale;
 436             rgbaFloat[k][GCOMP] = (GLfloat) span.color.rgba[k][GCOMP] * scale;
 437             rgbaFloat[k][BCOMP] = (GLfloat) span.color.rgba[k][BCOMP] * scale;
 438             rgbaFloat[k][ACOMP] = (GLfloat) span.color.rgba[k][ACOMP] * scale;
 439          }
 440          /* scale & bias */
 441          if (transferOps & IMAGE_SCALE_BIAS_BIT) {
 442             _mesa_scale_and_bias_rgba(ctx, width, rgbaFloat,
 443                                    ctx->Pixel.RedScale, ctx->Pixel.GreenScale,
 444                                    ctx->Pixel.BlueScale, ctx->Pixel.AlphaScale,
 445                                    ctx->Pixel.RedBias, ctx->Pixel.GreenBias,
 446                                    ctx->Pixel.BlueBias, ctx->Pixel.AlphaBias);
 447          }
 448          /* color map lookup */
 449          if (transferOps & IMAGE_MAP_COLOR_BIT) {
 450             _mesa_map_rgba(ctx, width, rgbaFloat);
 451          }
 452          /* GL_COLOR_TABLE lookup */
 453          if (transferOps & IMAGE_COLOR_TABLE_BIT) {
 454             _mesa_lookup_rgba(&ctx->ColorTable, width, rgbaFloat);
 455          }
 456          /* convolution */
 457          if (transferOps & IMAGE_CONVOLUTION_BIT) {
 458             abort();  /* should never get here; caught at top of function */
 459          }
 460          /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */
 461          if (transferOps & IMAGE_POST_CONVOLUTION_SCALE_BIAS) {
 462             _mesa_scale_and_bias_rgba(ctx, width, rgbaFloat,
 463                                       ctx->Pixel.PostConvolutionScale[RCOMP],
 464                                       ctx->Pixel.PostConvolutionScale[GCOMP],
 465                                       ctx->Pixel.PostConvolutionScale[BCOMP],
 466                                       ctx->Pixel.PostConvolutionScale[ACOMP],
 467                                       ctx->Pixel.PostConvolutionBias[RCOMP],
 468                                       ctx->Pixel.PostConvolutionBias[GCOMP],
 469                                       ctx->Pixel.PostConvolutionBias[BCOMP],
 470                                       ctx->Pixel.PostConvolutionBias[ACOMP]);
 471          }
 472          /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
 473          if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
 474             _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, width, rgbaFloat);
 475          }
 476          /* color matrix */
 477          if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
 478             _mesa_transform_rgba(ctx, width, rgbaFloat);
 479          }
 480          /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
 481          if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
 482             _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, width, rgbaFloat);
 483          }
 484          /* update histogram count */
 485          if (transferOps & IMAGE_HISTOGRAM_BIT) {
 486             _mesa_update_histogram(ctx, width, (CONST GLfloat (*)[4]) rgbaFloat);
 487          }
 488          /* update min/max */
 489          if (transferOps & IMAGE_MIN_MAX_BIT) {
 490             _mesa_update_minmax(ctx, width, (CONST GLfloat (*)[4]) rgbaFloat);
 491          }
 492          /* clamp to [0,1] and convert float back to chan */
 493          for (k = 0; k < width; k++) {
 494             GLint r = (GLint) (rgbaFloat[k][RCOMP] * CHAN_MAXF);
 495             GLint g = (GLint) (rgbaFloat[k][GCOMP] * CHAN_MAXF);
 496             GLint b = (GLint) (rgbaFloat[k][BCOMP] * CHAN_MAXF);
 497             GLint a = (GLint) (rgbaFloat[k][ACOMP] * CHAN_MAXF);
 498             span.color.rgba[k][RCOMP] = (GLchan) CLAMP(r, 0, CHAN_MAX);
 499             span.color.rgba[k][GCOMP] = (GLchan) CLAMP(g, 0, CHAN_MAX);
 500             span.color.rgba[k][BCOMP] = (GLchan) CLAMP(b, 0, CHAN_MAX);
 501             span.color.rgba[k][ACOMP] = (GLchan) CLAMP(a, 0, CHAN_MAX);
 502          }
 503          UNDEFARRAY(rgbaFloat);  /* mac 32k limitation */
 504       }
 505
 506       if (ctx->Pixel.PixelTextureEnabled && ctx->Texture._ReallyEnabled) {
 507          span.end = width;
 508          _swrast_pixel_texture(ctx, &span);
 509       }
 510
 511       if (quick_draw && dy >= 0 && dy < ctx->DrawBuffer->Height) {
 512          (*swrast->Driver.WriteRGBASpan)( ctx, width, destx, dy,
 513                                        (const GLchan (*)[4])span.color.rgba, NULL );
 514       }
 515       else if (zoom) {
 516          span.x = destx;
 517          span.y = dy;
 518          span.end = width;
 519          _mesa_write_zoomed_rgba_span(ctx, &span,
 520                                      (CONST GLchan (*)[4]) span.color.rgba,
 521                                      desty);
 522       }
 523       else {
 524          span.x = destx;
 525          span.y = dy;
 526          span.end = width;
 527          _mesa_write_rgba_span(ctx, &span, GL_BITMAP);
 528       }
 529    }
 530
 531    /* Restore pixel source to be the draw buffer (for blending, etc) */
 532    (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
 533                                  ctx->Color.DriverDrawBuffer );
 534
 535    if (overlapping)
 536       FREE(tmpImage);
 537 }
 538
 539
 540 static void copy_ci_pixels( GLcontext *ctx,
 541                             GLint srcx, GLint srcy, GLint width, GLint height,
 542                             GLint destx, GLint desty )
 543 {
 544    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 545    GLuint *tmpImage,*p;
 546    GLint sy, dy, stepy;
 547    GLint j;
 548    GLboolean changeBuffer;
 549    const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
 550    const GLboolean shift_or_offset = ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset;
 551    GLint overlapping;
 552    struct sw_span span;
 553
 554    INIT_SPAN(span);
 555    span.arrayMask |= SPAN_INDEX;
 556
 557    /* Determine if copy should be bottom-to-top or top-to-bottom */
 558    if (srcy<desty) {
 559       /* top-down  max-to-min */
 560       sy = srcy + height - 1;
 561       dy = desty + height - 1;
 562       stepy = -1;
 563    }
 564    else {
 565       /* bottom-up  min-to-max */
 566       sy = srcy;
 567       dy = desty;
 568       stepy = 1;
 569    }
 570
 571    overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
 572                                  ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
 573
 574    if (ctx->Depth.Test)
 575       _mesa_span_default_z(ctx, &span);
 576    if (ctx->Fog.Enabled)
 577       _mesa_span_default_fog(ctx, &span);
 578
 579    /* If read and draw buffer are different we must do buffer switching */
 580    changeBuffer = ctx->Pixel.ReadBuffer != ctx->Color.DrawBuffer
 581                || ctx->DrawBuffer != ctx->ReadBuffer;
 582
 583    (*swrast->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
 584                                  ctx->Pixel.DriverReadBuffer );
 585
 586    if (overlapping) {
 587       GLint ssy = sy;
 588       tmpImage = (GLuint *) MALLOC(width * height * sizeof(GLuint));
 589       if (!tmpImage) {
 590          _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
 591          return;
 592       }
 593       p = tmpImage;
 594       if (changeBuffer) {
 595          (*swrast->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
 596                                        ctx->Pixel.DriverReadBuffer );
 597       }
 598       for (j = 0; j < height; j++, ssy += stepy) {
 599          _mesa_read_index_span( ctx, ctx->ReadBuffer, width, srcx, ssy, p );
 600          p += width;
 601       }
 602       p = tmpImage;
 603    }
 604    else {
 605       tmpImage = NULL;  /* silence compiler warning */
 606       p = NULL;
 607    }
 608
 609    for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
 610       if (overlapping) {
 611          MEMCPY(span.color.index, p, width * sizeof(GLuint));
 612          p += width;
 613       }
 614       else {
 615          if (changeBuffer) {
 616             (*swrast->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
 617                                           ctx->Pixel.DriverReadBuffer );
 618          }
 619          _mesa_read_index_span( ctx, ctx->ReadBuffer, width, srcx, sy,
 620                                 span.color.index );
 621       }
 622
 623       if (changeBuffer) {
 624          /* set read buffer back to draw buffer (in case of logicops) */
 625          (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
 626                                        ctx->Color.DriverDrawBuffer );
 627       }
 628
 629       if (shift_or_offset) {
 630          _mesa_shift_and_offset_ci( ctx, width, span.color.index );
 631       }
 632       if (ctx->Pixel.MapColorFlag) {
 633          _mesa_map_ci( ctx, width, span.color.index );
 634       }
 635
 636       span.x = destx;
 637       span.y = dy;
 638       span.end = width;
 639       if (zoom)
 640          _mesa_write_zoomed_index_span(ctx, &span, desty);
 641       else
 642          _mesa_write_index_span(ctx, &span, GL_BITMAP);
 643    }
 644
 645    /* Restore pixel source to be the draw buffer (for blending, etc) */
 646    (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
 647                                  ctx->Color.DriverDrawBuffer );
 648
 649    if (overlapping)
 650       FREE(tmpImage);
 651 }
 652
 653
 654
 655 /*
 656  * TODO: Optimize!!!!
 657  */
 658 static void copy_depth_pixels( GLcontext *ctx, GLint srcx, GLint srcy,
 659                                GLint width, GLint height,
 660                                GLint destx, GLint desty )
 661 {
 662    GLfloat depth[MAX_WIDTH];
 663    GLfloat *p, *tmpImage;
 664    GLint sy, dy, stepy;
 665    GLint i, j;
 666    const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
 667    GLint overlapping;
 668    struct sw_span span;
 669
 670    INIT_SPAN(span);
 671    span.arrayMask |= SPAN_Z;
 672
 673    if (!ctx->Visual.depthBits) {
 674       _mesa_error( ctx, GL_INVALID_OPERATION, "glCopyPixels" );
 675       return;
 676    }
 677
 678    /* Determine if copy should be bottom-to-top or top-to-bottom */
 679    if (srcy<desty) {
 680       /* top-down  max-to-min */
 681       sy = srcy + height - 1;
 682       dy = desty + height - 1;
 683       stepy = -1;
 684    }
 685    else {
 686       /* bottom-up  min-to-max */
 687       sy = srcy;
 688       dy = desty;
 689       stepy = 1;
 690    }
 691
 692    overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
 693                                  ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
 694
 695    _mesa_span_default_color(ctx, &span);
 696    if (ctx->Fog.Enabled)
 697       _mesa_span_default_fog(ctx, &span);
 698
 699    if (overlapping) {
 700       GLint ssy = sy;
 701       tmpImage = (GLfloat *) MALLOC(width * height * sizeof(GLfloat));
 702       if (!tmpImage) {
 703          _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
 704          return;
 705       }
 706       p = tmpImage;
 707       for (j = 0; j < height; j++, ssy += stepy) {
 708          _mesa_read_depth_span_float(ctx, width, srcx, ssy, p);
 709          p += width;
 710       }
 711       p = tmpImage;
 712    }
 713    else {
 714       tmpImage = NULL;  /* silence compiler warning */
 715       p = NULL;
 716    }
 717
 718    for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
 719       if (overlapping) {
 720          MEMCPY(depth, p, width * sizeof(GLfloat));
 721          p += width;
 722       }
 723       else {
 724          _mesa_read_depth_span_float(ctx, width, srcx, sy, depth);
 725       }
 726
 727       for (i = 0; i < width; i++) {
 728          GLfloat d = depth[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
 729          span.zArray[i] = (GLdepth) (CLAMP(d, 0.0F, 1.0F) * ctx->DepthMax);
 730       }
 731
 732       span.x = destx;
 733       span.y = dy;
 734       span.end = width;
 735       if (ctx->Visual.rgbMode) {
 736          if (zoom)
 737             _mesa_write_zoomed_rgba_span( ctx, &span,
 738                                           (const GLchan (*)[4])span.color.rgba,
 739                                           desty );
 740          else
 741             _mesa_write_rgba_span(ctx, &span, GL_BITMAP);
 742       }
 743       else {
 744          if (zoom)
 745             _mesa_write_zoomed_index_span( ctx, &span, desty );
 746          else
 747             _mesa_write_index_span(ctx, &span, GL_BITMAP);
 748       }
 749    }
 750
 751    if (overlapping)
 752       FREE(tmpImage);
 753 }
 754
 755
 756
 757 static void copy_stencil_pixels( GLcontext *ctx, GLint srcx, GLint srcy,
 758                                  GLint width, GLint height,
 759                                  GLint destx, GLint desty )
 760 {
 761    GLint sy, dy, stepy;
 762    GLint j;
 763    GLstencil *p, *tmpImage;
 764    const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
 765    const GLboolean shift_or_offset = ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset;
 766    GLint overlapping;
 767
 768    if (!ctx->Visual.stencilBits) {
 769       _mesa_error( ctx, GL_INVALID_OPERATION, "glCopyPixels" );
 770       return;
 771    }
 772
 773    /* Determine if copy should be bottom-to-top or top-to-bottom */
 774    if (srcy < desty) {
 775       /* top-down  max-to-min */
 776       sy = srcy + height - 1;
 777       dy = desty + height - 1;
 778       stepy = -1;
 779    }
 780    else {
 781       /* bottom-up  min-to-max */
 782       sy = srcy;
 783       dy = desty;
 784       stepy = 1;
 785    }
 786
 787    overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
 788                                  ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
 789
 790    if (overlapping) {
 791       GLint ssy = sy;
 792       tmpImage = (GLstencil *) MALLOC(width * height * sizeof(GLstencil));
 793       if (!tmpImage) {
 794          _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
 795          return;
 796       }
 797       p = tmpImage;
 798       for (j = 0; j < height; j++, ssy += stepy) {
 799          _mesa_read_stencil_span( ctx, width, srcx, ssy, p );
 800          p += width;
 801       }
 802       p = tmpImage;
 803    }
 804    else {
 805       tmpImage = NULL;  /* silence compiler warning */
 806       p = NULL;
 807    }
 808
 809    for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
 810       GLstencil stencil[MAX_WIDTH];
 811
 812       if (overlapping) {
 813          MEMCPY(stencil, p, width * sizeof(GLstencil));
 814          p += width;
 815       }
 816       else {
 817          _mesa_read_stencil_span( ctx, width, srcx, sy, stencil );
 818       }
 819
 820       if (shift_or_offset) {
 821          _mesa_shift_and_offset_stencil( ctx, width, stencil );
 822       }
 823       if (ctx->Pixel.MapStencilFlag) {
 824          _mesa_map_stencil( ctx, width, stencil );
 825       }
 826
 827       if (zoom) {
 828          _mesa_write_zoomed_stencil_span( ctx, width, destx, dy, stencil, desty );
 829       }
 830       else {
 831          _mesa_write_stencil_span( ctx, width, destx, dy, stencil );
 832       }
 833    }
 834
 835    if (overlapping)
 836       FREE(tmpImage);
 837 }
 838
 839
 840
 841
 842 void
 843 _swrast_CopyPixels( GLcontext *ctx,
 844                     GLint srcx, GLint srcy, GLsizei width, GLsizei height,
 845                     GLint destx, GLint desty,
 846                     GLenum type )
 847 {
 848    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 849    RENDER_START(swrast,ctx);
 850
 851    if (swrast->NewState)
 852       _swrast_validate_derived( ctx );
 853
 854    if (type == GL_COLOR && ctx->Visual.rgbMode) {
 855       copy_rgba_pixels( ctx, srcx, srcy, width, height, destx, desty );
 856    }
 857    else if (type == GL_COLOR && !ctx->Visual.rgbMode) {
 858       copy_ci_pixels( ctx, srcx, srcy, width, height, destx, desty );
 859    }
 860    else if (type == GL_DEPTH) {
 861       copy_depth_pixels( ctx, srcx, srcy, width, height, destx, desty );
 862    }
 863    else if (type == GL_STENCIL) {
 864       copy_stencil_pixels( ctx, srcx, srcy, width, height, destx, desty );
 865    }
 866    else {
 867       _mesa_error( ctx, GL_INVALID_ENUM, "glCopyPixels" );
 868    }
 869
 870    RENDER_FINISH(swrast,ctx);
 871 }