SDL_rotozoom.c

   1 /*
   2
   3   SDL_rotozoom.c - rotozoomer for 32bit or 8bit surfaces
   4
   5   LGPL (c) A. Schiffler
   6
   7 */
   8
   9 #include <stdlib.h>
  10 #include <string.h>
  11
  12 #include "SDL_rotozoom.h"
  13
  14 #define MAX(a,b)    (((a) > (b)) ? (a) : (b))
  15
  16
  17 /*
  18
  19  32bit integer-factor averaging Shrinker
  20
  21  Shrinks 32bit RGBA/ABGR 'src' surface to 'dst' surface.
  22
  23 */
  24
  25 int shrinkSurfaceRGBA(SDL_Surface * src, SDL_Surface * dst, int factorx, int factory)
  26 {
  27     int x, y, dx, dy, sgap, dgap, ra, ga, ba, aa;
  28     int n_average;
  29     tColorRGBA *sp, *osp, *oosp;
  30     tColorRGBA *dp;
  31
  32     /*
  33      * Averaging integer shrink
  34      */
  35
  36     /* Precalculate division factor */
  37     n_average = factorx*factory;
  38
  39     /*
  40      * Scan destination
  41      */
  42     sp = (tColorRGBA *) src->pixels;
  43     sgap = src->pitch - src->w * 4;
  44
  45     dp = (tColorRGBA *) dst->pixels;
  46     dgap = dst->pitch - dst->w * 4;
  47
  48     for (y = 0; y < dst->h; y++) {
  49
  50       osp=sp;
  51       for (x = 0; x < dst->w; x++) {
  52
  53         /* Trace out source box and accumulate */
  54         oosp=sp;
  55         ra=ga=ba=aa=0;
  56         for (dy=0; dy < factory; dy++) {
  57          for (dx=0; dx < factorx; dx++) {
  58           ra += sp->r;
  59           ga += sp->g;
  60           ba += sp->b;
  61           aa += sp->a;
  62
  63           sp++;
  64          }
  65          sp = (tColorRGBA *)((Uint8*)sp + (src->pitch - 4*factorx));
  66         }
  67
  68
  69         sp = (tColorRGBA *)((Uint8*)oosp + 4*factorx);
  70
  71         /* Store result in destination */
  72         dp->r = ra/n_average;
  73         dp->g = ga/n_average;
  74         dp->b = ba/n_average;
  75         dp->a = aa/n_average;
  76
  77         /*
  78          * Advance destination pointer
  79          */
  80          dp++;
  81         }
  82
  83
  84         sp = (tColorRGBA *)((Uint8*)osp + src->pitch*factory);
  85
  86         /*
  87          * Advance destination pointers
  88          */
  89         dp = (tColorRGBA *) ((Uint8 *) dp + dgap);
  90       }
  91
  92     return (0);
  93 }
  94
  95 /*
  96
  97  8bit integer-factor averaging Shrinker
  98
  99  Shrinks 8bit Y 'src' surface to 'dst' surface.
 100
 101 */
 102
 103 int shrinkSurfaceY(SDL_Surface * src, SDL_Surface * dst, int factorx, int factory)
 104 {
 105     int x, y, dx, dy, sgap, dgap, a;
 106     int n_average;
 107     Uint8 *sp, *osp, *oosp;
 108     Uint8 *dp;
 109
 110     /*
 111      * Averaging integer shrink
 112      */
 113
 114     /* Precalculate division factor */
 115     n_average = factorx*factory;
 116
 117     /*
 118      * Scan destination
 119      */
 120     sp = (Uint8 *) src->pixels;
 121     sgap = src->pitch - src->w;
 122
 123     dp = (Uint8 *) dst->pixels;
 124     dgap = dst->pitch - dst->w;
 125
 126     for (y = 0; y < dst->h; y++) {
 127
 128       osp=sp;
 129       for (x = 0; x < dst->w; x++) {
 130
 131         /* Trace out source box and accumulate */
 132         oosp=sp;
 133         a=0;
 134         for (dy=0; dy < factory; dy++) {
 135          for (dx=0; dx < factorx; dx++) {
 136           a += (*sp);
 137           sp++;
 138          }
 139          sp = (Uint8 *)((Uint8*)sp + (src->pitch - factorx));
 140         }
 141
 142
 143         sp = (Uint8 *)((Uint8*)oosp + factorx);
 144
 145         /* Store result in destination */
 146         *dp = a/n_average;
 147
 148         /*
 149          * Advance destination pointer
 150          */
 151          dp++;
 152         }
 153
 154
 155         sp = (Uint8 *)((Uint8*)osp + src->pitch*factory);
 156
 157         /*
 158          * Advance destination pointers
 159          */
 160         dp = (Uint8 *)((Uint8 *)dp + dgap);
 161       }
 162
 163     return (0);
 164 }
 165
 166 /*
 167
 168  32bit Zoomer with optional anti-aliasing by bilinear interpolation.
 169
 170  Zoomes 32bit RGBA/ABGR 'src' surface to 'dst' surface.
 171
 172 */
 173
 174 int zoomSurfaceRGBA(SDL_Surface * src, SDL_Surface * dst, int flipx, int flipy, int smooth)
 175 {
 176     int x, y, sx, sy, *sax, *say, *csax, *csay, csx, csy, ex, ey, t1, t2, sstep;
 177     tColorRGBA *c00, *c01, *c10, *c11;
 178     tColorRGBA *sp, *csp, *dp;
 179     int dgap;
 180
 181     /*
 182      * Variable setup
 183      */
 184     if (smooth) {
 185         /*
 186          * For interpolation: assume source dimension is one pixel
 187          */
 188         /*
 189          * smaller to avoid overflow on right and bottom edge.
 190          */
 191         sx = (int) (65536.0 * (float) (src->w - 1) / (float) dst->w);
 192         sy = (int) (65536.0 * (float) (src->h - 1) / (float) dst->h);
 193     } else {
 194         sx = (int) (65536.0 * (float) src->w / (float) dst->w);
 195         sy = (int) (65536.0 * (float) src->h / (float) dst->h);
 196     }
 197
 198     /*
 199      * Allocate memory for row increments
 200      */
 201     if ((sax = (int *) malloc((dst->w + 1) * sizeof(Uint32))) == NULL) {
 202         return (-1);
 203     }
 204     if ((say = (int *) malloc((dst->h + 1) * sizeof(Uint32))) == NULL) {
 205         free(sax);
 206         return (-1);
 207     }
 208
 209     /*
 210      * Precalculate row increments
 211      */
 212     sp = csp = (tColorRGBA *) src->pixels;
 213     dp = (tColorRGBA *) dst->pixels;
 214
 215     if (flipx) csp += (src->w-1);
 216     if (flipy) csp  = (tColorRGBA*)( (Uint8*)csp + src->pitch*(src->h-1) );
 217
 218     csx = 0;
 219     csax = sax;
 220     for (x = 0; x <= dst->w; x++) {
 221         *csax = csx;
 222         csax++;
 223         csx &= 0xffff;
 224         csx += sx;
 225     }
 226     csy = 0;
 227     csay = say;
 228     for (y = 0; y <= dst->h; y++) {
 229         *csay = csy;
 230         csay++;
 231         csy &= 0xffff;
 232         csy += sy;
 233     }
 234
 235     dgap = dst->pitch - dst->w * 4;
 236
 237     /*
 238      * Switch between interpolating and non-interpolating code
 239      */
 240     if (smooth) {
 241
 242         /*
 243          * Interpolating Zoom
 244          */
 245
 246         /*
 247          * Scan destination
 248          */
 249         csay = say;
 250         for (y = 0; y < dst->h; y++) {
 251             /*
 252              * Setup color source pointers
 253              */
 254             c00 = csp;
 255             c01 = csp;
 256             c01++;
 257             c10 = (tColorRGBA *) ((Uint8 *) csp + src->pitch);
 258             c11 = c10;
 259             c11++;
 260             csax = sax;
 261             for (x = 0; x < dst->w; x++) {
 262
 263                 /*
 264                  * Interpolate colors
 265                  */
 266                 ex = (*csax & 0xffff);
 267                 ey = (*csay & 0xffff);
 268                 t1 = ((((c01->r - c00->r) * ex) >> 16) + c00->r) & 0xff;
 269                 t2 = ((((c11->r - c10->r) * ex) >> 16) + c10->r) & 0xff;
 270                 dp->r = (((t2 - t1) * ey) >> 16) + t1;
 271                 t1 = ((((c01->g - c00->g) * ex) >> 16) + c00->g) & 0xff;
 272                 t2 = ((((c11->g - c10->g) * ex) >> 16) + c10->g) & 0xff;
 273                 dp->g = (((t2 - t1) * ey) >> 16) + t1;
 274                 t1 = ((((c01->b - c00->b) * ex) >> 16) + c00->b) & 0xff;
 275                 t2 = ((((c11->b - c10->b) * ex) >> 16) + c10->b) & 0xff;
 276                 dp->b = (((t2 - t1) * ey) >> 16) + t1;
 277                 t1 = ((((c01->a - c00->a) * ex) >> 16) + c00->a) & 0xff;
 278                 t2 = ((((c11->a - c10->a) * ex) >> 16) + c10->a) & 0xff;
 279                 dp->a = (((t2 - t1) * ey) >> 16) + t1;
 280
 281                 /*
 282                  * Advance source pointers
 283                  */
 284                 csax++;
 285                 sstep = (*csax >> 16);
 286                 c00 += sstep;
 287                 c01 += sstep;
 288                 c10 += sstep;
 289                 c11 += sstep;
 290                 /*
 291                  * Advance destination pointer
 292                  */
 293                 dp++;
 294             }
 295             /*
 296              * Advance source pointer
 297              */
 298             csay++;
 299             csp = (tColorRGBA *) ((Uint8 *) csp + (*csay >> 16) * src->pitch);
 300             /*
 301              * Advance destination pointers
 302              */
 303             dp = (tColorRGBA *) ((Uint8 *) dp + dgap);
 304         }
 305
 306     } else {
 307
 308         /*
 309          * Non-Interpolating Zoom
 310          */
 311
 312         csay = say;
 313         for (y = 0; y < dst->h; y++) {
 314             sp = csp;
 315             csax = sax;
 316             for (x = 0; x < dst->w; x++) {
 317                 /*
 318                  * Draw
 319                  */
 320                 *dp = *sp;
 321                 /*
 322                  * Advance source pointers
 323                  */
 324                 csax++;
 325                 sstep = (*csax >> 16);
 326                 if (flipx) sstep = -sstep;
 327                 sp += sstep;
 328                 /*
 329                  * Advance destination pointer
 330                  */
 331                 dp++;
 332             }
 333             /*
 334              * Advance source pointer
 335              */
 336             csay++;
 337             sstep = (*csay >> 16) * src->pitch;
 338             if (flipy) sstep = -sstep;
 339             csp = (tColorRGBA *) ((Uint8 *) csp + sstep);
 340
 341             /*
 342              * Advance destination pointers
 343              */
 344             dp = (tColorRGBA *) ((Uint8 *) dp + dgap);
 345         }
 346
 347     }
 348
 349     /*
 350      * Remove temp arrays
 351      */
 352     free(sax);
 353     free(say);
 354
 355     return (0);
 356 }
 357
 358 /*
 359
 360  8bit Zoomer without smoothing.
 361
 362  Zoomes 8bit palette/Y 'src' surface to 'dst' surface.
 363
 364 */
 365
 366 int zoomSurfaceY(SDL_Surface * src, SDL_Surface * dst, int flipx, int flipy)
 367 {
 368     Uint32 x, y, sx, sy, *sax, *say, *csax, *csay, csx, csy;
 369     Uint8 *sp, *dp, *csp;
 370     int dgap;
 371
 372     /*
 373      * Variable setup
 374      */
 375     sx = (Uint32) (65536.0 * (float) src->w / (float) dst->w);
 376     sy = (Uint32) (65536.0 * (float) src->h / (float) dst->h);
 377
 378     /*
 379      * Allocate memory for row increments
 380      */
 381     if ((sax = (Uint32 *) malloc(dst->w * sizeof(Uint32))) == NULL) {
 382         return (-1);
 383     }
 384     if ((say = (Uint32 *) malloc(dst->h * sizeof(Uint32))) == NULL) {
 385         if (sax != NULL) {
 386             free(sax);
 387         }
 388         return (-1);
 389     }
 390
 391     /*
 392      * Precalculate row increments
 393      */
 394     csx = 0;
 395     csax = sax;
 396     for (x = 0; x < dst->w; x++) {
 397         csx += sx;
 398         *csax = (csx >> 16);
 399         csx &= 0xffff;
 400         csax++;
 401     }
 402     csy = 0;
 403     csay = say;
 404     for (y = 0; y < dst->h; y++) {
 405         csy += sy;
 406         *csay = (csy >> 16);
 407         csy &= 0xffff;
 408         csay++;
 409     }
 410
 411     csx = 0;
 412     csax = sax;
 413     for (x = 0; x < dst->w; x++) {
 414         csx += (*csax);
 415         csax++;
 416     }
 417     csy = 0;
 418     csay = say;
 419     for (y = 0; y < dst->h; y++) {
 420         csy += (*csay);
 421         csay++;
 422     }
 423
 424     /*
 425      * Pointer setup
 426      */
 427     sp = csp = (Uint8 *) src->pixels;
 428     dp = (Uint8 *) dst->pixels;
 429     dgap = dst->pitch - dst->w;
 430
 431     /*
 432      * Draw
 433      */
 434     csay = say;
 435     for (y = 0; y < dst->h; y++) {
 436         csax = sax;
 437         sp = csp;
 438         for (x = 0; x < dst->w; x++) {
 439             /*
 440              * Draw
 441              */
 442             *dp = *sp;
 443             /*
 444              * Advance source pointers
 445              */
 446             sp += (*csax);
 447             csax++;
 448             /*
 449              * Advance destination pointer
 450              */
 451             dp++;
 452         }
 453         /*
 454          * Advance source pointer (for row)
 455          */
 456         csp += ((*csay) * src->pitch);
 457         csay++;
 458         /*
 459          * Advance destination pointers
 460          */
 461         dp += dgap;
 462     }
 463
 464     /*
 465      * Remove temp arrays
 466      */
 467     free(sax);
 468     free(say);
 469
 470     return (0);
 471 }
 472
 473 /*
 474
 475  32bit Rotozoomer with optional anti-aliasing by bilinear interpolation.
 476
 477  Rotates and zoomes 32bit RGBA/ABGR 'src' surface to 'dst' surface.
 478
 479 */
 480
 481 void transformSurfaceRGBA(SDL_Surface * src, SDL_Surface * dst, int cx, int cy, int isin, int icos, int flipx, int flipy, int smooth)
 482 {
 483     int x, y, t1, t2, dx, dy, xd, yd, sdx, sdy, ax, ay, ex, ey, sw, sh;
 484     tColorRGBA c00, c01, c10, c11;
 485     tColorRGBA *pc, *sp;
 486     int gap;
 487
 488     /*
 489      * Variable setup
 490      */
 491     xd = ((src->w - dst->w) << 15);
 492     yd = ((src->h - dst->h) << 15);
 493     ax = (cx << 16) - (icos * cx);
 494     ay = (cy << 16) - (isin * cx);
 495     sw = src->w - 1;
 496     sh = src->h - 1;
 497     pc = dst->pixels;
 498     gap = dst->pitch - dst->w * 4;
 499
 500     /*
 501      * Switch between interpolating and non-interpolating code
 502      */
 503     if (smooth) {
 504         for (y = 0; y < dst->h; y++) {
 505             dy = cy - y;
 506             sdx = (ax + (isin * dy)) + xd;
 507             sdy = (ay - (icos * dy)) + yd;
 508             for (x = 0; x < dst->w; x++) {
 509                 dx = (sdx >> 16);
 510                 dy = (sdy >> 16);
 511                 if ((dx >= -1) && (dy >= -1) && (dx < src->w) && (dy < src->h)) {
 512                     if ((dx >= 0) && (dy >= 0) && (dx < sw) && (dy < sh)) {
 513                         sp = (tColorRGBA *) ((Uint8 *) src->pixels + src->pitch * dy);
 514                         sp += dx;
 515                         c00 = *sp;
 516                         sp += 1;
 517                         c01 = *sp;
 518                         sp = (tColorRGBA *) ((Uint8 *) sp + src->pitch);
 519                         sp -= 1;
 520                         c10 = *sp;
 521                         sp += 1;
 522                         c11 = *sp;
 523                     } else if ((dx == sw) && (dy == sh)) {
 524                         sp = (tColorRGBA *) ((Uint8 *) src->pixels + src->pitch * dy);
 525                         sp += dx;
 526                         c00 = *sp;
 527                         c01 = *sp;
 528                         c10 = *sp;
 529                         c11 = *sp;
 530                     } else if ((dx == -1) && (dy == -1)) {
 531                         sp = (tColorRGBA *) (src->pixels);
 532                         c00 = *sp;
 533                         c01 = *sp;
 534                         c10 = *sp;
 535                         c11 = *sp;
 536                     } else if ((dx == -1) && (dy == sh)) {
 537                         sp = (tColorRGBA *) (src->pixels);
 538                         sp = (tColorRGBA *) ((Uint8 *) src->pixels + src->pitch * dy);
 539                         c00 = *sp;
 540                         c01 = *sp;
 541                         c10 = *sp;
 542                         c11 = *sp;
 543                     } else if ((dx == sw) && (dy == -1)) {
 544                         sp = (tColorRGBA *) (src->pixels);
 545                         sp += dx;
 546                         c00 = *sp;
 547                         c01 = *sp;
 548                         c10 = *sp;
 549                         c11 = *sp;
 550                     } else if (dx == -1) {
 551                         sp = (tColorRGBA *) ((Uint8 *) src->pixels + src->pitch * dy);
 552                         c00 = *sp;
 553                         c01 = *sp;
 554                         c10 = *sp;
 555                         sp = (tColorRGBA *) ((Uint8 *) sp + src->pitch);
 556                         c11 = *sp;
 557                     } else if (dy == -1) {
 558                         sp = (tColorRGBA *) (src->pixels);
 559                         sp += dx;
 560                         c00 = *sp;
 561                         c01 = *sp;
 562                         c10 = *sp;
 563                         sp += 1;
 564                         c11 = *sp;
 565                     } else if (dx == sw) {
 566                         sp = (tColorRGBA *) ((Uint8 *) src->pixels + src->pitch * dy);
 567                         sp += dx;
 568                         c00 = *sp;
 569                         c01 = *sp;
 570                         sp = (tColorRGBA *) ((Uint8 *) sp + src->pitch);
 571                         c10 = *sp;
 572                         c11 = *sp;
 573                     } else if (dy == sh) {
 574                         sp = (tColorRGBA *) ((Uint8 *) src->pixels + src->pitch * dy);
 575                         sp += dx;
 576                         c00 = *sp;
 577                         sp += 1;
 578                         c01 = *sp;
 579                         c10 = *sp;
 580                         c11 = *sp;
 581                     }
 582                     /*
 583                      * Interpolate colors
 584                      */
 585                     ex = (sdx & 0xffff);
 586                     ey = (sdy & 0xffff);
 587                     t1 = ((((c01.r - c00.r) * ex) >> 16) + c00.r) & 0xff;
 588                     t2 = ((((c11.r - c10.r) * ex) >> 16) + c10.r) & 0xff;
 589                     pc->r = (((t2 - t1) * ey) >> 16) + t1;
 590                     t1 = ((((c01.g - c00.g) * ex) >> 16) + c00.g) & 0xff;
 591                     t2 = ((((c11.g - c10.g) * ex) >> 16) + c10.g) & 0xff;
 592                     pc->g = (((t2 - t1) * ey) >> 16) + t1;
 593                     t1 = ((((c01.b - c00.b) * ex) >> 16) + c00.b) & 0xff;
 594                     t2 = ((((c11.b - c10.b) * ex) >> 16) + c10.b) & 0xff;
 595                     pc->b = (((t2 - t1) * ey) >> 16) + t1;
 596                     t1 = ((((c01.a - c00.a) * ex) >> 16) + c00.a) & 0xff;
 597                     t2 = ((((c11.a - c10.a) * ex) >> 16) + c10.a) & 0xff;
 598                     pc->a = (((t2 - t1) * ey) >> 16) + t1;
 599                 }
 600                 sdx += icos;
 601                 sdy += isin;
 602                 pc++;
 603             }
 604             pc = (tColorRGBA *) ((Uint8 *) pc + gap);
 605         }
 606     } else {
 607         for (y = 0; y < dst->h; y++) {
 608             dy = cy - y;
 609             sdx = (ax + (isin * dy)) + xd;
 610             sdy = (ay - (icos * dy)) + yd;
 611             for (x = 0; x < dst->w; x++) {
 612                 dx = (short) (sdx >> 16);
 613                 dy = (short) (sdy >> 16);
 614                 if (flipx) dx = (src->w-1)-dx;
 615                 if (flipy) dy = (src->h-1)-dy;
 616                 if ((dx >= 0) && (dy >= 0) && (dx < src->w) && (dy < src->h)) {
 617                     sp = (tColorRGBA *) ((Uint8 *) src->pixels + src->pitch * dy);
 618                     sp += dx;
 619                     *pc = *sp;
 620                 }
 621                 sdx += icos;
 622                 sdy += isin;
 623                 pc++;
 624             }
 625             pc = (tColorRGBA *) ((Uint8 *) pc + gap);
 626         }
 627     }
 628 }
 629
 630 /*
 631
 632  8bit Rotozoomer without smoothing
 633
 634  Rotates and zoomes 8bit palette/Y 'src' surface to 'dst' surface.
 635
 636 */
 637
 638 void transformSurfaceY(SDL_Surface * src, SDL_Surface * dst, int cx, int cy, int isin, int icos)
 639 {
 640     int x, y, dx, dy, xd, yd, sdx, sdy, ax, ay, sw, sh;
 641     tColorY *pc, *sp;
 642     int gap;
 643
 644     /*
 645      * Variable setup
 646      */
 647     xd = ((src->w - dst->w) << 15);
 648     yd = ((src->h - dst->h) << 15);
 649     ax = (cx << 16) - (icos * cx);
 650     ay = (cy << 16) - (isin * cx);
 651     sw = src->w - 1;
 652     sh = src->h - 1;
 653     pc = dst->pixels;
 654     gap = dst->pitch - dst->w;
 655     /*
 656      * Clear surface to colorkey
 657      */
 658     memset(pc, (unsigned char) (src->format->colorkey & 0xff), dst->pitch * dst->h);
 659     /*
 660      * Iterate through destination surface
 661      */
 662     for (y = 0; y < dst->h; y++) {
 663         dy = cy - y;
 664         sdx = (ax + (isin * dy)) + xd;
 665         sdy = (ay - (icos * dy)) + yd;
 666         for (x = 0; x < dst->w; x++) {
 667             dx = (short) (sdx >> 16);
 668             dy = (short) (sdy >> 16);
 669             if ((dx >= 0) && (dy >= 0) && (dx < src->w) && (dy < src->h)) {
 670                 sp = (tColorY *) (src->pixels);
 671                 sp += (src->pitch * dy + dx);
 672                 *pc = *sp;
 673             }
 674             sdx += icos;
 675             sdy += isin;
 676             pc++;
 677         }
 678         pc += gap;
 679     }
 680 }
 681
 682
 683 /*
 684
 685  32bit specialized 90degree rotator
 686
 687  Rotates and zooms 'src' surface to 'dst' surface in 90degree increments.
 688
 689  (contributed by Jeff Schiller)
 690
 691 */
 692 SDL_Surface* rotateSurface90Degrees(SDL_Surface* pSurf, int numClockwiseTurns)
 693 {
 694  int row, col, newWidth, newHeight;
 695  SDL_Surface* pSurfOut;
 696
 697
 698  if (!pSurf || pSurf->format->BitsPerPixel != 32) { return NULL; }
 699
 700
 701  while(numClockwiseTurns < 0) { numClockwiseTurns += 4; }
 702  numClockwiseTurns = (numClockwiseTurns % 4);
 703
 704
 705  newWidth = (numClockwiseTurns % 2) ? (pSurf->h) : (pSurf->w);
 706  newHeight = (numClockwiseTurns % 2) ? (pSurf->w) : (pSurf->h);
 707  pSurfOut = SDL_CreateRGBSurface( pSurf->flags, newWidth, newHeight, pSurf->format->BitsPerPixel,
 708                            pSurf->format->Rmask,
 709                            pSurf->format->Gmask,
 710                            pSurf->format->Bmask,
 711                            pSurf->format->Amask);
 712  if(!pSurfOut) {
 713    return NULL;
 714  }
 715
 716  if(numClockwiseTurns != 0) {
 717    SDL_LockSurface(pSurf);
 718    SDL_LockSurface(pSurfOut);
 719    switch(numClockwiseTurns) {
 720
 721      case 1:
 722      {
 723        Uint32* srcBuf = NULL;
 724        Uint32* dstBuf = NULL;
 725
 726        for (row = 0; row < pSurf->h; ++row) {
 727          srcBuf = (Uint32*)(pSurf->pixels) + (row*pSurf->pitch/4);
 728          dstBuf = (Uint32*)(pSurfOut->pixels) + (pSurfOut->w - row - 1);
 729          for (col = 0; col < pSurf->w; ++col) {
 730            *dstBuf = *srcBuf;
 731            ++srcBuf;
 732            dstBuf += pSurfOut->pitch/4;
 733          }
 734        }
 735      }
 736      break;
 737
 738      case 2:
 739      {
 740        Uint32* srcBuf = NULL;
 741        Uint32* dstBuf = NULL;
 742
 743        for(row = 0; row < pSurf->h; ++row) {
 744          srcBuf = (Uint32*)(pSurf->pixels) + (row*pSurf->pitch/4);
 745          dstBuf = (Uint32*)(pSurfOut->pixels) + ((pSurfOut->h - row - 1)*pSurfOut->pitch/4) + (pSurfOut->w - 1);
 746          for(col = 0; col < pSurf->w; ++col) {
 747            *dstBuf = *srcBuf;
 748            ++srcBuf;
 749            --dstBuf;
 750          }
 751        }
 752      }
 753      break;
 754
 755      case 3:
 756      {
 757        Uint32* srcBuf = NULL;
 758        Uint32* dstBuf = NULL;
 759
 760        for(row = 0; row < pSurf->h; ++row) {
 761          srcBuf = (Uint32*)(pSurf->pixels) + (row*pSurf->pitch/4);
 762          dstBuf = (Uint32*)(pSurfOut->pixels) + row + ((pSurfOut->h - 1)*pSurfOut->pitch/4);
 763          for(col = 0; col < pSurf->w; ++col) {
 764            *dstBuf = *srcBuf;
 765            ++srcBuf;
 766            dstBuf -= pSurfOut->pitch/4;
 767          }
 768        }
 769      }
 770      break;
 771    }
 772
 773    SDL_UnlockSurface(pSurf);
 774    SDL_UnlockSurface(pSurfOut);
 775  }
 776  else {
 777    /* simply copy surface to output */
 778    if(SDL_BlitSurface(pSurf, NULL, pSurfOut, NULL)) {
 779      return NULL;
 780    }
 781  }
 782  return pSurfOut;
 783 }
 784
 785 /*
 786
 787  rotozoomSurface()
 788
 789  Rotates and zoomes a 32bit or 8bit 'src' surface to newly created 'dst' surface.
 790  'angle' is the rotation in degrees. 'zoom' a scaling factor. If 'smooth' is 1
 791  then the destination 32bit surface is anti-aliased. If the surface is not 8bit
 792  or 32bit RGBA/ABGR it will be converted into a 32bit RGBA format on the fly.
 793
 794 */
 795
 796 #define VALUE_LIMIT     0.001
 797
 798
 799 /* Local rotozoom-size function with trig result return */
 800
 801 void rotozoomSurfaceSizeTrig(int width, int height, double angle, double zoomx, double zoomy, int *dstwidth, int *dstheight,
 802                              double *canglezoom, double *sanglezoom)
 803 {
 804     double x, y, cx, cy, sx, sy;
 805     double radangle;
 806     int dstwidthhalf, dstheighthalf;
 807
 808     /*
 809      * Determine destination width and height by rotating a centered source box
 810      */
 811     radangle = angle * (M_PI / 180.0);
 812     *sanglezoom = sin(radangle);
 813     *canglezoom = cos(radangle);
 814     *sanglezoom *= zoomx;
 815     *canglezoom *= zoomx;
 816     x = width / 2;
 817     y = height / 2;
 818     cx = *canglezoom * x;
 819     cy = *canglezoom * y;
 820     sx = *sanglezoom * x;
 821     sy = *sanglezoom * y;
 822
 823     dstwidthhalf = MAX((int)
 824                        ceil(MAX(MAX(MAX(fabs(cx + sy), fabs(cx - sy)), fabs(-cx + sy)), fabs(-cx - sy))), 1);
 825     dstheighthalf = MAX((int)
 826                         ceil(MAX(MAX(MAX(fabs(sx + cy), fabs(sx - cy)), fabs(-sx + cy)), fabs(-sx - cy))), 1);
 827     *dstwidth = 2 * dstwidthhalf;
 828     *dstheight = 2 * dstheighthalf;
 829 }
 830
 831
 832 /* Publically available rotozoom-size function */
 833
 834 void rotozoomSurfaceSizeXY(int width, int height, double angle, double zoomx, double zoomy, int *dstwidth, int *dstheight)
 835 {
 836     double dummy_sanglezoom, dummy_canglezoom;
 837
 838     rotozoomSurfaceSizeTrig(width, height, angle, zoomx, zoomy, dstwidth, dstheight, &dummy_sanglezoom, &dummy_canglezoom);
 839 }
 840
 841 /* Publically available rotozoom-size function */
 842
 843 void rotozoomSurfaceSize(int width, int height, double angle, double zoom, int *dstwidth, int *dstheight)
 844 {
 845     double dummy_sanglezoom, dummy_canglezoom;
 846
 847     rotozoomSurfaceSizeTrig(width, height, angle, zoom, zoom, dstwidth, dstheight, &dummy_sanglezoom, &dummy_canglezoom);
 848 }
 849
 850 /* Publically available rotozoom function */
 851
 852 SDL_Surface *rotozoomSurface(SDL_Surface * src, double angle, double zoom, int smooth)
 853 {
 854   return rotozoomSurfaceXY(src, angle, zoom, zoom, smooth);
 855 }
 856
 857 /* Publically available rotozoom function */
 858
 859 SDL_Surface *rotozoomSurfaceXY(SDL_Surface * src, double angle, double zoomx, double zoomy, int smooth)
 860 {
 861     SDL_Surface *rz_src;
 862     SDL_Surface *rz_dst;
 863     double zoominv;
 864     double sanglezoom, canglezoom, sanglezoominv, canglezoominv;
 865     int dstwidthhalf, dstwidth, dstheighthalf, dstheight;
 866     int is32bit;
 867     int i, src_converted;
 868     int flipx,flipy;
 869     Uint8 r,g,b;
 870     Uint32 colorkey;
 871     int colorKeyAvailable = 0;
 872
 873     /*
 874      * Sanity check
 875      */
 876     if (src == NULL)
 877         return (NULL);
 878
 879     if( src->flags & SDL_SRCCOLORKEY )
 880     {
 881         colorkey = src->format->colorkey;
 882         SDL_GetRGB(colorkey, src->format, &r, &g, &b);
 883         colorKeyAvailable = 1;
 884     }
 885     /*
 886      * Determine if source surface is 32bit or 8bit
 887      */
 888     is32bit = (src->format->BitsPerPixel == 32);
 889     if ((is32bit) || (src->format->BitsPerPixel == 8)) {
 890         /*
 891          * Use source surface 'as is'
 892          */
 893         rz_src = src;
 894         src_converted = 0;
 895     } else {
 896         /*
 897          * New source surface is 32bit with a defined RGBA ordering
 898          */
 899         rz_src =
 900             SDL_CreateRGBSurface(SDL_SWSURFACE, src->w, src->h, 32,
 901 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
 902                                 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000
 903 #else
 904                                 0xff000000,  0x00ff0000, 0x0000ff00, 0x000000ff
 905 #endif
 906             );
 907                 if(colorKeyAvailable)
 908                         SDL_SetColorKey(src, 0, 0);
 909
 910         SDL_BlitSurface(src, NULL, rz_src, NULL);
 911
 912                 if(colorKeyAvailable)
 913                         SDL_SetColorKey(src, SDL_SRCCOLORKEY, colorkey);
 914         src_converted = 1;
 915         is32bit = 1;
 916     }
 917
 918     /*
 919      * Sanity check zoom factor
 920      */
 921     flipx = (zoomx<0);
 922     if (flipx) zoomx=-zoomx;
 923     flipy = (zoomy<0);
 924     if (flipy) zoomy=-zoomy;
 925     if (zoomx < VALUE_LIMIT) zoomx = VALUE_LIMIT;
 926     if (zoomy < VALUE_LIMIT) zoomy = VALUE_LIMIT;
 927     zoominv = 65536.0 / (zoomx * zoomx);
 928
 929     /*
 930      * Check if we have a rotozoom or just a zoom
 931      */
 932     if (fabs(angle) > VALUE_LIMIT) {
 933
 934         /*
 935          * Angle!=0: full rotozoom
 936          */
 937         /*
 938          * -----------------------
 939          */
 940
 941         /* Determine target size */
 942         rotozoomSurfaceSizeTrig(rz_src->w, rz_src->h, angle, zoomx, zoomy, &dstwidth, &dstheight, &canglezoom, &sanglezoom);
 943
 944         /*
 945          * Calculate target factors from sin/cos and zoom
 946          */
 947         sanglezoominv = sanglezoom;
 948         canglezoominv = canglezoom;
 949         sanglezoominv *= zoominv;
 950         canglezoominv *= zoominv;
 951
 952         /* Calculate half size */
 953         dstwidthhalf = dstwidth / 2;
 954         dstheighthalf = dstheight / 2;
 955
 956         /*
 957          * Alloc space to completely contain the rotated surface
 958          */
 959         rz_dst = NULL;
 960         if (is32bit) {
 961             /*
 962              * Target surface is 32bit with source RGBA/ABGR ordering
 963              */
 964             rz_dst =
 965                 SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight, 32,
 966                                      rz_src->format->Rmask, rz_src->format->Gmask,
 967                                      rz_src->format->Bmask, rz_src->format->Amask);
 968         } else {
 969             /*
 970              * Target surface is 8bit
 971              */
 972             rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight, 8, 0, 0, 0, 0);
 973         }
 974
 975         if (colorKeyAvailable == 1){
 976                 colorkey = SDL_MapRGB(rz_dst->format, r, g, b);
 977
 978                 SDL_FillRect(rz_dst, NULL, colorkey );
 979         }
 980
 981         /*
 982          * Lock source surface
 983          */
 984         SDL_LockSurface(rz_src);
 985         /*
 986          * Check which kind of surface we have
 987          */
 988         if (is32bit) {
 989             /*
 990              * Call the 32bit transformation routine to do the rotation (using alpha)
 991              */
 992             transformSurfaceRGBA(rz_src, rz_dst, dstwidthhalf, dstheighthalf,
 993                                  (int) (sanglezoominv), (int) (canglezoominv),
 994                                  flipx, flipy,
 995                                  smooth);
 996             /*
 997              * Turn on source-alpha support
 998              */
 999             SDL_SetAlpha(rz_dst, SDL_SRCALPHA, 255);
1000         } else {
1001             /*
1002              * Copy palette and colorkey info
1003              */
1004             for (i = 0; i < rz_src->format->palette->ncolors; i++) {
1005                 rz_dst->format->palette->colors[i] = rz_src->format->palette->colors[i];
1006             }
1007             rz_dst->format->palette->ncolors = rz_src->format->palette->ncolors;
1008             /*
1009              * Call the 8bit transformation routine to do the rotation
1010              */
1011             transformSurfaceY(rz_src, rz_dst, dstwidthhalf, dstheighthalf,
1012                               (int) (sanglezoominv), (int) (canglezoominv));
1013             SDL_SetColorKey(rz_dst, SDL_SRCCOLORKEY | SDL_RLEACCEL, rz_src->format->colorkey);
1014         }
1015         /*
1016          * Unlock source surface
1017          */
1018         SDL_UnlockSurface(rz_src);
1019
1020     } else {
1021
1022         /*
1023          * Angle=0: Just a zoom
1024          */
1025         /*
1026          * --------------------
1027          */
1028
1029         /*
1030          * Calculate target size
1031          */
1032         zoomSurfaceSize(rz_src->w, rz_src->h, zoomx, zoomy, &dstwidth, &dstheight);
1033
1034         /*
1035          * Alloc space to completely contain the zoomed surface
1036          */
1037         rz_dst = NULL;
1038         if (is32bit) {
1039             /*
1040              * Target surface is 32bit with source RGBA/ABGR ordering
1041              */
1042             rz_dst =
1043                 SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight, 32,
1044                                      rz_src->format->Rmask, rz_src->format->Gmask,
1045                                      rz_src->format->Bmask, rz_src->format->Amask);
1046         } else {
1047             /*
1048              * Target surface is 8bit
1049              */
1050             rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight, 8, 0, 0, 0, 0);
1051         }
1052
1053         if (colorKeyAvailable == 1){
1054                 colorkey = SDL_MapRGB(rz_dst->format, r, g, b);
1055
1056                 SDL_FillRect(rz_dst, NULL, colorkey );
1057         }
1058
1059         /*
1060          * Lock source surface
1061          */
1062         SDL_LockSurface(rz_src);
1063         /*
1064          * Check which kind of surface we have
1065          */
1066         if (is32bit) {
1067             /*
1068              * Call the 32bit transformation routine to do the zooming (using alpha)
1069              */
1070             zoomSurfaceRGBA(rz_src, rz_dst, flipx, flipy, smooth);
1071             /*
1072              * Turn on source-alpha support
1073              */
1074             SDL_SetAlpha(rz_dst, SDL_SRCALPHA, 255);
1075         } else {
1076             /*
1077              * Copy palette and colorkey info
1078              */
1079             for (i = 0; i < rz_src->format->palette->ncolors; i++) {
1080                 rz_dst->format->palette->colors[i] = rz_src->format->palette->colors[i];
1081             }
1082             rz_dst->format->palette->ncolors = rz_src->format->palette->ncolors;
1083             /*
1084              * Call the 8bit transformation routine to do the zooming
1085              */
1086             zoomSurfaceY(rz_src, rz_dst, flipx, flipy);
1087             SDL_SetColorKey(rz_dst, SDL_SRCCOLORKEY | SDL_RLEACCEL, rz_src->format->colorkey);
1088         }
1089         /*
1090          * Unlock source surface
1091          */
1092         SDL_UnlockSurface(rz_src);
1093     }
1094
1095     /*
1096      * Cleanup temp surface
1097      */
1098     if (src_converted) {
1099         SDL_FreeSurface(rz_src);
1100     }
1101
1102     /*
1103      * Return destination surface
1104      */
1105     return (rz_dst);
1106 }
1107
1108 /*
1109
1110  zoomSurface()
1111
1112  Zoomes a 32bit or 8bit 'src' surface to newly created 'dst' surface.
1113  'zoomx' and 'zoomy' are scaling factors for width and height. If 'smooth' is 1
1114  then the destination 32bit surface is anti-aliased. If the surface is not 8bit
1115  or 32bit RGBA/ABGR it will be converted into a 32bit RGBA format on the fly.
1116
1117 */
1118
1119 #define VALUE_LIMIT     0.001
1120
1121 void zoomSurfaceSize(int width, int height, double zoomx, double zoomy, int *dstwidth, int *dstheight)
1122 {
1123     /*
1124      * Sanity check zoom factors
1125      */
1126     if (zoomx < VALUE_LIMIT) {
1127         zoomx = VALUE_LIMIT;
1128     }
1129     if (zoomy < VALUE_LIMIT) {
1130         zoomy = VALUE_LIMIT;
1131     }
1132
1133     /*
1134      * Calculate target size
1135      */
1136     *dstwidth = (int) ((double) width * zoomx);
1137     *dstheight = (int) ((double) height * zoomy);
1138     if (*dstwidth < 1) {
1139         *dstwidth = 1;
1140     }
1141     if (*dstheight < 1) {
1142         *dstheight = 1;
1143     }
1144 }
1145
1146 SDL_Surface *zoomSurface(SDL_Surface * src, double zoomx, double zoomy, int smooth)
1147 {
1148     SDL_Surface *rz_src;
1149     SDL_Surface *rz_dst;
1150     int dstwidth, dstheight;
1151     int is32bit;
1152     int i, src_converted;
1153     int flipx, flipy;
1154
1155     /*
1156      * Sanity check
1157      */
1158     if (src == NULL)
1159         return (NULL);
1160
1161     /*
1162      * Determine if source surface is 32bit or 8bit
1163      */
1164     is32bit = (src->format->BitsPerPixel == 32);
1165     if ((is32bit) || (src->format->BitsPerPixel == 8)) {
1166         /*
1167          * Use source surface 'as is'
1168          */
1169         rz_src = src;
1170         src_converted = 0;
1171     } else {
1172         /*
1173          * New source surface is 32bit with a defined RGBA ordering
1174          */
1175         rz_src =
1176             SDL_CreateRGBSurface(SDL_SWSURFACE, src->w, src->h, 32,
1177 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
1178                                 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000
1179 #else
1180                                 0xff000000,  0x00ff0000, 0x0000ff00, 0x000000ff
1181 #endif
1182             );
1183         SDL_BlitSurface(src, NULL, rz_src, NULL);
1184         src_converted = 1;
1185         is32bit = 1;
1186     }
1187
1188     flipx = (zoomx<0);
1189     if (flipx) zoomx = -zoomx;
1190     flipy = (zoomy<0);
1191     if (flipy) zoomy = -zoomy;
1192
1193     /* Get size if target */
1194     zoomSurfaceSize(rz_src->w, rz_src->h, zoomx, zoomy, &dstwidth, &dstheight);
1195
1196     /*
1197      * Alloc space to completely contain the zoomed surface
1198      */
1199     rz_dst = NULL;
1200     if (is32bit) {
1201         /*
1202          * Target surface is 32bit with source RGBA/ABGR ordering
1203          */
1204         rz_dst =
1205             SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight, 32,
1206                                  rz_src->format->Rmask, rz_src->format->Gmask,
1207                                  rz_src->format->Bmask, rz_src->format->Amask);
1208     } else {
1209         /*
1210          * Target surface is 8bit
1211          */
1212         rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight, 8, 0, 0, 0, 0);
1213     }
1214
1215     /*
1216      * Lock source surface
1217      */
1218     SDL_LockSurface(rz_src);
1219     /*
1220      * Check which kind of surface we have
1221      */
1222     if (is32bit) {
1223         /*
1224          * Call the 32bit transformation routine to do the zooming (using alpha)
1225          */
1226         zoomSurfaceRGBA(rz_src, rz_dst, flipx, flipy, smooth);
1227         /*
1228          * Turn on source-alpha support
1229          */
1230         SDL_SetAlpha(rz_dst, SDL_SRCALPHA, 255);
1231     } else {
1232         /*
1233          * Copy palette and colorkey info
1234          */
1235         for (i = 0; i < rz_src->format->palette->ncolors; i++) {
1236             rz_dst->format->palette->colors[i] = rz_src->format->palette->colors[i];
1237         }
1238         rz_dst->format->palette->ncolors = rz_src->format->palette->ncolors;
1239         /*
1240          * Call the 8bit transformation routine to do the zooming
1241          */
1242         zoomSurfaceY(rz_src, rz_dst, flipx, flipy);
1243         SDL_SetColorKey(rz_dst, SDL_SRCCOLORKEY | SDL_RLEACCEL, rz_src->format->colorkey);
1244     }
1245     /*
1246      * Unlock source surface
1247      */
1248     SDL_UnlockSurface(rz_src);
1249
1250     /*
1251      * Cleanup temp surface
1252      */
1253     if (src_converted) {
1254         SDL_FreeSurface(rz_src);
1255     }
1256
1257     /*
1258      * Return destination surface
1259      */
1260     return (rz_dst);
1261 }
1262
1263 SDL_Surface *shrinkSurface(SDL_Surface * src, int factorx, int factory)
1264 {
1265     SDL_Surface *rz_src;
1266     SDL_Surface *rz_dst;
1267     int dstwidth, dstheight;
1268     int is32bit;
1269     int i, src_converted;
1270
1271     /*
1272      * Sanity check
1273      */
1274     if (src == NULL)
1275         return (NULL);
1276
1277     /*
1278      * Determine if source surface is 32bit or 8bit
1279      */
1280     is32bit = (src->format->BitsPerPixel == 32);
1281     if ((is32bit) || (src->format->BitsPerPixel == 8)) {
1282         /*
1283          * Use source surface 'as is'
1284          */
1285         rz_src = src;
1286         src_converted = 0;
1287     } else {
1288         /*
1289          * New source surface is 32bit with a defined RGBA ordering
1290          */
1291         rz_src =
1292             SDL_CreateRGBSurface(SDL_SWSURFACE, src->w, src->h, 32,
1293 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
1294                                 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000
1295 #else
1296                                 0xff000000,  0x00ff0000, 0x0000ff00, 0x000000ff
1297 #endif
1298             );
1299         SDL_BlitSurface(src, NULL, rz_src, NULL);
1300         src_converted = 1;
1301         is32bit = 1;
1302     }
1303
1304     /* Get size for target */
1305     dstwidth=rz_src->w/factorx;
1306     while (dstwidth*factorx>rz_src->w) { dstwidth--; }
1307     dstheight=rz_src->h/factory;
1308     while (dstheight*factory>rz_src->h) { dstheight--; }
1309
1310     /*
1311      * Alloc space to completely contain the shrunken surface
1312      */
1313     rz_dst = NULL;
1314     if (is32bit) {
1315         /*
1316          * Target surface is 32bit with source RGBA/ABGR ordering
1317          */
1318         rz_dst =
1319             SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight, 32,
1320                                  rz_src->format->Rmask, rz_src->format->Gmask,
1321                                  rz_src->format->Bmask, rz_src->format->Amask);
1322     } else {
1323         /*
1324          * Target surface is 8bit
1325          */
1326         rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight, 8, 0, 0, 0, 0);
1327     }
1328
1329     /*
1330      * Lock source surface
1331      */
1332     SDL_LockSurface(rz_src);
1333     /*
1334      * Check which kind of surface we have
1335      */
1336     if (is32bit) {
1337         /*
1338          * Call the 32bit transformation routine to do the shrinking (using alpha)
1339          */
1340         shrinkSurfaceRGBA(rz_src, rz_dst, factorx, factory);
1341         /*
1342          * Turn on source-alpha support
1343          */
1344         SDL_SetAlpha(rz_dst, SDL_SRCALPHA, 255);
1345     } else {
1346         /*
1347          * Copy palette and colorkey info
1348          */
1349         for (i = 0; i < rz_src->format->palette->ncolors; i++) {
1350             rz_dst->format->palette->colors[i] = rz_src->format->palette->colors[i];
1351         }
1352         rz_dst->format->palette->ncolors = rz_src->format->palette->ncolors;
1353         /*
1354          * Call the 8bit transformation routine to do the shrinking
1355          */
1356         shrinkSurfaceY(rz_src, rz_dst, factorx, factory);
1357         SDL_SetColorKey(rz_dst, SDL_SRCCOLORKEY | SDL_RLEACCEL, rz_src->format->colorkey);
1358     }
1359     /*
1360      * Unlock source surface
1361      */
1362     SDL_UnlockSurface(rz_src);
1363
1364     /*
1365      * Cleanup temp surface
1366      */
1367     if (src_converted) {
1368         SDL_FreeSurface(rz_src);
1369     }
1370
1371     /*
1372      * Return destination surface
1373      */
1374     return (rz_dst);
1375 }