Fix some style issues in sdl2gfx.

4 files changed, 1804 insertions, 1503 deletions

diff --git a/src/sdl2gfx/SDL2_framerate.cpp b/src/sdl2gfx/SDL2_framerate.cpp
index bb8cc1c75..e03a8ba7c 100644
--- a/src/sdl2gfx/SDL2_framerate.cpp
+++ b/src/sdl2gfx/SDL2_framerate.cpp
@@ -31,6 +31,8 @@ Changed for ManaPlus (C) 2013-2017  ManaPlus developers
 
 #include "sdl2gfx/SDL2_framerate.h"
 
+#include "debug.h"
+
 /*!
 \brief Internal wrapper to SDL_GetTicks that ensures a non-zero return value.
 
@@ -38,19 +40,22 @@ Changed for ManaPlus (C) 2013-2017  ManaPlus developers
 */
 static Uint32 _getTicks()
 {
-	Uint32 ticks = SDL_GetTicks();
-
-	/* 
-	* Since baseticks!=0 is used to track initialization
-	* we need to ensure that the tick count is always >0 
-	* since SDL_GetTicks may not have incremented yet and
-	* return 0 depending on the timing of the calls.
-	*/
-	if (ticks == 0) {
-		return 1;
-	} else {
-		return ticks;
-	}
+    Uint32 ticks = SDL_GetTicks();
+
+    /*
+    * Since baseticks!=0 is used to track initialization
+    * we need to ensure that the tick count is always >0
+    * since SDL_GetTicks may not have incremented yet and
+    * return 0 depending on the timing of the calls.
+    */
+    if (ticks == 0)
+    {
+        return 1;
+    }
+    else
+    {
+        return ticks;
+    }
 }
 
 /*!
@@ -63,19 +68,19 @@ reset delay interpolation.
 */
 void SDL_initFramerate(FPSmanager * manager)
 {
-	/*
-	* Store some sane values 
-	*/
-	manager->framecount = 0;
-	manager->rate = FPS_DEFAULT;
-	manager->rateticks = (1000.0f / static_cast<float>(FPS_DEFAULT));
-	manager->baseticks = _getTicks();
-	manager->lastticks = manager->baseticks;
+    /*
+    * Store some sane values
+    */
+    manager->framecount = 0;
+    manager->rate = FPS_DEFAULT;
+    manager->rateticks = (1000.0f / static_cast<float>(FPS_DEFAULT));
+    manager->baseticks = _getTicks();
+    manager->lastticks = manager->baseticks;
 
 }
 
 /*!
-\brief Set the framerate in Hz 
+\brief Set the framerate in Hz
 
 Sets a new framerate for the manager and reset delay interpolation.
 Rate values must be between FPS_LOWER_LIMIT and FPS_UPPER_LIMIT inclusive to be accepted.
@@ -87,18 +92,21 @@ Rate values must be between FPS_LOWER_LIMIT and FPS_UPPER_LIMIT inclusive to be
 */
 int SDL_setFramerate(FPSmanager * manager, Uint32 rate)
 {
-	if ((rate >= FPS_LOWER_LIMIT) && (rate <= FPS_UPPER_LIMIT)) {
-		manager->framecount = 0;
-		manager->rate = rate;
-		manager->rateticks = (1000.0f / static_cast<float>(rate));
-		return (0);
-	} else {
-		return (-1);
-	}
+    if ((rate >= FPS_LOWER_LIMIT) && (rate <= FPS_UPPER_LIMIT))
+    {
+        manager->framecount = 0;
+        manager->rate = rate;
+        manager->rateticks = (1000.0f / static_cast<float>(rate));
+        return (0);
+    }
+    else
+    {
+        return (-1);
+    }
 }
 
 /*!
-\brief Return the current target framerate in Hz 
+\brief Return the current target framerate in Hz
 
 Get the currently set framerate of the manager.
 
@@ -108,17 +116,20 @@ Get the currently set framerate of the manager.
 */
 int SDL_getFramerate(FPSmanager * manager)
 {
-	if (manager == nullptr) {
-		return (-1);
-	} else {
-		return (static_cast<int>(manager->rate));
-	}
+    if (manager == nullptr)
+    {
+        return (-1);
+    }
+    else
+    {
+        return (static_cast<int>(manager->rate));
+    }
 }
 
 /*!
 \brief Return the current framecount.
 
-Get the current framecount from the framerate manager. 
+Get the current framecount from the framerate manager.
 A frame is counted each time SDL_framerateDelay is called.
 
 \param manager Pointer to the framerate manager.
@@ -127,11 +138,14 @@ A frame is counted each time SDL_framerateDelay is called.
 */
 int SDL_getFramecount(FPSmanager * manager)
 {
-	if (manager == nullptr) {
-		return (-1);
-	} else {
-		return (static_cast<int>(manager->framecount));
-	}
+    if (manager == nullptr)
+    {
+        return (-1);
+    }
+    else
+    {
+        return (static_cast<int>(manager->framecount));
+    }
 }
 
 /*!
@@ -147,45 +161,51 @@ drawing too slow), the delay is zero and the delay interpolation is reset.
 */
 Uint32 SDL_framerateDelay(FPSmanager * manager)
 {
-	Uint32 current_ticks;
-	Uint32 target_ticks;
-	Uint32 the_delay;
-	Uint32 time_passed = 0;
-
-	/*
-	* No manager, no delay
-	*/
-	if (manager == nullptr) {
-		return 0;
-	}
-
-	/*
-	* Initialize uninitialized manager 
-	*/
-	if (manager->baseticks == 0) {
-		SDL_initFramerate(manager);
-	}
-
-	/*
-	* Next frame 
-	*/
-	manager->framecount++;
-
-	/*
-	* Get/calc ticks 
-	*/
-	current_ticks = _getTicks();
-	time_passed = current_ticks - manager->lastticks;
-	manager->lastticks = current_ticks;
-	target_ticks = manager->baseticks + static_cast<Uint32>(static_cast<float>(manager->framecount) * manager->rateticks);
-
-	if (current_ticks <= target_ticks) {
-		the_delay = target_ticks - current_ticks;
-		SDL_Delay(the_delay);
-	} else {
-		manager->framecount = 0;
-		manager->baseticks = _getTicks();
-	}
-
-	return time_passed;
+    Uint32 current_ticks;
+    Uint32 target_ticks;
+    Uint32 the_delay;
+    Uint32 time_passed = 0;
+
+    /*
+    * No manager, no delay
+    */
+    if (manager == nullptr)
+    {
+        return 0;
+    }
+
+    /*
+    * Initialize uninitialized manager
+    */
+    if (manager->baseticks == 0)
+    {
+        SDL_initFramerate(manager);
+    }
+
+    /*
+    * Next frame
+    */
+    manager->framecount++;
+
+    /*
+    * Get/calc ticks
+    */
+    current_ticks = _getTicks();
+    time_passed = current_ticks - manager->lastticks;
+    manager->lastticks = current_ticks;
+    target_ticks = manager->baseticks + static_cast<Uint32>(static_cast<float>(
+        manager->framecount) * manager->rateticks);
+
+    if (current_ticks <= target_ticks)
+    {
+        the_delay = target_ticks - current_ticks;
+        SDL_Delay(the_delay);
+    }
+    else
+    {
+        manager->framecount = 0;
+        manager->baseticks = _getTicks();
+    }
+
+    return time_passed;
 }
diff --git a/src/sdl2gfx/SDL2_framerate.h b/src/sdl2gfx/SDL2_framerate.h
index f08321140..add1b28c9 100644
--- a/src/sdl2gfx/SDL2_framerate.h
+++ b/src/sdl2gfx/SDL2_framerate.h
@@ -34,10 +34,11 @@ Changed for ManaPlus (C) 2013-2017  ManaPlus developers
 
 /* Set up for C function definitions, even when using C++ */
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-	/* --- */
+    /* --- */
 
 #include "localconsts.h"
 
@@ -46,35 +47,36 @@ PRAGMA48(GCC diagnostic ignored "-Wshadow")
 #include <SDL.h>
 PRAGMA48(GCC diagnostic pop)
 
-	/* --------- Definitions */
-
-	/*!
-	\brief Highest possible rate supported by framerate controller in Hz (1/s).
-	*/
-#define FPS_UPPER_LIMIT		200
-
-	/*!
-	\brief Lowest possible rate supported by framerate controller in Hz (1/s).
-	*/
-#define FPS_LOWER_LIMIT		1
-
-	/*!
-	\brief Default rate of framerate controller in Hz (1/s).
-	*/
-#define FPS_DEFAULT		30
-
-	/*! 
-	\brief Structure holding the state and timing information of the framerate controller. 
-	*/
-	typedef struct {
-		Uint32 framecount;
-		float rateticks;
-		Uint32 baseticks;
-		Uint32 lastticks;
-		Uint32 rate;
-	} FPSmanager;
-
-	/* ---- Function Prototypes */
+    /* --------- Definitions */
+
+    /*!
+    \brief Highest possible rate supported by framerate controller in Hz (1/s).
+    */
+#define FPS_UPPER_LIMIT        200
+
+    /*!
+    \brief Lowest possible rate supported by framerate controller in Hz (1/s).
+    */
+#define FPS_LOWER_LIMIT        1
+
+    /*!
+    \brief Default rate of framerate controller in Hz (1/s).
+    */
+#define FPS_DEFAULT        30
+
+    /*!
+    \brief Structure holding the state and timing information of the framerate controller.
+    */
+    typedef struct
+    {
+        Uint32 framecount;
+        float rateticks;
+        Uint32 baseticks;
+        Uint32 lastticks;
+        Uint32 rate;
+    } FPSmanager;
+
+    /* ---- Function Prototypes */
 
 #ifdef _MSC_VER
 #  if defined(DLL_EXPORT) && !defined(LIBSDL2_GFX_DLL_IMPORT)
@@ -89,19 +91,20 @@ PRAGMA48(GCC diagnostic pop)
 #  define SDL2_FRAMERATE_SCOPE extern
 #endif
 
-	/* Functions return 0 or value for sucess and -1 for error */
+    /* Functions return 0 or value for sucess and -1 for error */
 
-	SDL2_FRAMERATE_SCOPE void SDL_initFramerate(FPSmanager * manager);
-	SDL2_FRAMERATE_SCOPE int SDL_setFramerate(FPSmanager * manager, Uint32 rate);
-	SDL2_FRAMERATE_SCOPE int SDL_getFramerate(FPSmanager * manager);
-	SDL2_FRAMERATE_SCOPE int SDL_getFramecount(FPSmanager * manager);
-	SDL2_FRAMERATE_SCOPE Uint32 SDL_framerateDelay(FPSmanager * manager);
+    SDL2_FRAMERATE_SCOPE void SDL_initFramerate(FPSmanager * manager);
+    SDL2_FRAMERATE_SCOPE int SDL_setFramerate(FPSmanager * manager,
+                                              Uint32 rate);
+    SDL2_FRAMERATE_SCOPE int SDL_getFramerate(FPSmanager * manager);
+    SDL2_FRAMERATE_SCOPE int SDL_getFramecount(FPSmanager * manager);
+    SDL2_FRAMERATE_SCOPE Uint32 SDL_framerateDelay(FPSmanager * manager);
 
-	/* --- */
+    /* --- */
 
-	/* Ends C function definitions when using C++ */
+    /* Ends C function definitions when using C++ */
 #ifdef __cplusplus
 }
 #endif
 
-#endif				/* _SDL2_framerate_h */
+#endif                /* _SDL2_framerate_h */
diff --git a/src/sdl2gfx/SDL2_rotozoom.cpp b/src/sdl2gfx/SDL2_rotozoom.cpp
index 73461999f..a37e1c51e 100644
--- a/src/sdl2gfx/SDL2_rotozoom.cpp
+++ b/src/sdl2gfx/SDL2_rotozoom.cpp
@@ -1,4 +1,4 @@
-/*  
+/*
 
 SDL2_rotozoom.c: rotozoomer, zoomer and shrinker for 32bit or 8bit surfaces
 
@@ -38,37 +38,41 @@ Changed for ManaPlus (C) 2013-2017  ManaPlus developers
 
 #include "sdl2gfx/SDL2_rotozoom.h"
 
+#include "debug.h"
+
 /* ---- Internally used structures */
 
 /*!
 \brief A 32 bit RGBA pixel.
 */
