git.libre-soc.org Git - mesa.git/blob - src/mesa/drivers/dri/intel/intel

1 /**************************************************************************

2 *

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 **************************************************************************/

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"

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"

46 #define FILE_DEBUG_FLAG DEBUG_FBO

49 /**

50 * Create a new framebuffer object.

51 */

52 static struct gl_framebuffer *

 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 */

    return _mesa_new_framebuffer(ctx, name);

59 }

62 /** Called by gl_renderbuffer::Delete() */

63 static void

 intel_delete_renderbuffer(struct gl_renderbuffer *rb)

65 {

66 GET_CURRENT_CONTEXT(ctx);

    struct intel_context *intel = intel_context(ctx);

    struct intel_renderbuffer *irb = intel_renderbuffer(rb);

70 ASSERT(irb);

    if (irb->span_cache != NULL)

73 _mesa_free(irb->span_cache);

    if (intel && irb->region) {

76 intel_region_release(&irb->region);

77 }

79 _mesa_free(irb);

80 }

83 /**

84 * Return a pointer to a specific pixel in a renderbuffer.

85 */

86 static void *

 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 }

97 /**

98 * Called via glRenderbufferStorageEXT() to set the format and allocate

99 * storage for a user-created renderbuffer.

100 */

101 static GLboolean

 intel_alloc_renderbuffer_storage(GLcontext * ctx, struct gl_renderbuffer *rb,

103 GLenum internalFormat,

104 GLuint width, GLuint height)

105 {

    struct intel_context *intel = intel_context(ctx);

    struct intel_renderbuffer *irb = intel_renderbuffer(rb);

108 GLboolean softwareBuffer = GL_FALSE;

109 int cpp;

110

    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 irb->texformat = &_mesa_texformat_rgb565;

123 cpp = 2;

124 break;

125 case GL_RGB:

126 case GL_RGB8:

127 case GL_RGB10:

128 case GL_RGB12:

129 case GL_RGB16:

130 rb->_ActualFormat = GL_RGB8;

131 rb->DataType = GL_UNSIGNED_BYTE;

132 rb->RedBits = 8;

133 rb->GreenBits = 8;

134 rb->BlueBits = 8;

135 rb->AlphaBits = 0;

136 irb->texformat = &_mesa_texformat_argb8888; /* XXX: Need xrgb8888 */

137 cpp = 4;

138 break;

139 case GL_RGBA:

140 case GL_RGBA2:

141 case GL_RGBA4:

142 case GL_RGB5_A1:

143 case GL_RGBA8:

144 case GL_RGB10_A2:

145 case GL_RGBA12:

146 case GL_RGBA16:

147 rb->_ActualFormat = GL_RGBA8;

148 rb->DataType = GL_UNSIGNED_BYTE;

149 rb->RedBits = 8;

150 rb->GreenBits = 8;

151 rb->BlueBits = 8;

152 rb->AlphaBits = 8;

153 irb->texformat = &_mesa_texformat_argb8888;

154 cpp = 4;

155 break;

156 case GL_STENCIL_INDEX:

157 case GL_STENCIL_INDEX1_EXT:

158 case GL_STENCIL_INDEX4_EXT:

159 case GL_STENCIL_INDEX8_EXT:

160 case GL_STENCIL_INDEX16_EXT:

161 /* alloc a depth+stencil buffer */

162 rb->_ActualFormat = GL_DEPTH24_STENCIL8_EXT;

163 rb->DataType = GL_UNSIGNED_INT_24_8_EXT;

164 rb->StencilBits = 8;

165 cpp = 4;

166 irb->texformat = &_mesa_texformat_s8_z24;

167 break;

168 case GL_DEPTH_COMPONENT16:

169 rb->_ActualFormat = GL_DEPTH_COMPONENT16;

170 rb->DataType = GL_UNSIGNED_SHORT;

171 rb->DepthBits = 16;

172 cpp = 2;

173 irb->texformat = &_mesa_texformat_z16;

174 break;

175 case GL_DEPTH_COMPONENT:

176 case GL_DEPTH_COMPONENT24:

177 case GL_DEPTH_COMPONENT32:

178 rb->_ActualFormat = GL_DEPTH24_STENCIL8_EXT;

179 rb->DataType = GL_UNSIGNED_INT_24_8_EXT;

180 rb->DepthBits = 24;

181 cpp = 4;

182 irb->texformat = &_mesa_texformat_s8_z24;

183 break;

184 case GL_DEPTH_STENCIL_EXT:

185 case GL_DEPTH24_STENCIL8_EXT:

186 rb->_ActualFormat = GL_DEPTH24_STENCIL8_EXT;

187 rb->DataType = GL_UNSIGNED_INT_24_8_EXT;

188 rb->DepthBits = 24;

189 rb->StencilBits = 8;

190 cpp = 4;

191 irb->texformat = &_mesa_texformat_s8_z24;

192 break;

193 default:

194 _mesa_problem(ctx,

195 "Unexpected format in intel_alloc_renderbuffer_storage");

196 return GL_FALSE;

197 }

