--- a/src/video/SDL_surface.c	Sun May 21 17:27:13 2006 +0000
+++ b/src/video/SDL_surface.c	Sun May 28 13:04:16 2006 +0000
@@ -34,365 +34,373 @@
 /*
  * Create an empty RGB surface of the appropriate depth
  */
-SDL_Surface * SDL_CreateRGBSurface (Uint32 flags,
-			int width, int height, int depth,
-			Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
+SDL_Surface *
+SDL_CreateRGBSurface (Uint32 flags,
+                      int width, int height, int depth,
+                      Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
 {
-	SDL_VideoDevice *video = current_video;
-	SDL_VideoDevice *this  = current_video;
-	SDL_Surface *screen;
-	SDL_Surface *surface;
+    SDL_VideoDevice *_this = SDL_GetVideoDevice ();
+    SDL_Surface *screen;
+    SDL_Surface *surface;
 
-	/* Make sure the size requested doesn't overflow our datatypes */
-	/* Next time I write a library like SDL, I'll use int for size. :) */
-	if ( width >= 16384 || height >= 65536 ) {
-		SDL_SetError("Width or height is too large");
-		return(NULL);
-	}
+    /* Make sure the size requested doesn't overflow our datatypes */
+    /* Next time I write a library like SDL, I'll use int for size. :) */
+    if (width >= 16384 || height >= 65536) {
+        SDL_SetError ("Width or height is too large");
+        return (NULL);
+    }
 
-	/* Check to see if we desire the surface in video memory */
-	if ( video ) {
-		screen = SDL_PublicSurface;
-	} else {
-		screen = NULL;
-	}
-	if ( screen && ((screen->flags&SDL_HWSURFACE) == SDL_HWSURFACE) ) {
-		if ( (flags&(SDL_SRCCOLORKEY|SDL_SRCALPHA)) != 0 ) {
-			flags |= SDL_HWSURFACE;
-		}
-		if ( (flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) {
-			if ( ! current_video->info.blit_hw_CC ) {
-				flags &= ~SDL_HWSURFACE;
-			}
-		}
-		if ( (flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
-			if ( ! current_video->info.blit_hw_A ) {
-				flags &= ~SDL_HWSURFACE;
-			}
-		}
-	} else {
-		flags &= ~SDL_HWSURFACE;
-	}
+    /* Check to see if we desire the surface in video memory */
+    if (_this) {
+        screen = SDL_PublicSurface;
+    } else {
+        screen = NULL;
+    }
+    if (screen && ((screen->flags & SDL_HWSURFACE) == SDL_HWSURFACE)) {
+        if ((flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA)) != 0) {
+            flags |= SDL_HWSURFACE;
+        }
+        if ((flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {
+            if (!_this->info.blit_hw_CC) {
+                flags &= ~SDL_HWSURFACE;
+            }
+        }
+        if ((flags & SDL_SRCALPHA) == SDL_SRCALPHA) {
+            if (!_this->info.blit_hw_A) {
+                flags &= ~SDL_HWSURFACE;
+            }
+        }
+    } else {
+        flags &= ~SDL_HWSURFACE;
+    }
 
-	/* Allocate the surface */
-	surface = (SDL_Surface *)SDL_malloc(sizeof(*surface));
-	if ( surface == NULL ) {
-		SDL_OutOfMemory();
-		return(NULL);
-	}
-	surface->flags = SDL_SWSURFACE;
-	if ( (flags & SDL_HWSURFACE) == SDL_HWSURFACE ) {
-		if ((Amask) && (video->displayformatalphapixel))
-		{
-			depth = video->displayformatalphapixel->BitsPerPixel;
-			Rmask = video->displayformatalphapixel->Rmask;
-			Gmask = video->displayformatalphapixel->Gmask;
-			Bmask = video->displayformatalphapixel->Bmask;
-			Amask = video->displayformatalphapixel->Amask;
-		}
-		else
-		{
-			depth = screen->format->BitsPerPixel;
-			Rmask = screen->format->Rmask;
-			Gmask = screen->format->Gmask;
-			Bmask = screen->format->Bmask;
-			Amask = screen->format->Amask;
-		}
-	}
-	surface->format = SDL_AllocFormat(depth, Rmask, Gmask, Bmask, Amask);
-	if ( surface->format == NULL ) {
-		SDL_free(surface);
-		return(NULL);
-	}
-	if ( Amask ) {
-		surface->flags |= SDL_SRCALPHA;
-	}
-	surface->w = width;
-	surface->h = height;
-	surface->pitch = SDL_CalculatePitch(surface);
-	surface->pixels = NULL;
-	surface->offset = 0;
-	surface->hwdata = NULL;
-	surface->locked = 0;
-	surface->map = NULL;
-	surface->unused1 = 0;
-	SDL_SetClipRect(surface, NULL);
-	SDL_FormatChanged(surface);
+    /* Allocate the surface */
+    surface = (SDL_Surface *) SDL_malloc (sizeof (*surface));
+    if (surface == NULL) {
+        SDL_OutOfMemory ();
+        return (NULL);
+    }
+    surface->flags = SDL_SWSURFACE;
+    if ((flags & SDL_HWSURFACE) == SDL_HWSURFACE) {
+        if ((Amask) && (_this->displayformatalphapixel)) {
+            depth = _this->displayformatalphapixel->BitsPerPixel;
+            Rmask = _this->displayformatalphapixel->Rmask;
+            Gmask = _this->displayformatalphapixel->Gmask;
+            Bmask = _this->displayformatalphapixel->Bmask;
+            Amask = _this->displayformatalphapixel->Amask;
+        } else {
+            depth = screen->format->BitsPerPixel;
+            Rmask = screen->format->Rmask;
+            Gmask = screen->format->Gmask;
+            Bmask = screen->format->Bmask;
+            Amask = screen->format->Amask;
+        }
+    }
+    surface->format = SDL_AllocFormat (depth, Rmask, Gmask, Bmask, Amask);
+    if (surface->format == NULL) {
+        SDL_free (surface);
+        return (NULL);
+    }
+    if (Amask) {
+        surface->flags |= SDL_SRCALPHA;
+    }
+    surface->w = width;
+    surface->h = height;
+    surface->pitch = SDL_CalculatePitch (surface);
+    surface->pixels = NULL;
+    surface->offset = 0;
+    surface->hwdata = NULL;
+    surface->locked = 0;
+    surface->map = NULL;
+    surface->unused1 = 0;
+    SDL_SetClipRect (surface, NULL);
+    SDL_FormatChanged (surface);
 
-	/* Get the pixels */
-	if ( ((flags&SDL_HWSURFACE) == SDL_SWSURFACE) || 
-				(video->AllocHWSurface(this, surface) < 0) ) {
-		if ( surface->w && surface->h ) {
-			surface->pixels = SDL_malloc(surface->h*surface->pitch);
-			if ( surface->pixels == NULL ) {
-				SDL_FreeSurface(surface);
-				SDL_OutOfMemory();
-				return(NULL);
-			}
-			/* This is important for bitmaps */
-			SDL_memset(surface->pixels, 0, surface->h*surface->pitch);
-		}
-	}
+    /* Get the pixels */
+    if (((flags & SDL_HWSURFACE) == SDL_SWSURFACE) ||
+        (_this->AllocHWSurface (_this, surface) < 0)) {
+        if (surface->w && surface->h) {
+            surface->pixels = SDL_malloc (surface->h * surface->pitch);
+            if (surface->pixels == NULL) {
+                SDL_FreeSurface (surface);
+                SDL_OutOfMemory ();
+                return (NULL);
+            }
+            /* This is important for bitmaps */
+            SDL_memset (surface->pixels, 0, surface->h * surface->pitch);
+        }
+    }
 
-	/* Allocate an empty mapping */
-	surface->map = SDL_AllocBlitMap();
-	if ( surface->map == NULL ) {
-		SDL_FreeSurface(surface);
-		return(NULL);
-	}
+    /* Allocate an empty mapping */
+    surface->map = SDL_AllocBlitMap ();
+    if (surface->map == NULL) {
+        SDL_FreeSurface (surface);
+        return (NULL);
+    }
 
-	/* The surface is ready to go */
-	surface->refcount = 1;
+    /* The surface is ready to go */
+    surface->refcount = 1;
 #ifdef CHECK_LEAKS
-	++surfaces_allocated;
+    ++surfaces_allocated;
 #endif
-	return(surface);
+    return (surface);
 }
+
 /*
  * Create an RGB surface from an existing memory buffer
  */
-SDL_Surface * SDL_CreateRGBSurfaceFrom (void *pixels,
-			int width, int height, int depth, int pitch,
-			Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
+SDL_Surface *
+SDL_CreateRGBSurfaceFrom (void *pixels,
+                          int width, int height, int depth, int pitch,
+                          Uint32 Rmask, Uint32 Gmask, Uint32 Bmask,
+                          Uint32 Amask)
 {
-	SDL_Surface *surface;
+    SDL_Surface *surface;
 
-	surface = SDL_CreateRGBSurface(SDL_SWSURFACE, 0, 0, depth,
-	                               Rmask, Gmask, Bmask, Amask);
-	if ( surface != NULL ) {
-		surface->flags |= SDL_PREALLOC;
-		surface->pixels = pixels;
-		surface->w = width;
-		surface->h = height;
-		surface->pitch = pitch;
-		SDL_SetClipRect(surface, NULL);
-	}
-	return(surface);
+    surface = SDL_CreateRGBSurface (SDL_SWSURFACE, 0, 0, depth,
+                                    Rmask, Gmask, Bmask, Amask);
+    if (surface != NULL) {
+        surface->flags |= SDL_PREALLOC;
+        surface->pixels = pixels;
+        surface->w = width;
+        surface->h = height;
+        surface->pitch = pitch;
+        SDL_SetClipRect (surface, NULL);
+    }
+    return (surface);
 }
+
 /*
  * Set the color key in a blittable surface
  */
-int SDL_SetColorKey (SDL_Surface *surface, Uint32 flag, Uint32 key)
+int
+SDL_SetColorKey (SDL_Surface * surface, Uint32 flag, Uint32 key)
 {
-	/* Sanity check the flag as it gets passed in */
-	if ( flag & SDL_SRCCOLORKEY ) {
-		if ( flag & (SDL_RLEACCEL|SDL_RLEACCELOK) ) {
-			flag = (SDL_SRCCOLORKEY | SDL_RLEACCELOK);
-		} else {
-			flag = SDL_SRCCOLORKEY;
-		}
-	} else {
-		flag = 0;
-	}
+    /* Sanity check the flag as it gets passed in */
+    if (flag & SDL_SRCCOLORKEY) {
+        if (flag & (SDL_RLEACCEL | SDL_RLEACCELOK)) {
+            flag = (SDL_SRCCOLORKEY | SDL_RLEACCELOK);
+        } else {
+            flag = SDL_SRCCOLORKEY;
+        }
+    } else {
+        flag = 0;
+    }
 
-	/* Optimize away operations that don't change anything */
-	if ( (flag == (surface->flags & (SDL_SRCCOLORKEY|SDL_RLEACCELOK))) &&
-	     (key == surface->format->colorkey) ) {
-		return(0);
-	}
+    /* Optimize away operations that don't change anything */
+    if ((flag == (surface->flags & (SDL_SRCCOLORKEY | SDL_RLEACCELOK))) &&
+        (key == surface->format->colorkey)) {
+        return (0);
+    }
 
-	/* UnRLE surfaces before we change the colorkey */
-	if ( surface->flags & SDL_RLEACCEL ) {
-	        SDL_UnRLESurface(surface, 1);
-	}
+    /* UnRLE surfaces before we change the colorkey */
+    if (surface->flags & SDL_RLEACCEL) {
+        SDL_UnRLESurface (surface, 1);
+    }
 
-	if ( flag ) {
-		SDL_VideoDevice *video = current_video;
-		SDL_VideoDevice *this  = current_video;
-
+    if (flag) {
+        SDL_VideoDevice *_this = SDL_GetVideoDevice ();
 
-		surface->flags |= SDL_SRCCOLORKEY;
-		surface->format->colorkey = key;
-		if ( (surface->flags & SDL_HWACCEL) == SDL_HWACCEL ) {
-			if ( (video->SetHWColorKey == NULL) ||
-			     (video->SetHWColorKey(this, surface, key) < 0) ) {
-				surface->flags &= ~SDL_HWACCEL;
-			}
-		}
-		if ( flag & SDL_RLEACCELOK ) {
-			surface->flags |= SDL_RLEACCELOK;
-		} else {
-			surface->flags &= ~SDL_RLEACCELOK;
-		}
-	} else {
-		surface->flags &= ~(SDL_SRCCOLORKEY|SDL_RLEACCELOK);
-		surface->format->colorkey = 0;
-	}
-	SDL_InvalidateMap(surface->map);
-	return(0);
+        surface->flags |= SDL_SRCCOLORKEY;
+        surface->format->colorkey = key;
+        if ((surface->flags & SDL_HWACCEL) == SDL_HWACCEL) {
+            if ((_this->SetHWColorKey == NULL) ||
+                (_this->SetHWColorKey (_this, surface, key) < 0)) {
+                surface->flags &= ~SDL_HWACCEL;
+            }
+        }
+        if (flag & SDL_RLEACCELOK) {
+            surface->flags |= SDL_RLEACCELOK;
+        } else {
+            surface->flags &= ~SDL_RLEACCELOK;
+        }
+    } else {
+        surface->flags &= ~(SDL_SRCCOLORKEY | SDL_RLEACCELOK);
+        surface->format->colorkey = 0;
+    }
+    SDL_InvalidateMap (surface->map);
+    return (0);
 }
+
 /* This function sets the alpha channel of a surface */
-int SDL_SetAlpha (SDL_Surface *surface, Uint32 flag, Uint8 value)
+int
+SDL_SetAlpha (SDL_Surface * surface, Uint32 flag, Uint8 value)
 {
-	Uint32 oldflags = surface->flags;
-	Uint32 oldalpha = surface->format->alpha;
+    Uint32 oldflags = surface->flags;
+    Uint32 oldalpha = surface->format->alpha;
 
-	/* Sanity check the flag as it gets passed in */
-	if ( flag & SDL_SRCALPHA ) {
-		if ( flag & (SDL_RLEACCEL|SDL_RLEACCELOK) ) {
-			flag = (SDL_SRCALPHA | SDL_RLEACCELOK);
-		} else {
-			flag = SDL_SRCALPHA;
-		}
-	} else {
-		flag = 0;
-	}
+    /* Sanity check the flag as it gets passed in */
+    if (flag & SDL_SRCALPHA) {
+        if (flag & (SDL_RLEACCEL | SDL_RLEACCELOK)) {
+            flag = (SDL_SRCALPHA | SDL_RLEACCELOK);
+        } else {
+            flag = SDL_SRCALPHA;
+        }
+    } else {
+        flag = 0;
+    }
 
-	/* Optimize away operations that don't change anything */
-	if ( (flag == (surface->flags & (SDL_SRCALPHA|SDL_RLEACCELOK))) &&
-	     (!flag || value == oldalpha) ) {
-		return(0);
-	}
+    /* Optimize away operations that don't change anything */
+    if ((flag == (surface->flags & (SDL_SRCALPHA | SDL_RLEACCELOK))) &&
+        (!flag || value == oldalpha)) {
+        return (0);
+    }
 
-	if(!(flag & SDL_RLEACCELOK) && (surface->flags & SDL_RLEACCEL))
-		SDL_UnRLESurface(surface, 1);
+    if (!(flag & SDL_RLEACCELOK) && (surface->flags & SDL_RLEACCEL))
+        SDL_UnRLESurface (surface, 1);
 
-	if ( flag ) {
-		SDL_VideoDevice *video = current_video;
-		SDL_VideoDevice *this  = current_video;
+    if (flag) {
+        SDL_VideoDevice *_this = SDL_GetVideoDevice ();
 
-		surface->flags |= SDL_SRCALPHA;
-		surface->format->alpha = value;
-		if ( (surface->flags & SDL_HWACCEL) == SDL_HWACCEL ) {
-			if ( (video->SetHWAlpha == NULL) ||
-			     (video->SetHWAlpha(this, surface, value) < 0) ) {
-				surface->flags &= ~SDL_HWACCEL;
-			}
-		}
-		if ( flag & SDL_RLEACCELOK ) {
-		        surface->flags |= SDL_RLEACCELOK;
-		} else {
-		        surface->flags &= ~SDL_RLEACCELOK;
-		}
-	} else {
-		surface->flags &= ~SDL_SRCALPHA;
-		surface->format->alpha = SDL_ALPHA_OPAQUE;
-	}
-	/*
-	 * The representation for software surfaces is independent of
-	 * per-surface alpha, so no need to invalidate the blit mapping
-	 * if just the alpha value was changed. (If either is 255, we still
-	 * need to invalidate.)
-	 */
-	if((surface->flags & SDL_HWACCEL) == SDL_HWACCEL
-	   || oldflags != surface->flags
-	   || (((oldalpha + 1) ^ (value + 1)) & 0x100))
-		SDL_InvalidateMap(surface->map);
-	return(0);
+        surface->flags |= SDL_SRCALPHA;
+        surface->format->alpha = value;
+        if ((surface->flags & SDL_HWACCEL) == SDL_HWACCEL) {
+            if ((_this->SetHWAlpha == NULL) ||
+                (_this->SetHWAlpha (_this, surface, value) < 0)) {
+                surface->flags &= ~SDL_HWACCEL;
+            }
+        }
+        if (flag & SDL_RLEACCELOK) {
+            surface->flags |= SDL_RLEACCELOK;
+        } else {
+            surface->flags &= ~SDL_RLEACCELOK;
+        }
+    } else {
+        surface->flags &= ~SDL_SRCALPHA;
+        surface->format->alpha = SDL_ALPHA_OPAQUE;
+    }
+    /*
+     * The representation for software surfaces is independent of
+     * per-surface alpha, so no need to invalidate the blit mapping
+     * if just the alpha value was changed. (If either is 255, we still
+     * need to invalidate.)
+     */
+    if ((surface->flags & SDL_HWACCEL) == SDL_HWACCEL
+        || oldflags != surface->flags
+        || (((oldalpha + 1) ^ (value + 1)) & 0x100))
+        SDL_InvalidateMap (surface->map);
+    return (0);
 }
-int SDL_SetAlphaChannel(SDL_Surface *surface, Uint8 value)
+
+int
+SDL_SetAlphaChannel (SDL_Surface * surface, Uint8 value)
 {
-	int row, col;
-	int offset;
-	Uint8 *buf;
-
-	if ( (surface->format->Amask != 0xFF000000) &&
-	     (surface->format->Amask != 0x000000FF) ) {
-		SDL_SetError("Unsupported surface alpha mask format");
-		return -1;
-	}
+    int row, col;
+    int offset;
+    Uint8 *buf;
 
+    if ((surface->format->Amask != 0xFF000000) &&
+        (surface->format->Amask != 0x000000FF)) {
+        SDL_SetError ("Unsupported surface alpha mask format");
+        return -1;
+    }
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
-	if ( surface->format->Amask == 0xFF000000 ) {
-			offset = 3;
-	} else {
-			offset = 0;
-	}
+    if (surface->format->Amask == 0xFF000000) {
+        offset = 3;
+    } else {
+        offset = 0;
+    }
 #else
-	if ( surface->format->Amask == 0xFF000000 ) {
-			offset = 0;
-	} else {
-			offset = 3;
-	}
+    if (surface->format->Amask == 0xFF000000) {
+        offset = 0;
+    } else {
+        offset = 3;
+    }
 #endif /* Byte ordering */
 
-	/* Quickly set the alpha channel of an RGBA or ARGB surface */
-	if ( SDL_MUSTLOCK(surface) ) {
-		if ( SDL_LockSurface(surface) < 0 ) {
-			return -1;
-		}
-	}
-	row = surface->h;
-	while (row--) {
-		col = surface->w;
-		buf = (Uint8 *)surface->pixels + row * surface->pitch + offset;
-		while(col--) {
-			*buf = value;
-			buf += 4;
-		}
-	}
-	if ( SDL_MUSTLOCK(surface) ) {
-		SDL_UnlockSurface(surface);
-	}
-	return 0;
+    /* Quickly set the alpha channel of an RGBA or ARGB surface */
+    if (SDL_MUSTLOCK (surface)) {
+        if (SDL_LockSurface (surface) < 0) {
+            return -1;
+        }
+    }
+    row = surface->h;
+    while (row--) {
+        col = surface->w;
+        buf = (Uint8 *) surface->pixels + row * surface->pitch + offset;
+        while (col--) {
+            *buf = value;
+            buf += 4;
+        }
+    }
+    if (SDL_MUSTLOCK (surface)) {
+        SDL_UnlockSurface (surface);
+    }
+    return 0;
 }
 
 /*
  * A function to calculate the intersection of two rectangles:
  * return true if the rectangles intersect, false otherwise
  */
-static __inline__
-SDL_bool SDL_IntersectRect(const SDL_Rect *A, const SDL_Rect *B, SDL_Rect *intersection)
+static __inline__ SDL_bool
+SDL_IntersectRect (const SDL_Rect * A, const SDL_Rect * B,
+                   SDL_Rect * intersection)
 {
-	int Amin, Amax, Bmin, Bmax;
+    int Amin, Amax, Bmin, Bmax;
 
-	/* Horizontal intersection */
-	Amin = A->x;
-	Amax = Amin + A->w;
-	Bmin = B->x;
-	Bmax = Bmin + B->w;
-	if(Bmin > Amin)
-	        Amin = Bmin;
-	intersection->x = Amin;
-	if(Bmax < Amax)
-	        Amax = Bmax;
-	intersection->w = Amax - Amin > 0 ? Amax - Amin : 0;
+    /* Horizontal intersection */
+    Amin = A->x;
+    Amax = Amin + A->w;
+    Bmin = B->x;
+    Bmax = Bmin + B->w;
+    if (Bmin > Amin)
+        Amin = Bmin;
+    intersection->x = Amin;
+    if (Bmax < Amax)
+        Amax = Bmax;
+    intersection->w = Amax - Amin > 0 ? Amax - Amin : 0;
 
-	/* Vertical intersection */
-	Amin = A->y;
-	Amax = Amin + A->h;
-	Bmin = B->y;
-	Bmax = Bmin + B->h;
-	if(Bmin > Amin)
-	        Amin = Bmin;
-	intersection->y = Amin;
-	if(Bmax < Amax)
-	        Amax = Bmax;
-	intersection->h = Amax - Amin > 0 ? Amax - Amin : 0;
+    /* Vertical intersection */
+    Amin = A->y;
+    Amax = Amin + A->h;
+    Bmin = B->y;
+    Bmax = Bmin + B->h;
+    if (Bmin > Amin)
+        Amin = Bmin;
+    intersection->y = Amin;
+    if (Bmax < Amax)
+        Amax = Bmax;
+    intersection->h = Amax - Amin > 0 ? Amax - Amin : 0;
 
-	return (intersection->w && intersection->h);
+    return (intersection->w && intersection->h);
 }
+
 /*
  * Set the clipping rectangle for a blittable surface
  */
-SDL_bool SDL_SetClipRect(SDL_Surface *surface, const SDL_Rect *rect)
+SDL_bool
+SDL_SetClipRect (SDL_Surface * surface, const SDL_Rect * rect)
 {
-	SDL_Rect full_rect;
+    SDL_Rect full_rect;
 
-	/* Don't do anything if there's no surface to act on */
-	if ( ! surface ) {
-		return SDL_FALSE;
-	}
+    /* Don't do anything if there's no surface to act on */
+    if (!surface) {
+        return SDL_FALSE;
+    }
+
+    /* Set up the full surface rectangle */
+    full_rect.x = 0;
+    full_rect.y = 0;
+    full_rect.w = surface->w;
+    full_rect.h = surface->h;
 
-	/* Set up the full surface rectangle */
-	full_rect.x = 0;
-	full_rect.y = 0;
-	full_rect.w = surface->w;
-	full_rect.h = surface->h;
+    /* Set the clipping rectangle */
+    if (!rect) {
+        surface->clip_rect = full_rect;
+        return 1;
+    }
+    return SDL_IntersectRect (rect, &full_rect, &surface->clip_rect);
+}
 
-	/* Set the clipping rectangle */
-	if ( ! rect ) {
-		surface->clip_rect = full_rect;
-		return 1;
-	}
-	return SDL_IntersectRect(rect, &full_rect, &surface->clip_rect);
+void
+SDL_GetClipRect (SDL_Surface * surface, SDL_Rect * rect)
+{
+    if (surface && rect) {
+        *rect = surface->clip_rect;
+    }
 }
-void SDL_GetClipRect(SDL_Surface *surface, SDL_Rect *rect)
-{
-	if ( surface && rect ) {
-		*rect = surface->clip_rect;
-	}
-}
+
 /* 
  * Set up a blit between two surfaces -- split into three parts:
  * The upper part, SDL_UpperBlit(), performs clipping and rectangle 
@@ -404,538 +412,526 @@
  * you know exactly what you are doing, you can optimize your code
  * by calling the one(s) you need.
  */
-int SDL_LowerBlit (SDL_Surface *src, SDL_Rect *srcrect,
-				SDL_Surface *dst, SDL_Rect *dstrect)
+int
+SDL_LowerBlit (SDL_Surface * src, SDL_Rect * srcrect,
+               SDL_Surface * dst, SDL_Rect * dstrect)
 {
-	SDL_blit do_blit;
-	SDL_Rect hw_srcrect;
-	SDL_Rect hw_dstrect;
-
-	/* Check to make sure the blit mapping is valid */
-	if ( (src->map->dst != dst) ||
-             (src->map->dst->format_version != src->map->format_version) ) {
-		if ( SDL_MapSurface(src, dst) < 0 ) {
-			return(-1);
-		}
-	}
+    SDL_blit do_blit;
 
-	/* Figure out which blitter to use */
-	if ( (src->flags & SDL_HWACCEL) == SDL_HWACCEL ) {
-		if ( src == SDL_VideoSurface ) {
-			hw_srcrect = *srcrect;
-			hw_srcrect.x += current_video->offset_x;
-			hw_srcrect.y += current_video->offset_y;
-			srcrect = &hw_srcrect;
-		}
-		if ( dst == SDL_VideoSurface ) {
-			hw_dstrect = *dstrect;
-			hw_dstrect.x += current_video->offset_x;
-			hw_dstrect.y += current_video->offset_y;
-			dstrect = &hw_dstrect;
-		}
-		do_blit = src->map->hw_blit;
-	} else {
-		do_blit = src->map->sw_blit;
-	}
-	return(do_blit(src, srcrect, dst, dstrect));
+    /* Check to make sure the blit mapping is valid */
+    if ((src->map->dst != dst) ||
+        (src->map->dst->format_version != src->map->format_version)) {
+        if (SDL_MapSurface (src, dst) < 0) {
+            return (-1);
+        }
+    }
+
+    /* Figure out which blitter to use */
+    if ((src->flags & SDL_HWACCEL) == SDL_HWACCEL) {
+        do_blit = src->map->hw_blit;
+    } else {
+        do_blit = src->map->sw_blit;
+    }
+    return (do_blit (src, srcrect, dst, dstrect));
 }
 
 
-int SDL_UpperBlit (SDL_Surface *src, SDL_Rect *srcrect,
-		   SDL_Surface *dst, SDL_Rect *dstrect)
+int
+SDL_UpperBlit (SDL_Surface * src, SDL_Rect * srcrect,
+               SDL_Surface * dst, SDL_Rect * dstrect)
 {
-        SDL_Rect fulldst;
-	int srcx, srcy, w, h;
+    SDL_Rect fulldst;
+    int srcx, srcy, w, h;
 
-	/* Make sure the surfaces aren't locked */
-	if ( ! src || ! dst ) {
-		SDL_SetError("SDL_UpperBlit: passed a NULL surface");
-		return(-1);
-	}
-	if ( src->locked || dst->locked ) {
-		SDL_SetError("Surfaces must not be locked during blit");
-		return(-1);
-	}
+    /* Make sure the surfaces aren't locked */
+    if (!src || !dst) {
+        SDL_SetError ("SDL_UpperBlit: passed a NULL surface");
+        return (-1);
+    }
+    if (src->locked || dst->locked) {
+        SDL_SetError ("Surfaces must not be locked during blit");
+        return (-1);
+    }
 
-	/* If the destination rectangle is NULL, use the entire dest surface */
-	if ( dstrect == NULL ) {
-	        fulldst.x = fulldst.y = 0;
-		dstrect = &fulldst;
-	}
+    /* If the destination rectangle is NULL, use the entire dest surface */
+    if (dstrect == NULL) {
+        fulldst.x = fulldst.y = 0;
+        dstrect = &fulldst;
+    }
+
+    /* clip the source rectangle to the source surface */
+    if (srcrect) {
+        int maxw, maxh;
 
-	/* clip the source rectangle to the source surface */
-	if(srcrect) {
-	        int maxw, maxh;
-	
-		srcx = srcrect->x;
-		w = srcrect->w;
-		if(srcx < 0) {
-		        w += srcx;
-			dstrect->x -= srcx;
-			srcx = 0;
-		}
-		maxw = src->w - srcx;
-		if(maxw < w)
-			w = maxw;
+        srcx = srcrect->x;
+        w = srcrect->w;
+        if (srcx < 0) {
+            w += srcx;
+            dstrect->x -= srcx;
+            srcx = 0;
+        }
+        maxw = src->w - srcx;
+        if (maxw < w)
+            w = maxw;
 
-		srcy = srcrect->y;
-		h = srcrect->h;
-		if(srcy < 0) {
-		        h += srcy;
-			dstrect->y -= srcy;
-			srcy = 0;
-		}
-		maxh = src->h - srcy;
-		if(maxh < h)
-			h = maxh;
-	    
-	} else {
-	        srcx = srcy = 0;
-		w = src->w;
-		h = src->h;
-	}
+        srcy = srcrect->y;
+        h = srcrect->h;
+        if (srcy < 0) {
+            h += srcy;
+            dstrect->y -= srcy;
+            srcy = 0;
+        }
+        maxh = src->h - srcy;
+        if (maxh < h)
+            h = maxh;
 
-	/* clip the destination rectangle against the clip rectangle */
-	{
-	        SDL_Rect *clip = &dst->clip_rect;
-		int dx, dy;
+    } else {
+        srcx = srcy = 0;
+        w = src->w;
+        h = src->h;
+    }
+
+    /* clip the destination rectangle against the clip rectangle */
+    {
+        SDL_Rect *clip = &dst->clip_rect;
+        int dx, dy;
 
-		dx = clip->x - dstrect->x;
-		if(dx > 0) {
-			w -= dx;
-			dstrect->x += dx;
-			srcx += dx;
-		}
-		dx = dstrect->x + w - clip->x - clip->w;
-		if(dx > 0)
-			w -= dx;
+        dx = clip->x - dstrect->x;
+        if (dx > 0) {
+            w -= dx;
+            dstrect->x += dx;
+            srcx += dx;
+        }
+        dx = dstrect->x + w - clip->x - clip->w;
+        if (dx > 0)
+            w -= dx;
 
-		dy = clip->y - dstrect->y;
-		if(dy > 0) {
-			h -= dy;
-			dstrect->y += dy;
-			srcy += dy;
-		}
-		dy = dstrect->y + h - clip->y - clip->h;
-		if(dy > 0)
-			h -= dy;
-	}
+        dy = clip->y - dstrect->y;
+        if (dy > 0) {
+            h -= dy;
+            dstrect->y += dy;
+            srcy += dy;
+        }
+        dy = dstrect->y + h - clip->y - clip->h;
+        if (dy > 0)
+            h -= dy;
+    }
 
-	if(w > 0 && h > 0) {
-	        SDL_Rect sr;
-	        sr.x = srcx;
-		sr.y = srcy;
-		sr.w = dstrect->w = w;
-		sr.h = dstrect->h = h;
-		return SDL_LowerBlit(src, &sr, dst, dstrect);
-	}
-	dstrect->w = dstrect->h = 0;
-	return 0;
+    if (w > 0 && h > 0) {
+        SDL_Rect sr;
+        sr.x = srcx;
+        sr.y = srcy;
+        sr.w = dstrect->w = w;
+        sr.h = dstrect->h = h;
+        return SDL_LowerBlit (src, &sr, dst, dstrect);
+    }
+    dstrect->w = dstrect->h = 0;
+    return 0;
 }
 
-static int SDL_FillRect1(SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color)
+static int
+SDL_FillRect1 (SDL_Surface * dst, SDL_Rect * dstrect, Uint32 color)
 {
-	/* FIXME: We have to worry about packing order.. *sigh* */
-	SDL_SetError("1-bpp rect fill not yet implemented");
-	return -1;
+    /* FIXME: We have to worry about packing order.. *sigh* */
+    SDL_SetError ("1-bpp rect fill not yet implemented");
+    return -1;
 }
 
-static int SDL_FillRect4(SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color)
+static int
+SDL_FillRect4 (SDL_Surface * dst, SDL_Rect * dstrect, Uint32 color)
 {
-	/* FIXME: We have to worry about packing order.. *sigh* */
-	SDL_SetError("4-bpp rect fill not yet implemented");
-	return -1;
+    /* FIXME: We have to worry about packing order.. *sigh* */
+    SDL_SetError ("4-bpp rect fill not yet implemented");
+    return -1;
 }
 
 /* 
  * This function performs a fast fill of the given rectangle with 'color'
  */
-int SDL_FillRect(SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color)
+int
+SDL_FillRect (SDL_Surface * dst, SDL_Rect * dstrect, Uint32 color)
 {
-	SDL_VideoDevice *video = current_video;
-	SDL_VideoDevice *this  = current_video;
-	int x, y;
-	Uint8 *row;
+    SDL_VideoDevice *_this = SDL_GetVideoDevice ();
+    int x, y;
+    Uint8 *row;
 
-	/* This function doesn't work on surfaces < 8 bpp */
-	if ( dst->format->BitsPerPixel < 8 ) {
-		switch(dst->format->BitsPerPixel) {
-		    case 1:
-			return SDL_FillRect1(dst, dstrect, color);
-			break;
-		    case 4:
-			return SDL_FillRect4(dst, dstrect, color);
-			break;
-		    default:
-			SDL_SetError("Fill rect on unsupported surface format");
-			return(-1);
-			break;
-		}
-	}
+    /* This function doesn't work on surfaces < 8 bpp */
+    if (dst->format->BitsPerPixel < 8) {
+        switch (dst->format->BitsPerPixel) {
+        case 1:
+            return SDL_FillRect1 (dst, dstrect, color);
+            break;
+        case 4:
+            return SDL_FillRect4 (dst, dstrect, color);
+            break;
+        default:
+            SDL_SetError ("Fill rect on unsupported surface format");
+            return (-1);
+            break;
+        }
+    }
 
-	/* If 'dstrect' == NULL, then fill the whole surface */
-	if ( dstrect ) {
-		/* Perform clipping */
-		if ( !SDL_IntersectRect(dstrect, &dst->clip_rect, dstrect) ) {
-			return(0);
-		}
-	} else {
-		dstrect = &dst->clip_rect;
-	}
+    /* If 'dstrect' == NULL, then fill the whole surface */
+    if (dstrect) {
+        /* Perform clipping */
+        if (!SDL_IntersectRect (dstrect, &dst->clip_rect, dstrect)) {
+            return (0);
+        }
+    } else {
+        dstrect = &dst->clip_rect;
+    }
+
+    /* Check for hardware acceleration */
+    if (((dst->flags & SDL_HWSURFACE) == SDL_HWSURFACE) &&
+        _this->info.blit_fill) {
+        return (_this->FillHWRect (_this, dst, dstrect, color));
+    }
 
-	/* Check for hardware acceleration */
-	if ( ((dst->flags & SDL_HWSURFACE) == SDL_HWSURFACE) &&
-					video->info.blit_fill ) {
-		SDL_Rect hw_rect;
-		if ( dst == SDL_VideoSurface ) {
-			hw_rect = *dstrect;
-			hw_rect.x += current_video->offset_x;
-			hw_rect.y += current_video->offset_y;
-			dstrect = &hw_rect;
-		}
-		return(video->FillHWRect(this, dst, dstrect, color));
-	}
-
-	/* Perform software fill */
-	if ( SDL_LockSurface(dst) != 0 ) {
-		return(-1);
-	}
-	row = (Uint8 *)dst->pixels+dstrect->y*dst->pitch+
-			dstrect->x*dst->format->BytesPerPixel;
-	if ( dst->format->palette || (color == 0) ) {
-		x = dstrect->w*dst->format->BytesPerPixel;
-		if ( !color && !((uintptr_t)row&3) && !(x&3) && !(dst->pitch&3) ) {
-			int n = x >> 2;
-			for ( y=dstrect->h; y; --y ) {
-				SDL_memset4(row, 0, n);
-				row += dst->pitch;
-			}
-		} else {
+    /* Perform software fill */
+    if (SDL_LockSurface (dst) != 0) {
+        return (-1);
+    }
+    row = (Uint8 *) dst->pixels + dstrect->y * dst->pitch +
+        dstrect->x * dst->format->BytesPerPixel;
+    if (dst->format->palette || (color == 0)) {
+        x = dstrect->w * dst->format->BytesPerPixel;
+        if (!color && !((uintptr_t) row & 3) && !(x & 3)
+            && !(dst->pitch & 3)) {
+            int n = x >> 2;
+            for (y = dstrect->h; y; --y) {
+                SDL_memset4 (row, 0, n);
+                row += dst->pitch;
+            }
+        } else {
 #ifdef __powerpc__
-			/*
-			 * SDL_memset() on PPC (both glibc and codewarrior) uses
-			 * the dcbz (Data Cache Block Zero) instruction, which
-			 * causes an alignment exception if the destination is
-			 * uncachable, so only use it on software surfaces
-			 */
-			if((dst->flags & SDL_HWSURFACE) == SDL_HWSURFACE) {
-				if(dstrect->w >= 8) {
-					/*
-					 * 64-bit stores are probably most
-					 * efficient to uncached video memory
-					 */
-					double fill;
-					SDL_memset(&fill, color, (sizeof fill));
-					for(y = dstrect->h; y; y--) {
-						Uint8 *d = row;
-						unsigned n = x;
-						unsigned nn;
-						Uint8 c = color;
-						double f = fill;
-						while((unsigned long)d
-						      & (sizeof(double) - 1)) {
-							*d++ = c;
-							n--;
-						}
-						nn = n / (sizeof(double) * 4);
-						while(nn) {
-							((double *)d)[0] = f;
-							((double *)d)[1] = f;
-							((double *)d)[2] = f;
-							((double *)d)[3] = f;
-							d += 4*sizeof(double);
-							nn--;
-						}
-						n &= ~(sizeof(double) * 4 - 1);
-						nn = n / sizeof(double);
-						while(nn) {
-							*(double *)d = f;
-							d += sizeof(double);
-							nn--;
-						}
-						n &= ~(sizeof(double) - 1);
-						while(n) {
-							*d++ = c;
-							n--;
-						}
-						row += dst->pitch;
-					}
-				} else {
-					/* narrow boxes */
-					for(y = dstrect->h; y; y--) {
-						Uint8 *d = row;
-						Uint8 c = color;
-						int n = x;
-						while(n) {
-							*d++ = c;
-							n--;
-						}
-						row += dst->pitch;
-					}
-				}
-			} else
+            /*
+             * SDL_memset() on PPC (both glibc and codewarrior) uses
+             * the dcbz (Data Cache Block Zero) instruction, which
+             * causes an alignment exception if the destination is
+             * uncachable, so only use it on software surfaces
+             */
+            if ((dst->flags & SDL_HWSURFACE) == SDL_HWSURFACE) {
+                if (dstrect->w >= 8) {
+                    /*
+                     * 64-bit stores are probably most
+                     * efficient to uncached video memory
+                     */
+                    double fill;
+                    SDL_memset (&fill, color, (sizeof fill));
+                    for (y = dstrect->h; y; y--) {
+                        Uint8 *d = row;
+                        unsigned n = x;
+                        unsigned nn;
+                        Uint8 c = color;
+                        double f = fill;
+                        while ((unsigned long) d & (sizeof (double) - 1)) {
+                            *d++ = c;
+                            n--;
+                        }
+                        nn = n / (sizeof (double) * 4);
+                        while (nn) {
+                            ((double *) d)[0] = f;
+                            ((double *) d)[1] = f;
+                            ((double *) d)[2] = f;
+                            ((double *) d)[3] = f;
+                            d += 4 * sizeof (double);
+                            nn--;
+                        }
+                        n &= ~(sizeof (double) * 4 - 1);
+                        nn = n / sizeof (double);
+                        while (nn) {
+                            *(double *) d = f;
+                            d += sizeof (double);
+                            nn--;
+                        }
+                        n &= ~(sizeof (double) - 1);
+                        while (n) {
+                            *d++ = c;
+                            n--;
+                        }
+                        row += dst->pitch;
+                    }
+                } else {
+                    /* narrow boxes */
+                    for (y = dstrect->h; y; y--) {
+                        Uint8 *d = row;
+                        Uint8 c = color;
+                        int n = x;
+                        while (n) {
+                            *d++ = c;
+                            n--;
+                        }
+                        row += dst->pitch;
+                    }
+                }
+            } else
 #endif /* __powerpc__ */
-			{
-				for(y = dstrect->h; y; y--) {
-					SDL_memset(row, color, x);
-					row += dst->pitch;
-				}
-			}
-		}
-	} else {
-		switch (dst->format->BytesPerPixel) {
-		    case 2:
-			for ( y=dstrect->h; y; --y ) {
-				Uint16 *pixels = (Uint16 *)row;
-				Uint16 c = (Uint16)color;
-				Uint32 cc = (Uint32)c << 16 | c;
-				int n = dstrect->w;
-				if((uintptr_t)pixels & 3) {
-					*pixels++ = c;
-					n--;
-				}
-				if(n >> 1)
-					SDL_memset4(pixels, cc, n >> 1);
-				if(n & 1)
-					pixels[n - 1] = c;
-				row += dst->pitch;
-			}
-			break;
+            {
+                for (y = dstrect->h; y; y--) {
+                    SDL_memset (row, color, x);
+                    row += dst->pitch;
+                }
+            }
+        }
+    } else {
+        switch (dst->format->BytesPerPixel) {
+        case 2:
+            for (y = dstrect->h; y; --y) {
+                Uint16 *pixels = (Uint16 *) row;
+                Uint16 c = (Uint16) color;
+                Uint32 cc = (Uint32) c << 16 | c;
+                int n = dstrect->w;
+                if ((uintptr_t) pixels & 3) {
+                    *pixels++ = c;
+                    n--;
+                }
+                if (n >> 1)
+                    SDL_memset4 (pixels, cc, n >> 1);
+                if (n & 1)
+                    pixels[n - 1] = c;
+                row += dst->pitch;
+            }
+            break;
 
-		    case 3:
-			#if SDL_BYTEORDER == SDL_BIG_ENDIAN
-				color <<= 8;
-			#endif
-			for ( y=dstrect->h; y; --y ) {
-				Uint8 *pixels = row;
-				for ( x=dstrect->w; x; --x ) {
-					SDL_memcpy(pixels, &color, 3);
-					pixels += 3;
-				}
-				row += dst->pitch;
-			}
-			break;
+        case 3:
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+            color <<= 8;
+#endif
+            for (y = dstrect->h; y; --y) {
+                Uint8 *pixels = row;
+                for (x = dstrect->w; x; --x) {
+                    SDL_memcpy (pixels, &color, 3);
+                    pixels += 3;
+                }
+                row += dst->pitch;
+            }
+            break;
 
-		    case 4:
-			for(y = dstrect->h; y; --y) {
-				SDL_memset4(row, color, dstrect->w);
-				row += dst->pitch;
-			}
-			break;
-		}
-	}
-	SDL_UnlockSurface(dst);
+        case 4:
+            for (y = dstrect->h; y; --y) {
+                SDL_memset4 (row, color, dstrect->w);
+                row += dst->pitch;
+            }
+            break;
+        }
+    }
+    SDL_UnlockSurface (dst);
 
-	/* We're done! */
-	return(0);
+    /* We're done! */
+    return (0);
 }
 
 /*
  * Lock a surface to directly access the pixels
  */
-int SDL_LockSurface (SDL_Surface *surface)
+int
+SDL_LockSurface (SDL_Surface * surface)
 {
-	if ( ! surface->locked ) {
-		/* Perform the lock */
-		if ( surface->flags & (SDL_HWSURFACE|SDL_ASYNCBLIT) ) {
-			SDL_VideoDevice *video = current_video;
-			SDL_VideoDevice *this  = current_video;
-			if ( video->LockHWSurface(this, surface) < 0 ) {
-				return(-1);
-			}
-		}
-		if ( surface->flags & SDL_RLEACCEL ) {
-			SDL_UnRLESurface(surface, 1);
-			surface->flags |= SDL_RLEACCEL;	/* save accel'd state */
-		}
-		/* This needs to be done here in case pixels changes value */
-		surface->pixels = (Uint8 *)surface->pixels + surface->offset;
-	}
+    if (!surface->locked) {
+        /* Perform the lock */
+        if (surface->flags & SDL_HWSURFACE) {
+            SDL_VideoDevice *_this = SDL_GetVideoDevice ();
+            if (_this->LockHWSurface (_this, surface) < 0) {
+                return (-1);
+            }
+        }
+        if (surface->flags & SDL_RLEACCEL) {
+            SDL_UnRLESurface (surface, 1);
+            surface->flags |= SDL_RLEACCEL;     /* save accel'd state */
+        }
+        /* This needs to be done here in case pixels changes value */
+        surface->pixels = (Uint8 *) surface->pixels + surface->offset;
+    }
 
-	/* Increment the surface lock count, for recursive locks */
-	++surface->locked;
+    /* Increment the surface lock count, for recursive locks */
+    ++surface->locked;
 
-	/* Ready to go.. */
-	return(0);
+    /* Ready to go.. */
+    return (0);
 }
+
 /*
  * Unlock a previously locked surface
  */
-void SDL_UnlockSurface (SDL_Surface *surface)
+void
+SDL_UnlockSurface (SDL_Surface * surface)
 {
-	/* Only perform an unlock if we are locked */
-	if ( ! surface->locked || (--surface->locked > 0) ) {
-		return;
-	}
+    /* Only perform an unlock if we are locked */
+    if (!surface->locked || (--surface->locked > 0)) {
+        return;
+    }
 
-	/* Perform the unlock */
-	surface->pixels = (Uint8 *)surface->pixels - surface->offset;
+    /* Perform the unlock */
+    surface->pixels = (Uint8 *) surface->pixels - surface->offset;
 
-	/* Unlock hardware or accelerated surfaces */
-	if ( surface->flags & (SDL_HWSURFACE|SDL_ASYNCBLIT) ) {
-		SDL_VideoDevice *video = current_video;
-		SDL_VideoDevice *this  = current_video;
-		video->UnlockHWSurface(this, surface);
-	} else {
-		/* Update RLE encoded surface with new data */
-		if ( (surface->flags & SDL_RLEACCEL) == SDL_RLEACCEL ) {
-		        surface->flags &= ~SDL_RLEACCEL; /* stop lying */
-			SDL_RLESurface(surface);
-		}
-	}
+    /* Unlock hardware or accelerated surfaces */
+    if (surface->flags & SDL_HWSURFACE) {
+        SDL_VideoDevice *_this = SDL_GetVideoDevice ();
+        _this->UnlockHWSurface (_this, surface);
+    } else {
+        /* Update RLE encoded surface with new data */
+        if ((surface->flags & SDL_RLEACCEL) == SDL_RLEACCEL) {
+            surface->flags &= ~SDL_RLEACCEL;    /* stop lying */
+            SDL_RLESurface (surface);
+        }
+    }
 }
 
 /* 
  * Convert a surface into the specified pixel format.
  */
-SDL_Surface * SDL_ConvertSurface (SDL_Surface *surface,
-					SDL_PixelFormat *format, Uint32 flags)
+SDL_Surface *
+SDL_ConvertSurface (SDL_Surface * surface,
+                    SDL_PixelFormat * format, Uint32 flags)
 {
-	SDL_Surface *convert;
-	Uint32 colorkey = 0;
-	Uint8 alpha = 0;
-	Uint32 surface_flags;
-	SDL_Rect bounds;
+    SDL_Surface *convert;
+    Uint32 colorkey = 0;
+    Uint8 alpha = 0;
+    Uint32 surface_flags;
+    SDL_Rect bounds;
 
-	/* Check for empty destination palette! (results in empty image) */
-	if ( format->palette != NULL ) {
-		int i;
-		for ( i=0; i<format->palette->ncolors; ++i ) {
-			if ( (format->palette->colors[i].r != 0) ||
-			     (format->palette->colors[i].g != 0) ||
-			     (format->palette->colors[i].b != 0) )
-				break;
-		}
-		if ( i == format->palette->ncolors ) {
-			SDL_SetError("Empty destination palette");
-			return(NULL);
-		}
-	}
+    /* Check for empty destination palette! (results in empty image) */
+    if (format->palette != NULL) {
+        int i;
+        for (i = 0; i < format->palette->ncolors; ++i) {
+            if ((format->palette->colors[i].r != 0) ||
+                (format->palette->colors[i].g != 0) ||
+                (format->palette->colors[i].b != 0))
+                break;
+        }
+        if (i == format->palette->ncolors) {
+            SDL_SetError ("Empty destination palette");
+            return (NULL);
+        }
+    }
 
-	/* Only create hw surfaces with alpha channel if hw alpha blits
-	   are supported */
-	if(format->Amask != 0 && (flags & SDL_HWSURFACE)) {
-		const SDL_VideoInfo *vi = SDL_GetVideoInfo();
-		if(!vi || !vi->blit_hw_A)
-			flags &= ~SDL_HWSURFACE;
-	}
+    /* Only create hw surfaces with alpha channel if hw alpha blits
+       are supported */
+    if (format->Amask != 0 && (flags & SDL_HWSURFACE)) {
+        const SDL_VideoInfo *vi = SDL_GetVideoInfo ();
+        if (!vi || !vi->blit_hw_A)
+            flags &= ~SDL_HWSURFACE;
+    }
 
-	/* Create a new surface with the desired format */
-	convert = SDL_CreateRGBSurface(flags,
-				surface->w, surface->h, format->BitsPerPixel,
-		format->Rmask, format->Gmask, format->Bmask, format->Amask);
-	if ( convert == NULL ) {
-		return(NULL);
-	}
+    /* Create a new surface with the desired format */
+    convert = SDL_CreateRGBSurface (flags,
+                                    surface->w, surface->h,
+                                    format->BitsPerPixel, format->Rmask,
+                                    format->Gmask, format->Bmask,
+                                    format->Amask);
+    if (convert == NULL) {
+        return (NULL);
+    }
 
-	/* Copy the palette if any */
-	if ( format->palette && convert->format->palette ) {
-		SDL_memcpy(convert->format->palette->colors,
-				format->palette->colors,
-				format->palette->ncolors*sizeof(SDL_Color));
-		convert->format->palette->ncolors = format->palette->ncolors;
-	}
+    /* Copy the palette if any */
+    if (format->palette && convert->format->palette) {
+        SDL_memcpy (convert->format->palette->colors,
+                    format->palette->colors,
+                    format->palette->ncolors * sizeof (SDL_Color));
+        convert->format->palette->ncolors = format->palette->ncolors;
+    }
 
-	/* Save the original surface color key and alpha */
-	surface_flags = surface->flags;
-	if ( (surface_flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) {
-		/* Convert colourkeyed surfaces to RGBA if requested */
-		if((flags & SDL_SRCCOLORKEY) != SDL_SRCCOLORKEY
-		   && format->Amask) {
-			surface_flags &= ~SDL_SRCCOLORKEY;
-		} else {
-			colorkey = surface->format->colorkey;
-			SDL_SetColorKey(surface, 0, 0);
-		}
-	}
-	if ( (surface_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
-		/* Copy over the alpha channel to RGBA if requested */
-		if ( format->Amask ) {
-			surface->flags &= ~SDL_SRCALPHA;
-		} else {
-			alpha = surface->format->alpha;
-			SDL_SetAlpha(surface, 0, 0);
-		}
-	}
+    /* Save the original surface color key and alpha */
+    surface_flags = surface->flags;
+    if ((surface_flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {
+        /* Convert colourkeyed surfaces to RGBA if requested */
+        if ((flags & SDL_SRCCOLORKEY) != SDL_SRCCOLORKEY && format->Amask) {
+            surface_flags &= ~SDL_SRCCOLORKEY;
+        } else {
+            colorkey = surface->format->colorkey;
+            SDL_SetColorKey (surface, 0, 0);
+        }
+    }
+    if ((surface_flags & SDL_SRCALPHA) == SDL_SRCALPHA) {
+        /* Copy over the alpha channel to RGBA if requested */
+        if (format->Amask) {
+            surface->flags &= ~SDL_SRCALPHA;
+        } else {
+            alpha = surface->format->alpha;
+            SDL_SetAlpha (surface, 0, 0);
+        }
+    }
 
-	/* Copy over the image data */
-	bounds.x = 0;
-	bounds.y = 0;
-	bounds.w = surface->w;
-	bounds.h = surface->h;
-	SDL_LowerBlit(surface, &bounds, convert, &bounds);
+    /* Copy over the image data */
+    bounds.x = 0;
+    bounds.y = 0;
+    bounds.w = surface->w;
+    bounds.h = surface->h;
+    SDL_LowerBlit (surface, &bounds, convert, &bounds);
 
-	/* Clean up the original surface, and update converted surface */
-	if ( convert != NULL ) {
-		SDL_SetClipRect(convert, &surface->clip_rect);
-	}
-	if ( (surface_flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) {
-		Uint32 cflags = surface_flags&(SDL_SRCCOLORKEY|SDL_RLEACCELOK);
-		if ( convert != NULL ) {
-			Uint8 keyR, keyG, keyB;
+    /* Clean up the original surface, and update converted surface */
+    if (convert != NULL) {
+        SDL_SetClipRect (convert, &surface->clip_rect);
+    }
+    if ((surface_flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {
+        Uint32 cflags = surface_flags & (SDL_SRCCOLORKEY | SDL_RLEACCELOK);
+        if (convert != NULL) {
+            Uint8 keyR, keyG, keyB;
 
-			SDL_GetRGB(colorkey,surface->format,&keyR,&keyG,&keyB);
-			SDL_SetColorKey(convert, cflags|(flags&SDL_RLEACCELOK),
-				SDL_MapRGB(convert->format, keyR, keyG, keyB));
-		}
-		SDL_SetColorKey(surface, cflags, colorkey);
-	}
-	if ( (surface_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
-		Uint32 aflags = surface_flags&(SDL_SRCALPHA|SDL_RLEACCELOK);
-		if ( convert != NULL ) {
-		        SDL_SetAlpha(convert, aflags|(flags&SDL_RLEACCELOK),
-				alpha);
-		}
-		if ( format->Amask ) {
-			surface->flags |= SDL_SRCALPHA;
-		} else {
-			SDL_SetAlpha(surface, aflags, alpha);
-		}
-	}
+            SDL_GetRGB (colorkey, surface->format, &keyR, &keyG, &keyB);
+            SDL_SetColorKey (convert, cflags | (flags & SDL_RLEACCELOK),
+                             SDL_MapRGB (convert->format, keyR, keyG, keyB));
+        }
+        SDL_SetColorKey (surface, cflags, colorkey);
+    }
+    if ((surface_flags & SDL_SRCALPHA) == SDL_SRCALPHA) {
+        Uint32 aflags = surface_flags & (SDL_SRCALPHA | SDL_RLEACCELOK);
+        if (convert != NULL) {
+            SDL_SetAlpha (convert, aflags | (flags & SDL_RLEACCELOK), alpha);
+        }
+        if (format->Amask) {
+            surface->flags |= SDL_SRCALPHA;
+        } else {
+            SDL_SetAlpha (surface, aflags, alpha);
+        }
+    }
 
-	/* We're ready to go! */
-	return(convert);
+    /* We're ready to go! */
+    return (convert);
 }
 
 /*
  * Free a surface created by the above function.
  */
-void SDL_FreeSurface (SDL_Surface *surface)
+void
+SDL_FreeSurface (SDL_Surface * surface)
 {
-	/* Free anything that's not NULL, and not the screen surface */
-	if ((surface == NULL) ||
-	    (current_video &&
-	    ((surface == SDL_ShadowSurface)||(surface == SDL_VideoSurface)))) {
-		return;
-	}
-	if ( --surface->refcount > 0 ) {
-		return;
-	}
-	while ( surface->locked > 0 ) {
-		SDL_UnlockSurface(surface);
-	}
-	if ( (surface->flags & SDL_RLEACCEL) == SDL_RLEACCEL ) {
-	        SDL_UnRLESurface(surface, 0);
-	}
-	if ( surface->format ) {
-		SDL_FreeFormat(surface->format);
-		surface->format = NULL;
-	}
-	if ( surface->map != NULL ) {
-		SDL_FreeBlitMap(surface->map);
-		surface->map = NULL;
-	}
-	if ( surface->hwdata ) {
-		SDL_VideoDevice *video = current_video;
-		SDL_VideoDevice *this  = current_video;
-		video->FreeHWSurface(this, surface);
-	}
-	if ( surface->pixels &&
-	     ((surface->flags & SDL_PREALLOC) != SDL_PREALLOC) ) {
-		SDL_free(surface->pixels);
-	}
-	SDL_free(surface);
+    SDL_VideoDevice *_this = SDL_GetVideoDevice ();
+
+    /* Free anything that's not NULL, and not the screen surface */
+    if ((surface == NULL) ||
+        (_this &&
+         ((surface == SDL_ShadowSurface) || (surface == SDL_VideoSurface)))) {
+        return;
+    }
+    if (--surface->refcount > 0) {
+        return;
+    }
+    while (surface->locked > 0) {
+        SDL_UnlockSurface (surface);
+    }
+    if ((surface->flags & SDL_RLEACCEL) == SDL_RLEACCEL) {
+        SDL_UnRLESurface (surface, 0);
+    }
+    if (surface->format) {
+        SDL_FreeFormat (surface->format);
+        surface->format = NULL;
+    }
+    if (surface->map != NULL) {
+        SDL_FreeBlitMap (surface->map);
+        surface->map = NULL;
+    }
+    if (surface->hwdata) {
+        SDL_VideoDevice *_this = SDL_GetVideoDevice ();
+        _this->FreeHWSurface (_this, surface);
+    }
+    if (surface->pixels && ((surface->flags & SDL_PREALLOC) != SDL_PREALLOC)) {
+        SDL_free (surface->pixels);
+    }
+    SDL_free (surface);
 #ifdef CHECK_LEAKS
-	--surfaces_allocated;
+    --surfaces_allocated;
 #endif
 }
+
+/* vi: set ts=4 sw=4 expandtab: */