gallium: Drop pipe_texture->cpp and pipe_surface->cpp.

The chars-per-pixel concept falls apart with compressed and yuv images,
where more than one pixel are coded in a single data block.

14 files changed, 229 insertions, 320 deletions

diff --git a/src/gallium/drivers/i915simple/i915_blit.c b/src/gallium/drivers/i915simple/i915_blit.c
index 22f91fab926..45fae4c9995 100644
--- a/src/gallium/drivers/i915simple/i915_blit.c
+++ b/src/gallium/drivers/i915simple/i915_blit.c
@@ -47,8 +47,6 @@ i915_fill_blit(struct i915_context *i915,
 {
    unsigned BR13, CMD;
 
-   dst_pitch *= (short) cpp;
-
    switch (cpp) {
    case 1:
    case 2:
diff --git a/src/gallium/drivers/i915simple/i915_context.h b/src/gallium/drivers/i915simple/i915_context.h
index 5d411a66486..c8db4f608c5 100644
--- a/src/gallium/drivers/i915simple/i915_context.h
+++ b/src/gallium/drivers/i915simple/i915_context.h
@@ -188,9 +188,9 @@ struct i915_texture {
 
    /* Derived from the above:
     */
-   unsigned pitch;
-   unsigned depth_pitch;          /* per-image on i945? */
-   unsigned total_height;
+   unsigned stride;
+   unsigned depth_stride;          /* per-image on i945? */
+   unsigned total_nblocksy;
 
    unsigned tiled;
 
diff --git a/src/gallium/drivers/i915simple/i915_state_emit.c b/src/gallium/drivers/i915simple/i915_state_emit.c
index 19d968fd8b6..9bd6f92323d 100644
--- a/src/gallium/drivers/i915simple/i915_state_emit.c
+++ b/src/gallium/drivers/i915simple/i915_state_emit.c
@@ -211,7 +211,7 @@ i915_emit_hardware_state(struct i915_context *i915 )
       struct pipe_surface *depth_surface = i915->framebuffer.zsbuf;
 
       if (cbuf_surface) {
-	 unsigned cpitch = (cbuf_surface->pitch * cbuf_surface->cpp);
+	 unsigned cpitch = cbuf_surface->stride;
 	 unsigned ctile = BUF_3D_USE_FENCE;
 	 if (cbuf_surface->texture &&
 	       ((struct i915_texture*)(cbuf_surface->texture))->tiled) {
@@ -232,7 +232,7 @@ i915_emit_hardware_state(struct i915_context *i915 )
       /* What happens if no zbuf??
        */
       if (depth_surface) {
-	 unsigned zpitch = (depth_surface->pitch * depth_surface->cpp);
+	 unsigned zpitch = depth_surface->stride;
 	 unsigned ztile = BUF_3D_USE_FENCE;
 	 if (depth_surface->texture &&
 	       ((struct i915_texture*)(depth_surface->texture))->tiled) {
diff --git a/src/gallium/drivers/i915simple/i915_state_sampler.c b/src/gallium/drivers/i915simple/i915_state_sampler.c
index 379aff38460..7868f21ca6a 100644
--- a/src/gallium/drivers/i915simple/i915_state_sampler.c
+++ b/src/gallium/drivers/i915simple/i915_state_sampler.c
@@ -242,7 +242,7 @@ i915_update_texture(struct i915_context *i915,
    assert(depth);
 
    format = translate_texture_format(pt->format);
-   pitch = tex->pitch * pt->cpp;
+   pitch = tex->stride;
 
    assert(format);
    assert(pitch);
diff --git a/src/gallium/drivers/i915simple/i915_surface.c b/src/gallium/drivers/i915simple/i915_surface.c
index cc55a0910ed..0061b22f268 100644
--- a/src/gallium/drivers/i915simple/i915_surface.c
+++ b/src/gallium/drivers/i915simple/i915_surface.c
@@ -48,7 +48,9 @@ i915_surface_copy(struct pipe_context *pipe,
 		  unsigned srcx, unsigned srcy, unsigned width, unsigned height)
 {
    assert( dst != src );
-   assert( dst->cpp == src->cpp );
+   assert( dst->block.size == src->block.size );
+   assert( dst->block.width == src->block.height );
+   assert( dst->block.height == src->block.height );
 
    if (0) {
       void *dst_map = pipe->screen->surface_map( pipe->screen,
@@ -60,38 +62,30 @@ i915_surface_copy(struct pipe_context *pipe,
                                                        PIPE_BUFFER_USAGE_CPU_READ );
       
       pipe_copy_rect(dst_map,
-                     dst->cpp,
-                     dst->pitch,
+                     &dst->block,
+                     dst->stride,
                      dstx, dsty, 
                      width, height, 
                      src_map, 
-                     do_flip ? -(int) src->pitch : src->pitch, 
+                     do_flip ? -(int) src->stride : src->stride, 
                      srcx, do_flip ? height - 1 - srcy : srcy);
 
       pipe->screen->surface_unmap(pipe->screen, src);
       pipe->screen->surface_unmap(pipe->screen, dst);
    }
    else {
+      assert(dst->block.width == 1);
+      assert(dst->block.height == 1);
       i915_copy_blit( i915_context(pipe),
                       do_flip,
-		      dst->cpp,
-		      (short) src->pitch, src->buffer, src->offset,
-		      (short) dst->pitch, dst->buffer, dst->offset,
+                      dst->block.size,
+		      (short) src->stride/src->block.size, src->buffer, src->offset,
+		      (short) dst->stride/dst->block.size, dst->buffer, dst->offset,
 		      (short) srcx, (short) srcy, (short) dstx, (short) dsty, (short) width, (short) height );
    }
 }
 
 
-/* Fill a rectangular sub-region.  Need better logic about when to
- * push buffers into AGP - will currently do so whenever possible.
- */
-static void *
-get_pointer(struct pipe_surface *dst, void *dst_map, unsigned x, unsigned y)
-{
-   return (char *)dst_map + (y * dst->pitch + x) * dst->cpp;
-}
-
-
 static void
 i915_surface_fill(struct pipe_context *pipe,
 		  struct pipe_surface *dst,
@@ -99,50 +93,20 @@ i915_surface_fill(struct pipe_context *pipe,
 		  unsigned width, unsigned height, unsigned value)
 {
    if (0) {
-      unsigned i, j;
       void *dst_map = pipe->screen->surface_map( pipe->screen,
                                                  dst,
                                                  PIPE_BUFFER_USAGE_CPU_WRITE );
 
-
-      switch (dst->cpp) {
-      case 1: {
-	 ubyte *row = get_pointer(dst, dst_map, dstx, dsty);
-	 for (i = 0; i < height; i++) {
-	    memset(row, value, width);
-	    row += dst->pitch;
-	 }
-      }
-	 break;
-      case 2: {
-	 ushort *row = get_pointer(dst, dst_map, dstx, dsty);
-	 for (i = 0; i < height; i++) {
-	    for (j = 0; j < width; j++)
-	       row[j] = (ushort) value;
-	    row += dst->pitch;
-	 }
-      }
-	 break;
-      case 4: {
-	 unsigned *row = get_pointer(dst, dst_map, dstx, dsty);
-	 for (i = 0; i < height; i++) {
-	    for (j = 0; j < width; j++)
-	       row[j] = value;
-	    row += dst->pitch;
-	 }
-      }
-	 break;
-      default:
-	 assert(0);
-	 break;
-      }
+      pipe_fill_rect(dst_map, &dst->block, dst->stride, dstx, dsty, width, height, value);
 
       pipe->screen->surface_unmap(pipe->screen, dst);
    }
    else {
+      assert(dst->block.width == 1);
+      assert(dst->block.height == 1);
       i915_fill_blit( i915_context(pipe),
-		      dst->cpp,
-		      (short) dst->pitch, 
+		      dst->block.size,
+		      (short) dst->stride/dst->block.size, 
 		      dst->buffer, dst->offset,
 		      (short) dstx, (short) dsty, 
 		      (short) width, (short) height, 
diff --git a/src/gallium/drivers/i915simple/i915_texture.c b/src/gallium/drivers/i915simple/i915_texture.c
index b2e490c7db1..2815e61345c 100644
--- a/src/gallium/drivers/i915simple/i915_texture.c
+++ b/src/gallium/drivers/i915simple/i915_texture.c
@@ -109,6 +109,9 @@ i915_miptree_set_level_info(struct i915_texture *tex,
    pt->width[level] = w;
    pt->height[level] = h;
    pt->depth[level] = d;
+   
+   pt->nblocksx[level] = pf_get_nblocksx(&pt->block, w);
+   pt->nblocksy[level] = pf_get_nblocksy(&pt->block, h);
 
    tex->nr_images[level] = nr_images;
 
@@ -140,7 +143,7 @@ i915_miptree_set_image_offset(struct i915_texture *tex,
 
    assert(img < tex->nr_images[level]);
 
-   tex->image_offset[level][img] = (x + y * tex->pitch);
+   tex->image_offset[level][img] = y * tex->stride + x * tex->base.block.size;
 
    /*
    printf("%s level %d img %d pos %d,%d image_offset %x\n",
@@ -162,7 +165,7 @@ i915_displaytarget_layout(struct i915_texture *tex)
 {
    struct pipe_texture *pt = &tex->base;
 
-   if (pt->last_level > 0 || pt->cpp != 4)
+   if (pt->last_level > 0 || pt->block.size != 4)
       return 0;
 
    i915_miptree_set_level_info( tex, 0, 1,
@@ -172,18 +175,18 @@ i915_displaytarget_layout(struct i915_texture *tex)
    i915_miptree_set_image_offset( tex, 0, 0, 0, 0 );
 
    if (tex->base.width[0] >= 128) {
-      tex->pitch = power_of_two(tex->base.width[0] * pt->cpp) / pt->cpp;
-      tex->total_height = round_up(tex->base.height[0], 8);
+      tex->stride = power_of_two(tex->base.nblocksx[0] * pt->block.size);
+      tex->total_nblocksy = round_up(tex->base.nblocksy[0], 8);
       tex->tiled = 1;
    } else {
-      tex->pitch = round_up(tex->base.width[0], 64 / pt->cpp);
-      tex->total_height = tex->base.height[0];
+      tex->stride = round_up(tex->base.nblocksx[0] * pt->block.size, 64);
+      tex->total_nblocksy = tex->base.nblocksy[0];
    }
 
    /*
    printf("%s size: %d,%d,%d offset %d,%d (0x%x)\n", __FUNCTION__,
-      tex->base.width[0], tex->base.height[0], pt->cpp,
-      tex->pitch, tex->total_height, tex->pitch * tex->total_height * 4);
+      tex->base.width[0], tex->base.height[0], pt->block.size,
+      tex->stride, tex->total_nblocksy, tex->stride * tex->total_nblocksy);
    */
 
    return 1;
@@ -193,12 +196,14 @@ static void
 i945_miptree_layout_2d( struct i915_texture *tex )
 {
    struct pipe_texture *pt = &tex->base;
-   int align_h = 2, align_w = 4;
+   const int align_x = 2, align_y = 4;
    unsigned level;
    unsigned x = 0;
    unsigned y = 0;
    unsigned width = pt->width[0];
    unsigned height = pt->height[0];
+   unsigned nblocksx = pt->nblocksx[0];
+   unsigned nblocksy = pt->nblocksy[0];
 
 #if 0 /* used for tiled display targets */
    if (pt->last_level == 0 && pt->cpp == 4)
@@ -206,7 +211,7 @@ i945_miptree_layout_2d( struct i915_texture *tex )
 	 return;
 #endif
 
-   tex->pitch = pt->width[0];
+   tex->stride = round_up(pt->nblocksx[0] * pt->block.size, 4);
 
    /* May need to adjust pitch to accomodate the placement of
     * the 2nd mipmap level.  This occurs when the alignment
@@ -214,47 +219,43 @@ i945_miptree_layout_2d( struct i915_texture *tex )
     * 2nd mipmap level out past the width of its parent.
     */
    if (pt->last_level > 0) {
-      unsigned mip1_width = align_int(minify(pt->width[0]), align_w)
-			+ minify(minify(pt->width[0]));
+      unsigned mip1_nblocksx 
+	 = align_int(pf_get_nblocksx(&pt->block, minify(width)), align_x)
+         + pf_get_nblocksx(&pt->block, minify(minify(width)));
 
-      if (mip1_width > pt->width[0])
-	 tex->pitch = mip1_width;
+      if (mip1_nblocksx > nblocksx)
+	 tex->stride = mip1_nblocksx * pt->block.size;
    }
 
-   /* Pitch must be a whole number of dwords, even though we
-    * express it in texels.
+   /* Pitch must be a whole number of dwords
     */
-   tex->pitch = align_int(tex->pitch * pt->cpp, 64) / pt->cpp;
-   tex->total_height = 0;
+   tex->stride = align_int(tex->stride, 64);
+   tex->total_nblocksy = 0;
 
    for (level = 0; level <= pt->last_level; level++) {
-      unsigned img_height;
-
       i915_miptree_set_level_info(tex, level, 1, width, height, 1);
       i915_miptree_set_image_offset(tex, level, 0, x, y);
 
-      if (pt->compressed)
-	 img_height = MAX2(1, height/4);
-      else
-	 img_height = align_int(height, align_h);
-
+      nblocksy = align_int(nblocksy, align_y);
 
       /* Because the images are packed better, the final offset
        * might not be the maximal one:
        */
-      tex->total_height = MAX2(tex->total_height, y + img_height);
+      tex->total_nblocksy = MAX2(tex->total_nblocksy, y + nblocksy);
 
       /* Layout_below: step right after second mipmap level.
        */
       if (level == 1) {
-	 x += align_int(width, align_w);
+	 x += align_int(nblocksx, align_x);
       }
       else {
-	 y += img_height;
+	 y += nblocksy;
       }
 
       width  = minify(width);
       height = minify(height);
+      nblocksx = pf_get_nblocksx(&pt->block, width);
+      nblocksy = pf_get_nblocksy(&pt->block, height);
    }
 }
 
@@ -264,15 +265,16 @@ i945_miptree_layout_cube(struct i915_texture *tex)
    struct pipe_texture *pt = &tex->base;
    unsigned level;
 
-   const unsigned dim = pt->width[0];
+   const unsigned nblocks = pt->nblocksx[0];
    unsigned face;
-   unsigned lvlWidth = pt->width[0], lvlHeight = pt->height[0];
+   unsigned width = pt->width[0];
+   unsigned height = pt->height[0];
 
    /*
    printf("%s %i, %i\n", __FUNCTION__, pt->width[0], pt->height[0]);
    */
 
-   assert(lvlWidth == lvlHeight); /* cubemap images are square */
+   assert(width == height); /* cubemap images are square */
 
    /*
     * XXX Should only be used for compressed formats. But lets
@@ -282,35 +284,32 @@ i945_miptree_layout_cube(struct i915_texture *tex)
     * determined either by the old-style packing of cubemap faces,
     * or the final row of 4x4, 2x2 and 1x1 faces below this.
     */
-   if (dim > 32)
-      tex->pitch = ((dim * pt->cpp * 2 + 3) & ~3) / pt->cpp;
+   if (nblocks > 32)
+      tex->stride = round_up(nblocks * pt->block.size * 2, 4);
    else
-      tex->pitch = 14 * 8;
+      tex->stride = 14 * 8 * pt->block.size;
 
-   /*
-    * XXX The 4 is only needed for compressed formats. See above.
-    */
-   tex->total_height = dim * 4 + 4;
+   tex->total_nblocksy = nblocks * 4;
 
    /* Set all the levels to effectively occupy the whole rectangular region.
    */
    for (level = 0; level <= pt->last_level; level++) {
-      i915_miptree_set_level_info(tex, level, 6, lvlWidth, lvlHeight, 1);
-      lvlWidth /= 2;
-      lvlHeight /= 2;
+      i915_miptree_set_level_info(tex, level, 6, width, height, 1);
+      width /= 2;
+      height /= 2;
    }
 
    for (face = 0; face < 6; face++) {
-      unsigned x = initial_offsets[face][0] * dim;
-      unsigned y = initial_offsets[face][1] * dim;
-      unsigned d = dim;
+      unsigned x = initial_offsets[face][0] * nblocks;
+      unsigned y = initial_offsets[face][1] * nblocks;
+      unsigned d = nblocks;
 
 #if 0 /* Fix and enable this code for compressed formats */
-      if (dim == 4 && face >= 4) {
+      if (nblocks == 4 && face >= 4) {
          y = tex->total_height - 4;
          x = (face - 4) * 8;
       }
-      else if (dim < 4 && (face > 0)) {
+      else if (nblocks < 4 && (face > 0)) {
          y = tex->total_height - 4;
          x = face * 8;
       }
@@ -369,28 +368,28 @@ i915_miptree_layout(struct i915_texture * tex)
 
    switch (pt->target) {
    case PIPE_TEXTURE_CUBE: {
-         const unsigned dim = pt->width[0];
+         const unsigned nblocks = pt->nblocksx[0];
          unsigned face;
-         unsigned lvlWidth = pt->width[0], lvlHeight = pt->height[0];
+         unsigned width = pt->width[0], height = pt->height[0];
 
-         assert(lvlWidth == lvlHeight); /* cubemap images are square */
+         assert(width == height); /* cubemap images are square */
 
          /* double pitch for cube layouts */
-         tex->pitch = ((dim * pt->cpp * 2 + 3) & ~3) / pt->cpp;
-         tex->total_height = dim * 4;
+         tex->stride = round_up(nblocks * pt->block.size * 2, 4);
+         tex->total_nblocksy = nblocks * 4;
 
          for (level = 0; level <= pt->last_level; level++) {
             i915_miptree_set_level_info(tex, level, 6,
-                                         lvlWidth, lvlHeight,
+                                         width, height,
                                          1);
-            lvlWidth /= 2;
-            lvlHeight /= 2;
+            width /= 2;
+            height /= 2;
          }
 
          for (face = 0; face < 6; face++) {
-            unsigned x = initial_offsets[face][0] * dim;
-            unsigned y = initial_offsets[face][1] * dim;
-            unsigned d = dim;
+            unsigned x = initial_offsets[face][0] * nblocks;
+            unsigned y = initial_offsets[face][1] * nblocks;
+            unsigned d = nblocks;
 
             for (level = 0; level <= pt->last_level; level++) {
                i915_miptree_set_image_offset(tex, level, face, x, y);
@@ -405,25 +404,29 @@ i915_miptree_layout(struct i915_texture * tex)
          unsigned width = pt->width[0];
          unsigned height = pt->height[0];
          unsigned depth = pt->depth[0];
-         unsigned stack_height = 0;
+         unsigned nblocksx = pt->nblocksx[0];
+         unsigned nblocksy = pt->nblocksy[0];
+         unsigned stack_nblocksy = 0;
 
          /* Calculate the size of a single slice. 
           */
-         tex->pitch = ((pt->width[0] * pt->cpp + 3) & ~3) / pt->cpp;
+         tex->stride = round_up(pt->nblocksx[0] * pt->block.size, 4);
 
          /* XXX: hardware expects/requires 9 levels at minimum.
           */
          for (level = 0; level <= MAX2(8, pt->last_level);
               level++) {
             i915_miptree_set_level_info(tex, level, depth,
-                                         width, height, depth);
+                                        width, height, depth);
 
 
-            stack_height += MAX2(2, height);
+            stack_nblocksy += MAX2(2, nblocksy);
 
             width = minify(width);
             height = minify(height);
             depth = minify(depth);
+            nblocksx = pf_get_nblocksx(&pt->block, width);
+            nblocksy = pf_get_nblocksy(&pt->block, height);
          }
 
          /* Fixup depth image_offsets: 
@@ -433,7 +436,7 @@ i915_miptree_layout(struct i915_texture * tex)
             unsigned i;
             for (i = 0; i < depth; i++) 
                i915_miptree_set_image_offset(tex, level, i,
-                                              0, i * stack_height);
+                                             0, i * stack_nblocksy);
 
             depth = minify(depth);
          }
@@ -443,33 +446,33 @@ i915_miptree_layout(struct i915_texture * tex)
           * remarkable how wasteful of memory the i915 texture layouts
           * are.  They are largely fixed in the i945.
           */
-         tex->total_height = stack_height * pt->depth[0];
+         tex->total_nblocksy = stack_nblocksy * pt->depth[0];
          break;
       }
 
    default:{
          unsigned width = pt->width[0];
          unsigned height = pt->height[0];
-	 unsigned img_height;
+         unsigned nblocksx = pt->nblocksx[0];
+         unsigned nblocksy = pt->nblocksy[0];
 
-         tex->pitch = ((pt->width[0] * pt->cpp + 3) & ~3) / pt->cpp;
-         tex->total_height = 0;
+         tex->stride = round_up(pt->nblocksx[0] * pt->block.size, 4);
+         tex->total_nblocksy = 0;
 
          for (level = 0; level <= pt->last_level; level++) {
             i915_miptree_set_level_info(tex, level, 1,
-                                         width, height, 1);
+                                        width, height, 1);
             i915_miptree_set_image_offset(tex, level, 0,
-                                           0, tex->total_height);
+                                          0, tex->total_nblocksy);
 
-            if (pt->compressed)
-               img_height = MAX2(1, height / 4);
-            else
-               img_height = (MAX2(2, height) + 1) & ~1;
+            nblocksy = round_up(MAX2(2, nblocksy), 2);
 
-	    tex->total_height += img_height;
+	    tex->total_nblocksy += nblocksy;
 
             width = minify(width);
             height = minify(height);
+            nblocksx = pf_get_nblocksx(&pt->block, width);
+            nblocksy = pf_get_nblocksy(&pt->block, height);
          }
          break;
       }
@@ -477,7 +480,7 @@ i915_miptree_layout(struct i915_texture * tex)
    /*
    DBG("%s: %dx%dx%d - sz 0x%x\n", __FUNCTION__,
        tex->pitch,
-       tex->total_height, pt->cpp, tex->pitch * tex->total_height * pt->cpp);
+       tex->total_nblocksy, pt->block.size, tex->stride * tex->total_nblocksy);
    */
 
    return TRUE;
@@ -498,14 +501,16 @@ i945_miptree_layout(struct i915_texture * tex)
          unsigned width = pt->width[0];
          unsigned height = pt->height[0];
          unsigned depth = pt->depth[0];
+         unsigned nblocksx = pt->nblocksx[0];
+         unsigned nblocksy = pt->nblocksy[0];
          unsigned pack_x_pitch, pack_x_nr;
          unsigned pack_y_pitch;
 
-         tex->pitch = ((pt->width[0] * pt->cpp + 3) & ~3) / pt->cpp;
-         tex->total_height = 0;
+         tex->stride = round_up(pt->nblocksx[0] * pt->block.size, 4);
+         tex->total_nblocksy = 0;
 
-         pack_y_pitch = MAX2(pt->height[0], 2);
-         pack_x_pitch = tex->pitch;
+         pack_y_pitch = MAX2(pt->nblocksy[0], 2);
+         pack_x_pitch = tex->stride / pt->block.size;
          pack_x_nr = 1;
 
          for (level = 0; level <= pt->last_level; level++) {
@@ -515,11 +520,11 @@ i945_miptree_layout(struct i915_texture * tex)
             unsigned q, j;
 
             i915_miptree_set_level_info(tex, level, nr_images,
-                                         width, height, depth);
+                                        width, height, depth);
 
             for (q = 0; q < nr_images;) {
                for (j = 0; j < pack_x_nr && q < nr_images; j++, q++) {
-                  i915_miptree_set_image_offset(tex, level, q, x, y + tex->total_height);
+                  i915_miptree_set_image_offset(tex, level, q, x, y + tex->total_nblocksy);
                   x += pack_x_pitch;
                }
 
@@ -528,12 +533,12 @@ i945_miptree_layout(struct i915_texture * tex)
             }
 
 
-            tex->total_height += y;
+            tex->total_nblocksy += y;
 
             if (pack_x_pitch > 4) {
                pack_x_pitch >>= 1;
                pack_x_nr <<= 1;
-               assert(pack_x_pitch * pack_x_nr <= tex->pitch);
+               assert(pack_x_pitch * pack_x_nr * pt->block.size <= tex->stride);
             }
 
             if (pack_y_pitch > 2) {
@@ -543,6 +548,8 @@ i945_miptree_layout(struct i915_texture * tex)
             width = minify(width);
             height = minify(height);
             depth = minify(depth);
+            nblocksx = pf_get_nblocksx(&pt->block, width);
+            nblocksy = pf_get_nblocksy(&pt->block, height);
          }
          break;
       }
@@ -560,7 +567,7 @@ i945_miptree_layout(struct i915_texture * tex)
    /*
    DBG("%s: %dx%dx%d - sz 0x%x\n", __FUNCTION__,
        tex->pitch,
-       tex->total_height, pt->cpp, tex->pitch * tex->total_height * pt->cpp);
+       tex->total_nblocksy, pt->block.size, tex->stride * tex->total_nblocksy);
    */
 
    return TRUE;
@@ -582,6 +589,9 @@ i915_texture_create(struct pipe_screen *screen,
    tex->base.refcount = 1;
    tex->base.screen = screen;
 
+   tex->base.nblocksx[0] = pf_get_nblocksx(&tex->base.block, tex->base.width[0]);
+   tex->base.nblocksy[0] = pf_get_nblocksy(&tex->base.block, tex->base.height[0]);
+   
    if (i915screen->is_i945) {
       if (!i945_miptree_layout(tex))
 	 goto fail;
@@ -592,8 +602,8 @@ i915_texture_create(struct pipe_screen *screen,
 
    tex->buffer = ws->buffer_create(ws, 64,
 				   PIPE_BUFFER_USAGE_PIXEL,
-				   tex->pitch * tex->base.cpp *
-				   tex->total_height);
+				   tex->stride *
+				   tex->total_nblocksy);
 
    if (!tex->buffer)
       goto fail;
@@ -648,13 +658,13 @@ i915_get_tex_surface(struct pipe_screen *screen,
    unsigned offset;  /* in bytes */
 
    if (pt->target == PIPE_TEXTURE_CUBE) {
-      offset = tex->image_offset[level][face] * pt->cpp;
+      offset = tex->image_offset[level][face];
    }
    else if (pt->target == PIPE_TEXTURE_3D) {
-      offset = tex->image_offset[level][zslice] * pt->cpp;
+      offset = tex->image_offset[level][zslice];
    }
    else {
-      offset = tex->image_offset[level][0] * pt->cpp;
+      offset = tex->image_offset[level][0];
       assert(face == 0);
       assert(zslice == 0);
    }
@@ -666,10 +676,12 @@ i915_get_tex_surface(struct pipe_screen *screen,
       pipe_texture_reference(&ps->texture, pt);
       pipe_buffer_reference(ws, &ps->buffer, tex->buffer);
       ps->format = pt->format;
-      ps->cpp = pt->cpp;
       ps->width = pt->width[level];
       ps->height = pt->height[level];
-      ps->pitch = tex->pitch;
+      ps->block = pt->block;
+      ps->nblocksx = pt->nblocksx[level];
+      ps->nblocksy = pt->nblocksy[level];
+      ps->stride = tex->stride;
       ps->offset = offset;
       ps->usage = flags;
       ps->status = PIPE_SURFACE_STATUS_DEFINED;
@@ -680,7 +692,7 @@ i915_get_tex_surface(struct pipe_screen *screen,
 static struct pipe_texture *
 i915_texture_blanket(struct pipe_screen * screen,
                      const struct pipe_texture *base,
-                     const unsigned *pitch,
+                     const unsigned *stride,
                      struct pipe_buffer *buffer)
 {
    struct i915_texture *tex;
@@ -699,7 +711,7 @@ i915_texture_blanket(struct pipe_screen * screen,
 
    tex->base = *base;
 
-   tex->pitch = pitch[0];
+   tex->stride = stride[0];
 
    i915_miptree_set_level_info(tex, 0, 1, base->width[0], base->height[0], 1);
    i915_miptree_set_image_offset(tex, 0, 0, 0, 0);
diff --git a/src/gallium/drivers/i965simple/brw_context.h b/src/gallium/drivers/i965simple/brw_context.h
index 8ac6b4e6897..2cae7665f78 100644
--- a/src/gallium/drivers/i965simple/brw_context.h
+++ b/src/gallium/drivers/i965simple/brw_context.h
@@ -231,9 +231,9 @@ struct brw_texture {
 
    /* Derived from the above:
     */
-   unsigned pitch;
+   unsigned stride;
    unsigned depth_pitch;          /* per-image on i945? */
-   unsigned total_height;
+   unsigned total_nblocksy;
 
    unsigned nr_images[PIPE_MAX_TEXTURE_LEVELS];
 
diff --git a/src/gallium/drivers/i965simple/brw_misc_state.c b/src/gallium/drivers/i965simple/brw_misc_state.c
index 925049ecc19..be812c5da92 100644
--- a/src/gallium/drivers/i965simple/brw_misc_state.c
+++ b/src/gallium/drivers/i965simple/brw_misc_state.c
@@ -224,7 +224,9 @@ static void upload_depthbuffer(struct brw_context *brw)
    } else {
       unsigned int format;
 
-      switch (depth_surface->cpp) {
+      assert(depth_surface->block.width == 1);
+      assert(depth_surface->block.height == 1);
+      switch (depth_surface->block.size) {
       case 2:
 	 format = BRW_DEPTHFORMAT_D16_UNORM;
 	 break;
@@ -239,7 +241,7 @@ static void upload_depthbuffer(struct brw_context *brw)
 	 return;
       }
 
-      OUT_BATCH(((depth_surface->pitch * depth_surface->cpp) - 1) |
+      OUT_BATCH((depth_surface->stride - 1) |
 		(format << 18) |
 		(BRW_TILEWALK_YMAJOR << 26) |
 //		(depth_surface->region->tiled << 27) |
@@ -247,7 +249,7 @@ static void upload_depthbuffer(struct brw_context *brw)
       OUT_RELOC(depth_surface->buffer,
 		PIPE_BUFFER_USAGE_GPU_READ | PIPE_BUFFER_USAGE_GPU_WRITE, 0);
       OUT_BATCH((BRW_SURFACE_MIPMAPLAYOUT_BELOW << 1) |
-		((depth_surface->pitch - 1) << 6) |
+		((depth_surface->stride/depth_surface->block.size - 1) << 6) |
 		((depth_surface->height - 1) << 19));
       OUT_BATCH(0);
    }
diff --git a/src/gallium/drivers/i965simple/brw_surface.c b/src/gallium/drivers/i965simple/brw_surface.c
index 3d98a2bf199..0be3dfc7438 100644
--- a/src/gallium/drivers/i965simple/brw_surface.c
+++ b/src/gallium/drivers/i965simple/brw_surface.c
@@ -47,8 +47,10 @@ brw_surface_copy(struct pipe_context *pipe,
                  struct pipe_surface *src,
                  unsigned srcx, unsigned srcy, unsigned width, unsigned height)
 {
-   assert(dst != src);
-   assert(dst->cpp == src->cpp);
+   assert( dst != src );
+   assert( dst->block.size == src->block.size );
+   assert( dst->block.width == src->block.height );
+   assert( dst->block.height == src->block.height );
 
    if (0) {
       void *dst_map = pipe->screen->surface_map( pipe->screen,
@@ -60,37 +62,30 @@ brw_surface_copy(struct pipe_context *pipe,
                                                        PIPE_BUFFER_USAGE_CPU_READ );
       
       pipe_copy_rect(dst_map,
-                     dst->cpp,
-                     dst->pitch,
+                     &dst->block,
+                     dst->stride,
                      dstx, dsty, 
                      width, height, 
                      src_map, 
-                     do_flip ? -(int) src->pitch : src->pitch, 
+                     do_flip ? -(int) src->stride : src->stride, 
                      srcx, do_flip ? height - 1 - srcy : srcy);
 
       pipe->screen->surface_unmap(pipe->screen, src);
       pipe->screen->surface_unmap(pipe->screen, dst);
    }
    else {
+      assert(dst->block.width == 1);
+      assert(dst->block.height == 1);
       brw_copy_blit(brw_context(pipe),
                     do_flip,
-                    dst->cpp,
-                    (short) src->pitch, src->buffer, src->offset, FALSE,
-                    (short) dst->pitch, dst->buffer, dst->offset, FALSE,
+                    dst->block.size,
+                    (short) src->stride/src->block.size, src->buffer, src->offset, FALSE,
+                    (short) dst->stride/dst->block.size, dst->buffer, dst->offset, FALSE,
                     (short) srcx, (short) srcy, (short) dstx, (short) dsty,
                     (short) width, (short) height, PIPE_LOGICOP_COPY);
    }
 }
 
-/* Fill a rectangular sub-region.  Need better logic about when to
- * push buffers into AGP - will currently do so whenever possible.
- */
-static void *
-get_pointer(struct pipe_surface *dst, void *dst_map, unsigned x, unsigned y)
-{
-   return (char *)dst_map + (y * dst->pitch + x) * dst->cpp;
-}
-
 
 static void
 brw_surface_fill(struct pipe_context *pipe,
@@ -99,50 +94,20 @@ brw_surface_fill(struct pipe_context *pipe,
                  unsigned width, unsigned height, unsigned value)
 {
    if (0) {
-      unsigned i, j;
       void *dst_map = pipe->screen->surface_map( pipe->screen,
                                                  dst,
                                                  PIPE_BUFFER_USAGE_CPU_WRITE );
 
-
-      switch (dst->cpp) {
-      case 1: {
-	 ubyte *row = get_pointer(dst, dst_map, dstx, dsty);
-	 for (i = 0; i < height; i++) {
-	    memset(row, value, width);
-	    row += dst->pitch;
-	 }
-      }
-	 break;
-      case 2: {
-	 ushort *row = get_pointer(dst, dst_map, dstx, dsty);
-	 for (i = 0; i < height; i++) {
-	    for (j = 0; j < width; j++)
-	       row[j] = (ushort) value;
-	    row += dst->pitch;
-	 }
-      }
-	 break;
-      case 4: {
-	 unsigned *row = get_pointer(dst, dst_map, dstx, dsty);
-	 for (i = 0; i < height; i++) {
-	    for (j = 0; j < width; j++)
-	       row[j] = value;
-	    row += dst->pitch;
-	 }
-      }
-	 break;
-      default:
-	 assert(0);
-	 break;
-      }
+      pipe_fill_rect(dst_map, &dst->block, dst->stride, dstx, dsty, width, height, value);
 
       pipe->screen->surface_unmap(pipe->screen, dst);
    }
    else {
+      assert(dst->block.width == 1);
+      assert(dst->block.height == 1);
       brw_fill_blit(brw_context(pipe),
-                    dst->cpp,
-                    (short) dst->pitch,
+                    dst->block.size,
+                    (short) dst->stride/dst->block.size, 
                     dst->buffer, dst->offset, FALSE,
                     (short) dstx, (short) dsty,
                     (short) width, (short) height,
diff --git a/src/gallium/drivers/i965simple/brw_tex_layout.c b/src/gallium/drivers/i965simple/brw_tex_layout.c
index 78ae0b1223e..8c7725605be 100644
--- a/src/gallium/drivers/i965simple/brw_tex_layout.c
+++ b/src/gallium/drivers/i965simple/brw_tex_layout.c
@@ -81,7 +81,7 @@ static void intel_miptree_set_image_offset(struct brw_texture *tex,
       assert(x == 0 && y == 0);
    assert(img < tex->nr_images[level]);
 
-   tex->image_offset[level][img] = (x + y * tex->pitch) * pt->cpp;
+   tex->image_offset[level][img] = y * tex->stride + x * pt->block.size;
 }
 
 static void intel_miptree_set_level_info(struct brw_texture *tex,
@@ -97,8 +97,11 @@ static void intel_miptree_set_level_info(struct brw_texture *tex,
    pt->width[level] = w;
    pt->height[level] = h;
    pt->depth[level] = d;
+   
+   pt->nblocksx[level] = pf_get_nblocksx(&pt->block, w);
+   pt->nblocksy[level] = pf_get_nblocksy(&pt->block, h);
 
-   tex->level_offset[level] = (x + y * tex->pitch) * pt->cpp;
+   tex->level_offset[level] = y * tex->stride + x * tex->base.block.size;
    tex->nr_images[level] = nr_images;
 
    /*
@@ -123,77 +126,60 @@ static void intel_miptree_set_level_info(struct brw_texture *tex,
 static void i945_miptree_layout_2d(struct brw_texture *tex)
 {
    struct pipe_texture *pt = &tex->base;
-   unsigned align_h = 2, align_w = 4;
+   const int align_x = 2, align_y = 4;
    unsigned level;
    unsigned x = 0;
    unsigned y = 0;
    unsigned width = pt->width[0];
    unsigned height = pt->height[0];
+   unsigned nblocksx = pt->nblocksx[0];
+   unsigned nblocksy = pt->nblocksy[0];
 
-   tex->pitch = pt->width[0];
-
-#if 0
-   if (pt->compressed) {
-      align_w = intel_compressed_alignment(pt->internal_format);
-      tex->pitch = ALIGN(pt->width[0], align_w);
-   }
-#endif
+   tex->stride = align(pt->nblocksx[0] * pt->block.size, 4);
 
    /* May need to adjust pitch to accomodate the placement of
-    * the 2nd mipmap.  This occurs when the alignment
+    * the 2nd mipmap level.  This occurs when the alignment
     * constraints of mipmap placement push the right edge of the
-    * 2nd mipmap out past the width of its parent.
+    * 2nd mipmap level out past the width of its parent.
     */
    if (pt->last_level > 0) {
-      unsigned mip1_width;
-
-      if (pt->compressed) {
-         mip1_width = align(minify(pt->width[0]), align_w)
-                      + align(minify(minify(pt->width[0])), align_w);
-      } else {
-         mip1_width = align(minify(pt->width[0]), align_w)
-                      + minify(minify(pt->width[0]));
-      }
+      unsigned mip1_nblocksx 
+	 = align_int(pf_get_nblocksx(&pt->block, minify(width)), align_x)
+         + pf_get_nblocksx(&pt->block, minify(minify(width)));
 
-      if (mip1_width > tex->pitch) {
-         tex->pitch = mip1_width;
-      }
+      if (mip1_nblocksx > nblocksx)
+	 tex->stride = mip1_nblocksx * pt->block.size;
    }
 
-   /* Pitch must be a whole number of dwords, even though we
-    * express it in texels.
+   /* Pitch must be a whole number of dwords
     */
-   tex->pitch = align(tex->pitch * pt->cpp, 4) / pt->cpp;
-   tex->total_height = 0;
+   tex->stride = align_int(tex->stride, 64);
+   tex->total_nblocksy = 0;
 
    for (level = 0; level <= pt->last_level; level++) {
-      unsigned img_height;
-
       intel_miptree_set_level_info(tex, level, 1, x, y, width,
 				   height, 1);
 
-      if (pt->compressed)
-	 img_height = MAX2(1, height/4);
-      else
-	 img_height = align(height, align_h);
-
+      nblocksy = align_int(nblocksy, align_y);
 
       /* Because the images are packed better, the final offset
        * might not be the maximal one:
        */
-      tex->total_height = MAX2(tex->total_height, y + img_height);
+      tex->total_nblocksy = MAX2(tex->total_nblocksy, y + nblocksy);
 
-      /* Layout_below: step right after second mipmap.
+      /* Layout_below: step right after second mipmap level.
        */
       if (level == 1) {
-	 x += align(width, align_w);
+	 x += align_int(nblocksx, align_x);
       }
       else {
-	 y += img_height;
+	 y += nblocksy;
       }
 
       width  = minify(width);
       height = minify(height);
+      nblocksx = pf_get_nblocksx(&pt->block, width);
+      nblocksy = pf_get_nblocksy(&pt->block, height);
    }
 }
 
@@ -210,26 +196,20 @@ static boolean brw_miptree_layout(struct brw_texture *tex)
       unsigned width  = pt->width[0];
       unsigned height = pt->height[0];
       unsigned depth = pt->depth[0];
+      unsigned nblocksx = pt->nblocksx[0];
+      unsigned nblocksy = pt->nblocksy[0];
       unsigned pack_x_pitch, pack_x_nr;
       unsigned pack_y_pitch;
       unsigned level;
       unsigned align_h = 2;
       unsigned align_w = 4;
 
-      tex->total_height = 0;
-#if 0
-      if (pt->compressed) {
-         align_w = intel_compressed_alignment(pt->internal_format);
-         pt->pitch = align(width, align_w);
-         pack_y_pitch = (height + 3) / 4;
-      } else
-#endif
-      {
-         tex->pitch = align(pt->width[0] * pt->cpp, 4) / pt->cpp;
-         pack_y_pitch = align(pt->height[0], align_h);
-      }
+      tex->total_nblocksy = 0;
+
+      tex->stride = align(pt->nblocksx[0], 4);
+      pack_y_pitch = align(pt->nblocksy[0], align_h);
 
-      pack_x_pitch = tex->pitch;
+      pack_x_pitch = tex->stride / pt->block.size;
       pack_x_nr = 1;
 
       for (level = 0; level <= pt->last_level; level++) {
@@ -239,7 +219,7 @@ static boolean brw_miptree_layout(struct brw_texture *tex)
 	 uint q, j;
 
 	 intel_miptree_set_level_info(tex, level, nr_images,
-				      0, tex->total_height,
+				      0, tex->total_nblocksy,
 				      width, height, depth);
 
 	 for (q = 0; q < nr_images;) {
@@ -253,10 +233,12 @@ static boolean brw_miptree_layout(struct brw_texture *tex)
 	 }
 
 
-	 tex->total_height += y;
+	 tex->total_nblocksy += y;
 	 width  = minify(width);
 	 height = minify(height);
 	 depth  = minify(depth);
+         nblocksx = pf_get_nblocksx(&pt->block, width);
+         nblocksy = pf_get_nblocksy(&pt->block, height);
 
          if (pt->compressed) {
             pack_y_pitch = (height + 3) / 4;
@@ -269,7 +251,7 @@ static boolean brw_miptree_layout(struct brw_texture *tex)
             if (pack_x_pitch > 4) {
                pack_x_pitch >>= 1;
                pack_x_nr <<= 1;
-               assert(pack_x_pitch * pack_x_nr <= tex->pitch);
+               assert(pack_x_pitch * pack_x_nr * pt->block.size <= tex->stride);
             }
 
             if (pack_y_pitch > 2) {
@@ -289,9 +271,9 @@ static boolean brw_miptree_layout(struct brw_texture *tex)
 #if 0
    PRINT("%s: %dx%dx%d - sz 0x%x\n", __FUNCTION__,
        pt->pitch,
-       pt->total_height,
-       pt->cpp,
-       pt->pitch * pt->total_height * pt->cpp );
+       pt->total_nblocksy,
+       pt->block.size,
+       pt->stride * pt->total_nblocksy );
 #endif
 
    return TRUE;
@@ -309,11 +291,14 @@ brw_texture_create_screen(struct pipe_screen *screen,
       tex->base = *templat;
       tex->base.refcount = 1;
 
+      tex->base.nblocksx[0] = pf_get_nblocksx(&tex->base.block, tex->base.width[0]);
+      tex->base.nblocksy[0] = pf_get_nblocksy(&tex->base.block, tex->base.height[0]);
+   
       if (brw_miptree_layout(tex))
 	 tex->buffer = ws->buffer_create(ws, 64,
                                          PIPE_BUFFER_USAGE_PIXEL,
-                                         tex->pitch * tex->base.cpp *
-                                         tex->total_height);
+                                         tex->stride *
+                                         tex->total_nblocksy);
 
       if (!tex->buffer) {
 	 FREE(tex);
@@ -370,10 +355,10 @@ brw_get_tex_surface_screen(struct pipe_screen *screen,
    offset = tex->level_offset[level];
 
    if (pt->target == PIPE_TEXTURE_CUBE) {
-      offset += tex->image_offset[level][face] * pt->cpp;
+      offset += tex->image_offset[level][face];
    }
    else if (pt->target == PIPE_TEXTURE_3D) {
-      offset += tex->image_offset[level][zslice] * pt->cpp;
+      offset += tex->image_offset[level][zslice];
    }
    else {
       assert(face == 0);
@@ -386,10 +371,12 @@ brw_get_tex_surface_screen(struct pipe_screen *screen,
       assert(ps->refcount);
       pipe_buffer_reference(ws, &ps->buffer, tex->buffer);
       ps->format = pt->format;
-      ps->cpp = pt->cpp;
       ps->width = pt->width[level];
       ps->height = pt->height[level];
-      ps->pitch = tex->pitch;
+      ps->block = pt->block;
+      ps->nblocksx = pt->nblocksx[level];
+      ps->nblocksy = pt->nblocksy[level];
+      ps->stride = tex->stride;
       ps->offset = offset;
    }
    return ps;
diff --git a/src/gallium/drivers/i965simple/brw_wm_surface_state.c b/src/gallium/drivers/i965simple/brw_wm_surface_state.c
index 69e56dc8bd3..1a326f99186 100644
--- a/src/gallium/drivers/i965simple/brw_wm_surface_state.c
+++ b/src/gallium/drivers/i965simple/brw_wm_surface_state.c
@@ -160,7 +160,7 @@ void brw_update_texture_surface( struct brw_context *brw,
 
    surf.ss3.tile_walk = BRW_TILEWALK_XMAJOR;
    surf.ss3.tiled_surface = 0; /* always zero */
-   surf.ss3.pitch = tObj->pitch - 1;
+   surf.ss3.pitch = tObj->stride - 1;
    surf.ss3.depth = tObj->base.depth[0] - 1;
 
    surf.ss4.min_lod = 0;
@@ -197,7 +197,7 @@ static void upload_wm_surfaces(struct brw_context *brw )
       memset(&surf, 0, sizeof(surf));
 
       if (pipe_surface != NULL) {
-	 if (pipe_surface->cpp == 4)
+	 if (pipe_surface->block.size == 4)
 	    surf.ss0.surface_format = BRW_SURFACEFORMAT_B8G8R8A8_UNORM;
 	 else
 	    surf.ss0.surface_format = BRW_SURFACEFORMAT_B5G6R5_UNORM;
@@ -210,7 +210,7 @@ static void upload_wm_surfaces(struct brw_context *brw )
 	 surf.ss2.height = pipe_surface->height - 1;
 	 surf.ss3.tile_walk = BRW_TILEWALK_XMAJOR;
 	 surf.ss3.tiled_surface = 0;
-	 surf.ss3.pitch = (pipe_surface->pitch * pipe_surface->cpp) - 1;
+	 surf.ss3.pitch = pipe_surface->stride - 1;
       } else {
 	 surf.ss0.surface_format = BRW_SURFACEFORMAT_B8G8R8A8_UNORM;
 	 surf.ss0.surface_type = BRW_SURFACE_NULL;
diff --git a/src/gallium/drivers/softpipe/sp_surface.c b/src/gallium/drivers/softpipe/sp_surface.c
index 9fd48aeccc5..7dc15c38d10 100644
--- a/src/gallium/drivers/softpipe/sp_surface.c
+++ b/src/gallium/drivers/softpipe/sp_surface.c
@@ -58,18 +58,20 @@ sp_surface_copy(struct pipe_context *pipe,
                                                     src,
                                                     PIPE_BUFFER_USAGE_CPU_READ );
 
-   assert(dst->cpp == src->cpp);
+   assert(dst->block.size == src->block.size);
+   assert(dst->block.width == src->block.width);
+   assert(dst->block.height == src->block.height);
    assert(src_map);
    assert(dst_map);
 
    /* If do_flip, invert src_y position and pass negative src stride */
    pipe_copy_rect(dst_map,
-                  dst->cpp,
-                  dst->pitch,
+                  &dst->block,
+                  dst->stride,
                   dstx, dsty,
                   width, height,
                   src_map,
-                  do_flip ? -(int) src->pitch : src->pitch,
+                  do_flip ? -(int) src->stride : src->stride,
                   srcx, do_flip ? src->height - 1 - srcy : srcy);
 
    pipe->screen->surface_unmap(pipe->screen, src);
@@ -80,7 +82,7 @@ sp_surface_copy(struct pipe_context *pipe,
 static void *
 get_pointer(struct pipe_surface *dst, void *dst_map, unsigned x, unsigned y)
 {
-   return (char *)dst_map + (y * dst->pitch + x) * dst->cpp;
+   return (char *)dst_map + y / dst->block.height * dst->stride + x / dst->block.width * dst->block.size;
 }
 
 
@@ -102,39 +104,14 @@ sp_surface_fill(struct pipe_context *pipe,
                                               dst,
                                               PIPE_BUFFER_USAGE_CPU_WRITE );
 
-   assert(dst->pitch > 0);
-   assert(width <= dst->pitch);
+   assert(dst->stride > 0);
 
 
-   switch (dst->cpp) {
+   switch (dst->block.size) {
    case 1:
-      {
-	 ubyte *row = get_pointer(dst, dst_map, dstx, dsty);
-         for (i = 0; i < height; i++) {
-            memset(row, value, width);
-	 row += dst->pitch;
-         }
-      }
-      break;
    case 2:
-      {
-         ushort *row = get_pointer(dst, dst_map, dstx, dsty);
-         for (i = 0; i < height; i++) {
-            for (j = 0; j < width; j++)
-               row[j] = (ushort) value;
-            row += dst->pitch;
-         }
-      }
-      break;
    case 4:
-      {
-         unsigned *row = get_pointer(dst, dst_map, dstx, dsty);
-         for (i = 0; i < height; i++) {
-            for (j = 0; j < width; j++)
-               row[j] = value;
-            row += dst->pitch;
-         }
-      }
+      pipe_fill_rect(dst_map, &dst->block, dst->stride, dstx, dsty, width, height, value);
       break;
    case 8:
       {
@@ -155,7 +132,7 @@ sp_surface_fill(struct pipe_context *pipe,
                row[j*4+2] = val2;
                row[j*4+3] = val3;
             }
-            row += dst->pitch * 4;
+            row += dst->stride/2;
          }
       }
       break;
diff --git a/src/gallium/drivers/softpipe/sp_texture.c b/src/gallium/drivers/softpipe/sp_texture.c
index 2ef17a220b4..4db045cdc3d 100644
--- a/src/gallium/drivers/softpipe/sp_texture.c
+++ b/src/gallium/drivers/softpipe/sp_texture.c
@@ -71,13 +71,15 @@ softpipe_texture_layout(struct pipe_screen *screen,
       pt->width[level] = width;
       pt->height[level] = height;
       pt->depth[level] = depth;
-      spt->pitch[level] = width;
+      pt->nblocksx[level] = pf_get_nblocksx(&pt->block, width);  
+      pt->nblocksy[level] = pf_get_nblocksy(&pt->block, height);  
+      spt->stride[level] = pt->nblocksx[level]*pt->block.size;
 
       spt->level_offset[level] = buffer_size;
 
-      buffer_size += (((pt->compressed) ? MAX2(1, height/4) : height) *
+      buffer_size += (pt->nblocksy[level] *
                       ((pt->target == PIPE_TEXTURE_CUBE) ? 6 : depth) *
-                      width * pt->cpp);
+                      spt->stride[level]);
 
       width  = minify(width);
       height = minify(height);
@@ -121,7 +123,7 @@ softpipe_displaytarget_layout(struct pipe_screen *screen,
    /* Now extract the goodies: 
     */
    spt->buffer = surf.buffer;
-   spt->pitch[0] = surf.pitch;
+   spt->stride[0] = surf.stride;
 
    return spt->buffer != NULL;
 }
@@ -195,10 +197,12 @@ softpipe_get_tex_surface(struct pipe_screen *screen,
       assert(ps->winsys);
       pipe_buffer_reference(ws, &ps->buffer, spt->buffer);
       ps->format = pt->format;
-      ps->cpp = pt->cpp;
+      ps->block = pt->block;
       ps->width = pt->width[level];
       ps->height = pt->height[level];
-      ps->pitch = spt->pitch[level];
+      ps->nblocksx = pt->nblocksx[level];
+      ps->nblocksy = pt->nblocksy[level];
+      ps->stride = spt->stride[level];
       ps->offset = spt->level_offset[level];
       ps->usage = usage;
       
@@ -228,8 +232,8 @@ softpipe_get_tex_surface(struct pipe_screen *screen,
 
       if (pt->target == PIPE_TEXTURE_CUBE || pt->target == PIPE_TEXTURE_3D) {
 	 ps->offset += ((pt->target == PIPE_TEXTURE_CUBE) ? face : zslice) *
-		       (pt->compressed ? ps->height/4 : ps->height) *
-		       ps->width * ps->cpp;
+		       ps->nblocksy *
+		       ps->stride;
       }
       else {
 	 assert(face == 0);
diff --git a/src/gallium/drivers/softpipe/sp_texture.h b/src/gallium/drivers/softpipe/sp_texture.h
index 0e1017632c9..bf437a7c618 100644
--- a/src/gallium/drivers/softpipe/sp_texture.h
+++ b/src/gallium/drivers/softpipe/sp_texture.h
@@ -42,7 +42,7 @@ struct softpipe_texture
    struct pipe_texture base;
 
    unsigned long level_offset[PIPE_MAX_TEXTURE_LEVELS];
-   unsigned long pitch[PIPE_MAX_TEXTURE_LEVELS];
+   unsigned long stride[PIPE_MAX_TEXTURE_LEVELS];
 
    /* The data is held here:
     */