198

199 intelFlush(ctx);

200

201 /* free old region */

202 if (irb->region) {

203 intel_region_release(&irb->region);

204 }

205

206 /* allocate new memory region/renderbuffer */

207 if (softwareBuffer) {

       return _mesa_soft_renderbuffer_storage(ctx, rb, internalFormat,

209 width, height);

210 }

211 else {

212 /* Choose a pitch to match hardware requirements:

213 */

       GLuint pitch = ((cpp * width + 63) & ~63) / cpp;

215

216 /* alloc hardware renderbuffer */

       DBG("Allocating %d x %d Intel RBO (pitch %d)\n", width,

218 height, pitch);

219

       irb->region = intel_region_alloc(intel, I915_TILING_NONE,

221 cpp, width, height, pitch,

222 GL_TRUE);

223 if (!irb->region)

224 return GL_FALSE; /* out of memory? */

225

       ASSERT(irb->region->buffer);

227

228 rb->Width = width;

229 rb->Height = height;

230

231 return GL_TRUE;

232 }

233 }

234

235

236 /**

237 * Called for each hardware renderbuffer when a _window_ is resized.

238 * Just update fields.

239 * Not used for user-created renderbuffers!

240 */

241 static GLboolean

 intel_alloc_window_storage(GLcontext * ctx, struct gl_renderbuffer *rb,

243 GLenum internalFormat, GLuint width, GLuint height)

244 {

    ASSERT(rb->Name == 0);

246 rb->Width = width;

247 rb->Height = height;

248 rb->_ActualFormat = internalFormat;

249

250 return GL_TRUE;

251 }

252

253

254 static void

 intel_resize_buffers(GLcontext *ctx, struct gl_framebuffer *fb,

256 GLuint width, GLuint height)

257 {

    struct intel_framebuffer *intel_fb = (struct intel_framebuffer*)fb;

259 int i;

260

    _mesa_resize_framebuffer(ctx, fb, width, height);

262

263 fb->Initialized = GL_TRUE; /* XXX remove someday */

264

    if (fb->Name != 0) {

266 return;

267 }

268

269 /* Make sure all window system renderbuffers are up to date */

    for (i = 0; i < 2; i++) {

       struct gl_renderbuffer *rb = &intel_fb->color_rb[i]->Base;

272

273 /* only resize if size is changing */

       if (rb && (rb->Width != width || rb->Height != height)) {

          rb->AllocStorage(ctx, rb, rb->InternalFormat, width, height);

276 }

277 }

278 }

279

280

281 /** Dummy function for gl_renderbuffer::AllocStorage() */

282 static GLboolean

 intel_nop_alloc_storage(GLcontext * ctx, struct gl_renderbuffer *rb,

284 GLenum internalFormat, GLuint width, GLuint height)

