struct kgem_bo *sna_static_stream_fini(struct sna *sna,
struct sna_static_stream *stream)
{
struct kgem_bo *bo;
DBG(("uploaded %d bytes of static state\n", stream->used));
if (DEBUG_DUMP)
{
int fd = open("/tmp1/1/static.bin", O_CREAT|O_WRONLY);
if (fd != -1) {
write(fd, stream->data, stream->used);
close(fd);
}
else
{
printf("SNA: failed to write static stream\n");
asm volatile("int3");
}
}
bo = kgem_create_linear(&sna->kgem, stream->used, 0);
if (bo && !kgem_bo_write(&sna->kgem, bo, stream->data, stream->used)) {
kgem_bo_destroy(&sna->kgem, bo);
return NULL;
}
free(stream->data);
return bo;
}
static int sna_video_overlay_stop(ClientPtr client,
XvPortPtr port,
DrawablePtr draw)
{
struct sna_video *video = port->devPriv.ptr;
struct sna *sna = video->sna;
struct drm_intel_overlay_put_image request;
DBG(("%s()\n", __FUNCTION__));
REGION_EMPTY(scrn->pScreen, &video->clip);
request.flags = 0;
(void)drmIoctl(sna->kgem.fd,
DRM_IOCTL_I915_OVERLAY_PUT_IMAGE,
&request);
if (video->bo)
kgem_bo_destroy(&sna->kgem, video->bo);
video->bo = NULL;
sna_video_free_buffers(video);
sna_window_set_port((WindowPtr)draw, NULL);
return Success;
}
void sna_video_free_buffers(struct sna *sna, struct sna_video *video)
{
unsigned int i;
for (i = 0; i < ARRAY_SIZE(video->old_buf); i++) {
if (video->old_buf[i]) {
kgem_bo_destroy(&sna->kgem, video->old_buf[i]);
video->old_buf[i] = NULL;
}
}
if (video->buf) {
kgem_bo_destroy(&sna->kgem, video->buf);
video->buf = NULL;
}
}
struct kgem_bo *sna_static_stream_fini(struct sna *sna,
struct sna_static_stream *stream)
{
struct kgem_bo *bo;
DBG(("uploaded %d bytes of static state\n", stream->used));
bo = kgem_create_linear(&sna->kgem, stream->used, 0);
if (bo && !kgem_bo_write(&sna->kgem, bo, stream->data, stream->used)) {
kgem_bo_destroy(&sna->kgem, bo);
return NULL;
}
free(stream->data);
return bo;
}
void sna_read_boxes(struct sna *sna, PixmapPtr dst, struct kgem_bo *src_bo,
const BoxRec *box, int nbox)
{
struct kgem *kgem = &sna->kgem;
struct kgem_bo *dst_bo;
BoxRec extents;
const BoxRec *tmp_box;
int tmp_nbox;
void *ptr;
int src_pitch, cpp, offset;
int n, cmd, br13;
bool can_blt;
DBG(("%s x %d, src=(handle=%d), dst=(size=(%d, %d)\n",
__FUNCTION__, nbox, src_bo->handle,
dst->drawable.width, dst->drawable.height));
#ifndef NDEBUG
for (n = 0; n < nbox; n++) {
if (box[n].x1 < 0 || box[n].y1 < 0 ||
box[n].x2 * dst->drawable.bitsPerPixel/8 > src_bo->pitch ||
box[n].y2 * src_bo->pitch > kgem_bo_size(src_bo))
{
FatalError("source out-of-bounds box[%d]=(%d, %d), (%d, %d), pitch=%d, size=%d\n", n,
box[n].x1, box[n].y1,
box[n].x2, box[n].y2,
src_bo->pitch, kgem_bo_size(src_bo));
}
}
#endif
/* XXX The gpu is faster to perform detiling in bulk, but takes
* longer to setup and retrieve the results, with an additional
* copy. The long term solution is to use snoopable bo and avoid
* this path.
*/
if (download_inplace(kgem, dst, src_bo, box ,nbox)) {
fallback:
read_boxes_inplace(kgem, dst, src_bo, box, nbox);
return;
}
can_blt = kgem_bo_can_blt(kgem, src_bo) &&
(box[0].x2 - box[0].x1) * dst->drawable.bitsPerPixel < 8 * (MAXSHORT - 4);
extents = box[0];
for (n = 1; n < nbox; n++) {
if (box[n].x1 < extents.x1)
extents.x1 = box[n].x1;
if (box[n].x2 > extents.x2)
extents.x2 = box[n].x2;
if (can_blt)
can_blt = (box[n].x2 - box[n].x1) * dst->drawable.bitsPerPixel < 8 * (MAXSHORT - 4);
if (box[n].y1 < extents.y1)
extents.y1 = box[n].y1;
if (box[n].y2 > extents.y2)
extents.y2 = box[n].y2;
}
if (kgem_bo_can_map(kgem, src_bo)) {
/* Is it worth detiling? */
if ((extents.y2 - extents.y1 - 1) * src_bo->pitch < 4096)
goto fallback;
}
/* Try to avoid switching rings... */
if (!can_blt || kgem->ring == KGEM_RENDER ||
upload_too_large(sna, extents.x2 - extents.x1, extents.y2 - extents.y1)) {
PixmapRec tmp;
tmp.drawable.width = extents.x2 - extents.x1;
tmp.drawable.height = extents.y2 - extents.y1;
tmp.drawable.depth = dst->drawable.depth;
tmp.drawable.bitsPerPixel = dst->drawable.bitsPerPixel;
tmp.devPrivate.ptr = NULL;
assert(tmp.drawable.width);
assert(tmp.drawable.height);
if (must_tile(sna, tmp.drawable.width, tmp.drawable.height)) {
BoxRec tile, stack[64], *clipped, *c;
int step;
if (n > ARRAY_SIZE(stack)) {
clipped = malloc(sizeof(BoxRec) * n);
if (clipped == NULL)
goto fallback;
} else
clipped = stack;
step = MIN(sna->render.max_3d_size,
8*(MAXSHORT&~63) / dst->drawable.bitsPerPixel);
while (step * step * 4 > sna->kgem.max_upload_tile_size)
step /= 2;
DBG(("%s: tiling download, using %dx%d tiles\n",
__FUNCTION__, step, step));
assert(step);
for (tile.y1 = extents.y1; tile.y1 < extents.y2; tile.y1 = tile.y2) {
int y2 = tile.y1 + step;
if (y2 > extents.y2)
y2 = extents.y2;
tile.y2 = y2;
for (tile.x1 = extents.x1; tile.x1 < extents.x2; tile.x1 = tile.x2) {
int x2 = tile.x1 + step;
if (x2 > extents.x2)
x2 = extents.x2;
tile.x2 = x2;
tmp.drawable.width = tile.x2 - tile.x1;
tmp.drawable.height = tile.y2 - tile.y1;
c = clipped;
for (n = 0; n < nbox; n++) {
*c = box[n];
if (!box_intersect(c, &tile))
continue;
DBG(("%s: box(%d, %d), (%d, %d),, dst=(%d, %d)\n",
__FUNCTION__,
c->x1, c->y1,
c->x2, c->y2,
c->x1 - tile.x1,
c->y1 - tile.y1));
c++;
}
if (c == clipped)
continue;
dst_bo = kgem_create_buffer_2d(kgem,
tmp.drawable.width,
tmp.drawable.height,
tmp.drawable.bitsPerPixel,
KGEM_BUFFER_LAST,
&ptr);
if (!dst_bo) {
if (clipped != stack)
free(clipped);
goto fallback;
}
if (!sna->render.copy_boxes(sna, GXcopy,
dst, src_bo, 0, 0,
&tmp, dst_bo, -tile.x1, -tile.y1,
clipped, c-clipped, COPY_LAST)) {
kgem_bo_destroy(&sna->kgem, dst_bo);
if (clipped != stack)
free(clipped);
goto fallback;
}
kgem_bo_submit(&sna->kgem, dst_bo);
kgem_buffer_read_sync(kgem, dst_bo);
if (sigtrap_get() == 0) {
while (c-- != clipped) {
memcpy_blt(ptr, dst->devPrivate.ptr, tmp.drawable.bitsPerPixel,
dst_bo->pitch, dst->devKind,
c->x1 - tile.x1,
c->y1 - tile.y1,
c->x1, c->y1,
c->x2 - c->x1,
c->y2 - c->y1);
}
sigtrap_put();
}
kgem_bo_destroy(&sna->kgem, dst_bo);
}
}
if (clipped != stack)
free(clipped);
} else {
dst_bo = kgem_create_buffer_2d(kgem,
tmp.drawable.width,
tmp.drawable.height,
tmp.drawable.bitsPerPixel,
KGEM_BUFFER_LAST,
&ptr);
if (!dst_bo)
goto fallback;
if (!sna->render.copy_boxes(sna, GXcopy,
dst, src_bo, 0, 0,
&tmp, dst_bo, -extents.x1, -extents.y1,
box, nbox, COPY_LAST)) {
kgem_bo_destroy(&sna->kgem, dst_bo);
goto fallback;
}
kgem_bo_submit(&sna->kgem, dst_bo);
kgem_buffer_read_sync(kgem, dst_bo);
if (sigtrap_get() == 0) {
for (n = 0; n < nbox; n++) {
memcpy_blt(ptr, dst->devPrivate.ptr, tmp.drawable.bitsPerPixel,
dst_bo->pitch, dst->devKind,
box[n].x1 - extents.x1,
box[n].y1 - extents.y1,
box[n].x1, box[n].y1,
box[n].x2 - box[n].x1,
box[n].y2 - box[n].y1);
}
sigtrap_put();
}
kgem_bo_destroy(&sna->kgem, dst_bo);
}
return;
}
/* count the total number of bytes to be read and allocate a bo */
cpp = dst->drawable.bitsPerPixel / 8;
offset = 0;
for (n = 0; n < nbox; n++) {
int height = box[n].y2 - box[n].y1;
int width = box[n].x2 - box[n].x1;
offset += PITCH(width, cpp) * height;
}
DBG((" read buffer size=%d\n", offset));
dst_bo = kgem_create_buffer(kgem, offset, KGEM_BUFFER_LAST, &ptr);
if (!dst_bo) {
read_boxes_inplace(kgem, dst, src_bo, box, nbox);
return;
}
cmd = XY_SRC_COPY_BLT_CMD;
src_pitch = src_bo->pitch;
if (kgem->gen >= 040 && src_bo->tiling) {
cmd |= BLT_SRC_TILED;
src_pitch >>= 2;
}
static bool
sna_tiling_blt_copy_boxes__with_alpha(struct sna *sna, uint8_t alu,
struct kgem_bo *src_bo, int16_t src_dx, int16_t src_dy,
struct kgem_bo *dst_bo, int16_t dst_dx, int16_t dst_dy,
int bpp, int alpha_fixup,
const BoxRec *box, int nbox)
{
RegionRec region, tile, this;
struct kgem_bo *bo;
int max_size, step;
bool ret = false;
if (wedged(sna) ||
!kgem_bo_can_blt(&sna->kgem, src_bo) ||
!kgem_bo_can_blt(&sna->kgem, dst_bo)) {
/* XXX */
DBG(("%s: tiling blt fail: src?=%d, dst?=%d\n",
__FUNCTION__,
kgem_bo_can_blt(&sna->kgem, src_bo),
kgem_bo_can_blt(&sna->kgem, dst_bo)));
return false;
}
max_size = sna->kgem.aperture_high * PAGE_SIZE;
max_size -= MAX(kgem_bo_size(src_bo), kgem_bo_size(dst_bo));
if (max_size <= 0) {
DBG(("%s: tiles cannot fit into aperture\n", __FUNCTION__));
return false;
}
if (max_size > sna->kgem.max_copy_tile_size)
max_size = sna->kgem.max_copy_tile_size;
pixman_region_init_rects(®ion, box, nbox);
/* Use a small step to accommodate enlargement through tile alignment */
step = sna->render.max_3d_size;
if (region.extents.x1 & (8*512 / bpp - 1) || region.extents.y1 & 63)
step /= 2;
while (step * step * 4 > max_size)
step /= 2;
if (sna->kgem.gen < 033)
step /= 2; /* accommodate severe fence restrictions */
if (step == 0) {
DBG(("%s: tiles cannot fit into aperture\n", __FUNCTION__));
return false;
}
DBG(("%s (alu=%d), tile.size=%d, box=%dx[(%d, %d), (%d, %d)])\n",
__FUNCTION__, alu, step, nbox,
region.extents.x1, region.extents.y1,
region.extents.x2, region.extents.y2));
for (tile.extents.y1 = tile.extents.y2 = region.extents.y1;
tile.extents.y2 < region.extents.y2;
tile.extents.y1 = tile.extents.y2) {
int y2 = tile.extents.y1 + step;
if (y2 > region.extents.y2)
y2 = region.extents.y2;
tile.extents.y2 = y2;
for (tile.extents.x1 = tile.extents.x2 = region.extents.x1;
tile.extents.x2 < region.extents.x2;
tile.extents.x1 = tile.extents.x2) {
int w, h;
int x2 = tile.extents.x1 + step;
if (x2 > region.extents.x2)
x2 = region.extents.x2;
tile.extents.x2 = x2;
tile.data = NULL;
RegionNull(&this);
RegionIntersect(&this, ®ion, &tile);
if (RegionNil(&this))
continue;
w = this.extents.x2 - this.extents.x1;
h = this.extents.y2 - this.extents.y1;
bo = kgem_create_2d(&sna->kgem, w, h, bpp,
kgem_choose_tiling(&sna->kgem,
I915_TILING_X,
w, h, bpp),
CREATE_TEMPORARY);
if (bo) {
int16_t dx = this.extents.x1;
int16_t dy = this.extents.y1;
assert(bo->pitch <= 8192);
assert(bo->tiling != I915_TILING_Y);
if (!sna_blt_copy_boxes(sna, GXcopy,
src_bo, src_dx, src_dy,
bo, -dx, -dy,
bpp, REGION_RECTS(&this), REGION_NUM_RECTS(&this)))
goto err;
if (!sna_blt_copy_boxes__with_alpha(sna, alu,
bo, -dx, -dy,
dst_bo, dst_dx, dst_dy,
bpp, alpha_fixup,
REGION_RECTS(&this), REGION_NUM_RECTS(&this)))
goto err;
kgem_bo_destroy(&sna->kgem, bo);
}
RegionUninit(&this);
}
}
ret = true;
goto done;
err:
kgem_bo_destroy(&sna->kgem, bo);
RegionUninit(&this);
done:
pixman_region_fini(®ion);
return ret;
}
bool
sna_tiling_fill_boxes(struct sna *sna,
CARD8 op,
PictFormat format,
const xRenderColor *color,
PixmapPtr dst, struct kgem_bo *dst_bo,
const BoxRec *box, int n)
{
RegionRec region, tile, this;
struct kgem_bo *bo;
int step;
bool ret = false;
pixman_region_init_rects(®ion, box, n);
/* Use a small step to accommodate enlargement through tile alignment */
step = sna->render.max_3d_size;
if (region.extents.x1 & (8*512 / dst->drawable.bitsPerPixel - 1) ||
region.extents.y1 & 63)
step /= 2;
while (step * step * 4 > sna->kgem.max_copy_tile_size)
step /= 2;
DBG(("%s (op=%d, format=%x, color=(%04x,%04x,%04x, %04x), tile.size=%d, box=%dx[(%d, %d), (%d, %d)])\n",
__FUNCTION__, op, (int)format,
color->red, color->green, color->blue, color->alpha,
step, n,
region.extents.x1, region.extents.y1,
region.extents.x2, region.extents.y2));
for (tile.extents.y1 = tile.extents.y2 = region.extents.y1;
tile.extents.y2 < region.extents.y2;
tile.extents.y1 = tile.extents.y2) {
int y2 = tile.extents.y1 + step;
if (y2 > region.extents.y2)
y2 = region.extents.y2;
tile.extents.y2 = y2;
for (tile.extents.x1 = tile.extents.x2 = region.extents.x1;
tile.extents.x2 < region.extents.x2;
tile.extents.x1 = tile.extents.x2) {
PixmapRec tmp;
int x2 = tile.extents.x1 + step;
if (x2 > region.extents.x2)
x2 = region.extents.x2;
tile.extents.x2 = x2;
tile.data = NULL;
RegionNull(&this);
RegionIntersect(&this, ®ion, &tile);
if (RegionNil(&this))
continue;
tmp.drawable.width = this.extents.x2 - this.extents.x1;
tmp.drawable.height = this.extents.y2 - this.extents.y1;
tmp.drawable.depth = dst->drawable.depth;
tmp.drawable.bitsPerPixel = dst->drawable.bitsPerPixel;
tmp.devPrivate.ptr = NULL;
bo = kgem_create_2d(&sna->kgem,
tmp.drawable.width,
tmp.drawable.height,
dst->drawable.bitsPerPixel,
kgem_choose_tiling(&sna->kgem,
I915_TILING_X,
tmp.drawable.width,
tmp.drawable.height,
dst->drawable.bitsPerPixel),
CREATE_TEMPORARY);
if (bo) {
int16_t dx = this.extents.x1;
int16_t dy = this.extents.y1;
assert(kgem_bo_can_blt(&sna->kgem, bo));
if (!sna->render.copy_boxes(sna, GXcopy,
dst, dst_bo, 0, 0,
&tmp, bo, -dx, -dy,
REGION_RECTS(&this), REGION_NUM_RECTS(&this), 0))
goto err;
RegionTranslate(&this, -dx, -dy);
if (!sna->render.fill_boxes(sna, op, format, color,
&tmp, bo,
REGION_RECTS(&this), REGION_NUM_RECTS(&this)))
goto err;
if (!sna->render.copy_boxes(sna, GXcopy,
&tmp, bo, 0, 0,
dst, dst_bo, dx, dy,
REGION_RECTS(&this), REGION_NUM_RECTS(&this), 0))
goto err;
kgem_bo_destroy(&sna->kgem, bo);
}
RegionUninit(&this);
}
}
ret = true;
goto done;
err:
kgem_bo_destroy(&sna->kgem, bo);
RegionUninit(&this);
done:
pixman_region_fini(®ion);
return ret;
}
bool
sna_tiling_copy_boxes(struct sna *sna, uint8_t alu,
PixmapPtr src, struct kgem_bo *src_bo, int16_t src_dx, int16_t src_dy,
PixmapPtr dst, struct kgem_bo *dst_bo, int16_t dst_dx, int16_t dst_dy,
const BoxRec *box, int n)
{
BoxRec extents, tile, stack[64], *clipped, *c;
PixmapRec p;
int i, step, tiling;
bool create = true;
bool ret = false;
extents = box[0];
for (i = 1; i < n; i++) {
if (box[i].x1 < extents.x1)
extents.x1 = box[i].x1;
if (box[i].y1 < extents.y1)
extents.y1 = box[i].y1;
if (box[i].x2 > extents.x2)
extents.x2 = box[i].x2;
if (box[i].y2 > extents.y2)
extents.y2 = box[i].y2;
}
tiling = I915_TILING_X;
if (!kgem_bo_can_blt(&sna->kgem, src_bo) ||
!kgem_bo_can_blt(&sna->kgem, dst_bo))
tiling = I915_TILING_Y;
create = (src_bo->pitch > sna->render.max_3d_pitch ||
dst_bo->pitch > sna->render.max_3d_pitch);
step = sna->render.max_3d_size / 2;
if (create) {
while (step * step * 4 > sna->kgem.max_upload_tile_size)
step /= 2;
}
DBG(("%s: tiling copy %dx%d, %s %dx%d %c tiles\n", __FUNCTION__,
extents.x2-extents.x1, extents.y2-extents.y1,
create ? "creating" : "using",
step, step, tiling == I915_TILING_X ? 'X' : 'Y'));
if (n > ARRAY_SIZE(stack)) {
clipped = malloc(sizeof(BoxRec) * n);
if (clipped == NULL)
goto tiled_error;
} else
clipped = stack;
p.drawable.depth = src->drawable.depth;
p.drawable.bitsPerPixel = src->drawable.bitsPerPixel;
p.devPrivate.ptr = NULL;
for (tile.y1 = extents.y1; tile.y1 < extents.y2; tile.y1 = tile.y2) {
int y2 = tile.y1 + step;
if (y2 > extents.y2)
y2 = extents.y2;
tile.y2 = y2;
for (tile.x1 = extents.x1; tile.x1 < extents.x2; tile.x1 = tile.x2) {
struct kgem_bo *tmp_bo;
int x2 = tile.x1 + step;
if (x2 > extents.x2)
x2 = extents.x2;
tile.x2 = x2;
c = clipped;
for (i = 0; i < n; i++) {
*c = box[i];
if (!box_intersect(c, &tile))
continue;
DBG(("%s: box(%d, %d), (%d, %d), src=(%d, %d), dst=(%d, %d)\n",
__FUNCTION__,
c->x1, c->y1,
c->x2, c->y2,
src_dx, src_dy,
c->x1 - tile.x1,
c->y1 - tile.y1));
c++;
}
if (c == clipped)
continue;
p.drawable.width = tile.x2 - tile.x1;
p.drawable.height = tile.y2 - tile.y1;
DBG(("%s: tile (%d, %d), (%d, %d)\n",
__FUNCTION__, tile.x1, tile.y1, tile.x2, tile.y2));
if (create) {
tmp_bo = kgem_create_2d(&sna->kgem,
p.drawable.width,
p.drawable.height,
p.drawable.bitsPerPixel,
tiling, CREATE_TEMPORARY);
if (!tmp_bo)
goto tiled_error;
i = (sna->render.copy_boxes(sna, GXcopy,
src, src_bo, src_dx, src_dy,
&p, tmp_bo, -tile.x1, -tile.y1,
clipped, c - clipped, 0) &&
sna->render.copy_boxes(sna, alu,
&p, tmp_bo, -tile.x1, -tile.y1,
dst, dst_bo, dst_dx, dst_dy,
clipped, c - clipped, 0));
kgem_bo_destroy(&sna->kgem, tmp_bo);
} else {
i = sna->render.copy_boxes(sna, GXcopy,
src, src_bo, src_dx, src_dy,
dst, dst_bo, dst_dx, dst_dy,
clipped, c - clipped, 0);
}
if (!i)
goto tiled_error;
}
}
ret = true;
tiled_error:
if (clipped != stack)
free(clipped);
return ret;
}
bool sna_tiling_blt_copy_boxes(struct sna *sna, uint8_t alu,
struct kgem_bo *src_bo, int16_t src_dx, int16_t src_dy,
struct kgem_bo *dst_bo, int16_t dst_dx, int16_t dst_dy,
int bpp, const BoxRec *box, int nbox)
{
RegionRec region, tile, this;
struct kgem_bo *bo;
int step;
bool ret = false;
if (!kgem_bo_can_blt(&sna->kgem, src_bo) ||
!kgem_bo_can_blt(&sna->kgem, dst_bo)) {
/* XXX */
DBG(("%s: tiling blt fail: src?=%d, dst?=%d\n",
__FUNCTION__,
kgem_bo_can_blt(&sna->kgem, src_bo),
kgem_bo_can_blt(&sna->kgem, dst_bo)));
return false;
}
pixman_region_init_rects(®ion, box, nbox);
/* Use a small step to accommodate enlargement through tile alignment */
step = sna->render.max_3d_size;
if (region.extents.x1 & (8*512 / bpp - 1) || region.extents.y1 & 63)
step /= 2;
while (step * step * 4 > sna->kgem.max_copy_tile_size)
step /= 2;
DBG(("%s (alu=%d), tile.size=%d, box=%dx[(%d, %d), (%d, %d)])\n",
__FUNCTION__, alu, step, nbox,
region.extents.x1, region.extents.y1,
region.extents.x2, region.extents.y2));
for (tile.extents.y1 = tile.extents.y2 = region.extents.y1;
tile.extents.y2 < region.extents.y2;
tile.extents.y1 = tile.extents.y2) {
tile.extents.y2 = tile.extents.y1 + step;
if (tile.extents.y2 > region.extents.y2)
tile.extents.y2 = region.extents.y2;
for (tile.extents.x1 = tile.extents.x2 = region.extents.x1;
tile.extents.x2 < region.extents.x2;
tile.extents.x1 = tile.extents.x2) {
int w, h;
tile.extents.x2 = tile.extents.x1 + step;
if (tile.extents.x2 > region.extents.x2)
tile.extents.x2 = region.extents.x2;
tile.data = NULL;
RegionNull(&this);
RegionIntersect(&this, ®ion, &tile);
if (!RegionNotEmpty(&this))
continue;
w = this.extents.x2 - this.extents.x1;
h = this.extents.y2 - this.extents.y1;
bo = kgem_create_2d(&sna->kgem, w, h, bpp,
kgem_choose_tiling(&sna->kgem,
I915_TILING_X,
w, h, bpp),
CREATE_TEMPORARY);
if (bo) {
int16_t dx = this.extents.x1;
int16_t dy = this.extents.y1;
assert(bo->pitch <= 8192);
assert(bo->tiling != I915_TILING_Y);
if (!sna_blt_copy_boxes(sna, alu,
src_bo, src_dx, src_dy,
bo, -dx, -dy,
bpp, REGION_RECTS(&this), REGION_NUM_RECTS(&this)))
goto err;
if (!sna_blt_copy_boxes(sna, alu,
bo, -dx, -dy,
dst_bo, dst_dx, dst_dy,
bpp, REGION_RECTS(&this), REGION_NUM_RECTS(&this)))
goto err;
kgem_bo_destroy(&sna->kgem, bo);
}
RegionUninit(&this);
}
}
ret = true;
goto done;
err:
kgem_bo_destroy(&sna->kgem, bo);
RegionUninit(&this);
done:
pixman_region_fini(®ion);
return ret;
}
