Whitespace fixes.

5 files changed, 762 insertions, 906 deletions

diff --git a/ext/gd/libgd/gd_gd.c b/ext/gd/libgd/gd_gd.c
index 53b1c71f99..bbad474cd1 100644
--- a/ext/gd/libgd/gd_gd.c
+++ b/ext/gd/libgd/gd_gd.c
@@ -1,4 +1,3 @@
-
 #include <stdio.h>
 #include <math.h>
 #include <string.h>
@@ -20,252 +19,199 @@ extern void gdImageGd (gdImagePtr im, FILE * out);
 /* */
 /* Shared code to read color tables from gd file. */
 /* */
-int
-_gdGetColors (gdIOCtx * in, gdImagePtr im, int gd2xFlag)
+int _gdGetColors (gdIOCtx * in, gdImagePtr im, int gd2xFlag)
 {
-  int i;
-  if (gd2xFlag)
-    {
-      if (!gdGetByte (&im->trueColor, in))
-	{
-	  goto fail1;
-	}
-      /* This should have been a word all along */
-      if (!im->trueColor)
-	{
-	  if (!gdGetWord (&im->colorsTotal, in))
-	    {
-	      goto fail1;
-	    }
-	}
-      /* Int to accommodate truecolor single-color transparency */
-      if (!gdGetInt (&im->transparent, in))
-	{
-	  goto fail1;
-	}
-    }
-  else
-    {
-      if (!gdGetByte (&im->colorsTotal, in))
-	{
-	  goto fail1;
-	}
-      if (!gdGetWord (&im->transparent, in))
-	{
-	  goto fail1;
+	int i;
+	if (gd2xFlag) {
+		if (!gdGetByte (&im->trueColor, in)) {
+			goto fail1;
+		}
+		/* This should have been a word all along */
+		if (!im->trueColor && !gdGetWord(&im->colorsTotal, in)) {
+			goto fail1;
+		}
+		/* Int to accommodate truecolor single-color transparency */
+		if (!gdGetInt(&im->transparent, in)) {
+			goto fail1;
+		}
+	} else {
+		if (!gdGetByte(&im->colorsTotal, in)) {
+			goto fail1;
+		}
+		if (!gdGetWord (&im->transparent, in)) {
+			goto fail1;
+		}
+		if (im->transparent == 257) {
+			im->transparent = (-1);
+		}
 	}
-      if (im->transparent == 257)
-	{
-	  im->transparent = (-1);
+	GD2_DBG (php_gd_error("Pallette had %d colours (T=%d)\n", im->colorsTotal, im->transparent));
+
+	for (i = 0; i < gdMaxColors; i++) {
+		if (!gdGetByte(&im->red[i], in)) {
+			goto fail1;
+		}
+		if (!gdGetByte(&im->green[i], in)) {
+			goto fail1;
+		}
+		if (!gdGetByte(&im->blue[i], in)) {
+			goto fail1;
+		}
+		if (gd2xFlag && !gdGetByte (&im->alpha[i], in)) {
+			goto fail1;
+		}
 	}
-    }
-  GD2_DBG (printf ("Pallette had %d colours (T=%d)\n", im->colorsTotal, im->transparent));
 
-  for (i = 0; (i < gdMaxColors); i++)
-    {
-      if (!gdGetByte (&im->red[i], in))
-	{
-	  goto fail1;
+	for (i = 0; (i < im->colorsTotal); i++) {
+		im->open[i] = 0;
 	}
-      if (!gdGetByte (&im->green[i], in))
-	{
-	  goto fail1;
-	}
-      if (!gdGetByte (&im->blue[i], in))
-	{
-	  goto fail1;
-	}
-      if (gd2xFlag)
-	{
-	  if (!gdGetByte (&im->alpha[i], in))
-	    {
-	      goto fail1;
-	    }
-	}
-    }
-
-  for (i = 0; (i < im->colorsTotal); i++)
-    {
-      im->open[i] = 0;
-    };
 
-  return TRUE;
+	return TRUE;
 fail1:
-  return FALSE;
+	return FALSE;
 }
 
 /* */
 /* Use the common basic header info to make the image object. */
 /* This is also called from _gd2CreateFromFile */
 /* */
-static
-  gdImagePtr
-_gdCreateFromFile (gdIOCtx * in, int *sx, int *sy)
+static gdImagePtr _gdCreateFromFile (gdIOCtx * in, int *sx, int *sy)
 {
-  gdImagePtr im;
-  int gd2xFlag = 0;
-  if (!gdGetWord (sx, in))
-    {
-      goto fail1;
-    }
-  if (*sx == 65535)
-    {
-      /* This is a gd 2.0 .gd file */
-      gd2xFlag = 1;
-      if (!gdGetWord (sx, in))
-	{
-	  goto fail1;
+	gdImagePtr im;
+	int gd2xFlag = 0;
+	if (!gdGetWord(sx, in)) {
+		goto fail1;
+	}
+	if (*sx == 65535) {
+		/* This is a gd 2.0 .gd file */
+		gd2xFlag = 1;
+		if (!gdGetWord(sx, in)) {
+			goto fail1;
+		}
+	}
+	if (!gdGetWord(sy, in)) {
+		goto fail1;
 	}
-    }
-  if (!gdGetWord (sy, in))
-    {
-      goto fail1;
-    }
 
-  GD2_DBG (printf ("Image is %dx%d\n", *sx, *sy));
+	GD2_DBG(php_gd_error("Image is %dx%d\n", *sx, *sy));
 
-  im = gdImageCreate (*sx, *sy);
+	im = gdImageCreate (*sx, *sy);
 
-  if (!_gdGetColors (in, im, gd2xFlag))
-    {
-      goto fail2;
-    }
+	if (!_gdGetColors(in, im, gd2xFlag)) {
+		goto fail2;
+	}
 
-  return im;
+	return im;
 fail2:
-  gdImageDestroy (im);
+	gdImageDestroy(im);
 fail1:
-  return 0;
+	return 0;
 }
 
-gdImagePtr
-gdImageCreateFromGd (FILE * inFile)
+gdImagePtr gdImageCreateFromGd (FILE * inFile)
 {
-  gdImagePtr im;
-  gdIOCtx *in;
+	gdImagePtr im;
+	gdIOCtx *in;
 
-  in = gdNewFileCtx (inFile);
-  im = gdImageCreateFromGdCtx (in);
+	in = gdNewFileCtx (inFile);
+	im = gdImageCreateFromGdCtx (in);
 
-  in->gd_free (in);
+	in->gd_free(in);
 
-  return im;
+	return im;
 }
 
-gdImagePtr
-gdImageCreateFromGdCtx (gdIOCtxPtr in)
+gdImagePtr gdImageCreateFromGdCtx (gdIOCtxPtr in)
 {
-  int sx, sy;
-  int x, y;
-  gdImagePtr im;
+	int sx, sy;
+	int x, y;
+	gdImagePtr im;
 
-  /* Read the header */
-  im = _gdCreateFromFile (in, &sx, &sy);
-
-  if (im == NULL)
-    {
-      goto fail1;
-    };
+	/* Read the header */
+	if ((im = _gdCreateFromFile (in, &sx, &sy)) == NULL) {
+		goto fail1;
+	}
 
-  /* Then the data... */
-  for (y = 0; (y < sy); y++)
-    {
-      for (x = 0; (x < sx); x++)
-	{
-	  int ch;
-	  ch = gdGetC (in);
-	  if (ch == EOF)
-	    {
-	      goto fail2;
-	    }
-	  /* ROW-MAJOR IN GD 1.3 */
-	  im->pixels[y][x] = ch;
+	/* Then the data... */
+	for (y = 0; y < sy; y++) {
+		for (x = 0; x < sx; x++) {
+			int ch;
+			if ((ch = gdGetC(in)) == EOF) {
+				goto fail2;
+			}
+			/* ROW-MAJOR IN GD 1.3 */
+			im->pixels[y][x] = ch;
+		}
 	}
-    }
 
-  return im;
+	return im;
 
 fail2:
-  gdImageDestroy (im);
+	gdImageDestroy (im);
 fail1:
-  return 0;
+	return 0;
 }
 
-void
-_gdPutColors (gdImagePtr im, gdIOCtx * out)
+void _gdPutColors (gdImagePtr im, gdIOCtx * out)
 {
-  int i;
+	int i;
 
-  gdPutC (im->trueColor, out);
-  if (!im->trueColor)
-    {
-      gdPutWord (im->colorsTotal, out);
-    }
-  gdPutInt (im->transparent, out);
-  if (!im->trueColor)
-    {
-      for (i = 0; (i < gdMaxColors); i++)
-	{
-	  gdPutC ((unsigned char) im->red[i], out);
-	  gdPutC ((unsigned char) im->green[i], out);
-	  gdPutC ((unsigned char) im->blue[i], out);
-	  gdPutC ((unsigned char) im->alpha[i], out);
+	gdPutC(im->trueColor, out);
+	if (!im->trueColor) {
+		gdPutWord (im->colorsTotal, out);
+	}
+	gdPutInt (im->transparent, out);
+	if (!im->trueColor) {
+		for (i = 0; (i < gdMaxColors); i++) {
+			gdPutC((unsigned char) im->red[i], out);
+			gdPutC((unsigned char) im->green[i], out);
+			gdPutC((unsigned char) im->blue[i], out);
+			gdPutC((unsigned char) im->alpha[i], out);
+		}
 	}
-    }
 }
 
-static
-void
-_gdPutHeader (gdImagePtr im, gdIOCtx * out)
+static void _gdPutHeader (gdImagePtr im, gdIOCtx * out)
 {
-  /* 65535 indicates this is a gd 2.x .gd file. */
-  gdPutWord (65535, out);
-  gdPutWord (im->sx, out);
-  gdPutWord (im->sy, out);
-
-  _gdPutColors (im, out);
+	/* 65535 indicates this is a gd 2.x .gd file. */
+	gdPutWord(65535, out);
+	gdPutWord(im->sx, out);
+	gdPutWord(im->sy, out);
 
+	_gdPutColors (im, out);
 }
 
-static void
-_gdImageGd (gdImagePtr im, gdIOCtx * out)
+static void _gdImageGd (gdImagePtr im, gdIOCtx * out)
 {
-  int x, y;
-
-  _gdPutHeader (im, out);
-
-  for (y = 0; (y < im->sy); y++)
-    {
-      for (x = 0; (x < im->sx); x++)
-	{
-	  /* ROW-MAJOR IN GD 1.3 */
-	  if (im->trueColor)
-	    {
-	      gdPutInt (im->tpixels[y][x], out);
-	    }
-	  else
-	    {
-	      gdPutC ((unsigned char) im->pixels[y][x], out);
-	    }
+	int x, y;
+
+	_gdPutHeader (im, out);
+
+	for (y = 0; y < im->sy; y++) {
+		for (x = 0; x < im->sx; x++) {
+			/* ROW-MAJOR IN GD 1.3 */
+			if (im->trueColor) {
+				gdPutInt (im->tpixels[y][x], out);
+			} else {
+				gdPutC((unsigned char) im->pixels[y][x], out);
+			}
+		}
 	}
-    }
 }
 
-void
-gdImageGd (gdImagePtr im, FILE * outFile)
+void gdImageGd (gdImagePtr im, FILE * outFile)
 {
-  gdIOCtx *out = gdNewFileCtx (outFile);
-  _gdImageGd (im, out);
-  out->gd_free (out);
+	gdIOCtx *out = gdNewFileCtx(outFile);
+	_gdImageGd(im, out);
+	out->gd_free(out);
 }
 
-void *
-gdImageGdPtr (gdImagePtr im, int *size)
+void * gdImageGdPtr (gdImagePtr im, int *size)
 {
-  void *rv;
-  gdIOCtx *out = gdNewDynamicCtx (2048, NULL);
-  _gdImageGd (im, out);
-  rv = gdDPExtractData (out, size);
-  out->gd_free (out);
-  return rv;
+	void *rv;
+	gdIOCtx *out = gdNewDynamicCtx(2048, NULL);
+	_gdImageGd(im, out);
+	rv = gdDPExtractData(out, size);
+	out->gd_free(out);
+	return rv;
 }
diff --git a/ext/gd/libgd/gd_gd2.c b/ext/gd/libgd/gd_gd2.c
index 59c711763b..07fd0aac73 100644
--- a/ext/gd/libgd/gd_gd2.c
+++ b/ext/gd/libgd/gd_gd2.c
@@ -43,8 +43,7 @@ typedef struct
 {
 	int offset;
 	int size;
-}
-t_chunk_info;
+} t_chunk_info;
 
 extern int _gdGetColors(gdIOCtx * in, gdImagePtr im, int gd2xFlag);
 extern void _gdPutColors(gdImagePtr im, gdIOCtx * out);
diff --git a/ext/gd/libgd/gd_png.c b/ext/gd/libgd/gd_png.c
index a5850c6511..534ab63d51 100644
--- a/ext/gd/libgd/gd_png.c
+++ b/ext/gd/libgd/gd_png.c
@@ -38,696 +38,628 @@
 
 #ifndef PNG_SETJMP_NOT_SUPPORTED
 typedef struct _jmpbuf_wrapper
-  {
-    jmp_buf jmpbuf;
-  }
-jmpbuf_wrapper;
+{
+	jmp_buf jmpbuf;
+} jmpbuf_wrapper;
 
 static jmpbuf_wrapper gdPngJmpbufStruct;
 
-static void
-gdPngErrorHandler (png_structp png_ptr, png_const_charp msg)
+static void gdPngErrorHandler (png_structp png_ptr, png_const_charp msg)
 {
-  jmpbuf_wrapper *jmpbuf_ptr;
-
-  /* This function, aside from the extra step of retrieving the "error
-   * pointer" (below) and the fact that it exists within the application
-   * rather than within libpng, is essentially identical to libpng's
-   * default error handler.  The second point is critical:  since both
-   * setjmp() and longjmp() are called from the same code, they are
-   * guaranteed to have compatible notions of how big a jmp_buf is,
-   * regardless of whether _BSD_SOURCE or anything else has (or has not)
-   * been defined. */
-
-  php_gd_error_ex(E_ERROR, "gd-png:  fatal libpng error: %s\n", msg);
-
-  jmpbuf_ptr = png_get_error_ptr (png_ptr);
-  if (jmpbuf_ptr == NULL)
-    {				/* we are completely hosed now */
-      php_gd_error_ex(E_ERROR, "gd-png:  EXTREMELY fatal error: jmpbuf unrecoverable; terminating.\n");
-      exit (99);
-    }
+	jmpbuf_wrapper *jmpbuf_ptr;
+
+	/* This function, aside from the extra step of retrieving the "error
+	 * pointer" (below) and the fact that it exists within the application
+	 * rather than within libpng, is essentially identical to libpng's
+	 * default error handler.  The second point is critical:  since both
+	 * setjmp() and longjmp() are called from the same code, they are
+	 * guaranteed to have compatible notions of how big a jmp_buf is,
+	 * regardless of whether _BSD_SOURCE or anything else has (or has not)
+	 * been defined.
+	 */
+
+	php_gd_error_ex(E_ERROR, "gd-png:  fatal libpng error: %s\n", msg);
+
+	jmpbuf_ptr = png_get_error_ptr (png_ptr);
+	if (jmpbuf_ptr == NULL) { /* we are completely hosed now */
+		php_gd_error_ex(E_ERROR, "gd-png:  EXTREMELY fatal error: jmpbuf unrecoverable; terminating.\n");
+	}
 
-  longjmp (jmpbuf_ptr->jmpbuf, 1);
+	longjmp (jmpbuf_ptr->jmpbuf, 1);
 }
 #endif
 
-static void
-gdPngReadData (png_structp png_ptr,
-	       png_bytep data, png_size_t length)
+static void gdPngReadData (png_structp png_ptr, png_bytep data, png_size_t length)
 {
-  gdGetBuf (data, length, (gdIOCtx *)
-	    png_get_io_ptr (png_ptr));
+	gdGetBuf(data, length, (gdIOCtx *) png_get_io_ptr(png_ptr));
 }
 
-static void
-gdPngWriteData (png_structp png_ptr,
-		png_bytep data, png_size_t length)
+static void gdPngWriteData (png_structp png_ptr, png_bytep data, png_size_t length)
 {
-  gdPutBuf (data, length, (gdIOCtx *)
-	    png_get_io_ptr (png_ptr));
+	gdPutBuf (data, length, (gdIOCtx *) png_get_io_ptr(png_ptr));
 }
 
-static void
-gdPngFlushData (png_structp png_ptr)
+static void gdPngFlushData (png_structp png_ptr)
 {
 }
 
-gdImagePtr
-gdImageCreateFromPng (FILE * inFile)
+gdImagePtr gdImageCreateFromPng (FILE * inFile)
 {
-  gdImagePtr im;
-  gdIOCtx *in = gdNewFileCtx (inFile);
-  im = gdImageCreateFromPngCtx (in);
-  in->gd_free (in);
-  return im;
+	gdImagePtr im;
+	gdIOCtx *in = gdNewFileCtx(inFile);
+	im = gdImageCreateFromPngCtx(in);
+	in->gd_free(in);
+
+	return im;
 }
 
 
 /* This routine is based in part on the Chapter 13 demo code in "PNG: The
  *  Definitive Guide" (http://www.cdrom.com/pub/png/pngbook.html).
  */
-gdImagePtr
-gdImageCreateFromPngCtx (gdIOCtx * infile)
+gdImagePtr gdImageCreateFromPngCtx (gdIOCtx * infile)
 {
-  png_byte sig[8];
-  png_structp png_ptr;
-  png_infop info_ptr;
-  png_uint_32 width, height, rowbytes, w, h;
-  int bit_depth, color_type, interlace_type;
-  int num_palette, num_trans;
-  png_colorp palette;
-  png_color_16p trans_gray_rgb;
-  png_color_16p trans_color_rgb;
-  png_bytep trans;
-  png_bytep image_data = NULL;
-  png_bytepp row_pointers = NULL;
-  gdImagePtr im = NULL;
-  int i, j, *open = NULL;
-  volatile int transparent = -1;
-  volatile int palette_allocated = FALSE;
-
-  /* Make sure the signature can't match by dumb luck -- TBB */
-  /* GRR: isn't sizeof(infile) equal to the size of the pointer? */
-  memset (infile, 0, sizeof (infile));
-
-  /* first do a quick check that the file really is a PNG image; could
-   * have used slightly more general png_sig_cmp() function instead */
-  gdGetBuf (sig, 8, infile);
-  if (!png_check_sig (sig, 8))
-    return NULL;		/* bad signature */
+	png_byte sig[8];
+	png_structp png_ptr;
+	png_infop info_ptr;
+	png_uint_32 width, height, rowbytes, w, h;
+	int bit_depth, color_type, interlace_type;
+	int num_palette, num_trans;
+	png_colorp palette;
+	png_color_16p trans_gray_rgb;
+	png_color_16p trans_color_rgb;
+	png_bytep trans;
+	png_bytep image_data = NULL;
+	png_bytepp row_pointers = NULL;
+	gdImagePtr im = NULL;
+	int i, j, *open = NULL;
+	volatile int transparent = -1;
+	volatile int palette_allocated = FALSE;
+
+	/* Make sure the signature can't match by dumb luck -- TBB */
+	/* GRR: isn't sizeof(infile) equal to the size of the pointer? */
+	memset (infile, 0, sizeof(infile));
+
+	  /* first do a quick check that the file really is a PNG image; could
+	   * have used slightly more general png_sig_cmp() function instead 
+	   */
+	gdGetBuf(sig, 8, infile);
+	if (!png_check_sig (sig, 8)) { /* bad signature */
+		return NULL;
+	}
 
 #ifndef PNG_SETJMP_NOT_SUPPORTED
-  png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, &gdPngJmpbufStruct,
-				    gdPngErrorHandler, NULL);
+	png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, &gdPngJmpbufStruct, gdPngErrorHandler, NULL);
 #else
-  png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+	png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 #endif
-  if (png_ptr == NULL)
-    {
-      php_gd_error("gd-png error: cannot allocate libpng main struct\n");
-      return NULL;
-    }
+	if (png_ptr == NULL) {
+		php_gd_error("gd-png error: cannot allocate libpng main struct\n");
+		return NULL;
+	}
 
-  info_ptr = png_create_info_struct (png_ptr);
-  if (info_ptr == NULL)
-    {
-      php_gd_error("gd-png error: cannot allocate libpng info struct\n");
-      png_destroy_read_struct (&png_ptr, NULL, NULL);
-      return NULL;
-    }
+	info_ptr = png_create_info_struct(png_ptr);
+	if (info_ptr == NULL) {
+		php_gd_error("gd-png error: cannot allocate libpng info struct\n");
+		png_destroy_read_struct (&png_ptr, NULL, NULL);
 
-  /* we could create a second info struct here (end_info), but it's only
-   * useful if we want to keep pre- and post-IDAT chunk info separated
-   * (mainly for PNG-aware image editors and converters) */
+		return NULL;
+	}
 
-  /* setjmp() must be called in every non-callback function that calls a
-   * PNG-reading libpng function */
+	/* we could create a second info struct here (end_info), but it's only
+	 * useful if we want to keep pre- and post-IDAT chunk info separated
+	 * (mainly for PNG-aware image editors and converters) 
+	 */
+
+	/* setjmp() must be called in every non-callback function that calls a
+	 * PNG-reading libpng function
+	 */
 #ifndef PNG_SETJMP_NOT_SUPPORTED
-  if (setjmp (gdPngJmpbufStruct.jmpbuf))
-    {
-      php_gd_error("gd-png error: setjmp returns error condition\n");
-      png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
-      return NULL;
-    }
-#endif
+	if (setjmp(gdPngJmpbufStruct.jmpbuf)) {
+		php_gd_error("gd-png error: setjmp returns error condition\n");
+		png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
 
-  png_set_sig_bytes (png_ptr, 8);	/* we already read the 8 signature bytes */
+		return NULL;
+	}
+#endif
 
-  png_set_read_fn (png_ptr, (void *) infile, gdPngReadData);
-  png_read_info (png_ptr, info_ptr);	/* read all PNG info up to image data */
+	png_set_sig_bytes(png_ptr, 8);	/* we already read the 8 signature bytes */
 
-  png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
-		&interlace_type, NULL, NULL);
-  if ((color_type == PNG_COLOR_TYPE_RGB) ||
-      (color_type == PNG_COLOR_TYPE_RGB_ALPHA))
-    {
-      im = gdImageCreateTrueColor ((int) width, (int) height);
-    }
-  else
-    {
-      im = gdImageCreate ((int) width, (int) height);
-    }
-  if (im == NULL)
-    {
-      php_gd_error("gd-png error: cannot allocate gdImage struct\n");
-      png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
-      gdFree (image_data);
-      gdFree (row_pointers);
-      return NULL;
-    }
+	png_set_read_fn(png_ptr, (void *) infile, gdPngReadData);
+	png_read_info(png_ptr, info_ptr);	/* read all PNG info up to image data */
 
-  if (bit_depth == 16)
-    png_set_strip_16 (png_ptr);
-  else if (bit_depth < 8)
-    png_set_packing (png_ptr);	/* expand to 1 byte per pixel */
-  switch (color_type)
-    {
-    case PNG_COLOR_TYPE_PALETTE:
-      png_get_PLTE (png_ptr, info_ptr, &palette, &num_palette);
-#ifdef DEBUG
-      php_gd_error("gd-png color_type is palette, colors: %d\n",
-	       num_palette);
-#endif /* DEBUG */
-      if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
-	{
-	  /* gd 2.0: we support this rather thoroughly now. Grab the
-	     first fully transparent entry, if any, as the value of 
-	     the simple-transparency index, mostly for backwards
-	     binary compatibility. The alpha channel is where it's
-	     really at these days. */
-	  int firstZero = 1;
-	  png_get_tRNS (png_ptr, info_ptr, &trans, &num_trans, NULL);
-	  for (i = 0; i < num_trans; ++i)
-	    {
-	      im->alpha[i] = gdAlphaMax - (trans[i] >> 1);
-	      if ((trans[i] == 0) && (firstZero))
-		{
-		  transparent = i;
-		  firstZero = 0;
-		}
-	    }
-	}
-      break;
-
-    case PNG_COLOR_TYPE_GRAY:
-    case PNG_COLOR_TYPE_GRAY_ALPHA:
-      /* create a fake palette and check for single-shade transparency */
-      if ((palette = (png_colorp) gdMalloc (256 * sizeof (png_color))) == NULL)
-	{
-	  php_gd_error("gd-png error: cannot allocate gray palette\n");
-	  png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
-	  return NULL;
+	png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, NULL, NULL);
+	if ((color_type == PNG_COLOR_TYPE_RGB) || (color_type == PNG_COLOR_TYPE_RGB_ALPHA)) {
+		im = gdImageCreateTrueColor((int) width, (int) height);
+	} else {
+		im = gdImageCreate((int) width, (int) height);
 	}
-      palette_allocated = TRUE;
-      if (bit_depth < 8)
-	{
-	  num_palette = 1 << bit_depth;
-	  for (i = 0; i < 256; ++i)
-	    {
-	      j = (255 * i) / (num_palette - 1);
-	      palette[i].red = palette[i].green = palette[i].blue = j;
-	    }
-	}
-      else
-	{
-	  num_palette = 256;
-	  for (i = 0; i < 256; ++i)
-	    {
-	      palette[i].red = palette[i].green = palette[i].blue = i;
-	    }
+	if (im == NULL) {
+		php_gd_error("gd-png error: cannot allocate gdImage struct\n");
+		png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+		gdFree(image_data);
+		gdFree(row_pointers);
+
+		return NULL;
 	}
-      if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
-	{
-	  png_get_tRNS (png_ptr, info_ptr, NULL, NULL, &trans_gray_rgb);
-	  if (bit_depth == 16)	/* png_set_strip_16() not yet in effect */
-	    transparent = trans_gray_rgb->gray >> 8;
-	  else
-	    transparent = trans_gray_rgb->gray;
-	  /* Note slight error in 16-bit case:  up to 256 16-bit shades
-	   * may get mapped to a single 8-bit shade, and only one of them
-	   * is supposed to be transparent.  IOW, both opaque pixels and
-	   * transparent pixels will be mapped into the transparent entry.
-	   * There is no particularly good way around this in the case
-	   * that all 256 8-bit shades are used, but one could write some
-	   * custom 16-bit code to handle the case where there are gdFree
-	   * palette entries.  This error will be extremely rare in
-	   * general, though.  (Quite possibly there is only one such
-	   * image in existence.) */
+
+	if (bit_depth == 16) {
+		png_set_strip_16(png_ptr);
+	} else if (bit_depth < 8) {
+		png_set_packing (png_ptr); /* expand to 1 byte per pixel */
 	}
-      break;
-
-    case PNG_COLOR_TYPE_RGB:
-    case PNG_COLOR_TYPE_RGB_ALPHA:
-      /* gd 2.0: we now support truecolor. See the comment above
-         for a rare situation in which the transparent pixel may not
-         work properly with 16-bit channels. */
-      if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
-	{
-	  png_get_tRNS (png_ptr, info_ptr, NULL, NULL, &trans_color_rgb);
-	  if (bit_depth == 16)	/* png_set_strip_16() not yet in effect */
-	    transparent = gdTrueColor (trans_color_rgb->red >> 8,
-				       trans_color_rgb->green >> 8,
-				       trans_color_rgb->blue >> 8);
-	  else
-	    transparent = gdTrueColor (trans_color_rgb->red,
-				       trans_color_rgb->green,
-				       trans_color_rgb->blue);
+
+	switch (color_type) {
+		case PNG_COLOR_TYPE_PALETTE:
+			png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette);
+#ifdef DEBUG
+			php_gd_error("gd-png color_type is palette, colors: %d\n", num_palette);
+#endif /* DEBUG */
+			if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS)) {
+				/* gd 2.0: we support this rather thoroughly now. Grab the
+				 * first fully transparent entry, if any, as the value of 
+				 * the simple-transparency index, mostly for backwards
+				 * binary compatibility. The alpha channel is where it's
+				 * really at these days.
+				 */
+				int firstZero = 1;
+				png_get_tRNS(png_ptr, info_ptr, &trans, &num_trans, NULL);
+				for (i = 0; i < num_trans; ++i) {
+					im->alpha[i] = gdAlphaMax - (trans[i] >> 1);
+					if ((trans[i] == 0) && (firstZero)) {
+						transparent = i;
+						firstZero = 0;
+					}
+				}
+			}
+			break;
+		case PNG_COLOR_TYPE_GRAY:
+		case PNG_COLOR_TYPE_GRAY_ALPHA:
+			/* create a fake palette and check for single-shade transparency */
+			if ((palette = (png_colorp) gdMalloc (256 * sizeof (png_color))) == NULL) {
+				php_gd_error("gd-png error: cannot allocate gray palette\n");
+				png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+
+				return NULL;
+			}
+			palette_allocated = TRUE;
+			if (bit_depth < 8) {
+				num_palette = 1 << bit_depth;
+				for (i = 0; i < 256; ++i) {
+					j = (255 * i) / (num_palette - 1);
+					palette[i].red = palette[i].green = palette[i].blue = j;
+				}
+			} else {
+				num_palette = 256;
+				for (i = 0; i < 256; ++i) {
+					palette[i].red = palette[i].green = palette[i].blue = i;
+				}
+			}
+			if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
+				png_get_tRNS(png_ptr, info_ptr, NULL, NULL, &trans_gray_rgb);
+				if (bit_depth == 16) {	/* png_set_strip_16() not yet in effect */
+					transparent = trans_gray_rgb->gray >> 8;
+				} else {
+					transparent = trans_gray_rgb->gray;
+				}
+				/* Note slight error in 16-bit case:  up to 256 16-bit shades
+				 * may get mapped to a single 8-bit shade, and only one of them
+				 * is supposed to be transparent.  IOW, both opaque pixels and
+				 * transparent pixels will be mapped into the transparent entry.
+				 * There is no particularly good way around this in the case
+				 * that all 256 8-bit shades are used, but one could write some
+				 * custom 16-bit code to handle the case where there are gdFree
+				 * palette entries.  This error will be extremely rare in
+				 * general, though.  (Quite possibly there is only one such
+				 * image in existence.) 
+				 */
+			}
+			break;
+
+			case PNG_COLOR_TYPE_RGB:
+			case PNG_COLOR_TYPE_RGB_ALPHA:
+				/* gd 2.0: we now support truecolor. See the comment above
+				 * for a rare situation in which the transparent pixel may not
+				 * work properly with 16-bit channels. 
+				 */
+				if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
+					png_get_tRNS(png_ptr, info_ptr, NULL, NULL, &trans_color_rgb);
+					if (bit_depth == 16) { /* png_set_strip_16() not yet in effect */
+						transparent = gdTrueColor(trans_color_rgb->red >> 8, 
+									trans_color_rgb->green >> 8,
+									trans_color_rgb->blue >> 8);
+					} else {
+						transparent = gdTrueColor(trans_color_rgb->red, 
+									trans_color_rgb->green,
+									trans_color_rgb->blue);
+					}
+				}
+				break;
 	}
-      break;
-    }
 
-  png_read_update_info (png_ptr, info_ptr);
+	png_read_update_info(png_ptr, info_ptr);
 
-  /* allocate space for the PNG image data */
-  rowbytes = png_get_rowbytes (png_ptr, info_ptr);
-  if ((image_data = (png_bytep) gdMalloc (rowbytes * height)) == NULL)
-    {
-      php_gd_error("gd-png error: cannot allocate image data\n");
-      png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
-      return NULL;
-    }
-  if ((row_pointers = (png_bytepp) gdMalloc (height * sizeof (png_bytep))) == NULL)
-    {
-      php_gd_error("gd-png error: cannot allocate row pointers\n");
-      png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
-      gdFree (image_data);
-      return NULL;
-    }
+	/* allocate space for the PNG image data */
+	rowbytes = png_get_rowbytes(png_ptr, info_ptr);
+	image_data = (png_bytep) gdMalloc (rowbytes * height);
 
-  /* set the individual row_pointers to point at the correct offsets */
-  for (h = 0; h < height; ++h)
-    {
-      row_pointers[h] = image_data + h * rowbytes;
-    }
+	row_pointers = (png_bytepp) gdMalloc (height * sizeof (png_bytep));
 
-  png_read_image (png_ptr, row_pointers);	/* read whole image... */
-  png_read_end (png_ptr, NULL);	/* ...done! */
-
-  if (!im->trueColor)
-    {
-      im->colorsTotal = num_palette;
-      im->transparent = transparent;
-      /* load the palette and mark all entries "open" (unused) for now */
-      open = im->open;
-      for (i = 0; i < num_palette; ++i)
-	{
-	  im->red[i] = palette[i].red;
-	  im->green[i] = palette[i].green;
-	  im->blue[i] = palette[i].blue;
-	  open[i] = 1;
+	/* set the individual row_pointers to point at the correct offsets */
+	for (h = 0; h < height; ++h) {
+		row_pointers[h] = image_data + h * rowbytes;
 	}
-      for (i = num_palette; i < gdMaxColors; ++i)
-	{
-	  open[i] = 1;
-	}
-    }
-  im->interlace = (interlace_type == PNG_INTERLACE_ADAM7);
-
-  /* can't nuke structs until done with palette */
-  png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
-  switch (color_type)
-    {
-    case PNG_COLOR_TYPE_RGB:
-      for (h = 0; h < height; h++)
-	{
-	  int boffset = 0;
-	  for (w = 0; w < width; w++)
-	    {
-	      register png_byte r = row_pointers[h][boffset++];
-	      register png_byte g = row_pointers[h][boffset++];
-	      register png_byte b = row_pointers[h][boffset++];
-	      im->tpixels[h][w] = gdTrueColor (r, g, b);
-	    }
-	}
-      break;
-    case PNG_COLOR_TYPE_RGB_ALPHA:
-      for (h = 0; h < height; h++)
-	{
-	  int boffset = 0;
-	  for (w = 0; w < width; w++)
-	    {
-	      register png_byte r = row_pointers[h][boffset++];
-	      register png_byte g = row_pointers[h][boffset++];
-	      register png_byte b = row_pointers[h][boffset++];
-	      /* gd has only 7 bits of alpha channel resolution, and
-	         127 is transparent, 0 opaque. A moment of convenience, 
-	         a lifetime of compatibility. */
-	      register png_byte a = gdAlphaMax -
-	      (row_pointers[h][boffset++] >> 1);
-	      im->tpixels[h][w] = gdTrueColorAlpha (r, g, b, a);
-	    }
+
+	png_read_image(png_ptr, row_pointers);	/* read whole image... */
+	png_read_end(png_ptr, NULL);		/* ...done! */
+
+	if (!im->trueColor) {
+		im->colorsTotal = num_palette;
+		im->transparent = transparent;
+		/* load the palette and mark all entries "open" (unused) for now */
+		open = im->open;
+		for (i = 0; i < num_palette; ++i) {
+			im->red[i] = palette[i].red;
+			im->green[i] = palette[i].green;
+			im->blue[i] = palette[i].blue;
+			open[i] = 1;
+		}
+		for (i = num_palette; i < gdMaxColors; ++i) {
+			open[i] = 1;
+		}
 	}
-      break;
-    default:
-      /* Palette image, or something coerced to be one */
-      for (h = 0; h < height; ++h)
-	{
-	  for (w = 0; w < width; ++w)
-	    {
-	      register png_byte idx = row_pointers[h][w];
-	      im->pixels[h][w] = idx;
-	      open[idx] = 0;
-	    }
+
+	im->interlace = (interlace_type == PNG_INTERLACE_ADAM7);
+
+	/* can't nuke structs until done with palette */
+	png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+	switch (color_type) {
+		case PNG_COLOR_TYPE_RGB:
+			for (h = 0; h < height; h++) {
+				int boffset = 0;
+				for (w = 0; w < width; w++) {
+					register png_byte r = row_pointers[h][boffset++];
+					register png_byte g = row_pointers[h][boffset++];
+					register png_byte b = row_pointers[h][boffset++];
+					im->tpixels[h][w] = gdTrueColor (r, g, b);
+				}
+			}
+			break;
+
+		case PNG_COLOR_TYPE_RGB_ALPHA:
+			for (h = 0; h < height; h++) {
+				int boffset = 0;
+				for (w = 0; w < width; w++) {
+					register png_byte r = row_pointers[h][boffset++];
+					register png_byte g = row_pointers[h][boffset++];
+					register png_byte b = row_pointers[h][boffset++];
+
+					/* gd has only 7 bits of alpha channel resolution, and
+					 * 127 is transparent, 0 opaque. A moment of convenience, 
+					 *  a lifetime of compatibility.
+					 */
+
+					register png_byte a = gdAlphaMax - (row_pointers[h][boffset++] >> 1);
+					im->tpixels[h][w] = gdTrueColorAlpha(r, g, b, a);
+				}
+			}
+			break;
+
+		default:
+			/* Palette image, or something coerced to be one */
+			for (h = 0; h < height; ++h) {
+				for (w = 0; w < width; ++w) {
+					register png_byte idx = row_pointers[h][w];
+					im->pixels[h][w] = idx;
+					open[idx] = 0;
+				}
+			}
 	}
-    }
 #ifdef DEBUG
-  if (!im->trueColor)
-    {
-      for (i = num_palette; i < gdMaxColors; ++i)
-	{
-	  if (!open[i])
-	    {
-	      php_gd_error("gd-png warning: image data references out-of-range"
-		       " color index (%d)\n", i);
-	    }
+	if (!im->trueColor) {
+		for (i = num_palette; i < gdMaxColors; ++i) {
+			if (!open[i]) {
+				php_gd_error("gd-png warning: image data references out-of-range color index (%d)\n", i);
+			}
+		}
 	}
-    }
 #endif
 
-  if (palette_allocated)
-    gdFree (palette);
-  gdFree (image_data);
-  gdFree (row_pointers);
+	if (palette_allocated) {
+		gdFree(palette);
+	}
+	gdFree(image_data);
+	gdFree(row_pointers);
 
-  return im;
+	return im;
 }
 
 
-void
-gdImagePng (gdImagePtr im, FILE * outFile)
+void gdImagePng (gdImagePtr im, FILE * outFile)
 {
-  gdIOCtx *out = gdNewFileCtx (outFile);
-  gdImagePngCtx (im, out);
-  out->gd_free (out);
+	gdIOCtx *out = gdNewFileCtx(outFile);
+  	gdImagePngCtx(im, out);
+	out->gd_free(out);
 }
 
-void *
-gdImagePngPtr (gdImagePtr im, int *size)
+void * gdImagePngPtr (gdImagePtr im, int *size)
 {
-  void *rv;
-  gdIOCtx *out = gdNewDynamicCtx (2048, NULL);
-  gdImagePngCtx (im, out);
-  rv = gdDPExtractData (out, size);
-  out->gd_free (out);
-  return rv;
+	void *rv;
+	gdIOCtx *out = gdNewDynamicCtx(2048, NULL);
+	gdImagePngCtx(im, out);
+	rv = gdDPExtractData(out, size);
+	out->gd_free(out);
+
+	return rv;
 }
 
 /* This routine is based in part on code from Dale Lutz (Safe Software Inc.)
  *  and in part on demo code from Chapter 15 of "PNG: The Definitive Guide"
  *  (http://www.cdrom.com/pub/png/pngbook.html).
  */
-void
-gdImagePngCtx (gdImagePtr im, gdIOCtx * outfile)
+void gdImagePngCtx (gdImagePtr im, gdIOCtx * outfile)
 {
-  int i, j, bit_depth = 0, interlace_type;
-  int width = im->sx;
-  int height = im->sy;
-  int colors = im->colorsTotal;
-  int *open = im->open;
-  int mapping[gdMaxColors];	/* mapping[gd_index] == png_index */
-  png_byte trans_values[256];
-  png_color_16 trans_rgb_value;
-  png_color palette[gdMaxColors];
-  png_structp png_ptr;
-  png_infop info_ptr;
-  volatile int transparent = im->transparent;
-  volatile int remap = FALSE;
-
+	int i, j, bit_depth = 0, interlace_type;
+	int width = im->sx;
+	int height = im->sy;
+	int colors = im->colorsTotal;
+	int *open = im->open;
+	int mapping[gdMaxColors];	/* mapping[gd_index] == png_index */
+	png_byte trans_values[256];
+	png_color_16 trans_rgb_value;
+	png_color palette[gdMaxColors];
+	png_structp png_ptr;
+	png_infop info_ptr;
+	volatile int transparent = im->transparent;
+	volatile int remap = FALSE;
 
 #ifndef PNG_SETJMP_NOT_SUPPORTED
-  png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING,
-			       &gdPngJmpbufStruct, gdPngErrorHandler, NULL);
+	png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, &gdPngJmpbufStruct, gdPngErrorHandler, NULL);
 #else
-  png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+	png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 #endif
-  if (png_ptr == NULL)
-    {
-      php_gd_error("gd-png error: cannot allocate libpng main struct\n");
-      return;
-    }
+	if (png_ptr == NULL) {
+		php_gd_error("gd-png error: cannot allocate libpng main struct\n");
+		return;
+	}
 
-  info_ptr = png_create_info_struct (png_ptr);
-  if (info_ptr == NULL)
-    {
-      php_gd_error("gd-png error: cannot allocate libpng info struct\n");
-      png_destroy_write_struct (&png_ptr, (png_infopp) NULL);
-      return;
+	info_ptr = png_create_info_struct(png_ptr);
+	if (info_ptr == NULL) {
+		php_gd_error("gd-png error: cannot allocate libpng info struct\n");
+		png_destroy_write_struct (&png_ptr, (png_infopp) NULL);
+
+		return;
     }
 
 #ifndef PNG_SETJMP_NOT_SUPPORTED
-  if (setjmp (gdPngJmpbufStruct.jmpbuf))
-    {
-      php_gd_error("gd-png error: setjmp returns error condition\n");
-      png_destroy_write_struct (&png_ptr, &info_ptr);
-      return;
-    }
+	if (setjmp (gdPngJmpbufStruct.jmpbuf)) {
+		php_gd_error("gd-png error: setjmp returns error condition\n");
+		png_destroy_write_struct (&png_ptr, &info_ptr);
+
+		return;
+	}
 #endif
 
-  png_set_write_fn (png_ptr, (void *) outfile, gdPngWriteData, gdPngFlushData);
+	png_set_write_fn(png_ptr, (void *) outfile, gdPngWriteData, gdPngFlushData);
 
-  /* This is best for palette images, and libpng defaults to it for
-     palette images anyway, so we don't need to do it explicitly.
-     What to ideally do for truecolor images depends, alas, on the image.
-     gd is intentionally imperfect and doesn't spend a lot of time
-     fussing with such things. */
-/*  png_set_filter(png_ptr, 0, PNG_FILTER_NONE);  */
+	/* This is best for palette images, and libpng defaults to it for
+	 * palette images anyway, so we don't need to do it explicitly.
+	 * What to ideally do for truecolor images depends, alas, on the image.
+	 * gd is intentionally imperfect and doesn't spend a lot of time
+	 * fussing with such things.
+	 */
+	
+	/*  png_set_filter(png_ptr, 0, PNG_FILTER_NONE);  */
 
-  /* may want to force maximum compression, but time penalty is large */
-/*  png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);  */
+	/* may want to force maximum compression, but time penalty is large
+	 *  png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);  
+	 */
 
-  /* can set this to a smaller value without compromising compression if all
-   * image data is 16K or less; will save some decoder memory [min == 8] */
-/*  png_set_compression_window_bits(png_ptr, 15);  */
+	/* can set this to a smaller value without compromising compression if all
+	 * image data is 16K or less; will save some decoder memory [min == 8] 
+	 */
 
-  if (!im->trueColor)
-    {
-      if (transparent >= im->colorsTotal ||
-	  (transparent >= 0 && open[transparent]))
-	transparent = -1;
-    }
-  if (!im->trueColor)
-    {
-      for (i = 0; i < gdMaxColors; ++i)
-	mapping[i] = -1;
-    }
-  if (!im->trueColor)
-    {
-      /* count actual number of colors used (colorsTotal == high-water mark) */
-      colors = 0;
-      for (i = 0; i < im->colorsTotal; ++i)
-	{
-	  if (!open[i])
-	    {
-	      mapping[i] = colors;
-	      ++colors;
-	    }
-	}
-      if (colors < im->colorsTotal)
-	{
-	  remap = TRUE;
-	}
-      if (colors <= 2)
-	bit_depth = 1;
-      else if (colors <= 4)
-	bit_depth = 2;
-      else if (colors <= 16)
-	bit_depth = 4;
-      else
-	bit_depth = 8;
-    }
-  interlace_type = im->interlace ? PNG_INTERLACE_ADAM7 : PNG_INTERLACE_NONE;
-
-  if (im->trueColor)
-    {
-      if (im->saveAlphaFlag)
-	{
-	  png_set_IHDR (png_ptr, info_ptr, width, height, 8,
-			PNG_COLOR_TYPE_RGB_ALPHA, interlace_type,
-		     PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+	/*  png_set_compression_window_bits(png_ptr, 15);  */
+
+	if (!im->trueColor) {
+		if (transparent >= im->colorsTotal || (transparent >= 0 && open[transparent])) {
+			transparent = -1;
+		}
+
+		for (i = 0; i < gdMaxColors; ++i) {
+			mapping[i] = -1;
+		}
+
+		/* count actual number of colors used (colorsTotal == high-water mark) */
+		colors = 0;
+		for (i = 0; i < im->colorsTotal; ++i) {
+			if (!open[i]) {
+				mapping[i] = colors;
+				++colors;
+			}
+		}
+		if (colors < im->colorsTotal) {
+			remap = TRUE;
+		}
+		if (colors <= 2) {
+			bit_depth = 1;
+		} else if (colors <= 4) {
+			bit_depth = 2;
+		} else if (colors <= 16) { 
+			bit_depth = 4;
+		} else {
+			bit_depth = 8;
+		}
 	}
-      else
-	{
-	  png_set_IHDR (png_ptr, info_ptr, width, height, 8,
-			PNG_COLOR_TYPE_RGB, interlace_type,
-		     PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+	
+	interlace_type = im->interlace ? PNG_INTERLACE_ADAM7 : PNG_INTERLACE_NONE;
+
+	if (im->trueColor) {
+		if (im->saveAlphaFlag) {
+			png_set_IHDR(png_ptr, info_ptr, width, height, 8, PNG_COLOR_TYPE_RGB_ALPHA, interlace_type,
+					PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+		} else {
+			png_set_IHDR(png_ptr, info_ptr, width, height, 8, PNG_COLOR_TYPE_RGB, interlace_type,
+					PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+		}
+	} else {
+		png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, PNG_COLOR_TYPE_PALETTE, interlace_type,
+			PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
 	}
-    }
-  else
-    {
-      png_set_IHDR (png_ptr, info_ptr, width, height, bit_depth,
-		    PNG_COLOR_TYPE_PALETTE, interlace_type,
-		    PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
-    }
-  if (im->trueColor && (!im->saveAlphaFlag) && (transparent >= 0))
-    {
-    	/* 2.0.9: fixed by Thomas Winzig */
-      trans_rgb_value.red = gdTrueColorGetRed (im->transparent);
-      trans_rgb_value.green = gdTrueColorGetGreen (im->transparent);
-      trans_rgb_value.blue = gdTrueColorGetBlue (im->transparent);
-      png_set_tRNS (png_ptr, info_ptr, 0, 0, &trans_rgb_value);
-    }
-  if (!im->trueColor)
-    {
-      /* Oy veh. Remap the PNG palette to put the 
-         entries with interesting alpha channel
-         values first. This minimizes the size
-         of the tRNS chunk and thus the size
-         of the PNG file as a whole. */
-      int tc = 0;
-      int i;
-      int j;
-      int k;
-      for (i = 0; (i < im->colorsTotal); i++)
-	{
-	  if ((!im->open[i]) &&
-	      (im->alpha[i] != gdAlphaOpaque))
-	    {
-	      tc++;
-	    }
+
+	if (im->trueColor && !im->saveAlphaFlag && (transparent >= 0)) {
+		/* 2.0.9: fixed by Thomas Winzig */
+		trans_rgb_value.red = gdTrueColorGetRed (im->transparent);
+		trans_rgb_value.green = gdTrueColorGetGreen (im->transparent);
+		trans_rgb_value.blue = gdTrueColorGetBlue (im->transparent);
+		png_set_tRNS(png_ptr, info_ptr, 0, 0, &trans_rgb_value);
 	}
-      if (tc)
-	{
+
+	if (!im->trueColor) {
+		/* Oy veh. Remap the PNG palette to put the entries with interesting alpha channel
+		 * values first. This minimizes the size of the tRNS chunk and thus the size
+		 * of the PNG file as a whole. 
+		 */
+		
+		int tc = 0;
+		int i;
+		int j;
+		int k;
+
+		for (i = 0; (i < im->colorsTotal); i++) {
+			if ((!im->open[i]) && (im->alpha[i] != gdAlphaOpaque)) {
+				tc++;
+			}
+		}
+		if (tc) {
 #if 0
-	  for (i = 0; (i < im->colorsTotal); i++)
-	    {
-	      trans_values[i] = 255 -
-		((im->alpha[i] << 1) +
-		 (im->alpha[i] >> 6));
-	    }
-	  png_set_tRNS (png_ptr, info_ptr, trans_values, 256, NULL);
+			for (i = 0; (i < im->colorsTotal); i++) {
+				trans_values[i] = 255 - ((im->alpha[i] << 1) + (im->alpha[i] >> 6));
+			}
+			png_set_tRNS (png_ptr, info_ptr, trans_values, 256, NULL);
 #endif
-	  if (!remap)
-	    {
-	      remap = TRUE;
-	    }
-	  /* (Semi-)transparent indexes come up from the bottom
-	     of the list of real colors; opaque
-	     indexes come down from the top */
-	  j = 0;
-	  k = colors - 1;
-	  for (i = 0; (i < im->colorsTotal); i++)
-	    {
-	      if (!im->open[i])
-		{
-		  if (im->alpha[i] != gdAlphaOpaque)
-		    {
-		       /* Andrew Hull: >> 6, not >> 7! (gd 2.0.5) */ 
-		      trans_values[j] = 255 -
-			((im->alpha[i] << 1) +
-			 (im->alpha[i] >> 6));
-		      mapping[i] = j++;
-		    }
-		  else
-		    {
-		      mapping[i] = k--;
-		    }
+			if (!remap) {
+				remap = TRUE;
+			}
+
+			/* (Semi-)transparent indexes come up from the bottom of the list of real colors; opaque
+			 * indexes come down from the top
+			 */
+			j = 0;
+			k = colors - 1;
+
+			for (i = 0; i < im->colorsTotal; i++) {
+				if (!im->open[i]) {
+					if (im->alpha[i] != gdAlphaOpaque) {
+						/* Andrew Hull: >> 6, not >> 7! (gd 2.0.5) */ 
+						trans_values[j] = 255 - ((im->alpha[i] << 1) + (im->alpha[i] >> 6));
+						mapping[i] = j++;
+					} else {
+						mapping[i] = k--;
+					}
+				}
+			}
+			png_set_tRNS(png_ptr, info_ptr, trans_values, tc, NULL);
 		}
-	    }
-	  png_set_tRNS (png_ptr, info_ptr, trans_values, tc, NULL);
 	}
-    }
 
-  /* convert palette to libpng layout */
-  if (!im->trueColor)
-    {
-      if (remap)
-	for (i = 0; i < im->colorsTotal; ++i)
-	  {
-	    if (mapping[i] < 0)
-	      continue;
-	    palette[mapping[i]].red = im->red[i];
-	    palette[mapping[i]].green = im->green[i];
-	    palette[mapping[i]].blue = im->blue[i];
-	  }
-      else
-	for (i = 0; i < colors; ++i)
-	  {
-	    palette[i].red = im->red[i];
-	    palette[i].green = im->green[i];
-	    palette[i].blue = im->blue[i];
-	  }
-      png_set_PLTE (png_ptr, info_ptr, palette, colors);
-    }
-
-  /* write out the PNG header info (everything up to first IDAT) */
-  png_write_info (png_ptr, info_ptr);
-
-  /* make sure < 8-bit images are packed into pixels as tightly as possible */
-  png_set_packing (png_ptr);
-
-  /* This code allocates a set of row buffers and copies the gd image data
-   * into them only in the case that remapping is necessary; in gd 1.3 and
-   * later, the im->pixels array is laid out identically to libpng's row
-   * pointers and can be passed to png_write_image() function directly.
-   * The remapping case could be accomplished with less memory for non-
-   * interlaced images, but interlacing causes some serious complications. */
-  if (im->trueColor)
-    {
-      int channels = im->saveAlphaFlag ? 4 : 3;
-      /* Our little 7-bit alpha channel trick costs us a bit here. */
-      png_bytep *row_pointers;
-      row_pointers = gdMalloc (sizeof (png_bytep) * height);
-      for (j = 0; j < height; ++j)
-	{
-	  int bo = 0;
-	  row_pointers[j] = (png_bytep) gdMalloc (width * channels);
-	  for (i = 0; i < width; ++i)
-	    {
-	      unsigned char a;
-	      row_pointers[j][bo++] = gdTrueColorGetRed (im->tpixels[j][i]);
-	      row_pointers[j][bo++] = gdTrueColorGetGreen (im->tpixels[j][i]);
-	      row_pointers[j][bo++] = gdTrueColorGetBlue (im->tpixels[j][i]);
-	      if (im->saveAlphaFlag)
-		{
-		  /* convert the 7-bit alpha channel to an 8-bit alpha channel.
-		     We do a little bit-flipping magic, repeating the MSB
-		     as the LSB, to ensure that 0 maps to 0 and
-		     127 maps to 255. We also have to invert to match
-		     PNG's convention in which 255 is opaque. */
-		  a = gdTrueColorGetAlpha (im->tpixels[j][i]);
-		   /* Andrew Hull: >> 6, not >> 7! (gd 2.0.5) */ 
-		  row_pointers[j][bo++] = 255 - ((a << 1) + (a >> 6));
+	/* convert palette to libpng layout */
+	if (!im->trueColor) {
+		if (remap) {
+			for (i = 0; i < im->colorsTotal; ++i) {
+				if (mapping[i] < 0) {
+					continue;
+				}
+
+				palette[mapping[i]].red = im->red[i];
+				palette[mapping[i]].green = im->green[i];
+				palette[mapping[i]].blue = im->blue[i];
+			}
+		} else {
+			for (i = 0; i < colors; ++i) {
+				palette[i].red = im->red[i];
+				palette[i].green = im->green[i];
+				palette[i].blue = im->blue[i];
+			}
 		}
-	    }
+		png_set_PLTE(png_ptr, info_ptr, palette, colors);
 	}
 
-      png_write_image (png_ptr, row_pointers);
-      png_write_end (png_ptr, info_ptr);
+	/* write out the PNG header info (everything up to first IDAT) */
+	png_write_info(png_ptr, info_ptr);
+
+	/* make sure < 8-bit images are packed into pixels as tightly as possible */
+	png_set_packing(png_ptr);
+
+	/* This code allocates a set of row buffers and copies the gd image data
+	 * into them only in the case that remapping is necessary; in gd 1.3 and
+	 * later, the im->pixels array is laid out identically to libpng's row
+	 * pointers and can be passed to png_write_image() function directly.
+	 * The remapping case could be accomplished with less memory for non-
+	 * interlaced images, but interlacing causes some serious complications.
+	 */
+
+	if (im->trueColor) {
+		int channels = im->saveAlphaFlag ? 4 : 3;
+		/* Our little 7-bit alpha channel trick costs us a bit here. */
+		png_bytep *row_pointers;
+		row_pointers = gdMalloc(sizeof (png_bytep) * height);
+		for (j = 0; j < height; ++j) {
+			int bo = 0;
+			row_pointers[j] = (png_bytep) gdMalloc(width * channels);
+			for (i = 0; i < width; ++i) {
+				unsigned char a;
+				row_pointers[j][bo++] = gdTrueColorGetRed(im->tpixels[j][i]);
+				row_pointers[j][bo++] = gdTrueColorGetGreen(im->tpixels[j][i]);
+				row_pointers[j][bo++] = gdTrueColorGetBlue(im->tpixels[j][i]);
+				if (im->saveAlphaFlag) {
+					/* convert the 7-bit alpha channel to an 8-bit alpha channel.
+					 * We do a little bit-flipping magic, repeating the MSB
+					 * as the LSB, to ensure that 0 maps to 0 and
+					 * 127 maps to 255. We also have to invert to match
+					 * PNG's convention in which 255 is opaque.
+					 */
+					a = gdTrueColorGetAlpha(im->tpixels[j][i]);
+					/* Andrew Hull: >> 6, not >> 7! (gd 2.0.5) */ 
+					row_pointers[j][bo++] = 255 - ((a << 1) + (a >> 6));
+				}
+			}
+		}
 
-      for (j = 0; j < height; ++j)
-	gdFree (row_pointers[j]);
-      gdFree (row_pointers);
-    }
-  else
-    {
-      if (remap)
-	{
-	  png_bytep *row_pointers;
-	  row_pointers = gdMalloc (sizeof (png_bytep) * height);
-	  for (j = 0; j < height; ++j)
-	    {
-	      row_pointers[j] = (png_bytep) gdMalloc (width);
-	      for (i = 0; i < width; ++i) 
-		row_pointers[j][i] = mapping[im->pixels[j][i]];
-	    }
-
-	  png_write_image (png_ptr, row_pointers);
-	  png_write_end (png_ptr, info_ptr);
-
-	  for (j = 0; j < height; ++j)
-	    gdFree (row_pointers[j]);
-	  gdFree (row_pointers);
-	}
-      else
-	{
-	  png_write_image (png_ptr, im->pixels);
-	  png_write_end (png_ptr, info_ptr);
+		png_write_image(png_ptr, row_pointers);
+		png_write_end(png_ptr, info_ptr);
+
+		for (j = 0; j < height; ++j) {
+			gdFree(row_pointers[j]);
+		}
+	
+		gdFree(row_pointers);
+	} else {
+		if (remap) {
+			png_bytep *row_pointers;
+			row_pointers = gdMalloc(sizeof (png_bytep) * height);
+			for (j = 0; j < height; ++j) {
+				row_pointers[j] = (png_bytep) gdMalloc(width);
+				for (i = 0; i < width; ++i) {
+					row_pointers[j][i] = mapping[im->pixels[j][i]];
+				}
+			}
+
+			png_write_image(png_ptr, row_pointers);
+			png_write_end(png_ptr, info_ptr);
+
+			for (j = 0; j < height; ++j) {
+				gdFree(row_pointers[j]);
+			}
+
+			gdFree(row_pointers);
+		} else {
+			png_write_image(png_ptr, im->pixels);
+			png_write_end(png_ptr, info_ptr);
+		}
 	}
-    }
-  /* 1.6.3: maybe we should give that memory BACK! TBB */
-  png_destroy_write_struct (&png_ptr, &info_ptr);
+	/* 1.6.3: maybe we should give that memory BACK! TBB */
+	png_destroy_write_struct(&png_ptr, &info_ptr);
 }
 
-
 #endif /* HAVE_LIBPNG */
diff --git a/ext/gd/libgd/gd_ss.c b/ext/gd/libgd/gd_ss.c
index 10bc6aa747..78f91df9c9 100644
--- a/ext/gd/libgd/gd_ss.c
+++ b/ext/gd/libgd/gd_ss.c
@@ -17,37 +17,33 @@ extern gdImagePtr gdImageCreateFromPngSource (gdSourcePtr inSource);
 #define GD_SS_DBG(s)
 
 #ifdef HAVE_LIBPNG
-void
-gdImagePngToSink (gdImagePtr im, gdSinkPtr outSink)
+void gdImagePngToSink (gdImagePtr im, gdSinkPtr outSink)
 {
-  gdIOCtx *out = gdNewSSCtx (NULL, outSink);
-  gdImagePngCtx (im, out);
-  out->gd_free (out);
+	gdIOCtx *out = gdNewSSCtx(NULL, outSink);
+	gdImagePngCtx(im, out);
+	out->gd_free(out);
 }
 
-gdImagePtr
-gdImageCreateFromPngSource (gdSourcePtr inSource)
+gdImagePtr gdImageCreateFromPngSource (gdSourcePtr inSource)
 {
-  gdIOCtx *in = gdNewSSCtx (inSource, NULL);
-  gdImagePtr im;
+	gdIOCtx *in = gdNewSSCtx(inSource, NULL);
+	gdImagePtr im;
 
-  im = gdImageCreateFromPngCtx (in);
+	im = gdImageCreateFromPngCtx(in);
 
-  in->gd_free (in);
+	in->gd_free(in);
 
-  return im;
+	return im;
 }
 #else /* no HAVE_LIBPNG */
-void
-gdImagePngToSink (gdImagePtr im, gdSinkPtr outSink)
+void gdImagePngToSink (gdImagePtr im, gdSinkPtr outSink)
 {
-  php_gd_error("PNG support is not available\n");
+	php_gd_error("PNG support is not available\n");
 }
-gdImagePtr
-gdImageCreateFromPngSource (gdSourcePtr inSource)
+gdImagePtr gdImageCreateFromPngSource (gdSourcePtr inSource)
 {
-  php_gd_error("PNG support is not available\n");
-  return NULL;
+	php_gd_error("PNG support is not available\n");
+	return NULL;
 }
 #endif /* HAVE_LIBPNG */
 
diff --git a/ext/gd/libgd/gd_wbmp.c b/ext/gd/libgd/gd_wbmp.c
index 860f70c0a5..7307d6f9e9 100644
--- a/ext/gd/libgd/gd_wbmp.c
+++ b/ext/gd/libgd/gd_wbmp.c
@@ -1,5 +1,3 @@
-
-
 /*
    WBMP: Wireless Bitmap Type 0: B/W, Uncompressed Bitmap
    Specification of the WBMP format can be found in the file: 
@@ -67,10 +65,9 @@
    ** Wrapper around gdPutC for use with writewbmp
    **
  */
-void
-gd_putout (int i, void *out)
+void gd_putout (int i, void *out)
 {
-  gdPutC (i, (gdIOCtx *) out);
+	gdPutC(i, (gdIOCtx *) out);
 }
 
 
@@ -79,10 +76,9 @@ gd_putout (int i, void *out)
    ** Wrapper around gdGetC for use with readwbmp
    **
  */
-int
-gd_getin (void *in)
+int gd_getin (void *in)
 {
-  return (gdGetC ((gdIOCtx *) in));
+	return (gdGetC((gdIOCtx *) in));
 }
 
 
@@ -95,124 +91,111 @@ gd_getin (void *in)
    **          considered as background and will not be written
    **  out:    the stream where to write
  */
-void
-gdImageWBMPCtx (gdImagePtr image, int fg, gdIOCtx * out)
+void gdImageWBMPCtx (gdImagePtr image, int fg, gdIOCtx * out)
 {
+	int x, y, pos;
+	Wbmp *wbmp;
 
-  int x, y, pos;
-  Wbmp *wbmp;
-
-
-  /* create the WBMP */
-  if ((wbmp = createwbmp (gdImageSX (image), gdImageSY (image), WBMP_WHITE)) == NULL)
-    php_gd_error("Could not create WBMP\n");
-
-  /* fill up the WBMP structure */
-  pos = 0;
-  for (y = 0; y < gdImageSY (image); y++)
-    {
-      for (x = 0; x < gdImageSX (image); x++)
-	{
-	  if (gdImageGetPixel (image, x, y) == fg)
-	    {
-	      wbmp->bitmap[pos] = WBMP_BLACK;
-	    }
-	  pos++;
+	/* create the WBMP */
+	if ((wbmp = createwbmp (gdImageSX (image), gdImageSY (image), WBMP_WHITE)) == NULL) {
+		php_gd_error("Could not create WBMP\n");
 	}
-    }
 
-  /* write the WBMP to a gd file descriptor */
-  if (writewbmp (wbmp, &gd_putout, out))
-    php_gd_error("Could not save WBMP\n");
-  /* des submitted this bugfix: gdFree the memory. */
-  freewbmp (wbmp);
-}
+	/* fill up the WBMP structure */
+	pos = 0;
+	for (y = 0; y < gdImageSY(image); y++) {
+		for (x = 0; x < gdImageSX(image); x++) {
+			if (gdImageGetPixel (image, x, y) == fg) {
+				wbmp->bitmap[pos] = WBMP_BLACK;
+			}
+			pos++;
+		}
+	}
 
+	/* write the WBMP to a gd file descriptor */
+	if (writewbmp (wbmp, &gd_putout, out)) {
+		php_gd_error("Could not save WBMP\n");
+	}
+	/* des submitted this bugfix: gdFree the memory. */
+	freewbmp(wbmp);
+}
 
 /* gdImageCreateFromWBMPCtx
    ** ------------------------
    ** Create a gdImage from a WBMP file input from an gdIOCtx
  */
-gdImagePtr
-gdImageCreateFromWBMPCtx (gdIOCtx * infile)
+gdImagePtr gdImageCreateFromWBMPCtx (gdIOCtx * infile)
 {
-  /* FILE *wbmp_file; */
-  Wbmp *wbmp;
-  gdImagePtr im = NULL;
-  int black, white;
-  int col, row, pos;
-
-  if (readwbmp (&gd_getin, infile, &wbmp))
-    return (NULL);
-
-  if (!(im = gdImageCreate (wbmp->width, wbmp->height)))
-    {
-      freewbmp (wbmp);
-      return (NULL);
-    }
-
-  /* create the background color */
-  white = gdImageColorAllocate (im, 255, 255, 255);
-  /* create foreground color */
-  black = gdImageColorAllocate (im, 0, 0, 0);
-
-  /* fill in image (in a wbmp 1 = white/ 0 = black) */
-  pos = 0;
-  for (row = 0; row < wbmp->height; row++)
-    {
-      for (col = 0; col < wbmp->width; col++)
-	{
-	  if (wbmp->bitmap[pos++] == WBMP_WHITE)
-	    {
-	      gdImageSetPixel (im, col, row, white);
-	    }
-	  else
-	    {
-	      gdImageSetPixel (im, col, row, black);
-	    }
+	/* FILE *wbmp_file; */
+	Wbmp *wbmp;
+	gdImagePtr im = NULL;
+	int black, white;
+	int col, row, pos;
+
+	if (readwbmp (&gd_getin, infile, &wbmp)) {
+		return NULL;
 	}
-    }
 
-  freewbmp (wbmp);
+	if (!(im = gdImageCreate (wbmp->width, wbmp->height))) {
+		freewbmp (wbmp);
+		return NULL;
+	}
 
-  return (im);
-}
+	/* create the background color */
+	white = gdImageColorAllocate(im, 255, 255, 255);
+	/* create foreground color */
+	black = gdImageColorAllocate(im, 0, 0, 0);
+
+	/* fill in image (in a wbmp 1 = white/ 0 = black) */
+	pos = 0;
+	for (row = 0; row < wbmp->height; row++) {
+		for (col = 0; col < wbmp->width; col++) {
+			if (wbmp->bitmap[pos++] == WBMP_WHITE) {
+				gdImageSetPixel(im, col, row, white);
+			} else {
+				gdImageSetPixel(im, col, row, black);
+			}
+		}
+	}
 
+	freewbmp(wbmp);
+
+	return im;
+}
 
 /* gdImageCreateFromWBMP
    ** ---------------------
  */
-gdImagePtr
-gdImageCreateFromWBMP (FILE * inFile)
+gdImagePtr gdImageCreateFromWBMP (FILE * inFile)
 {
-  gdImagePtr im;
-  gdIOCtx *in = gdNewFileCtx (inFile);
-  im = gdImageCreateFromWBMPCtx (in);
-  in->gd_free (in);
-  return (im);
+	gdImagePtr im;
+	gdIOCtx *in = gdNewFileCtx(inFile);
+	im = gdImageCreateFromWBMPCtx(in);
+	in->gd_free(in);
+
+	return im;
 }
 
 /* gdImageWBMP
    ** -----------
  */
-void
-gdImageWBMP (gdImagePtr im, int fg, FILE * outFile)
+void gdImageWBMP (gdImagePtr im, int fg, FILE * outFile)
 {
-  gdIOCtx *out = gdNewFileCtx (outFile);
-  gdImageWBMPCtx (im, fg, out);
-  out->gd_free (out);
+	gdIOCtx *out = gdNewFileCtx(outFile);
+	gdImageWBMPCtx(im, fg, out);
+	out->gd_free(out);
 }
 
 /* gdImageWBMPPtr
    ** --------------
  */
-void *
-gdImageWBMPPtr (gdImagePtr im, int *size, int fg)
+void * gdImageWBMPPtr (gdImagePtr im, int *size, int fg)
 {
-  void *rv;
-  gdIOCtx *out = gdNewDynamicCtx (2048, NULL);
-  gdImageWBMPCtx (im, fg, out);
-  rv = gdDPExtractData (out, size);
-  out->gd_free (out);
-  return rv;
+	void *rv;
+	gdIOCtx *out = gdNewDynamicCtx(2048, NULL);
+	gdImageWBMPCtx(im, fg, out);
+	rv = gdDPExtractData(out, size);
+	out->gd_free(out);
+	
+	return rv;
 }