Remove useless checks for NULL before freeing

[profile/ivi/pixman.git] / pixman / pixman-edge-imp.h

diff --git a/pixman/pixman-edge-imp.h b/pixman/pixman-edge-imp.h
index 1687c0b..a4698ed 100644 (file)
--- a/pixman/pixman-edge-imp.h
+++ b/pixman/pixman-edge-imp.h
@@ -20,11 +20,11 @@
  * PERFORMANCE OF THIS SOFTWARE.
  */
 
-#ifndef rasterizeSpan
+#ifndef rasterize_span
 #endif
 
 static void
-rasterizeEdges (pixman_image_t  *image,
+RASTERIZE_EDGES (pixman_image_t  *image,
                pixman_edge_t   *l,
                pixman_edge_t   *r,
                pixman_fixed_t          t,
@@ -49,10 +49,14 @@ rasterizeEdges (pixman_image_t  *image,
        rx = r->x;
 #if N_BITS == 1
        /* For the non-antialiased case, round the coordinates up, in effect
-        * sampling the center of the pixel. (The AA case does a similar 
-        * adjustment in RenderSamplesX) */
-       lx += X_FRAC_FIRST(1);
-       rx += X_FRAC_FIRST(1);
+        * sampling just slightly to the left of the pixel. This is so that
+        * when the sample point lies exactly on the line, we round towards
+        * north-west.
+        *
+        * (The AA case does a similar  adjustment in RENDER_SAMPLES_X)
+        */
+       lx += X_FRAC_FIRST(1) - pixman_fixed_e;
+       rx += X_FRAC_FIRST(1) - pixman_fixed_e;
 #endif
        /* clip X */
        if (lx < 0)
@@ -79,22 +83,14 @@ rasterizeEdges (pixman_image_t  *image,
 #if N_BITS == 1
            {
 
-#ifdef WORDS_BIGENDIAN
-#   define SCREEN_SHIFT_LEFT(x,n)      ((x) << (n))
-#   define FbScrRight(x,n)     ((x) >> (n))
-#else
-#   define SCREEN_SHIFT_LEFT(x,n)      ((x) >> (n))
-#   define FbScrRight(x,n)     ((x) << (n))
-#endif
-
 #define LEFT_MASK(x)                                                   \
                (((x) & 0x1f) ?                                         \
-                FbScrRight (0xffffffff, (x) & 0x1f) : 0)
+                SCREEN_SHIFT_RIGHT (0xffffffff, (x) & 0x1f) : 0)
 #define RIGHT_MASK(x)                                                  \
                (((32 - (x)) & 0x1f) ?                                  \
                 SCREEN_SHIFT_LEFT (0xffffffff, (32 - (x)) & 0x1f) : 0)
                
-#define FbMaskBits(x,w,l,n,r) {                                                \
+#define MASK_BITS(x,w,l,n,r) {                                         \
                    n = (w);                                            \
                    r = RIGHT_MASK ((x) + n);                           \
                    l = LEFT_MASK (x);                                  \
@@ -119,7 +115,7 @@ rasterizeEdges (pixman_image_t  *image,
                a += x >> 5;
                x &= 0x1f;
                
-               FbMaskBits (x, width, startmask, nmiddle, endmask);
+               MASK_BITS (x, width, startmask, nmiddle, endmask);
 
                if (startmask) {
                    WRITE(image, a, READ(image, a) | startmask);
@@ -132,31 +128,31 @@ rasterizeEdges (pixman_image_t  *image,
            }
 #else
            {
-               DefineAlpha(line,lxi);
+               DEFINE_ALPHA(line,lxi);
                int         lxs;
                int     rxs;
 
                /* Sample coverage for edge pixels */
-               lxs = RenderSamplesX (lx, N_BITS);
-               rxs = RenderSamplesX (rx, N_BITS);
+               lxs = RENDER_SAMPLES_X (lx, N_BITS);
+               rxs = RENDER_SAMPLES_X (rx, N_BITS);
 
                /* Add coverage across row */
                if (lxi == rxi)
                {
-                   AddAlpha (rxs - lxs);
+                   ADD_ALPHA (rxs - lxs);
                }
                else
                {
                    int xi;
 
-                   AddAlpha (N_X_FRAC(N_BITS) - lxs);
-                   StepAlpha;
+                   ADD_ALPHA (N_X_FRAC(N_BITS) - lxs);
+                   STEP_ALPHA;
                    for (xi = lxi + 1; xi < rxi; xi++)
                    {
-                       AddAlpha (N_X_FRAC(N_BITS));
-                       StepAlpha;
+                       ADD_ALPHA (N_X_FRAC(N_BITS));
+                       STEP_ALPHA;
                    }
-                   AddAlpha (rxs);
+                   ADD_ALPHA (rxs);
                }
            }
 #endif
@@ -168,19 +164,19 @@ rasterizeEdges (pixman_image_t  *image,
 #if N_BITS > 1
        if (pixman_fixed_frac (y) != Y_FRAC_LAST(N_BITS))
        {
-           RenderEdgeStepSmall (l);
-           RenderEdgeStepSmall (r);
+           RENDER_EDGE_STEP_SMALL (l);
+           RENDER_EDGE_STEP_SMALL (r);
            y += STEP_Y_SMALL(N_BITS);
        }
        else
 #endif
        {
-           RenderEdgeStepBig (l);
-           RenderEdgeStepBig (r);
+           RENDER_EDGE_STEP_BIG (l);
+           RENDER_EDGE_STEP_BIG (r);
            y += STEP_Y_BIG(N_BITS);
            line += stride;
        }
     }
 }
 
-#undef rasterizeSpan
+#undef rasterize_span