-typedef struct tColorRGBA {
-	Uint8 r;
-	Uint8 g;
-	Uint8 b;
-	Uint8 a;
+typedef struct tColorRGBA
+{
+    Uint8 r;
+    Uint8 g;
+    Uint8 b;
+    Uint8 a;
 } tColorRGBA;
 
 /*!
 \brief A 8bit Y/palette pixel.
 */
-typedef struct tColorY {
-	Uint8 y;
+typedef struct tColorY
+{
+    Uint8 y;
 } tColorY;
 
-/*! 
+/*!
 \brief Returns maximum of two numbers a and b.
 */
 #define MAX(a,b)    (((a) > (b)) ? (a) : (b))
 
-/*! 
+/*!
 \brief Number of guard rows added to destination surfaces.
 
 This is a simple but effective workaround for observed issues.
 These rows allocate extra memory and are then hidden from the surface.
-Rows are added to the end of destination surfaces when they are allocated. 
-This catches any potential overflows which seem to happen with 
+Rows are added to the end of destination surfaces when they are allocated.
+This catches any potential overflows which seem to happen with
 just the right src image dimensions and scale/rotation and can lead
 to a situation where the program can segfault.
 */
@@ -77,20 +81,20 @@ to a situation where the program can segfault.
 /*!
 \brief Lower limit of absolute zoom factor or rotation degrees.
 */
-#define VALUE_LIMIT	0.001
+#define VALUE_LIMIT    0.001
 
 /*!
 \brief Returns colorkey info for a surface
 */
 static Uint32 _colorkey(SDL_Surface *src)
 {
-	Uint32 key = 0; 
-	SDL_GetColorKey(src, &key);
-	return key;
+    Uint32 key = 0;
+    SDL_GetColorKey(src, &key);
+    return key;
 }
 
 
-/*! 
+/*!
 \brief Internal 32 bit integer-factor averaging Shrinker.
 
 Shrinks 32 bit RGBA/ABGR 'src' surface to 'dst' surface.
@@ -105,80 +109,90 @@ Assumes dst surface was allocated with the correct dimensions.
 
 \return 0 for success or -1 for error.
 */
-static int _shrinkSurfaceRGBA(SDL_Surface * src, SDL_Surface * dst, int factorx, int factory)
+static int _shrinkSurfaceRGBA(SDL_Surface *src,
+                              SDL_Surface *dst,
+                              int factorx,
+                              int factory)
 {
-	int x, y, dx, dy, dgap, ra, ga, ba, aa;
-	int n_average;
-	tColorRGBA *sp, *osp, *oosp;
-	tColorRGBA *dp;
-
-	/*
-	* Averaging integer shrink
-	*/
-
-	/* Precalculate division factor */
-	n_average = factorx*factory;
-
-	/*
-	* Scan destination
-	*/
-	sp = static_cast<tColorRGBA *>(src->pixels);
-	
-	dp = static_cast<tColorRGBA *>(dst->pixels);
-	dgap = dst->pitch - dst->w * 4;
-
-	for (y = 0; y < dst->h; y++) {
-
-		osp=sp;
-		for (x = 0; x < dst->w; x++) {
-
-			/* Trace out source box and accumulate */
-			oosp=sp;
-			ra=ga=ba=aa=0;
-			for (dy=0; dy < factory; dy++) {
-				for (dx=0; dx < factorx; dx++) {
-					ra += sp->r;
-					ga += sp->g;
-					ba += sp->b;
-					aa += sp->a;
-
-					sp++;
-				} 
-				/* src dx loop */
-				sp = reinterpret_cast<tColorRGBA *>(reinterpret_cast<Uint8*>(sp) + (src->pitch - 4*factorx)); // next y
-			}
-			/* src dy loop */
-
-			/* next box-x */
-			sp = reinterpret_cast<tColorRGBA *>(reinterpret_cast<Uint8*>(oosp) + 4*factorx);
-
-			/* Store result in destination */
-			dp->r = ra/n_average;
-			dp->g = ga/n_average;
-			dp->b = ba/n_average;
-			dp->a = aa/n_average;
-
-			/*
-			* Advance destination pointer 
-			*/
-			dp++;
-		} 
-		/* dst x loop */
-
-		/* next box-y */
-		sp = reinterpret_cast<tColorRGBA *>(reinterpret_cast<Uint8*>(osp) + src->pitch*factory);
-
-		/*
-		* Advance destination pointers 
-		*/
-		dp = reinterpret_cast<tColorRGBA *>(reinterpret_cast<Uint8*>(dp) + dgap);
-	} 
-	/* dst y loop */
-
-	return (0);
+    int x, y, dx, dy, dgap, ra, ga, ba, aa;
+    int n_average;
+    tColorRGBA *sp, *osp, *oosp;
+    tColorRGBA *dp;
+
+    /*
+    * Averaging integer shrink
+    */
+
+    /* Precalculate division factor */
+    n_average = factorx*factory;
+
+    /*
+    * Scan destination
+    */
+    sp = static_cast<tColorRGBA *>(src->pixels);
+
+    dp = static_cast<tColorRGBA *>(dst->pixels);
+    dgap = dst->pitch - dst->w * 4;
+
+    for (y = 0; y < dst->h; y++)
+    {
+        osp=sp;
+        for (x = 0; x < dst->w; x++)
+        {
+            /* Trace out source box and accumulate */
+            oosp=sp;
+            ra=ga=ba=aa=0;
+            for (dy=0; dy < factory; dy++)
+            {
+                for (dx=0; dx < factorx; dx++)
+                {
+                    ra += sp->r;
+                    ga += sp->g;
+                    ba += sp->b;
+                    aa += sp->a;
+
+                    sp++;
+                }
+                /* src dx loop */
+                sp = reinterpret_cast<tColorRGBA *>(
+                    reinterpret_cast<Uint8*>(sp) +
+                    (src->pitch - 4*factorx)); // next y
+            }
+            /* src dy loop */
+
+            /* next box-x */
+            sp = reinterpret_cast<tColorRGBA *>(
+                reinterpret_cast<Uint8*>(oosp) + 4*factorx);
+
+            /* Store result in destination */
+            dp->r = ra/n_average;
+            dp->g = ga/n_average;
+            dp->b = ba/n_average;
+            dp->a = aa/n_average;
+
+            /*
+            * Advance destination pointer
+            */
+            dp++;
+        }
+        /* dst x loop */
+
+        /* next box-y */
+        sp = reinterpret_cast<tColorRGBA *>(reinterpret_cast<Uint8*>(osp) +
+            src->pitch*factory);
+
+        /*
+        * Advance destination pointers
+        */
+        dp = reinterpret_cast<tColorRGBA *>(reinterpret_cast<Uint8*>(dp) +
+            dgap);
+    }
+    /* dst y loop */
+
+    return (0);
 }
 
-/*! 
+/*!
 \brief Internal 8 bit integer-factor averaging shrinker.
 
 Shrinks 8bit Y 'src' surface to 'dst' surface.
@@ -193,75 +207,82 @@ Assumes dst surface was allocated with the correct dimensions.
 
 \return 0 for success or -1 for error.
 */
-static int _shrinkSurfaceY(SDL_Surface * src, SDL_Surface * dst, int factorx, int factory)
+static int _shrinkSurfaceY(SDL_Surface *src,
+                           SDL_Surface *dst,
+                           int factorx,
+                           int factory)
 {
-	int x, y, dx, dy, dgap, a;
-	int n_average;
-	Uint8 *sp, *osp, *oosp;
-	Uint8 *dp;
-
-	/*
-	* Averaging integer shrink
-	*/
-
-	/* Precalculate division factor */
-	n_average = factorx*factory;
-
-	/*
-	* Scan destination
-	*/
-	sp = static_cast<Uint8*>(src->pixels);
-
-	dp = static_cast<Uint8*>(dst->pixels);
-	dgap = dst->pitch - dst->w;
-
-	for (y = 0; y < dst->h; y++) {    
-
-		osp=sp;
-		for (x = 0; x < dst->w; x++) {
-
-			/* Trace out source box and accumulate */
-			oosp=sp;
-			a=0;
-			for (dy=0; dy < factory; dy++) {
-				for (dx=0; dx < factorx; dx++) {
-					a += (*sp);
-					/* next x */           
-					sp++;
-				} 
-				/* end src dx loop */         
-				/* next y */
-				sp = static_cast<Uint8*>(static_cast<Uint8*>(sp) + (src->pitch - factorx)); 
-			} 
-			/* end src dy loop */
-
-			/* next box-x */
-			sp = static_cast<Uint8*>(static_cast<Uint8*>(oosp) + factorx);
-
-			/* Store result in destination */
-			*dp = a/n_average;
-
-			/*
-			* Advance destination pointer 
-			*/
-			dp++;
-		} 
-		/* end dst x loop */
-
-		/* next box-y */
-		sp = static_cast<Uint8*>(static_cast<Uint8*>(osp) + src->pitch*factory);
-
-		/*
-		* Advance destination pointers 
-		*/
-		dp = static_cast<Uint8*>(static_cast<Uint8*>(dp) + dgap);
-	} 
-	/* end dst y loop */
-
-	return (0);
+    int x, y, dx, dy, dgap, a;
+    int n_average;
+    Uint8 *sp, *osp, *oosp;
+    Uint8 *dp;
+
+    /*
+    * Averaging integer shrink
+    */
+
+    /* Precalculate division factor */
+    n_average = factorx*factory;
+
+    /*
+    * Scan destination
+    */
+    sp = static_cast<Uint8*>(src->pixels);
+
+    dp = static_cast<Uint8*>(dst->pixels);
+    dgap = dst->pitch - dst->w;
+
+    for (y = 0; y < dst->h; y++)
+    {
+        osp=sp;
+        for (x = 0; x < dst->w; x++)
+        {
+            /* Trace out source box and accumulate */
+            oosp=sp;
+            a=0;
+            for (dy=0; dy < factory; dy++)
+            {
+                for (dx=0; dx < factorx; dx++)
+                {
+                    a += (*sp);
+                    /* next x */
+                    sp++;
+                }
+                /* end src dx loop */
+                /* next y */
+                sp = static_cast<Uint8*>(static_cast<Uint8*>(sp) +
+                    (src->pitch - factorx));
+            }
+            /* end src dy loop */
+
+            /* next box-x */
+            sp = static_cast<Uint8*>(static_cast<Uint8*>(oosp) + factorx);
+
+            /* Store result in destination */
+            *dp = a/n_average;
+
+            /*
+            * Advance destination pointer
+            */
+            dp++;
+        }
+        /* end dst x loop */
+
+        /* next box-y */
+        sp = static_cast<Uint8*>(static_cast<Uint8*>(osp) +
+            src->pitch*factory);
+
+        /*
+        * Advance destination pointers
+        */
+        dp = static_cast<Uint8*>(static_cast<Uint8*>(dp) + dgap);
+    }
+    /* end dst y loop */
+
+    return (0);
 }
 
-/*! 
+/*!
 \brief Internal 32 bit Zoomer with optional anti-aliasing by bilinear interpolation.
 
 Zooms 32 bit RGBA/ABGR 'src' surface to 'dst' surface.
@@ -276,225 +297,266 @@ Assumes dst surface was allocated with the correct dimensions.
 
 \return 0 for success or -1 for error.
 */
-static int _zoomSurfaceRGBA(SDL_Surface * src, SDL_Surface * dst, int flipx, int flipy, int smooth)
+static int _zoomSurfaceRGBA(SDL_Surface *src,
+                            SDL_Surface *dst,
+                            int flipx,
+                            int flipy,
+                            int smooth)
 {
-	int x, y, sx, sy, ssx, ssy, *sax, *say, *csax, *csay, *salast, csx, csy, ex, ey, cx, cy, sstep, sstepx, sstepy;
-	tColorRGBA *c00, *c01, *c10, *c11;
-	tColorRGBA *sp, *csp, *dp;
-	int spixelgap, spixelw, spixelh, dgap, t1, t2;
-
-	/*
-	* Allocate memory for row/column increments 
-	*/
-	if ((sax = static_cast<int *>(malloc((dst->w + 1) * sizeof(Uint32)))) == nullptr) {
-		return (-1);
-	}
-	if ((say = static_cast<int *>(malloc((dst->h + 1) * sizeof(Uint32)))) == nullptr) {
-		free(sax);
-		return (-1);
-	}
-
-	/*
-	* Precalculate row increments 
-	*/
-	spixelw = (src->w - 1);
-	spixelh = (src->h - 1);
-	if (smooth) {
-		sx = static_cast<int>(65536.0 * static_cast<float>(spixelw) / static_cast<float>(dst->w - 1));
-		sy = static_cast<int>(65536.0 * static_cast<float>(spixelh) / static_cast<float>(dst->h - 1));
-	} else {
-		sx = static_cast<int>(65536.0 * static_cast<float>(src->w) / static_cast<float>(dst->w));
-		sy = static_cast<int>(65536.0 * static_cast<float>(src->h) / static_cast<float>(dst->h));
-	}
-
-	/* Maximum scaled source size */
-	ssx = (src->w << 16) - 1;
-	ssy = (src->h << 16) - 1;
-
-	/* Precalculate horizontal row increments */
-	csx = 0;
-	csax = sax;
-	for (x = 0; x <= dst->w; x++) {
-		*csax = csx;
-		csax++;
-		csx += sx;
-
-		/* Guard from overflows */
-		if (csx > ssx) { 
-			csx = ssx; 
-		}
-	}
-
-	/* Precalculate vertical row increments */
-	csy = 0;
-	csay = say;
-	for (y = 0; y <= dst->h; y++) {
-		*csay = csy;
-		csay++;
-		csy += sy;
-
-		/* Guard from overflows */
-		if (csy > ssy) {
-			csy = ssy;
-		}
-	}
-
-	sp = static_cast<tColorRGBA *>(src->pixels);
-	dp = static_cast<tColorRGBA *>(dst->pixels);
-	dgap = dst->pitch - dst->w * 4;
-	spixelgap = src->pitch/4;
-
-	if (flipx) sp += spixelw;
-	if (flipy) sp += (spixelgap * spixelh);
-
-	/*
-	* Switch between interpolating and non-interpolating code 
-	*/
-	if (smooth) {
-
-		/*
-		* Interpolating Zoom 
-		*/
-		csay = say;
-		for (y = 0; y < dst->h; y++) {
-			csp = sp;
-			csax = sax;
-			for (x = 0; x < dst->w; x++) {
-				/*
-				* Setup color source pointers 
-				*/
-				ex = (*csax & 0xffff);
-				ey = (*csay & 0xffff);
-				cx = (*csax >> 16);
-				cy = (*csay >> 16);
-				sstepx = cx < spixelw;
-				sstepy = cy < spixelh;
-				c00 = sp;
-				c01 = sp;
-				c10 = sp;
-				if (sstepy) {
-					if (flipy) {
-						c10 -= spixelgap;
-					} else {
-						c10 += spixelgap;
-					}
-				}
-				c11 = c10;
-				if (sstepx) {
-					if (flipx) {
-						c01--;
-						c11--;
-					} else {
-						c01++;
-						c11++;
-					}
-				}
-
-				/*
-				* Draw and interpolate colors 
-				*/
-				t1 = ((((c01->r - c00->r) * ex) >> 16) + c00->r) & 0xff;
-				t2 = ((((c11->r - c10->r) * ex) >> 16) + c10->r) & 0xff;
-				dp->r = (((t2 - t1) * ey) >> 16) + t1;
-				t1 = ((((c01->g - c00->g) * ex) >> 16) + c00->g) & 0xff;
-				t2 = ((((c11->g - c10->g) * ex) >> 16) + c10->g) & 0xff;
-				dp->g = (((t2 - t1) * ey) >> 16) + t1;
-				t1 = ((((c01->b - c00->b) * ex) >> 16) + c00->b) & 0xff;
-				t2 = ((((c11->b - c10->b) * ex) >> 16) + c10->b) & 0xff;
-				dp->b = (((t2 - t1) * ey) >> 16) + t1;
-				t1 = ((((c01->a - c00->a) * ex) >> 16) + c00->a) & 0xff;
-				t2 = ((((c11->a - c10->a) * ex) >> 16) + c10->a) & 0xff;
-				dp->a = (((t2 - t1) * ey) >> 16) + t1;				
-				/*
-				* Advance source pointer x
-				*/
-				salast = csax;
-				csax++;				
-				sstep = (*csax >> 16) - (*salast >> 16);
-				if (flipx) {
-					sp -= sstep;
-				} else {
-					sp += sstep;
-				}
-
-				/*
-				* Advance destination pointer x
-				*/
-				dp++;
-			}
-			/*
-			* Advance source pointer y
-			*/
-			salast = csay;
-			csay++;
-			sstep = (*csay >> 16) - (*salast >> 16);
-			sstep *= spixelgap;
-			if (flipy) { 
-				sp = csp - sstep;
-			} else {
-				sp = csp + sstep;
-			}
-
-			/*
-			* Advance destination pointer y
-			*/
-			dp = reinterpret_cast<tColorRGBA *>(reinterpret_cast<Uint8*>(dp) + dgap);
-		}
-	} else {
-		/*
-		* Non-Interpolating Zoom 
-		*/		
-		csay = say;
-		for (y = 0; y < dst->h; y++) {
-			csp = sp;
-			csax = sax;
-			for (x = 0; x < dst->w; x++) {
-				/*
-				* Draw 
-				*/
-				*dp = *sp;
-
-				/*
-				* Advance source pointer x
-				*/
-				salast = csax;
-				csax++;				
-				sstep = (*csax >> 16) - (*salast >> 16);
-				if (flipx) sstep = -sstep;
-				sp += sstep;
-
-				/*
-				* Advance destination pointer x
-				*/
-				dp++;
-			}
-			/*
-			* Advance source pointer y
-			*/
-			salast = csay;
-			csay++;
-			sstep = (*csay >> 16) - (*salast >> 16);
-			sstep *= spixelgap;
-			if (flipy) sstep = -sstep;			
-			sp = csp + sstep;
-
-			/*
-			* Advance destination pointer y
-			*/
-			dp = reinterpret_cast<tColorRGBA *>(reinterpret_cast<Uint8*>(dp) + dgap);
-		}
-	}
-
-	/*
-	* Remove temp arrays 
-	*/
-	free(sax);
-	free(say);
-
-	return (0);
+    int x, y, sx, sy, ssx, ssy;
+    int *sax, *say, *csax, *csay, *salast;
+    int csx, csy, ex, ey, cx, cy, sstep, sstepx, sstepy;
+    tColorRGBA *c00, *c01, *c10, *c11;
+    tColorRGBA *sp, *csp, *dp;
+    int spixelgap, spixelw, spixelh, dgap, t1, t2;
+
+    /*
+    * Allocate memory for row/column increments
+    */
+    if ((sax = static_cast<int *>(malloc((dst->w + 1) * sizeof(Uint32)))) == nullptr)
+    {
+        return (-1);
+    }
+    if ((say = static_cast<int *>(malloc((dst->h + 1) * sizeof(Uint32)))) == nullptr)
+    {
+        free(sax);
+        return (-1);
+    }
+
+    /*
+    * Precalculate row increments
+    */
+    spixelw = (src->w - 1);
+    spixelh = (src->h - 1);
+    if (smooth)
+    {
+        sx = static_cast<int>(65536.0 * static_cast<float>(spixelw) /
+            static_cast<float>(dst->w - 1));
+        sy = static_cast<int>(65536.0 * static_cast<float>(spixelh) /
+            static_cast<float>(dst->h - 1));
+    }
+    else
+    {
+        sx = static_cast<int>(65536.0 * static_cast<float>(src->w) /
+            static_cast<float>(dst->w));
+        sy = static_cast<int>(65536.0 * static_cast<float>(src->h) /
+            static_cast<float>(dst->h));
+    }
+
+    /* Maximum scaled source size */
+    ssx = (src->w << 16) - 1;
+    ssy = (src->h << 16) - 1;
+
+    /* Precalculate horizontal row increments */
+    csx = 0;
+    csax = sax;
+    for (x = 0; x <= dst->w; x++)
+    {
+        *csax = csx;
+        csax++;
+        csx += sx;
+
+        /* Guard from overflows */
+        if (csx > ssx)
+        {
+            csx = ssx;
+        }
+    }
+
+    /* Precalculate vertical row increments */
+    csy = 0;
+    csay = say;
+    for (y = 0; y <= dst->h; y++)
+    {
+        *csay = csy;
+        csay++;
+        csy += sy;
+
+        /* Guard from overflows */
+        if (csy > ssy)
+        {
+            csy = ssy;
+        }
+    }
+
+    sp = static_cast<tColorRGBA *>(src->pixels);
+    dp = static_cast<tColorRGBA *>(dst->pixels);
+    dgap = dst->pitch - dst->w * 4;
+    spixelgap = src->pitch/4;
+
+    if (flipx) sp += spixelw;
+    if (flipy) sp += (spixelgap * spixelh);
+
+    /*
+    * Switch between interpolating and non-interpolating code
+    */
+    if (smooth)
+    {
+        /*
+        * Interpolating Zoom
+        */
+        csay = say;
+        for (y = 0; y < dst->h; y++)
+        {
+            csp = sp;
+            csax = sax;
+            for (x = 0; x < dst->w; x++)
+            {
+                /*
+                * Setup color source pointers
+                */
+                ex = (*csax & 0xffff);
+                ey = (*csay & 0xffff);
+                cx = (*csax >> 16);
+                cy = (*csay >> 16);
+                sstepx = cx < spixelw;
+                sstepy = cy < spixelh;
+                c00 = sp;
+                c01 = sp;
+                c10 = sp;
+                if (sstepy)
+                {
+                    if (flipy)
+                    {
+                        c10 -= spixelgap;
+                    }
+                    else
+                    {
+                        c10 += spixelgap;
+                    }
+                }
+                c11 = c10;
+                if (sstepx)
+                {
+                    if (flipx)
+                    {
+                        c01--;
+                        c11--;
+                    }
+                    else
+                    {
+                        c01++;
+                        c11++;
+                    }
+                }
+
+                /*
+                * Draw and interpolate colors
+                */
+                t1 = ((((c01->r - c00->r) * ex) >> 16) + c00->r) & 0xff;
+                t2 = ((((c11->r - c10->r) * ex) >> 16) + c10->r) & 0xff;
+                dp->r = (((t2 - t1) * ey) >> 16) + t1;
+                t1 = ((((c01->g - c00->g) * ex) >> 16) + c00->g) & 0xff;
+                t2 = ((((c11->g - c10->g) * ex) >> 16) + c10->g) & 0xff;
+                dp->g = (((t2 - t1) * ey) >> 16) + t1;
+                t1 = ((((c01->b - c00->b) * ex) >> 16) + c00->b) & 0xff;
+                t2 = ((((c11->b - c10->b) * ex) >> 16) + c10->b) & 0xff;
+                dp->b = (((t2 - t1) * ey) >> 16) + t1;
+                t1 = ((((c01->a - c00->a) * ex) >> 16) + c00->a) & 0xff;
+                t2 = ((((c11->a - c10->a) * ex) >> 16) + c10->a) & 0xff;
+                dp->a = (((t2 - t1) * ey) >> 16) + t1;
+                /*
+                * Advance source pointer x
+                */
+                salast = csax;
+                csax++;
+                sstep = (*csax >> 16) - (*salast >> 16);
+                if (flipx)
+                {
+                    sp -= sstep;
+                }
+                else
+                {
+                    sp += sstep;
+                }
+
+                /*
+                * Advance destination pointer x
+                */
+                dp++;
+            }
+            /*
+            * Advance source pointer y
+            */
+            salast = csay;
+            csay++;
+            sstep = (*csay >> 16) - (*salast >> 16);
+            sstep *= spixelgap;
+            if (flipy)
+            {
+                sp = csp - sstep;
+            }
+            else
+            {
+                sp = csp + sstep;
+            }
+
+            /*
+            * Advance destination pointer y
+            */
+            dp = reinterpret_cast<tColorRGBA *>(
+                reinterpret_cast<Uint8*>(dp) + dgap);
+        }
+    }
+    else
+    {
+        /*
+        * Non-Interpolating Zoom
+        */
+        csay = say;
+        for (y = 0; y < dst->h; y++)
+        {
+            csp = sp;
+            csax = sax;
+            for (x = 0; x < dst->w; x++)
+            {
+                /*
+                * Draw
+                */
+                *dp = *sp;
+
+                /*
+                * Advance source pointer x
+                */
+                salast = csax;
+                csax++;
+                sstep = (*csax >> 16) - (*salast >> 16);
+                if (flipx) sstep = -sstep;
+                sp += sstep;
+
+                /*
+                * Advance destination pointer x
+                */
+                dp++;
+            }
+            /*
+            * Advance source pointer y
+            */
+            salast = csay;
+            csay++;
+            sstep = (*csay >> 16) - (*salast >> 16);
+            sstep *= spixelgap;
+            if (flipy) sstep = -sstep;
+            sp = csp + sstep;
+
+            /*
+            * Advance destination pointer y
+            */
+            dp = reinterpret_cast<tColorRGBA *>(
+                reinterpret_cast<Uint8*>(dp) + dgap);
+        }
+    }
+
+    /*
+    * Remove temp arrays
+    */
+    free(sax);
+    free(say);
+
+    return (0);
 }
 
-/*! 
+/*!
 
 \brief Internal 8 bit Zoomer without smoothing.
 
@@ -509,110 +571,123 @@ Assumes dst surface was allocated with the correct dimensions.
 
 \return 0 for success or -1 for error.
 */
-static int _zoomSurfaceY(SDL_Surface * src, SDL_Surface * dst, int flipx, int flipy)
+static int _zoomSurfaceY(SDL_Surface *src,
+                         SDL_Surface *dst,
+                         int flipx,
+                         int flipy)
 {
-	int x, y;
-	Uint32 *sax, *say, *csax, *csay;
-	int csx, csy;
-	Uint8 *sp, *dp, *csp;
-	int dgap;
-
-	/*
-	* Allocate memory for row increments 
-	*/
-	if ((sax = static_cast<Uint32 *>(malloc((dst->w + 1) * sizeof(Uint32)))) == nullptr) {
-		return (-1);
-	}
-	if ((say = static_cast<Uint32 *>(malloc((dst->h + 1) * sizeof(Uint32)))) == nullptr) {
-		free(sax);
-		return (-1);
-	}
-
-	/*
-	* Pointer setup 
-	*/
-	sp = csp = static_cast<Uint8*>(src->pixels);
-	dp = static_cast<Uint8*>(dst->pixels);
-	dgap = dst->pitch - dst->w;
-
-	if (flipx) csp += (src->w-1);
-	if (flipy) csp  = (static_cast<Uint8*>(csp) + src->pitch*(src->h-1) );
-
-	/*
-	* Precalculate row increments 
-	*/
-	csx = 0;
-	csax = sax;
-	for (x = 0; x < dst->w; x++) {
-		csx += src->w;
-		*csax = 0;
-		while (csx >= dst->w) {
-			csx -= dst->w;
-			(*csax)++;
-		}
-		(*csax) = (*csax) * (flipx ? -1 : 1);
-		csax++;
-	}
-	csy = 0;
-	csay = say;
-	for (y = 0; y < dst->h; y++) {
-		csy += src->h;
-		*csay = 0;
-		while (csy >= dst->h) {
-			csy -= dst->h;
-			(*csay)++;
-		}
-		(*csay) = (*csay) * (flipy ? -1 : 1);
-		csay++;
-	}
-
-	/*
-	* Draw 
-	*/
-	csay = say;
-	for (y = 0; y < dst->h; y++) {
-		csax = sax;
-		sp = csp;
-		for (x = 0; x < dst->w; x++) {
-			/*
-			* Draw 
-			*/
-			*dp = *sp;
-			/*
-			* Advance source pointers 
-			*/
-			sp += (*csax);
-			csax++;
-			/*
-			* Advance destination pointer 
-			*/
-			dp++;
-		}
-		/*
-		* Advance source pointer (for row) 
-		*/
-		csp += ((*csay) * src->pitch);
-		csay++;
-
-		/*
-		* Advance destination pointers 
-		*/
-		dp += dgap;
-	}
-
-	/*
-	* Remove temp arrays 
-	*/
-	free(sax);
-	free(say);
-
-	return (0);
+    int x, y;
+    Uint32 *sax, *say, *csax, *csay;
+    int csx, csy;
+    Uint8 *sp, *dp, *csp;
+    int dgap;
+
+    /*
+    * Allocate memory for row increments
+    */
+    if ((sax = static_cast<Uint32 *>(malloc((dst->w + 1) *
+        sizeof(Uint32)))) == nullptr)
+    {
+        return (-1);
+    }
+    if ((say = static_cast<Uint32 *>(malloc((dst->h + 1) *
+        sizeof(Uint32)))) == nullptr)
+    {
+        free(sax);
+        return (-1);
+    }
+
+    /*
+    * Pointer setup
+    */
+    sp = csp = static_cast<Uint8*>(src->pixels);
+    dp = static_cast<Uint8*>(dst->pixels);
+    dgap = dst->pitch - dst->w;
+
+    if (flipx) csp += (src->w-1);
+    if (flipy) csp  = (static_cast<Uint8*>(csp) + src->pitch*(src->h-1));
+
+    /*
+    * Precalculate row increments
+    */
+    csx = 0;
+    csax = sax;
+    for (x = 0; x < dst->w; x++)
+    {
+        csx += src->w;
+        *csax = 0;
+        while (csx >= dst->w)
+        {
+            csx -= dst->w;
+            (*csax)++;
+        }
+        (*csax) = (*csax) * (flipx ? -1 : 1);
+        csax++;
+    }
+    csy = 0;
+    csay = say;
+    for (y = 0; y < dst->h; y++)
+    {
+        csy += src->h;
+        *csay = 0;
+        while (csy >= dst->h)
+        {
+            csy -= dst->h;
+            (*csay)++;
+        }
+        (*csay) = (*csay) * (flipy ? -1 : 1);
+        csay++;
+    }
+
+    /*
+    * Draw
+    */
+    csay = say;
+    for (y = 0; y < dst->h; y++)
+    {
+        csax = sax;
+        sp = csp;
+        for (x = 0; x < dst->w; x++)
+        {
+            /*
+            * Draw
+            */
+            *dp = *sp;
+            /*
+            * Advance source pointers
+            */
+            sp += (*csax);
+            csax++;
+            /*
+            * Advance destination pointer
+            */
+            dp++;
+        }
+        /*
+        * Advance source pointer (for row)
+        */
+        csp += ((*csay) * src->pitch);
+        csay++;
+
+        /*
+        * Advance destination pointers
+        */
+        dp += dgap;
+    }
+
+    /*
+    * Remove temp arrays
+    */
+    free(sax);
+    free(say);
+
+    return (0);
 }
 
-/*! 
+/*!
 \brief Internal 32 bit rotozoomer with optional anti-aliasing.
 
-Rotates and zooms 32 bit RGBA/ABGR 'src' surface to 'dst' surface based on the control 
+Rotates and zooms 32 bit RGBA/ABGR 'src' surface to 'dst' surface based on the control
 parameters by scanning the destination surface and applying optionally anti-aliasing
 by bilinear interpolation.
 Assumes src and dst surfaces are of 32 bit depth.
@@ -628,110 +703,134 @@ Assumes dst surface was allocated with the correct dimensions.
 \param flipy Flag indicating vertical mirroring should be applied.
 \param smooth Flag indicating anti-aliasing should be used.
 */
-static void _transformSurfaceRGBA(SDL_Surface * src, SDL_Surface * dst, int cx, int cy, int isin, int icos, int flipx, int flipy, int smooth)
+static void _transformSurfaceRGBA(SDL_Surface *src,
+                                  SDL_Surface *dst,
+                                  int cx,
+                                  int cy,
+                                  int isin,
+                                  int icos,
+                                  int flipx,
+                                  int flipy,
+                                  int smooth)
 {
-	int x, y, t1, t2, dx, dy, xd, yd, sdx, sdy, ax, ay, ex, ey, sw, sh;
-	tColorRGBA c00, c01, c10, c11, cswap;
-	tColorRGBA *pc, *sp;
-	int gap;
-
-	/*
-	* Variable setup 
-	*/
-	xd = ((src->w - dst->w) << 15);
-	yd = ((src->h - dst->h) << 15);
-	ax = (cx << 16) - (icos * cx);
-	ay = (cy << 16) - (isin * cx);
-	sw = src->w - 1;
-	sh = src->h - 1;
-	pc = static_cast<tColorRGBA*>(dst->pixels);
-	gap = dst->pitch - dst->w * 4;
-
-	/*
-	* Switch between interpolating and non-interpolating code 
-	*/
-	if (smooth) {
-		for (y = 0; y < dst->h; y++) {
-			dy = cy - y;
-			sdx = (ax + (isin * dy)) + xd;
-			sdy = (ay - (icos * dy)) + yd;
-			for (x = 0; x < dst->w; x++) {
-				dx = (sdx >> 16);
-				dy = (sdy >> 16);
-				if (flipx) dx = sw - dx;
-				if (flipy) dy = sh - dy;
-				if ((dx > -1) && (dy > -1) && (dx < (src->w-1)) && (dy < (src->h-1))) {
-					sp = static_cast<tColorRGBA *>(src->pixels);
-					sp += ((src->pitch/4) * dy);
-					sp += dx;
-					c00 = *sp;
-					sp += 1;
-					c01 = *sp;
-					sp += (src->pitch/4);
-					c11 = *sp;
-					sp -= 1;
-					c10 = *sp;
-					if (flipx) {
-						cswap = c00; c00=c01; c01=cswap;
-						cswap = c10; c10=c11; c11=cswap;
-					}
-					if (flipy) {
-						cswap = c00; c00=c10; c10=cswap;
-						cswap = c01; c01=c11; c11=cswap;
-					}
-					/*
-					* Interpolate colors 
-					*/
-					ex = (sdx & 0xffff);
-					ey = (sdy & 0xffff);
-					t1 = ((((c01.r - c00.r) * ex) >> 16) + c00.r) & 0xff;
-					t2 = ((((c11.r - c10.r) * ex) >> 16) + c10.r) & 0xff;
-					pc->r = (((t2 - t1) * ey) >> 16) + t1;
-					t1 = ((((c01.g - c00.g) * ex) >> 16) + c00.g) & 0xff;
-					t2 = ((((c11.g - c10.g) * ex) >> 16) + c10.g) & 0xff;
-					pc->g = (((t2 - t1) * ey) >> 16) + t1;
-					t1 = ((((c01.b - c00.b) * ex) >> 16) + c00.b) & 0xff;
-					t2 = ((((c11.b - c10.b) * ex) >> 16) + c10.b) & 0xff;
-					pc->b = (((t2 - t1) * ey) >> 16) + t1;
-					t1 = ((((c01.a - c00.a) * ex) >> 16) + c00.a) & 0xff;
-					t2 = ((((c11.a - c10.a) * ex) >> 16) + c10.a) & 0xff;
-					pc->a = (((t2 - t1) * ey) >> 16) + t1;
-				}
-				sdx += icos;
-				sdy += isin;
-				pc++;
-			}
-			pc = reinterpret_cast<tColorRGBA *>(reinterpret_cast<Uint8*>(pc) + gap);
-		}
-	} else {
-		for (y = 0; y < dst->h; y++) {
-			dy = cy - y;
-			sdx = (ax + (isin * dy)) + xd;
-			sdy = (ay - (icos * dy)) + yd;
-			for (x = 0; x < dst->w; x++) {
-				dx = static_cast<short>(sdx >> 16);
-				dy = static_cast<short>(sdy >> 16);
-				if (flipx) dx = (src->w-1)-dx;
-				if (flipy) dy = (src->h-1)-dy;
-				if ((dx >= 0) && (dy >= 0) && (dx < src->w) && (dy < src->h)) {
-					sp = reinterpret_cast<tColorRGBA *>(reinterpret_cast<Uint8*>(src->pixels) + src->pitch * dy);
-					sp += dx;
-					*pc = *sp;
-				}
-				sdx += icos;
-				sdy += isin;
-				pc++;
-			}
-			pc = reinterpret_cast<tColorRGBA *>(reinterpret_cast<Uint8*>(pc) + gap);
-		}
-	}
+    int x, y, t1, t2, dx, dy, xd, yd, sdx, sdy, ax, ay, ex, ey, sw, sh;
+    tColorRGBA c00, c01, c10, c11, cswap;
+    tColorRGBA *pc, *sp;
+    int gap;
+
+    /*
+    * Variable setup
+    */
+    xd = ((src->w - dst->w) << 15);
+    yd = ((src->h - dst->h) << 15);
+    ax = (cx << 16) - (icos * cx);
+    ay = (cy << 16) - (isin * cx);
+    sw = src->w - 1;
+    sh = src->h - 1;
+    pc = static_cast<tColorRGBA*>(dst->pixels);
+    gap = dst->pitch - dst->w * 4;
+
+    /*
+    * Switch between interpolating and non-interpolating code
+    */
+    if (smooth)
+    {
+        for (y = 0; y < dst->h; y++)
+        {
+            dy = cy - y;
+            sdx = (ax + (isin * dy)) + xd;
+            sdy = (ay - (icos * dy)) + yd;
+            for (x = 0; x < dst->w; x++)
+            {
+                dx = (sdx >> 16);
+                dy = (sdy >> 16);
+                if (flipx) dx = sw - dx;
+                if (flipy) dy = sh - dy;
+                if ((dx > -1) && (dy > -1) &&
+                    (dx < (src->w-1)) && (dy < (src->h-1)))
+                {
+                    sp = static_cast<tColorRGBA *>(src->pixels);
+                    sp += ((src->pitch/4) * dy);
+                    sp += dx;
+                    c00 = *sp;
+                    sp += 1;
+                    c01 = *sp;
+                    sp += (src->pitch/4);
+                    c11 = *sp;
+                    sp -= 1;
+                    c10 = *sp;
+                    if (flipx)
+                    {
+                        cswap = c00; c00=c01; c01=cswap;
+                        cswap = c10; c10=c11; c11=cswap;
+                    }
+                    if (flipy)
+                    {
+                        cswap = c00; c00=c10; c10=cswap;
+                        cswap = c01; c01=c11; c11=cswap;
+                    }
+                    /*
+                    * Interpolate colors
+                    */
+                    ex = (sdx & 0xffff);
+                    ey = (sdy & 0xffff);
+                    t1 = ((((c01.r - c00.r) * ex) >> 16) + c00.r) & 0xff;
+                    t2 = ((((c11.r - c10.r) * ex) >> 16) + c10.r) & 0xff;
+                    pc->r = (((t2 - t1) * ey) >> 16) + t1;
+                    t1 = ((((c01.g - c00.g) * ex) >> 16) + c00.g) & 0xff;
+                    t2 = ((((c11.g - c10.g) * ex) >> 16) + c10.g) & 0xff;
+                    pc->g = (((t2 - t1) * ey) >> 16) + t1;
+                    t1 = ((((c01.b - c00.b) * ex) >> 16) + c00.b) & 0xff;
+                    t2 = ((((c11.b - c10.b) * ex) >> 16) + c10.b) & 0xff;
+                    pc->b = (((t2 - t1) * ey) >> 16) + t1;
+                    t1 = ((((c01.a - c00.a) * ex) >> 16) + c00.a) & 0xff;
+                    t2 = ((((c11.a - c10.a) * ex) >> 16) + c10.a) & 0xff;
+                    pc->a = (((t2 - t1) * ey) >> 16) + t1;
+                }
+                sdx += icos;
+                sdy += isin;
+                pc++;
+            }
+            pc = reinterpret_cast<tColorRGBA *>(
+                reinterpret_cast<Uint8*>(pc) + gap);
+        }
+    }
+    else
+    {
+        for (y = 0; y < dst->h; y++)
+        {
+            dy = cy - y;
+            sdx = (ax + (isin * dy)) + xd;
+            sdy = (ay - (icos * dy)) + yd;
+            for (x = 0; x < dst->w; x++)
+            {
+                dx = static_cast<short>(sdx >> 16);
+                dy = static_cast<short>(sdy >> 16);
+                if (flipx) dx = (src->w-1)-dx;
+                if (flipy) dy = (src->h-1)-dy;
+                if ((dx >= 0) && (dy >= 0) && (dx < src->w) && (dy < src->h))
+                {
+                    sp = reinterpret_cast<tColorRGBA *>(
+                        reinterpret_cast<Uint8*>(src->pixels) +
+                        src->pitch * dy);
+                    sp += dx;
+                    *pc = *sp;
+                }
+                sdx += icos;
+                sdy += isin;
+                pc++;
+            }
+            pc = reinterpret_cast<tColorRGBA *>(
+                reinterpret_cast<Uint8*>(pc) + gap);
+        }
+    }
 }
 
 /*!
 
 \brief Rotates and zooms 8 bit palette/Y 'src' surface to 'dst' surface without smoothing.
 
-Rotates and zooms 8 bit RGBA/ABGR 'src' surface to 'dst' surface based on the control 
+Rotates and zooms 8 bit RGBA/ABGR 'src' surface to 'dst' surface based on the control
 parameters by scanning the destination surface.
 Assumes src and dst surfaces are of 8 bit depth.
 Assumes dst surface was allocated with the correct dimensions.
@@ -745,54 +844,64 @@ Assumes dst surface was allocated with the correct dimensions.
 \param flipx Flag indicating horizontal mirroring should be applied.
 \param flipy Flag indicating vertical mirroring should be applied.
 */
-static void transformSurfaceY(SDL_Surface * src, SDL_Surface * dst, int cx, int cy, int isin, int icos, int flipx, int flipy)
+static void transformSurfaceY(SDL_Surface *src,
+                              SDL_Surface *dst,
+                              int cx,
+                              int cy,
+                              int isin,
+                              int icos,
+                              int flipx,
+                              int flipy)
 {
-	int x, y, dx, dy, xd, yd, sdx, sdy, ax, ay;
-	tColorY *pc, *sp;
-	int gap;
-
-	/*
-	* Variable setup 
-	*/
-	xd = ((src->w - dst->w) << 15);
-	yd = ((src->h - dst->h) << 15);
-	ax = (cx << 16) - (icos * cx);
-	ay = (cy << 16) - (isin * cx);
-	pc = static_cast<tColorY*>(dst->pixels);
-	gap = dst->pitch - dst->w;
-	/*
-	* Clear surface to colorkey 
-	*/ 	
-	memset(pc, static_cast<int>(_colorkey(src) & 0xff), dst->pitch * dst->h);
-	/*
-	* Iterate through destination surface 
-	*/
-	for (y = 0; y < dst->h; y++) {
-		dy = cy - y;
-		sdx = (ax + (isin * dy)) + xd;
-		sdy = (ay - (icos * dy)) + yd;
-		for (x = 0; x < dst->w; x++) {
-			dx = static_cast<short>(sdx >> 16);
-			dy = static_cast<short>(sdy >> 16);
-			if (flipx) dx = (src->w-1)-dx;
-			if (flipy) dy = (src->h-1)-dy;
-			if ((dx >= 0) && (dy >= 0) && (dx < src->w) && (dy < src->h)) {
-				sp = static_cast<tColorY *>(src->pixels);
-				sp += (src->pitch * dy + dx);
-				*pc = *sp;
-			}
-			sdx += icos;
-			sdy += isin;
-			pc++;
-		}
-		pc += gap;
-	}
+    int x, y, dx, dy, xd, yd, sdx, sdy, ax, ay;
+    tColorY *pc, *sp;
+    int gap;
+
+    /*
+    * Variable setup
+    */
+    xd = ((src->w - dst->w) << 15);
+    yd = ((src->h - dst->h) << 15);
+    ax = (cx << 16) - (icos * cx);
+    ay = (cy << 16) - (isin * cx);
+    pc = static_cast<tColorY*>(dst->pixels);
+    gap = dst->pitch - dst->w;
+    /*
+    * Clear surface to colorkey
+    */
+    memset(pc, static_cast<int>(_colorkey(src) & 0xff), dst->pitch * dst->h);
+    /*
+    * Iterate through destination surface
+    */
+    for (y = 0; y < dst->h; y++)
+    {
+        dy = cy - y;
+        sdx = (ax + (isin * dy)) + xd;
+        sdy = (ay - (icos * dy)) + yd;
+        for (x = 0; x < dst->w; x++)
+        {
+            dx = static_cast<short>(sdx >> 16);
+            dy = static_cast<short>(sdy >> 16);
+            if (flipx) dx = (src->w-1)-dx;
+            if (flipy) dy = (src->h-1)-dy;
+            if ((dx >= 0) && (dy >= 0) && (dx < src->w) && (dy < src->h))
+            {
+                sp = static_cast<tColorY *>(src->pixels);
+                sp += (src->pitch * dy + dx);
+                *pc = *sp;
+            }
+            sdx += icos;
+            sdy += isin;
+            pc++;
+        }
+        pc += gap;
+    }
 }
 
 /*!
 \brief Rotates a 8/16/24/32 bit surface in increments of 90 degrees.
 
-Specialized 90 degree rotator which rotates a 'src' surface in 90 degree 
+Specialized 90 degree rotator which rotates a 'src' surface in 90 degree
 increments clockwise returning a new surface. Faster than rotozoomer since
 no scanning or interpolation takes place. Input surface must be 8/16/24/32 bit.
 (code contributed by J. Schiller, improved by C. Allport and A. Schiffler)
@@ -802,147 +911,179 @@ no scanning or interpolation takes place. Input surface must be 8/16/24/32 bit.
 
 \returns The new, rotated surface; or nullptr for surfaces with incorrect input format.
 */
-SDL_Surface* rotateSurface90Degrees(SDL_Surface* src, int numClockwiseTurns) 
+SDL_Surface* rotateSurface90Degrees(SDL_Surface *src,
+                                    int numClockwiseTurns)
 {
-	int row, col, newWidth, newHeight;
-	int bpp, bpr;
-	SDL_Surface* dst;
-	Uint8* srcBuf;
-	Uint8* dstBuf;
-	int normalizedClockwiseTurns;
-
-	/* Has to be a valid surface pointer and be a Nbit surface where n is divisible by 8 */
-	if (!src || 
-	    !src->format) {
-		SDL_SetError("NULL source surface or source surface format");
-	    return nullptr; 
-	}
-
-	if ((src->format->BitsPerPixel % 8) != 0) {
-		SDL_SetError("Invalid source surface bit depth");
-	    return nullptr; 
-	}
-
-	/* normalize numClockwiseTurns */
-	normalizedClockwiseTurns = (numClockwiseTurns % 4);
-	if (normalizedClockwiseTurns < 0) {
-		normalizedClockwiseTurns += 4;
-	}
-
-	/* If turns are even, our new width/height will be the same as the source surface */
-	if (normalizedClockwiseTurns % 2) {
-		newWidth = src->h;
-		newHeight = src->w;
-	} else {
-		newWidth = src->w;
-		newHeight = src->h;
-	}
-
-	dst = SDL_CreateRGBSurface( src->flags, newWidth, newHeight, src->format->BitsPerPixel,
-		src->format->Rmask,
-		src->format->Gmask, 
-		src->format->Bmask, 
-		src->format->Amask);
-	if(!dst) {
-		SDL_SetError("Could not create destination surface"); 
-		return nullptr;
-	}
-
-	if (SDL_MUSTLOCK(src)) {
-		SDL_LockSurface(src);
-	}
-	if (SDL_MUSTLOCK(dst)) {
-		SDL_LockSurface(dst);
-	}
-
-	/* Calculate byte-per-pixel */
-	bpp = src->format->BitsPerPixel / 8;
-
-	switch(normalizedClockwiseTurns) {
-	case 0: /* Make a copy of the surface */
-		{
-			/* Unfortunately SDL_BlitSurface cannot be used to make a copy of the surface
-			since it does not preserve alpha. */
-
-			if (src->pitch == dst->pitch) {
-				/* If the pitch is the same for both surfaces, the memory can be copied all at once. */
-				memcpy(dst->pixels, src->pixels, (src->h * src->pitch));
-			}
-			else
-			{
-				/* If the pitch differs, copy each row separately */
-				srcBuf = static_cast<Uint8*>(src->pixels);
-				dstBuf = static_cast<Uint8*>(dst->pixels);
-				bpr = src->w * bpp;
-				for (row = 0; row < src->h; row++) {
-					memcpy(dstBuf, srcBuf, bpr);
-					srcBuf += src->pitch;
-					dstBuf += dst->pitch;
-				}
-			}
-		}
-		break;
-
-		/* rotate clockwise */
-	case 1: /* rotated 90 degrees clockwise */
-		{
-			for (row = 0; row < src->h; ++row) {
-				srcBuf = static_cast<Uint8*>(src->pixels) + (row * src->pitch);
-				dstBuf = static_cast<Uint8*>(dst->pixels) + (dst->w - row - 1) * bpp;
-				for (col = 0; col < src->w; ++col) {
-					memcpy (dstBuf, srcBuf, bpp);
-					srcBuf += bpp;
-					dstBuf += dst->pitch;
-				} 
-			} 
-		}
-		break;
-
-	case 2: /* rotated 180 degrees clockwise */
-		{
-			for (row = 0; row < src->h; ++row) {
-				srcBuf = static_cast<Uint8*>(src->pixels) + (row * src->pitch);
-				dstBuf = static_cast<Uint8*>(dst->pixels) + ((dst->h - row - 1) * dst->pitch) + (dst->w - 1) * bpp;
-				for (col = 0; col < src->w; ++col) {
-					memcpy (dstBuf, srcBuf, bpp);
-					srcBuf += bpp;
-					dstBuf -= bpp;
-				} 
-			} 
-		}
-		break;
-
-	case 3: /* rotated 270 degrees clockwise */
-		{
-			for (row = 0; row < src->h; ++row) {
-				srcBuf = static_cast<Uint8*>(src->pixels) + (row * src->pitch);
-				dstBuf = static_cast<Uint8*>(dst->pixels) + (row * bpp) + (dst->h * dst->pitch);
-				for (col = 0; col < src->w; ++col) {
-					memcpy (dstBuf, srcBuf, bpp);
-					srcBuf += bpp;
-					dstBuf -= dst->pitch;
-				} 
-			} 
-		}
-		break;
-	default:
-		break;
-	} 
-	/* end switch */
-
-	if (SDL_MUSTLOCK(src)) {
-		SDL_UnlockSurface(src);
-	}
-	if (SDL_MUSTLOCK(dst)) {
-		SDL_UnlockSurface(dst);
-	}
-
-	return dst;
+    int row, col, newWidth, newHeight;
+    int bpp, bpr;
+    SDL_Surface* dst;
+    Uint8* srcBuf;
+    Uint8* dstBuf;
+    int normalizedClockwiseTurns;
+
+    /* Has to be a valid surface pointer and be a Nbit surface where n is divisible by 8 */
+    if (!src ||
+        !src->format)
+    {
+        SDL_SetError("NULL source surface or source surface format");
+        return nullptr;
+    }
+
+    if ((src->format->BitsPerPixel % 8) != 0)
+    {
+        SDL_SetError("Invalid source surface bit depth");
+        return nullptr;
+    }
+
+    /* normalize numClockwiseTurns */
+    normalizedClockwiseTurns = (numClockwiseTurns % 4);
+    if (normalizedClockwiseTurns < 0)
+    {
+        normalizedClockwiseTurns += 4;
+    }
+
+    /* If turns are even, our new width/height will be the same as the source surface */
+    if (normalizedClockwiseTurns % 2)
+    {
+        newWidth = src->h;
+        newHeight = src->w;
+    }
+    else
+    {
+        newWidth = src->w;
+        newHeight = src->h;
+    }
+
+    dst = SDL_CreateRGBSurface(src->flags,
+        newWidth,
+        newHeight,
+        src->format->BitsPerPixel,
+        src->format->Rmask,
+        src->format->Gmask,
+        src->format->Bmask,
+        src->format->Amask);
+    if (!dst)
+    {
+        SDL_SetError("Could not create destination surface");
+        return nullptr;
+    }
+
+    if (SDL_MUSTLOCK(src))
+    {
+        SDL_LockSurface(src);
+    }
+    if (SDL_MUSTLOCK(dst))
+    {
+        SDL_LockSurface(dst);
+    }
+
+    /* Calculate byte-per-pixel */
+    bpp = src->format->BitsPerPixel / 8;
+
+    switch (normalizedClockwiseTurns)
+    {
+    case 0: /* Make a copy of the surface */
+        {
+            /* Unfortunately SDL_BlitSurface cannot be used to
+            make a copy of the surface
+            since it does not preserve alpha. */
+
+            if (src->pitch == dst->pitch)
+            {
+                /* If the pitch is the same for both surfaces,
+                the memory can be copied all at once. */
+                memcpy(dst->pixels, src->pixels, (src->h * src->pitch));
+            }
+            else
+            {
+                /* If the pitch differs, copy each row separately */
+                srcBuf = static_cast<Uint8*>(src->pixels);
+                dstBuf = static_cast<Uint8*>(dst->pixels);
+                bpr = src->w * bpp;
+                for (row = 0; row < src->h; row++)
+                {
+                    memcpy(dstBuf, srcBuf, bpr);
+                    srcBuf += src->pitch;
+                    dstBuf += dst->pitch;
+                }
+            }
+        }
+        break;
+
+        /* rotate clockwise */
+    case 1: /* rotated 90 degrees clockwise */
+        {
+            for (row = 0; row < src->h; ++row)
+            {
+                srcBuf = static_cast<Uint8*>(src->pixels) +
+                    (row * src->pitch);
+                dstBuf = static_cast<Uint8*>(dst->pixels) +
+                    (dst->w - row - 1) * bpp;
+                for (col = 0; col < src->w; ++col)
+                {
+                    memcpy (dstBuf, srcBuf, bpp);
+                    srcBuf += bpp;
+                    dstBuf += dst->pitch;
+                }
+            }
+        }
+        break;
+
+    case 2: /* rotated 180 degrees clockwise */
+        {
+            for (row = 0; row < src->h; ++row)
+            {
+                srcBuf = static_cast<Uint8*>(src->pixels) +
+                    (row * src->pitch);
+                dstBuf = static_cast<Uint8*>(dst->pixels) +
+                    ((dst->h - row - 1) * dst->pitch) + (dst->w - 1) * bpp;
+                for (col = 0; col < src->w; ++col)
+                {
+                    memcpy (dstBuf, srcBuf, bpp);
+                    srcBuf += bpp;
+                    dstBuf -= bpp;
+                }
+            }
+        }
+        break;
+
+    case 3: /* rotated 270 degrees clockwise */
+        {
+            for (row = 0; row < src->h; ++row)
+            {
+                srcBuf = static_cast<Uint8*>(src->pixels) + (row * src->pitch);
+                dstBuf = static_cast<Uint8*>(dst->pixels) +
+                    (row * bpp) + (dst->h * dst->pitch);
+                for (col = 0; col < src->w; ++col)
+                {
+                    memcpy (dstBuf, srcBuf, bpp);
+                    srcBuf += bpp;
+                    dstBuf -= dst->pitch;
+                }
+            }
+        }
+        break;
+    default:
+        break;
+    }
+    /* end switch */
+
+    if (SDL_MUSTLOCK(src))
+    {
+        SDL_UnlockSurface(src);
+    }
+    if (SDL_MUSTLOCK(dst))
+    {
+        SDL_UnlockSurface(dst);
+    }
+
+    return dst;
 }
 
 
 /*!
-\brief Internal target surface sizing function for rotozooms with trig result return. 
+\brief Internal target surface sizing function for rotozooms
+with trig result return.
 
 \param width The source surface width.
 \param height The source surface height.
@@ -955,39 +1096,48 @@ SDL_Surface* rotateSurface90Degrees(SDL_Surface* src, int numClockwiseTurns)
 \param sanglezoom The cosine of the angle adjusted by the zoom factor.
 
 */
-static void _rotozoomSurfaceSizeTrig(int width, int height, double angle, double zoomx, double zoomy, 
-	int *dstwidth, int *dstheight, 
-	double *canglezoom, double *sanglezoom)
+static void _rotozoomSurfaceSizeTrig(int width,
+                                     int height,
+                                     double angle,
+                                     double zoomx,
+                                     double zoomy,
+                                     int *dstwidth,
+                                     int *dstheight,
+                                     double *canglezoom,
+                                     double *sanglezoom)
 {
-	double x, y, cx, cy, sx, sy;
-	double radangle;
-	int dstwidthhalf, dstheighthalf;
-
-	/*
-	* Determine destination width and height by rotating a centered source box 
-	*/
-	radangle = angle * (M_PI / 180.0);
-	*sanglezoom = sin(radangle);
-	*canglezoom = cos(radangle);
-	*sanglezoom *= zoomx;
-	*canglezoom *= zoomy;
-	x = static_cast<double>(width / 2);
-	y = static_cast<double>(height / 2);
-	cx = *canglezoom * x;
-	cy = *canglezoom * y;
-	sx = *sanglezoom * x;
-	sy = *sanglezoom * y;
-
-	dstwidthhalf = MAX(static_cast<int>(
-		ceil(MAX(MAX(MAX(fabs(cx + sy), fabs(cx - sy)), fabs(-cx + sy)), fabs(-cx - sy)))), 1);
-	dstheighthalf = MAX(static_cast<int>(
-		ceil(MAX(MAX(MAX(fabs(sx + cy), fabs(sx - cy)), fabs(-sx + cy)), fabs(-sx - cy)))), 1);
-	*dstwidth = 2 * dstwidthhalf;
-	*dstheight = 2 * dstheighthalf;
+    double x, y, cx, cy, sx, sy;
+    double radangle;
+    int dstwidthhalf, dstheighthalf;
+
+    /*
+    * Determine destination width and height by rotating a centered source box
+    */
+    radangle = angle * (M_PI / 180.0);
+    *sanglezoom = sin(radangle);
+    *canglezoom = cos(radangle);
+    *sanglezoom *= zoomx;
+    *canglezoom *= zoomy;
+    x = static_cast<double>(width / 2);
+    y = static_cast<double>(height / 2);
+    cx = *canglezoom * x;
+    cy = *canglezoom * y;
+    sx = *sanglezoom * x;
+    sy = *sanglezoom * y;
+
+    dstwidthhalf = MAX(static_cast<int>(
+        ceil(MAX(MAX(MAX(fabs(cx + sy), fabs(cx - sy)),
+        fabs(-cx + sy)), fabs(-cx - sy)))), 1);
+    dstheighthalf = MAX(static_cast<int>(
+        ceil(MAX(MAX(MAX(fabs(sx + cy), fabs(sx - cy)),
+        fabs(-sx + cy)), fabs(-sx - cy)))), 1);
+    *dstwidth = 2 * dstwidthhalf;
+    *dstheight = 2 * dstheighthalf;
 }
 
-/*! 
-\brief Returns the size of the resulting target surface for a rotozoomSurfaceXY() call. 
+/*!
+\brief Returns the size of the resulting target surface for a
+rotozoomSurfaceXY() call.
 
 \param width The source surface width.
 \param height The source surface height.
@@ -997,15 +1147,23 @@ static void _rotozoomSurfaceSizeTrig(int width, int height, double angle, double
 \param dstwidth The calculated width of the rotozoomed destination surface.
 \param dstheight The calculated height of the rotozoomed destination surface.
 */
-void rotozoomSurfaceSizeXY(int width, int height, double angle, double zoomx, double zoomy, int *dstwidth, int *dstheight)
+void rotozoomSurfaceSizeXY(int width,
+                           int height,
+                           double angle,
+                           double zoomx,
+                           double zoomy,
+                           int *dstwidth,
+                           int *dstheight)
 {
-	double dummy_sanglezoom, dummy_canglezoom;
+    double dummy_sanglezoom, dummy_canglezoom;
 
-	_rotozoomSurfaceSizeTrig(width, height, angle, zoomx, zoomy, dstwidth, dstheight, &dummy_sanglezoom, &dummy_canglezoom);
+    _rotozoomSurfaceSizeTrig(width, height, angle, zoomx, zoomy,
+        dstwidth, dstheight, &dummy_sanglezoom, &dummy_canglezoom);
 }
 
-/*! 
-\brief Returns the size of the resulting target surface for a rotozoomSurface() call. 
+/*!
+\brief Returns the size of the resulting target surface for a rotozoomSurface()
+call.
 
 \param width The source surface width.
 \param height The source surface height.
@@ -1014,20 +1172,27 @@ void rotozoomSurfaceSizeXY(int width, int height, double angle, double zoomx, do
 \param dstwidth The calculated width of the rotozoomed destination surface.
 \param dstheight The calculated height of the rotozoomed destination surface.
 */
-void rotozoomSurfaceSize(int width, int height, double angle, double zoom, int *dstwidth, int *dstheight)
+void rotozoomSurfaceSize(int width,
+                         int height,
+                         double angle,
+                         double zoom,
+                         int *dstwidth,
+                         int *dstheight)
 {
-	double dummy_sanglezoom, dummy_canglezoom;
+    double dummy_sanglezoom, dummy_canglezoom;
 
-	_rotozoomSurfaceSizeTrig(width, height, angle, zoom, zoom, dstwidth, dstheight, &dummy_sanglezoom, &dummy_canglezoom);
+    _rotozoomSurfaceSizeTrig(width, height, angle, zoom, zoom,
+        dstwidth, dstheight, &dummy_sanglezoom, &dummy_canglezoom);
 }
 
 /*!
-\brief Rotates and zooms a surface and optional anti-aliasing. 
+\brief Rotates and zooms a surface and optional anti-aliasing.
 
-Rotates and zoomes a 32bit or 8bit 'src' surface to newly created 'dst' surface.
-'angle' is the rotation in degrees and 'zoom' a scaling factor. If 'smooth' is set
-then the destination 32bit surface is anti-aliased. If the surface is not 8bit
-or 32bit RGBA/ABGR it will be converted into a 32bit RGBA format on the fly.
+Rotates and zoomes a 32bit or 8bit 'src' surface to newly created 'dst'
+surface. 'angle' is the rotation in degrees and 'zoom' a scaling factor.
+If 'smooth' is set then the destination 32bit surface is anti-aliased.
+If the surface is not 8bit or 32bit RGBA/ABGR it will be converted into
+a 32bit RGBA format on the fly.
 
 \param src The surface to rotozoom.
 \param angle The angle to rotate in degrees.
@@ -1036,18 +1201,23 @@ or 32bit RGBA/ABGR it will be converted into a 32bit RGBA format on the fly.
 
 \return The new rotozoomed surface.
 */
-SDL_Surface *rotozoomSurface(SDL_Surface * src, double angle, double zoom, int smooth)
+SDL_Surface *rotozoomSurface(SDL_Surface *src,
+                             double angle,
+                             double zoom,
+                             int smooth)
 {
-	return rotozoomSurfaceXY(src, angle, zoom, zoom, smooth);
+    return rotozoomSurfaceXY(src, angle, zoom, zoom, smooth);
 }
 
 /*!
-\brief Rotates and zooms a surface with different horizontal and vertival scaling factors and optional anti-aliasing. 
+\brief Rotates and zooms a surface with different horizontal and
+vertival scaling factors and optional anti-aliasing.
 
 Rotates and zooms a 32bit or 8bit 'src' surface to newly created 'dst' surface.
-'angle' is the rotation in degrees, 'zoomx and 'zoomy' scaling factors. If 'smooth' is set
-then the destination 32bit surface is anti-aliased. If the surface is not 8bit
-or 32bit RGBA/ABGR it will be converted into a 32bit RGBA format on the fly.
+'angle' is the rotation in degrees, 'zoomx and 'zoomy' scaling factors.
+If 'smooth' is set then the destination 32bit surface is anti-aliased.
+If the surface is not 8bit or 32bit RGBA/ABGR it will be converted into
+a 32bit RGBA format on the fly.
 
 \param src The surface to rotozoom.
 \param angle The angle to rotate in degrees.
@@ -1057,297 +1227,352 @@ or 32bit RGBA/ABGR it will be converted into a 32bit RGBA format on the fly.
 
 \return The new rotozoomed surface.
 */
-SDL_Surface *rotozoomSurfaceXY(SDL_Surface * src, double angle, double zoomx, double zoomy, int smooth)
+SDL_Surface *rotozoomSurfaceXY(SDL_Surface *src,
+                               double angle,
+                               double zoomx,
+                               double zoomy,
+                               int smooth)
 {
-	SDL_Surface *rz_src;
-	SDL_Surface *rz_dst;
-	double zoominv;
-	double sanglezoom, canglezoom, sanglezoominv, canglezoominv;
-	int dstwidthhalf, dstwidth, dstheighthalf, dstheight;
-	int is32bit;
-	int i, src_converted;
-	int flipx,flipy;
-
-	/*
-	* Sanity check 
-	*/
-	if (src == nullptr) {
-		return (nullptr);
-	}
-
-	/*
-	* Determine if source surface is 32bit or 8bit 
-	*/
-	is32bit = (src->format->BitsPerPixel == 32);
-	if ((is32bit) || (src->format->BitsPerPixel == 8)) {
-		/*
-		* Use source surface 'as is' 
-		*/
-		rz_src = src;
-		src_converted = 0;
-	} else {
-		/*
-		* New source surface is 32bit with a defined RGBA ordering 
-		*/
-		rz_src =
-			SDL_CreateRGBSurface(SDL_SWSURFACE, src->w, src->h, 32, 
+    SDL_Surface *rz_src;
+    SDL_Surface *rz_dst;
+    double zoominv;
+    double sanglezoom, canglezoom, sanglezoominv, canglezoominv;
+    int dstwidthhalf, dstwidth, dstheighthalf, dstheight;
+    int is32bit;
+    int i, src_converted;
+    int flipx,flipy;
+
+    /*
+    * Sanity check
+    */
+    if (src == nullptr)
+    {
+        return (nullptr);
+    }
+
+    /*
+    * Determine if source surface is 32bit or 8bit
+    */
+    is32bit = (src->format->BitsPerPixel == 32);
+    if ((is32bit) || (src->format->BitsPerPixel == 8))
+    {
+        /*
+        * Use source surface 'as is'
+        */
+        rz_src = src;
+        src_converted = 0;
+    }
+    else
+    {
+        /*
+        * New source surface is 32bit with a defined RGBA ordering
+        */
+        rz_src =
+            SDL_CreateRGBSurface(SDL_SWSURFACE, src->w, src->h, 32,
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
-			0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000
+            0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000
 #else
-			0xff000000,  0x00ff0000, 0x0000ff00, 0x000000ff
+            0xff000000,  0x00ff0000, 0x0000ff00, 0x000000ff
 #endif
-			);
-
-		SDL_BlitSurface(src, nullptr, rz_src, nullptr);
-
-		src_converted = 1;
-		is32bit = 1;
-	}
-
-	/*
-	* Sanity check zoom factor 
-	*/
-	flipx = (zoomx<0.0);
-	if (flipx) zoomx=-zoomx;
-	flipy = (zoomy<0.0);
-	if (flipy) zoomy=-zoomy;
-	if (zoomx < VALUE_LIMIT) zoomx = VALUE_LIMIT;
-	if (zoomy < VALUE_LIMIT) zoomy = VALUE_LIMIT;
-	zoominv = 65536.0 / (zoomx * zoomx);
-
-	/*
-	* Check if we have a rotozoom or just a zoom 
-	*/
-	if (fabs(angle) > VALUE_LIMIT) {
-
-		/*
-		* Angle!=0: full rotozoom 
-		*/
-		/*
-		* ----------------------- 
-		*/
-
-		/* Determine target size */
-		_rotozoomSurfaceSizeTrig(rz_src->w, rz_src->h, angle, zoomx, zoomy, &dstwidth, &dstheight, &canglezoom, &sanglezoom);
-
-		/*
-		* Calculate target factors from sin/cos and zoom 
-		*/
-		sanglezoominv = sanglezoom;
-		canglezoominv = canglezoom;
-		sanglezoominv *= zoominv;
-		canglezoominv *= zoominv;
-
-		/* Calculate half size */
-		dstwidthhalf = dstwidth / 2;
-		dstheighthalf = dstheight / 2;
-
-		/*
-		* Alloc space to completely contain the rotated surface 
-		*/
-		rz_dst = nullptr;
-		if (is32bit) {
-			/*
-			* Target surface is 32bit with source RGBA/ABGR ordering 
-			*/
-			rz_dst =
-				SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight + GUARD_ROWS, 32,
-				rz_src->format->Rmask, rz_src->format->Gmask,
-				rz_src->format->Bmask, rz_src->format->Amask);
-		} else {
-			/*
-			* Target surface is 8bit 
-			*/
-			rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight + GUARD_ROWS, 8, 0, 0, 0, 0);
-		}
-
-		/* Check target */
-		if (rz_dst == nullptr)
-			return nullptr;
-
-		/* Adjust for guard rows */
-		rz_dst->h = dstheight;
-
-		/*
-		* Lock source surface 
-		*/
-		if (SDL_MUSTLOCK(rz_src)) {
-			SDL_LockSurface(rz_src);
-		}
-
-		/*
-		* Check which kind of surface we have 
-		*/
-		if (is32bit) {
-			/*
-			* Call the 32bit transformation routine to do the rotation (using alpha) 
-			*/
-			_transformSurfaceRGBA(rz_src, rz_dst, dstwidthhalf, dstheighthalf,
-				static_cast<int>(sanglezoominv), static_cast<int>(canglezoominv), 
-				flipx, flipy,
-				smooth);
-		} else {
-			/*
-			* Copy palette and colorkey info 
-			*/
-			for (i = 0; i < rz_src->format->palette->ncolors; i++) {
-				rz_dst->format->palette->colors[i] = rz_src->format->palette->colors[i];
-			}
-			rz_dst->format->palette->ncolors = rz_src->format->palette->ncolors;
-			/*
-			* Call the 8bit transformation routine to do the rotation 
-			*/
-			transformSurfaceY(rz_src, rz_dst, dstwidthhalf, dstheighthalf,
-				static_cast<int>(sanglezoominv), static_cast<int>(canglezoominv),
-				flipx, flipy);
-		}
-		/*
-		* Unlock source surface 
-		*/
-		if (SDL_MUSTLOCK(rz_src)) {
-			SDL_UnlockSurface(rz_src);
-		}
-
-	} else {
-
-		/*
-		* Angle=0: Just a zoom 
-		*/
-		/*
-		* -------------------- 
-		*/
-
-		/*
-		* Calculate target size
-		*/
-		zoomSurfaceSize(rz_src->w, rz_src->h, zoomx, zoomy, &dstwidth, &dstheight);
-
-		/*
-		* Alloc space to completely contain the zoomed surface 
-		*/
-		rz_dst = nullptr;
-		if (is32bit) {
-			/*
-			* Target surface is 32bit with source RGBA/ABGR ordering 
-			*/
-			rz_dst =
-				SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight + GUARD_ROWS, 32,
-				rz_src->format->Rmask, rz_src->format->Gmask,
-				rz_src->format->Bmask, rz_src->format->Amask);
-		} else {
-			/*
-			* Target surface is 8bit 
-			*/
-			rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight + GUARD_ROWS, 8, 0, 0, 0, 0);
-		}
-
-		/* Check target */
-		if (rz_dst == nullptr)
-			return nullptr;
-
-		/* Adjust for guard rows */
-		rz_dst->h = dstheight;
-
-		/*
-		* Lock source surface 
-		*/
-		if (SDL_MUSTLOCK(rz_src)) {
-			SDL_LockSurface(rz_src);
-		}
-
-		/*
-		* Check which kind of surface we have 
-		*/
-		if (is32bit) {
-			/*
-			* Call the 32bit transformation routine to do the zooming (using alpha) 
-			*/
-			_zoomSurfaceRGBA(rz_src, rz_dst, flipx, flipy, smooth);
-
-		} else {
-			/*
-			* Copy palette and colorkey info 
-			*/
-			for (i = 0; i < rz_src->format->palette->ncolors; i++) {
-				rz_dst->format->palette->colors[i] = rz_src->format->palette->colors[i];
-			}
-			rz_dst->format->palette->ncolors = rz_src->format->palette->ncolors;
-
-			/*
-			* Call the 8bit transformation routine to do the zooming 
-			*/
-			_zoomSurfaceY(rz_src, rz_dst, flipx, flipy);
-		}
-
-		/*
-		* Unlock source surface 
-		*/
-		if (SDL_MUSTLOCK(rz_src)) {
-			SDL_UnlockSurface(rz_src);
-		}
-	}
-
-	/*
-	* Cleanup temp surface 
-	*/
-	if (src_converted) {
-		SDL_FreeSurface(rz_src);
-	}
-
-	/*
-	* Return destination surface 
-	*/
-	return (rz_dst);
+            );
+
+        SDL_BlitSurface(src, nullptr, rz_src, nullptr);
+
+        src_converted = 1;
+        is32bit = 1;
+    }
+
+    /*
+    * Sanity check zoom factor
+    */
+    flipx = (zoomx<0.0);
+    if (flipx) zoomx=-zoomx;
+    flipy = (zoomy<0.0);
+    if (flipy) zoomy=-zoomy;
+    if (zoomx < VALUE_LIMIT) zoomx = VALUE_LIMIT;
+    if (zoomy < VALUE_LIMIT) zoomy = VALUE_LIMIT;
+    zoominv = 65536.0 / (zoomx * zoomx);
+
+    /*
+    * Check if we have a rotozoom or just a zoom
+    */
+    if (fabs(angle) > VALUE_LIMIT)
+    {
+
+        /*
+        * Angle!=0: full rotozoom
+        */
+        /*
+        * -----------------------
+        */
+
+        /* Determine target size */
+        _rotozoomSurfaceSizeTrig(rz_src->w, rz_src->h, angle, zoomx, zoomy,
+            &dstwidth, &dstheight, &canglezoom, &sanglezoom);
+
+        /*
+        * Calculate target factors from sin/cos and zoom
+        */
+        sanglezoominv = sanglezoom;
+        canglezoominv = canglezoom;
+        sanglezoominv *= zoominv;
+        canglezoominv *= zoominv;
+
+        /* Calculate half size */
+        dstwidthhalf = dstwidth / 2;
+        dstheighthalf = dstheight / 2;
+
+        /*
+        * Alloc space to completely contain the rotated surface
+        */
+        rz_dst = nullptr;
+        if (is32bit)
+        {
+            /*
+            * Target surface is 32bit with source RGBA/ABGR ordering
+            */
+            rz_dst =
+                SDL_CreateRGBSurface(SDL_SWSURFACE,
+                dstwidth, dstheight + GUARD_ROWS, 32,
+                rz_src->format->Rmask, rz_src->format->Gmask,
+                rz_src->format->Bmask, rz_src->format->Amask);
+        }
+        else
+        {
+            /*
+            * Target surface is 8bit
+            */
+            rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth,
+                dstheight + GUARD_ROWS, 8, 0, 0, 0, 0);
+        }
+
+        /* Check target */
+        if (rz_dst == nullptr)
+            return nullptr;
+
+        /* Adjust for guard rows */
+        rz_dst->h = dstheight;
+
+        /*
+        * Lock source surface
+        */
+        if (SDL_MUSTLOCK(rz_src))
+        {
+            SDL_LockSurface(rz_src);
+        }
+
+        /*
+        * Check which kind of surface we have
+        */
+        if (is32bit)
+        {
+            /*
+            * Call the 32bit transformation routine to do the rotation
+            * (using alpha)
+            */
+            _transformSurfaceRGBA(rz_src, rz_dst, dstwidthhalf, dstheighthalf,
+                static_cast<int>(sanglezoominv),
+                static_cast<int>(canglezoominv),
+                flipx, flipy,
+                smooth);
+        }
+        else
+        {
+            /*
+            * Copy palette and colorkey info
+            */
+            for (i = 0; i < rz_src->format->palette->ncolors; i++)
+            {
+                rz_dst->format->palette->colors[i] =
+                    rz_src->format->palette->colors[i];
+            }
+            rz_dst->format->palette->ncolors =
+                rz_src->format->palette->ncolors;
+            /*
+            * Call the 8bit transformation routine to do the rotation
+            */
+            transformSurfaceY(rz_src, rz_dst, dstwidthhalf, dstheighthalf,
+                static_cast<int>(sanglezoominv),
+                static_cast<int>(canglezoominv),
+                flipx, flipy);
+        }
+        /*
+        * Unlock source surface
+        */
+        if (SDL_MUSTLOCK(rz_src))
+        {
+            SDL_UnlockSurface(rz_src);
+        }
+
+    }
+    else
+    {
+        /*
+        * Angle=0: Just a zoom
+        */
+        /*
+        * --------------------
+        */
+
+        /*
+        * Calculate target size
+        */
+        zoomSurfaceSize(rz_src->w, rz_src->h, zoomx, zoomy,
+            &dstwidth, &dstheight);
+
+        /*
+        * Alloc space to completely contain the zoomed surface
+        */
+        rz_dst = nullptr;
+        if (is32bit)
+        {
+            /*
+            * Target surface is 32bit with source RGBA/ABGR ordering
+            */
+            rz_dst =
+                SDL_CreateRGBSurface(SDL_SWSURFACE,
+                dstwidth, dstheight + GUARD_ROWS, 32,
+                rz_src->format->Rmask, rz_src->format->Gmask,
+                rz_src->format->Bmask, rz_src->format->Amask);
+        }
+        else
+        {
+            /*
+            * Target surface is 8bit
+            */
+            rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE,
+                dstwidth, dstheight + GUARD_ROWS, 8, 0, 0, 0, 0);
+        }
+
+        /* Check target */
+        if (rz_dst == nullptr)
+            return nullptr;
+
+        /* Adjust for guard rows */
+        rz_dst->h = dstheight;
+
+        /*
+        * Lock source surface
+        */
+        if (SDL_MUSTLOCK(rz_src))
+        {
+            SDL_LockSurface(rz_src);
+        }
+
+        /*
+        * Check which kind of surface we have
+        */
+        if (is32bit)
+        {
+            /*
+            * Call the 32bit transformation routine to do the zooming
+            * (using alpha)
+            */
+            _zoomSurfaceRGBA(rz_src, rz_dst, flipx, flipy, smooth);
+
+        }
+        else
+        {
+            /*
+            * Copy palette and colorkey info
+            */
+            for (i = 0; i < rz_src->format->palette->ncolors; i++)
+            {
+                rz_dst->format->palette->colors[i] =
+                    rz_src->format->palette->colors[i];
+            }
+            rz_dst->format->palette->ncolors =
+                rz_src->format->palette->ncolors;
+
+            /*
+            * Call the 8bit transformation routine to do the zooming
+            */
+            _zoomSurfaceY(rz_src, rz_dst, flipx, flipy);
+        }
+
+        /*
+        * Unlock source surface
+        */
+        if (SDL_MUSTLOCK(rz_src))
+        {
+            SDL_UnlockSurface(rz_src);
+        }
+    }
+
+    /*
+    * Cleanup temp surface
+    */
+    if (src_converted)
+    {
+        SDL_FreeSurface(rz_src);
+    }
+
+    /*
+    * Return destination surface
+    */
+    return (rz_dst);
 }
 
 /*!
 \brief Calculates the size of the target surface for a zoomSurface() call.
 
-The minimum size of the target surface is 1. The input factors can be positive or negative.
+The minimum size of the target surface is 1. The input factors
+can be positive or negative.
 
 \param width The width of the source surface to zoom.
 \param height The height of the source surface to zoom.
 \param zoomx The horizontal zoom factor.
 \param zoomy The vertical zoom factor.
-\param dstwidth Pointer to an integer to store the calculated width of the zoomed target surface.
-\param dstheight Pointer to an integer to store the calculated height of the zoomed target surface.
+\param dstwidth Pointer to an integer to store the calculated
+width of the zoomed target surface.
+\param dstheight Pointer to an integer to store the calculated
+height of the zoomed target surface.
 */
