for (i = 0; i < height; i++) {
uint32_t *row = (uint32_t *)dst;
for (j = 0; j < width; j++)
- *row++ = uc->ui;
+ *row++ = uc->ui[0];
dst += dst_stride;
}
break;
}
+void
+util_fill_box(ubyte * dst,
+ enum pipe_format format,
+ unsigned stride,
+ unsigned layer_stride,
+ unsigned x,
+ unsigned y,
+ unsigned z,
+ unsigned width,
+ unsigned height,
+ unsigned depth,
+ union util_color *uc)
+{
+ unsigned layer;
+ dst += z * layer_stride;
+ for (layer = z; layer < depth; layer++) {
+ util_fill_rect(dst, format,
+ stride,
+ x, y, width, height, uc);
+ dst += layer_stride;
+ }
+}
+
+
/**
* Fallback function for pipe->resource_copy_region().
+ * We support copying between different formats (including compressed/
+ * uncompressed) if the bytes per block or pixel matches. If copying
+ * compressed -> uncompressed, the dst region is reduced by the block
+ * width, height. If copying uncompressed -> compressed, the dest region
+ * is expanded by the block width, height. See GL_ARB_copy_image.
* Note: (X,Y)=(0,0) is always the upper-left corner.
*/
void
unsigned dst_x, unsigned dst_y, unsigned dst_z,
struct pipe_resource *src,
unsigned src_level,
- const struct pipe_box *src_box)
+ const struct pipe_box *src_box_in)
{
struct pipe_transfer *src_trans, *dst_trans;
uint8_t *dst_map;
const uint8_t *src_map;
- enum pipe_format src_format, dst_format;
- struct pipe_box dst_box;
+ MAYBE_UNUSED enum pipe_format src_format;
+ enum pipe_format dst_format;
+ struct pipe_box src_box, dst_box;
+ unsigned src_bs, dst_bs, src_bw, dst_bw, src_bh, dst_bh;
assert(src && dst);
if (!src || !dst)
src_format = src->format;
dst_format = dst->format;
- assert(util_format_get_blocksize(dst_format) == util_format_get_blocksize(src_format));
- assert(util_format_get_blockwidth(dst_format) == util_format_get_blockwidth(src_format));
- assert(util_format_get_blockheight(dst_format) == util_format_get_blockheight(src_format));
+ /* init src box */
+ src_box = *src_box_in;
+
+ /* init dst box */
+ dst_box.x = dst_x;
+ dst_box.y = dst_y;
+ dst_box.z = dst_z;
+ dst_box.width = src_box.width;
+ dst_box.height = src_box.height;
+ dst_box.depth = src_box.depth;
+
+ src_bs = util_format_get_blocksize(src_format);
+ src_bw = util_format_get_blockwidth(src_format);
+ src_bh = util_format_get_blockheight(src_format);
+ dst_bs = util_format_get_blocksize(dst_format);
+ dst_bw = util_format_get_blockwidth(dst_format);
+ dst_bh = util_format_get_blockheight(dst_format);
+
+ /* Note: all box positions and sizes are in pixels */
+ if (src_bw > 1 && dst_bw == 1) {
+ /* Copy from compressed to uncompressed.
+ * Shrink dest box by the src block size.
+ */
+ dst_box.width /= src_bw;
+ dst_box.height /= src_bh;
+ }
+ else if (src_bw == 1 && dst_bw > 1) {
+ /* Copy from uncompressed to compressed.
+ * Expand dest box by the dest block size.
+ */
+ dst_box.width *= dst_bw;
+ dst_box.height *= dst_bh;
+ }
+ else {
+ /* compressed -> compressed or uncompressed -> uncompressed copy */
+ assert(src_bw == dst_bw);
+ assert(src_bh == dst_bh);
+ }
+
+ assert(src_bs == dst_bs);
+ if (src_bs != dst_bs) {
+ /* This can happen if we fail to do format checking before hand.
+ * Don't crash below.
+ */
+ return;
+ }
+
+ /* check that region boxes are block aligned */
+ assert(src_box.x % src_bw == 0);
+ assert(src_box.y % src_bh == 0);
+ assert(src_box.width % src_bw == 0 ||
+ src_box.x + src_box.width == u_minify(src->width0, src_level));
+ assert(src_box.height % src_bh == 0 ||
+ src_box.y + src_box.height == u_minify(src->height0, src_level));
+ assert(dst_box.x % dst_bw == 0);
+ assert(dst_box.y % dst_bh == 0);
+ assert(dst_box.width % dst_bw == 0 ||
+ dst_box.x + dst_box.width == u_minify(dst->width0, dst_level));
+ assert(dst_box.height % dst_bh == 0 ||
+ dst_box.y + dst_box.height == u_minify(dst->height0, dst_level));
+
+ /* check that region boxes are not out of bounds */
+ assert(src_box.x + src_box.width <= u_minify(src->width0, src_level));
+ assert(src_box.y + src_box.height <= u_minify(src->height0, src_level));
+ assert(dst_box.x + dst_box.width <= u_minify(dst->width0, dst_level));
+ assert(dst_box.y + dst_box.height <= u_minify(dst->height0, dst_level));
+
+ /* check that total number of src, dest bytes match */
+ assert((src_box.width / src_bw) * (src_box.height / src_bh) * src_bs ==
+ (dst_box.width / dst_bw) * (dst_box.height / dst_bh) * dst_bs);
src_map = pipe->transfer_map(pipe,
src,
src_level,
PIPE_TRANSFER_READ,
- src_box, &src_trans);
+ &src_box, &src_trans);
assert(src_map);
if (!src_map) {
goto no_src_map;
}
- dst_box.x = dst_x;
- dst_box.y = dst_y;
- dst_box.z = dst_z;
- dst_box.width = src_box->width;
- dst_box.height = src_box->height;
- dst_box.depth = src_box->depth;
-
dst_map = pipe->transfer_map(pipe,
dst,
dst_level,
- PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD_RANGE,
- &dst_box, &dst_trans);
+ PIPE_TRANSFER_WRITE |
+ PIPE_TRANSFER_DISCARD_RANGE, &dst_box,
+ &dst_trans);
assert(dst_map);
if (!dst_map) {
goto no_dst_map;
}
if (dst->target == PIPE_BUFFER && src->target == PIPE_BUFFER) {
- assert(src_box->height == 1);
- assert(src_box->depth == 1);
- memcpy(dst_map, src_map, src_box->width);
+ assert(src_box.height == 1);
+ assert(src_box.depth == 1);
+ memcpy(dst_map, src_map, src_box.width);
} else {
util_copy_box(dst_map,
- dst_format,
+ src_format,
dst_trans->stride, dst_trans->layer_stride,
0, 0, 0,
- src_box->width, src_box->height, src_box->depth,
+ src_box.width, src_box.height, src_box.depth,
src_map,
src_trans->stride, src_trans->layer_stride,
0, 0, 0);
;
}
+static void
+util_clear_color_texture_helper(struct pipe_transfer *dst_trans,
+ ubyte *dst_map,
+ enum pipe_format format,
+ const union pipe_color_union *color,
+ unsigned width, unsigned height, unsigned depth)
+{
+ union util_color uc;
+
+ assert(dst_trans->stride > 0);
+
+ if (util_format_is_pure_integer(format)) {
+ /*
+ * We expect int/uint clear values here, though some APIs
+ * might disagree (but in any case util_pack_color()
+ * couldn't handle it)...
+ */
+ if (util_format_is_pure_sint(format)) {
+ util_format_write_4i(format, color->i, 0, &uc, 0, 0, 0, 1, 1);
+ } else {
+ assert(util_format_is_pure_uint(format));
+ util_format_write_4ui(format, color->ui, 0, &uc, 0, 0, 0, 1, 1);
+ }
+ } else {
+ util_pack_color(color->f, format, &uc);
+ }
+
+ util_fill_box(dst_map, format,
+ dst_trans->stride, dst_trans->layer_stride,
+ 0, 0, 0, width, height, depth, &uc);
+}
+
+static void
+util_clear_color_texture(struct pipe_context *pipe,
+ struct pipe_resource *texture,
+ enum pipe_format format,
+ const union pipe_color_union *color,
+ unsigned level,
+ unsigned dstx, unsigned dsty, unsigned dstz,
+ unsigned width, unsigned height, unsigned depth)
+{
+ struct pipe_transfer *dst_trans;
+ ubyte *dst_map;
+
+ dst_map = pipe_transfer_map_3d(pipe,
+ texture,
+ level,
+ PIPE_TRANSFER_WRITE,
+ dstx, dsty, dstz,
+ width, height, depth,
+ &dst_trans);
+ if (!dst_map)
+ return;
+
+ if (dst_trans->stride > 0) {
+ util_clear_color_texture_helper(dst_trans, dst_map, format, color,
+ width, height, depth);
+ }
+ pipe->transfer_unmap(pipe, dst_trans);
+}
#define UBYTE_TO_USHORT(B) ((B) | ((B) << 8))
* cpp > 4 looks like a gross hack at best...
* Plus can't use these transfer fallbacks when clearing
* multisampled surfaces for instance.
+ * Clears all bound layers.
*/
void
util_clear_render_target(struct pipe_context *pipe,
unsigned width, unsigned height)
{
struct pipe_transfer *dst_trans;
- void *dst_map;
- union util_color uc;
+ ubyte *dst_map;
assert(dst->texture);
if (!dst->texture)
PIPE_TRANSFER_WRITE,
dx, 0, w, 1,
&dst_trans);
+ if (dst_map) {
+ util_clear_color_texture_helper(dst_trans, dst_map, dst->format,
+ color, width, height, 1);
+ pipe->transfer_unmap(pipe, dst_trans);
+ }
}
else {
- /* XXX: should handle multiple layers */
- dst_map = pipe_transfer_map(pipe,
- dst->texture,
- dst->u.tex.level,
- dst->u.tex.first_layer,
- PIPE_TRANSFER_WRITE,
- dstx, dsty, width, height, &dst_trans);
-
- }
-
- assert(dst_map);
-
- if (dst_map) {
- enum pipe_format format = dst->format;
- assert(dst_trans->stride > 0);
-
- if (util_format_is_pure_integer(format)) {
- /*
- * We expect int/uint clear values here, though some APIs
- * might disagree (but in any case util_pack_color()
- * couldn't handle it)...
- */
- if (util_format_is_pure_sint(format)) {
- util_format_write_4i(format, color->i, 0, &uc, 0, 0, 0, 1, 1);
- }
- else {
- assert(util_format_is_pure_uint(format));
- util_format_write_4ui(format, color->ui, 0, &uc, 0, 0, 0, 1, 1);
- }
- }
- else {
- util_pack_color(color->f, dst->format, &uc);
- }
- util_fill_rect(dst_map, dst->format,
- dst_trans->stride,
- 0, 0, width, height, &uc);
-
- pipe->transfer_unmap(pipe, dst_trans);
+ unsigned depth = dst->u.tex.last_layer - dst->u.tex.first_layer + 1;
+ util_clear_color_texture(pipe, dst->texture, dst->format, color,
+ dst->u.tex.level, dstx, dsty,
+ dst->u.tex.first_layer, width, height, depth);
}
}
-/**
- * Fallback for pipe->clear_stencil() function.
- * sw fallback doesn't look terribly useful here.
- * Plus can't use these transfer fallbacks when clearing
- * multisampled surfaces for instance.
- */
-void
-util_clear_depth_stencil(struct pipe_context *pipe,
- struct pipe_surface *dst,
- unsigned clear_flags,
- double depth,
- unsigned stencil,
- unsigned dstx, unsigned dsty,
- unsigned width, unsigned height)
+static void
+util_clear_depth_stencil_texture(struct pipe_context *pipe,
+ struct pipe_resource *texture,
+ enum pipe_format format,
+ unsigned clear_flags,
+ uint64_t zstencil, unsigned level,
+ unsigned dstx, unsigned dsty, unsigned dstz,
+ unsigned width, unsigned height, unsigned depth)
{
- enum pipe_format format = dst->format;
struct pipe_transfer *dst_trans;
ubyte *dst_map;
boolean need_rmw = FALSE;
+ unsigned dst_stride;
+ ubyte *dst_layer;
+ unsigned i, j, layer;
if ((clear_flags & PIPE_CLEAR_DEPTHSTENCIL) &&
((clear_flags & PIPE_CLEAR_DEPTHSTENCIL) != PIPE_CLEAR_DEPTHSTENCIL) &&
util_format_is_depth_and_stencil(format))
need_rmw = TRUE;
- assert(dst->texture);
- if (!dst->texture)
- return;
- dst_map = pipe_transfer_map(pipe,
- dst->texture,
- dst->u.tex.level,
- dst->u.tex.first_layer,
- (need_rmw ? PIPE_TRANSFER_READ_WRITE :
- PIPE_TRANSFER_WRITE),
- dstx, dsty, width, height, &dst_trans);
+ dst_map = pipe_transfer_map_3d(pipe,
+ texture,
+ level,
+ (need_rmw ? PIPE_TRANSFER_READ_WRITE :
+ PIPE_TRANSFER_WRITE),
+ dstx, dsty, dstz,
+ width, height, depth, &dst_trans);
assert(dst_map);
+ if (!dst_map)
+ return;
+
+ dst_stride = dst_trans->stride;
+ dst_layer = dst_map;
+ assert(dst_trans->stride > 0);
- if (dst_map) {
- unsigned dst_stride = dst_trans->stride;
- uint64_t zstencil = util_pack64_z_stencil(format,
- depth, stencil);
- unsigned i, j;
- assert(dst_trans->stride > 0);
+ for (layer = 0; layer < depth; layer++) {
+ dst_map = dst_layer;
switch (util_format_get_blocksize(format)) {
case 1:
assert(0);
break;
}
-
- pipe->transfer_unmap(pipe, dst_trans);
+ dst_layer += dst_trans->layer_stride;
}
+
+ pipe->transfer_unmap(pipe, dst_trans);
}
-/* Return whether this is an RGBA, Z, S, or combined ZS format.
- */
-static unsigned
-get_format_mask(enum pipe_format format)
+void
+util_clear_texture(struct pipe_context *pipe,
+ struct pipe_resource *tex,
+ unsigned level,
+ const struct pipe_box *box,
+ const void *data)
{
- const struct util_format_description *desc = util_format_description(format);
+ const struct util_format_description *desc =
+ util_format_description(tex->format);
+
+ if (level > tex->last_level)
+ return;
- assert(desc);
+ if (util_format_is_depth_or_stencil(tex->format)) {
+ unsigned clear = 0;
+ float depth = 0.0f;
+ uint8_t stencil = 0;
+ uint64_t zstencil;
- if (util_format_has_depth(desc)) {
- if (util_format_has_stencil(desc)) {
- return PIPE_MASK_ZS;
- } else {
- return PIPE_MASK_Z;
+ if (util_format_has_depth(desc)) {
+ clear |= PIPE_CLEAR_DEPTH;
+ desc->unpack_z_float(&depth, 0, data, 0, 1, 1);
}
- } else {
+
if (util_format_has_stencil(desc)) {
- return PIPE_MASK_S;
- } else {
- return PIPE_MASK_RGBA;
+ clear |= PIPE_CLEAR_STENCIL;
+ desc->unpack_s_8uint(&stencil, 0, data, 0, 1, 1);
}
+
+ zstencil = util_pack64_z_stencil(tex->format, depth, stencil);
+
+ util_clear_depth_stencil_texture(pipe, tex, tex->format, clear, zstencil,
+ level, box->x, box->y, box->z,
+ box->width, box->height, box->depth);
+ } else {
+ union pipe_color_union color;
+ if (util_format_is_pure_uint(tex->format))
+ desc->unpack_rgba_uint(color.ui, 0, data, 0, 1, 1);
+ else if (util_format_is_pure_sint(tex->format))
+ desc->unpack_rgba_sint(color.i, 0, data, 0, 1, 1);
+ else
+ desc->unpack_rgba_float(color.f, 0, data, 0, 1, 1);
+
+ util_clear_color_texture(pipe, tex, tex->format, &color, level,
+ box->x, box->y, box->z,
+ box->width, box->height, box->depth);
}
}
+
+/**
+ * Fallback for pipe->clear_stencil() function.
+ * sw fallback doesn't look terribly useful here.
+ * Plus can't use these transfer fallbacks when clearing
+ * multisampled surfaces for instance.
+ * Clears all bound layers.
+ */
+void
+util_clear_depth_stencil(struct pipe_context *pipe,
+ struct pipe_surface *dst,
+ unsigned clear_flags,
+ double depth,
+ unsigned stencil,
+ unsigned dstx, unsigned dsty,
+ unsigned width, unsigned height)
+{
+ uint64_t zstencil;
+ unsigned max_layer;
+
+ assert(dst->texture);
+ if (!dst->texture)
+ return;
+
+ zstencil = util_pack64_z_stencil(dst->format, depth, stencil);
+ max_layer = dst->u.tex.last_layer - dst->u.tex.first_layer;
+ util_clear_depth_stencil_texture(pipe, dst->texture, dst->format,
+ clear_flags, zstencil, dst->u.tex.level,
+ dstx, dsty, dst->u.tex.first_layer,
+ width, height, max_layer + 1);
+}
+
+
/* Return if the box is totally inside the resource.
*/
static boolean
depth = res->array_size;
assert(res->array_size % 6 == 0);
break;
- case PIPE_MAX_TEXTURE_TYPES:;
+ case PIPE_MAX_TEXTURE_TYPES:
+ break;
}
return box->x >= 0 &&
return res->nr_samples ? res->nr_samples : 1;
}
+
/**
- * Try to do a blit using resource_copy_region. The function calls
- * resource_copy_region if the blit description is compatible with it.
- *
- * It returns TRUE if the blit was done using resource_copy_region.
- *
- * It returns FALSE otherwise and the caller must fall back to a more generic
- * codepath for the blit operation. (e.g. by using u_blitter)
+ * Check if a blit() command can be implemented with a resource_copy_region().
+ * If tight_format_check is true, only allow the resource_copy_region() if
+ * the blit src/dst formats are identical, ignoring the resource formats.
+ * Otherwise, check for format casting and compatibility.
*/
boolean
-util_try_blit_via_copy_region(struct pipe_context *ctx,
- const struct pipe_blit_info *blit)
+util_can_blit_via_copy_region(const struct pipe_blit_info *blit,
+ boolean tight_format_check)
{
- unsigned mask = get_format_mask(blit->dst.format);
-
- /* No format conversions. */
- if (blit->src.resource->format != blit->src.format ||
- blit->dst.resource->format != blit->dst.format ||
- !util_is_format_compatible(
- util_format_description(blit->src.resource->format),
- util_format_description(blit->dst.resource->format))) {
- return FALSE;
+ const struct util_format_description *src_desc, *dst_desc;
+
+ src_desc = util_format_description(blit->src.resource->format);
+ dst_desc = util_format_description(blit->dst.resource->format);
+
+ if (tight_format_check) {
+ /* no format conversions allowed */
+ if (blit->src.format != blit->dst.format) {
+ return FALSE;
+ }
+ }
+ else {
+ /* do loose format compatibility checking */
+ if (blit->src.resource->format != blit->src.format ||
+ blit->dst.resource->format != blit->dst.format ||
+ !util_is_format_compatible(src_desc, dst_desc)) {
+ return FALSE;
+ }
}
- /* No masks, no filtering, no scissor. */
+ unsigned mask = util_format_get_mask(blit->dst.format);
+
+ /* No masks, no filtering, no scissor, no blending */
if ((blit->mask & mask) != mask ||
blit->filter != PIPE_TEX_FILTER_NEAREST ||
- blit->scissor_enable) {
+ blit->scissor_enable ||
+ blit->num_window_rectangles > 0 ||
+ blit->alpha_blend) {
return FALSE;
}
- /* No flipping. */
- if (blit->src.box.width < 0 ||
- blit->src.box.height < 0 ||
- blit->src.box.depth < 0) {
- return FALSE;
- }
+ /* Only the src box can have negative dims for flipping */
+ assert(blit->dst.box.width >= 1);
+ assert(blit->dst.box.height >= 1);
+ assert(blit->dst.box.depth >= 1);
- /* No scaling. */
+ /* No scaling or flipping */
if (blit->src.box.width != blit->dst.box.width ||
blit->src.box.height != blit->dst.box.height ||
blit->src.box.depth != blit->dst.box.depth) {
return FALSE;
}
- ctx->resource_copy_region(ctx, blit->dst.resource, blit->dst.level,
- blit->dst.box.x, blit->dst.box.y, blit->dst.box.z,
- blit->src.resource, blit->src.level,
- &blit->src.box);
return TRUE;
}
+
+
+/**
+ * Try to do a blit using resource_copy_region. The function calls
+ * resource_copy_region if the blit description is compatible with it.
+ *
+ * It returns TRUE if the blit was done using resource_copy_region.
+ *
+ * It returns FALSE otherwise and the caller must fall back to a more generic
+ * codepath for the blit operation. (e.g. by using u_blitter)
+ */
+boolean
+util_try_blit_via_copy_region(struct pipe_context *ctx,
+ const struct pipe_blit_info *blit)
+{
+ if (util_can_blit_via_copy_region(blit, FALSE)) {
+ ctx->resource_copy_region(ctx, blit->dst.resource, blit->dst.level,
+ blit->dst.box.x, blit->dst.box.y,
+ blit->dst.box.z,
+ blit->src.resource, blit->src.level,
+ &blit->src.box);
+ return TRUE;
+ }
+ else {
+ return FALSE;
+ }
+}
projects / mesa.git / blobdiff