285 {

    _mesa_problem(ctx, "intel_op_alloc_storage should never be called.");

287 return GL_FALSE;

288 }

289

290

291 void

 intel_renderbuffer_set_region(struct intel_renderbuffer *rb,

293 struct intel_region *region)

294 {

295 struct intel_region *old;

296

297 old = rb->region;

298 rb->region = NULL;

    intel_region_reference(&rb->region, region);

300 intel_region_release(&old);

301 }

302

303

304 /**

305 * Create a new intel_renderbuffer which corresponds to an on-screen window,

306 * not a user-created renderbuffer.

307 */

308 struct intel_renderbuffer *

309 intel_create_renderbuffer(GLenum intFormat)

310 {

311 GET_CURRENT_CONTEXT(ctx);

312

313 struct intel_renderbuffer *irb;

314 const GLuint name = 0;

315

316 irb = CALLOC_STRUCT(intel_renderbuffer);

317 if (!irb) {

       _mesa_error(ctx, GL_OUT_OF_MEMORY, "creating renderbuffer");

319 return NULL;

320 }

321

    _mesa_init_renderbuffer(&irb->Base, name);

323 irb->Base.ClassID = INTEL_RB_CLASS;

324

325 switch (intFormat) {

326 case GL_RGB5:

327 irb->Base._ActualFormat = GL_RGB5;

328 irb->Base._BaseFormat = GL_RGBA;

       irb->Base.RedBits = 5;

       irb->Base.GreenBits = 6;

       irb->Base.BlueBits = 5;

332 irb->Base.DataType = GL_UNSIGNED_BYTE;

333 irb->texformat = &_mesa_texformat_rgb565;

334 break;

335 case GL_RGB8:

336 irb->Base._ActualFormat = GL_RGB8;

337 irb->Base._BaseFormat = GL_RGB;

       irb->Base.RedBits = 8;

       irb->Base.GreenBits = 8;

       irb->Base.BlueBits = 8;

       irb->Base.AlphaBits = 0;

342 irb->Base.DataType = GL_UNSIGNED_BYTE;

343 irb->texformat = &_mesa_texformat_argb8888; /* XXX: Need xrgb8888 */

344 break;

345 case GL_RGBA8:

346 irb->Base._ActualFormat = GL_RGBA8;

347 irb->Base._BaseFormat = GL_RGBA;

       irb->Base.RedBits = 8;

       irb->Base.GreenBits = 8;

       irb->Base.BlueBits = 8;

       irb->Base.AlphaBits = 8;

352 irb->Base.DataType = GL_UNSIGNED_BYTE;

353 irb->texformat = &_mesa_texformat_argb8888;

354 break;

355 case GL_STENCIL_INDEX8_EXT:

356 irb->Base._ActualFormat = GL_STENCIL_INDEX8_EXT;

357 irb->Base._BaseFormat = GL_STENCIL_INDEX;

       irb->Base.StencilBits = 8;

359 irb->Base.DataType = GL_UNSIGNED_BYTE;

360 irb->texformat = &_mesa_texformat_s8_z24;

361 break;

362 case GL_DEPTH_COMPONENT16:

363 irb->Base._ActualFormat = GL_DEPTH_COMPONENT16;

364 irb->Base._BaseFormat = GL_DEPTH_COMPONENT;

       irb->Base.DepthBits = 16;

366 irb->Base.DataType = GL_UNSIGNED_SHORT;

367 irb->texformat = &_mesa_texformat_z16;

368 break;

369 case GL_DEPTH_COMPONENT24:

370 irb->Base._ActualFormat = GL_DEPTH24_STENCIL8_EXT;

371 irb->Base._BaseFormat = GL_DEPTH_COMPONENT;

       irb->Base.DepthBits = 24;

373 irb->Base.DataType = GL_UNSIGNED_INT;

374 irb->texformat = &_mesa_texformat_s8_z24;

375 break;

376 case GL_DEPTH24_STENCIL8_EXT:

377 irb->Base._ActualFormat = GL_DEPTH24_STENCIL8_EXT;

378 irb->Base._BaseFormat = GL_DEPTH_STENCIL_EXT;

       irb->Base.DepthBits = 24;

       irb->Base.StencilBits = 8;

381 irb->Base.DataType = GL_UNSIGNED_INT_24_8_EXT;

382 irb->texformat = &_mesa_texformat_s8_z24;

383 break;

384 default:

385 _mesa_problem(NULL,

386 "Unexpected intFormat in intel_create_renderbuffer");

387 return NULL;

388 }

389

390 irb->Base.InternalFormat = intFormat;

391

392 /* intel-specific methods */

393 irb->Base.Delete = intel_delete_renderbuffer;

394 irb->Base.AllocStorage = intel_alloc_window_storage;

395 irb->Base.GetPointer = intel_get_pointer;

396

397 return irb;

398 }