-void zoomSurfaceSize(int width, int height, double zoomx, double zoomy, int *dstwidth, int *dstheight)
+void zoomSurfaceSize(int width, int height,
+                     double zoomx, double zoomy,
+                     int *dstwidth, int *dstheight)
 {
-	/*
-	* Make zoom factors positive 
-	*/
-	int flipx, flipy;
-	flipx = (zoomx<0.0);
-	if (flipx) zoomx = -zoomx;
-	flipy = (zoomy<0.0);
-	if (flipy) zoomy = -zoomy;
-
-	/*
-	* Sanity check zoom factors 
-	*/
-	if (zoomx < VALUE_LIMIT) {
-		zoomx = VALUE_LIMIT;
-	}
-	if (zoomy < VALUE_LIMIT) {
-		zoomy = VALUE_LIMIT;
-	}
-
-	/*
-	* Calculate target size 
-	*/
-	*dstwidth = static_cast<int>(floor((static_cast<double>(width) * zoomx) + 0.5));
-	*dstheight = static_cast<int>(floor((static_cast<double>(height) * zoomy) + 0.5));
-	if (*dstwidth < 1) {
-		*dstwidth = 1;
-	}
-	if (*dstheight < 1) {
-		*dstheight = 1;
-	}
+    /*
+    * Make zoom factors positive
+    */
+    int flipx, flipy;
+    flipx = (zoomx<0.0);
+    if (flipx) zoomx = -zoomx;
+    flipy = (zoomy<0.0);
+    if (flipy) zoomy = -zoomy;
+
+    /*
+    * Sanity check zoom factors
+    */
+    if (zoomx < VALUE_LIMIT)
+    {
+        zoomx = VALUE_LIMIT;
+    }
+    if (zoomy < VALUE_LIMIT)
+    {
+        zoomy = VALUE_LIMIT;
+    }
+
+    /*
+    * Calculate target size
+    */
+    *dstwidth = static_cast<int>(floor((static_cast<double>(
+        width) * zoomx) + 0.5));
+    *dstheight = static_cast<int>(floor((static_cast<double>(
+        height) * zoomy) + 0.5));
+    if (*dstwidth < 1)
+    {
+        *dstwidth = 1;
+    }
+    if (*dstheight < 1)
+    {
+        *dstheight = 1;
+    }
 }
 
