X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fswrast%2Fs_stencil.c;h=73bddc32fb83c5e6f773642bab3f2b44a0d65fbb;hb=8ef874f1a543c693cfef9c935bed05903800fbfe;hp=dd438e8dcbae6c98233b79956abd56ad8425ba90;hpb=79c2f534916046fab91f53ebd37f705bd25f7dcb;p=mesa.git

diff --git a/src/mesa/swrast/s_stencil.c b/src/mesa/swrast/s_stencil.c
index dd438e8dcba..73bddc32fb8 100644
--- a/src/mesa/swrast/s_stencil.c
+++ b/src/mesa/swrast/s_stencil.c
@@ -1,4 +1,3 @@
-/* $Id: s_stencil.c,v 1.20 2002/02/04 15:59:30 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -28,7 +27,7 @@
 #include "glheader.h"
 #include "context.h"
 #include "macros.h"
-#include "mem.h"
+#include "imports.h"
 
 #include "s_context.h"
 #include "s_depth.h"
@@ -65,17 +64,18 @@ ENDIF
  * Don't touch stencil[i] if mask[i] is zero.
  * Input:  n - size of stencil array
  *         oper - the stencil buffer operator
+ *         face - 0 or 1 for front or back face operation
  *         stencil - array of stencil values
  *         mask - array [n] of flag:  1=apply operator, 0=don't apply operator
  * Output:  stencil - modified values
  */
 static void
