Merge branch 'master' into gallium-new-formats

Conflicts:
	src/gallium/auxiliary/util/u_format.csv

9 files changed, 356 insertions, 331 deletions

diff --git a/src/gallium/state_trackers/dri/common/dri_st_api.c b/src/gallium/state_trackers/dri/common/dri_st_api.c
index 40b24b18e9..7ba7ec383d 100644
--- a/src/gallium/state_trackers/dri/common/dri_st_api.c
+++ b/src/gallium/state_trackers/dri/common/dri_st_api.c
@@ -80,7 +80,7 @@ dri_st_framebuffer_validate(struct st_framebuffer_iface *stfbi,
       }
 #else
       if (new_stamp)
-         drisw_update_drawable_info(drawable->dPriv);
+         drisw_update_drawable_info(drawable);
 
       drisw_allocate_textures(drawable, statt_mask);
 #endif
diff --git a/src/gallium/state_trackers/dri/drm/dri1.c b/src/gallium/state_trackers/dri/drm/dri1.c
index aad098bb30..9b5842ba2b 100644
--- a/src/gallium/state_trackers/dri/drm/dri1.c
+++ b/src/gallium/state_trackers/dri/drm/dri1.c
@@ -404,6 +404,19 @@ dri1_allocate_textures(struct dri_drawable *drawable,
    drawable->old_h = height;
 }
 
+/*
+ * Backend function for init_screen.
+ */
+
+static const __DRIextension *dri1_screen_extensions[] = {
+   &driReadDrawableExtension,
+   &driCopySubBufferExtension.base,
+   &driSwapControlExtension.base,
+   &driFrameTrackingExtension.base,
+   &driMediaStreamCounterExtension.base,
+   NULL
+};
+
 static void
 st_dri_lock(struct pipe_context *pipe)
 {
@@ -442,21 +455,6 @@ static struct dri1_api_lock_funcs dri1_lf = {
    .clear_lost_lock = st_dri_clear_lost_lock
 };
 
-/*
- * Backend function for init_screen.
- */
-
-static const __DRIextension *dri1_screen_extensions[] = {
-   &driReadDrawableExtension,
-   &driCopySubBufferExtension.base,
-   &driSwapControlExtension.base,
-   &driFrameTrackingExtension.base,
-   &driMediaStreamCounterExtension.base,
-   NULL
-};
-
-struct dri1_api *__dri1_api_hooks = NULL;
-
 static INLINE void
 dri1_copy_version(struct dri1_api_version *dst,
 		  const struct __DRIversionRec *src)
@@ -466,6 +464,8 @@ dri1_copy_version(struct dri1_api_version *dst,
    dst->patch_level = src->patch;
 }
 
+struct dri1_api *__dri1_api_hooks = NULL;
+
 const __DRIconfig **
 dri1_init_screen(__DRIscreen * sPriv)
 {
diff --git a/src/gallium/state_trackers/dri/sw/drisw.c b/src/gallium/state_trackers/dri/sw/drisw.c
index b7eba63bcb..b825671097 100644
--- a/src/gallium/state_trackers/dri/sw/drisw.c
+++ b/src/gallium/state_trackers/dri/sw/drisw.c
@@ -28,37 +28,17 @@
 
 /* TODO:
  *
- * stride:
- *
- * The driver and the loaders (libGL, xserver/glx) compute the stride from the
- * width independently. winsys has a workaround that works for softpipe but may
- * explode for other drivers or platforms, rendering- or performance-wise.
- * Solving this issue properly requires extending the DRISW loader extension,
- * in order to make the stride available to the putImage callback.
- *
- * drisw_api:
- *
- * Define drisw_api similarly to dri1_api and use it to call the loader. This
- * is predicated on support for calling the loader from the winsys, which has
- * to grow for DRI2 as well.
- *
  * xshm / texture_from_pixmap / EGLImage:
  *
  * Allow the loaders to use the XSHM extension. It probably requires callbacks
- * for createImage/destroyImage similar to DRI2 getBuffers. Probably not worth
- * it, given the scope of DRISW, unless it falls naturally from properly
- * solving the other issues.
- *
- * fences:
- *
- * No fences are used, are they needed for llvmpipe / cell ?
+ * for createImage/destroyImage similar to DRI2 getBuffers.
  */
 
 #include "util/u_format.h"
 #include "util/u_memory.h"
 #include "util/u_inlines.h"
 #include "pipe/p_context.h"
-#include "state_tracker/drm_api.h"
+#include "state_tracker/drisw_api.h"
 
 #include "dri_screen.h"
 #include "dri_context.h"
@@ -80,60 +60,47 @@ get_drawable_info(__DRIdrawable *dPriv, int *w, int *h)
                            dPriv->loaderPrivate);
 }
 
