src/gallium/drivers/i915/i915_resource_texture.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2006 Tungsten Graphics, Inc., Cedar Park, Texas.
   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 TUNGSTEN GRAPHICS 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 <keith@tungstengraphics.com>
  30   *   Michel Dänzer <michel@tungstengraphics.com>
  31   */
  32
  33 #include "pipe/p_state.h"
  34 #include "pipe/p_context.h"
  35 #include "pipe/p_defines.h"
  36 #include "util/u_inlines.h"
  37 #include "util/u_format.h"
  38 #include "util/u_math.h"
  39 #include "util/u_memory.h"
  40
  41 #include "i915_context.h"
  42 #include "i915_resource.h"
  43 #include "i915_screen.h"
  44 #include "i915_winsys.h"
  45
  46
  47 /*
  48  * Helper function and arrays
  49  */
  50
  51
  52 /**
  53  * Initial offset for Cube map.
  54  */
  55 static const int initial_offsets[6][2] = {
  56    {0, 0},
  57    {0, 2},
  58    {1, 0},
  59    {1, 2},
  60    {1, 1},
  61    {1, 3}
  62 };
  63
  64 /**
  65  * Step offsets for Cube map.
  66  */
  67 static const int step_offsets[6][2] = {
  68    {0, 2},
  69    {0, 2},
  70    {-1, 2},
  71    {-1, 2},
  72    {-1, 1},
  73    {-1, 1}
  74 };
  75
  76 /* XXX really need twice the size if x is already pot?
  77    Otherwise just use util_next_power_of_two?
  78 */
  79 static unsigned
  80 power_of_two(unsigned x)
  81 {
  82    unsigned value = 1;
  83    while (value < x)
  84       value = value << 1;
  85    return value;
  86 }
  87
  88 /*
  89  * More advanced helper funcs
  90  */
  91
  92
  93 static void
  94 i915_texture_set_level_info(struct i915_texture *tex,
  95                              unsigned level,
  96                              unsigned nr_images,
  97                              unsigned w, unsigned h, unsigned d)
  98 {
  99    assert(level < Elements(tex->nr_images));
 100
 101    tex->nr_images[level] = nr_images;
 102
 103    /*
 104    DBG("%s level %d size: %d,%d,%d offset %d,%d (0x%x)\n", __FUNCTION__,
 105        level, w, h, d, x, y, tex->level_offset[level]);
 106    */
 107
 108    /* Not sure when this would happen, but anyway:
 109     */
 110    if (tex->image_offset[level]) {
 111       FREE(tex->image_offset[level]);
 112       tex->image_offset[level] = NULL;
 113    }
 114
 115    assert(nr_images);
 116    assert(!tex->image_offset[level]);
 117
 118    tex->image_offset[level] = (unsigned *) MALLOC(nr_images * sizeof(unsigned));
 119    tex->image_offset[level][0] = 0;
 120 }
 121
 122 static void
 123 i915_texture_set_image_offset(struct i915_texture *tex,
 124                               unsigned level, unsigned img, unsigned x, unsigned y)
 125 {
 126    if (img == 0 && level == 0)
 127       assert(x == 0 && y == 0);
 128
 129    assert(img < tex->nr_images[level]);
 130
 131    tex->image_offset[level][img] = y * tex->stride + x * util_format_get_blocksize(tex->b.b.format);
 132
 133    /*
 134    printf("%s level %d img %d pos %d,%d image_offset %x\n",
 135        __FUNCTION__, level, img, x, y, tex->image_offset[level][img]);
 136    */
 137 }
 138
 139
 140 /*
 141  * Shared layout functions
 142  */
 143
 144
 145 /**
 146  * Special case to deal with scanout textures.
 147  */
 148 static boolean
 149 i9x5_scanout_layout(struct i915_texture *tex)
 150 {
 151    struct pipe_resource *pt = &tex->b.b;
 152
 153    if (pt->last_level > 0 || util_format_get_blocksize(pt->format) != 4)
 154       return FALSE;
 155
 156    i915_texture_set_level_info(tex, 0, 1,
 157                                pt->width0,
 158                                pt->height0,
 159                                1);
 160    i915_texture_set_image_offset(tex, 0, 0, 0, 0);
 161
 162    if (pt->width0 >= 240) {
 163       tex->stride = power_of_two(util_format_get_stride(pt->format, pt->width0));
 164       tex->total_nblocksy = align(util_format_get_nblocksy(pt->format, pt->height0), 8);
 165       tex->hw_tiled = I915_TILE_X;
 166    } else if (pt->width0 == 64 && pt->height0 == 64) {
 167       tex->stride = power_of_two(util_format_get_stride(pt->format, pt->width0));
 168       tex->total_nblocksy = align(util_format_get_nblocksy(pt->format, pt->height0), 8);
 169    } else {
 170       return FALSE;
 171    }
 172
 173    debug_printf("%s size: %d,%d,%d offset %d,%d (0x%x)\n", __FUNCTION__,
 174       pt->width0, pt->height0, util_format_get_blocksize(pt->format),
 175       tex->stride, tex->total_nblocksy, tex->stride * tex->total_nblocksy);
 176
 177    return TRUE;
 178 }
 179
 180 /**
 181  * Special case to deal with shared textures.
 182  */
 183 static boolean
 184 i9x5_display_target_layout(struct i915_texture *tex)
 185 {
 186    struct pipe_resource *pt = &tex->b.b;
 187
 188    if (pt->last_level > 0 || util_format_get_blocksize(pt->format) != 4)
 189       return FALSE;
 190
 191    /* fallback to normal textures for small textures */
 192    if (pt->width0 < 240)
 193       return FALSE;
 194
 195    i915_texture_set_level_info(tex, 0, 1,
 196                                pt->width0,
 197                                pt->height0,
 198                                1);
 199    i915_texture_set_image_offset(tex, 0, 0, 0, 0);
 200
 201    tex->stride = power_of_two(util_format_get_stride(pt->format, pt->width0));
 202    tex->total_nblocksy = align(util_format_get_nblocksy(pt->format, pt->height0), 8);
 203    tex->hw_tiled = I915_TILE_X;
 204
 205    debug_printf("%s size: %d,%d,%d offset %d,%d (0x%x)\n", __FUNCTION__,
 206       pt->width0, pt->height0, util_format_get_blocksize(pt->format),
 207       tex->stride, tex->total_nblocksy, tex->stride * tex->total_nblocksy);
 208
 209    return TRUE;
 210 }
 211
 212
 213 /*
 214  * i915 layout functions
 215  */
 216
 217
 218 static void
 219 i915_texture_layout_2d(struct i915_texture *tex)
 220 {
 221    struct pipe_resource *pt = &tex->b.b;
 222    unsigned level;
 223    unsigned width = pt->width0;
 224    unsigned height = pt->height0;
 225    unsigned nblocksy = util_format_get_nblocksy(pt->format, pt->width0);
 226
 227    /* used for scanouts that need special layouts */
 228    if (pt->bind & PIPE_BIND_SCANOUT)
 229       if (i9x5_scanout_layout(tex))
 230          return;
 231
 232    /* shared buffers needs to be compatible with X servers
 233     *
 234     * XXX: need a better name than shared for this if it is to be part
 235     * of core gallium, and probably move the flag to resource.flags,
 236     * rather than bindings.
 237     */
 238    if (pt->bind & (PIPE_BIND_SHARED | PIPE_BIND_DISPLAY_TARGET))
 239       if (i9x5_display_target_layout(tex))
 240          return;
 241
 242    tex->stride = align(util_format_get_stride(pt->format, pt->width0), 4);
 243    tex->total_nblocksy = 0;
 244
 245    for (level = 0; level <= pt->last_level; level++) {
 246       i915_texture_set_level_info(tex, level, 1, width, height, 1);
 247       i915_texture_set_image_offset(tex, level, 0, 0, tex->total_nblocksy);
 248
 249       nblocksy = align(MAX2(2, nblocksy), 2);
 250
 251       tex->total_nblocksy += nblocksy;
 252
 253       width = u_minify(width, 1);
 254       height = u_minify(height, 1);
 255       nblocksy = util_format_get_nblocksy(pt->format, height);
 256    }
 257 }
 258
 259 static void
 260 i915_texture_layout_3d(struct i915_texture *tex)
 261 {
 262    struct pipe_resource *pt = &tex->b.b;
 263    unsigned level;
 264
 265    unsigned width = pt->width0;
 266    unsigned height = pt->height0;
 267    unsigned depth = pt->depth0;
 268    unsigned nblocksy = util_format_get_nblocksy(pt->format, pt->height0);
 269    unsigned stack_nblocksy = 0;
 270
 271    /* Calculate the size of a single slice.
 272     */
 273    tex->stride = align(util_format_get_stride(pt->format, pt->width0), 4);
 274
 275    /* XXX: hardware expects/requires 9 levels at minimum.
 276     */
 277    for (level = 0; level <= MAX2(8, pt->last_level); level++) {
 278       i915_texture_set_level_info(tex, level, depth, width, height, depth);
 279
 280       stack_nblocksy += MAX2(2, nblocksy);
 281
 282       width = u_minify(width, 1);
 283       height = u_minify(height, 1);
 284       nblocksy = util_format_get_nblocksy(pt->format, height);
 285    }
 286
 287    /* Fixup depth image_offsets:
 288     */
 289    for (level = 0; level <= pt->last_level; level++) {
 290       unsigned i;
 291       for (i = 0; i < depth; i++)
 292          i915_texture_set_image_offset(tex, level, i, 0, i * stack_nblocksy);
 293
 294       depth = u_minify(depth, 1);
 295    }
 296
 297    /* Multiply slice size by texture depth for total size.  It's
 298     * remarkable how wasteful of memory the i915 texture layouts
 299     * are.  They are largely fixed in the i945.
 300     */
 301    tex->total_nblocksy = stack_nblocksy * pt->depth0;
 302 }
 303
 304 static void
 305 i915_texture_layout_cube(struct i915_texture *tex)
 306 {
 307    struct pipe_resource *pt = &tex->b.b;
 308    unsigned width = pt->width0, height = pt->height0;
 309    const unsigned nblocks = util_format_get_nblocksx(pt->format, pt->width0);
 310    unsigned level;
 311    unsigned face;
 312
 313    assert(width == height); /* cubemap images are square */
 314
 315    /* double pitch for cube layouts */
 316    tex->stride = align(nblocks * util_format_get_blocksize(pt->format) * 2, 4);
 317    tex->total_nblocksy = nblocks * 4;
 318
 319    for (level = 0; level <= pt->last_level; level++) {
 320       i915_texture_set_level_info(tex, level, 6, width, height, 1);
 321       width /= 2;
 322       height /= 2;
 323    }
 324
 325    for (face = 0; face < 6; face++) {
 326       unsigned x = initial_offsets[face][0] * nblocks;
 327       unsigned y = initial_offsets[face][1] * nblocks;
 328       unsigned d = nblocks;
 329
 330       for (level = 0; level <= pt->last_level; level++) {
 331          i915_texture_set_image_offset(tex, level, face, x, y);
 332          d >>= 1;
 333          x += step_offsets[face][0] * d;
 334          y += step_offsets[face][1] * d;
 335       }
 336    }
 337 }
 338
 339 static boolean
 340 i915_texture_layout(struct i915_texture * tex)
 341 {
 342    struct pipe_resource *pt = &tex->b.b;
 343
 344    switch (pt->target) {
 345    case PIPE_TEXTURE_1D:
 346    case PIPE_TEXTURE_2D:
 347       i915_texture_layout_2d(tex);
 348       break;
 349    case PIPE_TEXTURE_3D:
 350       i915_texture_layout_3d(tex);
 351       break;
 352    case PIPE_TEXTURE_CUBE:
 353       i915_texture_layout_cube(tex);
 354       break;
 355    default:
 356       assert(0);
 357       return FALSE;
 358    }
 359
 360    return TRUE;
 361 }
 362
 363
 364 /*
 365  * i945 layout functions
 366  */
 367
 368
 369 static void
 370 i945_texture_layout_2d(struct i915_texture *tex)
 371 {
 372    struct pipe_resource *pt = &tex->b.b;
 373    const int align_x = 2, align_y = 4;
 374    unsigned level;
 375    unsigned x = 0;
 376    unsigned y = 0;
 377    unsigned width = pt->width0;
 378    unsigned height = pt->height0;
 379    unsigned nblocksx = util_format_get_nblocksx(pt->format, pt->width0);
 380    unsigned nblocksy = util_format_get_nblocksy(pt->format, pt->height0);
 381
 382    /* used for scanouts that need special layouts */
 383    if (tex->b.b.bind & PIPE_BIND_SCANOUT)
 384       if (i9x5_scanout_layout(tex))
 385          return;
 386
 387    /* shared buffers needs to be compatible with X servers */
 388    if (tex->b.b.bind & (PIPE_BIND_SHARED | PIPE_BIND_DISPLAY_TARGET))
 389       if (i9x5_display_target_layout(tex))
 390          return;
 391
 392    tex->stride = align(util_format_get_stride(pt->format, pt->width0), 4);
 393
 394    /* May need to adjust pitch to accomodate the placement of
 395     * the 2nd mipmap level.  This occurs when the alignment
 396     * constraints of mipmap placement push the right edge of the
 397     * 2nd mipmap level out past the width of its parent.
 398     */
 399    if (pt->last_level > 0) {
 400       unsigned mip1_nblocksx
 401          = align(util_format_get_nblocksx(pt->format, u_minify(width, 1)), align_x)
 402          + util_format_get_nblocksx(pt->format, u_minify(width, 2));
 403
 404       if (mip1_nblocksx > nblocksx)
 405          tex->stride = mip1_nblocksx * util_format_get_blocksize(pt->format);
 406    }
 407
 408    /* Pitch must be a whole number of dwords
 409     */
 410    tex->stride = align(tex->stride, 64);
 411    tex->total_nblocksy = 0;
 412
 413    for (level = 0; level <= pt->last_level; level++) {
 414       i915_texture_set_level_info(tex, level, 1, width, height, 1);
 415       i915_texture_set_image_offset(tex, level, 0, x, y);
 416
 417       nblocksy = align(nblocksy, align_y);
 418
 419       /* Because the images are packed better, the final offset
 420        * might not be the maximal one:
 421        */
 422       tex->total_nblocksy = MAX2(tex->total_nblocksy, y + nblocksy);
 423
 424       /* Layout_below: step right after second mipmap level.
 425        */
 426       if (level == 1) {
 427          x += align(nblocksx, align_x);
 428       }
 429       else {
 430          y += nblocksy;
 431       }
 432
 433       width  = u_minify(width, 1);
 434       height = u_minify(height, 1);
 435       nblocksx = util_format_get_nblocksx(pt->format, width);
 436       nblocksy = util_format_get_nblocksy(pt->format, height);
 437    }
 438 }
 439
 440 static void
 441 i945_texture_layout_3d(struct i915_texture *tex)
 442 {
 443    struct pipe_resource *pt = &tex->b.b;
 444    unsigned width = pt->width0;
 445    unsigned height = pt->height0;
 446    unsigned depth = pt->depth0;
 447    unsigned nblocksy = util_format_get_nblocksy(pt->format, pt->width0);
 448    unsigned pack_x_pitch, pack_x_nr;
 449    unsigned pack_y_pitch;
 450    unsigned level;
 451
 452    tex->stride = align(util_format_get_stride(pt->format, pt->width0), 4);
 453    tex->total_nblocksy = 0;
 454
 455    pack_y_pitch = MAX2(nblocksy, 2);
 456    pack_x_pitch = tex->stride / util_format_get_blocksize(pt->format);
 457    pack_x_nr = 1;
 458
 459    for (level = 0; level <= pt->last_level; level++) {
 460       int x = 0;
 461       int y = 0;
 462       unsigned q, j;
 463
 464       i915_texture_set_level_info(tex, level, depth, width, height, depth);
 465
 466       for (q = 0; q < depth;) {
 467          for (j = 0; j < pack_x_nr && q < depth; j++, q++) {
 468             i915_texture_set_image_offset(tex, level, q, x, y + tex->total_nblocksy);
 469             x += pack_x_pitch;
 470          }
 471
 472          x = 0;
 473          y += pack_y_pitch;
 474       }
 475
 476       tex->total_nblocksy += y;
 477
 478       if (pack_x_pitch > 4) {
 479          pack_x_pitch >>= 1;
 480          pack_x_nr <<= 1;
 481          assert(pack_x_pitch * pack_x_nr * util_format_get_blocksize(pt->format) <= tex->stride);
 482       }
 483
 484       if (pack_y_pitch > 2) {
 485          pack_y_pitch >>= 1;
 486       }
 487
 488       width = u_minify(width, 1);
 489       height = u_minify(height, 1);
 490       depth = u_minify(depth, 1);
 491       nblocksy = util_format_get_nblocksy(pt->format, height);
 492    }
 493 }
 494
 495 static void
 496 i945_texture_layout_cube(struct i915_texture *tex)
 497 {
 498    struct pipe_resource *pt = &tex->b.b;
 499    unsigned level;
 500
 501    const unsigned nblocks = util_format_get_nblocksx(pt->format, pt->width0);
 502    unsigned face;
 503    unsigned width = pt->width0;
 504    unsigned height = pt->height0;
 505
 506    /*
 507    printf("%s %i, %i\n", __FUNCTION__, pt->width0, pt->height0);
 508    */
 509
 510    assert(width == height); /* cubemap images are square */
 511
 512    /*
 513     * XXX Should only be used for compressed formats. But lets
 514     * keep this code active just in case.
 515     *
 516     * Depending on the size of the largest images, pitch can be
 517     * determined either by the old-style packing of cubemap faces,
 518     * or the final row of 4x4, 2x2 and 1x1 faces below this.
 519     */
 520    if (nblocks > 32)
 521       tex->stride = align(nblocks * util_format_get_blocksize(pt->format) * 2, 4);
 522    else
 523       tex->stride = 14 * 8 * util_format_get_blocksize(pt->format);
 524
 525    tex->total_nblocksy = nblocks * 4;
 526
 527    /* Set all the levels to effectively occupy the whole rectangular region.
 528    */
 529    for (level = 0; level <= pt->last_level; level++) {
 530       i915_texture_set_level_info(tex, level, 6, width, height, 1);
 531       width /= 2;
 532       height /= 2;
 533    }
 534
 535    for (face = 0; face < 6; face++) {
 536       unsigned x = initial_offsets[face][0] * nblocks;
 537       unsigned y = initial_offsets[face][1] * nblocks;
 538       unsigned d = nblocks;
 539
 540 #if 0 /* Fix and enable this code for compressed formats */
 541       if (nblocks == 4 && face >= 4) {
 542          y = tex->total_height - 4;
 543          x = (face - 4) * 8;
 544       }
 545       else if (nblocks < 4 && (face > 0)) {
 546          y = tex->total_height - 4;
 547          x = face * 8;
 548       }
 549 #endif
 550
 551       for (level = 0; level <= pt->last_level; level++) {
 552          i915_texture_set_image_offset(tex, level, face, x, y);
 553
 554          d >>= 1;
 555
 556 #if 0 /* Fix and enable this code for compressed formats */
 557          switch (d) {
 558             case 4:
 559                switch (face) {
 560                   case PIPE_TEX_FACE_POS_X:
 561                   case PIPE_TEX_FACE_NEG_X:
 562                      x += step_offsets[face][0] * d;
 563                      y += step_offsets[face][1] * d;
 564                      break;
 565                   case PIPE_TEX_FACE_POS_Y:
 566                   case PIPE_TEX_FACE_NEG_Y:
 567                      y += 12;
 568                      x -= 8;
 569                      break;
 570                   case PIPE_TEX_FACE_POS_Z:
 571                   case PIPE_TEX_FACE_NEG_Z:
 572                      y = tex->total_height - 4;
 573                      x = (face - 4) * 8;
 574                      break;
 575                }
 576             case 2:
 577                y = tex->total_height - 4;
 578                x = 16 + face * 8;
 579                break;
 580
 581             case 1:
 582                x += 48;
 583                break;
 584             default:
 585 #endif
 586                x += step_offsets[face][0] * d;
 587                y += step_offsets[face][1] * d;
 588 #if 0
 589                break;
 590          }
 591 #endif
 592       }
 593    }
 594 }
 595
 596 static boolean
 597 i945_texture_layout(struct i915_texture * tex)
 598 {
 599    struct pipe_resource *pt = &tex->b.b;
 600
 601    switch (pt->target) {
 602    case PIPE_TEXTURE_1D:
 603    case PIPE_TEXTURE_2D:
 604       i945_texture_layout_2d(tex);
 605       break;
 606    case PIPE_TEXTURE_3D:
 607       i945_texture_layout_3d(tex);
 608       break;
 609    case PIPE_TEXTURE_CUBE:
 610       i945_texture_layout_cube(tex);
 611       break;
 612    default:
 613       assert(0);
 614       return FALSE;
 615    }
 616
 617    return TRUE;
 618 }
 619
 620
 621
 622 /*
 623  * Screen texture functions
 624  */
 625
 626
 627
 628 static boolean
 629 i915_texture_get_handle(struct pipe_screen * screen,
 630                         struct pipe_resource *texture,
 631                         struct winsys_handle *whandle)
 632 {
 633    struct i915_screen *is = i915_screen(screen);
 634    struct i915_texture *tex = i915_texture(texture);
 635    struct i915_winsys *iws = is->iws;
 636
 637    return iws->buffer_get_handle(iws, tex->buffer, whandle, tex->stride);
 638 }
 639
 640
 641 static void
 642 i915_texture_destroy(struct pipe_screen *screen,
 643                      struct pipe_resource *pt)
 644 {
 645    struct i915_texture *tex = i915_texture(pt);
 646    struct i915_winsys *iws = i915_screen(screen)->iws;
 647    uint i;
 648
 649    /*
 650      DBG("%s deleting %p\n", __FUNCTION__, (void *) tex);
 651    */
 652
 653    iws->buffer_destroy(iws, tex->buffer);
 654
 655    for (i = 0; i < Elements(tex->image_offset); i++)
 656       if (tex->image_offset[i])
 657          FREE(tex->image_offset[i]);
 658
 659    FREE(tex);
 660 }
 661
 662 static struct pipe_transfer *
 663 i915_texture_get_transfer(struct pipe_context *context,
 664                           struct pipe_resource *resource,
 665                           struct pipe_subresource sr,
 666                           unsigned usage,
 667                           const struct pipe_box *box)
 668 {
 669    struct i915_texture *tex = i915_texture(resource);
 670    struct pipe_transfer *transfer = CALLOC_STRUCT(pipe_transfer);
 671    if (transfer == NULL)
 672       return NULL;
 673
 674    transfer->resource = resource;
 675    transfer->sr = sr;
 676    transfer->usage = usage;
 677    transfer->box = *box;
 678    transfer->stride = tex->stride;
 679
 680    return transfer;
 681 }
 682
 683
 684 static void *
 685 i915_texture_transfer_map(struct pipe_context *pipe,
 686                           struct pipe_transfer *transfer)
 687 {
 688    struct pipe_resource *resource = transfer->resource;
 689    struct i915_texture *tex = i915_texture(resource);
 690    struct i915_winsys *iws = i915_screen(pipe->screen)->iws;
 691    struct pipe_subresource sr = transfer->sr;
 692    struct pipe_box *box = &transfer->box;
 693    enum pipe_format format = resource->format;
 694    unsigned offset;
 695    char *map;
 696
 697    if (resource->target == PIPE_TEXTURE_CUBE) {
 698       offset = tex->image_offset[sr.level][sr.face];
 699    }
 700    else if (resource->target == PIPE_TEXTURE_3D) {
 701       offset = tex->image_offset[sr.level][box->z];
 702    }
 703    else {
 704       offset = tex->image_offset[sr.level][0];
 705       assert(sr.face == 0);
 706       assert(box->z == 0);
 707    }
 708
 709    map = iws->buffer_map(iws,
 710                          tex->buffer,
 711                          (transfer->usage & PIPE_TRANSFER_WRITE) ? TRUE : FALSE);
 712    if (map == NULL)
 713       return NULL;
 714
 715    return map + offset +
 716       box->y / util_format_get_blockheight(format) * transfer->stride +
 717       box->x / util_format_get_blockwidth(format) * util_format_get_blocksize(format);
 718 }
 719
 720 static void
 721 i915_texture_transfer_unmap(struct pipe_context *pipe,
 722                             struct pipe_transfer *transfer)
 723 {
 724    struct i915_texture *tex = i915_texture(transfer->resource);
 725    struct i915_winsys *iws = i915_screen(tex->b.b.screen)->iws;
 726    iws->buffer_unmap(iws, tex->buffer);
 727 }
 728
 729
 730
 731 struct u_resource_vtbl i915_texture_vtbl =
 732 {
 733    i915_texture_get_handle,           /* get_handle */
 734    i915_texture_destroy,              /* resource_destroy */
 735    NULL,                              /* is_resource_referenced */
 736    i915_texture_get_transfer,         /* get_transfer */
 737    u_default_transfer_destroy,        /* transfer_destroy */
 738    i915_texture_transfer_map,         /* transfer_map */
 739    u_default_transfer_flush_region,   /* transfer_flush_region */
 740    i915_texture_transfer_unmap,       /* transfer_unmap */
 741    u_default_transfer_inline_write    /* transfer_inline_write */
 742 };
 743
 744
 745
 746
 747 struct pipe_resource *
 748 i915_texture_create(struct pipe_screen *screen,
 749                     const struct pipe_resource *template)
 750 {
 751    struct i915_screen *is = i915_screen(screen);
 752    struct i915_winsys *iws = is->iws;
 753    struct i915_texture *tex = CALLOC_STRUCT(i915_texture);
 754    size_t tex_size;
 755    unsigned buf_usage = 0;
 756
 757    if (!tex)
 758       return NULL;
 759
 760    tex->b.b = *template;
 761    tex->b.vtbl = &i915_texture_vtbl;
 762    pipe_reference_init(&tex->b.b.reference, 1);
 763    tex->b.b.screen = screen;
 764
 765    if (is->is_i945) {
 766       if (!i945_texture_layout(tex))
 767          goto fail;
 768    } else {
 769       if (!i915_texture_layout(tex))
 770          goto fail;
 771    }
 772
 773    tex_size = tex->stride * tex->total_nblocksy;
 774
 775    /* for scanouts and cursors, cursors arn't scanouts */
 776
 777    /* XXX: use a custom flag for cursors, don't rely on magically
 778     * guessing that this is Xorg asking for a cursor
 779     */
 780    if ((template->bind & PIPE_BIND_SCANOUT) && template->width0 != 64)
 781       buf_usage = I915_NEW_SCANOUT;
 782    else
 783       buf_usage = I915_NEW_TEXTURE;
 784
 785    tex->buffer = iws->buffer_create(iws, tex_size, 64, buf_usage);
 786    if (!tex->buffer)
 787       goto fail;
 788
 789    /* setup any hw fences */
 790    if (tex->hw_tiled) {
 791       assert(tex->sw_tiled == I915_TILE_NONE);
 792       iws->buffer_set_fence_reg(iws, tex->buffer, tex->stride, tex->hw_tiled);
 793    }
 794
 795
 796 #if 0
 797    void *ptr = ws->buffer_map(ws, tex->buffer,
 798       PIPE_BUFFER_USAGE_CPU_WRITE);
 799    memset(ptr, 0x80, tex_size);
 800    ws->buffer_unmap(ws, tex->buffer);
 801 #endif
 802
 803    return &tex->b.b;
 804
 805 fail:
 806    FREE(tex);
 807    return NULL;
 808 }
 809
 810 struct pipe_resource *
 811 i915_texture_from_handle(struct pipe_screen * screen,
 812                           const struct pipe_resource *template,
 813                           struct winsys_handle *whandle)
 814 {
 815    struct i915_screen *is = i915_screen(screen);
 816    struct i915_texture *tex;
 817    struct i915_winsys *iws = is->iws;
 818    struct i915_winsys_buffer *buffer;
 819    unsigned stride;
 820
 821    assert(screen);
 822
 823    buffer = iws->buffer_from_handle(iws, whandle, &stride);
 824
 825    /* Only supports one type */
 826    if (template->target != PIPE_TEXTURE_2D ||
 827        template->last_level != 0 ||
 828        template->depth0 != 1) {
 829       return NULL;
 830    }
 831
 832    tex = CALLOC_STRUCT(i915_texture);
 833    if (!tex)
 834       return NULL;
 835
 836    tex->b.b = *template;
 837    tex->b.vtbl = &i915_texture_vtbl;
 838    pipe_reference_init(&tex->b.b.reference, 1);
 839    tex->b.b.screen = screen;
 840
 841    tex->stride = stride;
 842
 843    i915_texture_set_level_info(tex, 0, 1, template->width0, template->height0, 1);
 844    i915_texture_set_image_offset(tex, 0, 0, 0, 0);
 845
 846    tex->buffer = buffer;
 847
 848    return &tex->b.b;
 849 }
 850