intel_fbo.c revision f9995b30756140724f41daf963fa06167912be7f
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_batchbuffer.h" 41#include "intel_buffers.h" 42#include "intel_fbo.h" 43#include "intel_mipmap_tree.h" 44#include "intel_regions.h" 45 46#define FILE_DEBUG_FLAG DEBUG_FBO 47 48 49/** 50 * Create a new framebuffer object. 51 */ 52static struct gl_framebuffer * 53intel_new_framebuffer(struct gl_context * 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() */ 63static void 64intel_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 (intel && irb->region) { 73 intel_region_release(&irb->region); 74 } 75 76 free(irb); 77} 78 79 80/** 81 * Return a pointer to a specific pixel in a renderbuffer. 82 */ 83static void * 84intel_get_pointer(struct gl_context * ctx, struct gl_renderbuffer *rb, 85 GLint x, GLint y) 86{ 87 /* By returning NULL we force all software rendering to go through 88 * the span routines. 89 */ 90 return NULL; 91} 92 93 94/** 95 * Called via glRenderbufferStorageEXT() to set the format and allocate 96 * storage for a user-created renderbuffer. 97 */ 98static GLboolean 99intel_alloc_renderbuffer_storage(struct gl_context * ctx, struct gl_renderbuffer *rb, 100 GLenum internalFormat, 101 GLuint width, GLuint height) 102{ 103 struct intel_context *intel = intel_context(ctx); 104 struct intel_renderbuffer *irb = intel_renderbuffer(rb); 105 int cpp, tiling; 106 107 ASSERT(rb->Name != 0); 108 109 switch (internalFormat) { 110 case GL_RED: 111 case GL_R8: 112 rb->Format = MESA_FORMAT_R8; 113 rb->DataType = GL_UNSIGNED_BYTE; 114 break; 115 case GL_R16: 116 rb->Format = MESA_FORMAT_R16; 117 rb->DataType = GL_UNSIGNED_SHORT; 118 break; 119 case GL_RG: 120 case GL_RG8: 121 rb->Format = MESA_FORMAT_RG88; 122 rb->DataType = GL_UNSIGNED_BYTE; 123 break; 124 case GL_RG16: 125 rb->Format = MESA_FORMAT_RG1616; 126 rb->DataType = GL_UNSIGNED_SHORT; 127 break; 128 case GL_R3_G3_B2: 129 case GL_RGB4: 130 case GL_RGB5: 131 rb->Format = MESA_FORMAT_RGB565; 132 rb->DataType = GL_UNSIGNED_BYTE; 133 break; 134 case GL_RGB: 135 case GL_RGB8: 136 case GL_RGB10: 137 case GL_RGB12: 138 case GL_RGB16: 139 rb->Format = MESA_FORMAT_XRGB8888; 140 rb->DataType = GL_UNSIGNED_BYTE; 141 break; 142 case GL_RGBA: 143 case GL_RGBA2: 144 case GL_RGBA4: 145 case GL_RGB5_A1: 146 case GL_RGBA8: 147 case GL_RGB10_A2: 148 case GL_RGBA12: 149 case GL_RGBA16: 150 rb->Format = MESA_FORMAT_ARGB8888; 151 rb->DataType = GL_UNSIGNED_BYTE; 152 break; 153 case GL_ALPHA: 154 case GL_ALPHA8: 155 rb->Format = MESA_FORMAT_A8; 156 rb->DataType = GL_UNSIGNED_BYTE; 157 break; 158 case GL_DEPTH_COMPONENT16: 159 rb->Format = MESA_FORMAT_Z16; 160 rb->DataType = GL_UNSIGNED_SHORT; 161 break; 162 case GL_STENCIL_INDEX: 163 case GL_STENCIL_INDEX1_EXT: 164 case GL_STENCIL_INDEX4_EXT: 165 case GL_STENCIL_INDEX8_EXT: 166 case GL_STENCIL_INDEX16_EXT: 167 case GL_DEPTH_COMPONENT: 168 case GL_DEPTH_COMPONENT24: 169 case GL_DEPTH_COMPONENT32: 170 case GL_DEPTH_STENCIL_EXT: 171 case GL_DEPTH24_STENCIL8_EXT: 172 /* alloc a depth+stencil buffer */ 173 rb->Format = MESA_FORMAT_S8_Z24; 174 rb->DataType = GL_UNSIGNED_INT_24_8_EXT; 175 break; 176 default: 177 _mesa_problem(ctx, 178 "Unexpected format in intel_alloc_renderbuffer_storage"); 179 return GL_FALSE; 180 } 181 182 rb->_BaseFormat = _mesa_base_fbo_format(ctx, internalFormat); 183 cpp = _mesa_get_format_bytes(rb->Format); 184 185 intel_flush(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 194 /* alloc hardware renderbuffer */ 195 DBG("Allocating %d x %d Intel RBO\n", width, height); 196 197 tiling = I915_TILING_NONE; 198 199 /* Gen6 requires depth must be tiling */ 200 if (intel->gen >= 6 && rb->Format == MESA_FORMAT_S8_Z24) 201 tiling = I915_TILING_Y; 202 203 irb->region = intel_region_alloc(intel->intelScreen, tiling, cpp, 204 width, height, GL_TRUE); 205 if (!irb->region) 206 return GL_FALSE; /* out of memory? */ 207 208 ASSERT(irb->region->buffer); 209 210 rb->Width = width; 211 rb->Height = height; 212 213 return GL_TRUE; 214} 215 216 217#if FEATURE_OES_EGL_image 218static void 219intel_image_target_renderbuffer_storage(struct gl_context *ctx, 220 struct gl_renderbuffer *rb, 221 void *image_handle) 222{ 223 struct intel_context *intel = intel_context(ctx); 224 struct intel_renderbuffer *irb; 225 __DRIscreen *screen; 226 __DRIimage *image; 227 228 screen = intel->intelScreen->driScrnPriv; 229 image = screen->dri2.image->lookupEGLImage(screen, image_handle, 230 screen->loaderPrivate); 231 if (image == NULL) 232 return; 233 234 irb = intel_renderbuffer(rb); 235 if (irb->region) 236 intel_region_release(&irb->region); 237 intel_region_reference(&irb->region, image->region); 238 239 rb->InternalFormat = image->internal_format; 240 rb->Width = image->region->width; 241 rb->Height = image->region->height; 242 rb->Format = image->format; 243 rb->DataType = image->data_type; 244 rb->_BaseFormat = _mesa_base_fbo_format(&intel->ctx, 245 image->internal_format); 246} 247#endif 248 249/** 250 * Called for each hardware renderbuffer when a _window_ is resized. 251 * Just update fields. 252 * Not used for user-created renderbuffers! 253 */ 254static GLboolean 255intel_alloc_window_storage(struct gl_context * ctx, struct gl_renderbuffer *rb, 256 GLenum internalFormat, GLuint width, GLuint height) 257{ 258 ASSERT(rb->Name == 0); 259 rb->Width = width; 260 rb->Height = height; 261 rb->InternalFormat = internalFormat; 262 263 return GL_TRUE; 264} 265 266 267static void 268intel_resize_buffers(struct gl_context *ctx, struct gl_framebuffer *fb, 269 GLuint width, GLuint height) 270{ 271 int i; 272 273 _mesa_resize_framebuffer(ctx, fb, width, height); 274 275 fb->Initialized = GL_TRUE; /* XXX remove someday */ 276 277 if (fb->Name != 0) { 278 return; 279 } 280 281 282 /* Make sure all window system renderbuffers are up to date */ 283 for (i = BUFFER_FRONT_LEFT; i <= BUFFER_BACK_RIGHT; i++) { 284 struct gl_renderbuffer *rb = fb->Attachment[i].Renderbuffer; 285 286 /* only resize if size is changing */ 287 if (rb && (rb->Width != width || rb->Height != height)) { 288 rb->AllocStorage(ctx, rb, rb->InternalFormat, width, height); 289 } 290 } 291} 292 293 294/** Dummy function for gl_renderbuffer::AllocStorage() */ 295static GLboolean 296intel_nop_alloc_storage(struct gl_context * ctx, struct gl_renderbuffer *rb, 297 GLenum internalFormat, GLuint width, GLuint height) 298{ 299 _mesa_problem(ctx, "intel_op_alloc_storage should never be called."); 300 return GL_FALSE; 301} 302 303 304void 305intel_renderbuffer_set_region(struct intel_context *intel, 306 struct intel_renderbuffer *rb, 307 struct intel_region *region) 308{ 309 struct intel_region *old; 310 311 old = rb->region; 312 rb->region = NULL; 313 intel_region_reference(&rb->region, region); 314 intel_region_release(&old); 315} 316 317 318/** 319 * Create a new intel_renderbuffer which corresponds to an on-screen window, 320 * not a user-created renderbuffer. 321 */ 322struct intel_renderbuffer * 323intel_create_renderbuffer(gl_format format) 324{ 325 GET_CURRENT_CONTEXT(ctx); 326 327 struct intel_renderbuffer *irb; 328 329 irb = CALLOC_STRUCT(intel_renderbuffer); 330 if (!irb) { 331 _mesa_error(ctx, GL_OUT_OF_MEMORY, "creating renderbuffer"); 332 return NULL; 333 } 334 335 _mesa_init_renderbuffer(&irb->Base, 0); 336 irb->Base.ClassID = INTEL_RB_CLASS; 337 338 switch (format) { 339 case MESA_FORMAT_RGB565: 340 irb->Base._BaseFormat = GL_RGB; 341 irb->Base.DataType = GL_UNSIGNED_BYTE; 342 break; 343 case MESA_FORMAT_XRGB8888: 344 irb->Base._BaseFormat = GL_RGB; 345 irb->Base.DataType = GL_UNSIGNED_BYTE; 346 break; 347 case MESA_FORMAT_ARGB8888: 348 irb->Base._BaseFormat = GL_RGBA; 349 irb->Base.DataType = GL_UNSIGNED_BYTE; 350 break; 351 case MESA_FORMAT_Z16: 352 irb->Base._BaseFormat = GL_DEPTH_COMPONENT; 353 irb->Base.DataType = GL_UNSIGNED_SHORT; 354 break; 355 case MESA_FORMAT_X8_Z24: 356 irb->Base._BaseFormat = GL_DEPTH_COMPONENT; 357 irb->Base.DataType = GL_UNSIGNED_INT; 358 break; 359 case MESA_FORMAT_S8_Z24: 360 irb->Base._BaseFormat = GL_DEPTH_STENCIL; 361 irb->Base.DataType = GL_UNSIGNED_INT_24_8_EXT; 362 break; 363 case MESA_FORMAT_A8: 364 irb->Base._BaseFormat = GL_ALPHA; 365 irb->Base.DataType = GL_UNSIGNED_BYTE; 366 break; 367 case MESA_FORMAT_R8: 368 irb->Base._BaseFormat = GL_RED; 369 irb->Base.DataType = GL_UNSIGNED_BYTE; 370 break; 371 case MESA_FORMAT_RG88: 372 irb->Base._BaseFormat = GL_RG; 373 irb->Base.DataType = GL_UNSIGNED_BYTE; 374 break; 375 default: 376 _mesa_problem(NULL, 377 "Unexpected intFormat in intel_create_renderbuffer"); 378 free(irb); 379 return NULL; 380 } 381 382 irb->Base.Format = format; 383 irb->Base.InternalFormat = irb->Base._BaseFormat; 384 385 /* intel-specific methods */ 386 irb->Base.Delete = intel_delete_renderbuffer; 387 irb->Base.AllocStorage = intel_alloc_window_storage; 388 irb->Base.GetPointer = intel_get_pointer; 389 390 return irb; 391} 392 393 394/** 395 * Create a new renderbuffer object. 396 * Typically called via glBindRenderbufferEXT(). 397 */ 398static struct gl_renderbuffer * 399intel_new_renderbuffer(struct gl_context * ctx, GLuint name) 400{ 401 /*struct intel_context *intel = intel_context(ctx); */ 402 struct intel_renderbuffer *irb; 403 404 irb = CALLOC_STRUCT(intel_renderbuffer); 405 if (!irb) { 406 _mesa_error(ctx, GL_OUT_OF_MEMORY, "creating renderbuffer"); 407 return NULL; 408 } 409 410 _mesa_init_renderbuffer(&irb->Base, name); 411 irb->Base.ClassID = INTEL_RB_CLASS; 412 413 /* intel-specific methods */ 414 irb->Base.Delete = intel_delete_renderbuffer; 415 irb->Base.AllocStorage = intel_alloc_renderbuffer_storage; 416 irb->Base.GetPointer = intel_get_pointer; 417 /* span routines set in alloc_storage function */ 418 419 return &irb->Base; 420} 421 422 423/** 424 * Called via glBindFramebufferEXT(). 425 */ 426static void 427intel_bind_framebuffer(struct gl_context * ctx, GLenum target, 428 struct gl_framebuffer *fb, struct gl_framebuffer *fbread) 429{ 430 if (target == GL_FRAMEBUFFER_EXT || target == GL_DRAW_FRAMEBUFFER_EXT) { 431 intel_draw_buffer(ctx, fb); 432 } 433 else { 434 /* don't need to do anything if target == GL_READ_FRAMEBUFFER_EXT */ 435 } 436} 437 438 439/** 440 * Called via glFramebufferRenderbufferEXT(). 441 */ 442static void 443intel_framebuffer_renderbuffer(struct gl_context * ctx, 444 struct gl_framebuffer *fb, 445 GLenum attachment, struct gl_renderbuffer *rb) 446{ 447 DBG("Intel FramebufferRenderbuffer %u %u\n", fb->Name, rb ? rb->Name : 0); 448 449 intel_flush(ctx); 450 451 _mesa_framebuffer_renderbuffer(ctx, fb, attachment, rb); 452 intel_draw_buffer(ctx, fb); 453} 454 455 456static GLboolean 457intel_update_wrapper(struct gl_context *ctx, struct intel_renderbuffer *irb, 458 struct gl_texture_image *texImage) 459{ 460 if (texImage->TexFormat == MESA_FORMAT_ARGB8888) { 461 irb->Base.DataType = GL_UNSIGNED_BYTE; 462 DBG("Render to RGBA8 texture OK\n"); 463 } 464 else if (texImage->TexFormat == MESA_FORMAT_XRGB8888) { 465 irb->Base.DataType = GL_UNSIGNED_BYTE; 466 DBG("Render to XGBA8 texture OK\n"); 467 } 468 else if (texImage->TexFormat == MESA_FORMAT_SARGB8) { 469 irb->Base.DataType = GL_UNSIGNED_BYTE; 470 DBG("Render to SARGB8 texture OK\n"); 471 } 472 else if (texImage->TexFormat == MESA_FORMAT_RGB565) { 473 irb->Base.DataType = GL_UNSIGNED_BYTE; 474 DBG("Render to RGB5 texture OK\n"); 475 } 476 else if (texImage->TexFormat == MESA_FORMAT_ARGB1555) { 477 irb->Base.DataType = GL_UNSIGNED_BYTE; 478 DBG("Render to ARGB1555 texture OK\n"); 479 } 480 else if (texImage->TexFormat == MESA_FORMAT_ARGB4444) { 481 irb->Base.DataType = GL_UNSIGNED_BYTE; 482 DBG("Render to ARGB4444 texture OK\n"); 483 } 484 else if (texImage->TexFormat == MESA_FORMAT_A8) { 485 irb->Base.DataType = GL_UNSIGNED_BYTE; 486 DBG("Render to A8 texture OK\n"); 487 } 488 else if (texImage->TexFormat == MESA_FORMAT_R8) { 489 irb->Base.DataType = GL_UNSIGNED_BYTE; 490 DBG("Render to R8 texture OK\n"); 491 } 492 else if (texImage->TexFormat == MESA_FORMAT_RG88) { 493 irb->Base.DataType = GL_UNSIGNED_BYTE; 494 DBG("Render to RG88 texture OK\n"); 495 } 496 else if (texImage->TexFormat == MESA_FORMAT_R16) { 497 irb->Base.DataType = GL_UNSIGNED_SHORT; 498 DBG("Render to R8 texture OK\n"); 499 } 500 else if (texImage->TexFormat == MESA_FORMAT_RG1616) { 501 irb->Base.DataType = GL_UNSIGNED_SHORT; 502 DBG("Render to RG88 texture OK\n"); 503 } 504 else if (texImage->TexFormat == MESA_FORMAT_Z16) { 505 irb->Base.DataType = GL_UNSIGNED_SHORT; 506 DBG("Render to DEPTH16 texture OK\n"); 507 } 508 else if (texImage->TexFormat == MESA_FORMAT_S8_Z24) { 509 irb->Base.DataType = GL_UNSIGNED_INT_24_8_EXT; 510 DBG("Render to DEPTH_STENCIL texture OK\n"); 511 } 512 else { 513 DBG("Render to texture BAD FORMAT %s\n", 514 _mesa_get_format_name(texImage->TexFormat)); 515 return GL_FALSE; 516 } 517 518 irb->Base.Format = texImage->TexFormat; 519 520 irb->Base.InternalFormat = texImage->InternalFormat; 521 irb->Base._BaseFormat = _mesa_base_fbo_format(ctx, irb->Base.InternalFormat); 522 irb->Base.Width = texImage->Width; 523 irb->Base.Height = texImage->Height; 524 525 irb->Base.Delete = intel_delete_renderbuffer; 526 irb->Base.AllocStorage = intel_nop_alloc_storage; 527 528 return GL_TRUE; 529} 530 531 532/** 533 * When glFramebufferTexture[123]D is called this function sets up the 534 * gl_renderbuffer wrapper around the texture image. 535 * This will have the region info needed for hardware rendering. 536 */ 537static struct intel_renderbuffer * 538intel_wrap_texture(struct gl_context * ctx, struct gl_texture_image *texImage) 539{ 540 const GLuint name = ~0; /* not significant, but distinct for debugging */ 541 struct intel_renderbuffer *irb; 542 543 /* make an intel_renderbuffer to wrap the texture image */ 544 irb = CALLOC_STRUCT(intel_renderbuffer); 545 if (!irb) { 546 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glFramebufferTexture"); 547 return NULL; 548 } 549 550 _mesa_init_renderbuffer(&irb->Base, name); 551 irb->Base.ClassID = INTEL_RB_CLASS; 552 553 if (!intel_update_wrapper(ctx, irb, texImage)) { 554 free(irb); 555 return NULL; 556 } 557 558 return irb; 559} 560 561 562/** 563 * Called by glFramebufferTexture[123]DEXT() (and other places) to 564 * prepare for rendering into texture memory. This might be called 565 * many times to choose different texture levels, cube faces, etc 566 * before intel_finish_render_texture() is ever called. 567 */ 568static void 569intel_render_texture(struct gl_context * ctx, 570 struct gl_framebuffer *fb, 571 struct gl_renderbuffer_attachment *att) 572{ 573 struct gl_texture_image *newImage 574 = att->Texture->Image[att->CubeMapFace][att->TextureLevel]; 575 struct intel_renderbuffer *irb = intel_renderbuffer(att->Renderbuffer); 576 struct intel_texture_image *intel_image; 577 GLuint dst_x, dst_y; 578 579 (void) fb; 580 581 ASSERT(newImage); 582 583 intel_image = intel_texture_image(newImage); 584 if (!intel_image->mt) { 585 /* Fallback on drawing to a texture that doesn't have a miptree 586 * (has a border, width/height 0, etc.) 587 */ 588 _mesa_reference_renderbuffer(&att->Renderbuffer, NULL); 589 _mesa_render_texture(ctx, fb, att); 590 return; 591 } 592 else if (!irb) { 593 irb = intel_wrap_texture(ctx, newImage); 594 if (irb) { 595 /* bind the wrapper to the attachment point */ 596 _mesa_reference_renderbuffer(&att->Renderbuffer, &irb->Base); 597 } 598 else { 599 /* fallback to software rendering */ 600 _mesa_render_texture(ctx, fb, att); 601 return; 602 } 603 } 604 605 if (!intel_update_wrapper(ctx, irb, newImage)) { 606 _mesa_reference_renderbuffer(&att->Renderbuffer, NULL); 607 _mesa_render_texture(ctx, fb, att); 608 return; 609 } 610 611 DBG("Begin render texture tid %lx tex=%u w=%d h=%d refcount=%d\n", 612 _glthread_GetID(), 613 att->Texture->Name, newImage->Width, newImage->Height, 614 irb->Base.RefCount); 615 616 /* point the renderbufer's region to the texture image region */ 617 if (irb->region != intel_image->mt->region) { 618 if (irb->region) 619 intel_region_release(&irb->region); 620 intel_region_reference(&irb->region, intel_image->mt->region); 621 } 622 623 /* compute offset of the particular 2D image within the texture region */ 624 intel_miptree_get_image_offset(intel_image->mt, 625 att->TextureLevel, 626 att->CubeMapFace, 627 att->Zoffset, 628 &dst_x, &dst_y); 629 630 intel_image->mt->region->draw_offset = (dst_y * intel_image->mt->region->pitch + 631 dst_x) * intel_image->mt->cpp; 632 intel_image->mt->region->draw_x = dst_x; 633 intel_image->mt->region->draw_y = dst_y; 634 intel_image->used_as_render_target = GL_TRUE; 635 636 /* update drawing region, etc */ 637 intel_draw_buffer(ctx, fb); 638} 639 640 641/** 642 * Called by Mesa when rendering to a texture is done. 643 */ 644static void 645intel_finish_render_texture(struct gl_context * ctx, 646 struct gl_renderbuffer_attachment *att) 647{ 648 struct intel_context *intel = intel_context(ctx); 649 struct gl_texture_object *tex_obj = att->Texture; 650 struct gl_texture_image *image = 651 tex_obj->Image[att->CubeMapFace][att->TextureLevel]; 652 struct intel_texture_image *intel_image = intel_texture_image(image); 653 654 DBG("Finish render texture tid %lx tex=%u\n", 655 _glthread_GetID(), att->Texture->Name); 656 657 /* Flag that this image may now be validated into the object's miptree. */ 658 intel_image->used_as_render_target = GL_FALSE; 659 660 /* Since we've (probably) rendered to the texture and will (likely) use 661 * it in the texture domain later on in this batchbuffer, flush the 662 * batch. Once again, we wish for a domain tracker in libdrm to cover 663 * usage inside of a batchbuffer like GEM does in the kernel. 664 */ 665 intel_batchbuffer_emit_mi_flush(intel->batch); 666} 667 668/** 669 * Do additional "completeness" testing of a framebuffer object. 670 */ 671static void 672intel_validate_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb) 673{ 674 const struct intel_renderbuffer *depthRb = 675 intel_get_renderbuffer(fb, BUFFER_DEPTH); 676 const struct intel_renderbuffer *stencilRb = 677 intel_get_renderbuffer(fb, BUFFER_STENCIL); 678 int i; 679 680 if (depthRb && stencilRb && stencilRb != depthRb) { 681 if (ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Type == GL_TEXTURE && 682 ctx->DrawBuffer->Attachment[BUFFER_STENCIL].Type == GL_TEXTURE && 683 (ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Texture->Name == 684 ctx->DrawBuffer->Attachment[BUFFER_STENCIL].Texture->Name)) { 685 /* OK */ 686 } else { 687 /* we only support combined depth/stencil buffers, not separate 688 * stencil buffers. 689 */ 690 DBG("Only supports combined depth/stencil (found %s, %s)\n", 691 depthRb ? _mesa_get_format_name(depthRb->Base.Format): "NULL", 692 stencilRb ? _mesa_get_format_name(stencilRb->Base.Format): "NULL"); 693 fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT; 694 } 695 } 696 697 for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) { 698 struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[i]; 699 struct intel_renderbuffer *irb = intel_renderbuffer(rb); 700 701 if (rb == NULL) 702 continue; 703 704 if (irb == NULL) { 705 DBG("software rendering renderbuffer\n"); 706 fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT; 707 continue; 708 } 709 710 switch (irb->Base.Format) { 711 case MESA_FORMAT_ARGB8888: 712 case MESA_FORMAT_XRGB8888: 713 case MESA_FORMAT_SARGB8: 714 case MESA_FORMAT_RGB565: 715 case MESA_FORMAT_ARGB1555: 716 case MESA_FORMAT_ARGB4444: 717 case MESA_FORMAT_A8: 718 case MESA_FORMAT_R8: 719 case MESA_FORMAT_R16: 720 case MESA_FORMAT_RG88: 721 case MESA_FORMAT_RG1616: 722 break; 723 default: 724 fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT; 725 } 726 } 727} 728 729 730/** 731 * Do one-time context initializations related to GL_EXT_framebuffer_object. 732 * Hook in device driver functions. 733 */ 734void 735intel_fbo_init(struct intel_context *intel) 736{ 737 intel->ctx.Driver.NewFramebuffer = intel_new_framebuffer; 738 intel->ctx.Driver.NewRenderbuffer = intel_new_renderbuffer; 739 intel->ctx.Driver.BindFramebuffer = intel_bind_framebuffer; 740 intel->ctx.Driver.FramebufferRenderbuffer = intel_framebuffer_renderbuffer; 741 intel->ctx.Driver.RenderTexture = intel_render_texture; 742 intel->ctx.Driver.FinishRenderTexture = intel_finish_render_texture; 743 intel->ctx.Driver.ResizeBuffers = intel_resize_buffers; 744 intel->ctx.Driver.ValidateFramebuffer = intel_validate_framebuffer; 745 intel->ctx.Driver.BlitFramebuffer = _mesa_meta_BlitFramebuffer; 746 747#if FEATURE_OES_EGL_image 748 intel->ctx.Driver.EGLImageTargetRenderbufferStorage = 749 intel_image_target_renderbuffer_storage; 750#endif 751} 752