intel: Replace pbo-only drawpixels function with a generic Mesa metaops.

Improves performance of some oglconform regression tests 9x.

1 files changed, 108 insertions, 276 deletions

diff --git a/src/mesa/drivers/dri/intel/intel_pixel_draw.c b/src/mesa/drivers/dri/intel/intel_pixel_draw.c
index 5e32d8a8ed2..0ddc3aa30d8 100644
--- a/src/mesa/drivers/dri/intel/intel_pixel_draw.c
+++ b/src/mesa/drivers/dri/intel/intel_pixel_draw.c
@@ -31,6 +31,14 @@
 #include "main/mtypes.h"
 #include "main/macros.h"
 #include "main/bufferobj.h"
+#include "main/teximage.h"
+#include "main/texobj.h"
+#include "main/texstate.h"
+#include "main/matrix.h"
+#include "main/varray.h"
+#include "main/attrib.h"
+#include "main/enable.h"
+#include "glapi/dispatch.h"
 #include "swrast/swrast.h"
 
 #include "intel_screen.h"
@@ -44,294 +52,123 @@
 #include "intel_tris.h"
 
 
-
 static GLboolean
-do_texture_drawpixels(GLcontext * ctx,
-                      GLint x, GLint y,
-                      GLsizei width, GLsizei height,
-                      GLenum format, GLenum type,
-                      const struct gl_pixelstore_attrib *unpack,
-                      const GLvoid * pixels)
+intel_texture_drawpixels(GLcontext * ctx,
+			 GLint x, GLint y,
+			 GLsizei width, GLsizei height,
+			 GLenum format,
+			 GLenum type,
+			 const struct gl_pixelstore_attrib *unpack,
+			 const GLvoid *pixels)
 {
-   struct intel_context *intel = intel_context(ctx);
-   struct intel_region *dst = intel_drawbuf_region(intel);
-   struct intel_buffer_object *src = intel_buffer_object(unpack->BufferObj);
-   GLuint rowLength = unpack->RowLength ? unpack->RowLength : width;
-   GLuint src_offset;
-
-   if (INTEL_DEBUG & DEBUG_PIXEL)
-      fprintf(stderr, "%s\n", __FUNCTION__);
-
-   intelFlush(&intel->ctx);
-
-   if (!dst)
-      return GL_FALSE;
-
-   intel->vtbl.render_start(intel);
-   intel->vtbl.emit_state(intel);
-
-   if (src) {
-      if (!_mesa_validate_pbo_access(2, unpack, width, height, 1,
-                                     format, type, pixels)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION, "glDrawPixels");
-         return GL_TRUE;
-      }
-   }
-   else {
-      /* PBO only for now:
-       */
-      if (INTEL_DEBUG & DEBUG_PIXEL)
-	 _mesa_printf("%s - not PBO\n", __FUNCTION__);
-      return GL_FALSE;
-   }
+   GLuint texname;
+   GLfloat vertices[4][4];
+   GLfloat texcoords[4][2];
 
-   /* There are a couple of things we can't do yet, one of which is
-    * set the correct state for pixel operations when GL texturing is
-    * enabled.  That's a pretty rare state and probably not worth the
-    * effort.  A completely device-independent version of this may do
-    * more.
-    *
-    * Similarly, we make no attempt to merge metaops processing with
-    * an enabled fragment program, though it would certainly be
-    * possible.
+   /* We're going to mess with texturing with no regard to existing texture
+    * state, so if there is some set up we have to bail.
     */
-   if (!intel_check_meta_tex_fragment_ops(ctx)) {
-      if (INTEL_DEBUG & DEBUG_PIXEL)
-         _mesa_printf("%s - bad GL fragment state for metaops texture\n",
-                      __FUNCTION__);
+   if (ctx->Texture._EnabledUnits != 0)
       return GL_FALSE;
-   }
 
-   intel->vtbl.install_meta_state(intel);
-
-
-   /* Is this true?  Also will need to turn depth testing on according
-    * to state:
+   /* Can't do textured DrawPixels with a fragment program, unless we were
+    * to generate a new program that sampled our texture and put the results
+    * in the fragment color before the user's program started.
     */
