diff src/video/SDL_blit_A.c @ 1895:c121d94672cb

SDL 1.2 is moving to a branch, and SDL 1.3 is becoming the head.
author Sam Lantinga <slouken@libsdl.org>
date Mon, 10 Jul 2006 21:04:37 +0000
parents 398ac0f88e4d
children eb5aedc79992
line wrap: on
line diff
--- a/src/video/SDL_blit_A.c	Thu Jul 06 18:01:37 2006 +0000
+++ b/src/video/SDL_blit_A.c	Mon Jul 10 21:04:37 2006 +0000
@@ -46,22 +46,24 @@
 /* Functions to perform alpha blended blitting */
 
 /* N->1 blending with per-surface alpha */
-static void BlitNto1SurfaceAlpha(SDL_BlitInfo *info)
+static void
+BlitNto1SurfaceAlpha(SDL_BlitInfo * info)
 {
-	int width = info->d_width;
-	int height = info->d_height;
-	Uint8 *src = info->s_pixels;
-	int srcskip = info->s_skip;
-	Uint8 *dst = info->d_pixels;
-	int dstskip = info->d_skip;
-	Uint8 *palmap = info->table;
-	SDL_PixelFormat *srcfmt = info->src;
-	SDL_PixelFormat *dstfmt = info->dst;
-	int srcbpp = srcfmt->BytesPerPixel;
+    int width = info->d_width;
+    int height = info->d_height;
+    Uint8 *src = info->s_pixels;
+    int srcskip = info->s_skip;
+    Uint8 *dst = info->d_pixels;
+    int dstskip = info->d_skip;
+    Uint8 *palmap = info->table;
+    SDL_PixelFormat *srcfmt = info->src;
+    SDL_PixelFormat *dstfmt = info->dst;
+    int srcbpp = srcfmt->BytesPerPixel;
 
-	const unsigned A = srcfmt->alpha;
+    const unsigned A = srcfmt->alpha;
 
-	while ( height-- ) {
+    while (height--) {
+	    /* *INDENT-OFF* */
 	    DUFFS_LOOP4(
 	    {
 		Uint32 Pixel;
@@ -93,27 +95,30 @@
 		src += srcbpp;
 	    },
 	    width);
-	    src += srcskip;
-	    dst += dstskip;
-	}
+	    /* *INDENT-ON* */
+        src += srcskip;
+        dst += dstskip;
+    }
 }
 
 /* N->1 blending with pixel alpha */
-static void BlitNto1PixelAlpha(SDL_BlitInfo *info)
+static void
+BlitNto1PixelAlpha(SDL_BlitInfo * info)
 {
-	int width = info->d_width;
-	int height = info->d_height;
-	Uint8 *src = info->s_pixels;
-	int srcskip = info->s_skip;
-	Uint8 *dst = info->d_pixels;
-	int dstskip = info->d_skip;
-	Uint8 *palmap = info->table;
-	SDL_PixelFormat *srcfmt = info->src;
-	SDL_PixelFormat *dstfmt = info->dst;
-	int srcbpp = srcfmt->BytesPerPixel;
+    int width = info->d_width;
+    int height = info->d_height;
+    Uint8 *src = info->s_pixels;
+    int srcskip = info->s_skip;
+    Uint8 *dst = info->d_pixels;
+    int dstskip = info->d_skip;
+    Uint8 *palmap = info->table;
+    SDL_PixelFormat *srcfmt = info->src;
+    SDL_PixelFormat *dstfmt = info->dst;
+    int srcbpp = srcfmt->BytesPerPixel;
 
-	/* FIXME: fix alpha bit field expansion here too? */
-	while ( height-- ) {
+    /* FIXME: fix alpha bit field expansion here too? */
+    while (height--) {
+	    /* *INDENT-OFF* */
 	    DUFFS_LOOP4(
 	    {
 		Uint32 Pixel;
@@ -146,29 +151,32 @@
 		src += srcbpp;
 	    },
 	    width);
-	    src += srcskip;
-	    dst += dstskip;
-	}
+	    /* *INDENT-ON* */
+        src += srcskip;
+        dst += dstskip;
+    }
 }
 
 /* colorkeyed N->1 blending with per-surface alpha */
-static void BlitNto1SurfaceAlphaKey(SDL_BlitInfo *info)
+static void
+BlitNto1SurfaceAlphaKey(SDL_BlitInfo * info)
 {
-	int width = info->d_width;
-	int height = info->d_height;
-	Uint8 *src = info->s_pixels;
-	int srcskip = info->s_skip;
-	Uint8 *dst = info->d_pixels;
-	int dstskip = info->d_skip;
-	Uint8 *palmap = info->table;
-	SDL_PixelFormat *srcfmt = info->src;
-	SDL_PixelFormat *dstfmt = info->dst;
-	int srcbpp = srcfmt->BytesPerPixel;
-	Uint32 ckey = srcfmt->colorkey;
+    int width = info->d_width;
+    int height = info->d_height;
+    Uint8 *src = info->s_pixels;
+    int srcskip = info->s_skip;
+    Uint8 *dst = info->d_pixels;
+    int dstskip = info->d_skip;
+    Uint8 *palmap = info->table;
+    SDL_PixelFormat *srcfmt = info->src;
+    SDL_PixelFormat *dstfmt = info->dst;
+    int srcbpp = srcfmt->BytesPerPixel;
+    Uint32 ckey = srcfmt->colorkey;
 
-	const int A = srcfmt->alpha;
+    const int A = srcfmt->alpha;
 
-	while ( height-- ) {
+    while (height--) {
+	    /* *INDENT-OFF* */
 	    DUFFS_LOOP(
 	    {
 		Uint32 Pixel;
@@ -202,31 +210,34 @@
 		src += srcbpp;
 	    },
 	    width);
-	    src += srcskip;
-	    dst += dstskip;
-	}
+	    /* *INDENT-ON* */
+        src += srcskip;
+        dst += dstskip;
+    }
 }
 
 #if GCC_ASMBLIT
 /* fast RGB888->(A)RGB888 blending with surface alpha=128 special case */
-static void BlitRGBtoRGBSurfaceAlpha128MMX(SDL_BlitInfo *info)
+static void
+BlitRGBtoRGBSurfaceAlpha128MMX(SDL_BlitInfo * info)
 {
-	int width = info->d_width;
-	int height = info->d_height;
-	Uint32 *srcp = (Uint32 *)info->s_pixels;
-	int srcskip = info->s_skip >> 2;
-	Uint32 *dstp = (Uint32 *)info->d_pixels;
-	int dstskip = info->d_skip >> 2;
-	Uint32 dalpha = info->dst->Amask;
-	Uint8 load[8];
+    int width = info->d_width;
+    int height = info->d_height;
+    Uint32 *srcp = (Uint32 *) info->s_pixels;
+    int srcskip = info->s_skip >> 2;
+    Uint32 *dstp = (Uint32 *) info->d_pixels;
+    int dstskip = info->d_skip >> 2;
+    Uint32 dalpha = info->dst->Amask;
+    Uint8 load[8];
 
-	*(Uint64 *)load = 0x00fefefe00fefefeULL;/* alpha128 mask */
-	movq_m2r(*load, mm4); /* alpha128 mask -> mm4 */
-	*(Uint64 *)load = 0x0001010100010101ULL;/* !alpha128 mask */
-	movq_m2r(*load, mm3); /* !alpha128 mask -> mm3 */
-	movd_m2r(dalpha, mm7); /* dst alpha mask */
-	punpckldq_r2r(mm7, mm7); /* dst alpha mask | dst alpha mask -> mm7 */
-	while(height--) {
+    *(Uint64 *) load = 0x00fefefe00fefefeULL;   /* alpha128 mask */
+    movq_m2r(*load, mm4);       /* alpha128 mask -> mm4 */
+    *(Uint64 *) load = 0x0001010100010101ULL;   /* !alpha128 mask */
+    movq_m2r(*load, mm3);       /* !alpha128 mask -> mm3 */
+    movd_m2r(dalpha, mm7);      /* dst alpha mask */
+    punpckldq_r2r(mm7, mm7);    /* dst alpha mask | dst alpha mask -> mm7 */
+    while (height--) {
+		/* *INDENT-OFF* */
 		DUFFS_LOOP_DOUBLE2(
 		{
 			Uint32 s = *srcp++;
@@ -253,43 +264,48 @@
 			dstp += 2;
 			srcp += 2;
 		}, width);
-		srcp += srcskip;
-		dstp += dstskip;
-	}
-	emms();
+		/* *INDENT-ON* */
+        srcp += srcskip;
+        dstp += dstskip;
+    }
+    emms();
 }
 
 /* fast RGB888->(A)RGB888 blending with surface alpha */
-static void BlitRGBtoRGBSurfaceAlphaMMX(SDL_BlitInfo *info)
+static void
+BlitRGBtoRGBSurfaceAlphaMMX(SDL_BlitInfo * info)
 {
-	SDL_PixelFormat* df = info->dst;
-	unsigned alpha = info->src->alpha;
+    SDL_PixelFormat *df = info->dst;
+    unsigned alpha = info->src->alpha;
+
+    if (alpha == 128 && (df->Rmask | df->Gmask | df->Bmask) == 0x00FFFFFF) {
+        /* only call a128 version when R,G,B occupy lower bits */
+        BlitRGBtoRGBSurfaceAlpha128MMX(info);
+    } else {
+        int width = info->d_width;
+        int height = info->d_height;
+        Uint32 *srcp = (Uint32 *) info->s_pixels;
+        int srcskip = info->s_skip >> 2;
+        Uint32 *dstp = (Uint32 *) info->d_pixels;
+        int dstskip = info->d_skip >> 2;
 
-	if (alpha == 128 && (df->Rmask | df->Gmask | df->Bmask) == 0x00FFFFFF) {
-			/* only call a128 version when R,G,B occupy lower bits */
-		BlitRGBtoRGBSurfaceAlpha128MMX(info);
-	} else {
-		int width = info->d_width;
-		int height = info->d_height;
-		Uint32 *srcp = (Uint32 *)info->s_pixels;
-		int srcskip = info->s_skip >> 2;
-		Uint32 *dstp = (Uint32 *)info->d_pixels;
-		int dstskip = info->d_skip >> 2;
+        pxor_r2r(mm5, mm5);     /* 0 -> mm5 */
+        /* form the alpha mult */
+        movd_m2r(alpha, mm4);   /* 0000000A -> mm4 */
+        punpcklwd_r2r(mm4, mm4);        /* 00000A0A -> mm4 */
+        punpckldq_r2r(mm4, mm4);        /* 0A0A0A0A -> mm4 */
+        alpha =
+            (0xff << df->Rshift) | (0xff << df->Gshift) | (0xff << df->
+                                                           Bshift);
+        movd_m2r(alpha, mm0);   /* 00000FFF -> mm0 */
+        punpcklbw_r2r(mm0, mm0);        /* 00FFFFFF -> mm0 */
+        pand_r2r(mm0, mm4);     /* 0A0A0A0A -> mm4, minus 1 chan */
+        /* at this point mm4 can be 000A0A0A or 0A0A0A00 or another combo */
+        movd_m2r(df->Amask, mm7);       /* dst alpha mask */
+        punpckldq_r2r(mm7, mm7);        /* dst alpha mask | dst alpha mask -> mm7 */
 
-		pxor_r2r(mm5, mm5); /* 0 -> mm5 */
-		/* form the alpha mult */
-		movd_m2r(alpha, mm4); /* 0000000A -> mm4 */
-		punpcklwd_r2r(mm4, mm4); /* 00000A0A -> mm4 */
-		punpckldq_r2r(mm4, mm4); /* 0A0A0A0A -> mm4 */
-		alpha = (0xff << df->Rshift) | (0xff << df->Gshift) | (0xff << df->Bshift);
-		movd_m2r(alpha, mm0); /* 00000FFF -> mm0 */
-		punpcklbw_r2r(mm0, mm0); /* 00FFFFFF -> mm0 */
-		pand_r2r(mm0, mm4); /* 0A0A0A0A -> mm4, minus 1 chan */
-			/* at this point mm4 can be 000A0A0A or 0A0A0A00 or another combo */
-		movd_m2r(df->Amask, mm7); /* dst alpha mask */
-		punpckldq_r2r(mm7, mm7); /* dst alpha mask | dst alpha mask -> mm7 */
-		
-		while(height--) {
+        while (height--) {
+			/* *INDENT-OFF* */
 			DUFFS_LOOP_DOUBLE2({
 				/* One Pixel Blend */
 				movd_m2r((*srcp), mm1);/* src(ARGB) -> mm1 (0000ARGB)*/
@@ -337,41 +353,44 @@
   				srcp += 2;
   				dstp += 2;
   			}, width);
-			srcp += srcskip;
-			dstp += dstskip;
-		}
-		emms();
-	}
+			/* *INDENT-ON* */
+            srcp += srcskip;
+            dstp += dstskip;
+        }
+        emms();
+    }
 }
 
 /* fast ARGB888->(A)RGB888 blending with pixel alpha */
