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.

4 files changed, 128 insertions, 80 deletions

diff --git a/src/gallium/auxiliary/util/p_tile.c b/src/gallium/auxiliary/util/p_tile.c
index 5728757d2fb..ab603ff6e4d 100644
--- a/src/gallium/auxiliary/util/p_tile.c
+++ b/src/gallium/auxiliary/util/p_tile.c
@@ -48,34 +48,23 @@ void
 pipe_get_tile_raw(struct pipe_context *pipe,
                   struct pipe_surface *ps,
                   uint x, uint y, uint w, uint h,
-                  void *p, int dst_stride)
+                  void *dst, int dst_stride)
 {
    struct pipe_screen *screen = pipe->screen;
-   const uint cpp = ps->cpp;
-   const ubyte *pSrc;
-   const uint src_stride = ps->pitch * cpp;
-   ubyte *pDest;
-   uint i;
-
-   if (dst_stride == 0) {
-      dst_stride = w * cpp;
-   }
+   const void *src;
 
    if (pipe_clip_tile(x, y, &w, &h, ps))
       return;
 
-   pSrc = (const ubyte *) screen->surface_map(screen, ps,
-                                              PIPE_BUFFER_USAGE_CPU_READ);
-   assert(pSrc);                /* XXX: proper error handling! */
+   if (dst_stride == 0)
+      dst_stride = pf_get_nblocksx(&ps->block, w) * ps->block.size;
 
-   pSrc += (y * ps->pitch + x) * cpp;
-   pDest = (ubyte *) p;
+   src = screen->surface_map(screen, ps, PIPE_BUFFER_USAGE_CPU_READ);
+   assert(src);
+   if(!src)
+      return;
 
-   for (i = 0; i < h; i++) {
-      memcpy(pDest, pSrc, w * cpp);
-      pDest += dst_stride;
-      pSrc += src_stride;
-   }
+   pipe_copy_rect(dst, &ps->block, dst_stride, 0, 0, w, h, src, ps->stride, x, y);
 
    screen->surface_unmap(screen, ps);
 }
@@ -89,34 +78,23 @@ void
 pipe_put_tile_raw(struct pipe_context *pipe,
                   struct pipe_surface *ps,
                   uint x, uint y, uint w, uint h,
-                  const void *p, int src_stride)
+                  const void *src, int src_stride)
 {
    struct pipe_screen *screen = pipe->screen;
-   const uint cpp = ps->cpp;
-   const ubyte *pSrc;
-   const uint dst_stride = ps->pitch * cpp;
-   ubyte *pDest;
-   uint i;
-
-   if (src_stride == 0) {
-      src_stride = w * cpp;
-   }
+   void *dst;
 
    if (pipe_clip_tile(x, y, &w, &h, ps))
       return;
 
-   pSrc = (const ubyte *) p;
+   if (src_stride == 0)
+      src_stride = pf_get_nblocksx(&ps->block, w) * ps->block.size;
 
-   pDest = screen->surface_map(screen, ps, PIPE_BUFFER_USAGE_CPU_WRITE);
-   assert(pDest);               /* XXX: proper error handling */
-
-   pDest += (y * ps->pitch + x) * cpp;
+   dst = screen->surface_map(screen, ps, PIPE_BUFFER_USAGE_CPU_WRITE);
+   assert(dst);
+   if(!dst)
+      return;
 
-   for (i = 0; i < h; i++) {
-      memcpy(pDest, pSrc, w * cpp);
-      pDest += dst_stride;
-      pSrc += src_stride;
-   }
+   pipe_copy_rect(dst, &ps->block, ps->stride, x, y, w, h, src, src_stride, 0, 0);
 
    screen->surface_unmap(screen, ps);
 }
