toolkit/SDL_rotozoom.c

/*

SDL_rotozoom.c - rotozoomer, zoomer and shrinker for 32bit or 8bit surfaces

LGPL (c) A. Schiffler

*/

#include <global.h>

/* ---- Internally used structures */

typedef struct tColorRGBA {
    Uint8 r;
    Uint8 g;
    Uint8 b;
    Uint8 a;
} tColorRGBA;

typedef struct tColorY {
    Uint8 y;
} tColorY;

#define GUARD_ROWS (2)

#define VALUE_LIMIT 0.001

Uint32 _colorkey(SDL_Surface *src)
{
    Uint32 key = 0;
#if (SDL_MINOR_VERSION == 3)
    SDL_GetColorKey(src, &key);
#else
    if (src)
    {
        key = src->format->colorkey;
    }
#endif
    return key;
}


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 = (tColorRGBA *) src->pixels;

    dp = (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 = (tColorRGBA *)((Uint8*)sp + (src->pitch - 4*factorx)); /* next y */
            }
            /* src dy loop */

            /* next box-x */
            sp = (tColorRGBA *)((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 = (tColorRGBA *)((Uint8*)osp + src->pitch*factory);

        /*
        * Advance destination pointers
        */
        dp = (tColorRGBA *) ((Uint8 *) dp + dgap);
    }
    /* dst y loop */

    return (0);
}

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 = (Uint8 *) src->pixels;

    dp = (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 = (Uint8 *)((Uint8*)sp + (src->pitch - factorx));
            }
            /* end src dy loop */

            /* next box-x */
            sp = (Uint8 *)((Uint8*)oosp + factorx);

            /* Store result in destination */
            *dp = a/n_average;

            /*
            * Advance destination pointer
            */
            dp++;
        }
        /* end dst x loop */

        /* next box-y */
        sp = (Uint8 *)((Uint8*)osp + src->pitch*factory);

        /*
        * Advance destination pointers
        */
        dp = (Uint8 *)((Uint8 *)dp + dgap);
    }
    /* end dst y loop */

    return (0);
}

