pajoye          Wed May 27 07:16:55 2009 UTC

  Added files:                 
    /php-src/ext/gd/libgd       gd_rotate.c 

  Modified files:              
    /php-src/ext/gd     config.m4 config.w32 gd.c php_gd.h 
    /php-src/ext/gd/libgd       gd.c gd_compat.h 
  Log:
  - [DOC] always enable imagerotate (using bundled or system gd)
  
http://cvs.php.net/viewvc.cgi/php-src/ext/gd/config.m4?r1=1.181&r2=1.182&diff_format=u
Index: php-src/ext/gd/config.m4
diff -u php-src/ext/gd/config.m4:1.181 php-src/ext/gd/config.m4:1.182
--- php-src/ext/gd/config.m4:1.181      Tue May 26 19:34:17 2009
+++ php-src/ext/gd/config.m4    Wed May 27 07:16:55 2009
@@ -1,5 +1,5 @@
 dnl
-dnl $Id: config.m4,v 1.181 2009/05/26 19:34:17 pajoye Exp $
+dnl $Id: config.m4,v 1.182 2009/05/27 07:16:55 pajoye Exp $
 dnl
 
 dnl
@@ -274,7 +274,8 @@
                  libgd/gdxpm.c libgd/gdfontt.c libgd/gdfonts.c 
libgd/gdfontmb.c libgd/gdfontl.c \
                  libgd/gdfontg.c libgd/gdtables.c libgd/gdft.c libgd/gdcache.c 
libgd/gdkanji.c \
                  libgd/wbmp.c libgd/gd_wbmp.c libgd/gdhelpers.c 
libgd/gd_topal.c libgd/gd_gif_in.c \
-                 libgd/xbm.c libgd/gd_gif_out.c libgd/gd_security.c 
libgd/gd_filter.c libgd/gd_pixelate.c libgd/gd_arc.c"
+                 libgd/xbm.c libgd/gd_gif_out.c libgd/gd_security.c 
libgd/gd_filter.c \
+                 libgd/gd_pixelate.c libgd/gd_arc.c libgd/gd_rotate.c"
 
 dnl check for fabsf and floorf which are available since C99
   AC_CHECK_FUNCS([fabsf floorf])
@@ -311,7 +312,7 @@
   PHP_ADD_BUILD_DIR($ext_builddir/libgd)
 
   GD_MODULE_TYPE=external
-  extra_sources="gdcache.c libgd/gd_compat.c libgd/gd_filter.c 
libgd/gd_pixelate.c libgd/gd_arc.c"
+  extra_sources="gdcache.c libgd/gd_compat.c libgd/gd_filter.c 
libgd/gd_pixelate.c libgd/gd_arc.c libgd/gd_rotate.c"
 
   GD_FEATURES=`$GDLIB_CONFIG --features`
 
http://cvs.php.net/viewvc.cgi/php-src/ext/gd/config.w32?r1=1.37&r2=1.38&diff_format=u
Index: php-src/ext/gd/config.w32
diff -u php-src/ext/gd/config.w32:1.37 php-src/ext/gd/config.w32:1.38
--- php-src/ext/gd/config.w32:1.37      Tue May 26 19:43:11 2009
+++ php-src/ext/gd/config.w32   Wed May 27 07:16:55 2009
@@ -1,4 +1,4 @@
-// $Id: config.w32,v 1.37 2009/05/26 19:43:11 pajoye Exp $
+// $Id: config.w32,v 1.38 2009/05/27 07:16:55 pajoye Exp $
 // vim:ft=javascript
 
 ARG_WITH("gd", "Bundled GD support", "yes,shared");
@@ -33,7 +33,8 @@
                        gdcache.c gdfontg.c gdfontl.c gdfontmb.c gdfonts.c 
gdfontt.c \
                        gdft.c gd_gd2.c gd_gd.c gd_gif_in.c gd_gif_out.c 
gdhelpers.c gd_io.c gd_io_dp.c \
                        gd_io_file.c gd_io_ss.c gd_jpeg.c gdkanji.c gd_png.c 
gd_ss.c \
-                       gdtables.c gd_topal.c gd_wbmp.c gdxpm.c wbmp.c xbm.c 
gd_security.c gd_filter.c gd_pixelate.c gd_arc.c", "gd");
+                       gdtables.c gd_topal.c gd_wbmp.c gdxpm.c wbmp.c xbm.c 
gd_security.c \
+                       gd_filter.c gd_pixelate.c gd_arc.c gd_rotate.c", "gd");
                AC_DEFINE('HAVE_LIBGD', 1, 'GD support');
                ADD_FLAG("CFLAGS_GD", " \
 /D HAVE_GD_BUNDLED=1  \
http://cvs.php.net/viewvc.cgi/php-src/ext/gd/gd.c?r1=1.413&r2=1.414&diff_format=u
Index: php-src/ext/gd/gd.c
diff -u php-src/ext/gd/gd.c:1.413 php-src/ext/gd/gd.c:1.414
--- php-src/ext/gd/gd.c:1.413   Tue May 26 19:34:17 2009
+++ php-src/ext/gd/gd.c Wed May 27 07:16:55 2009
@@ -18,7 +18,7 @@
    +----------------------------------------------------------------------+
  */
 
-/* $Id: gd.c,v 1.413 2009/05/26 19:34:17 pajoye Exp $ */
+/* $Id: gd.c,v 1.414 2009/05/27 07:16:55 pajoye Exp $ */
 
 /* gd 1.2 is copyright 1994, 1995, Quest Protein Database Center,
    Cold Spring Harbor Labs. */
@@ -272,14 +272,12 @@
 ZEND_END_ARG_INFO()
 #endif
 
-#ifdef HAVE_GD_BUNDLED
 ZEND_BEGIN_ARG_INFO_EX(arginfo_imagerotate, 0, 0, 3)
        ZEND_ARG_INFO(0, im)
        ZEND_ARG_INFO(0, angle)
        ZEND_ARG_INFO(0, bgdcolor)
        ZEND_ARG_INFO(0, ignoretransparent)
 ZEND_END_ARG_INFO()
-#endif
 
 #if HAVE_GD_IMAGESETTILE
 ZEND_BEGIN_ARG_INFO(arginfo_imagesettile, 0)
@@ -882,8 +880,9 @@
        PHP_FE(imagegrabscreen,                                                 
arginfo_imagegrabscreen)
 #endif
 
-#ifdef HAVE_GD_BUNDLED
        PHP_FE(imagerotate,                                                     
arginfo_imagerotate)
+
+#ifdef HAVE_GD_BUNDLED
        PHP_FE(imageantialias,                                                  
arginfo_imageantialias)
 #endif
 
@@ -1967,7 +1966,6 @@
 /* }}} */
 #endif /* PHP_WIN32 */
 
-#ifdef HAVE_GD_BUNDLED
 /* {{{ proto resource imagerotate(resource src_im, float angle, int bgdcolor 
[, int ignoretransparent]) U
    Rotate an image using a custom angle */
 PHP_FUNCTION(imagerotate)
@@ -1993,7 +1991,6 @@
        }
 }
 /* }}} */
