static void
intel_miptree_copy_slice_sw(struct intel_context *intel,
struct intel_mipmap_tree *dst_mt,
struct intel_mipmap_tree *src_mt,
int level,
int slice,
int width,
int height)
{
void *src, *dst;
int src_stride, dst_stride;
int cpp = dst_mt->cpp;
intel_miptree_map(intel, src_mt,
level, slice,
0, 0,
width, height,
GL_MAP_READ_BIT,
&src, &src_stride);
intel_miptree_map(intel, dst_mt,
level, slice,
0, 0,
width, height,
GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT,
&dst, &dst_stride);
DBG("sw blit %s mt %p %p/%d -> %s mt %p %p/%d (%dx%d)\n",
_mesa_get_format_name(src_mt->format),
src_mt, src, src_stride,
_mesa_get_format_name(dst_mt->format),
dst_mt, dst, dst_stride,
width, height);
int row_size = cpp * width;
if (src_stride == row_size &&
dst_stride == row_size) {
memcpy(dst, src, row_size * height);
} else {
for (int i = 0; i < height; i++) {
memcpy(dst, src, row_size);
dst += dst_stride;
src += src_stride;
}
}
intel_miptree_unmap(intel, dst_mt, level, slice);
intel_miptree_unmap(intel, src_mt, level, slice);
}
static void
intel_unmap_texture_image(struct gl_context *ctx,
struct gl_texture_image *tex_image, GLuint slice)
{
struct intel_context *intel = intel_context(ctx);
struct intel_texture_image *intel_image = intel_texture_image(tex_image);
struct intel_mipmap_tree *mt = intel_image->mt;
if (tex_image->TexObject->Target == GL_TEXTURE_CUBE_MAP)
slice = tex_image->Face;
intel_miptree_unmap(intel, mt, tex_image->Level, slice);
}
/**
* \see dd_function_table::UnmapRenderbuffer
*/
static void
intel_unmap_renderbuffer(struct gl_context *ctx,
struct gl_renderbuffer *rb)
{
struct intel_context *intel = intel_context(ctx);
struct swrast_renderbuffer *srb = (struct swrast_renderbuffer *)rb;
struct intel_renderbuffer *irb = intel_renderbuffer(rb);
DBG("%s: rb %d (%s)\n", __FUNCTION__,
rb->Name, _mesa_get_format_name(rb->Format));
if (srb->Buffer) {
/* this is a malloc'd renderbuffer (accum buffer) */
/* nothing to do */
return;
}
intel_miptree_unmap(intel, irb->mt, irb->mt_level, irb->mt_layer);
}
static void
copy_image_with_memcpy(struct brw_context *brw,
struct intel_mipmap_tree *src_mt, int src_level,
int src_x, int src_y, int src_z,
struct intel_mipmap_tree *dst_mt, int dst_level,
int dst_x, int dst_y, int dst_z,
int src_width, int src_height)
{
bool same_slice;
void *mapped, *src_mapped, *dst_mapped;
ptrdiff_t src_stride, dst_stride, cpp;
int map_x1, map_y1, map_x2, map_y2;
GLuint src_bw, src_bh;
cpp = _mesa_get_format_bytes(src_mt->format);
_mesa_get_format_block_size(src_mt->format, &src_bw, &src_bh);
assert(src_width % src_bw == 0);
assert(src_height % src_bh == 0);
assert(src_x % src_bw == 0);
assert(src_y % src_bh == 0);
/* If we are on the same miptree, same level, and same slice, then
* intel_miptree_map won't let us map it twice. We have to do things a
* bit differently. In particular, we do a single map large enough for
* both portions and in read-write mode.
*/
same_slice = src_mt == dst_mt && src_level == dst_level && src_z == dst_z;
if (same_slice) {
assert(dst_x % src_bw == 0);
assert(dst_y % src_bh == 0);
map_x1 = MIN2(src_x, dst_x);
map_y1 = MIN2(src_y, dst_y);
map_x2 = MAX2(src_x, dst_x) + src_width;
map_y2 = MAX2(src_y, dst_y) + src_height;
intel_miptree_map(brw, src_mt, src_level, src_z,
map_x1, map_y1, map_x2 - map_x1, map_y2 - map_y1,
GL_MAP_READ_BIT | GL_MAP_WRITE_BIT,
&mapped, &src_stride);
dst_stride = src_stride;
/* Set the offsets here so we don't have to think about while looping */
src_mapped = mapped + ((src_y - map_y1) / src_bh) * src_stride +
((src_x - map_x1) / src_bw) * cpp;
dst_mapped = mapped + ((dst_y - map_y1) / src_bh) * dst_stride +
((dst_x - map_x1) / src_bw) * cpp;
} else {
intel_miptree_map(brw, src_mt, src_level, src_z,
src_x, src_y, src_width, src_height,
GL_MAP_READ_BIT, &src_mapped, &src_stride);
intel_miptree_map(brw, dst_mt, dst_level, dst_z,
dst_x, dst_y, src_width, src_height,
GL_MAP_WRITE_BIT, &dst_mapped, &dst_stride);
}
src_width /= (int)src_bw;
src_height /= (int)src_bh;
for (int i = 0; i < src_height; ++i) {
memcpy(dst_mapped, src_mapped, src_width * cpp);
src_mapped += src_stride;
dst_mapped += dst_stride;
}
if (same_slice) {
intel_miptree_unmap(brw, src_mt, src_level, src_z);
} else {
intel_miptree_unmap(brw, dst_mt, dst_level, dst_z);
intel_miptree_unmap(brw, src_mt, src_level, src_z);
}
}