399

400

401 /**

402 * Create a new renderbuffer object.

403 * Typically called via glBindRenderbufferEXT().

404 */

405 static struct gl_renderbuffer *

 intel_new_renderbuffer(GLcontext * ctx, GLuint name)

407 {

408 /*struct intel_context *intel = intel_context(ctx); */

409 struct intel_renderbuffer *irb;

410

411 irb = CALLOC_STRUCT(intel_renderbuffer);

412 if (!irb) {

       _mesa_error(ctx, GL_OUT_OF_MEMORY, "creating renderbuffer");

414 return NULL;

415 }

416

    _mesa_init_renderbuffer(&irb->Base, name);

418 irb->Base.ClassID = INTEL_RB_CLASS;

419

420 /* intel-specific methods */

421 irb->Base.Delete = intel_delete_renderbuffer;

422 irb->Base.AllocStorage = intel_alloc_renderbuffer_storage;

423 irb->Base.GetPointer = intel_get_pointer;

424 /* span routines set in alloc_storage function */

425

426 return &irb->Base;

427 }

428

429

430 /**

431 * Called via glBindFramebufferEXT().

432 */

433 static void

 intel_bind_framebuffer(GLcontext * ctx, GLenum target,

                        struct gl_framebuffer *fb, struct gl_framebuffer *fbread)

436 {

    if (target == GL_FRAMEBUFFER_EXT || target == GL_DRAW_FRAMEBUFFER_EXT) {

438 intel_draw_buffer(ctx, fb);

439 }

440 else {

441 /* don't need to do anything if target == GL_READ_FRAMEBUFFER_EXT */

442 }

443 }

444

445

446 /**

447 * Called via glFramebufferRenderbufferEXT().

448 */

449 static void

450 intel_framebuffer_renderbuffer(GLcontext * ctx,

451 struct gl_framebuffer *fb,

452 GLenum attachment, struct gl_renderbuffer *rb)

453 {

    DBG("Intel FramebufferRenderbuffer %u %u\n", fb->Name, rb ? rb->Name : 0);

455

456 intelFlush(ctx);

457

    _mesa_framebuffer_renderbuffer(ctx, fb, attachment, rb);

459 intel_draw_buffer(ctx, fb);

460 }

461

462

463 static GLboolean

 intel_update_wrapper(GLcontext *ctx, struct intel_renderbuffer *irb, 

465 struct gl_texture_image *texImage)

