Synchronized bundled GD library with GD 2.0.22.

Author: Ilia Alshanetsky

ext/gd/gd.c

@@ -453,7 +453,7 @@ PHP_RSHUTDOWN_FUNCTION(gd)
 /* }}} */
 
 #if HAVE_GD_BUNDLED
-#define PHP_GD_VERSION_STRING "bundled (2.0.17 compatible)"
+#define PHP_GD_VERSION_STRING "bundled (2.0.22 compatible)"
 #elif HAVE_LIBGD20
 #define PHP_GD_VERSION_STRING "2.0 or higher"
 #elif HAVE_GDIMAGECOLORRESOLVE

ext/gd/libgd/gd.c

@@ -2300,15 +2300,17 @@ void gdImageCopyResized (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int
 					  	int tmp = gdImageGetPixel (src, x, y);
 		  				mapTo = gdImageGetTrueColorPixel (src, x, y);
 					  	if (gdImageGetTransparent (src) == tmp) {
-					  		tox++;
+							/* 2.0.21, TK: not tox++ */
+							tox += stx[x - srcX];
 					  		continue;
 					  	}
 					} else {
 						/* TK: old code follows */
 					  	mapTo = gdImageGetTrueColorPixel (src, x, y);
 						/* Added 7/24/95: support transparent copies */
 						if (gdImageGetTransparent (src) == mapTo) {
-							tox++;
+							/* 2.0.21, TK: not tox++ */
+							tox += stx[x - srcX];
 							continue;
 						}
 					}