-/*
- * Set the width to 'stride / cpp'. PutImage seems to correctly clip the width
- * to the actual width of the dst drawable. Even if this is not specified but
- * an implementation detail, it is the correct thing to do, so rely on it. XXX
- */
 static INLINE void
-put_image(__DRIdrawable *dPriv, void *data, unsigned width)
+put_image(__DRIdrawable *dPriv, void *data, unsigned width, unsigned height)
 {
    __DRIscreen *sPriv = dPriv->driScreenPriv;
    const __DRIswrastLoaderExtension *loader = sPriv->swrast_loader;
 
    loader->putImage(dPriv, __DRI_SWRAST_IMAGE_OP_SWAP,
-                    0, 0, width, dPriv->h,
+                    0, 0, width, height,
                     data, dPriv->loaderPrivate);
 }
 
 void
-drisw_update_drawable_info(__DRIdrawable *dPriv)
+drisw_update_drawable_info(struct dri_drawable *drawable)
 {
+   __DRIdrawable *dPriv = drawable->dPriv;
+
    get_drawable_info(dPriv, &dPriv->w, &dPriv->h);
 }
 
+static void
+drisw_put_image(struct dri_drawable *drawable,
+                void *data, unsigned width, unsigned height)
+{
+   __DRIdrawable *dPriv = drawable->dPriv;
+
+   put_image(dPriv, data, width, height);
+}
+
 static INLINE void
 drisw_present_texture(__DRIdrawable *dPriv,
                       struct pipe_texture *ptex)
 {
    struct dri_drawable *drawable = dri_drawable(dPriv);
    struct dri_screen *screen = dri_screen(drawable->sPriv);
-   struct pipe_context *pipe;
    struct pipe_surface *psurf;
-   struct pipe_transfer *ptrans;
-   void *pmap;
-   unsigned width;
 
-   pipe = dri1_get_pipe_context(screen);
    psurf = dri1_get_pipe_surface(drawable, ptex);
-   if (!pipe || !psurf)
+   if (!psurf)
       return;
 
-   ptrans = pipe->get_tex_transfer(pipe, ptex, 0, 0, 0,
-                                   PIPE_TRANSFER_READ,
-                                   0, 0, dPriv->w, dPriv->h);
-
-   width = ptrans->stride / util_format_get_blocksize(ptex->format);
-
-   pmap = pipe->transfer_map(pipe, ptrans);
-
-   assert(pmap);
-
-   put_image(dPriv, pmap, width);
-
-   pipe->transfer_unmap(pipe, ptrans);
-
-   pipe->tex_transfer_destroy(pipe, ptrans);
+   screen->pipe_screen->flush_frontbuffer(screen->pipe_screen, psurf, drawable);
 }
 
 static INLINE void
