Making the API simpler, moved the surface drawing functions to the software renderer.
authorSam Lantinga <slouken@libsdl.org>
Thu, 03 Feb 2011 02:45:29 -0800
changeset 5163 d72793305335
parent 5162 e2b3f003e085
child 5164 97423d858a1a
Making the API simpler, moved the surface drawing functions to the software renderer.
include/SDL_surface.h
src/render/software/SDL_blendfillrect.c
src/render/software/SDL_blendfillrect.h
src/render/software/SDL_blendline.c
src/render/software/SDL_blendline.h
src/render/software/SDL_blendpoint.c
src/render/software/SDL_blendpoint.h
src/render/software/SDL_draw.h
src/render/software/SDL_drawline.c
src/render/software/SDL_drawline.h
src/render/software/SDL_drawpoint.c
src/render/software/SDL_drawpoint.h
src/render/software/SDL_renderer_sw.c
src/video/SDL_alphamult.c
src/video/SDL_alphamult.h
src/video/SDL_blendfillrect.c
src/video/SDL_blendline.c
src/video/SDL_blendpoint.c
src/video/SDL_blendrect.c
src/video/SDL_blit.h
src/video/SDL_draw.h
src/video/SDL_drawline.c
src/video/SDL_drawpoint.c
src/video/SDL_drawrect.c
test/automated/surface/surface.c
--- a/include/SDL_surface.h	Thu Feb 03 02:42:50 2011 -0800
+++ b/include/SDL_surface.h	Thu Feb 03 02:45:29 2011 -0800
@@ -364,85 +364,6 @@
                                               void * dst, int dst_pitch);
 
 /**
- *  Draws a point with \c color.
- *
- *  The color should be a pixel of the format used by the surface, and 
- *  can be generated by the SDL_MapRGB() function.
- *  
- *  \return 0 on success, or -1 on error.
- */
-extern DECLSPEC int SDLCALL SDL_DrawPoint
-    (SDL_Surface * dst, int x, int y, Uint32 color);
-extern DECLSPEC int SDLCALL SDL_DrawPoints
-    (SDL_Surface * dst, const SDL_Point * points, int count, Uint32 color);
-
-/**
- *  Blends a point with an RGBA value.
- *  
- *  \return 0 on success, or -1 on error.
- */
-extern DECLSPEC int SDLCALL SDL_BlendPoint
-    (SDL_Surface * dst, int x, int y,
-     SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
-extern DECLSPEC int SDLCALL SDL_BlendPoints
-    (SDL_Surface * dst, const SDL_Point * points, int count,
-     SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
-
-/**
- *  Draws a line with \c color.
- *  
- *  The color should be a pixel of the format used by the surface, and 
- *  can be generated by the SDL_MapRGB() function.
- *  
- *  \return 0 on success, or -1 on error.
- */
-extern DECLSPEC int SDLCALL SDL_DrawLine
-    (SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color);
-extern DECLSPEC int SDLCALL SDL_DrawLines
-    (SDL_Surface * dst, const SDL_Point * points, int count, Uint32 color);
-
-/**
- *  Blends an RGBA value along a line.
- *  
- *  \return 0 on success, or -1 on error.
- */
-extern DECLSPEC int SDLCALL SDL_BlendLine
-    (SDL_Surface * dst, int x1, int y1, int x2, int y2,
-     SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
-extern DECLSPEC int SDLCALL SDL_BlendLines
-    (SDL_Surface * dst, const SDL_Point * points, int count,
-     SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
-
-/**
- *  Draws the given rectangle with \c color.
- *  
- *  If \c rect is NULL, the whole surface will be outlined with \c color.
- *  
- *  The color should be a pixel of the format used by the surface, and 
- *  can be generated by the SDL_MapRGB() function.
- *  
- *  \return 0 on success, or -1 on error.
- */
-extern DECLSPEC int SDLCALL SDL_DrawRect
-    (SDL_Surface * dst, const SDL_Rect * rect, Uint32 color);
-extern DECLSPEC int SDLCALL SDL_DrawRects
-    (SDL_Surface * dst, const SDL_Rect ** rects, int count, Uint32 color);
-
-/**
- *  Blends an RGBA value into the outline of the given rectangle.
- *  
- *  If \c rect is NULL, the whole surface will have a blended outline.
- *  
- *  \return 0 on success, or -1 on error.
- */
-extern DECLSPEC int SDLCALL SDL_BlendRect
-    (SDL_Surface * dst, const SDL_Rect * rect,
-     SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
-extern DECLSPEC int SDLCALL SDL_BlendRects
-    (SDL_Surface * dst, const SDL_Rect ** rects, int count,
-     SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
-
-/**
  *  Performs a fast fill of the given rectangle with \c color.
  *  
  *  If \c rect is NULL, the whole surface will be filled with \c color.
@@ -458,20 +379,6 @@
     (SDL_Surface * dst, const SDL_Rect ** rects, int count, Uint32 color);
 
 /**
- *  Blends an RGBA value into the given rectangle.
- *  
- *  If \c rect is NULL, the whole surface will be blended with the color.
- *  
- *  \return This function returns 0 on success, or -1 on error.
- */
-extern DECLSPEC int SDLCALL SDL_BlendFillRect
-    (SDL_Surface * dst, const SDL_Rect * rect,
-     SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
-extern DECLSPEC int SDLCALL SDL_BlendFillRects
-    (SDL_Surface * dst, const SDL_Rect ** rects, int count,
-     SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
-
-/**
  *  Performs a fast blit from the source surface to the destination surface.
  *  
  *  This assumes that the source and destination rectangles are
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/render/software/SDL_blendfillrect.c	Thu Feb 03 02:45:29 2011 -0800
@@ -0,0 +1,327 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#include "SDL_draw.h"
+#include "SDL_blendfillrect.h"
+
+
+static int
+SDL_BlendFillRect_RGB555(SDL_Surface * dst, const SDL_Rect * rect,
+                         SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    unsigned inva = 0xff - a;
+
+    switch (blendMode) {
+    case SDL_BLENDMODE_BLEND:
+        FILLRECT(Uint16, DRAW_SETPIXEL_BLEND_RGB555);
+        break;
+    case SDL_BLENDMODE_ADD:
+        FILLRECT(Uint16, DRAW_SETPIXEL_ADD_RGB555);
+        break;
+    default:
+        FILLRECT(Uint16, DRAW_SETPIXEL_RGB555);
+        break;
+    }
+    return 0;
+}
+
+static int
+SDL_BlendFillRect_RGB565(SDL_Surface * dst, const SDL_Rect * rect,
+                         SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    unsigned inva = 0xff - a;
+
+    switch (blendMode) {
+    case SDL_BLENDMODE_BLEND:
+        FILLRECT(Uint16, DRAW_SETPIXEL_BLEND_RGB565);
+        break;
+    case SDL_BLENDMODE_ADD:
+        FILLRECT(Uint16, DRAW_SETPIXEL_ADD_RGB565);
+        break;
+    default:
+        FILLRECT(Uint16, DRAW_SETPIXEL_RGB565);
+        break;
+    }
+    return 0;
+}
+
+static int
+SDL_BlendFillRect_RGB888(SDL_Surface * dst, const SDL_Rect * rect,
+                         SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    unsigned inva = 0xff - a;
+
+    switch (blendMode) {
+    case SDL_BLENDMODE_BLEND:
+        FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_RGB888);
+        break;
+    case SDL_BLENDMODE_ADD:
+        FILLRECT(Uint32, DRAW_SETPIXEL_ADD_RGB888);
+        break;
+    default:
+        FILLRECT(Uint32, DRAW_SETPIXEL_RGB888);
+        break;
+    }
+    return 0;
+}
+
+static int
+SDL_BlendFillRect_ARGB8888(SDL_Surface * dst, const SDL_Rect * rect,
+                           SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    unsigned inva = 0xff - a;
+
+    switch (blendMode) {
+    case SDL_BLENDMODE_BLEND:
+        FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888);
+        break;
+    case SDL_BLENDMODE_ADD:
+        FILLRECT(Uint32, DRAW_SETPIXEL_ADD_ARGB8888);
+        break;
+    default:
+        FILLRECT(Uint32, DRAW_SETPIXEL_ARGB8888);
+        break;
+    }
+    return 0;
+}
+
+static int
+SDL_BlendFillRect_RGB(SDL_Surface * dst, const SDL_Rect * rect,
+                      SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    SDL_PixelFormat *fmt = dst->format;
+    unsigned inva = 0xff - a;
+
+    switch (fmt->BytesPerPixel) {
+    case 2:
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            FILLRECT(Uint16, DRAW_SETPIXEL_BLEND_RGB);
+            break;
+        case SDL_BLENDMODE_ADD:
+            FILLRECT(Uint16, DRAW_SETPIXEL_ADD_RGB);
+            break;
+        default:
+            FILLRECT(Uint16, DRAW_SETPIXEL_RGB);
+            break;
+        }
+        return 0;
+    case 4:
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_RGB);
+            break;
+        case SDL_BLENDMODE_ADD:
+            FILLRECT(Uint32, DRAW_SETPIXEL_ADD_RGB);
+            break;
+        default:
+            FILLRECT(Uint32, DRAW_SETPIXEL_RGB);
+            break;
+        }
+        return 0;
+    default:
+        SDL_Unsupported();
+        return -1;
+    }
+}
+
+static int
+SDL_BlendFillRect_RGBA(SDL_Surface * dst, const SDL_Rect * rect,
+                       SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    SDL_PixelFormat *fmt = dst->format;
+    unsigned inva = 0xff - a;
+
+    switch (fmt->BytesPerPixel) {
+    case 4:
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_RGBA);
+            break;
+        case SDL_BLENDMODE_ADD:
+            FILLRECT(Uint32, DRAW_SETPIXEL_ADD_RGBA);
+            break;
+        default:
+            FILLRECT(Uint32, DRAW_SETPIXEL_RGBA);
+            break;
+        }
+        return 0;
+    default:
+        SDL_Unsupported();
+        return -1;
+    }
+}
+
+int
+SDL_BlendFillRect(SDL_Surface * dst, const SDL_Rect * rect,
+                  SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    SDL_Rect clipped;
+
+    if (!dst) {
+        SDL_SetError("Passed NULL destination surface");
+        return -1;
+    }
+
+    /* This function doesn't work on surfaces < 8 bpp */
+    if (dst->format->BitsPerPixel < 8) {
+        SDL_SetError("SDL_BlendFillRect(): Unsupported surface format");
+        return -1;
+    }
+
+    /* If 'rect' == NULL, then fill the whole surface */
+    if (rect) {
+        /* Perform clipping */
+        if (!SDL_IntersectRect(rect, &dst->clip_rect, &clipped)) {
+            return 0;
+        }
+        rect = &clipped;
+    } else {
+        rect = &dst->clip_rect;
+    }
+
+    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+        r = DRAW_MUL(r, a);
+        g = DRAW_MUL(g, a);
+        b = DRAW_MUL(b, a);
+    }
+
+    switch (dst->format->BitsPerPixel) {
+    case 15:
+        switch (dst->format->Rmask) {
+        case 0x7C00:
+            return SDL_BlendFillRect_RGB555(dst, rect, blendMode, r, g, b, a);
+        }
+        break;
+    case 16:
+        switch (dst->format->Rmask) {
+        case 0xF800:
+            return SDL_BlendFillRect_RGB565(dst, rect, blendMode, r, g, b, a);
+        }
+        break;
+    case 32:
+        switch (dst->format->Rmask) {
+        case 0x00FF0000:
+            if (!dst->format->Amask) {
+                return SDL_BlendFillRect_RGB888(dst, rect, blendMode, r, g, b, a);
+            } else {
+                return SDL_BlendFillRect_ARGB8888(dst, rect, blendMode, r, g, b, a);
+            }
+            break;
+        }
+        break;
+    default:
+        break;
+    }
+
+    if (!dst->format->Amask) {
+        return SDL_BlendFillRect_RGB(dst, rect, blendMode, r, g, b, a);
+    } else {
+        return SDL_BlendFillRect_RGBA(dst, rect, blendMode, r, g, b, a);
+    }
+}
+
+int
+SDL_BlendFillRects(SDL_Surface * dst, const SDL_Rect ** rects, int count,
+                   SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    SDL_Rect clipped;
+    int i;
+    int (*func)(SDL_Surface * dst, const SDL_Rect * rect,
+                SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a) = NULL;
+    int status = 0;
+
+    if (!dst) {
+        SDL_SetError("Passed NULL destination surface");
+        return -1;
+    }
+
+    /* This function doesn't work on surfaces < 8 bpp */
+    if (dst->format->BitsPerPixel < 8) {
+        SDL_SetError("SDL_BlendFillRects(): Unsupported surface format");
+        return -1;
+    }
+
+    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+        r = DRAW_MUL(r, a);
+        g = DRAW_MUL(g, a);
+        b = DRAW_MUL(b, a);
+    }
+
+    /* FIXME: Does this function pointer slow things down significantly? */
+    switch (dst->format->BitsPerPixel) {
+    case 15:
+        switch (dst->format->Rmask) {
+        case 0x7C00:
+            func = SDL_BlendFillRect_RGB555;
+        }
+        break;
+    case 16:
+        switch (dst->format->Rmask) {
+        case 0xF800:
+            func = SDL_BlendFillRect_RGB565;
+        }
+        break;
+    case 32:
+        switch (dst->format->Rmask) {
+        case 0x00FF0000:
+            if (!dst->format->Amask) {
+                func = SDL_BlendFillRect_RGB888;
+            } else {
+                func = SDL_BlendFillRect_ARGB8888;
+            }
+            break;
+        }
+        break;
+    default:
+        break;
+    }
+
+    if (!func) {
+        if (!dst->format->Amask) {
+            func = SDL_BlendFillRect_RGB;
+        } else {
+            func = SDL_BlendFillRect_RGBA;
+        }
+    }
+
+    for (i = 0; i < count; ++i) {
+        const SDL_Rect * rect = rects[i];
+
+        /* If 'rect' == NULL, then fill the whole surface */
+        if (rect) {
+            /* Perform clipping */
+            if (!SDL_IntersectRect(rect, &dst->clip_rect, &clipped)) {
+                continue;
+            }
+            rect = &clipped;
+        } else {
+            rect = &dst->clip_rect;
+        }
+
+        status = func(dst, rect, blendMode, r, g, b, a);
+    }
+    return status;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/render/software/SDL_blendfillrect.h	Thu Feb 03 02:45:29 2011 -0800
@@ -0,0 +1,28 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+
+extern int SDL_BlendFillRect(SDL_Surface * dst, const SDL_Rect * rect, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+extern int SDL_BlendFillRects(SDL_Surface * dst, const SDL_Rect ** rects, int count, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+
+/* vi: set ts=4 sw=4 expandtab: */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/render/software/SDL_blendline.c	Thu Feb 03 02:45:29 2011 -0800
@@ -0,0 +1,683 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#include "SDL_draw.h"
+#include "SDL_blendline.h"
+
+
+static void
+SDL_BlendLine_RGB2(SDL_Surface * dst, int x1, int y1, int x2, int y2,
+                   SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
+                   SDL_bool draw_end)
+{
+    const SDL_PixelFormat *fmt = dst->format;
+    unsigned r, g, b, a, inva;
+
+    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+        r = DRAW_MUL(_r, _a);
+        g = DRAW_MUL(_g, _a);
+        b = DRAW_MUL(_b, _a);
+        a = _a;
+    } else {
+        r = _r;
+        g = _g;
+        b = _b;
+        a = _a;
+    }
+    inva = (a ^ 0xff);
+
+    if (y1 == y2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
+            break;
+        default:
+            HLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
+            break;
+        }
+    } else if (x1 == x2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
+            break;
+        default:
+            VLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
+            break;
+        }
+    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
+            break;
+        default:
+            DLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
+            break;
+        }
+    } else {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY2_BLEND_RGB, DRAW_SETPIXELXY2_BLEND_RGB,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY2_ADD_RGB, DRAW_SETPIXELXY2_ADD_RGB,
+                   draw_end);
+            break;
+        default:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY2_RGB, DRAW_SETPIXELXY2_BLEND_RGB,
+                   draw_end);
+            break;
+        }
+    }
+}
+
+static void
+SDL_BlendLine_RGB555(SDL_Surface * dst, int x1, int y1, int x2, int y2,
+                     SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
+                     SDL_bool draw_end)
+{
+    const SDL_PixelFormat *fmt = dst->format;
+    unsigned r, g, b, a, inva;
+
+    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+        r = DRAW_MUL(_r, _a);
+        g = DRAW_MUL(_g, _a);
+        b = DRAW_MUL(_b, _a);
+        a = _a;
+    } else {
+        r = _r;
+        g = _g;
+        b = _b;
+        a = _a;
+    }
+    inva = (a ^ 0xff);
+
+    if (y1 == y2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
+            break;
+        default:
+            HLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
+            break;
+        }
+    } else if (x1 == x2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
+            break;
+        default:
+            VLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
+            break;
+        }
+    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
+            break;
+        default:
+            DLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
+            break;
+        }
+    } else {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_BLEND_RGB555, DRAW_SETPIXELXY_BLEND_RGB555,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_ADD_RGB555, DRAW_SETPIXELXY_ADD_RGB555,
+                   draw_end);
+            break;
+        default:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_RGB555, DRAW_SETPIXELXY_BLEND_RGB555,
+                   draw_end);
+            break;
+        }
+    }
+}
+
+static void
+SDL_BlendLine_RGB565(SDL_Surface * dst, int x1, int y1, int x2, int y2,
+                     SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
+                     SDL_bool draw_end)
+{
+    const SDL_PixelFormat *fmt = dst->format;
+    unsigned r, g, b, a, inva;
+
+    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+        r = DRAW_MUL(_r, _a);
+        g = DRAW_MUL(_g, _a);
+        b = DRAW_MUL(_b, _a);
+        a = _a;
+    } else {
+        r = _r;
+        g = _g;
+        b = _b;
+        a = _a;
+    }
+    inva = (a ^ 0xff);
+
+    if (y1 == y2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
+            break;
+        default:
+            HLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
+            break;
+        }
+    } else if (x1 == x2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
+            break;
+        default:
+            VLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
+            break;
+        }
+    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
+            break;
+        default:
+            DLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
+            break;
+        }
+    } else {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_BLEND_RGB565, DRAW_SETPIXELXY_BLEND_RGB565,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_ADD_RGB565, DRAW_SETPIXELXY_ADD_RGB565,
+                   draw_end);
+            break;
+        default:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_RGB565, DRAW_SETPIXELXY_BLEND_RGB565,
+                   draw_end);
+            break;
+        }
+    }
+}
+
+static void
+SDL_BlendLine_RGB4(SDL_Surface * dst, int x1, int y1, int x2, int y2,
+                   SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
+                   SDL_bool draw_end)
+{
+    const SDL_PixelFormat *fmt = dst->format;
+    unsigned r, g, b, a, inva;
+
+    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+        r = DRAW_MUL(_r, _a);
+        g = DRAW_MUL(_g, _a);
+        b = DRAW_MUL(_b, _a);
+        a = _a;
+    } else {
+        r = _r;
+        g = _g;
+        b = _b;
+        a = _a;
+    }
+    inva = (a ^ 0xff);
+
+    if (y1 == y2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            HLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
+            break;
+        default:
+            HLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
+            break;
+        }
+    } else if (x1 == x2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            VLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
+            break;
+        default:
+            VLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
+            break;
+        }
+    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            DLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
+            break;
+        default:
+            DLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
+            break;
+        }
+    } else {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY4_BLEND_RGB, DRAW_SETPIXELXY4_BLEND_RGB,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY4_ADD_RGB, DRAW_SETPIXELXY4_ADD_RGB,
+                   draw_end);
+            break;
+        default:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY4_RGB, DRAW_SETPIXELXY4_BLEND_RGB,
+                   draw_end);
+            break;
+        }
+    }
+}
+
+static void
+SDL_BlendLine_RGBA4(SDL_Surface * dst, int x1, int y1, int x2, int y2,
+                    SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
+                    SDL_bool draw_end)
+{
+    const SDL_PixelFormat *fmt = dst->format;
+    unsigned r, g, b, a, inva;
+
+    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+        r = DRAW_MUL(_r, _a);
+        g = DRAW_MUL(_g, _a);
+        b = DRAW_MUL(_b, _a);
+        a = _a;
+    } else {
+        r = _r;
+        g = _g;
+        b = _b;
+        a = _a;
+    }
+    inva = (a ^ 0xff);
+
+    if (y1 == y2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            HLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
+            break;
+        default:
+            HLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
+            break;
+        }
+    } else if (x1 == x2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            VLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
+            break;
+        default:
+            VLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
+            break;
+        }
+    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            DLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
+            break;
+        default:
+            DLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
+            break;
+        }
+    } else {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY4_BLEND_RGBA, DRAW_SETPIXELXY4_BLEND_RGBA,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY4_ADD_RGBA, DRAW_SETPIXELXY4_ADD_RGBA,
+                   draw_end);
+            break;
+        default:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY4_RGBA, DRAW_SETPIXELXY4_BLEND_RGBA,
+                   draw_end);
+            break;
+        }
+    }
+}
+
+static void
+SDL_BlendLine_RGB888(SDL_Surface * dst, int x1, int y1, int x2, int y2,
+                     SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
+                     SDL_bool draw_end)
+{
+    const SDL_PixelFormat *fmt = dst->format;
+    unsigned r, g, b, a, inva;
+
+    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+        r = DRAW_MUL(_r, _a);
+        g = DRAW_MUL(_g, _a);
+        b = DRAW_MUL(_b, _a);
+        a = _a;
+    } else {
+        r = _r;
+        g = _g;
+        b = _b;
+        a = _a;
+    }
+    inva = (a ^ 0xff);
+
+    if (y1 == y2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            HLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
+            break;
+        default:
+            HLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
+            break;
+        }
+    } else if (x1 == x2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            VLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
+            break;
+        default:
+            VLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
+            break;
+        }
+    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            DLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
+            break;
+        default:
+            DLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
+            break;
+        }
+    } else {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_BLEND_RGB888, DRAW_SETPIXELXY_BLEND_RGB888,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_ADD_RGB888, DRAW_SETPIXELXY_ADD_RGB888,
+                   draw_end);
+            break;
+        default:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_RGB888, DRAW_SETPIXELXY_BLEND_RGB888,
+                   draw_end);
+            break;
+        }
+    }
+}
+
+static void
+SDL_BlendLine_ARGB8888(SDL_Surface * dst, int x1, int y1, int x2, int y2,
+                       SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
+                       SDL_bool draw_end)
+{
+    const SDL_PixelFormat *fmt = dst->format;
+    unsigned r, g, b, a, inva;
+
+    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+        r = DRAW_MUL(_r, _a);
+        g = DRAW_MUL(_g, _a);
+        b = DRAW_MUL(_b, _a);
+        a = _a;
+    } else {
+        r = _r;
+        g = _g;
+        b = _b;
+        a = _a;
+    }
+    inva = (a ^ 0xff);
+
+    if (y1 == y2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            HLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            HLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
+            break;
+        default:
+            HLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
+            break;
+        }
+    } else if (x1 == x2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            VLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            VLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
+            break;
+        default:
+            VLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
+            break;
+        }
+    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            DLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            DLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
+            break;
+        default:
+            DLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
+            break;
+        }
+    } else {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_BLEND_ARGB8888, DRAW_SETPIXELXY_BLEND_ARGB8888,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_ADD_ARGB8888, DRAW_SETPIXELXY_ADD_ARGB8888,
+                   draw_end);
+            break;
+        default:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_ARGB8888, DRAW_SETPIXELXY_BLEND_ARGB8888,
+                   draw_end);
+            break;
+        }
+    }
+}
+
+typedef void (*BlendLineFunc) (SDL_Surface * dst,
+                               int x1, int y1, int x2, int y2,
+                               SDL_BlendMode blendMode,
+                               Uint8 r, Uint8 g, Uint8 b, Uint8 a,
+                               SDL_bool draw_end);
+
+static BlendLineFunc
+SDL_CalculateBlendLineFunc(const SDL_PixelFormat * fmt)
+{
+    switch (fmt->BytesPerPixel) {
+    case 2:
+        if (fmt->Rmask == 0x7C00) {
+            return SDL_BlendLine_RGB555;
+        } else if (fmt->Rmask == 0xF800) {
+            return SDL_BlendLine_RGB565;
+        } else {
+            return SDL_BlendLine_RGB2;
+        }
+        break;
+    case 4:
+        if (fmt->Rmask == 0x00FF0000) {
+            if (fmt->Amask) {
+                return SDL_BlendLine_ARGB8888;
+            } else {
+                return SDL_BlendLine_RGB888;
+            }
+        } else {
+            if (fmt->Amask) {
+                return SDL_BlendLine_RGBA4;
+            } else {
+                return SDL_BlendLine_RGB4;
+            }
+        }
+    }
+    return NULL;
+}
+
+int
+SDL_BlendLine(SDL_Surface * dst, int x1, int y1, int x2, int y2,
+              SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    BlendLineFunc func;
+
+    if (!dst) {
+        SDL_SetError("SDL_BlendLine(): Passed NULL destination surface");
+        return -1;
+    }
+
+    func = SDL_CalculateBlendLineFunc(dst->format);
+    if (!func) {
+        SDL_SetError("SDL_BlendLine(): Unsupported surface format");
+        return -1;
+    }
+
+    /* Perform clipping */
+    /* FIXME: We don't actually want to clip, as it may change line slope */
+    if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
+        return 0;
+    }
+
+    func(dst, x1, y1, x2, y2, blendMode, r, g, b, a, SDL_TRUE);
+    return 0;
+}
+
+int
+SDL_BlendLines(SDL_Surface * dst, const SDL_Point * points, int count,
+               SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    int i;
+    int x1, y1;
+    int x2, y2;
+    SDL_bool draw_end;
+    BlendLineFunc func;
+
+    if (!dst) {
+        SDL_SetError("SDL_BlendLines(): Passed NULL destination surface");
+        return -1;
+    }
+
+    func = SDL_CalculateBlendLineFunc(dst->format);
+    if (!func) {
+        SDL_SetError("SDL_BlendLines(): Unsupported surface format");
+        return -1;
+    }
+
+    for (i = 1; i < count; ++i) {
+        x1 = points[i-1].x;
+        y1 = points[i-1].y;
+        x2 = points[i].x;
+        y2 = points[i].y;
+
+        /* Perform clipping */
+        /* FIXME: We don't actually want to clip, as it may change line slope */
+        if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
+            continue;
+        }
+
+        /* Draw the end if it was clipped */
+        draw_end = (x2 != points[i].x || y2 != points[i].y);
+
+        func(dst, x1, y1, x2, y2, blendMode, r, g, b, a, draw_end);
+    }
+    if (points[0].x != points[count-1].x || points[0].y != points[count-1].y) {
+        SDL_BlendPoint(dst, points[count-1].x, points[count-1].y,
+                       blendMode, r, g, b, a);
+    }
+    return 0;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/render/software/SDL_blendline.h	Thu Feb 03 02:45:29 2011 -0800
@@ -0,0 +1,28 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+
+extern int SDL_BlendLine(SDL_Surface * dst, int x1, int y1, int x2, int y2, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+extern int SDL_BlendLines(SDL_Surface * dst, const SDL_Point * points, int count, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+
+/* vi: set ts=4 sw=4 expandtab: */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/render/software/SDL_blendpoint.c	Thu Feb 03 02:45:29 2011 -0800
@@ -0,0 +1,325 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#include "SDL_draw.h"
+#include "SDL_blendpoint.h"
+
+
+static int
+SDL_BlendPoint_RGB555(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
+                      Uint8 g, Uint8 b, Uint8 a)
+{
+    unsigned inva = 0xff - a;
+
+    switch (blendMode) {
+    case SDL_BLENDMODE_BLEND:
+        DRAW_SETPIXELXY_BLEND_RGB555(x, y);
+        break;
+    case SDL_BLENDMODE_ADD:
+        DRAW_SETPIXELXY_ADD_RGB555(x, y);
+        break;
+    default:
+        DRAW_SETPIXELXY_RGB555(x, y);
+        break;
+    }
+    return 0;
+}
+
+static int
+SDL_BlendPoint_RGB565(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
+                      Uint8 g, Uint8 b, Uint8 a)
+{
+    unsigned inva = 0xff - a;
+
+    switch (blendMode) {
+    case SDL_BLENDMODE_BLEND:
+        DRAW_SETPIXELXY_BLEND_RGB565(x, y);
+        break;
+    case SDL_BLENDMODE_ADD:
+        DRAW_SETPIXELXY_ADD_RGB565(x, y);
+        break;
+    default:
+        DRAW_SETPIXELXY_RGB565(x, y);
+        break;
+    }
+    return 0;
+}
+
+static int
+SDL_BlendPoint_RGB888(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
+                      Uint8 g, Uint8 b, Uint8 a)
+{
+    unsigned inva = 0xff - a;
+
+    switch (blendMode) {
+    case SDL_BLENDMODE_BLEND:
+        DRAW_SETPIXELXY_BLEND_RGB888(x, y);
+        break;
+    case SDL_BLENDMODE_ADD:
+        DRAW_SETPIXELXY_ADD_RGB888(x, y);
+        break;
+    default:
+        DRAW_SETPIXELXY_RGB888(x, y);
+        break;
+    }
+    return 0;
+}
+
+static int
+SDL_BlendPoint_ARGB8888(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode,
+                        Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    unsigned inva = 0xff - a;
+
+    switch (blendMode) {
+    case SDL_BLENDMODE_BLEND:
+        DRAW_SETPIXELXY_BLEND_ARGB8888(x, y);
+        break;
+    case SDL_BLENDMODE_ADD:
+        DRAW_SETPIXELXY_ADD_ARGB8888(x, y);
+        break;
+    default:
+        DRAW_SETPIXELXY_ARGB8888(x, y);
+        break;
+    }
+    return 0;
+}
+
+static int
+SDL_BlendPoint_RGB(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
+                   Uint8 g, Uint8 b, Uint8 a)
+{
+    SDL_PixelFormat *fmt = dst->format;
+    unsigned inva = 0xff - a;
+
+    switch (fmt->BytesPerPixel) {
+    case 2:
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            DRAW_SETPIXELXY2_BLEND_RGB(x, y);
+            break;
+        case SDL_BLENDMODE_ADD:
+            DRAW_SETPIXELXY2_ADD_RGB(x, y);
+            break;
+        default:
+            DRAW_SETPIXELXY2_RGB(x, y);
+            break;
+        }
+        return 0;
+    case 4:
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            DRAW_SETPIXELXY4_BLEND_RGB(x, y);
+            break;
+        case SDL_BLENDMODE_ADD:
+            DRAW_SETPIXELXY4_ADD_RGB(x, y);
+            break;
+        default:
+            DRAW_SETPIXELXY4_RGB(x, y);
+            break;
+        }
+        return 0;
+    default:
+        SDL_Unsupported();
+        return -1;
+    }
+}
+
+static int
+SDL_BlendPoint_RGBA(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
+                    Uint8 g, Uint8 b, Uint8 a)
+{
+    SDL_PixelFormat *fmt = dst->format;
+    unsigned inva = 0xff - a;
+
+    switch (fmt->BytesPerPixel) {
+    case 4:
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            DRAW_SETPIXELXY4_BLEND_RGBA(x, y);
+            break;
+        case SDL_BLENDMODE_ADD:
+            DRAW_SETPIXELXY4_ADD_RGBA(x, y);
+            break;
+        default:
+            DRAW_SETPIXELXY4_RGBA(x, y);
+            break;
+        }
+        return 0;
+    default:
+        SDL_Unsupported();
+        return -1;
+    }
+}
+
+int
+SDL_BlendPoint(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
+               Uint8 g, Uint8 b, Uint8 a)
+{
+    if (!dst) {
+        SDL_SetError("Passed NULL destination surface");
+        return -1;
+    }
+
+    /* This function doesn't work on surfaces < 8 bpp */
+    if (dst->format->BitsPerPixel < 8) {
+        SDL_SetError("SDL_BlendPoint(): Unsupported surface format");
+        return -1;
+    }
+
+    /* Perform clipping */
+    if (x < dst->clip_rect.x || y < dst->clip_rect.y ||
+        x >= (dst->clip_rect.x + dst->clip_rect.w) ||
+        y >= (dst->clip_rect.y + dst->clip_rect.h)) {
+        return 0;
+    }
+
+    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+        r = DRAW_MUL(r, a);
+        g = DRAW_MUL(g, a);
+        b = DRAW_MUL(b, a);
+    }
+
+    switch (dst->format->BitsPerPixel) {
+    case 15:
+        switch (dst->format->Rmask) {
+        case 0x7C00:
+            return SDL_BlendPoint_RGB555(dst, x, y, blendMode, r, g, b, a);
+        }
+        break;
+    case 16:
+        switch (dst->format->Rmask) {
+        case 0xF800:
+            return SDL_BlendPoint_RGB565(dst, x, y, blendMode, r, g, b, a);
+        }
+        break;
+    case 32:
+        switch (dst->format->Rmask) {
+        case 0x00FF0000:
+            if (!dst->format->Amask) {
+                return SDL_BlendPoint_RGB888(dst, x, y, blendMode, r, g, b,
+                                             a);
+            } else {
+                return SDL_BlendPoint_ARGB8888(dst, x, y, blendMode, r, g, b,
+                                               a);
+            }
+            break;
+        }
+        break;
+    default:
+        break;
+    }
+
+    if (!dst->format->Amask) {
+        return SDL_BlendPoint_RGB(dst, x, y, blendMode, r, g, b, a);
+    } else {
+        return SDL_BlendPoint_RGBA(dst, x, y, blendMode, r, g, b, a);
+    }
+}
+
+int
+SDL_BlendPoints(SDL_Surface * dst, const SDL_Point * points, int count,
+                SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    int minx, miny;
+    int maxx, maxy;
+    int i;
+    int x, y;
+    int (*func)(SDL_Surface * dst, int x, int y,
+                SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a) = NULL;
+    int status = 0;
+
+    if (!dst) {
+        SDL_SetError("Passed NULL destination surface");
+        return -1;
+    }
+
+    /* This function doesn't work on surfaces < 8 bpp */
+    if (dst->format->BitsPerPixel < 8) {
+        SDL_SetError("SDL_BlendPoints(): Unsupported surface format");
+        return (-1);
+    }
+
+    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+        r = DRAW_MUL(r, a);
+        g = DRAW_MUL(g, a);
+        b = DRAW_MUL(b, a);
+    }
+
+    /* FIXME: Does this function pointer slow things down significantly? */
+    switch (dst->format->BitsPerPixel) {
+    case 15:
+        switch (dst->format->Rmask) {
+        case 0x7C00:
+            func = SDL_BlendPoint_RGB555;
+            break;
+        }
+        break;
+    case 16:
+        switch (dst->format->Rmask) {
+        case 0xF800:
+            func = SDL_BlendPoint_RGB565;
+            break;
+        }
+        break;
+    case 32:
+        switch (dst->format->Rmask) {
+        case 0x00FF0000:
+            if (!dst->format->Amask) {
+                func = SDL_BlendPoint_RGB888;
+            } else {
+                func = SDL_BlendPoint_ARGB8888;
+            }
+            break;
+        }
+        break;
+    default:
+        break;
+    }
+
+    if (!func) {
+        if (!dst->format->Amask) {
+            func = SDL_BlendPoint_RGB;
+        } else {
+            func = SDL_BlendPoint_RGBA;
+        }
+    }
+
+    minx = dst->clip_rect.x;
+    maxx = dst->clip_rect.x + dst->clip_rect.w - 1;
+    miny = dst->clip_rect.y;
+    maxy = dst->clip_rect.y + dst->clip_rect.h - 1;
+
+    for (i = 0; i < count; ++i) {
+        x = points[i].x;
+        y = points[i].y;
+
+        if (x < minx || x > maxx || y < miny || y > maxy) {
+            continue;
+        }
+        status = func(dst, x, y, blendMode, r, g, b, a);
+    }
+    return status;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/render/software/SDL_blendpoint.h	Thu Feb 03 02:45:29 2011 -0800
@@ -0,0 +1,28 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+
+extern int SDL_BlendPoint(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+extern int SDL_BlendPoints(SDL_Surface * dst, const SDL_Point * points, int count, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+
+/* vi: set ts=4 sw=4 expandtab: */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/render/software/SDL_draw.h	Thu Feb 03 02:45:29 2011 -0800
@@ -0,0 +1,521 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#include "../../video/SDL_blit.h"
+
+/* This code assumes that r, g, b, a are the source color,
+ * and in the blend and add case, the RGB values are premultiplied by a.
+ */
+
+#define DRAW_MUL(_a, _b) (((unsigned)(_a)*(_b))/255)
+
+#define DRAW_FASTSETPIXEL(type) \
+    *pixel = (type) color
+
+#define DRAW_FASTSETPIXEL1 DRAW_FASTSETPIXEL(Uint8)
+#define DRAW_FASTSETPIXEL2 DRAW_FASTSETPIXEL(Uint16)
+#define DRAW_FASTSETPIXEL4 DRAW_FASTSETPIXEL(Uint32)
+
+#define DRAW_FASTSETPIXELXY(x, y, type, bpp, color) \
+    *(type *)((Uint8 *)dst->pixels + (y) * dst->pitch \
+                                   + (x) * bpp) = (type) color
+
+#define DRAW_FASTSETPIXELXY1(x, y) DRAW_FASTSETPIXELXY(x, y, Uint8, 1, color)
+#define DRAW_FASTSETPIXELXY2(x, y) DRAW_FASTSETPIXELXY(x, y, Uint16, 2, color)
+#define DRAW_FASTSETPIXELXY4(x, y) DRAW_FASTSETPIXELXY(x, y, Uint32, 4, color)
+
+#define DRAW_SETPIXEL(setpixel) \
+do { \
+    unsigned sr = r, sg = g, sb = b, sa = a; \
+    setpixel; \
+} while (0)
+
+#define DRAW_SETPIXEL_BLEND(getpixel, setpixel) \
+do { \
+    unsigned sr, sg, sb, sa; sa; \
+    getpixel; \
+    sr = DRAW_MUL(inva, sr) + r; \
+    sg = DRAW_MUL(inva, sg) + g; \
+    sb = DRAW_MUL(inva, sb) + b; \
+    setpixel; \
+} while (0)
+
+#define DRAW_SETPIXEL_ADD(getpixel, setpixel) \
+do { \
+    unsigned sr, sg, sb, sa; sa; \
+    getpixel; \
+    sr += r; if (sr > 0xff) sr = 0xff; \
+    sg += g; if (sg > 0xff) sg = 0xff; \
+    sb += b; if (sb > 0xff) sb = 0xff; \
+    setpixel; \
+} while (0)
+
+#define DRAW_SETPIXELXY(x, y, type, bpp, op) \
+do { \
+    type *pixel = (type *)((Uint8 *)dst->pixels + (y) * dst->pitch \
+                                                + (x) * bpp); \
+    op; \
+} while (0)
+
+/*
+ * Define draw operators for RGB555
+ */
+
+#define DRAW_SETPIXEL_RGB555 \
+    DRAW_SETPIXEL(RGB555_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_BLEND_RGB555 \
+    DRAW_SETPIXEL_BLEND(RGB_FROM_RGB555(*pixel, sr, sg, sb), \
+                        RGB555_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_ADD_RGB555 \
+    DRAW_SETPIXEL_ADD(RGB_FROM_RGB555(*pixel, sr, sg, sb), \
+                      RGB555_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXELXY_RGB555(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_RGB555)
+
+#define DRAW_SETPIXELXY_BLEND_RGB555(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_BLEND_RGB555)
+
+#define DRAW_SETPIXELXY_ADD_RGB555(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_ADD_RGB555)
+
+/*
+ * Define draw operators for RGB565
+ */
+
+#define DRAW_SETPIXEL_RGB565 \
+    DRAW_SETPIXEL(RGB565_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_BLEND_RGB565 \
+    DRAW_SETPIXEL_BLEND(RGB_FROM_RGB565(*pixel, sr, sg, sb), \
+                        RGB565_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_ADD_RGB565 \
+    DRAW_SETPIXEL_ADD(RGB_FROM_RGB565(*pixel, sr, sg, sb), \
+                      RGB565_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXELXY_RGB565(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_RGB565)
+
+#define DRAW_SETPIXELXY_BLEND_RGB565(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_BLEND_RGB565)
+
+#define DRAW_SETPIXELXY_ADD_RGB565(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_ADD_RGB565)
+
+/*
+ * Define draw operators for RGB888
+ */
+
+#define DRAW_SETPIXEL_RGB888 \
+    DRAW_SETPIXEL(RGB888_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_BLEND_RGB888 \
+    DRAW_SETPIXEL_BLEND(RGB_FROM_RGB888(*pixel, sr, sg, sb), \
+                        RGB888_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_ADD_RGB888 \
+    DRAW_SETPIXEL_ADD(RGB_FROM_RGB888(*pixel, sr, sg, sb), \
+                      RGB888_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXELXY_RGB888(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_RGB888)
+
+#define DRAW_SETPIXELXY_BLEND_RGB888(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_RGB888)
+
+#define DRAW_SETPIXELXY_ADD_RGB888(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_RGB888)
+
+/*
+ * Define draw operators for ARGB8888
+ */
+
+#define DRAW_SETPIXEL_ARGB8888 \
+    DRAW_SETPIXEL(ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))
+
+#define DRAW_SETPIXEL_BLEND_ARGB8888 \
+    DRAW_SETPIXEL_BLEND(RGBA_FROM_ARGB8888(*pixel, sr, sg, sb, sa), \
+                        ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))
+
+#define DRAW_SETPIXEL_ADD_ARGB8888 \
+    DRAW_SETPIXEL_ADD(RGBA_FROM_ARGB8888(*pixel, sr, sg, sb, sa), \
+                      ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))
+
+#define DRAW_SETPIXELXY_ARGB8888(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ARGB8888)
+
+#define DRAW_SETPIXELXY_BLEND_ARGB8888(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_ARGB8888)
+
+#define DRAW_SETPIXELXY_ADD_ARGB8888(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_ARGB8888)
+
+/*
+ * Define draw operators for general RGB
+ */
+
+#define DRAW_SETPIXEL_RGB \
+    DRAW_SETPIXEL(PIXEL_FROM_RGB(*pixel, fmt, sr, sg, sb))
+
+#define DRAW_SETPIXEL_BLEND_RGB \
+    DRAW_SETPIXEL_BLEND(RGB_FROM_PIXEL(*pixel, fmt, sr, sg, sb), \
+                        PIXEL_FROM_RGB(*pixel, fmt, sr, sg, sb))
+
+#define DRAW_SETPIXEL_ADD_RGB \
+    DRAW_SETPIXEL_ADD(RGB_FROM_PIXEL(*pixel, fmt, sr, sg, sb), \
+                      PIXEL_FROM_RGB(*pixel, fmt, sr, sg, sb))
+
+#define DRAW_SETPIXELXY2_RGB(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_RGB)
+
+#define DRAW_SETPIXELXY4_RGB(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_RGB)
+
+#define DRAW_SETPIXELXY2_BLEND_RGB(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_BLEND_RGB)
+
+#define DRAW_SETPIXELXY4_BLEND_RGB(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_RGB)
+
+#define DRAW_SETPIXELXY2_ADD_RGB(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_ADD_RGB)
+
+#define DRAW_SETPIXELXY4_ADD_RGB(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_RGB)
+
+
+/*
+ * Define draw operators for general RGBA
+ */
+
+#define DRAW_SETPIXEL_RGBA \
+    DRAW_SETPIXEL(PIXEL_FROM_RGBA(*pixel, fmt, sr, sg, sb, sa))
+
+#define DRAW_SETPIXEL_BLEND_RGBA \
+    DRAW_SETPIXEL_BLEND(RGBA_FROM_PIXEL(*pixel, fmt, sr, sg, sb, sa), \
+                        PIXEL_FROM_RGBA(*pixel, fmt, sr, sg, sb, sa))
+
+#define DRAW_SETPIXEL_ADD_RGBA \
+    DRAW_SETPIXEL_ADD(RGBA_FROM_PIXEL(*pixel, fmt, sr, sg, sb, sa), \
+                      PIXEL_FROM_RGBA(*pixel, fmt, sr, sg, sb, sa))
+
+#define DRAW_SETPIXELXY4_RGBA(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_RGBA)
+
+#define DRAW_SETPIXELXY4_BLEND_RGBA(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_RGBA)
+
+#define DRAW_SETPIXELXY4_ADD_RGBA(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_RGBA)
+
+/*
+ * Define line drawing macro
+ */
+
+#define ABS(_x) ((_x) < 0 ? -(_x) : (_x))
+
+/* Horizontal line */
+#define HLINE(type, op, draw_end) \
+{ \
+    int length; \
+    int pitch = (dst->pitch / dst->format->BytesPerPixel); \
+    type *pixel; \
+    if (x1 <= x2) { \
+        pixel = (type *)dst->pixels + y1 * pitch + x1; \
+        length = draw_end ? (x2-x1+1) : (x2-x1); \
+    } else { \
+        pixel = (type *)dst->pixels + y1 * pitch + x2; \
+        if (!draw_end) { \
+            ++pixel; \
+        } \
+        length = draw_end ? (x1-x2+1) : (x1-x2); \
+    } \
+    while (length--) { \
+        op; \
+        ++pixel; \
+    } \
+}
+
+/* Vertical line */
+#define VLINE(type, op, draw_end) \
+{ \
+    int length; \
+    int pitch = (dst->pitch / dst->format->BytesPerPixel); \
+    type *pixel; \
+    if (y1 <= y2) { \
+        pixel = (type *)dst->pixels + y1 * pitch + x1; \
+        length = draw_end ? (y2-y1+1) : (y2-y1); \
+    } else { \
+        pixel = (type *)dst->pixels + y2 * pitch + x1; \
+        if (!draw_end) { \
+            pixel += pitch; \
+        } \
+        length = draw_end ? (y1-y2+1) : (y1-y2); \
+    } \
+    while (length--) { \
+        op; \
+        pixel += pitch; \
+    } \
+}
+
+/* Diagonal line */
+#define DLINE(type, op, draw_end) \
+{ \
+    int length; \
+    int pitch = (dst->pitch / dst->format->BytesPerPixel); \
+    type *pixel; \
+    if (y1 <= y2) { \
+        pixel = (type *)dst->pixels + y1 * pitch + x1; \
+        if (x1 <= x2) { \
+            ++pitch; \
+        } else { \
+            --pitch; \
+        } \
+        length = (y2-y1); \
+    } else { \
+        pixel = (type *)dst->pixels + y2 * pitch + x2; \
+        if (x2 <= x1) { \
+            ++pitch; \
+        } else { \
+            --pitch; \
+        } \
+        if (!draw_end) { \
+            pixel += pitch; \
+        } \
+        length = (y1-y2); \
+    } \
+    if (draw_end) { \
+        ++length; \
+    } \
+    while (length--) { \
+        op; \
+        pixel += pitch; \
+    } \
+}
+
+/* Bresenham's line algorithm */
+#define BLINE(x1, y1, x2, y2, op, draw_end) \
+{ \
+    int i, deltax, deltay, numpixels; \
+    int d, dinc1, dinc2; \
+    int x, xinc1, xinc2; \
+    int y, yinc1, yinc2; \
+ \
+    deltax = ABS(x2 - x1); \
+    deltay = ABS(y2 - y1); \
+ \
+    if (deltax >= deltay) { \
+        numpixels = deltax + 1; \
+        d = (2 * deltay) - deltax; \
+        dinc1 = deltay * 2; \
+        dinc2 = (deltay - deltax) * 2; \
+        xinc1 = 1; \
+        xinc2 = 1; \
+        yinc1 = 0; \
+        yinc2 = 1; \
+    } else { \
+        numpixels = deltay + 1; \
+        d = (2 * deltax) - deltay; \
+        dinc1 = deltax * 2; \
+        dinc2 = (deltax - deltay) * 2; \
+        xinc1 = 0; \
+        xinc2 = 1; \
+        yinc1 = 1; \
+        yinc2 = 1; \
+    } \
+ \
+    if (x1 > x2) { \
+        xinc1 = -xinc1; \
+        xinc2 = -xinc2; \
+    } \
+    if (y1 > y2) { \
+        yinc1 = -yinc1; \
+        yinc2 = -yinc2; \
+    } \
+ \
+    x = x1; \
+    y = y1; \
+ \
+    if (!draw_end) { \
+        --numpixels; \
+    } \
+    for (i = 0; i < numpixels; ++i) { \
+        op(x, y); \
+        if (d < 0) { \
+            d += dinc1; \
+            x += xinc1; \
+            y += yinc1; \
+        } else { \
+            d += dinc2; \
+            x += xinc2; \
+            y += yinc2; \
+        } \
+    } \
+}
+
+/* Xiaolin Wu's line algorithm, based on Michael Abrash's implementation */
+#define WULINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end) \
+{ \
+    Uint16 ErrorAdj, ErrorAcc; \
+    Uint16 ErrorAccTemp, Weighting; \
+    int DeltaX, DeltaY, Temp, XDir; \
+    unsigned r, g, b, a, inva; \
+ \
+    /* Draw the initial pixel, which is always exactly intersected by \
+       the line and so needs no weighting */ \
+    opaque_op(x1, y1); \
+ \
+    /* Draw the final pixel, which is always exactly intersected by the line \
+       and so needs no weighting */ \
+    if (draw_end) { \
+        opaque_op(x2, y2); \
+    } \
+ \
+    /* Make sure the line runs top to bottom */ \
+    if (y1 > y2) { \
+        Temp = y1; y1 = y2; y2 = Temp; \
+        Temp = x1; x1 = x2; x2 = Temp; \
+    } \
+    DeltaY = y2 - y1; \
+ \
+    if ((DeltaX = x2 - x1) >= 0) { \
+        XDir = 1; \
+    } else { \
+        XDir = -1; \
+        DeltaX = -DeltaX; /* make DeltaX positive */ \
+    } \
+ \
+    /* line is not horizontal, diagonal, or vertical */ \
+    ErrorAcc = 0;  /* initialize the line error accumulator to 0 */ \
+ \
+    /* Is this an X-major or Y-major line? */ \
+    if (DeltaY > DeltaX) { \
+        /* Y-major line; calculate 16-bit fixed-point fractional part of a \
+          pixel that X advances each time Y advances 1 pixel, truncating the \
+          result so that we won't overrun the endpoint along the X axis */ \
+        ErrorAdj = ((unsigned long) DeltaX << 16) / (unsigned long) DeltaY; \
+        /* Draw all pixels other than the first and last */ \
+        while (--DeltaY) { \
+            ErrorAccTemp = ErrorAcc;   /* remember currrent accumulated error */ \
+            ErrorAcc += ErrorAdj;      /* calculate error for next pixel */ \
+            if (ErrorAcc <= ErrorAccTemp) { \
+                /* The error accumulator turned over, so advance the X coord */ \
+                x1 += XDir; \
+            } \
+            y1++; /* Y-major, so always advance Y */ \
+            /* The IntensityBits most significant bits of ErrorAcc give us the \
+             intensity weighting for this pixel, and the complement of the \
+             weighting for the paired pixel */ \
+            Weighting = ErrorAcc >> 8; \
+            { \
+                a = DRAW_MUL(_a, (Weighting ^ 255)); \
+                r = DRAW_MUL(_r, a); \
+                g = DRAW_MUL(_g, a); \
+                b = DRAW_MUL(_b, a); \
+                inva = (a ^ 0xFF); \
+                blend_op(x1, y1); \
+            } \
+            { \
+                a = DRAW_MUL(_a, Weighting); \
+                r = DRAW_MUL(_r, a); \
+                g = DRAW_MUL(_g, a); \
+                b = DRAW_MUL(_b, a); \
+                inva = (a ^ 0xFF); \
+                blend_op(x1 + XDir, y1); \
+            } \
+        } \
+    } else { \
+        /* X-major line; calculate 16-bit fixed-point fractional part of a \
+           pixel that Y advances each time X advances 1 pixel, truncating the \
+           result to avoid overrunning the endpoint along the X axis */ \
+        ErrorAdj = ((unsigned long) DeltaY << 16) / (unsigned long) DeltaX; \
+        /* Draw all pixels other than the first and last */ \
+        while (--DeltaX) { \
+            ErrorAccTemp = ErrorAcc;   /* remember currrent accumulated error */ \
+            ErrorAcc += ErrorAdj;      /* calculate error for next pixel */ \
+            if (ErrorAcc <= ErrorAccTemp) { \
+                /* The error accumulator turned over, so advance the Y coord */ \
+                y1++; \
+            } \
+            x1 += XDir; /* X-major, so always advance X */ \
+            /* The IntensityBits most significant bits of ErrorAcc give us the \
+              intensity weighting for this pixel, and the complement of the \
+              weighting for the paired pixel */ \
+            Weighting = ErrorAcc >> 8; \
+            { \
+                a = DRAW_MUL(_a, (Weighting ^ 255)); \
+                r = DRAW_MUL(_r, a); \
+                g = DRAW_MUL(_g, a); \
+                b = DRAW_MUL(_b, a); \
+                inva = (a ^ 0xFF); \
+                blend_op(x1, y1); \
+            } \
+            { \
+                a = DRAW_MUL(_a, Weighting); \
+                r = DRAW_MUL(_r, a); \
+                g = DRAW_MUL(_g, a); \
+                b = DRAW_MUL(_b, a); \
+                inva = (a ^ 0xFF); \
+                blend_op(x1, y1 + 1); \
+            } \
+        } \
+    } \
+}
+
+#ifdef AA_LINES
+#define AALINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end) \
+            WULINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end)
+#else
+#define AALINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end) \
+            BLINE(x1, y1, x2, y2, opaque_op, draw_end)
+#endif
+
+/*
+ * Define fill rect macro
+ */
+
+#define FILLRECT(type, op) \
+do { \
+    int width = rect->w; \
+    int height = rect->h; \
+    int pitch = (dst->pitch / dst->format->BytesPerPixel); \
+    int skip = pitch - width; \
+    type *pixel = (type *)dst->pixels + rect->y * pitch + rect->x; \
+    while (height--) { \
+        { int n = (width+3)/4; \
+            switch (width & 3) { \
+            case 0: do {   op; pixel++; \
+            case 3:        op; pixel++; \
+            case 2:        op; pixel++; \
+            case 1:        op; pixel++; \
+                    } while ( --n > 0 ); \
+            } \
+        } \
+        pixel += skip; \
+    } \
+} while (0)
+
+/* vi: set ts=4 sw=4 expandtab: */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/render/software/SDL_drawline.c	Thu Feb 03 02:45:29 2011 -0800
@@ -0,0 +1,210 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#include "SDL_draw.h"
+#include "SDL_drawline.h"
+
+
+static void
+SDL_DrawLine1(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color,
+              SDL_bool draw_end)
+{
+    if (y1 == y2) {
+        //HLINE(Uint8, DRAW_FASTSETPIXEL1, draw_end);
+        int length;
+        int pitch = (dst->pitch / dst->format->BytesPerPixel);
+        Uint8 *pixel;
+        if (x1 <= x2) {
+            pixel = (Uint8 *)dst->pixels + y1 * pitch + x1;
+            length = draw_end ? (x2-x1+1) : (x2-x1);
+        } else {
+            pixel = (Uint8 *)dst->pixels + y1 * pitch + x2;
+            if (!draw_end) {
+                ++pixel;
+            }
+            length = draw_end ? (x1-x2+1) : (x1-x2);
+        }
+        SDL_memset(pixel, color, length);
+    } else if (x1 == x2) {
+        VLINE(Uint8, DRAW_FASTSETPIXEL1, draw_end);
+    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+        DLINE(Uint8, DRAW_FASTSETPIXEL1, draw_end);
+    } else {
+        BLINE(x1, y1, x2, y2, DRAW_FASTSETPIXELXY1, draw_end);
+    }
+}
+
+static void
+SDL_DrawLine2(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color,
+              SDL_bool draw_end)
+{
+    if (y1 == y2) {
+        HLINE(Uint16, DRAW_FASTSETPIXEL2, draw_end);
+    } else if (x1 == x2) {
+        VLINE(Uint16, DRAW_FASTSETPIXEL2, draw_end);
+    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+        DLINE(Uint16, DRAW_FASTSETPIXEL2, draw_end);
+    } else {
+        Uint8 _r, _g, _b, _a;
+        const SDL_PixelFormat * fmt = dst->format;
+        SDL_GetRGBA(color, fmt, &_r, &_g, &_b, &_a);
+        if (fmt->Rmask == 0x7C00) {
+            AALINE(x1, y1, x2, y2,
+                   DRAW_FASTSETPIXELXY2, DRAW_SETPIXELXY_BLEND_RGB555,
+                   draw_end);
+        } else if (fmt->Rmask == 0xF800) {
+            AALINE(x1, y1, x2, y2,
+                   DRAW_FASTSETPIXELXY2, DRAW_SETPIXELXY_BLEND_RGB565,
+                   draw_end);
+        } else {
+            AALINE(x1, y1, x2, y2,
+                   DRAW_FASTSETPIXELXY2, DRAW_SETPIXELXY2_BLEND_RGB,
+                   draw_end);
+        }
+    }
+}
+
+static void
+SDL_DrawLine4(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color,
+              SDL_bool draw_end)
+{
+    if (y1 == y2) {
+        HLINE(Uint32, DRAW_FASTSETPIXEL4, draw_end);
+    } else if (x1 == x2) {
+        VLINE(Uint32, DRAW_FASTSETPIXEL4, draw_end);
+    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+        DLINE(Uint32, DRAW_FASTSETPIXEL4, draw_end);
+    } else {
+        Uint8 _r, _g, _b, _a;
+        const SDL_PixelFormat * fmt = dst->format;
+        SDL_GetRGBA(color, fmt, &_r, &_g, &_b, &_a);
+        if (fmt->Rmask == 0x00FF0000) {
+            if (!fmt->Amask) {
+                AALINE(x1, y1, x2, y2,
+                       DRAW_FASTSETPIXELXY4, DRAW_SETPIXELXY_BLEND_RGB888,
+                       draw_end);
+            } else {
+                AALINE(x1, y1, x2, y2,
+                       DRAW_FASTSETPIXELXY4, DRAW_SETPIXELXY_BLEND_ARGB8888,
+                       draw_end);
+            }
+        } else {
+            AALINE(x1, y1, x2, y2,
+                   DRAW_FASTSETPIXELXY4, DRAW_SETPIXELXY4_BLEND_RGB,
+                   draw_end);
+        }
+    }
+}
+
+typedef void (*DrawLineFunc) (SDL_Surface * dst,
+                              int x1, int y1, int x2, int y2,
+                              Uint32 color, SDL_bool draw_end);
+
+static DrawLineFunc
+SDL_CalculateDrawLineFunc(const SDL_PixelFormat * fmt)
+{
+    switch (fmt->BytesPerPixel) {
+    case 1:
+        if (fmt->BitsPerPixel < 8) {
+            break;
+        }
+        return SDL_DrawLine1;
+    case 2:
+        return SDL_DrawLine2;
+    case 4:
+        return SDL_DrawLine4;
+    }
+    return NULL;
+}
+
+int
+SDL_DrawLine(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color)
+{
+    DrawLineFunc func;
+
+    if (!dst) {
+        SDL_SetError("SDL_DrawLine(): Passed NULL destination surface");
+        return -1;
+    }
+
+    func = SDL_CalculateDrawLineFunc(dst->format);
+    if (!func) {
+        SDL_SetError("SDL_DrawLine(): Unsupported surface format");
+        return -1;
+    }
+
+    /* Perform clipping */
+    /* FIXME: We don't actually want to clip, as it may change line slope */
+    if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
+        return 0;
+    }
+
+    func(dst, x1, y1, x2, y2, color, SDL_TRUE);
+    return 0;
+}
+
+int
+SDL_DrawLines(SDL_Surface * dst, const SDL_Point * points, int count,
+              Uint32 color)
+{
+    int i;
+    int x1, y1;
+    int x2, y2;
+    SDL_bool draw_end;
+    DrawLineFunc func;
+
+    if (!dst) {
+        SDL_SetError("SDL_DrawLines(): Passed NULL destination surface");
+        return -1;
+    }
+
+    func = SDL_CalculateDrawLineFunc(dst->format);
+    if (!func) {
+        SDL_SetError("SDL_DrawLines(): Unsupported surface format");
+        return -1;
+    }
+
+    for (i = 1; i < count; ++i) {
+        x1 = points[i-1].x;
+        y1 = points[i-1].y;
+        x2 = points[i].x;
+        y2 = points[i].y;
+
+        /* Perform clipping */
+        /* FIXME: We don't actually want to clip, as it may change line slope */
+        if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
+            continue;
+        }
+
+        /* Draw the end if it was clipped */
+        draw_end = (x2 != points[i].x || y2 != points[i].y);
+
+        func(dst, x1, y1, x2, y2, color, draw_end);
+    }
+    if (points[0].x != points[count-1].x || points[0].y != points[count-1].y) {
+        SDL_DrawPoint(dst, points[count-1].x, points[count-1].y, color);
+    }
+    return 0;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/render/software/SDL_drawline.h	Thu Feb 03 02:45:29 2011 -0800
@@ -0,0 +1,28 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+
+extern int SDL_DrawLine(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color);
+extern int SDL_DrawLines(SDL_Surface * dst, const SDL_Point * points, int count, Uint32 color);
+
+/* vi: set ts=4 sw=4 expandtab: */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/render/software/SDL_drawpoint.c	Thu Feb 03 02:45:29 2011 -0800
@@ -0,0 +1,117 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#include "SDL_draw.h"
+#include "SDL_drawpoint.h"
+
+
+int
+SDL_DrawPoint(SDL_Surface * dst, int x, int y, Uint32 color)
+{
+    if (!dst) {
+        SDL_SetError("Passed NULL destination surface");
+        return -1;
+    }
+
+    /* This function doesn't work on surfaces < 8 bpp */
+    if (dst->format->BitsPerPixel < 8) {
+        SDL_SetError("SDL_DrawPoint(): Unsupported surface format");
+        return -1;
+    }
+
+    /* Perform clipping */
+    if (x < dst->clip_rect.x || y < dst->clip_rect.y ||
+        x >= (dst->clip_rect.x + dst->clip_rect.w) ||
+        y >= (dst->clip_rect.y + dst->clip_rect.h)) {
+        return 0;
+    }
+
+    switch (dst->format->BytesPerPixel) {
+    case 1:
+        DRAW_FASTSETPIXELXY1(x, y);
+        break;
+    case 2:
+        DRAW_FASTSETPIXELXY2(x, y);
+        break;
+    case 3:
+        SDL_Unsupported();
+        return -1;
+    case 4:
+        DRAW_FASTSETPIXELXY4(x, y);
+        break;
+    }
+    return 0;
+}
+
+int
+SDL_DrawPoints(SDL_Surface * dst, const SDL_Point * points, int count,
+               Uint32 color)
+{
+    int minx, miny;
+    int maxx, maxy;
+    int i;
+    int x, y;
+
+    if (!dst) {
+        SDL_SetError("Passed NULL destination surface");
+        return -1;
+    }
+
+    /* This function doesn't work on surfaces < 8 bpp */
+    if (dst->format->BitsPerPixel < 8) {
+        SDL_SetError("SDL_DrawPoints(): Unsupported surface format");
+        return -1;
+    }
+
+    minx = dst->clip_rect.x;
+    maxx = dst->clip_rect.x + dst->clip_rect.w - 1;
+    miny = dst->clip_rect.y;
+    maxy = dst->clip_rect.y + dst->clip_rect.h - 1;
+
+    for (i = 0; i < count; ++i) {
+        x = points[i].x;
+        y = points[i].y;
+
+        if (x < minx || x > maxx || y < miny || y > maxy) {
+            continue;
+        }
+
+        switch (dst->format->BytesPerPixel) {
+        case 1:
+            DRAW_FASTSETPIXELXY1(x, y);
+            break;
+        case 2:
+            DRAW_FASTSETPIXELXY2(x, y);
+            break;
+        case 3:
+            SDL_Unsupported();
+            return -1;
+        case 4:
+            DRAW_FASTSETPIXELXY4(x, y);
+            break;
+        }
+    }
+    return 0;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/render/software/SDL_drawpoint.h	Thu Feb 03 02:45:29 2011 -0800
@@ -0,0 +1,28 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+
+extern int SDL_DrawPoint(SDL_Surface * dst, int x, int y, Uint32 color);
+extern int SDL_DrawPoints(SDL_Surface * dst, const SDL_Point * points, int count, Uint32 color);
+
+/* vi: set ts=4 sw=4 expandtab: */
--- a/src/render/software/SDL_renderer_sw.c	Thu Feb 03 02:42:50 2011 -0800
+++ b/src/render/software/SDL_renderer_sw.c	Thu Feb 03 02:45:29 2011 -0800
@@ -24,6 +24,13 @@
 #include "../SDL_sysrender.h"
 #include "../../video/SDL_pixels_c.h"
 
+#include "SDL_draw.h"
+#include "SDL_blendfillrect.h"
+#include "SDL_blendline.h"
+#include "SDL_blendpoint.h"
+#include "SDL_drawline.h"
+#include "SDL_drawpoint.h"
+
 
 /* SDL surface based renderer implementation */
 
--- a/src/video/SDL_alphamult.c	Thu Feb 03 02:42:50 2011 -0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,60 +0,0 @@
-/*
-    SDL - Simple DirectMedia Layer
-    Copyright (C) 1997-2010 Sam Lantinga
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-    Sam Lantinga
-    slouken@libsdl.org
-*/
-#include "SDL_config.h"
-
-#include "SDL_blit.h"
-#include "SDL_alphamult.h"
-
-/* Functions to pre-multiply the alpha channel into the color channels */
-
-#define DEFINE_PREMULTIPLY_FUNC(fmt) \
-void \
-SDL_PreMultiplyAlpha##fmt(int w, int h, Uint32 *pixels, int pitch) \
-{ \
-    pitch /= 4; \
-    while (h--) { \
-        int n; \
-        Uint32 *row = pixels; \
-        Uint32 pixel; \
-        unsigned r, g, b, a; \
- \
-        for (n = w; n--; ) { \
-            pixel = *row; \
-            RGBA_FROM_##fmt(pixel, r, g, b, a); \
-            r = (r * a) / 255; \
-            g = (g * a) / 255; \
-            b = (b * a) / 255; \
-            fmt##_FROM_RGBA(*row, r, g, b, a); \
-            ++row; \
-        } \
-        pixels += pitch; \
-    } \
-}
-
-/* *INDENT-OFF* */
-DEFINE_PREMULTIPLY_FUNC(ARGB8888)
-DEFINE_PREMULTIPLY_FUNC(RGBA8888)
-DEFINE_PREMULTIPLY_FUNC(ABGR8888)
-DEFINE_PREMULTIPLY_FUNC(BGRA8888)
-/* *INDENT-ON* */
-
-/* vi: set ts=4 sw=4 expandtab: */
--- a/src/video/SDL_alphamult.h	Thu Feb 03 02:42:50 2011 -0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,38 +0,0 @@
-/*
-    SDL - Simple DirectMedia Layer
-    Copyright (C) 1997-2010 Sam Lantinga
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-    Sam Lantinga
-    slouken@libsdl.org
-*/
-
-/* Functions to pre-multiply the alpha channel into the color channels */
-
-#define DEFINE_PREMULTIPLY_FUNC(fmt) \
-void \
-SDL_PreMultiplyAlpha##fmt(int w, int h, Uint32 *pixels, int pitch);
-
-/* *INDENT-OFF* */
-DEFINE_PREMULTIPLY_FUNC(ARGB8888)
-DEFINE_PREMULTIPLY_FUNC(RGBA8888)
-DEFINE_PREMULTIPLY_FUNC(ABGR8888)
-DEFINE_PREMULTIPLY_FUNC(BGRA8888)
-/* *INDENT-ON* */
-
-#undef DEFINE_PREMULTIPLY_FUNC
-
-/* vi: set ts=4 sw=4 expandtab: */
--- a/src/video/SDL_blendfillrect.c	Thu Feb 03 02:42:50 2011 -0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,326 +0,0 @@
-/*
-    SDL - Simple DirectMedia Layer
-    Copyright (C) 1997-2010 Sam Lantinga
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-    Sam Lantinga
-    slouken@libsdl.org
-*/
-#include "SDL_config.h"
-
-#include "SDL_video.h"
-#include "SDL_draw.h"
-
-static int
-SDL_BlendFillRect_RGB555(SDL_Surface * dst, const SDL_Rect * rect,
-                         SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
-    unsigned inva = 0xff - a;
-
-    switch (blendMode) {
-    case SDL_BLENDMODE_BLEND:
-        FILLRECT(Uint16, DRAW_SETPIXEL_BLEND_RGB555);
-        break;
-    case SDL_BLENDMODE_ADD:
-        FILLRECT(Uint16, DRAW_SETPIXEL_ADD_RGB555);
-        break;
-    default:
-        FILLRECT(Uint16, DRAW_SETPIXEL_RGB555);
-        break;
-    }
-    return 0;
-}
-
-static int
-SDL_BlendFillRect_RGB565(SDL_Surface * dst, const SDL_Rect * rect,
-                         SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
-    unsigned inva = 0xff - a;
-
-    switch (blendMode) {
-    case SDL_BLENDMODE_BLEND:
-        FILLRECT(Uint16, DRAW_SETPIXEL_BLEND_RGB565);
-        break;
-    case SDL_BLENDMODE_ADD:
-        FILLRECT(Uint16, DRAW_SETPIXEL_ADD_RGB565);
-        break;
-    default:
-        FILLRECT(Uint16, DRAW_SETPIXEL_RGB565);
-        break;
-    }
-    return 0;
-}
-
-static int
-SDL_BlendFillRect_RGB888(SDL_Surface * dst, const SDL_Rect * rect,
-                         SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
-    unsigned inva = 0xff - a;
-
-    switch (blendMode) {
-    case SDL_BLENDMODE_BLEND:
-        FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_RGB888);
-        break;
-    case SDL_BLENDMODE_ADD:
-        FILLRECT(Uint32, DRAW_SETPIXEL_ADD_RGB888);
-        break;
-    default:
-        FILLRECT(Uint32, DRAW_SETPIXEL_RGB888);
-        break;
-    }
-    return 0;
-}
-
-static int
-SDL_BlendFillRect_ARGB8888(SDL_Surface * dst, const SDL_Rect * rect,
-                           SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
-    unsigned inva = 0xff - a;
-
-    switch (blendMode) {
-    case SDL_BLENDMODE_BLEND:
-        FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888);
-        break;
-    case SDL_BLENDMODE_ADD:
-        FILLRECT(Uint32, DRAW_SETPIXEL_ADD_ARGB8888);
-        break;
-    default:
-        FILLRECT(Uint32, DRAW_SETPIXEL_ARGB8888);
-        break;
-    }
-    return 0;
-}
-
-static int
-SDL_BlendFillRect_RGB(SDL_Surface * dst, const SDL_Rect * rect,
-                      SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
-    SDL_PixelFormat *fmt = dst->format;
-    unsigned inva = 0xff - a;
-
-    switch (fmt->BytesPerPixel) {
-    case 2:
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            FILLRECT(Uint16, DRAW_SETPIXEL_BLEND_RGB);
-            break;
-        case SDL_BLENDMODE_ADD:
-            FILLRECT(Uint16, DRAW_SETPIXEL_ADD_RGB);
-            break;
-        default:
-            FILLRECT(Uint16, DRAW_SETPIXEL_RGB);
-            break;
-        }
-        return 0;
-    case 4:
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_RGB);
-            break;
-        case SDL_BLENDMODE_ADD:
-            FILLRECT(Uint32, DRAW_SETPIXEL_ADD_RGB);
-            break;
-        default:
-            FILLRECT(Uint32, DRAW_SETPIXEL_RGB);
-            break;
-        }
-        return 0;
-    default:
-        SDL_Unsupported();
-        return -1;
-    }
-}
-
-static int
-SDL_BlendFillRect_RGBA(SDL_Surface * dst, const SDL_Rect * rect,
-                       SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
-    SDL_PixelFormat *fmt = dst->format;
-    unsigned inva = 0xff - a;
-
-    switch (fmt->BytesPerPixel) {
-    case 4:
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_RGBA);
-            break;
-        case SDL_BLENDMODE_ADD:
-            FILLRECT(Uint32, DRAW_SETPIXEL_ADD_RGBA);
-            break;
-        default:
-            FILLRECT(Uint32, DRAW_SETPIXEL_RGBA);
-            break;
-        }
-        return 0;
-    default:
-        SDL_Unsupported();
-        return -1;
-    }
-}
-
-int
-SDL_BlendFillRect(SDL_Surface * dst, const SDL_Rect * rect,
-                  SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
-    SDL_Rect clipped;
-
-    if (!dst) {
-        SDL_SetError("Passed NULL destination surface");
-        return -1;
-    }
-
-    /* This function doesn't work on surfaces < 8 bpp */
-    if (dst->format->BitsPerPixel < 8) {
-        SDL_SetError("SDL_BlendFillRect(): Unsupported surface format");
-        return -1;
-    }
-
-    /* If 'rect' == NULL, then fill the whole surface */
-    if (rect) {
-        /* Perform clipping */
-        if (!SDL_IntersectRect(rect, &dst->clip_rect, &clipped)) {
-            return 0;
-        }
-        rect = &clipped;
-    } else {
-        rect = &dst->clip_rect;
-    }
-
-    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
-        r = DRAW_MUL(r, a);
-        g = DRAW_MUL(g, a);
-        b = DRAW_MUL(b, a);
-    }
-
-    switch (dst->format->BitsPerPixel) {
-    case 15:
-        switch (dst->format->Rmask) {
-        case 0x7C00:
-            return SDL_BlendFillRect_RGB555(dst, rect, blendMode, r, g, b, a);
-        }
-        break;
-    case 16:
-        switch (dst->format->Rmask) {
-        case 0xF800:
-            return SDL_BlendFillRect_RGB565(dst, rect, blendMode, r, g, b, a);
-        }
-        break;
-    case 32:
-        switch (dst->format->Rmask) {
-        case 0x00FF0000:
-            if (!dst->format->Amask) {
-                return SDL_BlendFillRect_RGB888(dst, rect, blendMode, r, g, b, a);
-            } else {
-                return SDL_BlendFillRect_ARGB8888(dst, rect, blendMode, r, g, b, a);
-            }
-            break;
-        }
-        break;
-    default:
-        break;
-    }
-
-    if (!dst->format->Amask) {
-        return SDL_BlendFillRect_RGB(dst, rect, blendMode, r, g, b, a);
-    } else {
-        return SDL_BlendFillRect_RGBA(dst, rect, blendMode, r, g, b, a);
-    }
-}
-
-int
-SDL_BlendFillRects(SDL_Surface * dst, const SDL_Rect ** rects, int count,
-                   SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
-    SDL_Rect clipped;
-    int i;
-    int (*func)(SDL_Surface * dst, const SDL_Rect * rect,
-                SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a) = NULL;
-    int status = 0;
-
-    if (!dst) {
-        SDL_SetError("Passed NULL destination surface");
-        return -1;
-    }
-
-    /* This function doesn't work on surfaces < 8 bpp */
-    if (dst->format->BitsPerPixel < 8) {
-        SDL_SetError("SDL_BlendFillRects(): Unsupported surface format");
-        return -1;
-    }
-
-    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
-        r = DRAW_MUL(r, a);
-        g = DRAW_MUL(g, a);
-        b = DRAW_MUL(b, a);
-    }
-
-    /* FIXME: Does this function pointer slow things down significantly? */
-    switch (dst->format->BitsPerPixel) {
-    case 15:
-        switch (dst->format->Rmask) {
-        case 0x7C00:
-            func = SDL_BlendFillRect_RGB555;
-        }
-        break;
-    case 16:
-        switch (dst->format->Rmask) {
-        case 0xF800:
-            func = SDL_BlendFillRect_RGB565;
-        }
-        break;
-    case 32:
-        switch (dst->format->Rmask) {
-        case 0x00FF0000:
-            if (!dst->format->Amask) {
-                func = SDL_BlendFillRect_RGB888;
-            } else {
-                func = SDL_BlendFillRect_ARGB8888;
-            }
-            break;
-        }
-        break;
-    default:
-        break;
-    }
-
-    if (!func) {
-        if (!dst->format->Amask) {
-            func = SDL_BlendFillRect_RGB;
-        } else {
-            func = SDL_BlendFillRect_RGBA;
-        }
-    }
-
-    for (i = 0; i < count; ++i) {
-        const SDL_Rect * rect = rects[i];
-
-        /* If 'rect' == NULL, then fill the whole surface */
-        if (rect) {
-            /* Perform clipping */
-            if (!SDL_IntersectRect(rect, &dst->clip_rect, &clipped)) {
-                continue;
-            }
-            rect = &clipped;
-        } else {
-            rect = &dst->clip_rect;
-        }
-
-        status = func(dst, rect, blendMode, r, g, b, a);
-    }
-    return status;
-}
-
-/* vi: set ts=4 sw=4 expandtab: */
--- a/src/video/SDL_blendline.c	Thu Feb 03 02:42:50 2011 -0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,682 +0,0 @@
-/*
-    SDL - Simple DirectMedia Layer
-    Copyright (C) 1997-2010 Sam Lantinga
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-    Sam Lantinga
-    slouken@libsdl.org
-*/
-#include "SDL_config.h"
-
-#include "SDL_draw.h"
-
-
-static void
-SDL_BlendLine_RGB2(SDL_Surface * dst, int x1, int y1, int x2, int y2,
-                   SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
-                   SDL_bool draw_end)
-{
-    const SDL_PixelFormat *fmt = dst->format;
-    unsigned r, g, b, a, inva;
-
-    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
-        r = DRAW_MUL(_r, _a);
-        g = DRAW_MUL(_g, _a);
-        b = DRAW_MUL(_b, _a);
-        a = _a;
-    } else {
-        r = _r;
-        g = _g;
-        b = _b;
-        a = _a;
-    }
-    inva = (a ^ 0xff);
-
-    if (y1 == y2) {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
-            break;
-        default:
-            HLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
-            break;
-        }
-    } else if (x1 == x2) {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
-            break;
-        default:
-            VLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
-            break;
-        }
-    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
-            break;
-        default:
-            DLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
-            break;
-        }
-    } else {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            AALINE(x1, y1, x2, y2,
-                   DRAW_SETPIXELXY2_BLEND_RGB, DRAW_SETPIXELXY2_BLEND_RGB,
-                   draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            AALINE(x1, y1, x2, y2,
-                   DRAW_SETPIXELXY2_ADD_RGB, DRAW_SETPIXELXY2_ADD_RGB,
-                   draw_end);
-            break;
-        default:
-            AALINE(x1, y1, x2, y2,
-                   DRAW_SETPIXELXY2_RGB, DRAW_SETPIXELXY2_BLEND_RGB,
-                   draw_end);
-            break;
-        }
-    }
-}
-
-static void
-SDL_BlendLine_RGB555(SDL_Surface * dst, int x1, int y1, int x2, int y2,
-                     SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
-                     SDL_bool draw_end)
-{
-    const SDL_PixelFormat *fmt = dst->format;
-    unsigned r, g, b, a, inva;
-
-    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
-        r = DRAW_MUL(_r, _a);
-        g = DRAW_MUL(_g, _a);
-        b = DRAW_MUL(_b, _a);
-        a = _a;
-    } else {
-        r = _r;
-        g = _g;
-        b = _b;
-        a = _a;
-    }
-    inva = (a ^ 0xff);
-
-    if (y1 == y2) {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
-            break;
-        default:
-            HLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
-            break;
-        }
-    } else if (x1 == x2) {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
-            break;
-        default:
-            VLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
-            break;
-        }
-    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
-            break;
-        default:
-            DLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
-            break;
-        }
-    } else {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            AALINE(x1, y1, x2, y2,
-                   DRAW_SETPIXELXY_BLEND_RGB555, DRAW_SETPIXELXY_BLEND_RGB555,
-                   draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            AALINE(x1, y1, x2, y2,
-                   DRAW_SETPIXELXY_ADD_RGB555, DRAW_SETPIXELXY_ADD_RGB555,
-                   draw_end);
-            break;
-        default:
-            AALINE(x1, y1, x2, y2,
-                   DRAW_SETPIXELXY_RGB555, DRAW_SETPIXELXY_BLEND_RGB555,
-                   draw_end);
-            break;
-        }
-    }
-}
-
-static void
-SDL_BlendLine_RGB565(SDL_Surface * dst, int x1, int y1, int x2, int y2,
-                     SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
-                     SDL_bool draw_end)
-{
-    const SDL_PixelFormat *fmt = dst->format;
-    unsigned r, g, b, a, inva;
-
-    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
-        r = DRAW_MUL(_r, _a);
-        g = DRAW_MUL(_g, _a);
-        b = DRAW_MUL(_b, _a);
-        a = _a;
-    } else {
-        r = _r;
-        g = _g;
-        b = _b;
-        a = _a;
-    }
-    inva = (a ^ 0xff);
-
-    if (y1 == y2) {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
-            break;
-        default:
-            HLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
-            break;
-        }
-    } else if (x1 == x2) {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
-            break;
-        default:
-            VLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
-            break;
-        }
-    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
-            break;
-        default:
-            DLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
-            break;
-        }
-    } else {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            AALINE(x1, y1, x2, y2,
-                   DRAW_SETPIXELXY_BLEND_RGB565, DRAW_SETPIXELXY_BLEND_RGB565,
-                   draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            AALINE(x1, y1, x2, y2,
-                   DRAW_SETPIXELXY_ADD_RGB565, DRAW_SETPIXELXY_ADD_RGB565,
-                   draw_end);
-            break;
-        default:
-            AALINE(x1, y1, x2, y2,
-                   DRAW_SETPIXELXY_RGB565, DRAW_SETPIXELXY_BLEND_RGB565,
-                   draw_end);
-            break;
-        }
-    }
-}
-
-static void
-SDL_BlendLine_RGB4(SDL_Surface * dst, int x1, int y1, int x2, int y2,
-                   SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
-                   SDL_bool draw_end)
-{
-    const SDL_PixelFormat *fmt = dst->format;
-    unsigned r, g, b, a, inva;
-
-    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
-        r = DRAW_MUL(_r, _a);
-        g = DRAW_MUL(_g, _a);
-        b = DRAW_MUL(_b, _a);
-        a = _a;
-    } else {
-        r = _r;
-        g = _g;
-        b = _b;
-        a = _a;
-    }
-    inva = (a ^ 0xff);
-
-    if (y1 == y2) {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            HLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
-            break;
-        default:
-            HLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
-            break;
-        }
-    } else if (x1 == x2) {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            VLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
-            break;
-        default:
-            VLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
-            break;
-        }
-    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            DLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
-            break;
-        default:
-            DLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
-            break;
-        }
-    } else {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            AALINE(x1, y1, x2, y2,
-                   DRAW_SETPIXELXY4_BLEND_RGB, DRAW_SETPIXELXY4_BLEND_RGB,
-                   draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            AALINE(x1, y1, x2, y2,
-                   DRAW_SETPIXELXY4_ADD_RGB, DRAW_SETPIXELXY4_ADD_RGB,
-                   draw_end);
-            break;
-        default:
-            AALINE(x1, y1, x2, y2,
-                   DRAW_SETPIXELXY4_RGB, DRAW_SETPIXELXY4_BLEND_RGB,
-                   draw_end);
-            break;
-        }
-    }
-}
-
-static void
-SDL_BlendLine_RGBA4(SDL_Surface * dst, int x1, int y1, int x2, int y2,
-                    SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
-                    SDL_bool draw_end)
-{
-    const SDL_PixelFormat *fmt = dst->format;
-    unsigned r, g, b, a, inva;
-
-    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
-        r = DRAW_MUL(_r, _a);
-        g = DRAW_MUL(_g, _a);
-        b = DRAW_MUL(_b, _a);
-        a = _a;
-    } else {
-        r = _r;
-        g = _g;
-        b = _b;
-        a = _a;
-    }
-    inva = (a ^ 0xff);
-
-    if (y1 == y2) {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            HLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
-            break;
-        default:
-            HLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
-            break;
-        }
-    } else if (x1 == x2) {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            VLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
-            break;
-        default:
-            VLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
-            break;
-        }
-    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            DLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
-            break;
-        default:
-            DLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
-            break;
-        }
-    } else {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            AALINE(x1, y1, x2, y2,
-                   DRAW_SETPIXELXY4_BLEND_RGBA, DRAW_SETPIXELXY4_BLEND_RGBA,
-                   draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            AALINE(x1, y1, x2, y2,
-                   DRAW_SETPIXELXY4_ADD_RGBA, DRAW_SETPIXELXY4_ADD_RGBA,
-                   draw_end);
-            break;
-        default:
-            AALINE(x1, y1, x2, y2,
-                   DRAW_SETPIXELXY4_RGBA, DRAW_SETPIXELXY4_BLEND_RGBA,
-                   draw_end);
-            break;
-        }
-    }
-}
-
-static void
-SDL_BlendLine_RGB888(SDL_Surface * dst, int x1, int y1, int x2, int y2,
-                     SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
-                     SDL_bool draw_end)
-{
-    const SDL_PixelFormat *fmt = dst->format;
-    unsigned r, g, b, a, inva;
-
-    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
-        r = DRAW_MUL(_r, _a);
-        g = DRAW_MUL(_g, _a);
-        b = DRAW_MUL(_b, _a);
-        a = _a;
-    } else {
-        r = _r;
-        g = _g;
-        b = _b;
-        a = _a;
-    }
-    inva = (a ^ 0xff);
-
-    if (y1 == y2) {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            HLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
-            break;
-        default:
-            HLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
-            break;
-        }
-    } else if (x1 == x2) {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            VLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
-            break;
-        default:
-            VLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
-            break;
-        }
-    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            DLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
-            break;
-        default:
-            DLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
-            break;
-        }
-    } else {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            AALINE(x1, y1, x2, y2,
-                   DRAW_SETPIXELXY_BLEND_RGB888, DRAW_SETPIXELXY_BLEND_RGB888,
-                   draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            AALINE(x1, y1, x2, y2,
-                   DRAW_SETPIXELXY_ADD_RGB888, DRAW_SETPIXELXY_ADD_RGB888,
-                   draw_end);
-            break;
-        default:
-            AALINE(x1, y1, x2, y2,
-                   DRAW_SETPIXELXY_RGB888, DRAW_SETPIXELXY_BLEND_RGB888,
-                   draw_end);
-            break;
-        }
-    }
-}
-
-static void
-SDL_BlendLine_ARGB8888(SDL_Surface * dst, int x1, int y1, int x2, int y2,
-                       SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
-                       SDL_bool draw_end)
-{
-    const SDL_PixelFormat *fmt = dst->format;
-    unsigned r, g, b, a, inva;
-
-    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
-        r = DRAW_MUL(_r, _a);
-        g = DRAW_MUL(_g, _a);
-        b = DRAW_MUL(_b, _a);
-        a = _a;
-    } else {
-        r = _r;
-        g = _g;
-        b = _b;
-        a = _a;
-    }
-    inva = (a ^ 0xff);
-
-    if (y1 == y2) {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            HLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            HLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
-            break;
-        default:
-            HLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
-            break;
-        }
-    } else if (x1 == x2) {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            VLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            VLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
-            break;
-        default:
-            VLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
-            break;
-        }
-    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            DLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            DLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
-            break;
-        default:
-            DLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
-            break;
-        }
-    } else {
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            AALINE(x1, y1, x2, y2,
-                   DRAW_SETPIXELXY_BLEND_ARGB8888, DRAW_SETPIXELXY_BLEND_ARGB8888,
-                   draw_end);
-            break;
-        case SDL_BLENDMODE_ADD:
-            AALINE(x1, y1, x2, y2,
-                   DRAW_SETPIXELXY_ADD_ARGB8888, DRAW_SETPIXELXY_ADD_ARGB8888,
-                   draw_end);
-            break;
-        default:
-            AALINE(x1, y1, x2, y2,
-                   DRAW_SETPIXELXY_ARGB8888, DRAW_SETPIXELXY_BLEND_ARGB8888,
-                   draw_end);
-            break;
-        }
-    }
-}
-
-typedef void (*BlendLineFunc) (SDL_Surface * dst,
-                               int x1, int y1, int x2, int y2,
-                               SDL_BlendMode blendMode,
-                               Uint8 r, Uint8 g, Uint8 b, Uint8 a,
-                               SDL_bool draw_end);
-
-static BlendLineFunc
-SDL_CalculateBlendLineFunc(const SDL_PixelFormat * fmt)
-{
-    switch (fmt->BytesPerPixel) {
-    case 2:
-        if (fmt->Rmask == 0x7C00) {
-            return SDL_BlendLine_RGB555;
-        } else if (fmt->Rmask == 0xF800) {
-            return SDL_BlendLine_RGB565;
-        } else {
-            return SDL_BlendLine_RGB2;
-        }
-        break;
-    case 4:
-        if (fmt->Rmask == 0x00FF0000) {
-            if (fmt->Amask) {
-                return SDL_BlendLine_ARGB8888;
-            } else {
-                return SDL_BlendLine_RGB888;
-            }
-        } else {
-            if (fmt->Amask) {
-                return SDL_BlendLine_RGBA4;
-            } else {
-                return SDL_BlendLine_RGB4;
-            }
-        }
-    }
-    return NULL;
-}
-
-int
-SDL_BlendLine(SDL_Surface * dst, int x1, int y1, int x2, int y2,
-              SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
-    BlendLineFunc func;
-
-    if (!dst) {
-        SDL_SetError("SDL_BlendLine(): Passed NULL destination surface");
-        return -1;
-    }
-
-    func = SDL_CalculateBlendLineFunc(dst->format);
-    if (!func) {
-        SDL_SetError("SDL_BlendLine(): Unsupported surface format");
-        return -1;
-    }
-
-    /* Perform clipping */
-    /* FIXME: We don't actually want to clip, as it may change line slope */
-    if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
-        return 0;
-    }
-
-    func(dst, x1, y1, x2, y2, blendMode, r, g, b, a, SDL_TRUE);
-    return 0;
-}
-
-int
-SDL_BlendLines(SDL_Surface * dst, const SDL_Point * points, int count,
-               SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
-    int i;
-    int x1, y1;
-    int x2, y2;
-    SDL_bool draw_end;
-    BlendLineFunc func;
-
-    if (!dst) {
-        SDL_SetError("SDL_BlendLines(): Passed NULL destination surface");
-        return -1;
-    }
-
-    func = SDL_CalculateBlendLineFunc(dst->format);
-    if (!func) {
-        SDL_SetError("SDL_BlendLines(): Unsupported surface format");
-        return -1;
-    }
-
-    for (i = 1; i < count; ++i) {
-        x1 = points[i-1].x;
-        y1 = points[i-1].y;
-        x2 = points[i].x;
-        y2 = points[i].y;
-
-        /* Perform clipping */
-        /* FIXME: We don't actually want to clip, as it may change line slope */
-        if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
-            continue;
-        }
-
-        /* Draw the end if it was clipped */
-        draw_end = (x2 != points[i].x || y2 != points[i].y);
-
-        func(dst, x1, y1, x2, y2, blendMode, r, g, b, a, draw_end);
-    }
-    if (points[0].x != points[count-1].x || points[0].y != points[count-1].y) {
-        SDL_BlendPoint(dst, points[count-1].x, points[count-1].y,
-                       blendMode, r, g, b, a);
-    }
-    return 0;
-}
-
-/* vi: set ts=4 sw=4 expandtab: */
--- a/src/video/SDL_blendpoint.c	Thu Feb 03 02:42:50 2011 -0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,323 +0,0 @@
-/*
-    SDL - Simple DirectMedia Layer
-    Copyright (C) 1997-2010 Sam Lantinga
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-    Sam Lantinga
-    slouken@libsdl.org
-*/
-#include "SDL_config.h"
-
-#include "SDL_draw.h"
-
-static int
-SDL_BlendPoint_RGB555(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
-                      Uint8 g, Uint8 b, Uint8 a)
-{
-    unsigned inva = 0xff - a;
-
-    switch (blendMode) {
-    case SDL_BLENDMODE_BLEND:
-        DRAW_SETPIXELXY_BLEND_RGB555(x, y);
-        break;
-    case SDL_BLENDMODE_ADD:
-        DRAW_SETPIXELXY_ADD_RGB555(x, y);
-        break;
-    default:
-        DRAW_SETPIXELXY_RGB555(x, y);
-        break;
-    }
-    return 0;
-}
-
-static int
-SDL_BlendPoint_RGB565(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
-                      Uint8 g, Uint8 b, Uint8 a)
-{
-    unsigned inva = 0xff - a;
-
-    switch (blendMode) {
-    case SDL_BLENDMODE_BLEND:
-        DRAW_SETPIXELXY_BLEND_RGB565(x, y);
-        break;
-    case SDL_BLENDMODE_ADD:
-        DRAW_SETPIXELXY_ADD_RGB565(x, y);
-        break;
-    default:
-        DRAW_SETPIXELXY_RGB565(x, y);
-        break;
-    }
-    return 0;
-}
-
-static int
-SDL_BlendPoint_RGB888(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
-                      Uint8 g, Uint8 b, Uint8 a)
-{
-    unsigned inva = 0xff - a;
-
-    switch (blendMode) {
-    case SDL_BLENDMODE_BLEND:
-        DRAW_SETPIXELXY_BLEND_RGB888(x, y);
-        break;
-    case SDL_BLENDMODE_ADD:
-        DRAW_SETPIXELXY_ADD_RGB888(x, y);
-        break;
-    default:
-        DRAW_SETPIXELXY_RGB888(x, y);
-        break;
-    }
-    return 0;
-}
-
-static int
-SDL_BlendPoint_ARGB8888(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode,
-                        Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
-    unsigned inva = 0xff - a;
-
-    switch (blendMode) {
-    case SDL_BLENDMODE_BLEND:
-        DRAW_SETPIXELXY_BLEND_ARGB8888(x, y);
-        break;
-    case SDL_BLENDMODE_ADD:
-        DRAW_SETPIXELXY_ADD_ARGB8888(x, y);
-        break;
-    default:
-        DRAW_SETPIXELXY_ARGB8888(x, y);
-        break;
-    }
-    return 0;
-}
-
-static int
-SDL_BlendPoint_RGB(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
-                   Uint8 g, Uint8 b, Uint8 a)
-{
-    SDL_PixelFormat *fmt = dst->format;
-    unsigned inva = 0xff - a;
-
-    switch (fmt->BytesPerPixel) {
-    case 2:
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            DRAW_SETPIXELXY2_BLEND_RGB(x, y);
-            break;
-        case SDL_BLENDMODE_ADD:
-            DRAW_SETPIXELXY2_ADD_RGB(x, y);
-            break;
-        default:
-            DRAW_SETPIXELXY2_RGB(x, y);
-            break;
-        }
-        return 0;
-    case 4:
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            DRAW_SETPIXELXY4_BLEND_RGB(x, y);
-            break;
-        case SDL_BLENDMODE_ADD:
-            DRAW_SETPIXELXY4_ADD_RGB(x, y);
-            break;
-        default:
-            DRAW_SETPIXELXY4_RGB(x, y);
-            break;
-        }
-        return 0;
-    default:
-        SDL_Unsupported();
-        return -1;
-    }
-}
-
-static int
-SDL_BlendPoint_RGBA(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
-                    Uint8 g, Uint8 b, Uint8 a)
-{
-    SDL_PixelFormat *fmt = dst->format;
-    unsigned inva = 0xff - a;
-
-    switch (fmt->BytesPerPixel) {
-    case 4:
-        switch (blendMode) {
-        case SDL_BLENDMODE_BLEND:
-            DRAW_SETPIXELXY4_BLEND_RGBA(x, y);
-            break;
-        case SDL_BLENDMODE_ADD:
-            DRAW_SETPIXELXY4_ADD_RGBA(x, y);
-            break;
-        default:
-            DRAW_SETPIXELXY4_RGBA(x, y);
-            break;
-        }
-        return 0;
-    default:
-        SDL_Unsupported();
-        return -1;
-    }
-}
-
-int
-SDL_BlendPoint(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
-               Uint8 g, Uint8 b, Uint8 a)
-{
-    if (!dst) {
-        SDL_SetError("Passed NULL destination surface");
-        return -1;
-    }
-
-    /* This function doesn't work on surfaces < 8 bpp */
-    if (dst->format->BitsPerPixel < 8) {
-        SDL_SetError("SDL_BlendPoint(): Unsupported surface format");
-        return -1;
-    }
-
-    /* Perform clipping */
-    if (x < dst->clip_rect.x || y < dst->clip_rect.y ||
-        x >= (dst->clip_rect.x + dst->clip_rect.w) ||
-        y >= (dst->clip_rect.y + dst->clip_rect.h)) {
-        return 0;
-    }
-
-    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
-        r = DRAW_MUL(r, a);
-        g = DRAW_MUL(g, a);
-        b = DRAW_MUL(b, a);
-    }
-
-    switch (dst->format->BitsPerPixel) {
-    case 15:
-        switch (dst->format->Rmask) {
-        case 0x7C00:
-            return SDL_BlendPoint_RGB555(dst, x, y, blendMode, r, g, b, a);
-        }
-        break;
-    case 16:
-        switch (dst->format->Rmask) {
-        case 0xF800:
-            return SDL_BlendPoint_RGB565(dst, x, y, blendMode, r, g, b, a);
-        }
-        break;
-    case 32:
-        switch (dst->format->Rmask) {
-        case 0x00FF0000:
-            if (!dst->format->Amask) {
-                return SDL_BlendPoint_RGB888(dst, x, y, blendMode, r, g, b,
-                                             a);
-            } else {
-                return SDL_BlendPoint_ARGB8888(dst, x, y, blendMode, r, g, b,
-                                               a);
-            }
-            break;
-        }
-        break;
-    default:
-        break;
-    }
-
-    if (!dst->format->Amask) {
-        return SDL_BlendPoint_RGB(dst, x, y, blendMode, r, g, b, a);
-    } else {
-        return SDL_BlendPoint_RGBA(dst, x, y, blendMode, r, g, b, a);
-    }
-}
-
-int
-SDL_BlendPoints(SDL_Surface * dst, const SDL_Point * points, int count,
-                SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
-    int minx, miny;
-    int maxx, maxy;
-    int i;
-    int x, y;
-    int (*func)(SDL_Surface * dst, int x, int y,
-                SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a) = NULL;
-    int status = 0;
-
-    if (!dst) {
-        SDL_SetError("Passed NULL destination surface");
-        return -1;
-    }
-
-    /* This function doesn't work on surfaces < 8 bpp */
-    if (dst->format->BitsPerPixel < 8) {
-        SDL_SetError("SDL_BlendPoints(): Unsupported surface format");
-        return (-1);
-    }
-
-    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
-        r = DRAW_MUL(r, a);
-        g = DRAW_MUL(g, a);
-        b = DRAW_MUL(b, a);
-    }
-
-    /* FIXME: Does this function pointer slow things down significantly? */
-    switch (dst->format->BitsPerPixel) {
-    case 15:
-        switch (dst->format->Rmask) {
-        case 0x7C00:
-            func = SDL_BlendPoint_RGB555;
-            break;
-        }
-        break;
-    case 16:
-        switch (dst->format->Rmask) {
-        case 0xF800:
-            func = SDL_BlendPoint_RGB565;
-            break;
-        }
-        break;
-    case 32:
-        switch (dst->format->Rmask) {
-        case 0x00FF0000:
-            if (!dst->format->Amask) {
-                func = SDL_BlendPoint_RGB888;
-            } else {
-                func = SDL_BlendPoint_ARGB8888;
-            }
-            break;
-        }
-        break;
-    default:
-        break;
-    }
-
-    if (!func) {
-        if (!dst->format->Amask) {
-            func = SDL_BlendPoint_RGB;
-        } else {
-            func = SDL_BlendPoint_RGBA;
-        }
-    }
-
-    minx = dst->clip_rect.x;
-    maxx = dst->clip_rect.x + dst->clip_rect.w - 1;
-    miny = dst->clip_rect.y;
-    maxy = dst->clip_rect.y + dst->clip_rect.h - 1;
-
-    for (i = 0; i < count; ++i) {
-        x = points[i].x;
-        y = points[i].y;
-
-        if (x < minx || x > maxx || y < miny || y > maxy) {
-            continue;
-        }
-        status = func(dst, x, y, blendMode, r, g, b, a);
-    }
-    return status;
-}
-
-/* vi: set ts=4 sw=4 expandtab: */
--- a/src/video/SDL_blendrect.c	Thu Feb 03 02:42:50 2011 -0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,75 +0,0 @@
-/*
-    SDL - Simple DirectMedia Layer
-    Copyright (C) 1997-2010 Sam Lantinga
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-    Sam Lantinga
-    slouken@libsdl.org
-*/
-#include "SDL_config.h"
-
-#include "SDL_video.h"
-
-
-int
-SDL_BlendRect(SDL_Surface * dst, const SDL_Rect * rect,
-              SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
-    SDL_Rect full_rect;
-    SDL_Point points[5];
-
-    if (!dst) {
-        SDL_SetError("Passed NULL destination surface");
-        return -1;
-    }
-
-    /* If 'rect' == NULL, then outline the whole surface */
-    if (!rect) {
-        full_rect.x = 0;
-        full_rect.y = 0;
-        full_rect.w = dst->w;
-        full_rect.h = dst->h;
-        rect = &full_rect;
-    }
-
-    points[0].x = rect->x;
-    points[0].y = rect->y;
-    points[1].x = rect->x+rect->w-1;
-    points[1].y = rect->y;
-    points[2].x = rect->x+rect->w-1;
-    points[2].y = rect->y+rect->h-1;
-    points[3].x = rect->x;
-    points[3].y = rect->y+rect->h-1;
-    points[4].x = rect->x;
-    points[4].y = rect->y;
-    return SDL_BlendLines(dst, points, 5, blendMode, r, g, b, a);
-}
-
-int
-SDL_BlendRects(SDL_Surface * dst, const SDL_Rect ** rects, int count,
-               SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
-{
-    int i;
-
-    for (i = 0; i < count; ++i) {
-        if (SDL_BlendRect(dst, rects[i], blendMode, r, g, b, a) < 0) {
-            return -1;
-        }
-    }
-    return 0;
-}
-
-/* vi: set ts=4 sw=4 expandtab: */
--- a/src/video/SDL_blit.h	Thu Feb 03 02:42:50 2011 -0800
+++ b/src/video/SDL_blit.h	Thu Feb 03 02:45:29 2011 -0800
@@ -47,7 +47,7 @@
 
 #include "SDL_cpuinfo.h"
 #include "SDL_endian.h"
-#include "SDL_video.h"
+#include "SDL_surface.h"
 
 /* SDL blit copy flags */
 #define SDL_COPY_MODULATE_COLOR     0x00000001
--- a/src/video/SDL_draw.h	Thu Feb 03 02:42:50 2011 -0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,521 +0,0 @@
-/*
-    SDL - Simple DirectMedia Layer
-    Copyright (C) 1997-2010 Sam Lantinga
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-    Sam Lantinga
-    slouken@libsdl.org
-*/
-#include "SDL_config.h"
-
-#include "SDL_blit.h"
-
-/* This code assumes that r, g, b, a are the source color,
- * and in the blend and add case, the RGB values are premultiplied by a.
- */
-
-#define DRAW_MUL(_a, _b) (((unsigned)(_a)*(_b))/255)
-
-#define DRAW_FASTSETPIXEL(type) \
-    *pixel = (type) color
-
-#define DRAW_FASTSETPIXEL1 DRAW_FASTSETPIXEL(Uint8)
-#define DRAW_FASTSETPIXEL2 DRAW_FASTSETPIXEL(Uint16)
-#define DRAW_FASTSETPIXEL4 DRAW_FASTSETPIXEL(Uint32)
-
-#define DRAW_FASTSETPIXELXY(x, y, type, bpp, color) \
-    *(type *)((Uint8 *)dst->pixels + (y) * dst->pitch \
-                                   + (x) * bpp) = (type) color
-
-#define DRAW_FASTSETPIXELXY1(x, y) DRAW_FASTSETPIXELXY(x, y, Uint8, 1, color)
-#define DRAW_FASTSETPIXELXY2(x, y) DRAW_FASTSETPIXELXY(x, y, Uint16, 2, color)
-#define DRAW_FASTSETPIXELXY4(x, y) DRAW_FASTSETPIXELXY(x, y, Uint32, 4, color)
-
-#define DRAW_SETPIXEL(setpixel) \
-do { \
-    unsigned sr = r, sg = g, sb = b, sa = a; \
-    setpixel; \
-} while (0)
-
-#define DRAW_SETPIXEL_BLEND(getpixel, setpixel) \
-do { \
-    unsigned sr, sg, sb, sa; sa; \
-    getpixel; \
-    sr = DRAW_MUL(inva, sr) + r; \
-    sg = DRAW_MUL(inva, sg) + g; \
-    sb = DRAW_MUL(inva, sb) + b; \
-    setpixel; \
-} while (0)
-
-#define DRAW_SETPIXEL_ADD(getpixel, setpixel) \
-do { \
-    unsigned sr, sg, sb, sa; sa; \
-    getpixel; \
-    sr += r; if (sr > 0xff) sr = 0xff; \
-    sg += g; if (sg > 0xff) sg = 0xff; \
-    sb += b; if (sb > 0xff) sb = 0xff; \
-    setpixel; \
-} while (0)
-
-#define DRAW_SETPIXELXY(x, y, type, bpp, op) \
-do { \
-    type *pixel = (type *)((Uint8 *)dst->pixels + (y) * dst->pitch \
-                                                + (x) * bpp); \
-    op; \
-} while (0)
-
-/*
- * Define draw operators for RGB555
- */
-
-#define DRAW_SETPIXEL_RGB555 \
-    DRAW_SETPIXEL(RGB555_FROM_RGB(*pixel, sr, sg, sb))
-
-#define DRAW_SETPIXEL_BLEND_RGB555 \
-    DRAW_SETPIXEL_BLEND(RGB_FROM_RGB555(*pixel, sr, sg, sb), \
-                        RGB555_FROM_RGB(*pixel, sr, sg, sb))
-
-#define DRAW_SETPIXEL_ADD_RGB555 \
-    DRAW_SETPIXEL_ADD(RGB_FROM_RGB555(*pixel, sr, sg, sb), \
-                      RGB555_FROM_RGB(*pixel, sr, sg, sb))
-
-#define DRAW_SETPIXELXY_RGB555(x, y) \
-    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_RGB555)
-
-#define DRAW_SETPIXELXY_BLEND_RGB555(x, y) \
-    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_BLEND_RGB555)
-
-#define DRAW_SETPIXELXY_ADD_RGB555(x, y) \
-    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_ADD_RGB555)
-
-/*
- * Define draw operators for RGB565
- */
-
-#define DRAW_SETPIXEL_RGB565 \
-    DRAW_SETPIXEL(RGB565_FROM_RGB(*pixel, sr, sg, sb))
-
-#define DRAW_SETPIXEL_BLEND_RGB565 \
-    DRAW_SETPIXEL_BLEND(RGB_FROM_RGB565(*pixel, sr, sg, sb), \
-                        RGB565_FROM_RGB(*pixel, sr, sg, sb))
-
-#define DRAW_SETPIXEL_ADD_RGB565 \
-    DRAW_SETPIXEL_ADD(RGB_FROM_RGB565(*pixel, sr, sg, sb), \
-                      RGB565_FROM_RGB(*pixel, sr, sg, sb))
-
-#define DRAW_SETPIXELXY_RGB565(x, y) \
-    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_RGB565)
-
-#define DRAW_SETPIXELXY_BLEND_RGB565(x, y) \
-    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_BLEND_RGB565)
-
-#define DRAW_SETPIXELXY_ADD_RGB565(x, y) \
-    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_ADD_RGB565)
-
-/*
- * Define draw operators for RGB888
- */
-
-#define DRAW_SETPIXEL_RGB888 \
-    DRAW_SETPIXEL(RGB888_FROM_RGB(*pixel, sr, sg, sb))
-
-#define DRAW_SETPIXEL_BLEND_RGB888 \
-    DRAW_SETPIXEL_BLEND(RGB_FROM_RGB888(*pixel, sr, sg, sb), \
-                        RGB888_FROM_RGB(*pixel, sr, sg, sb))
-
-#define DRAW_SETPIXEL_ADD_RGB888 \
-    DRAW_SETPIXEL_ADD(RGB_FROM_RGB888(*pixel, sr, sg, sb), \
-                      RGB888_FROM_RGB(*pixel, sr, sg, sb))
-
-#define DRAW_SETPIXELXY_RGB888(x, y) \
-    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_RGB888)
-
-#define DRAW_SETPIXELXY_BLEND_RGB888(x, y) \
-    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_RGB888)
-
-#define DRAW_SETPIXELXY_ADD_RGB888(x, y) \
-    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_RGB888)
-
-/*
- * Define draw operators for ARGB8888
- */
-
-#define DRAW_SETPIXEL_ARGB8888 \
-    DRAW_SETPIXEL(ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))
-
-#define DRAW_SETPIXEL_BLEND_ARGB8888 \
-    DRAW_SETPIXEL_BLEND(RGBA_FROM_ARGB8888(*pixel, sr, sg, sb, sa), \
-                        ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))
-
-#define DRAW_SETPIXEL_ADD_ARGB8888 \
-    DRAW_SETPIXEL_ADD(RGBA_FROM_ARGB8888(*pixel, sr, sg, sb, sa), \
-                      ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))
-
-#define DRAW_SETPIXELXY_ARGB8888(x, y) \
-    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ARGB8888)
-
-#define DRAW_SETPIXELXY_BLEND_ARGB8888(x, y) \
-    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_ARGB8888)
-
-#define DRAW_SETPIXELXY_ADD_ARGB8888(x, y) \
-    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_ARGB8888)
-
-/*
- * Define draw operators for general RGB
- */
-
-#define DRAW_SETPIXEL_RGB \
-    DRAW_SETPIXEL(PIXEL_FROM_RGB(*pixel, fmt, sr, sg, sb))
-
-#define DRAW_SETPIXEL_BLEND_RGB \
-    DRAW_SETPIXEL_BLEND(RGB_FROM_PIXEL(*pixel, fmt, sr, sg, sb), \
-                        PIXEL_FROM_RGB(*pixel, fmt, sr, sg, sb))
-
-#define DRAW_SETPIXEL_ADD_RGB \
-    DRAW_SETPIXEL_ADD(RGB_FROM_PIXEL(*pixel, fmt, sr, sg, sb), \
-                      PIXEL_FROM_RGB(*pixel, fmt, sr, sg, sb))
-
-#define DRAW_SETPIXELXY2_RGB(x, y) \
-    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_RGB)
-
-#define DRAW_SETPIXELXY4_RGB(x, y) \
-    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_RGB)
-
-#define DRAW_SETPIXELXY2_BLEND_RGB(x, y) \
-    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_BLEND_RGB)
-
-#define DRAW_SETPIXELXY4_BLEND_RGB(x, y) \
-    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_RGB)
-
-#define DRAW_SETPIXELXY2_ADD_RGB(x, y) \
-    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_ADD_RGB)
-
-#define DRAW_SETPIXELXY4_ADD_RGB(x, y) \
-    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_RGB)
-
-
-/*
- * Define draw operators for general RGBA
- */
-
-#define DRAW_SETPIXEL_RGBA \
-    DRAW_SETPIXEL(PIXEL_FROM_RGBA(*pixel, fmt, sr, sg, sb, sa))
-
-#define DRAW_SETPIXEL_BLEND_RGBA \
-    DRAW_SETPIXEL_BLEND(RGBA_FROM_PIXEL(*pixel, fmt, sr, sg, sb, sa), \
-                        PIXEL_FROM_RGBA(*pixel, fmt, sr, sg, sb, sa))
-
-#define DRAW_SETPIXEL_ADD_RGBA \
-    DRAW_SETPIXEL_ADD(RGBA_FROM_PIXEL(*pixel, fmt, sr, sg, sb, sa), \
-                      PIXEL_FROM_RGBA(*pixel, fmt, sr, sg, sb, sa))
-
-#define DRAW_SETPIXELXY4_RGBA(x, y) \
-    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_RGBA)
-
-#define DRAW_SETPIXELXY4_BLEND_RGBA(x, y) \
-    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_RGBA)
-
-#define DRAW_SETPIXELXY4_ADD_RGBA(x, y) \
-    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_RGBA)
-
-/*
- * Define line drawing macro
- */
-
-#define ABS(_x) ((_x) < 0 ? -(_x) : (_x))
-
-/* Horizontal line */
-#define HLINE(type, op, draw_end) \
-{ \
-    int length; \
-    int pitch = (dst->pitch / dst->format->BytesPerPixel); \
-    type *pixel; \
-    if (x1 <= x2) { \
-        pixel = (type *)dst->pixels + y1 * pitch + x1; \
-        length = draw_end ? (x2-x1+1) : (x2-x1); \
-    } else { \
-        pixel = (type *)dst->pixels + y1 * pitch + x2; \
-        if (!draw_end) { \
-            ++pixel; \
-        } \
-        length = draw_end ? (x1-x2+1) : (x1-x2); \
-    } \
-    while (length--) { \
-        op; \
-        ++pixel; \
-    } \
-}
-
-/* Vertical line */
-#define VLINE(type, op, draw_end) \
-{ \
-    int length; \
-    int pitch = (dst->pitch / dst->format->BytesPerPixel); \
-    type *pixel; \
-    if (y1 <= y2) { \
-        pixel = (type *)dst->pixels + y1 * pitch + x1; \
-        length = draw_end ? (y2-y1+1) : (y2-y1); \
-    } else { \
-        pixel = (type *)dst->pixels + y2 * pitch + x1; \
-        if (!draw_end) { \
-            pixel += pitch; \
-        } \
-        length = draw_end ? (y1-y2+1) : (y1-y2); \
-    } \
-    while (length--) { \
-        op; \
-        pixel += pitch; \
-    } \
-}
-
-/* Diagonal line */
-#define DLINE(type, op, draw_end) \
-{ \
-    int length; \
-    int pitch = (dst->pitch / dst->format->BytesPerPixel); \
-    type *pixel; \
-    if (y1 <= y2) { \
-        pixel = (type *)dst->pixels + y1 * pitch + x1; \
-        if (x1 <= x2) { \
-            ++pitch; \
-        } else { \
-            --pitch; \
-        } \
-        length = (y2-y1); \
-    } else { \
-        pixel = (type *)dst->pixels + y2 * pitch + x2; \
-        if (x2 <= x1) { \
-            ++pitch; \
-        } else { \
-            --pitch; \
-        } \
-        if (!draw_end) { \
-            pixel += pitch; \
-        } \
-        length = (y1-y2); \
-    } \
-    if (draw_end) { \
-        ++length; \
-    } \
-    while (length--) { \
-        op; \
-        pixel += pitch; \
-    } \
-}
-
-/* Bresenham's line algorithm */
-#define BLINE(x1, y1, x2, y2, op, draw_end) \
-{ \
-    int i, deltax, deltay, numpixels; \
-    int d, dinc1, dinc2; \
-    int x, xinc1, xinc2; \
-    int y, yinc1, yinc2; \
- \
-    deltax = ABS(x2 - x1); \
-    deltay = ABS(y2 - y1); \
- \
-    if (deltax >= deltay) { \
-        numpixels = deltax + 1; \
-        d = (2 * deltay) - deltax; \
-        dinc1 = deltay * 2; \
-        dinc2 = (deltay - deltax) * 2; \
-        xinc1 = 1; \
-        xinc2 = 1; \
-        yinc1 = 0; \
-        yinc2 = 1; \
-    } else { \
-        numpixels = deltay + 1; \
-        d = (2 * deltax) - deltay; \
-        dinc1 = deltax * 2; \
-        dinc2 = (deltax - deltay) * 2; \
-        xinc1 = 0; \
-        xinc2 = 1; \
-        yinc1 = 1; \
-        yinc2 = 1; \
-    } \
- \
-    if (x1 > x2) { \
-        xinc1 = -xinc1; \
-        xinc2 = -xinc2; \
-    } \
-    if (y1 > y2) { \
-        yinc1 = -yinc1; \
-        yinc2 = -yinc2; \
-    } \
- \
-    x = x1; \
-    y = y1; \
- \
-    if (!draw_end) { \
-        --numpixels; \
-    } \
-    for (i = 0; i < numpixels; ++i) { \
-        op(x, y); \
-        if (d < 0) { \
-            d += dinc1; \
-            x += xinc1; \
-            y += yinc1; \
-        } else { \
-            d += dinc2; \
-            x += xinc2; \
-            y += yinc2; \
-        } \
-    } \
-}
-
-/* Xiaolin Wu's line algorithm, based on Michael Abrash's implementation */
-#define WULINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end) \
-{ \
-    Uint16 ErrorAdj, ErrorAcc; \
-    Uint16 ErrorAccTemp, Weighting; \
-    int DeltaX, DeltaY, Temp, XDir; \
-    unsigned r, g, b, a, inva; \
- \
-    /* Draw the initial pixel, which is always exactly intersected by \
-       the line and so needs no weighting */ \
-    opaque_op(x1, y1); \
- \
-    /* Draw the final pixel, which is always exactly intersected by the line \
-       and so needs no weighting */ \
-    if (draw_end) { \
-        opaque_op(x2, y2); \
-    } \
- \
-    /* Make sure the line runs top to bottom */ \
-    if (y1 > y2) { \
-        Temp = y1; y1 = y2; y2 = Temp; \
-        Temp = x1; x1 = x2; x2 = Temp; \
-    } \
-    DeltaY = y2 - y1; \
- \
-    if ((DeltaX = x2 - x1) >= 0) { \
-        XDir = 1; \
-    } else { \
-        XDir = -1; \
-        DeltaX = -DeltaX; /* make DeltaX positive */ \
-    } \
- \
-    /* line is not horizontal, diagonal, or vertical */ \
-    ErrorAcc = 0;  /* initialize the line error accumulator to 0 */ \
- \
-    /* Is this an X-major or Y-major line? */ \
-    if (DeltaY > DeltaX) { \
-        /* Y-major line; calculate 16-bit fixed-point fractional part of a \
-          pixel that X advances each time Y advances 1 pixel, truncating the \
-          result so that we won't overrun the endpoint along the X axis */ \
-        ErrorAdj = ((unsigned long) DeltaX << 16) / (unsigned long) DeltaY; \
-        /* Draw all pixels other than the first and last */ \
-        while (--DeltaY) { \
-            ErrorAccTemp = ErrorAcc;   /* remember currrent accumulated error */ \
-            ErrorAcc += ErrorAdj;      /* calculate error for next pixel */ \
-            if (ErrorAcc <= ErrorAccTemp) { \
-                /* The error accumulator turned over, so advance the X coord */ \
-                x1 += XDir; \
-            } \
-            y1++; /* Y-major, so always advance Y */ \
-            /* The IntensityBits most significant bits of ErrorAcc give us the \
-             intensity weighting for this pixel, and the complement of the \
-             weighting for the paired pixel */ \
-            Weighting = ErrorAcc >> 8; \
-            { \
-                a = DRAW_MUL(_a, (Weighting ^ 255)); \
-                r = DRAW_MUL(_r, a); \
-                g = DRAW_MUL(_g, a); \
-                b = DRAW_MUL(_b, a); \
-                inva = (a ^ 0xFF); \
-                blend_op(x1, y1); \
-            } \
-            { \
-                a = DRAW_MUL(_a, Weighting); \
-                r = DRAW_MUL(_r, a); \
-                g = DRAW_MUL(_g, a); \
-                b = DRAW_MUL(_b, a); \
-                inva = (a ^ 0xFF); \
-                blend_op(x1 + XDir, y1); \
-            } \
-        } \
-    } else { \
-        /* X-major line; calculate 16-bit fixed-point fractional part of a \
-           pixel that Y advances each time X advances 1 pixel, truncating the \
-           result to avoid overrunning the endpoint along the X axis */ \
-        ErrorAdj = ((unsigned long) DeltaY << 16) / (unsigned long) DeltaX; \
-        /* Draw all pixels other than the first and last */ \
-        while (--DeltaX) { \
-            ErrorAccTemp = ErrorAcc;   /* remember currrent accumulated error */ \
-            ErrorAcc += ErrorAdj;      /* calculate error for next pixel */ \
-            if (ErrorAcc <= ErrorAccTemp) { \
-                /* The error accumulator turned over, so advance the Y coord */ \
-                y1++; \
-            } \
-            x1 += XDir; /* X-major, so always advance X */ \
-            /* The IntensityBits most significant bits of ErrorAcc give us the \
-              intensity weighting for this pixel, and the complement of the \
-              weighting for the paired pixel */ \
-            Weighting = ErrorAcc >> 8; \
-            { \
-                a = DRAW_MUL(_a, (Weighting ^ 255)); \
-                r = DRAW_MUL(_r, a); \
-                g = DRAW_MUL(_g, a); \
-                b = DRAW_MUL(_b, a); \
-                inva = (a ^ 0xFF); \
-                blend_op(x1, y1); \
-            } \
-            { \
-                a = DRAW_MUL(_a, Weighting); \
-                r = DRAW_MUL(_r, a); \
-                g = DRAW_MUL(_g, a); \
-                b = DRAW_MUL(_b, a); \
-                inva = (a ^ 0xFF); \
-                blend_op(x1, y1 + 1); \
-            } \
-        } \
-    } \
-}
-
-#ifdef AA_LINES
-#define AALINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end) \
-            WULINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end)
-#else
-#define AALINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end) \
-            BLINE(x1, y1, x2, y2, opaque_op, draw_end)
-#endif
-
-/*
- * Define fill rect macro
- */
-
-#define FILLRECT(type, op) \
-do { \
-    int width = rect->w; \
-    int height = rect->h; \
-    int pitch = (dst->pitch / dst->format->BytesPerPixel); \
-    int skip = pitch - width; \
-    type *pixel = (type *)dst->pixels + rect->y * pitch + rect->x; \
-    while (height--) { \
-        { int n = (width+3)/4; \
-            switch (width & 3) { \
-            case 0: do {   op; pixel++; \
-            case 3:        op; pixel++; \
-            case 2:        op; pixel++; \
-            case 1:        op; pixel++; \
-                    } while ( --n > 0 ); \
-            } \
-        } \
-        pixel += skip; \
-    } \
-} while (0)
-
-/* vi: set ts=4 sw=4 expandtab: */
--- a/src/video/SDL_drawline.c	Thu Feb 03 02:42:50 2011 -0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,208 +0,0 @@
-/*
-    SDL - Simple DirectMedia Layer
-    Copyright (C) 1997-2010 Sam Lantinga
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-    Sam Lantinga
-    slouken@libsdl.org
-*/
-#include "SDL_config.h"
-
-#include "SDL_draw.h"
-
-static void
-SDL_DrawLine1(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color,
-              SDL_bool draw_end)
-{
-    if (y1 == y2) {
-        //HLINE(Uint8, DRAW_FASTSETPIXEL1, draw_end);
-        int length;
-        int pitch = (dst->pitch / dst->format->BytesPerPixel);
-        Uint8 *pixel;
-        if (x1 <= x2) {
-            pixel = (Uint8 *)dst->pixels + y1 * pitch + x1;
-            length = draw_end ? (x2-x1+1) : (x2-x1);
-        } else {
-            pixel = (Uint8 *)dst->pixels + y1 * pitch + x2;
-            if (!draw_end) {
-                ++pixel;
-            }
-            length = draw_end ? (x1-x2+1) : (x1-x2);
-        }
-        SDL_memset(pixel, color, length);
-    } else if (x1 == x2) {
-        VLINE(Uint8, DRAW_FASTSETPIXEL1, draw_end);
-    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
-        DLINE(Uint8, DRAW_FASTSETPIXEL1, draw_end);
-    } else {
-        BLINE(x1, y1, x2, y2, DRAW_FASTSETPIXELXY1, draw_end);
-    }
-}
-
-static void
-SDL_DrawLine2(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color,
-              SDL_bool draw_end)
-{
-    if (y1 == y2) {
-        HLINE(Uint16, DRAW_FASTSETPIXEL2, draw_end);
-    } else if (x1 == x2) {
-        VLINE(Uint16, DRAW_FASTSETPIXEL2, draw_end);
-    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
-        DLINE(Uint16, DRAW_FASTSETPIXEL2, draw_end);
-    } else {
-        Uint8 _r, _g, _b, _a;
-        const SDL_PixelFormat * fmt = dst->format;
-        SDL_GetRGBA(color, fmt, &_r, &_g, &_b, &_a);
-        if (fmt->Rmask == 0x7C00) {
-            AALINE(x1, y1, x2, y2,
-                   DRAW_FASTSETPIXELXY2, DRAW_SETPIXELXY_BLEND_RGB555,
-                   draw_end);
-        } else if (fmt->Rmask == 0xF800) {
-            AALINE(x1, y1, x2, y2,
-                   DRAW_FASTSETPIXELXY2, DRAW_SETPIXELXY_BLEND_RGB565,
-                   draw_end);
-        } else {
-            AALINE(x1, y1, x2, y2,
-                   DRAW_FASTSETPIXELXY2, DRAW_SETPIXELXY2_BLEND_RGB,
-                   draw_end);
-        }
-    }
-}
-
-static void
-SDL_DrawLine4(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color,
-              SDL_bool draw_end)
-{
-    if (y1 == y2) {
-        HLINE(Uint32, DRAW_FASTSETPIXEL4, draw_end);
-    } else if (x1 == x2) {
-        VLINE(Uint32, DRAW_FASTSETPIXEL4, draw_end);
-    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
-        DLINE(Uint32, DRAW_FASTSETPIXEL4, draw_end);
-    } else {
-        Uint8 _r, _g, _b, _a;
-        const SDL_PixelFormat * fmt = dst->format;
-        SDL_GetRGBA(color, fmt, &_r, &_g, &_b, &_a);
-        if (fmt->Rmask == 0x00FF0000) {
-            if (!fmt->Amask) {
-                AALINE(x1, y1, x2, y2,
-                       DRAW_FASTSETPIXELXY4, DRAW_SETPIXELXY_BLEND_RGB888,
-                       draw_end);
-            } else {
-                AALINE(x1, y1, x2, y2,
-                       DRAW_FASTSETPIXELXY4, DRAW_SETPIXELXY_BLEND_ARGB8888,
-                       draw_end);
-            }
-        } else {
-            AALINE(x1, y1, x2, y2,
-                   DRAW_FASTSETPIXELXY4, DRAW_SETPIXELXY4_BLEND_RGB,
-                   draw_end);
-        }
-    }
-}
-
-typedef void (*DrawLineFunc) (SDL_Surface * dst,
-                              int x1, int y1, int x2, int y2,
-                              Uint32 color, SDL_bool draw_end);
-
-static DrawLineFunc
-SDL_CalculateDrawLineFunc(const SDL_PixelFormat * fmt)
-{
-    switch (fmt->BytesPerPixel) {
-    case 1:
-        if (fmt->BitsPerPixel < 8) {
-            break;
-        }
-        return SDL_DrawLine1;
-    case 2:
-        return SDL_DrawLine2;
-    case 4:
-        return SDL_DrawLine4;
-    }
-    return NULL;
-}
-
-int
-SDL_DrawLine(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color)
-{
-    DrawLineFunc func;
-
-    if (!dst) {
-        SDL_SetError("SDL_DrawLine(): Passed NULL destination surface");
-        return -1;
-    }
-
-    func = SDL_CalculateDrawLineFunc(dst->format);
-    if (!func) {
-        SDL_SetError("SDL_DrawLine(): Unsupported surface format");
-        return -1;
-    }
-
-    /* Perform clipping */
-    /* FIXME: We don't actually want to clip, as it may change line slope */
-    if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
-        return 0;
-    }
-
-    func(dst, x1, y1, x2, y2, color, SDL_TRUE);
-    return 0;
-}
-
-int
-SDL_DrawLines(SDL_Surface * dst, const SDL_Point * points, int count,
-              Uint32 color)
-{
-    int i;
-    int x1, y1;
-    int x2, y2;
-    SDL_bool draw_end;
-    DrawLineFunc func;
-
-    if (!dst) {
-        SDL_SetError("SDL_DrawLines(): Passed NULL destination surface");
-        return -1;
-    }
-
-    func = SDL_CalculateDrawLineFunc(dst->format);
-    if (!func) {
-        SDL_SetError("SDL_DrawLines(): Unsupported surface format");
-        return -1;
-    }
-
-    for (i = 1; i < count; ++i) {
-        x1 = points[i-1].x;
-        y1 = points[i-1].y;
-        x2 = points[i].x;
-        y2 = points[i].y;
-
-        /* Perform clipping */
-        /* FIXME: We don't actually want to clip, as it may change line slope */
-        if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
-            continue;
-        }
-
-        /* Draw the end if it was clipped */
-        draw_end = (x2 != points[i].x || y2 != points[i].y);
-
-        func(dst, x1, y1, x2, y2, color, draw_end);
-    }
-    if (points[0].x != points[count-1].x || points[0].y != points[count-1].y) {
-        SDL_DrawPoint(dst, points[count-1].x, points[count-1].y, color);
-    }
-    return 0;
-}
-
-/* vi: set ts=4 sw=4 expandtab: */
--- a/src/video/SDL_drawpoint.c	Thu Feb 03 02:42:50 2011 -0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,116 +0,0 @@
-/*
-    SDL - Simple DirectMedia Layer
-    Copyright (C) 1997-2010 Sam Lantinga
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-    Sam Lantinga
-    slouken@libsdl.org
-*/
-#include "SDL_config.h"
-
-#include "SDL_draw.h"
-
-
-int
-SDL_DrawPoint(SDL_Surface * dst, int x, int y, Uint32 color)
-{
-    if (!dst) {
-        SDL_SetError("Passed NULL destination surface");
-        return -1;
-    }
-
-    /* This function doesn't work on surfaces < 8 bpp */
-    if (dst->format->BitsPerPixel < 8) {
-        SDL_SetError("SDL_DrawPoint(): Unsupported surface format");
-        return -1;
-    }
-
-    /* Perform clipping */
-    if (x < dst->clip_rect.x || y < dst->clip_rect.y ||
-        x >= (dst->clip_rect.x + dst->clip_rect.w) ||
-        y >= (dst->clip_rect.y + dst->clip_rect.h)) {
-        return 0;
-    }
-
-    switch (dst->format->BytesPerPixel) {
-    case 1:
-        DRAW_FASTSETPIXELXY1(x, y);
-        break;
-    case 2:
-        DRAW_FASTSETPIXELXY2(x, y);
-        break;
-    case 3:
-        SDL_Unsupported();
-        return -1;
-    case 4:
-        DRAW_FASTSETPIXELXY4(x, y);
-        break;
-    }
-    return 0;
-}
-
-int
-SDL_DrawPoints(SDL_Surface * dst, const SDL_Point * points, int count,
-               Uint32 color)
-{
-    int minx, miny;
-    int maxx, maxy;
-    int i;
-    int x, y;
-
-    if (!dst) {
-        SDL_SetError("Passed NULL destination surface");
-        return -1;
-    }
-
-    /* This function doesn't work on surfaces < 8 bpp */
-    if (dst->format->BitsPerPixel < 8) {
-        SDL_SetError("SDL_DrawPoints(): Unsupported surface format");
-        return -1;
-    }
-
-    minx = dst->clip_rect.x;
-    maxx = dst->clip_rect.x + dst->clip_rect.w - 1;
-    miny = dst->clip_rect.y;
-    maxy = dst->clip_rect.y + dst->clip_rect.h - 1;
-
-    for (i = 0; i < count; ++i) {
-        x = points[i].x;
-        y = points[i].y;
-
-        if (x < minx || x > maxx || y < miny || y > maxy) {
-            continue;
-        }
-
-        switch (dst->format->BytesPerPixel) {
-        case 1:
-            DRAW_FASTSETPIXELXY1(x, y);
-            break;
-        case 2:
-            DRAW_FASTSETPIXELXY2(x, y);
-            break;
-        case 3:
-            SDL_Unsupported();
-            return -1;
-        case 4:
-            DRAW_FASTSETPIXELXY4(x, y);
-            break;
-        }
-    }
-    return 0;
-}
-
-/* vi: set ts=4 sw=4 expandtab: */
--- a/src/video/SDL_drawrect.c	Thu Feb 03 02:42:50 2011 -0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,74 +0,0 @@
-/*
-    SDL - Simple DirectMedia Layer
-    Copyright (C) 1997-2010 Sam Lantinga
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-    Sam Lantinga
-    slouken@libsdl.org
-*/
-#include "SDL_config.h"
-
-#include "SDL_video.h"
-
-
-int
-SDL_DrawRect(SDL_Surface * dst, const SDL_Rect * rect, Uint32 color)
-{
-    SDL_Rect full_rect;
-    SDL_Point points[5];
-
-    if (!dst) {
-        SDL_SetError("Passed NULL destination surface");
-        return -1;
-    }
-
-    /* If 'rect' == NULL, then outline the whole surface */
-    if (!rect) {
-        full_rect.x = 0;
-        full_rect.y = 0;
-        full_rect.w = dst->w;
-        full_rect.h = dst->h;
-        rect = &full_rect;
-    }
-
-    points[0].x = rect->x;
-    points[0].y = rect->y;
-    points[1].x = rect->x+rect->w-1;
-    points[1].y = rect->y;
-    points[2].x = rect->x+rect->w-1;
-    points[2].y = rect->y+rect->h-1;
-    points[3].x = rect->x;
-    points[3].y = rect->y+rect->h-1;
-    points[4].x = rect->x;
-    points[4].y = rect->y;
-    return SDL_DrawLines(dst, points, 5, color);
-}
-
-int
-SDL_DrawRects(SDL_Surface * dst, const SDL_Rect ** rects, int count,
-              Uint32 color)
-{
-    int i;
-
-    for (i = 0; i < count; ++i) {
-        if (SDL_DrawRect(dst, rects[i], color) < 0) {
-            return -1;
-        }
-    }
-    return 0;
-}
-
-/* vi: set ts=4 sw=4 expandtab: */
--- a/test/automated/surface/surface.c	Thu Feb 03 02:42:50 2011 -0800
+++ b/test/automated/surface/surface.c	Thu Feb 03 02:45:29 2011 -0800
@@ -26,8 +26,6 @@
  */
 /* Testcases. */
 static void surface_testLoad( SDL_Surface *testsur );