-   intel->vtbl.meta_no_stencil_write(intel);
-   intel->vtbl.meta_no_depth_write(intel);
-
-   /* Set the 3d engine to draw into the destination region:
-    */
-   intel->vtbl.meta_draw_region(intel, dst, intel->depth_region);
-
-   intel->vtbl.meta_import_pixel_state(intel);
-
-   src_offset = (GLuint) _mesa_image_address(2, unpack, pixels, width, height,
-                                             format, type, 0, 0, 0);
-
-
-   /* Setup the pbo up as a rectangular texture, if possible.
-    *
-    * TODO: This is almost always possible if the i915 fragment
-    * program is adjusted to correctly swizzle the sampled colors.
-    * The major exception is any 24bit texture, like RGB888, for which
-    * there is no hardware support.  
-    */
-   if (!intel->vtbl.meta_tex_rect_source(intel, src->buffer, src_offset,
-                                         rowLength, height, format, type)) {
-      intel->vtbl.leave_meta_state(intel);
-      return GL_FALSE;
-   }
-
-   intel->vtbl.meta_texture_blend_replace(intel);
-
-
-   LOCK_HARDWARE(intel);
-
-   if (intel->driDrawable->numClipRects) {
-      __DRIdrawablePrivate *dPriv = intel->driDrawable;
-      GLint srcx, srcy;
-      GLint dstx, dsty;
-
-      dstx = x;
-      dsty = dPriv->h - (y + height);
-
-      srcx = 0;                 /* skiprows/pixels already done */
-      srcy = 0;
-
-      if (0) {
-         const GLint orig_x = dstx;
-         const GLint orig_y = dsty;
-
-         if (!_mesa_clip_to_region(0, 0, dst->pitch, dst->height,
-                                   &dstx, &dsty, &width, &height))
-            goto out;
-
-         srcx += dstx - orig_x;
-         srcy += dsty - orig_y;
-      }
-
-
-      if (INTEL_DEBUG & DEBUG_PIXEL)
-         _mesa_printf("draw %d,%d %dx%d\n", dstx, dsty, width, height);
-
-      /* Must use the regular cliprect mechanism in order to get the
-       * drawing origin set correctly.  Otherwise scissor state is in
-       * incorrect coordinate space.  Does this even need to hold the
-       * lock???
-       */
-      intel->vtbl.meta_draw_quad(intel,
-				 dstx, dstx + width * ctx->Pixel.ZoomX,
-				 dPriv->h - (y + height * ctx->Pixel.ZoomY),
-				 dPriv->h - (y),
-				 -ctx->Current.RasterPos[2] * .5,
-				 0x00ff00ff,
-				 srcx, srcx + width, srcy + height, srcy);
-    out:
-      intel->vtbl.leave_meta_state(intel);
-      intel_batchbuffer_emit_mi_flush(intel->batch);
-   }
-   UNLOCK_HARDWARE(intel);
-   return GL_TRUE;
-}
-
-
-
-
-
-/* Pros:  
- *   - no waiting for idle before updating framebuffer.
- *   
- * Cons:
- *   - if upload is by memcpy, this may actually be slower than fallback path.
- *   - uploads the whole image even if destination is clipped
- *   
- * Need to benchmark.
- *
- * Given the questions about performance, implement for pbo's only.
- * This path is definitely a win if the pbo is already in agp.  If it
- * turns out otherwise, we can add the code necessary to upload client
- * data to agp space before performing the blit.  (Though it may turn
- * out to be better/simpler just to use the texture engine).
- */
-static GLboolean
-do_blit_drawpixels(GLcontext * ctx,
-                   GLint x, GLint y,
-                   GLsizei width, GLsizei height,
-                   GLenum format, GLenum type,
-                   const struct gl_pixelstore_attrib *unpack,
-                   const GLvoid * pixels)
-{
-   struct intel_context *intel = intel_context(ctx);
-   struct intel_region *dest = intel_drawbuf_region(intel);
-   struct intel_buffer_object *src = intel_buffer_object(unpack->BufferObj);
-   GLuint src_offset;
-   GLuint rowLength;
-
-   if (INTEL_DEBUG & DEBUG_PIXEL)
-      _mesa_printf("%s\n", __FUNCTION__);
-
-
-   if (!dest) {
-      if (INTEL_DEBUG & DEBUG_PIXEL)
-         _mesa_printf("%s - no dest\n", __FUNCTION__);
-      return GL_FALSE;
-   }
-
-   if (src) {
-      /* This validation should be done by core mesa:
-       */
-      if (!_mesa_validate_pbo_access(2, unpack, width, height, 1,
-                                     format, type, pixels)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION, "glDrawPixels");
-         return GL_TRUE;
-      }
-   }
-   else {
-      /* PBO only for now:
-       */
-      if (INTEL_DEBUG & DEBUG_PIXEL)
-         _mesa_printf("%s - not PBO\n", __FUNCTION__);
+   if (ctx->FragmentProgram.Enabled)
       return GL_FALSE;
-   }
 
