From e94eb5e6000e293d73452b76a95754a3734f5065 Mon Sep 17 00:00:00 2001 From: Rob Clark Date: Tue, 28 Nov 2017 10:47:06 -0500 Subject: gallium/util: add u_transfer_helper Add a new helper that drivers can use to emulate various things that need special handling in particular in transfer_map: 1) z32_s8x24.. gl/gallium treats this as a single buffer with depth and stencil interleaved but hardware frequently treats this as separate z32 and s8 buffers. Special pack/unpack handling is needed in transfer_map/unmap to pack/unpack the exposed buffer 2) fake RGTC.. GPUs designed with GLES in mind, but which can other- wise do GL3, if native RGTC is not supported it can be emulated by converting to uncompressed internally, but needs pack/unpack in transfer_map/unmap 3) MSAA resolves in the transfer_map() case v2: add MSAA resolve based on Eric's "gallium: Add helpers for MSAA resolves in pipe_transfer_map()/unmap()." patch; avoid wrapping pipe_resource, to make it possible for drivers to use both this and threaded_context. Signed-off-by: Rob Clark --- src/gallium/auxiliary/util/u_transfer_helper.c | 503 +++++++++++++++++++++++++ src/gallium/auxiliary/util/u_transfer_helper.h | 135 +++++++ 2 files changed, 638 insertions(+) create mode 100644 src/gallium/auxiliary/util/u_transfer_helper.c create mode 100644 src/gallium/auxiliary/util/u_transfer_helper.h (limited to 'src/gallium/auxiliary/util') diff --git a/src/gallium/auxiliary/util/u_transfer_helper.c b/src/gallium/auxiliary/util/u_transfer_helper.c new file mode 100644 index 00000000000..dd31049920f --- /dev/null +++ b/src/gallium/auxiliary/util/u_transfer_helper.c @@ -0,0 +1,503 @@ +/* + * Copyright © 2017 Red Hat + * + * 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 (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 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 "pipe/p_screen.h" + +#include "util/u_box.h" +#include "util/u_format.h" +#include "util/u_format_rgtc.h" +#include "util/u_format_zs.h" +#include "util/u_inlines.h" +#include "util/u_transfer_helper.h" + + +struct u_transfer_helper { + const struct u_transfer_vtbl *vtbl; + bool separate_z32s8; + bool fake_rgtc; + bool msaa_map; +}; + +static inline bool handle_transfer(struct pipe_resource *prsc) +{ + struct u_transfer_helper *helper = prsc->screen->transfer_helper; + + if (helper->vtbl->get_internal_format) { + enum pipe_format internal_format = + helper->vtbl->get_internal_format(prsc); + if (internal_format != prsc->format) + return true; + } + + if (helper->msaa_map && (prsc->nr_samples > 1)) + return true; + + return false; +} + +/* The pipe_transfer ptr could either be the driver's, or u_transfer, + * depending on whether we are intervening or not. Check handle_transfer() + * before dereferencing. + */ +struct u_transfer { + struct pipe_transfer base; + /* Note that in case of MSAA resolve for transfer plus z32s8 or fake rgtc + * we end up with stacked u_transfer's. The MSAA resolve case doesn't call + * helper->vtbl fxns directly, but calls back to pctx->transfer_map()/etc + * so the format related handling can work in conjunction with MSAA resolve. + */ + struct pipe_transfer *trans; /* driver's transfer */ + struct pipe_transfer *trans2; /* 2nd transfer for s8 stencil buffer in z32s8 */ + void *ptr, *ptr2; /* ptr to trans, and trans2 */ + void *staging; /* staging buffer */ + struct pipe_resource *ss; /* staging resource for MSAA resolves */ +}; + +static inline struct u_transfer * +u_transfer(struct pipe_transfer *ptrans) +{ + debug_assert(handle_transfer(ptrans->resource)); + return (struct u_transfer *)ptrans; +} + +struct pipe_resource * +u_transfer_helper_resource_create(struct pipe_screen *pscreen, + const struct pipe_resource *templ) +{ + struct u_transfer_helper *helper = pscreen->transfer_helper; + enum pipe_format format = templ->format; + struct pipe_resource *prsc; + + if ((format == PIPE_FORMAT_Z32_FLOAT_S8X24_UINT) && helper->separate_z32s8) { + struct pipe_resource t = *templ; + struct pipe_resource *stencil; + + t.format = PIPE_FORMAT_Z32_FLOAT; + + prsc = helper->vtbl->resource_create(pscreen, &t); + if (!prsc) + return NULL; + + prsc->format = format; /* frob the format back to the "external" format */ + + t.format = PIPE_FORMAT_S8_UINT; + stencil = helper->vtbl->resource_create(pscreen, &t); + + if (!stencil) { + helper->vtbl->resource_destroy(pscreen, prsc); + return NULL; + } + + helper->vtbl->set_stencil(prsc, stencil); + } else if ((util_format_description(format)->layout == UTIL_FORMAT_LAYOUT_RGTC) && + helper->fake_rgtc) { + struct pipe_resource t = *templ; + t.format = PIPE_FORMAT_R8G8B8A8_UNORM; + + prsc = helper->vtbl->resource_create(pscreen, &t); + if (!prsc) + return NULL; + + prsc->format = format; /* frob the format back to the "external" format */ + } else { + /* normal case, no special handling: */ + prsc = helper->vtbl->resource_create(pscreen, templ); + if (!prsc) + return NULL; + } + + return prsc; +} + +void +u_transfer_helper_resource_destroy(struct pipe_screen *pscreen, + struct pipe_resource *prsc) +{ + struct u_transfer_helper *helper = pscreen->transfer_helper; + + if (helper->vtbl->get_stencil) { + struct pipe_resource *stencil = helper->vtbl->get_stencil(prsc); + + if (stencil) + helper->vtbl->resource_destroy(pscreen, stencil); + } + + helper->vtbl->resource_destroy(pscreen, prsc); +} + +static bool needs_pack(unsigned usage) +{ + return (usage & PIPE_TRANSFER_READ) && + !(usage & (PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE | PIPE_TRANSFER_DISCARD_RANGE)); +} + +/* In the case of transfer_map of a multi-sample resource, call back into + * pctx->transfer_map() to map the staging resource, to handle cases of + * MSAA + separate_z32s8 or fake_rgtc + */ +static void * +transfer_map_msaa(struct pipe_context *pctx, + struct pipe_resource *prsc, + unsigned level, unsigned usage, + const struct pipe_box *box, + struct pipe_transfer **pptrans) +{ + struct pipe_screen *pscreen = pctx->screen; + struct u_transfer *trans = calloc(1, sizeof(*trans)); + if (!trans) + return NULL; + struct pipe_transfer *ptrans = &trans->base; + + pipe_resource_reference(&ptrans->resource, prsc); + ptrans->level = level; + ptrans->usage = usage; + ptrans->box = *box; + + struct pipe_resource tmpl = { + .target = prsc->target, + .format = prsc->format, + .width0 = box->width, + .height0 = box->height, + .depth0 = 1, + .array_size = 1, + }; + trans->ss = pscreen->resource_create(pscreen, &tmpl); + if (!trans->ss) { + free(trans); + return NULL; + } + + if (needs_pack(usage)) { + struct pipe_blit_info blit; + memset(&blit, 0, sizeof(blit)); + + blit.src.resource = ptrans->resource; + blit.src.format = ptrans->resource->format; + blit.src.level = ptrans->level; + blit.src.box = *box; + + blit.dst.resource = trans->ss; + blit.dst.format = trans->ss->format; + blit.dst.box.width = box->width; + blit.dst.box.height = box->height; + blit.dst.box.depth = 1; + + blit.mask = util_format_get_mask(prsc->format); + blit.filter = PIPE_TEX_FILTER_NEAREST; + + pctx->blit(pctx, &blit); + } + + void *ss_map = pctx->transfer_map(pctx, trans->ss, 0, usage, box, + &trans->trans); + if (!ss_map) { + free(trans); + return NULL; + } + + *pptrans = ptrans; + return ss_map; +} + +void * +u_transfer_helper_transfer_map(struct pipe_context *pctx, + struct pipe_resource *prsc, + unsigned level, unsigned usage, + const struct pipe_box *box, + struct pipe_transfer **pptrans) +{ + struct u_transfer_helper *helper = pctx->screen->transfer_helper; + struct u_transfer *trans; + struct pipe_transfer *ptrans; + enum pipe_format format = prsc->format; + unsigned width = box->width; + unsigned height = box->height; + + if (!handle_transfer(prsc)) + return helper->vtbl->transfer_map(pctx, prsc, level, usage, box, pptrans); + + if (helper->msaa_map && (prsc->nr_samples > 1)) + return transfer_map_msaa(pctx, prsc, level, usage, box, pptrans); + + debug_assert(box->depth == 1); + + trans = calloc(1, sizeof(*trans)); + if (!trans) + return NULL; + + ptrans = &trans->base; + pipe_resource_reference(&ptrans->resource, prsc); + ptrans->level = level; + ptrans->usage = usage; + ptrans->box = *box; + ptrans->stride = util_format_get_stride(format, box->width); + ptrans->layer_stride = ptrans->stride * box->height; + + trans->staging = malloc(ptrans->layer_stride); + if (!trans->staging) + goto fail; + + trans->ptr = helper->vtbl->transfer_map(pctx, prsc, level, usage, box, + &trans->trans); + if (!trans->ptr) + goto fail; + + if (prsc->format == PIPE_FORMAT_Z32_FLOAT_S8X24_UINT) { + struct pipe_resource *stencil = helper->vtbl->get_stencil(prsc); + trans->ptr2 = helper->vtbl->transfer_map(pctx, stencil, level, + usage, box, &trans->trans2); + + if (needs_pack(usage)) { + util_format_z32_float_s8x24_uint_pack_z_float(trans->staging, + ptrans->stride, + trans->ptr, + trans->trans->stride, + width, height); + util_format_z32_float_s8x24_uint_pack_s_8uint(trans->staging, + ptrans->stride, + trans->ptr2, + trans->trans2->stride, + width, height); + } + } else if (needs_pack(usage) && + util_format_description(prsc->format)->layout == UTIL_FORMAT_LAYOUT_RGTC) { + switch (prsc->format) { + case PIPE_FORMAT_RGTC1_UNORM: + case PIPE_FORMAT_RGTC1_SNORM: + case PIPE_FORMAT_LATC1_UNORM: + case PIPE_FORMAT_LATC1_SNORM: + util_format_rgtc1_unorm_pack_rgba_8unorm(trans->staging, + ptrans->stride, + trans->ptr, + trans->trans->stride, + width, height); + break; + case PIPE_FORMAT_RGTC2_UNORM: + case PIPE_FORMAT_RGTC2_SNORM: + case PIPE_FORMAT_LATC2_UNORM: + case PIPE_FORMAT_LATC2_SNORM: + util_format_rgtc2_unorm_pack_rgba_8unorm(trans->staging, + ptrans->stride, + trans->ptr, + trans->trans->stride, + width, height); + break; + default: + assert(!"Unexpected format"); + break; + } + } else { + unreachable("bleh"); + } + + *pptrans = ptrans; + return trans->staging; + +fail: + if (trans->trans) + helper->vtbl->transfer_unmap(pctx, trans->trans); + if (trans->trans2) + helper->vtbl->transfer_unmap(pctx, trans->trans2); + pipe_resource_reference(&ptrans->resource, NULL); + free(trans->staging); + free(trans); + return NULL; +} + +static void +flush_region(struct pipe_context *pctx, struct pipe_transfer *ptrans, + const struct pipe_box *box) +{ + struct u_transfer_helper *helper = pctx->screen->transfer_helper; + struct u_transfer *trans = u_transfer(ptrans); + enum pipe_format iformat, format = ptrans->resource->format; + unsigned width = box->width; + unsigned height = box->height; + void *src, *dst; + + if (!(ptrans->usage & PIPE_TRANSFER_WRITE)) + return; + + if (trans->ss) { + struct pipe_blit_info blit; + memset(&blit, 0, sizeof(blit)); + + blit.src.resource = trans->ss; + blit.src.format = trans->ss->format; + blit.src.box = *box; + + blit.dst.resource = ptrans->resource; + blit.dst.format = ptrans->resource->format; + blit.dst.level = ptrans->level; + + u_box_2d(ptrans->box.x + box->x, + ptrans->box.y + box->y, + box->width, box->height, + &blit.dst.box); + + blit.mask = util_format_get_mask(ptrans->resource->format); + blit.filter = PIPE_TEX_FILTER_NEAREST; + + pctx->blit(pctx, &blit); + + return; + } + + iformat = helper->vtbl->get_internal_format(ptrans->resource); + + src = (uint8_t *)trans->staging + + (box->y * ptrans->stride) + + (box->x * util_format_get_blocksize(format)); + dst = (uint8_t *)trans->ptr + + (box->y * trans->trans->stride) + + (box->x * util_format_get_blocksize(iformat)); + + switch (format) { + case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT: + util_format_z32_float_s8x24_uint_unpack_z_float(dst, + trans->trans->stride, + src, + ptrans->stride, + width, height); + /* fallthru */ + case PIPE_FORMAT_X32_S8X24_UINT: + dst = (uint8_t *)trans->ptr2 + + (box->y * trans->trans2->stride) + + (box->x * util_format_get_blocksize(PIPE_FORMAT_S8_UINT)); + + util_format_z32_float_s8x24_uint_unpack_s_8uint(dst, + trans->trans2->stride, + src, + ptrans->stride, + width, height); + break; + case PIPE_FORMAT_RGTC1_UNORM: + case PIPE_FORMAT_RGTC1_SNORM: + case PIPE_FORMAT_LATC1_UNORM: + case PIPE_FORMAT_LATC1_SNORM: + util_format_rgtc1_unorm_unpack_rgba_8unorm(dst, + trans->trans->stride, + src, + ptrans->stride, + width, height); + break; + case PIPE_FORMAT_RGTC2_UNORM: + case PIPE_FORMAT_RGTC2_SNORM: + case PIPE_FORMAT_LATC2_UNORM: + case PIPE_FORMAT_LATC2_SNORM: + util_format_rgtc2_unorm_unpack_rgba_8unorm(dst, + trans->trans->stride, + src, + ptrans->stride, + width, height); + break; + default: + assert(!"Unexpected staging transfer type"); + break; + } +} + +void +u_transfer_helper_transfer_flush_region(struct pipe_context *pctx, + struct pipe_transfer *ptrans, + const struct pipe_box *box) +{ + struct u_transfer_helper *helper = pctx->screen->transfer_helper; + + if (handle_transfer(ptrans->resource)) { + struct u_transfer *trans = u_transfer(ptrans); + + flush_region(pctx, ptrans, box); + + /* handle MSAA case, since there could be multiple levels of + * wrapped transfer, call pctx->transfer_flush_region() + * instead of helper->vtbl->transfer_flush_region() + */ + if (trans->ss) { + pctx->transfer_flush_region(pctx, trans->trans, box); + return; + } + + helper->vtbl->transfer_flush_region(pctx, trans->trans, box); + if (trans->trans2) + helper->vtbl->transfer_flush_region(pctx, trans->trans2, box); + + } else { + helper->vtbl->transfer_flush_region(pctx, ptrans, box); + } +} + +void +u_transfer_helper_transfer_unmap(struct pipe_context *pctx, + struct pipe_transfer *ptrans) +{ + struct u_transfer_helper *helper = pctx->screen->transfer_helper; + + if (handle_transfer(ptrans->resource)) { + struct u_transfer *trans = u_transfer(ptrans); + + if (!(ptrans->usage & PIPE_TRANSFER_FLUSH_EXPLICIT)) { + struct pipe_box box; + u_box_2d(0, 0, ptrans->box.width, ptrans->box.height, &box); + flush_region(pctx, ptrans, &box); + } + + /* in MSAA case, there could be multiple levels of wrapping + * so don't call helper->vtbl->transfer_unmap() directly + */ + if (trans->ss) { + pctx->transfer_unmap(pctx, trans->trans); + pipe_resource_reference(&trans->ss, NULL); + } else { + helper->vtbl->transfer_unmap(pctx, trans->trans); + if (trans->trans2) + helper->vtbl->transfer_unmap(pctx, trans->trans2); + } + + free(trans); + } else { + helper->vtbl->transfer_unmap(pctx, ptrans); + } +} + +struct u_transfer_helper * +u_transfer_helper_create(const struct u_transfer_vtbl *vtbl, + bool separate_z32s8, + bool fake_rgtc, + bool msaa_map) +{ + struct u_transfer_helper *helper = calloc(1, sizeof(*helper)); + + helper->vtbl = vtbl; + helper->separate_z32s8 = separate_z32s8; + helper->fake_rgtc = fake_rgtc; + helper->msaa_map = msaa_map; + + return helper; +} + +void +u_transfer_helper_destroy(struct u_transfer_helper *helper) +{ + free(helper); +} diff --git a/src/gallium/auxiliary/util/u_transfer_helper.h b/src/gallium/auxiliary/util/u_transfer_helper.h new file mode 100644 index 00000000000..b13a1ec06c1 --- /dev/null +++ b/src/gallium/auxiliary/util/u_transfer_helper.h @@ -0,0 +1,135 @@ +/* + * Copyright © 2017 Red Hat + * + * 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 (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 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. + */ + +#ifndef _U_TRANSFER_HELPER_H +#define _U_TRANSFER_HELPER_H + +#include "pipe/p_state.h" +#include "pipe/p_context.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* A helper to implement various "lowering" for transfers: + * + * - exposing separate z32 and s8 as z32x24s8 + * - fake RGTC support for GLES class hardware which needs it to expose GL3+ + * - MSAA resolves + * + * To use this, drivers should: + * + * 1) populate u_transfer_vtbl and plug that into pipe_screen::transfer_helper + * 2) plug the transfer helpers into pipe_screen/pipe_context + * + * To avoid subclassing pipe_resource (and conflicting with threaded_context) + * the vtbl contains setter/getter methods used for fake_rgct & separate_stencil + * to access the internal_format and separate stencil buffer. + */ + +struct u_transfer_vtbl { + /* NOTE I am not expecting resource_create_from_handle() or + * resource_create_with_modifiers() paths to be creating any + * resources that need special handling. Otherwise they would + * need to be wrapped too. + */ + struct pipe_resource * (*resource_create)(struct pipe_screen *pscreen, + const struct pipe_resource *templ); + + void (*resource_destroy)(struct pipe_screen *pscreen, + struct pipe_resource *prsc); + + void *(*transfer_map)(struct pipe_context *pctx, + struct pipe_resource *prsc, + unsigned level, + unsigned usage, + const struct pipe_box *box, + struct pipe_transfer **pptrans); + + + void (*transfer_flush_region)(struct pipe_context *pctx, + struct pipe_transfer *ptrans, + const struct pipe_box *box); + + void (*transfer_unmap)(struct pipe_context *pctx, + struct pipe_transfer *ptrans); + + /* + * auxiliary methods to access internal format, stencil: + */ + + /** + * Must be implemented if separate_z32s8 or fake_rgtc is used. The + * internal_format is the format the resource was created with. In + * the case of separate_z32s8 or fake_rgtc, prsc->format is set back + * to the state tracker visible format (Z32_FLOAT_S8X24_UINT or + * PIPE_FORMAT_{RTGC,LATC}* after the resource is created. + */ + enum pipe_format (*get_internal_format)(struct pipe_resource *prsc); + + /** + * Must be implemented if separate_z32s8 is used. Used to set/get + * the separate s8 stencil buffer. + * + * These two do not get/put references to the pipe_resource. The + * stencil resource will be destroyed by u_transfer_helper_resource_destroy(). + */ + void (*set_stencil)(struct pipe_resource *prsc, struct pipe_resource *stencil); + struct pipe_resource *(*get_stencil)(struct pipe_resource *prsc); +}; + +struct pipe_resource *u_transfer_helper_resource_create( + struct pipe_screen *pscreen, const struct pipe_resource *templ); + +void u_transfer_helper_resource_destroy(struct pipe_screen *pscreen, + struct pipe_resource *prsc); + +void *u_transfer_helper_transfer_map(struct pipe_context *pctx, + struct pipe_resource *prsc, + unsigned level, + unsigned usage, + const struct pipe_box *box, + struct pipe_transfer **pptrans); + + +void u_transfer_helper_transfer_flush_region(struct pipe_context *pctx, + struct pipe_transfer *ptrans, + const struct pipe_box *box); + +void u_transfer_helper_transfer_unmap(struct pipe_context *pctx, + struct pipe_transfer *ptrans); + +struct u_transfer_helper; + +struct u_transfer_helper * u_transfer_helper_create(const struct u_transfer_vtbl *vtbl, + bool separate_z32s8, + bool fake_rgtc, + bool msaa_map); + +void u_transfer_helper_destroy(struct u_transfer_helper *helper); + +#ifdef __cplusplus +} // extern "C" { +#endif + +#endif /* _U_TRANSFER_HELPER_H */ -- cgit v1.2.3