Attachment 82999 Details for Bug 67305 – Clip in blit rather than reject

[patch] Clip in blit rather than reject

0001-sna-dri-Discard-the-strict-checking-for-stale-bo-bef.patch (text/plain), 19.80 KB, created by Chris Wilson on 2013-07-25 14:41:06 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Chris Wilson

Created: 2013-07-25 14:41:06 UTC

Size: 19.80 KB

patch

obsolete

>From ce07ba5190b2f1bddf6e3112d74a942535cb17bd Mon Sep 17 00:00:00 2001
>From: Chris Wilson <chris@chris-wilson.co.uk>
>Date: Thu, 25 Jul 2013 08:29:55 +0100
>Subject: [PATCH] sna/dri: Discard the strict checking for stale bo before
> performing a blit
>
>Instead of checking that the DRI2Buffers match up with the current
>DRI2Drawable, clip the area that is being copied to the minimum extents
>of the Drawable, source and destination buffers. This ensures that we
>never read nor write beyond the extents of the allocated or visible
>regions.
>
>Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
>---
> src/sna/sna_dri.c | 459 +++++++++++++-----------------------------------------
> 1 file changed, 106 insertions(+), 353 deletions(-)
>
>diff --git a/src/sna/sna_dri.c b/src/sna/sna_dri.c
>index f4481b6..65066e9 100644
>--- a/src/sna/sna_dri.c
>+++ b/src/sna/sna_dri.c
>@@ -60,8 +60,6 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
> 
> #define COLOR_PREFER_TILING_Y 0
> 
>-#define STRICT_BLIT 1
>-
> enum frame_event_type {
> 	DRI2_SWAP,
> 	DRI2_SWAP_WAIT,
>@@ -654,37 +652,73 @@ sna_dri_copy_fallback(struct sna *sna, int bpp,
> }
> 
> static struct kgem_bo *
>-sna_dri_copy_to_front(struct sna *sna, DrawablePtr draw, RegionPtr region,
>-		      struct kgem_bo *dst_bo, struct kgem_bo *src_bo,
>+__sna_dri_copy_region(struct sna *sna, DrawablePtr draw, RegionPtr region,
>+		      DRI2Buffer2Ptr src, DRI2Buffer2Ptr dst,
> 		      bool sync)
> {
> 	PixmapPtr pixmap = get_drawable_pixmap(draw);
>+	struct sna_dri_private *src_priv = get_private(src);
>+	struct sna_dri_private *dst_priv = get_private(dst);
> 	pixman_region16_t clip;
> 	struct kgem_bo *bo = NULL;
>-	bool flush = false;
>-	xf86CrtcPtr crtc;
>+	struct kgem_bo *src_bo;
>+	struct kgem_bo *dst_bo;
> 	BoxRec *boxes;
> 	int16_t dx, dy;
>-	int n;
>+	int w, h, n;
>+
>+	/* To hide a stale DRI2Buffer, one may choose to substitute
>+	 * pixmap->gpu_bo instead of dst/src->bo, however you then run
>+	 * the risk of copying around invalid data. So either you may not
>+	 * see the results of the copy, or you may see the wrong pixels.
>+	 * Either way you eventually lose.
>+	 */
>+
>+	assert(dst->attachment == DRI2BufferFrontLeft ||
>+	       src->attachment == DRI2BufferFrontLeft);
>+
>+	src_bo = src_priv->bo;
>+	if (src->attachment == DRI2BufferFrontLeft && 0)
>+		src_bo = sna_pixmap_get_bo(pixmap);
>+
>+	dst_bo = dst_priv->bo;
>+	if (dst->attachment == DRI2BufferFrontLeft)
>+		dst_bo = sna_pixmap_get_bo(pixmap);
>+
>+	/* Copy the minimum of the Drawable / src / dst extents */
>+	w = draw->width;
>+	if ((src_priv->size & 0xffff) < w)
>+		w = src_priv->size & 0xffff;
>+	if ((dst_priv->size & 0xffff) < w)
>+		w = dst_priv->size & 0xffff;
>+
>+	h = draw->height;
>+	if ((src_priv->size >> 16) < h)
>+		h = src_priv->size >> 16;
>+	if ((dst_priv->size >> 16) < h)
>+		h = dst_priv->size >> 16;
> 
> 	clip.extents.x1 = draw->x;
> 	clip.extents.y1 = draw->y;
>-	clip.extents.x2 = draw->x + draw->width;
>-	clip.extents.y2 = draw->y + draw->height;
>+	clip.extents.x2 = draw->x + w;
>+	clip.extents.y2 = draw->y + h;
> 	clip.data = NULL;
> 
> 	if (region) {
> 		pixman_region_translate(region, draw->x, draw->y);
> 		pixman_region_intersect(&clip, &clip, region);
> 		region = &clip;
>+	}
> 
>-		if (!pixman_region_not_empty(region)) {
>-			DBG(("%s: all clipped\n", __FUNCTION__));
>-			return NULL;
>-		}
>+	if (clip.extents.x1 >= clip.extents.x2 ||
>+	    clip.extents.y1 >= clip.extents.y2) {
>+		DBG(("%s: all clipped\n", __FUNCTION__));
>+		return NULL;
> 	}
> 
> 	if (!wedged(sna)) {
>+		if (dst->attachment != DRI2BufferFrontLeft)
>+			sync = false;
> 		if (sync)
> 			sync = sna_pixmap_is_scanout(sna, pixmap);
> 
>@@ -693,7 +727,7 @@ sna_dri_copy_to_front(struct sna *sna, DrawablePtr draw, RegionPtr region,
> 		sync = false;
> 
> 	dx = dy = 0;
>-	if (draw->type != DRAWABLE_PIXMAP) {
>+	if (draw->type == DRAWABLE_WINDOW) {
> 		WindowPtr win = (WindowPtr)draw;
> 
> 		if (is_clipped(&win->clipList, draw)) {
>@@ -703,10 +737,8 @@ sna_dri_copy_to_front(struct sna *sna, DrawablePtr draw, RegionPtr region,
> 			     win->clipList.extents.x1, win->clipList.extents.y1,
> 			     win->clipList.extents.x2, win->clipList.extents.y2));
> 
>-			if (region == NULL)
>-				region = &clip;
>-
>-			pixman_region_intersect(&clip, &win->clipList, region);
>+			assert(region == NULL || region == &clip);
>+			pixman_region_intersect(&clip, &win->clipList, &clip);
> 			if (!pixman_region_not_empty(&clip)) {
> 				DBG(("%s: all clipped\n", __FUNCTION__));
> 				return NULL;
>@@ -716,13 +748,16 @@ sna_dri_copy_to_front(struct sna *sna, DrawablePtr draw, RegionPtr region,
> 		}
> 
> 		if (sync) {
>+			xf86CrtcPtr crtc;
>+
> 			crtc = sna_covering_crtc(sna->scrn, &clip.extents, NULL);
>-			if (crtc)
>-				flush = sna_wait_for_scanline(sna, pixmap, crtc,
>-							      &clip.extents);
>+			sync = crtc &&
>+				sna_wait_for_scanline(sna, pixmap, crtc,
>+						      &clip.extents);
> 		}
> 
>-		get_drawable_deltas(draw, pixmap, &dx, &dy);
>+		if (get_drawable_deltas(draw, pixmap, &dx, &dy))
>+			pixman_region_translate(region ?: &clip, dx, dy);
> 	}
> 
> 	damage(pixmap, region);
>@@ -735,7 +770,6 @@ sna_dri_copy_to_front(struct sna *sna, DrawablePtr draw, RegionPtr region,
> 		boxes = &clip.extents;
> 		n = 1;
> 	}
>-	pixman_region_translate(region, dx, dy);
> 	DamageRegionAppend(&pixmap->drawable, region);
> 	if (wedged(sna)) {
> 		sna_dri_copy_fallback(sna, draw->bitsPerPixel,
>@@ -746,7 +780,7 @@ sna_dri_copy_to_front(struct sna *sna, DrawablePtr draw, RegionPtr region,
> 		unsigned flags;
> 
> 		flags = COPY_LAST;
>-		if (flush)
>+		if (sync)
> 			flags |= COPY_SYNC;
> 		sna->render.copy_boxes(sna, GXcopy,
> 				       (PixmapPtr)draw, src_bo, -draw->x-dx, -draw->y-dy,
>@@ -754,7 +788,7 @@ sna_dri_copy_to_front(struct sna *sna, DrawablePtr draw, RegionPtr region,
> 				       boxes, n, flags);
> 
> 		DBG(("%s: flushing? %d\n", __FUNCTION__, flush));
>-		if (flush) { /* STAT! */
>+		if (sync) { /* STAT! */
> 			struct kgem_request *rq = sna->kgem.next_request;
> 			kgem_submit(&sna->kgem);
> 			if (rq->bo)
>@@ -771,290 +805,44 @@ sna_dri_copy_to_front(struct sna *sna, DrawablePtr draw, RegionPtr region,
> }
> 
> static void
>-sna_dri_copy_from_front(struct sna *sna, DrawablePtr draw, RegionPtr region,
>-			struct kgem_bo *dst_bo, struct kgem_bo *src_bo,
>-			bool sync)
>-{
>-	PixmapPtr pixmap = get_drawable_pixmap(draw);
>-	pixman_region16_t clip;
>-	BoxRec box, *boxes;
>-	int16_t dx, dy;
>-	int n;
>-
>-	box.x1 = draw->x;
>-	box.y1 = draw->y;
>-	box.x2 = draw->x + draw->width;
>-	box.y2 = draw->y + draw->height;
>-
>-	if (region) {
>-		pixman_region_translate(region, draw->x, draw->y);
>-		pixman_region_init_rects(&clip, &box, 1);
>-		pixman_region_intersect(&clip, &clip, region);
>-		region = &clip;
>-
>-		if (!pixman_region_not_empty(region)) {
>-			DBG(("%s: all clipped\n", __FUNCTION__));
>-			return;
>-		}
>-	}
>-
>-	dx = dy = 0;
>-	if (draw->type != DRAWABLE_PIXMAP) {
>-		WindowPtr win = (WindowPtr)draw;
>-
>-		DBG(("%s: draw=(%d, %d), delta=(%d, %d), clip.extents=(%d, %d), (%d, %d)\n",
>-		     __FUNCTION__, draw->x, draw->y,
>-		     get_drawable_dx(draw), get_drawable_dy(draw),
>-		     win->clipList.extents.x1, win->clipList.extents.y1,
>-		     win->clipList.extents.x2, win->clipList.extents.y2));
>-
>-		if (region == NULL) {
>-			pixman_region_init_rects(&clip, &box, 1);
>-			region = &clip;
>-		}
>-
>-		pixman_region_intersect(region, &win->clipList, region);
>-		if (!pixman_region_not_empty(region)) {
>-			DBG(("%s: all clipped\n", __FUNCTION__));
>-			return;
>-		}
>-
>-		get_drawable_deltas(draw, pixmap, &dx, &dy);
>-	}
>-
>-	if (region) {
>-		boxes = REGION_RECTS(region);
>-		n = REGION_NUM_RECTS(region);
>-		assert(n);
>-	} else {
>-		pixman_region_init_rects(&clip, &box, 1);
>-		region = &clip;
>-		boxes = &box;
>-		n = 1;
>-	}
>-	if (wedged(sna)) {
>-		sna_dri_copy_fallback(sna, draw->bitsPerPixel,
>-				      src_bo, dx, dy,
>-				      dst_bo, -draw->x, -draw->y,
>-				      boxes, n);
>-	} else {
>-		sna_dri_select_mode(sna, dst_bo, src_bo, false);
>-		sna->render.copy_boxes(sna, GXcopy,
>-				       pixmap, src_bo, dx, dy,
>-				       (PixmapPtr)draw, dst_bo, -draw->x, -draw->y,
>-				       boxes, n, COPY_LAST);
>-	}
>-
>-	if (region == &clip)
>-		pixman_region_fini(&clip);
>-}
>-
>-static void
>-sna_dri_copy(struct sna *sna, DrawablePtr draw, RegionPtr region,
>-	     struct kgem_bo *dst_bo, struct kgem_bo *src_bo,
>-	     bool sync)
>-{
>-	pixman_region16_t clip;
>-	BoxRec box, *boxes;
>-	int n;
>-
>-	box.x1 = 0;
>-	box.y1 = 0;
>-	box.x2 = draw->width;
>-	box.y2 = draw->height;
>-
>-	if (region) {
>-		pixman_region_init_rects(&clip, &box, 1);
>-		pixman_region_intersect(&clip, &clip, region);
>-		region = &clip;
>-
>-		if (!pixman_region_not_empty(region)) {
>-			DBG(("%s: all clipped\n", __FUNCTION__));
>-			return;
>-		}
>-
>-		boxes = REGION_RECTS(region);
>-		n = REGION_NUM_RECTS(region);
>-		assert(n);
>-	} else {
>-		boxes = &box;
>-		n = 1;
>-	}
>-
>-	if (wedged(sna)) {
>-		sna_dri_copy_fallback(sna, draw->bitsPerPixel,
>-				      src_bo, 0, 0,
>-				      dst_bo, 0, 0,
>-				      boxes, n);
>-	} else {
>-		sna_dri_select_mode(sna, dst_bo, src_bo, false);
>-		sna->render.copy_boxes(sna, GXcopy,
>-				       (PixmapPtr)draw, src_bo, 0, 0,
>-				       (PixmapPtr)draw, dst_bo, 0, 0,
>-				       boxes, n, COPY_LAST);
>-	}
>-
>-	if (region == &clip)
>-		pixman_region_fini(&clip);
>-}
>-
>-static bool
>-can_blit(struct sna *sna,
>-	 DrawablePtr draw,
>-	 DRI2BufferPtr dst,
>-	 DRI2BufferPtr src)
>-{
>-	RegionPtr clip;
>-	uint32_t s;
>-	BoxRec extents;
>-	int16_t dx, dy;
>-
>-	if (draw->type == DRAWABLE_PIXMAP)
>-		return true;
>-
>-	if (STRICT_BLIT && dst->attachment == DRI2BufferFrontLeft) {
>-		if (unlikely(get_private(dst)->pixmap != get_drawable_pixmap(draw))) {
>-			DBG(("%s: reject as dst pixmap=%ld, but expecting pixmap=%ld\n",
>-			     __FUNCTION__,
>-			     get_private(dst)->pixmap ? get_private(dst)->pixmap->drawable.serialNumber : 0,
>-			     get_drawable_pixmap(draw)->drawable.serialNumber));
>-			return false;
>-		}
>-
>-		assert(sna_pixmap(get_private(dst)->pixmap)->flush);
>-	}
>-
>-	assert(get_private(dst)->bo->flush);
>-	assert(get_private(src)->bo->flush);
>-
>-	clip = &((WindowPtr)draw)->clipList;
>-	if (clip->extents.x1 >= clip->extents.x2 ||
>-	    clip->extents.y1 >= clip->extents.y2) {
>-		DBG(("%s: reject, outside clip (%d, %d), (%d, %d)\n",
>-		     __func__,
>-		     clip->extents.x1, clip->extents.y1,
>-		     clip->extents.x2, clip->extents.y2));
>-		return false;
>-	}
>-
>-	/* Check the read/write extents against the size of the attachments */
>-	extents = clip->extents;
>-	if (get_drawable_deltas(draw, get_drawable_pixmap(draw), &dx, &dy)) {
>-		extents.x1 += dx; extents.x2 += dx;
>-		extents.y1 += dy; extents.y2 += dy;
>-	}
>-
>-	/* This should never happen as the Drawable->Pixmap is local! */
>-	if (unlikely(extents.x1 < 0 || extents.y1 < 0)) {
>-		DBG(("%s: reject as read/write extents, origin=(%d, %d), is out of bounds\n",
>-		     __FUNCTION__, extents.x1, extents.y1));
>-		return false;
>-	}
>-
>-	/* But the dst/src bo may be stale (older than the Drawable) and be
>-	 * too small for the blit.
>-	 */
>-	extents.x1 -= draw->x; extents.x2 -= draw->x;
>-	extents.y1 -= draw->y; extents.y2 -= draw->y;
>-
>-	s = get_private(dst)->size;
>-	if (unlikely((s>>16) < extents.y2 || (s&0xffff) < extents.x2)) {
>-		DBG(("%s: reject as write extents (bottom-right=(%d, %d), size=(%d, %d)) is out of bounds\n",
>-		     __FUNCTION__,
>-		     extents.x2, extents.y2,
>-		     s&0xffff, s>>16));
>-		return false;
>-	}
>-
>-	s = get_private(src)->size;
>-	if (unlikely((s>>16) < extents.y2 || (s&0xffff) < extents.x2)) {
>-		DBG(("%s: reject as src read extents (bottom-right=(%d, %d), size=(%d, %d)) is out of bounds\n",
>-		     __FUNCTION__,
>-		     extents.x2, extents.y2,
>-		     s&0xffff, s>>16));
>-		return false;
>-	}
>-
>-	return true;
>-}
>-
>-static void
> sna_dri_copy_region(DrawablePtr draw,
> 		    RegionPtr region,
>-		    DRI2BufferPtr dst_buffer,
>-		    DRI2BufferPtr src_buffer)
>+		    DRI2BufferPtr dst,
>+		    DRI2BufferPtr src)
> {
> 	PixmapPtr pixmap = get_drawable_pixmap(draw);
> 	struct sna *sna = to_sna_from_pixmap(pixmap);
>-	struct kgem_bo *src, *dst;
>-	void (*copy)(struct sna *, DrawablePtr, RegionPtr,
>-		     struct kgem_bo *, struct kgem_bo *, bool) = sna_dri_copy;
> 
> 	DBG(("%s: pixmap=%ld, src=%u (refs=%d/%d, flush=%d, attach=%d) , dst=%u (refs=%d/%d, flush=%d, attach=%d)\n",
> 	     __FUNCTION__,
> 	     pixmap->drawable.serialNumber,
>-	     get_private(src_buffer)->bo->handle,
>-	     get_private(src_buffer)->refcnt,
>-	     get_private(src_buffer)->bo->refcnt,
>-	     get_private(src_buffer)->bo->flush,
>-	     src_buffer->attachment,
>-	     get_private(dst_buffer)->bo->handle,
>-	     get_private(dst_buffer)->refcnt,
>-	     get_private(dst_buffer)->bo->refcnt,
>-	     get_private(dst_buffer)->bo->flush,
>-	     dst_buffer->attachment));
>-
>-	assert(get_private(src_buffer)->refcnt);
>-	assert(get_private(dst_buffer)->refcnt);
>-
>-	assert(get_private(src_buffer)->bo->refcnt);
>-	assert(get_private(src_buffer)->bo->flush);
>-
>-	assert(get_private(dst_buffer)->bo->refcnt);
>-	assert(get_private(dst_buffer)->bo->flush);
>-
>-	if (!can_blit(sna, draw, dst_buffer, src_buffer))
>-		return;
>-
>-	dst = get_private(dst_buffer)->bo;
>-	if (dst_buffer->attachment == DRI2BufferFrontLeft) {
>-		copy = (void *)sna_dri_copy_to_front;
>-		if (!STRICT_BLIT) {
>-			dst = sna_pixmap_get_bo(pixmap);
>-			if (dst == NULL)
>-				return;
>-		}
>-	}
>-
>-	DBG(("%s: dst -- attachment=%d, name=%d, handle=%d [screen=%d]\n",
>-	     __FUNCTION__,
>-	     dst_buffer->attachment, dst_buffer->name, dst ? dst->handle : 0,
>-	     sna_pixmap_get_bo(sna->front)->handle));
>-	assert(dst != NULL);
>-
>-	src = get_private(src_buffer)->bo;
>-	if (src_buffer->attachment == DRI2BufferFrontLeft) {
>-		assert(copy == sna_dri_copy);
>-		copy = sna_dri_copy_from_front;
>-		if (!STRICT_BLIT) {
>-			src = sna_pixmap_get_bo(pixmap);
>-			if (src == NULL)
>-				return;
>-		}
>-	}
>+	     get_private(src)->bo->handle,
>+	     get_private(src)->refcnt,
>+	     get_private(src)->bo->refcnt,
>+	     get_private(src)->bo->flush,
>+	     src->attachment,
>+	     get_private(dst)->bo->handle,
>+	     get_private(dst)->refcnt,
>+	     get_private(dst)->bo->refcnt,
>+	     get_private(dst)->bo->flush,
>+	     dst->attachment));
>+
>+	assert(get_private(src)->refcnt);
>+	assert(get_private(dst)->refcnt);
>+
>+	assert(get_private(src)->bo->refcnt);
>+	assert(get_private(src)->bo->flush);
> 
>-	DBG(("%s: src -- attachment=%d, name=%d, handle=%d\n",
>-	     __FUNCTION__,
>-	     src_buffer->attachment, src_buffer->name, src ? src->handle : 0));
>-	assert(src != NULL);
>+	assert(get_private(dst)->bo->refcnt);
>+	assert(get_private(dst)->bo->flush);
> 
>-	DBG(("%s: region (%d, %d), (%d, %d) x %d\n",
>+	DBG(("%s: region (%d, %d), (%d, %d) x %ld\n",
> 	     __FUNCTION__,
> 	     region->extents.x1, region->extents.y1,
> 	     region->extents.x2, region->extents.y2,
>-	     REGION_NUM_RECTS(region)));
>+	     (long)REGION_NUM_RECTS(region)));
> 
>-	copy(sna, draw, region, dst, src, false);
>+	__sna_dri_copy_region(sna, draw, region, src, dst, false);
> }
> 
> static inline int sna_wait_vblank(struct sna *sna, drmVBlank *vbl)
>@@ -1432,7 +1220,6 @@ static void chain_swap(struct sna *sna,
> 		       struct sna_dri_frame_event *chain)
> {
> 	drmVBlank vbl;
>-	int type;
> 
> 	assert(chain == sna_dri_window_get_chain((WindowPtr)draw));
> 	DBG(("%s: chaining type=%d\n", __FUNCTION__, chain->type));
>@@ -1443,26 +1230,15 @@ static void chain_swap(struct sna *sna,
> 		return;
> 	}
> 
>-	if (can_blit(sna, draw, chain->front, chain->back)) {
>-		DBG(("%s: emitting chained vsync'ed blit\n", __FUNCTION__));
>-
>-		chain->bo = sna_dri_copy_to_front(sna, draw, NULL,
>-						  get_private(chain->front)->bo,
>-						  get_private(chain->back)->bo,
>-						  true);
>+	DBG(("%s: emitting chained vsync'ed blit\n", __FUNCTION__));
> 
>-		type = DRI2_BLIT_COMPLETE;
>-	} else {
>-		DRI2SwapComplete(chain->client, draw,
>-				 0, 0, 0, DRI2_BLIT_COMPLETE,
>-				 chain->client ? chain->event_complete : NULL, chain->event_data);
>-		sna_dri_frame_event_info_free(sna, draw, chain);
>-		return;
>-	}
>+	chain->bo = __sna_dri_copy_region(sna, draw, NULL,
>+					  chain->back, chain->front, true);
> 
> 	DRI2SwapComplete(chain->client, draw,
> 			 frame, tv_sec, tv_usec,
>-			 type, chain->client ? chain->event_complete : NULL, chain->event_data);
>+			 DRI2_BLIT_COMPLETE,
>+			 chain->client ? chain->event_complete : NULL, chain->event_data);
> 
> 	VG_CLEAR(vbl);
> 	vbl.request.type =
>@@ -1519,11 +1295,8 @@ void sna_dri_vblank_handler(struct sna *sna, struct drm_event_vblank *event)
> 
> 		/* else fall through to blit */
> 	case DRI2_SWAP:
>-		if (can_blit(sna, draw, info->front, info->back))
>-			info->bo = sna_dri_copy_to_front(sna, draw, NULL,
>-							 get_private(info->front)->bo,
>-							 get_private(info->back)->bo,
>-							 true);
>+		info->bo = __sna_dri_copy_region(sna, draw, NULL,
>+						 info->back, info->front, true);
> 		info->type = DRI2_SWAP_WAIT;
> 		/* fall through to SwapComplete */
> 	case DRI2_SWAP_WAIT:
>@@ -1577,9 +1350,6 @@ sna_dri_immediate_blit(struct sna *sna,
> 	DrawablePtr draw = info->draw;
> 	bool ret = false;
> 
>-	if (!can_blit(sna, draw, info->front, info->back))
>-		goto out;
>-
> 	if (sna->flags & SNA_NO_WAIT)
> 		sync = false;
> 
>@@ -1595,9 +1365,9 @@ sna_dri_immediate_blit(struct sna *sna,
> 			DBG(("%s: no pending blit, starting chain\n",
> 			     __FUNCTION__));
> 
>-			info->bo = sna_dri_copy_to_front(sna, draw, NULL,
>-							 get_private(info->front)->bo,
>-							 get_private(info->back)->bo,
>+			info->bo = __sna_dri_copy_region(sna, draw, NULL,
>+							 info->back,
>+							 info->front,
> 							 true);
> 			if (event) {
> 				DRI2SwapComplete(info->client, draw, 0, 0, 0,
>@@ -1618,17 +1388,13 @@ sna_dri_immediate_blit(struct sna *sna,
> 		} else
> 			ret = true;
> 	} else {
>-		info->bo = sna_dri_copy_to_front(sna, draw, NULL,
>-						 get_private(info->front)->bo,
>-						 get_private(info->back)->bo,
>-						 false);
>-out:
>-		if (event) {
>+		info->bo = __sna_dri_copy_region(sna, draw, NULL,
>+						 info->back, info->front, true);
>+		if (event)
> 			DRI2SwapComplete(info->client, draw, 0, 0, 0,
> 					 DRI2_BLIT_COMPLETE,
> 					 info->event_complete,
> 					 info->event_data);
>-		}
> 	}
> 
> 	DBG(("%s: continue? %d\n", __FUNCTION__, ret));
>@@ -1763,13 +1529,10 @@ static void chain_flip(struct sna *sna)
> 	    sna_dri_page_flip(sna, chain)) {
> 		DBG(("%s: performing chained flip\n", __FUNCTION__));
> 	} else {
>-		if (can_blit(sna, chain->draw, chain->front, chain->back)) {
>-			DBG(("%s: emitting chained vsync'ed blit\n", __FUNCTION__));
>-			chain->bo = sna_dri_copy_to_front(sna, chain->draw, NULL,
>-							  get_private(chain->front)->bo,
>-							  get_private(chain->back)->bo,
>-							  true);
>-		}
>+		DBG(("%s: emitting chained vsync'ed blit\n", __FUNCTION__));
>+		chain->bo = __sna_dri_copy_region(sna, chain->draw, NULL,
>+						  chain->back, chain->front,
>+						  true);
> 		DRI2SwapComplete(chain->client, chain->draw, 0, 0, 0,
> 				 DRI2_BLIT_COMPLETE, chain->client ? chain->event_complete : NULL, chain->event_data);
> 		sna_dri_frame_event_info_free(sna, chain->draw, chain);
>@@ -2256,13 +2019,8 @@ sna_dri_schedule_swap(ClientPtr client, DrawablePtr draw, DRI2BufferPtr front,
> 	return TRUE;
> 
> blit:
>-	if (can_blit(sna, draw, front, back)) {
>-		DBG(("%s -- blit\n", __FUNCTION__));
>-		sna_dri_copy_to_front(sna, draw, NULL,
>-				      get_private(front)->bo,
>-				      get_private(back)->bo,
>-				      false);
>-	}
>+	DBG(("%s -- blit\n", __FUNCTION__));
>+	__sna_dri_copy_region(sna, draw, NULL, back, front, false);
> 	if (info)
> 		sna_dri_frame_event_info_free(sna, draw, info);
> skip:
>@@ -2287,17 +2045,12 @@ sna_dri_async_swap(ClientPtr client, DrawablePtr draw,
> 	    (pipe = sna_dri_get_pipe(draw)) < 0 ||
> 	    !sna_dri_schedule_flip(client, draw, front, back, pipe,
> 				   &target_msc, 0, 0, func, data)) {
>-		pipe = DRI2_BLIT_COMPLETE;
>-		if (can_blit(sna, draw, front, back)) {
>-			DBG(("%s: unable to flip, so blit\n", __FUNCTION__));
>-			sna_dri_copy_to_front(sna, draw, NULL,
>-					      get_private(front)->bo,
>-					      get_private(back)->bo,
>-					      false);
>-		}
>+		DBG(("%s: unable to flip, so blit\n", __FUNCTION__));
>+		__sna_dri_copy_region(sna, draw, NULL, back, front, false);
> 
>-		DRI2SwapComplete(client, draw, 0, 0, 0, pipe, func, data);
>-		return pipe == DRI2_EXCHANGE_COMPLETE;
>+		DRI2SwapComplete(client, draw, 0, 0, 0,
>+				 DRI2_BLIT_COMPLETE, func, data);
>+		return false;
> 	}
> 	return TRUE;
> }
>-- 
>1.8.1.2
>

Actions: View | Splinter Review

Attachments on bug 67305: 82999

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.