-/*! 
-\brief Zoom a surface by independent horizontal and vertical factors with optional smoothing.
+/*!
+\brief Zoom a surface by independent horizontal and vertical
+factors with optional smoothing.
 
 Zooms a 32bit or 8bit 'src' surface to newly created 'dst' surface.
 'zoomx' and 'zoomy' are scaling factors for width and height. If 'smooth' is on
@@ -1362,141 +1587,162 @@ If zoom factors are negative, the image is flipped on the axes.
 
 \return The new, zoomed surface.
 */
-SDL_Surface *zoomSurface(SDL_Surface * src, double zoomx, double zoomy, int smooth)
+SDL_Surface *zoomSurface(SDL_Surface *src,
+                         double zoomx,
+                         double zoomy,
+                         int smooth)
 {
-	SDL_Surface *rz_src;
-	SDL_Surface *rz_dst;
-	int dstwidth, dstheight;
-	int is32bit;
-	int i, src_converted;
-	int flipx, flipy;
-
-	/*
-	* Sanity check 
-	*/
-	if (src == nullptr)
-		return (nullptr);
-
-	/*
-	* Determine if source surface is 32bit or 8bit 
-	*/
-	is32bit = (src->format->BitsPerPixel == 32);
-	if ((is32bit) || (src->format->BitsPerPixel == 8)) {
-		/*
-		* Use source surface 'as is' 
-		*/
-		rz_src = src;
-		src_converted = 0;
-	} else {
-		/*
-		* New source surface is 32bit with a defined RGBA ordering 
-		*/
-		rz_src =
-			SDL_CreateRGBSurface(SDL_SWSURFACE, src->w, src->h, 32, 
+    SDL_Surface *rz_src;
+    SDL_Surface *rz_dst;
+    int dstwidth, dstheight;
+    int is32bit;
+    int i, src_converted;
+    int flipx, flipy;
+
+    /*
+    * Sanity check
+    */
+    if (src == nullptr)
+        return (nullptr);
+
+    /*
+    * Determine if source surface is 32bit or 8bit
+    */
+    is32bit = (src->format->BitsPerPixel == 32);
+    if ((is32bit) || (src->format->BitsPerPixel == 8))
+    {
+        /*
+        * Use source surface 'as is'
+        */
+        rz_src = src;
+        src_converted = 0;
+    }
+    else
+    {
+        /*
+        * New source surface is 32bit with a defined RGBA ordering
+        */
+        rz_src =
+            SDL_CreateRGBSurface(SDL_SWSURFACE, src->w, src->h, 32,
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
-			0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000
+            0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000
 #else
-			0xff000000,  0x00ff0000, 0x0000ff00, 0x000000ff
+            0xff000000,  0x00ff0000, 0x0000ff00, 0x000000ff
 #endif
-			);
-		if (rz_src == nullptr) {
-			return nullptr;
-		}
-		SDL_BlitSurface(src, nullptr, rz_src, nullptr);
-		src_converted = 1;
-		is32bit = 1;
-	}
-
-	flipx = (zoomx<0.0);
-	if (flipx) zoomx = -zoomx;
-	flipy = (zoomy<0.0);
-	if (flipy) zoomy = -zoomy;
-
-	/* Get size if target */
-	zoomSurfaceSize(rz_src->w, rz_src->h, zoomx, zoomy, &dstwidth, &dstheight);
-
-	/*
-	* Alloc space to completely contain the zoomed surface 
-	*/
-	rz_dst = nullptr;
-	if (is32bit) {
-		/*
-		* Target surface is 32bit with source RGBA/ABGR ordering 
-		*/
-		rz_dst =
-			SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight + GUARD_ROWS, 32,
-			rz_src->format->Rmask, rz_src->format->Gmask,
-			rz_src->format->Bmask, rz_src->format->Amask);
-	} else {
-		/*
-		* Target surface is 8bit 
-		*/
-		rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight + GUARD_ROWS, 8, 0, 0, 0, 0);
-	}
-
-	/* Check target */
-	if (rz_dst == nullptr) {
-		/*
-		* Cleanup temp surface 
-		*/
-		if (src_converted) {
-			SDL_FreeSurface(rz_src);
-		}		
-		return nullptr;
-	}
-
-	/* Adjust for guard rows */
-	rz_dst->h = dstheight;
-
-	/*
-	* Lock source surface 
-	*/
-	if (SDL_MUSTLOCK(rz_src)) {
-		SDL_LockSurface(rz_src);
-	}
-
-	/*
-	* Check which kind of surface we have 
-	*/
-	if (is32bit) {
-		/*
-		* Call the 32bit transformation routine to do the zooming (using alpha) 
-		*/
-		_zoomSurfaceRGBA(rz_src, rz_dst, flipx, flipy, smooth);
-	} else {
-		/*
-		* Copy palette and colorkey info 
-		*/
-		for (i = 0; i < rz_src->format->palette->ncolors; i++) {
-			rz_dst->format->palette->colors[i] = rz_src->format->palette->colors[i];
-		}
-		rz_dst->format->palette->ncolors = rz_src->format->palette->ncolors;
-		/*
-		* Call the 8bit transformation routine to do the zooming 
-		*/
-		_zoomSurfaceY(rz_src, rz_dst, flipx, flipy);
-	}
-	/*
-	* Unlock source surface 
-	*/
-	if (SDL_MUSTLOCK(rz_src)) {
-		SDL_UnlockSurface(rz_src);
-	}
-
-	/*
-	* Cleanup temp surface 
-	*/
-	if (src_converted) {
-		SDL_FreeSurface(rz_src);
-	}
-
-	/*
-	* Return destination surface 
-	*/
-	return (rz_dst);
+            );
+        if (rz_src == nullptr)
+        {
+            return nullptr;
+        }
+        SDL_BlitSurface(src, nullptr, rz_src, nullptr);
+        src_converted = 1;
+        is32bit = 1;
+    }
+
+    flipx = (zoomx<0.0);
+    if (flipx) zoomx = -zoomx;
+    flipy = (zoomy<0.0);
+    if (flipy) zoomy = -zoomy;
+
+    /* Get size if target */
+    zoomSurfaceSize(rz_src->w, rz_src->h, zoomx, zoomy, &dstwidth, &dstheight);
+
+    /*
+    * Alloc space to completely contain the zoomed surface
+    */
+    rz_dst = nullptr;
+    if (is32bit)
+    {
+        /*
+        * Target surface is 32bit with source RGBA/ABGR ordering
+        */
+        rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE,
+            dstwidth, dstheight + GUARD_ROWS, 32,
+            rz_src->format->Rmask, rz_src->format->Gmask,
+            rz_src->format->Bmask, rz_src->format->Amask);
+    }
+    else
+    {
+        /*
+        * Target surface is 8bit
+        */
+        rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE,
+            dstwidth, dstheight + GUARD_ROWS, 8, 0, 0, 0, 0);
+    }
+
+    /* Check target */
+    if (rz_dst == nullptr)
+    {
+        /*
+        * Cleanup temp surface
+        */
+        if (src_converted)
+        {
+            SDL_FreeSurface(rz_src);
+        }
+        return nullptr;
+    }
+
+    /* Adjust for guard rows */
+    rz_dst->h = dstheight;
+
+    /*
+    * Lock source surface
+    */
+    if (SDL_MUSTLOCK(rz_src))
+    {
+        SDL_LockSurface(rz_src);
+    }
+
+    /*
+    * Check which kind of surface we have
+    */
+    if (is32bit)
+    {
+        /*
+        * Call the 32bit transformation routine to do the zooming (using alpha)
+        */
+        _zoomSurfaceRGBA(rz_src, rz_dst, flipx, flipy, smooth);
+    }
+    else
+    {
+        /*
+        * Copy palette and colorkey info
+        */
+        for (i = 0; i < rz_src->format->palette->ncolors; i++)
+        {
+            rz_dst->format->palette->colors[i] =
+                rz_src->format->palette->colors[i];
+        }
+        rz_dst->format->palette->ncolors = rz_src->format->palette->ncolors;
+        /*
+        * Call the 8bit transformation routine to do the zooming
+        */
+        _zoomSurfaceY(rz_src, rz_dst, flipx, flipy);
+    }
+    /*
+    * Unlock source surface
+    */
+    if (SDL_MUSTLOCK(rz_src))
+    {
+        SDL_UnlockSurface(rz_src);
+    }
+
+    /*
+    * Cleanup temp surface
+    */
+    if (src_converted)
+    {
+        SDL_FreeSurface(rz_src);
+    }
+
+    /*
+    * Return destination surface
+    */
+    return (rz_dst);
 }
 