-#endif
 
 #if HAVE_GD_IMAGESETTILE
 /* {{{ proto bool imagesettile(resource image, resource tile) U
http://cvs.php.net/viewvc.cgi/php-src/ext/gd/php_gd.h?r1=1.80&r2=1.81&diff_format=u
Index: php-src/ext/gd/php_gd.h
diff -u php-src/ext/gd/php_gd.h:1.80 php-src/ext/gd/php_gd.h:1.81
--- php-src/ext/gd/php_gd.h:1.80        Tue May 26 14:48:18 2009
+++ php-src/ext/gd/php_gd.h     Wed May 27 07:16:55 2009
@@ -17,7 +17,7 @@
    +----------------------------------------------------------------------+
 */
 
-/* $Id: php_gd.h,v 1.80 2009/05/26 14:48:18 pajoye Exp $ */
+/* $Id: php_gd.h,v 1.81 2009/05/27 07:16:55 pajoye Exp $ */
 
 #ifndef PHP_GD_H
 #define PHP_GD_H
@@ -119,8 +119,9 @@
 PHP_FUNCTION(imagegrabscreen);
 #endif
 
-#ifdef HAVE_GD_BUNDLED
 PHP_FUNCTION(imagerotate);
+
+#ifdef HAVE_GD_BUNDLED
 PHP_FUNCTION(imageantialias);
 #endif
 
http://cvs.php.net/viewvc.cgi/php-src/ext/gd/libgd/gd.c?r1=1.125&r2=1.126&diff_format=u
Index: php-src/ext/gd/libgd/gd.c
diff -u php-src/ext/gd/libgd/gd.c:1.125 php-src/ext/gd/libgd/gd.c:1.126
--- php-src/ext/gd/libgd/gd.c:1.125     Tue May 26 19:56:17 2009
+++ php-src/ext/gd/libgd/gd.c   Wed May 27 07:16:55 2009
@@ -2550,540 +2550,6 @@
        }
 }
 
