SDL2_rotozoom.cpp File Reference

(986a3bf)

#include <stdlib.h>
#include <string.h>
#include "sdl2gfx/SDL2_rotozoom.h"
#include "debug.h"

Go to the source code of this file.

Data Structures
struct	tColorRGBA
	A 32 bit RGBA pixel. More...
struct	tColorY
	A 8bit Y/palette pixel. More...

Macros
#define	MAX(a, b)   (((a) > (b)) ? (a) : (b))
	Returns maximum of two numbers a and b. More...
#define	GUARD_ROWS   (2)
	Number of guard rows added to destination surfaces. More...
#define	VALUE_LIMIT   0.001
	Lower limit of absolute zoom factor or rotation degrees. More...

Typedefs
typedef struct tColorRGBA	tColorRGBA
	A 32 bit RGBA pixel. More...
typedef struct tColorY	tColorY
	A 8bit Y/palette pixel. More...

Functions
static Uint32	_colorkey (SDL_Surface *src)
	Returns colorkey info for a surface. More...
static int	_shrinkSurfaceRGBA (SDL_Surface *src, SDL_Surface *dst, int factorx, int factory)
	Internal 32 bit integer-factor averaging Shrinker. More...
static int	_shrinkSurfaceY (SDL_Surface *src, SDL_Surface *dst, int factorx, int factory)
	Internal 8 bit integer-factor averaging shrinker. More...
static int	_zoomSurfaceRGBA (SDL_Surface *src, SDL_Surface *dst, int flipx, int flipy, int smooth)
	Internal 32 bit Zoomer with optional anti-aliasing by bilinear interpolation. More...
static int	_zoomSurfaceY (SDL_Surface *src, SDL_Surface *dst, int flipx, int flipy)
	Internal 8 bit Zoomer without smoothing. More...
static void	_transformSurfaceRGBA (SDL_Surface *src, SDL_Surface *dst, int cx, int cy, int isin, int icos, int flipx, int flipy, int smooth)
	Internal 32 bit rotozoomer with optional anti-aliasing. More...
static void	transformSurfaceY (SDL_Surface *src, SDL_Surface *dst, int cx, int cy, int isin, int icos, int flipx, int flipy)
	Rotates and zooms 8 bit palette/Y 'src' surface to 'dst' surface without smoothing. More...
SDL_Surface *	rotateSurface90Degrees (SDL_Surface *src, int numClockwiseTurns)
	Rotates a 8/16/24/32 bit surface in increments of 90 degrees. More...
static void	_rotozoomSurfaceSizeTrig (int width, int height, double angle, double zoomx, double zoomy, int *dstwidth, int *dstheight, double *canglezoom, double *sanglezoom)
	Internal target surface sizing function for rotozooms with trig result return. More...
void	rotozoomSurfaceSizeXY (int width, int height, double angle, double zoomx, double zoomy, int *dstwidth, int *dstheight)
	Returns the size of the resulting target surface for a rotozoomSurfaceXY() call. More...
void	rotozoomSurfaceSize (int width, int height, double angle, double zoom, int *dstwidth, int *dstheight)
	Returns the size of the resulting target surface for a rotozoomSurface() call. More...
SDL_Surface *	rotozoomSurface (SDL_Surface *src, double angle, double zoom, int smooth)
	Rotates and zooms a surface and optional anti-aliasing. More...
SDL_Surface *	rotozoomSurfaceXY (SDL_Surface *src, double angle, double zoomx, double zoomy, int smooth)
	Rotates and zooms a surface with different horizontal and vertival scaling factors and optional anti-aliasing. More...
void	zoomSurfaceSize (int width, int height, double zoomx, double zoomy, int *dstwidth, int *dstheight)
	Calculates the size of the target surface for a zoomSurface() call. More...
SDL_Surface *	zoomSurface (SDL_Surface *src, double zoomx, double zoomy, int smooth)
	Zoom a surface by independent horizontal and vertical factors with optional smoothing. More...
