intel_fbo.c revision 29c4f95cbcad29d52bf3b6c875840b38b8823e4c
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#include "intel_tex.h" 46#include "intel_span.h" 47 48#define FILE_DEBUG_FLAG DEBUG_FBO 49 50 51/** 52 * Create a new framebuffer object. 53 */ 54static struct gl_framebuffer * 55intel_new_framebuffer(struct gl_context * ctx, GLuint name) 56{ 57 /* Only drawable state in intel_framebuffer at this time, just use Mesa's 58 * class 59 */ 60 return _mesa_new_framebuffer(ctx, name); 61} 62 63 64/** Called by gl_renderbuffer::Delete() */ 65static void 66intel_delete_renderbuffer(struct gl_renderbuffer *rb) 67{ 68 GET_CURRENT_CONTEXT(ctx); 69 struct intel_context *intel = intel_context(ctx); 70 struct intel_renderbuffer *irb = intel_renderbuffer(rb); 71 72 ASSERT(irb); 73 74 if (intel && irb->region) { 75 intel_region_release(&irb->region); 76 } 77 78 free(irb); 79} 80 81 82/** 83 * Return a pointer to a specific pixel in a renderbuffer. 84 */ 85static void * 86intel_get_pointer(struct gl_context * ctx, struct gl_renderbuffer *rb, 87 GLint x, GLint y) 88{ 89 /* By returning NULL we force all software rendering to go through 90 * the span routines. 91 */ 92 return NULL; 93} 94 95 96/** 97 * Called via glRenderbufferStorageEXT() to set the format and allocate 98 * storage for a user-created renderbuffer. 99 */ 100static GLboolean 101intel_alloc_renderbuffer_storage(struct gl_context * ctx, struct gl_renderbuffer *rb, 102 GLenum internalFormat, 103 GLuint width, GLuint height) 104{ 105 struct intel_context *intel = intel_context(ctx); 106 struct intel_renderbuffer *irb = intel_renderbuffer(rb); 107 int cpp, tiling; 108 109 ASSERT(rb->Name != 0); 110 111 switch (internalFormat) { 112 default: 113 /* Use the same format-choice logic as for textures. 114 * Renderbuffers aren't any different from textures for us, 115 * except they're less useful because you can't texture with 116 * them. 117 */ 118 rb->Format = intel->ctx.Driver.ChooseTextureFormat(ctx, internalFormat, 119 GL_NONE, GL_NONE); 120 break; 121 case GL_STENCIL_INDEX: 122 case GL_STENCIL_INDEX1_EXT: 123 case GL_STENCIL_INDEX4_EXT: 124 case GL_STENCIL_INDEX8_EXT: 125 case GL_STENCIL_INDEX16_EXT: 126 /* These aren't actual texture formats, so force them here. */ 127 rb->Format = MESA_FORMAT_S8_Z24; 128 break; 129 } 130 131 rb->_BaseFormat = _mesa_base_fbo_format(ctx, internalFormat); 132 rb->DataType = intel_mesa_format_to_rb_datatype(rb->Format); 133 cpp = _mesa_get_format_bytes(rb->Format); 134 135 intel_flush(ctx); 136 137 /* free old region */ 138 if (irb->region) { 139 intel_region_release(&irb->region); 140 } 141 142 /* allocate new memory region/renderbuffer */ 143 144 /* alloc hardware renderbuffer */ 145 DBG("Allocating %d x %d Intel RBO\n", width, height); 146 147 tiling = I915_TILING_NONE; 148 if (intel->use_texture_tiling) { 149 GLenum base_format = _mesa_get_format_base_format(rb->Format); 150 151 if (intel->gen >= 4 && (base_format == GL_DEPTH_COMPONENT || 152 base_format == GL_DEPTH_STENCIL)) 153 tiling = I915_TILING_Y; 154 else 155 tiling = I915_TILING_X; 156 } 157 158 irb->region = intel_region_alloc(intel->intelScreen, tiling, cpp, 159 width, height, GL_TRUE); 160 if (!irb->region) 161 return GL_FALSE; /* out of memory? */ 162 163 ASSERT(irb->region->buffer); 164 165 rb->Width = width; 166 rb->Height = height; 167 168 return GL_TRUE; 169} 170 171 172#if FEATURE_OES_EGL_image 173static void 174intel_image_target_renderbuffer_storage(struct gl_context *ctx, 175 struct gl_renderbuffer *rb, 176 void *image_handle) 177{ 178 struct intel_context *intel = intel_context(ctx); 179 struct intel_renderbuffer *irb; 180 __DRIscreen *screen; 181 __DRIimage *image; 182 183 screen = intel->intelScreen->driScrnPriv; 184 image = screen->dri2.image->lookupEGLImage(screen, image_handle, 185 screen->loaderPrivate); 186 if (image == NULL) 187 return; 188 189 irb = intel_renderbuffer(rb); 190 if (irb->region) 191 intel_region_release(&irb->region); 192 intel_region_reference(&irb->region, image->region); 193 194 rb->InternalFormat = image->internal_format; 195 rb->Width = image->region->width; 196 rb->Height = image->region->height; 197 rb->Format = image->format; 198 rb->DataType = image->data_type; 199 rb->_BaseFormat = _mesa_base_fbo_format(&intel->ctx, 200 image->internal_format); 201} 202#endif 203 204/** 205 * Called for each hardware renderbuffer when a _window_ is resized. 206 * Just update fields. 207 * Not used for user-created renderbuffers! 208 */ 209static GLboolean 210intel_alloc_window_storage(struct gl_context * ctx, struct gl_renderbuffer *rb, 211 GLenum internalFormat, GLuint width, GLuint height) 212{ 213 ASSERT(rb->Name == 0); 214 rb->Width = width; 215 rb->Height = height; 216 rb->InternalFormat = internalFormat; 217 218 return GL_TRUE; 219} 220 221 222static void 223intel_resize_buffers(struct gl_context *ctx, struct gl_framebuffer *fb, 224 GLuint width, GLuint height) 225{ 226 int i; 227 228 _mesa_resize_framebuffer(ctx, fb, width, height); 229 230 fb->Initialized = GL_TRUE; /* XXX remove someday */ 231 232 if (fb->Name != 0) { 233 return; 234 } 235 236 237 /* Make sure all window system renderbuffers are up to date */ 238 for (i = BUFFER_FRONT_LEFT; i <= BUFFER_BACK_RIGHT; i++) { 239 struct gl_renderbuffer *rb = fb->Attachment[i].Renderbuffer; 240 241 /* only resize if size is changing */ 242 if (rb && (rb->Width != width || rb->Height != height)) { 243 rb->AllocStorage(ctx, rb, rb->InternalFormat, width, height); 244 } 245 } 246} 247 248 249/** Dummy function for gl_renderbuffer::AllocStorage() */ 250static GLboolean 251intel_nop_alloc_storage(struct gl_context * ctx, struct gl_renderbuffer *rb, 252 GLenum internalFormat, GLuint width, GLuint height) 253{ 254 _mesa_problem(ctx, "intel_op_alloc_storage should never be called."); 255 return GL_FALSE; 256} 257 258 259void 260intel_renderbuffer_set_region(struct intel_context *intel, 261 struct intel_renderbuffer *rb, 262 struct intel_region *region) 263{ 264 struct intel_region *old; 265 266 old = rb->region; 267 rb->region = NULL; 268 intel_region_reference(&rb->region, region); 269 intel_region_release(&old); 270} 271 272 273/** 274 * Create a new intel_renderbuffer which corresponds to an on-screen window, 275 * not a user-created renderbuffer. 276 */ 277struct intel_renderbuffer * 278intel_create_renderbuffer(gl_format format) 279{ 280 GET_CURRENT_CONTEXT(ctx); 281 282 struct intel_renderbuffer *irb; 283 284 irb = CALLOC_STRUCT(intel_renderbuffer); 285 if (!irb) { 286 _mesa_error(ctx, GL_OUT_OF_MEMORY, "creating renderbuffer"); 287 return NULL; 288 } 289 290 _mesa_init_renderbuffer(&irb->Base, 0); 291 irb->Base.ClassID = INTEL_RB_CLASS; 292 irb->Base._BaseFormat = _mesa_get_format_base_format(format); 293 irb->Base.Format = format; 294 irb->Base.InternalFormat = irb->Base._BaseFormat; 295 irb->Base.DataType = intel_mesa_format_to_rb_datatype(format); 296 297 /* intel-specific methods */ 298 irb->Base.Delete = intel_delete_renderbuffer; 299 irb->Base.AllocStorage = intel_alloc_window_storage; 300 irb->Base.GetPointer = intel_get_pointer; 301 302 return irb; 303} 304 305 306/** 307 * Create a new renderbuffer object. 308 * Typically called via glBindRenderbufferEXT(). 309 */ 310static struct gl_renderbuffer * 311intel_new_renderbuffer(struct gl_context * ctx, GLuint name) 312{ 313 /*struct intel_context *intel = intel_context(ctx); */ 314 struct intel_renderbuffer *irb; 315 316 irb = CALLOC_STRUCT(intel_renderbuffer); 317 if (!irb) { 318 _mesa_error(ctx, GL_OUT_OF_MEMORY, "creating renderbuffer"); 319 return NULL; 320 } 321 322 _mesa_init_renderbuffer(&irb->Base, name); 323 irb->Base.ClassID = INTEL_RB_CLASS; 324 325 /* intel-specific methods */ 326 irb->Base.Delete = intel_delete_renderbuffer; 327 irb->Base.AllocStorage = intel_alloc_renderbuffer_storage; 328 irb->Base.GetPointer = intel_get_pointer; 329 /* span routines set in alloc_storage function */ 330 331 return &irb->Base; 332} 333 334 335/** 336 * Called via glBindFramebufferEXT(). 337 */ 338static void 339intel_bind_framebuffer(struct gl_context * ctx, GLenum target, 340 struct gl_framebuffer *fb, struct gl_framebuffer *fbread) 341{ 342 if (target == GL_FRAMEBUFFER_EXT || target == GL_DRAW_FRAMEBUFFER_EXT) { 343 intel_draw_buffer(ctx, fb); 344 } 345 else { 346 /* don't need to do anything if target == GL_READ_FRAMEBUFFER_EXT */ 347 } 348} 349 350 351/** 352 * Called via glFramebufferRenderbufferEXT(). 353 */ 354static void 355intel_framebuffer_renderbuffer(struct gl_context * ctx, 356 struct gl_framebuffer *fb, 357 GLenum attachment, struct gl_renderbuffer *rb) 358{ 359 DBG("Intel FramebufferRenderbuffer %u %u\n", fb->Name, rb ? rb->Name : 0); 360 361 intel_flush(ctx); 362 363 _mesa_framebuffer_renderbuffer(ctx, fb, attachment, rb); 364 intel_draw_buffer(ctx, fb); 365} 366 367 368static GLboolean 369intel_update_wrapper(struct gl_context *ctx, struct intel_renderbuffer *irb, 370 struct gl_texture_image *texImage) 371{ 372 if (!intel_span_supports_format(texImage->TexFormat)) { 373 DBG("Render to texture BAD FORMAT %s\n", 374 _mesa_get_format_name(texImage->TexFormat)); 375 return GL_FALSE; 376 } else { 377 DBG("Render to texture %s\n", _mesa_get_format_name(texImage->TexFormat)); 378 } 379 380 irb->Base.Format = texImage->TexFormat; 381 irb->Base.DataType = intel_mesa_format_to_rb_datatype(texImage->TexFormat); 382 irb->Base.InternalFormat = texImage->InternalFormat; 383 irb->Base._BaseFormat = _mesa_base_fbo_format(ctx, irb->Base.InternalFormat); 384 irb->Base.Width = texImage->Width; 385 irb->Base.Height = texImage->Height; 386 387 irb->Base.Delete = intel_delete_renderbuffer; 388 irb->Base.AllocStorage = intel_nop_alloc_storage; 389 390 return GL_TRUE; 391} 392 393 394/** 395 * When glFramebufferTexture[123]D is called this function sets up the 396 * gl_renderbuffer wrapper around the texture image. 397 * This will have the region info needed for hardware rendering. 398 */ 399static struct intel_renderbuffer * 400intel_wrap_texture(struct gl_context * ctx, struct gl_texture_image *texImage) 401{ 402 const GLuint name = ~0; /* not significant, but distinct for debugging */ 403 struct intel_renderbuffer *irb; 404 405 /* make an intel_renderbuffer to wrap the texture image */ 406 irb = CALLOC_STRUCT(intel_renderbuffer); 407 if (!irb) { 408 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glFramebufferTexture"); 409 return NULL; 410 } 411 412 _mesa_init_renderbuffer(&irb->Base, name); 413 irb->Base.ClassID = INTEL_RB_CLASS; 414 415 if (!intel_update_wrapper(ctx, irb, texImage)) { 416 free(irb); 417 return NULL; 418 } 419 420 return irb; 421} 422 423 424/** 425 * Called by glFramebufferTexture[123]DEXT() (and other places) to 426 * prepare for rendering into texture memory. This might be called 427 * many times to choose different texture levels, cube faces, etc 428 * before intel_finish_render_texture() is ever called. 429 */ 430static void 431intel_render_texture(struct gl_context * ctx, 432 struct gl_framebuffer *fb, 433 struct gl_renderbuffer_attachment *att) 434{ 435 struct gl_texture_image *newImage 436 = att->Texture->Image[att->CubeMapFace][att->TextureLevel]; 437 struct intel_renderbuffer *irb = intel_renderbuffer(att->Renderbuffer); 438 struct intel_texture_image *intel_image; 439 GLuint dst_x, dst_y; 440 441 (void) fb; 442 443 ASSERT(newImage); 444 445 intel_image = intel_texture_image(newImage); 446 if (!intel_image->mt) { 447 /* Fallback on drawing to a texture that doesn't have a miptree 448 * (has a border, width/height 0, etc.) 449 */ 450 _mesa_reference_renderbuffer(&att->Renderbuffer, NULL); 451 _mesa_render_texture(ctx, fb, att); 452 return; 453 } 454 else if (!irb) { 455 irb = intel_wrap_texture(ctx, newImage); 456 if (irb) { 457 /* bind the wrapper to the attachment point */ 458 _mesa_reference_renderbuffer(&att->Renderbuffer, &irb->Base); 459 } 460 else { 461 /* fallback to software rendering */ 462 _mesa_render_texture(ctx, fb, att); 463 return; 464 } 465 } 466 467 if (!intel_update_wrapper(ctx, irb, newImage)) { 468 _mesa_reference_renderbuffer(&att->Renderbuffer, NULL); 469 _mesa_render_texture(ctx, fb, att); 470 return; 471 } 472 473 DBG("Begin render texture tid %lx tex=%u w=%d h=%d refcount=%d\n", 474 _glthread_GetID(), 475 att->Texture->Name, newImage->Width, newImage->Height, 476 irb->Base.RefCount); 477 478 /* point the renderbufer's region to the texture image region */ 479 if (irb->region != intel_image->mt->region) { 480 if (irb->region) 481 intel_region_release(&irb->region); 482 intel_region_reference(&irb->region, intel_image->mt->region); 483 } 484 485 /* compute offset of the particular 2D image within the texture region */ 486 intel_miptree_get_image_offset(intel_image->mt, 487 att->TextureLevel, 488 att->CubeMapFace, 489 att->Zoffset, 490 &dst_x, &dst_y); 491 492 intel_image->mt->region->draw_offset = (dst_y * intel_image->mt->region->pitch + 493 dst_x) * intel_image->mt->cpp; 494 intel_image->mt->region->draw_x = dst_x; 495 intel_image->mt->region->draw_y = dst_y; 496 intel_image->used_as_render_target = GL_TRUE; 497 498 /* update drawing region, etc */ 499 intel_draw_buffer(ctx, fb); 500} 501 502 503/** 504 * Called by Mesa when rendering to a texture is done. 505 */ 506static void 507intel_finish_render_texture(struct gl_context * ctx, 508 struct gl_renderbuffer_attachment *att) 509{ 510 struct intel_context *intel = intel_context(ctx); 511 struct gl_texture_object *tex_obj = att->Texture; 512 struct gl_texture_image *image = 513 tex_obj->Image[att->CubeMapFace][att->TextureLevel]; 514 struct intel_texture_image *intel_image = intel_texture_image(image); 515 516 DBG("Finish render texture tid %lx tex=%u\n", 517 _glthread_GetID(), att->Texture->Name); 518 519 /* Flag that this image may now be validated into the object's miptree. */ 520 if (intel_image) 521 intel_image->used_as_render_target = GL_FALSE; 522 523 /* Since we've (probably) rendered to the texture and will (likely) use 524 * it in the texture domain later on in this batchbuffer, flush the 525 * batch. Once again, we wish for a domain tracker in libdrm to cover 526 * usage inside of a batchbuffer like GEM does in the kernel. 527 */ 528 intel_batchbuffer_emit_mi_flush(intel->batch); 529} 530 531/** 532 * Do additional "completeness" testing of a framebuffer object. 533 */ 534static void 535intel_validate_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb) 536{ 537 struct intel_context *intel = intel_context(ctx); 538 const struct intel_renderbuffer *depthRb = 539 intel_get_renderbuffer(fb, BUFFER_DEPTH); 540 const struct intel_renderbuffer *stencilRb = 541 intel_get_renderbuffer(fb, BUFFER_STENCIL); 542 int i; 543 544 if (depthRb && stencilRb && stencilRb != depthRb) { 545 if (fb->Attachment[BUFFER_DEPTH].Type == GL_TEXTURE && 546 fb->Attachment[BUFFER_STENCIL].Type == GL_TEXTURE && 547 (fb->Attachment[BUFFER_DEPTH].Texture->Name == 548 fb->Attachment[BUFFER_STENCIL].Texture->Name)) { 549 /* OK */ 550 } else { 551 /* we only support combined depth/stencil buffers, not separate 552 * stencil buffers. 553 */ 554 DBG("Only supports combined depth/stencil (found %s, %s)\n", 555 depthRb ? _mesa_get_format_name(depthRb->Base.Format): "NULL", 556 stencilRb ? _mesa_get_format_name(stencilRb->Base.Format): "NULL"); 557 fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT; 558 } 559 } 560 561 for (i = 0; i < Elements(fb->Attachment); i++) { 562 struct gl_renderbuffer *rb; 563 struct intel_renderbuffer *irb; 564 565 if (fb->Attachment[i].Type == GL_NONE) 566 continue; 567 568 /* A supported attachment will have a Renderbuffer set either 569 * from being a Renderbuffer or being a texture that got the 570 * intel_wrap_texture() treatment. 571 */ 572 rb = fb->Attachment[i].Renderbuffer; 573 if (rb == NULL) { 574 DBG("attachment without renderbuffer\n"); 575 fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT; 576 continue; 577 } 578 579 irb = intel_renderbuffer(rb); 580 if (irb == NULL) { 581 DBG("software rendering renderbuffer\n"); 582 fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT; 583 continue; 584 } 585 586 if (!intel_span_supports_format(irb->Base.Format) || 587 !intel->vtbl.render_target_supported(irb->Base.Format)) { 588 DBG("Unsupported texture/renderbuffer format attached: %s\n", 589 _mesa_get_format_name(irb->Base.Format)); 590 fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT; 591 } 592 } 593} 594 595 596/** 597 * Do one-time context initializations related to GL_EXT_framebuffer_object. 598 * Hook in device driver functions. 599 */ 600void 601intel_fbo_init(struct intel_context *intel) 602{ 603 intel->ctx.Driver.NewFramebuffer = intel_new_framebuffer; 604 intel->ctx.Driver.NewRenderbuffer = intel_new_renderbuffer; 605 intel->ctx.Driver.BindFramebuffer = intel_bind_framebuffer; 606 intel->ctx.Driver.FramebufferRenderbuffer = intel_framebuffer_renderbuffer; 607 intel->ctx.Driver.RenderTexture = intel_render_texture; 608 intel->ctx.Driver.FinishRenderTexture = intel_finish_render_texture; 609 intel->ctx.Driver.ResizeBuffers = intel_resize_buffers; 610 intel->ctx.Driver.ValidateFramebuffer = intel_validate_framebuffer; 611 intel->ctx.Driver.BlitFramebuffer = _mesa_meta_BlitFramebuffer; 612 613#if FEATURE_OES_EGL_image 614 intel->ctx.Driver.EGLImageTargetRenderbufferStorage = 615 intel_image_target_renderbuffer_storage; 616#endif 617} 618