685 lines
21 KiB
C
685 lines
21 KiB
C
/**************************************************************************
|
|
*
|
|
* Copyright 2009 VMware, Inc. All Rights Reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sub license, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the
|
|
* next paragraph) shall be included in all copies or substantial portions
|
|
* of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
|
* IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
|
|
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
**************************************************************************/
|
|
|
|
/**
|
|
* @file
|
|
* Surface utility functions.
|
|
*
|
|
* @author Brian Paul
|
|
*/
|
|
|
|
|
|
#include "pipe/p_defines.h"
|
|
#include "pipe/p_screen.h"
|
|
#include "pipe/p_state.h"
|
|
|
|
#include "util/u_format.h"
|
|
#include "util/u_inlines.h"
|
|
#include "util/u_rect.h"
|
|
#include "util/u_surface.h"
|
|
#include "util/u_pack_color.h"
|
|
|
|
|
|
/**
|
|
* Initialize a pipe_surface object. 'view' is considered to have
|
|
* uninitialized contents.
|
|
*/
|
|
void
|
|
u_surface_default_template(struct pipe_surface *surf,
|
|
const struct pipe_resource *texture)
|
|
{
|
|
memset(surf, 0, sizeof(*surf));
|
|
|
|
surf->format = texture->format;
|
|
}
|
|
|
|
|
|
/**
|
|
* Copy 2D rect from one place to another.
|
|
* Position and sizes are in pixels.
|
|
* src_stride may be negative to do vertical flip of pixels from source.
|
|
*/
|
|
void
|
|
util_copy_rect(ubyte * dst,
|
|
enum pipe_format format,
|
|
unsigned dst_stride,
|
|
unsigned dst_x,
|
|
unsigned dst_y,
|
|
unsigned width,
|
|
unsigned height,
|
|
const ubyte * src,
|
|
int src_stride,
|
|
unsigned src_x,
|
|
unsigned src_y)
|
|
{
|
|
unsigned i;
|
|
int src_stride_pos = src_stride < 0 ? -src_stride : src_stride;
|
|
int blocksize = util_format_get_blocksize(format);
|
|
int blockwidth = util_format_get_blockwidth(format);
|
|
int blockheight = util_format_get_blockheight(format);
|
|
|
|
assert(blocksize > 0);
|
|
assert(blockwidth > 0);
|
|
assert(blockheight > 0);
|
|
|
|
dst_x /= blockwidth;
|
|
dst_y /= blockheight;
|
|
width = (width + blockwidth - 1)/blockwidth;
|
|
height = (height + blockheight - 1)/blockheight;
|
|
src_x /= blockwidth;
|
|
src_y /= blockheight;
|
|
|
|
dst += dst_x * blocksize;
|
|
src += src_x * blocksize;
|
|
dst += dst_y * dst_stride;
|
|
src += src_y * src_stride_pos;
|
|
width *= blocksize;
|
|
|
|
if (width == dst_stride && width == src_stride)
|
|
memcpy(dst, src, height * width);
|
|
else {
|
|
for (i = 0; i < height; i++) {
|
|
memcpy(dst, src, width);
|
|
dst += dst_stride;
|
|
src += src_stride;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Copy 3D box from one place to another.
|
|
* Position and sizes are in pixels.
|
|
*/
|
|
void
|
|
util_copy_box(ubyte * dst,
|
|
enum pipe_format format,
|
|
unsigned dst_stride, unsigned dst_slice_stride,
|
|
unsigned dst_x, unsigned dst_y, unsigned dst_z,
|
|
unsigned width, unsigned height, unsigned depth,
|
|
const ubyte * src,
|
|
int src_stride, unsigned src_slice_stride,
|
|
unsigned src_x, unsigned src_y, unsigned src_z)
|
|
{
|
|
unsigned z;
|
|
dst += dst_z * dst_slice_stride;
|
|
src += src_z * src_slice_stride;
|
|
for (z = 0; z < depth; ++z) {
|
|
util_copy_rect(dst,
|
|
format,
|
|
dst_stride,
|
|
dst_x, dst_y,
|
|
width, height,
|
|
src,
|
|
src_stride,
|
|
src_x, src_y);
|
|
|
|
dst += dst_slice_stride;
|
|
src += src_slice_stride;
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
util_fill_rect(ubyte * dst,
|
|
enum pipe_format format,
|
|
unsigned dst_stride,
|
|
unsigned dst_x,
|
|
unsigned dst_y,
|
|
unsigned width,
|
|
unsigned height,
|
|
union util_color *uc)
|
|
{
|
|
const struct util_format_description *desc = util_format_description(format);
|
|
unsigned i, j;
|
|
unsigned width_size;
|
|
int blocksize = desc->block.bits / 8;
|
|
int blockwidth = desc->block.width;
|
|
int blockheight = desc->block.height;
|
|
|
|
assert(blocksize > 0);
|
|
assert(blockwidth > 0);
|
|
assert(blockheight > 0);
|
|
|
|
dst_x /= blockwidth;
|
|
dst_y /= blockheight;
|
|
width = (width + blockwidth - 1)/blockwidth;
|
|
height = (height + blockheight - 1)/blockheight;
|
|
|
|
dst += dst_x * blocksize;
|
|
dst += dst_y * dst_stride;
|
|
width_size = width * blocksize;
|
|
|
|
switch (blocksize) {
|
|
case 1:
|
|
if(dst_stride == width_size)
|
|
memset(dst, uc->ub, height * width_size);
|
|
else {
|
|
for (i = 0; i < height; i++) {
|
|
memset(dst, uc->ub, width_size);
|
|
dst += dst_stride;
|
|
}
|
|
}
|
|
break;
|
|
case 2:
|
|
for (i = 0; i < height; i++) {
|
|
uint16_t *row = (uint16_t *)dst;
|
|
for (j = 0; j < width; j++)
|
|
*row++ = uc->us;
|
|
dst += dst_stride;
|
|
}
|
|
break;
|
|
case 4:
|
|
for (i = 0; i < height; i++) {
|
|
uint32_t *row = (uint32_t *)dst;
|
|
for (j = 0; j < width; j++)
|
|
*row++ = uc->ui;
|
|
dst += dst_stride;
|
|
}
|
|
break;
|
|
default:
|
|
for (i = 0; i < height; i++) {
|
|
ubyte *row = dst;
|
|
for (j = 0; j < width; j++) {
|
|
memcpy(row, uc, blocksize);
|
|
row += blocksize;
|
|
}
|
|
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().
|
|
* Note: (X,Y)=(0,0) is always the upper-left corner.
|
|
*/
|
|
void
|
|
util_resource_copy_region(struct pipe_context *pipe,
|
|
struct pipe_resource *dst,
|
|
unsigned dst_level,
|
|
unsigned dst_x, unsigned dst_y, unsigned dst_z,
|
|
struct pipe_resource *src,
|
|
unsigned src_level,
|
|
const struct pipe_box *src_box)
|
|
{
|
|
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;
|
|
|
|
assert(src && dst);
|
|
if (!src || !dst)
|
|
return;
|
|
|
|
assert((src->target == PIPE_BUFFER && dst->target == PIPE_BUFFER) ||
|
|
(src->target != PIPE_BUFFER && dst->target != PIPE_BUFFER));
|
|
|
|
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));
|
|
|
|
src_map = pipe->transfer_map(pipe,
|
|
src,
|
|
src_level,
|
|
PIPE_TRANSFER_READ,
|
|
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);
|
|
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);
|
|
} else {
|
|
util_copy_box(dst_map,
|
|
dst_format,
|
|
dst_trans->stride, dst_trans->layer_stride,
|
|
0, 0, 0,
|
|
src_box->width, src_box->height, src_box->depth,
|
|
src_map,
|
|
src_trans->stride, src_trans->layer_stride,
|
|
0, 0, 0);
|
|
}
|
|
|
|
pipe->transfer_unmap(pipe, dst_trans);
|
|
no_dst_map:
|
|
pipe->transfer_unmap(pipe, src_trans);
|
|
no_src_map:
|
|
;
|
|
}
|
|
|
|
|
|
|
|
#define UBYTE_TO_USHORT(B) ((B) | ((B) << 8))
|
|
|
|
|
|
/**
|
|
* Fallback for pipe->clear_render_target() function.
|
|
* XXX this looks too hackish to be really useful.
|
|
* 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,
|
|
struct pipe_surface *dst,
|
|
const union pipe_color_union *color,
|
|
unsigned dstx, unsigned dsty,
|
|
unsigned width, unsigned height)
|
|
{
|
|
struct pipe_transfer *dst_trans;
|
|
ubyte *dst_map;
|
|
union util_color uc;
|
|
unsigned max_layer;
|
|
|
|
assert(dst->texture);
|
|
if (!dst->texture)
|
|
return;
|
|
|
|
if (dst->texture->target == PIPE_BUFFER) {
|
|
/*
|
|
* The fill naturally works on the surface format, however
|
|
* the transfer uses resource format which is just bytes for buffers.
|
|
*/
|
|
unsigned dx, w;
|
|
unsigned pixstride = util_format_get_blocksize(dst->format);
|
|
dx = (dst->u.buf.first_element + dstx) * pixstride;
|
|
w = width * pixstride;
|
|
max_layer = 0;
|
|
dst_map = pipe_transfer_map(pipe,
|
|
dst->texture,
|
|
0, 0,
|
|
PIPE_TRANSFER_WRITE,
|
|
dx, 0, w, 1,
|
|
&dst_trans);
|
|
}
|
|
else {
|
|
max_layer = dst->u.tex.last_layer - dst->u.tex.first_layer;
|
|
dst_map = pipe_transfer_map_3d(pipe,
|
|
dst->texture,
|
|
dst->u.tex.level,
|
|
PIPE_TRANSFER_WRITE,
|
|
dstx, dsty, dst->u.tex.first_layer,
|
|
width, height, max_layer + 1, &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_box(dst_map, dst->format,
|
|
dst_trans->stride, dst_trans->layer_stride,
|
|
0, 0, 0, width, height, max_layer + 1, &uc);
|
|
|
|
pipe->transfer_unmap(pipe, dst_trans);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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)
|
|
{
|
|
enum pipe_format format = dst->format;
|
|
struct pipe_transfer *dst_trans;
|
|
ubyte *dst_map;
|
|
boolean need_rmw = FALSE;
|
|
unsigned max_layer, 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;
|
|
|
|
max_layer = dst->u.tex.last_layer - dst->u.tex.first_layer;
|
|
dst_map = pipe_transfer_map_3d(pipe,
|
|
dst->texture,
|
|
dst->u.tex.level,
|
|
(need_rmw ? PIPE_TRANSFER_READ_WRITE :
|
|
PIPE_TRANSFER_WRITE),
|
|
dstx, dsty, dst->u.tex.first_layer,
|
|
width, height, max_layer + 1, &dst_trans);
|
|
assert(dst_map);
|
|
|
|
if (dst_map) {
|
|
unsigned dst_stride = dst_trans->stride;
|
|
uint64_t zstencil = util_pack64_z_stencil(format, depth, stencil);
|
|
ubyte *dst_layer = dst_map;
|
|
unsigned i, j;
|
|
assert(dst_trans->stride > 0);
|
|
|
|
for (layer = 0; layer <= max_layer; layer++) {
|
|
dst_map = dst_layer;
|
|
|
|
switch (util_format_get_blocksize(format)) {
|
|
case 1:
|
|
assert(format == PIPE_FORMAT_S8_UINT);
|
|
if(dst_stride == width)
|
|
memset(dst_map, (uint8_t) zstencil, height * width);
|
|
else {
|
|
for (i = 0; i < height; i++) {
|
|
memset(dst_map, (uint8_t) zstencil, width);
|
|
dst_map += dst_stride;
|
|
}
|
|
}
|
|
break;
|
|
case 2:
|
|
assert(format == PIPE_FORMAT_Z16_UNORM);
|
|
for (i = 0; i < height; i++) {
|
|
uint16_t *row = (uint16_t *)dst_map;
|
|
for (j = 0; j < width; j++)
|
|
*row++ = (uint16_t) zstencil;
|
|
dst_map += dst_stride;
|
|
}
|
|
break;
|
|
case 4:
|
|
if (!need_rmw) {
|
|
for (i = 0; i < height; i++) {
|
|
uint32_t *row = (uint32_t *)dst_map;
|
|
for (j = 0; j < width; j++)
|
|
*row++ = (uint32_t) zstencil;
|
|
dst_map += dst_stride;
|
|
}
|
|
}
|
|
else {
|
|
uint32_t dst_mask;
|
|
if (format == PIPE_FORMAT_Z24_UNORM_S8_UINT)
|
|
dst_mask = 0x00ffffff;
|
|
else {
|
|
assert(format == PIPE_FORMAT_S8_UINT_Z24_UNORM);
|
|
dst_mask = 0xffffff00;
|
|
}
|
|
if (clear_flags & PIPE_CLEAR_DEPTH)
|
|
dst_mask = ~dst_mask;
|
|
for (i = 0; i < height; i++) {
|
|
uint32_t *row = (uint32_t *)dst_map;
|
|
for (j = 0; j < width; j++) {
|
|
uint32_t tmp = *row & dst_mask;
|
|
*row++ = tmp | ((uint32_t) zstencil & ~dst_mask);
|
|
}
|
|
dst_map += dst_stride;
|
|
}
|
|
}
|
|
break;
|
|
case 8:
|
|
if (!need_rmw) {
|
|
for (i = 0; i < height; i++) {
|
|
uint64_t *row = (uint64_t *)dst_map;
|
|
for (j = 0; j < width; j++)
|
|
*row++ = zstencil;
|
|
dst_map += dst_stride;
|
|
}
|
|
}
|
|
else {
|
|
uint64_t src_mask;
|
|
|
|
if (clear_flags & PIPE_CLEAR_DEPTH)
|
|
src_mask = 0x00000000ffffffffull;
|
|
else
|
|
src_mask = 0x000000ff00000000ull;
|
|
|
|
for (i = 0; i < height; i++) {
|
|
uint64_t *row = (uint64_t *)dst_map;
|
|
for (j = 0; j < width; j++) {
|
|
uint64_t tmp = *row & ~src_mask;
|
|
*row++ = tmp | (zstencil & src_mask);
|
|
}
|
|
dst_map += dst_stride;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
assert(0);
|
|
break;
|
|
}
|
|
dst_layer += dst_trans->layer_stride;
|
|
}
|
|
|
|
pipe->transfer_unmap(pipe, dst_trans);
|
|
}
|
|
}
|
|
|
|
|
|
/* Return if the box is totally inside the resource.
|
|
*/
|
|
static boolean
|
|
is_box_inside_resource(const struct pipe_resource *res,
|
|
const struct pipe_box *box,
|
|
unsigned level)
|
|
{
|
|
unsigned width = 1, height = 1, depth = 1;
|
|
|
|
switch (res->target) {
|
|
case PIPE_BUFFER:
|
|
width = res->width0;
|
|
height = 1;
|
|
depth = 1;
|
|
break;
|
|
case PIPE_TEXTURE_1D:
|
|
width = u_minify(res->width0, level);
|
|
height = 1;
|
|
depth = 1;
|
|
break;
|
|
case PIPE_TEXTURE_2D:
|
|
case PIPE_TEXTURE_RECT:
|
|
width = u_minify(res->width0, level);
|
|
height = u_minify(res->height0, level);
|
|
depth = 1;
|
|
break;
|
|
case PIPE_TEXTURE_3D:
|
|
width = u_minify(res->width0, level);
|
|
height = u_minify(res->height0, level);
|
|
depth = u_minify(res->depth0, level);
|
|
break;
|
|
case PIPE_TEXTURE_CUBE:
|
|
width = u_minify(res->width0, level);
|
|
height = u_minify(res->height0, level);
|
|
depth = 6;
|
|
break;
|
|
case PIPE_TEXTURE_1D_ARRAY:
|
|
width = u_minify(res->width0, level);
|
|
height = 1;
|
|
depth = res->array_size;
|
|
break;
|
|
case PIPE_TEXTURE_2D_ARRAY:
|
|
width = u_minify(res->width0, level);
|
|
height = u_minify(res->height0, level);
|
|
depth = res->array_size;
|
|
break;
|
|
case PIPE_TEXTURE_CUBE_ARRAY:
|
|
width = u_minify(res->width0, level);
|
|
height = u_minify(res->height0, level);
|
|
depth = res->array_size;
|
|
assert(res->array_size % 6 == 0);
|
|
break;
|
|
case PIPE_MAX_TEXTURE_TYPES:;
|
|
}
|
|
|
|
return box->x >= 0 &&
|
|
box->x + box->width <= (int) width &&
|
|
box->y >= 0 &&
|
|
box->y + box->height <= (int) height &&
|
|
box->z >= 0 &&
|
|
box->z + box->depth <= (int) depth;
|
|
}
|
|
|
|
static unsigned
|
|
get_sample_count(const struct pipe_resource *res)
|
|
{
|
|
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)
|
|
*/
|
|
boolean
|
|
util_try_blit_via_copy_region(struct pipe_context *ctx,
|
|
const struct pipe_blit_info *blit)
|
|
{
|
|
unsigned mask = util_format_get_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;
|
|
}
|
|
|
|
/* No masks, no filtering, no scissor. */
|
|
if ((blit->mask & mask) != mask ||
|
|
blit->filter != PIPE_TEX_FILTER_NEAREST ||
|
|
blit->scissor_enable) {
|
|
return FALSE;
|
|
}
|
|
|
|
/* No flipping. */
|
|
if (blit->src.box.width < 0 ||
|
|
blit->src.box.height < 0 ||
|
|
blit->src.box.depth < 0) {
|
|
return FALSE;
|
|
}
|
|
|
|
/* No scaling. */
|
|
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;
|
|
}
|
|
|
|
/* No out-of-bounds access. */
|
|
if (!is_box_inside_resource(blit->src.resource, &blit->src.box,
|
|
blit->src.level) ||
|
|
!is_box_inside_resource(blit->dst.resource, &blit->dst.box,
|
|
blit->dst.level)) {
|
|
return FALSE;
|
|
}
|
|
|
|
/* Sample counts must match. */
|
|
if (get_sample_count(blit->src.resource) !=
|
|
get_sample_count(blit->dst.resource)) {
|
|
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;
|
|
}
|