-   if (!intel_check_blit_format(dest, format, type)) {
-      if (INTEL_DEBUG & DEBUG_PIXEL)
-         _mesa_printf("%s - bad format for blit\n", __FUNCTION__);
+   /* Don't even want to think about it */
+   if (format == GL_COLOR_INDEX)
       return GL_FALSE;
-   }
 
-   if (!intel_check_blit_fragment_ops(ctx, GL_FALSE)) {
-      if (INTEL_DEBUG & DEBUG_PIXEL)
-         _mesa_printf("%s - bad GL fragment state for blitter\n",
-                      __FUNCTION__);
+   /* We don't have a way to generate fragments with stencil values which *
+    * will set the resulting stencil value.
+    */
+   if (format == GL_STENCIL_INDEX)
       return GL_FALSE;
-   }
 
-   if (ctx->Pixel.ZoomX != 1.0F) {
-      if (INTEL_DEBUG & DEBUG_PIXEL)
-         _mesa_printf("%s - bad PixelZoomX for blit\n", __FUNCTION__);
-      return GL_FALSE;
-   }
-
-
-   if (unpack->RowLength > 0)
-      rowLength = unpack->RowLength;
-   else
-      rowLength = width;
-
-   if (ctx->Pixel.ZoomY == -1.0F) {
-      if (INTEL_DEBUG & DEBUG_PIXEL)
-         _mesa_printf("%s - bad PixelZoomY for blit\n", __FUNCTION__);
-      return GL_FALSE;          /* later */
-      y -= height;
-   }
-   else if (ctx->Pixel.ZoomY == 1.0F) {
-      rowLength = -rowLength;
-   }
-   else {
-      if (INTEL_DEBUG & DEBUG_PIXEL)
-         _mesa_printf("%s - bad PixelZoomY for blit\n", __FUNCTION__);
+   /* To do DEPTH_COMPONENT, we would need to change our setup to not draw to
+    * the color buffer, and sample the texture values into the fragment depth
+    * in a program.
+    */
+   if (format == GL_DEPTH_COMPONENT)
       return GL_FALSE;
-   }
-
-   src_offset = (GLuint) _mesa_image_address(2, unpack, pixels, width, height,
-                                             format, type, 0, 0, 0);
-
-   intelFlush(&intel->ctx);
-   LOCK_HARDWARE(intel);
-
-   if (intel->driDrawable->numClipRects) {
-      __DRIdrawablePrivate *dPriv = intel->driDrawable;
-      int nbox = dPriv->numClipRects;
-      drm_clip_rect_t *box = dPriv->pClipRects;
-      drm_clip_rect_t rect;
-      drm_clip_rect_t dest_rect;
-      dri_bo *src_buffer = intel_bufferobj_buffer(intel, src, INTEL_READ);
-      int i;
 
-      dest_rect.x1 = dPriv->x + x;
-      dest_rect.y1 = dPriv->y + dPriv->h - (y + height);
-      dest_rect.x2 = dest_rect.x1 + width;
-      dest_rect.y2 = dest_rect.y1 + height;
-
-      for (i = 0; i < nbox; i++) {
-         if (!intel_intersect_cliprects(&rect, &dest_rect, &box[i]))
-            continue;
-
-         intelEmitCopyBlit(intel,
-                           dest->cpp,
-                           rowLength, src_buffer, src_offset, GL_FALSE,
-                           dest->pitch, dest->buffer, 0, dest->tiling,
-                           rect.x1 - dest_rect.x1,
-                           rect.y2 - dest_rect.y2,
-                           rect.x1,
-                           rect.y1, rect.x2 - rect.x1, rect.y2 - rect.y1,
-			   ctx->Color.ColorLogicOpEnabled ?
-			   ctx->Color.LogicOp : GL_COPY);
-      }
-   }
-   UNLOCK_HARDWARE(intel);
-
-   if (INTEL_DEBUG & DEBUG_PIXEL)
-      _mesa_printf("%s - DONE\n", __FUNCTION__);
+   _mesa_PushAttrib(GL_ENABLE_BIT | GL_TRANSFORM_BIT | GL_TEXTURE_BIT |
+		    GL_CURRENT_BIT);
+   _mesa_PushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
+
+   /* XXX: pixel store stuff */
+   _mesa_Disable(GL_POLYGON_STIPPLE);
+
+   _mesa_ActiveTextureARB(GL_TEXTURE0_ARB);
+   _mesa_Enable(GL_TEXTURE_2D);
+   _mesa_GenTextures(1, &texname);
+   _mesa_BindTexture(GL_TEXTURE_2D, texname);
+   _mesa_TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+   _mesa_TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+   _mesa_TexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+   /*
+   _mesa_TexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
+   _mesa_TexEnvf(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
+   */
+   _mesa_TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, format,
+		    type, pixels);
+
+   _mesa_MatrixMode(GL_PROJECTION);
+   _mesa_PushMatrix();
+   _mesa_LoadIdentity();
+   _mesa_Ortho(0, ctx->DrawBuffer->Width, 0, ctx->DrawBuffer->Height, 1, -1);
+
+   _mesa_MatrixMode(GL_MODELVIEW);
+   _mesa_PushMatrix();
+   _mesa_LoadIdentity();
+
+   vertices[0][0] = x;
+   vertices[0][1] = y;
+   vertices[0][2] = ctx->Current.RasterPos[2];
+   vertices[0][3] = ctx->Current.RasterPos[3];
+   vertices[1][0] = x + width * ctx->Pixel.ZoomX;
+   vertices[1][1] = y;
+   vertices[1][2] = ctx->Current.RasterPos[2];
+   vertices[1][3] = ctx->Current.RasterPos[3];
+   vertices[2][0] = x + width * ctx->Pixel.ZoomX;
+   vertices[2][1] = y + height * ctx->Pixel.ZoomY;
+   vertices[2][2] = ctx->Current.RasterPos[2];
+   vertices[2][3] = ctx->Current.RasterPos[3];
+   vertices[3][0] = x;
+   vertices[3][1] = y + height * ctx->Pixel.ZoomY;
+   vertices[3][2] = ctx->Current.RasterPos[2];
+   vertices[3][3] = ctx->Current.RasterPos[3];
+
+   texcoords[0][0] = 0.0;
+   texcoords[0][1] = 0.0;
+   texcoords[1][0] = 1.0;
+   texcoords[1][1] = 0.0;
+   texcoords[2][0] = 1.0;
+   texcoords[2][1] = 1.0;
+   texcoords[3][0] = 0.0;
+   texcoords[3][1] = 1.0;
+
+   _mesa_VertexPointer(4, GL_FLOAT, 4 * sizeof(GLfloat), &vertices);
+   _mesa_TexCoordPointer(2, GL_FLOAT, 2 * sizeof(GLfloat), &texcoords);
+   _mesa_Enable(GL_VERTEX_ARRAY);
+   _mesa_Enable(GL_TEXTURE_COORD_ARRAY);
+   CALL_DrawArrays(ctx->Exec, (GL_TRIANGLE_FAN, 0, 4));
+
+   _mesa_MatrixMode(GL_PROJECTION);
+   _mesa_PopMatrix();
+   _mesa_MatrixMode(GL_MODELVIEW);
+   _mesa_PopMatrix();
+   _mesa_PopClientAttrib();
+   _mesa_PopAttrib();
+
+   _mesa_DeleteTextures(1, &texname);
 
    return GL_TRUE;
 }
 
-
-
 void
 intelDrawPixels(GLcontext * ctx,
                 GLint x, GLint y,
@@ -341,15 +178,10 @@ intelDrawPixels(GLcontext * ctx,
                 const struct gl_pixelstore_attrib *unpack,
                 const GLvoid * pixels)
 {
-   if (do_blit_drawpixels(ctx, x, y, width, height, format, type,
-                          unpack, pixels))
+   if (intel_texture_drawpixels(ctx, x, y, width, height, format, type,
+				unpack, pixels))
       return;
 
-   if (do_texture_drawpixels(ctx, x, y, width, height, format, type,
-                             unpack, pixels))
-      return;
-
-
    if (INTEL_DEBUG & DEBUG_PIXEL)
       _mesa_printf("%s: fallback to swrast\n", __FUNCTION__);