@@ -2364,22 +2366,24 @@ void gdImageCopyResized (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int
 void gdImageCopyResampled (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH)
 {
 	int x, y;
+	double sy1, sy2, sx1, sx2;
 	if (!dst->trueColor) {
 		gdImageCopyResized (dst, src, dstX, dstY, srcX, srcY, dstW, dstH, srcW, srcH);
 		return;
 	}
 	for (y = dstY; (y < dstY + dstH); y++) {
+		sy1 = ((double) y - (double) dstY) * (double) srcH / (double) dstH;
+		sy2 = ((double) (y + 1) - (double) dstY) * (double) srcH / (double) dstH;
 		for (x = dstX; (x < dstX + dstW); x++) {
-			float sy1, sy2, sx1, sx2;
-			float sx, sy;
-			float spixels = 0.0f;
-			float red = 0.0f, green = 0.0f, blue = 0.0f, alpha = 0.0f;
-			float alpha_factor, alpha_sum = 0.0f, contrib_sum = 0.0f;
-			sy1 = ((float)(y - dstY)) * (float)srcH / (float)dstH;
-			sy2 = ((float)(y + 1 - dstY)) * (float) srcH / (float) dstH;
+			double sx, sy;
+			double spixels = 0;
+			double red = 0.0, green = 0.0, blue = 0.0, alpha = 0.0;
+			double alpha_factor, alpha_sum = 0.0, contrib_sum = 0.0;
+			sx1 = ((double) x - (double) dstX) * (double) srcW / dstW;
+			sx2 = ((double) (x + 1) - (double) dstX) * (double) srcW / dstW;
 			sy = sy1;
 			do {
-				float yportion;
+				double yportion;
 				if (floor_cast(sy) == floor_cast(sy1)) {
 					yportion = 1.0f - (sy - floor_cast(sy));
 					if (yportion > sy2 - sy1) {
@@ -2391,12 +2395,10 @@ void gdImageCopyResampled (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, i
 				} else {
 					yportion = 1.0f;
 				}
-				sx1 = ((float)(x - dstX)) * (float) srcW / dstW;
-				sx2 = ((float)(x + 1 - dstX)) * (float) srcW / dstW;
 				sx = sx1;
 				do {
-					float xportion;
-					float pcontribution;
+					double xportion;
+					double pcontribution;
 					int p;
 					if (floorf(sx) == floor_cast(sx1)) {
 						xportion = 1.0f - (sx - floor_cast(sx));

ext/gd/libgd/gd.h

@@ -579,6 +579,7 @@ void gdImageSaveAlpha(gdImagePtr im, int saveAlphaArg);
 
 gdIOCtx* gdNewFileCtx(FILE*);
 gdIOCtx* gdNewDynamicCtx(int, void*);
+gdIOCtx *gdNewDynamicCtxEx(int size, void *data, int freeFlag);
 gdIOCtx* gdNewSSCtx(gdSourcePtr in, gdSinkPtr out);
 void* gdDPExtractData(struct gdIOCtx* ctx, int *size);
 

ext/gd/libgd/gd_gd.c

@@ -146,6 +146,16 @@ gdImagePtr gdImageCreateFromGd (FILE * inFile)
 	return im;
 }
 
+gdImagePtr gdImageCreateFromGdPtr (int size, void *data)
+{
+	gdImagePtr im;
+	gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0);
+	im = gdImageCreateFromGdCtx(in);
+	in->gd_free(in);
+
+	return im;
+}
+
 gdImagePtr gdImageCreateFromGdCtx (gdIOCtxPtr in)
 {
 	int sx, sy;

ext/gd/libgd/gd_gd2.c

@@ -236,6 +236,16 @@ gdImagePtr gdImageCreateFromGd2 (FILE * inFile)
 	return im;
 }
 
+gdImagePtr gdImageCreateFromGd2Ptr (int size, void *data)
+{
+	gdImagePtr im;
+	gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0);
+	im = gdImageCreateFromGd2Ctx(in);
+	in->gd_free(in);
+
+	return im;
+}
+
 gdImagePtr gdImageCreateFromGd2Ctx (gdIOCtxPtr in)
 {
 	int sx, sy;
@@ -377,6 +387,16 @@ gdImagePtr gdImageCreateFromGd2Ctx (gdIOCtxPtr in)
 	return 0;
 }
 
+gdImagePtr gdImageCreateFromGd2PartPtr (int size, void *data, int srcx, int srcy, int w, int h)
+{
+	gdImagePtr im;
+	gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0);
+	im = gdImageCreateFromGd2PartCtx(in, srcx, srcy, w, h);
+	in->gd_free(in);
+
+	return im;
+}
+
 gdImagePtr gdImageCreateFromGd2Part (FILE * inFile, int srcx, int srcy, int w, int h)
 {
 	gdImagePtr im;

ext/gd/libgd/gd_io_dp.c

@@ -33,6 +33,7 @@ typedef struct dpStruct
 	int realSize;
 	int dataGood;
 	int pos;
+	int freeOK;
 } dynamicPtr;
 
 typedef struct dpIOCtx
@@ -49,7 +50,7 @@ static int appendDynamic (dynamicPtr * dp, const void *src, int size);
 static int gdReallocDynamic (dynamicPtr * dp, int required);
 static int trimDynamic (dynamicPtr * dp);
 static void gdFreeDynamicCtx (struct gdIOCtx *ctx);
-static dynamicPtr *newDynamic (int initialSize, void *data);
+static dynamicPtr *newDynamic (int initialSize, void *data, int freeOKFlag);
 
 static int dynamicPutbuf (struct gdIOCtx *, const void *, int);
 static void dynamicPutchar (struct gdIOCtx *, int a);
@@ -62,13 +63,18 @@ static long dynamicTell (struct gdIOCtx *);
 
 /* return data as a dynamic pointer */
 gdIOCtx * gdNewDynamicCtx (int initialSize, void *data)
+{
+	return gdNewDynamicCtxEx(initialSize, data, 1);
+}
+
+gdIOCtx * gdNewDynamicCtxEx (int initialSize, void *data, int freeOKFlag)
 {
 	dpIOCtx *ctx;
 	dynamicPtr *dp;
 
 	ctx = (dpIOCtx *) gdMalloc (sizeof (dpIOCtx));
 
-	dp = newDynamic(initialSize, data);
+	dp = newDynamic(initialSize, data, freeOKFlag);
 
 	ctx->dp = dp;
 
@@ -103,7 +109,7 @@ void * gdDPExtractData (struct gdIOCtx *ctx, int *size)
 	} else {
 		*size = 0;
 		data = NULL;
-		if (dp->data != NULL) {
+		if (dp->data != NULL && dp->freeOK) {
 			gdFree(dp->data);
 		}
 	}
@@ -155,6 +161,10 @@ static int dynamicSeek (struct gdIOCtx *ctx, const int pos)
 
 	bytesNeeded = pos;
 	if (bytesNeeded > dp->realSize) {
+		/* 2.0.21 */
+		if (!dp->freeOK) {
+			return FALSE;
+		}
 		gdReallocDynamic (dp, dp->realSize * 2);
 	}
 
@@ -171,14 +181,15 @@ static int dynamicSeek (struct gdIOCtx *ctx, const int pos)
 }
 
 /* return data as a dynamic pointer */
-static dynamicPtr * newDynamic (int initialSize, void *data)
+static dynamicPtr * newDynamic (int initialSize, void *data, int freeOKFlag)
 {
 	dynamicPtr *dp;
 	dp = (dynamicPtr *) gdMalloc (sizeof (dynamicPtr));
 
 	allocDynamic (dp, initialSize, data);
 
 	dp->pos = 0;
+	dp->freeOK = freeOKFlag;
 
 	return dp;
 }
@@ -292,6 +303,10 @@ static int appendDynamic (dynamicPtr * dp, const void *src, int size)
 	bytesNeeded = dp->pos + size;
 
 	if (bytesNeeded > dp->realSize) {
+		/* 2.0.21 */
+		if (!dp->freeOK) {
+			return FALSE;
+		}
 		gdReallocDynamic(dp, bytesNeeded * 2);
 	}
 
@@ -337,5 +352,9 @@ static int gdReallocDynamic (dynamicPtr * dp, int required)
 /* trim pointer so that its real and logical sizes match */
 static int trimDynamic (dynamicPtr * dp)
 {
+	/* 2.0.21: we don't reallocate memory we don't own */
+	if (!dp->freeOK) {
+		return FALSE;
+	}
 	return gdReallocDynamic(dp, dp->logicalSize);
 }

ext/gd/libgd/gd_jpeg.c

@@ -217,8 +217,20 @@ gdImagePtr gdImageCreateFromJpeg (FILE * inFile)
 	return im;
 }
 
+gdImagePtr gdImageCreateFromJpegPtr (int size, void *data)
+{
+	gdImagePtr im;
+	gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0);
+	im = gdImageCreateFromJpegCtx(in);
+	in->gd_free(in);
+
+	return im;
+}
+
 void jpeg_gdIOCtx_src (j_decompress_ptr cinfo, gdIOCtx * infile);
 
+static int CMYKToRGB(int c, int m, int y, int k, int inverted);
+
 /*
  * Create a gd-format image from the JPEG-format INFILE.  Returns the
  * image, or NULL upon error.
@@ -235,6 +247,8 @@ gdImagePtr gdImageCreateFromJpegCtx (gdIOCtx * infile)
 	unsigned int i, j;
 	int retval;
 	JDIMENSION nrows;
+	int channels = 3;
+	int inverted = 0;
 
 	memset (&cinfo, 0, sizeof (cinfo));
 	memset (&jerr, 0, sizeof (jerr));
@@ -258,6 +272,9 @@ gdImagePtr gdImageCreateFromJpegCtx (gdIOCtx * infile)
 
 	jpeg_gdIOCtx_src (&cinfo, infile);
 
+	/* 2.0.22: save the APP14 marker to check for Adobe Photoshop CMYK files with inverted components. */
+	jpeg_save_markers(&cinfo, JPEG_APP0 + 14, 256);
+
 	retval = jpeg_read_header (&cinfo, TRUE);
 	if (retval != JPEG_HEADER_OK) {
 		php_gd_error_ex(E_WARNING, "gd-jpeg: warning: jpeg_read_header returned %d, expected %d", retval, JPEG_HEADER_OK);
@@ -277,8 +294,14 @@ gdImagePtr gdImageCreateFromJpegCtx (gdIOCtx * infile)
 		goto error;
 	}
 
-	/* Force the image into RGB colorspace, but don't reduce the number of colors anymore (GD 2.0) */
-	cinfo.out_color_space = JCS_RGB;
+	/* 2.0.22: very basic support for reading CMYK colorspace files. Nice for
+	 * thumbnails but there's no support for fussy adjustment of the
+	 * assumed properties of inks and paper. */
+	if ((cinfo.jpeg_color_space == JCS_CMYK) || (cinfo.jpeg_color_space == JCS_YCCK)) {
+		cinfo.out_color_space = JCS_CMYK;
+	} else {
+		cinfo.out_color_space = JCS_RGB;
+	}
 
 	if (jpeg_start_decompress (&cinfo) != TRUE) {
 		php_gd_error("gd-jpeg: warning: jpeg_start_decompress reports suspended data source");
@@ -297,8 +320,29 @@ gdImagePtr gdImageCreateFromJpegCtx (gdIOCtx * infile)
   gdImageInterlace (im, cinfo.progressive_mode != 0);
 #endif
 
-	if (cinfo.output_components != 3) {
-		php_gd_error_ex(E_WARNING, "gd-jpeg: error: JPEG color quantization request resulted in output_components == %d (expected 3)", cinfo.output_components);
+	if (cinfo.out_color_space == JCS_RGB) {
+		if (cinfo.output_components != 3) {
+			php_gd_error_ex(E_WARNING, "gd-jpeg: error: JPEG color quantization request resulted in output_components == %d (expected 3 for RGB)", cinfo.output_components);
+			goto error;
+		}
+		channels = 3;
+	} else if (cinfo.out_color_space == JCS_CMYK) {
+		jpeg_saved_marker_ptr marker;
+		if (cinfo.output_components != 4)  {
+			php_gd_error_ex(E_WARNING, "gd-jpeg: error: JPEG color quantization request resulted in output_components == %d (expected 4 for CMYK)", cinfo.output_components);
+			goto error;
+		}
+		channels = 4;
+		marker = cinfo.marker_list;
+		while (marker) {
+			if ((marker->marker == (JPEG_APP0 + 14)) && (marker->data_length >= 12) && (!strncmp((const char *) marker->data, "Adobe", 5))) {
+				inverted = 1;
+				break;
+			}
+			marker = marker->next;
+		}
+	} else {
+		php_gd_error_ex(E_WARNING, "gd-jpeg: error: unexpected colorspace.");
 		goto error;
 	}
 
@@ -307,22 +351,37 @@ gdImagePtr gdImageCreateFromJpegCtx (gdIOCtx * infile)
 	goto error;
 #endif /* BITS_IN_JSAMPLE == 12 */
 
-	row = safe_emalloc(cinfo.output_width * 3, sizeof(JSAMPLE), 0);
-	memset(row, 0, cinfo.output_width * 3 * sizeof(JSAMPLE));
+	row = safe_emalloc(cinfo.output_width * channels, sizeof(JSAMPLE), 0);
+	memset(row, 0, cinfo.output_width * channels * sizeof(JSAMPLE));
 	rowptr[0] = row;
 
-	for (i = 0; i < cinfo.output_height; i++) {
-		register JSAMPROW currow = row;
-		register int *tpix = im->tpixels[i];
-		nrows = jpeg_read_scanlines (&cinfo, rowptr, 1);
-		if (nrows != 1) {
-			php_gd_error_ex(E_WARNING, "gd-jpeg: error: jpeg_read_scanlines returns %u, expected 1", nrows);
-			goto error;
+	if (cinfo.out_color_space == JCS_CMYK) {
+		for (i = 0; i < cinfo.output_height; i++) {
+			register JSAMPROW currow = row;
+			register int *tpix = im->tpixels[i];
+			nrows = jpeg_read_scanlines (&cinfo, rowptr, 1);
+			if (nrows != 1) {
+				php_gd_error_ex(E_WARNING, "gd-jpeg: error: jpeg_read_scanlines returns %u, expected 1", nrows);
+				goto error;
+			}
+			for (j = 0; j < cinfo.output_width; j++, currow += 4, tpix++) {
+				*tpix = CMYKToRGB (currow[0], currow[1], currow[2], currow[3], inverted);
+			}
 		}
-		for (j = 0; j < cinfo.output_width; j++, currow += 3, tpix++) {
-			*tpix = gdTrueColor (currow[0], currow[1], currow[2]);
+	} else {
+		for (i = 0; i < cinfo.output_height; i++) {
+			register JSAMPROW currow = row;
+			register int *tpix = im->tpixels[i];
+			nrows = jpeg_read_scanlines (&cinfo, rowptr, 1);
+			if (nrows != 1) {
+				php_gd_error_ex(E_WARNING, "gd-jpeg: error: jpeg_read_scanlines returns %u, expected 1", nrows);
+				goto error;
+			}
+			for (j = 0; j < cinfo.output_width; j++, currow += 3, tpix++) {
+				*tpix = gdTrueColor (currow[0], currow[1], currow[2]);
+			}
 		}
-	}
+	} 
 
 	if (jpeg_finish_decompress (&cinfo) != TRUE) {
 		php_gd_error("gd-jpeg: warning: jpeg_finish_decompress reports suspended data source");
@@ -349,8 +408,19 @@ gdImagePtr gdImageCreateFromJpegCtx (gdIOCtx * infile)
 	return 0;
 }
 
-/*
+/* A very basic conversion approach, TBB */
+static int CMYKToRGB(int c, int m, int y, int k, int inverted)
+{
+	if (inverted) {
+		c = 255 - c;
+		m = 255 - m;
+		y = 255 - y;
+		k = 255 - k;
+	}
+	return gdTrueColor((255 - c) * (255 - k) / 255, (255 - m) * (255 - k) / 255, (255 - y) * (255 - k) / 255);
+}
 
+/*
  * gdIOCtx JPEG data sources and sinks, T. Boutell
  * almost a simple global replace from T. Lane's stdio versions.
  *