SDL_Surface *	shrinkSurface (SDL_Surface *src, int factorx, int factory)
	Shrink a surface by an integer ratio using averaging. More...

Macro Definition Documentation

GUARD_ROWS

#define GUARD_ROWS   (2)

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 just the right src image dimensions and scale/rotation and can lead to a situation where the program can segfault.

Definition at line 79 of file SDL2_rotozoom.cpp.

MAX

#define MAX	(		a,
			b
	)		(((a) > (b)) ? (a) : (b))

Returns maximum of two numbers a and b.

Definition at line 67 of file SDL2_rotozoom.cpp.

VALUE_LIMIT

#define VALUE_LIMIT   0.001

Lower limit of absolute zoom factor or rotation degrees.

Definition at line 84 of file SDL2_rotozoom.cpp.

Typedef Documentation

tColorRGBA

typedef struct tColorRGBA tColorRGBA

A 32 bit RGBA pixel.

tColorY

typedef struct tColorY tColorY

A 8bit Y/palette pixel.

Function Documentation

_colorkey()

static Uint32 _colorkey ( SDL_Surface *  src )

static

Returns colorkey info for a surface.

Definition at line 89 of file SDL2_rotozoom.cpp.

{
    Uint32 key = 0;
    SDL_GetColorKey(src, &key);
    return key;
}

Referenced by transformSurfaceY().

_rotozoomSurfaceSizeTrig()

static void _rotozoomSurfaceSizeTrig ( int  width, int  height, double  angle, double  zoomx, double  zoomy, int *  dstwidth, int *  dstheight, double *  canglezoom, double *  sanglezoom  )

static

Internal target surface sizing function for rotozooms with trig result return.

Parameters

width	The source surface width.
height	The source surface height.
angle	The angle to rotate in degrees.
zoomx	The horizontal scaling factor.
zoomy	The vertical scaling factor.
dstwidth	The calculated width of the destination surface.
dstheight	The calculated height of the destination surface.
canglezoom	The sine of the angle adjusted by the zoom factor.
sanglezoom	The cosine of the angle adjusted by the zoom factor.

Definition at line 1099 of file SDL2_rotozoom.cpp.

{
    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;
}

References MAX, x, and y.

Referenced by rotozoomSurfaceSize(), rotozoomSurfaceSizeXY(), and rotozoomSurfaceXY().

_shrinkSurfaceRGBA()

static int _shrinkSurfaceRGBA ( SDL_Surface *  src, SDL_Surface *  dst, int  factorx, int  factory  )

static

Internal 32 bit integer-factor averaging Shrinker.

Shrinks 32 bit RGBA/ABGR 'src' surface to 'dst' surface. Averages color and alpha values values of src pixels to calculate dst pixels. Assumes src and dst surfaces are of 32 bit depth. Assumes dst surface was allocated with the correct dimensions.

Parameters

src	The surface to shrink (input).
dst	The shrunken surface (output).
factorx	The horizontal shrinking ratio.
factory	The vertical shrinking ratio.

Returns

0 for success or -1 for error.

Definition at line 112 of file SDL2_rotozoom.cpp.

{
    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);
}

References tColorRGBA::a, tColorRGBA::b, tColorRGBA::g, tColorRGBA::r, x, and y.

Referenced by shrinkSurface().

_shrinkSurfaceY()

static int _shrinkSurfaceY ( SDL_Surface *  src, SDL_Surface *  dst, int  factorx, int  factory  )

static

Internal 8 bit integer-factor averaging shrinker.

Shrinks 8bit Y 'src' surface to 'dst' surface. Averages color (brightness) values values of src pixels to calculate dst pixels. Assumes src and dst surfaces are of 8 bit depth. Assumes dst surface was allocated with the correct dimensions.

Parameters