-
-/*
- * Rotate function Added on 2003/12
- * by Pierre-Alain Joye (paj...@pearfr.org)
- **/
-/* Begin rotate function */
-#ifdef ROTATE_PI
-#undef ROTATE_PI
-#endif /* ROTATE_PI */
-
-#define ROTATE_DEG2RAD  3.1415926535897932384626433832795/180
-void gdImageSkewX (gdImagePtr dst, gdImagePtr src, int uRow, int iOffset, 
double dWeight, int clrBack, int ignoretransparent)
-{
-       typedef int (*FuncPtr)(gdImagePtr, int, int);
-       int i, r, g, b, a, clrBackR, clrBackG, clrBackB, clrBackA;
-       FuncPtr f;
-
-       int pxlOldLeft, pxlLeft=0, pxlSrc;
-
-       /* Keep clrBack as color index if required */
-       if (src->trueColor) {
-               pxlOldLeft = clrBack;
-               f = gdImageGetTrueColorPixel;
-       } else {
-               pxlOldLeft = clrBack;
-               clrBackR = gdImageRed(src, clrBack);
-               clrBackG = gdImageGreen(src, clrBack);
-               clrBackB = gdImageBlue(src, clrBack);
-               clrBackA = gdImageAlpha(src, clrBack);
-               clrBack =  gdTrueColorAlpha(clrBackR, clrBackG, clrBackB, 
clrBackA);
-               f = gdImageGetPixel;
-       }
-
-       for (i = 0; i < iOffset; i++) {
-               gdImageSetPixel (dst, i, uRow, clrBack);
-       }
-
-       if (i < dst->sx) {
-               gdImageSetPixel (dst, i, uRow, clrBack);
-       }
-
-       for (i = 0; i < src->sx; i++) {
-               pxlSrc = f (src,i,uRow);
-
-               r = (int)(gdImageRed(src,pxlSrc) * dWeight);
-               g = (int)(gdImageGreen(src,pxlSrc) * dWeight);
-               b = (int)(gdImageBlue(src,pxlSrc) * dWeight);
-               a = (int)(gdImageAlpha(src,pxlSrc) * dWeight);
-
-               pxlLeft = gdImageColorAllocateAlpha(src, r, g, b, a);
-
-               if (pxlLeft == -1) {
-                       pxlLeft = gdImageColorClosestAlpha(src, r, g, b, a);
-               }
-
-               r = gdImageRed(src,pxlSrc) - (gdImageRed(src,pxlLeft) - 
gdImageRed(src,pxlOldLeft));
-               g = gdImageGreen(src,pxlSrc) - (gdImageGreen(src,pxlLeft) - 
gdImageGreen(src,pxlOldLeft));
-               b = gdImageBlue(src,pxlSrc) - (gdImageBlue(src,pxlLeft) - 
gdImageBlue(src,pxlOldLeft));
-               a = gdImageAlpha(src,pxlSrc) - (gdImageAlpha(src,pxlLeft) - 
gdImageAlpha(src,pxlOldLeft));
-
-        if (r>255) {
-               r = 255;
-        }
-
-               if (g>255) {
-                       g = 255;
-               }
-
-               if (b>255) {
-                       b = 255;
-               }
-
-               if (a>127) {
-                       a = 127;
-               }
-
-               if (ignoretransparent && pxlSrc == dst->transparent) {
-                       pxlSrc = dst->transparent;
-               } else {
-                       pxlSrc = gdImageColorAllocateAlpha(dst, r, g, b, a);
-
-                       if (pxlSrc == -1) {
-                               pxlSrc = gdImageColorClosestAlpha(dst, r, g, b, 
a);
-                       }
-               }
-
-               if ((i + iOffset >= 0) && (i + iOffset < dst->sx)) {
-                       gdImageSetPixel (dst, i+iOffset, uRow,  pxlSrc);
-               }
-
-               pxlOldLeft = pxlLeft;
-       }
-
-       i += iOffset;
-
-       if (i < dst->sx) {
-               gdImageSetPixel (dst, i, uRow, pxlLeft);
-       }
-
-       gdImageSetPixel (dst, iOffset, uRow, clrBack);
-
-       i--;
-
-       while (++i < dst->sx) {
-               gdImageSetPixel (dst, i, uRow, clrBack);
-       }
-}
-
-void gdImageSkewY (gdImagePtr dst, gdImagePtr src, int uCol, int iOffset, 
double dWeight, int clrBack, int ignoretransparent)
-{
-       typedef int (*FuncPtr)(gdImagePtr, int, int);
-       int i, iYPos=0, r, g, b, a;
-       FuncPtr f;
-       int pxlOldLeft, pxlLeft=0, pxlSrc;
-
-       if (src->trueColor) {
-               f = gdImageGetTrueColorPixel;
-       } else {
-               f = gdImageGetPixel;
-       }
-
-       for (i = 0; i<=iOffset; i++) {
-               gdImageSetPixel (dst, uCol, i, clrBack);
-       }
-       r = (int)((double)gdImageRed(src,clrBack) * dWeight);
-       g = (int)((double)gdImageGreen(src,clrBack) * dWeight);
-       b = (int)((double)gdImageBlue(src,clrBack) * dWeight);
-       a = (int)((double)gdImageAlpha(src,clrBack) * dWeight);
-
-       pxlOldLeft = gdImageColorAllocateAlpha(dst, r, g, b, a);
-
-       for (i = 0; i < src->sy; i++) {
-               pxlSrc = f (src, uCol, i);
-               iYPos = i + iOffset;
-
-               r = (int)((double)gdImageRed(src,pxlSrc) * dWeight);
-               g = (int)((double)gdImageGreen(src,pxlSrc) * dWeight);
-               b = (int)((double)gdImageBlue(src,pxlSrc) * dWeight);
-               a = (int)((double)gdImageAlpha(src,pxlSrc) * dWeight);
-
-               pxlLeft = gdImageColorAllocateAlpha(src, r, g, b, a);
-
-               if (pxlLeft == -1) {
-                       pxlLeft = gdImageColorClosestAlpha(src, r, g, b, a);
-               }
-
-               r = gdImageRed(src,pxlSrc) - (gdImageRed(src,pxlLeft) - 
gdImageRed(src,pxlOldLeft));
-               g = gdImageGreen(src,pxlSrc) - (gdImageGreen(src,pxlLeft) - 
gdImageGreen(src,pxlOldLeft));
-               b = gdImageBlue(src,pxlSrc) - (gdImageBlue(src,pxlLeft) - 
gdImageBlue(src,pxlOldLeft));
-               a = gdImageAlpha(src,pxlSrc) - (gdImageAlpha(src,pxlLeft) - 
gdImageAlpha(src,pxlOldLeft));
-
-               if (r>255) {
-                       r = 255;
-               }
-
-               if (g>255) {
-                       g = 255;
-               }
-
-               if (b>255) {
-                       b = 255;
-               }
-
-               if (a>127) {
-                       a = 127;
-               }
-
-               if (ignoretransparent && pxlSrc == dst->transparent) {
-                       pxlSrc = dst->transparent;
-               } else {
-                       pxlSrc = gdImageColorAllocateAlpha(dst, r, g, b, a);
-
-                       if (pxlSrc == -1) {
-                               pxlSrc = gdImageColorClosestAlpha(dst, r, g, b, 
a);
-                       }
-               }
-
-               if ((iYPos >= 0) && (iYPos < dst->sy)) {
-                       gdImageSetPixel (dst, uCol, iYPos, pxlSrc);
-               }
-
-               pxlOldLeft = pxlLeft;
-       }
-
-       i = iYPos;
-       if (i < dst->sy) {
-               gdImageSetPixel (dst, uCol, i, pxlLeft);
-       }
-
-       i--;
-       while (++i < dst->sy) {
-               gdImageSetPixel (dst, uCol, i, clrBack);
-       }
-}
-
-/* Rotates an image by 90 degrees (counter clockwise) */
-gdImagePtr gdImageRotate90 (gdImagePtr src, int ignoretransparent)
-{
-       int uY, uX;
-       int c,r,g,b,a;
-       gdImagePtr dst;
-       typedef int (*FuncPtr)(gdImagePtr, int, int);
-       FuncPtr f;
-
-       if (src->trueColor) {
-               f = gdImageGetTrueColorPixel;
-       } else {
-               f = gdImageGetPixel;
-       }
-       dst = gdImageCreateTrueColor(src->sy, src->sx);
-       dst->transparent = src->transparent;
-
-       if (dst != NULL) {
-               int old_blendmode = dst->alphaBlendingFlag;
-               dst->alphaBlendingFlag = 0;
-
-               gdImagePaletteCopy (dst, src);
-
-               for (uY = 0; uY<src->sy; uY++) {
-                       for (uX = 0; uX<src->sx; uX++) {
-                               c = f (src, uX, uY);
-                               if (!src->trueColor) {
-                                       r = gdImageRed(src,c);
-                                       g = gdImageGreen(src,c);
-                                       b = gdImageBlue(src,c);
-                                       a = gdImageAlpha(src,c);
-                                       c = gdTrueColorAlpha(r, g, b, a);
-                               }
-                               if (ignoretransparent && c == dst->transparent) 
{
-                                       gdImageSetPixel(dst, uY, (dst->sy - uX 
- 1), dst->transparent);
-                               } else {
-                                       gdImageSetPixel(dst, uY, (dst->sy - uX 
- 1), c);
-                               }
-                       }
-               }
-               dst->alphaBlendingFlag = old_blendmode;
-       }
-
-       return dst;
-}
-
-/* Rotates an image by 180 degrees (counter clockwise) */
-gdImagePtr gdImageRotate180 (gdImagePtr src, int ignoretransparent)
-{
-       int uY, uX;
-       int c,r,g,b,a;
-       gdImagePtr dst;
-       typedef int (*FuncPtr)(gdImagePtr, int, int);
-       FuncPtr f;
-
-       if (src->trueColor) {
-               f = gdImageGetTrueColorPixel;
-       } else {
-               f = gdImageGetPixel;
-       }
-       dst = gdImageCreateTrueColor(src->sx, src->sy);
-       dst->transparent = src->transparent;
-
-       if (dst != NULL) {
-               int old_blendmode = dst->alphaBlendingFlag;
-               dst->alphaBlendingFlag = 0;
-
-               gdImagePaletteCopy (dst, src);
-
-               for (uY = 0; uY<src->sy; uY++) {
-                       for (uX = 0; uX<src->sx; uX++) {
-                               c = f (src, uX, uY);
-                               if (!src->trueColor) {
-                                       r = gdImageRed(src,c);
-                                       g = gdImageGreen(src,c);
-                                       b = gdImageBlue(src,c);
-                                       a = gdImageAlpha(src,c);
-                                       c = gdTrueColorAlpha(r, g, b, a);
-                               }
-
-                               if (ignoretransparent && c == dst->transparent) 
{
-                                       gdImageSetPixel(dst, (dst->sx - uX - 
1), (dst->sy - uY - 1), dst->transparent);
-                               } else {
-                                       gdImageSetPixel(dst, (dst->sx - uX - 
1), (dst->sy - uY - 1), c);
-                               }
-                       }
-               }
-               dst->alphaBlendingFlag = old_blendmode;
-       }
-
-       return dst;
-}
-
-/* Rotates an image by 270 degrees (counter clockwise) */
-gdImagePtr gdImageRotate270 (gdImagePtr src, int ignoretransparent)
-{
-       int uY, uX;
-       int c,r,g,b,a;
-       gdImagePtr dst;
-       typedef int (*FuncPtr)(gdImagePtr, int, int);
-       FuncPtr f;
-
-       if (src->trueColor) {
-               f = gdImageGetTrueColorPixel;
-       } else {
-               f = gdImageGetPixel;
-       }
-       dst = gdImageCreateTrueColor (src->sy, src->sx);
-       dst->transparent = src->transparent;
-
-       if (dst != NULL) {
-               int old_blendmode = dst->alphaBlendingFlag;
-               dst->alphaBlendingFlag = 0;
-
-               gdImagePaletteCopy (dst, src);
-
-               for (uY = 0; uY<src->sy; uY++) {
-                       for (uX = 0; uX<src->sx; uX++) {
-                               c = f (src, uX, uY);
-                               if (!src->trueColor) {
-                                       r = gdImageRed(src,c);
-                                       g = gdImageGreen(src,c);
-                                       b = gdImageBlue(src,c);
-                                       a = gdImageAlpha(src,c);
-                                       c = gdTrueColorAlpha(r, g, b, a);
-                               }
-
-                               if (ignoretransparent && c == dst->transparent) 
{
-                                       gdImageSetPixel(dst, (dst->sx - uY - 
1), uX, dst->transparent);
-                               } else {
-                                       gdImageSetPixel(dst, (dst->sx - uY - 
1), uX, c);
-                               }
-                       }
-               }
-               dst->alphaBlendingFlag = old_blendmode;
-       }
-
-       return dst;
-}
-
-gdImagePtr gdImageRotate45 (gdImagePtr src, double dAngle, int clrBack, int 
ignoretransparent)
-{
-       typedef int (*FuncPtr)(gdImagePtr, int, int);
-       gdImagePtr dst1,dst2,dst3;
-       FuncPtr f;
-       double dRadAngle, dSinE, dTan, dShear;
-       double dOffset;     /* Variable skew offset */
-       int u, iShear, newx, newy;
-       int clrBackR, clrBackG, clrBackB, clrBackA;
-
-       /* See GEMS I for the algorithm details */
-       dRadAngle = dAngle * ROTATE_DEG2RAD; /* Angle in radians */
-       dSinE = sin (dRadAngle);
-       dTan = tan (dRadAngle / 2.0);
-
-       newx = (int)(src->sx + src->sy * fabs(dTan));
-       newy = src->sy;
-
-       /* 1st shear */
-       if (src->trueColor) {
-               f = gdImageGetTrueColorPixel;
-       } else {
-               f = gdImageGetPixel;
-       }
-
-       dst1 = gdImageCreateTrueColor(newx, newy);
-       /******* Perform 1st shear (horizontal) ******/
-       if (dst1 == NULL) {
-               return NULL;
-       }
-       dst1->alphaBlendingFlag = gdEffectReplace;
-
-       if (dAngle == 0.0) {
-               /* Returns copy of src */
-               gdImageCopy (dst1, src,0,0,0,0,src->sx,src->sy);
-               return dst1;
-       }
-
-       gdImagePaletteCopy (dst1, src);
-
-       if (ignoretransparent) {
-               if (gdImageTrueColor(src)) {
-                       dst1->transparent = src->transparent;
-               } else {
-
-                       dst1->transparent = gdTrueColorAlpha(gdImageRed(src, 
src->transparent), gdImageBlue(src, src->transparent), gdImageGreen(src, 
src->transparent), 127);
-               }
-       }
-
-       dRadAngle = dAngle * ROTATE_DEG2RAD; /* Angle in radians */
-       dSinE = sin (dRadAngle);
-       dTan = tan (dRadAngle / 2.0);
-
-       for (u = 0; u < dst1->sy; u++) {
-               if (dTan >= 0.0) {
-                       dShear = ((double)(u + 0.5)) * dTan;
-               } else {
-                       dShear = ((double)(u - dst1->sy) + 0.5) * dTan;
-               }
-
-               iShear = (int)floor(dShear);
-               gdImageSkewX(dst1, src, u, iShear, (dShear - iShear), clrBack, 
ignoretransparent);
-       }
-
-       /*
-       The 1st shear may use the original clrBack as color index
-       Convert it once here
-       */
-       if(!src->trueColor) {
-               clrBackR = gdImageRed(src, clrBack);
-               clrBackG = gdImageGreen(src, clrBack);
-               clrBackB = gdImageBlue(src, clrBack);
-               clrBackA = gdImageAlpha(src, clrBack);
-               clrBack =  gdTrueColorAlpha(clrBackR, clrBackG, clrBackB, 
clrBackA);
-       }
-       /* 2nd shear */
-       newx = dst1->sx;
-
-       if (dSinE > 0.0) {
-               dOffset = (src->sx-1) * dSinE;
-       } else {
-               dOffset = -dSinE *  (src->sx - newx);
-       }
-
-       newy = (int) ((double) src->sx * fabs( dSinE ) + (double) src->sy * cos 
(dRadAngle))+1;
-
-       if (src->trueColor) {
-               f = gdImageGetTrueColorPixel;
-       } else {
-               f = gdImageGetPixel;
-       }
-       dst2 = gdImageCreateTrueColor(newx, newy);
-       if (dst2 == NULL) {
-               gdImageDestroy(dst1);
-               return NULL;
-       }
-       dst2->alphaBlendingFlag = gdEffectReplace;
-       if (ignoretransparent) {
-               dst2->transparent = dst1->transparent;
-       }
-
-       for (u = 0; u < dst2->sx; u++, dOffset -= dSinE) {
-               iShear = (int)floor (dOffset);
-               gdImageSkewY(dst2, dst1, u, iShear, (dOffset - (double)iShear), 
clrBack, ignoretransparent);
-       }
-
-       /* 3rd shear */
-       gdImageDestroy(dst1);
-
-       newx = (int) ((double)src->sy * fabs (dSinE) + (double)src->sx * cos 
(dRadAngle)) + 1;
-       newy = dst2->sy;
-
-       if (src->trueColor) {
-               f = gdImageGetTrueColorPixel;
-       } else {
-               f = gdImageGetPixel;
-       }
-       dst3 = gdImageCreateTrueColor(newx, newy);
-       if (dst3 == NULL) {
-               gdImageDestroy(dst2);
-               return NULL;
-       }
-
-       dst3->alphaBlendingFlag = gdEffectReplace;
-       if (ignoretransparent) {
-               dst3->transparent = dst2->transparent;
-       }
-
-       if (dSinE >= 0.0) {
-               dOffset = (double)(src->sx - 1) * dSinE * -dTan;
-       } else {
-               dOffset = dTan * ((double)(src->sx - 1) * -dSinE + (double)(1 - 
newy));
-       }
-
-       for (u = 0; u < dst3->sy; u++, dOffset += dTan) {
-               int iShear = (int)floor(dOffset);
-               gdImageSkewX(dst3, dst2, u, iShear, (dOffset - iShear), 
clrBack, ignoretransparent);
-       }
-
-       gdImageDestroy(dst2);
-
-       return dst3;
-}
-
-gdImagePtr gdImageRotate (gdImagePtr src, double dAngle, int clrBack, int 
ignoretransparent)
-{
-       gdImagePtr pMidImg;
-       gdImagePtr rotatedImg;
-
-       if (src == NULL) {
-               return NULL;
-       }
-
-       if (!gdImageTrueColor(src) && (clrBack < 0 || 
clrBack>=gdImageColorsTotal(src))) {
-               return NULL;
-       }
-
-       while (dAngle >= 360.0) {
-               dAngle -= 360.0;
-       }
-
-       while (dAngle < 0) {
-               dAngle += 360.0;
-       }
-
-       if (dAngle == 90.00) {
-               return gdImageRotate90(src, ignoretransparent);
-       }
-       if (dAngle == 180.00) {
-               return gdImageRotate180(src, ignoretransparent);
-       }
-       if(dAngle == 270.00) {
-               return gdImageRotate270 (src, ignoretransparent);
-       }
-
-       if ((dAngle > 45.0) && (dAngle <= 135.0)) {
-               pMidImg = gdImageRotate90 (src, ignoretransparent);
-               dAngle -= 90.0;
-       } else if ((dAngle > 135.0) && (dAngle <= 225.0)) {
-               pMidImg = gdImageRotate180 (src, ignoretransparent);
-               dAngle -= 180.0;
-       } else if ((dAngle > 225.0) && (dAngle <= 315.0)) {
-               pMidImg = gdImageRotate270 (src, ignoretransparent);
-               dAngle -= 270.0;
-       } else {
-               return gdImageRotate45 (src, dAngle, clrBack, 
ignoretransparent);
-       }
-
-       if (pMidImg == NULL) {
-               return NULL;
-       }
-
-       rotatedImg = gdImageRotate45 (pMidImg, dAngle, clrBack, 
ignoretransparent);
-       gdImageDestroy(pMidImg);
-
-       return rotatedImg;
-}
-/* End Rotate function */
-
 void gdImagePolygon (gdImagePtr im, gdPointPtr p, int n, int c)
 {
        int i;
http://cvs.php.net/viewvc.cgi/php-src/ext/gd/libgd/gd_compat.h?r1=1.4&r2=1.5&diff_format=u
Index: php-src/ext/gd/libgd/gd_compat.h
diff -u php-src/ext/gd/libgd/gd_compat.h:1.4 
php-src/ext/gd/libgd/gd_compat.h:1.5
--- php-src/ext/gd/libgd/gd_compat.h:1.4        Tue May 26 19:34:18 2009
+++ php-src/ext/gd/libgd/gd_compat.h    Wed May 27 07:16:55 2009
@@ -53,6 +53,7 @@
 void gdImageEllipse(gdImagePtr im, int cx, int cy, int w, int h, int c);
 #endif
 
+gdImagePtr gdImageRotate (gdImagePtr src, double dAngle, int clrBack, int 
ignoretransparent);
 
 #endif
 

http://cvs.php.net/viewvc.cgi/php-src/ext/gd/libgd/gd_rotate.c?view=markup&rev=1.1
Index: php-src/ext/gd/libgd/gd_rotate.c
+++ php-src/ext/gd/libgd/gd_rotate.c
#if HAVE_GD_BUNDLED
# include "gd.h"
#else
# include <gd.h>
#endif

#include "gd_intern.h"
#include <math.h>

/*
 * Rotate function Added on 2003/12
 * by Pierre-Alain Joye (pie...@php.net)
 **/
/* Begin rotate function */
#ifdef ROTATE_PI
#undef ROTATE_PI
#endif /* ROTATE_PI */

#define ROTATE_DEG2RAD  3.1415926535897932384626433832795/180
void gdImageSkewX (gdImagePtr dst, gdImagePtr src, int uRow, int iOffset, 
double dWeight, int clrBack, int ignoretransparent)
{
        typedef int (*FuncPtr)(gdImagePtr, int, int);
        int i, r, g, b, a, clrBackR, clrBackG, clrBackB, clrBackA;
        FuncPtr f;

        int pxlOldLeft, pxlLeft=0, pxlSrc;

        /* Keep clrBack as color index if required */
        if (src->trueColor) {
                pxlOldLeft = clrBack;
                f = gdImageGetTrueColorPixel;
        } else {
                pxlOldLeft = clrBack;
                clrBackR = gdImageRed(src, clrBack);
                clrBackG = gdImageGreen(src, clrBack);
                clrBackB = gdImageBlue(src, clrBack);
                clrBackA = gdImageAlpha(src, clrBack);
                clrBack =  gdTrueColorAlpha(clrBackR, clrBackG, clrBackB, 
clrBackA);
                f = gdImageGetPixel;
        }

        for (i = 0; i < iOffset; i++) {
                gdImageSetPixel (dst, i, uRow, clrBack);
        }

        if (i < dst->sx) {
                gdImageSetPixel (dst, i, uRow, clrBack);
        }

        for (i = 0; i < src->sx; i++) {
                pxlSrc = f (src,i,uRow);

                r = (int)(gdImageRed(src,pxlSrc) * dWeight);
                g = (int)(gdImageGreen(src,pxlSrc) * dWeight);
                b = (int)(gdImageBlue(src,pxlSrc) * dWeight);
                a = (int)(gdImageAlpha(src,pxlSrc) * dWeight);

                pxlLeft = gdImageColorAllocateAlpha(src, r, g, b, a);

                if (pxlLeft == -1) {
                        pxlLeft = gdImageColorClosestAlpha(src, r, g, b, a);
                }

                r = gdImageRed(src,pxlSrc) - (gdImageRed(src,pxlLeft) - 
gdImageRed(src,pxlOldLeft));
                g = gdImageGreen(src,pxlSrc) - (gdImageGreen(src,pxlLeft) - 
gdImageGreen(src,pxlOldLeft));
                b = gdImageBlue(src,pxlSrc) - (gdImageBlue(src,pxlLeft) - 
gdImageBlue(src,pxlOldLeft));
                a = gdImageAlpha(src,pxlSrc) - (gdImageAlpha(src,pxlLeft) - 
gdImageAlpha(src,pxlOldLeft));

        if (r>255) {
                r = 255;
        }

                if (g>255) {
                        g = 255;
                }

                if (b>255) {
                        b = 255;
                }

                if (a>127) {
                        a = 127;
                }

                if (ignoretransparent && pxlSrc == dst->transparent) {
                        pxlSrc = dst->transparent;
                } else {
                        pxlSrc = gdImageColorAllocateAlpha(dst, r, g, b, a);

                        if (pxlSrc == -1) {
                                pxlSrc = gdImageColorClosestAlpha(dst, r, g, b, 
a);
                        }
                }

                if ((i + iOffset >= 0) && (i + iOffset < dst->sx)) {
                        gdImageSetPixel (dst, i+iOffset, uRow,  pxlSrc);
                }

                pxlOldLeft = pxlLeft;
        }

        i += iOffset;

        if (i < dst->sx) {
                gdImageSetPixel (dst, i, uRow, pxlLeft);
        }

        gdImageSetPixel (dst, iOffset, uRow, clrBack);

        i--;

        while (++i < dst->sx) {
                gdImageSetPixel (dst, i, uRow, clrBack);
        }
}

void gdImageSkewY (gdImagePtr dst, gdImagePtr src, int uCol, int iOffset, 
double dWeight, int clrBack, int ignoretransparent)
{
        typedef int (*FuncPtr)(gdImagePtr, int, int);
        int i, iYPos=0, r, g, b, a;
        FuncPtr f;
        int pxlOldLeft, pxlLeft=0, pxlSrc;

        if (src->trueColor) {
                f = gdImageGetTrueColorPixel;
        } else {
                f = gdImageGetPixel;
        }

        for (i = 0; i<=iOffset; i++) {
                gdImageSetPixel (dst, uCol, i, clrBack);
        }
        r = (int)((double)gdImageRed(src,clrBack) * dWeight);
        g = (int)((double)gdImageGreen(src,clrBack) * dWeight);
        b = (int)((double)gdImageBlue(src,clrBack) * dWeight);
        a = (int)((double)gdImageAlpha(src,clrBack) * dWeight);

        pxlOldLeft = gdImageColorAllocateAlpha(dst, r, g, b, a);

        for (i = 0; i < src->sy; i++) {
                pxlSrc = f (src, uCol, i);
                iYPos = i + iOffset;

                r = (int)((double)gdImageRed(src,pxlSrc) * dWeight);
                g = (int)((double)gdImageGreen(src,pxlSrc) * dWeight);
                b = (int)((double)gdImageBlue(src,pxlSrc) * dWeight);
                a = (int)((double)gdImageAlpha(src,pxlSrc) * dWeight);

                pxlLeft = gdImageColorAllocateAlpha(src, r, g, b, a);

                if (pxlLeft == -1) {
                        pxlLeft = gdImageColorClosestAlpha(src, r, g, b, a);
                }

                r = gdImageRed(src,pxlSrc) - (gdImageRed(src,pxlLeft) - 
gdImageRed(src,pxlOldLeft));
                g = gdImageGreen(src,pxlSrc) - (gdImageGreen(src,pxlLeft) - 
gdImageGreen(src,pxlOldLeft));
                b = gdImageBlue(src,pxlSrc) - (gdImageBlue(src,pxlLeft) - 
gdImageBlue(src,pxlOldLeft));
                a = gdImageAlpha(src,pxlSrc) - (gdImageAlpha(src,pxlLeft) - 
gdImageAlpha(src,pxlOldLeft));

                if (r>255) {
                        r = 255;
                }

                if (g>255) {
                        g = 255;
                }

                if (b>255) {
                        b = 255;
                }

                if (a>127) {
                        a = 127;
                }

                if (ignoretransparent && pxlSrc == dst->transparent) {
                        pxlSrc = dst->transparent;
                } else {
                        pxlSrc = gdImageColorAllocateAlpha(dst, r, g, b, a);

                        if (pxlSrc == -1) {
                                pxlSrc = gdImageColorClosestAlpha(dst, r, g, b, 
a);
                        }
                }

                if ((iYPos >= 0) && (iYPos < dst->sy)) {
                        gdImageSetPixel (dst, uCol, iYPos, pxlSrc);
                }

                pxlOldLeft = pxlLeft;
        }

        i = iYPos;
        if (i < dst->sy) {
                gdImageSetPixel (dst, uCol, i, pxlLeft);
        }

        i--;
        while (++i < dst->sy) {
                gdImageSetPixel (dst, uCol, i, clrBack);
        }
}

/* Rotates an image by 90 degrees (counter clockwise) */
gdImagePtr gdImageRotate90 (gdImagePtr src, int ignoretransparent)
{
        int uY, uX;
        int c,r,g,b,a;
        gdImagePtr dst;
        typedef int (*FuncPtr)(gdImagePtr, int, int);
        FuncPtr f;

        if (src->trueColor) {
                f = gdImageGetTrueColorPixel;
        } else {
                f = gdImageGetPixel;
        }
        dst = gdImageCreateTrueColor(src->sy, src->sx);
        dst->transparent = src->transparent;

        if (dst != NULL) {
                int old_blendmode = dst->alphaBlendingFlag;
                dst->alphaBlendingFlag = 0;

                gdImagePaletteCopy (dst, src);

                for (uY = 0; uY<src->sy; uY++) {
                        for (uX = 0; uX<src->sx; uX++) {
                                c = f (src, uX, uY);
                                if (!src->trueColor) {
                                        r = gdImageRed(src,c);
                                        g = gdImageGreen(src,c);
                                        b = gdImageBlue(src,c);
                                        a = gdImageAlpha(src,c);
                                        c = gdTrueColorAlpha(r, g, b, a);
                                }
                                if (ignoretransparent && c == dst->transparent) 
{
                                        gdImageSetPixel(dst, uY, (dst->sy - uX 
- 1), dst->transparent);
                                } else {
                                        gdImageSetPixel(dst, uY, (dst->sy - uX 
- 1), c);
                                }
                        }
                }
                dst->alphaBlendingFlag = old_blendmode;
        }

        return dst;
}

/* Rotates an image by 180 degrees (counter clockwise) */
gdImagePtr gdImageRotate180 (gdImagePtr src, int ignoretransparent)
{
        int uY, uX;
        int c,r,g,b,a;
        gdImagePtr dst;
        typedef int (*FuncPtr)(gdImagePtr, int, int);
        FuncPtr f;

        if (src->trueColor) {
                f = gdImageGetTrueColorPixel;
        } else {
                f = gdImageGetPixel;
        }
        dst = gdImageCreateTrueColor(src->sx, src->sy);
        dst->transparent = src->transparent;

        if (dst != NULL) {
                int old_blendmode = dst->alphaBlendingFlag;
                dst->alphaBlendingFlag = 0;

                gdImagePaletteCopy (dst, src);

                for (uY = 0; uY<src->sy; uY++) {
                        for (uX = 0; uX<src->sx; uX++) {
                                c = f (src, uX, uY);
                                if (!src->trueColor) {
                                        r = gdImageRed(src,c);
                                        g = gdImageGreen(src,c);
                                        b = gdImageBlue(src,c);
                                        a = gdImageAlpha(src,c);
                                        c = gdTrueColorAlpha(r, g, b, a);
                                }

                                if (ignoretransparent && c == dst->transparent) 
{
                                        gdImageSetPixel(dst, (dst->sx - uX - 
1), (dst->sy - uY - 1), dst->transparent);
                                } else {
                                        gdImageSetPixel(dst, (dst->sx - uX - 
1), (dst->sy - uY - 1), c);
                                }
                        }
                }
                dst->alphaBlendingFlag = old_blendmode;
        }

        return dst;
}

/* Rotates an image by 270 degrees (counter clockwise) */
gdImagePtr gdImageRotate270 (gdImagePtr src, int ignoretransparent)
{
        int uY, uX;
        int c,r,g,b,a;
        gdImagePtr dst;
        typedef int (*FuncPtr)(gdImagePtr, int, int);
        FuncPtr f;

        if (src->trueColor) {
                f = gdImageGetTrueColorPixel;
        } else {
                f = gdImageGetPixel;
        }
        dst = gdImageCreateTrueColor (src->sy, src->sx);
        dst->transparent = src->transparent;

        if (dst != NULL) {
                int old_blendmode = dst->alphaBlendingFlag;
                dst->alphaBlendingFlag = 0;

                gdImagePaletteCopy (dst, src);

                for (uY = 0; uY<src->sy; uY++) {
                        for (uX = 0; uX<src->sx; uX++) {
                                c = f (src, uX, uY);
                                if (!src->trueColor) {
                                        r = gdImageRed(src,c);
                                        g = gdImageGreen(src,c);
                                        b = gdImageBlue(src,c);
                                        a = gdImageAlpha(src,c);
                                        c = gdTrueColorAlpha(r, g, b, a);
                                }

                                if (ignoretransparent && c == dst->transparent) 
{
                                        gdImageSetPixel(dst, (dst->sx - uY - 
1), uX, dst->transparent);
                                } else {
                                        gdImageSetPixel(dst, (dst->sx - uY - 
1), uX, c);
                                }
                        }
                }
                dst->alphaBlendingFlag = old_blendmode;
        }

        return dst;
}

gdImagePtr gdImageRotate45 (gdImagePtr src, double dAngle, int clrBack, int 
ignoretransparent)
{
        typedef int (*FuncPtr)(gdImagePtr, int, int);
        gdImagePtr dst1,dst2,dst3;
        FuncPtr f;
        double dRadAngle, dSinE, dTan, dShear;
        double dOffset;     /* Variable skew offset */
        int u, iShear, newx, newy;
        int clrBackR, clrBackG, clrBackB, clrBackA;

        /* See GEMS I for the algorithm details */
        dRadAngle = dAngle * ROTATE_DEG2RAD; /* Angle in radians */
        dSinE = sin (dRadAngle);
        dTan = tan (dRadAngle / 2.0);

        newx = (int)(src->sx + src->sy * fabs(dTan));
        newy = src->sy;

        /* 1st shear */
        if (src->trueColor) {
                f = gdImageGetTrueColorPixel;
        } else {
                f = gdImageGetPixel;
        }

        dst1 = gdImageCreateTrueColor(newx, newy);
        /******* Perform 1st shear (horizontal) ******/
        if (dst1 == NULL) {
                return NULL;
        }
#ifdef HAVE_GD_BUNDLED
        dst1->alphaBlendingFlag = gdEffectReplace;
#else
        gdImageAlphaBlending(dst1, 0);
#endif
        if (dAngle == 0.0) {
                /* Returns copy of src */
                gdImageCopy (dst1, src,0,0,0,0,src->sx,src->sy);
                return dst1;
        }

        gdImagePaletteCopy (dst1, src);

        if (ignoretransparent) {
                if (gdImageTrueColor(src)) {
                        dst1->transparent = src->transparent;
                } else {

                        dst1->transparent = gdTrueColorAlpha(gdImageRed(src, 
src->transparent), gdImageBlue(src, src->transparent), gdImageGreen(src, 
src->transparent), 127);
                }
        }

        dRadAngle = dAngle * ROTATE_DEG2RAD; /* Angle in radians */
        dSinE = sin (dRadAngle);
        dTan = tan (dRadAngle / 2.0);

        for (u = 0; u < dst1->sy; u++) {
                if (dTan >= 0.0) {
                        dShear = ((double)(u + 0.5)) * dTan;
                } else {
                        dShear = ((double)(u - dst1->sy) + 0.5) * dTan;
                }

                iShear = (int)floor(dShear);
                gdImageSkewX(dst1, src, u, iShear, (dShear - iShear), clrBack, 
ignoretransparent);
        }

        /*
        The 1st shear may use the original clrBack as color index
        Convert it once here
        */
        if(!src->trueColor) {
                clrBackR = gdImageRed(src, clrBack);
                clrBackG = gdImageGreen(src, clrBack);
                clrBackB = gdImageBlue(src, clrBack);
                clrBackA = gdImageAlpha(src, clrBack);
                clrBack =  gdTrueColorAlpha(clrBackR, clrBackG, clrBackB, 
clrBackA);
        }
        /* 2nd shear */
        newx = dst1->sx;

        if (dSinE > 0.0) {
                dOffset = (src->sx-1) * dSinE;
        } else {
                dOffset = -dSinE *  (src->sx - newx);
        }

        newy = (int) ((double) src->sx * fabs( dSinE ) + (double) src->sy * cos 
(dRadAngle))+1;

        if (src->trueColor) {
                f = gdImageGetTrueColorPixel;
        } else {
                f = gdImageGetPixel;
        }
        dst2 = gdImageCreateTrueColor(newx, newy);
        if (dst2 == NULL) {
                gdImageDestroy(dst1);
                return NULL;
        }

#ifdef HAVE_GD_BUNDLED
        dst2->alphaBlendingFlag = gdEffectReplace;
#else
        gdImageAlphaBlending(dst2, 0);
#endif

        if (ignoretransparent) {
                dst2->transparent = dst1->transparent;
        }

        for (u = 0; u < dst2->sx; u++, dOffset -= dSinE) {
                iShear = (int)floor (dOffset);
                gdImageSkewY(dst2, dst1, u, iShear, (dOffset - (double)iShear), 
clrBack, ignoretransparent);
        }

        /* 3rd shear */
        gdImageDestroy(dst1);

        newx = (int) ((double)src->sy * fabs (dSinE) + (double)src->sx * cos 
(dRadAngle)) + 1;
        newy = dst2->sy;

        if (src->trueColor) {
                f = gdImageGetTrueColorPixel;
        } else {
                f = gdImageGetPixel;
        }
        dst3 = gdImageCreateTrueColor(newx, newy);
        if (dst3 == NULL) {
                gdImageDestroy(dst2);
                return NULL;
        }

#ifdef HAVE_GD_BUNDLED
        dst3->alphaBlendingFlag = gdEffectReplace;
#else
        gdImageAlphaBlending(dst3, 0);
#endif

        if (ignoretransparent) {
                dst3->transparent = dst2->transparent;
        }

        if (dSinE >= 0.0) {
                dOffset = (double)(src->sx - 1) * dSinE * -dTan;
        } else {
                dOffset = dTan * ((double)(src->sx - 1) * -dSinE + (double)(1 - 
newy));
        }

        for (u = 0; u < dst3->sy; u++, dOffset += dTan) {
                int iShear = (int)floor(dOffset);
                gdImageSkewX(dst3, dst2, u, iShear, (dOffset - iShear), 
clrBack, ignoretransparent);
        }

        gdImageDestroy(dst2);

        return dst3;
}

gdImagePtr gdImageRotate (gdImagePtr src, double dAngle, int clrBack, int 
ignoretransparent)
{
        gdImagePtr pMidImg;
        gdImagePtr rotatedImg;

        if (src == NULL) {
                return NULL;
        }

        if (!gdImageTrueColor(src) && (clrBack < 0 || 
clrBack>=gdImageColorsTotal(src))) {
                return NULL;
        }

        while (dAngle >= 360.0) {
                dAngle -= 360.0;
        }

        while (dAngle < 0) {
                dAngle += 360.0;
        }

        if (dAngle == 90.00) {
                return gdImageRotate90(src, ignoretransparent);
        }
        if (dAngle == 180.00) {
                return gdImageRotate180(src, ignoretransparent);
        }
        if(dAngle == 270.00) {
                return gdImageRotate270 (src, ignoretransparent);
        }

        if ((dAngle > 45.0) && (dAngle <= 135.0)) {
                pMidImg = gdImageRotate90 (src, ignoretransparent);
                dAngle -= 90.0;
        } else if ((dAngle > 135.0) && (dAngle <= 225.0)) {
                pMidImg = gdImageRotate180 (src, ignoretransparent);
                dAngle -= 180.0;
        } else if ((dAngle > 225.0) && (dAngle <= 315.0)) {
                pMidImg = gdImageRotate270 (src, ignoretransparent);
                dAngle -= 270.0;
        } else {
                return gdImageRotate45 (src, dAngle, clrBack, 
ignoretransparent);
        }

        if (pMidImg == NULL) {
                return NULL;
        }

        rotatedImg = gdImageRotate45 (pMidImg, dAngle, clrBack, 
ignoretransparent);
        gdImageDestroy(pMidImg);

        return rotatedImg;
}
/* End Rotate function */



-- 
PHP CVS Mailing List (http://www.php.net/)
To unsubscribe, visit: http://www.php.net/unsub.php

Reply via email to