src/mesa/drivers/dri/i965/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 /* Code to layout images in a mipmap tree for i965.
  33  */
  34
  35 #include "intel_mipmap_tree.h"
  36 #include "intel_tex_layout.h"
  37 #include "intel_context.h"
  38 #include "main/macros.h"
  39 #include "intel_chipset.h"
  40
  41 #define FILE_DEBUG_FLAG DEBUG_MIPTREE
  42
  43 GLboolean brw_miptree_layout(struct intel_context *intel,
  44                              struct intel_mipmap_tree *mt,
  45                              uint32_t tiling)
  46 {
  47    /* XXX: these vary depending on image format: */
  48    /* GLint align_w = 4; */
  49
  50    switch (mt->target) {
  51    case GL_TEXTURE_CUBE_MAP:
  52       if (IS_IGDNG(intel->intelScreen->deviceID)) {
  53           GLuint align_h = 2, align_w = 4;
  54           GLuint level;
  55           GLuint x = 0;
  56           GLuint y = 0;
  57           GLuint width = mt->width0;
  58           GLuint height = mt->height0;
  59           GLuint qpitch = 0;
  60           GLuint y_pitch = 0;
  61
  62           mt->pitch = mt->width0;
  63           intel_get_texture_alignment_unit(mt->internal_format, &align_w, &align_h);
  64           y_pitch = ALIGN(height, align_h);
  65
  66           if (mt->compressed) {
  67               mt->pitch = ALIGN(mt->width0, align_w);
  68               qpitch = (y_pitch + ALIGN(minify(y_pitch), align_h) + 11 * align_h) / 4 * mt->pitch * mt->cpp;
  69               mt->total_height = (y_pitch + ALIGN(minify(y_pitch), align_h) + 11 * align_h) / 4 * 6;
  70           } else {
  71               qpitch = (y_pitch + ALIGN(minify(y_pitch), align_h) + 11 * align_h) * mt->pitch * mt->cpp;
  72               mt->total_height = (y_pitch + ALIGN(minify(y_pitch), align_h) + 11 * align_h) * 6;
  73           }
  74
  75           if (mt->first_level != mt->last_level) {
  76               GLuint mip1_width;
  77
  78               if (mt->compressed) {
  79                   mip1_width = ALIGN(minify(mt->width0), align_w)
  80                       + ALIGN(minify(minify(mt->width0)), align_w);
  81               } else {
  82                   mip1_width = ALIGN(minify(mt->width0), align_w)
  83                       + minify(minify(mt->width0));
  84               }
  85
  86               if (mip1_width > mt->pitch) {
  87                   mt->pitch = mip1_width;
  88               }
  89           }
  90
  91           mt->pitch = intel_miptree_pitch_align(intel, mt, tiling, mt->pitch);
  92
  93           for (level = mt->first_level; level <= mt->last_level; level++) {
  94               GLuint img_height;
  95               GLuint nr_images = 6;
  96               GLuint q = 0;
  97
  98               intel_miptree_set_level_info(mt, level, nr_images, x, y, width,
  99                                            height, 1);
 100
 101               for (q = 0; q < nr_images; q++)
 102                   intel_miptree_set_image_offset_ex(mt, level, q, x, y, q * qpitch);
 103
 104               if (mt->compressed)
 105                   img_height = MAX2(1, height/4);
 106               else
 107                   img_height = ALIGN(height, align_h);
 108
 109               if (level == mt->first_level + 1) {
 110                   x += ALIGN(width, align_w);
 111               }
 112               else {
 113                   y += img_height;
 114               }
 115
 116               width  = minify(width);
 117               height = minify(height);
 118           }
 119
 120           break;
 121       }
 122
 123    case GL_TEXTURE_3D: {
 124       GLuint width  = mt->width0;
 125       GLuint height = mt->height0;
 126       GLuint depth = mt->depth0;
 127       GLuint pack_x_pitch, pack_x_nr;
 128       GLuint pack_y_pitch;
 129       GLuint level;
 130       GLuint align_h = 2;
 131       GLuint align_w = 4;
 132
 133       mt->total_height = 0;
 134       intel_get_texture_alignment_unit(mt->internal_format, &align_w, &align_h);
 135
 136       if (mt->compressed) {
 137           mt->pitch = ALIGN(width, align_w);
 138           pack_y_pitch = (height + 3) / 4;
 139       } else {
 140          mt->pitch = intel_miptree_pitch_align (intel, mt, tiling, mt->width0);
 141          pack_y_pitch = ALIGN(mt->height0, align_h);
 142       }
 143
 144       pack_x_pitch = width;
 145       pack_x_nr = 1;
 146
 147       for (level = mt->first_level ; level <= mt->last_level ; level++) {
 148          GLuint nr_images = mt->target == GL_TEXTURE_3D ? depth : 6;
 149          GLint x = 0;
 150          GLint y = 0;
 151          GLint q, j;
 152
 153          intel_miptree_set_level_info(mt, level, nr_images,
 154                                       0, mt->total_height,
 155                                       width, height, depth);
 156
 157          for (q = 0; q < nr_images;) {
 158             for (j = 0; j < pack_x_nr && q < nr_images; j++, q++) {
 159                intel_miptree_set_image_offset(mt, level, q, x, y);
 160                x += pack_x_pitch;
 161             }
 162
 163             x = 0;
 164             y += pack_y_pitch;
 165          }
 166
 167
 168          mt->total_height += y;
 169          width  = minify(width);
 170          height = minify(height);
 171          depth  = minify(depth);
 172
 173          if (mt->compressed) {
 174             pack_y_pitch = (height + 3) / 4;
 175
 176             if (pack_x_pitch > ALIGN(width, align_w)) {
 177                pack_x_pitch = ALIGN(width, align_w);
 178                pack_x_nr <<= 1;
 179             }
 180          } else {
 181             if (pack_x_pitch > 4) {
 182                pack_x_pitch >>= 1;
 183                pack_x_nr <<= 1;
 184                assert(pack_x_pitch * pack_x_nr <= mt->pitch);
 185             }
 186
 187             if (pack_y_pitch > 2) {
 188                pack_y_pitch >>= 1;
 189                pack_y_pitch = ALIGN(pack_y_pitch, align_h);
 190             }
 191          }
 192
 193       }
 194       break;
 195    }
 196
 197    default:
 198       i945_miptree_layout_2d(intel, mt, tiling);
 199       break;
 200    }
 201    DBG("%s: %dx%dx%d - sz 0x%x\n", __FUNCTION__,
 202                 mt->pitch,
 203                 mt->total_height,
 204                 mt->cpp,
 205                 mt->pitch * mt->total_height * mt->cpp );
 206
 207    return GL_TRUE;
 208 }
 209