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/texrender.h"
  37 #include "drivers/common/meta.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->Format = MESA_FORMAT_RGB565;
 118       rb->DataType = GL_UNSIGNED_BYTE;
 119       irb->texformat = MESA_FORMAT_RGB565;
 120       cpp = 2;
 121       break;
 122    case GL_RGB:
 123    case GL_RGB8:
 124    case GL_RGB10:
 125    case GL_RGB12:
 126    case GL_RGB16:
 127       rb->Format = MESA_FORMAT_ARGB8888;
 128       rb->DataType = GL_UNSIGNED_BYTE;
 129       irb->texformat = MESA_FORMAT_ARGB8888; /* XXX: Need xrgb8888 */
 130       cpp = 4;
 131       break;
 132    case GL_RGBA:
 133    case GL_RGBA2:
 134    case GL_RGBA4:
 135    case GL_RGB5_A1:
 136    case GL_RGBA8:
 137    case GL_RGB10_A2:
 138    case GL_RGBA12:
 139    case GL_RGBA16:
 140       rb->Format = MESA_FORMAT_ARGB8888;
 141       rb->DataType = GL_UNSIGNED_BYTE;
 142       irb->texformat = MESA_FORMAT_ARGB8888;
 143       cpp = 4;
 144       break;
 145    case GL_STENCIL_INDEX:
 146    case GL_STENCIL_INDEX1_EXT:
 147    case GL_STENCIL_INDEX4_EXT:
 148    case GL_STENCIL_INDEX8_EXT:
 149    case GL_STENCIL_INDEX16_EXT:
 150       /* alloc a depth+stencil buffer */
 151       rb->Format = MESA_FORMAT_S8_Z24;
 152       rb->DataType = GL_UNSIGNED_INT_24_8_EXT;
 153       cpp = 4;
 154       irb->texformat = MESA_FORMAT_S8_Z24;
 155       break;
 156    case GL_DEPTH_COMPONENT16:
 157       rb->Format = MESA_FORMAT_Z16;
 158       rb->DataType = GL_UNSIGNED_SHORT;
 159       cpp = 2;
 160       irb->texformat = MESA_FORMAT_Z16;
 161       break;
 162    case GL_DEPTH_COMPONENT:
 163    case GL_DEPTH_COMPONENT24:
 164    case GL_DEPTH_COMPONENT32:
 165       rb->Format = MESA_FORMAT_S8_Z24;
 166       rb->DataType = GL_UNSIGNED_INT_24_8_EXT;
 167       cpp = 4;
 168       irb->texformat = MESA_FORMAT_S8_Z24;
 169       break;
 170    case GL_DEPTH_STENCIL_EXT:
 171    case GL_DEPTH24_STENCIL8_EXT:
 172       rb->Format = MESA_FORMAT_S8_Z24;
 173       rb->DataType = GL_UNSIGNED_INT_24_8_EXT;
 174       cpp = 4;
 175       irb->texformat = MESA_FORMAT_S8_Z24;
 176       break;
 177    default:
 178       _mesa_problem(ctx,
 179                     "Unexpected format in intel_alloc_renderbuffer_storage");
 180       return GL_FALSE;
 181    }
 182
 183    rb->_BaseFormat = _mesa_base_fbo_format(ctx, internalFormat);
 184
 185    intelFlush(ctx);
 186
 187    /* free old region */
 188    if (irb->region) {
 189       intel_region_release(&irb->region);
 190    }
 191
 192    /* allocate new memory region/renderbuffer */
 193    if (softwareBuffer) {
 194       return _mesa_soft_renderbuffer_storage(ctx, rb, internalFormat,
 195                                              width, height);
 196    }
 197    else {
 198       /* Choose a pitch to match hardware requirements:
 199        */
 200       GLuint pitch = ((cpp * width + 63) & ~63) / cpp;
 201
 202       /* alloc hardware renderbuffer */
 203       DBG("Allocating %d x %d Intel RBO (pitch %d)\n", width,
 204           height, pitch);
 205
 206       irb->region = intel_region_alloc(intel, I915_TILING_NONE,
 207                                        cpp, width, height, pitch,
 208                                        GL_TRUE);
 209       if (!irb->region)
 210          return GL_FALSE;       /* out of memory? */
 211
 212       ASSERT(irb->region->buffer);
 213
 214       rb->Width = width;
 215       rb->Height = height;
 216
 217       return GL_TRUE;
 218    }
 219 }
 220
 221
 222 /**
 223  * Called for each hardware renderbuffer when a _window_ is resized.
 224  * Just update fields.
 225  * Not used for user-created renderbuffers!
 226  */
 227 static GLboolean
 228 intel_alloc_window_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
 229                            GLenum internalFormat, GLuint width, GLuint height)
 230 {
 231    ASSERT(rb->Name == 0);
 232    rb->Width = width;
 233    rb->Height = height;
 234    rb->InternalFormat = internalFormat;
 235
 236    return GL_TRUE;
 237 }
 238
 239
 240 static void
 241 intel_resize_buffers(GLcontext *ctx, struct gl_framebuffer *fb,
 242                      GLuint width, GLuint height)
 243 {
 244    struct intel_framebuffer *intel_fb = (struct intel_framebuffer*)fb;
 245    int i;
 246
 247    _mesa_resize_framebuffer(ctx, fb, width, height);
 248
 249    fb->Initialized = GL_TRUE; /* XXX remove someday */
 250
 251    if (fb->Name != 0) {
 252       return;
 253    }
 254
 255    /* Make sure all window system renderbuffers are up to date */
 256    for (i = 0; i < 2; i++) {
 257       struct gl_renderbuffer *rb = &intel_fb->color_rb[i]->Base;
 258
 259       /* only resize if size is changing */
 260       if (rb && (rb->Width != width || rb->Height != height)) {
 261          rb->AllocStorage(ctx, rb, rb->InternalFormat, width, height);
 262       }
 263    }
 264 }
 265
 266
 267 /** Dummy function for gl_renderbuffer::AllocStorage() */
 268 static GLboolean
 269 intel_nop_alloc_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
 270                         GLenum internalFormat, GLuint width, GLuint height)
 271 {
 272    _mesa_problem(ctx, "intel_op_alloc_storage should never be called.");
 273    return GL_FALSE;
 274 }
 275
 276
 277 void
 278 intel_renderbuffer_set_region(struct intel_renderbuffer *rb,
 279                               struct intel_region *region)
 280 {
 281    struct intel_region *old;
 282
 283    old = rb->region;
 284    rb->region = NULL;
 285    intel_region_reference(&rb->region, region);
 286    intel_region_release(&old);
 287 }
 288
 289
 290 /**
 291  * Create a new intel_renderbuffer which corresponds to an on-screen window,
 292  * not a user-created renderbuffer.
 293  */
 294 struct intel_renderbuffer *
 295 intel_create_renderbuffer(GLenum intFormat)
 296 {
 297    GET_CURRENT_CONTEXT(ctx);
 298
 299    struct intel_renderbuffer *irb;
 300    const GLuint name = 0;
 301
 302    irb = CALLOC_STRUCT(intel_renderbuffer);
 303    if (!irb) {
 304       _mesa_error(ctx, GL_OUT_OF_MEMORY, "creating renderbuffer");
 305       return NULL;
 306    }
 307
 308    _mesa_init_renderbuffer(&irb->Base, name);
 309    irb->Base.ClassID = INTEL_RB_CLASS;
 310
 311    switch (intFormat) {
 312    case GL_RGB5:
 313       irb->Base.Format = MESA_FORMAT_RGB565;
 314       irb->Base._BaseFormat = GL_RGB;
 315       irb->Base.DataType = GL_UNSIGNED_BYTE;
 316       irb->texformat = MESA_FORMAT_RGB565;
 317       break;
 318    case GL_RGB8:
 319       irb->Base.Format = MESA_FORMAT_ARGB8888; /* XXX: NEED XRGB8888 */
 320       irb->Base._BaseFormat = GL_RGB;
 321       irb->Base.DataType = GL_UNSIGNED_BYTE;
 322       irb->texformat = MESA_FORMAT_ARGB8888; /* XXX: NEED XRGB8888 */
 323       break;
 324    case GL_RGBA8:
 325       irb->Base.Format = MESA_FORMAT_ARGB8888;
 326       irb->Base._BaseFormat = GL_RGBA;
 327       irb->Base.DataType = GL_UNSIGNED_BYTE;
 328       irb->texformat = MESA_FORMAT_ARGB8888;
 329       break;
 330    case GL_STENCIL_INDEX8_EXT:
 331       irb->Base.Format = MESA_FORMAT_S8_Z24;
 332       irb->Base._BaseFormat = GL_STENCIL_INDEX;
 333       irb->Base.DataType = GL_UNSIGNED_BYTE;
 334       irb->texformat = MESA_FORMAT_S8_Z24;
 335       break;
 336    case GL_DEPTH_COMPONENT16:
 337       irb->Base.Format = MESA_FORMAT_Z16;
 338       irb->Base._BaseFormat = GL_DEPTH_COMPONENT;
 339       irb->Base.DataType = GL_UNSIGNED_SHORT;
 340       irb->texformat = MESA_FORMAT_Z16;
 341       break;
 342    case GL_DEPTH_COMPONENT24:
 343       irb->Base.Format = MESA_FORMAT_S8_Z24;
 344       irb->Base._BaseFormat = GL_DEPTH_COMPONENT;
 345       irb->Base.DataType = GL_UNSIGNED_INT;
 346       irb->texformat = MESA_FORMAT_S8_Z24;
 347       break;
 348    case GL_DEPTH24_STENCIL8_EXT:
 349       irb->Base.Format = MESA_FORMAT_S8_Z24;
 350       irb->Base._BaseFormat = GL_DEPTH_STENCIL;
 351       irb->Base.DataType = GL_UNSIGNED_INT_24_8_EXT;
 352       irb->texformat = MESA_FORMAT_S8_Z24;
 353       break;
 354    default:
 355       _mesa_problem(NULL,
 356                     "Unexpected intFormat in intel_create_renderbuffer");
 357       _mesa_free(irb);
 358       return NULL;
 359    }
 360
 361    irb->Base.InternalFormat = intFormat;
 362
 363    /* intel-specific methods */
 364    irb->Base.Delete = intel_delete_renderbuffer;
 365    irb->Base.AllocStorage = intel_alloc_window_storage;
 366    irb->Base.GetPointer = intel_get_pointer;
 367
 368    return irb;
 369 }
 370
 371
 372 /**
 373  * Create a new renderbuffer object.
 374  * Typically called via glBindRenderbufferEXT().
 375  */
 376 static struct gl_renderbuffer *
 377 intel_new_renderbuffer(GLcontext * ctx, GLuint name)
 378 {
 379    /*struct intel_context *intel = intel_context(ctx); */
 380    struct intel_renderbuffer *irb;
 381
 382    irb = CALLOC_STRUCT(intel_renderbuffer);
 383    if (!irb) {
 384       _mesa_error(ctx, GL_OUT_OF_MEMORY, "creating renderbuffer");
 385       return NULL;
 386    }
 387
 388    _mesa_init_renderbuffer(&irb->Base, name);
 389    irb->Base.ClassID = INTEL_RB_CLASS;
 390
 391    /* intel-specific methods */
 392    irb->Base.Delete = intel_delete_renderbuffer;
 393    irb->Base.AllocStorage = intel_alloc_renderbuffer_storage;
 394    irb->Base.GetPointer = intel_get_pointer;
 395    /* span routines set in alloc_storage function */
 396
 397    return &irb->Base;
 398 }
 399
 400
 401 /**
 402  * Called via glBindFramebufferEXT().
 403  */
 404 static void
 405 intel_bind_framebuffer(GLcontext * ctx, GLenum target,
 406                        struct gl_framebuffer *fb, struct gl_framebuffer *fbread)
 407 {
 408    if (target == GL_FRAMEBUFFER_EXT || target == GL_DRAW_FRAMEBUFFER_EXT) {
 409       intel_draw_buffer(ctx, fb);
 410    }
 411    else {
 412       /* don't need to do anything if target == GL_READ_FRAMEBUFFER_EXT */
 413    }
 414 }
 415
 416
 417 /**
 418  * Called via glFramebufferRenderbufferEXT().
 419  */
 420 static void
 421 intel_framebuffer_renderbuffer(GLcontext * ctx,
 422                                struct gl_framebuffer *fb,
 423                                GLenum attachment, struct gl_renderbuffer *rb)
 424 {
 425    DBG("Intel FramebufferRenderbuffer %u %u\n", fb->Name, rb ? rb->Name : 0);
 426
 427    intelFlush(ctx);
 428
 429    _mesa_framebuffer_renderbuffer(ctx, fb, attachment, rb);
 430    intel_draw_buffer(ctx, fb);
 431 }
 432
 433
 434 static GLboolean
 435 intel_update_wrapper(GLcontext *ctx, struct intel_renderbuffer *irb,
 436                      struct gl_texture_image *texImage)
 437 {
 438    irb->texformat = texImage->TexFormat;
 439    gl_format texFormat;
 440
 441    if (texImage->TexFormat == MESA_FORMAT_ARGB8888) {
 442       irb->Base.DataType = GL_UNSIGNED_BYTE;
 443       DBG("Render to RGBA8 texture OK\n");
 444    }
 445    else if (texImage->TexFormat == MESA_FORMAT_RGB565) {
 446       irb->Base.DataType = GL_UNSIGNED_BYTE;
 447       DBG("Render to RGB5 texture OK\n");
 448    }
 449    else if (texImage->TexFormat == MESA_FORMAT_ARGB1555) {
 450       irb->Base.DataType = GL_UNSIGNED_BYTE;
 451       DBG("Render to ARGB1555 texture OK\n");
 452    }
 453    else if (texImage->TexFormat == MESA_FORMAT_ARGB4444) {
 454       irb->Base.DataType = GL_UNSIGNED_BYTE;
 455       DBG("Render to ARGB4444 texture OK\n");
 456    }
 457    else if (texImage->TexFormat == MESA_FORMAT_Z16) {
 458       irb->Base.DataType = GL_UNSIGNED_SHORT;
 459       DBG("Render to DEPTH16 texture OK\n");
 460    }
 461    else if (texImage->TexFormat == MESA_FORMAT_S8_Z24) {
 462       irb->Base.DataType = GL_UNSIGNED_INT_24_8_EXT;
 463       DBG("Render to DEPTH_STENCIL texture OK\n");
 464    }
 465    else {
 466       DBG("Render to texture BAD FORMAT %d\n", texImage->TexFormat);
 467       return GL_FALSE;
 468    }
 469
 470    irb->Base.Format = texImage->TexFormat;
 471
 472    texFormat = texImage->TexFormat;
 473
 474    irb->Base.InternalFormat = texImage->InternalFormat;
 475    irb->Base._BaseFormat = _mesa_base_fbo_format(ctx, irb->Base.InternalFormat);
 476    irb->Base.Width = texImage->Width;
 477    irb->Base.Height = texImage->Height;
 478
 479    irb->Base.Delete = intel_delete_renderbuffer;
 480    irb->Base.AllocStorage = intel_nop_alloc_storage;
 481
 482    return GL_TRUE;
 483 }
 484
 485
 486 /**
 487  * When glFramebufferTexture[123]D is called this function sets up the
 488  * gl_renderbuffer wrapper around the texture image.
 489  * This will have the region info needed for hardware rendering.
 490  */
 491 static struct intel_renderbuffer *
 492 intel_wrap_texture(GLcontext * ctx, struct gl_texture_image *texImage)
 493 {
 494    const GLuint name = ~0;   /* not significant, but distinct for debugging */
 495    struct intel_renderbuffer *irb;
 496
 497    /* make an intel_renderbuffer to wrap the texture image */
 498    irb = CALLOC_STRUCT(intel_renderbuffer);
 499    if (!irb) {
 500       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glFramebufferTexture");
 501       return NULL;
 502    }
 503
 504    _mesa_init_renderbuffer(&irb->Base, name);
 505    irb->Base.ClassID = INTEL_RB_CLASS;
 506
 507    if (!intel_update_wrapper(ctx, irb, texImage)) {
 508       _mesa_free(irb);
 509       return NULL;
 510    }
 511
 512    return irb;
 513 }
 514
 515
 516 /**
 517  * Called by glFramebufferTexture[123]DEXT() (and other places) to
 518  * prepare for rendering into texture memory.  This might be called
 519  * many times to choose different texture levels, cube faces, etc
 520  * before intel_finish_render_texture() is ever called.
 521  */
 522 static void
 523 intel_render_texture(GLcontext * ctx,
 524                      struct gl_framebuffer *fb,
 525                      struct gl_renderbuffer_attachment *att)
 526 {
 527    struct gl_texture_image *newImage
 528       = att->Texture->Image[att->CubeMapFace][att->TextureLevel];
 529    struct intel_renderbuffer *irb = intel_renderbuffer(att->Renderbuffer);
 530    struct intel_texture_image *intel_image;
 531    GLuint dst_x, dst_y;
 532
 533    (void) fb;
 534
 535    ASSERT(newImage);
 536
 537    intel_image = intel_texture_image(newImage);
 538    if (!intel_image->mt) {
 539       /* Fallback on drawing to a texture that doesn't have a miptree
 540        * (has a border, width/height 0, etc.)
 541        */
 542       _mesa_reference_renderbuffer(&att->Renderbuffer, NULL);
 543       _mesa_render_texture(ctx, fb, att);
 544       return;
 545    }
 546    else if (!irb) {
 547       irb = intel_wrap_texture(ctx, newImage);
 548       if (irb) {
 549          /* bind the wrapper to the attachment point */
 550          _mesa_reference_renderbuffer(&att->Renderbuffer, &irb->Base);
 551       }
 552       else {
 553          /* fallback to software rendering */
 554          _mesa_render_texture(ctx, fb, att);
 555          return;
 556       }
 557    }
 558
 559    if (!intel_update_wrapper(ctx, irb, newImage)) {
 560        _mesa_reference_renderbuffer(&att->Renderbuffer, NULL);
 561        _mesa_render_texture(ctx, fb, att);
 562        return;
 563    }
 564
 565    DBG("Begin render texture tid %x tex=%u w=%d h=%d refcount=%d\n",
 566        _glthread_GetID(),
 567        att->Texture->Name, newImage->Width, newImage->Height,
 568        irb->Base.RefCount);
 569
 570    /* point the renderbufer's region to the texture image region */
 571    if (irb->region != intel_image->mt->region) {
 572       if (irb->region)
 573          intel_region_release(&irb->region);
 574       intel_region_reference(&irb->region, intel_image->mt->region);
 575    }
 576
 577    /* compute offset of the particular 2D image within the texture region */
 578    intel_miptree_get_image_offset(intel_image->mt,
 579                                   att->TextureLevel,
 580                                   att->CubeMapFace,
 581                                   att->Zoffset,
 582                                   &dst_x, &dst_y);
 583
 584    intel_image->mt->region->draw_offset = (dst_y * intel_image->mt->pitch +
 585                                            dst_x) * intel_image->mt->cpp;
 586    intel_image->mt->region->draw_x = dst_x;
 587    intel_image->mt->region->draw_y = dst_y;
 588
 589    /* update drawing region, etc */
 590    intel_draw_buffer(ctx, fb);
 591 }
 592
 593
 594 /**
 595  * Called by Mesa when rendering to a texture is done.
 596  */
 597 static void
 598 intel_finish_render_texture(GLcontext * ctx,
 599                             struct gl_renderbuffer_attachment *att)
 600 {
 601    /* no-op
 602     * Previously we released the renderbuffer's intel_region but
 603     * that's not necessary and actually caused problems when trying
 604     * to do a glRead/CopyPixels from the renderbuffer later.
 605     * The region will be released later if the texture is replaced
 606     * or the renderbuffer deleted.
 607     *
 608     * The intention of this driver hook is more of a "done rendering
 609     * to texture, please re-twiddle/etc if necessary".
 610     */
 611 }
 612
 613
 614 /**
 615  * Do additional "completeness" testing of a framebuffer object.
 616  */
 617 static void
 618 intel_validate_framebuffer(GLcontext *ctx, struct gl_framebuffer *fb)
 619 {
 620    const struct intel_renderbuffer *depthRb =
 621       intel_get_renderbuffer(fb, BUFFER_DEPTH);
 622    const struct intel_renderbuffer *stencilRb =
 623       intel_get_renderbuffer(fb, BUFFER_STENCIL);
 624    int i;
 625
 626    if (stencilRb && stencilRb != depthRb) {
 627       /* we only support combined depth/stencil buffers, not separate
 628        * stencil buffers.
 629        */
 630       fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
 631    }
 632
 633    for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
 634       struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[i];
 635       struct intel_renderbuffer *irb = intel_renderbuffer(rb);
 636
 637       if (rb == NULL)
 638          continue;
 639
 640       if (irb == NULL) {
 641          fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
 642          continue;
 643       }
 644
 645       switch (irb->texformat) {
 646       case MESA_FORMAT_ARGB8888:
 647       case MESA_FORMAT_RGB565:
 648       case MESA_FORMAT_ARGB1555:
 649       case MESA_FORMAT_ARGB4444:
 650          break;
 651       default:
 652          fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
 653       }
 654    }
 655 }
 656
 657
 658 /**
 659  * Do one-time context initializations related to GL_EXT_framebuffer_object.
 660  * Hook in device driver functions.
 661  */
 662 void
 663 intel_fbo_init(struct intel_context *intel)
 664 {
 665    intel->ctx.Driver.NewFramebuffer = intel_new_framebuffer;
 666    intel->ctx.Driver.NewRenderbuffer = intel_new_renderbuffer;
 667    intel->ctx.Driver.BindFramebuffer = intel_bind_framebuffer;
 668    intel->ctx.Driver.FramebufferRenderbuffer = intel_framebuffer_renderbuffer;
 669    intel->ctx.Driver.RenderTexture = intel_render_texture;
 670    intel->ctx.Driver.FinishRenderTexture = intel_finish_render_texture;
 671    intel->ctx.Driver.ResizeBuffers = intel_resize_buffers;
 672    intel->ctx.Driver.ValidateFramebuffer = intel_validate_framebuffer;
 673    intel->ctx.Driver.BlitFramebuffer = _mesa_meta_BlitFramebuffer;
 674 }