src/gallium/drivers/r300/r300_transfer.c

   1 /*
   2  * Copyright 2008 Corbin Simpson <MostAwesomeDude@gmail.com>
   3  * Copyright 2010 Marek Olšák <maraeo@gmail.com>
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * on the rights to use, copy, modify, merge, publish, distribute, sub
   9  * license, and/or sell copies of the Software, and to permit persons to whom
  10  * the Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  22  * USE OR OTHER DEALINGS IN THE SOFTWARE. */
  23
  24 #include "r300_transfer.h"
  25 #include "r300_texture.h"
  26 #include "r300_screen_buffer.h"
  27
  28 #include "util/u_memory.h"
  29 #include "util/u_format.h"
  30
  31 struct r300_transfer {
  32     /* Parent class */
  33     struct pipe_transfer transfer;
  34
  35     /* Offset from start of buffer. */
  36     unsigned offset;
  37
  38     /* Detiled texture. */
  39     struct r300_texture *detiled_texture;
  40 };
  41
  42 /* Convenience cast wrapper. */
  43 static INLINE struct r300_transfer*
  44 r300_transfer(struct pipe_transfer* transfer)
  45 {
  46     return (struct r300_transfer*)transfer;
  47 }
  48
  49 /* Copy from a tiled texture to a detiled one. */
  50 static void r300_copy_from_tiled_texture(struct pipe_context *ctx,
  51                                          struct r300_transfer *r300transfer)
  52 {
  53     struct pipe_transfer *transfer = (struct pipe_transfer*)r300transfer;
  54     struct pipe_resource *tex = transfer->resource;
  55     struct pipe_subresource subdst;
  56
  57     subdst.face = 0;
  58     subdst.level = 0;
  59
  60     ctx->resource_copy_region(ctx, &r300transfer->detiled_texture->b.b, subdst,
  61                               0, 0, 0,
  62                               tex, transfer->sr,
  63                               transfer->box.x, transfer->box.y, transfer->box.z,
  64                               transfer->box.width, transfer->box.height);
  65 }
  66
  67 /* Copy a detiled texture to a tiled one. */
  68 static void r300_copy_into_tiled_texture(struct pipe_context *ctx,
  69                                          struct r300_transfer *r300transfer)
  70 {
  71     struct pipe_transfer *transfer = (struct pipe_transfer*)r300transfer;
  72     struct pipe_resource *tex = transfer->resource;
  73     struct pipe_subresource subsrc;
  74
  75     subsrc.face = 0;
  76     subsrc.level = 0;
  77
  78     ctx->resource_copy_region(ctx, tex, transfer->sr,
  79                               transfer->box.x, transfer->box.y, transfer->box.z,
  80                               &r300transfer->detiled_texture->b.b, subsrc,
  81                               0, 0, 0,
  82                               transfer->box.width, transfer->box.height);
  83
  84     ctx->flush(ctx, 0, NULL);
  85 }
  86
  87 struct pipe_transfer*
  88 r300_texture_get_transfer(struct pipe_context *ctx,
  89                           struct pipe_resource *texture,
  90                           struct pipe_subresource sr,
  91                           unsigned usage,
  92                           const struct pipe_box *box)
  93 {
  94     struct r300_context *r300 = r300_context(ctx);
  95     struct r300_texture *tex = r300_texture(texture);
  96     struct r300_screen *r300screen = r300_screen(ctx->screen);
  97     struct r300_transfer *trans;
  98     struct pipe_resource base;
  99     boolean referenced_cs, referenced_hw, blittable;
 100
 101     referenced_cs =
 102         r300->rws->cs_is_buffer_referenced(r300->cs,
 103                                            tex->buffer, R300_REF_CS);
 104     if (referenced_cs) {
 105         referenced_hw = TRUE;
 106     } else {
 107         referenced_hw =
 108             r300->rws->cs_is_buffer_referenced(r300->cs,
 109                                                tex->buffer, R300_REF_HW);
 110     }
 111
 112     blittable = ctx->screen->is_format_supported(
 113             ctx->screen, texture->format, texture->target, 0,
 114             PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET, 0);
 115
 116     trans = CALLOC_STRUCT(r300_transfer);
 117     if (trans) {
 118         /* Initialize the transfer object. */
 119         pipe_resource_reference(&trans->transfer.resource, texture);
 120         trans->transfer.sr = sr;
 121         trans->transfer.usage = usage;
 122         trans->transfer.box = *box;
 123
 124         /* If the texture is tiled, we must create a temporary detiled texture
 125          * for this transfer.
 126          * Also make write transfers pipelined. */
 127         if (tex->microtile || tex->macrotile ||
 128             ((referenced_hw & !(usage & PIPE_TRANSFER_READ)) && blittable)) {
 129             base.target = PIPE_TEXTURE_2D;
 130             base.format = texture->format;
 131             base.width0 = box->width;
 132             base.height0 = box->height;
 133             base.depth0 = 0;
 134             base.last_level = 0;
 135             base.nr_samples = 0;
 136             base.usage = PIPE_USAGE_DYNAMIC;
 137             base.bind = 0;
 138             base.flags = R300_RESOURCE_FLAG_TRANSFER;
 139
 140             /* For texture reading, the temporary (detiled) texture is used as
 141              * a render target when blitting from a tiled texture. */
 142             if (usage & PIPE_TRANSFER_READ) {
 143                 base.bind |= PIPE_BIND_RENDER_TARGET;
 144             }
 145             /* For texture writing, the temporary texture is used as a sampler
 146              * when blitting into a tiled texture. */
 147             if (usage & PIPE_TRANSFER_WRITE) {
 148                 base.bind |= PIPE_BIND_SAMPLER_VIEW;
 149             }
 150
 151             /* Create the temporary texture. */
 152             trans->detiled_texture = r300_texture(
 153                ctx->screen->resource_create(ctx->screen,
 154                                             &base));
 155
 156             if (!trans->detiled_texture) {
 157                 /* Oh crap, the thing can't create the texture.
 158                  * Let's flush and try again. */
 159                 ctx->flush(ctx, 0, NULL);
 160
 161                 trans->detiled_texture = r300_texture(
 162                    ctx->screen->resource_create(ctx->screen,
 163                                                 &base));
 164
 165                 if (!trans->detiled_texture) {
 166                     /* For linear textures, it's safe to fallback to
 167                      * an unpipelined transfer. */
 168                     if (!tex->microtile && !tex->macrotile) {
 169                         goto unpipelined;
 170                     }
 171
 172                     /* Otherwise, go to hell. */
 173                     fprintf(stderr,
 174                         "r300: Failed to create a transfer object, praise.\n");
 175                     FREE(trans);
 176                     return NULL;
 177                 }
 178             }
 179
 180             assert(!trans->detiled_texture->microtile &&
 181                    !trans->detiled_texture->macrotile);
 182
 183             /* Set the stride.
 184              *
 185              * Even though we are using an internal texture for this,
 186              * the transfer sr, box and usage parameters still reflect
 187              * the arguments received to get_transfer.  We just do the
 188              * right thing internally.
 189              */
 190             trans->transfer.stride =
 191                 r300_texture_get_stride(r300screen, trans->detiled_texture, 0);
 192
 193             if (usage & PIPE_TRANSFER_READ) {
 194                 /* We cannot map a tiled texture directly because the data is
 195                  * in a different order, therefore we do detiling using a blit. */
 196                 r300_copy_from_tiled_texture(ctx, trans);
 197
 198                 /* Always referenced in the blit. */
 199                 ctx->flush(ctx, 0, NULL);
 200             }
 201             return &trans->transfer;
 202         }
 203
 204     unpipelined:
 205         /* Unpipelined transfer. */
 206         trans->transfer.stride =
 207                 r300_texture_get_stride(r300screen, tex, sr.level);
 208         trans->offset = r300_texture_get_offset(tex, sr.level, box->z, sr.face);
 209
 210         if (referenced_cs)
 211             ctx->flush(ctx, PIPE_FLUSH_RENDER_CACHE, NULL);
 212         return &trans->transfer;
 213     }
 214     return NULL;
 215 }
 216
 217 void r300_texture_transfer_destroy(struct pipe_context *ctx,
 218                                    struct pipe_transfer *trans)
 219 {
 220     struct r300_transfer *r300transfer = r300_transfer(trans);
 221
 222     if (r300transfer->detiled_texture) {
 223         if (trans->usage & PIPE_TRANSFER_WRITE) {
 224             r300_copy_into_tiled_texture(ctx, r300transfer);
 225         }
 226
 227         pipe_resource_reference(
 228             (struct pipe_resource**)&r300transfer->detiled_texture, NULL);
 229     }
 230     pipe_resource_reference(&trans->resource, NULL);
 231     FREE(trans);
 232 }
 233
 234 void* r300_texture_transfer_map(struct pipe_context *ctx,
 235                                 struct pipe_transfer *transfer)
 236 {
 237     struct r300_context *r300 = r300_context(ctx);
 238     struct r300_winsys_screen *rws = (struct r300_winsys_screen *)ctx->winsys;
 239     struct r300_transfer *r300transfer = r300_transfer(transfer);
 240     struct r300_texture *tex = r300_texture(transfer->resource);
 241     char *map;
 242     enum pipe_format format = tex->b.b.format;
 243
 244     if (r300transfer->detiled_texture) {
 245         /* The detiled texture is of the same size as the region being mapped
 246          * (no offset needed). */
 247         return rws->buffer_map(rws,
 248                                r300transfer->detiled_texture->buffer,
 249                                r300->cs,
 250                                transfer->usage);
 251     } else {
 252         /* Tiling is disabled. */
 253         map = rws->buffer_map(rws, tex->buffer, r300->cs,
 254                               transfer->usage);
 255
 256         if (!map) {
 257             return NULL;
 258         }
 259
 260         return map + r300_transfer(transfer)->offset +
 261             transfer->box.y / util_format_get_blockheight(format) * transfer->stride +
 262             transfer->box.x / util_format_get_blockwidth(format) * util_format_get_blocksize(format);
 263     }
 264 }
 265
 266 void r300_texture_transfer_unmap(struct pipe_context *ctx,
 267                                  struct pipe_transfer *transfer)
 268 {
 269     struct r300_winsys_screen *rws = (struct r300_winsys_screen *)ctx->winsys;
 270     struct r300_transfer *r300transfer = r300_transfer(transfer);
 271     struct r300_texture *tex = r300_texture(transfer->resource);
 272
 273     if (r300transfer->detiled_texture) {
 274         rws->buffer_unmap(rws, r300transfer->detiled_texture->buffer);
 275     } else {
 276         rws->buffer_unmap(rws, tex->buffer);
 277     }
 278 }