-/*! 
+/*!
 \brief Shrink a surface by an integer ratio using averaging.
 
 Shrinks a 32bit or 8bit 'src' surface to a newly created 'dst' surface.
@@ -1512,156 +1758,187 @@ The input surface is not modified. The output surface is newly allocated.
 
 \return The new, shrunken surface.
 */
-/*@nullptr@*/ 
-SDL_Surface *shrinkSurface(SDL_Surface *src, int factorx, int factory)
+/*@nullptr@*/
+SDL_Surface *shrinkSurface(SDL_Surface *src,
+                           int factorx,
+                           int factory)
 {
-	int result;
-	SDL_Surface *rz_src;
-	SDL_Surface *rz_dst = nullptr;
-	int dstwidth, dstheight;
-	int is32bit;
-	int i, src_converted = 0;
-	int haveError = 0;
-
-	/*
-	* Sanity check 
-	*/
-	if (src == nullptr) {
-		return (nullptr);
-	}
-
-	/*
-	* Determine if source surface is 32bit or 8bit 
-	*/
-	is32bit = (src->format->BitsPerPixel == 32);
-	if ((is32bit) || (src->format->BitsPerPixel == 8)) {
-		/*
-		* Use source surface 'as is' 
-		*/
-		rz_src = src;
-		src_converted = 0;
-	} else {
-		/*
-		* New source surface is 32bit with a defined RGBA ordering 
-		*/
-		rz_src = SDL_CreateRGBSurface(SDL_SWSURFACE, src->w, src->h, 32, 
+    int result;
+    SDL_Surface *rz_src;
+    SDL_Surface *rz_dst = nullptr;
+    int dstwidth, dstheight;
+    int is32bit;
+    int i, src_converted = 0;
+    int haveError = 0;
+
+    /*
+    * Sanity check
+    */
+    if (src == nullptr)
+    {
+        return (nullptr);
+    }
+
+    /*
+    * Determine if source surface is 32bit or 8bit
+    */
+    is32bit = (src->format->BitsPerPixel == 32);
+    if ((is32bit) || (src->format->BitsPerPixel == 8))
+    {
+        /*
+        * Use source surface 'as is'
+        */
+        rz_src = src;
+        src_converted = 0;
+    }
+    else
+    {
+        /*
+        * New source surface is 32bit with a defined RGBA ordering
+        */
+        rz_src = SDL_CreateRGBSurface(SDL_SWSURFACE, src->w, src->h, 32,
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
-			0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000
+            0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000
 #else
-			0xff000000,  0x00ff0000, 0x0000ff00, 0x000000ff
+            0xff000000,  0x00ff0000, 0x0000ff00, 0x000000ff
 #endif
-			);
-		if (rz_src==nullptr) {
-			haveError = 1;
-			goto exitShrinkSurface;
-		}
-
-		SDL_BlitSurface(src, nullptr, rz_src, nullptr);
-		src_converted = 1;
-		is32bit = 1;
-	}
-
-	/*
-	* Lock the surface 
-	*/
-	if (SDL_MUSTLOCK(rz_src)) {
-		if (SDL_LockSurface(rz_src) < 0) {
-			haveError = 1;
-			goto exitShrinkSurface;
-		}
-	}
-
-	/* Get size for target */
-	dstwidth=rz_src->w/factorx;
-	while (dstwidth*factorx>rz_src->w) { dstwidth--; }
-	dstheight=rz_src->h/factory;
-	while (dstheight*factory>rz_src->h) { dstheight--; }
-
-	/*
-	* Alloc space to completely contain the shrunken surface
-	* (with added guard rows)
-	*/
-	if (is32bit==1) {
-		/*
-		* Target surface is 32bit with source RGBA/ABGR ordering 
-		*/
-		rz_dst =
-			SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight + GUARD_ROWS, 32,
-			rz_src->format->Rmask, rz_src->format->Gmask,
-			rz_src->format->Bmask, rz_src->format->Amask);
-	} else {
-		/*
-		* Target surface is 8bit 
-		*/
-		rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight + GUARD_ROWS, 8, 0, 0, 0, 0);
-	}
-
-	/* Check target */
-	if (rz_dst == nullptr) {
-		haveError = 1;
-		goto exitShrinkSurface;
-	}
-
-	/* Adjust for guard rows */
-	rz_dst->h = dstheight;
-
-	/*
-	* Check which kind of surface we have 
-	*/
-	if (is32bit==1) {
-		/*
-		* Call the 32bit transformation routine to do the shrinking (using alpha) 
-		*/
-		result = _shrinkSurfaceRGBA(rz_src, rz_dst, factorx, factory);		
-		if ((result!=0) || (rz_dst==nullptr)) {
-			haveError = 1;
-			goto exitShrinkSurface;
-		}
-	} else {
-		/*
-		* Copy palette and colorkey info 
-		*/
-		for (i = 0; i < rz_src->format->palette->ncolors; i++) {
-			rz_dst->format->palette->colors[i] = rz_src->format->palette->colors[i];
-		}
-		rz_dst->format->palette->ncolors = rz_src->format->palette->ncolors;
-		/*
-		* Call the 8bit transformation routine to do the shrinking 
-		*/
-		result = _shrinkSurfaceY(rz_src, rz_dst, factorx, factory);
-		if (result!=0) {
-			haveError = 1;
-			goto exitShrinkSurface;
-		}
-	}
+            );
+        if (rz_src==nullptr)
+        {
+            haveError = 1;
+            goto exitShrinkSurface;
+        }
+
+        SDL_BlitSurface(src, nullptr, rz_src, nullptr);
+        src_converted = 1;
+        is32bit = 1;
+    }
+
+    /*
+    * Lock the surface
+    */
+    if (SDL_MUSTLOCK(rz_src))
+    {
+        if (SDL_LockSurface(rz_src) < 0)
+        {
+            haveError = 1;
+            goto exitShrinkSurface;
+        }
+    }
+
+    /* Get size for target */
+    dstwidth=rz_src->w/factorx;
+    while (dstwidth*factorx>rz_src->w)
+    {
+        dstwidth--;
+    }
+    dstheight=rz_src->h/factory;
+    while (dstheight*factory>rz_src->h)
+    {
+        dstheight--;
+    }
+
+    /*
+    * Alloc space to completely contain the shrunken surface
+    * (with added guard rows)
+    */
+    if (is32bit==1)
+    {
+        /*
+        * Target surface is 32bit with source RGBA/ABGR ordering
+        */
+        rz_dst = SDL_CreateRGBSurface(
+            SDL_SWSURFACE, dstwidth, dstheight + GUARD_ROWS, 32,
+            rz_src->format->Rmask, rz_src->format->Gmask,
+            rz_src->format->Bmask, rz_src->format->Amask);
+    }
+    else
+    {
+        /*
+        * Target surface is 8bit
+        */
+        rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE,
+            dstwidth, dstheight + GUARD_ROWS, 8, 0, 0, 0, 0);
+    }
+
+    /* Check target */
+    if (rz_dst == nullptr)
+    {
+        haveError = 1;
+        goto exitShrinkSurface;
+    }
+
+    /* Adjust for guard rows */
+    rz_dst->h = dstheight;
+
+    /*
+    * Check which kind of surface we have
+    */
+    if (is32bit==1)
+    {
+        /*
+        * Call the 32bit transformation routine to do the shrinking (using alpha)
+        */
+        result = _shrinkSurfaceRGBA(rz_src, rz_dst, factorx, factory);
+        if ((result!=0) || (rz_dst==nullptr))
+        {
+            haveError = 1;
+            goto exitShrinkSurface;
+        }
+    }
+    else
+    {
+        /*
+        * Copy palette and colorkey info
+        */
+        for (i = 0; i < rz_src->format->palette->ncolors; i++)
+        {
+            rz_dst->format->palette->colors[i] = rz_src->format->palette->colors[i];
+        }
+        rz_dst->format->palette->ncolors = rz_src->format->palette->ncolors;
+        /*
+        * Call the 8bit transformation routine to do the shrinking
+        */
+        result = _shrinkSurfaceY(rz_src, rz_dst, factorx, factory);
+        if (result!=0)
+        {
+            haveError = 1;
+            goto exitShrinkSurface;
+        }
+    }
 
 exitShrinkSurface:
-	if (rz_src!=nullptr) {
-		/*
-		* Unlock source surface 
-		*/
-		if (SDL_MUSTLOCK(rz_src)) {
-			SDL_UnlockSurface(rz_src);
-		}
-
-		/*
-		* Cleanup temp surface 
-		*/
-		if (src_converted==1) {
-			SDL_FreeSurface(rz_src);
-		}
-	}
-
-	/* Check error state; maybe need to cleanup destination */
-	if (haveError==1) {
-		if (rz_dst!=nullptr) {
-			SDL_FreeSurface(rz_dst);
-		}
-		rz_dst=nullptr;
-	} 
-
-	/*
-	* Return destination surface 
-	*/
-	return (rz_dst);
+    if (rz_src!=nullptr)
+    {
+        /*
+        * Unlock source surface
+        */
+        if (SDL_MUSTLOCK(rz_src))
+        {
+            SDL_UnlockSurface(rz_src);
+        }
+
+        /*
+        * Cleanup temp surface
+        */
+        if (src_converted==1)
+        {
+            SDL_FreeSurface(rz_src);
+        }
+    }
+
+    /* Check error state; maybe need to cleanup destination */
+    if (haveError==1)
+    {
+        if (rz_dst!=nullptr)
+        {
+            SDL_FreeSurface(rz_dst);
+        }
+        rz_dst=nullptr;
+    }
+
+    /*
+    * Return destination surface
+    */
+    return (rz_dst);
 }