466 {

467 irb->texformat = texImage->TexFormat;

468

    if (texImage->TexFormat == &_mesa_texformat_argb8888) {

470 irb->Base._ActualFormat = GL_RGBA8;

471 irb->Base._BaseFormat = GL_RGBA;

472 irb->Base.DataType = GL_UNSIGNED_BYTE;

       DBG("Render to RGBA8 texture OK\n");

474 }

    else if (texImage->TexFormat == &_mesa_texformat_rgb565) {

476 irb->Base._ActualFormat = GL_RGB5;

477 irb->Base._BaseFormat = GL_RGB;

478 irb->Base.DataType = GL_UNSIGNED_BYTE;

       DBG("Render to RGB5 texture OK\n");

480 }

    else if (texImage->TexFormat == &_mesa_texformat_argb1555) {

482 irb->Base._ActualFormat = GL_RGB5_A1;

483 irb->Base._BaseFormat = GL_RGBA;

484 irb->Base.DataType = GL_UNSIGNED_BYTE;

       DBG("Render to ARGB1555 texture OK\n");

486 }

    else if (texImage->TexFormat == &_mesa_texformat_argb4444) {

488 irb->Base._ActualFormat = GL_RGBA4;

489 irb->Base._BaseFormat = GL_RGBA;

490 irb->Base.DataType = GL_UNSIGNED_BYTE;

       DBG("Render to ARGB4444 texture OK\n");

492 }

    else if (texImage->TexFormat == &_mesa_texformat_z16) {

494 irb->Base._ActualFormat = GL_DEPTH_COMPONENT16;

495 irb->Base._BaseFormat = GL_DEPTH_COMPONENT;

496 irb->Base.DataType = GL_UNSIGNED_SHORT;

       DBG("Render to DEPTH16 texture OK\n");

498 }

    else if (texImage->TexFormat == &_mesa_texformat_s8_z24) {

500 irb->Base._ActualFormat = GL_DEPTH24_STENCIL8_EXT;

501 irb->Base._BaseFormat = GL_DEPTH_STENCIL_EXT;

502 irb->Base.DataType = GL_UNSIGNED_INT_24_8_EXT;

       DBG("Render to DEPTH_STENCIL texture OK\n");

504 }

505 else {

       DBG("Render to texture BAD FORMAT %d\n",

507 texImage->TexFormat->MesaFormat);

508 return GL_FALSE;

509 }

510

    irb->Base.InternalFormat = irb->Base._ActualFormat;

    irb->Base.Width = texImage->Width;

    irb->Base.Height = texImage->Height;

    irb->Base.RedBits = texImage->TexFormat->RedBits;

    irb->Base.GreenBits = texImage->TexFormat->GreenBits;

    irb->Base.BlueBits = texImage->TexFormat->BlueBits;

    irb->Base.AlphaBits = texImage->TexFormat->AlphaBits;

    irb->Base.DepthBits = texImage->TexFormat->DepthBits;

519

520 irb->Base.Delete = intel_delete_renderbuffer;

521 irb->Base.AllocStorage = intel_nop_alloc_storage;

522

523 return GL_TRUE;

524 }

525

526

527 /**

528 * When glFramebufferTexture[123]D is called this function sets up the

529 * gl_renderbuffer wrapper around the texture image.

530 * This will have the region info needed for hardware rendering.

531 */

532 static struct intel_renderbuffer *

 intel_wrap_texture(GLcontext * ctx, struct gl_texture_image *texImage)

534 {

    const GLuint name = ~0;   /* not significant, but distinct for debugging */

536 struct intel_renderbuffer *irb;

537

538 /* make an intel_renderbuffer to wrap the texture image */

539 irb = CALLOC_STRUCT(intel_renderbuffer);

540 if (!irb) {

       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glFramebufferTexture");

542 return NULL;

543 }

544

    _mesa_init_renderbuffer(&irb->Base, name);

546 irb->Base.ClassID = INTEL_RB_CLASS;

547

    if (!intel_update_wrapper(ctx, irb, texImage)) {

549 _mesa_free(irb);

550 return NULL;

551 }

552

553 return irb;

554 }

555

556

557 /**

558 * Called by glFramebufferTexture[123]DEXT() (and other places) to

559 * prepare for rendering into texture memory. This might be called

560 * many times to choose different texture levels, cube faces, etc

561 * before intel_finish_render_texture() is ever called.

562 */

563 static void

564 intel_render_texture(GLcontext * ctx,

565 struct gl_framebuffer *fb,

566 struct gl_renderbuffer_attachment *att)