int _zoomSurfaceRGBA(SDL_Surface * src, SDL_Surface * dst, int flipx, int flipy, int smooth)
{
    int x, y, sx, sy, *sax, *say, *csax, *csay, csx, csy, ex, ey, t1, t2, sstep, lx, ly;
    tColorRGBA *c00, *c01, *c10, *c11, *cswap;
    tColorRGBA *sp, *csp, *dp;
    int dgap;

    /*
    * Variable setup
    */
    if (smooth) {
        /*
        * For interpolation: assume source dimension is one pixel
        * smaller to avoid overflow on right and bottom edge.
        */
        sx = (int) (65536.0 * (float) (src->w - 1) / (float) dst->w);
        sy = (int) (65536.0 * (float) (src->h - 1) / (float) dst->h);
    } else {
        sx = (int) (65536.0 * (float) src->w / (float) dst->w);
        sy = (int) (65536.0 * (float) src->h / (float) dst->h);
    }

    /*
    * Allocate memory for row increments
    */
    if ((sax = (int *) malloc((dst->w + 1) * sizeof(Uint32))) == NULL) {
        return (-1);
    }
    if ((say = (int *) malloc((dst->h + 1) * sizeof(Uint32))) == NULL) {
        free(sax);
        return (-1);
    }

    /*
    * Precalculate row increments
    */
    sp = csp = (tColorRGBA *) src->pixels;
    dp = (tColorRGBA *) dst->pixels;

    if (flipx) csp += (src->w-1);
    if (flipy) csp += ((src->pitch/4)*(src->h-1));

    csx = 0;
    csax = sax;
    for (x = 0; x <= dst->w; x++) {
        *csax = csx;
        csax++;
        csx &= 0xffff;
        csx += sx;
    }
    csy = 0;
    csay = say;
    for (y = 0; y <= dst->h; y++) {
        *csay = csy;
        csay++;
        csy &= 0xffff;
        csy += sy;
    }

    dgap = dst->pitch - dst->w * 4;

    /*
    * Switch between interpolating and non-interpolating code
    */
    if (smooth) {

        /*
        * Interpolating Zoom
        */

        /*
        * Scan destination
        */
        csay = say;
        ly = 0;
        for (y = 0; y < dst->h; y++) {
            /*
            * Setup color source pointers
            */
            c00 = csp;
            c01 = csp;
            c01++;
            c10 = csp;
            c10 += src->pitch/4;
            c11 = c10;
            c11++;
            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;
            }

            csax = sax;
            lx = 0;
            for (x = 0; x < dst->w; x++) {
                /*
                * Draw and interpolate colors
                */
                ex = (*csax & 0xffff);
                ey = (*csay & 0xffff);
                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 pointers
                */
                csax++;
                if (*csax > 0)
                {
                    sstep = (*csax >> 16);
                    lx += sstep;
                    if (flipx) sstep = -sstep;
                    if (lx <= src->w)
                    {
                        c00 += sstep;
                        c01 += sstep;
                        c10 += sstep;
                        c11 += sstep;
                    }
                }

                /*
                * Advance destination pointer
                */
                dp++;
            }

            /*
            * Advance source pointer
            */
            csay++;
            if (*csay > 0)
            {
                sstep = (*csay >> 16);
                ly += sstep;
                if (flipy) sstep = -sstep;
                if (ly < src->h)
                {
                    csp += (sstep * (src->pitch/4));
                }
            }

            /*
            * Advance destination pointers
            */
            dp = (tColorRGBA *) ((Uint8 *) dp + dgap);
        }
    } else {

        /*
        * Non-Interpolating Zoom
        */
        csay = say;
        for (y = 0; y < dst->h; y++) {
            sp = csp;
            csax = sax;
            for (x = 0; x < dst->w; x++) {
                /*
                * Draw
                */
                *dp = *sp;
                /*
                * Advance source pointers
                */
                csax++;
                if (*csax > 0)
                {
                    sstep = (*csax >> 16);
                    if (flipx) sstep = -sstep;
                    sp += sstep;
                }
                /*
                * Advance destination pointer
                */
                dp++;
            }
            /*
            * Advance source pointer
            */
            csay++;
            if (*csay > 0)
            {
                sstep = (*csay >> 16) * (src->pitch/4);
                if (flipy) sstep = -sstep;
                csp += sstep;
            }

            /*
            * Advance destination pointers
            */
            dp = (tColorRGBA *) ((Uint8 *) dp + dgap);
        }
    }

    /*
    * Remove temp arrays
    */
    free(sax);
    free(say);

    return (0);
}

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 = (Uint32 *) malloc((dst->w + 1) * sizeof(Uint32))) == NULL) {
        return (-1);
    }
    if ((say = (Uint32 *) malloc((dst->h + 1) * sizeof(Uint32))) == NULL) {
        free(sax);
        return (-1);
    }

    /*
    * Pointer setup
    */
    sp = csp = (Uint8 *) src->pixels;
    dp = (Uint8 *) dst->pixels;
    dgap = dst->pitch - dst->w;

    if (flipx) csp += (src->w-1);
    if (flipy) csp  = ( (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++;
    }
    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++;
    }

    /*
    * 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) * (flipx ? -1 : 1);
            csax++;
            /*
            * Advance destination pointer
            */
            dp++;
        }
        /*
        * Advance source pointer (for row)
        */
        csp += ((*csay) * src->pitch) * (flipy ? -1 : 1);
        csay++;

        /*
        * Advance destination pointers
        */
        dp += dgap;
    }

    /*
    * Remove temp arrays
    */
    free(sax);
    free(say);

    return (0);
}

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 = (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 = (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 = (tColorRGBA *) ((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 = (short) (sdx >> 16);
                dy = (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 = (tColorRGBA *) ((Uint8 *) src->pixels + src->pitch * dy);
                    sp += dx;
                    *pc = *sp;
                }
                sdx += icos;
                sdy += isin;
                pc++;
            }
            pc = (tColorRGBA *) ((Uint8 *) pc + gap);
        }
    }
}

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 = (tColorY*) dst->pixels;
    gap = dst->pitch - dst->w;
    /*
    * Clear surface to colorkey
    */
    memset(pc, (unsigned char) (_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 = (short) (sdx >> 16);
            dy = (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 = (tColorY *) (src->pixels);
                sp += (src->pitch * dy + dx);
                *pc = *sp;
            }
            sdx += icos;
            sdy += isin;
            pc++;
        }
        pc += gap;
    }
}

