src/mesa/swrast/s_blit.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.5
   4  *
   5  * Copyright (C) 1999-2006  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/condrender.h"
  28 #include "main/image.h"
  29 #include "main/macros.h"
  30 #include "main/format_unpack.h"
  31 #include "main/format_pack.h"
  32 #include "s_context.h"
  33
  34
  35 #define ABS(X)   ((X) < 0 ? -(X) : (X))
  36
  37
  38 /**
  39  * Generate a row resampler function for GL_NEAREST mode.
  40  */
  41 #define RESAMPLE(NAME, PIXELTYPE, SIZE)                 \
  42 static void                                             \
  43 NAME(GLint srcWidth, GLint dstWidth,                    \
  44      const GLvoid *srcBuffer, GLvoid *dstBuffer,        \
  45      GLboolean flip)                                    \
  46 {                                                       \
  47    const PIXELTYPE *src = (const PIXELTYPE *) srcBuffer;\
  48    PIXELTYPE *dst = (PIXELTYPE *) dstBuffer;            \
  49    GLint dstCol;                                        \
  50                                                         \
  51    if (flip) {                                          \
  52       for (dstCol = 0; dstCol < dstWidth; dstCol++) {   \
  53          GLint srcCol = (dstCol * srcWidth) / dstWidth; \
  54          ASSERT(srcCol >= 0);                           \
  55          ASSERT(srcCol < srcWidth);                     \
  56          srcCol = srcWidth - 1 - srcCol; /* flip */     \
  57          if (SIZE == 1) {                               \
  58             dst[dstCol] = src[srcCol];                  \
  59          }                                              \
  60          else if (SIZE == 2) {                          \
  61             dst[dstCol*2+0] = src[srcCol*2+0];          \
  62             dst[dstCol*2+1] = src[srcCol*2+1];          \
  63          }                                              \
  64          else if (SIZE == 4) {                          \
  65             dst[dstCol*4+0] = src[srcCol*4+0];          \
  66             dst[dstCol*4+1] = src[srcCol*4+1];          \
  67             dst[dstCol*4+2] = src[srcCol*4+2];          \
  68             dst[dstCol*4+3] = src[srcCol*4+3];          \
  69          }                                              \
  70       }                                                 \
  71    }                                                    \
  72    else {                                               \
  73       for (dstCol = 0; dstCol < dstWidth; dstCol++) {   \
  74          GLint srcCol = (dstCol * srcWidth) / dstWidth; \
  75          ASSERT(srcCol >= 0);                           \
  76          ASSERT(srcCol < srcWidth);                     \
  77          if (SIZE == 1) {                               \
  78             dst[dstCol] = src[srcCol];                  \
  79          }                                              \
  80          else if (SIZE == 2) {                          \
  81             dst[dstCol*2+0] = src[srcCol*2+0];          \
  82             dst[dstCol*2+1] = src[srcCol*2+1];          \
  83          }                                              \
  84          else if (SIZE == 4) {                          \
  85             dst[dstCol*4+0] = src[srcCol*4+0];          \
  86             dst[dstCol*4+1] = src[srcCol*4+1];          \
  87             dst[dstCol*4+2] = src[srcCol*4+2];          \
  88             dst[dstCol*4+3] = src[srcCol*4+3];          \
  89          }                                              \
  90       }                                                 \
  91    }                                                    \
  92 }
  93
  94 /**
  95  * Resamplers for 1, 2, 4, 8 and 16-byte pixels.
  96  */
  97 RESAMPLE(resample_row_1, GLubyte, 1)
  98 RESAMPLE(resample_row_2, GLushort, 1)
  99 RESAMPLE(resample_row_4, GLuint, 1)
 100 RESAMPLE(resample_row_8, GLuint, 2)
 101 RESAMPLE(resample_row_16, GLuint, 4)
 102
 103
 104 /**
 105  * Blit color, depth or stencil with GL_NEAREST filtering.
 106  */
 107 static void
 108 blit_nearest(struct gl_context *ctx,
 109              GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
 110              GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
 111              GLbitfield buffer)
 112 {
 113    struct gl_renderbuffer *readRb, *drawRb;
 114
 115    const GLint srcWidth = ABS(srcX1 - srcX0);
 116    const GLint dstWidth = ABS(dstX1 - dstX0);
 117    const GLint srcHeight = ABS(srcY1 - srcY0);
 118    const GLint dstHeight = ABS(dstY1 - dstY0);
 119
 120    const GLint srcXpos = MIN2(srcX0, srcX1);
 121    const GLint srcYpos = MIN2(srcY0, srcY1);
 122    const GLint dstXpos = MIN2(dstX0, dstX1);
 123    const GLint dstYpos = MIN2(dstY0, dstY1);
 124
 125    const GLboolean invertX = (srcX1 < srcX0) ^ (dstX1 < dstX0);
 126    const GLboolean invertY = (srcY1 < srcY0) ^ (dstY1 < dstY0);
 127    enum mode {
 128       DIRECT,
 129       UNPACK_RGBA_FLOAT,
 130       UNPACK_Z_FLOAT,
 131       UNPACK_Z_INT,
 132       UNPACK_S,
 133    } mode;
 134    GLubyte *srcMap, *dstMap;
 135    GLint srcRowStride, dstRowStride;
 136    GLint dstRow;
 137
 138    GLint pixelSize;
 139    GLvoid *srcBuffer, *dstBuffer;
 140    GLint prevY = -1;
 141
 142    typedef void (*resample_func)(GLint srcWidth, GLint dstWidth,
 143                                  const GLvoid *srcBuffer, GLvoid *dstBuffer,
 144                                  GLboolean flip);
 145    resample_func resampleRow;
 146
 147    switch (buffer) {
 148    case GL_COLOR_BUFFER_BIT:
 149       readRb = ctx->ReadBuffer->_ColorReadBuffer;
 150       drawRb = ctx->DrawBuffer->_ColorDrawBuffers[0];
 151
 152       if (readRb->Format == drawRb->Format) {
 153          mode = DIRECT;
 154          pixelSize = _mesa_get_format_bytes(readRb->Format);
 155       } else {
 156          mode = UNPACK_RGBA_FLOAT;
 157          pixelSize = 16;
 158       }
 159
 160       break;
 161    case GL_DEPTH_BUFFER_BIT:
 162       readRb = ctx->ReadBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
 163       drawRb = ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
 164
 165       /* Note that for depth/stencil, the formats of src/dst must match.  By
 166        * using the core helpers for pack/unpack, we avoid needing to handle
 167        * masking for things like DEPTH copies of Z24S8.
 168        */
 169       if (readRb->Format == MESA_FORMAT_Z32_FLOAT ||
 170           readRb->Format == MESA_FORMAT_Z32_FLOAT_X24S8) {
 171          mode = UNPACK_Z_FLOAT;
 172       } else {
 173          mode = UNPACK_Z_INT;
 174       }
 175       pixelSize = 4;
 176       break;
 177    case GL_STENCIL_BUFFER_BIT:
 178       readRb = ctx->ReadBuffer->Attachment[BUFFER_STENCIL].Renderbuffer;
 179       drawRb = ctx->DrawBuffer->Attachment[BUFFER_STENCIL].Renderbuffer;
 180       mode = UNPACK_S;
 181       pixelSize = 1;
 182       break;
 183    default:
 184       _mesa_problem(ctx, "unexpected buffer in blit_nearest()");
 185       return;
 186    }
 187
 188    /* choose row resampler */
 189    switch (pixelSize) {
 190    case 1:
 191       resampleRow = resample_row_1;
 192       break;
 193    case 2:
 194       resampleRow = resample_row_2;
 195       break;
 196    case 4:
 197       resampleRow = resample_row_4;
 198       break;
 199    case 8:
 200       resampleRow = resample_row_8;
 201       break;
 202    case 16:
 203       resampleRow = resample_row_16;
 204       break;
 205    default:
 206       _mesa_problem(ctx, "unexpected pixel size (%d) in blit_nearest",
 207                     pixelSize);
 208       return;
 209    }
 210
 211    if (readRb == drawRb) {
 212       /* map whole buffer for read/write */
 213       /* XXX we could be clever and just map the union region of the
 214        * source and dest rects.
 215        */
 216       GLubyte *map;
 217       GLint rowStride;
 218       GLint formatSize = _mesa_get_format_bytes(readRb->Format);
 219
 220       ctx->Driver.MapRenderbuffer(ctx, readRb, 0, 0,
 221                                   readRb->Width, readRb->Height,
 222                                   GL_MAP_READ_BIT | GL_MAP_WRITE_BIT,
 223                                   &map, &rowStride);
 224       if (!map) {
 225          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFramebuffer");
 226          return;
 227       }
 228
 229       srcMap = map + srcYpos * rowStride + srcXpos * formatSize;
 230       dstMap = map + dstYpos * rowStride + dstXpos * formatSize;
 231
 232       /* this handles overlapping copies */
 233       if (srcY0 < dstY0) {
 234          /* copy in reverse (top->down) order */
 235          srcMap += rowStride * (readRb->Height - 1);
 236          dstMap += rowStride * (readRb->Height - 1);
 237          srcRowStride = -rowStride;
 238          dstRowStride = -rowStride;
 239       }
 240       else {
 241          /* copy in normal (bottom->up) order */
 242          srcRowStride = rowStride;
 243          dstRowStride = rowStride;
 244       }
 245    }
 246    else {
 247       /* different src/dst buffers */
 248       ctx->Driver.MapRenderbuffer(ctx, readRb,
 249                                   srcXpos, srcYpos,
 250                                   srcWidth, srcHeight,
 251                                   GL_MAP_READ_BIT, &srcMap, &srcRowStride);
 252       if (!srcMap) {
 253          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFramebuffer");
 254          return;
 255       }
 256       ctx->Driver.MapRenderbuffer(ctx, drawRb,
 257                                   dstXpos, dstYpos,
 258                                   dstWidth, dstHeight,
 259                                   GL_MAP_WRITE_BIT, &dstMap, &dstRowStride);
 260       if (!dstMap) {
 261          ctx->Driver.UnmapRenderbuffer(ctx, readRb);
 262          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFramebuffer");
 263          return;
 264       }
 265    }
 266
 267    /* allocate the src/dst row buffers */
 268    srcBuffer = malloc(pixelSize * srcWidth);
 269    if (!srcBuffer) {
 270       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFrameBufferEXT");
 271       return;
 272    }
 273    dstBuffer = malloc(pixelSize * dstWidth);
 274    if (!dstBuffer) {
 275       free(srcBuffer);
 276       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFrameBufferEXT");
 277       return;
 278    }
 279
 280    for (dstRow = 0; dstRow < dstHeight; dstRow++) {
 281       GLint srcRow = (dstRow * srcHeight) / dstHeight;
 282       GLubyte *dstRowStart = dstMap + dstRowStride * dstRow;
 283
 284       ASSERT(srcRow >= 0);
 285       ASSERT(srcRow < srcHeight);
 286
 287       if (invertY) {
 288          srcRow = srcHeight - 1 - srcRow;
 289       }
 290
 291       /* get pixel row from source and resample to match dest width */
 292       if (prevY != srcRow) {
 293          GLubyte *srcRowStart = srcMap + srcRowStride * srcRow;
 294
 295          switch (mode) {
 296          case DIRECT:
 297             memcpy(srcBuffer, srcRowStart, pixelSize * srcWidth);
 298             break;
 299          case UNPACK_RGBA_FLOAT:
 300             _mesa_unpack_rgba_row(readRb->Format, srcWidth, srcRowStart,
 301                                   srcBuffer);
 302             break;
 303          case UNPACK_Z_FLOAT:
 304             _mesa_unpack_float_z_row(readRb->Format, srcWidth, srcRowStart,
 305                                      srcBuffer);
 306             break;
 307          case UNPACK_Z_INT:
 308             _mesa_unpack_uint_z_row(readRb->Format, srcWidth, srcRowStart,
 309                                     srcBuffer);
 310             break;
 311          case UNPACK_S:
 312             _mesa_unpack_ubyte_stencil_row(readRb->Format, srcWidth,
 313                                            srcRowStart, srcBuffer);
 314             break;
 315          }
 316
 317          (*resampleRow)(srcWidth, dstWidth, srcBuffer, dstBuffer, invertX);
 318          prevY = srcRow;
 319       }
 320
 321       /* store pixel row in destination */
 322       switch (mode) {
 323       case DIRECT:
 324          memcpy(dstRowStart, dstBuffer, pixelSize * srcWidth);
 325          break;
 326       case UNPACK_RGBA_FLOAT:
 327          _mesa_pack_float_rgba_row(drawRb->Format, dstWidth, dstBuffer,
 328                                    dstRowStart);
 329          break;
 330       case UNPACK_Z_FLOAT:
 331          _mesa_pack_float_z_row(drawRb->Format, dstWidth, dstBuffer,
 332                                 dstRowStart);
 333          break;
 334       case UNPACK_Z_INT:
 335          _mesa_pack_uint_z_row(drawRb->Format, dstWidth, dstBuffer,
 336                                dstRowStart);
 337          break;
 338       case UNPACK_S:
 339          _mesa_pack_ubyte_stencil_row(drawRb->Format, dstWidth, dstBuffer,
 340                                       dstRowStart);
 341          break;
 342       }
 343    }
 344
 345    free(srcBuffer);
 346    free(dstBuffer);
 347
 348    ctx->Driver.UnmapRenderbuffer(ctx, readRb);
 349    if (drawRb != readRb) {
 350       ctx->Driver.UnmapRenderbuffer(ctx, drawRb);
 351    }
 352 }
 353
 354
 355
 356 #define LERP(T, A, B)  ( (A) + (T) * ((B) - (A)) )
 357
 358 static inline GLfloat
 359 lerp_2d(GLfloat a, GLfloat b,
 360         GLfloat v00, GLfloat v10, GLfloat v01, GLfloat v11)
 361 {
 362    const GLfloat temp0 = LERP(a, v00, v10);
 363    const GLfloat temp1 = LERP(a, v01, v11);
 364    return LERP(b, temp0, temp1);
 365 }
 366
 367
 368 /**
 369  * Bilinear interpolation of two source rows.
 370  * GLubyte pixels.
 371  */
 372 static void
 373 resample_linear_row_ub(GLint srcWidth, GLint dstWidth,
 374                        const GLvoid *srcBuffer0, const GLvoid *srcBuffer1,
 375                        GLvoid *dstBuffer, GLboolean flip, GLfloat rowWeight)
 376 {
 377    const GLubyte (*srcColor0)[4] = (const GLubyte (*)[4]) srcBuffer0;
 378    const GLubyte (*srcColor1)[4] = (const GLubyte (*)[4]) srcBuffer1;
 379    GLubyte (*dstColor)[4] = (GLubyte (*)[4]) dstBuffer;
 380    const GLfloat dstWidthF = (GLfloat) dstWidth;
 381    GLint dstCol;
 382
 383    for (dstCol = 0; dstCol < dstWidth; dstCol++) {
 384       const GLfloat srcCol = (dstCol * srcWidth) / dstWidthF;
 385       GLint srcCol0 = IFLOOR(srcCol);
 386       GLint srcCol1 = srcCol0 + 1;
 387       GLfloat colWeight = srcCol - srcCol0; /* fractional part of srcCol */
 388       GLfloat red, green, blue, alpha;
 389
 390       ASSERT(srcCol0 >= 0);
 391       ASSERT(srcCol0 < srcWidth);
 392       ASSERT(srcCol1 <= srcWidth);
 393
 394       if (srcCol1 == srcWidth) {
 395          /* last column fudge */
 396          srcCol1--;
 397          colWeight = 0.0;
 398       }
 399
 400       if (flip) {
 401          srcCol0 = srcWidth - 1 - srcCol0;
 402          srcCol1 = srcWidth - 1 - srcCol1;
 403       }
 404
 405       red = lerp_2d(colWeight, rowWeight,
 406                     srcColor0[srcCol0][RCOMP], srcColor0[srcCol1][RCOMP],
 407                     srcColor1[srcCol0][RCOMP], srcColor1[srcCol1][RCOMP]);
 408       green = lerp_2d(colWeight, rowWeight,
 409                     srcColor0[srcCol0][GCOMP], srcColor0[srcCol1][GCOMP],
 410                     srcColor1[srcCol0][GCOMP], srcColor1[srcCol1][GCOMP]);
 411       blue = lerp_2d(colWeight, rowWeight,
 412                     srcColor0[srcCol0][BCOMP], srcColor0[srcCol1][BCOMP],
 413                     srcColor1[srcCol0][BCOMP], srcColor1[srcCol1][BCOMP]);
 414       alpha = lerp_2d(colWeight, rowWeight,
 415                     srcColor0[srcCol0][ACOMP], srcColor0[srcCol1][ACOMP],
 416                     srcColor1[srcCol0][ACOMP], srcColor1[srcCol1][ACOMP]);
 417
 418       dstColor[dstCol][RCOMP] = IFLOOR(red);
 419       dstColor[dstCol][GCOMP] = IFLOOR(green);
 420       dstColor[dstCol][BCOMP] = IFLOOR(blue);
 421       dstColor[dstCol][ACOMP] = IFLOOR(alpha);
 422    }
 423 }
 424
 425
 426 /**
 427  * Bilinear interpolation of two source rows.  floating point pixels.
 428  */
 429 static void
 430 resample_linear_row_float(GLint srcWidth, GLint dstWidth,
 431                           const GLvoid *srcBuffer0, const GLvoid *srcBuffer1,
 432                           GLvoid *dstBuffer, GLboolean flip, GLfloat rowWeight)
 433 {
 434    const GLfloat (*srcColor0)[4] = (const GLfloat (*)[4]) srcBuffer0;
 435    const GLfloat (*srcColor1)[4] = (const GLfloat (*)[4]) srcBuffer1;
 436    GLfloat (*dstColor)[4] = (GLfloat (*)[4]) dstBuffer;
 437    const GLfloat dstWidthF = (GLfloat) dstWidth;
 438    GLint dstCol;
 439
 440    for (dstCol = 0; dstCol < dstWidth; dstCol++) {
 441       const GLfloat srcCol = (dstCol * srcWidth) / dstWidthF;
 442       GLint srcCol0 = IFLOOR(srcCol);
 443       GLint srcCol1 = srcCol0 + 1;
 444       GLfloat colWeight = srcCol - srcCol0; /* fractional part of srcCol */
 445       GLfloat red, green, blue, alpha;
 446
 447       ASSERT(srcCol0 >= 0);
 448       ASSERT(srcCol0 < srcWidth);
 449       ASSERT(srcCol1 <= srcWidth);
 450
 451       if (srcCol1 == srcWidth) {
 452          /* last column fudge */
 453          srcCol1--;
 454          colWeight = 0.0;
 455       }
 456
 457       if (flip) {
 458          srcCol0 = srcWidth - 1 - srcCol0;
 459          srcCol1 = srcWidth - 1 - srcCol1;
 460       }
 461
 462       red = lerp_2d(colWeight, rowWeight,
 463                     srcColor0[srcCol0][RCOMP], srcColor0[srcCol1][RCOMP],
 464                     srcColor1[srcCol0][RCOMP], srcColor1[srcCol1][RCOMP]);
 465       green = lerp_2d(colWeight, rowWeight,
 466                     srcColor0[srcCol0][GCOMP], srcColor0[srcCol1][GCOMP],
 467                     srcColor1[srcCol0][GCOMP], srcColor1[srcCol1][GCOMP]);
 468       blue = lerp_2d(colWeight, rowWeight,
 469                     srcColor0[srcCol0][BCOMP], srcColor0[srcCol1][BCOMP],
 470                     srcColor1[srcCol0][BCOMP], srcColor1[srcCol1][BCOMP]);
 471       alpha = lerp_2d(colWeight, rowWeight,
 472                     srcColor0[srcCol0][ACOMP], srcColor0[srcCol1][ACOMP],
 473                     srcColor1[srcCol0][ACOMP], srcColor1[srcCol1][ACOMP]);
 474
 475       dstColor[dstCol][RCOMP] = red;
 476       dstColor[dstCol][GCOMP] = green;
 477       dstColor[dstCol][BCOMP] = blue;
 478       dstColor[dstCol][ACOMP] = alpha;
 479    }
 480 }
 481
 482
 483
 484 /**
 485  * Bilinear filtered blit (color only, non-integer values).
 486  */
 487 static void
 488 blit_linear(struct gl_context *ctx,
 489             GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
 490             GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1)
 491 {
 492    struct gl_renderbuffer *readRb = ctx->ReadBuffer->_ColorReadBuffer;
 493    struct gl_renderbuffer *drawRb = ctx->DrawBuffer->_ColorDrawBuffers[0];
 494
 495    const GLint srcWidth = ABS(srcX1 - srcX0);
 496    const GLint dstWidth = ABS(dstX1 - dstX0);
 497    const GLint srcHeight = ABS(srcY1 - srcY0);
 498    const GLint dstHeight = ABS(dstY1 - dstY0);
 499    const GLfloat dstHeightF = (GLfloat) dstHeight;
 500
 501    const GLint srcXpos = MIN2(srcX0, srcX1);
 502    const GLint srcYpos = MIN2(srcY0, srcY1);
 503    const GLint dstXpos = MIN2(dstX0, dstX1);
 504    const GLint dstYpos = MIN2(dstY0, dstY1);
 505
 506    const GLboolean invertX = (srcX1 < srcX0) ^ (dstX1 < dstX0);
 507    const GLboolean invertY = (srcY1 < srcY0) ^ (dstY1 < dstY0);
 508
 509    GLint dstRow;
 510
 511    GLint pixelSize;
 512    GLvoid *srcBuffer0, *srcBuffer1;
 513    GLint srcBufferY0 = -1, srcBufferY1 = -1;
 514    GLvoid *dstBuffer;
 515
 516    gl_format readFormat = _mesa_get_srgb_format_linear(readRb->Format);
 517    gl_format drawFormat = _mesa_get_srgb_format_linear(drawRb->Format);
 518    GLuint bpp = _mesa_get_format_bytes(readFormat);
 519
 520    GLenum pixelType;
 521
 522    GLubyte *srcMap, *dstMap;
 523    GLint srcRowStride, dstRowStride;
 524
 525
 526    /* Determine datatype for resampling */
 527    if (_mesa_get_format_max_bits(readFormat) == 8 &&
 528        _mesa_get_format_datatype(readFormat) == GL_UNSIGNED_NORMALIZED) {
 529       pixelType = GL_UNSIGNED_BYTE;
 530       pixelSize = 4 * sizeof(GLubyte);
 531    }
 532    else {
 533       pixelType = GL_FLOAT;
 534       pixelSize = 4 * sizeof(GLfloat);
 535    }
 536
 537    /* Allocate the src/dst row buffers.
 538     * Keep two adjacent src rows around for bilinear sampling.
 539     */
 540    srcBuffer0 = malloc(pixelSize * srcWidth);
 541    if (!srcBuffer0) {
 542       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFrameBufferEXT");
 543       return;
 544    }
 545    srcBuffer1 = malloc(pixelSize * srcWidth);
 546    if (!srcBuffer1) {
 547       free(srcBuffer0);
 548       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFrameBufferEXT");
 549       return;
 550    }
 551    dstBuffer = malloc(pixelSize * dstWidth);
 552    if (!dstBuffer) {
 553       free(srcBuffer0);
 554       free(srcBuffer1);
 555       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFrameBufferEXT");
 556       return;
 557    }
 558
 559    /*
 560     * Map src / dst renderbuffers
 561     */
 562    if (readRb == drawRb) {
 563       /* map whole buffer for read/write */
 564       ctx->Driver.MapRenderbuffer(ctx, readRb,
 565                                   0, 0, readRb->Width, readRb->Height,
 566                                   GL_MAP_READ_BIT | GL_MAP_WRITE_BIT,
 567                                   &srcMap, &srcRowStride);
 568       if (!srcMap) {
 569          free(srcBuffer0);
 570          free(srcBuffer1);
 571          free(dstBuffer);
 572          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFramebuffer");
 573          return;
 574       }
 575
 576       dstMap = srcMap;
 577       dstRowStride = srcRowStride;
 578    }
 579    else {
 580       /* different src/dst buffers */
 581       /* XXX with a bit of work we could just map the regions to be
 582        * read/written instead of the whole buffers.
 583        */
 584       ctx->Driver.MapRenderbuffer(ctx, readRb,
 585                                   0, 0, readRb->Width, readRb->Height,
 586                                   GL_MAP_READ_BIT, &srcMap, &srcRowStride);
 587       if (!srcMap) {
 588          free(srcBuffer0);
 589          free(srcBuffer1);
 590          free(dstBuffer);
 591          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFramebuffer");
 592          return;
 593       }
 594       ctx->Driver.MapRenderbuffer(ctx, drawRb,
 595                                   0, 0, drawRb->Width, drawRb->Height,
 596                                   GL_MAP_WRITE_BIT, &dstMap, &dstRowStride);
 597       if (!dstMap) {
 598          ctx->Driver.UnmapRenderbuffer(ctx, readRb);
 599          free(srcBuffer0);
 600          free(srcBuffer1);
 601          free(dstBuffer);
 602          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFramebuffer");
 603          return;
 604       }
 605    }
 606
 607    for (dstRow = 0; dstRow < dstHeight; dstRow++) {
 608       const GLint dstY = dstYpos + dstRow;
 609       const GLfloat srcRow = (dstRow * srcHeight) / dstHeightF;
 610       GLint srcRow0 = IFLOOR(srcRow);
 611       GLint srcRow1 = srcRow0 + 1;
 612       GLfloat rowWeight = srcRow - srcRow0; /* fractional part of srcRow */
 613
 614       ASSERT(srcRow >= 0);
 615       ASSERT(srcRow < srcHeight);
 616
 617       if (srcRow1 == srcHeight) {
 618          /* last row fudge */
 619          srcRow1 = srcRow0;
 620          rowWeight = 0.0;
 621       }
 622
 623       if (invertY) {
 624          srcRow0 = srcHeight - 1 - srcRow0;
 625          srcRow1 = srcHeight - 1 - srcRow1;
 626       }
 627
 628       srcY0 = srcYpos + srcRow0;
 629       srcY1 = srcYpos + srcRow1;
 630
 631       /* get the two source rows */
 632       if (srcY0 == srcBufferY0 && srcY1 == srcBufferY1) {
 633          /* use same source row buffers again */
 634       }
 635       else if (srcY0 == srcBufferY1) {
 636          /* move buffer1 into buffer0 by swapping pointers */
 637          GLvoid *tmp = srcBuffer0;
 638          srcBuffer0 = srcBuffer1;
 639          srcBuffer1 = tmp;
 640          /* get y1 row */
 641          {
 642             GLubyte *src = srcMap + srcY1 * srcRowStride + srcXpos * bpp;
 643             if (pixelType == GL_UNSIGNED_BYTE) {
 644                _mesa_unpack_ubyte_rgba_row(readFormat, srcWidth,
 645                                            src, srcBuffer1);
 646             }
 647             else {
 648                _mesa_unpack_rgba_row(readFormat, srcWidth,
 649                                      src, srcBuffer1);
 650             }
 651          }
 652          srcBufferY0 = srcY0;
 653          srcBufferY1 = srcY1;
 654       }
 655       else {
 656          /* get both new rows */
 657          {
 658             GLubyte *src0 = srcMap + srcY0 * srcRowStride + srcXpos * bpp;
 659             GLubyte *src1 = srcMap + srcY1 * srcRowStride + srcXpos * bpp;
 660             if (pixelType == GL_UNSIGNED_BYTE) {
 661                _mesa_unpack_ubyte_rgba_row(readFormat, srcWidth,
 662                                            src0, srcBuffer0);
 663                _mesa_unpack_ubyte_rgba_row(readFormat, srcWidth,
 664                                            src1, srcBuffer1);
 665             }
 666             else {
 667                _mesa_unpack_rgba_row(readFormat, srcWidth, src0, srcBuffer0);
 668                _mesa_unpack_rgba_row(readFormat, srcWidth, src1, srcBuffer1);
 669             }
 670          }
 671          srcBufferY0 = srcY0;
 672          srcBufferY1 = srcY1;
 673       }
 674
 675       if (pixelType == GL_UNSIGNED_BYTE) {
 676          resample_linear_row_ub(srcWidth, dstWidth, srcBuffer0, srcBuffer1,
 677                                 dstBuffer, invertX, rowWeight);
 678       }
 679       else {
 680          resample_linear_row_float(srcWidth, dstWidth, srcBuffer0, srcBuffer1,
 681                                    dstBuffer, invertX, rowWeight);
 682       }
 683
 684       /* store pixel row in destination */
 685       {
 686          GLubyte *dst = dstMap + dstY * dstRowStride + dstXpos * bpp;
 687          if (pixelType == GL_UNSIGNED_BYTE) {
 688             _mesa_pack_ubyte_rgba_row(drawFormat, dstWidth, dstBuffer, dst);
 689          }
 690          else {
 691             _mesa_pack_float_rgba_row(drawFormat, dstWidth, dstBuffer, dst);
 692          }
 693       }
 694    }
 695
 696    free(srcBuffer0);
 697    free(srcBuffer1);
 698    free(dstBuffer);
 699
 700    ctx->Driver.UnmapRenderbuffer(ctx, readRb);
 701    if (drawRb != readRb) {
 702       ctx->Driver.UnmapRenderbuffer(ctx, drawRb);
 703    }
 704 }
 705
 706
 707
 708 /**
 709  * Software fallback for glBlitFramebufferEXT().
 710  */
 711 void
 712 _swrast_BlitFramebuffer(struct gl_context *ctx,
 713                         GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
 714                         GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
 715                         GLbitfield mask, GLenum filter)
 716 {
 717    static const GLbitfield buffers[3] = {
 718       GL_COLOR_BUFFER_BIT,
 719       GL_DEPTH_BUFFER_BIT,
 720       GL_STENCIL_BUFFER_BIT
 721    };
 722    static const GLenum buffer_enums[3] = {
 723       GL_COLOR,
 724       GL_DEPTH,
 725       GL_STENCIL,
 726    };
 727    GLint i;
 728
 729    if (!_mesa_clip_blit(ctx, &srcX0, &srcY0, &srcX1, &srcY1,
 730                         &dstX0, &dstY0, &dstX1, &dstY1)) {
 731       return;
 732    }
 733
 734    if (SWRAST_CONTEXT(ctx)->NewState)
 735       _swrast_validate_derived(ctx);
 736
 737    /* First, try covering whatever buffers possible using the fast 1:1 copy
 738     * path.
 739     */
 740    if (srcX1 - srcX0 == dstX1 - dstX0 &&
 741        srcY1 - srcY0 == dstY1 - dstY0 &&
 742        srcX0 < srcX1 &&
 743        srcY0 < srcY1 &&
 744        dstX0 < dstX1 &&
 745        dstY0 < dstY1) {
 746       for (i = 0; i < 3; i++) {
 747          if (mask & buffers[i]) {
 748             if (swrast_fast_copy_pixels(ctx,
 749                                         srcX0, srcY0,
 750                                         srcX1 - srcX0, srcY1 - srcY0,
 751                                         dstX0, dstY0,
 752                                         buffer_enums[i])) {
 753                mask &= ~buffers[i];
 754             }
 755          }
 756       }
 757
 758       if (!mask)
 759          return;
 760    }
 761
 762    if (filter == GL_NEAREST) {
 763       for (i = 0; i < 3; i++) {
 764          if (mask & buffers[i]) {
 765             blit_nearest(ctx,  srcX0, srcY0, srcX1, srcY1,
 766                          dstX0, dstY0, dstX1, dstY1, buffers[i]);
 767          }
 768       }
 769    }
 770    else {
 771       ASSERT(filter == GL_LINEAR);
 772       if (mask & GL_COLOR_BUFFER_BIT) {  /* depth/stencil not allowed */
 773          blit_linear(ctx,  srcX0, srcY0, srcX1, srcY1,
 774                      dstX0, dstY0, dstX1, dstY1);
 775       }
 776    }
 777
 778 }