diff --git a/src/sdl2gfx/SDL2_rotozoom.h b/src/sdl2gfx/SDL2_rotozoom.h
index 0ceb30db9..ffab24fbc 100644
--- a/src/sdl2gfx/SDL2_rotozoom.h
+++ b/src/sdl2gfx/SDL2_rotozoom.h
@@ -1,4 +1,4 @@
-/*  
+/*
 
 SDL2_rotozoom.c: rotozoomer, zoomer and shrinker for 32bit or 8bit surfaces
 
@@ -36,11 +36,12 @@ Changed for ManaPlus (C) 2013-2017  ManaPlus developers
 
 /* Set up for C function definitions, even when using C++ */
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
 #ifndef M_PI
-#define M_PI	3.1415926535897932384626433832795
+#define M_PI    3.1415926535897932384626433832795
 #endif
 
 #include "localconsts.h"
@@ -50,19 +51,19 @@ PRAGMA48(GCC diagnostic ignored "-Wshadow")
 #include <SDL.h>
 PRAGMA48(GCC diagnostic pop)
 
-	/* ---- Defines */
+    /* ---- Defines */
 
-	/*!
-	\brief Disable anti-aliasing (no smoothing).
-	*/
-#define SMOOTHING_OFF		0
+    /*!
+    \brief Disable anti-aliasing (no smoothing).
+    */
+#define SMOOTHING_OFF        0
 