@@ -692,12 +670,12 @@ pipe_get_tile_rgba(struct pipe_context *pipe,
    if (pipe_clip_tile(x, y, &w, &h, ps))
       return;
 
-   packed = MALLOC(h * w * ps->cpp);
+   packed = MALLOC(pf_get_nblocks(&ps->block, w, h) * ps->block.size);
 
    if (!packed)
       return;
 
-   pipe_get_tile_raw(pipe, ps, x, y, w, h, packed, w * ps->cpp);
+   pipe_get_tile_raw(pipe, ps, x, y, w, h, packed, 0);
 
    switch (ps->format) {
    case PIPE_FORMAT_A8R8G8B8_UNORM:
@@ -774,7 +752,7 @@ pipe_put_tile_rgba(struct pipe_context *pipe,
    if (pipe_clip_tile(x, y, &w, &h, ps))
       return;
 
-   packed = MALLOC(h * w * ps->cpp);
+   packed = MALLOC(pf_get_nblocks(&ps->block, w, h) * ps->block.size);
 
    if (!packed)
       return;
@@ -829,7 +807,7 @@ pipe_put_tile_rgba(struct pipe_context *pipe,
       assert(0);
    }
 
-   pipe_put_tile_raw(pipe, ps, x, y, w, h, packed, w * ps->cpp);
+   pipe_put_tile_raw(pipe, ps, x, y, w, h, packed, 0);
 
    FREE(packed);
 }
@@ -846,14 +824,14 @@ pipe_get_tile_z(struct pipe_context *pipe,
 {
    struct pipe_screen *screen = pipe->screen;
    const uint dstStride = w;
-   void *map;
+   ubyte *map;
    uint *pDest = z;
    uint i, j;
 
    if (pipe_clip_tile(x, y, &w, &h, ps))
       return;
 
-   map = screen->surface_map(screen, ps, PIPE_BUFFER_USAGE_CPU_READ);
+   map = (ubyte *)screen->surface_map(screen, ps, PIPE_BUFFER_USAGE_CPU_READ);
    if (!map) {
       assert(0);
       return;
@@ -863,11 +841,11 @@ pipe_get_tile_z(struct pipe_context *pipe,
    case PIPE_FORMAT_Z32_UNORM:
       {
          const uint *pSrc
-            = (const uint *)map  + (y * ps->pitch + x);
+            = (const uint *)(map  + y * ps->stride + x*4);
          for (i = 0; i < h; i++) {
             memcpy(pDest, pSrc, 4 * w);
             pDest += dstStride;
-            pSrc += ps->pitch;
+            pSrc += ps->stride/4;
          }
       }
       break;
@@ -875,28 +853,28 @@ pipe_get_tile_z(struct pipe_context *pipe,
    case PIPE_FORMAT_X8Z24_UNORM:
       {
          const uint *pSrc
-            = (const uint *)map + (y * ps->pitch + x);
+            = (const uint *)(map + y * ps->stride + x*4);
          for (i = 0; i < h; i++) {
             for (j = 0; j < w; j++) {
                /* convert 24-bit Z to 32-bit Z */
                pDest[j] = (pSrc[j] << 8) | (pSrc[j] & 0xff);
             }
             pDest += dstStride;
-            pSrc += ps->pitch;
+            pSrc += ps->stride/4;
          }
       }
       break;
    case PIPE_FORMAT_Z16_UNORM:
       {
          const ushort *pSrc
-            = (const ushort *)map + (y * ps->pitch + x);
+            = (const ushort *)(map + y * ps->stride + x*2);
          for (i = 0; i < h; i++) {
             for (j = 0; j < w; j++) {
                /* convert 16-bit Z to 32-bit Z */
                pDest[j] = (pSrc[j] << 16) | pSrc[j];
             }
             pDest += dstStride;
-            pSrc += ps->pitch;
+            pSrc += ps->stride/2;
          }
       }
       break;
@@ -917,13 +895,13 @@ pipe_put_tile_z(struct pipe_context *pipe,
    struct pipe_screen *screen = pipe->screen;
    const uint srcStride = w;
    const uint *pSrc = zSrc;
-   void *map;
+   ubyte *map;
    uint i, j;
 
    if (pipe_clip_tile(x, y, &w, &h, ps))
       return;
 
-   map = screen->surface_map(screen, ps, PIPE_BUFFER_USAGE_CPU_WRITE);
+   map = (ubyte *)screen->surface_map(screen, ps, PIPE_BUFFER_USAGE_CPU_WRITE);
    if (!map) {
       assert(0);
       return;
@@ -932,10 +910,10 @@ pipe_put_tile_z(struct pipe_context *pipe,
    switch (ps->format) {
    case PIPE_FORMAT_Z32_UNORM:
       {
-         uint *pDest = (uint *) map + (y * ps->pitch + x);
+         uint *pDest = (uint *) (map + y * ps->stride + x*4);
          for (i = 0; i < h; i++) {
             memcpy(pDest, pSrc, 4 * w);
-            pDest += ps->pitch;
+            pDest += ps->stride/4;
             pSrc += srcStride;
          }
       }
@@ -943,26 +921,26 @@ pipe_put_tile_z(struct pipe_context *pipe,
    case PIPE_FORMAT_S8Z24_UNORM:
    case PIPE_FORMAT_X8Z24_UNORM:
       {
-         uint *pDest = (uint *) map + (y * ps->pitch + x);
+         uint *pDest = (uint *) (map + y * ps->stride + x*4);
          for (i = 0; i < h; i++) {
             for (j = 0; j < w; j++) {
                /* convert 32-bit Z to 24-bit Z (0 stencil) */
                pDest[j] = pSrc[j] >> 8;
             }
-            pDest += ps->pitch;
+            pDest += ps->stride/4;
             pSrc += srcStride;
          }
       }
       break;
    case PIPE_FORMAT_Z16_UNORM:
       {
-         ushort *pDest = (ushort *) map + (y * ps->pitch + x);
+         ushort *pDest = (ushort *) (map + y * ps->stride + x*2);
          for (i = 0; i < h; i++) {
             for (j = 0; j < w; j++) {
                /* convert 32-bit Z to 16-bit Z */
                pDest[j] = pSrc[j] >> 16;
             }
-            pDest += ps->pitch;
+            pDest += ps->stride/2;
             pSrc += srcStride;
          }
       }
diff --git a/src/gallium/auxiliary/util/p_util.c b/src/gallium/auxiliary/util/p_util.c
index 4e60b1b8418..271be4edf14 100644
--- a/src/gallium/auxiliary/util/p_util.c
+++ b/src/gallium/auxiliary/util/p_util.c
@@ -32,6 +32,7 @@
 
 #include "pipe/p_defines.h"
 #include "pipe/p_util.h"
+#include "pipe/p_format.h"
 
 
 /**
@@ -41,42 +42,109 @@
  */
 void
 pipe_copy_rect(ubyte * dst,
-               unsigned cpp,
-               unsigned dst_pitch,
+               const struct pipe_format_block *block,
+               unsigned dst_stride,
                unsigned dst_x,
                unsigned dst_y,
                unsigned width,
                unsigned height,
                const ubyte * src,
-               int src_pitch,
+               int src_stride,
                unsigned src_x, 
                int src_y)
 {
    unsigned i;
-   int src_pitch_pos = src_pitch < 0 ? -src_pitch : src_pitch;
+   int src_stride_pos = src_stride < 0 ? -src_stride : src_stride;
 
-   assert(cpp > 0);
+   assert(block->size > 0);
+   assert(block->width > 0);
+   assert(block->height > 0);
    assert(src_x >= 0);
    assert(src_y >= 0);
    assert(dst_x >= 0);
    assert(dst_y >= 0);
 
-   dst_pitch *= cpp;
-   src_pitch *= cpp;
-   src_pitch_pos *= cpp;
-   dst += dst_x * cpp;
-   src += src_x * cpp;
-   dst += dst_y * dst_pitch;
-   src += src_y * src_pitch_pos;
-   width *= cpp;
+   dst_x /= block->width;
+   dst_y /= block->height;
+   width = (width + block->width - 1)/block->width;
+   height = (height + block->height - 1)/block->height;
+   src_x /= block->width;
+   src_y /= block->height;
+   
+   dst += dst_x * block->size;
+   src += src_x * block->size;
+   dst += dst_y * dst_stride;
+   src += src_y * src_stride_pos;
+   width *= block->size;
 
-   if (width == dst_pitch && width == src_pitch)
+   if (width == dst_stride && width == src_stride)
       memcpy(dst, src, height * width);
    else {
       for (i = 0; i < height; i++) {
          memcpy(dst, src, width);
-         dst += dst_pitch;
-         src += src_pitch;
+         dst += dst_stride;
+         src += src_stride;
       }
    }
 }
+
+void
+pipe_fill_rect(ubyte * dst,
+               const struct pipe_format_block *block,
+               unsigned dst_stride,
+               unsigned dst_x,
+               unsigned dst_y,
+               unsigned width,
+               unsigned height,
+               uint32_t value)
+{
+   unsigned i, j;
+   unsigned width_size;
+
+   assert(block->size > 0);
+   assert(block->width > 0);
+   assert(block->height > 0);
+   assert(dst_x >= 0);
+   assert(dst_y >= 0);
+
+   dst_x /= block->width;
+   dst_y /= block->height;
+   width = (width + block->width - 1)/block->width;
+   height = (height + block->height - 1)/block->height;
+   
+   dst += dst_x * block->size;
+   dst += dst_y * dst_stride;
+   width_size = width * block->size;
+   
+   switch (block->size) {
+   case 1:
+      if(dst_stride == width_size)
+	 memset(dst, (ubyte) value, height * width_size);
+      else {
+	 for (i = 0; i < height; i++) {
+	    memset(dst, (ubyte) value, width_size);
+	    dst += dst_stride;
+	 }
+      }
+      break;
+   case 2:
+      for (i = 0; i < height; i++) {
+	 uint16_t *row = (uint16_t *)dst;
+	 for (j = 0; j < width; j++)
+	    *row++ = (uint16_t) value;
+	 dst += dst_stride;
+      }
+      break;
+   case 4:
+      for (i = 0; i < height; i++) {
+	 uint32_t *row = (uint32_t *)dst;
+	 for (j = 0; j < width; j++)
+	    *row++ = value;
+	 dst += dst_stride;
+      }
+      break;
+   default:
+	 assert(0);
+	 break;
+   }
+}
diff --git a/src/gallium/auxiliary/util/u_blit.c b/src/gallium/auxiliary/util/u_blit.c
index 6555dcd5882..ae779335dc0 100644
--- a/src/gallium/auxiliary/util/u_blit.c
+++ b/src/gallium/auxiliary/util/u_blit.c
@@ -324,7 +324,7 @@ util_blit_pixels(struct blit_state *ctx,
    texTemp.height[0] = srcH;
    texTemp.depth[0] = 1;
    texTemp.compressed = 0;
-   texTemp.cpp = pf_get_size(src->format);
+   pf_get_block(src->format, &texTemp.block);
 
    tex = screen->texture_create(screen, &texTemp);
    if (!tex)
diff --git a/src/gallium/auxiliary/util/u_gen_mipmap.c b/src/gallium/auxiliary/util/u_gen_mipmap.c
index 7d71aefda9d..5313a8008a9 100644
--- a/src/gallium/auxiliary/util/u_gen_mipmap.c
+++ b/src/gallium/auxiliary/util/u_gen_mipmap.c
@@ -625,7 +625,9 @@ make_2d_mipmap(struct gen_mipmap_state *ctx,
    struct pipe_winsys *winsys = pipe->winsys;
    const uint zslice = 0;
    uint dstLevel;
-   const int bpt = pf_get_size(pt->format);
+   
+   assert(pt->block.width == 1);
+   assert(pt->block.height == 1);
 
    for (dstLevel = baseLevel + 1; dstLevel <= lastLevel; dstLevel++) {
       const uint srcLevel = dstLevel - 1;
@@ -646,9 +648,9 @@ make_2d_mipmap(struct gen_mipmap_state *ctx,
 
       reduce_2d(pt->format,
                 srcSurf->width, srcSurf->height,
-                srcSurf->pitch * bpt, srcMap,
+                srcSurf->stride, srcMap,
                 dstSurf->width, dstSurf->height,
-                dstSurf->pitch * bpt, dstMap);
+                dstSurf->stride, dstMap);
 
       winsys->buffer_unmap(winsys, srcSurf->buffer);
       winsys->buffer_unmap(winsys, dstSurf->buffer);