src/mesa/drivers/dri/intel/intel_fbo.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2006 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * 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
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28
  29 #include "main/imports.h"
  30 #include "main/macros.h"
  31 #include "main/mtypes.h"
  32 #include "main/fbobject.h"
  33 #include "main/framebuffer.h"
  34 #include "main/renderbuffer.h"
  35 #include "main/context.h"
  36 #include "main/texformat.h"
  37 #include "main/texrender.h"
  38
  39 #include "intel_context.h"
  40 #include "intel_buffers.h"
  41 #include "intel_fbo.h"
  42 #include "intel_mipmap_tree.h"
  43 #include "intel_regions.h"
  44
  45
  46 #define FILE_DEBUG_FLAG DEBUG_FBO
  47
  48
  49 /**
  50  * Create a new framebuffer object.
  51  */
  52 static struct gl_framebuffer *
  53 intel_new_framebuffer(GLcontext * ctx, GLuint name)
  54 {
  55    /* Only drawable state in intel_framebuffer at this time, just use Mesa's
  56     * class
  57     */
  58    return _mesa_new_framebuffer(ctx, name);
  59 }
  60
  61
  62 /** Called by gl_renderbuffer::Delete() */
  63 static void
  64 intel_delete_renderbuffer(struct gl_renderbuffer *rb)
  65 {
  66    GET_CURRENT_CONTEXT(ctx);
  67    struct intel_context *intel = intel_context(ctx);
  68    struct intel_renderbuffer *irb = intel_renderbuffer(rb);
  69
  70    ASSERT(irb);
  71
  72    if (irb->span_cache != NULL)
  73       _mesa_free(irb->span_cache);
  74
  75    if (intel && irb->region) {
  76       intel_region_release(&irb->region);
  77    }
  78
  79    _mesa_free(irb);
  80 }
  81
  82
  83 /**
  84  * Return a pointer to a specific pixel in a renderbuffer.
  85  */
  86 static void *
  87 intel_get_pointer(GLcontext * ctx, struct gl_renderbuffer *rb,
  88                   GLint x, GLint y)
  89 {
  90    /* By returning NULL we force all software rendering to go through
  91     * the span routines.
  92     */
  93    return NULL;
  94 }
  95
  96
  97 /**
  98  * Called via glRenderbufferStorageEXT() to set the format and allocate
  99  * storage for a user-created renderbuffer.
 100  */
 101 static GLboolean
 102 intel_alloc_renderbuffer_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
 103                                  GLenum internalFormat,
 104                                  GLuint width, GLuint height)
 105 {
 106    struct intel_context *intel = intel_context(ctx);
 107    struct intel_renderbuffer *irb = intel_renderbuffer(rb);
 108    GLboolean softwareBuffer = GL_FALSE;
 109    int cpp;
 110
 111    ASSERT(rb->Name != 0);
 112
 113    switch (internalFormat) {
 114    case GL_R3_G3_B2:
 115    case GL_RGB4:
 116    case GL_RGB5:
 117       rb->_ActualFormat = GL_RGB5;
 118       rb->DataType = GL_UNSIGNED_BYTE;
 119       rb->RedBits = 5;
 120       rb->GreenBits = 6;
 121       rb->BlueBits = 5;
 122       cpp = 2;
 123       break;
 124    case GL_RGB:
 125    case GL_RGB8:
 126    case GL_RGB10:
 127    case GL_RGB12:
 128    case GL_RGB16:
 129       rb->_ActualFormat = GL_RGB8;
 130       rb->DataType = GL_UNSIGNED_BYTE;
 131       rb->RedBits = 8;
 132       rb->GreenBits = 8;
 133       rb->BlueBits = 8;
 134       rb->AlphaBits = 0;
 135       cpp = 4;
 136       break;
 137    case GL_RGBA:
 138    case GL_RGBA2:
 139    case GL_RGBA4:
 140    case GL_RGB5_A1:
 141    case GL_RGBA8:
 142    case GL_RGB10_A2:
 143    case GL_RGBA12:
 144    case GL_RGBA16:
 145       rb->_ActualFormat = GL_RGBA8;
 146       rb->DataType = GL_UNSIGNED_BYTE;
 147       rb->RedBits = 8;
 148       rb->GreenBits = 8;
 149       rb->BlueBits = 8;
 150       rb->AlphaBits = 8;
 151       cpp = 4;
 152       break;
 153    case GL_STENCIL_INDEX:
 154    case GL_STENCIL_INDEX1_EXT:
 155    case GL_STENCIL_INDEX4_EXT:
 156    case GL_STENCIL_INDEX8_EXT:
 157    case GL_STENCIL_INDEX16_EXT:
 158       /* alloc a depth+stencil buffer */
 159       rb->_ActualFormat = GL_DEPTH24_STENCIL8_EXT;
 160       rb->DataType = GL_UNSIGNED_INT_24_8_EXT;
 161       rb->StencilBits = 8;
 162       cpp = 4;
 163       break;
 164    case GL_DEPTH_COMPONENT16:
 165       rb->_ActualFormat = GL_DEPTH_COMPONENT16;
 166       rb->DataType = GL_UNSIGNED_SHORT;
 167       rb->DepthBits = 16;
 168       cpp = 2;
 169       break;
 170    case GL_DEPTH_COMPONENT:
 171    case GL_DEPTH_COMPONENT24:
 172    case GL_DEPTH_COMPONENT32:
 173       rb->_ActualFormat = GL_DEPTH24_STENCIL8_EXT;
 174       rb->DataType = GL_UNSIGNED_INT_24_8_EXT;
 175       rb->DepthBits = 24;
 176       cpp = 4;
 177       break;
 178    case GL_DEPTH_STENCIL_EXT:
 179    case GL_DEPTH24_STENCIL8_EXT:
 180       rb->_ActualFormat = GL_DEPTH24_STENCIL8_EXT;
 181       rb->DataType = GL_UNSIGNED_INT_24_8_EXT;
 182       rb->DepthBits = 24;
 183       rb->StencilBits = 8;
 184       cpp = 4;
 185       break;
 186    default:
 187       _mesa_problem(ctx,
 188                     "Unexpected format in intel_alloc_renderbuffer_storage");
 189       return GL_FALSE;
 190    }
 191
 192    intelFlush(ctx);
 193
 194    /* free old region */
 195    if (irb->region) {
 196       intel_region_release(&irb->region);
 197    }
 198
 199    /* allocate new memory region/renderbuffer */
 200    if (softwareBuffer) {
 201       return _mesa_soft_renderbuffer_storage(ctx, rb, internalFormat,
 202                                              width, height);
 203    }
 204    else {
 205       /* Choose a pitch to match hardware requirements:
 206        */
 207       GLuint pitch = ((cpp * width + 63) & ~63) / cpp;
 208
 209       /* alloc hardware renderbuffer */
 210       DBG("Allocating %d x %d Intel RBO (pitch %d)\n", width,
 211           height, pitch);
 212
 213       irb->region = intel_region_alloc(intel, cpp, width, height, pitch,
 214                                        GL_TRUE);
 215       if (!irb->region)
 216          return GL_FALSE;       /* out of memory? */
 217
 218       ASSERT(irb->region->buffer);
 219
 220       rb->Width = width;
 221       rb->Height = height;
 222
 223       return GL_TRUE;
 224    }
 225 }
 226
 227
 228 /**
 229  * Called for each hardware renderbuffer when a _window_ is resized.
 230  * Just update fields.
 231  * Not used for user-created renderbuffers!
 232  */
 233 static GLboolean
 234 intel_alloc_window_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
 235                            GLenum internalFormat, GLuint width, GLuint height)
 236 {
 237    ASSERT(rb->Name == 0);
 238    rb->Width = width;
 239    rb->Height = height;
 240    rb->_ActualFormat = internalFormat;
 241
 242    return GL_TRUE;
 243 }
 244
 245
 246 static void
 247 intel_resize_buffers(GLcontext *ctx, struct gl_framebuffer *fb,
 248                      GLuint width, GLuint height)
 249 {
 250    struct intel_framebuffer *intel_fb = (struct intel_framebuffer*)fb;
 251    int i;
 252
 253    _mesa_resize_framebuffer(ctx, fb, width, height);
 254
 255    fb->Initialized = GL_TRUE; /* XXX remove someday */
 256
 257    if (fb->Name != 0) {
 258       return;
 259    }
 260
 261    /* Make sure all window system renderbuffers are up to date */
 262    for (i = 0; i < 2; i++) {
 263       struct gl_renderbuffer *rb = &intel_fb->color_rb[i]->Base;
 264
 265       /* only resize if size is changing */
 266       if (rb && (rb->Width != width || rb->Height != height)) {
 267          rb->AllocStorage(ctx, rb, rb->InternalFormat, width, height);
 268       }
 269    }
 270 }
 271
 272
 273 /** Dummy function for gl_renderbuffer::AllocStorage() */
 274 static GLboolean
 275 intel_nop_alloc_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
 276                         GLenum internalFormat, GLuint width, GLuint height)
 277 {
 278    _mesa_problem(ctx, "intel_op_alloc_storage should never be called.");
 279    return GL_FALSE;
 280 }
 281
 282
 283 void
 284 intel_renderbuffer_set_region(struct intel_renderbuffer *rb,
 285                               struct intel_region *region)
 286 {
 287    struct intel_region *old;
 288
 289    old = rb->region;
 290    rb->region = NULL;
 291    intel_region_reference(&rb->region, region);
 292    intel_region_release(&old);
 293 }
 294
 295
 296 /**
 297  * Create a new intel_renderbuffer which corresponds to an on-screen window,
 298  * not a user-created renderbuffer.
 299  */
 300 struct intel_renderbuffer *
 301 intel_create_renderbuffer(GLenum intFormat)
 302 {
 303    GET_CURRENT_CONTEXT(ctx);
 304
 305    struct intel_renderbuffer *irb;
 306    const GLuint name = 0;
 307
 308    irb = CALLOC_STRUCT(intel_renderbuffer);
 309    if (!irb) {
 310       _mesa_error(ctx, GL_OUT_OF_MEMORY, "creating renderbuffer");
 311       return NULL;
 312    }
 313
 314    _mesa_init_renderbuffer(&irb->Base, name);
 315    irb->Base.ClassID = INTEL_RB_CLASS;
 316
 317    switch (intFormat) {
 318    case GL_RGB5:
 319       irb->Base._ActualFormat = GL_RGB5;
 320       irb->Base._BaseFormat = GL_RGBA;
 321       irb->Base.RedBits = 5;
 322       irb->Base.GreenBits = 6;
 323       irb->Base.BlueBits = 5;
 324       irb->Base.DataType = GL_UNSIGNED_BYTE;
 325       break;
 326    case GL_RGBA8:
 327       irb->Base._ActualFormat = GL_RGBA8;
 328       irb->Base._BaseFormat = GL_RGBA;
 329       irb->Base.RedBits = 8;
 330       irb->Base.GreenBits = 8;
 331       irb->Base.BlueBits = 8;
 332       irb->Base.AlphaBits = 8;
 333       irb->Base.DataType = GL_UNSIGNED_BYTE;
 334       break;
 335    case GL_STENCIL_INDEX8_EXT:
 336       irb->Base._ActualFormat = GL_STENCIL_INDEX8_EXT;
 337       irb->Base._BaseFormat = GL_STENCIL_INDEX;
 338       irb->Base.StencilBits = 8;
 339       irb->Base.DataType = GL_UNSIGNED_BYTE;
 340       break;
 341    case GL_DEPTH_COMPONENT16:
 342       irb->Base._ActualFormat = GL_DEPTH_COMPONENT16;
 343       irb->Base._BaseFormat = GL_DEPTH_COMPONENT;
 344       irb->Base.DepthBits = 16;
 345       irb->Base.DataType = GL_UNSIGNED_SHORT;
 346       break;
 347    case GL_DEPTH_COMPONENT24:
 348       irb->Base._ActualFormat = GL_DEPTH24_STENCIL8_EXT;
 349       irb->Base._BaseFormat = GL_DEPTH_COMPONENT;
 350       irb->Base.DepthBits = 24;
 351       irb->Base.DataType = GL_UNSIGNED_INT;
 352       break;
 353    case GL_DEPTH24_STENCIL8_EXT:
 354       irb->Base._ActualFormat = GL_DEPTH24_STENCIL8_EXT;
 355       irb->Base._BaseFormat = GL_DEPTH_STENCIL_EXT;
 356       irb->Base.DepthBits = 24;
 357       irb->Base.StencilBits = 8;
 358       irb->Base.DataType = GL_UNSIGNED_INT_24_8_EXT;
 359       break;
 360    default:
 361       _mesa_problem(NULL,
 362                     "Unexpected intFormat in intel_create_renderbuffer");
 363       return NULL;
 364    }
 365
 366    irb->Base.InternalFormat = intFormat;
 367
 368    /* intel-specific methods */
 369    irb->Base.Delete = intel_delete_renderbuffer;
 370    irb->Base.AllocStorage = intel_alloc_window_storage;
 371    irb->Base.GetPointer = intel_get_pointer;
 372
 373    return irb;
 374 }
 375
 376
 377 /**
 378  * Create a new renderbuffer object.
 379  * Typically called via glBindRenderbufferEXT().
 380  */
 381 static struct gl_renderbuffer *
 382 intel_new_renderbuffer(GLcontext * ctx, GLuint name)
 383 {
 384    /*struct intel_context *intel = intel_context(ctx); */
 385    struct intel_renderbuffer *irb;
 386
 387    irb = CALLOC_STRUCT(intel_renderbuffer);
 388    if (!irb) {
 389       _mesa_error(ctx, GL_OUT_OF_MEMORY, "creating renderbuffer");
 390       return NULL;
 391    }
 392
 393    _mesa_init_renderbuffer(&irb->Base, name);
 394    irb->Base.ClassID = INTEL_RB_CLASS;
 395
 396    /* intel-specific methods */
 397    irb->Base.Delete = intel_delete_renderbuffer;
 398    irb->Base.AllocStorage = intel_alloc_renderbuffer_storage;
 399    irb->Base.GetPointer = intel_get_pointer;
 400    /* span routines set in alloc_storage function */
 401
 402    return &irb->Base;
 403 }
 404
 405
 406 /**
 407  * Called via glBindFramebufferEXT().
 408  */
 409 static void
 410 intel_bind_framebuffer(GLcontext * ctx, GLenum target,
 411                        struct gl_framebuffer *fb, struct gl_framebuffer *fbread)
 412 {
 413    if (target == GL_FRAMEBUFFER_EXT || target == GL_DRAW_FRAMEBUFFER_EXT) {
 414       intel_draw_buffer(ctx, fb);
 415    }
 416    else {
 417       /* don't need to do anything if target == GL_READ_FRAMEBUFFER_EXT */
 418    }
 419 }
 420
 421
 422 /**
 423  * Called via glFramebufferRenderbufferEXT().
 424  */
 425 static void
 426 intel_framebuffer_renderbuffer(GLcontext * ctx,
 427                                struct gl_framebuffer *fb,
 428                                GLenum attachment, struct gl_renderbuffer *rb)
 429 {
 430    DBG("Intel FramebufferRenderbuffer %u %u\n", fb->Name, rb ? rb->Name : 0);
 431
 432    intelFlush(ctx);
 433
 434    _mesa_framebuffer_renderbuffer(ctx, fb, attachment, rb);
 435    intel_draw_buffer(ctx, fb);
 436 }
 437
 438
 439 static GLboolean
 440 intel_update_wrapper(GLcontext *ctx, struct intel_renderbuffer *irb,
 441                      struct gl_texture_image *texImage)
 442 {
 443    if (texImage->TexFormat == &_mesa_texformat_argb8888) {
 444       irb->Base._ActualFormat = GL_RGBA8;
 445       irb->Base._BaseFormat = GL_RGBA;
 446       irb->Base.DataType = GL_UNSIGNED_BYTE;
 447       DBG("Render to RGBA8 texture OK\n");
 448    }
 449    else if (texImage->TexFormat == &_mesa_texformat_rgb565) {
 450       irb->Base._ActualFormat = GL_RGB5;
 451       irb->Base._BaseFormat = GL_RGB;
 452       irb->Base.DataType = GL_UNSIGNED_SHORT;
 453       DBG("Render to RGB5 texture OK\n");
 454    }
 455    else if (texImage->TexFormat == &_mesa_texformat_z16) {
 456       irb->Base._ActualFormat = GL_DEPTH_COMPONENT16;
 457       irb->Base._BaseFormat = GL_DEPTH_COMPONENT;
 458       irb->Base.DataType = GL_UNSIGNED_SHORT;
 459       DBG("Render to DEPTH16 texture OK\n");
 460    }
 461    else if (texImage->TexFormat == &_mesa_texformat_s8_z24) {
 462       irb->Base._ActualFormat = GL_DEPTH24_STENCIL8_EXT;
 463       irb->Base._BaseFormat = GL_DEPTH_STENCIL_EXT;
 464       irb->Base.DataType = GL_UNSIGNED_INT_24_8_EXT;
 465       DBG("Render to DEPTH_STENCIL texture OK\n");
 466    }
 467    else {
 468       DBG("Render to texture BAD FORMAT %d\n",
 469           texImage->TexFormat->MesaFormat);
 470       return GL_FALSE;
 471    }
 472
 473    irb->Base.InternalFormat = irb->Base._ActualFormat;
 474    irb->Base.Width = texImage->Width;
 475    irb->Base.Height = texImage->Height;
 476    irb->Base.RedBits = texImage->TexFormat->RedBits;
 477    irb->Base.GreenBits = texImage->TexFormat->GreenBits;
 478    irb->Base.BlueBits = texImage->TexFormat->BlueBits;
 479    irb->Base.AlphaBits = texImage->TexFormat->AlphaBits;
 480    irb->Base.DepthBits = texImage->TexFormat->DepthBits;
 481
 482    irb->Base.Delete = intel_delete_renderbuffer;
 483    irb->Base.AllocStorage = intel_nop_alloc_storage;
 484
 485    return GL_TRUE;
 486 }
 487
 488
 489 /**
 490  * When glFramebufferTexture[123]D is called this function sets up the
 491  * gl_renderbuffer wrapper around the texture image.
 492  * This will have the region info needed for hardware rendering.
 493  */
 494 static struct intel_renderbuffer *
 495 intel_wrap_texture(GLcontext * ctx, struct gl_texture_image *texImage)
 496 {
 497    const GLuint name = ~0;   /* not significant, but distinct for debugging */
 498    struct intel_renderbuffer *irb;
 499
 500    /* make an intel_renderbuffer to wrap the texture image */
 501    irb = CALLOC_STRUCT(intel_renderbuffer);
 502    if (!irb) {
 503       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glFramebufferTexture");
 504       return NULL;
 505    }
 506
 507    _mesa_init_renderbuffer(&irb->Base, name);
 508    irb->Base.ClassID = INTEL_RB_CLASS;
 509
 510    if (!intel_update_wrapper(ctx, irb, texImage)) {
 511       _mesa_free(irb);
 512       return NULL;
 513    }
 514
 515    return irb;
 516 }
 517
 518
 519 /**
 520  * Called by glFramebufferTexture[123]DEXT() (and other places) to
 521  * prepare for rendering into texture memory.  This might be called
 522  * many times to choose different texture levels, cube faces, etc
 523  * before intel_finish_render_texture() is ever called.
 524  */
 525 static void
 526 intel_render_texture(GLcontext * ctx,
 527                      struct gl_framebuffer *fb,
 528                      struct gl_renderbuffer_attachment *att)
 529 {
 530    struct gl_texture_image *newImage
 531       = att->Texture->Image[att->CubeMapFace][att->TextureLevel];
 532    struct intel_renderbuffer *irb = intel_renderbuffer(att->Renderbuffer);
 533    struct intel_texture_image *intel_image;
 534    GLuint imageOffset;
 535
 536    (void) fb;
 537
 538    ASSERT(newImage);
 539
 540    if (newImage->Border != 0) {
 541       /* Fallback on drawing to a texture with a border, which won't have a
 542        * miptree.
 543        */
 544       _mesa_reference_renderbuffer(&att->Renderbuffer, NULL);
 545       _mesa_render_texture(ctx, fb, att);
 546       return;
 547    }
 548    else if (!irb) {
 549       irb = intel_wrap_texture(ctx, newImage);
 550       if (irb) {
 551          /* bind the wrapper to the attachment point */
 552          _mesa_reference_renderbuffer(&att->Renderbuffer, &irb->Base);
 553       }
 554       else {
 555          /* fallback to software rendering */
 556          _mesa_render_texture(ctx, fb, att);
 557          return;
 558       }
 559    }
 560
 561    if (!intel_update_wrapper(ctx, irb, newImage)) {
 562        _mesa_reference_renderbuffer(&att->Renderbuffer, NULL);
 563        _mesa_render_texture(ctx, fb, att);
 564        return;
 565    }
 566
 567    DBG("Begin render texture tid %x tex=%u w=%d h=%d refcount=%d\n",
 568        _glthread_GetID(),
 569        att->Texture->Name, newImage->Width, newImage->Height,
 570        irb->Base.RefCount);
 571
 572    /* point the renderbufer's region to the texture image region */
 573    intel_image = intel_texture_image(newImage);
 574    if (irb->region != intel_image->mt->region) {
 575       if (irb->region)
 576          intel_region_release(&irb->region);
 577       intel_region_reference(&irb->region, intel_image->mt->region);
 578    }
 579
 580    /* compute offset of the particular 2D image within the texture region */
 581    imageOffset = intel_miptree_image_offset(intel_image->mt,
 582                                             att->CubeMapFace,
 583                                             att->TextureLevel);
 584
 585    if (att->Texture->Target == GL_TEXTURE_3D) {
 586       const GLuint *offsets = intel_miptree_depth_offsets(intel_image->mt,
 587                                                           att->TextureLevel);
 588       imageOffset += offsets[att->Zoffset];
 589    }
 590
 591    /* store that offset in the region */
 592    intel_image->mt->region->draw_offset = imageOffset;
 593
 594    /* update drawing region, etc */
 595    intel_draw_buffer(ctx, fb);
 596 }
 597
 598
 599 /**
 600  * Called by Mesa when rendering to a texture is done.
 601  */
 602 static void
 603 intel_finish_render_texture(GLcontext * ctx,
 604                             struct gl_renderbuffer_attachment *att)
 605 {
 606    struct intel_renderbuffer *irb = intel_renderbuffer(att->Renderbuffer);
 607
 608    DBG("End render texture (tid %x) tex %u\n", _glthread_GetID(), att->Texture->Name);
 609
 610    if (irb) {
 611       /* just release the region */
 612       intel_region_release(&irb->region);
 613    }
 614    else if (att->Renderbuffer) {
 615       /* software fallback */
 616       _mesa_finish_render_texture(ctx, att);
 617       /* XXX FBO: Need to unmap the buffer (or in intelSpanRenderStart???) */
 618    }
 619 }
 620
 621
 622 /**
 623  * Do additional "completeness" testing of a framebuffer object.
 624  */
 625 static void
 626 intel_validate_framebuffer(GLcontext *ctx, struct gl_framebuffer *fb)
 627 {
 628    const struct intel_renderbuffer *depthRb =
 629       intel_get_renderbuffer(fb, BUFFER_DEPTH);
 630    const struct intel_renderbuffer *stencilRb =
 631       intel_get_renderbuffer(fb, BUFFER_STENCIL);
 632
 633    if (stencilRb && stencilRb != depthRb) {
 634       /* we only support combined depth/stencil buffers, not separate
 635        * stencil buffers.
 636        */
 637       fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
 638    }
 639 }
 640
 641
 642 /**
 643  * Called from glBlitFramebuffer().
 644  * For now, we're doing an approximation with glCopyPixels().
 645  * XXX we need to bypass all the per-fragment operations, except scissor.
 646  */
 647 static void
 648 intel_blit_framebuffer(GLcontext *ctx,
 649                        GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
 650                        GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
 651                        GLbitfield mask, GLenum filter)
 652 {
 653    const GLfloat xZoomSave = ctx->Pixel.ZoomX;
 654    const GLfloat yZoomSave = ctx->Pixel.ZoomY;
 655    GLsizei width, height;
 656    GLfloat xFlip = 1.0F, yFlip = 1.0F;
 657
 658    if (srcX1 < srcX0) {
 659       GLint tmp = srcX1;
 660       srcX1 = srcX0;
 661       srcX0 = tmp;
 662       xFlip = -1.0F;
 663    }
 664
 665    if (srcY1 < srcY0) {
 666       GLint tmp = srcY1;
 667       srcY1 = srcY0;
 668       srcY0 = tmp;
 669       yFlip = -1.0F;
 670    }
 671
 672    width = srcX1 - srcX0;
 673    height = srcY1 - srcY0;
 674
 675    ctx->Pixel.ZoomX = xFlip * (dstX1 - dstX0) / (srcX1 - srcY0);
 676    ctx->Pixel.ZoomY = yFlip * (dstY1 - dstY0) / (srcY1 - srcY0);
 677
 678    if (ctx->Pixel.ZoomX < 0.0F) {
 679       dstX0 = MAX2(dstX0, dstX1);
 680    }
 681    else {
 682       dstX0 = MIN2(dstX0, dstX1);
 683    }
 684
 685    if (ctx->Pixel.ZoomY < 0.0F) {
 686       dstY0 = MAX2(dstY0, dstY1);
 687    }
 688    else {
 689       dstY0 = MIN2(dstY0, dstY1);
 690    }
 691
 692    if (mask & GL_COLOR_BUFFER_BIT) {
 693       ctx->Driver.CopyPixels(ctx, srcX0, srcY0, width, height,
 694                              dstX0, dstY0, GL_COLOR);
 695    }
 696    if (mask & GL_DEPTH_BUFFER_BIT) {
 697       ctx->Driver.CopyPixels(ctx, srcX0, srcY0, width, height,
 698                              dstX0, dstY0, GL_DEPTH);
 699    }
 700    if (mask & GL_STENCIL_BUFFER_BIT) {
 701       ctx->Driver.CopyPixels(ctx, srcX0, srcY0, width, height,
 702                              dstX0, dstY0, GL_STENCIL);
 703    }
 704
 705    ctx->Pixel.ZoomX = xZoomSave;
 706    ctx->Pixel.ZoomY = yZoomSave;
 707 }
 708
 709
 710 /**
 711  * Do one-time context initializations related to GL_EXT_framebuffer_object.
 712  * Hook in device driver functions.
 713  */
 714 void
 715 intel_fbo_init(struct intel_context *intel)
 716 {
 717    intel->ctx.Driver.NewFramebuffer = intel_new_framebuffer;
 718    intel->ctx.Driver.NewRenderbuffer = intel_new_renderbuffer;
 719    intel->ctx.Driver.BindFramebuffer = intel_bind_framebuffer;
 720    intel->ctx.Driver.FramebufferRenderbuffer = intel_framebuffer_renderbuffer;
 721    intel->ctx.Driver.RenderTexture = intel_render_texture;
 722    intel->ctx.Driver.FinishRenderTexture = intel_finish_render_texture;
 723    intel->ctx.Driver.ResizeBuffers = intel_resize_buffers;
 724    intel->ctx.Driver.ValidateFramebuffer = intel_validate_framebuffer;
 725    intel->ctx.Driver.BlitFramebuffer = intel_blit_framebuffer;
 726 }