-static void BlitRGBtoRGBPixelAlphaMMX(SDL_BlitInfo *info)
+static void
+BlitRGBtoRGBPixelAlphaMMX(SDL_BlitInfo * info)
 {
-	int width = info->d_width;
-	int height = info->d_height;
-	Uint32 *srcp = (Uint32 *)info->s_pixels;
-	int srcskip = info->s_skip >> 2;
-	Uint32 *dstp = (Uint32 *)info->d_pixels;
-	int dstskip = info->d_skip >> 2;
-	SDL_PixelFormat* sf = info->src;
-	Uint32 amask = sf->Amask;
+    int width = info->d_width;
+    int height = info->d_height;
+    Uint32 *srcp = (Uint32 *) info->s_pixels;
+    int srcskip = info->s_skip >> 2;
+    Uint32 *dstp = (Uint32 *) info->d_pixels;
+    int dstskip = info->d_skip >> 2;
+    SDL_PixelFormat *sf = info->src;
+    Uint32 amask = sf->Amask;
 
-	pxor_r2r(mm6, mm6); /* 0 -> mm6 */
-	/* form multiplication mask */
-	movd_m2r(sf->Amask, mm7); /* 0000F000 -> mm7 */
-	punpcklbw_r2r(mm7, mm7); /* FF000000 -> mm7 */
-	pcmpeqb_r2r(mm0, mm0); /* FFFFFFFF -> mm0 */
-	movq_r2r(mm0, mm3); /* FFFFFFFF -> mm3 (for later) */
-	pxor_r2r(mm0, mm7); /* 00FFFFFF -> mm7 (mult mask) */
-	/* form channel masks */
-	movq_r2r(mm7, mm0); /* 00FFFFFF -> mm0 */
-	packsswb_r2r(mm6, mm0); /* 00000FFF -> mm0 (channel mask) */
-	packsswb_r2r(mm6, mm3); /* 0000FFFF -> mm3 */
-	pxor_r2r(mm0, mm3); /* 0000F000 -> mm3 (~channel mask) */
-	/* get alpha channel shift */
-	movd_m2r(sf->Ashift, mm5); /* Ashift -> mm5 */
+    pxor_r2r(mm6, mm6);         /* 0 -> mm6 */
+    /* form multiplication mask */
+    movd_m2r(sf->Amask, mm7);   /* 0000F000 -> mm7 */
+    punpcklbw_r2r(mm7, mm7);    /* FF000000 -> mm7 */
+    pcmpeqb_r2r(mm0, mm0);      /* FFFFFFFF -> mm0 */
+    movq_r2r(mm0, mm3);         /* FFFFFFFF -> mm3 (for later) */
+    pxor_r2r(mm0, mm7);         /* 00FFFFFF -> mm7 (mult mask) */
+    /* form channel masks */
+    movq_r2r(mm7, mm0);         /* 00FFFFFF -> mm0 */
+    packsswb_r2r(mm6, mm0);     /* 00000FFF -> mm0 (channel mask) */
+    packsswb_r2r(mm6, mm3);     /* 0000FFFF -> mm3 */
+    pxor_r2r(mm0, mm3);         /* 0000F000 -> mm3 (~channel mask) */
+    /* get alpha channel shift */
+    movd_m2r(sf->Ashift, mm5);  /* Ashift -> mm5 */
 
-	while(height--) {
+    while (height--) {
+	    /* *INDENT-OFF* */
 	    DUFFS_LOOP4({
 		Uint32 alpha = *srcp & amask;
 		/* FIXME: Here we special-case opaque alpha since the
@@ -416,185 +435,195 @@
 		++srcp;
 		++dstp;
 	    }, width);
-	    srcp += srcskip;
-	    dstp += dstskip;
-	}
-	emms();
+	    /* *INDENT-ON* */
+        srcp += srcskip;
+        dstp += dstskip;
+    }
+    emms();
 }
+
 /* End GCC_ASMBLIT */
 
 #elif MSVC_ASMBLIT
 /* fast RGB888->(A)RGB888 blending with surface alpha=128 special case */
-static void BlitRGBtoRGBSurfaceAlpha128MMX(SDL_BlitInfo *info)
+static void
+BlitRGBtoRGBSurfaceAlpha128MMX(SDL_BlitInfo * info)
 {
-	int width = info->d_width;
-	int height = info->d_height;
-	Uint32 *srcp = (Uint32 *)info->s_pixels;
-	int srcskip = info->s_skip >> 2;
-	Uint32 *dstp = (Uint32 *)info->d_pixels;
-	int dstskip = info->d_skip >> 2;
-	Uint32 dalpha = info->dst->Amask;
+    int width = info->d_width;
+    int height = info->d_height;
+    Uint32 *srcp = (Uint32 *) info->s_pixels;
+    int srcskip = info->s_skip >> 2;
+    Uint32 *dstp = (Uint32 *) info->d_pixels;
+    int dstskip = info->d_skip >> 2;
+    Uint32 dalpha = info->dst->Amask;
+
+    __m64 src1, src2, dst1, dst2, lmask, hmask, dsta;
 
-	__m64 src1, src2, dst1, dst2, lmask, hmask, dsta;
-	
-	hmask = _mm_set_pi32(0x00fefefe, 0x00fefefe); /* alpha128 mask -> hmask */
-	lmask = _mm_set_pi32(0x00010101, 0x00010101); /* !alpha128 mask -> lmask */
-	dsta = _mm_set_pi32(dalpha, dalpha); /* dst alpha mask -> dsta */
+    hmask = _mm_set_pi32(0x00fefefe, 0x00fefefe);       /* alpha128 mask -> hmask */
+    lmask = _mm_set_pi32(0x00010101, 0x00010101);       /* !alpha128 mask -> lmask */
+    dsta = _mm_set_pi32(dalpha, dalpha);        /* dst alpha mask -> dsta */
+
+    while (height--) {
+        int n = width;
+        if (n & 1) {
+            Uint32 s = *srcp++;
+            Uint32 d = *dstp;
+            *dstp++ = ((((s & 0x00fefefe) + (d & 0x00fefefe)) >> 1)
+                       + (s & d & 0x00010101)) | dalpha;
+            n--;
+        }
 
-	while (height--) {
-		int n = width;
-		if ( n & 1 ) {
-			Uint32 s = *srcp++;
-			Uint32 d = *dstp;
-			*dstp++ = ((((s & 0x00fefefe) + (d & 0x00fefefe)) >> 1)
-				   + (s & d & 0x00010101)) | dalpha;
-			n--;
-		}
-		
-		for (n >>= 1; n > 0; --n) {
-			dst1 = *(__m64*)dstp; /* 2 x dst -> dst1(ARGBARGB) */
-			dst2 = dst1;   /* 2 x dst -> dst2(ARGBARGB) */
+        for (n >>= 1; n > 0; --n) {
+            dst1 = *(__m64 *) dstp;     /* 2 x dst -> dst1(ARGBARGB) */
+            dst2 = dst1;        /* 2 x dst -> dst2(ARGBARGB) */
 
-			src1 = *(__m64*)srcp; /* 2 x src -> src1(ARGBARGB) */
-			src2 = src1; /* 2 x src -> src2(ARGBARGB) */
+            src1 = *(__m64 *) srcp;     /* 2 x src -> src1(ARGBARGB) */
+            src2 = src1;        /* 2 x src -> src2(ARGBARGB) */
+
+            dst2 = _mm_and_si64(dst2, hmask);   /* dst & mask -> dst2 */
+            src2 = _mm_and_si64(src2, hmask);   /* src & mask -> src2 */
+            src2 = _mm_add_pi32(src2, dst2);    /* dst2 + src2 -> src2 */
+            src2 = _mm_srli_pi32(src2, 1);      /* src2 >> 1 -> src2 */
 
-			dst2 = _mm_and_si64(dst2, hmask); /* dst & mask -> dst2 */
-			src2 = _mm_and_si64(src2, hmask); /* src & mask -> src2 */
-			src2 = _mm_add_pi32(src2, dst2); /* dst2 + src2 -> src2 */
-			src2 = _mm_srli_pi32(src2, 1); /* src2 >> 1 -> src2 */
+            dst1 = _mm_and_si64(dst1, src1);    /* src & dst -> dst1 */
+            dst1 = _mm_and_si64(dst1, lmask);   /* dst1 & !mask -> dst1 */
+            dst1 = _mm_add_pi32(dst1, src2);    /* src2 + dst1 -> dst1 */
+            dst1 = _mm_or_si64(dst1, dsta);     /* dsta(full alpha) | dst1 -> dst1 */
 
-			dst1 = _mm_and_si64(dst1, src1); /* src & dst -> dst1 */
-			dst1 = _mm_and_si64(dst1, lmask); /* dst1 & !mask -> dst1 */
-			dst1 = _mm_add_pi32(dst1, src2); /* src2 + dst1 -> dst1 */
-			dst1 = _mm_or_si64(dst1, dsta); /* dsta(full alpha) | dst1 -> dst1 */
-			
-			*(__m64*)dstp = dst1; /* dst1 -> 2 x dst pixels */
-			dstp += 2;
-			srcp += 2;
-		}
-		
-		srcp += srcskip;
-		dstp += dstskip;
-	}
-	_mm_empty();
+            *(__m64 *) dstp = dst1;     /* dst1 -> 2 x dst pixels */
+            dstp += 2;
+            srcp += 2;
+        }
+
+        srcp += srcskip;
+        dstp += dstskip;
+    }
+    _mm_empty();
 }
 
 /* fast RGB888->(A)RGB888 blending with surface alpha */
-static void BlitRGBtoRGBSurfaceAlphaMMX(SDL_BlitInfo *info)
+static void
+BlitRGBtoRGBSurfaceAlphaMMX(SDL_BlitInfo * info)
 {
-	SDL_PixelFormat* df = info->dst;
-	Uint32 chanmask = df->Rmask | df->Gmask | df->Bmask;
-	unsigned alpha = info->src->alpha;
+    SDL_PixelFormat *df = info->dst;
+    Uint32 chanmask = df->Rmask | df->Gmask | df->Bmask;
+    unsigned alpha = info->src->alpha;
 
-	if (alpha == 128 && (df->Rmask | df->Gmask | df->Bmask) == 0x00FFFFFF) {
-			/* only call a128 version when R,G,B occupy lower bits */
-		BlitRGBtoRGBSurfaceAlpha128MMX(info);
-	} else {
-		int width = info->d_width;
-		int height = info->d_height;
-		Uint32 *srcp = (Uint32 *)info->s_pixels;
-		int srcskip = info->s_skip >> 2;
-		Uint32 *dstp = (Uint32 *)info->d_pixels;
-		int dstskip = info->d_skip >> 2;
-		Uint32 dalpha = df->Amask;
-		Uint32 amult;
+    if (alpha == 128 && (df->Rmask | df->Gmask | df->Bmask) == 0x00FFFFFF) {
+        /* only call a128 version when R,G,B occupy lower bits */
+        BlitRGBtoRGBSurfaceAlpha128MMX(info);
+    } else {
+        int width = info->d_width;
+        int height = info->d_height;
+        Uint32 *srcp = (Uint32 *) info->s_pixels;
+        int srcskip = info->s_skip >> 2;
+        Uint32 *dstp = (Uint32 *) info->d_pixels;
+        int dstskip = info->d_skip >> 2;
+        Uint32 dalpha = df->Amask;
+        Uint32 amult;
+
+        __m64 src1, src2, dst1, dst2, mm_alpha, mm_zero, dsta;
 
-		__m64 src1, src2, dst1, dst2, mm_alpha, mm_zero, dsta;
-		
-		mm_zero = _mm_setzero_si64(); /* 0 -> mm_zero */
-		/* form the alpha mult */
-		amult = alpha | (alpha << 8);
-		amult = amult | (amult << 16);
-		chanmask = (0xff << df->Rshift) | (0xff << df->Gshift) | (0xff << df->Bshift);
-		mm_alpha = _mm_set_pi32(0, amult & chanmask); /* 0000AAAA -> mm_alpha, minus 1 chan */
-		mm_alpha = _mm_unpacklo_pi8(mm_alpha, mm_zero); /* 0A0A0A0A -> mm_alpha, minus 1 chan */
-			/* at this point mm_alpha can be 000A0A0A or 0A0A0A00 or another combo */
-		dsta = _mm_set_pi32(dalpha, dalpha); /* dst alpha mask -> dsta */
-		
-		while (height--) {
-			int n = width;
-			if (n & 1) {
-				/* One Pixel Blend */
-				src2 = _mm_cvtsi32_si64(*srcp); /* src(ARGB) -> src2 (0000ARGB)*/
-				src2 = _mm_unpacklo_pi8(src2, mm_zero); /* 0A0R0G0B -> src2 */
+        mm_zero = _mm_setzero_si64();   /* 0 -> mm_zero */
+        /* form the alpha mult */
+        amult = alpha | (alpha << 8);
+        amult = amult | (amult << 16);
+        chanmask =
+            (0xff << df->Rshift) | (0xff << df->Gshift) | (0xff << df->
+                                                           Bshift);
+        mm_alpha = _mm_set_pi32(0, amult & chanmask);   /* 0000AAAA -> mm_alpha, minus 1 chan */
+        mm_alpha = _mm_unpacklo_pi8(mm_alpha, mm_zero); /* 0A0A0A0A -> mm_alpha, minus 1 chan */
+        /* at this point mm_alpha can be 000A0A0A or 0A0A0A00 or another combo */
+        dsta = _mm_set_pi32(dalpha, dalpha);    /* dst alpha mask -> dsta */
 
-				dst1 = _mm_cvtsi32_si64(*dstp); /* dst(ARGB) -> dst1 (0000ARGB)*/
-				dst1 = _mm_unpacklo_pi8(dst1, mm_zero); /* 0A0R0G0B -> dst1 */
+        while (height--) {
+            int n = width;
+            if (n & 1) {
+                /* One Pixel Blend */
+                src2 = _mm_cvtsi32_si64(*srcp); /* src(ARGB) -> src2 (0000ARGB) */
+                src2 = _mm_unpacklo_pi8(src2, mm_zero); /* 0A0R0G0B -> src2 */
+
+                dst1 = _mm_cvtsi32_si64(*dstp); /* dst(ARGB) -> dst1 (0000ARGB) */
+                dst1 = _mm_unpacklo_pi8(dst1, mm_zero); /* 0A0R0G0B -> dst1 */
 
-				src2 = _mm_sub_pi16(src2, dst1); /* src2 - dst2 -> src2 */
-				src2 = _mm_mullo_pi16(src2, mm_alpha); /* src2 * alpha -> src2 */
-				src2 = _mm_srli_pi16(src2, 8); /* src2 >> 8 -> src2 */
-				dst1 = _mm_add_pi8(src2, dst1); /* src2 + dst1 -> dst1 */
-				
-				dst1 = _mm_packs_pu16(dst1, mm_zero);  /* 0000ARGB -> dst1 */
-				dst1 = _mm_or_si64(dst1, dsta); /* dsta | dst1 -> dst1 */
-				*dstp = _mm_cvtsi64_si32(dst1); /* dst1 -> pixel */
+                src2 = _mm_sub_pi16(src2, dst1);        /* src2 - dst2 -> src2 */
+                src2 = _mm_mullo_pi16(src2, mm_alpha);  /* src2 * alpha -> src2 */
+                src2 = _mm_srli_pi16(src2, 8);  /* src2 >> 8 -> src2 */
+                dst1 = _mm_add_pi8(src2, dst1); /* src2 + dst1 -> dst1 */
+
+                dst1 = _mm_packs_pu16(dst1, mm_zero);   /* 0000ARGB -> dst1 */
+                dst1 = _mm_or_si64(dst1, dsta); /* dsta | dst1 -> dst1 */
+                *dstp = _mm_cvtsi64_si32(dst1); /* dst1 -> pixel */
 
-				++srcp;
-				++dstp;
-				
-				n--;
-			}
+                ++srcp;
+                ++dstp;
+
+                n--;
+            }
 
-			for (n >>= 1; n > 0; --n) {
-				/* Two Pixels Blend */
-				src1 = *(__m64*)srcp; /* 2 x src -> src1(ARGBARGB)*/
-				src2 = src1; /* 2 x src -> src2(ARGBARGB) */
-				src1 = _mm_unpacklo_pi8(src1, mm_zero); /* low - 0A0R0G0B -> src1 */
-				src2 = _mm_unpackhi_pi8(src2, mm_zero); /* high - 0A0R0G0B -> src2 */
+            for (n >>= 1; n > 0; --n) {
+                /* Two Pixels Blend */
+                src1 = *(__m64 *) srcp; /* 2 x src -> src1(ARGBARGB) */
+                src2 = src1;    /* 2 x src -> src2(ARGBARGB) */
+                src1 = _mm_unpacklo_pi8(src1, mm_zero); /* low - 0A0R0G0B -> src1 */
+                src2 = _mm_unpackhi_pi8(src2, mm_zero); /* high - 0A0R0G0B -> src2 */
 
-				dst1 = *(__m64*)dstp;/* 2 x dst -> dst1(ARGBARGB) */
-				dst2 = dst1; /* 2 x dst -> dst2(ARGBARGB) */
-				dst1 = _mm_unpacklo_pi8(dst1, mm_zero); /* low - 0A0R0G0B -> dst1 */
-				dst2 = _mm_unpackhi_pi8(dst2, mm_zero); /* high - 0A0R0G0B -> dst2 */
+                dst1 = *(__m64 *) dstp; /* 2 x dst -> dst1(ARGBARGB) */
+                dst2 = dst1;    /* 2 x dst -> dst2(ARGBARGB) */
+                dst1 = _mm_unpacklo_pi8(dst1, mm_zero); /* low - 0A0R0G0B -> dst1 */
+                dst2 = _mm_unpackhi_pi8(dst2, mm_zero); /* high - 0A0R0G0B -> dst2 */
 
-				src1 = _mm_sub_pi16(src1, dst1);/* src1 - dst1 -> src1 */
-				src1 = _mm_mullo_pi16(src1, mm_alpha); /* src1 * alpha -> src1 */
-				src1 = _mm_srli_pi16(src1, 8); /* src1 >> 8 -> src1 */
-				dst1 = _mm_add_pi8(src1, dst1); /* src1 + dst1(dst1) -> dst1 */
+                src1 = _mm_sub_pi16(src1, dst1);        /* src1 - dst1 -> src1 */
+                src1 = _mm_mullo_pi16(src1, mm_alpha);  /* src1 * alpha -> src1 */
+                src1 = _mm_srli_pi16(src1, 8);  /* src1 >> 8 -> src1 */
+                dst1 = _mm_add_pi8(src1, dst1); /* src1 + dst1(dst1) -> dst1 */
 
-				src2 = _mm_sub_pi16(src2, dst2);/* src2 - dst2 -> src2 */
-				src2 = _mm_mullo_pi16(src2, mm_alpha); /* src2 * alpha -> src2 */
-				src2 = _mm_srli_pi16(src2, 8); /* src2 >> 8 -> src2 */
-				dst2 = _mm_add_pi8(src2, dst2); /* src2 + dst2(dst2) -> dst2 */
-				
-				dst1 = _mm_packs_pu16(dst1, dst2); /* 0A0R0G0B(res1), 0A0R0G0B(res2) -> dst1(ARGBARGB) */
-				dst1 = _mm_or_si64(dst1, dsta); /* dsta | dst1 -> dst1 */
+                src2 = _mm_sub_pi16(src2, dst2);        /* src2 - dst2 -> src2 */
+                src2 = _mm_mullo_pi16(src2, mm_alpha);  /* src2 * alpha -> src2 */
+                src2 = _mm_srli_pi16(src2, 8);  /* src2 >> 8 -> src2 */
+                dst2 = _mm_add_pi8(src2, dst2); /* src2 + dst2(dst2) -> dst2 */
+
+                dst1 = _mm_packs_pu16(dst1, dst2);      /* 0A0R0G0B(res1), 0A0R0G0B(res2) -> dst1(ARGBARGB) */
+                dst1 = _mm_or_si64(dst1, dsta); /* dsta | dst1 -> dst1 */
 
-				*(__m64*)dstp = dst1; /* dst1 -> 2 x pixel */
+                *(__m64 *) dstp = dst1; /* dst1 -> 2 x pixel */
 
-				srcp += 2;
-				dstp += 2;
-			}
-			srcp += srcskip;
-			dstp += dstskip;
-		}
-		_mm_empty();
-	}
+                srcp += 2;
+                dstp += 2;
+            }
+            srcp += srcskip;
+            dstp += dstskip;
+        }
+        _mm_empty();
+    }
 }
 
 /* fast ARGB888->(A)RGB888 blending with pixel alpha */
-static void BlitRGBtoRGBPixelAlphaMMX(SDL_BlitInfo *info)
+static void
+BlitRGBtoRGBPixelAlphaMMX(SDL_BlitInfo * info)
 {
-	int width = info->d_width;
-	int height = info->d_height;
-	Uint32 *srcp = (Uint32 *)info->s_pixels;
-	int srcskip = info->s_skip >> 2;
-	Uint32 *dstp = (Uint32 *)info->d_pixels;
-	int dstskip = info->d_skip >> 2;
-	SDL_PixelFormat* sf = info->src;
-	Uint32 chanmask = sf->Rmask | sf->Gmask | sf->Bmask;
-	Uint32 amask = sf->Amask;
-	Uint32 ashift = sf->Ashift;
-	Uint64 multmask;
+    int width = info->d_width;
+    int height = info->d_height;
+    Uint32 *srcp = (Uint32 *) info->s_pixels;
+    int srcskip = info->s_skip >> 2;
+    Uint32 *dstp = (Uint32 *) info->d_pixels;
+    int dstskip = info->d_skip >> 2;
+    SDL_PixelFormat *sf = info->src;
+    Uint32 chanmask = sf->Rmask | sf->Gmask | sf->Bmask;
+    Uint32 amask = sf->Amask;
+    Uint32 ashift = sf->Ashift;
+    Uint64 multmask;
 
-	__m64 src1, dst1, mm_alpha, mm_zero, dmask;
+    __m64 src1, dst1, mm_alpha, mm_zero, dmask;
 
-	mm_zero = _mm_setzero_si64(); /* 0 -> mm_zero */
-	multmask = ~(0xFFFFi64 << (ashift * 2));
-	dmask = *(__m64*) &multmask; /* dst alpha mask -> dmask */
+    mm_zero = _mm_setzero_si64();       /* 0 -> mm_zero */
+	/* *INDENT-OFF* */
+	multmask = ~(0xFFFFI64 << (ashift * 2));
+	/* *INDENT-ON* */
+    dmask = *(__m64 *) & multmask;      /* dst alpha mask -> dmask */
 
-	while(height--) {
+    while (height--) {
+		/* *INDENT-OFF* */
 		DUFFS_LOOP4({
 		Uint32 alpha = *srcp & amask;
 		if (alpha == 0) {
@@ -627,11 +656,13 @@
 		++srcp;
 		++dstp;
 	    }, width);
-	    srcp += srcskip;
-	    dstp += dstskip;
-	}
-	_mm_empty();
+		/* *INDENT-ON* */
+        srcp += srcskip;
+        dstp += dstskip;
+    }
+    _mm_empty();
 }
+
 /* End MSVC_ASMBLIT */
 
 #endif /* GCC_ASMBLIT, MSVC_ASMBLIT */
@@ -646,14 +677,14 @@
 #include <assert.h>
 
 #if (defined(__MACOSX__) && (__GNUC__ < 4))
-    #define VECUINT8_LITERAL(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \
+#define VECUINT8_LITERAL(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \
         (vector unsigned char) ( a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p )
-    #define VECUINT16_LITERAL(a,b,c,d,e,f,g,h) \
+#define VECUINT16_LITERAL(a,b,c,d,e,f,g,h) \
         (vector unsigned short) ( a,b,c,d,e,f,g,h )
 #else
-    #define VECUINT8_LITERAL(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \
+#define VECUINT8_LITERAL(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \
         (vector unsigned char) { a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p }
-    #define VECUINT16_LITERAL(a,b,c,d,e,f,g,h) \
+#define VECUINT16_LITERAL(a,b,c,d,e,f,g,h) \
         (vector unsigned short) { a,b,c,d,e,f,g,h }
 #endif
 
@@ -678,7 +709,7 @@
     ? vec_lvsl(0, src) \
     : vec_add(vec_lvsl(8, src), vec_splat_u8(8)))
 
-   
+
 #define VEC_MULTIPLY_ALPHA(vs, vd, valpha, mergePermute, v1_16, v8_16) do { \
     /* vtemp1 contains source AAGGAAGGAAGGAAGG */ \
     vector unsigned short vtemp1 = vec_mule(vs, valpha); \
@@ -704,10 +735,10 @@
     /* (>>8) and get ARGBARGBARGBARGB */ \
     vd = (vector unsigned char)vec_perm(vtemp1, vtemp2, mergePermute); \
 } while (0)
- 
+
 /* Calculate the permute vector used for 32->32 swizzling */
-static vector unsigned char calc_swizzle32(const SDL_PixelFormat *srcfmt,
-                                  const SDL_PixelFormat *dstfmt)
+static vector unsigned char
+calc_swizzle32(const SDL_PixelFormat * srcfmt, const SDL_PixelFormat * dstfmt)
 {
     /*
      * We have to assume that the bits that aren't used by other
@@ -720,18 +751,19 @@
         0, 0, 0, 0,
         16, 8, 0, 24,
         0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000,
-        0, 0};
+        0, 0
+    };
     if (!srcfmt) {
         srcfmt = &default_pixel_format;
     }
     if (!dstfmt) {
         dstfmt = &default_pixel_format;
     }
-    const vector unsigned char plus = VECUINT8_LITERAL
-                                            ( 0x00, 0x00, 0x00, 0x00,
-                                              0x04, 0x04, 0x04, 0x04,
-                                              0x08, 0x08, 0x08, 0x08,
-                                              0x0C, 0x0C, 0x0C, 0x0C );
+    const vector unsigned char plus = VECUINT8_LITERAL(0x00, 0x00, 0x00, 0x00,
+                                                       0x04, 0x04, 0x04, 0x04,
+                                                       0x08, 0x08, 0x08, 0x08,
+                                                       0x0C, 0x0C, 0x0C,
+                                                       0x0C);
     vector unsigned char vswiz;
     vector unsigned int srcvec;
 #define RESHIFT(X) (3 - ((X) >> 3))
@@ -741,22 +773,27 @@
     Uint32 amask;
     /* Use zero for alpha if either surface doesn't have alpha */
     if (dstfmt->Amask) {
-        amask = ((srcfmt->Amask) ? RESHIFT(srcfmt->Ashift) : 0x10) << (dstfmt->Ashift);
+        amask =
+            ((srcfmt->Amask) ? RESHIFT(srcfmt->Ashift) : 0x10) << (dstfmt->
+                                                                   Ashift);
     } else {
-        amask = 0x10101010 & ((dstfmt->Rmask | dstfmt->Gmask | dstfmt->Bmask) ^ 0xFFFFFFFF);
+        amask =
+            0x10101010 & ((dstfmt->Rmask | dstfmt->Gmask | dstfmt->Bmask) ^
+                          0xFFFFFFFF);
     }
-#undef RESHIFT  
-    ((unsigned int *)(char*)&srcvec)[0] = (rmask | gmask | bmask | amask);
-    vswiz = vec_add(plus, (vector unsigned char)vec_splat(srcvec, 0));
-    return(vswiz);
+#undef RESHIFT
+    ((unsigned int *) (char *) &srcvec)[0] = (rmask | gmask | bmask | amask);
+    vswiz = vec_add(plus, (vector unsigned char) vec_splat(srcvec, 0));
+    return (vswiz);
 }
 
-static void Blit32to565PixelAlphaAltivec(SDL_BlitInfo *info)
+static void
+Blit32to565PixelAlphaAltivec(SDL_BlitInfo * info)
 {
     int height = info->d_height;
-    Uint8 *src = (Uint8 *)info->s_pixels;
+    Uint8 *src = (Uint8 *) info->s_pixels;
     int srcskip = info->s_skip;
-    Uint8 *dst = (Uint8 *)info->d_pixels;
+    Uint8 *dst = (Uint8 *) info->d_pixels;
     int dstskip = info->d_skip;
     SDL_PixelFormat *srcfmt = info->src;
 
@@ -767,66 +804,63 @@
     vector unsigned short v3_16 = vec_splat_u16(3);
     vector unsigned int v8_32 = vec_splat_u32(8);
     vector unsigned int v16_32 = vec_add(v8_32, v8_32);
-    vector unsigned short v3f = VECUINT16_LITERAL(
-        0x003f, 0x003f, 0x003f, 0x003f,
-        0x003f, 0x003f, 0x003f, 0x003f);
-    vector unsigned short vfc = VECUINT16_LITERAL(
-        0x00fc, 0x00fc, 0x00fc, 0x00fc,
-        0x00fc, 0x00fc, 0x00fc, 0x00fc);
+    vector unsigned short v3f =
+        VECUINT16_LITERAL(0x003f, 0x003f, 0x003f, 0x003f,
+                          0x003f, 0x003f, 0x003f, 0x003f);
+    vector unsigned short vfc =
+        VECUINT16_LITERAL(0x00fc, 0x00fc, 0x00fc, 0x00fc,
+                          0x00fc, 0x00fc, 0x00fc, 0x00fc);
 
     /* 
-        0x10 - 0x1f is the alpha
-        0x00 - 0x0e evens are the red
-        0x01 - 0x0f odds are zero
-    */
-    vector unsigned char vredalpha1 = VECUINT8_LITERAL(
-        0x10, 0x00, 0x01, 0x01,
-        0x10, 0x02, 0x01, 0x01,
-        0x10, 0x04, 0x01, 0x01,
-        0x10, 0x06, 0x01, 0x01
-    );
-    vector unsigned char vredalpha2 = (vector unsigned char)(
-        vec_add((vector unsigned int)vredalpha1, vec_sl(v8_32, v16_32))
-    );
+       0x10 - 0x1f is the alpha
+       0x00 - 0x0e evens are the red
+       0x01 - 0x0f odds are zero
+     */
+    vector unsigned char vredalpha1 = VECUINT8_LITERAL(0x10, 0x00, 0x01, 0x01,
+                                                       0x10, 0x02, 0x01, 0x01,
+                                                       0x10, 0x04, 0x01, 0x01,
+                                                       0x10, 0x06, 0x01,
+                                                       0x01);
+    vector unsigned char vredalpha2 =
+        (vector unsigned char) (vec_add((vector unsigned int) vredalpha1,
+                                        vec_sl(v8_32, v16_32))
+        );
     /*
-        0x00 - 0x0f is ARxx ARxx ARxx ARxx
-        0x11 - 0x0f odds are blue
-    */
-    vector unsigned char vblue1 = VECUINT8_LITERAL(
-        0x00, 0x01, 0x02, 0x11,
-        0x04, 0x05, 0x06, 0x13,
-        0x08, 0x09, 0x0a, 0x15,
-        0x0c, 0x0d, 0x0e, 0x17
-    );
-    vector unsigned char vblue2 = (vector unsigned char)(
-        vec_add((vector unsigned int)vblue1, v8_32)
-    );
+       0x00 - 0x0f is ARxx ARxx ARxx ARxx
+       0x11 - 0x0f odds are blue
+     */
+    vector unsigned char vblue1 = VECUINT8_LITERAL(0x00, 0x01, 0x02, 0x11,
+                                                   0x04, 0x05, 0x06, 0x13,
+                                                   0x08, 0x09, 0x0a, 0x15,
+                                                   0x0c, 0x0d, 0x0e, 0x17);
+    vector unsigned char vblue2 =
+        (vector unsigned char) (vec_add((vector unsigned int) vblue1, v8_32)
+        );
     /*
-        0x00 - 0x0f is ARxB ARxB ARxB ARxB
-        0x10 - 0x0e evens are green
-    */
-    vector unsigned char vgreen1 = VECUINT8_LITERAL(
-        0x00, 0x01, 0x10, 0x03,
-        0x04, 0x05, 0x12, 0x07,
-        0x08, 0x09, 0x14, 0x0b,
-        0x0c, 0x0d, 0x16, 0x0f
-    );
-    vector unsigned char vgreen2 = (vector unsigned char)(
-        vec_add((vector unsigned int)vgreen1, vec_sl(v8_32, v8_32))
-    );
-    vector unsigned char vgmerge = VECUINT8_LITERAL(
-        0x00, 0x02, 0x00, 0x06,
-        0x00, 0x0a, 0x00, 0x0e,
-        0x00, 0x12, 0x00, 0x16,
-        0x00, 0x1a, 0x00, 0x1e);
+       0x00 - 0x0f is ARxB ARxB ARxB ARxB
+       0x10 - 0x0e evens are green
+     */
+    vector unsigned char vgreen1 = VECUINT8_LITERAL(0x00, 0x01, 0x10, 0x03,
+                                                    0x04, 0x05, 0x12, 0x07,
+                                                    0x08, 0x09, 0x14, 0x0b,
+                                                    0x0c, 0x0d, 0x16, 0x0f);
+    vector unsigned char vgreen2 =
+        (vector unsigned
+         char) (vec_add((vector unsigned int) vgreen1, vec_sl(v8_32, v8_32))
+        );
+    vector unsigned char vgmerge = VECUINT8_LITERAL(0x00, 0x02, 0x00, 0x06,
+                                                    0x00, 0x0a, 0x00, 0x0e,
+                                                    0x00, 0x12, 0x00, 0x16,
+                                                    0x00, 0x1a, 0x00, 0x1e);
     vector unsigned char mergePermute = VEC_MERGE_PERMUTE();
     vector unsigned char vpermute = calc_swizzle32(srcfmt, NULL);
-    vector unsigned char valphaPermute = vec_and(vec_lvsl(0, (int *)NULL), vec_splat_u8(0xC));
+    vector unsigned char valphaPermute =
+        vec_and(vec_lvsl(0, (int *) NULL), vec_splat_u8(0xC));
 
-    vector unsigned short vf800 = (vector unsigned short)vec_splat_u8(-7);
+    vector unsigned short vf800 = (vector unsigned short) vec_splat_u8(-7);
     vf800 = vec_sl(vf800, vec_splat_u16(8));
 
-    while(height--) {
+    while (height--) {
         int extrawidth;
         vector unsigned char valigner;
         vector unsigned char vsrc;
@@ -855,7 +889,7 @@
         ONE_PIXEL_BLEND((UNALIGNED_PTR(dst)) && (width), width);
         extrawidth = (width % 8);
         valigner = VEC_ALIGNER(src);
-        vsrc = (vector unsigned char)vec_ld(0, src);
+        vsrc = (vector unsigned char) vec_ld(0, src);
         width -= extrawidth;
         while (width) {
             vector unsigned char valpha;
@@ -865,44 +899,57 @@
             vector unsigned short vpixel, vrpixel, vgpixel, vbpixel;
 
             /* Load 8 pixels from src as ARGB */
-            voverflow = (vector unsigned char)vec_ld(15, src);
+            voverflow = (vector unsigned char) vec_ld(15, src);
             vsrc = vec_perm(vsrc, voverflow, valigner);
             vsrc1 = vec_perm(vsrc, vsrc, vpermute);
             src += 16;
-            vsrc = (vector unsigned char)vec_ld(15, src);
+            vsrc = (vector unsigned char) vec_ld(15, src);
             voverflow = vec_perm(voverflow, vsrc, valigner);
             vsrc2 = vec_perm(voverflow, voverflow, vpermute);
             src += 16;
 
             /* Load 8 pixels from dst as XRGB */
             voverflow = vec_ld(0, dst);
-            vR = vec_and((vector unsigned short)voverflow, vf800);
-            vB = vec_sl((vector unsigned short)voverflow, v3_16);
+            vR = vec_and((vector unsigned short) voverflow, vf800);
+            vB = vec_sl((vector unsigned short) voverflow, v3_16);
             vG = vec_sl(vB, v2_16);
-            vdst1 = (vector unsigned char)vec_perm((vector unsigned char)vR, (vector unsigned char)vR, vredalpha1);
-            vdst1 = vec_perm(vdst1, (vector unsigned char)vB, vblue1);
-            vdst1 = vec_perm(vdst1, (vector unsigned char)vG, vgreen1);
-            vdst2 = (vector unsigned char)vec_perm((vector unsigned char)vR, (vector unsigned char)vR, vredalpha2);
-            vdst2 = vec_perm(vdst2, (vector unsigned char)vB, vblue2);
-            vdst2 = vec_perm(vdst2, (vector unsigned char)vG, vgreen2);
+            vdst1 =
+                (vector unsigned char) vec_perm((vector unsigned char) vR,
+                                                (vector unsigned char) vR,
+                                                vredalpha1);
+            vdst1 = vec_perm(vdst1, (vector unsigned char) vB, vblue1);
+            vdst1 = vec_perm(vdst1, (vector unsigned char) vG, vgreen1);
+            vdst2 =
+                (vector unsigned char) vec_perm((vector unsigned char) vR,
+                                                (vector unsigned char) vR,
+                                                vredalpha2);
+            vdst2 = vec_perm(vdst2, (vector unsigned char) vB, vblue2);
+            vdst2 = vec_perm(vdst2, (vector unsigned char) vG, vgreen2);
 
             /* Alpha blend 8 pixels as ARGB */
             valpha = vec_perm(vsrc1, v0, valphaPermute);
-            VEC_MULTIPLY_ALPHA(vsrc1, vdst1, valpha, mergePermute, v1_16, v8_16);
+            VEC_MULTIPLY_ALPHA(vsrc1, vdst1, valpha, mergePermute, v1_16,
+                               v8_16);
             valpha = vec_perm(vsrc2, v0, valphaPermute);
-            VEC_MULTIPLY_ALPHA(vsrc2, vdst2, valpha, mergePermute, v1_16, v8_16);
+            VEC_MULTIPLY_ALPHA(vsrc2, vdst2, valpha, mergePermute, v1_16,
+                               v8_16);
 
             /* Convert 8 pixels to 565 */
-            vpixel = (vector unsigned short)vec_packpx((vector unsigned int)vdst1, (vector unsigned int)vdst2);
-            vgpixel = (vector unsigned short)vec_perm(vdst1, vdst2, vgmerge);
+            vpixel = (vector unsigned short) vec_packpx((vector unsigned int)
+                                                        vdst1,
+                                                        (vector unsigned int)
+                                                        vdst2);
+            vgpixel = (vector unsigned short) vec_perm(vdst1, vdst2, vgmerge);
             vgpixel = vec_and(vgpixel, vfc);
             vgpixel = vec_sl(vgpixel, v3_16);
             vrpixel = vec_sl(vpixel, v1_16);
             vrpixel = vec_and(vrpixel, vf800);
             vbpixel = vec_and(vpixel, v3f);
-            vdst1 = vec_or((vector unsigned char)vrpixel, (vector unsigned char)vgpixel);
-            vdst1 = vec_or(vdst1, (vector unsigned char)vbpixel);
-            
+            vdst1 =
+                vec_or((vector unsigned char) vrpixel,
+                       (vector unsigned char) vgpixel);
+            vdst1 = vec_or(vdst1, (vector unsigned char) vbpixel);
+
             /* Store 8 pixels */
             vec_st(vdst1, 0, dst);
 
@@ -916,13 +963,14 @@
     }
 }
 
-static void Blit32to32SurfaceAlphaKeyAltivec(SDL_BlitInfo *info)
+static void
+Blit32to32SurfaceAlphaKeyAltivec(SDL_BlitInfo * info)
 {
     unsigned alpha = info->src->alpha;
     int height = info->d_height;
-    Uint32 *srcp = (Uint32 *)info->s_pixels;
+    Uint32 *srcp = (Uint32 *) info->s_pixels;
     int srcskip = info->s_skip >> 2;
-    Uint32 *dstp = (Uint32 *)info->d_pixels;
+    Uint32 *dstp = (Uint32 *) info->d_pixels;
     int dstskip = info->d_skip >> 2;
     SDL_PixelFormat *srcfmt = info->src;
     SDL_PixelFormat *dstfmt = info->dst;
@@ -956,17 +1004,17 @@
     vsdstPermute = calc_swizzle32(dstfmt, NULL);
 
     /* set a vector full of alpha and 255-alpha */
-    ((unsigned char *)&valpha)[0] = alpha;
+    ((unsigned char *) &valpha)[0] = alpha;
     valpha = vec_splat(valpha, 0);
-    vbits = (vector unsigned char)vec_splat_s8(-1);
+    vbits = (vector unsigned char) vec_splat_s8(-1);
 
     ckey &= rgbmask;
-    ((unsigned int *)(char*)&vckey)[0] = ckey;
+    ((unsigned int *) (char *) &vckey)[0] = ckey;
     vckey = vec_splat(vckey, 0);
-    ((unsigned int *)(char*)&vrgbmask)[0] = rgbmask;
+    ((unsigned int *) (char *) &vrgbmask)[0] = rgbmask;
     vrgbmask = vec_splat(vrgbmask, 0);
 
-    while(height--) {
+    while (height--) {
         int width = info->d_width;
 #define ONE_PIXEL_BLEND(condition, widthvar) \
         while (condition) { \
@@ -987,7 +1035,7 @@
         if (width > 0) {
             int extrawidth = (width % 4);
             vector unsigned char valigner = VEC_ALIGNER(srcp);
-            vector unsigned char vs = (vector unsigned char)vec_ld(0, srcp);
+            vector unsigned char vs = (vector unsigned char) vec_ld(0, srcp);
             width -= extrawidth;
             while (width) {
                 vector unsigned char vsel;
@@ -996,18 +1044,21 @@
                 vector unsigned char vd_orig;
 
                 /* s = *srcp */
-                voverflow = (vector unsigned char)vec_ld(15, srcp);
+                voverflow = (vector unsigned char) vec_ld(15, srcp);
                 vs = vec_perm(vs, voverflow, valigner);
-                
+
                 /* vsel is set for items that match the key */
-                vsel = (vector unsigned char)vec_and((vector unsigned int)vs, vrgbmask);
-                vsel = (vector unsigned char)vec_cmpeq((vector unsigned int)vsel, vckey);
+                vsel =
+                    (vector unsigned char) vec_and((vector unsigned int) vs,
+                                                   vrgbmask);
+                vsel = (vector unsigned char) vec_cmpeq((vector unsigned int)
+                                                        vsel, vckey);
 
                 /* permute to source format */
                 vs = vec_perm(vs, valpha, vsrcPermute);
 
                 /* d = *dstp */
-                vd = (vector unsigned char)vec_ld(0, dstp);
+                vd = (vector unsigned char) vec_ld(0, dstp);
                 vd_orig = vd = vec_perm(vd, v0, vsdstPermute);
 
                 VEC_MULTIPLY_ALPHA(vs, vd, valpha, mergePermute, v1, v8);
@@ -1017,13 +1068,13 @@
 
                 /* mask out color key */
                 vd = vec_sel(vd, vd_orig, vsel);
-                
+
                 /* permute to dest format */
                 vd = vec_perm(vd, vbits, vdstPermute);
 
                 /* *dstp = res */
-                vec_st((vector unsigned int)vd, 0, dstp);
-                
+                vec_st((vector unsigned int) vd, 0, dstp);
+
                 srcp += 4;
                 dstp += 4;
                 width -= 4;
@@ -1032,20 +1083,21 @@
             ONE_PIXEL_BLEND((extrawidth), extrawidth);
         }
 #undef ONE_PIXEL_BLEND
- 
+
         srcp += srcskip;
         dstp += dstskip;
     }
 }
 
 
-static void Blit32to32PixelAlphaAltivec(SDL_BlitInfo *info)
+static void
+Blit32to32PixelAlphaAltivec(SDL_BlitInfo * info)
 {
     int width = info->d_width;
     int height = info->d_height;
-    Uint32 *srcp = (Uint32 *)info->s_pixels;
+    Uint32 *srcp = (Uint32 *) info->s_pixels;
     int srcskip = info->s_skip >> 2;
-    Uint32 *dstp = (Uint32 *)info->d_pixels;
+    Uint32 *dstp = (Uint32 *) info->d_pixels;
     int dstskip = info->d_skip >> 2;
     SDL_PixelFormat *srcfmt = info->src;
     SDL_PixelFormat *dstfmt = info->dst;
@@ -1065,13 +1117,13 @@
     v8 = vec_splat_u16(8);
     mergePermute = VEC_MERGE_PERMUTE();
     valphamask = VEC_ALPHA_MASK();
-    valphaPermute = vec_and(vec_lvsl(0, (int *)NULL), vec_splat_u8(0xC));
+    valphaPermute = vec_and(vec_lvsl(0, (int *) NULL), vec_splat_u8(0xC));
     vpixelmask = vec_nor(valphamask, v0);
     vsrcPermute = calc_swizzle32(srcfmt, NULL);
     vdstPermute = calc_swizzle32(NULL, dstfmt);
     vsdstPermute = calc_swizzle32(dstfmt, NULL);
 
-	while ( height-- ) {
+    while (height--) {
         width = info->d_width;
 #define ONE_PIXEL_BLEND(condition, widthvar) while ((condition)) { \
             Uint32 Pixel; \
@@ -1092,7 +1144,7 @@
             /* vdstPermute */
             int extrawidth = (width % 4);
             vector unsigned char valigner = VEC_ALIGNER(srcp);
-            vector unsigned char vs = (vector unsigned char)vec_ld(0, srcp);
+            vector unsigned char vs = (vector unsigned char) vec_ld(0, srcp);
             width -= extrawidth;
             while (width) {
                 vector unsigned char voverflow;
@@ -1100,14 +1152,14 @@
                 vector unsigned char valpha;
                 vector unsigned char vdstalpha;
                 /* s = *srcp */
-                voverflow = (vector unsigned char)vec_ld(15, srcp);
+                voverflow = (vector unsigned char) vec_ld(15, srcp);
                 vs = vec_perm(vs, voverflow, valigner);
                 vs = vec_perm(vs, v0, vsrcPermute);
 
                 valpha = vec_perm(vs, v0, valphaPermute);
-                
+
                 /* d = *dstp */
-                vd = (vector unsigned char)vec_ld(0, dstp);
+                vd = (vector unsigned char) vec_ld(0, dstp);
                 vd = vec_perm(vd, v0, vsdstPermute);
                 vdstalpha = vec_and(vd, valphamask);
 
@@ -1119,8 +1171,8 @@
                 vd = vec_perm(vd, v0, vdstPermute);
 
                 /* *dstp = res */
-                vec_st((vector unsigned int)vd, 0, dstp);
-                
+                vec_st((vector unsigned int) vd, 0, dstp);
+
                 srcp += 4;
                 dstp += 4;
                 width -= 4;
@@ -1129,21 +1181,22 @@
             }
             ONE_PIXEL_BLEND((extrawidth), extrawidth);
         }
-	    srcp += srcskip;
-	    dstp += dstskip;
+        srcp += srcskip;
+        dstp += dstskip;
 #undef ONE_PIXEL_BLEND
-	}
+    }
 }
 
 /* fast ARGB888->(A)RGB888 blending with pixel alpha */
-static void BlitRGBtoRGBPixelAlphaAltivec(SDL_BlitInfo *info)
+static void
+BlitRGBtoRGBPixelAlphaAltivec(SDL_BlitInfo * info)
 {
-	int width = info->d_width;
-	int height = info->d_height;
-	Uint32 *srcp = (Uint32 *)info->s_pixels;
-	int srcskip = info->s_skip >> 2;
-	Uint32 *dstp = (Uint32 *)info->d_pixels;
-	int dstskip = info->d_skip >> 2;
+    int width = info->d_width;
+    int height = info->d_height;
+    Uint32 *srcp = (Uint32 *) info->s_pixels;
+    int srcskip = info->s_skip >> 2;
+    Uint32 *dstp = (Uint32 *) info->d_pixels;
+    int dstskip = info->d_skip >> 2;
     vector unsigned char mergePermute;
     vector unsigned char valphaPermute;
     vector unsigned char valphamask;
@@ -1156,11 +1209,11 @@
     v8 = vec_splat_u16(8);
     mergePermute = VEC_MERGE_PERMUTE();
     valphamask = VEC_ALPHA_MASK();
-    valphaPermute = vec_and(vec_lvsl(0, (int *)NULL), vec_splat_u8(0xC));
-    
- 
+    valphaPermute = vec_and(vec_lvsl(0, (int *) NULL), vec_splat_u8(0xC));
+
+
     vpixelmask = vec_nor(valphamask, v0);
-	while(height--) {
+    while (height--) {
         width = info->d_width;
 #define ONE_PIXEL_BLEND(condition, widthvar) \
         while ((condition)) { \
@@ -1193,7 +1246,7 @@
         if (width > 0) {
             int extrawidth = (width % 4);
             vector unsigned char valigner = VEC_ALIGNER(srcp);
-            vector unsigned char vs = (vector unsigned char)vec_ld(0, srcp);
+            vector unsigned char vs = (vector unsigned char) vec_ld(0, srcp);
             width -= extrawidth;
             while (width) {
                 vector unsigned char voverflow;
@@ -1201,13 +1254,13 @@
                 vector unsigned char valpha;
                 vector unsigned char vdstalpha;
                 /* s = *srcp */
-                voverflow = (vector unsigned char)vec_ld(15, srcp);
+                voverflow = (vector unsigned char) vec_ld(15, srcp);
                 vs = vec_perm(vs, voverflow, valigner);
 
                 valpha = vec_perm(vs, v0, valphaPermute);
-                
+
                 /* d = *dstp */
-                vd = (vector unsigned char)vec_ld(0, dstp);
+                vd = (vector unsigned char) vec_ld(0, dstp);
                 vdstalpha = vec_and(vd, valphamask);
 
                 VEC_MULTIPLY_ALPHA(vs, vd, valpha, mergePermute, v1, v8);
@@ -1217,8 +1270,8 @@
                 vd = vec_or(vd, vdstalpha);
 
                 /* *dstp = res */
-                vec_st((vector unsigned int)vd, 0, dstp);
-                
+                vec_st((vector unsigned int) vd, 0, dstp);
+
                 srcp += 4;
                 dstp += 4;
                 width -= 4;
@@ -1226,25 +1279,26 @@
             }
             ONE_PIXEL_BLEND((extrawidth), extrawidth);
         }
-	    srcp += srcskip;
-	    dstp += dstskip;
-	}
+        srcp += srcskip;
+        dstp += dstskip;
+    }
 #undef ONE_PIXEL_BLEND
 }
 
-static void Blit32to32SurfaceAlphaAltivec(SDL_BlitInfo *info)
+static void
+Blit32to32SurfaceAlphaAltivec(SDL_BlitInfo * info)
 {
     /* XXX : 6 */
-	unsigned alpha = info->src->alpha;
+    unsigned alpha = info->src->alpha;
     int height = info->d_height;
-    Uint32 *srcp = (Uint32 *)info->s_pixels;
+    Uint32 *srcp = (Uint32 *) info->s_pixels;
     int srcskip = info->s_skip >> 2;
-    Uint32 *dstp = (Uint32 *)info->d_pixels;
+    Uint32 *dstp = (Uint32 *) info->d_pixels;
     int dstskip = info->d_skip >> 2;
     SDL_PixelFormat *srcfmt = info->src;
     SDL_PixelFormat *dstfmt = info->dst;
-	unsigned sA = srcfmt->alpha;
-	unsigned dA = dstfmt->Amask ? SDL_ALPHA_OPAQUE : 0;
+    unsigned sA = srcfmt->alpha;
+    unsigned dA = dstfmt->Amask ? SDL_ALPHA_OPAQUE : 0;
     vector unsigned char mergePermute;
     vector unsigned char vsrcPermute;
     vector unsigned char vdstPermute;
@@ -1267,11 +1321,11 @@
     vsdstPermute = calc_swizzle32(dstfmt, NULL);
 
     /* set a vector full of alpha and 255-alpha */
-    ((unsigned char *)&valpha)[0] = alpha;
+    ((unsigned char *) &valpha)[0] = alpha;
     valpha = vec_splat(valpha, 0);
-    vbits = (vector unsigned char)vec_splat_s8(-1);
+    vbits = (vector unsigned char) vec_splat_s8(-1);
 
-    while(height--) {
+    while (height--) {
         int width = info->d_width;
 #define ONE_PIXEL_BLEND(condition, widthvar) while ((condition)) { \
             Uint32 Pixel; \
@@ -1288,19 +1342,19 @@
         if (width > 0) {
             int extrawidth = (width % 4);
             vector unsigned char valigner = vec_lvsl(0, srcp);
-            vector unsigned char vs = (vector unsigned char)vec_ld(0, srcp);
+            vector unsigned char vs = (vector unsigned char) vec_ld(0, srcp);
             width -= extrawidth;
             while (width) {
                 vector unsigned char voverflow;
                 vector unsigned char vd;
 
                 /* s = *srcp */
-                voverflow = (vector unsigned char)vec_ld(15, srcp);
+                voverflow = (vector unsigned char) vec_ld(15, srcp);
                 vs = vec_perm(vs, voverflow, valigner);
                 vs = vec_perm(vs, valpha, vsrcPermute);
-                
+
                 /* d = *dstp */
-                vd = (vector unsigned char)vec_ld(0, dstp);
+                vd = (vector unsigned char) vec_ld(0, dstp);
                 vd = vec_perm(vd, vd, vsdstPermute);
 
                 VEC_MULTIPLY_ALPHA(vs, vd, valpha, mergePermute, v1, v8);
@@ -1310,8 +1364,8 @@
                 vd = vec_perm(vd, vbits, vdstPermute);
 
                 /* *dstp = res */
-                vec_st((vector unsigned int)vd, 0, dstp);
-                
+                vec_st((vector unsigned int) vd, 0, dstp);
+
                 srcp += 4;
                 dstp += 4;
                 width -= 4;
@@ -1320,7 +1374,7 @@
             ONE_PIXEL_BLEND((extrawidth), extrawidth);
         }
 #undef ONE_PIXEL_BLEND
- 
+
         srcp += srcskip;
         dstp += dstskip;
     }
@@ -1329,13 +1383,14 @@
 
 
 /* fast RGB888->(A)RGB888 blending */
-static void BlitRGBtoRGBSurfaceAlphaAltivec(SDL_BlitInfo *info)
+static void
+BlitRGBtoRGBSurfaceAlphaAltivec(SDL_BlitInfo * info)
 {
-	unsigned alpha = info->src->alpha;
+    unsigned alpha = info->src->alpha;
     int height = info->d_height;
-    Uint32 *srcp = (Uint32 *)info->s_pixels;
+    Uint32 *srcp = (Uint32 *) info->s_pixels;
     int srcskip = info->s_skip >> 2;
-    Uint32 *dstp = (Uint32 *)info->d_pixels;
+    Uint32 *dstp = (Uint32 *) info->d_pixels;
     int dstskip = info->d_skip >> 2;
     vector unsigned char mergePermute;
     vector unsigned char valpha;
@@ -1351,10 +1406,10 @@
     valphamask = VEC_ALPHA_MASK();
 
     /* set a vector full of alpha and 255-alpha */
-    ((unsigned char *)&valpha)[0] = alpha;
+    ((unsigned char *) &valpha)[0] = alpha;
     valpha = vec_splat(valpha, 0);
 
-    while(height--) {
+    while (height--) {
         int width = info->d_width;
 #define ONE_PIXEL_BLEND(condition, widthvar) while ((condition)) { \
             Uint32 s = *srcp; \
@@ -1375,18 +1430,18 @@
         if (width > 0) {
             int extrawidth = (width % 4);
             vector unsigned char valigner = VEC_ALIGNER(srcp);
-            vector unsigned char vs = (vector unsigned char)vec_ld(0, srcp);
+            vector unsigned char vs = (vector unsigned char) vec_ld(0, srcp);
             width -= extrawidth;
             while (width) {
                 vector unsigned char voverflow;
                 vector unsigned char vd;
 
                 /* s = *srcp */
-                voverflow = (vector unsigned char)vec_ld(15, srcp);
+                voverflow = (vector unsigned char) vec_ld(15, srcp);
                 vs = vec_perm(vs, voverflow, valigner);
-                
+
                 /* d = *dstp */
-                vd = (vector unsigned char)vec_ld(0, dstp);
+                vd = (vector unsigned char) vec_ld(0, dstp);
 
                 VEC_MULTIPLY_ALPHA(vs, vd, valpha, mergePermute, v1, v8);
 
@@ -1394,8 +1449,8 @@
                 vd = vec_or(vd, valphamask);
 
                 /* *dstp = res */
-                vec_st((vector unsigned int)vd, 0, dstp);
-                
+                vec_st((vector unsigned int) vd, 0, dstp);
+
                 srcp += 4;
                 dstp += 4;
                 width -= 4;
@@ -1404,57 +1459,63 @@
             ONE_PIXEL_BLEND((extrawidth), extrawidth);
         }
 #undef ONE_PIXEL_BLEND
- 
+
         srcp += srcskip;
         dstp += dstskip;
     }
 }
+
 #if __MWERKS__
 #pragma altivec_model off
 #endif
 #endif /* SDL_ALTIVEC_BLITTERS */
 
 /* fast RGB888->(A)RGB888 blending with surface alpha=128 special case */
-static void BlitRGBtoRGBSurfaceAlpha128(SDL_BlitInfo *info)
+static void
+BlitRGBtoRGBSurfaceAlpha128(SDL_BlitInfo * info)
 {
-	int width = info->d_width;
-	int height = info->d_height;
-	Uint32 *srcp = (Uint32 *)info->s_pixels;
-	int srcskip = info->s_skip >> 2;
-	Uint32 *dstp = (Uint32 *)info->d_pixels;
-	int dstskip = info->d_skip >> 2;
+    int width = info->d_width;
+    int height = info->d_height;
+    Uint32 *srcp = (Uint32 *) info->s_pixels;
+    int srcskip = info->s_skip >> 2;
+    Uint32 *dstp = (Uint32 *) info->d_pixels;
+    int dstskip = info->d_skip >> 2;
 
-	while(height--) {
+    while (height--) {
+	    /* *INDENT-OFF* */
 	    DUFFS_LOOP4({
 		    Uint32 s = *srcp++;
 		    Uint32 d = *dstp;
 		    *dstp++ = ((((s & 0x00fefefe) + (d & 0x00fefefe)) >> 1)
 			       + (s & d & 0x00010101)) | 0xff000000;
 	    }, width);
-	    srcp += srcskip;
-	    dstp += dstskip;
-	}
+	    /* *INDENT-ON* */
+        srcp += srcskip;
+        dstp += dstskip;
+    }
 }
 
 /* fast RGB888->(A)RGB888 blending with surface alpha */
-static void BlitRGBtoRGBSurfaceAlpha(SDL_BlitInfo *info)
+static void
+BlitRGBtoRGBSurfaceAlpha(SDL_BlitInfo * info)
 {
-	unsigned alpha = info->src->alpha;
-	if(alpha == 128) {
-		BlitRGBtoRGBSurfaceAlpha128(info);
-	} else {
-		int width = info->d_width;
-		int height = info->d_height;
-		Uint32 *srcp = (Uint32 *)info->s_pixels;
-		int srcskip = info->s_skip >> 2;
-		Uint32 *dstp = (Uint32 *)info->d_pixels;
-		int dstskip = info->d_skip >> 2;
-		Uint32 s;
-		Uint32 d;
-		Uint32 s1;
-		Uint32 d1;
+    unsigned alpha = info->src->alpha;
+    if (alpha == 128) {
+        BlitRGBtoRGBSurfaceAlpha128(info);
+    } else {
+        int width = info->d_width;
+        int height = info->d_height;
+        Uint32 *srcp = (Uint32 *) info->s_pixels;
+        int srcskip = info->s_skip >> 2;
+        Uint32 *dstp = (Uint32 *) info->d_pixels;
+        int dstskip = info->d_skip >> 2;
+        Uint32 s;
+        Uint32 d;
+        Uint32 s1;
+        Uint32 d1;
 
-		while(height--) {
+        while (height--) {
+			/* *INDENT-OFF* */
 			DUFFS_LOOP_DOUBLE2({
 				/* One Pixel Blend */
 				s = *srcp;
@@ -1499,23 +1560,26 @@
 				++srcp;
 				++dstp;
 			}, width);
-			srcp += srcskip;
-			dstp += dstskip;
-		}
-	}
+			/* *INDENT-ON* */
+            srcp += srcskip;
+            dstp += dstskip;
+        }
+    }
 }
 
 /* fast ARGB888->(A)RGB888 blending with pixel alpha */
-static void BlitRGBtoRGBPixelAlpha(SDL_BlitInfo *info)
+static void
+BlitRGBtoRGBPixelAlpha(SDL_BlitInfo * info)
 {
-	int width = info->d_width;
-	int height = info->d_height;
-	Uint32 *srcp = (Uint32 *)info->s_pixels;
-	int srcskip = info->s_skip >> 2;
-	Uint32 *dstp = (Uint32 *)info->d_pixels;
-	int dstskip = info->d_skip >> 2;
+    int width = info->d_width;
+    int height = info->d_height;
+    Uint32 *srcp = (Uint32 *) info->s_pixels;
+    int srcskip = info->s_skip >> 2;
+    Uint32 *dstp = (Uint32 *) info->d_pixels;
+    int dstskip = info->d_skip >> 2;
 
-	while(height--) {
+    while (height--) {
+	    /* *INDENT-OFF* */
 	    DUFFS_LOOP4({
 		Uint32 dalpha;
 		Uint32 d;
@@ -1549,48 +1613,47 @@
 		++srcp;
 		++dstp;
 	    }, width);
-	    srcp += srcskip;
-	    dstp += dstskip;
-	}
+	    /* *INDENT-ON* */
+        srcp += srcskip;
+        dstp += dstskip;
+    }
 }
 
 #if GCC_ASMBLIT
 /* fast (as in MMX with prefetch) ARGB888->(A)RGB888 blending with pixel alpha */
-inline static void BlitRGBtoRGBPixelAlphaMMX3DNOW(SDL_BlitInfo *info)
+inline static void
+BlitRGBtoRGBPixelAlphaMMX3DNOW(SDL_BlitInfo * info)
 {
-	int width = info->d_width;
-	int height = info->d_height;
-	Uint32 *srcp = (Uint32 *)info->s_pixels;
-	int srcskip = info->s_skip >> 2;
-	Uint32 *dstp = (Uint32 *)info->d_pixels;
-	int dstskip = info->d_skip >> 2;
-	SDL_PixelFormat* sf = info->src;
-	Uint32 amask = sf->Amask;
+    int width = info->d_width;
+    int height = info->d_height;
+    Uint32 *srcp = (Uint32 *) info->s_pixels;
+    int srcskip = info->s_skip >> 2;
+    Uint32 *dstp = (Uint32 *) info->d_pixels;
+    int dstskip = info->d_skip >> 2;
+    SDL_PixelFormat *sf = info->src;
+    Uint32 amask = sf->Amask;
 
-	__asm__ (
-	/* make mm6 all zeros. */
-	"pxor       %%mm6, %%mm6\n"
-	
-	/* Make a mask to preserve the alpha. */
-	"movd      %0, %%mm7\n\t"           /* 0000F000 -> mm7 */
-	"punpcklbw %%mm7, %%mm7\n\t"        /* FF000000 -> mm7 */
-	"pcmpeqb   %%mm4, %%mm4\n\t"        /* FFFFFFFF -> mm4 */
-	"movq      %%mm4, %%mm3\n\t"        /* FFFFFFFF -> mm3 (for later) */
-	"pxor      %%mm4, %%mm7\n\t"        /* 00FFFFFF -> mm7 (mult mask) */
+    __asm__(
+               /* make mm6 all zeros. */
+               "pxor       %%mm6, %%mm6\n"
+               /* Make a mask to preserve the alpha. */
+               "movd      %0, %%mm7\n\t"        /* 0000F000 -> mm7 */
+               "punpcklbw %%mm7, %%mm7\n\t"     /* FF000000 -> mm7 */
+               "pcmpeqb   %%mm4, %%mm4\n\t"     /* FFFFFFFF -> mm4 */
+               "movq      %%mm4, %%mm3\n\t"     /* FFFFFFFF -> mm3 (for later) */
+               "pxor      %%mm4, %%mm7\n\t"     /* 00FFFFFF -> mm7 (mult mask) */
+               /* form channel masks */
+               "movq      %%mm7, %%mm4\n\t"     /* 00FFFFFF -> mm4 */
+               "packsswb  %%mm6, %%mm4\n\t"     /* 00000FFF -> mm4 (channel mask) */
+               "packsswb  %%mm6, %%mm3\n\t"     /* 0000FFFF -> mm3 */
+               "pxor      %%mm4, %%mm3\n\t"     /* 0000F000 -> mm3 (~channel mask) */
+               /* get alpha channel shift */
+               "movd      %1, %%mm5\n\t"        /* Ashift -> mm5 */
+  : /* nothing */ :            "m"(sf->Amask), "m"(sf->Ashift));
 
-	/* form channel masks */
-	"movq      %%mm7, %%mm4\n\t"        /* 00FFFFFF -> mm4 */
-	"packsswb  %%mm6, %%mm4\n\t"        /* 00000FFF -> mm4 (channel mask) */
-	"packsswb  %%mm6, %%mm3\n\t"        /* 0000FFFF -> mm3 */
-	"pxor      %%mm4, %%mm3\n\t"        /* 0000F000 -> mm3 (~channel mask) */
-	
-	/* get alpha channel shift */
-	"movd      %1, %%mm5\n\t" /* Ashift -> mm5 */
+    while (height--) {
 
-	  : /* nothing */ : "m" (sf->Amask), "m" (sf->Ashift) );
-
-	while(height--) {
-
+	    /* *INDENT-OFF* */
 	    DUFFS_LOOP4({
 		Uint32 alpha;
 
@@ -1662,39 +1725,43 @@
 		++srcp;
 		++dstp;
 	    }, width);
-	    srcp += srcskip;
-	    dstp += dstskip;
-	}
+	    /* *INDENT-ON* */
+        srcp += srcskip;
+        dstp += dstskip;
+    }
 
-	__asm__ (
-	"emms\n"
-		:   );
+  __asm__("emms\n":);
 }
+
 /* End GCC_ASMBLIT*/
 
 #elif MSVC_ASMBLIT
 /* fast (as in MMX with prefetch) ARGB888->(A)RGB888 blending with pixel alpha */
-static void BlitRGBtoRGBPixelAlphaMMX3DNOW(SDL_BlitInfo *info)
+static void
+BlitRGBtoRGBPixelAlphaMMX3DNOW(SDL_BlitInfo * info)
 {
-	int width = info->d_width;
-	int height = info->d_height;
-	Uint32 *srcp = (Uint32 *)info->s_pixels;
-	int srcskip = info->s_skip >> 2;
-	Uint32 *dstp = (Uint32 *)info->d_pixels;
-	int dstskip = info->d_skip >> 2;
-	SDL_PixelFormat* sf = info->src;
-	Uint32 chanmask = sf->Rmask | sf->Gmask | sf->Bmask;
-	Uint32 amask = sf->Amask;
-	Uint32 ashift = sf->Ashift;
-	Uint64 multmask;
-	
-	__m64 src1, dst1, mm_alpha, mm_zero, dmask;
+    int width = info->d_width;
+    int height = info->d_height;
+    Uint32 *srcp = (Uint32 *) info->s_pixels;
+    int srcskip = info->s_skip >> 2;
+    Uint32 *dstp = (Uint32 *) info->d_pixels;
+    int dstskip = info->d_skip >> 2;
+    SDL_PixelFormat *sf = info->src;
+    Uint32 chanmask = sf->Rmask | sf->Gmask | sf->Bmask;
+    Uint32 amask = sf->Amask;
+    Uint32 ashift = sf->Ashift;
+    Uint64 multmask;
 
-	mm_zero = _mm_setzero_si64(); /* 0 -> mm_zero */
-	multmask = ~(0xFFFFi64 << (ashift * 2));
-	dmask = *(__m64*) &multmask; /* dst alpha mask -> dmask */
+    __m64 src1, dst1, mm_alpha, mm_zero, dmask;
 
-	while(height--) {
+    mm_zero = _mm_setzero_si64();       /* 0 -> mm_zero */
+	/* *INDENT-OFF* */
+    multmask = ~(0xFFFFI64 << (ashift * 2));
+	/* *INDENT-ON* */
+    dmask = *(__m64 *) & multmask;      /* dst alpha mask -> dmask */
+
+    while (height--) {
+	    /* *INDENT-OFF* */
 	    DUFFS_LOOP4({
 		Uint32 alpha;
 
@@ -1732,11 +1799,13 @@
 		++srcp;
 		++dstp;
 	    }, width);
-	    srcp += srcskip;
-	    dstp += dstskip;
-	}
-	_mm_empty();
+	    /* *INDENT-ON* */
+        srcp += srcskip;
+        dstp += dstskip;
+    }
+    _mm_empty();
 }
+
 /* End MSVC_ASMBLIT */
 
 #endif /* GCC_ASMBLIT, MSVC_ASMBLIT */
@@ -1752,138 +1821,141 @@
 	(((s & (mask | mask << 16)) >> 1) + ((d & (mask | mask << 16)) >> 1) \
 	 + (s & d & (~(mask | mask << 16))))
 
-static void Blit16to16SurfaceAlpha128(SDL_BlitInfo *info, Uint16 mask)
+static void
+Blit16to16SurfaceAlpha128(SDL_BlitInfo * info, Uint16 mask)
 {
-	int width = info->d_width;
-	int height = info->d_height;
-	Uint16 *srcp = (Uint16 *)info->s_pixels;
-	int srcskip = info->s_skip >> 1;
-	Uint16 *dstp = (Uint16 *)info->d_pixels;
-	int dstskip = info->d_skip >> 1;
+    int width = info->d_width;
+    int height = info->d_height;
+    Uint16 *srcp = (Uint16 *) info->s_pixels;
+    int srcskip = info->s_skip >> 1;
+    Uint16 *dstp = (Uint16 *) info->d_pixels;
+    int dstskip = info->d_skip >> 1;
 
-	while(height--) {
-		if(((uintptr_t)srcp ^ (uintptr_t)dstp) & 2) {
-			/*
-			 * Source and destination not aligned, pipeline it.
-			 * This is mostly a win for big blits but no loss for
-			 * small ones
-			 */
-			Uint32 prev_sw;
-			int w = width;
+    while (height--) {
+        if (((uintptr_t) srcp ^ (uintptr_t) dstp) & 2) {
+            /*
+             * Source and destination not aligned, pipeline it.
+             * This is mostly a win for big blits but no loss for
+             * small ones
+             */
+            Uint32 prev_sw;
+            int w = width;
 
-			/* handle odd destination */
-			if((uintptr_t)dstp & 2) {
-				Uint16 d = *dstp, s = *srcp;
-				*dstp = BLEND16_50(d, s, mask);
-				dstp++;
-				srcp++;
-				w--;
-			}
-			srcp++;	/* srcp is now 32-bit aligned */
+            /* handle odd destination */
+            if ((uintptr_t) dstp & 2) {
+                Uint16 d = *dstp, s = *srcp;
+                *dstp = BLEND16_50(d, s, mask);
+                dstp++;
+                srcp++;
+                w--;
+            }
+            srcp++;             /* srcp is now 32-bit aligned */
 
-			/* bootstrap pipeline with first halfword */
-			prev_sw = ((Uint32 *)srcp)[-1];
+            /* bootstrap pipeline with first halfword */
+            prev_sw = ((Uint32 *) srcp)[-1];
 
-			while(w > 1) {
-				Uint32 sw, dw, s;
-				sw = *(Uint32 *)srcp;
-				dw = *(Uint32 *)dstp;
+            while (w > 1) {
+                Uint32 sw, dw, s;
+                sw = *(Uint32 *) srcp;
+                dw = *(Uint32 *) dstp;
 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-				s = (prev_sw << 16) + (sw >> 16);
+                s = (prev_sw << 16) + (sw >> 16);
 #else
-				s = (prev_sw >> 16) + (sw << 16);
+                s = (prev_sw >> 16) + (sw << 16);
 #endif
-				prev_sw = sw;
-				*(Uint32 *)dstp = BLEND2x16_50(dw, s, mask);
-				dstp += 2;
-				srcp += 2;
-				w -= 2;
-			}
+                prev_sw = sw;
+                *(Uint32 *) dstp = BLEND2x16_50(dw, s, mask);
+                dstp += 2;
+                srcp += 2;
+                w -= 2;
+            }
 
-			/* final pixel if any */
-			if(w) {
-				Uint16 d = *dstp, s;
+            /* final pixel if any */
+            if (w) {
+                Uint16 d = *dstp, s;
 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-				s = (Uint16)prev_sw;
+                s = (Uint16) prev_sw;
 #else
-				s = (Uint16)(prev_sw >> 16);
+                s = (Uint16) (prev_sw >> 16);
 #endif
-				*dstp = BLEND16_50(d, s, mask);
-				srcp++;
-				dstp++;
-			}
-			srcp += srcskip - 1;
-			dstp += dstskip;
-		} else {
-			/* source and destination are aligned */
-			int w = width;
+                *dstp = BLEND16_50(d, s, mask);
+                srcp++;
+                dstp++;
+            }
+            srcp += srcskip - 1;
+            dstp += dstskip;
+        } else {
+            /* source and destination are aligned */
+            int w = width;
 
-			/* first odd pixel? */
-			if((uintptr_t)srcp & 2) {
-				Uint16 d = *dstp, s = *srcp;
-				*dstp = BLEND16_50(d, s, mask);
-				srcp++;
-				dstp++;
-				w--;
-			}
-			/* srcp and dstp are now 32-bit aligned */
+            /* first odd pixel? */
+            if ((uintptr_t) srcp & 2) {
+                Uint16 d = *dstp, s = *srcp;
+                *dstp = BLEND16_50(d, s, mask);
+                srcp++;
+                dstp++;
+                w--;
+            }
+            /* srcp and dstp are now 32-bit aligned */
 
-			while(w > 1) {
-				Uint32 sw = *(Uint32 *)srcp;
-				Uint32 dw = *(Uint32 *)dstp;
-				*(Uint32 *)dstp = BLEND2x16_50(dw, sw, mask);
-				srcp += 2;
-				dstp += 2;
-				w -= 2;
-			}
+            while (w > 1) {
+                Uint32 sw = *(Uint32 *) srcp;
+                Uint32 dw = *(Uint32 *) dstp;
+                *(Uint32 *) dstp = BLEND2x16_50(dw, sw, mask);
+                srcp += 2;
+                dstp += 2;
+                w -= 2;
+            }
 
-			/* last odd pixel? */
-			if(w) {
-				Uint16 d = *dstp, s = *srcp;
-				*dstp = BLEND16_50(d, s, mask);
-				srcp++;
-				dstp++;
-			}
-			srcp += srcskip;
-			dstp += dstskip;
-		}
-	}
+            /* last odd pixel? */
+            if (w) {
+                Uint16 d = *dstp, s = *srcp;
+                *dstp = BLEND16_50(d, s, mask);
+                srcp++;
+                dstp++;
+            }
+            srcp += srcskip;
+            dstp += dstskip;
+        }
+    }
 }
 
 #if GCC_ASMBLIT
 /* fast RGB565->RGB565 blending with surface alpha */
-static void Blit565to565SurfaceAlphaMMX(SDL_BlitInfo *info)
+static void
+Blit565to565SurfaceAlphaMMX(SDL_BlitInfo * info)
 {
-	unsigned alpha = info->src->alpha; /* downscale alpha to 5 bits */
-	if(alpha == 128) {
-		Blit16to16SurfaceAlpha128(info, 0xf7de);
-	} else {
-		int width = info->d_width;
-		int height = info->d_height;
-		Uint16 *srcp = (Uint16 *)info->s_pixels;
-		int srcskip = info->s_skip >> 1;
-		Uint16 *dstp = (Uint16 *)info->d_pixels;
-		int dstskip = info->d_skip >> 1;
-		Uint32 s, d;
-		Uint8 load[8];
-	  
-		alpha &= ~(1+2+4);		/* cut alpha to get the exact same behaviour */
-		*(Uint64 *)load = alpha;
-		alpha >>= 3;		/* downscale alpha to 5 bits */
+    unsigned alpha = info->src->alpha;  /* downscale alpha to 5 bits */
+    if (alpha == 128) {
+        Blit16to16SurfaceAlpha128(info, 0xf7de);
+    } else {
+        int width = info->d_width;
+        int height = info->d_height;
+        Uint16 *srcp = (Uint16 *) info->s_pixels;
+        int srcskip = info->s_skip >> 1;
+        Uint16 *dstp = (Uint16 *) info->d_pixels;
+        int dstskip = info->d_skip >> 1;
+        Uint32 s, d;
+        Uint8 load[8];
 
-		movq_m2r(*load, mm0); /* alpha(0000000A) -> mm0 */
-		punpcklwd_r2r(mm0, mm0); /* 00000A0A -> mm0 */
-		punpcklwd_r2r(mm0, mm0); /* 0A0A0A0A -> mm0 */
-		/* position alpha to allow for mullo and mulhi on diff channels
-		   to reduce the number of operations */
-		psllq_i2r(3, mm0);
-	  
-		/* Setup the 565 color channel masks */
-		*(Uint64 *)load = 0x07E007E007E007E0ULL;
-		movq_m2r(*load, mm4); /* MASKGREEN -> mm4 */
-		*(Uint64 *)load = 0x001F001F001F001FULL;
-		movq_m2r(*load, mm7); /* MASKBLUE -> mm7 */
-		while(height--) {
+        alpha &= ~(1 + 2 + 4);  /* cut alpha to get the exact same behaviour */
+        *(Uint64 *) load = alpha;
+        alpha >>= 3;            /* downscale alpha to 5 bits */
+
+        movq_m2r(*load, mm0);   /* alpha(0000000A) -> mm0 */
+        punpcklwd_r2r(mm0, mm0);        /* 00000A0A -> mm0 */
+        punpcklwd_r2r(mm0, mm0);        /* 0A0A0A0A -> mm0 */
+        /* position alpha to allow for mullo and mulhi on diff channels
+           to reduce the number of operations */
+        psllq_i2r(3, mm0);
+
+        /* Setup the 565 color channel masks */
+        *(Uint64 *) load = 0x07E007E007E007E0ULL;
+        movq_m2r(*load, mm4);   /* MASKGREEN -> mm4 */
+        *(Uint64 *) load = 0x001F001F001F001FULL;
+        movq_m2r(*load, mm7);   /* MASKBLUE -> mm7 */
+        while (height--) {
+			/* *INDENT-OFF* */
 			DUFFS_LOOP_QUATRO2(
 			{
 				s = *srcp++;
@@ -1983,46 +2055,49 @@
 				srcp += 4;
 				dstp += 4;
 			}, width);			
-			srcp += srcskip;
-			dstp += dstskip;
-		}
-		emms();
-	}
+			/* *INDENT-ON* */
+            srcp += srcskip;
+            dstp += dstskip;
+        }
+        emms();
+    }
 }
 
 /* fast RGB555->RGB555 blending with surface alpha */
-static void Blit555to555SurfaceAlphaMMX(SDL_BlitInfo *info)
+static void
+Blit555to555SurfaceAlphaMMX(SDL_BlitInfo * info)
 {
-	unsigned alpha = info->src->alpha; /* downscale alpha to 5 bits */
-	if(alpha == 128) {
-		Blit16to16SurfaceAlpha128(info, 0xfbde);
-	} else {
-		int width = info->d_width;
-		int height = info->d_height;
-		Uint16 *srcp = (Uint16 *)info->s_pixels;
-		int srcskip = info->s_skip >> 1;
-		Uint16 *dstp = (Uint16 *)info->d_pixels;
-		int dstskip = info->d_skip >> 1;
-		Uint32 s, d;
-		Uint8 load[8];
-	  
-		alpha &= ~(1+2+4);		/* cut alpha to get the exact same behaviour */
-		*(Uint64 *)load = alpha;
-		alpha >>= 3;		/* downscale alpha to 5 bits */
+    unsigned alpha = info->src->alpha;  /* downscale alpha to 5 bits */
+    if (alpha == 128) {
+        Blit16to16SurfaceAlpha128(info, 0xfbde);
+    } else {
+        int width = info->d_width;
+        int height = info->d_height;
+        Uint16 *srcp = (Uint16 *) info->s_pixels;
+        int srcskip = info->s_skip >> 1;
+        Uint16 *dstp = (Uint16 *) info->d_pixels;
+        int dstskip = info->d_skip >> 1;
+        Uint32 s, d;
+        Uint8 load[8];
 
-		movq_m2r(*load, mm0); /* alpha(0000000A) -> mm0 */
-		punpcklwd_r2r(mm0, mm0); /* 00000A0A -> mm0 */
-		punpcklwd_r2r(mm0, mm0); /* 0A0A0A0A -> mm0 */
-		/* position alpha to allow for mullo and mulhi on diff channels
-		   to reduce the number of operations */
-		psllq_i2r(3, mm0);
+        alpha &= ~(1 + 2 + 4);  /* cut alpha to get the exact same behaviour */
+        *(Uint64 *) load = alpha;
+        alpha >>= 3;            /* downscale alpha to 5 bits */
 
-		/* Setup the 555 color channel masks */
-		*(Uint64 *)load = 0x03E003E003E003E0ULL;
-		movq_m2r(*load, mm4); /* MASKGREEN -> mm4 */
-		*(Uint64 *)load = 0x001F001F001F001FULL;
-		movq_m2r(*load, mm7); /* MASKBLUE -> mm7 */
-		while(height--) {
+        movq_m2r(*load, mm0);   /* alpha(0000000A) -> mm0 */
+        punpcklwd_r2r(mm0, mm0);        /* 00000A0A -> mm0 */
+        punpcklwd_r2r(mm0, mm0);        /* 0A0A0A0A -> mm0 */
+        /* position alpha to allow for mullo and mulhi on diff channels
+           to reduce the number of operations */
+        psllq_i2r(3, mm0);
+
+        /* Setup the 555 color channel masks */
+        *(Uint64 *) load = 0x03E003E003E003E0ULL;
+        movq_m2r(*load, mm4);   /* MASKGREEN -> mm4 */
+        *(Uint64 *) load = 0x001F001F001F001FULL;
+        movq_m2r(*load, mm7);   /* MASKBLUE -> mm7 */
+        while (height--) {
+			/* *INDENT-OFF* */
 			DUFFS_LOOP_QUATRO2(
 			{
 				s = *srcp++;
@@ -2126,48 +2201,52 @@
 
 				srcp += 4;
 				dstp += 4;
-			}, width);			
-			srcp += srcskip;
-			dstp += dstskip;
-		}
-		emms();
-	}
+			}, width);
+			/* *INDENT-ON* */
+            srcp += srcskip;
+            dstp += dstskip;
+        }
+        emms();
+    }
 }
+
 /* End GCC_ASMBLIT */
 
 #elif MSVC_ASMBLIT
 /* fast RGB565->RGB565 blending with surface alpha */
-static void Blit565to565SurfaceAlphaMMX(SDL_BlitInfo *info)
+static void
+Blit565to565SurfaceAlphaMMX(SDL_BlitInfo * info)
 {
-	unsigned alpha = info->src->alpha;
-	if(alpha == 128) {
-		Blit16to16SurfaceAlpha128(info, 0xf7de);
-	} else {
-		int width = info->d_width;
-		int height = info->d_height;
-		Uint16 *srcp = (Uint16 *)info->s_pixels;
-		int srcskip = info->s_skip >> 1;
-		Uint16 *dstp = (Uint16 *)info->d_pixels;
-		int dstskip = info->d_skip >> 1;
-		Uint32 s, d;
-	  
-		__m64 src1, dst1, src2, dst2, gmask, bmask, mm_res, mm_alpha;
+    unsigned alpha = info->src->alpha;
+    if (alpha == 128) {
+        Blit16to16SurfaceAlpha128(info, 0xf7de);
+    } else {
+        int width = info->d_width;
+        int height = info->d_height;
+        Uint16 *srcp = (Uint16 *) info->s_pixels;
+        int srcskip = info->s_skip >> 1;
+        Uint16 *dstp = (Uint16 *) info->d_pixels;
+        int dstskip = info->d_skip >> 1;
+        Uint32 s, d;
+
+        __m64 src1, dst1, src2, dst2, gmask, bmask, mm_res, mm_alpha;
 
-		alpha &= ~(1+2+4);		/* cut alpha to get the exact same behaviour */
-		mm_alpha = _mm_set_pi32(0, alpha); /* 0000000A -> mm_alpha */
-		alpha >>= 3;		/* downscale alpha to 5 bits */
+        alpha &= ~(1 + 2 + 4);  /* cut alpha to get the exact same behaviour */
+        mm_alpha = _mm_set_pi32(0, alpha);      /* 0000000A -> mm_alpha */
+        alpha >>= 3;            /* downscale alpha to 5 bits */
 
-		mm_alpha = _mm_unpacklo_pi16(mm_alpha, mm_alpha); /* 00000A0A -> mm_alpha */
-		mm_alpha = _mm_unpacklo_pi32(mm_alpha, mm_alpha); /* 0A0A0A0A -> mm_alpha */
-		/* position alpha to allow for mullo and mulhi on diff channels
-		   to reduce the number of operations */
-		mm_alpha = _mm_slli_si64(mm_alpha, 3);
-	  
-		/* Setup the 565 color channel masks */
-		gmask = _mm_set_pi32(0x07E007E0, 0x07E007E0); /* MASKGREEN -> gmask */
-		bmask = _mm_set_pi32(0x001F001F, 0x001F001F); /* MASKBLUE -> bmask */
-		
-		while(height--) {
+        mm_alpha = _mm_unpacklo_pi16(mm_alpha, mm_alpha);       /* 00000A0A -> mm_alpha */
+        mm_alpha = _mm_unpacklo_pi32(mm_alpha, mm_alpha);       /* 0A0A0A0A -> mm_alpha */
+        /* position alpha to allow for mullo and mulhi on diff channels
+           to reduce the number of operations */
+        mm_alpha = _mm_slli_si64(mm_alpha, 3);
+
+        /* Setup the 565 color channel masks */
+        gmask = _mm_set_pi32(0x07E007E0, 0x07E007E0);   /* MASKGREEN -> gmask */
+        bmask = _mm_set_pi32(0x001F001F, 0x001F001F);   /* MASKBLUE -> bmask */
+
+        while (height--) {
+			/* *INDENT-OFF* */
 			DUFFS_LOOP_QUATRO2(
 			{
 				s = *srcp++;
@@ -2262,47 +2341,50 @@
 
 				srcp += 4;
 				dstp += 4;
-			}, width);			
-			srcp += srcskip;
-			dstp += dstskip;
-		}
-		_mm_empty();
-	}
+			}, width);
+			/* *INDENT-ON* */
+            srcp += srcskip;
+            dstp += dstskip;
+        }
+        _mm_empty();
+    }
 }
 
 /* fast RGB555->RGB555 blending with surface alpha */
-static void Blit555to555SurfaceAlphaMMX(SDL_BlitInfo *info)
+static void
+Blit555to555SurfaceAlphaMMX(SDL_BlitInfo * info)
 {
-	unsigned alpha = info->src->alpha;
-	if(alpha == 128) {
-		Blit16to16SurfaceAlpha128(info, 0xfbde);
-	} else {
-		int width = info->d_width;
-		int height = info->d_height;
-		Uint16 *srcp = (Uint16 *)info->s_pixels;
-		int srcskip = info->s_skip >> 1;
-		Uint16 *dstp = (Uint16 *)info->d_pixels;
-		int dstskip = info->d_skip >> 1;
-		Uint32 s, d;
-	  
-		__m64 src1, dst1, src2, dst2, rmask, gmask, bmask, mm_res, mm_alpha;
+    unsigned alpha = info->src->alpha;
+    if (alpha == 128) {
+        Blit16to16SurfaceAlpha128(info, 0xfbde);
+    } else {
+        int width = info->d_width;
+        int height = info->d_height;
+        Uint16 *srcp = (Uint16 *) info->s_pixels;
+        int srcskip = info->s_skip >> 1;
+        Uint16 *dstp = (Uint16 *) info->d_pixels;
+        int dstskip = info->d_skip >> 1;
+        Uint32 s, d;
+
+        __m64 src1, dst1, src2, dst2, rmask, gmask, bmask, mm_res, mm_alpha;
 
-		alpha &= ~(1+2+4);		/* cut alpha to get the exact same behaviour */
-		mm_alpha = _mm_set_pi32(0, alpha); /* 0000000A -> mm_alpha */
-		alpha >>= 3;		/* downscale alpha to 5 bits */
+        alpha &= ~(1 + 2 + 4);  /* cut alpha to get the exact same behaviour */
+        mm_alpha = _mm_set_pi32(0, alpha);      /* 0000000A -> mm_alpha */
+        alpha >>= 3;            /* downscale alpha to 5 bits */
 
-		mm_alpha = _mm_unpacklo_pi16(mm_alpha, mm_alpha); /* 00000A0A -> mm_alpha */
-		mm_alpha = _mm_unpacklo_pi32(mm_alpha, mm_alpha); /* 0A0A0A0A -> mm_alpha */
-		/* position alpha to allow for mullo and mulhi on diff channels
-		   to reduce the number of operations */
-		mm_alpha = _mm_slli_si64(mm_alpha, 3);
-	  
-		/* Setup the 555 color channel masks */
-		rmask = _mm_set_pi32(0x7C007C00, 0x7C007C00); /* MASKRED -> rmask */
-		gmask = _mm_set_pi32(0x03E003E0, 0x03E003E0); /* MASKGREEN -> gmask */
-		bmask = _mm_set_pi32(0x001F001F, 0x001F001F); /* MASKBLUE -> bmask */
+        mm_alpha = _mm_unpacklo_pi16(mm_alpha, mm_alpha);       /* 00000A0A -> mm_alpha */
+        mm_alpha = _mm_unpacklo_pi32(mm_alpha, mm_alpha);       /* 0A0A0A0A -> mm_alpha */
+        /* position alpha to allow for mullo and mulhi on diff channels
+           to reduce the number of operations */
+        mm_alpha = _mm_slli_si64(mm_alpha, 3);
 
-		while(height--) {
+        /* Setup the 555 color channel masks */
+        rmask = _mm_set_pi32(0x7C007C00, 0x7C007C00);   /* MASKRED -> rmask */
+        gmask = _mm_set_pi32(0x03E003E0, 0x03E003E0);   /* MASKGREEN -> gmask */
+        bmask = _mm_set_pi32(0x001F001F, 0x001F001F);   /* MASKBLUE -> bmask */
+
+        while (height--) {
+			/* *INDENT-OFF* */
 			DUFFS_LOOP_QUATRO2(
 			{
 				s = *srcp++;
@@ -2397,31 +2479,34 @@
 
 				srcp += 4;
 				dstp += 4;
-			}, width);			
-			srcp += srcskip;
-			dstp += dstskip;
-		}
-		_mm_empty();
-	}
+			}, width);
+			/* *INDENT-ON* */
+            srcp += srcskip;
+            dstp += dstskip;
+        }
+        _mm_empty();
+    }
 }
 #endif /* GCC_ASMBLIT, MSVC_ASMBLIT */
 
 /* fast RGB565->RGB565 blending with surface alpha */
-static void Blit565to565SurfaceAlpha(SDL_BlitInfo *info)
+static void
+Blit565to565SurfaceAlpha(SDL_BlitInfo * info)
 {
-	unsigned alpha = info->src->alpha;
-	if(alpha == 128) {
-		Blit16to16SurfaceAlpha128(info, 0xf7de);
-	} else {
-		int width = info->d_width;
-		int height = info->d_height;
-		Uint16 *srcp = (Uint16 *)info->s_pixels;
-		int srcskip = info->s_skip >> 1;
-		Uint16 *dstp = (Uint16 *)info->d_pixels;
-		int dstskip = info->d_skip >> 1;
-		alpha >>= 3;	/* downscale alpha to 5 bits */
+    unsigned alpha = info->src->alpha;
+    if (alpha == 128) {
+        Blit16to16SurfaceAlpha128(info, 0xf7de);
+    } else {
+        int width = info->d_width;
+        int height = info->d_height;
+        Uint16 *srcp = (Uint16 *) info->s_pixels;
+        int srcskip = info->s_skip >> 1;
+        Uint16 *dstp = (Uint16 *) info->d_pixels;
+        int dstskip = info->d_skip >> 1;
+        alpha >>= 3;            /* downscale alpha to 5 bits */
 
-		while(height--) {
+        while (height--) {
+			/* *INDENT-OFF* */
 			DUFFS_LOOP4({
 				Uint32 s = *srcp++;
 				Uint32 d = *dstp;
@@ -2436,28 +2521,31 @@
 				d &= 0x07e0f81f;
 				*dstp++ = (Uint16)(d | d >> 16);
 			}, width);
-			srcp += srcskip;
-			dstp += dstskip;
-		}
-	}
+			/* *INDENT-ON* */
+            srcp += srcskip;
+            dstp += dstskip;
+        }
+    }
 }
 
 /* fast RGB555->RGB555 blending with surface alpha */
-static void Blit555to555SurfaceAlpha(SDL_BlitInfo *info)
+static void
+Blit555to555SurfaceAlpha(SDL_BlitInfo * info)
 {
-	unsigned alpha = info->src->alpha; /* downscale alpha to 5 bits */
-	if(alpha == 128) {
-		Blit16to16SurfaceAlpha128(info, 0xfbde);
-	} else {
-		int width = info->d_width;
-		int height = info->d_height;
-		Uint16 *srcp = (Uint16 *)info->s_pixels;
-		int srcskip = info->s_skip >> 1;
-		Uint16 *dstp = (Uint16 *)info->d_pixels;
-		int dstskip = info->d_skip >> 1;
-		alpha >>= 3;		/* downscale alpha to 5 bits */
+    unsigned alpha = info->src->alpha;  /* downscale alpha to 5 bits */
+    if (alpha == 128) {
+        Blit16to16SurfaceAlpha128(info, 0xfbde);
+    } else {
+        int width = info->d_width;
+        int height = info->d_height;
+        Uint16 *srcp = (Uint16 *) info->s_pixels;
+        int srcskip = info->s_skip >> 1;
+        Uint16 *dstp = (Uint16 *) info->d_pixels;
+        int dstskip = info->d_skip >> 1;
+        alpha >>= 3;            /* downscale alpha to 5 bits */
 
-		while(height--) {
+        while (height--) {
+			/* *INDENT-OFF* */
 			DUFFS_LOOP4({
 				Uint32 s = *srcp++;
 				Uint32 d = *dstp;
@@ -2472,23 +2560,26 @@
 				d &= 0x03e07c1f;
 				*dstp++ = (Uint16)(d | d >> 16);
 			}, width);
-			srcp += srcskip;
-			dstp += dstskip;
-		}
-	}
+			/* *INDENT-ON* */
+            srcp += srcskip;
+            dstp += dstskip;
+        }
+    }
 }
 
 /* fast ARGB8888->RGB565 blending with pixel alpha */
-static void BlitARGBto565PixelAlpha(SDL_BlitInfo *info)
+static void
+BlitARGBto565PixelAlpha(SDL_BlitInfo * info)
 {
-	int width = info->d_width;
-	int height = info->d_height;
-	Uint32 *srcp = (Uint32 *)info->s_pixels;
-	int srcskip = info->s_skip >> 2;
-	Uint16 *dstp = (Uint16 *)info->d_pixels;
-	int dstskip = info->d_skip >> 1;
+    int width = info->d_width;
+    int height = info->d_height;
+    Uint32 *srcp = (Uint32 *) info->s_pixels;
+    int srcskip = info->s_skip >> 2;
+    Uint16 *dstp = (Uint16 *) info->d_pixels;
+    int dstskip = info->d_skip >> 1;
 
-	while(height--) {
+    while (height--) {
+	    /* *INDENT-OFF* */
 	    DUFFS_LOOP4({
 		Uint32 s = *srcp;
 		unsigned alpha = s >> 27; /* downscale alpha to 5 bits */
@@ -2516,22 +2607,25 @@
 		srcp++;
 		dstp++;
 	    }, width);
-	    srcp += srcskip;
-	    dstp += dstskip;
-	}
+	    /* *INDENT-ON* */
+        srcp += srcskip;
+        dstp += dstskip;
+    }
 }
 
 /* fast ARGB8888->RGB555 blending with pixel alpha */
-static void BlitARGBto555PixelAlpha(SDL_BlitInfo *info)
+static void
+BlitARGBto555PixelAlpha(SDL_BlitInfo * info)
 {
-	int width = info->d_width;
-	int height = info->d_height;
-	Uint32 *srcp = (Uint32 *)info->s_pixels;
-	int srcskip = info->s_skip >> 2;
-	Uint16 *dstp = (Uint16 *)info->d_pixels;
-	int dstskip = info->d_skip >> 1;
+    int width = info->d_width;
+    int height = info->d_height;
+    Uint32 *srcp = (Uint32 *) info->s_pixels;
+    int srcskip = info->s_skip >> 2;
+    Uint16 *dstp = (Uint16 *) info->d_pixels;
+    int dstskip = info->d_skip >> 1;
 
-	while(height--) {
+    while (height--) {
+	    /* *INDENT-OFF* */
 	    DUFFS_LOOP4({
 		unsigned alpha;
 		Uint32 s = *srcp;
@@ -2560,29 +2654,32 @@
 		srcp++;
 		dstp++;
 	    }, width);
-	    srcp += srcskip;
-	    dstp += dstskip;
-	}
+	    /* *INDENT-ON* */
+        srcp += srcskip;
+        dstp += dstskip;
+    }
 }
 
 /* General (slow) N->N blending with per-surface alpha */
-static void BlitNtoNSurfaceAlpha(SDL_BlitInfo *info)
+static void
+BlitNtoNSurfaceAlpha(SDL_BlitInfo * info)
 {
-	int width = info->d_width;
-	int height = info->d_height;
-	Uint8 *src = info->s_pixels;
-	int srcskip = info->s_skip;
-	Uint8 *dst = info->d_pixels;
-	int dstskip = info->d_skip;
-	SDL_PixelFormat *srcfmt = info->src;
-	SDL_PixelFormat *dstfmt = info->dst;
-	int srcbpp = srcfmt->BytesPerPixel;
-	int dstbpp = dstfmt->BytesPerPixel;
-	unsigned sA = srcfmt->alpha;
-	unsigned dA = dstfmt->Amask ? SDL_ALPHA_OPAQUE : 0;
+    int width = info->d_width;
+    int height = info->d_height;
+    Uint8 *src = info->s_pixels;
+    int srcskip = info->s_skip;
+    Uint8 *dst = info->d_pixels;
+    int dstskip = info->d_skip;
+    SDL_PixelFormat *srcfmt = info->src;
+    SDL_PixelFormat *dstfmt = info->dst;
+    int srcbpp = srcfmt->BytesPerPixel;
+    int dstbpp = dstfmt->BytesPerPixel;
+    unsigned sA = srcfmt->alpha;
+    unsigned dA = dstfmt->Amask ? SDL_ALPHA_OPAQUE : 0;
 
-	if(sA) {
-	  while ( height-- ) {
+    if (sA) {
+        while (height--) {
+	    /* *INDENT-OFF* */
 	    DUFFS_LOOP4(
 	    {
 		Uint32 Pixel;
@@ -2600,30 +2697,33 @@
 		dst += dstbpp;
 	    },
 	    width);
-	    src += srcskip;
-	    dst += dstskip;
-	  }
-	}
+	    /* *INDENT-ON* */
+            src += srcskip;
+            dst += dstskip;
+        }
+    }
 }
 
 /* General (slow) colorkeyed N->N blending with per-surface alpha */
-static void BlitNtoNSurfaceAlphaKey(SDL_BlitInfo *info)
+static void
+BlitNtoNSurfaceAlphaKey(SDL_BlitInfo * info)
 {
-	int width = info->d_width;
-	int height = info->d_height;
-	Uint8 *src = info->s_pixels;
-	int srcskip = info->s_skip;
-	Uint8 *dst = info->d_pixels;
-	int dstskip = info->d_skip;
-	SDL_PixelFormat *srcfmt = info->src;
-	SDL_PixelFormat *dstfmt = info->dst;
-	Uint32 ckey = srcfmt->colorkey;
-	int srcbpp = srcfmt->BytesPerPixel;
-	int dstbpp = dstfmt->BytesPerPixel;
-	unsigned sA = srcfmt->alpha;
-	unsigned dA = dstfmt->Amask ? SDL_ALPHA_OPAQUE : 0;
+    int width = info->d_width;
+    int height = info->d_height;
+    Uint8 *src = info->s_pixels;
+    int srcskip = info->s_skip;
+    Uint8 *dst = info->d_pixels;
+    int dstskip = info->d_skip;
+    SDL_PixelFormat *srcfmt = info->src;
+    SDL_PixelFormat *dstfmt = info->dst;
+    Uint32 ckey = srcfmt->colorkey;
+    int srcbpp = srcfmt->BytesPerPixel;
+    int dstbpp = dstfmt->BytesPerPixel;
+    unsigned sA = srcfmt->alpha;
+    unsigned dA = dstfmt->Amask ? SDL_ALPHA_OPAQUE : 0;
 
-	while ( height-- ) {
+    while (height--) {
+	    /* *INDENT-OFF* */
 	    DUFFS_LOOP4(
 	    {
 		Uint32 Pixel;
@@ -2644,36 +2744,39 @@
 		dst += dstbpp;
 	    },
 	    width);
-	    src += srcskip;
-	    dst += dstskip;
-	}
+	    /* *INDENT-ON* */
+        src += srcskip;
+        dst += dstskip;
+    }
 }
 
 /* General (slow) N->N blending with pixel alpha */
-static void BlitNtoNPixelAlpha(SDL_BlitInfo *info)
+static void
+BlitNtoNPixelAlpha(SDL_BlitInfo * info)
 {
-	int width = info->d_width;
-	int height = info->d_height;
-	Uint8 *src = info->s_pixels;
-	int srcskip = info->s_skip;
-	Uint8 *dst = info->d_pixels;
-	int dstskip = info->d_skip;
-	SDL_PixelFormat *srcfmt = info->src;
-	SDL_PixelFormat *dstfmt = info->dst;
+    int width = info->d_width;
+    int height = info->d_height;
+    Uint8 *src = info->s_pixels;
+    int srcskip = info->s_skip;
+    Uint8 *dst = info->d_pixels;
+    int dstskip = info->d_skip;
+    SDL_PixelFormat *srcfmt = info->src;
+    SDL_PixelFormat *dstfmt = info->dst;
 
-	int  srcbpp;
-	int  dstbpp;
+    int srcbpp;
+    int dstbpp;
 
-	/* Set up some basic variables */
-	srcbpp = srcfmt->BytesPerPixel;
-	dstbpp = dstfmt->BytesPerPixel;
+    /* Set up some basic variables */
+    srcbpp = srcfmt->BytesPerPixel;
+    dstbpp = dstfmt->BytesPerPixel;
 
-	/* FIXME: for 8bpp source alpha, this doesn't get opaque values
-	   quite right. for <8bpp source alpha, it gets them very wrong
-	   (check all macros!)
-	   It is unclear whether there is a good general solution that doesn't
-	   need a branch (or a divide). */
-	while ( height-- ) {
+    /* FIXME: for 8bpp source alpha, this doesn't get opaque values
+       quite right. for <8bpp source alpha, it gets them very wrong
+       (check all macros!)
+       It is unclear whether there is a good general solution that doesn't
+       need a branch (or a divide). */
+    while (height--) {
+	    /* *INDENT-OFF* */
 	    DUFFS_LOOP4(
 	    {
 		Uint32 Pixel;
@@ -2695,160 +2798,155 @@
 		dst += dstbpp;
 	    },
 	    width);
-	    src += srcskip;
-	    dst += dstskip;
-	}
+	    /* *INDENT-ON* */
+        src += srcskip;
+        dst += dstskip;
+    }
 }
 
 
-SDL_loblit SDL_CalculateAlphaBlit(SDL_Surface *surface, int blit_index)
+SDL_loblit
+SDL_CalculateAlphaBlit(SDL_Surface * surface, int blit_index)
 {
     SDL_PixelFormat *sf = surface->format;
     SDL_PixelFormat *df = surface->map->dst->format;
 
-    if(sf->Amask == 0) {
-	if((surface->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {
-	    if(df->BytesPerPixel == 1)
-		return BlitNto1SurfaceAlphaKey;
-	    else
+    if (sf->Amask == 0) {
+        if ((surface->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {
+            if (df->BytesPerPixel == 1)
+                return BlitNto1SurfaceAlphaKey;
+            else
 #if SDL_ALTIVEC_BLITTERS
-	if (sf->BytesPerPixel == 4 && df->BytesPerPixel == 4 &&
-	    !(surface->map->dst->flags & SDL_HWSURFACE) && SDL_HasAltiVec())
-            return Blit32to32SurfaceAlphaKeyAltivec;
-        else
+                if (sf->BytesPerPixel == 4 && df->BytesPerPixel == 4 &&
+                    !(surface->map->dst->flags & SDL_HWSURFACE)
+                    && SDL_HasAltiVec())
+                return Blit32to32SurfaceAlphaKeyAltivec;
+            else
 #endif
-            return BlitNtoNSurfaceAlphaKey;
-	} else {
-	    /* Per-surface alpha blits */
-	    switch(df->BytesPerPixel) {
-	    case 1:
-		return BlitNto1SurfaceAlpha;
+                return BlitNtoNSurfaceAlphaKey;
+        } else {
+            /* Per-surface alpha blits */
+            switch (df->BytesPerPixel) {
+            case 1:
+                return BlitNto1SurfaceAlpha;
 
-	    case 2:
-		if(surface->map->identity) {
-		    if(df->Gmask == 0x7e0)
-		    {
+            case 2:
+                if (surface->map->identity) {
+                    if (df->Gmask == 0x7e0) {
 #if MMX_ASMBLIT
-		if(SDL_HasMMX())
-			return Blit565to565SurfaceAlphaMMX;
-		else
-#endif
-			return Blit565to565SurfaceAlpha;
-		    }
-		    else if(df->Gmask == 0x3e0)
-		    {
-#if MMX_ASMBLIT
-		if(SDL_HasMMX())
-			return Blit555to555SurfaceAlphaMMX;
-		else
+                        if (SDL_HasMMX())
+                            return Blit565to565SurfaceAlphaMMX;
+                        else
 #endif
-			return Blit555to555SurfaceAlpha;
-		    }
-		}
-		return BlitNtoNSurfaceAlpha;
-
-	    case 4:
-		if(sf->Rmask == df->Rmask
-		   && sf->Gmask == df->Gmask
-		   && sf->Bmask == df->Bmask
-		   && sf->BytesPerPixel == 4)
-		{
+                            return Blit565to565SurfaceAlpha;
+                    } else if (df->Gmask == 0x3e0) {
 #if MMX_ASMBLIT
-			if(sf->Rshift % 8 == 0
-			   && sf->Gshift % 8 == 0
-			   && sf->Bshift % 8 == 0
-			   && SDL_HasMMX())
-			    return BlitRGBtoRGBSurfaceAlphaMMX;
+                        if (SDL_HasMMX())
+                            return Blit555to555SurfaceAlphaMMX;
+                        else
 #endif
-			if((sf->Rmask | sf->Gmask | sf->Bmask) == 0xffffff)
-			{
-#if SDL_ALTIVEC_BLITTERS
-				if(!(surface->map->dst->flags & SDL_HWSURFACE)
-					&& SDL_HasAltiVec())
-					return BlitRGBtoRGBSurfaceAlphaAltivec;
+                            return Blit555to555SurfaceAlpha;
+                    }
+                }
+                return BlitNtoNSurfaceAlpha;
+
+            case 4:
+                if (sf->Rmask == df->Rmask
+                    && sf->Gmask == df->Gmask
+                    && sf->Bmask == df->Bmask && sf->BytesPerPixel == 4) {
+#if MMX_ASMBLIT
+                    if (sf->Rshift % 8 == 0
+                        && sf->Gshift % 8 == 0
+                        && sf->Bshift % 8 == 0 && SDL_HasMMX())
+                        return BlitRGBtoRGBSurfaceAlphaMMX;
 #endif
-				return BlitRGBtoRGBSurfaceAlpha;
-			}
-		}
+                    if ((sf->Rmask | sf->Gmask | sf->Bmask) == 0xffffff) {
 #if SDL_ALTIVEC_BLITTERS
-		if((sf->BytesPerPixel == 4) &&
-		   !(surface->map->dst->flags & SDL_HWSURFACE) && SDL_HasAltiVec())
-			return Blit32to32SurfaceAlphaAltivec;
-		else
+                        if (!(surface->map->dst->flags & SDL_HWSURFACE)
+                            && SDL_HasAltiVec())
+                            return BlitRGBtoRGBSurfaceAlphaAltivec;
 #endif
-			return BlitNtoNSurfaceAlpha;
+                        return BlitRGBtoRGBSurfaceAlpha;
+                    }
+                }
+#if SDL_ALTIVEC_BLITTERS
+                if ((sf->BytesPerPixel == 4) &&
+                    !(surface->map->dst->flags & SDL_HWSURFACE)
+                    && SDL_HasAltiVec())
+                    return Blit32to32SurfaceAlphaAltivec;
+                else
+#endif
+                    return BlitNtoNSurfaceAlpha;
 
-	    case 3:
-	    default:
-		return BlitNtoNSurfaceAlpha;
-	    }
-	}
+            case 3:
+            default:
+                return BlitNtoNSurfaceAlpha;
+            }
+        }
     } else {
-	/* Per-pixel alpha blits */
-	switch(df->BytesPerPixel) {
-	case 1:
-	    return BlitNto1PixelAlpha;
+        /* Per-pixel alpha blits */
+        switch (df->BytesPerPixel) {
+        case 1:
+            return BlitNto1PixelAlpha;
 
-	case 2:
+        case 2:
 #if SDL_ALTIVEC_BLITTERS
-	if(sf->BytesPerPixel == 4 && !(surface->map->dst->flags & SDL_HWSURFACE) &&
-           df->Gmask == 0x7e0 &&
-	   df->Bmask == 0x1f && SDL_HasAltiVec())
-            return Blit32to565PixelAlphaAltivec;
-        else
+            if (sf->BytesPerPixel == 4
+                && !(surface->map->dst->flags & SDL_HWSURFACE)
+                && df->Gmask == 0x7e0 && df->Bmask == 0x1f
+                && SDL_HasAltiVec())
+                return Blit32to565PixelAlphaAltivec;
+            else
 #endif
-	    if(sf->BytesPerPixel == 4 && sf->Amask == 0xff000000
-	       && sf->Gmask == 0xff00
-	       && ((sf->Rmask == 0xff && df->Rmask == 0x1f)
-		   || (sf->Bmask == 0xff && df->Bmask == 0x1f))) {
-		if(df->Gmask == 0x7e0)
-		    return BlitARGBto565PixelAlpha;
-		else if(df->Gmask == 0x3e0)
-		    return BlitARGBto555PixelAlpha;
-	    }
-	    return BlitNtoNPixelAlpha;
+                if (sf->BytesPerPixel == 4 && sf->Amask == 0xff000000
+                    && sf->Gmask == 0xff00
+                    && ((sf->Rmask == 0xff && df->Rmask == 0x1f)
+                        || (sf->Bmask == 0xff && df->Bmask == 0x1f))) {
+                if (df->Gmask == 0x7e0)
+                    return BlitARGBto565PixelAlpha;
+                else if (df->Gmask == 0x3e0)
+                    return BlitARGBto555PixelAlpha;
+            }
+            return BlitNtoNPixelAlpha;
 
-	case 4:
-	    if(sf->Rmask == df->Rmask
-	       && sf->Gmask == df->Gmask
-	       && sf->Bmask == df->Bmask
-	       && sf->BytesPerPixel == 4)
-	    {
+        case 4:
+            if (sf->Rmask == df->Rmask
+                && sf->Gmask == df->Gmask
+                && sf->Bmask == df->Bmask && sf->BytesPerPixel == 4) {
 #if MMX_ASMBLIT
-		if(sf->Rshift % 8 == 0
-		   && sf->Gshift % 8 == 0
-		   && sf->Bshift % 8 == 0
-		   && sf->Ashift % 8 == 0
-		   && sf->Aloss == 0)
-		{
-			if(SDL_Has3DNow())
-				return BlitRGBtoRGBPixelAlphaMMX3DNOW;
-			if(SDL_HasMMX())
-				return BlitRGBtoRGBPixelAlphaMMX;
-		}
+                if (sf->Rshift % 8 == 0
+                    && sf->Gshift % 8 == 0
+                    && sf->Bshift % 8 == 0
+                    && sf->Ashift % 8 == 0 && sf->Aloss == 0) {
+                    if (SDL_Has3DNow())
+                        return BlitRGBtoRGBPixelAlphaMMX3DNOW;
+                    if (SDL_HasMMX())
+                        return BlitRGBtoRGBPixelAlphaMMX;
+                }
 #endif
-		if(sf->Amask == 0xff000000)
-		{
+                if (sf->Amask == 0xff000000) {
 #if SDL_ALTIVEC_BLITTERS
-			if(!(surface->map->dst->flags & SDL_HWSURFACE)
-				&& SDL_HasAltiVec())
-				return BlitRGBtoRGBPixelAlphaAltivec;
+                    if (!(surface->map->dst->flags & SDL_HWSURFACE)
+                        && SDL_HasAltiVec())
+                        return BlitRGBtoRGBPixelAlphaAltivec;
 #endif
-			return BlitRGBtoRGBPixelAlpha;
-		}
-	    }
+                    return BlitRGBtoRGBPixelAlpha;
+                }
+            }
 #if SDL_ALTIVEC_BLITTERS
-	    if (sf->Amask && sf->BytesPerPixel == 4 &&
-	        !(surface->map->dst->flags & SDL_HWSURFACE) && SDL_HasAltiVec())
-		return Blit32to32PixelAlphaAltivec;
-	    else
+            if (sf->Amask && sf->BytesPerPixel == 4 &&
+                !(surface->map->dst->flags & SDL_HWSURFACE)
+                && SDL_HasAltiVec())
+                return Blit32to32PixelAlphaAltivec;
+            else
 #endif
-		return BlitNtoNPixelAlpha;
+                return BlitNtoNPixelAlpha;
 
-	case 3:
-	default:
-	    return BlitNtoNPixelAlpha;
-	}
+        case 3:
+        default:
+            return BlitNtoNPixelAlpha;
+        }
     }
 }
 
+/* vi: set ts=4 sw=4 expandtab: */