@@ -163,38 +130,38 @@ drisw_copy_to_front(__DRIdrawable * dPriv,
  */
 
 void
-drisw_flush_frontbuffer(struct dri_drawable *drawable,
-                        enum st_attachment_type statt)
+drisw_swap_buffers(__DRIdrawable *dPriv)
 {
    struct dri_context *ctx = dri_get_current();
+   struct dri_drawable *drawable = dri_drawable(dPriv);
    struct pipe_texture *ptex;
 
    if (!ctx)
       return;
 
-   ptex = drawable->textures[statt];
+   ptex = drawable->textures[ST_ATTACHMENT_BACK_LEFT];
 
    if (ptex) {
-      drisw_copy_to_front(ctx->dPriv, ptex);
+      ctx->st->flush(ctx->st, PIPE_FLUSH_RENDER_CACHE, NULL);
+
+      drisw_copy_to_front(dPriv, ptex);
    }
 }
 
 void
-drisw_swap_buffers(__DRIdrawable *dPriv)
+drisw_flush_frontbuffer(struct dri_drawable *drawable,
+                        enum st_attachment_type statt)
 {
    struct dri_context *ctx = dri_get_current();
-   struct dri_drawable *drawable = dri_drawable(dPriv);
    struct pipe_texture *ptex;
 
    if (!ctx)
       return;
 
-   ptex = drawable->textures[ST_ATTACHMENT_BACK_LEFT];
+   ptex = drawable->textures[statt];
 
    if (ptex) {
-      ctx->st->flush(ctx->st, PIPE_FLUSH_RENDER_CACHE, NULL);
-
-      drisw_copy_to_front(dPriv, ptex);
+      drisw_copy_to_front(ctx->dPriv, ptex);
    }
 }
 
@@ -286,12 +253,16 @@ static const __DRIextension *drisw_screen_extensions[] = {
    NULL
 };
 
+static struct drisw_loader_funcs drisw_lf = {
+   .put_image = drisw_put_image
+};
+
 const __DRIconfig **
 drisw_init_screen(__DRIscreen * sPriv)
 {
    const __DRIconfig **configs;
    struct dri_screen *screen;
-   struct drm_create_screen_arg arg;
+   struct drisw_create_screen_arg arg;
 
    screen = CALLOC_STRUCT(dri_screen);
    if (!screen)
@@ -304,9 +275,10 @@ drisw_init_screen(__DRIscreen * sPriv)
    sPriv->private = (void *)screen;
    sPriv->extensions = drisw_screen_extensions;
 
-   arg.mode = DRM_CREATE_DRISW;
+   arg.base.mode = DRM_CREATE_DRISW;
+   arg.lf = &drisw_lf;
 
-   configs = dri_init_screen_helper(screen, &arg, 32);
+   configs = dri_init_screen_helper(screen, &arg.base, 32);
    if (!configs)
       goto fail;
 
diff --git a/src/gallium/state_trackers/dri/sw/drisw.h b/src/gallium/state_trackers/dri/sw/drisw.h
index 2c0d5610fa..c0c874f732 100644
--- a/src/gallium/state_trackers/dri/sw/drisw.h
+++ b/src/gallium/state_trackers/dri/sw/drisw.h
@@ -39,7 +39,7 @@ const __DRIconfig **
 drisw_init_screen(__DRIscreen * sPriv);
 
 void
-drisw_update_drawable_info(__DRIdrawable *dPriv);
+drisw_update_drawable_info(struct dri_drawable *drawable);
 
 void
 drisw_flush_frontbuffer(struct dri_drawable *drawable,
diff --git a/src/gallium/state_trackers/python/SConscript b/src/gallium/state_trackers/python/SConscript
index d0d141fd24..781f54bf2b 100644
--- a/src/gallium/state_trackers/python/SConscript
+++ b/src/gallium/state_trackers/python/SConscript
@@ -3,8 +3,7 @@ import os.path
 
 Import('*')
 
-if 'python' in env['statetrackers'] and 0:
-    # FIXME: Disable python state tracker until transfers are done by contexts  
+if 'python' in env['statetrackers']:
 
     env = env.Clone()
     
diff --git a/src/gallium/state_trackers/python/p_context.i b/src/gallium/state_trackers/python/p_context.i
index df700bc663..bccaeead01 100644
--- a/src/gallium/state_trackers/python/p_context.i
+++ b/src/gallium/state_trackers/python/p_context.i
@@ -280,8 +280,11 @@ struct st_context {
       struct pipe_context *pipe = $self->pipe;
       struct pipe_screen *screen = pipe->screen;
       struct pipe_buffer *vbuf;
+      struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS];
+      struct pipe_vertex_buffer vbuffer;
       float *map;
       unsigned size;
+      unsigned i;
 
       size = num_verts * num_attribs * 4 * sizeof(float);
 
@@ -297,9 +300,31 @@ struct st_context {
          goto error2;
       memcpy(map, vertices, size);
       pipe_buffer_unmap(screen, vbuf);
-      
-      util_draw_vertex_buffer(pipe, vbuf, 0, prim, num_verts, num_attribs);
-      
+
+      cso_save_vertex_elements($self->cso);
+
+      /* tell pipe about the vertex attributes */
+      for (i = 0; i < num_attribs; i++) {
+         velements[i].src_offset = i * 4 * sizeof(float);
+         velements[i].instance_divisor = 0;
+         velements[i].vertex_buffer_index = 0;
+         velements[i].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
+      }
+      cso_set_vertex_elements($self->cso, num_attribs, velements);
+
+      /* tell pipe about the vertex buffer */
+      memset(&vbuffer, 0, sizeof(vbuffer));
+      vbuffer.buffer = vbuf;
+      vbuffer.stride = num_attribs * 4 * sizeof(float);  /* vertex size */
+      vbuffer.buffer_offset = 0;
+      vbuffer.max_index = num_verts - 1;
+      pipe->set_vertex_buffers(pipe, 1, &vbuffer);
+
+      /* draw */
+      pipe->draw_arrays(pipe, prim, 0, num_verts);
+
+      cso_restore_vertex_elements($self->cso);
+
 error2:
       pipe_buffer_reference(&vbuf, NULL);
 error1:
@@ -307,6 +332,13 @@ error1:
    }
    
    void
+   clear(unsigned buffers, const float *rgba, double depth = 0.0f,
+         unsigned stencil = 0)
+   {
+      $self->pipe->clear($self->pipe, buffers, rgba, depth, stencil);
+   }
+
+   void
    flush(unsigned flags = 0) {
       struct pipe_fence_handle *fence = NULL; 
       $self->pipe->flush($self->pipe, flags | PIPE_FLUSH_RENDER_CACHE, &fence);
@@ -362,10 +394,253 @@ error1:
       pipe_surface_reference(&_dst, NULL);
    }
 
-   void clear(unsigned buffers, const float *rgba, double depth = 0.0f,
-              unsigned stencil = 0)
+   %cstring_output_allocate_size(char **STRING, int *LENGTH, free(*$1));
+   void
+   surface_read_raw(struct st_surface *surface,
+                    unsigned x, unsigned y, unsigned w, unsigned h,
+                    char **STRING, int *LENGTH)
    {
-      $self->pipe->clear($self->pipe, buffers, rgba, depth, stencil);
+      struct pipe_texture *texture = surface->texture;
+      struct pipe_context *pipe = $self->pipe;
+      struct pipe_transfer *transfer;
+      unsigned stride;
+
+      stride = util_format_get_stride(texture->format, w);
+      *LENGTH = util_format_get_nblocksy(texture->format, h) * stride;
+      *STRING = (char *) malloc(*LENGTH);
+      if(!*STRING)
+         return;
+
+      transfer = pipe->get_tex_transfer(pipe,
+                                          surface->texture,
+                                          surface->face,
+                                          surface->level,
+                                          surface->zslice,
+                                          PIPE_TRANSFER_READ,
+                                          x, y, w, h);
+      if(transfer) {
+         pipe_get_tile_raw(pipe, transfer, 0, 0, w, h, *STRING, stride);
+         pipe->tex_transfer_destroy(pipe, transfer);
+      }
+   }
+
+   %cstring_input_binary(const char *STRING, unsigned LENGTH);
+   void
+   surface_write_raw(struct st_surface *surface,
+                     unsigned x, unsigned y, unsigned w, unsigned h,
+                     const char *STRING, unsigned LENGTH, unsigned stride = 0)
+   {
+      struct pipe_texture *texture = surface->texture;
+      struct pipe_context *pipe = $self->pipe;
+      struct pipe_transfer *transfer;
+
+      if(stride == 0)
+         stride = util_format_get_stride(texture->format, w);
+
+      if(LENGTH < util_format_get_nblocksy(texture->format, h) * stride)
+         SWIG_exception(SWIG_ValueError, "offset must be smaller than buffer size");
+
+      transfer = pipe->get_tex_transfer(pipe,
+                                          surface->texture,
+                                          surface->face,
+                                          surface->level,
+                                          surface->zslice,
+                                          PIPE_TRANSFER_WRITE,
+                                          x, y, w, h);
+      if(!transfer)
+         SWIG_exception(SWIG_MemoryError, "couldn't initiate transfer");
+
+      pipe_put_tile_raw(pipe, transfer, 0, 0, w, h, STRING, stride);
+      pipe->tex_transfer_destroy(pipe, transfer);
+
+   fail:
+      return;
+   }
+
+   void
+   surface_read_rgba(struct st_surface *surface,
+                     unsigned x, unsigned y, unsigned w, unsigned h,
+                     float *rgba)
+   {
+      struct pipe_context *pipe = $self->pipe;
+      struct pipe_transfer *transfer;
+      transfer = pipe->get_tex_transfer(pipe,
+                                          surface->texture,
+                                          surface->face,
+                                          surface->level,
+                                          surface->zslice,
+                                          PIPE_TRANSFER_READ,
+                                          x, y, w, h);
+      if(transfer) {
+         pipe_get_tile_rgba(pipe, transfer, 0, 0, w, h, rgba);
+         pipe->tex_transfer_destroy(pipe, transfer);
+      }
+   }
+
+   void
+   surface_write_rgba(struct st_surface *surface,
+                      unsigned x, unsigned y, unsigned w, unsigned h,
+                      const float *rgba)
+   {
+      struct pipe_context *pipe = $self->pipe;
+      struct pipe_transfer *transfer;
+      transfer = pipe->get_tex_transfer(pipe,
+                                          surface->texture,
+                                          surface->face,
+                                          surface->level,
+                                          surface->zslice,
+                                          PIPE_TRANSFER_WRITE,
+                                          x, y, w, h);
+      if(transfer) {
+         pipe_put_tile_rgba(pipe, transfer, 0, 0, w, h, rgba);
+         pipe->tex_transfer_destroy(pipe, transfer);
+      }
+   }
+
+   %cstring_output_allocate_size(char **STRING, int *LENGTH, free(*$1));
+   void
+   surface_read_rgba8(struct st_surface *surface,
+                      unsigned x, unsigned y, unsigned w, unsigned h,
+                      char **STRING, int *LENGTH)
+   {
+      struct pipe_context *pipe = $self->pipe;
+      struct pipe_transfer *transfer;
+      float *rgba;
+      unsigned char *rgba8;
+      unsigned i, j, k;
+
+      *LENGTH = 0;
+      *STRING = NULL;
+
+      if (!surface)
+         return;
+
+      *LENGTH = h*w*4;
+      *STRING = (char *) malloc(*LENGTH);
+      if(!*STRING)
+         return;
+
+      rgba = malloc(h*w*4*sizeof(float));
+      if(!rgba)
+         return;
+
+      rgba8 = (unsigned char *) *STRING;
+
+      transfer = pipe->get_tex_transfer(pipe,
+                                          surface->texture,
+                                          surface->face,
+                                          surface->level,
+                                          surface->zslice,
+                                          PIPE_TRANSFER_READ,
+                                          x, y,
+                                          w, h);
+      if(transfer) {
+         pipe_get_tile_rgba(pipe, transfer, 0, 0, w, h, rgba);
+         for(j = 0; j < h; ++j) {
+            for(i = 0; i < w; ++i)
+               for(k = 0; k <4; ++k)
+                  rgba8[j*w*4 + i*4 + k] = float_to_ubyte(rgba[j*w*4 + i*4 + k]);
+         }
+         pipe->tex_transfer_destroy(pipe, transfer);
+      }
+
+      free(rgba);
+   }
+
+   void
+   surface_read_z(struct st_surface *surface,
+                  unsigned x, unsigned y, unsigned w, unsigned h,
+                  unsigned *z)
+   {
+      struct pipe_context *pipe = $self->pipe;
+      struct pipe_transfer *transfer;
+      transfer = pipe->get_tex_transfer(pipe,
+                                          surface->texture,
+                                          surface->face,
+                                          surface->level,
+                                          surface->zslice,
+                                          PIPE_TRANSFER_READ,
+                                          x, y, w, h);
+      if(transfer) {
+         pipe_get_tile_z(pipe, transfer, 0, 0, w, h, z);
+         pipe->tex_transfer_destroy(pipe, transfer);
+      }
+   }
+
+   void
+   surface_write_z(struct st_surface *surface,
+                   unsigned x, unsigned y, unsigned w, unsigned h,
+                   const unsigned *z)
+   {
+      struct pipe_context *pipe = $self->pipe;
+      struct pipe_transfer *transfer;
+      transfer = pipe->get_tex_transfer(pipe,
+                                          surface->texture,
+                                          surface->face,
+                                          surface->level,
+                                          surface->zslice,
+                                          PIPE_TRANSFER_WRITE,
+                                          x, y, w, h);
+      if(transfer) {
+         pipe_put_tile_z(pipe, transfer, 0, 0, w, h, z);
+         pipe->tex_transfer_destroy(pipe, transfer);
+      }
+   }
+
+   void
+   surface_sample_rgba(struct st_surface *surface,
+                       float *rgba)
+   {
+      st_sample_surface($self->pipe, surface, rgba);
+   }
+
+   unsigned
+   surface_compare_rgba(struct st_surface *surface,
+                        unsigned x, unsigned y, unsigned w, unsigned h,
+                        const float *rgba, float tol = 0.0)
+   {
+      struct pipe_context *pipe = $self->pipe;
+      struct pipe_transfer *transfer;
+      float *rgba2;
+      const float *p1;
+      const float *p2;
+      unsigned i, j, n;
+
+      rgba2 = MALLOC(h*w*4*sizeof(float));
+      if(!rgba2)
+         return ~0;
+
+      transfer = pipe->get_tex_transfer(pipe,
+                                          surface->texture,
+                                          surface->face,
+                                          surface->level,
+                                          surface->zslice,
+                                          PIPE_TRANSFER_READ,
+                                          x, y, w, h);
+      if(!transfer) {
+         FREE(rgba2);
+         return ~0;
+      }
+
+      pipe_get_tile_rgba(pipe, transfer, 0, 0, w, h, rgba2);
+      pipe->tex_transfer_destroy(pipe, transfer);
+
+      p1 = rgba;
+      p2 = rgba2;
+      n = 0;
+      for(i = h*w; i; --i) {
+         unsigned differs = 0;
+         for(j = 4; j; --j) {
+            float delta = *p2++ - *p1++;
+            if (delta < -tol || delta > tol)
+                differs = 1;
+         }
+         n += differs;
+      }
+
+      FREE(rgba2);
+
+      return n;
    }
 
 };
diff --git a/src/gallium/state_trackers/python/p_texture.i b/src/gallium/state_trackers/python/p_texture.i
index 2dd9e5050e..923a628528 100644
--- a/src/gallium/state_trackers/python/p_texture.i
+++ b/src/gallium/state_trackers/python/p_texture.i
@@ -124,232 +124,6 @@ struct st_surface
       FREE($self);
    }
    
-   %cstring_output_allocate_size(char **STRING, int *LENGTH, free(*$1));
-   void get_tile_raw(struct st_context *ctx, unsigned x, unsigned y, unsigned w, unsigned h, char **STRING, int *LENGTH)
-   {
-      struct pipe_texture *texture = $self->texture;
-      struct pipe_context *pipe = ctx->pipe;
-      struct pipe_transfer *transfer;
-      unsigned stride;
-
-      stride = util_format_get_stride(texture->format, w);
-      *LENGTH = util_format_get_nblocksy(texture->format, h) * stride;
-      *STRING = (char *) malloc(*LENGTH);
-      if(!*STRING)
-         return;
-
-      transfer = pipe->get_tex_transfer(pipe,
-                                          $self->texture,
-                                          $self->face,
-                                          $self->level,
-                                          $self->zslice,
-                                          PIPE_TRANSFER_READ,
-                                          x, y, w, h);
-      if(transfer) {
-         pipe_get_tile_raw(pipe, transfer, 0, 0, w, h, *STRING, stride);
-         pipe->tex_transfer_destroy(pipe, transfer);
-      }
-   }
-
-   %cstring_input_binary(const char *STRING, unsigned LENGTH);
-   void put_tile_raw(struct st_context *ctx, unsigned x, unsigned y, unsigned w, unsigned h, const char *STRING, unsigned LENGTH, unsigned stride = 0)
-   {
-      struct pipe_texture *texture = $self->texture;
-      struct pipe_context *pipe = ctx->pipe;
-      struct pipe_transfer *transfer;
-     
-      if(stride == 0)
-         stride = util_format_get_stride(texture->format, w);
-      
-      if(LENGTH < util_format_get_nblocksy(texture->format, h) * stride)
-         SWIG_exception(SWIG_ValueError, "offset must be smaller than buffer size");
-         
-      transfer = pipe->get_tex_transfer(pipe,
-                                          $self->texture,
-                                          $self->face,
-                                          $self->level,
-                                          $self->zslice,
-                                          PIPE_TRANSFER_WRITE,
-                                          x, y, w, h);
-      if(!transfer)
-         SWIG_exception(SWIG_MemoryError, "couldn't initiate transfer");
-         
-      pipe_put_tile_raw(pipe, transfer, 0, 0, w, h, STRING, stride);
-      pipe->tex_transfer_destroy(pipe, transfer);
-
-   fail:
-      return;
-   }
-
-   void get_tile_rgba(struct st_context *ctx, unsigned x, unsigned y, unsigned w, unsigned h, float *rgba) 
-   {
-      struct pipe_context *pipe = ctx->pipe;
-      struct pipe_transfer *transfer;
-      transfer = pipe->get_tex_transfer(pipe,
-                                          $self->texture,
-                                          $self->face,
-                                          $self->level,
-                                          $self->zslice,
-                                          PIPE_TRANSFER_READ,
-                                          x, y, w, h);
-      if(transfer) {
-         pipe_get_tile_rgba(pipe, transfer, 0, 0, w, h, rgba);
-         pipe->tex_transfer_destroy(pipe, transfer);
-      }
-   }
-
-   void
-      put_tile_rgba(struct st_context *ctx, unsigned x, unsigned y, unsigned w, unsigned h, const float *rgba)
-   {
-      struct pipe_context *pipe = ctx->pipe;
-      struct pipe_transfer *transfer;
-      transfer = pipe->get_tex_transfer(pipe,
-                                          $self->texture,
-                                          $self->face,
-                                          $self->level,
-                                          $self->zslice,
-                                          PIPE_TRANSFER_WRITE,
-                                          x, y, w, h);
-      if(transfer) {
-         pipe_put_tile_rgba(pipe, transfer, 0, 0, w, h, rgba);
-         pipe->tex_transfer_destroy(pipe, transfer);
-      }
-   }
-
-   %cstring_output_allocate_size(char **STRING, int *LENGTH, free(*$1));
-   void
-   get_tile_rgba8(struct st_context *ctx, unsigned x, unsigned y, unsigned w, unsigned h, char **STRING, int *LENGTH) 
-   {
-      struct pipe_context *pipe = ctx->pipe;
-      struct pipe_transfer *transfer;
-      float *rgba;
-      unsigned char *rgba8;
-      unsigned i, j, k;
-
-      *LENGTH = 0;
-      *STRING = NULL;
-      
-      if (!$self)
-         return;
-
-      *LENGTH = h*w*4;
-      *STRING = (char *) malloc(*LENGTH);
-      if(!*STRING)
-         return;
-      
-      rgba = malloc(h*w*4*sizeof(float));
-      if(!rgba)
-         return;
-      
-      rgba8 = (unsigned char *) *STRING;
-
-      transfer = pipe->get_tex_transfer(pipe,
-                                          $self->texture,
-                                          $self->face,
-                                          $self->level,
-                                          $self->zslice,
-                                          PIPE_TRANSFER_READ,
-                                          x, y,
-                                          w, h);
-      if(transfer) {
-         pipe_get_tile_rgba(pipe, transfer, 0, 0, w, h, rgba);
-         for(j = 0; j < h; ++j) {
-            for(i = 0; i < w; ++i)
-               for(k = 0; k <4; ++k)
-                  rgba8[j*w*4 + i*4 + k] = float_to_ubyte(rgba[j*w*4 + i*4 + k]);
-         }
-         pipe->tex_transfer_destroy(pipe, transfer);
-      }
-      
-      free(rgba);
-   }
-
-   void get_tile_z(struct st_context *ctx, unsigned x, unsigned y, unsigned w, unsigned h, unsigned *z)
-   {
-      struct pipe_context *pipe = ctx->pipe;
-      struct pipe_transfer *transfer;
-      transfer = pipe->get_tex_transfer(pipe,
-                                          $self->texture,
-                                          $self->face,
-                                          $self->level,
-                                          $self->zslice,
-                                          PIPE_TRANSFER_READ,
-                                          x, y, w, h);
-      if(transfer) {
-         pipe_get_tile_z(pipe, transfer, 0, 0, w, h, z);
-         pipe->tex_transfer_destroy(pipe, transfer);
-      }
-   }
-
-   void put_tile_z(struct st_context *ctx, unsigned x, unsigned y, unsigned w, unsigned h, const unsigned *z)
-   {
-      struct pipe_context *pipe = ctx->pipe;
-      struct pipe_transfer *transfer;
-      transfer = pipe->get_tex_transfer(pipe,
-                                          $self->texture,
-                                          $self->face,
-                                          $self->level,
-                                          $self->zslice,
-                                          PIPE_TRANSFER_WRITE,
-                                          x, y, w, h);
-      if(transfer) {
-         pipe_put_tile_z(pipe, transfer, 0, 0, w, h, z);
-         pipe->tex_transfer_destroy(pipe, transfer);
-      }
-   }
-   
-/*
-   void
-   sample_rgba(float *rgba) {
-      st_sample_surface($self, rgba);
-   }
-*/
-   
-   unsigned compare_tile_rgba(struct st_context *ctx, unsigned x, unsigned y, unsigned w, unsigned h, const float *rgba, float tol = 0.0) 
-   {
-      struct pipe_context *pipe = ctx->pipe;
-      struct pipe_transfer *transfer;
-      float *rgba2;
-      const float *p1;
-      const float *p2;
-      unsigned i, j, n;
-      
-      rgba2 = MALLOC(h*w*4*sizeof(float));
-      if(!rgba2)
-         return ~0;
-
-      transfer = pipe->get_tex_transfer(pipe,
-                                          $self->texture,
-                                          $self->face,
-                                          $self->level,
-                                          $self->zslice,
-                                          PIPE_TRANSFER_READ,
-                                          x, y, w, h);
-      if(!transfer) {
-         FREE(rgba2);
-         return ~0;
-      }
-
-      pipe_get_tile_rgba(pipe, transfer, 0, 0, w, h, rgba2);
-      pipe->tex_transfer_destroy(pipe, transfer);
-
-      p1 = rgba;
-      p2 = rgba2;
-      n = 0;
-      for(i = h*w; i; --i) {
-         unsigned differs = 0;
-         for(j = 4; j; --j) {
-            float delta = *p2++ - *p1++;
-            if (delta < -tol || delta > tol)
-                differs = 1;
-         }
-         n += differs;
-      }
-      
-      FREE(rgba2);
-      
-      return n;
-   }
 
 };
 