src	The surface to shrink (input).
dst	The shrunken surface (output).
factorx	The horizontal shrinking ratio.
factory	The vertical shrinking ratio.

Returns

0 for success or -1 for error.

Definition at line 210 of file SDL2_rotozoom.cpp.

{
    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);
}

References x, and y.

Referenced by shrinkSurface().

_transformSurfaceRGBA()

static void _transformSurfaceRGBA ( SDL_Surface *  src, SDL_Surface *  dst, int  cx, int  cy, int  isin, int  icos, int  flipx, int  flipy, int  smooth  )

static

Internal 32 bit rotozoomer with optional anti-aliasing.

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. Assumes dst surface was allocated with the correct dimensions.

Parameters

src	Source surface.
dst	Destination surface.
cx	Horizontal center coordinate.
cy	Vertical center coordinate.
isin	Integer version of sine of angle.
icos	Integer version of cosine of angle.
flipx	Flag indicating horizontal mirroring should be applied.
flipy	Flag indicating vertical mirroring should be applied.
smooth	Flag indicating anti-aliasing should be used.

Definition at line 706 of file SDL2_rotozoom.cpp.

{
    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);
        }
    }
}

References tColorRGBA::a, tColorRGBA::b, tColorRGBA::g, tColorRGBA::r, x, and y.

Referenced by rotozoomSurfaceXY().

_zoomSurfaceRGBA()

static int _zoomSurfaceRGBA ( SDL_Surface *  src, SDL_Surface *  dst, int  flipx, int  flipy, int  smooth  )

static

Internal 32 bit Zoomer with optional anti-aliasing by bilinear interpolation.

Zooms 32 bit RGBA/ABGR 'src' surface to 'dst' surface. Assumes src and dst surfaces are of 32 bit depth. Assumes dst surface was allocated with the correct dimensions.

Parameters

src	The surface to zoom (input).
dst	The zoomed surface (output).
flipx	Flag indicating if the image should be horizontally flipped.
flipy	Flag indicating if the image should be vertically flipped.
smooth	Antialiasing flag; set to SMOOTHING_ON to enable.

Returns

0 for success or -1 for error.

Definition at line 300 of file SDL2_rotozoom.cpp.

{
    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);
}

References tColorRGBA::a, tColorRGBA::b, tColorRGBA::g, tColorRGBA::r, x, and y.

Referenced by rotozoomSurfaceXY(), and zoomSurface().

_zoomSurfaceY()

static int _zoomSurfaceY ( SDL_Surface *  src, SDL_Surface *  dst, int  flipx, int  flipy  )

static

Internal 8 bit Zoomer without smoothing.

Zooms 8bit palette/Y 'src' surface to 'dst' surface. Assumes src and dst surfaces are of 8 bit depth. Assumes dst surface was allocated with the correct dimensions.

Parameters

src	The surface to zoom (input).
dst	The zoomed surface (output).
flipx	Flag indicating if the image should be horizontally flipped.
flipy	Flag indicating if the image should be vertically flipped.

Returns

0 for success or -1 for error.

Definition at line 574 of file SDL2_rotozoom.cpp.

{
    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);
}

References x, and y.

Referenced by rotozoomSurfaceXY(), and zoomSurface().

rotateSurface90Degrees()

SDL_Surface* rotateSurface90Degrees	(	SDL_Surface *	src,
		int	numClockwiseTurns
	)

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 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)

Parameters

src	Source surface to rotate.
numClockwiseTurns	Number of clockwise 90 degree turns to apply to the source.

Returns

The new, rotated surface; or nullptr for surfaces with incorrect input format.

< Surface is in video memory

< Use asynchronous blits if possible

< Surface is RLE encoded

< Surface is in video memory

< Use asynchronous blits if possible

< Surface is RLE encoded

< Surface is in video memory

< Use asynchronous blits if possible

< Surface is RLE encoded

< Surface is in video memory

