texk 1

git-svn-id: svn://tug.org/texlive/trunk@1485 c570f23f-e606-0410-a88d-b1316a301751

1 files changed, 593 insertions, 0 deletions

diff --git a/Build/source/texk/web2c/pdftexdir/writepng.c b/Build/source/texk/web2c/pdftexdir/writepng.c
new file mode 100644
index 00000000000..30340c9e08e
--- /dev/null
+++ b/Build/source/texk/web2c/pdftexdir/writepng.c
@@ -0,0 +1,593 @@
+/*
+Copyright (c) 1996-2004 Han The Thanh, <thanh@pdftex.org>
+
+This file is part of pdfTeX.
+
+pdfTeX is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+pdfTeX is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with pdfTeX; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+$Id: //depot/Build/source.development/TeX/texk/web2c/pdftexdir/writepng.c#8 $
+*/
+
+#include "ptexlib.h"
+#include "image.h"
+
+
+
+static const char perforce_id[] = 
+    "$Id: //depot/Build/source.development/TeX/texk/web2c/pdftexdir/writepng.c#8 $";
+
+
+void read_png_info(integer img)
+{
+    double gamma;
+    FILE *png_file = xfopen(img_name(img), FOPEN_RBIN_MODE);
+    
+    if ((png_ptr(img) = png_create_read_struct(PNG_LIBPNG_VER_STRING, 
+        NULL, NULL, NULL)) == NULL)
+        pdftex_fail("libpng: png_create_read_struct() failed");
+    if ((png_info(img) = png_create_info_struct(png_ptr(img))) == NULL)
+        pdftex_fail("libpng: png_create_info_struct() failed");
+    if (setjmp(png_ptr(img)->jmpbuf))
+        pdftex_fail("libpng: internal error");
+    png_init_io(png_ptr(img), png_file);
+    png_read_info(png_ptr(img), png_info(img));
+	/* simple transparency support */
+    if (png_get_valid(png_ptr(img), png_info(img),  PNG_INFO_tRNS)) {
+      png_set_tRNS_to_alpha(png_ptr(img));
+	}
+    /* alpha channel support  */
+    if (fixedpdfminorversion < 4 && png_ptr(img)->color_type | PNG_COLOR_MASK_ALPHA)
+	  png_set_strip_alpha(png_ptr(img));
+    /* 16bit depth support */
+    if  (fixedpdfminorversion < 5)
+      fixedimagehicolor = 0;
+    if (png_info(img)->bit_depth == 16 && !fixedimagehicolor)
+	  png_set_strip_16(png_ptr(img));
+    /* gamma support */
+	if (fixedimageapplygamma) {
+	  if(png_get_gAMA(png_ptr(img), png_info(img), &gamma))
+		png_set_gamma(png_ptr(img), (fixedgamma / 1000.0), gamma);
+	  else
+		png_set_gamma(png_ptr(img), (fixedgamma / 1000.0), (1000.0/ fixedimagegamma ));
+    }
+    /* reset structure */
+    png_read_update_info(png_ptr(img), png_info(img));
+    /* resolution support */
+    img_width(img) =  png_info(img)->width;
+    img_height(img) =  png_info(img)->height;
+    if (png_info(img)->valid & PNG_INFO_pHYs) {
+	  img_xres(img) = 
+		round(0.0254*png_get_x_pixels_per_meter(png_ptr(img), png_info(img)));
+	  img_yres(img) =
+		round(0.0254*png_get_y_pixels_per_meter(png_ptr(img), png_info(img)));
+    }
+    switch (png_info(img)->color_type) {
+    case PNG_COLOR_TYPE_PALETTE:
+        img_color(img) = IMAGE_COLOR_C | IMAGE_COLOR_I;
+        break;
+    case PNG_COLOR_TYPE_GRAY:
+    case PNG_COLOR_TYPE_GRAY_ALPHA:
+        img_color(img) = IMAGE_COLOR_B;
+        break;
+    case PNG_COLOR_TYPE_RGB:
+    case PNG_COLOR_TYPE_RGB_ALPHA:
+        img_color(img) = IMAGE_COLOR_C;
+        break;
+    default:
+        pdftex_fail("unsupported type of color_type <%i>", png_info(img)->color_type);
+    }
+}
+
+
+#define write_gray_pixel_16(r)                           \
+  if (j % 4 == 0||j % 4 == 1)  pdfbuf[pdfptr++]  = *r++; \
+  else                        smask[smask_ptr++] = *r++
+
+#define write_gray_pixel_8(r)                   \
+    if (j % 2 == 0)  pdfbuf[pdfptr++]   = *r++; \
+    else  	     smask[smask_ptr++] = *r++
+
+
+#define write_rgb_pixel_16(r)                                 \
+    if (!(j % 8 == 6||j % 8 == 7)) pdfbuf[pdfptr++]  = *r++;  \
+    else                           smask[smask_ptr++] = *r++
+
+#define write_rgb_pixel_8(r)                                 \
+    if (j % 4 != 3)      pdfbuf[pdfptr++]  = *r++;           \
+    else                 smask[smask_ptr++] = *r++
+
+#define write_simple_pixel(r)    pdfbuf[pdfptr++] = *r++
+
+
+#define write_noninterlaced(outmac)                    \
+  for (i = 0; i < (int)png_info(img)->height; i++) {   \
+    png_read_row(png_ptr(img), row, NULL);             \
+    r = row;                                           \
+    k = png_info(img)->rowbytes;                       \
+    while(k > 0) {                                     \
+	l = (k > pdfbufsize)? pdfbufsize : k;          \
+		pdfroom(l);                            \
+		for (j = 0; j < l; j++) {              \
+		  outmac;	                       \
+		}                                      \
+		k -= l;                                \
+	    }                                          \
+        }
+
+#define write_interlaced(outmac)                       \
+  for (i = 0; i < (int)png_info(img)->height; i++) {   \
+            row = rows[i];                             \
+	    k = png_info(img)->rowbytes;               \
+	    while(k > 0) {                             \
+		l = (k > pdfbufsize)? pdfbufsize : k;  \
+		pdfroom(l);                            \
+		for (j = 0; j < l; j++) {              \
+		  outmac;           	               \
+		}                                      \
+		k -= l;                                \
+	    }                                          \
+            xfree(rows[i]);                            \
+        }
+
+
+void write_png_palette (integer img)
+{
+    int i, j, k, l;
+    png_bytep row, r, *rows;
+    integer palette_objnum = 0;
+    pdfcreateobj(0, 0);
+    palette_objnum = objptr;
+    if (img_colorspace_ref(img) != 0) {
+	  pdf_printf("%i 0 R\n", (int)img_colorspace_ref(img));
+    }
+    else {
+	  pdf_printf("[/Indexed /DeviceRGB %i %i 0 R]\n",
+	       (int)(png_info(img)->num_palette - 1),
+	       (int)palette_objnum);
+	}
+    pdfbeginstream();
+    if (png_info(img)->interlace_type == PNG_INTERLACE_NONE) {
+        row = xtalloc(png_info(img)->rowbytes, png_byte);
+	write_noninterlaced(write_simple_pixel(r));
+        xfree(row);
+    } else {
+        if (png_info(img)->height*png_info(img)->rowbytes >= 10240000L)
+            pdftex_warn("large interlaced PNG might cause out of memory (use non-interlaced PNG to fix this)");
+        rows = xtalloc(png_info(img)->height, png_bytep);
+        for (i = 0; i < png_info(img)->height; i++)
+            rows[i] = xtalloc(png_info(img)->rowbytes, png_byte);
+        png_read_image(png_ptr(img), rows);
+        write_interlaced(write_simple_pixel(row));
+        xfree(rows);
+    }
+    pdfendstream();
+    if (palette_objnum > 0) {
+        pdfbegindict(palette_objnum);
+        pdfbeginstream();
+        for (i = 0; i < png_info(img)->num_palette; i++) {
+            pdfroom(3);
+            pdfbuf[pdfptr++] = png_info(img)->palette[i].red;
+            pdfbuf[pdfptr++] = png_info(img)->palette[i].green;
+            pdfbuf[pdfptr++] = png_info(img)->palette[i].blue;
+        }
+        pdfendstream();
+    }
+}
+
+void write_png_gray (integer img)
+{
+    int i, j, k, l;
+    png_bytep row, r, *rows;
+    if (img_colorspace_ref(img) != 0) {
+        pdf_printf("%i 0 R\n", (int)img_colorspace_ref(img));
+    }
+    else {
+	  pdf_puts("/DeviceGray\n");
+	}
+    pdfbeginstream();
+    if (png_info(img)->interlace_type == PNG_INTERLACE_NONE) {
+        row = xtalloc(png_info(img)->rowbytes, png_byte);
+	write_noninterlaced(write_simple_pixel(r));
+        xfree(row);
+    } else {
+        if (png_info(img)->height*png_info(img)->rowbytes >= 10240000L)
+            pdftex_warn("large interlaced PNG might cause out of memory (use non-interlaced PNG to fix this)");
+        rows = xtalloc(png_info(img)->height, png_bytep);
+        for (i = 0; i < png_info(img)->height; i++)
+            rows[i] = xtalloc(png_info(img)->rowbytes, png_byte);
+        png_read_image(png_ptr(img), rows);
+        write_interlaced(write_simple_pixel(row));
+        xfree(rows);
+    }
+    pdfendstream();
+}
+
+
+
+void write_png_gray_alpha (integer img)
+{
+    int i, j, k, l;
+    png_bytep row, r, *rows;
+    integer smask_objnum = 0;
+    png_bytep smask;
+    integer smask_ptr = 0;
+    integer smask_size = 0;
+    int bitdepth;
+    if (img_colorspace_ref(img) != 0) {
+        pdf_printf("%i 0 R\n", (int)img_colorspace_ref(img));
+    }
+    else {
+	  pdf_puts("/DeviceGray\n");
+	}
+    pdfcreateobj(0, 0);
+    smask_objnum = objptr;
+    pdf_printf("/SMask %i 0 R\n",
+	       (int)smask_objnum);
+    smask_size = (png_info(img)->rowbytes/2)*png_info(img)->height;
+    smask = xtalloc(smask_size, png_byte);
+    pdfbeginstream();
+    if (png_info(img)->interlace_type == PNG_INTERLACE_NONE) {
+        row = xtalloc(png_info(img)->rowbytes, png_byte);
+	if ((png_info(img)->bit_depth == 16) && fixedimagehicolor) {
+	  write_noninterlaced(write_gray_pixel_16(r));
+	} else {
+	  write_noninterlaced(write_gray_pixel_8(r));
+	}
+        xfree(row);
+    } else {
+        if (png_info(img)->height*png_info(img)->rowbytes >= 10240000L)
+            pdftex_warn("large interlaced PNG might cause out of memory (use non-interlaced PNG to fix this)");
+        rows = xtalloc(png_info(img)->height, png_bytep);
+        for (i = 0; i < png_info(img)->height; i++)
+            rows[i] = xtalloc(png_info(img)->rowbytes, png_byte);
+        png_read_image(png_ptr(img), rows);
+	if ((png_info(img)->bit_depth == 16) && fixedimagehicolor) {
+	  write_interlaced(write_gray_pixel_16(row));
+	} else {
+	  write_interlaced(write_gray_pixel_8(row));
+	}
+        xfree(rows);
+    }
+    pdfendstream();
+    pdfflush();
+    /* now write the Smask object */
+    if (smask_objnum > 0) {
+	  bitdepth = (int)png_info(img)->bit_depth;
+      pdfbegindict(smask_objnum);
+      pdf_puts("/Type /XObject\n/Subtype /Image\n");
+      pdf_printf("/Width %i\n/Height %i\n/BitsPerComponent %i\n",
+		 (int)png_info(img)->width,
+		 (int)png_info(img)->height,
+		 (bitdepth == 16 ? 8 : bitdepth));
+      pdf_puts("/ColorSpace /DeviceGray\n");
+      pdfbeginstream();
+      for (i = 0; i <smask_size; i++) {
+		if (i % 8 == 0)
+		  pdfroom(8);
+		pdfbuf[pdfptr++] = smask[i];
+		if (bitdepth == 16)
+		  i++;
+      }
+      xfree(smask);
+      pdfendstream();
+    }
+}
+
+void write_png_rgb (integer img)
+{
+    int i, j, k, l;
+    png_bytep row, r, *rows;
+    if (img_colorspace_ref(img) != 0) {
+        pdf_printf("%i 0 R\n", (int)img_colorspace_ref(img));
+    }
+    else {
+	  pdf_puts("/DeviceRGB\n");
+	}
+    pdfbeginstream();
+    if (png_info(img)->interlace_type == PNG_INTERLACE_NONE) {
+        row = xtalloc(png_info(img)->rowbytes, png_byte);
+	write_noninterlaced(write_simple_pixel(r));
+        xfree(row);
+    } else {
+        if (png_info(img)->height*png_info(img)->rowbytes >= 10240000L)
+            pdftex_warn("large interlaced PNG might cause out of memory (use non-interlaced PNG to fix this)");
+        rows = xtalloc(png_info(img)->height, png_bytep);
+        for (i = 0; i < png_info(img)->height; i++)
+            rows[i] = xtalloc(png_info(img)->rowbytes, png_byte);
+        png_read_image(png_ptr(img), rows);
+        write_interlaced(write_simple_pixel(row));
+        xfree(rows);
+    }
+    pdfendstream();
+}
+
+void write_png_rgb_alpha (integer img)
+{
+    int i, j, k, l;
+    png_bytep row, r, *rows;
+    integer smask_objnum = 0;
+    png_bytep smask;
+    integer smask_ptr = 0;
+    integer smask_size = 0;
+    int bitdepth;
+    if (img_colorspace_ref(img) != 0) {
+        pdf_printf("%i 0 R\n", (int)img_colorspace_ref(img));
+    }
+    else {
+	  pdf_puts("/DeviceRGB\n");
+	}
+    pdfcreateobj(0, 0);
+    smask_objnum = objptr;
+    pdf_printf("/SMask %i 0 R\n",
+	       (int)smask_objnum);
+    smask_size = (png_info(img)->rowbytes/2)*png_info(img)->height;
+    smask = xtalloc(smask_size, png_byte);
+    pdfbeginstream();
+    if (png_info(img)->interlace_type == PNG_INTERLACE_NONE) {
+        row = xtalloc(png_info(img)->rowbytes, png_byte);
+	if ((png_info(img)->bit_depth == 16) && fixedimagehicolor) {
+	  write_noninterlaced(write_rgb_pixel_16(r));
+	} else {
+	  write_noninterlaced(write_rgb_pixel_8(r));
+	}
+        xfree(row);
+    } else {
+        if (png_info(img)->height*png_info(img)->rowbytes >= 10240000L)
+            pdftex_warn("large interlaced PNG might cause out of memory (use non-interlaced PNG to fix this)");
+        rows = xtalloc(png_info(img)->height, png_bytep);
+        for (i = 0; i < png_info(img)->height; i++)
+            rows[i] = xtalloc(png_info(img)->rowbytes, png_byte);
+        png_read_image(png_ptr(img), rows);
+	if ((png_info(img)->bit_depth == 16) && fixedimagehicolor) {
+	  write_interlaced(write_rgb_pixel_16(row));
+	} else {
+	  write_interlaced(write_rgb_pixel_8(row));
+	}
+        xfree(rows);
+    }
+    pdfendstream();
+    pdfflush();
+    /* now write the Smask object */
+    if (smask_objnum > 0) {
+	  bitdepth = (int)png_info(img)->bit_depth;
+      pdfbegindict(smask_objnum);
+      pdf_puts("/Type /XObject\n/Subtype /Image\n");
+      pdf_printf("/Width %i\n/Height %i\n/BitsPerComponent %i\n",
+		 (int)png_info(img)->width,
+		 (int)png_info(img)->height,
+				 (bitdepth == 16 ? 8 : bitdepth));
+      pdf_puts("/ColorSpace /DeviceGray\n");
+      pdfbeginstream();
+      for (i = 0; i <smask_size; i++) {
+		if (i % 8 == 0)
+		  pdfroom(8);
+		pdfbuf[pdfptr++] = smask[i];
+		if (bitdepth == 16)
+		  i++;
+      }
+      xfree(smask);
+      pdfendstream();
+    }
+}
+
+
+/**********************************************************************/
+/*
+ *
+ * The |copy_png| function is from Hartmut Henkel. The goal is to use 
+ * pdf's native FlateDecode support if that is possible.
+ *
+ * Only a subset of the png files allows this, but when possible it
+ * greatly improves inclusion speed. 
+ *
+ */
+
+/* Code cheerfully gleaned from Thomas Merz' PDFlib, file p_png.c "SPNG - Simple PNG" */
+
+static int spng_getint(FILE * fp)
+{
+    unsigned char buf[4];
+    if (fread(buf, 1, 4, fp) != 4)
+	pdftex_fail("writepng: reading chunk type failed");
+    return (((((int) buf[0] << 8) + buf[1]) << 8) + buf[2] << 8) + buf[3];
+}
+
+#define SPNG_CHUNK_IDAT 0x49444154
+#define SPNG_CHUNK_IEND 0x49454E44
+
+void copy_png(integer img)
+{
+    FILE *fp = png_ptr(img)->io_ptr;
+    int i, len, type, streamlength = 0;
+    boolean endflag = false;
+    int idat = 0;		/* flag to check continuous IDAT chunks sequence */
+    /* 1st pass to find overall stream /Length */
+    if (fseek(fp, 8, SEEK_SET) != 0)
+	  pdftex_fail("writepng: fseek in PNG file failed");
+    do {
+	  len = spng_getint(fp);
+	  type = spng_getint(fp);
+	  switch (type) {
+	  case SPNG_CHUNK_IEND:
+	    endflag = true;
+	    break;
+	  case SPNG_CHUNK_IDAT:
+	    streamlength += len;
+	  default:
+	    if (fseek(fp, len + 4, SEEK_CUR) != 0)
+		pdftex_fail("writepng: fseek in PNG file failed");
+	  }
+    } while (endflag == false);
+    pdf_printf("/Length %d\n", streamlength);
+    pdf_printf("/Filter /FlateDecode\n");
+    pdf_printf("/DecodeParms << ");
+    pdf_printf("/Colors %d ", png_info(img)->color_type == 2 ? 3 : 1);
+    pdf_printf("/Columns %d ", (int) png_info(img)->width);
+    pdf_printf("/BitsPerComponent %i ", (int) png_info(img)->bit_depth);
+    pdf_printf("/Predictor %d ", 10);	/* actual predictor defined on line basis */
+    pdf_printf(">>\n>>\nstream\n");
+    /* 2nd pass to copy data */
+    endflag = false;
+    if (fseek(fp, 8, SEEK_SET) != 0)
+	pdftex_fail("writepng: fseek in PNG file failed");
+    do {
+	len = spng_getint(fp);
+	type = spng_getint(fp);
+	switch (type) {
+	case SPNG_CHUNK_IDAT:	/* do copy */
+	    if (idat == 2)
+		pdftex_fail("writepng: IDAT chunk sequence broken");
+	    idat = 1;
+	    while (len > 0) {
+		i = (len > pdfbufsize) ? pdfbufsize : len;
+		pdfroom(i);
+		fread(&pdfbuf[pdfptr], 1, i, fp);
+		pdfptr += i;
+		len -= i;
+	    }
+	    if (fseek(fp, 4, SEEK_CUR) != 0)
+		pdftex_fail("writepng: fseek in PNG file failed");
+	    break;
+	case SPNG_CHUNK_IEND:	/* done */
+	    pdf_puts("\nendstream\nendobj\n");
+	    endflag = true;
+	    break;
+	default:
+	    if (idat == 1)
+		idat = 2;
+	    if (fseek(fp, len + 4, SEEK_CUR) != 0)
+		pdftex_fail("writepng: fseek in PNG file failed");
+	}
+    } while (endflag == false);
+}
+
+void write_png (integer img)
+{
+
+    double gamma, checked_gamma;
+	int i;
+    integer palette_objnum = 0;
+    if  (fixedpdfminorversion < 5)
+      fixedimagehicolor = 0;
+
+    pdf_puts("/Type /XObject\n/Subtype /Image\n");
+    pdf_printf("/Width %i\n/Height %i\n/BitsPerComponent %i\n",
+               (int)png_info(img)->width,
+               (int)png_info(img)->height,
+               (int)png_info(img)->bit_depth);
+    pdf_puts("/ColorSpace ");
+	checked_gamma = 1.0;
+	if (fixedimageapplygamma) {
+	  if(png_get_gAMA(png_ptr(img), png_info(img), &gamma)) {
+		checked_gamma = (fixedgamma / 1000.0) * gamma;
+	  } else {
+		checked_gamma = (fixedgamma / 1000.0) * (1000.0/ fixedimagegamma );
+	  }
+	}
+    /* the switching between |png_info| and |png_ptr| queries has been trial and error. 
+	 */
+    if (fixedpdfminorversion > 1
+		&& png_info(img)->interlace_type == PNG_INTERLACE_NONE 
+		&& (png_ptr(img)->transformations == 0 || 
+			png_ptr(img)->transformations == 0x2000 ) /* gamma */
+		&& !(png_ptr(img)->color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
+			 png_ptr(img)->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+		&& (fixedimagehicolor || (png_ptr(img)->bit_depth <= 8))
+		&& (checked_gamma <= 1.01 && checked_gamma > 0.99)
+		) 
+	  {
+    if (img_colorspace_ref(img) != 0) {
+        pdf_printf("%i 0 R\n", (int)img_colorspace_ref(img));
+    }
+    else {
+	  switch (png_info(img)->color_type) {
+	  case PNG_COLOR_TYPE_PALETTE:
+		pdfcreateobj(0, 0);
+		palette_objnum = objptr;
+		pdf_printf("[/Indexed /DeviceRGB %i %i 0 R]\n",
+				   (int) (png_info(img)->num_palette - 1),
+				   (int) palette_objnum);
+		break;
+      case PNG_COLOR_TYPE_GRAY:
+		pdf_puts("/DeviceGray\n");
+        break;
+	  default: /* RGB */
+		pdf_puts("/DeviceRGB\n");
+	  };
+	}
+	  tex_printf(" (PNG copy)");
+	  copy_png(img);
+	  if (palette_objnum > 0) {
+		pdfbegindict(palette_objnum);
+		pdfbeginstream();
+		for (i = 0; i < png_info(img)->num_palette; i++) {
+		  pdfroom(3);
+		  pdfbuf[pdfptr++] = png_info(img)->palette[i].red;
+		  pdfbuf[pdfptr++] = png_info(img)->palette[i].green;
+		  pdfbuf[pdfptr++] = png_info(img)->palette[i].blue;
+		}
+		pdfendstream();
+	  }
+	} else {
+    if (0) {
+	  tex_printf(" PNG copy skipped because: ");
+	  if(fixedimageapplygamma && 
+         (checked_gamma > 1.01 || checked_gamma < 0.99))
+		tex_printf("gamma delta=%lf ", checked_gamma);
+	  if (png_ptr(img)->transformations != PNG_TRANSFORM_IDENTITY)
+		tex_printf("transform=%d",png_ptr(img)->transformations);
+	  if ((png_info(img)->color_type != PNG_COLOR_TYPE_GRAY) &&
+			   (png_info(img)->color_type != PNG_COLOR_TYPE_RGB) &&
+			   (png_info(img)->color_type != PNG_COLOR_TYPE_PALETTE))
+		tex_printf("colortype ");
+ 	  if (fixedpdfminorversion <= 1)
+		tex_printf("version=%d ",fixedpdfminorversion);
+	  if (png_info(img)->interlace_type != PNG_INTERLACE_NONE)
+		tex_printf("interlaced ");
+	  if (png_info(img)->bit_depth > 8)
+		tex_printf("bitdepth=%d ",png_info(img)->bit_depth);
+	  if (png_get_valid(png_ptr(img), png_info(img),  PNG_INFO_tRNS)) 
+		tex_printf("simple transparancy ");
+	}
+	  switch (png_info(img)->color_type) {
+	  case PNG_COLOR_TYPE_PALETTE:
+		write_png_palette(img);
+		break;
+	  case PNG_COLOR_TYPE_GRAY:
+		write_png_gray(img);
+		break;
+	  case PNG_COLOR_TYPE_GRAY_ALPHA:
+		if (fixedpdfminorversion >=4)
+		  write_png_gray_alpha(img);
+		else
+		  write_png_gray(img);
+		break;
+	  case PNG_COLOR_TYPE_RGB:
+		write_png_rgb(img);
+		break;
+	  case PNG_COLOR_TYPE_RGB_ALPHA:
+		if (fixedpdfminorversion >=4)
+		  write_png_rgb_alpha(img);
+		else
+		  write_png_rgb(img);
+		break;
+	  default:
+		pdftex_fail("unsupported type of color_type <%i>", png_info(img)->color_type);
+	  }
+	}
+	pdfflush(); 
+}
+
+