开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 浏览器 > 查看源码
png.c
资源名称：arena-beta-2b-src.tar.gz　[点击查看]
上传用户：zlh9724
上传日期：2007-01-04
资源大小：1991k
文件大小：18k
源码类别：

浏览器

开发平台：

Unix_Linux

png.c：源码内容
  1. #include <stdio.h>
  2. #define Byte WWWByte
  3. #include "www.h"
  4. #undef Byte
  6. #ifdef PNG
  8. #include "png.h"
  10. extern Visual *visual;
  11. extern int RPixelShift;   /* GRR */
  12. extern int GPixelShift;   /* GRR */
  13. extern int BPixelShift;   /* GRR */
  14. extern int RPixelMask, GPixelMask, BPixelMask;
  15. extern int depth;         /* Depth of display in bits */
  16. extern Colormap colormap;
  17. extern int imaging;       /* set to COLOR888, COLOR232, GREY4 or MONO */
  18. extern int tileWidth, tileHeight;
  19. extern unsigned char *tileData;
  20. extern unsigned long windowColor;
  21. extern unsigned long stdcmap[128];  /* 2/3/2 color maps for gifs etc */
  22. extern unsigned long greymap[16];
  23. extern debug;
  24. extern unsigned long transparent;
  25. extern double Gamma;
  26. extern XColor papercols[256];
  27. extern unsigned char *gamma_table; /* For gamma correcting paper */
  29. /* defined in module dither */
  30. extern int Magic256[256];
  31. extern int Magic16[256];
  32. extern int Magic32[256];
  33. extern int Magic64[256];
  35. /*png_rw_ptr */
  36. static void
  37. arena_png_read_data(png_structp png_ptr, png_bytep data, png_uint_32 length)
  38. {
  39.   Block *bp=(Block*)png_get_io_ptr(png_ptr);
  40.   
  41.   if (bp->size > bp->next) {
  42.     if (bp->next + length > bp->size)
  43.       length = bp->size - bp->next;
  44.     
  45.     memcpy(data, bp->buffer + bp->next, length);
  46.     bp->next += length;
  47.     return;
  48.   } else {
  49.     png_error(png_ptr, "Read Error");
  50.   }
  51. }
  54. void
  55. png_error(png_struct *png_ptr, char *message)
  56. {
  57.   fprintf(stderr,"libpng error: %sn", message);
  58.   /* Warn("libpng error: %sn", message); */
  59.   longjmp(png_ptr->jmpbuf, 1);
  60. }
  62. void
  63. png_warning(png_struct *png_ptr, char *message)
  64. {
  65.   if (!png_ptr)
  66.     return;
  68.   fprintf(stderr,"libpng warning: %sn", message);
  69.   /* Warn("libpng warning: %sn", message); */
  70. }
  73. /* Read image into displays 1,2 or 4 bit deep */
  74. unsigned char *ReadPNGImage_1_2_4(png_struct *png_ptr, png_info *info_ptr, png_byte *png_image) 
  75. {
  76.   png_byte *pp;
  77.   unsigned char *data, *dp;
  78.   int ypos;
  79.   int ppb, bpl;
  80.   int len=info_ptr->width;
  81.   int color_type=info_ptr->color_type;
  82.   int alpha;
  83.   int newbyte;
  84.   
  85.   ppb = 8/depth; /* pixels per byte */
  86.   bpl = len/ppb + (len%ppb ? 1 : 0); /* bytes per line */
  87.   
  88.   data = (unsigned char *)malloc(bpl * info_ptr->height);
  89.   if (data == NULL)
  90.     png_error (png_ptr, "couldn't alloc space for X image data");
  91.   
  92.   /* Remove alpha channel from type,  but remember it */
  93.   alpha=color_type & PNG_COLOR_MASK_ALPHA;
  94.   color_type &= ~PNG_COLOR_MASK_ALPHA;
  95.   
  96.   pp=png_image;
  97.   dp=data;
  98.   newbyte = 1;
  99.   for (ypos = 0; ypos < png_ptr->height; ypos++)
  100.     {
  101.       int col = ypos & 0x0f;
  102.       int shift=0;
  103.       int xpos;
  104.       
  105.       for (xpos = 0; xpos < len; ++xpos)
  106. {
  107.   int row = xpos & 0x0f;
  108.   int gr;
  109.   int cr=0, cg=0, cb=0, cgr, a;
  110.   int isgrey = 0;
  111.   
  112.   if (newbyte) {
  113.     *dp = 0;
  114.     newbyte = 0;
  115.   }
  116.   
  117. /*
  118. (From gif.c)
  119. Some quick notes to remember how shift is calculated:
  121. 0 1 2 3 4 5 6 7 8 9  xpos
  122. 0 1 2 3 4 5 6 7 0 1     xpos %8
  123. 7 6 5 4 3 2 1 0 7 6     7 - (xpos % 8)
  125. 1 0 1 0 1 0 1 0 1 0     (7 - (xpos % 8)) % ppb               pixels perl byte = 2
  126. 4 0 4 0 4 0 4 0 4 0     ((7 - (xpos % 8)) % ppb) * depth     depth = 4
  128. 3 2 1 0 3 2 1                                                pixels per byte = 4
  129. 6 4 2 0 6 4 2                                                depth = 2
  131. */
  132.   shift = (((7 - (xpos % 8)) % ppb) * depth);
  133.   
  134.   if (color_type == PNG_COLOR_TYPE_GRAY) {
  135.     cr=cg=cb=cgr=(*pp++);
  136.     isgrey=1;
  137.   } else if (color_type == PNG_COLOR_TYPE_RGB) {
  138.     int drb, dgb, dbr;
  139.     
  140.     cr= (*pp++);
  141.     cg= (*pp++);
  142.     cb= (*pp++);
  143.     cgr = (0.59*cr) + (0.20*cg) + (0.11*cb);
  145.     drb = abs(cr - cb);
  146.     dgb = abs(cg - cb);
  147.     dbr = abs(cb - cr);
  148.     if (drb < 20 && dgb < 20 && dbr < 20)
  149.       isgrey=1;
  150.   } else {
  151.     png_error(png_ptr, "Unknown PNG color type seen (ReadPNGImage_1_2_4)");
  152.   }
  153.   
  154.   /* Process alpha channel if present */
  155.   if (alpha)
  156.     a=(*pp++);
  157.   
  158.   if (alpha && a != 0xff) {
  159.     int tr,tg,tb;
  160.     int drb, dgb, dbr;
  161.     
  162.     /* From www.c - sorry! */
  163.     if(depth==1) {
  164.       tr=255; tg=255; tb=255;
  165.     } else {
  166.       tr=220; tg=209; tb=186;
  167.     }
  168.       
  169.             /* Add picture pixel to background pixel */
  170.     cr=(a/255.0)*cr + ((255.0-a)/255.0) * tr;
  171.     cg=(a/255.0)*cg + ((255.0-a)/255.0) * tg;
  172.     cb=(a/255.0)*cb + ((255.0-a)/255.0) * tb;
  173.     
  174.     /* Recalculate grayness */
  175.     cgr = (0.59*cr) + (0.20*cg) + (0.11*cb);
  176.     isgrey=0;
  177.     drb = abs(cr - cb);
  178.     dgb = abs(cg - cb);
  179.     dbr = abs(cb - cr);
  180.     if (drb < 20 && dgb < 20 && dbr < 20)
  181.       isgrey=1;
  182.   }
  183.   
  184.   if (alpha && !a)
  185.     *dp |= transparent << shift;
  186.   else if (imaging == COLOR232)
  187.     {
  188.       if (isgrey) {
  189.                 int gr = cgr & 0xF0;
  191.                 if (cgr - gr > Magic16[(row << 4) + col])
  192.                     gr += 16;
  194.                 gr = min(gr, 0xF0);
  195.                 
  196. *dp |= greymap[gr >> 4] << shift;
  197.       } else {
  198. int r = cr & 0xC0;
  199. int g = cg & 0xE0;
  200. int b = cb & 0xC0;
  201. int v = (row << 4) + col;
  203. if (cr - r > Magic64[v])
  204.   r += 64;
  206. if (cg - g > Magic32[v])
  207.   g += 32;
  209. if (cb - b > Magic64[v])
  210.   b += 64;
  212. /* clamp error to keep color in range 0 to 255 */
  214. r = min(r, 255) & 0xC0;
  215. g = min(g, 255) & 0xE0;
  216. b = min(b, 255) & 0xC0;
  217.   
  218. *dp |= stdcmap[(r >> 6) | (g >> 3) | (b >> 1)] << shift;
  219.       }
  220.     }
  221.   else if (imaging == MONO)
  222.     {
  223.       if (cgr < Magic256[(row << 4) + col])
  224. *dp |= greymap[0] << shift;
  225.       else
  226. *dp |= greymap[15] << shift;
  227.     }
  228.   else /* Not COLOR232 or MONO */
  229.     {
  230.       gr = cgr & 0xF0;
  231.       if (cgr - gr > Magic16[(row << 4) + col])
  232. gr += 16;
  234.       gr = min(gr, 0xF0);
  235.       *dp |= greymap[gr >> 4] << shift;
  236.     }
  237.   
  238.   if (shift == 0) {
  239.     dp++;
  240.     newbyte = 1;
  241.   }
  242.   
  243. } /* xpos */
  244.       
  245.       if (shift) {
  246.   dp++;   /* make sure we start on a new byte for the next line */
  247.   newbyte = 1;
  248. }
  249.     } /* ypos */
  250.   
  251.   return(data);
  252.   
  253. }
  256. /* Read image into displays 24 bit deep */
  257. unsigned char *ReadPNGImage_24(png_struct *png_ptr, png_info *info_ptr, png_byte *png_image) 
  258. {
  259.   png_byte *pp;
  260.   unsigned char *data, *dp;
  261.   unsigned long int ulp;
  262.   int ypos;
  263.   int len=info_ptr->width;
  264.   int color_type=info_ptr->color_type;
  265.   int alpha;
  266.   
  267.   data = (unsigned char *)malloc(4 * len * info_ptr->height);
  268.   if (data == NULL)
  269.     png_error (png_ptr, "couldn't alloc space for X image data");
  270.   
  271.   /* Remove alpha channel from type,  but remember it */
  272.   alpha=color_type & PNG_COLOR_MASK_ALPHA;
  273.   color_type &= ~PNG_COLOR_MASK_ALPHA;
  274.   
  275.   pp=png_image;
  276.   dp=data;
  277.   for (ypos = 0; ypos < png_ptr->height; ypos++)
  278.     {
  279.       int xpos;
  280.       
  281.       for (xpos = 0; xpos < len; ++xpos)
  282. {
  283.   int cr, cg, cb, cgr, a;
  284.   
  285.   if (color_type == PNG_COLOR_TYPE_GRAY) {
  286.     cr=cg=cb=cgr=(*pp++);
  287.   } else if (color_type == PNG_COLOR_TYPE_RGB) {
  288.     cr= (*pp++);
  289.     cg= (*pp++);
  290.     cb= (*pp++);
  291.     cgr = (0.59*cr) + (0.20*cg) + (0.11*cb);
  292.   } else {
  293.     png_error(png_ptr, "Unknown PNG color type seen (ReadPNGImage_24)");
  294.   }
  295.   
  296.   /* Process alpha channel if present */
  297.   if (alpha)
  298.     a=(*pp++);
  299.   
  300.    /* Assume COLOR888 */
  301.   if (alpha && a != 0xff)
  302.     {
  303.       int tr,tg,tb;
  304.     
  305.       /* Get tile colour without gamma - from www.c */
  306.       if (tileData)
  307. {
  308.   int x = xpos % tileWidth;
  309.   int y = ypos % tileHeight;
  310.   int i = y * tileWidth + x;
  311.   unsigned char *s = tileData + 4 * i;
  312.   tr=s[(RPixelShift) ? 1 : 3];
  313.   tg=s[2];
  314.   tb=s[(RPixelShift) ? 3 : 1];
  315. }
  316.       else
  317. {
  318.   tr = (transparent  >> 16) & 0xFF;
  319.   tg = (transparent  >> 8) & 0xFF;
  320.   tb = transparent & 0xFF;
  321. }
  322.       
  323.       /* Add picture pixel to background pixel */
  324.       cr=(a/255.0)*cr + ((255.0-a)/255.0) * tr;
  325.       cg=(a/255.0)*cg + ((255.0-a)/255.0) * tg;
  326.       cb=(a/255.0)*cb + ((255.0-a)/255.0) * tb;
  327.     }
  329.   GetColor(cr, cg, cb, &ulp);
  330.   *dp++ = '';
  331.   *dp++ = (ulp >> 16) & 0xff; 
  332.   *dp++ = (ulp >> 8) & 0xff; 
  333.   *dp++ = ulp & 0xff; 
  334.   
  335. } /* xpos */
  336.       
  337.     } /* ypos */      
  338.   
  339.   return data;
  340. }
  342. /* Read image into displays 16 bit deep */
  343. unsigned char *ReadPNGImage_16(png_struct *png_ptr, png_info *info_ptr, png_byte *png_image) 
  344. {
  345.   png_byte *pp;
  346.   unsigned char *data, *dp;
  347.   unsigned long int ulp;
  348.   int ypos;
  349.   int len=info_ptr->width;
  350.   int color_type=info_ptr->color_type;
  351.   int alpha;
  352.   
  353.   data = (unsigned char *)malloc(2 * len * info_ptr->height);
  354.   if (data == NULL)
  355.     png_error (png_ptr, "couldn't alloc space for X image data");
  356.   
  357.   /* Remove alpha channel from type,  but remember it */
  358.   alpha=color_type & PNG_COLOR_MASK_ALPHA;
  359.   color_type &= ~PNG_COLOR_MASK_ALPHA;
  360.   
  361.   pp=png_image;
  362.   dp=data;
  363.   for (ypos = 0; ypos < png_ptr->height; ypos++)
  364.     {
  365.       int xpos;
  366.       
  367.       for (xpos = 0; xpos < len; ++xpos)
  368. {
  369.   int cr=0, cg=0, cb=0, cgr, a;
  370.   
  371.   if (color_type == PNG_COLOR_TYPE_GRAY) {
  372.     cr=cg=cb=cgr=(*pp++);
  373.   } else if (color_type == PNG_COLOR_TYPE_RGB) {
  374.     cr= (*pp++);
  375.     cg= (*pp++);
  376.     cb= (*pp++);
  377.     cgr = (0.59*cr) + (0.20*cg) + (0.11*cb);
  378.   } else {
  379.     png_error(png_ptr, "Unknown PNG color type seen (ReadPNGImage_16)");
  380.   }
  381.   
  382.   /* Process alpha channel if present */
  383.   if (alpha)
  384.     a=(*pp++);
  385.   
  386.   if (alpha && a != 0xff)
  387.     {
  388.       int tr,tg,tb;
  389.     
  390.       /* Get tile colour without gamma - from www.c */
  391.       if (tileData)
  392.       {
  393.   int x = xpos % tileWidth;
  394.   int y = ypos % tileHeight;
  395.   int i = y * tileWidth + x;
  396.   unsigned char *s = (tileData + 2 * i);
  397.   unsigned short val;
  398.   val = *s * 256  + *(s+1);
  399.   tr= (((val & visual->red_mask) >> RPixelShift) << 8) / (RPixelMask+1);
  400.   tg= (((val & visual->green_mask) >> GPixelShift) << 8) /  (GPixelMask+1);
  401.   tb= (((val & visual->blue_mask) >> BPixelShift) << 8 ) / (BPixelMask+1);
  402.       }
  403.       else
  404.       {
  405.     tr = (((transparent & visual->red_mask) >> RPixelShift) << 8) / (RPixelMask+1);
  406.     tg = (((transparent & visual->green_mask) >> GPixelShift) << 8) /  (GPixelMask+1);
  407.   tb = (((transparent & visual->blue_mask)  >> BPixelShift) << 8 ) / (BPixelMask+1);
  408.       }
  409.       
  410.       /* Add picture pixel to background pixel */
  411.       cr=(a/255.0)*cr + ((255.0-a)/255.0) * tr;
  412.       cg=(a/255.0)*cg + ((255.0-a)/255.0) * tg;
  413.       cb=(a/255.0)*cb + ((255.0-a)/255.0) * tb;
  414.     }
  415.   
  416.   GetColor(cr, cg, cb, &ulp);
  417.   *dp++ = (unsigned char)((ulp >> 8) & 0xff);
  418.   *dp++ = (unsigned char)((ulp) & 0xff);
  419.   
  420. } /* xpos */
  421.       
  422.     } /* ypos */      
  423.   
  424.   return data;
  425. }
  427. /* Read image into displays, not 1,2,4,16 or 24 bit deep */
  428. unsigned char *ReadPNGImage(png_struct *png_ptr, png_info *info_ptr, png_byte *png_image) 
  429. {
  430.   png_byte *pp;
  431.   unsigned char *data, *dp;
  432.   int ypos;
  433.   int len=info_ptr->width;
  434.   int color_type=info_ptr->color_type;
  435.   int alpha;
  436.   
  437.   data = (unsigned char *)malloc(len * info_ptr->height);
  438.   if (data == NULL)
  439.     png_error (png_ptr, "couldn't alloc space for X image data");
  440.   
  441.   /* Remove alpha channel from type,  but remember it */
  442.   alpha=color_type & PNG_COLOR_MASK_ALPHA;
  443.   color_type &= ~PNG_COLOR_MASK_ALPHA;
  444.   
  445.   pp=png_image;
  446.   dp=data;
  447.   for (ypos = 0; ypos < png_ptr->height; ypos++)
  448.     {
  449.       int col = ypos & 0x0f;
  450.       int xpos;
  451.       
  452.       for (xpos = 0; xpos < len; ++xpos)
  453. {
  454.   int row = xpos & 0x0f;
  455.   int cr=0, cg=0, cb=0, cgr, a;
  456.   int gr;
  457.   int isgrey = 0;
  458.   
  459.   if (color_type == PNG_COLOR_TYPE_GRAY) {
  460.     cr=cg=cb=cgr=(*pp++);
  461.     isgrey=1;
  462.   } else if (color_type == PNG_COLOR_TYPE_RGB) {
  463.     int drb, dgb, dbr;
  464.     
  465.     cr= (*pp++);
  466.     cg= (*pp++);
  467.     cb= (*pp++);
  468.     cgr = (0.59*cr) + (0.20*cg) + (0.11*cb);
  470.     drb = abs(cr - cb);
  471.     dgb = abs(cg - cb);
  472.     dbr = abs(cb - cr);
  473.     if (drb < 20 && dgb < 20 && dbr < 20)
  474.       isgrey=1;
  475.   } else {
  476.     png_error(png_ptr, "Unknown PNG color type seen (ReadPNGImage)");
  477.   }
  478.   
  479.   
  480.   /* Process alpha channel if present */
  481.   if (alpha) {
  482.     a=(*pp++);
  483.   
  484.     if(!a) {
  485.       dp=Transparent(dp, xpos, ypos);
  486.       continue;
  487.     } else if(a != 0xff) {
  488.       int tcolor, tr,tg,tb;
  489.       int drb, dgb, dbr;
  490.       
  491.       /* Get tile colour without gamma - from www.c */
  492.       if (tileData)
  493. {
  494.   unsigned int x = xpos % tileWidth;
  495.   unsigned int y = ypos % tileHeight;
  496.   unsigned int i = y * tileWidth + x;
  497.   tcolor=tileData[i];
  498. }
  499.       else
  500. tcolor=transparent;
  501.       
  502.       tr=papercols[tcolor].red;
  503.       tg=papercols[tcolor].green;
  504.       tb=papercols[tcolor].blue;
  506.       /* Add picture pixel to background pixel */
  507.       cr=(a/255.0)*cr + ((255.0-a)/255.0) * tr;
  508.       cg=(a/255.0)*cg + ((255.0-a)/255.0) * tg;
  509.       cb=(a/255.0)*cb + ((255.0-a)/255.0) * tb;
  510.       
  511.       /* Recalculate grayness */
  512.       cgr = (0.59*cr) + (0.20*cg) + (0.11*cb);
  513.       isgrey=0;
  514.       drb = abs(cr - cb);
  515.       dgb = abs(cg - cb);
  516.       dbr = abs(cb - cr);
  517.       if (drb < 20 && dgb < 20 && dbr < 20)
  518. isgrey=1;
  519.     }
  520.   }
  521.   
  522.   if (imaging == COLOR232)
  523.     {
  524.       if (isgrey) {
  525.                 int gr = cgr & 0xF0;
  527.                 if (cgr - gr > Magic16[(row << 4) + col])
  528.                     gr += 16;
  530.                 gr = min(gr, 0xF0);
  531.                 
  532. *dp++ = greymap[gr >> 4];
  533.       } else {
  534.       int r = cr & 0xC0;
  535.       int g = cg & 0xE0;
  536.       int b = cb & 0xC0;
  537.       int v = (row << 4) + col;
  539.       if (cr - r > Magic64[v])
  540. r += 64;
  542.       if (cg - g > Magic32[v])
  543. g += 32;
  545.       if (cb - b > Magic64[v])
  546. b += 64;
  548.       /* clamp error to keep color in range 0 to 255 */
  550.       r = min(r, 255) & 0xC0;
  551.       g = min(g, 255) & 0xE0;
  552.       b = min(b, 255) & 0xC0;
  553.     
  554.       *dp++ = stdcmap[(r >> 6) | (g >> 3) | (b >> 1)];
  555.       }
  556.     }
  557.   else if (imaging == MONO)
  558.     {
  559.       if (cgr < Magic256[(row << 4) + col])
  560. *dp++ = greymap[0];
  561.       else
  562. *dp++ = greymap[15];
  563.     }
  564.   else /* Not COLOR232 or MONO */
  565.     {
  566.       gr = cgr & 0xF0;
  567.       if (cgr - gr > Magic16[(row << 4) + col])
  568. gr += 16;
  569.       
  570.       gr = min(gr, 0xF0);
  571.       *dp++ = greymap[gr >> 4];
  572.     }
  574. } /* xpos */
  575.       
  576.     } /* ypos */      
  577.   
  578.   return data;
  579. }
  582. static char *png_color_type[] = {"grayscale", "undefined type", "RGB",
  583.  "colormap", "grayscale+alpha",
  584.  "undefined type", "RGB+alpha"};
  586. unsigned char *LoadPNGImage(Image *image, Block *bp, unsigned int depth) {
  587.   png_struct *png_ptr; 
  588.   png_info *info_ptr;
  589.   png_byte *row_pointer;
  590.   png_byte *png_image=NULL;
  591.   int number_passes, pass, row, bit_depth, image_width;
  592.   unsigned char *ximage=NULL;
  593.   int color_type, orig_color_type;
  594.   double image_gamma;
  595.   
  596.   png_ptr = malloc(sizeof (png_struct));
  597.   if (!png_ptr)
  598.     return 0;
  599.   info_ptr = malloc(sizeof (png_info));
  600.   if (!info_ptr) {
  601.     free(png_ptr);
  602.     return 0;
  603.   }
  604.    
  605.   if (setjmp(png_ptr->jmpbuf)) {
  606.     png_read_destroy(png_ptr, info_ptr, (png_info *)0);
  607.     free(png_ptr);
  608.     free(info_ptr);
  609.     if (ximage)
  610.       free(ximage);
  611.     if (png_image)
  612.       free(png_image);
  613.     return 0;
  614.   }
  615.   
  616.   png_read_init(png_ptr);
  617.   png_info_init(info_ptr);
  618.   /* No need to init PNG I/O - only ever do a read */
  619.   png_set_read_fn(png_ptr, bp, &arena_png_read_data);
  620.   png_read_info(png_ptr, info_ptr);
  621.   bit_depth=info_ptr->bit_depth;
  622.   orig_color_type = color_type = info_ptr->color_type;
  624.   if (IMAGE_TRACE)
  625.     fprintf(stderr, "PNG Image: %ld x %ld, %d-bit%s, %s, %sinterlacedn",
  626.     info_ptr->width, info_ptr->height,
  627.     bit_depth, bit_depth>1 ? "s" : "",
  628.     (color_type>6) ? png_color_type[1] : png_color_type[color_type],
  629.     info_ptr->interlace_type ? "" : "non-");
  630.   
  632.   /* expand to RGB or 8 bit grayscale (with alpha if present) */
  633.   png_set_expand(png_ptr);
  634.   
  635.   /* tell libpng to handle the gamma conversion */
  636.   if (info_ptr->valid & PNG_INFO_gAMA)
  637.     image_gamma=info_ptr->gamma;
  638.   else
  639.     image_gamma=(double)0.45; /* FIXME: OR: 1/Gamma ? */
  640.   
  641.   /* Only gamma correct if >1.1% difference */
  642.   if (abs((Gamma * image_gamma) -1) > 0.011)
  643.     png_set_gamma(png_ptr, Gamma, image_gamma);
  644.   
  645.   if (info_ptr->valid & PNG_INFO_bKGD)
  646.     png_set_background(png_ptr, &(png_ptr->background),
  647.        PNG_BACKGROUND_GAMMA_FILE, 1, image_gamma);
  649.   /* tell libpng to convert 16 bits per channel to 8 */
  650.   if (info_ptr->bit_depth == 16)
  651.       png_set_strip_16(png_ptr); 
  652.   
  653.   /* read all the image into the rows allocated above */
  654.   /* (Automatically handles interlacing) */
  655.   number_passes = png_set_interlace_handling(png_ptr);
  656.   
  657.   /* Optional call to update the info_ptr area with the new settings */
  658.   png_read_update_info(png_ptr, info_ptr);
  659.   bit_depth=info_ptr->bit_depth;
  660.   color_type=info_ptr->color_type;
  661.   image_width= info_ptr->width * info_ptr->channels;
  663.   png_image = malloc (info_ptr->height * image_width);
  664.   if (png_image == NULL)
  665.     png_error (png_ptr, "couldn't alloc space for PNG image");
  668.   /* optional call to update palette with transformations, except
  669.      it doesn't do any! */
  670.   png_start_read_image(png_ptr);
  671.   
  672.   for (pass = 0; pass < number_passes; pass++)
  673.     {
  674. /*      if ((depth == 24)||(depth == 16))
  675. row_pointer=(png_byte*)ximage;
  676. else    --patch dsr 24-bits display 8-Dec-95 */
  677. row_pointer=png_image;
  679. for (row = 0; row < info_ptr->height; row++)
  680. {
  681.     png_read_row(png_ptr, NULL, row_pointer);
  682.     row_pointer += image_width;
  683. }
  684.     }
  685.   
  686.   /* Now convert PNG image to X one */
  687.   if (depth == 1 || depth == 2 || depth == 4)
  688.       ximage = ReadPNGImage_1_2_4(png_ptr, info_ptr, png_image);
  689.   else if (depth == 24)
  690.       ximage = ReadPNGImage_24(png_ptr, info_ptr, png_image);
  691.   else if (depth == 16) 
  692.       ximage = ReadPNGImage_16(png_ptr, info_ptr, png_image);
  693.   else
  694.       ximage = ReadPNGImage(png_ptr, info_ptr, png_image);
  695.   
  696.   image->npixels = 0; /* Set to 0 in gif.c, icon.c, image.c  */
  697.   image->width = info_ptr->width;
  698.   image->height = info_ptr->height;
  700.   /* Finish */
  701.   png_read_end(png_ptr, info_ptr);
  702.   png_read_destroy(png_ptr, info_ptr, (png_info *)0);
  704.   free(png_ptr);   /* howcome 23/10/95: applied patch from Dave Beckett */
  705.   free(info_ptr);  /* howcome 23/10/95: applied patch from Dave Beckett */
  707.   free(png_image);
  709.   
  710.   return(ximage);
  711. }
  712. #endif /* PNG */