diff --git a/src/gallium/state_trackers/python/st_sample.c b/src/gallium/state_trackers/python/st_sample.c
index f9622533fb..e2c1e06017 100644
--- a/src/gallium/state_trackers/python/st_sample.c
+++ b/src/gallium/state_trackers/python/st_sample.c
@@ -521,12 +521,13 @@ st_sample_pixel_block(enum pipe_format format,
    }
 }
 
-#if 0
+
 void
-st_sample_surface(struct st_surface *surface, float *rgba) 
+st_sample_surface(struct pipe_context *pipe,
+                  struct st_surface *surface,
+                  float *rgba)
 {
    struct pipe_texture *texture = surface->texture;
-   struct pipe_screen *screen = texture->screen;
    unsigned width = u_minify(texture->width0, surface->level);
    unsigned height = u_minify(texture->height0, surface->level);
    uint rgba_stride = width * 4;
@@ -534,18 +535,18 @@ st_sample_surface(struct st_surface *surface, float *rgba)
    void *raw;
 
    transfer = pipe->get_tex_transfer(pipe,
-                                       surface->texture,
-                                       surface->face,
-                                       surface->level,
-                                       surface->zslice,
-                                       PIPE_TRANSFER_WRITE,
-                                       0, 0,
-                                       width,
-                                       height);
+                                     surface->texture,
+                                     surface->face,
+                                     surface->level,
+                                     surface->zslice,
+                                     PIPE_TRANSFER_WRITE,
+                                     0, 0,
+                                     width,
+                                     height);
    if (!transfer)
       return;
 