567 {

568 struct gl_texture_image *newImage

       = att->Texture->Image[att->CubeMapFace][att->TextureLevel];

    struct intel_renderbuffer *irb = intel_renderbuffer(att->Renderbuffer);

571 struct intel_texture_image *intel_image;

572 GLuint imageOffset;

573

574 (void) fb;

575

576 ASSERT(newImage);

577

578 intel_image = intel_texture_image(newImage);

579 if (!intel_image->mt) {

580 /* Fallback on drawing to a texture that doesn't have a miptree

581 * (has a border, width/height 0, etc.)

582 */

       _mesa_reference_renderbuffer(&att->Renderbuffer, NULL);

       _mesa_render_texture(ctx, fb, att);

585 return;

586 }

587 else if (!irb) {

       irb = intel_wrap_texture(ctx, newImage);

589 if (irb) {

590 /* bind the wrapper to the attachment point */

          _mesa_reference_renderbuffer(&att->Renderbuffer, &irb->Base);

592 }

593 else {

594 /* fallback to software rendering */

          _mesa_render_texture(ctx, fb, att);

596 return;

597 }

598 }

599

    if (!intel_update_wrapper(ctx, irb, newImage)) {

        _mesa_reference_renderbuffer(&att->Renderbuffer, NULL);

        _mesa_render_texture(ctx, fb, att);

603 return;

604 }

605

    DBG("Begin render texture tid %x tex=%u w=%d h=%d refcount=%d\n",

607 _glthread_GetID(),

        att->Texture->Name, newImage->Width, newImage->Height,

609 irb->Base.RefCount);

610

611 /* point the renderbufer's region to the texture image region */

    if (irb->region != intel_image->mt->region) {

613 if (irb->region)

614 intel_region_release(&irb->region);

       intel_region_reference(&irb->region, intel_image->mt->region);

616 }

617

618 /* compute offset of the particular 2D image within the texture region */

    imageOffset = intel_miptree_image_offset(intel_image->mt,

620 att->CubeMapFace,

621 att->TextureLevel);

622

    if (att->Texture->Target == GL_TEXTURE_3D) {

       const GLuint *offsets = intel_miptree_depth_offsets(intel_image->mt,

625 att->TextureLevel);

626 imageOffset += offsets[att->Zoffset];

627 }

628

629 /* store that offset in the region */

    intel_image->mt->region->draw_offset = imageOffset;

631

632 /* update drawing region, etc */

633 intel_draw_buffer(ctx, fb);

634 }

635

636

637 /**

638 * Called by Mesa when rendering to a texture is done.

639 */

640 static void

641 intel_finish_render_texture(GLcontext * ctx,

642 struct gl_renderbuffer_attachment *att)

643 {

644 /* no-op

645 * Previously we released the renderbuffer's intel_region but

646 * that's not necessary and actually caused problems when trying

647 * to do a glRead/CopyPixels from the renderbuffer later.

648 * The region will be released later if the texture is replaced

649 * or the renderbuffer deleted.

650 *

651 * The intention of this driver hook is more of a "done rendering

652 * to texture, please re-twiddle/etc if necessary".

653 */

654 }

655

656

657 /**

658 * Do additional "completeness" testing of a framebuffer object.

659 */

660 static void

 intel_validate_framebuffer(GLcontext *ctx, struct gl_framebuffer *fb)

662 {

663 const struct intel_renderbuffer *depthRb =

664 intel_get_renderbuffer(fb, BUFFER_DEPTH);

665 const struct intel_renderbuffer *stencilRb =

666 intel_get_renderbuffer(fb, BUFFER_STENCIL);

667 int i;

668

    if (stencilRb && stencilRb != depthRb) {

670 /* we only support combined depth/stencil buffers, not separate

671 * stencil buffers.

672 */

673 fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;

674 }

675

    for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {

       struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[i];

       struct intel_renderbuffer *irb = intel_renderbuffer(rb);

679

680 if (rb == NULL)

681 continue;

682

683 if (irb == NULL) {

684 fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;

685 continue;

686 }

687

       switch (irb->texformat->MesaFormat) {

689 case MESA_FORMAT_ARGB8888:

690 case MESA_FORMAT_RGB565:

691 case MESA_FORMAT_ARGB1555:

692 case MESA_FORMAT_ARGB4444:

693 break;

694 default:

695 fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;

696 }

697 }

698 }

