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     (void)flipx;
 369     (void)flipy;
 370
 371     Uint32 x, y, sx, sy, *sax, *say, *csax, *csay, csx, csy;
 372     Uint8 *sp, *dp, *csp;
 373     int dgap;
 374
 375     /*
 376      * Variable setup
 377      */
 378     sx = (Uint32) (65536.0 * (float) src->w / (float) dst->w);
 379     sy = (Uint32) (65536.0 * (float) src->h / (float) dst->h);
 380
 381     /*
 382      * Allocate memory for row increments
 383      */
 384     if ((sax = (Uint32 *) malloc(dst->w * sizeof(Uint32))) == NULL) {
 385         return (-1);
 386     }
 387     if ((say = (Uint32 *) malloc(dst->h * sizeof(Uint32))) == NULL) {
 388         if (sax != NULL) {
 389             free(sax);
 390         }
 391         return (-1);
 392     }
 393
 394     /*
 395      * Precalculate row increments
 396      */
 397     csx = 0;
 398     csax = sax;
 399     for (x = 0; x < (Uint32)dst->w; x++) {
 400         csx += sx;
 401         *csax = (csx >> 16);
 402         csx &= 0xffff;
 403         csax++;
 404     }
 405     csy = 0;
 406     csay = say;
 407     for (y = 0; y < (Uint32)dst->h; y++) {
 408         csy += sy;
 409         *csay = (csy >> 16);
 410         csy &= 0xffff;
 411         csay++;
 412     }
 413
 414     csx = 0;
 415     csax = sax;
 416     for (x = 0; x < (Uint32)dst->w; x++) {
 417         csx += (*csax);
 418         csax++;
 419     }
 420     csy = 0;
 421     csay = say;
 422     for (y = 0; y < (Uint32)dst->h; y++) {
 423         csy += (*csay);
 424         csay++;
 425     }
 426
 427     /*
 428      * Pointer setup
 429      */
 430     sp = csp = (Uint8 *) src->pixels;
 431     dp = (Uint8 *) dst->pixels;
 432     dgap = dst->pitch - dst->w;
 433
 434     /*
 435      * Draw
 436      */
 437     csay = say;
 438     for (y = 0; y < (Uint32)dst->h; y++) {
 439         csax = sax;
 440         sp = csp;
 441         for (x = 0; x < (Uint32)dst->w; x++) {
 442             /*
 443              * Draw
 444              */
 445             *dp = *sp;
 446             /*
 447              * Advance source pointers
 448              */
 449             sp += (*csax);
 450             csax++;
 451             /*
 452              * Advance destination pointer
 453              */
 454             dp++;
 455         }
 456         /*
 457          * Advance source pointer (for row)
 458          */
 459         csp += ((*csay) * src->pitch);
 460         csay++;
 461         /*
 462          * Advance destination pointers
 463          */
 464         dp += dgap;
 465     }
 466
 467     /*
 468      * Remove temp arrays
 469      */
 470     free(sax);
 471     free(say);
 472
 473     return (0);
 474 }
 475
 476 /*
 477
 478  32bit Rotozoomer with optional anti-aliasing by bilinear interpolation.
 479
 480  Rotates and zoomes 32bit RGBA/ABGR 'src' surface to 'dst' surface.
 481
 482 */
 483
 484 void transformSurfaceRGBA(SDL_Surface * src, SDL_Surface * dst, int cx, int cy, int isin, int icos, int flipx, int flipy, int smooth)
 485 {
 486     int x, y, t1, t2, dx, dy, xd, yd, sdx, sdy, ax, ay, ex, ey, sw, sh;
 487     tColorRGBA c00, c01, c10, c11;
 488     tColorRGBA *pc, *sp;
 489     int gap;
 490
 491     /*
 492      * Variable setup
 493      */
 494     xd = ((src->w - dst->w) << 15);
 495     yd = ((src->h - dst->h) << 15);
 496     ax = (cx << 16) - (icos * cx);
 497     ay = (cy << 16) - (isin * cx);
 498     sw = src->w - 1;
 499     sh = src->h - 1;
 500     pc = (tColorRGBA*)dst->pixels;
 501     gap = dst->pitch - dst->w * 4;
 502
 503     /*
 504      * Switch between interpolating and non-interpolating code
 505      */
 506     if (smooth) {
 507         for (y = 0; y < dst->h; y++) {
 508             dy = cy - y;
 509             sdx = (ax + (isin * dy)) + xd;
 510             sdy = (ay - (icos * dy)) + yd;
 511             for (x = 0; x < dst->w; x++) {
 512                 dx = (sdx >> 16);
 513                 dy = (sdy >> 16);
 514                 if ((dx >= -1) && (dy >= -1) && (dx < src->w) && (dy < src->h)) {
 515                     if ((dx >= 0) && (dy >= 0) && (dx < sw) && (dy < sh)) {
 516                         sp = (tColorRGBA *) ((Uint8 *) src->pixels + src->pitch * dy);
 517                         sp += dx;
 518                         c00 = *sp;
 519                         sp += 1;
 520                         c01 = *sp;
 521                         sp = (tColorRGBA *) ((Uint8 *) sp + src->pitch);
 522                         sp -= 1;
 523                         c10 = *sp;
 524                         sp += 1;
 525                         c11 = *sp;
 526                     } else if ((dx == sw) && (dy == sh)) {
 527                         sp = (tColorRGBA *) ((Uint8 *) src->pixels + src->pitch * dy);
 528                         sp += dx;
 529                         c00 = *sp;
 530                         c01 = *sp;
 531                         c10 = *sp;
 532                         c11 = *sp;
 533                     } else if ((dx == -1) && (dy == -1)) {
 534                         sp = (tColorRGBA *) (src->pixels);
 535                         c00 = *sp;
 536                         c01 = *sp;
 537                         c10 = *sp;
 538                         c11 = *sp;
 539                     } else if ((dx == -1) && (dy == sh)) {
 540                         sp = (tColorRGBA *) (src->pixels);
 541                         sp = (tColorRGBA *) ((Uint8 *) src->pixels + src->pitch * dy);
 542                         c00 = *sp;
 543                         c01 = *sp;
 544                         c10 = *sp;
 545                         c11 = *sp;
 546                     } else if ((dx == sw) && (dy == -1)) {
 547                         sp = (tColorRGBA *) (src->pixels);
 548                         sp += dx;
 549                         c00 = *sp;
 550                         c01 = *sp;
 551                         c10 = *sp;
 552                         c11 = *sp;
 553                     } else if (dx == -1) {
 554                         sp = (tColorRGBA *) ((Uint8 *) src->pixels + src->pitch * dy);
 555                         c00 = *sp;
 556                         c01 = *sp;
 557                         c10 = *sp;
 558                         sp = (tColorRGBA *) ((Uint8 *) sp + src->pitch);
 559                         c11 = *sp;
 560                     } else if (dy == -1) {
 561                         sp = (tColorRGBA *) (src->pixels);
 562                         sp += dx;
 563                         c00 = *sp;
 564                         c01 = *sp;
 565                         c10 = *sp;
 566                         sp += 1;
 567                         c11 = *sp;
 568                     } else if (dx == sw) {
 569                         sp = (tColorRGBA *) ((Uint8 *) src->pixels + src->pitch * dy);
 570                         sp += dx;
 571                         c00 = *sp;
 572                         c01 = *sp;
 573                         sp = (tColorRGBA *) ((Uint8 *) sp + src->pitch);
 574                         c10 = *sp;
 575                         c11 = *sp;
 576                     } else if (dy == sh) {
 577                         sp = (tColorRGBA *) ((Uint8 *) src->pixels + src->pitch * dy);
 578                         sp += dx;
 579                         c00 = *sp;
 580                         sp += 1;
 581                         c01 = *sp;
 582                         c10 = *sp;
 583                         c11 = *sp;
 584                     }
 585                     /*
 586                      * Interpolate colors
 587                      */
 588                     ex = (sdx & 0xffff);
 589                     ey = (sdy & 0xffff);
 590                     t1 = ((((c01.r - c00.r) * ex) >> 16) + c00.r) & 0xff;
 591                     t2 = ((((c11.r - c10.r) * ex) >> 16) + c10.r) & 0xff;
 592                     pc->r = (((t2 - t1) * ey) >> 16) + t1;
 593                     t1 = ((((c01.g - c00.g) * ex) >> 16) + c00.g) & 0xff;
 594                     t2 = ((((c11.g - c10.g) * ex) >> 16) + c10.g) & 0xff;
 595                     pc->g = (((t2 - t1) * ey) >> 16) + t1;
 596                     t1 = ((((c01.b - c00.b) * ex) >> 16) + c00.b) & 0xff;
 597                     t2 = ((((c11.b - c10.b) * ex) >> 16) + c10.b) & 0xff;
 598                     pc->b = (((t2 - t1) * ey) >> 16) + t1;
 599                     t1 = ((((c01.a - c00.a) * ex) >> 16) + c00.a) & 0xff;
 600                     t2 = ((((c11.a - c10.a) * ex) >> 16) + c10.a) & 0xff;
 601                     pc->a = (((t2 - t1) * ey) >> 16) + t1;
 602                 }
 603                 sdx += icos;
 604                 sdy += isin;
 605                 pc++;
 606             }
 607             pc = (tColorRGBA *) ((Uint8 *) pc + gap);
 608         }
 609     } else {
 610         for (y = 0; y < dst->h; y++) {
 611             dy = cy - y;
 612             sdx = (ax + (isin * dy)) + xd;
 613             sdy = (ay - (icos * dy)) + yd;
 614             for (x = 0; x < dst->w; x++) {
 615                 dx = (short) (sdx >> 16);
 616                 dy = (short) (sdy >> 16);
 617                 if (flipx) dx = (src->w-1)-dx;
 618                 if (flipy) dy = (src->h-1)-dy;
 619                 if ((dx >= 0) && (dy >= 0) && (dx < src->w) && (dy < src->h)) {
 620                     sp = (tColorRGBA *) ((Uint8 *) src->pixels + src->pitch * dy);
 621                     sp += dx;
 622                     *pc = *sp;
 623                 }
 624                 sdx += icos;
 625                 sdy += isin;
 626                 pc++;
 627             }
 628             pc = (tColorRGBA *) ((Uint8 *) pc + gap);
 629         }
 630     }
 631 }
 632
 633 /*
 634
 635  8bit Rotozoomer without smoothing
 636
 637  Rotates and zoomes 8bit palette/Y 'src' surface to 'dst' surface.
 638
 639 */
 640
 641 void transformSurfaceY(SDL_Surface * src, SDL_Surface * dst, int cx, int cy, int isin, int icos)
 642 {
 643     int x, y, dx, dy, xd, yd, sdx, sdy, ax, ay, sw, sh;
 644     tColorY *pc, *sp;
 645     int gap;
 646
 647     /*
 648      * Variable setup
 649      */
 650     xd = ((src->w - dst->w) << 15);
 651     yd = ((src->h - dst->h) << 15);
 652     ax = (cx << 16) - (icos * cx);
 653     ay = (cy << 16) - (isin * cx);
 654     sw = src->w - 1;
 655     sh = src->h - 1;
 656     pc = (tColorY*)dst->pixels;
 657     gap = dst->pitch - dst->w;
 658     /*
 659      * Clear surface to colorkey
 660      */
 661     memset(pc, (unsigned char) (src->format->colorkey & 0xff), dst->pitch * dst->h);
 662     /*
 663      * Iterate through destination surface
 664      */
 665     for (y = 0; y < dst->h; y++) {
 666         dy = cy - y;
 667         sdx = (ax + (isin * dy)) + xd;
 668         sdy = (ay - (icos * dy)) + yd;
 669         for (x = 0; x < dst->w; x++) {
 670             dx = (short) (sdx >> 16);
 671             dy = (short) (sdy >> 16);
 672             if ((dx >= 0) && (dy >= 0) && (dx < src->w) && (dy < src->h)) {
 673                 sp = (tColorY *) (src->pixels);
 674                 sp += (src->pitch * dy + dx);
 675                 *pc = *sp;
 676             }
 677             sdx += icos;
 678             sdy += isin;
 679             pc++;
 680         }
 681         pc += gap;
 682     }
 683 }
 684
 685
 686 /*
 687
 688  32bit specialized 90degree rotator
 689
 690  Rotates and zooms 'src' surface to 'dst' surface in 90degree increments.
 691
 692  (contributed by Jeff Schiller)
 693
 694 */
 695 SDL_Surface* rotateSurface90Degrees(SDL_Surface* pSurf, int numClockwiseTurns)
 696 {
 697  int row, col, newWidth, newHeight;
 698  SDL_Surface* pSurfOut;
 699
 700
 701  if (!pSurf || pSurf->format->BitsPerPixel != 32) { return NULL; }
 702
 703
 704  while(numClockwiseTurns < 0) { numClockwiseTurns += 4; }
 705  numClockwiseTurns = (numClockwiseTurns % 4);
 706
 707
 708  newWidth = (numClockwiseTurns % 2) ? (pSurf->h) : (pSurf->w);
 709  newHeight = (numClockwiseTurns % 2) ? (pSurf->w) : (pSurf->h);
 710  pSurfOut = SDL_CreateRGBSurface( pSurf->flags, newWidth, newHeight, pSurf->format->BitsPerPixel,
 711                            pSurf->format->Rmask,
 712                            pSurf->format->Gmask,
 713                            pSurf->format->Bmask,
 714                            pSurf->format->Amask);
 715  if(!pSurfOut) {
 716    return NULL;
 717  }
 718
 719  if(numClockwiseTurns != 0) {
 720    SDL_LockSurface(pSurf);
 721    SDL_LockSurface(pSurfOut);
 722    switch(numClockwiseTurns) {
 723
 724      case 1:
 725      {
 726        Uint32* srcBuf = NULL;
 727        Uint32* dstBuf = NULL;
 728
 729        for (row = 0; row < pSurf->h; ++row) {
 730          srcBuf = (Uint32*)(pSurf->pixels) + (row*pSurf->pitch/4);
 731          dstBuf = (Uint32*)(pSurfOut->pixels) + (pSurfOut->w - row - 1);
 732          for (col = 0; col < pSurf->w; ++col) {
 733            *dstBuf = *srcBuf;
 734            ++srcBuf;
 735            dstBuf += pSurfOut->pitch/4;
 736          }
 737        }
 738      }
 739      break;
 740
 741      case 2:
 742      {
 743        Uint32* srcBuf = NULL;
 744        Uint32* dstBuf = NULL;
 745
 746        for(row = 0; row < pSurf->h; ++row) {
 747          srcBuf = (Uint32*)(pSurf->pixels) + (row*pSurf->pitch/4);
 748          dstBuf = (Uint32*)(pSurfOut->pixels) + ((pSurfOut->h - row - 1)*pSurfOut->pitch/4) + (pSurfOut->w - 1);
 749          for(col = 0; col < pSurf->w; ++col) {
 750            *dstBuf = *srcBuf;
 751            ++srcBuf;
 752            --dstBuf;
 753          }
 754        }
 755      }
 756      break;
 757
 758      case 3:
 759      {
 760        Uint32* srcBuf = NULL;
 761        Uint32* dstBuf = NULL;
 762
 763        for(row = 0; row < pSurf->h; ++row) {
 764          srcBuf = (Uint32*)(pSurf->pixels) + (row*pSurf->pitch/4);
 765          dstBuf = (Uint32*)(pSurfOut->pixels) + row + ((pSurfOut->h - 1)*pSurfOut->pitch/4);
 766          for(col = 0; col < pSurf->w; ++col) {
 767            *dstBuf = *srcBuf;
 768            ++srcBuf;
 769            dstBuf -= pSurfOut->pitch/4;
 770          }
 771        }
 772      }
 773      break;
 774    }
 775
 776    SDL_UnlockSurface(pSurf);
 777    SDL_UnlockSurface(pSurfOut);
 778  }
 779  else {
 780    /* simply copy surface to output */
 781    if(SDL_BlitSurface(pSurf, NULL, pSurfOut, NULL)) {
 782      return NULL;
 783    }
 784  }
 785  return pSurfOut;
 786 }
 787
 788 /*
 789
 790  rotozoomSurface()
 791
 792  Rotates and zoomes a 32bit or 8bit 'src' surface to newly created 'dst' surface.
 793  'angle' is the rotation in degrees. 'zoom' a scaling factor. If 'smooth' is 1
 794  then the destination 32bit surface is anti-aliased. If the surface is not 8bit
 795  or 32bit RGBA/ABGR it will be converted into a 32bit RGBA format on the fly.
 796
 797 */
 798
 799 #define VALUE_LIMIT     0.001
 800
 801
 802 /* Local rotozoom-size function with trig result return */
 803
 804 void rotozoomSurfaceSizeTrig(int width, int height, double angle, double zoomx, double zoomy, int *dstwidth, int *dstheight,
 805                              double *canglezoom, double *sanglezoom)
 806 {
 807     (void)zoomy;
 808
 809     double x, y, cx, cy, sx, sy;
 810     double radangle;
 811     int dstwidthhalf, dstheighthalf;
 812
 813     /*
 814      * Determine destination width and height by rotating a centered source box
 815      */
 816     radangle = angle * (M_PI / 180.0);
 817     *sanglezoom = sin(radangle);
 818     *canglezoom = cos(radangle);
 819     *sanglezoom *= zoomx;
 820     *canglezoom *= zoomx;
 821     x = width / 2;
 822     y = height / 2;
 823     cx = *canglezoom * x;
 824     cy = *canglezoom * y;
 825     sx = *sanglezoom * x;
 826     sy = *sanglezoom * y;
 827
 828     dstwidthhalf = MAX((int)
 829                        ceil(MAX(MAX(MAX(fabs(cx + sy), fabs(cx - sy)), fabs(-cx + sy)), fabs(-cx - sy))), 1);
 830     dstheighthalf = MAX((int)
 831                         ceil(MAX(MAX(MAX(fabs(sx + cy), fabs(sx - cy)), fabs(-sx + cy)), fabs(-sx - cy))), 1);
 832     *dstwidth = 2 * dstwidthhalf;
 833     *dstheight = 2 * dstheighthalf;
 834 }
 835
 836
 837 /* Publically available rotozoom-size function */
 838
 839 void rotozoomSurfaceSizeXY(int width, int height, double angle, double zoomx, double zoomy, int *dstwidth, int *dstheight)
 840 {
 841     double dummy_sanglezoom, dummy_canglezoom;
 842
 843     rotozoomSurfaceSizeTrig(width, height, angle, zoomx, zoomy, dstwidth, dstheight, &dummy_sanglezoom, &dummy_canglezoom);
 844 }
 845
 846 /* Publically available rotozoom-size function */
 847
 848 void rotozoomSurfaceSize(int width, int height, double angle, double zoom, int *dstwidth, int *dstheight)
 849 {
 850     double dummy_sanglezoom, dummy_canglezoom;
 851
 852     rotozoomSurfaceSizeTrig(width, height, angle, zoom, zoom, dstwidth, dstheight, &dummy_sanglezoom, &dummy_canglezoom);
 853 }
 854
 855 /* Publically available rotozoom function */
 856
 857 SDL_Surface *rotozoomSurface(SDL_Surface * src, double angle, double zoom, int smooth)
 858 {
 859   return rotozoomSurfaceXY(src, angle, zoom, zoom, smooth);
 860 }
 861
 862 /* Publically available rotozoom function */
 863
 864 SDL_Surface *rotozoomSurfaceXY(SDL_Surface * src, double angle, double zoomx, double zoomy, int smooth)
 865 {
 866     SDL_Surface *rz_src;
 867     SDL_Surface *rz_dst;
 868     double zoominv;
 869     double sanglezoom, canglezoom, sanglezoominv, canglezoominv;
 870     int dstwidthhalf, dstwidth, dstheighthalf, dstheight;
 871     int is32bit;
 872     int i, src_converted;
 873     int flipx,flipy;
 874     Uint8 r,g,b;
 875     Uint32 colorkey;
 876     int colorKeyAvailable = 0;
 877
 878     /*
 879      * Sanity check
 880      */
 881     if (src == NULL)
 882         return (NULL);
 883
 884     if( src->flags & SDL_SRCCOLORKEY )
 885     {
 886         colorkey = src->format->colorkey;
 887         SDL_GetRGB(colorkey, src->format, &r, &g, &b);
 888         colorKeyAvailable = 1;
 889     }
 890     /*
 891      * Determine if source surface is 32bit or 8bit
 892      */
 893     is32bit = (src->format->BitsPerPixel == 32);
 894     if ((is32bit) || (src->format->BitsPerPixel == 8)) {
 895         /*
 896          * Use source surface 'as is'
 897          */
 898         rz_src = src;
 899         src_converted = 0;
 900     } else {
 901         /*
 902          * New source surface is 32bit with a defined RGBA ordering
 903          */
 904         rz_src =
 905             SDL_CreateRGBSurface(SDL_SWSURFACE, src->w, src->h, 32,
 906 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
 907                                 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000
 908 #else
 909                                 0xff000000,  0x00ff0000, 0x0000ff00, 0x000000ff
 910 #endif
 911             );
 912                 if(colorKeyAvailable)
 913                         SDL_SetColorKey(src, 0, 0);
 914
 915         SDL_BlitSurface(src, NULL, rz_src, NULL);
 916
 917                 if(colorKeyAvailable)
 918                         SDL_SetColorKey(src, SDL_SRCCOLORKEY, colorkey);
 919         src_converted = 1;
 920         is32bit = 1;
 921     }
 922
 923     /*
 924      * Sanity check zoom factor
 925      */
 926     flipx = (zoomx<0);
 927     if (flipx) zoomx=-zoomx;
 928     flipy = (zoomy<0);
 929     if (flipy) zoomy=-zoomy;
 930     if (zoomx < VALUE_LIMIT) zoomx = VALUE_LIMIT;
 931     if (zoomy < VALUE_LIMIT) zoomy = VALUE_LIMIT;
 932     zoominv = 65536.0 / (zoomx * zoomx);
 933
 934     /*
 935      * Check if we have a rotozoom or just a zoom
 936      */
 937     if (fabs(angle) > VALUE_LIMIT) {
 938
 939         /*
 940          * Angle!=0: full rotozoom
 941          */
 942         /*
 943          * -----------------------
 944          */
 945
 946         /* Determine target size */
 947         rotozoomSurfaceSizeTrig(rz_src->w, rz_src->h, angle, zoomx, zoomy, &dstwidth, &dstheight, &canglezoom, &sanglezoom);
 948
 949         /*
 950          * Calculate target factors from sin/cos and zoom
 951          */
 952         sanglezoominv = sanglezoom;
 953         canglezoominv = canglezoom;
 954         sanglezoominv *= zoominv;
 955         canglezoominv *= zoominv;
 956
 957         /* Calculate half size */
 958         dstwidthhalf = dstwidth / 2;
 959         dstheighthalf = dstheight / 2;
 960
 961         /*
 962          * Alloc space to completely contain the rotated surface
 963          */
 964         rz_dst = NULL;
 965         if (is32bit) {
 966             /*
 967              * Target surface is 32bit with source RGBA/ABGR ordering
 968              */
 969             rz_dst =
 970                 SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight, 32,
 971                                      rz_src->format->Rmask, rz_src->format->Gmask,
 972                                      rz_src->format->Bmask, rz_src->format->Amask);
 973         } else {
 974             /*
 975              * Target surface is 8bit
 976              */
 977             rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight, 8, 0, 0, 0, 0);
 978         }
 979
 980         if (colorKeyAvailable == 1){
 981                 colorkey = SDL_MapRGB(rz_dst->format, r, g, b);
 982
 983                 SDL_FillRect(rz_dst, NULL, colorkey );
 984         }
 985
 986         /*
 987          * Lock source surface
 988          */
 989         SDL_LockSurface(rz_src);
 990         /*
 991          * Check which kind of surface we have
 992          */
 993         if (is32bit) {
 994             /*
 995              * Call the 32bit transformation routine to do the rotation (using alpha)
 996              */
 997             transformSurfaceRGBA(rz_src, rz_dst, dstwidthhalf, dstheighthalf,
 998                                  (int) (sanglezoominv), (int) (canglezoominv),
 999                                  flipx, flipy,
1000                                  smooth);
1001             /*
1002              * Turn on source-alpha support
1003              */
1004             SDL_SetAlpha(rz_dst, SDL_SRCALPHA, 255);
1005         } else {
1006             /*
1007              * Copy palette and colorkey info
1008              */
1009             for (i = 0; i < rz_src->format->palette->ncolors; i++) {
1010                 rz_dst->format->palette->colors[i] = rz_src->format->palette->colors[i];
1011             }
1012             rz_dst->format->palette->ncolors = rz_src->format->palette->ncolors;
1013             /*
1014              * Call the 8bit transformation routine to do the rotation
1015              */
1016             transformSurfaceY(rz_src, rz_dst, dstwidthhalf, dstheighthalf,
1017                               (int) (sanglezoominv), (int) (canglezoominv));
1018             SDL_SetColorKey(rz_dst, SDL_SRCCOLORKEY | SDL_RLEACCEL, rz_src->format->colorkey);
1019         }
1020         /*
1021          * Unlock source surface
1022          */
1023         SDL_UnlockSurface(rz_src);
1024
1025     } else {
1026
1027         /*
1028          * Angle=0: Just a zoom
1029          */
1030         /*
1031          * --------------------
1032          */
1033
1034         /*
1035          * Calculate target size
1036          */
1037         zoomSurfaceSize(rz_src->w, rz_src->h, zoomx, zoomy, &dstwidth, &dstheight);
1038
1039         /*
1040          * Alloc space to completely contain the zoomed surface
1041          */
1042         rz_dst = NULL;
1043         if (is32bit) {
1044             /*
1045              * Target surface is 32bit with source RGBA/ABGR ordering
1046              */
1047             rz_dst =
1048                 SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight, 32,
1049                                      rz_src->format->Rmask, rz_src->format->Gmask,
1050                                      rz_src->format->Bmask, rz_src->format->Amask);
1051         } else {
1052             /*
1053              * Target surface is 8bit
1054              */
1055             rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight, 8, 0, 0, 0, 0);
1056         }
1057
1058         if (colorKeyAvailable == 1){
1059                 colorkey = SDL_MapRGB(rz_dst->format, r, g, b);
1060
1061                 SDL_FillRect(rz_dst, NULL, colorkey );
1062         }
1063
1064         /*
1065          * Lock source surface
1066          */
1067         SDL_LockSurface(rz_src);
1068         /*
1069          * Check which kind of surface we have
1070          */
1071         if (is32bit) {
1072             /*
1073              * Call the 32bit transformation routine to do the zooming (using alpha)
1074              */
1075             zoomSurfaceRGBA(rz_src, rz_dst, flipx, flipy, smooth);
1076             /*
1077              * Turn on source-alpha support
1078              */
1079             SDL_SetAlpha(rz_dst, SDL_SRCALPHA, 255);
1080         } else {
1081             /*
1082              * Copy palette and colorkey info
1083              */
1084             for (i = 0; i < rz_src->format->palette->ncolors; i++) {
1085                 rz_dst->format->palette->colors[i] = rz_src->format->palette->colors[i];
1086             }
1087             rz_dst->format->palette->ncolors = rz_src->format->palette->ncolors;
1088             /*
1089              * Call the 8bit transformation routine to do the zooming
1090              */
1091             zoomSurfaceY(rz_src, rz_dst, flipx, flipy);
1092             SDL_SetColorKey(rz_dst, SDL_SRCCOLORKEY | SDL_RLEACCEL, rz_src->format->colorkey);
1093         }
1094         /*
1095          * Unlock source surface
1096          */
1097         SDL_UnlockSurface(rz_src);
1098     }
1099
1100     /*
1101      * Cleanup temp surface
1102      */
1103     if (src_converted) {
1104         SDL_FreeSurface(rz_src);
1105     }
1106
1107     /*
1108      * Return destination surface
1109      */
1110     return (rz_dst);
1111 }
1112
1113 /*
1114
1115  zoomSurface()
1116
1117  Zoomes a 32bit or 8bit 'src' surface to newly created 'dst' surface.
1118  'zoomx' and 'zoomy' are scaling factors for width and height. If 'smooth' is 1
1119  then the destination 32bit surface is anti-aliased. If the surface is not 8bit
1120  or 32bit RGBA/ABGR it will be converted into a 32bit RGBA format on the fly.
1121
1122 */
1123
1124 #define VALUE_LIMIT     0.001
1125
1126 void zoomSurfaceSize(int width, int height, double zoomx, double zoomy, int *dstwidth, int *dstheight)
1127 {
1128     /*
1129      * Sanity check zoom factors
1130      */
1131     if (zoomx < VALUE_LIMIT) {
1132         zoomx = VALUE_LIMIT;
1133     }
1134     if (zoomy < VALUE_LIMIT) {
1135         zoomy = VALUE_LIMIT;
1136     }
1137
1138     /*
1139      * Calculate target size
1140      */
1141     *dstwidth = (int) ((double) width * zoomx);
1142     *dstheight = (int) ((double) height * zoomy);
1143     if (*dstwidth < 1) {
1144         *dstwidth = 1;
1145     }
1146     if (*dstheight < 1) {
1147         *dstheight = 1;
1148     }
1149 }
1150
1151 SDL_Surface *zoomSurface(SDL_Surface * src, double zoomx, double zoomy, int smooth)
1152 {
1153     SDL_Surface *rz_src;
1154     SDL_Surface *rz_dst;
1155     int dstwidth, dstheight;
1156     int is32bit;
1157     int i, src_converted;
1158     int flipx, flipy;
1159
1160     /*
1161      * Sanity check
1162      */
1163     if (src == NULL)
1164         return (NULL);
1165
1166     /*
1167      * Determine if source surface is 32bit or 8bit
1168      */
1169     is32bit = (src->format->BitsPerPixel == 32);
1170     if ((is32bit) || (src->format->BitsPerPixel == 8)) {
1171         /*
1172          * Use source surface 'as is'
1173          */
1174         rz_src = src;
1175         src_converted = 0;
1176     } else {
1177         /*
1178          * New source surface is 32bit with a defined RGBA ordering
1179          */
1180         rz_src =
1181             SDL_CreateRGBSurface(SDL_SWSURFACE, src->w, src->h, 32,
1182 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
1183                                 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000
1184 #else
1185                                 0xff000000,  0x00ff0000, 0x0000ff00, 0x000000ff
1186 #endif
1187             );
1188         SDL_BlitSurface(src, NULL, rz_src, NULL);
1189         src_converted = 1;
1190         is32bit = 1;
1191     }
1192
1193     flipx = (zoomx<0);
1194     if (flipx) zoomx = -zoomx;
1195     flipy = (zoomy<0);
1196     if (flipy) zoomy = -zoomy;
1197
1198     /* Get size if target */
1199     zoomSurfaceSize(rz_src->w, rz_src->h, zoomx, zoomy, &dstwidth, &dstheight);
1200
1201     /*
1202      * Alloc space to completely contain the zoomed surface
1203      */
1204     rz_dst = NULL;
1205     if (is32bit) {
1206         /*
1207          * Target surface is 32bit with source RGBA/ABGR ordering
1208          */
1209         rz_dst =
1210             SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight, 32,
1211                                  rz_src->format->Rmask, rz_src->format->Gmask,
1212                                  rz_src->format->Bmask, rz_src->format->Amask);
1213     } else {
1214         /*
1215          * Target surface is 8bit
1216          */
1217         rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight, 8, 0, 0, 0, 0);
1218     }
1219
1220     /*
1221      * Lock source surface
1222      */
1223     SDL_LockSurface(rz_src);
1224     /*
1225      * Check which kind of surface we have
1226      */
1227     if (is32bit) {
1228         /*
1229          * Call the 32bit transformation routine to do the zooming (using alpha)
1230          */
1231         zoomSurfaceRGBA(rz_src, rz_dst, flipx, flipy, smooth);
1232         /*
1233          * Turn on source-alpha support
1234          */
1235         SDL_SetAlpha(rz_dst, SDL_SRCALPHA, 255);
1236     } else {
1237         /*
1238          * Copy palette and colorkey info
1239          */
1240         for (i = 0; i < rz_src->format->palette->ncolors; i++) {
1241             rz_dst->format->palette->colors[i] = rz_src->format->palette->colors[i];
1242         }
1243         rz_dst->format->palette->ncolors = rz_src->format->palette->ncolors;
1244         /*
1245          * Call the 8bit transformation routine to do the zooming
1246          */
1247         zoomSurfaceY(rz_src, rz_dst, flipx, flipy);
1248         SDL_SetColorKey(rz_dst, SDL_SRCCOLORKEY | SDL_RLEACCEL, rz_src->format->colorkey);
1249     }
1250     /*
1251      * Unlock source surface
1252      */
1253     SDL_UnlockSurface(rz_src);
1254
1255     /*
1256      * Cleanup temp surface
1257      */
1258     if (src_converted) {
1259         SDL_FreeSurface(rz_src);
1260     }
1261
1262     /*
1263      * Return destination surface
1264      */
1265     return (rz_dst);
1266 }
1267
1268 SDL_Surface *shrinkSurface(SDL_Surface * src, int factorx, int factory)
1269 {
1270     SDL_Surface *rz_src;
1271     SDL_Surface *rz_dst;
1272     int dstwidth, dstheight;
1273     int is32bit;
1274     int i, src_converted;
1275
1276     /*
1277      * Sanity check
1278      */
1279     if (src == NULL)
1280         return (NULL);
1281
1282     /*
1283      * Determine if source surface is 32bit or 8bit
1284      */
1285     is32bit = (src->format->BitsPerPixel == 32);
1286     if ((is32bit) || (src->format->BitsPerPixel == 8)) {
1287         /*
1288          * Use source surface 'as is'
1289          */
1290         rz_src = src;
1291         src_converted = 0;
1292     } else {
1293         /*
1294          * New source surface is 32bit with a defined RGBA ordering
1295          */
1296         rz_src =
1297             SDL_CreateRGBSurface(SDL_SWSURFACE, src->w, src->h, 32,
1298 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
1299                                 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000
1300 #else
1301                                 0xff000000,  0x00ff0000, 0x0000ff00, 0x000000ff
1302 #endif
1303             );
1304         SDL_BlitSurface(src, NULL, rz_src, NULL);
1305         src_converted = 1;
1306         is32bit = 1;
1307     }
1308
1309     /* Get size for target */
1310     dstwidth=rz_src->w/factorx;
1311     while (dstwidth*factorx>rz_src->w) { dstwidth--; }
1312     dstheight=rz_src->h/factory;
1313     while (dstheight*factory>rz_src->h) { dstheight--; }
1314
1315     /*
1316      * Alloc space to completely contain the shrunken surface
1317      */
1318     rz_dst = NULL;
1319     if (is32bit) {
1320         /*
1321          * Target surface is 32bit with source RGBA/ABGR ordering
1322          */
1323         rz_dst =
1324             SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight, 32,
1325                                  rz_src->format->Rmask, rz_src->format->Gmask,
1326                                  rz_src->format->Bmask, rz_src->format->Amask);
1327     } else {
1328         /*
1329          * Target surface is 8bit
1330          */
1331         rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight, 8, 0, 0, 0, 0);
1332     }
1333
1334     /*
1335      * Lock source surface
1336      */
1337     SDL_LockSurface(rz_src);
1338     /*
1339      * Check which kind of surface we have
1340      */
1341     if (is32bit) {
1342         /*
1343          * Call the 32bit transformation routine to do the shrinking (using alpha)
1344          */
1345         shrinkSurfaceRGBA(rz_src, rz_dst, factorx, factory);
1346         /*
1347          * Turn on source-alpha support
1348          */
1349         SDL_SetAlpha(rz_dst, SDL_SRCALPHA, 255);
1350     } else {
1351         /*
1352          * Copy palette and colorkey info
1353          */
1354         for (i = 0; i < rz_src->format->palette->ncolors; i++) {
1355             rz_dst->format->palette->colors[i] = rz_src->format->palette->colors[i];
1356         }
1357         rz_dst->format->palette->ncolors = rz_src->format->palette->ncolors;
1358         /*
1359          * Call the 8bit transformation routine to do the shrinking
1360          */
1361         shrinkSurfaceY(rz_src, rz_dst, factorx, factory);
1362         SDL_SetColorKey(rz_dst, SDL_SRCCOLORKEY | SDL_RLEACCEL, rz_src->format->colorkey);
1363     }
1364     /*
1365      * Unlock source surface
1366      */
1367     SDL_UnlockSurface(rz_src);
1368
1369     /*
1370      * Cleanup temp surface
1371      */
1372     if (src_converted) {
1373         SDL_FreeSurface(rz_src);
1374     }
1375
1376     /*
1377      * Return destination surface
1378      */
1379     return (rz_dst);
1380 }