src/mesa/swrast/s_drawpix.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.1
   4  *
   5  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25
  26 #include "main/glheader.h"
  27 #include "main/bufferobj.h"
  28 #include "main/colormac.h"
  29 #include "main/condrender.h"
  30 #include "main/context.h"
  31 #include "main/format_pack.h"
  32 #include "main/image.h"
  33 #include "main/imports.h"
  34 #include "main/macros.h"
  35 #include "main/pack.h"
  36 #include "main/pbo.h"
  37 #include "main/pixeltransfer.h"
  38 #include "main/state.h"
  39
  40 #include "s_context.h"
  41 #include "s_span.h"
  42 #include "s_stencil.h"
  43 #include "s_zoom.h"
  44
  45
  46 /**
  47  * Handle a common case of drawing GL_RGB/GL_UNSIGNED_BYTE into a
  48  * MESA_FORMAT_XRGB888 or MESA_FORMAT_ARGB888 renderbuffer.
  49  */
  50 static void
  51 fast_draw_rgb_ubyte_pixels(struct gl_context *ctx,
  52                            struct gl_renderbuffer *rb,
  53                            GLint x, GLint y,
  54                            GLsizei width, GLsizei height,
  55                            const struct gl_pixelstore_attrib *unpack,
  56                            const GLvoid *pixels)
  57 {
  58    const GLubyte *src = (const GLubyte *)
  59       _mesa_image_address2d(unpack, pixels, width,
  60                             height, GL_RGB, GL_UNSIGNED_BYTE, 0, 0);
  61    const GLint srcRowStride = _mesa_image_row_stride(unpack, width,
  62                                                      GL_RGB, GL_UNSIGNED_BYTE);
  63    GLint i, j;
  64    GLubyte *dst;
  65    GLint dstRowStride;
  66
  67    ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height,
  68                                GL_MAP_WRITE_BIT, &dst, &dstRowStride);
  69
  70    if (!dst) {
  71       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDrawPixels");
  72       return;
  73    }
  74
  75    if (ctx->Pixel.ZoomY == -1.0f) {
  76       dst = dst + (height - 1) * dstRowStride;
  77       dstRowStride = -dstRowStride;
  78    }
  79
  80    for (i = 0; i < height; i++) {
  81       GLuint *dst4 = (GLuint *) dst;
  82       for (j = 0; j < width; j++) {
  83          dst4[j] = PACK_COLOR_8888(0xff, src[j*3+0], src[j*3+1], src[j*3+2]);
  84       }
  85       dst += dstRowStride;
  86       src += srcRowStride;
  87    }
  88
  89    ctx->Driver.UnmapRenderbuffer(ctx, rb);
  90 }
  91
  92
  93 /**
  94  * Handle a common case of drawing GL_RGBA/GL_UNSIGNED_BYTE into a
  95  * MESA_FORMAT_ARGB888 or MESA_FORMAT_xRGB888 renderbuffer.
  96  */
  97 static void
  98 fast_draw_rgba_ubyte_pixels(struct gl_context *ctx,
  99                            struct gl_renderbuffer *rb,
 100                            GLint x, GLint y,
 101                            GLsizei width, GLsizei height,
 102                            const struct gl_pixelstore_attrib *unpack,
 103                            const GLvoid *pixels)
 104 {
 105    const GLubyte *src = (const GLubyte *)
 106       _mesa_image_address2d(unpack, pixels, width,
 107                             height, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
 108    const GLint srcRowStride =
 109       _mesa_image_row_stride(unpack, width, GL_RGBA, GL_UNSIGNED_BYTE);
 110    GLint i, j;
 111    GLubyte *dst;
 112    GLint dstRowStride;
 113
 114    ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height,
 115                                GL_MAP_WRITE_BIT, &dst, &dstRowStride);
 116
 117    if (!dst) {
 118       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDrawPixels");
 119       return;
 120    }
 121
 122    if (ctx->Pixel.ZoomY == -1.0f) {
 123       dst = dst + (height - 1) * dstRowStride;
 124       dstRowStride = -dstRowStride;
 125    }
 126
 127    for (i = 0; i < height; i++) {
 128       GLuint *dst4 = (GLuint *) dst;
 129       for (j = 0; j < width; j++) {
 130          dst4[j] = PACK_COLOR_8888(src[j*4+3], src[j*4+0],
 131                                    src[j*4+1], src[j*4+2]);
 132       }
 133       dst += dstRowStride;
 134       src += srcRowStride;
 135    }
 136
 137    ctx->Driver.UnmapRenderbuffer(ctx, rb);
 138 }
 139
 140
 141 /**
 142  * Handle a common case of drawing a format/type combination that
 143  * exactly matches the renderbuffer format.
 144  */
 145 static void
 146 fast_draw_generic_pixels(struct gl_context *ctx,
 147                          struct gl_renderbuffer *rb,
 148                          GLint x, GLint y,
 149                          GLsizei width, GLsizei height,
 150                          GLenum format, GLenum type,
 151                          const struct gl_pixelstore_attrib *unpack,
 152                          const GLvoid *pixels)
 153 {
 154    const GLubyte *src = (const GLubyte *)
 155       _mesa_image_address2d(unpack, pixels, width,
 156                             height, format, type, 0, 0);
 157    const GLint srcRowStride =
 158       _mesa_image_row_stride(unpack, width, format, type);
 159    const GLint rowLength = width * _mesa_get_format_bytes(rb->Format);
 160    GLint i;
 161    GLubyte *dst;
 162    GLint dstRowStride;
 163
 164    ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height,
 165                                GL_MAP_WRITE_BIT, &dst, &dstRowStride);
 166
 167    if (!dst) {
 168       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDrawPixels");
 169       return;
 170    }
 171
 172    if (ctx->Pixel.ZoomY == -1.0f) {
 173       dst = dst + (height - 1) * dstRowStride;
 174       dstRowStride = -dstRowStride;
 175    }
 176
 177    for (i = 0; i < height; i++) {
 178       memcpy(dst, src, rowLength);
 179       dst += dstRowStride;
 180       src += srcRowStride;
 181    }
 182
 183    ctx->Driver.UnmapRenderbuffer(ctx, rb);
 184 }
 185
 186
 187 /**
 188  * Try to do a fast and simple RGB(a) glDrawPixels.
 189  * Return:  GL_TRUE if success, GL_FALSE if slow path must be used instead
 190  */
 191 static GLboolean
 192 fast_draw_rgba_pixels(struct gl_context *ctx, GLint x, GLint y,
 193                       GLsizei width, GLsizei height,
 194                       GLenum format, GLenum type,
 195                       const struct gl_pixelstore_attrib *userUnpack,
 196                       const GLvoid *pixels)
 197 {
 198    struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0];
 199    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 200    struct gl_pixelstore_attrib unpack;
 201
 202    if (!rb)
 203       return GL_TRUE; /* no-op */
 204
 205    if (ctx->DrawBuffer->_NumColorDrawBuffers > 1 ||
 206        (swrast->_RasterMask & ~CLIP_BIT) ||
 207        ctx->Texture._EnabledCoordUnits ||
 208        userUnpack->SwapBytes ||
 209        ctx->Pixel.ZoomX != 1.0f ||
 210        fabsf(ctx->Pixel.ZoomY) != 1.0f ||
 211        ctx->_ImageTransferState) {
 212       /* can't handle any of those conditions */
 213       return GL_FALSE;
 214    }
 215
 216    unpack = *userUnpack;
 217
 218    /* clipping */
 219    if (!_mesa_clip_drawpixels(ctx, &x, &y, &width, &height, &unpack)) {
 220       /* image was completely clipped: no-op, all done */
 221       return GL_TRUE;
 222    }
 223
 224    if (format == GL_RGB &&
 225        type == GL_UNSIGNED_BYTE &&
 226        (rb->Format == MESA_FORMAT_XRGB8888 ||
 227         rb->Format == MESA_FORMAT_ARGB8888)) {
 228       fast_draw_rgb_ubyte_pixels(ctx, rb, x, y, width, height,
 229                                  &unpack, pixels);
 230       return GL_TRUE;
 231    }
 232
 233    if (format == GL_RGBA &&
 234        type == GL_UNSIGNED_BYTE &&
 235        (rb->Format == MESA_FORMAT_XRGB8888 ||
 236         rb->Format == MESA_FORMAT_ARGB8888)) {
 237       fast_draw_rgba_ubyte_pixels(ctx, rb, x, y, width, height,
 238                                   &unpack, pixels);
 239       return GL_TRUE;
 240    }
 241
 242    if (_mesa_format_matches_format_and_type(rb->Format, format, type,
 243                                             ctx->Unpack.SwapBytes)) {
 244       fast_draw_generic_pixels(ctx, rb, x, y, width, height,
 245                                format, type, &unpack, pixels);
 246       return GL_TRUE;
 247    }
 248
 249    /* can't handle this pixel format and/or data type */
 250    return GL_FALSE;
 251 }
 252
 253
 254
 255 /*
 256  * Draw stencil image.
 257  */
 258 static void
 259 draw_stencil_pixels( struct gl_context *ctx, GLint x, GLint y,
 260                      GLsizei width, GLsizei height,
 261                      GLenum type,
 262                      const struct gl_pixelstore_attrib *unpack,
 263                      const GLvoid *pixels )
 264 {
 265    const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;
 266    const GLenum destType = GL_UNSIGNED_BYTE;
 267    GLint row;
 268    GLubyte *values;
 269
 270    values = malloc(width * sizeof(GLubyte));
 271    if (!values) {
 272       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDrawPixels");
 273       return;
 274    }
 275
 276    for (row = 0; row < height; row++) {
 277       const GLvoid *source = _mesa_image_address2d(unpack, pixels,
 278                                                    width, height,
 279                                                    GL_STENCIL_INDEX, type,
 280                                                    row, 0);
 281       _mesa_unpack_stencil_span(ctx, width, destType, values,
 282                                 type, source, unpack,
 283                                 ctx->_ImageTransferState);
 284       if (zoom) {
 285          _swrast_write_zoomed_stencil_span(ctx, x, y, width,
 286                                            x, y, values);
 287       }
 288       else {
 289          _swrast_write_stencil_span(ctx, width, x, y, values);
 290       }
 291
 292       y++;
 293    }
 294
 295    free(values);
 296 }
 297
 298
 299 /*
 300  * Draw depth image.
 301  */
 302 static void
 303 draw_depth_pixels( struct gl_context *ctx, GLint x, GLint y,
 304                    GLsizei width, GLsizei height,
 305                    GLenum type,
 306                    const struct gl_pixelstore_attrib *unpack,
 307                    const GLvoid *pixels )
 308 {
 309    const GLboolean scaleOrBias
 310       = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;
 311    const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;
 312    SWspan span;
 313
 314    INIT_SPAN(span, GL_BITMAP);
 315    span.arrayMask = SPAN_Z;
 316    _swrast_span_default_attribs(ctx, &span);
 317
 318    if (type == GL_UNSIGNED_SHORT
 319        && ctx->DrawBuffer->Visual.depthBits == 16
 320        && !scaleOrBias
 321        && !zoom
 322        && width <= SWRAST_MAX_WIDTH
 323        && !unpack->SwapBytes) {
 324       /* Special case: directly write 16-bit depth values */
 325       GLint row;
 326       for (row = 0; row < height; row++) {
 327          const GLushort *zSrc = (const GLushort *)
 328             _mesa_image_address2d(unpack, pixels, width, height,
 329                                   GL_DEPTH_COMPONENT, type, row, 0);
 330          GLint i;
 331          for (i = 0; i < width; i++)
 332             span.array->z[i] = zSrc[i];
 333          span.x = x;
 334          span.y = y + row;
 335          span.end = width;
 336          _swrast_write_rgba_span(ctx, &span);
 337       }
 338    }
 339    else if (type == GL_UNSIGNED_INT
 340             && !scaleOrBias
 341             && !zoom
 342             && width <= SWRAST_MAX_WIDTH
 343             && !unpack->SwapBytes) {
 344       /* Special case: shift 32-bit values down to Visual.depthBits */
 345       const GLint shift = 32 - ctx->DrawBuffer->Visual.depthBits;
 346       GLint row;
 347       for (row = 0; row < height; row++) {
 348          const GLuint *zSrc = (const GLuint *)
 349             _mesa_image_address2d(unpack, pixels, width, height,
 350                                   GL_DEPTH_COMPONENT, type, row, 0);
 351          if (shift == 0) {
 352             memcpy(span.array->z, zSrc, width * sizeof(GLuint));
 353          }
 354          else {
 355             GLint col;
 356             for (col = 0; col < width; col++)
 357                span.array->z[col] = zSrc[col] >> shift;
 358          }
 359          span.x = x;
 360          span.y = y + row;
 361          span.end = width;
 362          _swrast_write_rgba_span(ctx, &span);
 363       }
 364    }
 365    else {
 366       /* General case */
 367       const GLuint depthMax = ctx->DrawBuffer->_DepthMax;
 368       GLint skipPixels = 0;
 369
 370       /* in case width > SWRAST_MAX_WIDTH do the copy in chunks */
 371       while (skipPixels < width) {
 372          const GLint spanWidth = MIN2(width - skipPixels, SWRAST_MAX_WIDTH);
 373          GLint row;
 374          ASSERT(span.end <= SWRAST_MAX_WIDTH);
 375          for (row = 0; row < height; row++) {
 376             const GLvoid *zSrc = _mesa_image_address2d(unpack,
 377                                                       pixels, width, height,
 378                                                       GL_DEPTH_COMPONENT, type,
 379                                                       row, skipPixels);
 380
 381             /* Set these for each row since the _swrast_write_* function may
 382              * change them while clipping.
 383              */
 384             span.x = x + skipPixels;
 385             span.y = y + row;
 386             span.end = spanWidth;
 387
 388             _mesa_unpack_depth_span(ctx, spanWidth,
 389                                     GL_UNSIGNED_INT, span.array->z, depthMax,
 390                                     type, zSrc, unpack);
 391             if (zoom) {
 392                _swrast_write_zoomed_depth_span(ctx, x, y, &span);
 393             }
 394             else {
 395                _swrast_write_rgba_span(ctx, &span);
 396             }
 397          }
 398          skipPixels += spanWidth;
 399       }
 400    }
 401 }
 402
 403
 404
 405 /**
 406  * Draw RGBA image.
 407  */
 408 static void
 409 draw_rgba_pixels( struct gl_context *ctx, GLint x, GLint y,
 410                   GLsizei width, GLsizei height,
 411                   GLenum format, GLenum type,
 412                   const struct gl_pixelstore_attrib *unpack,
 413                   const GLvoid *pixels )
 414 {
 415    const GLint imgX = x, imgY = y;
 416    const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0;
 417    GLfloat *convImage = NULL;
 418    GLbitfield transferOps = ctx->_ImageTransferState;
 419    SWspan span;
 420
 421    /* Try an optimized glDrawPixels first */
 422    if (fast_draw_rgba_pixels(ctx, x, y, width, height, format, type,
 423                              unpack, pixels)) {
 424       return;
 425    }
 426
 427    swrast_render_start(ctx);
 428
 429    INIT_SPAN(span, GL_BITMAP);
 430    _swrast_span_default_attribs(ctx, &span);
 431    span.arrayMask = SPAN_RGBA;
 432    span.arrayAttribs = FRAG_BIT_COL0; /* we're fill in COL0 attrib values */
 433
 434    if (ctx->DrawBuffer->_NumColorDrawBuffers > 0) {
 435       GLenum datatype = _mesa_get_format_datatype(
 436                  ctx->DrawBuffer->_ColorDrawBuffers[0]->Format);
 437       if (datatype != GL_FLOAT &&
 438           ctx->Color.ClampFragmentColor != GL_FALSE) {
 439          /* need to clamp colors before applying fragment ops */
 440          transferOps |= IMAGE_CLAMP_BIT;
 441       }
 442    }
 443
 444    /*
 445     * General solution
 446     */
 447    {
 448       const GLbitfield interpMask = span.interpMask;
 449       const GLbitfield arrayMask = span.arrayMask;
 450       const GLint srcStride
 451          = _mesa_image_row_stride(unpack, width, format, type);
 452       GLint skipPixels = 0;
 453       /* use span array for temp color storage */
 454       GLfloat *rgba = (GLfloat *) span.array->attribs[FRAG_ATTRIB_COL0];
 455
 456       /* if the span is wider than SWRAST_MAX_WIDTH we have to do it in chunks */
 457       while (skipPixels < width) {
 458          const GLint spanWidth = MIN2(width - skipPixels, SWRAST_MAX_WIDTH);
 459          const GLubyte *source
 460             = (const GLubyte *) _mesa_image_address2d(unpack, pixels,
 461                                                       width, height, format,
 462                                                       type, 0, skipPixels);
 463          GLint row;
 464
 465          for (row = 0; row < height; row++) {
 466             /* get image row as float/RGBA */
 467             _mesa_unpack_color_span_float(ctx, spanWidth, GL_RGBA, rgba,
 468                                      format, type, source, unpack,
 469                                      transferOps);
 470             /* Set these for each row since the _swrast_write_* functions
 471              * may change them while clipping/rendering.
 472              */
 473             span.array->ChanType = GL_FLOAT;
 474             span.x = x + skipPixels;
 475             span.y = y + row;
 476             span.end = spanWidth;
 477             span.arrayMask = arrayMask;
 478             span.interpMask = interpMask;
 479             if (zoom) {
 480                _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span, rgba);
 481             }
 482             else {
 483                _swrast_write_rgba_span(ctx, &span);
 484             }
 485
 486             source += srcStride;
 487          } /* for row */
 488
 489          skipPixels += spanWidth;
 490       } /* while skipPixels < width */
 491
 492       /* XXX this is ugly/temporary, to undo above change */
 493       span.array->ChanType = CHAN_TYPE;
 494    }
 495
 496    if (convImage) {
 497       free(convImage);
 498    }
 499
 500    swrast_render_finish(ctx);
 501 }
 502
 503
 504 /**
 505  * Draw depth+stencil values into a MESA_FORAMT_Z24_S8 or MESA_FORMAT_S8_Z24
 506  * renderbuffer.  No masking, zooming, scaling, etc.
 507  */
 508 static void
 509 fast_draw_depth_stencil(struct gl_context *ctx, GLint x, GLint y,
 510                         GLsizei width, GLsizei height,
 511                         const struct gl_pixelstore_attrib *unpack,
 512                         const GLvoid *pixels)
 513 {
 514    const GLenum format = GL_DEPTH_STENCIL_EXT;
 515    const GLenum type = GL_UNSIGNED_INT_24_8;
 516    struct gl_renderbuffer *rb =
 517       ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
 518    struct swrast_renderbuffer *srb = swrast_renderbuffer(rb);
 519    GLubyte *src, *dst;
 520    GLint srcRowStride, dstRowStride;
 521    GLint i;
 522
 523    src = _mesa_image_address2d(unpack, pixels, width, height,
 524                                format, type, 0, 0);
 525    srcRowStride = _mesa_image_row_stride(unpack, width, format, type);
 526
 527    dst = _swrast_pixel_address(rb, x, y);
 528    dstRowStride = srb->RowStride;
 529
 530    for (i = 0; i < height; i++) {
 531       _mesa_pack_uint_24_8_depth_stencil_row(rb->Format, width,
 532                                              (const GLuint *) src, dst);
 533       dst += dstRowStride;
 534       src += srcRowStride;
 535    }
 536 }
 537
 538
 539
 540 /**
 541  * This is a bit different from drawing GL_DEPTH_COMPONENT pixels.
 542  * The only per-pixel operations that apply are depth scale/bias,
 543  * stencil offset/shift, GL_DEPTH_WRITEMASK and GL_STENCIL_WRITEMASK,
 544  * and pixel zoom.
 545  * Also, only the depth buffer and stencil buffers are touched, not the
 546  * color buffer(s).
 547  */
 548 static void
 549 draw_depth_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,
 550                           GLsizei width, GLsizei height, GLenum type,
 551                           const struct gl_pixelstore_attrib *unpack,
 552                           const GLvoid *pixels)
 553 {
 554    const GLint imgX = x, imgY = y;
 555    const GLboolean scaleOrBias
 556       = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;
 557    const GLuint stencilMask = ctx->Stencil.WriteMask[0];
 558    const GLenum stencilType = GL_UNSIGNED_BYTE;
 559    const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;
 560    struct gl_renderbuffer *depthRb, *stencilRb;
 561    struct gl_pixelstore_attrib clippedUnpack = *unpack;
 562
 563    if (!zoom) {
 564       if (!_mesa_clip_drawpixels(ctx, &x, &y, &width, &height,
 565                                  &clippedUnpack)) {
 566          /* totally clipped */
 567          return;
 568       }
 569    }
 570
 571    depthRb = ctx->ReadBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
 572    stencilRb = ctx->ReadBuffer->Attachment[BUFFER_STENCIL].Renderbuffer;
 573    ASSERT(depthRb);
 574    ASSERT(stencilRb);
 575
 576    if (depthRb == stencilRb &&
 577        (depthRb->Format == MESA_FORMAT_Z24_S8 ||
 578         depthRb->Format == MESA_FORMAT_S8_Z24) &&
 579        type == GL_UNSIGNED_INT_24_8 &&
 580        !scaleOrBias &&
 581        !zoom &&
 582        ctx->Depth.Mask &&
 583        (stencilMask & 0xff) == 0xff) {
 584       fast_draw_depth_stencil(ctx, x, y, width, height,
 585                               &clippedUnpack, pixels);
 586    }
 587    else {
 588       /* sub-optimal cases:
 589        * Separate depth/stencil buffers, or pixel transfer ops required.
 590        */
 591       /* XXX need to handle very wide images (skippixels) */
 592       GLuint *zValues;  /* 32-bit Z values */
 593       GLint i;
 594
 595       zValues = malloc(width * sizeof(GLuint));
 596       if (!zValues) {
 597          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDrawPixels");
 598          return;
 599       }
 600
 601       for (i = 0; i < height; i++) {
 602          const GLuint *depthStencilSrc = (const GLuint *)
 603             _mesa_image_address2d(&clippedUnpack, pixels, width, height,
 604                                   GL_DEPTH_STENCIL_EXT, type, i, 0);
 605
 606          if (ctx->Depth.Mask) {
 607             _mesa_unpack_depth_span(ctx, width,
 608                                     GL_UNSIGNED_INT, /* dest type */
 609                                     zValues,         /* dest addr */
 610                                     0xffffffff,      /* depth max */
 611                                     type,            /* src type */
 612                                     depthStencilSrc, /* src addr */
 613                                     &clippedUnpack);
 614             if (zoom) {
 615                _swrast_write_zoomed_z_span(ctx, imgX, imgY, width, x,
 616                                            y + i, zValues);
 617             }
 618             else {
 619                GLubyte *dst = _swrast_pixel_address(depthRb, x, y + i);
 620                _mesa_pack_uint_z_row(depthRb->Format, width, zValues, dst);
 621             }
 622          }
 623
 624          if (stencilMask != 0x0) {
 625             GLubyte *stencilValues = (GLubyte *) zValues; /* re-use buffer */
 626             /* get stencil values, with shift/offset/mapping */
 627             _mesa_unpack_stencil_span(ctx, width, stencilType, stencilValues,
 628                                       type, depthStencilSrc, &clippedUnpack,
 629                                       ctx->_ImageTransferState);
 630             if (zoom)
 631                _swrast_write_zoomed_stencil_span(ctx, imgX, imgY, width,
 632                                                   x, y + i, stencilValues);
 633             else
 634                _swrast_write_stencil_span(ctx, width, x, y + i, stencilValues);
 635          }
 636       }
 637
 638       free(zValues);
 639    }
 640 }
 641
 642
 643 /**
 644  * Execute software-based glDrawPixels.
 645  * By time we get here, all error checking will have been done.
 646  */
 647 void
 648 _swrast_DrawPixels( struct gl_context *ctx,
 649                     GLint x, GLint y,
 650                     GLsizei width, GLsizei height,
 651                     GLenum format, GLenum type,
 652                     const struct gl_pixelstore_attrib *unpack,
 653                     const GLvoid *pixels )
 654 {
 655    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 656    GLboolean save_vp_override = ctx->VertexProgram._Overriden;
 657
 658    if (!_mesa_check_conditional_render(ctx))
 659       return; /* don't draw */
 660
 661    /* We are creating fragments directly, without going through vertex
 662     * programs.
 663     *
 664     * This override flag tells the fragment processing code that its input
 665     * comes from a non-standard source, and it may therefore not rely on
 666     * optimizations that assume e.g. constant color if there is no color
 667     * vertex array.
 668     */
 669    _mesa_set_vp_override(ctx, GL_TRUE);
 670
 671    if (ctx->NewState)
 672       _mesa_update_state(ctx);
 673
 674    if (swrast->NewState)
 675       _swrast_validate_derived( ctx );
 676
 677    pixels = _mesa_map_pbo_source(ctx, unpack, pixels);
 678    if (!pixels) {
 679       _mesa_set_vp_override(ctx, save_vp_override);
 680       return;
 681    }
 682
 683    /*
 684     * By time we get here, all error checking should have been done.
 685     */
 686    switch (format) {
 687    case GL_STENCIL_INDEX:
 688       swrast_render_start(ctx);
 689       draw_stencil_pixels( ctx, x, y, width, height, type, unpack, pixels );
 690       swrast_render_finish(ctx);
 691       break;
 692    case GL_DEPTH_COMPONENT:
 693       swrast_render_start(ctx);
 694       draw_depth_pixels( ctx, x, y, width, height, type, unpack, pixels );
 695       swrast_render_finish(ctx);
 696       break;
 697    case GL_DEPTH_STENCIL_EXT:
 698       swrast_render_start(ctx);
 699       draw_depth_stencil_pixels(ctx, x, y, width, height, type, unpack, pixels);
 700       swrast_render_finish(ctx);
 701       break;
 702    default:
 703       /* all other formats should be color formats */
 704       draw_rgba_pixels(ctx, x, y, width, height, format, type, unpack, pixels);
 705    }
 706
 707    _mesa_set_vp_override(ctx, save_vp_override);
 708
 709    _mesa_unmap_pbo_source(ctx, unpack);
 710 }