src/gallium/drivers/i965simple/brw_tex_layout.c

   1 /*
   2  Copyright (C) Intel Corp.  2006.  All Rights Reserved.
   3  Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
   4  develop this 3D driver.
   5
   6  Permission is hereby granted, free of charge, to any person obtaining
   7  a 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, sublicense, 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
  16  portions of the Software.
  17
  18  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  21  IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  22  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  23  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  24  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25
  26  **********************************************************************/
  27  /*
  28   * Authors:
  29   *   Keith Whitwell <keith@tungstengraphics.com>
  30   */
  31
  32
  33 /* Code to layout images in a mipmap tree for i965.
  34  */
  35
  36 #include "pipe/p_state.h"
  37 #include "pipe/p_context.h"
  38 #include "pipe/p_defines.h"
  39 #include "pipe/p_inlines.h"
  40 #include "pipe/internal/p_winsys_screen.h"
  41 #include "util/u_math.h"
  42 #include "util/u_memory.h"
  43 #include "brw_context.h"
  44 #include "brw_tex_layout.h"
  45
  46
  47 #define FILE_DEBUG_FLAG DEBUG_TEXTURE
  48
  49 #if 0
  50 unsigned intel_compressed_alignment(unsigned internalFormat)
  51 {
  52     unsigned alignment = 4;
  53
  54     switch (internalFormat) {
  55     case GL_COMPRESSED_RGB_FXT1_3DFX:
  56     case GL_COMPRESSED_RGBA_FXT1_3DFX:
  57         alignment = 8;
  58         break;
  59
  60     default:
  61         break;
  62     }
  63
  64     return alignment;
  65 }
  66 #endif
  67
  68 static unsigned minify( unsigned d )
  69 {
  70    return MAX2(1, d>>1);
  71 }
  72
  73
  74 static void intel_miptree_set_image_offset(struct brw_texture *tex,
  75                                            unsigned level,
  76                                            unsigned img,
  77                                            unsigned x, unsigned y)
  78 {
  79    struct pipe_texture *pt = &tex->base;
  80    if (img == 0 && level == 0)
  81       assert(x == 0 && y == 0);
  82    assert(img < tex->nr_images[level]);
  83
  84    tex->image_offset[level][img] = y * tex->stride + x * pt->block.size;
  85 }
  86
  87 static void intel_miptree_set_level_info(struct brw_texture *tex,
  88                                          unsigned level,
  89                                          unsigned nr_images,
  90                                          unsigned x, unsigned y,
  91                                          unsigned w, unsigned h, unsigned d)
  92 {
  93    struct pipe_texture *pt = &tex->base;
  94
  95    assert(level < PIPE_MAX_TEXTURE_LEVELS);
  96
  97    pt->width[level] = w;
  98    pt->height[level] = h;
  99    pt->depth[level] = d;
 100
 101    pt->nblocksx[level] = pf_get_nblocksx(&pt->block, w);
 102    pt->nblocksy[level] = pf_get_nblocksy(&pt->block, h);
 103
 104    tex->level_offset[level] = y * tex->stride + x * tex->base.block.size;
 105    tex->nr_images[level] = nr_images;
 106
 107    /*
 108    DBG("%s level %d size: %d,%d,%d offset %d,%d (0x%x)\n", __FUNCTION__,
 109        level, w, h, d, x, y, tex->level_offset[level]);
 110    */
 111
 112    /* Not sure when this would happen, but anyway:
 113     */
 114    if (tex->image_offset[level]) {
 115       FREE(tex->image_offset[level]);
 116       tex->image_offset[level] = NULL;
 117    }
 118
 119    assert(nr_images);
 120    assert(!tex->image_offset[level]);
 121
 122    tex->image_offset[level] = (unsigned *) MALLOC(nr_images * sizeof(unsigned));
 123    tex->image_offset[level][0] = 0;
 124 }
 125
 126 static void i945_miptree_layout_2d(struct brw_texture *tex)
 127 {
 128    struct pipe_texture *pt = &tex->base;
 129    const int align_x = 2, align_y = 4;
 130    unsigned level;
 131    unsigned x = 0;
 132    unsigned y = 0;
 133    unsigned width = pt->width[0];
 134    unsigned height = pt->height[0];
 135    unsigned nblocksx = pt->nblocksx[0];
 136    unsigned nblocksy = pt->nblocksy[0];
 137
 138    tex->stride = align(pt->nblocksx[0] * pt->block.size, 4);
 139
 140    /* May need to adjust pitch to accomodate the placement of
 141     * the 2nd mipmap level.  This occurs when the alignment
 142     * constraints of mipmap placement push the right edge of the
 143     * 2nd mipmap level out past the width of its parent.
 144     */
 145    if (pt->last_level > 0) {
 146       unsigned mip1_nblocksx
 147          = align(pf_get_nblocksx(&pt->block, minify(width)), align_x)
 148          + pf_get_nblocksx(&pt->block, minify(minify(width)));
 149
 150       if (mip1_nblocksx > nblocksx)
 151          tex->stride = mip1_nblocksx * pt->block.size;
 152    }
 153
 154    /* Pitch must be a whole number of dwords
 155     */
 156    tex->stride = align(tex->stride, 64);
 157    tex->total_nblocksy = 0;
 158
 159    for (level = 0; level <= pt->last_level; level++) {
 160       intel_miptree_set_level_info(tex, level, 1, x, y, width,
 161                                    height, 1);
 162
 163       nblocksy = align(nblocksy, align_y);
 164
 165       /* Because the images are packed better, the final offset
 166        * might not be the maximal one:
 167        */
 168       tex->total_nblocksy = MAX2(tex->total_nblocksy, y + nblocksy);
 169
 170       /* Layout_below: step right after second mipmap level.
 171        */
 172       if (level == 1) {
 173          x += align(nblocksx, align_x);
 174       }
 175       else {
 176          y += nblocksy;
 177       }
 178
 179       width  = minify(width);
 180       height = minify(height);
 181       nblocksx = pf_get_nblocksx(&pt->block, width);
 182       nblocksy = pf_get_nblocksy(&pt->block, height);
 183    }
 184 }
 185
 186 static boolean brw_miptree_layout(struct brw_texture *tex)
 187 {
 188    struct pipe_texture *pt = &tex->base;
 189    /* XXX: these vary depending on image format:
 190     */
 191 /*    int align_w = 4; */
 192
 193    switch (pt->target) {
 194    case PIPE_TEXTURE_CUBE:
 195    case PIPE_TEXTURE_3D: {
 196       unsigned width  = pt->width[0];
 197       unsigned height = pt->height[0];
 198       unsigned depth = pt->depth[0];
 199       unsigned nblocksx = pt->nblocksx[0];
 200       unsigned nblocksy = pt->nblocksy[0];
 201       unsigned pack_x_pitch, pack_x_nr;
 202       unsigned pack_y_pitch;
 203       unsigned level;
 204       unsigned align_h = 2;
 205       unsigned align_w = 4;
 206
 207       tex->total_nblocksy = 0;
 208
 209       tex->stride = align(pt->nblocksx[0], 4);
 210       pack_y_pitch = align(pt->nblocksy[0], align_h);
 211
 212       pack_x_pitch = tex->stride / pt->block.size;
 213       pack_x_nr = 1;
 214
 215       for (level = 0; level <= pt->last_level; level++) {
 216          unsigned nr_images = pt->target == PIPE_TEXTURE_3D ? depth : 6;
 217          int x = 0;
 218          int y = 0;
 219          uint q, j;
 220
 221          intel_miptree_set_level_info(tex, level, nr_images,
 222                                       0, tex->total_nblocksy,
 223                                       width, height, depth);
 224
 225          for (q = 0; q < nr_images;) {
 226             for (j = 0; j < pack_x_nr && q < nr_images; j++, q++) {
 227                intel_miptree_set_image_offset(tex, level, q, x, y);
 228                x += pack_x_pitch;
 229             }
 230
 231             x = 0;
 232             y += pack_y_pitch;
 233          }
 234
 235
 236          tex->total_nblocksy += y;
 237          width  = minify(width);
 238          height = minify(height);
 239          depth  = minify(depth);
 240          nblocksx = pf_get_nblocksx(&pt->block, width);
 241          nblocksy = pf_get_nblocksy(&pt->block, height);
 242
 243          if (pt->compressed) {
 244             pack_y_pitch = (height + 3) / 4;
 245
 246             if (pack_x_pitch > align(width, align_w)) {
 247                pack_x_pitch = align(width, align_w);
 248                pack_x_nr <<= 1;
 249             }
 250          } else {
 251             if (pack_x_pitch > 4) {
 252                pack_x_pitch >>= 1;
 253                pack_x_nr <<= 1;
 254                assert(pack_x_pitch * pack_x_nr * pt->block.size <= tex->stride);
 255             }
 256
 257             if (pack_y_pitch > 2) {
 258                pack_y_pitch >>= 1;
 259                pack_y_pitch = align(pack_y_pitch, align_h);
 260             }
 261          }
 262
 263       }
 264       break;
 265    }
 266
 267    default:
 268       i945_miptree_layout_2d(tex);
 269       break;
 270    }
 271 #if 0
 272    PRINT("%s: %dx%dx%d - sz 0x%x\n", __FUNCTION__,
 273        pt->pitch,
 274        pt->total_nblocksy,
 275        pt->block.size,
 276        pt->stride * pt->total_nblocksy );
 277 #endif
 278
 279    return TRUE;
 280 }
 281
 282
 283 static struct pipe_texture *
 284 brw_texture_create_screen(struct pipe_screen *screen,
 285                           const struct pipe_texture *templat)
 286 {
 287    struct pipe_winsys *ws = screen->winsys;
 288    struct brw_texture *tex = CALLOC_STRUCT(brw_texture);
 289
 290    if (tex) {
 291       tex->base = *templat;
 292       tex->base.refcount = 1;
 293
 294       tex->base.nblocksx[0] = pf_get_nblocksx(&tex->base.block, tex->base.width[0]);
 295       tex->base.nblocksy[0] = pf_get_nblocksy(&tex->base.block, tex->base.height[0]);
 296
 297       if (brw_miptree_layout(tex))
 298          tex->buffer = ws->buffer_create(ws, 64,
 299                                           PIPE_BUFFER_USAGE_PIXEL,
 300                                           tex->stride *
 301                                           tex->total_nblocksy);
 302
 303       if (!tex->buffer) {
 304          FREE(tex);
 305          return NULL;
 306       }
 307    }
 308
 309    return &tex->base;
 310 }
 311
 312
 313 static void
 314 brw_texture_release_screen(struct pipe_screen *screen,
 315                            struct pipe_texture **pt)
 316 {
 317    if (!*pt)
 318       return;
 319
 320    /*
 321    DBG("%s %p refcount will be %d\n",
 322        __FUNCTION__, (void *) *pt, (*pt)->refcount - 1);
 323    */
 324    if (--(*pt)->refcount <= 0) {
 325       struct brw_texture *tex = (struct brw_texture *)*pt;
 326       uint i;
 327
 328       /*
 329       DBG("%s deleting %p\n", __FUNCTION__, (void *) tex);
 330       */
 331
 332       pipe_buffer_reference(screen, &tex->buffer, NULL);
 333
 334       for (i = 0; i < PIPE_MAX_TEXTURE_LEVELS; i++)
 335          if (tex->image_offset[i])
 336             free(tex->image_offset[i]);
 337
 338       free(tex);
 339    }
 340    *pt = NULL;
 341 }
 342
 343
 344 static struct pipe_surface *
 345 brw_get_tex_surface_screen(struct pipe_screen *screen,
 346                            struct pipe_texture *pt,
 347                            unsigned face, unsigned level, unsigned zslice)
 348 {
 349    struct brw_texture *tex = (struct brw_texture *)pt;
 350    struct pipe_surface *ps;
 351    unsigned offset;  /* in bytes */
 352
 353    offset = tex->level_offset[level];
 354
 355    if (pt->target == PIPE_TEXTURE_CUBE) {
 356       offset += tex->image_offset[level][face];
 357    }
 358    else if (pt->target == PIPE_TEXTURE_3D) {
 359       offset += tex->image_offset[level][zslice];
 360    }
 361    else {
 362       assert(face == 0);
 363       assert(zslice == 0);
 364    }
 365
 366    ps = CALLOC_STRUCT(pipe_surface);
 367    if (ps) {
 368       ps->refcount = 1;
 369       pipe_texture_reference(&ps->texture, pt);
 370       ps->format = pt->format;
 371       ps->width = pt->width[level];
 372       ps->height = pt->height[level];
 373       ps->block = pt->block;
 374       ps->nblocksx = pt->nblocksx[level];
 375       ps->nblocksy = pt->nblocksy[level];
 376       ps->stride = tex->stride;
 377       ps->offset = offset;
 378       ps->status = PIPE_SURFACE_STATUS_DEFINED;
 379    }
 380    return ps;
 381 }
 382
 383
 384 void
 385 brw_init_texture_functions(struct brw_context *brw)
 386 {
 387 //   brw->pipe.texture_update = brw_texture_update;
 388 }
 389
 390
 391 void
 392 brw_init_screen_texture_funcs(struct pipe_screen *screen)
 393 {
 394    screen->texture_create  = brw_texture_create_screen;
 395    screen->texture_release = brw_texture_release_screen;
 396    screen->get_tex_surface = brw_get_tex_surface_screen;
 397 }
 398