-   raw = screen->transfer_map(screen, transfer);
+   raw = pipe->transfer_map(pipe, transfer);
    if (raw) {
       enum pipe_format format = texture->format;
       uint x, y;
@@ -567,9 +568,8 @@ st_sample_surface(struct st_surface *surface, float *rgba)
          }
       }
 
-      screen->transfer_unmap(screen, transfer);
+      pipe->transfer_unmap(pipe, transfer);
    }
    
-   screen->tex_transfer_destroy(transfer);
+   pipe->tex_transfer_destroy(pipe, transfer);
 }
-#endif
diff --git a/src/gallium/state_trackers/python/st_sample.h b/src/gallium/state_trackers/python/st_sample.h
index 888114d302..6fb8417add 100644
--- a/src/gallium/state_trackers/python/st_sample.h
+++ b/src/gallium/state_trackers/python/st_sample.h
@@ -32,6 +32,9 @@
 
 #include "pipe/p_format.h"
 
+struct pipe_context;
+struct st_surface;
+
 
 void 
 st_sample_pixel_block(enum pipe_format format,
@@ -40,7 +43,9 @@ st_sample_pixel_block(enum pipe_format format,
                       unsigned w, unsigned h);
 
 void
-st_sample_surface(struct st_surface *surface, float *rgba);
+st_sample_surface(struct pipe_context *pipe,
+                  struct st_surface *surface,
+                  float *rgba);
 
 
 #endif /* ST_SAMPLE_H_ */