-	/*!
-	\brief Enable anti-aliasing (smoothing).
-	*/
-#define SMOOTHING_ON		1
+    /*!
+    \brief Enable anti-aliasing (smoothing).
+    */
+#define SMOOTHING_ON        1
 
-	/* ---- Function Prototypes */
+    /* ---- Function Prototypes */
 
 #ifdef _MSC_VER
 #  if defined(DLL_EXPORT) && !defined(LIBSDL2_GFX_DLL_IMPORT)
@@ -77,54 +78,54 @@ PRAGMA48(GCC diagnostic pop)
 #  define SDL2_ROTOZOOM_SCOPE extern
 #endif
 
-	/* 
+    /*
 
-	Rotozoom functions
+    Rotozoom functions
 
-	*/
+    */
 
-	SDL2_ROTOZOOM_SCOPE SDL_Surface *rotozoomSurface(SDL_Surface * src, double angle, double zoom, int smooth);
+    SDL2_ROTOZOOM_SCOPE SDL_Surface *rotozoomSurface(SDL_Surface * src, double angle, double zoom, int smooth);
 
-	SDL2_ROTOZOOM_SCOPE SDL_Surface *rotozoomSurfaceXY
-		(SDL_Surface * src, double angle, double zoomx, double zoomy, int smooth);
+    SDL2_ROTOZOOM_SCOPE SDL_Surface *rotozoomSurfaceXY
+        (SDL_Surface * src, double angle, double zoomx, double zoomy, int smooth);
 
 
-	SDL2_ROTOZOOM_SCOPE void rotozoomSurfaceSize(int width, int height, double angle, double zoom, int *dstwidth,
-		int *dstheight);
+    SDL2_ROTOZOOM_SCOPE void rotozoomSurfaceSize(int width, int height, double angle, double zoom, int *dstwidth,
+        int *dstheight);
 
-	SDL2_ROTOZOOM_SCOPE void rotozoomSurfaceSizeXY
-		(int width, int height, double angle, double zoomx, double zoomy, 
-		int *dstwidth, int *dstheight);
+    SDL2_ROTOZOOM_SCOPE void rotozoomSurfaceSizeXY
+        (int width, int height, double angle, double zoomx, double zoomy,
+        int *dstwidth, int *dstheight);
 
-	/* 
+    /*
 
-	Zooming functions
+    Zooming functions
 
-	*/
+    */
 
-	SDL2_ROTOZOOM_SCOPE SDL_Surface *zoomSurface(SDL_Surface * src, double zoomx, double zoomy, int smooth);
+    SDL2_ROTOZOOM_SCOPE SDL_Surface *zoomSurface(SDL_Surface * src, double zoomx, double zoomy, int smooth);
 
-	SDL2_ROTOZOOM_SCOPE void zoomSurfaceSize(int width, int height, double zoomx, double zoomy, int *dstwidth, int *dstheight);
+    SDL2_ROTOZOOM_SCOPE void zoomSurfaceSize(int width, int height, double zoomx, double zoomy, int *dstwidth, int *dstheight);
 
-	/* 
+    /*
 
-	Shrinking functions
+    Shrinking functions
 
-	*/     
+    */
 
-	SDL2_ROTOZOOM_SCOPE SDL_Surface *shrinkSurface(SDL_Surface * src, int factorx, int factory);
+    SDL2_ROTOZOOM_SCOPE SDL_Surface *shrinkSurface(SDL_Surface * src, int factorx, int factory);
 
-	/* 
+    /*
 
-	Specialized rotation functions
+    Specialized rotation functions
 
-	*/
+    */
 
-	SDL2_ROTOZOOM_SCOPE SDL_Surface* rotateSurface90Degrees(SDL_Surface* src, int numClockwiseTurns);
+    SDL2_ROTOZOOM_SCOPE SDL_Surface* rotateSurface90Degrees(SDL_Surface* src, int numClockwiseTurns);
 
-	/* Ends C function definitions when using C++ */
+    /* Ends C function definitions when using C++ */
 #ifdef __cplusplus
 }
 #endif
 
-#endif				/* _SDL2_rotozoom_h */
+#endif                /* _SDL2_rotozoom_h */