< Use asynchronous blits if possible

< Surface is RLE encoded

Definition at line 914 of file SDL2_rotozoom.cpp.

{
    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;
}

rotozoomSurface()

SDL_Surface* rotozoomSurface	(	SDL_Surface *	src,
		double	angle,
		double	zoom,
		int	smooth
	)

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.

Parameters

src	The surface to rotozoom.
angle	The angle to rotate in degrees.
zoom	The scaling factor.
smooth	Antialiasing flag; set to SMOOTHING_ON to enable.

Returns

The new rotozoomed surface.

Definition at line 1204 of file SDL2_rotozoom.cpp.

{
    return rotozoomSurfaceXY(src, angle, zoom, zoom, smooth);
}

References rotozoomSurfaceXY().

rotozoomSurfaceSize()

void rotozoomSurfaceSize	(	int	width,
		int	height,
		double	angle,
		double	zoom,
		int *	dstwidth,
		int *	dstheight
	)

Returns the size of the resulting target surface for a rotozoomSurface() call.

Parameters

width	The source surface width.
height	The source surface height.
angle	The angle to rotate in degrees.
zoom	The scaling factor.
dstwidth	The calculated width of the rotozoomed destination surface.
dstheight	The calculated height of the rotozoomed destination surface.

Definition at line 1175 of file SDL2_rotozoom.cpp.

{
    double dummy_sanglezoom, dummy_canglezoom;
 
    _rotozoomSurfaceSizeTrig(width, height, angle, zoom, zoom,
        dstwidth, dstheight, &dummy_sanglezoom, &dummy_canglezoom);
}

References _rotozoomSurfaceSizeTrig().

rotozoomSurfaceSizeXY()

void rotozoomSurfaceSizeXY	(	int	width,
		int	height,
		double	angle,
		double	zoomx,
		double	zoomy,
		int *	dstwidth,
		int *	dstheight
	)

Returns the size of the resulting target surface for a rotozoomSurfaceXY() call.

Parameters

width	The source surface width.
height	The source surface height.
angle	The angle to rotate in degrees.
zoomx	The horizontal scaling factor.
zoomy	The vertical scaling factor.
dstwidth	The calculated width of the rotozoomed destination surface.
dstheight	The calculated height of the rotozoomed destination surface.

Definition at line 1150 of file SDL2_rotozoom.cpp.

{
    double dummy_sanglezoom, dummy_canglezoom;
 
    _rotozoomSurfaceSizeTrig(width, height, angle, zoomx, zoomy,
        dstwidth, dstheight, &dummy_sanglezoom, &dummy_canglezoom);
}

References _rotozoomSurfaceSizeTrig().

rotozoomSurfaceXY()

SDL_Surface* rotozoomSurfaceXY	(	SDL_Surface *	src,
		double	angle,
		double	zoomx,
		double	zoomy,
		int	smooth
	)

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.

Parameters

src	The surface to rotozoom.
angle	The angle to rotate in degrees.
zoomx	The horizontal scaling factor.
zoomy	The vertical scaling factor.
smooth	Antialiasing flag; set to SMOOTHING_ON to enable.

Returns

The new rotozoomed surface.

< Surface is in system memory

< Surface is in system memory

< Surface is in system memory

< Surface is in video memory

< Use asynchronous blits if possible

< Surface is RLE encoded

< Surface is in video memory

< Use asynchronous blits if possible

< Surface is RLE encoded

< Surface is in system memory

< Surface is in system memory

< Surface is in video memory

< Use asynchronous blits if possible

< Surface is RLE encoded

< Surface is in video memory

< Use asynchronous blits if possible

< Surface is RLE encoded

Definition at line 1230 of file SDL2_rotozoom.cpp.

{
    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
#else
            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);
}

References _rotozoomSurfaceSizeTrig(), _transformSurfaceRGBA(), _zoomSurfaceRGBA(), _zoomSurfaceY(), GUARD_ROWS, transformSurfaceY(), VALUE_LIMIT, and zoomSurfaceSize().

