src/gallium/drivers/softpipe/sp_texture.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2006 VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27  /*
  28   * Authors:
  29   *   Keith Whitwell <keithw@vmware.com>
  30   *   Michel Dänzer <daenzer@vmware.com>
  31   */
  32
  33 #include "pipe/p_defines.h"
  34 #include "util/u_inlines.h"
  35
  36 #include "util/u_format.h"
  37 #include "util/u_math.h"
  38 #include "util/u_memory.h"
  39 #include "util/u_transfer.h"
  40
  41 #include "sp_context.h"
  42 #include "sp_flush.h"
  43 #include "sp_texture.h"
  44 #include "sp_screen.h"
  45
  46 #include "state_tracker/sw_winsys.h"
  47
  48
  49 /**
  50  * Conventional allocation path for non-display textures:
  51  * Use a simple, maximally packed layout.
  52  */
  53 static boolean
  54 softpipe_resource_layout(struct pipe_screen *screen,
  55                          struct softpipe_resource *spr,
  56                          boolean allocate)
  57 {
  58    struct pipe_resource *pt = &spr->base;
  59    unsigned level;
  60    unsigned width = pt->width0;
  61    unsigned height = pt->height0;
  62    unsigned depth = pt->depth0;
  63    uint64_t buffer_size = 0;
  64
  65    for (level = 0; level <= pt->last_level; level++) {
  66       unsigned slices, nblocksy;
  67
  68       nblocksy = util_format_get_nblocksy(pt->format, height);
  69
  70       if (pt->target == PIPE_TEXTURE_CUBE)
  71          assert(pt->array_size == 6);
  72
  73       if (pt->target == PIPE_TEXTURE_3D)
  74          slices = depth;
  75       else
  76          slices = pt->array_size;
  77
  78       spr->stride[level] = util_format_get_stride(pt->format, width);
  79
  80       spr->level_offset[level] = buffer_size;
  81
  82       /* if row_stride * height > SP_MAX_TEXTURE_SIZE */
  83       if ((uint64_t)spr->stride[level] * nblocksy > SP_MAX_TEXTURE_SIZE) {
  84          /* image too large */
  85          return FALSE;
  86       }
  87
  88       spr->img_stride[level] = spr->stride[level] * nblocksy;
  89
  90       buffer_size += (uint64_t) spr->img_stride[level] * slices;
  91
  92       width  = u_minify(width, 1);
  93       height = u_minify(height, 1);
  94       depth = u_minify(depth, 1);
  95    }
  96
  97    if (buffer_size > SP_MAX_TEXTURE_SIZE)
  98       return FALSE;
  99
 100    if (allocate) {
 101       spr->data = align_malloc(buffer_size, 64);
 102       return spr->data != NULL;
 103    }
 104    else {
 105       return TRUE;
 106    }
 107 }
 108
 109
 110 /**
 111  * Check the size of the texture specified by 'res'.
 112  * \return TRUE if OK, FALSE if too large.
 113  */
 114 static boolean
 115 softpipe_can_create_resource(struct pipe_screen *screen,
 116                              const struct pipe_resource *res)
 117 {
 118    struct softpipe_resource spr;
 119    memset(&spr, 0, sizeof(spr));
 120    spr.base = *res;
 121    return softpipe_resource_layout(screen, &spr, FALSE);
 122 }
 123
 124
 125 /**
 126  * Texture layout for simple color buffers.
 127  */
 128 static boolean
 129 softpipe_displaytarget_layout(struct pipe_screen *screen,
 130                               struct softpipe_resource *spr,
 131                               const void *map_front_private)
 132 {
 133    struct sw_winsys *winsys = softpipe_screen(screen)->winsys;
 134
 135    /* Round up the surface size to a multiple of the tile size?
 136     */
 137    spr->dt = winsys->displaytarget_create(winsys,
 138                                           spr->base.bind,
 139                                           spr->base.format,
 140                                           spr->base.width0,
 141                                           spr->base.height0,
 142                                           64,
 143                                           map_front_private,
 144                                           &spr->stride[0] );
 145
 146    return spr->dt != NULL;
 147 }
 148
 149
 150 /**
 151  * Create new pipe_resource given the template information.
 152  */
 153 static struct pipe_resource *
 154 softpipe_resource_create_front(struct pipe_screen *screen,
 155                                const struct pipe_resource *templat,
 156                                const void *map_front_private)
 157 {
 158    struct softpipe_resource *spr = CALLOC_STRUCT(softpipe_resource);
 159    if (!spr)
 160       return NULL;
 161
 162    assert(templat->format != PIPE_FORMAT_NONE);
 163
 164    spr->base = *templat;
 165    pipe_reference_init(&spr->base.reference, 1);
 166    spr->base.screen = screen;
 167
 168    spr->pot = (util_is_power_of_two(templat->width0) &&
 169                util_is_power_of_two(templat->height0) &&
 170                util_is_power_of_two(templat->depth0));
 171
 172    if (spr->base.bind & (PIPE_BIND_DISPLAY_TARGET |
 173                          PIPE_BIND_SCANOUT |
 174                          PIPE_BIND_SHARED)) {
 175       if (!softpipe_displaytarget_layout(screen, spr, map_front_private))
 176          goto fail;
 177    }
 178    else {
 179       if (!softpipe_resource_layout(screen, spr, TRUE))
 180          goto fail;
 181    }
 182
 183    return &spr->base;
 184
 185  fail:
 186    FREE(spr);
 187    return NULL;
 188 }
 189
 190 static struct pipe_resource *
 191 softpipe_resource_create(struct pipe_screen *screen,
 192                          const struct pipe_resource *templat)
 193 {
 194    return softpipe_resource_create_front(screen, templat, NULL);
 195 }
 196
 197 static void
 198 softpipe_resource_destroy(struct pipe_screen *pscreen,
 199                           struct pipe_resource *pt)
 200 {
 201    struct softpipe_screen *screen = softpipe_screen(pscreen);
 202    struct softpipe_resource *spr = softpipe_resource(pt);
 203
 204    if (spr->dt) {
 205       /* display target */
 206       struct sw_winsys *winsys = screen->winsys;
 207       winsys->displaytarget_destroy(winsys, spr->dt);
 208    }
 209    else if (!spr->userBuffer) {
 210       /* regular texture */
 211       align_free(spr->data);
 212    }
 213
 214    FREE(spr);
 215 }
 216
 217
 218 static struct pipe_resource *
 219 softpipe_resource_from_handle(struct pipe_screen *screen,
 220                               const struct pipe_resource *templat,
 221                               struct winsys_handle *whandle,
 222                               unsigned usage)
 223 {
 224    struct sw_winsys *winsys = softpipe_screen(screen)->winsys;
 225    struct softpipe_resource *spr = CALLOC_STRUCT(softpipe_resource);
 226    if (!spr)
 227       return NULL;
 228
 229    spr->base = *templat;
 230    pipe_reference_init(&spr->base.reference, 1);
 231    spr->base.screen = screen;
 232
 233    spr->pot = (util_is_power_of_two(templat->width0) &&
 234                util_is_power_of_two(templat->height0) &&
 235                util_is_power_of_two(templat->depth0));
 236
 237    spr->dt = winsys->displaytarget_from_handle(winsys,
 238                                                templat,
 239                                                whandle,
 240                                                &spr->stride[0]);
 241    if (!spr->dt)
 242       goto fail;
 243
 244    return &spr->base;
 245
 246  fail:
 247    FREE(spr);
 248    return NULL;
 249 }
 250
 251
 252 static boolean
 253 softpipe_resource_get_handle(struct pipe_screen *screen,
 254                              struct pipe_resource *pt,
 255                              struct winsys_handle *whandle,
 256                              unsigned usage)
 257 {
 258    struct sw_winsys *winsys = softpipe_screen(screen)->winsys;
 259    struct softpipe_resource *spr = softpipe_resource(pt);
 260
 261    assert(spr->dt);
 262    if (!spr->dt)
 263       return FALSE;
 264
 265    return winsys->displaytarget_get_handle(winsys, spr->dt, whandle);
 266 }
 267
 268
 269 /**
 270  * Helper function to compute offset (in bytes) for a particular
 271  * texture level/face/slice from the start of the buffer.
 272  */
 273 static unsigned
 274 sp_get_tex_image_offset(const struct softpipe_resource *spr,
 275                         unsigned level, unsigned layer)
 276 {
 277    unsigned offset = spr->level_offset[level];
 278
 279    offset += layer * spr->img_stride[level];
 280
 281    return offset;
 282 }
 283
 284
 285 /**
 286  * Get a pipe_surface "view" into a texture resource.
 287  */
 288 static struct pipe_surface *
 289 softpipe_create_surface(struct pipe_context *pipe,
 290                         struct pipe_resource *pt,
 291                         const struct pipe_surface *surf_tmpl)
 292 {
 293    struct pipe_surface *ps;
 294
 295    ps = CALLOC_STRUCT(pipe_surface);
 296    if (ps) {
 297       pipe_reference_init(&ps->reference, 1);
 298       pipe_resource_reference(&ps->texture, pt);
 299       ps->context = pipe;
 300       ps->format = surf_tmpl->format;
 301       if (pt->target != PIPE_BUFFER) {
 302          assert(surf_tmpl->u.tex.level <= pt->last_level);
 303          ps->width = u_minify(pt->width0, surf_tmpl->u.tex.level);
 304          ps->height = u_minify(pt->height0, surf_tmpl->u.tex.level);
 305          ps->u.tex.level = surf_tmpl->u.tex.level;
 306          ps->u.tex.first_layer = surf_tmpl->u.tex.first_layer;
 307          ps->u.tex.last_layer = surf_tmpl->u.tex.last_layer;
 308          if (ps->u.tex.first_layer != ps->u.tex.last_layer) {
 309             debug_printf("creating surface with multiple layers, rendering to first layer only\n");
 310          }
 311       }
 312       else {
 313          /* setting width as number of elements should get us correct renderbuffer width */
 314          ps->width = surf_tmpl->u.buf.last_element - surf_tmpl->u.buf.first_element + 1;
 315          ps->height = pt->height0;
 316          ps->u.buf.first_element = surf_tmpl->u.buf.first_element;
 317          ps->u.buf.last_element = surf_tmpl->u.buf.last_element;
 318          assert(ps->u.buf.first_element <= ps->u.buf.last_element);
 319          assert(ps->u.buf.last_element < ps->width);
 320       }
 321    }
 322    return ps;
 323 }
 324
 325
 326 /**
 327  * Free a pipe_surface which was created with softpipe_create_surface().
 328  */
 329 static void
 330 softpipe_surface_destroy(struct pipe_context *pipe,
 331                          struct pipe_surface *surf)
 332 {
 333    /* Effectively do the texture_update work here - if texture images
 334     * needed post-processing to put them into hardware layout, this is
 335     * where it would happen.  For softpipe, nothing to do.
 336     */
 337    assert(surf->texture);
 338    pipe_resource_reference(&surf->texture, NULL);
 339    FREE(surf);
 340 }
 341
 342
 343 /**
 344  * Geta pipe_transfer object which is used for moving data in/out of
 345  * a resource object.
 346  * \param pipe  rendering context
 347  * \param resource  the resource to transfer in/out of
 348  * \param level  which mipmap level
 349  * \param usage  bitmask of PIPE_TRANSFER_x flags
 350  * \param box  the 1D/2D/3D region of interest
 351  */
 352 static void *
 353 softpipe_transfer_map(struct pipe_context *pipe,
 354                       struct pipe_resource *resource,
 355                       unsigned level,
 356                       unsigned usage,
 357                       const struct pipe_box *box,
 358                       struct pipe_transfer **transfer)
 359 {
 360    struct sw_winsys *winsys = softpipe_screen(pipe->screen)->winsys;
 361    struct softpipe_resource *spr = softpipe_resource(resource);
 362    struct softpipe_transfer *spt;
 363    struct pipe_transfer *pt;
 364    enum pipe_format format = resource->format;
 365    uint8_t *map;
 366
 367    assert(resource);
 368    assert(level <= resource->last_level);
 369
 370    /* make sure the requested region is in the image bounds */
 371    assert(box->x + box->width <= (int) u_minify(resource->width0, level));
 372    if (resource->target == PIPE_TEXTURE_1D_ARRAY) {
 373       assert(box->y + box->height <= (int) resource->array_size);
 374    }
 375    else {
 376       assert(box->y + box->height <= (int) u_minify(resource->height0, level));
 377       if (resource->target == PIPE_TEXTURE_2D_ARRAY) {
 378          assert(box->z + box->depth <= (int) resource->array_size);
 379       }
 380       else if (resource->target == PIPE_TEXTURE_CUBE) {
 381          assert(box->z < 6);
 382       }
 383       else if (resource->target == PIPE_TEXTURE_CUBE_ARRAY) {
 384          assert(box->z <= (int) resource->array_size);
 385       }
 386       else {
 387          assert(box->z + box->depth <= (int) u_minify(resource->depth0, level));
 388       }
 389    }
 390
 391    /*
 392     * Transfers, like other pipe operations, must happen in order, so flush the
 393     * context if necessary.
 394     */
 395    if (!(usage & PIPE_TRANSFER_UNSYNCHRONIZED)) {
 396       boolean read_only = !(usage & PIPE_TRANSFER_WRITE);
 397       boolean do_not_block = !!(usage & PIPE_TRANSFER_DONTBLOCK);
 398       if (!softpipe_flush_resource(pipe, resource,
 399                                    level, box->depth > 1 ? -1 : box->z,
 400                                    0, /* flush_flags */
 401                                    read_only,
 402                                    TRUE, /* cpu_access */
 403                                    do_not_block)) {
 404          /*
 405           * It would have blocked, but state tracker requested no to.
 406           */
 407          assert(do_not_block);
 408          return NULL;
 409       }
 410    }
 411
 412    spt = CALLOC_STRUCT(softpipe_transfer);
 413    if (!spt)
 414       return NULL;
 415
 416    pt = &spt->base;
 417
 418    pipe_resource_reference(&pt->resource, resource);
 419    pt->level = level;
 420    pt->usage = usage;
 421    pt->box = *box;
 422    pt->stride = spr->stride[level];
 423    pt->layer_stride = spr->img_stride[level];
 424
 425    spt->offset = sp_get_tex_image_offset(spr, level, box->z);
 426
 427    spt->offset +=
 428          box->y / util_format_get_blockheight(format) * spt->base.stride +
 429          box->x / util_format_get_blockwidth(format) * util_format_get_blocksize(format);
 430
 431    /* resources backed by display target treated specially:
 432     */
 433    if (spr->dt) {
 434       map = winsys->displaytarget_map(winsys, spr->dt, usage);
 435    }
 436    else {
 437       map = spr->data;
 438    }
 439
 440    if (!map) {
 441       pipe_resource_reference(&pt->resource, NULL);
 442       FREE(spt);
 443       return NULL;
 444    }
 445
 446    *transfer = pt;
 447    return map + spt->offset;
 448 }
 449
 450
 451 /**
 452  * Unmap memory mapping for given pipe_transfer object.
 453  */
 454 static void
 455 softpipe_transfer_unmap(struct pipe_context *pipe,
 456                         struct pipe_transfer *transfer)
 457 {
 458    struct softpipe_resource *spr;
 459
 460    assert(transfer->resource);
 461    spr = softpipe_resource(transfer->resource);
 462
 463    if (spr->dt) {
 464       /* display target */
 465       struct sw_winsys *winsys = softpipe_screen(pipe->screen)->winsys;
 466       winsys->displaytarget_unmap(winsys, spr->dt);
 467    }
 468
 469    if (transfer->usage & PIPE_TRANSFER_WRITE) {
 470       /* Mark the texture as dirty to expire the tile caches. */
 471       spr->timestamp++;
 472    }
 473
 474    pipe_resource_reference(&transfer->resource, NULL);
 475    FREE(transfer);
 476 }
 477
 478 /**
 479  * Create buffer which wraps user-space data.
 480  */
 481 struct pipe_resource *
 482 softpipe_user_buffer_create(struct pipe_screen *screen,
 483                             void *ptr,
 484                             unsigned bytes,
 485                             unsigned bind_flags)
 486 {
 487    struct softpipe_resource *spr;
 488
 489    spr = CALLOC_STRUCT(softpipe_resource);
 490    if (!spr)
 491       return NULL;
 492
 493    pipe_reference_init(&spr->base.reference, 1);
 494    spr->base.screen = screen;
 495    spr->base.format = PIPE_FORMAT_R8_UNORM; /* ?? */
 496    spr->base.bind = bind_flags;
 497    spr->base.usage = PIPE_USAGE_IMMUTABLE;
 498    spr->base.flags = 0;
 499    spr->base.width0 = bytes;
 500    spr->base.height0 = 1;
 501    spr->base.depth0 = 1;
 502    spr->base.array_size = 1;
 503    spr->userBuffer = TRUE;
 504    spr->data = ptr;
 505
 506    return &spr->base;
 507 }
 508
 509
 510 void
 511 softpipe_init_texture_funcs(struct pipe_context *pipe)
 512 {
 513    pipe->transfer_map = softpipe_transfer_map;
 514    pipe->transfer_unmap = softpipe_transfer_unmap;
 515
 516    pipe->transfer_flush_region = u_default_transfer_flush_region;
 517    pipe->transfer_inline_write = u_default_transfer_inline_write;
 518
 519    pipe->create_surface = softpipe_create_surface;
 520    pipe->surface_destroy = softpipe_surface_destroy;
 521 }
 522
 523
 524 void
 525 softpipe_init_screen_texture_funcs(struct pipe_screen *screen)
 526 {
 527    screen->resource_create = softpipe_resource_create;
 528    screen->resource_create_front = softpipe_resource_create_front;
 529    screen->resource_destroy = softpipe_resource_destroy;
 530    screen->resource_from_handle = softpipe_resource_from_handle;
 531    screen->resource_get_handle = softpipe_resource_get_handle;
 532    screen->can_create_resource = softpipe_can_create_resource;
 533 }