-apply_stencil_op( const GLcontext *ctx, GLenum oper,
+apply_stencil_op( const GLcontext *ctx, GLenum oper, GLuint face,
                   GLuint n, GLstencil stencil[], const GLubyte mask[] )
 {
-   const GLstencil ref = ctx->Stencil.Ref;
-   const GLstencil wrtmask = ctx->Stencil.WriteMask;
-   const GLstencil invmask = (GLstencil) (~ctx->Stencil.WriteMask);
+   const GLstencil ref = ctx->Stencil.Ref[face];
+   const GLstencil wrtmask = ctx->Stencil.WriteMask[face];
+   const GLstencil invmask = (GLstencil) (~wrtmask);
    GLuint i;
 
    switch (oper) {
@@ -223,7 +223,8 @@ apply_stencil_op( const GLcontext *ctx, GLenum oper,
 
 /**
  * Apply stencil test to an array of stencil values (before depth buffering).
- * Input:  n - number of pixels in the array
+ * Input:  face - 0 or 1 for front or back-face polygons
+ *         n - number of pixels in the array
  *         stencil - array of [n] stencil values
  *         mask - array [n] of flag:  0=skip the pixel, 1=stencil the pixel
  * Output:  mask - pixels which fail the stencil test will have their
@@ -232,13 +233,14 @@ apply_stencil_op( const GLcontext *ctx, GLenum oper,
  * Return:  GL_FALSE = all pixels failed, GL_TRUE = zero or more pixels passed.
  */
 static GLboolean
-do_stencil_test( GLcontext *ctx, GLuint n, GLstencil stencil[],
+do_stencil_test( GLcontext *ctx, GLuint face, GLuint n, GLstencil stencil[],
                  GLubyte mask[] )
 {
    GLubyte fail[MAX_WIDTH];
    GLboolean allfail = GL_FALSE;
    GLuint i;
    GLstencil r, s;
+   const GLuint valueMask = ctx->Stencil.ValueMask[face];
 
    ASSERT(n <= MAX_WIDTH);
 
@@ -251,7 +253,7 @@ do_stencil_test( GLcontext *ctx, GLuint n, GLstencil stencil[],
     *       the stencil fail operator is not to be applied
     *   ENDIF
     */
-   switch (ctx->Stencil.Function) {
+   switch (ctx->Stencil.Function[face]) {
       case GL_NEVER:
          /* never pass; always fail */
          for (i=0;i<n;i++) {
@@ -266,10 +268,10 @@ do_stencil_test( GLcontext *ctx, GLuint n, GLstencil stencil[],
 	 allfail = GL_TRUE;
 	 break;
       case GL_LESS:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
 	 for (i=0;i<n;i++) {
 	    if (mask[i]) {
-	       s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
+	       s = (GLstencil) (stencil[i] & valueMask);
 	       if (r < s) {
 		  /* passed */
 		  fail[i] = 0;
@@ -285,10 +287,10 @@ do_stencil_test( GLcontext *ctx, GLuint n, GLstencil stencil[],
 	 }
 	 break;
       case GL_LEQUAL:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
 	 for (i=0;i<n;i++) {
 	    if (mask[i]) {
-	       s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
+	       s = (GLstencil) (stencil[i] & valueMask);
 	       if (r <= s) {
 		  /* pass */
 		  fail[i] = 0;
@@ -304,10 +306,10 @@ do_stencil_test( GLcontext *ctx, GLuint n, GLstencil stencil[],
 	 }
 	 break;
       case GL_GREATER:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
 	 for (i=0;i<n;i++) {
 	    if (mask[i]) {
-	       s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
+	       s = (GLstencil) (stencil[i] & valueMask);
 	       if (r > s) {
 		  /* passed */
 		  fail[i] = 0;
@@ -323,10 +325,10 @@ do_stencil_test( GLcontext *ctx, GLuint n, GLstencil stencil[],
 	 }
 	 break;
       case GL_GEQUAL:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
 	 for (i=0;i<n;i++) {
 	    if (mask[i]) {
-	       s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
+	       s = (GLstencil) (stencil[i] & valueMask);
 	       if (r >= s) {
 		  /* passed */
 		  fail[i] = 0;
@@ -342,10 +344,10 @@ do_stencil_test( GLcontext *ctx, GLuint n, GLstencil stencil[],
 	 }
 	 break;
       case GL_EQUAL:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
 	 for (i=0;i<n;i++) {
 	    if (mask[i]) {
-	       s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
+	       s = (GLstencil) (stencil[i] & valueMask);
 	       if (r == s) {
 		  /* passed */
 		  fail[i] = 0;
@@ -361,10 +363,10 @@ do_stencil_test( GLcontext *ctx, GLuint n, GLstencil stencil[],
 	 }
 	 break;
       case GL_NOTEQUAL:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
 	 for (i=0;i<n;i++) {
 	    if (mask[i]) {
-	       s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
+	       s = (GLstencil) (stencil[i] & valueMask);
 	       if (r != s) {
 		  /* passed */
 		  fail[i] = 0;
@@ -390,8 +392,8 @@ do_stencil_test( GLcontext *ctx, GLuint n, GLstencil stencil[],
          return 0;
    }
 
-   if (ctx->Stencil.FailFunc != GL_KEEP) {
-      apply_stencil_op( ctx, ctx->Stencil.FailFunc, n, stencil, fail );
+   if (ctx->Stencil.FailFunc[face] != GL_KEEP) {
+      apply_stencil_op( ctx, ctx->Stencil.FailFunc[face], face, n, stencil, fail );
    }
 
    return !allfail;
@@ -412,7 +414,7 @@ do_stencil_test( GLcontext *ctx, GLuint n, GLstencil stencil[],
  *
  */
 static GLboolean
-stencil_and_ztest_span(GLcontext *ctx, struct sw_span *span)
+stencil_and_ztest_span(GLcontext *ctx, struct sw_span *span, GLuint face)
 {
    SWcontext *swrast = SWRAST_CONTEXT(ctx);
    GLstencil stencilRow[MAX_WIDTH];
@@ -420,7 +422,7 @@ stencil_and_ztest_span(GLcontext *ctx, struct sw_span *span)
    const GLuint n = span->end;
    const GLint x = span->x;
    const GLint y = span->y;
-   GLubyte *mask = span->mask;
+   GLubyte *mask = span->array->mask;
 
    ASSERT((span->arrayMask & SPAN_XY) == 0);
    ASSERT(ctx->Stencil.Enabled);
@@ -447,7 +449,7 @@ stencil_and_ztest_span(GLcontext *ctx, struct sw_span *span)
     * Apply the stencil test to the fragments.
     * failMask[i] is 1 if the stencil test failed.
     */
-   if (do_stencil_test( ctx, n, stencil, mask ) == GL_FALSE) {
+   if (do_stencil_test( ctx, face, n, stencil, mask ) == GL_FALSE) {
       /* all fragments failed the stencil test, we're done. */
       span->writeAll = GL_FALSE;
       return GL_FALSE;
@@ -461,7 +463,7 @@ stencil_and_ztest_span(GLcontext *ctx, struct sw_span *span)
       /*
        * No depth buffer, just apply zpass stencil function to active pixels.
        */
-      apply_stencil_op( ctx, ctx->Stencil.ZPassFunc, n, stencil, mask );
+      apply_stencil_op( ctx, ctx->Stencil.ZPassFunc[face], face, n, stencil, mask );
    }
    else {
       /*
@@ -474,7 +476,7 @@ stencil_and_ztest_span(GLcontext *ctx, struct sw_span *span)
       MEMCPY(oldmask, mask, n * sizeof(GLubyte));
 
       /* apply the depth test */
-      _mesa_depth_test_span(ctx, span);
+      _swrast_depth_test_span(ctx, span);
 
       /* Set the stencil pass/fail flags according to result of depth testing.
        * if oldmask[i] == 0 then
@@ -493,11 +495,13 @@ stencil_and_ztest_span(GLcontext *ctx, struct sw_span *span)
       }
 
       /* apply the pass and fail operations */
-      if (ctx->Stencil.ZFailFunc != GL_KEEP) {
-         apply_stencil_op( ctx, ctx->Stencil.ZFailFunc, n, stencil, failmask );
+      if (ctx->Stencil.ZFailFunc[face] != GL_KEEP) {
+         apply_stencil_op( ctx, ctx->Stencil.ZFailFunc[face], face,
+                           n, stencil, failmask );
       }
-      if (ctx->Stencil.ZPassFunc != GL_KEEP) {
-         apply_stencil_op( ctx, ctx->Stencil.ZPassFunc, n, stencil, passmask );
+      if (ctx->Stencil.ZPassFunc[face] != GL_KEEP) {
+         apply_stencil_op( ctx, ctx->Stencil.ZPassFunc[face], face,
+                           n, stencil, passmask );
       }
    }
 
@@ -529,11 +533,11 @@ stencil_and_ztest_span(GLcontext *ctx, struct sw_span *span)
 static void
 apply_stencil_op_to_pixels( const GLcontext *ctx,
                             GLuint n, const GLint x[], const GLint y[],
-                            GLenum oper, const GLubyte mask[] )
+                            GLenum oper, GLuint face, const GLubyte mask[] )
 {
-   const GLstencil ref = ctx->Stencil.Ref;
-   const GLstencil wrtmask = ctx->Stencil.WriteMask;
-   const GLstencil invmask = (GLstencil) (~ctx->Stencil.WriteMask);
+   const GLstencil ref = ctx->Stencil.Ref[face];
+   const GLstencil wrtmask = ctx->Stencil.WriteMask[face];
+   const GLstencil invmask = (GLstencil) (~wrtmask);
    GLuint i;
 
    ASSERT(!SWRAST_CONTEXT(ctx)->Driver.WriteStencilSpan);  /* software stencil buffer only! */
@@ -695,13 +699,14 @@ apply_stencil_op_to_pixels( const GLcontext *ctx,
  * \return  GL_FALSE = all pixels failed, GL_TRUE = zero or more pixels passed.
  */
 static GLboolean
-stencil_test_pixels( GLcontext *ctx, GLuint n,
+stencil_test_pixels( GLcontext *ctx, GLuint face, GLuint n,
                      const GLint x[], const GLint y[], GLubyte mask[] )
 {
    GLubyte fail[MAX_WIDTH];
    GLstencil r, s;
    GLuint i;
    GLboolean allfail = GL_FALSE;
+   const GLuint valueMask = ctx->Stencil.ValueMask[face];
 
   /* software stencil buffer only! */
    ASSERT(ctx->DrawBuffer->UseSoftwareStencilBuffer);
@@ -718,7 +723,7 @@ stencil_test_pixels( GLcontext *ctx, GLuint n,
     *   ENDIF
     */
 
-   switch (ctx->Stencil.Function) {
+   switch (ctx->Stencil.Function[face]) {
       case GL_NEVER:
          /* always fail */
          for (i=0;i<n;i++) {
@@ -733,11 +738,11 @@ stencil_test_pixels( GLcontext *ctx, GLuint n,
 	 allfail = GL_TRUE;
 	 break;
       case GL_LESS:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
 	 for (i=0;i<n;i++) {
 	    if (mask[i]) {
                GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
-	       s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
+	       s = (GLstencil) (*sptr & valueMask);
 	       if (r < s) {
 		  /* passed */
 		  fail[i] = 0;
@@ -753,11 +758,11 @@ stencil_test_pixels( GLcontext *ctx, GLuint n,
 	 }
 	 break;
       case GL_LEQUAL:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
 	 for (i=0;i<n;i++) {
 	    if (mask[i]) {
                GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
-	       s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
+	       s = (GLstencil) (*sptr & valueMask);
 	       if (r <= s) {
 		  /* pass */
 		  fail[i] = 0;
@@ -773,11 +778,11 @@ stencil_test_pixels( GLcontext *ctx, GLuint n,
 	 }
 	 break;
       case GL_GREATER:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
 	 for (i=0;i<n;i++) {
 	    if (mask[i]) {
                GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
-	       s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
+	       s = (GLstencil) (*sptr & valueMask);
 	       if (r > s) {
 		  /* passed */
 		  fail[i] = 0;
@@ -793,11 +798,11 @@ stencil_test_pixels( GLcontext *ctx, GLuint n,
 	 }
 	 break;
       case GL_GEQUAL:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
 	 for (i=0;i<n;i++) {
 	    if (mask[i]) {
                GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
-	       s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
+	       s = (GLstencil) (*sptr & valueMask);
 	       if (r >= s) {
 		  /* passed */
 		  fail[i] = 0;
@@ -813,11 +818,11 @@ stencil_test_pixels( GLcontext *ctx, GLuint n,
 	 }
 	 break;
       case GL_EQUAL:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
 	 for (i=0;i<n;i++) {
 	    if (mask[i]) {
                GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
-	       s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
+	       s = (GLstencil) (*sptr & valueMask);
 	       if (r == s) {
 		  /* passed */
 		  fail[i] = 0;
@@ -833,11 +838,11 @@ stencil_test_pixels( GLcontext *ctx, GLuint n,
 	 }
 	 break;
       case GL_NOTEQUAL:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
 	 for (i=0;i<n;i++) {
 	    if (mask[i]) {
                GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
-	       s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
+	       s = (GLstencil) (*sptr & valueMask);
 	       if (r != s) {
 		  /* passed */
 		  fail[i] = 0;
@@ -863,8 +868,9 @@ stencil_test_pixels( GLcontext *ctx, GLuint n,
          return 0;
    }
 
-   if (ctx->Stencil.FailFunc != GL_KEEP) {
-      apply_stencil_op_to_pixels( ctx, n, x, y, ctx->Stencil.FailFunc, fail );
+   if (ctx->Stencil.FailFunc[face] != GL_KEEP) {
+      apply_stencil_op_to_pixels( ctx, n, x, y, ctx->Stencil.FailFunc[face],
+                                  face, fail );
    }
 
    return !allfail;
@@ -890,12 +896,12 @@ stencil_test_pixels( GLcontext *ctx, GLuint n,
  *         GL_TRUE - one or more fragments passed the testing
  */
 static GLboolean
-stencil_and_ztest_pixels( GLcontext *ctx, struct sw_span *span )
+stencil_and_ztest_pixels( GLcontext *ctx, struct sw_span *span, GLuint face )
 {
    const GLuint n = span->end;
-   const GLint *x = span->xArray;
-   const GLint *y = span->yArray;
-   GLubyte *mask = span->mask;
+   const GLint *x = span->array->x;
+   const GLint *y = span->array->y;
+   GLubyte *mask = span->array->mask;
    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 
    ASSERT(span->arrayMask & SPAN_XY);
@@ -913,32 +919,33 @@ stencil_and_ztest_pixels( GLcontext *ctx, struct sw_span *span )
 
       MEMCPY(origMask, mask, n * sizeof(GLubyte));
 
-      (void) do_stencil_test(ctx, n, stencil, mask);
+      (void) do_stencil_test(ctx, face, n, stencil, mask);
 
       if (ctx->Depth.Test == GL_FALSE) {
-         apply_stencil_op(ctx, ctx->Stencil.ZPassFunc, n, stencil, mask);
+         apply_stencil_op(ctx, ctx->Stencil.ZPassFunc[face], face,
+                          n, stencil, mask);
       }
       else {
-         _mesa_depth_test_span(ctx, span);
+         _swrast_depth_test_span(ctx, span);
 
-         if (ctx->Stencil.ZFailFunc != GL_KEEP) {
+         if (ctx->Stencil.ZFailFunc[face] != GL_KEEP) {
             GLubyte failmask[MAX_WIDTH];
             GLuint i;
             for (i = 0; i < n; i++) {
                ASSERT(mask[i] == 0 || mask[i] == 1);
                failmask[i] = origMask[i] & (mask[i] ^ 1);
             }
-            apply_stencil_op(ctx, ctx->Stencil.ZFailFunc,
+            apply_stencil_op(ctx, ctx->Stencil.ZFailFunc[face], face,
                              n, stencil, failmask);
          }
-         if (ctx->Stencil.ZPassFunc != GL_KEEP) {
+         if (ctx->Stencil.ZPassFunc[face] != GL_KEEP) {
             GLubyte passmask[MAX_WIDTH];
             GLuint i;
             for (i = 0; i < n; i++) {
                ASSERT(mask[i] == 0 || mask[i] == 1);
                passmask[i] = origMask[i] & mask[i];
             }
-            apply_stencil_op(ctx, ctx->Stencil.ZPassFunc,
+            apply_stencil_op(ctx, ctx->Stencil.ZPassFunc[face], face,
                              n, stencil, passmask);
          }
       }
@@ -953,14 +960,14 @@ stencil_and_ztest_pixels( GLcontext *ctx, struct sw_span *span )
 
       ASSERT(ctx->DrawBuffer->UseSoftwareStencilBuffer);
 
-      if (stencil_test_pixels(ctx, n, x, y, mask) == GL_FALSE) {
+      if (stencil_test_pixels(ctx, face, n, x, y, mask) == GL_FALSE) {
          /* all fragments failed the stencil test, we're done. */
          return GL_FALSE;
       }
 
       if (ctx->Depth.Test==GL_FALSE) {
          apply_stencil_op_to_pixels(ctx, n, x, y,
-                                    ctx->Stencil.ZPassFunc, mask);
+                                    ctx->Stencil.ZPassFunc[face], face, mask);
       }
       else {
          GLubyte passmask[MAX_WIDTH], failmask[MAX_WIDTH], oldmask[MAX_WIDTH];
@@ -968,7 +975,7 @@ stencil_and_ztest_pixels( GLcontext *ctx, struct sw_span *span )
 
          MEMCPY(oldmask, mask, n * sizeof(GLubyte));
 
-         _mesa_depth_test_span(ctx, span);
+         _swrast_depth_test_span(ctx, span);
 
          for (i=0;i<n;i++) {
             ASSERT(mask[i] == 0 || mask[i] == 1);
@@ -976,13 +983,15 @@ stencil_and_ztest_pixels( GLcontext *ctx, struct sw_span *span )
             failmask[i] = oldmask[i] & (mask[i] ^ 1);
          }
 
-         if (ctx->Stencil.ZFailFunc != GL_KEEP) {
+         if (ctx->Stencil.ZFailFunc[face] != GL_KEEP) {
             apply_stencil_op_to_pixels(ctx, n, x, y,
-                                       ctx->Stencil.ZFailFunc, failmask);
+                                       ctx->Stencil.ZFailFunc[face],
+                                       face, failmask);
          }
-         if (ctx->Stencil.ZPassFunc != GL_KEEP) {
+         if (ctx->Stencil.ZPassFunc[face] != GL_KEEP) {
             apply_stencil_op_to_pixels(ctx, n, x, y,
-                                       ctx->Stencil.ZPassFunc, passmask);
+                                       ctx->Stencil.ZPassFunc[face],
+                                       face, passmask);
          }
       }
 
@@ -996,12 +1005,14 @@ stencil_and_ztest_pixels( GLcontext *ctx, struct sw_span *span )
  * GL_FALSE = all fragments failed.
  */
 GLboolean
-_mesa_stencil_and_ztest_span(GLcontext *ctx, struct sw_span *span)
+_swrast_stencil_and_ztest_span(GLcontext *ctx, struct sw_span *span)
 {
+   /* span->facing can only be non-zero if using two-sided stencil */
+   ASSERT(ctx->Stencil.TestTwoSide || span->facing == 0);
    if (span->arrayMask & SPAN_XY)
-      return stencil_and_ztest_pixels(ctx, span);
+      return stencil_and_ztest_pixels(ctx, span, span->facing);
    else
-      return stencil_and_ztest_span(ctx, span);
+      return stencil_and_ztest_span(ctx, span, span->facing);
 }
 
 
@@ -1013,12 +1024,14 @@ _mesa_stencil_and_ztest_span(GLcontext *ctx, struct sw_span *span)
  * Output:  stencil - the array of stencil values
  */
 void
-_mesa_read_stencil_span( GLcontext *ctx,
+_swrast_read_stencil_span( GLcontext *ctx,
                          GLint n, GLint x, GLint y, GLstencil stencil[] )
 {
    SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   if (y < 0 || y >= ctx->DrawBuffer->Height ||
-       x + n <= 0 || x >= ctx->DrawBuffer->Width) {
+   const GLint bufWidth = (GLint) ctx->DrawBuffer->Width;
+   const GLint bufHeight = (GLint) ctx->DrawBuffer->Height;
+
+   if (y < 0 || y >= bufHeight || x + n <= 0 || x >= bufWidth) {
       /* span is completely outside framebuffer */
       return; /* undefined values OK */
    }
@@ -1029,8 +1042,8 @@ _mesa_read_stencil_span( GLcontext *ctx,
       n -= dx;
       stencil += dx;
    }
-   if (x + n > ctx->DrawBuffer->Width) {
-      GLint dx = x + n - ctx->DrawBuffer->Width;
+   if (x + n > bufWidth) {
+      GLint dx = x + n - bufWidth;
       n -= dx;
    }
    if (n <= 0) {
@@ -1064,14 +1077,15 @@ _mesa_read_stencil_span( GLcontext *ctx,
  *         stencil - the array of stencil values
  */
 void
-_mesa_write_stencil_span( GLcontext *ctx, GLint n, GLint x, GLint y,
+_swrast_write_stencil_span( GLcontext *ctx, GLint n, GLint x, GLint y,
                           const GLstencil stencil[] )
 {
    SWcontext *swrast = SWRAST_CONTEXT(ctx);
    const GLstencil *ssrc = stencil;
+   const GLint bufWidth = (GLint) ctx->DrawBuffer->Width;
+   const GLint bufHeight = (GLint) ctx->DrawBuffer->Height;
 
-   if (y < 0 || y >= ctx->DrawBuffer->Height ||
-       x + n <= 0 || x >= ctx->DrawBuffer->Width) {
+   if (y < 0 || y >= bufHeight || x + n <= 0 || x >= bufWidth) {
       /* span is completely outside framebuffer */
       return; /* undefined values OK */
    }
@@ -1082,8 +1096,8 @@ _mesa_write_stencil_span( GLcontext *ctx, GLint n, GLint x, GLint y,
       n -= dx;
       ssrc += dx;
    }
-   if (x + n > ctx->DrawBuffer->Width) {
-      GLint dx = x + n - ctx->DrawBuffer->Width;
+   if (x + n > bufWidth) {
+      GLint dx = x + n - bufWidth;
       n -= dx;
    }
    if (n <= 0) {
@@ -1112,22 +1126,20 @@ _mesa_write_stencil_span( GLcontext *ctx, GLint n, GLint x, GLint y,
  * deallocated first.  The new stencil buffer will be uninitialized.
  */
 void
-_mesa_alloc_stencil_buffer( GLcontext *ctx )
+_swrast_alloc_stencil_buffer( GLframebuffer *buffer )
 {
-   GLuint buffersize = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
-
    /* deallocate current stencil buffer if present */
-   if (ctx->DrawBuffer->Stencil) {
-      FREE(ctx->DrawBuffer->Stencil);
-      ctx->DrawBuffer->Stencil = NULL;
+   if (buffer->Stencil) {
+      MESA_PBUFFER_FREE(buffer->Stencil);
+      buffer->Stencil = NULL;
    }
 
    /* allocate new stencil buffer */
-   ctx->DrawBuffer->Stencil = (GLstencil *) MALLOC(buffersize * sizeof(GLstencil));
-   if (!ctx->DrawBuffer->Stencil) {
+   buffer->Stencil = (GLstencil *)
+      MESA_PBUFFER_ALLOC(buffer->Width * buffer->Height * sizeof(GLstencil));
+   if (!buffer->Stencil) {
       /* out of memory */
-/*        _mesa_set_enable( ctx, GL_STENCIL_TEST, GL_FALSE ); */
-      _mesa_error( ctx, GL_OUT_OF_MEMORY, "_mesa_alloc_stencil_buffer" );
+      _mesa_error( NULL, GL_OUT_OF_MEMORY, "_swrast_alloc_stencil_buffer" );
    }
 }
 
@@ -1147,11 +1159,11 @@ clear_software_stencil_buffer( GLcontext *ctx )
    if (ctx->Scissor.Enabled) {
       /* clear scissor region only */
       const GLint width = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
-      if (ctx->Stencil.WriteMask != STENCIL_MAX) {
+      if (ctx->Stencil.WriteMask[0] != STENCIL_MAX) {
          /* must apply mask to the clear */
          GLint y;
          for (y = ctx->DrawBuffer->_Ymin; y < ctx->DrawBuffer->_Ymax; y++) {
-            const GLstencil mask = ctx->Stencil.WriteMask;
+            const GLstencil mask = ctx->Stencil.WriteMask[0];
             const GLstencil invMask = ~mask;
             const GLstencil clearVal = (ctx->Stencil.Clear & mask);
             GLstencil *stencil = STENCIL_ADDRESS( ctx->DrawBuffer->_Xmin, y );
@@ -1178,11 +1190,11 @@ clear_software_stencil_buffer( GLcontext *ctx )
    }
    else {
       /* clear whole stencil buffer */
-      if (ctx->Stencil.WriteMask != STENCIL_MAX) {
+      if (ctx->Stencil.WriteMask[0] != STENCIL_MAX) {
          /* must apply mask to the clear */
          const GLuint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
          GLstencil *stencil = ctx->DrawBuffer->Stencil;
-         const GLstencil mask = ctx->Stencil.WriteMask;
+         const GLstencil mask = ctx->Stencil.WriteMask[0];
          const GLstencil invMask = ~mask;
          const GLstencil clearVal = (ctx->Stencil.Clear & mask);
          GLuint i;
@@ -1229,11 +1241,11 @@ clear_hardware_stencil_buffer( GLcontext *ctx )
       /* clear scissor region only */
       const GLint x = ctx->DrawBuffer->_Xmin;
       const GLint width = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
-      if (ctx->Stencil.WriteMask != STENCIL_MAX) {
+      if (ctx->Stencil.WriteMask[0] != STENCIL_MAX) {
          /* must apply mask to the clear */
          GLint y;
          for (y = ctx->DrawBuffer->_Ymin; y < ctx->DrawBuffer->_Ymax; y++) {
-            const GLstencil mask = ctx->Stencil.WriteMask;
+            const GLstencil mask = ctx->Stencil.WriteMask[0];
             const GLstencil invMask = ~mask;
             const GLstencil clearVal = (ctx->Stencil.Clear & mask);
             GLstencil stencil[MAX_WIDTH];
@@ -1259,9 +1271,9 @@ clear_hardware_stencil_buffer( GLcontext *ctx )
    }
    else {
       /* clear whole stencil buffer */
-      if (ctx->Stencil.WriteMask != STENCIL_MAX) {
+      if (ctx->Stencil.WriteMask[0] != STENCIL_MAX) {
          /* must apply mask to the clear */
-         const GLstencil mask = ctx->Stencil.WriteMask;
+         const GLstencil mask = ctx->Stencil.WriteMask[0];
          const GLstencil invMask = ~mask;
          const GLstencil clearVal = (ctx->Stencil.Clear & mask);
          const GLint width = ctx->DrawBuffer->Width;
@@ -1301,7 +1313,7 @@ clear_hardware_stencil_buffer( GLcontext *ctx )
  * Clear the stencil buffer (hardware or software).
  */
 void
-_mesa_clear_stencil_buffer( GLcontext *ctx )
+_swrast_clear_stencil_buffer( GLcontext *ctx )
 {
    SWcontext *swrast = SWRAST_CONTEXT(ctx);
    if (swrast->Driver.WriteStencilSpan) {