src/mesa/swrast/s_blit.c

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