699

700

701 /**

702 * Called from glBlitFramebuffer().

703 * For now, we're doing an approximation with glCopyPixels().

704 * XXX we need to bypass all the per-fragment operations, except scissor.

705 */

706 static void

707 intel_blit_framebuffer(GLcontext *ctx,

708 GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,

709 GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,

710 GLbitfield mask, GLenum filter)

711 {

    const GLfloat xZoomSave = ctx->Pixel.ZoomX;

    const GLfloat yZoomSave = ctx->Pixel.ZoomY;

714 GLsizei width, height;

    GLfloat xFlip = 1.0F, yFlip = 1.0F;

716

717 if (srcX1 < srcX0) {

718 GLint tmp = srcX1;

719 srcX1 = srcX0;

720 srcX0 = tmp;

721 xFlip = -1.0F;

722 }

723

724 if (srcY1 < srcY0) {

725 GLint tmp = srcY1;

726 srcY1 = srcY0;

727 srcY0 = tmp;

728 yFlip = -1.0F;

729 }

730

731 width = srcX1 - srcX0;

732 height = srcY1 - srcY0;

733

    ctx->Pixel.ZoomX = xFlip * (dstX1 - dstX0) / (srcX1 - srcY0);

    ctx->Pixel.ZoomY = yFlip * (dstY1 - dstY0) / (srcY1 - srcY0);

736

    if (ctx->Pixel.ZoomX < 0.0F) {

       dstX0 = MAX2(dstX0, dstX1);

739 }

740 else {

       dstX0 = MIN2(dstX0, dstX1);

742 }

743

    if (ctx->Pixel.ZoomY < 0.0F) {

       dstY0 = MAX2(dstY0, dstY1);

746 }

747 else {

       dstY0 = MIN2(dstY0, dstY1);

749 }

750

751 if (mask & GL_COLOR_BUFFER_BIT) {

       ctx->Driver.CopyPixels(ctx, srcX0, srcY0, width, height,

753 dstX0, dstY0, GL_COLOR);

754 }

755 if (mask & GL_DEPTH_BUFFER_BIT) {

       ctx->Driver.CopyPixels(ctx, srcX0, srcY0, width, height,

757 dstX0, dstY0, GL_DEPTH);

758 }

759 if (mask & GL_STENCIL_BUFFER_BIT) {

       ctx->Driver.CopyPixels(ctx, srcX0, srcY0, width, height,

761 dstX0, dstY0, GL_STENCIL);

762 }

763

764 ctx->Pixel.ZoomX = xZoomSave;

765 ctx->Pixel.ZoomY = yZoomSave;

766 }

767

768

769 /**

770 * Do one-time context initializations related to GL_EXT_framebuffer_object.

771 * Hook in device driver functions.

772 */

773 void

 intel_fbo_init(struct intel_context *intel)

775 {

    intel->ctx.Driver.NewFramebuffer = intel_new_framebuffer;

    intel->ctx.Driver.NewRenderbuffer = intel_new_renderbuffer;

    intel->ctx.Driver.BindFramebuffer = intel_bind_framebuffer;

    intel->ctx.Driver.FramebufferRenderbuffer = intel_framebuffer_renderbuffer;

    intel->ctx.Driver.RenderTexture = intel_render_texture;

    intel->ctx.Driver.FinishRenderTexture = intel_finish_render_texture;

    intel->ctx.Driver.ResizeBuffers = intel_resize_buffers;

    intel->ctx.Driver.ValidateFramebuffer = intel_validate_framebuffer;

    intel->ctx.Driver.BlitFramebuffer = intel_blit_framebuffer;

785 }