projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[915] Make polygon stipple use pre-unpacked pixel data.
[mesa.git] / src / mesa / drivers / dri / intel / intel_buffers.c
1 /**************************************************************************
2 *
3 * Copyright 2003 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 #include "intel_screen.h"
29 #include "intel_context.h"
30 #include "intel_blit.h"
31 #include "intel_buffers.h"
32 #include "intel_depthstencil.h"
33 #include "intel_fbo.h"
34 #include "intel_tris.h"
35 #include "intel_regions.h"
36 #include "intel_batchbuffer.h"
37 #include "intel_reg.h"
38 #include "context.h"
39 #include "utils.h"
40 #include "drirenderbuffer.h"
41 #include "framebuffer.h"
42 #include "swrast/swrast.h"
43 #include "vblank.h"
44
45
46 /* This block can be removed when libdrm >= 2.3.1 is required */
47
48 #ifndef DRM_IOCTL_I915_FLIP
49
50 #define DRM_VBLANK_FLIP 0x8000000
51
52 typedef struct drm_i915_flip {
53 int pipes;
54 } drm_i915_flip_t;
55
56 #undef DRM_IOCTL_I915_FLIP
57 #define DRM_IOCTL_I915_FLIP DRM_IOW(DRM_COMMAND_BASE + DRM_I915_FLIP, \
58 drm_i915_flip_t)
59
60 #endif
61
62 #define FILE_DEBUG_FLAG DEBUG_BLIT
63
64 /**
65 * XXX move this into a new dri/common/cliprects.c file.
66 */
67 GLboolean
68 intel_intersect_cliprects(drm_clip_rect_t * dst,
69 const drm_clip_rect_t * a,
70 const drm_clip_rect_t * b)
71 {
72 GLint bx = b->x1;
73 GLint by = b->y1;
74 GLint bw = b->x2 - bx;
75 GLint bh = b->y2 - by;
76
77 if (bx < a->x1)
78 bw -= a->x1 - bx, bx = a->x1;
79 if (by < a->y1)
80 bh -= a->y1 - by, by = a->y1;
81 if (bx + bw > a->x2)
82 bw = a->x2 - bx;
83 if (by + bh > a->y2)
84 bh = a->y2 - by;
85 if (bw <= 0)
86 return GL_FALSE;
87 if (bh <= 0)
88 return GL_FALSE;
89
90 dst->x1 = bx;
91 dst->y1 = by;
92 dst->x2 = bx + bw;
93 dst->y2 = by + bh;
94
95 return GL_TRUE;
96 }
97
98 /**
99 * Return pointer to current color drawing region, or NULL.
100 */
101 struct intel_region *
102 intel_drawbuf_region(struct intel_context *intel)
103 {
104 struct intel_renderbuffer *irbColor =
105 intel_renderbuffer(intel->ctx.DrawBuffer->_ColorDrawBuffers[0][0]);
106 if (irbColor)
107 return irbColor->region;
108 else
109 return NULL;
110 }
111
112 /**
113 * Return pointer to current color reading region, or NULL.
114 */
115 struct intel_region *
116 intel_readbuf_region(struct intel_context *intel)
117 {
118 struct intel_renderbuffer *irb
119 = intel_renderbuffer(intel->ctx.ReadBuffer->_ColorReadBuffer);
120 if (irb)
121 return irb->region;
122 else
123 return NULL;
124 }
125
126
127
128 /**
129 * Update the following fields for rendering to a user-created FBO:
130 * intel->numClipRects
131 * intel->pClipRects
132 * intel->drawX
133 * intel->drawY
134 */
135 static void
136 intelSetRenderbufferClipRects(struct intel_context *intel)
137 {
138 assert(intel->ctx.DrawBuffer->Width > 0);
139 assert(intel->ctx.DrawBuffer->Height > 0);
140 intel->fboRect.x1 = 0;
141 intel->fboRect.y1 = 0;
142 intel->fboRect.x2 = intel->ctx.DrawBuffer->Width;
143 intel->fboRect.y2 = intel->ctx.DrawBuffer->Height;
144 intel->numClipRects = 1;
145 intel->pClipRects = &intel->fboRect;
146 intel->drawX = 0;
147 intel->drawY = 0;
148 }
149
150
151 /**
152 * As above, but for rendering to front buffer of a window.
153 * \sa intelSetRenderbufferClipRects
154 */
155 static void
156 intelSetFrontClipRects(struct intel_context *intel)
157 {
158 __DRIdrawablePrivate *dPriv = intel->driDrawable;
159
160 if (!dPriv)
161 return;
162
163 intel->numClipRects = dPriv->numClipRects;
164 intel->pClipRects = dPriv->pClipRects;
165 intel->drawX = dPriv->x;
166 intel->drawY = dPriv->y;
167 }
168
169
170 /**
171 * As above, but for rendering to back buffer of a window.
172 */
173 static void
174 intelSetBackClipRects(struct intel_context *intel)
175 {
176 __DRIdrawablePrivate *dPriv = intel->driDrawable;
177 struct intel_framebuffer *intel_fb;
178
179 if (!dPriv)
180 return;
181
182 intel_fb = dPriv->driverPrivate;
183
184 if (intel_fb->pf_active || dPriv->numBackClipRects == 0) {
185 /* use the front clip rects */
186 intel->numClipRects = dPriv->numClipRects;
187 intel->pClipRects = dPriv->pClipRects;
188 intel->drawX = dPriv->x;
189 intel->drawY = dPriv->y;
190 }
191 else {
192 /* use the back clip rects */
193 intel->numClipRects = dPriv->numBackClipRects;
194 intel->pClipRects = dPriv->pBackClipRects;
195 intel->drawX = dPriv->backX;
196 intel->drawY = dPriv->backY;
197 }
198 }
199
200
201 /**
202 * This will be called whenever the currently bound window is moved/resized.
203 * XXX: actually, it seems to NOT be called when the window is only moved (BP).
204 */
205 void
206 intelWindowMoved(struct intel_context *intel)
207 {
208 GLcontext *ctx = &intel->ctx;
209 __DRIdrawablePrivate *dPriv = intel->driDrawable;
210 struct intel_framebuffer *intel_fb = dPriv->driverPrivate;
211
212 if (!intel->ctx.DrawBuffer) {
213 /* when would this happen? -BP */
214 intelSetFrontClipRects(intel);
215 }
216 else if (intel->ctx.DrawBuffer->Name != 0) {
217 /* drawing to user-created FBO - do nothing */
218 /* Cliprects would be set from intelDrawBuffer() */
219 }
220 else {
221 /* drawing to a window */
222 switch (intel_fb->Base._ColorDrawBufferMask[0]) {
223 case BUFFER_BIT_FRONT_LEFT:
224 intelSetFrontClipRects(intel);
225 break;
226 case BUFFER_BIT_BACK_LEFT:
227 intelSetBackClipRects(intel);
228 break;
229 default:
230 /* glDrawBuffer(GL_NONE or GL_FRONT_AND_BACK): software fallback */
231 intelSetFrontClipRects(intel);
232 }
233 }
234
235 if (intel->intelScreen->driScrnPriv->ddx_version.minor >= 7) {
236 drmI830Sarea *sarea = intel->sarea;
237 drm_clip_rect_t drw_rect = { .x1 = dPriv->x, .x2 = dPriv->x + dPriv->w,
238 .y1 = dPriv->y, .y2 = dPriv->y + dPriv->h };
239 drm_clip_rect_t planeA_rect = { .x1 = sarea->planeA_x, .y1 = sarea->planeA_y,
240 .x2 = sarea->planeA_x + sarea->planeA_w,
241 .y2 = sarea->planeA_y + sarea->planeA_h };
242 drm_clip_rect_t planeB_rect = { .x1 = sarea->planeB_x, .y1 = sarea->planeB_y,
243 .x2 = sarea->planeB_x + sarea->planeB_w,
244 .y2 = sarea->planeB_y + sarea->planeB_h };
245 GLint areaA = driIntersectArea( drw_rect, planeA_rect );
246 GLint areaB = driIntersectArea( drw_rect, planeB_rect );
247 GLuint flags = dPriv->vblFlags;
248 GLboolean pf_active;
249 GLint pf_planes;
250
251 /* Update page flipping info
252 */
253 pf_planes = 0;
254
255 if (areaA > 0)
256 pf_planes |= 1;
257
258 if (areaB > 0)
259 pf_planes |= 2;
260
261 intel_fb->pf_current_page = (intel->sarea->pf_current_page >>
262 (intel_fb->pf_planes & 0x2)) & 0x3;
263
264 intel_fb->pf_num_pages = intel->intelScreen->third.handle ? 3 : 2;
265
266 pf_active = pf_planes && (pf_planes & intel->sarea->pf_active) == pf_planes;
267
268 if (INTEL_DEBUG & DEBUG_LOCK)
269 if (pf_active != intel_fb->pf_active)
270 _mesa_printf("%s - Page flipping %sactive\n", __progname,
271 pf_active ? "" : "in");
272
273 if (pf_active) {
274 /* Sync pages between planes if flipping on both at the same time */
275 if (pf_planes == 0x3 && pf_planes != intel_fb->pf_planes &&
276 (intel->sarea->pf_current_page & 0x3) !=
277 (((intel->sarea->pf_current_page) >> 2) & 0x3)) {
278 drm_i915_flip_t flip;
279
280 if (intel_fb->pf_current_page ==
281 (intel->sarea->pf_current_page & 0x3)) {
282 /* XXX: This is ugly, but emitting two flips 'in a row' can cause
283 * lockups for unknown reasons.
284 */
285 intel->sarea->pf_current_page =
286 intel->sarea->pf_current_page & 0x3;
287 intel->sarea->pf_current_page |=
288 ((intel_fb->pf_current_page + intel_fb->pf_num_pages - 1) %
289 intel_fb->pf_num_pages) << 2;
290
291 flip.pipes = 0x2;
292 } else {
293 intel->sarea->pf_current_page =
294 intel->sarea->pf_current_page & (0x3 << 2);
295 intel->sarea->pf_current_page |=
296 (intel_fb->pf_current_page + intel_fb->pf_num_pages - 1) %
297 intel_fb->pf_num_pages;
298
299 flip.pipes = 0x1;
300 }
301
302 drmCommandWrite(intel->driFd, DRM_I915_FLIP, &flip, sizeof(flip));
303 }
304
305 intel_fb->pf_planes = pf_planes;
306 }
307
308 intel_fb->pf_active = pf_active;
309 intel_flip_renderbuffers(intel_fb);
310 intel_draw_buffer(&intel->ctx, intel->ctx.DrawBuffer);
311
312 /* Update vblank info
313 */
314 if (areaB > areaA || (areaA == areaB && areaB > 0)) {
315 flags = dPriv->vblFlags | VBLANK_FLAG_SECONDARY;
316 } else {
317 flags = dPriv->vblFlags & ~VBLANK_FLAG_SECONDARY;
318 }
319
320 /* Check to see if we changed pipes */
321 if (flags != dPriv->vblFlags && dPriv->vblFlags &&
322 !(dPriv->vblFlags & VBLANK_FLAG_NO_IRQ)) {
323 int64_t count;
324 drmVBlank vbl;
325 int i;
326
327 /*
328 * Deal with page flipping
329 */
330 vbl.request.type = DRM_VBLANK_ABSOLUTE;
331
332 if ( dPriv->vblFlags & VBLANK_FLAG_SECONDARY ) {
333 vbl.request.type |= DRM_VBLANK_SECONDARY;
334 }
335
336 for (i = 0; i < intel_fb->pf_num_pages; i++) {
337 if (!intel_fb->color_rb[i] ||
338 (intel_fb->vbl_waited - intel_fb->color_rb[i]->vbl_pending) <=
339 (1<<23))
340 continue;
341
342 vbl.request.sequence = intel_fb->color_rb[i]->vbl_pending;
343 drmWaitVBlank(intel->driFd, &vbl);
344 }
345
346 /*
347 * Update msc_base from old pipe
348 */
349 driDrawableGetMSC32(dPriv->driScreenPriv, dPriv, &count);
350 dPriv->msc_base = count;
351 /*
352 * Then get new vblank_base and vblSeq values
353 */
354 dPriv->vblFlags = flags;
355 driGetCurrentVBlank(dPriv);
356 dPriv->vblank_base = dPriv->vblSeq;
357
358 intel_fb->vbl_waited = dPriv->vblSeq;
359
360 for (i = 0; i < intel_fb->pf_num_pages; i++) {
361 if (intel_fb->color_rb[i])
362 intel_fb->color_rb[i]->vbl_pending = intel_fb->vbl_waited;
363 }
364 }
365 } else {
366 dPriv->vblFlags &= ~VBLANK_FLAG_SECONDARY;
367 }
368
369 /* Update Mesa's notion of window size */
370 driUpdateFramebufferSize(ctx, dPriv);
371 intel_fb->Base.Initialized = GL_TRUE; /* XXX remove someday */
372
373 /* Update hardware scissor */
374 ctx->Driver.Scissor(ctx, ctx->Scissor.X, ctx->Scissor.Y,
375 ctx->Scissor.Width, ctx->Scissor.Height);
376
377 /* Re-calculate viewport related state */
378 ctx->Driver.DepthRange( ctx, ctx->Viewport.Near, ctx->Viewport.Far );
379 }
380
381
382
383 /* A true meta version of this would be very simple and additionally
384 * machine independent. Maybe we'll get there one day.
385 */
386 static void
387 intelClearWithTris(struct intel_context *intel, GLbitfield mask)
388 {
389 GLcontext *ctx = &intel->ctx;
390 struct gl_framebuffer *fb = ctx->DrawBuffer;
391 GLuint buf;
392
393 intel->vtbl.install_meta_state(intel);
394
395 /* Back and stencil cliprects are the same. Try and do both
396 * buffers at once:
397 */
398 if (mask & (BUFFER_BIT_BACK_LEFT | BUFFER_BIT_STENCIL | BUFFER_BIT_DEPTH)) {
399 struct intel_region *backRegion =
400 intel_get_rb_region(fb, BUFFER_BACK_LEFT);
401 struct intel_region *depthRegion =
402 intel_get_rb_region(fb, BUFFER_DEPTH);
403
404 intel->vtbl.meta_draw_region(intel, backRegion, depthRegion);
405
406 if (mask & BUFFER_BIT_BACK_LEFT)
407 intel->vtbl.meta_color_mask(intel, GL_TRUE);
408 else
409 intel->vtbl.meta_color_mask(intel, GL_FALSE);
410
411 if (mask & BUFFER_BIT_STENCIL)
412 intel->vtbl.meta_stencil_replace(intel,
413 intel->ctx.Stencil.WriteMask[0],
414 intel->ctx.Stencil.Clear);
415 else
416 intel->vtbl.meta_no_stencil_write(intel);
417
418 if (mask & BUFFER_BIT_DEPTH)
419 intel->vtbl.meta_depth_replace(intel);
420 else
421 intel->vtbl.meta_no_depth_write(intel);
422
423 intel_meta_draw_quad(intel,
424 fb->_Xmin,
425 fb->_Xmax,
426 fb->_Ymin,
427 fb->_Ymax,
428 intel->ctx.Depth.Clear, intel->ClearColor8888,
429 0, 0, 0, 0); /* texcoords */
430
431 mask &= ~(BUFFER_BIT_BACK_LEFT | BUFFER_BIT_STENCIL | BUFFER_BIT_DEPTH);
432 }
433
434 /* clear the remaining (color) renderbuffers */
435 for (buf = 0; buf < BUFFER_COUNT && mask; buf++) {
436 const GLuint bufBit = 1 << buf;
437 if (mask & bufBit) {
438 struct intel_renderbuffer *irbColor =
439 intel_renderbuffer(fb->Attachment[buf].Renderbuffer);
440
441 ASSERT(irbColor);
442
443 intel->vtbl.meta_no_depth_write(intel);
444 intel->vtbl.meta_no_stencil_write(intel);
445 intel->vtbl.meta_color_mask(intel, GL_TRUE);
446 intel->vtbl.meta_draw_region(intel, irbColor->region, NULL);
447
448 /* XXX: Using INTEL_BATCH_NO_CLIPRECTS here is dangerous as the
449 * drawing origin may not be correctly emitted.
450 */
451 intel_meta_draw_quad(intel,
452 fb->_Xmin,
453 fb->_Xmax,
454 fb->_Ymin,
455 fb->_Ymax,
456 0, intel->ClearColor8888,
457 0, 0, 0, 0); /* texcoords */
458
459 mask &= ~bufBit;
460 }
461 }
462
463 intel->vtbl.leave_meta_state(intel);
464 intel_batchbuffer_flush(intel->batch);
465 }
466
467 static const char *buffer_names[] = {
468 [BUFFER_FRONT_LEFT] = "front",
469 [BUFFER_BACK_LEFT] = "back",
470 [BUFFER_FRONT_RIGHT] = "front right",
471 [BUFFER_BACK_RIGHT] = "back right",
472 [BUFFER_AUX0] = "aux0",
473 [BUFFER_AUX1] = "aux1",
474 [BUFFER_AUX2] = "aux2",
475 [BUFFER_AUX3] = "aux3",
476 [BUFFER_DEPTH] = "depth",
477 [BUFFER_STENCIL] = "stencil",
478 [BUFFER_ACCUM] = "accum",
479 [BUFFER_COLOR0] = "color0",
480 [BUFFER_COLOR1] = "color1",
481 [BUFFER_COLOR2] = "color2",
482 [BUFFER_COLOR3] = "color3",
483 [BUFFER_COLOR4] = "color4",
484 [BUFFER_COLOR5] = "color5",
485 [BUFFER_COLOR6] = "color6",
486 [BUFFER_COLOR7] = "color7",
487 };
488
489 /**
490 * Called by ctx->Driver.Clear.
491 */
492 static void
493 intelClear(GLcontext *ctx, GLbitfield mask)
494 {
495 struct intel_context *intel = intel_context(ctx);
496 const GLuint colorMask = *((GLuint *) & ctx->Color.ColorMask);
497 GLbitfield tri_mask = 0;
498 GLbitfield blit_mask = 0;
499 GLbitfield swrast_mask = 0;
500 struct gl_framebuffer *fb = ctx->DrawBuffer;
501 GLuint i;
502
503 if (0)
504 fprintf(stderr, "%s\n", __FUNCTION__);
505
506 /* HW color buffers (front, back, aux, generic FBO, etc) */
507 if (colorMask == ~0) {
508 /* clear all R,G,B,A */
509 /* XXX FBO: need to check if colorbuffers are software RBOs! */
510 blit_mask |= (mask & BUFFER_BITS_COLOR);
511 }
512 else {
513 /* glColorMask in effect */
514 tri_mask |= (mask & BUFFER_BITS_COLOR);
515 }
516
517 /* HW stencil */
518 if (mask & BUFFER_BIT_STENCIL) {
519 const struct intel_region *stencilRegion
520 = intel_get_rb_region(fb, BUFFER_STENCIL);
521 if (stencilRegion) {
522 /* have hw stencil */
523 if ((ctx->Stencil.WriteMask[0] & 0xff) != 0xff) {
524 /* not clearing all stencil bits, so use triangle clearing */
525 tri_mask |= BUFFER_BIT_STENCIL;
526 }
527 else {
528 /* clearing all stencil bits, use blitting */
529 blit_mask |= BUFFER_BIT_STENCIL;
530 }
531 }
532 }
533
534 /* HW depth */
535 if (mask & BUFFER_BIT_DEPTH) {
536 /* clear depth with whatever method is used for stencil (see above) */
537 if (tri_mask & BUFFER_BIT_STENCIL)
538 tri_mask |= BUFFER_BIT_DEPTH;
539 else
540 blit_mask |= BUFFER_BIT_DEPTH;
541 }
542
543 /* SW fallback clearing */
544 swrast_mask = mask & ~tri_mask & ~blit_mask;
545
546 for (i = 0; i < BUFFER_COUNT; i++) {
547 GLuint bufBit = 1 << i;
548 if ((blit_mask | tri_mask) & bufBit) {
549 if (!fb->Attachment[i].Renderbuffer->ClassID) {
550 blit_mask &= ~bufBit;
551 tri_mask &= ~bufBit;
552 swrast_mask |= bufBit;
553 }
554 }
555 }
556
557 intelFlush(ctx); /* XXX intelClearWithBlit also does this */
558
559 if (blit_mask) {
560 if (INTEL_DEBUG & DEBUG_BLIT) {
561 DBG("blit clear:");
562 for (i = 0; i < BUFFER_COUNT; i++) {
563 if (blit_mask & (1 << i))
564 DBG(" %s", buffer_names[i]);
565 }
566 DBG("\n");
567 }
568 intelClearWithBlit(ctx, blit_mask);
569 }
570
571 if (tri_mask) {
572 if (INTEL_DEBUG & DEBUG_BLIT) {
573 DBG("tri clear:");
574 for (i = 0; i < BUFFER_COUNT; i++) {
575 if (tri_mask & (1 << i))
576 DBG(" %s", buffer_names[i]);
577 }
578 DBG("\n");
579 }
580 intelClearWithTris(intel, tri_mask);
581 }
582
583 if (swrast_mask) {
584 if (INTEL_DEBUG & DEBUG_BLIT) {
585 DBG("swrast clear:");
586 for (i = 0; i < BUFFER_COUNT; i++) {
587 if (swrast_mask & (1 << i))
588 DBG(" %s", buffer_names[i]);
589 }
590 DBG("\n");
591 }
592 _swrast_Clear(ctx, swrast_mask);
593 }
594 }
595
596
597 /* Emit wait for pending flips */
598 void
599 intel_wait_flips(struct intel_context *intel, GLuint batch_flags)
600 {
601 struct intel_framebuffer *intel_fb =
602 (struct intel_framebuffer *) intel->ctx.DrawBuffer;
603 struct intel_renderbuffer *intel_rb =
604 intel_get_renderbuffer(&intel_fb->Base,
605 intel_fb->Base._ColorDrawBufferMask[0] ==
606 BUFFER_BIT_FRONT_LEFT ? BUFFER_FRONT_LEFT :
607 BUFFER_BACK_LEFT);
608
609 if (intel_fb->Base.Name == 0 && intel_rb &&
610 intel_rb->pf_pending == intel_fb->pf_seq) {
611 GLint pf_planes = intel_fb->pf_planes;
612 BATCH_LOCALS;
613
614 /* Wait for pending flips to take effect */
615 BEGIN_BATCH(2, batch_flags);
616 OUT_BATCH(pf_planes & 0x1 ? (MI_WAIT_FOR_EVENT | MI_WAIT_FOR_PLANE_A_FLIP)
617 : 0);
618 OUT_BATCH(pf_planes & 0x2 ? (MI_WAIT_FOR_EVENT | MI_WAIT_FOR_PLANE_B_FLIP)
619 : 0);
620 ADVANCE_BATCH();
621
622 intel_rb->pf_pending--;
623 }
624 }
625
626
627 /* Flip the front & back buffers
628 */
629 static GLboolean
630 intelPageFlip(const __DRIdrawablePrivate * dPriv)
631 {
632 struct intel_context *intel;
633 int ret;
634 struct intel_framebuffer *intel_fb = dPriv->driverPrivate;
635
636 if (INTEL_DEBUG & DEBUG_IOCTL)
637 fprintf(stderr, "%s\n", __FUNCTION__);
638
639 assert(dPriv);
640 assert(dPriv->driContextPriv);
641 assert(dPriv->driContextPriv->driverPrivate);
642
643 intel = (struct intel_context *) dPriv->driContextPriv->driverPrivate;
644
645 if (intel->intelScreen->drmMinor < 9)
646 return GL_FALSE;
647
648 intelFlush(&intel->ctx);
649
650 ret = 0;
651
652 LOCK_HARDWARE(intel);
653
654 if (dPriv->numClipRects && intel_fb->pf_active) {
655 drm_i915_flip_t flip;
656
657 flip.pipes = intel_fb->pf_planes;
658
659 ret = drmCommandWrite(intel->driFd, DRM_I915_FLIP, &flip, sizeof(flip));
660 }
661
662 UNLOCK_HARDWARE(intel);
663
664 if (ret || !intel_fb->pf_active)
665 return GL_FALSE;
666
667 if (!dPriv->numClipRects) {
668 usleep(10000); /* throttle invisible client 10ms */
669 }
670
671 intel_fb->pf_current_page = (intel->sarea->pf_current_page >>
672 (intel_fb->pf_planes & 0x2)) & 0x3;
673
674 if (dPriv->numClipRects != 0) {
675 intel_get_renderbuffer(&intel_fb->Base, BUFFER_FRONT_LEFT)->pf_pending =
676 intel_get_renderbuffer(&intel_fb->Base, BUFFER_BACK_LEFT)->pf_pending =
677 ++intel_fb->pf_seq;
678 }
679
680 intel_flip_renderbuffers(intel_fb);
681 intel_draw_buffer(&intel->ctx, &intel_fb->Base);
682
683 return GL_TRUE;
684 }
685
686 #if 0
687 void
688 intelSwapBuffers(__DRIdrawablePrivate * dPriv)
689 {
690 if (dPriv->driverPrivate) {
691 const struct gl_framebuffer *fb
692 = (struct gl_framebuffer *) dPriv->driverPrivate;
693 if (fb->Visual.doubleBufferMode) {
694 GET_CURRENT_CONTEXT(ctx);
695 if (ctx && ctx->DrawBuffer == fb) {
696 _mesa_notifySwapBuffers(ctx); /* flush pending rendering */
697 }
698 if (intel->doPageFlip) {
699 intelPageFlip(dPriv);
700 }
701 else {
702 intelCopyBuffer(dPriv);
703 }
704 }
705 }
706 else {
707 _mesa_problem(NULL,
708 "dPriv has no gl_framebuffer pointer in intelSwapBuffers");
709 }
710 }
711 #else
712 /* Trunk version:
713 */
714
715 static GLboolean
716 intelScheduleSwap(__DRIdrawablePrivate * dPriv, GLboolean *missed_target)
717 {
718 struct intel_framebuffer *intel_fb = dPriv->driverPrivate;
719 unsigned int interval;
720 struct intel_context *intel =
721 intelScreenContext(dPriv->driScreenPriv->private);
722 const intelScreenPrivate *intelScreen = intel->intelScreen;
723 unsigned int target;
724 drm_i915_vblank_swap_t swap;
725 GLboolean ret;
726
727 if (!dPriv->vblFlags ||
728 (dPriv->vblFlags & VBLANK_FLAG_NO_IRQ) ||
729 intelScreen->drmMinor < (intel_fb->pf_active ? 9 : 6))
730 return GL_FALSE;
731
732 interval = driGetVBlankInterval(dPriv);
733
734 swap.seqtype = DRM_VBLANK_ABSOLUTE;
735
736 if (dPriv->vblFlags & VBLANK_FLAG_SYNC) {
737 swap.seqtype |= DRM_VBLANK_NEXTONMISS;
738 } else if (interval == 0) {
739 return GL_FALSE;
740 }
741
742 swap.drawable = dPriv->hHWDrawable;
743 target = swap.sequence = dPriv->vblSeq + interval;
744
745 if ( dPriv->vblFlags & VBLANK_FLAG_SECONDARY ) {
746 swap.seqtype |= DRM_VBLANK_SECONDARY;
747 }
748
749 LOCK_HARDWARE(intel);
750
751 intel_batchbuffer_flush(intel->batch);
752
753 if ( intel_fb->pf_active ) {
754 swap.seqtype |= DRM_VBLANK_FLIP;
755
756 intel_fb->pf_current_page = (((intel->sarea->pf_current_page >>
757 (intel_fb->pf_planes & 0x2)) & 0x3) + 1) %
758 intel_fb->pf_num_pages;
759 }
760
761 if (!drmCommandWriteRead(intel->driFd, DRM_I915_VBLANK_SWAP, &swap,
762 sizeof(swap))) {
763 dPriv->vblSeq = swap.sequence;
764 swap.sequence -= target;
765 *missed_target = swap.sequence > 0 && swap.sequence <= (1 << 23);
766
767 intel_get_renderbuffer(&intel_fb->Base, BUFFER_BACK_LEFT)->vbl_pending =
768 intel_get_renderbuffer(&intel_fb->Base,
769 BUFFER_FRONT_LEFT)->vbl_pending =
770 dPriv->vblSeq;
771
772 if (swap.seqtype & DRM_VBLANK_FLIP) {
773 intel_flip_renderbuffers(intel_fb);
774 intel_draw_buffer(&intel->ctx, intel->ctx.DrawBuffer);
775 }
776
777 ret = GL_TRUE;
778 } else {
779 if (swap.seqtype & DRM_VBLANK_FLIP) {
780 intel_fb->pf_current_page = ((intel->sarea->pf_current_page >>
781 (intel_fb->pf_planes & 0x2)) & 0x3) %
782 intel_fb->pf_num_pages;
783 }
784
785 ret = GL_FALSE;
786 }
787
788 UNLOCK_HARDWARE(intel);
789
790 return ret;
791 }
792
793 void
794 intelSwapBuffers(__DRIdrawablePrivate * dPriv)
795 {
796 if (dPriv->driContextPriv && dPriv->driContextPriv->driverPrivate) {
797 GET_CURRENT_CONTEXT(ctx);
798 struct intel_context *intel;
799
800 if (ctx == NULL)
801 return;
802
803 intel = intel_context(ctx);
804
805 if (ctx->Visual.doubleBufferMode) {
806 GLboolean missed_target;
807 struct intel_framebuffer *intel_fb = dPriv->driverPrivate;
808 int64_t ust;
809
810 _mesa_notifySwapBuffers(ctx); /* flush pending rendering comands */
811
812 if (!intelScheduleSwap(dPriv, &missed_target)) {
813 driWaitForVBlank(dPriv, &missed_target);
814
815 if (!intelPageFlip(dPriv)) {
816 intelCopyBuffer(dPriv, NULL);
817 }
818 }
819
820 intel_fb->swap_count++;
821 (*dri_interface->getUST) (&ust);
822 if (missed_target) {
823 intel_fb->swap_missed_count++;
824 intel_fb->swap_missed_ust = ust - intel_fb->swap_ust;
825 }
826
827 intel_fb->swap_ust = ust;
828 }
829 }
830 else {
831 /* XXX this shouldn't be an error but we can't handle it for now */
832 fprintf(stderr, "%s: drawable has no context!\n", __FUNCTION__);
833 }
834 }
835 #endif
836
837 void
838 intelCopySubBuffer(__DRIdrawablePrivate * dPriv, int x, int y, int w, int h)
839 {
840 if (dPriv->driContextPriv && dPriv->driContextPriv->driverPrivate) {
841 struct intel_context *intel =
842 (struct intel_context *) dPriv->driContextPriv->driverPrivate;
843 GLcontext *ctx = &intel->ctx;
844
845 if (ctx->Visual.doubleBufferMode) {
846 drm_clip_rect_t rect;
847 rect.x1 = x + dPriv->x;
848 rect.y1 = (dPriv->h - y - h) + dPriv->y;
849 rect.x2 = rect.x1 + w;
850 rect.y2 = rect.y1 + h;
851 _mesa_notifySwapBuffers(ctx); /* flush pending rendering comands */
852 intelCopyBuffer(dPriv, &rect);
853 }
854 }
855 else {
856 /* XXX this shouldn't be an error but we can't handle it for now */
857 fprintf(stderr, "%s: drawable has no context!\n", __FUNCTION__);
858 }
859 }
860
861
862 /**
863 * Update the hardware state for drawing into a window or framebuffer object.
864 *
865 * Called by glDrawBuffer, glBindFramebufferEXT, MakeCurrent, and other
866 * places within the driver.
867 *
868 * Basically, this needs to be called any time the current framebuffer
869 * changes, the renderbuffers change, or we need to draw into different
870 * color buffers.
871 */
872 void
873 intel_draw_buffer(GLcontext * ctx, struct gl_framebuffer *fb)
874 {
875 struct intel_context *intel = intel_context(ctx);
876 struct intel_region *colorRegion, *depthRegion = NULL;
877 struct intel_renderbuffer *irbDepth = NULL, *irbStencil = NULL;
878 int front = 0; /* drawing to front color buffer? */
879
880 if (!fb) {
881 /* this can happen during the initial context initialization */
882 return;
883 }
884
885 /* Do this here, note core Mesa, since this function is called from
886 * many places within the driver.
887 */
888 if (ctx->NewState & (_NEW_BUFFERS | _NEW_COLOR | _NEW_PIXEL)) {
889 /* this updates the DrawBuffer->_NumColorDrawBuffers fields, etc */
890 _mesa_update_framebuffer(ctx);
891 /* this updates the DrawBuffer's Width/Height if it's a FBO */
892 _mesa_update_draw_buffer_bounds(ctx);
893 }
894
895 if (fb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
896 /* this may occur when we're called by glBindFrameBuffer() during
897 * the process of someone setting up renderbuffers, etc.
898 */
899 /*_mesa_debug(ctx, "DrawBuffer: incomplete user FBO\n");*/
900 return;
901 }
902
903 if (fb->Name)
904 intel_validate_paired_depth_stencil(ctx, fb);
905
906 /*
907 * How many color buffers are we drawing into?
908 */
909 if (fb->_NumColorDrawBuffers[0] != 1) {
910 /* writing to 0 or 2 or 4 color buffers */
911 /*_mesa_debug(ctx, "Software rendering\n");*/
912 FALLBACK(intel, INTEL_FALLBACK_DRAW_BUFFER, GL_TRUE);
913 colorRegion = NULL;
914 }
915 else {
916 /* draw to exactly one color buffer */
917 /*_mesa_debug(ctx, "Hardware rendering\n");*/
918 FALLBACK(intel, INTEL_FALLBACK_DRAW_BUFFER, GL_FALSE);
919 if (fb->_ColorDrawBufferMask[0] == BUFFER_BIT_FRONT_LEFT) {
920 front = 1;
921 }
922
923 /*
924 * Get the intel_renderbuffer for the colorbuffer we're drawing into.
925 * And set up cliprects.
926 */
927 if (fb->Name == 0) {
928 /* drawing to window system buffer */
929 if (front) {
930 intelSetFrontClipRects(intel);
931 colorRegion = intel_get_rb_region(fb, BUFFER_FRONT_LEFT);
932 }
933 else {
934 intelSetBackClipRects(intel);
935 colorRegion = intel_get_rb_region(fb, BUFFER_BACK_LEFT);
936 }
937 }
938 else {
939 /* drawing to user-created FBO */
940 struct intel_renderbuffer *irb;
941 intelSetRenderbufferClipRects(intel);
942 irb = intel_renderbuffer(fb->_ColorDrawBuffers[0][0]);
943 colorRegion = (irb && irb->region) ? irb->region : NULL;
944 }
945 }
946
947 /* Update culling direction which changes depending on the
948 * orientation of the buffer:
949 */
950 if (ctx->Driver.FrontFace)
951 ctx->Driver.FrontFace(ctx, ctx->Polygon.FrontFace);
952 else
953 ctx->NewState |= _NEW_POLYGON;
954
955 if (!colorRegion) {
956 FALLBACK(intel, INTEL_FALLBACK_DRAW_BUFFER, GL_TRUE);
957 }
958 else {
959 FALLBACK(intel, INTEL_FALLBACK_DRAW_BUFFER, GL_FALSE);
960 }
961
962 /***
963 *** Get depth buffer region and check if we need a software fallback.
964 *** Note that the depth buffer is usually a DEPTH_STENCIL buffer.
965 ***/
966 if (fb->_DepthBuffer && fb->_DepthBuffer->Wrapped) {
967 irbDepth = intel_renderbuffer(fb->_DepthBuffer->Wrapped);
968 if (irbDepth && irbDepth->region) {
969 FALLBACK(intel, INTEL_FALLBACK_DEPTH_BUFFER, GL_FALSE);
970 depthRegion = irbDepth->region;
971 }
972 else {
973 FALLBACK(intel, INTEL_FALLBACK_DEPTH_BUFFER, GL_TRUE);
974 depthRegion = NULL;
975 }
976 }
977 else {
978 /* not using depth buffer */
979 FALLBACK(intel, INTEL_FALLBACK_DEPTH_BUFFER, GL_FALSE);
980 depthRegion = NULL;
981 }
982
983 /***
984 *** Stencil buffer
985 *** This can only be hardware accelerated if we're using a
986 *** combined DEPTH_STENCIL buffer (for now anyway).
987 ***/
988 if (fb->_StencilBuffer && fb->_StencilBuffer->Wrapped) {
989 irbStencil = intel_renderbuffer(fb->_StencilBuffer->Wrapped);
990 if (irbStencil && irbStencil->region) {
991 ASSERT(irbStencil->Base._ActualFormat == GL_DEPTH24_STENCIL8_EXT);
992 FALLBACK(intel, INTEL_FALLBACK_STENCIL_BUFFER, GL_FALSE);
993 /* need to re-compute stencil hw state */
994 ctx->Driver.Enable(ctx, GL_STENCIL_TEST, ctx->Stencil.Enabled);
995 if (!depthRegion)
996 depthRegion = irbStencil->region;
997 }
998 else {
999 FALLBACK(intel, INTEL_FALLBACK_STENCIL_BUFFER, GL_TRUE);
1000 }
1001 }
1002 else {
1003 /* XXX FBO: instead of FALSE, pass ctx->Stencil.Enabled ??? */
1004 FALLBACK(intel, INTEL_FALLBACK_STENCIL_BUFFER, GL_FALSE);
1005 /* need to re-compute stencil hw state */
1006 ctx->Driver.Enable(ctx, GL_STENCIL_TEST, ctx->Stencil.Enabled);
1007 }
1008
1009 /*
1010 * Update depth test state
1011 */
1012 if (ctx->Depth.Test && fb->Visual.depthBits > 0) {
1013 ctx->Driver.Enable(ctx, GL_DEPTH_TEST, GL_TRUE);
1014 }
1015 else {
1016 ctx->Driver.Enable(ctx, GL_DEPTH_TEST, GL_FALSE);
1017 }
1018
1019 intel->vtbl.set_draw_region(intel, colorRegion, depthRegion);
1020
1021 /* update viewport since it depends on window size */
1022 ctx->Driver.Viewport(ctx, ctx->Viewport.X, ctx->Viewport.Y,
1023 ctx->Viewport.Width, ctx->Viewport.Height);
1024
1025 /* Update hardware scissor */
1026 ctx->Driver.Scissor(ctx, ctx->Scissor.X, ctx->Scissor.Y,
1027 ctx->Scissor.Width, ctx->Scissor.Height);
1028 }
1029
1030
1031 static void
1032 intelDrawBuffer(GLcontext * ctx, GLenum mode)
1033 {
1034 intel_draw_buffer(ctx, ctx->DrawBuffer);
1035 }
1036
1037
1038 static void
1039 intelReadBuffer(GLcontext * ctx, GLenum mode)
1040 {
1041 if (ctx->ReadBuffer == ctx->DrawBuffer) {
1042 /* This will update FBO completeness status.
1043 * A framebuffer will be incomplete if the GL_READ_BUFFER setting
1044 * refers to a missing renderbuffer. Calling glReadBuffer can set
1045 * that straight and can make the drawing buffer complete.
1046 */
1047 intel_draw_buffer(ctx, ctx->DrawBuffer);
1048 }
1049 /* Generally, functions which read pixels (glReadPixels, glCopyPixels, etc)
1050 * reference ctx->ReadBuffer and do appropriate state checks.
1051 */
1052 }
1053
1054
1055 void
1056 intelInitBufferFuncs(struct dd_function_table *functions)
1057 {
1058 functions->Clear = intelClear;
1059 functions->DrawBuffer = intelDrawBuffer;
1060 functions->ReadBuffer = intelReadBuffer;
1061 }