SDL_Surface* rotateSurface90Degrees(SDL_Surface* src, int numClockwiseTurns)
{
    int row, col, newWidth, newHeight;
    int bpp, src_ipr, dst_ipr;
    SDL_Surface* dst;
    Uint32* srcBuf;
    Uint32* dstBuf;

    /* Has to be a valid surface pointer and only 32-bit surfaces (for now) */
    if (!src || src->format->BitsPerPixel != 32) { return NULL; }

    /* normalize numClockwiseTurns */
    while(numClockwiseTurns < 0) { numClockwiseTurns += 4; }
    numClockwiseTurns = (numClockwiseTurns % 4);

    /* if it's even, our new width will be the same as the source surface */
    newWidth = (numClockwiseTurns % 2) ? (src->h) : (src->w);
    newHeight = (numClockwiseTurns % 2) ? (src->w) : (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) {
        return NULL;
    }

    if (SDL_MUSTLOCK(dst)) {
        SDL_LockSurface(dst);
    }
    if (SDL_MUSTLOCK(dst)) {
        SDL_LockSurface(dst);
    }

    /* Calculate int-per-row */
    bpp = src->format->BitsPerPixel / 8;
    src_ipr = src->pitch / bpp;
    dst_ipr = dst->pitch / bpp;

    switch(numClockwiseTurns) {
        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 = (Uint32*)(src->pixels);
                    dstBuf = (Uint32*)(dst->pixels);
                    for (row = 0; row < src->h; row++) {
                        memcpy(dstBuf, srcBuf, dst->w * bpp);
                        srcBuf += src_ipr;
                        dstBuf += dst_ipr;
                    } /* end for(col) */
                } /* end for(row) */
            }
            break;

            /* rotate clockwise */
        case 1: /* rotated 90 degrees clockwise */
         {
             for (row = 0; row < src->h; ++row) {
                 srcBuf = (Uint32*)(src->pixels) + (row * src_ipr);
                 dstBuf = (Uint32*)(dst->pixels) + (dst->w - row - 1);
                 for (col = 0; col < src->w; ++col) {
                     *dstBuf = *srcBuf;
                     ++srcBuf;
                     dstBuf += dst_ipr;
                 }
                 /* end for(col) */
             }
             /* end for(row) */
         }
         break;

        case 2: /* rotated 180 degrees clockwise */
         {
             for (row = 0; row < src->h; ++row) {
                 srcBuf = (Uint32*)(src->pixels) + (row * src_ipr);
                 dstBuf = (Uint32*)(dst->pixels) + ((dst->h - row - 1) * dst_ipr) + (dst->w - 1);
                 for (col = 0; col < src->w; ++col) {
                     *dstBuf = *srcBuf;
                     ++srcBuf;
                     --dstBuf;
                 }
             }
         }
         break;

        case 3:
         {
             for (row = 0; row < src->h; ++row) {
                 srcBuf = (Uint32*)(src->pixels) + (row * src_ipr);
                 dstBuf = (Uint32*)(dst->pixels) + row + ((dst->h - 1) * dst_ipr);
                 for (col = 0; col < src->w; ++col) {
                     *dstBuf = *srcBuf;
                     ++srcBuf;
                     dstBuf -= dst_ipr;
                 }
             }
         }
         break;
    }
    /* end switch */

    if (SDL_MUSTLOCK(src)) {
        SDL_UnlockSurface(src);
    }
    if (SDL_MUSTLOCK(dst)) {
        SDL_UnlockSurface(dst);
    }

    return dst;
}


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;
    double dstwidthhalf, dstheighthalf;

    (void) zoomy;

    /*
    * 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 *= zoomx;
    x = width / 2;
    y = height / 2;
    cx = *canglezoom * x;
    cy = *canglezoom * y;
    sx = *sanglezoom * x;
    sy = *sanglezoom * y;

    dstwidthhalf = MAX(ceil(MAX(MAX(MAX(fabs(cx + sy), fabs(cx - sy)), fabs(-cx + sy)), fabs(-cx - sy))), 1);
    dstheighthalf = MAX(ceil(MAX(MAX(MAX(fabs(sx + cy), fabs(sx - cy)), fabs(-sx + cy)), fabs(-sx - cy))), 1);
    *dstwidth = (int) (dstwidthhalf * 2.0);
    *dstheight = (int) (dstheighthalf * 2.0);
}

void rotozoomSurfaceSizeXY(int width, int height, double angle, double zoomx, double zoomy, int *dstwidth, int *dstheight)
{
    double dummy_sanglezoom, dummy_canglezoom;

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

void rotozoomSurfaceSize(int width, int height, double angle, double zoom, int *dstwidth, int *dstheight)
{
    double dummy_sanglezoom, dummy_canglezoom;

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

SDL_Surface *rotozoomSurface(SDL_Surface * src, double angle, double zoom, int smooth)
{
    return rotozoomSurfaceXY(src, angle, zoom, zoom, 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;
    Uint8 r,g,b;
    Uint32 colorkey = 0;
    int colorKeyAvailable = 0;

    /*
    * Sanity check
    */
    if (src == NULL)
        return (NULL);

    if (src->flags & SDL_SRCCOLORKEY)
    {
        colorkey = _colorkey(src);
        SDL_GetRGB(colorkey, src->format, &r, &g, &b);
        colorKeyAvailable = 1;
    }
    /*
    * 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(colorKeyAvailable)
            SDL_SetColorKey(src, 0, 0);

        SDL_BlitSurface(src, NULL, rz_src, NULL);

        if(colorKeyAvailable)
            SDL_SetColorKey(src, SDL_SRCCOLORKEY, colorkey);
        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 = NULL;
        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 == NULL)
            return NULL;

        /* Adjust for guard rows */
        rz_dst->h = dstheight;

        if (colorKeyAvailable == 1){
            colorkey = SDL_MapRGB(rz_dst->format, r, g, b);

            SDL_FillRect(rz_dst, NULL, colorkey );
        }

        /*
        * 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,
                (int) (sanglezoominv), (int) (canglezoominv),
                flipx, flipy,
                smooth);
            /*
            * Turn on source-alpha support
            */
            SDL_SetAlpha(rz_dst, SDL_SRCALPHA, 255);
            SDL_SetColorKey(rz_dst, SDL_SRCCOLORKEY | SDL_RLEACCEL, _colorkey(rz_src));
        } 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,
                (int) (sanglezoominv), (int) (canglezoominv),
                flipx, flipy);
            SDL_SetColorKey(rz_dst, SDL_SRCCOLORKEY | SDL_RLEACCEL, _colorkey(rz_src));
        }
        /*
        * 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 = NULL;
        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 == NULL)
            return NULL;

        /* Adjust for guard rows */
        rz_dst->h = dstheight;

        if (colorKeyAvailable == 1){
            colorkey = SDL_MapRGB(rz_dst->format, r, g, b);

            SDL_FillRect(rz_dst, NULL, colorkey );
        }

        /*
        * 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);

            /*
            * Turn on source-alpha support
            */
            SDL_SetAlpha(rz_dst, SDL_SRCALPHA, 255);
            SDL_SetColorKey(rz_dst, SDL_SRCCOLORKEY | SDL_RLEACCEL, _colorkey(rz_src));
        } 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);
            SDL_SetColorKey(rz_dst, SDL_SRCCOLORKEY | SDL_RLEACCEL, _colorkey(rz_src));
        }

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

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 = (int) ((double) width * zoomx);
    *dstheight = (int) ((double) height * zoomy);
    if (*dstwidth < 1) {
        *dstwidth = 1;
    }
    if (*dstheight < 1) {
        *dstheight = 1;
    }
}

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 == NULL)
        return (NULL);

    /*
    * 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, NULL, rz_src, NULL);
        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 = NULL;
    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 == NULL)
        return NULL;

    /* 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);
        /*
        * Turn on source-alpha support
        */
        SDL_SetAlpha(rz_dst, SDL_SRCALPHA, 255);
    } 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);
        SDL_SetColorKey(rz_dst, SDL_SRCCOLORKEY | SDL_RLEACCEL, _colorkey(rz_src));
    }
    /*
    * 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_Surface *shrinkSurface(SDL_Surface *src, int factorx, int factory)
{
    SDL_Surface *rz_src;
    SDL_Surface *rz_dst;
    int dstwidth, dstheight;
    int is32bit;
    int i, src_converted;

    /*
    * Sanity check
    */
    if (src == NULL)
        return (NULL);

    /*
    * 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, NULL, rz_src, NULL);
        src_converted = 1;
        is32bit = 1;
    }

    /* 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)
    */
    rz_dst = NULL;
    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 == NULL)
        return NULL;

    /* 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 shrinking (using alpha)
        */
        _shrinkSurfaceRGBA(rz_src, rz_dst, factorx, factory);
        /*
        * Turn on source-alpha support
        */
        SDL_SetAlpha(rz_dst, SDL_SRCALPHA, 255);
    } 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
        */
        _shrinkSurfaceY(rz_src, rz_dst, factorx, factory);
        SDL_SetColorKey(rz_dst, SDL_SRCCOLORKEY | SDL_RLEACCEL, _colorkey(rz_src));
    }

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