42dccb1233
some of them had typos, didn't say 'authors or copyright holders', or other mistakes. This is now https://opensource.org/licenses/MIT text, formatted consistently.
240 lines
9.1 KiB
C
240 lines
9.1 KiB
C
/*
|
||
* Copyright © 2017 Intel Corporation
|
||
*
|
||
* 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, sublicense,
|
||
* 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 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 NONINFRINGEMENT. IN NO EVENT SHALL
|
||
* THE AUTHORS OR COPYRIGHT HOLDERS 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.
|
||
*/
|
||
|
||
#include <stdio.h>
|
||
#include "pipe/p_defines.h"
|
||
#include "pipe/p_state.h"
|
||
#include "pipe/p_context.h"
|
||
#include "pipe/p_screen.h"
|
||
#include "util/u_format.h"
|
||
#include "util/u_inlines.h"
|
||
#include "util/ralloc.h"
|
||
#include "intel/blorp/blorp.h"
|
||
#include "iris_context.h"
|
||
#include "iris_resource.h"
|
||
#include "iris_screen.h"
|
||
|
||
void
|
||
iris_blorp_surf_for_resource(struct blorp_surf *surf,
|
||
struct pipe_resource *p_res,
|
||
enum isl_aux_usage aux_usage,
|
||
bool is_render_target)
|
||
{
|
||
struct iris_resource *res = (void *) p_res;
|
||
|
||
*surf = (struct blorp_surf) {
|
||
.surf = &res->surf,
|
||
.addr = (struct blorp_address) {
|
||
.buffer = res->bo,
|
||
.offset = 0, // XXX: ???
|
||
.reloc_flags = is_render_target ? EXEC_OBJECT_WRITE : 0,
|
||
.mocs = I915_MOCS_CACHED, // XXX: BDW MOCS, PTE MOCS
|
||
},
|
||
.aux_usage = aux_usage,
|
||
};
|
||
|
||
assert(surf->aux_usage == ISL_AUX_USAGE_NONE);
|
||
}
|
||
|
||
static enum isl_format
|
||
iris_get_blorp_format(enum pipe_format pf)
|
||
{
|
||
switch (pf) {
|
||
case PIPE_FORMAT_Z24_UNORM_S8_UINT:
|
||
return ISL_FORMAT_R24_UNORM_X8_TYPELESS;
|
||
case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
|
||
return ISL_FORMAT_R32_FLOAT;
|
||
default:
|
||
return iris_isl_format_for_pipe_format(pf);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* The pipe->blit() driver hook.
|
||
*
|
||
* This performs a blit between two surfaces, which copies data but may
|
||
* also perform format conversion, scaling, flipping, and so on.
|
||
*/
|
||
static void
|
||
iris_blit(struct pipe_context *ctx, const struct pipe_blit_info *info)
|
||
{
|
||
struct iris_context *ice = (void *) ctx;
|
||
struct blorp_surf src_surf, dst_surf;
|
||
iris_blorp_surf_for_resource(&src_surf, info->src.resource,
|
||
ISL_AUX_USAGE_NONE, false);
|
||
iris_blorp_surf_for_resource(&dst_surf, info->dst.resource,
|
||
ISL_AUX_USAGE_NONE, true);
|
||
|
||
enum isl_format src_isl_format = iris_get_blorp_format(info->src.format);
|
||
enum isl_format dst_isl_format = iris_get_blorp_format(info->dst.format);
|
||
|
||
struct isl_swizzle src_isl_swizzle = ISL_SWIZZLE_IDENTITY;
|
||
|
||
int src_x0 = info->src.box.x;
|
||
int src_x1 = info->src.box.x + info->src.box.width;
|
||
int src_y0 = info->src.box.y;
|
||
int src_y1 = info->src.box.y + info->src.box.height;
|
||
int dst_x0 = info->dst.box.x;
|
||
int dst_x1 = info->dst.box.x + info->dst.box.width;
|
||
int dst_y0 = info->dst.box.y;
|
||
int dst_y1 = info->dst.box.y + info->dst.box.height;
|
||
bool mirror_x = false;
|
||
bool mirror_y = false;
|
||
enum blorp_filter filter;
|
||
|
||
if (abs(info->dst.box.width) == abs(info->src.box.width) &&
|
||
abs(info->dst.box.height) == abs(info->src.box.height)) {
|
||
if (src_surf.surf->samples > 1 && dst_surf.surf->samples <= 1) {
|
||
/* The OpenGL ES 3.2 specification, section 16.2.1, says:
|
||
*
|
||
* "If the read framebuffer is multisampled (its effective
|
||
* value of SAMPLE_BUFFERS is one) and the draw framebuffer
|
||
* is not (its value of SAMPLE_BUFFERS is zero), the samples
|
||
* corresponding to each pixel location in the source are
|
||
* converted to a single sample before being written to the
|
||
* destination. The filter parameter is ignored. If the
|
||
* source formats are integer types or stencil values, a
|
||
* single sample’s value is selected for each pixel. If the
|
||
* source formats are floating-point or normalized types,
|
||
* the sample values for each pixel are resolved in an
|
||
* implementation-dependent manner. If the source formats
|
||
* are depth values, sample values are resolved in an
|
||
* implementation-dependent manner where the result will be
|
||
* between the minimum and maximum depth values in the pixel."
|
||
*
|
||
* When selecting a single sample, we always choose sample 0.
|
||
*/
|
||
if (util_format_is_depth_or_stencil(info->src.format) ||
|
||
util_format_is_pure_integer(info->src.format)) {
|
||
filter = BLORP_FILTER_SAMPLE_0;
|
||
} else {
|
||
filter = BLORP_FILTER_AVERAGE;
|
||
}
|
||
} else {
|
||
/* The OpenGL 4.6 specification, section 18.3.1, says:
|
||
*
|
||
* "If the source and destination dimensions are identical,
|
||
* no filtering is applied."
|
||
*
|
||
* Using BLORP_FILTER_NONE will also handle the upsample case by
|
||
* replicating the one value in the source to all values in the
|
||
* destination.
|
||
*/
|
||
filter = BLORP_FILTER_NONE;
|
||
}
|
||
} else if (info->filter == PIPE_TEX_FILTER_LINEAR) {
|
||
filter = BLORP_FILTER_BILINEAR;
|
||
} else {
|
||
filter = BLORP_FILTER_NEAREST;
|
||
}
|
||
|
||
struct iris_batch *batch = &ice->render_batch;
|
||
|
||
struct blorp_batch blorp_batch;
|
||
blorp_batch_init(&ice->blorp, &blorp_batch, batch, 0);
|
||
|
||
for (int slice = 0; slice < info->dst.box.depth; slice++) {
|
||
iris_batch_maybe_flush(batch, 1500);
|
||
|
||
blorp_blit(&blorp_batch,
|
||
&src_surf, info->src.level, info->src.box.z + slice,
|
||
src_isl_format, src_isl_swizzle,
|
||
&dst_surf, info->dst.level, info->dst.box.z + slice,
|
||
dst_isl_format, ISL_SWIZZLE_IDENTITY,
|
||
src_x0, src_y0, src_x1, src_y1,
|
||
dst_x0, dst_y0, dst_x1, dst_y1,
|
||
filter, mirror_x, mirror_y);
|
||
}
|
||
|
||
if (util_format_is_depth_and_stencil(info->dst.format) &&
|
||
util_format_has_stencil(util_format_description(info->src.format))) {
|
||
struct iris_resource *src_res, *dst_res, *junk;
|
||
iris_get_depth_stencil_resources(info->src.resource, &junk, &src_res);
|
||
iris_get_depth_stencil_resources(info->dst.resource, &junk, &dst_res);
|
||
iris_blorp_surf_for_resource(&src_surf, &src_res->base,
|
||
ISL_AUX_USAGE_NONE, false);
|
||
iris_blorp_surf_for_resource(&dst_surf, &dst_res->base,
|
||
ISL_AUX_USAGE_NONE, true);
|
||
|
||
for (int slice = 0; slice < info->dst.box.depth; slice++) {
|
||
iris_batch_maybe_flush(batch, 1500);
|
||
|
||
blorp_blit(&blorp_batch,
|
||
&src_surf, info->src.level, info->src.box.z + slice,
|
||
ISL_FORMAT_R8_UINT, src_isl_swizzle,
|
||
&dst_surf, info->dst.level, info->dst.box.z + slice,
|
||
ISL_FORMAT_R8_UINT, ISL_SWIZZLE_IDENTITY,
|
||
src_x0, src_y0, src_x1, src_y1,
|
||
dst_x0, dst_y0, dst_x1, dst_y1,
|
||
filter, mirror_x, mirror_y);
|
||
}
|
||
}
|
||
|
||
blorp_batch_finish(&blorp_batch);
|
||
}
|
||
|
||
/**
|
||
* The pipe->resource_copy_region() driver hook.
|
||
*
|
||
* This implements ARB_copy_image semantics - a raw memory copy between
|
||
* compatible view classes.
|
||
*/
|
||
static void
|
||
iris_resource_copy_region(struct pipe_context *ctx,
|
||
struct pipe_resource *dst,
|
||
unsigned dst_level,
|
||
unsigned dstx, unsigned dsty, unsigned dstz,
|
||
struct pipe_resource *src,
|
||
unsigned src_level,
|
||
const struct pipe_box *src_box)
|
||
{
|
||
struct iris_context *ice = (void *) ctx;
|
||
struct blorp_surf src_surf, dst_surf;
|
||
iris_blorp_surf_for_resource(&src_surf, src, ISL_AUX_USAGE_NONE, false);
|
||
iris_blorp_surf_for_resource(&dst_surf, dst, ISL_AUX_USAGE_NONE, true);
|
||
|
||
// XXX: ???
|
||
unsigned dst_layer = dstz;
|
||
unsigned src_layer = src_box->z;
|
||
|
||
assert(src_box->depth == 1);
|
||
|
||
struct iris_batch *batch = &ice->render_batch;
|
||
|
||
iris_batch_maybe_flush(batch, 1500);
|
||
|
||
struct blorp_batch blorp_batch;
|
||
blorp_batch_init(&ice->blorp, &blorp_batch, batch, 0);
|
||
blorp_copy(&blorp_batch, &src_surf, src_level, src_layer,
|
||
&dst_surf, dst_level, dst_layer,
|
||
src_box->x, src_box->y, dstx, dsty,
|
||
src_box->width, src_box->height);
|
||
blorp_batch_finish(&blorp_batch);
|
||
}
|
||
|
||
void
|
||
iris_init_blit_functions(struct pipe_context *ctx)
|
||
{
|
||
ctx->blit = iris_blit;
|
||
ctx->resource_copy_region = iris_resource_copy_region;
|
||
}
|