-static void surface_testPrimitives( SDL_Surface *testsur );
-static void surface_testPrimitivesBlend( SDL_Surface *testsur );
 static void surface_testBlit( SDL_Surface *testsur );
 static int surface_testBlitBlendMode( SDL_Surface *testsur, SDL_Surface *face, int mode );
 static void surface_testBlitBlend( SDL_Surface *testsur );
@@ -85,167 +83,6 @@
 
 
 /**
- * @brief Tests the SDL primitives for rendering.
- */
-static void surface_testPrimitives( SDL_Surface *testsur )
-{
-   int ret;
-   int x, y;
-   SDL_Rect rect;
-
-   SDL_ATbegin( "Primitives Test" );
-
-   /* Clear surface. */
-   ret = SDL_FillRect( testsur, NULL,
-         SDL_MapRGB( testsur->format, 0, 0, 0 ) );
-   if (SDL_ATassert( "SDL_FillRect", ret == 0))
-      return;
-
-   /* Draw a rectangle. */
-   rect.x = 40;
-   rect.y = 0;
-   rect.w = 40;
-   rect.h = 80;
-   ret = SDL_FillRect( testsur, &rect,
-         SDL_MapRGB( testsur->format, 13, 73, 200 ) );
-   if (SDL_ATassert( "SDL_FillRect", ret == 0))
-      return;
-
-   /* Draw a rectangle. */
-   rect.x = 10;
-   rect.y = 10;
-   rect.w = 60;
-   rect.h = 40;
-   ret = SDL_FillRect( testsur, &rect,
-         SDL_MapRGB( testsur->format, 200, 0, 100 ) );
-   if (SDL_ATassert( "SDL_FillRect", ret == 0))
-      return;
-
-   /* Draw some points like so:
-    * X.X.X.X..
-    * .X.X.X.X.
-    * X.X.X.X.. */
-   for (y=0; y<3; y++) {
-      x = y % 2;
-      for (; x<80; x+=2) {
-         ret = SDL_DrawPoint( testsur, x, y,
-               SDL_MapRGB( testsur->format, x*y, x*y/2, x*y/3 ) );
-         if (SDL_ATassert( "SDL_DrawPoint", ret == 0))
-            return;
-      }
-   }
-
-   /* Draw some lines. */
-   ret = SDL_DrawLine( testsur, 0, 30, 80, 30,
-         SDL_MapRGB( testsur->format, 0, 255, 0 ) );
-   if (SDL_ATassert( "SDL_DrawLine", ret == 0))
-      return;
-   ret = SDL_DrawLine( testsur, 40, 30, 40, 60,
-         SDL_MapRGB( testsur->format, 55, 55, 5 ) );
-   if (SDL_ATassert( "SDL_DrawLine", ret == 0))
-      return;
-   ret = SDL_DrawLine( testsur, 0, 0, 29, 29,
-         SDL_MapRGB( testsur->format, 5, 105, 105 ) );
-   if (SDL_ATassert( "SDL_DrawLine", ret == 0))
-      return;
-   ret = SDL_DrawLine( testsur, 29, 30, 0, 59,
-         SDL_MapRGB( testsur->format, 5, 105, 105 ) );
-   if (SDL_ATassert( "SDL_DrawLine", ret == 0))
-      return;
-   ret = SDL_DrawLine( testsur, 79, 0, 50, 29,
-         SDL_MapRGB( testsur->format, 5, 105, 105 ) );
-   if (SDL_ATassert( "SDL_DrawLine", ret == 0))
-      return;
-   ret = SDL_DrawLine( testsur, 79, 59, 50, 30,
-         SDL_MapRGB( testsur->format, 5, 105, 105 ) );
-   if (SDL_ATassert( "SDL_DrawLine", ret == 0))
-      return;
-
-   /* See if it's the same. */
-   if (SDL_ATassert( "Primitives output not the same.",
-            surface_compare( testsur, &img_primitives, 0 )==0 ))
-      return;
-
-   SDL_ATend();
-}
-
-
-/**
- * @brief Tests the SDL primitives with alpha for rendering.
- */
-static void surface_testPrimitivesBlend( SDL_Surface *testsur )
-{
-   int ret;
-   int i, j;
-   SDL_Rect rect;
-
-   SDL_ATbegin( "Primitives Blend Test" );
-
-   /* Clear surface. */
-   ret = SDL_FillRect( testsur, NULL,
-         SDL_MapRGB( testsur->format, 0, 0, 0 ) );
-   if (SDL_ATassert( "SDL_FillRect", ret == 0))
-      return;
-
-   /* Create some rectangles for each blend mode. */
-   ret = SDL_BlendFillRect( testsur, NULL, SDL_BLENDMODE_NONE, 255, 255, 255, 0 );
-   if (SDL_ATassert( "SDL_BlendFillRect", ret == 0))
-      return;
-   rect.x = 10;
-   rect.y = 25;
-   rect.w = 40;
-   rect.h = 25;
-   ret = SDL_BlendFillRect( testsur, &rect, SDL_BLENDMODE_ADD, 240, 10, 10, 75 );
-   if (SDL_ATassert( "SDL_BlendFillRect", ret == 0))
-      return;
-   rect.x = 30;
-   rect.y = 40;
-   rect.w = 45;
-   rect.h = 15;
-   ret = SDL_BlendFillRect( testsur, &rect, SDL_BLENDMODE_BLEND, 10, 240, 10, 100 );
-   if (SDL_ATassert( "SDL_BlendFillRect", ret == 0))
-      return;
-
-   /* Draw blended lines, lines for everyone. */
-   for (i=0; i<testsur->w; i+=2)  {
-      ret = SDL_BlendLine( testsur, 0, 0, i, 59,
-            (((i/2)%3)==0) ? SDL_BLENDMODE_BLEND :
-               (((i/2)%3)==1) ? SDL_BLENDMODE_ADD : SDL_BLENDMODE_NONE,
-            60+2*i, 240-2*i, 50, 3*i );
-      if (SDL_ATassert( "SDL_BlendLine", ret == 0))
-         return;
-   }
-   for (i=0; i<testsur->h; i+=2)  {
-      ret = SDL_BlendLine( testsur, 0, 0, 79, i,
-            (((i/2)%3)==0) ? SDL_BLENDMODE_BLEND :
-               (((i/2)%3)==1) ? SDL_BLENDMODE_ADD : SDL_BLENDMODE_NONE,
-            60+2*i, 240-2*i, 50, 3*i );
-      if (SDL_ATassert( "SDL_BlendLine", ret == 0))
-         return;
-   }
-
-   /* Draw points. */
-   for (j=0; j<testsur->h; j+=3) {
-      for (i=0; i<testsur->w; i+=3) {
-      ret = SDL_BlendPoint( testsur, i, j,
-            ((((i+j)/3)%3)==0) ? SDL_BLENDMODE_BLEND :
-               ((((i+j)/3)%3)==1) ? SDL_BLENDMODE_ADD : SDL_BLENDMODE_NONE,
-            j*4, i*3, j*4, i*3 );
-      if (SDL_ATassert( "SDL_BlendPoint", ret == 0))
-         return;
-      }
-   }
-
-   /* See if it's the same. */
-   if (SDL_ATassert( "Primitives output not the same.",
-            surface_compare( testsur, &img_blend, 0 )==0 ))
-      return;
-
-   SDL_ATend();
-}
-
-
-/**
  * @brief Tests some blitting routines.
  */
 static void surface_testBlit( SDL_Surface *testsur )
@@ -546,8 +383,6 @@
 void surface_runTests( SDL_Surface *testsur )
 {
    /* Software surface blitting. */
-   surface_testPrimitives( testsur );
-   surface_testPrimitivesBlend( testsur );
    surface_testBlit( testsur );
    surface_testBlitBlend( testsur );
 }