|
SDL_gfx
2.0.25
|
00001 /* 00002 00003 SDL_rotozoom.c: rotozoomer, zoomer and shrinker for 32bit or 8bit surfaces 00004 00005 Copyright (C) 2001-2012 Andreas Schiffler 00006 00007 This software is provided 'as-is', without any express or implied 00008 warranty. In no event will the authors be held liable for any damages 00009 arising from the use of this software. 00010 00011 Permission is granted to anyone to use this software for any purpose, 00012 including commercial applications, and to alter it and redistribute it 00013 freely, subject to the following restrictions: 00014 00015 1. The origin of this software must not be misrepresented; you must not 00016 claim that you wrote the original software. If you use this software 00017 in a product, an acknowledgment in the product documentation would be 00018 appreciated but is not required. 00019 00020 2. Altered source versions must be plainly marked as such, and must not be 00021 misrepresented as being the original software. 00022 00023 3. This notice may not be removed or altered from any source 00024 distribution. 00025 00026 Andreas Schiffler -- aschiffler at ferzkopp dot net 00027 00028 */ 00029 00030 #ifdef WIN32 00031 #include <windows.h> 00032 #endif 00033 00034 #include <stdlib.h> 00035 #include <string.h> 00036 00037 #include "SDL_rotozoom.h" 00038 00039 /* ---- Internally used structures */ 00040 00044 typedef struct tColorRGBA { 00045 Uint8 r; 00046 Uint8 g; 00047 Uint8 b; 00048 Uint8 a; 00049 } tColorRGBA; 00050 00054 typedef struct tColorY { 00055 Uint8 y; 00056 } tColorY; 00057 00061 #define MAX(a,b) (((a) > (b)) ? (a) : (b)) 00062 00073 #define GUARD_ROWS (2) 00074 00078 #define VALUE_LIMIT 0.001 00079 00083 Uint32 _colorkey(SDL_Surface *src) 00084 { 00085 Uint32 key = 0; 00086 #if (SDL_MINOR_VERSION == 3) 00087 SDL_GetColorKey(src, &key); 00088 #else 00089 if (src) 00090 { 00091 key = src->format->colorkey; 00092 } 00093 #endif 00094 return key; 00095 } 00096 00097 00113 int _shrinkSurfaceRGBA(SDL_Surface * src, SDL_Surface * dst, int factorx, int factory) 00114 { 00115 int x, y, dx, dy, sgap, dgap, ra, ga, ba, aa; 00116 int n_average; 00117 tColorRGBA *sp, *osp, *oosp; 00118 tColorRGBA *dp; 00119 00120 /* 00121 * Averaging integer shrink 00122 */ 00123 00124 /* Precalculate division factor */ 00125 n_average = factorx*factory; 00126 00127 /* 00128 * Scan destination 00129 */ 00130 sp = (tColorRGBA *) src->pixels; 00131 sgap = src->pitch - src->w * 4; 00132 00133 dp = (tColorRGBA *) dst->pixels; 00134 dgap = dst->pitch - dst->w * 4; 00135 00136 for (y = 0; y < dst->h; y++) { 00137 00138 osp=sp; 00139 for (x = 0; x < dst->w; x++) { 00140 00141 /* Trace out source box and accumulate */ 00142 oosp=sp; 00143 ra=ga=ba=aa=0; 00144 for (dy=0; dy < factory; dy++) { 00145 for (dx=0; dx < factorx; dx++) { 00146 ra += sp->r; 00147 ga += sp->g; 00148 ba += sp->b; 00149 aa += sp->a; 00150 00151 sp++; 00152 } 00153 /* src dx loop */ 00154 sp = (tColorRGBA *)((Uint8*)sp + (src->pitch - 4*factorx)); // next y 00155 } 00156 /* src dy loop */ 00157 00158 /* next box-x */ 00159 sp = (tColorRGBA *)((Uint8*)oosp + 4*factorx); 00160 00161 /* Store result in destination */ 00162 dp->r = ra/n_average; 00163 dp->g = ga/n_average; 00164 dp->b = ba/n_average; 00165 dp->a = aa/n_average; 00166 00167 /* 00168 * Advance destination pointer 00169 */ 00170 dp++; 00171 } 00172 /* dst x loop */ 00173 00174 /* next box-y */ 00175 sp = (tColorRGBA *)((Uint8*)osp + src->pitch*factory); 00176 00177 /* 00178 * Advance destination pointers 00179 */ 00180 dp = (tColorRGBA *) ((Uint8 *) dp + dgap); 00181 } 00182 /* dst y loop */ 00183 00184 return (0); 00185 } 00186 00202 int _shrinkSurfaceY(SDL_Surface * src, SDL_Surface * dst, int factorx, int factory) 00203 { 00204 int x, y, dx, dy, sgap, dgap, a; 00205 int n_average; 00206 Uint8 *sp, *osp, *oosp; 00207 Uint8 *dp; 00208 00209 /* 00210 * Averaging integer shrink 00211 */ 00212 00213 /* Precalculate division factor */ 00214 n_average = factorx*factory; 00215 00216 /* 00217 * Scan destination 00218 */ 00219 sp = (Uint8 *) src->pixels; 00220 sgap = src->pitch - src->w; 00221 00222 dp = (Uint8 *) dst->pixels; 00223 dgap = dst->pitch - dst->w; 00224 00225 for (y = 0; y < dst->h; y++) { 00226 00227 osp=sp; 00228 for (x = 0; x < dst->w; x++) { 00229 00230 /* Trace out source box and accumulate */ 00231 oosp=sp; 00232 a=0; 00233 for (dy=0; dy < factory; dy++) { 00234 for (dx=0; dx < factorx; dx++) { 00235 a += (*sp); 00236 /* next x */ 00237 sp++; 00238 } 00239 /* end src dx loop */ 00240 /* next y */ 00241 sp = (Uint8 *)((Uint8*)sp + (src->pitch - factorx)); 00242 } 00243 /* end src dy loop */ 00244 00245 /* next box-x */ 00246 sp = (Uint8 *)((Uint8*)oosp + factorx); 00247 00248 /* Store result in destination */ 00249 *dp = a/n_average; 00250 00251 /* 00252 * Advance destination pointer 00253 */ 00254 dp++; 00255 } 00256 /* end dst x loop */ 00257 00258 /* next box-y */ 00259 sp = (Uint8 *)((Uint8*)osp + src->pitch*factory); 00260 00261 /* 00262 * Advance destination pointers 00263 */ 00264 dp = (Uint8 *)((Uint8 *)dp + dgap); 00265 } 00266 /* end dst y loop */ 00267 00268 return (0); 00269 } 00270 00286 int _zoomSurfaceRGBA(SDL_Surface * src, SDL_Surface * dst, int flipx, int flipy, int smooth) 00287 { 00288 int x, y, sx, sy, ssx, ssy, *sax, *say, *csax, *csay, *salast, csx, csy, ex, ey, cx, cy, sstep, sstepx, sstepy; 00289 tColorRGBA *c00, *c01, *c10, *c11; 00290 tColorRGBA *sp, *csp, *dp; 00291 int spixelgap, spixelw, spixelh, dgap, t1, t2; 00292 00293 /* 00294 * Allocate memory for row/column increments 00295 */ 00296 if ((sax = (int *) malloc((dst->w + 1) * sizeof(Uint32))) == NULL) { 00297 return (-1); 00298 } 00299 if ((say = (int *) malloc((dst->h + 1) * sizeof(Uint32))) == NULL) { 00300 free(sax); 00301 return (-1); 00302 } 00303 00304 /* 00305 * Precalculate row increments 00306 */ 00307 spixelw = (src->w - 1); 00308 spixelh = (src->h - 1); 00309 if (smooth) { 00310 sx = (int) (65536.0 * (float) spixelw / (float) (dst->w - 1)); 00311 sy = (int) (65536.0 * (float) spixelh / (float) (dst->h - 1)); 00312 } else { 00313 sx = (int) (65536.0 * (float) (src->w) / (float) (dst->w)); 00314 sy = (int) (65536.0 * (float) (src->h) / (float) (dst->h)); 00315 } 00316 00317 /* Maximum scaled source size */ 00318 ssx = (src->w << 16) - 1; 00319 ssy = (src->h << 16) - 1; 00320 00321 /* Precalculate horizontal row increments */ 00322 csx = 0; 00323 csax = sax; 00324 for (x = 0; x <= dst->w; x++) { 00325 *csax = csx; 00326 csax++; 00327 csx += sx; 00328 00329 /* Guard from overflows */ 00330 if (csx > ssx) { 00331 csx = ssx; 00332 } 00333 } 00334 00335 /* Precalculate vertical row increments */ 00336 csy = 0; 00337 csay = say; 00338 for (y = 0; y <= dst->h; y++) { 00339 *csay = csy; 00340 csay++; 00341 csy += sy; 00342 00343 /* Guard from overflows */ 00344 if (csy > ssy) { 00345 csy = ssy; 00346 } 00347 } 00348 00349 sp = (tColorRGBA *) src->pixels; 00350 dp = (tColorRGBA *) dst->pixels; 00351 dgap = dst->pitch - dst->w * 4; 00352 spixelgap = src->pitch/4; 00353 00354 if (flipx) sp += spixelw; 00355 if (flipy) sp += (spixelgap * spixelh); 00356 00357 /* 00358 * Switch between interpolating and non-interpolating code 00359 */ 00360 if (smooth) { 00361 00362 /* 00363 * Interpolating Zoom 00364 */ 00365 csay = say; 00366 for (y = 0; y < dst->h; y++) { 00367 csp = sp; 00368 csax = sax; 00369 for (x = 0; x < dst->w; x++) { 00370 /* 00371 * Setup color source pointers 00372 */ 00373 ex = (*csax & 0xffff); 00374 ey = (*csay & 0xffff); 00375 cx = (*csax >> 16); 00376 cy = (*csay >> 16); 00377 sstepx = cx < spixelw; 00378 sstepy = cy < spixelh; 00379 c00 = sp; 00380 c01 = sp; 00381 c10 = sp; 00382 if (sstepy) { 00383 if (flipy) { 00384 c10 -= spixelgap; 00385 } else { 00386 c10 += spixelgap; 00387 } 00388 } 00389 c11 = c10; 00390 if (sstepx) { 00391 if (flipx) { 00392 c01--; 00393 c11--; 00394 } else { 00395 c01++; 00396 c11++; 00397 } 00398 } 00399 00400 /* 00401 * Draw and interpolate colors 00402 */ 00403 t1 = ((((c01->r - c00->r) * ex) >> 16) + c00->r) & 0xff; 00404 t2 = ((((c11->r - c10->r) * ex) >> 16) + c10->r) & 0xff; 00405 dp->r = (((t2 - t1) * ey) >> 16) + t1; 00406 t1 = ((((c01->g - c00->g) * ex) >> 16) + c00->g) & 0xff; 00407 t2 = ((((c11->g - c10->g) * ex) >> 16) + c10->g) & 0xff; 00408 dp->g = (((t2 - t1) * ey) >> 16) + t1; 00409 t1 = ((((c01->b - c00->b) * ex) >> 16) + c00->b) & 0xff; 00410 t2 = ((((c11->b - c10->b) * ex) >> 16) + c10->b) & 0xff; 00411 dp->b = (((t2 - t1) * ey) >> 16) + t1; 00412 t1 = ((((c01->a - c00->a) * ex) >> 16) + c00->a) & 0xff; 00413 t2 = ((((c11->a - c10->a) * ex) >> 16) + c10->a) & 0xff; 00414 dp->a = (((t2 - t1) * ey) >> 16) + t1; 00415 /* 00416 * Advance source pointer x 00417 */ 00418 salast = csax; 00419 csax++; 00420 sstep = (*csax >> 16) - (*salast >> 16); 00421 if (flipx) { 00422 sp -= sstep; 00423 } else { 00424 sp += sstep; 00425 } 00426 00427 /* 00428 * Advance destination pointer x 00429 */ 00430 dp++; 00431 } 00432 /* 00433 * Advance source pointer y 00434 */ 00435 salast = csay; 00436 csay++; 00437 sstep = (*csay >> 16) - (*salast >> 16); 00438 sstep *= spixelgap; 00439 if (flipy) { 00440 sp = csp - sstep; 00441 } else { 00442 sp = csp + sstep; 00443 } 00444 00445 /* 00446 * Advance destination pointer y 00447 */ 00448 dp = (tColorRGBA *) ((Uint8 *) dp + dgap); 00449 } 00450 } else { 00451 /* 00452 * Non-Interpolating Zoom 00453 */ 00454 csay = say; 00455 for (y = 0; y < dst->h; y++) { 00456 csp = sp; 00457 csax = sax; 00458 for (x = 0; x < dst->w; x++) { 00459 /* 00460 * Draw 00461 */ 00462 *dp = *sp; 00463 00464 /* 00465 * Advance source pointer x 00466 */ 00467 salast = csax; 00468 csax++; 00469 sstep = (*csax >> 16) - (*salast >> 16); 00470 if (flipx) sstep = -sstep; 00471 sp += sstep; 00472 00473 /* 00474 * Advance destination pointer x 00475 */ 00476 dp++; 00477 } 00478 /* 00479 * Advance source pointer y 00480 */ 00481 salast = csay; 00482 csay++; 00483 sstep = (*csay >> 16) - (*salast >> 16); 00484 sstep *= spixelgap; 00485 if (flipy) sstep = -sstep; 00486 sp = csp + sstep; 00487 00488 /* 00489 * Advance destination pointer y 00490 */ 00491 dp = (tColorRGBA *) ((Uint8 *) dp + dgap); 00492 } 00493 } 00494 00495 /* 00496 * Remove temp arrays 00497 */ 00498 free(sax); 00499 free(say); 00500 00501 return (0); 00502 } 00503 00519 int _zoomSurfaceY(SDL_Surface * src, SDL_Surface * dst, int flipx, int flipy) 00520 { 00521 int x, y; 00522 Uint32 *sax, *say, *csax, *csay; 00523 int csx, csy; 00524 Uint8 *sp, *dp, *csp; 00525 int dgap; 00526 00527 /* 00528 * Allocate memory for row increments 00529 */ 00530 if ((sax = (Uint32 *) malloc((dst->w + 1) * sizeof(Uint32))) == NULL) { 00531 return (-1); 00532 } 00533 if ((say = (Uint32 *) malloc((dst->h + 1) * sizeof(Uint32))) == NULL) { 00534 free(sax); 00535 return (-1); 00536 } 00537 00538 /* 00539 * Pointer setup 00540 */ 00541 sp = csp = (Uint8 *) src->pixels; 00542 dp = (Uint8 *) dst->pixels; 00543 dgap = dst->pitch - dst->w; 00544 00545 if (flipx) csp += (src->w-1); 00546 if (flipy) csp = ( (Uint8*)csp + src->pitch*(src->h-1) ); 00547 00548 /* 00549 * Precalculate row increments 00550 */ 00551 csx = 0; 00552 csax = sax; 00553 for (x = 0; x < dst->w; x++) { 00554 csx += src->w; 00555 *csax = 0; 00556 while (csx >= dst->w) { 00557 csx -= dst->w; 00558 (*csax)++; 00559 } 00560 (*csax) = (*csax) * (flipx ? -1 : 1); 00561 csax++; 00562 } 00563 csy = 0; 00564 csay = say; 00565 for (y = 0; y < dst->h; y++) { 00566 csy += src->h; 00567 *csay = 0; 00568 while (csy >= dst->h) { 00569 csy -= dst->h; 00570 (*csay)++; 00571 } 00572 (*csay) = (*csay) * (flipy ? -1 : 1); 00573 csay++; 00574 } 00575 00576 /* 00577 * Draw 00578 */ 00579 csay = say; 00580 for (y = 0; y < dst->h; y++) { 00581 csax = sax; 00582 sp = csp; 00583 for (x = 0; x < dst->w; x++) { 00584 /* 00585 * Draw 00586 */ 00587 *dp = *sp; 00588 /* 00589 * Advance source pointers 00590 */ 00591 sp += (*csax); 00592 csax++; 00593 /* 00594 * Advance destination pointer 00595 */ 00596 dp++; 00597 } 00598 /* 00599 * Advance source pointer (for row) 00600 */ 00601 csp += ((*csay) * src->pitch); 00602 csay++; 00603 00604 /* 00605 * Advance destination pointers 00606 */ 00607 dp += dgap; 00608 } 00609 00610 /* 00611 * Remove temp arrays 00612 */ 00613 free(sax); 00614 free(say); 00615 00616 return (0); 00617 } 00618 00638 void _transformSurfaceRGBA(SDL_Surface * src, SDL_Surface * dst, int cx, int cy, int isin, int icos, int flipx, int flipy, int smooth) 00639 { 00640 int x, y, t1, t2, dx, dy, xd, yd, sdx, sdy, ax, ay, ex, ey, sw, sh; 00641 tColorRGBA c00, c01, c10, c11, cswap; 00642 tColorRGBA *pc, *sp; 00643 int gap; 00644 00645 /* 00646 * Variable setup 00647 */ 00648 xd = ((src->w - dst->w) << 15); 00649 yd = ((src->h - dst->h) << 15); 00650 ax = (cx << 16) - (icos * cx); 00651 ay = (cy << 16) - (isin * cx); 00652 sw = src->w - 1; 00653 sh = src->h - 1; 00654 pc = (tColorRGBA*) dst->pixels; 00655 gap = dst->pitch - dst->w * 4; 00656 00657 /* 00658 * Switch between interpolating and non-interpolating code 00659 */ 00660 if (smooth) { 00661 for (y = 0; y < dst->h; y++) { 00662 dy = cy - y; 00663 sdx = (ax + (isin * dy)) + xd; 00664 sdy = (ay - (icos * dy)) + yd; 00665 for (x = 0; x < dst->w; x++) { 00666 dx = (sdx >> 16); 00667 dy = (sdy >> 16); 00668 if (flipx) dx = sw - dx; 00669 if (flipy) dy = sh - dy; 00670 if ((dx > -1) && (dy > -1) && (dx < (src->w-1)) && (dy < (src->h-1))) { 00671 sp = (tColorRGBA *)src->pixels;; 00672 sp += ((src->pitch/4) * dy); 00673 sp += dx; 00674 c00 = *sp; 00675 sp += 1; 00676 c01 = *sp; 00677 sp += (src->pitch/4); 00678 c11 = *sp; 00679 sp -= 1; 00680 c10 = *sp; 00681 if (flipx) { 00682 cswap = c00; c00=c01; c01=cswap; 00683 cswap = c10; c10=c11; c11=cswap; 00684 } 00685 if (flipy) { 00686 cswap = c00; c00=c10; c10=cswap; 00687 cswap = c01; c01=c11; c11=cswap; 00688 } 00689 /* 00690 * Interpolate colors 00691 */ 00692 ex = (sdx & 0xffff); 00693 ey = (sdy & 0xffff); 00694 t1 = ((((c01.r - c00.r) * ex) >> 16) + c00.r) & 0xff; 00695 t2 = ((((c11.r - c10.r) * ex) >> 16) + c10.r) & 0xff; 00696 pc->r = (((t2 - t1) * ey) >> 16) + t1; 00697 t1 = ((((c01.g - c00.g) * ex) >> 16) + c00.g) & 0xff; 00698 t2 = ((((c11.g - c10.g) * ex) >> 16) + c10.g) & 0xff; 00699 pc->g = (((t2 - t1) * ey) >> 16) + t1; 00700 t1 = ((((c01.b - c00.b) * ex) >> 16) + c00.b) & 0xff; 00701 t2 = ((((c11.b - c10.b) * ex) >> 16) + c10.b) & 0xff; 00702 pc->b = (((t2 - t1) * ey) >> 16) + t1; 00703 t1 = ((((c01.a - c00.a) * ex) >> 16) + c00.a) & 0xff; 00704 t2 = ((((c11.a - c10.a) * ex) >> 16) + c10.a) & 0xff; 00705 pc->a = (((t2 - t1) * ey) >> 16) + t1; 00706 } 00707 sdx += icos; 00708 sdy += isin; 00709 pc++; 00710 } 00711 pc = (tColorRGBA *) ((Uint8 *) pc + gap); 00712 } 00713 } else { 00714 for (y = 0; y < dst->h; y++) { 00715 dy = cy - y; 00716 sdx = (ax + (isin * dy)) + xd; 00717 sdy = (ay - (icos * dy)) + yd; 00718 for (x = 0; x < dst->w; x++) { 00719 dx = (short) (sdx >> 16); 00720 dy = (short) (sdy >> 16); 00721 if (flipx) dx = (src->w-1)-dx; 00722 if (flipy) dy = (src->h-1)-dy; 00723 if ((dx >= 0) && (dy >= 0) && (dx < src->w) && (dy < src->h)) { 00724 sp = (tColorRGBA *) ((Uint8 *) src->pixels + src->pitch * dy); 00725 sp += dx; 00726 *pc = *sp; 00727 } 00728 sdx += icos; 00729 sdy += isin; 00730 pc++; 00731 } 00732 pc = (tColorRGBA *) ((Uint8 *) pc + gap); 00733 } 00734 } 00735 } 00736 00755 void transformSurfaceY(SDL_Surface * src, SDL_Surface * dst, int cx, int cy, int isin, int icos, int flipx, int flipy) 00756 { 00757 int x, y, dx, dy, xd, yd, sdx, sdy, ax, ay, sw, sh; 00758 tColorY *pc, *sp; 00759 int gap; 00760 00761 /* 00762 * Variable setup 00763 */ 00764 xd = ((src->w - dst->w) << 15); 00765 yd = ((src->h - dst->h) << 15); 00766 ax = (cx << 16) - (icos * cx); 00767 ay = (cy << 16) - (isin * cx); 00768 sw = src->w - 1; 00769 sh = src->h - 1; 00770 pc = (tColorY*) dst->pixels; 00771 gap = dst->pitch - dst->w; 00772 /* 00773 * Clear surface to colorkey 00774 */ 00775 memset(pc, (int)(_colorkey(src) & 0xff), dst->pitch * dst->h); 00776 /* 00777 * Iterate through destination surface 00778 */ 00779 for (y = 0; y < dst->h; y++) { 00780 dy = cy - y; 00781 sdx = (ax + (isin * dy)) + xd; 00782 sdy = (ay - (icos * dy)) + yd; 00783 for (x = 0; x < dst->w; x++) { 00784 dx = (short) (sdx >> 16); 00785 dy = (short) (sdy >> 16); 00786 if (flipx) dx = (src->w-1)-dx; 00787 if (flipy) dy = (src->h-1)-dy; 00788 if ((dx >= 0) && (dy >= 0) && (dx < src->w) && (dy < src->h)) { 00789 sp = (tColorY *) (src->pixels); 00790 sp += (src->pitch * dy + dx); 00791 *pc = *sp; 00792 } 00793 sdx += icos; 00794 sdy += isin; 00795 pc++; 00796 } 00797 pc += gap; 00798 } 00799 } 00800 00814 SDL_Surface* rotateSurface90Degrees(SDL_Surface* src, int numClockwiseTurns) 00815 { 00816 int row, col, newWidth, newHeight; 00817 int bpp, src_ipr, dst_ipr; 00818 SDL_Surface* dst; 00819 Uint32* srcBuf; 00820 Uint32* dstBuf; 00821 00822 /* Has to be a valid surface pointer and only 32-bit surfaces (for now) */ 00823 if (!src || src->format->BitsPerPixel != 32) { return NULL; } 00824 00825 /* normalize numClockwiseTurns */ 00826 while(numClockwiseTurns < 0) { numClockwiseTurns += 4; } 00827 numClockwiseTurns = (numClockwiseTurns % 4); 00828 00829 /* if it's even, our new width will be the same as the source surface */ 00830 newWidth = (numClockwiseTurns % 2) ? (src->h) : (src->w); 00831 newHeight = (numClockwiseTurns % 2) ? (src->w) : (src->h); 00832 dst = SDL_CreateRGBSurface( src->flags, newWidth, newHeight, src->format->BitsPerPixel, 00833 src->format->Rmask, 00834 src->format->Gmask, 00835 src->format->Bmask, 00836 src->format->Amask); 00837 if(!dst) { 00838 return NULL; 00839 } 00840 00841 if (SDL_MUSTLOCK(dst)) { 00842 SDL_LockSurface(dst); 00843 } 00844 if (SDL_MUSTLOCK(dst)) { 00845 SDL_LockSurface(dst); 00846 } 00847 00848 /* Calculate int-per-row */ 00849 bpp = src->format->BitsPerPixel / 8; 00850 src_ipr = src->pitch / bpp; 00851 dst_ipr = dst->pitch / bpp; 00852 00853 switch(numClockwiseTurns) { 00854 case 0: /* Make a copy of the surface */ 00855 { 00856 /* Unfortunately SDL_BlitSurface cannot be used to make a copy of the surface 00857 since it does not preserve alpha. */ 00858 00859 if (src->pitch == dst->pitch) { 00860 /* If the pitch is the same for both surfaces, the memory can be copied all at once. */ 00861 memcpy(dst->pixels, src->pixels, (src->h * src->pitch)); 00862 } 00863 else 00864 { 00865 /* If the pitch differs, copy each row separately */ 00866 srcBuf = (Uint32*)(src->pixels); 00867 dstBuf = (Uint32*)(dst->pixels); 00868 for (row = 0; row < src->h; row++) { 00869 memcpy(dstBuf, srcBuf, dst->w * bpp); 00870 srcBuf += src_ipr; 00871 dstBuf += dst_ipr; 00872 } /* end for(col) */ 00873 } /* end for(row) */ 00874 } 00875 break; 00876 00877 /* rotate clockwise */ 00878 case 1: /* rotated 90 degrees clockwise */ 00879 { 00880 for (row = 0; row < src->h; ++row) { 00881 srcBuf = (Uint32*)(src->pixels) + (row * src_ipr); 00882 dstBuf = (Uint32*)(dst->pixels) + (dst->w - row - 1); 00883 for (col = 0; col < src->w; ++col) { 00884 *dstBuf = *srcBuf; 00885 ++srcBuf; 00886 dstBuf += dst_ipr; 00887 } 00888 /* end for(col) */ 00889 } 00890 /* end for(row) */ 00891 } 00892 break; 00893 00894 case 2: /* rotated 180 degrees clockwise */ 00895 { 00896 for (row = 0; row < src->h; ++row) { 00897 srcBuf = (Uint32*)(src->pixels) + (row * src_ipr); 00898 dstBuf = (Uint32*)(dst->pixels) + ((dst->h - row - 1) * dst_ipr) + (dst->w - 1); 00899 for (col = 0; col < src->w; ++col) { 00900 *dstBuf = *srcBuf; 00901 ++srcBuf; 00902 --dstBuf; 00903 } 00904 } 00905 } 00906 break; 00907 00908 case 3: 00909 { 00910 for (row = 0; row < src->h; ++row) { 00911 srcBuf = (Uint32*)(src->pixels) + (row * src_ipr); 00912 dstBuf = (Uint32*)(dst->pixels) + row + ((dst->h - 1) * dst_ipr); 00913 for (col = 0; col < src->w; ++col) { 00914 *dstBuf = *srcBuf; 00915 ++srcBuf; 00916 dstBuf -= dst_ipr; 00917 } 00918 } 00919 } 00920 break; 00921 } 00922 /* end switch */ 00923 00924 if (SDL_MUSTLOCK(src)) { 00925 SDL_UnlockSurface(src); 00926 } 00927 if (SDL_MUSTLOCK(dst)) { 00928 SDL_UnlockSurface(dst); 00929 } 00930 00931 return dst; 00932 } 00933 00934 00949 void _rotozoomSurfaceSizeTrig(int width, int height, double angle, double zoomx, double zoomy, 00950 int *dstwidth, int *dstheight, 00951 double *canglezoom, double *sanglezoom) 00952 { 00953 double x, y, cx, cy, sx, sy; 00954 double radangle; 00955 int dstwidthhalf, dstheighthalf; 00956 00957 /* 00958 * Determine destination width and height by rotating a centered source box 00959 */ 00960 radangle = angle * (M_PI / 180.0); 00961 *sanglezoom = sin(radangle); 00962 *canglezoom = cos(radangle); 00963 *sanglezoom *= zoomx; 00964 *canglezoom *= zoomx; 00965 x = (double)(width / 2); 00966 y = (double)(height / 2); 00967 cx = *canglezoom * x; 00968 cy = *canglezoom * y; 00969 sx = *sanglezoom * x; 00970 sy = *sanglezoom * y; 00971 00972 dstwidthhalf = MAX((int) 00973 ceil(MAX(MAX(MAX(fabs(cx + sy), fabs(cx - sy)), fabs(-cx + sy)), fabs(-cx - sy))), 1); 00974 dstheighthalf = MAX((int) 00975 ceil(MAX(MAX(MAX(fabs(sx + cy), fabs(sx - cy)), fabs(-sx + cy)), fabs(-sx - cy))), 1); 00976 *dstwidth = 2 * dstwidthhalf; 00977 *dstheight = 2 * dstheighthalf; 00978 } 00979 00991 void rotozoomSurfaceSizeXY(int width, int height, double angle, double zoomx, double zoomy, int *dstwidth, int *dstheight) 00992 { 00993 double dummy_sanglezoom, dummy_canglezoom; 00994 00995 _rotozoomSurfaceSizeTrig(width, height, angle, zoomx, zoomy, dstwidth, dstheight, &dummy_sanglezoom, &dummy_canglezoom); 00996 } 00997 01008 void rotozoomSurfaceSize(int width, int height, double angle, double zoom, int *dstwidth, int *dstheight) 01009 { 01010 double dummy_sanglezoom, dummy_canglezoom; 01011 01012 _rotozoomSurfaceSizeTrig(width, height, angle, zoom, zoom, dstwidth, dstheight, &dummy_sanglezoom, &dummy_canglezoom); 01013 } 01014 01030 SDL_Surface *rotozoomSurface(SDL_Surface * src, double angle, double zoom, int smooth) 01031 { 01032 return rotozoomSurfaceXY(src, angle, zoom, zoom, smooth); 01033 } 01034 01051 SDL_Surface *rotozoomSurfaceXY(SDL_Surface * src, double angle, double zoomx, double zoomy, int smooth) 01052 { 01053 SDL_Surface *rz_src; 01054 SDL_Surface *rz_dst; 01055 double zoominv; 01056 double sanglezoom, canglezoom, sanglezoominv, canglezoominv; 01057 int dstwidthhalf, dstwidth, dstheighthalf, dstheight; 01058 int is32bit; 01059 int i, src_converted; 01060 int flipx,flipy; 01061 Uint8 r,g,b; 01062 Uint32 colorkey = 0; 01063 int colorKeyAvailable = 0; 01064 01065 /* 01066 * Sanity check 01067 */ 01068 if (src == NULL) 01069 return (NULL); 01070 01071 if (src->flags & SDL_SRCCOLORKEY) 01072 { 01073 colorkey = _colorkey(src); 01074 SDL_GetRGB(colorkey, src->format, &r, &g, &b); 01075 colorKeyAvailable = 1; 01076 } 01077 /* 01078 * Determine if source surface is 32bit or 8bit 01079 */ 01080 is32bit = (src->format->BitsPerPixel == 32); 01081 if ((is32bit) || (src->format->BitsPerPixel == 8)) { 01082 /* 01083 * Use source surface 'as is' 01084 */ 01085 rz_src = src; 01086 src_converted = 0; 01087 } else { 01088 /* 01089 * New source surface is 32bit with a defined RGBA ordering 01090 */ 01091 rz_src = 01092 SDL_CreateRGBSurface(SDL_SWSURFACE, src->w, src->h, 32, 01093 #if SDL_BYTEORDER == SDL_LIL_ENDIAN 01094 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 01095 #else 01096 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff 01097 #endif 01098 ); 01099 if(colorKeyAvailable) 01100 SDL_SetColorKey(src, 0, 0); 01101 01102 SDL_BlitSurface(src, NULL, rz_src, NULL); 01103 01104 if(colorKeyAvailable) 01105 SDL_SetColorKey(src, SDL_SRCCOLORKEY, colorkey); 01106 src_converted = 1; 01107 is32bit = 1; 01108 } 01109 01110 /* 01111 * Sanity check zoom factor 01112 */ 01113 flipx = (zoomx<0.0); 01114 if (flipx) zoomx=-zoomx; 01115 flipy = (zoomy<0.0); 01116 if (flipy) zoomy=-zoomy; 01117 if (zoomx < VALUE_LIMIT) zoomx = VALUE_LIMIT; 01118 if (zoomy < VALUE_LIMIT) zoomy = VALUE_LIMIT; 01119 zoominv = 65536.0 / (zoomx * zoomx); 01120 01121 /* 01122 * Check if we have a rotozoom or just a zoom 01123 */ 01124 if (fabs(angle) > VALUE_LIMIT) { 01125 01126 /* 01127 * Angle!=0: full rotozoom 01128 */ 01129 /* 01130 * ----------------------- 01131 */ 01132 01133 /* Determine target size */ 01134 _rotozoomSurfaceSizeTrig(rz_src->w, rz_src->h, angle, zoomx, zoomy, &dstwidth, &dstheight, &canglezoom, &sanglezoom); 01135 01136 /* 01137 * Calculate target factors from sin/cos and zoom 01138 */ 01139 sanglezoominv = sanglezoom; 01140 canglezoominv = canglezoom; 01141 sanglezoominv *= zoominv; 01142 canglezoominv *= zoominv; 01143 01144 /* Calculate half size */ 01145 dstwidthhalf = dstwidth / 2; 01146 dstheighthalf = dstheight / 2; 01147 01148 /* 01149 * Alloc space to completely contain the rotated surface 01150 */ 01151 rz_dst = NULL; 01152 if (is32bit) { 01153 /* 01154 * Target surface is 32bit with source RGBA/ABGR ordering 01155 */ 01156 rz_dst = 01157 SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight + GUARD_ROWS, 32, 01158 rz_src->format->Rmask, rz_src->format->Gmask, 01159 rz_src->format->Bmask, rz_src->format->Amask); 01160 } else { 01161 /* 01162 * Target surface is 8bit 01163 */ 01164 rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight + GUARD_ROWS, 8, 0, 0, 0, 0); 01165 } 01166 01167 /* Check target */ 01168 if (rz_dst == NULL) 01169 return NULL; 01170 01171 /* Adjust for guard rows */ 01172 rz_dst->h = dstheight; 01173 01174 if (colorKeyAvailable == 1){ 01175 colorkey = SDL_MapRGB(rz_dst->format, r, g, b); 01176 01177 SDL_FillRect(rz_dst, NULL, colorkey ); 01178 } 01179 01180 /* 01181 * Lock source surface 01182 */ 01183 if (SDL_MUSTLOCK(rz_src)) { 01184 SDL_LockSurface(rz_src); 01185 } 01186 01187 /* 01188 * Check which kind of surface we have 01189 */ 01190 if (is32bit) { 01191 /* 01192 * Call the 32bit transformation routine to do the rotation (using alpha) 01193 */ 01194 _transformSurfaceRGBA(rz_src, rz_dst, dstwidthhalf, dstheighthalf, 01195 (int) (sanglezoominv), (int) (canglezoominv), 01196 flipx, flipy, 01197 smooth); 01198 /* 01199 * Turn on source-alpha support 01200 */ 01201 SDL_SetAlpha(rz_dst, SDL_SRCALPHA, 255); 01202 SDL_SetColorKey(rz_dst, SDL_SRCCOLORKEY | SDL_RLEACCEL, _colorkey(rz_src)); 01203 } else { 01204 /* 01205 * Copy palette and colorkey info 01206 */ 01207 for (i = 0; i < rz_src->format->palette->ncolors; i++) { 01208 rz_dst->format->palette->colors[i] = rz_src->format->palette->colors[i]; 01209 } 01210 rz_dst->format->palette->ncolors = rz_src->format->palette->ncolors; 01211 /* 01212 * Call the 8bit transformation routine to do the rotation 01213 */ 01214 transformSurfaceY(rz_src, rz_dst, dstwidthhalf, dstheighthalf, 01215 (int) (sanglezoominv), (int) (canglezoominv), 01216 flipx, flipy); 01217 SDL_SetColorKey(rz_dst, SDL_SRCCOLORKEY | SDL_RLEACCEL, _colorkey(rz_src)); 01218 } 01219 /* 01220 * Unlock source surface 01221 */ 01222 if (SDL_MUSTLOCK(rz_src)) { 01223 SDL_UnlockSurface(rz_src); 01224 } 01225 01226 } else { 01227 01228 /* 01229 * Angle=0: Just a zoom 01230 */ 01231 /* 01232 * -------------------- 01233 */ 01234 01235 /* 01236 * Calculate target size 01237 */ 01238 zoomSurfaceSize(rz_src->w, rz_src->h, zoomx, zoomy, &dstwidth, &dstheight); 01239 01240 /* 01241 * Alloc space to completely contain the zoomed surface 01242 */ 01243 rz_dst = NULL; 01244 if (is32bit) { 01245 /* 01246 * Target surface is 32bit with source RGBA/ABGR ordering 01247 */ 01248 rz_dst = 01249 SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight + GUARD_ROWS, 32, 01250 rz_src->format->Rmask, rz_src->format->Gmask, 01251 rz_src->format->Bmask, rz_src->format->Amask); 01252 } else { 01253 /* 01254 * Target surface is 8bit 01255 */ 01256 rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight + GUARD_ROWS, 8, 0, 0, 0, 0); 01257 } 01258 01259 /* Check target */ 01260 if (rz_dst == NULL) 01261 return NULL; 01262 01263 /* Adjust for guard rows */ 01264 rz_dst->h = dstheight; 01265 01266 if (colorKeyAvailable == 1){ 01267 colorkey = SDL_MapRGB(rz_dst->format, r, g, b); 01268 01269 SDL_FillRect(rz_dst, NULL, colorkey ); 01270 } 01271 01272 /* 01273 * Lock source surface 01274 */ 01275 if (SDL_MUSTLOCK(rz_src)) { 01276 SDL_LockSurface(rz_src); 01277 } 01278 01279 /* 01280 * Check which kind of surface we have 01281 */ 01282 if (is32bit) { 01283 /* 01284 * Call the 32bit transformation routine to do the zooming (using alpha) 01285 */ 01286 _zoomSurfaceRGBA(rz_src, rz_dst, flipx, flipy, smooth); 01287 01288 /* 01289 * Turn on source-alpha support 01290 */ 01291 SDL_SetAlpha(rz_dst, SDL_SRCALPHA, 255); 01292 SDL_SetColorKey(rz_dst, SDL_SRCCOLORKEY | SDL_RLEACCEL, _colorkey(rz_src)); 01293 } else { 01294 /* 01295 * Copy palette and colorkey info 01296 */ 01297 for (i = 0; i < rz_src->format->palette->ncolors; i++) { 01298 rz_dst->format->palette->colors[i] = rz_src->format->palette->colors[i]; 01299 } 01300 rz_dst->format->palette->ncolors = rz_src->format->palette->ncolors; 01301 01302 /* 01303 * Call the 8bit transformation routine to do the zooming 01304 */ 01305 _zoomSurfaceY(rz_src, rz_dst, flipx, flipy); 01306 SDL_SetColorKey(rz_dst, SDL_SRCCOLORKEY | SDL_RLEACCEL, _colorkey(rz_src)); 01307 } 01308 01309 /* 01310 * Unlock source surface 01311 */ 01312 if (SDL_MUSTLOCK(rz_src)) { 01313 SDL_UnlockSurface(rz_src); 01314 } 01315 } 01316 01317 /* 01318 * Cleanup temp surface 01319 */ 01320 if (src_converted) { 01321 SDL_FreeSurface(rz_src); 01322 } 01323 01324 /* 01325 * Return destination surface 01326 */ 01327 return (rz_dst); 01328 } 01329 01342 void zoomSurfaceSize(int width, int height, double zoomx, double zoomy, int *dstwidth, int *dstheight) 01343 { 01344 /* 01345 * Make zoom factors positive 01346 */ 01347 int flipx, flipy; 01348 flipx = (zoomx<0.0); 01349 if (flipx) zoomx = -zoomx; 01350 flipy = (zoomy<0.0); 01351 if (flipy) zoomy = -zoomy; 01352 01353 /* 01354 * Sanity check zoom factors 01355 */ 01356 if (zoomx < VALUE_LIMIT) { 01357 zoomx = VALUE_LIMIT; 01358 } 01359 if (zoomy < VALUE_LIMIT) { 01360 zoomy = VALUE_LIMIT; 01361 } 01362 01363 /* 01364 * Calculate target size 01365 */ 01366 *dstwidth = (int) floor(((double) width * zoomx) + 0.5); 01367 *dstheight = (int) floor(((double) height * zoomy) + 0.5); 01368 if (*dstwidth < 1) { 01369 *dstwidth = 1; 01370 } 01371 if (*dstheight < 1) { 01372 *dstheight = 1; 01373 } 01374 } 01375 01392 SDL_Surface *zoomSurface(SDL_Surface * src, double zoomx, double zoomy, int smooth) 01393 { 01394 SDL_Surface *rz_src; 01395 SDL_Surface *rz_dst; 01396 int dstwidth, dstheight; 01397 int is32bit; 01398 int i, src_converted; 01399 int flipx, flipy; 01400 01401 /* 01402 * Sanity check 01403 */ 01404 if (src == NULL) 01405 return (NULL); 01406 01407 /* 01408 * Determine if source surface is 32bit or 8bit 01409 */ 01410 is32bit = (src->format->BitsPerPixel == 32); 01411 if ((is32bit) || (src->format->BitsPerPixel == 8)) { 01412 /* 01413 * Use source surface 'as is' 01414 */ 01415 rz_src = src; 01416 src_converted = 0; 01417 } else { 01418 /* 01419 * New source surface is 32bit with a defined RGBA ordering 01420 */ 01421 rz_src = 01422 SDL_CreateRGBSurface(SDL_SWSURFACE, src->w, src->h, 32, 01423 #if SDL_BYTEORDER == SDL_LIL_ENDIAN 01424 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 01425 #else 01426 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff 01427 #endif 01428 ); 01429 if (rz_src == NULL) { 01430 return NULL; 01431 } 01432 SDL_BlitSurface(src, NULL, rz_src, NULL); 01433 src_converted = 1; 01434 is32bit = 1; 01435 } 01436 01437 flipx = (zoomx<0.0); 01438 if (flipx) zoomx = -zoomx; 01439 flipy = (zoomy<0.0); 01440 if (flipy) zoomy = -zoomy; 01441 01442 /* Get size if target */ 01443 zoomSurfaceSize(rz_src->w, rz_src->h, zoomx, zoomy, &dstwidth, &dstheight); 01444 01445 /* 01446 * Alloc space to completely contain the zoomed surface 01447 */ 01448 rz_dst = NULL; 01449 if (is32bit) { 01450 /* 01451 * Target surface is 32bit with source RGBA/ABGR ordering 01452 */ 01453 rz_dst = 01454 SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight + GUARD_ROWS, 32, 01455 rz_src->format->Rmask, rz_src->format->Gmask, 01456 rz_src->format->Bmask, rz_src->format->Amask); 01457 } else { 01458 /* 01459 * Target surface is 8bit 01460 */ 01461 rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight + GUARD_ROWS, 8, 0, 0, 0, 0); 01462 } 01463 01464 /* Check target */ 01465 if (rz_dst == NULL) { 01466 /* 01467 * Cleanup temp surface 01468 */ 01469 if (src_converted) { 01470 SDL_FreeSurface(rz_src); 01471 } 01472 return NULL; 01473 } 01474 01475 /* Adjust for guard rows */ 01476 rz_dst->h = dstheight; 01477 01478 /* 01479 * Lock source surface 01480 */ 01481 if (SDL_MUSTLOCK(rz_src)) { 01482 SDL_LockSurface(rz_src); 01483 } 01484 01485 /* 01486 * Check which kind of surface we have 01487 */ 01488 if (is32bit) { 01489 /* 01490 * Call the 32bit transformation routine to do the zooming (using alpha) 01491 */ 01492 _zoomSurfaceRGBA(rz_src, rz_dst, flipx, flipy, smooth); 01493 /* 01494 * Turn on source-alpha support 01495 */ 01496 SDL_SetAlpha(rz_dst, SDL_SRCALPHA, 255); 01497 } else { 01498 /* 01499 * Copy palette and colorkey info 01500 */ 01501 for (i = 0; i < rz_src->format->palette->ncolors; i++) { 01502 rz_dst->format->palette->colors[i] = rz_src->format->palette->colors[i]; 01503 } 01504 rz_dst->format->palette->ncolors = rz_src->format->palette->ncolors; 01505 /* 01506 * Call the 8bit transformation routine to do the zooming 01507 */ 01508 _zoomSurfaceY(rz_src, rz_dst, flipx, flipy); 01509 SDL_SetColorKey(rz_dst, SDL_SRCCOLORKEY | SDL_RLEACCEL, _colorkey(rz_src)); 01510 } 01511 /* 01512 * Unlock source surface 01513 */ 01514 if (SDL_MUSTLOCK(rz_src)) { 01515 SDL_UnlockSurface(rz_src); 01516 } 01517 01518 /* 01519 * Cleanup temp surface 01520 */ 01521 if (src_converted) { 01522 SDL_FreeSurface(rz_src); 01523 } 01524 01525 /* 01526 * Return destination surface 01527 */ 01528 return (rz_dst); 01529 } 01530 01547 /*@null@*/ 01548 SDL_Surface *shrinkSurface(SDL_Surface *src, int factorx, int factory) 01549 { 01550 int result; 01551 SDL_Surface *rz_src; 01552 SDL_Surface *rz_dst = NULL; 01553 int dstwidth, dstheight; 01554 int is32bit; 01555 int i, src_converted; 01556 int haveError = 0; 01557 01558 /* 01559 * Sanity check 01560 */ 01561 if (src == NULL) { 01562 return (NULL); 01563 } 01564 01565 /* 01566 * Determine if source surface is 32bit or 8bit 01567 */ 01568 is32bit = (src->format->BitsPerPixel == 32); 01569 if ((is32bit) || (src->format->BitsPerPixel == 8)) { 01570 /* 01571 * Use source surface 'as is' 01572 */ 01573 rz_src = src; 01574 src_converted = 0; 01575 } else { 01576 /* 01577 * New source surface is 32bit with a defined RGBA ordering 01578 */ 01579 rz_src = SDL_CreateRGBSurface(SDL_SWSURFACE, src->w, src->h, 32, 01580 #if SDL_BYTEORDER == SDL_LIL_ENDIAN 01581 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 01582 #else 01583 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff 01584 #endif 01585 ); 01586 if (rz_src==NULL) { 01587 haveError = 1; 01588 goto exitShrinkSurface; 01589 } 01590 01591 SDL_BlitSurface(src, NULL, rz_src, NULL); 01592 src_converted = 1; 01593 is32bit = 1; 01594 } 01595 01596 /* 01597 * Lock the surface 01598 */ 01599 if (SDL_MUSTLOCK(rz_src)) { 01600 if (SDL_LockSurface(rz_src) < 0) { 01601 haveError = 1; 01602 goto exitShrinkSurface; 01603 } 01604 } 01605 01606 /* Get size for target */ 01607 dstwidth=rz_src->w/factorx; 01608 while (dstwidth*factorx>rz_src->w) { dstwidth--; } 01609 dstheight=rz_src->h/factory; 01610 while (dstheight*factory>rz_src->h) { dstheight--; } 01611 01612 /* 01613 * Alloc space to completely contain the shrunken surface 01614 * (with added guard rows) 01615 */ 01616 if (is32bit==1) { 01617 /* 01618 * Target surface is 32bit with source RGBA/ABGR ordering 01619 */ 01620 rz_dst = 01621 SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight + GUARD_ROWS, 32, 01622 rz_src->format->Rmask, rz_src->format->Gmask, 01623 rz_src->format->Bmask, rz_src->format->Amask); 01624 } else { 01625 /* 01626 * Target surface is 8bit 01627 */ 01628 rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight + GUARD_ROWS, 8, 0, 0, 0, 0); 01629 } 01630 01631 /* Check target */ 01632 if (rz_dst == NULL) { 01633 haveError = 1; 01634 goto exitShrinkSurface; 01635 } 01636 01637 /* Adjust for guard rows */ 01638 rz_dst->h = dstheight; 01639 01640 /* 01641 * Check which kind of surface we have 01642 */ 01643 if (is32bit==1) { 01644 /* 01645 * Call the 32bit transformation routine to do the shrinking (using alpha) 01646 */ 01647 result = _shrinkSurfaceRGBA(rz_src, rz_dst, factorx, factory); 01648 if ((result!=0) || (rz_dst==NULL)) { 01649 haveError = 1; 01650 goto exitShrinkSurface; 01651 } 01652 01653 /* 01654 * Turn on source-alpha support 01655 */ 01656 result = SDL_SetAlpha(rz_dst, SDL_SRCALPHA, 255); 01657 if (result!=0) { 01658 haveError = 1; 01659 goto exitShrinkSurface; 01660 } 01661 } else { 01662 /* 01663 * Copy palette and colorkey info 01664 */ 01665 for (i = 0; i < rz_src->format->palette->ncolors; i++) { 01666 rz_dst->format->palette->colors[i] = rz_src->format->palette->colors[i]; 01667 } 01668 rz_dst->format->palette->ncolors = rz_src->format->palette->ncolors; 01669 /* 01670 * Call the 8bit transformation routine to do the shrinking 01671 */ 01672 result = _shrinkSurfaceY(rz_src, rz_dst, factorx, factory); 01673 if (result!=0) { 01674 haveError = 1; 01675 goto exitShrinkSurface; 01676 } 01677 01678 /* 01679 * Set colorkey on target 01680 */ 01681 result = SDL_SetColorKey(rz_dst, SDL_SRCCOLORKEY | SDL_RLEACCEL, _colorkey(rz_src)); 01682 if (result!=0) { 01683 haveError = 1; 01684 goto exitShrinkSurface; 01685 } 01686 } 01687 01688 exitShrinkSurface: 01689 if (rz_src!=NULL) { 01690 /* 01691 * Unlock source surface 01692 */ 01693 if (SDL_MUSTLOCK(rz_src)) { 01694 SDL_UnlockSurface(rz_src); 01695 } 01696 01697 /* 01698 * Cleanup temp surface 01699 */ 01700 if (src_converted==1) { 01701 SDL_FreeSurface(rz_src); 01702 } 01703 } 01704 01705 /* Check error state; maybe need to cleanup destination */ 01706 if (haveError==1) { 01707 if (rz_dst!=NULL) { 01708 SDL_FreeSurface(rz_dst); 01709 } 01710 rz_dst=NULL; 01711 } 01712 01713 /* 01714 * Return destination surface 01715 */ 01716 return (rz_dst); 01717 }
1.8.0