Referenced by rotozoomSurface().

shrinkSurface()

SDL_Surface* shrinkSurface	(	SDL_Surface *	src,
		int	factorx,
		int	factory
	)

Shrink a surface by an integer ratio using averaging.

Shrinks a 32bit or 8bit 'src' surface to a newly created 'dst' surface. 'factorx' and 'factory' are the shrinking ratios (i.e. 2=1/2 the size, 3=1/3 the size, etc.) The destination surface is antialiased by averaging the source box RGBA or Y information. If the surface is not 8bit or 32bit RGBA/ABGR it will be converted into a 32bit RGBA format on the fly. The input surface is not modified. The output surface is newly allocated.

Parameters

src	The surface to shrink.
factorx	The horizontal shrinking ratio.
factory	The vertical shrinking ratio.

Returns

The new, shrunken surface.

< Surface is in system memory

< Surface is in video memory

< Use asynchronous blits if possible

< Surface is RLE encoded

< Surface is in system memory

< Surface is in system memory

< Surface is in video memory

< Use asynchronous blits if possible

< Surface is RLE encoded

Definition at line 1762 of file SDL2_rotozoom.cpp.

{
    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
#else
            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;
        }
    }
 
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);
}

References _shrinkSurfaceRGBA(), _shrinkSurfaceY(), and GUARD_ROWS.

transformSurfaceY()

static void transformSurfaceY ( SDL_Surface *  src, SDL_Surface *  dst, int  cx, int  cy, int  isin, int  icos, int  flipx, int  flipy  )

static

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 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.

Parameters

src	Source surface.
dst	Destination surface.
cx	Horizontal center coordinate.
cy	Vertical center coordinate.
isin	Integer version of sine of angle.
icos	Integer version of cosine of angle.
flipx	Flag indicating horizontal mirroring should be applied.
flipy	Flag indicating vertical mirroring should be applied.

Definition at line 847 of file SDL2_rotozoom.cpp.

{
    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;
    }
}

References _colorkey(), x, and y.

Referenced by rotozoomSurfaceXY().

zoomSurface()

SDL_Surface* zoomSurface	(	SDL_Surface *	src,
		double	zoomx,
		double	zoomy,
		int	smooth
	)

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 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. If zoom factors are negative, the image is flipped on the axes.

Parameters

src	The surface to zoom.
zoomx	The horizontal zoom factor.
zoomy	The vertical zoom factor.
smooth	Antialiasing flag; set to SMOOTHING_ON to enable.

Returns

The new, zoomed surface.

< Surface is in system memory

< Surface is in system memory

< Surface is in system memory

< Surface is in video memory

< Use asynchronous blits if possible

< Surface is RLE encoded

< Surface is in video memory

< Use asynchronous blits if possible

< Surface is RLE encoded

Definition at line 1590 of file SDL2_rotozoom.cpp.

{
    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
#else
            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);
}

References _zoomSurfaceRGBA(), _zoomSurfaceY(), GUARD_ROWS, and zoomSurfaceSize().

zoomSurfaceSize()

void zoomSurfaceSize	(	int	width,
		int	height,
		double	zoomx,
		double	zoomy,
		int *	dstwidth,
		int *	dstheight
	)

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.

Parameters

width	The width of the source surface to zoom.
height	The height of the source surface to zoom.
zoomx	The horizontal zoom factor.
zoomy	The vertical zoom factor.
dstwidth	Pointer to an integer to store the calculated width of the zoomed target surface.
dstheight	Pointer to an integer to store the calculated height of the zoomed target surface.

Definition at line 1531 of file SDL2_rotozoom.cpp.

{
    /*
    * 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;
    }
}

References VALUE_LIMIT.

Referenced by rotozoomSurfaceXY(), and zoomSurface().