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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 图片显示 > 查看源码
gif2png.c
资源名称：gif2png-2.3.2.tar.gz　[点击查看]
上传用户：sorock1981
上传日期：2007-01-06
资源大小：73k
文件大小：22k
源码类别：

图片显示

开发平台：

Unix_Linux

gif2png.c：源码内容
  1. /*
  2.  * gif2png.c
  3.  * Copyright (C) 1995 Alexander Lehmann
  4.  * Bug fixes and enhancements by Greg Roelofs, 5 September 1999.
  5.  * Production release packaging by Eric S. Raymond <esr@thyrsus.com>.
  6.  * For conditions of distribution and use, see the file COPYING.
  7.  */
  9. #include <stdio.h>
  10. #include <string.h>
  11. #include <stdlib.h>
  12. #include <unistd.h> /* for isatty() */
  14. #define FALSE 0
  15. #define TRUE 1
  17. #define PNG_INTERNAL
  18. #include "gif2png.h"
  20. struct GIFelement first={NULL};
  21. struct GIFelement *current;
  22. int delete = FALSE;
  23. int optimize = FALSE;
  24. int histogram = FALSE;
  25. int interlaced = PNG_INTERLACE_LAST;
  26. int progress = FALSE;
  27. int verbose = FALSE;
  28. int recover = FALSE;
  29. int webconvert = FALSE;
  30. int software_chunk = TRUE;
  31. int filtermode = FALSE;
  32. int matte = FALSE;
  33. int gamma_srgb = FALSE;
  34. GifColor matte_color;
  35. long numgifs = 0L;
  36. long numpngs = 0L;
  39. int interlace_line(int height, int line)
  40. /* return the actual line # used to store an interlaced line */
  41. {
  42.     int res;
  44.     if ((line & 7) == 0) {
  45. return line >> 3;
  46.     }
  47.     res = (height+7) >> 3;
  48.     if ((line & 7) == 4) {
  49. return res+((line-4) >> 3);
  50.     }
  51.     res += (height+3) >> 3;
  52.     if ((line & 3) == 2) {
  53. return res + ((line-2) >> 2);
  54.     }
  55.     return res + ((height+1) >> 2) + ((line-1) >> 1);
  56. }
  58. int inv_interlace_line(int height, int line)
  59. /* inverse function of above, used for recovery of interlaced images */
  60. {
  61.     if ((line << 3)<height) {
  62. return line << 3;
  63.     }
  64.     line -= (height+7) >> 3;
  65.     if ((line << 3) + 4 < height) {
  66. return (line << 3) + 4;
  67.     }
  68.     line -= (height+3) >> 3;
  69.     if ((line << 2) + 2 < height) {
  70. return (line << 2) + 2;
  71.     }
  72.     line -= (height + 1) >> 2;
  73.     return (line << 1) + 1;
  74. }
  76. /* 
  77.  * Do some adjustments of the color palette.
  78.  *
  79.  * We won't check for duplicate colors, this is probably only a very
  80.  * rare case, but we check if all used colors are grays.  Some GIF
  81.  * writers (e.g. some versions of ppmtogif) leave the unused entries
  82.  * uninitialized, which breaks the detection of grayscale images
  83.  * (e.g. in QPV).
  84.  *
  85.  * If the image is grayscale we will use PNG color type 0, except when
  86.  * the transparency color is also appearing as a visible color. In
  87.  * this case we write a paletted image.  Another solution would be
  88.  * gray+alpha, but that would probably increase the image size too
  89.  * much.
  90.  *
  91.  * If there are only few gray levels (<=16), we try to create a 4-bit
  92.  * or less grayscale file, but if the gray levels do not fit into the
  93.  * necessary grid, we write a paletted image--e.g., if the image
  94.  * contains black, white and 50% gray, the grayscale image would
  95.  * require 8-bit, but the paletted image only 2-bit. Even with
  96.  * filtering, the 8-bit file will be larger.
  97.  */
  99. int is_gray(png_color c)
  100. {
  101.     /* check if r==g==b, moved to function to work around NeXTstep 3.3 cc bug.
  102.      * life could be so easy if at least the basic tools worked as expected.
  103.      */
  104.     return c.red == c.green && c.green == c.blue;
  105. }
  107. int writefile(struct GIFelement *s,struct GIFelement *e, FILE *fp, int lastimg)
  108. {
  109.     int i;
  110.     struct GIFimagestruct *img = e->imagestruct;
  111.     unsigned long *count = img->color_count;
  112.     GifColor *colors = img->colors;
  113.     int colors_used = 0;
  114.     byte remap[MAXCMSIZE];
  115.     int low_prec;
  116.     png_struct *png_ptr = xalloc(sizeof (png_struct));
  117.     png_info *info_ptr = xalloc(sizeof (png_info));
  118.     int p;
  119.     int gray_bitdepth;
  120.     png_color pal_rgb[MAXCMSIZE], *pltep;
  121.     png_byte pal_trans[MAXCMSIZE];
  122.     png_color_16 color16trans, color16back;
  123.     byte buffer[24]; /* used for gIFt and gIFg */
  124.     byte *data;
  125.     int j;
  126.     png_uint_16 histogr[MAXCMSIZE];
  127.     unsigned long hist_maxvalue;
  128.     int passcount;
  129.     int errorcount = 0;
  130.     png_text software;
  132.     /* these volatile declarations prevent gcc warnings ("variable might be
  133.      *  clobbered by `longjmp' or `vfork'") */
  134.     volatile int gray = TRUE;
  135.     volatile int last_color = 0;
  136.     volatile int remapping = FALSE;
  137.     volatile int bitdepth;
  139.     /* ignore the transparency value if no pixel in the image uses it */
  140.     if (img->trans != -1 && !count[img->trans])
  141. img->trans = -1;
  143.     if (optimize) {
  144. /* zero out unused color table entries and use zlib level 9 */
  145. for (i = 0; i < MAXCMSIZE; i++)
  146.     if(!count[i])
  147. colors[i].red = colors[i].green = colors[i].blue = 0;
  148. /*
  149.  * The way that last_color is computed ensures that trailing zeroed-out
  150.  * entries will be dropped.
  151.  * FIXME: someday, actually compact unused colors out of the table
  152.  * and remap pixels appropriately.
  153.  */
  154.     } else if (!recover) {
  155. /* report unused colors so user can choose to reconvert */
  156. int unused = 0;
  158. for (i = 0; i < MAXCMSIZE; i++)
  159.     if (!count[i])
  160. unused++;
  162. if (unused)
  163. {
  164.     fprintf(stderr, 
  165.     "gif2png: %d unused colors; convert with -O to removen",
  166.     unused);
  167.     errorcount++;
  168. }
  169.     }
  171.     for (i = 0; i < MAXCMSIZE; i++)
  172. if (count[i]) {
  173.     gray &= is_gray(colors[i]);
  174.     colors_used++;
  175.     if (last_color < i) 
  176. last_color = i;
  177. }
  179.     if (gray) {
  180. if (verbose > 1)
  181.     fprintf(stderr, "gif2png: input image is grayscalen");
  183. if (img->trans != -1) {
  184.     for (i = 0; i < MAXCMSIZE; i++) {
  185. if (i!=img->trans && colors[i].red == colors[img->trans].red) {
  186.     gray = FALSE;
  187.     if (verbose > 1)
  188. fprintf(stderr,
  189. "gif2png: transparent color is repeated in visible colors, using paletten");
  190.     break;
  191. }
  192.     }
  193. }
  194.     }
  196.     bitdepth = 8;
  197.     if (last_color<16) bitdepth = 4;
  198.     if (last_color<4) bitdepth = 2;
  199.     if (last_color<2) bitdepth = 1;
  201.     if (gray) {
  202. remapping = TRUE;
  203. for (i = 0; i < MAXCMSIZE; i++)
  204.     remap[i] = colors[i].red;
  206. gray_bitdepth = 8;
  208. /* try to adjust to 4-bit precision grayscale */
  210. low_prec = TRUE;
  211. for (i = 0; i < MAXCMSIZE; i++) {
  212.     if ((remap[i]&0xf)*0x11 != remap[i]) {
  213. low_prec = FALSE;
  214. break;
  215.     }
  216. }
  217. if (low_prec) {
  218.     for (i = 0; i < MAXCMSIZE; i++) {
  219. remap[i] &= 0xf;
  220.     }
  221.     gray_bitdepth = 4;
  222. }
  224. /* try to adjust to 2-bit precision grayscale */
  226. if (low_prec) {
  227.     for (i = 0; i < MAXCMSIZE; i++) {
  228. if ((remap[i]&3)*5 != remap[i]) {
  229.     low_prec = FALSE;
  230.     break;
  231. }
  232.     }
  233. }
  235. if (low_prec) {
  236.     for (i = 0; i < MAXCMSIZE; i++) {
  237. remap[i] &= 3;
  238.     }
  239.     gray_bitdepth = 2;
  240. }
  242. /* try to adjust to 1-bit precision grayscale */
  244. if (low_prec) {
  245.     for (i = 0; i < MAXCMSIZE; i++) {
  246. if ((remap[i]&1)*3 != remap[i]) {
  247.     low_prec = FALSE;
  248.     break;
  249. }
  250.     }
  251. }
  252. if (low_prec) {
  253.     for (i = 0; i < MAXCMSIZE; i++) {
  254. remap[i] &= 1;
  255.     }
  256.     gray_bitdepth=1;
  257. }
  259. if (bitdepth<gray_bitdepth) {
  260.     gray = FALSE; /* write palette file */
  261.     remapping = FALSE;
  262. } else {
  263.     bitdepth = gray_bitdepth;
  264. }
  265.     }
  267.     if (verbose > 1)
  268. fprintf(stderr, "gif2png: %d colors used, highest color %d, %s, bitdepth %dn",
  269. colors_used, last_color, gray ? "gray":"palette", bitdepth);
  271.     if (verbose > 2)
  272. for (i = 0; i <= last_color; i++) {
  273.     fprintf(stderr, "(%3d, %3d, %3d)n", 
  274.     colors[i].red, colors[i].blue, colors[i].green);  
  275. }
  277.     if (setjmp(png_ptr->jmpbuf)) {
  278. fprintf(stderr, "gif2png:  libpng returns fatal error conditionn");
  279. free(png_ptr);
  280. free(info_ptr);
  281. return 1;
  282.     }
  284.     /* initialize PNG writing */
  285.     png_write_init(png_ptr);
  286.     png_info_init(info_ptr);
  287.     png_init_io(png_ptr, fp);
  288.     if(optimize)
  289.        png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);
  291.     if (gamma_srgb)
  292.     {
  293.           png_set_gAMA(png_ptr, info_ptr, 1./2.2);
  294. #if (PNG_LIBPNG_VER > 96)
  295.   png_set_sRGB(png_ptr, info_ptr, PNG_sRGB_INTENT_PERCEPTUAL);
  296. #endif
  297.     }
  299.     /* set basic image properties: width/height, type, bit depth, interlace */
  300.     if (interlaced == PNG_INTERLACE_LAST)
  301. interlaced = current->imagestruct->interlace ? PNG_INTERLACE_ADAM7 : PNG_INTERLACE_NONE;
  303.     png_set_IHDR(png_ptr, info_ptr, 
  304.  current->imagestruct->width, current->imagestruct->height,
  305.  bitdepth, 
  306.  gray ? PNG_COLOR_TYPE_GRAY : PNG_COLOR_TYPE_PALETTE,
  307.  interlaced, 
  308.  PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
  310.     /* if the GIF specified an aspect ratio, turn it into a pHYs chunk */
  311.     if (GifScreen.AspectRatio != 0 && GifScreen.AspectRatio != 49)
  312. png_set_pHYs(png_ptr, info_ptr, 
  313.      GifScreen.AspectRatio+15, 64, PNG_RESOLUTION_UNKNOWN);
  315.     /* if the GIF specified an image offset, turn it into a oFFs chunk */
  316.     if (img->offset_x>0 && img->offset_y>0)
  317. png_set_oFFs(png_ptr, info_ptr, 
  318.      img->offset_x, img->offset_y, PNG_OFFSET_PIXEL);
  320.     if (GifScreen.Background > 0) { /* no background for palette entry 0 */
  321. /* if the background color doesn't appear in local palette, we just
  322.    leave it out, if the pic is part of an animation, at least some will
  323.    use the global palette */
  325. if (gray) {
  326.     if (is_gray(GifScreen.ColorMap[GifScreen.Background])) {
  327. color16back.gray = remap[GifScreen.Background];
  328. png_set_bKGD(png_ptr, info_ptr, &color16back);
  329.     }
  330. } else {
  331.     for (i = 0; i < MAXCMSIZE; i++) {
  332. if (GifScreen.ColorMap[GifScreen.Background].red == colors[i].red &&
  333.     GifScreen.ColorMap[GifScreen.Background].green == colors[i].green &&
  334.     GifScreen.ColorMap[GifScreen.Background].blue == colors[i].blue) {
  335.     if (last_color < i) 
  336. last_color = i;
  337.     color16back.index = i;
  338.     info_ptr->background = color16back;
  339.     info_ptr->valid |= PNG_INFO_bKGD;
  340.     break;
  341. }
  342.     }
  343. }
  344.     }
  346.     /* transparency handling */
  347.     if (img->trans != -1) {
  348. if (gray) {
  349.     if (verbose > 2)
  350. fprintf(stderr, "gif2png: handling grayscale transparencyn");
  351.     color16trans.gray = remap[img->trans];
  352.     png_set_tRNS(png_ptr, info_ptr, NULL, 0, &color16trans);
  353. } else {
  354.     if (verbose > 2)
  355. fprintf(stderr, "gif2png: handling palette transparencyn");
  356. #if 0
  357.     for (i = 0; i < MAXCMSIZE; i++)
  358. pal_trans[i] = 255;
  359.     pal_trans[img->trans] = 0;
  360.     png_set_tRNS(png_ptr, info_ptr, pal_trans, img->trans+1, NULL);
  361. #else
  362.     /* GRR NOTE:  may be inconsistent with background-color logic (above) */
  363.     remapping = TRUE;
  364.     for (i = 0; i < MAXCMSIZE; i++)
  365. remap[i] = i;
  366.     remap[0] = img->trans;
  367.     remap[img->trans] = 0;
  368.     pal_trans[0] = 0;
  369.     png_set_tRNS(png_ptr, info_ptr, pal_trans, 1, NULL);
  370. #endif
  371. }
  372.     }
  374.     /* generate the PNG palette */
  375.     if (!gray) {
  376. if (remapping) {
  377.     if (verbose > 2)
  378. fprintf(stderr, "Remapping palette...n");
  379.     for (i = 0; i <= last_color; i++) {
  380. pal_rgb[i].red   = current->imagestruct->colors[remap[i]].red;
  381. pal_rgb[i].green = current->imagestruct->colors[remap[i]].green;
  382. pal_rgb[i].blue  = current->imagestruct->colors[remap[i]].blue;
  383.     }
  384.     pltep = pal_rgb;
  385. } else {
  386.     if (verbose > 2)
  387. fprintf(stderr, "Palette copied from GIF colors...n");
  388.     pltep = current->imagestruct->colors;
  389. }
  390. png_set_PLTE(png_ptr, info_ptr, pltep, last_color+1);
  392. if (verbose > 2) {
  393.     fprintf(stderr,"PNG palette generated with %d colors:n",last_color+1);
  394.     for (i = 0; i <= last_color; i++) {
  395. fprintf(stderr, "(%3d, %3d, %3d)n", 
  396. pltep[i].red, pltep[i].blue, pltep[i].green);  
  397.     }
  398. }
  399.     }
  401.     /* generate histogram chunk for paletted images only */
  402.     if (histogram && !gray) {
  403. hist_maxvalue = 0;
  404. for (i = 0; i < MAXCMSIZE; i++)
  405.     if (count[i]>hist_maxvalue)
  406. hist_maxvalue = count[i];
  407. if (hist_maxvalue <= 65535) {
  408.     /* no scaling necessary */
  409.     for (i = 0; i < MAXCMSIZE; i++)
  410. histogr[i] = (png_uint_16)count[i];
  411. } else {
  412.     for (i = 0; i < MAXCMSIZE; i++)
  413. if (count[i]) {
  414.     histogr[i] = (png_uint_16)
  415. #ifdef __GO32__
  416. /* avoid using fpu instructions on djgpp, so we don't need emu387 */
  417. (((long long)count[i]*65535)/hist_maxvalue);
  418. #else
  419.     ((double)count[i]*65535.0/hist_maxvalue);
  420. #endif
  421.     if (histogr[i] == 0)
  422. histogr[i] = 1;
  423. } else {
  424.     histogr[i] = 0;
  425. }
  426. }
  427. png_set_hIST(png_ptr, info_ptr, histogr);
  428.     }
  430.     /* transcribe software chunk if necessary */
  431.     if (software_chunk) {
  432. software.compression = PNG_TEXT_COMPRESSION_NONE;
  433. software.key = "Software";
  434. software.text = (char*)version;
  435. software.text_length = strlen(software.text);
  437. png_set_text(png_ptr, info_ptr, &software, 1);
  438.     }
  440.     png_write_info(png_ptr, info_ptr);
  442.     if (info_ptr->bit_depth<8)
  443. png_set_packing(png_ptr);
  445.     /* loop over elements until we reach the image or the last element if
  446.        this is the last image in a GIF */
  448.     while(lastimg ? s != NULL : s != e->next) {
  449. switch((byte)s->GIFtype) {
  450. case GIFimage:
  451.     passcount = png_set_interlace_handling(png_ptr);
  452.     for (p = 0; p<passcount;p++)
  453. for (i = 0; i<current->imagestruct->height; i++) {
  454.     if (progress) {
  455. if (passcount>1)
  456.     fprintf(stderr, "%d/%d ", p+1, passcount);
  457. fprintf(stderr, "%2d%%r",
  458. (int)(((long)i*100)/current->imagestruct->height));
  459. fflush(stderr);
  460.     }
  461.     data = access_data(current, (long) (img->interlace ?
  462. interlace_line(current->imagestruct->height,i) : i) *
  463.        current->imagestruct->width,
  464.        current->imagestruct->width);
  465. #ifndef TMPFILE
  466.     /* if we store the image in memory, we have to remap once */
  467.     if (remapping && p == 0)
  468. #else
  469. /* if we store the image in a file, we have to remap each time */
  470. if (remapping)
  471. #endif
  472. {
  473.     for (j = 0; j < img->width; j++) {
  474. data[j] = remap[data[j]];
  475.     }
  476. }
  477.     png_write_row(png_ptr, data);
  478. }
  479.     break;
  481. case GIFcomment:
  482.     data = access_data(s, 0, s->size);
  483.     j = s->size;
  484.     if (data[j-1] == '')  /* some apps include a NULL in GIF comment */
  485. --j;
  486.     if (j<500) {
  487. png_write_tEXt(png_ptr, "Comment", (png_charp)data, j);
  488.     } else {
  489. png_write_zTXt(png_ptr, "Comment", (png_charp)data, j, 0);
  490.     }
  491.     break;
  493. case GIFapplication:
  494.     data = access_data(s, 0, s->size);
  495.     png_write_chunk_start(png_ptr, "gIFx", s->size);
  496.     png_write_chunk_data(png_ptr, data, s->size);
  497.     png_write_chunk_end(png_ptr);
  498.     break;
  500. /* Plain Text Extensions are not supported because they represent a separate
  501.    subimage, and PNG is explicitly a single-image format.  PNG's gIFt chunk
  502.    has been officially deprecated.
  503. */
  504. #if 0
  505. case GIFplaintext:
  506.     data = access_data(s, 0, s->size);
  507.     /* gIFt is 12 bytes longer than GCE, due to 32-bit ints and
  508.        rgb colors */
  509.     png_write_chunk_start(png_ptr, "gIFt", s->size+12);
  510.     memset(buffer, 0, 24);
  511.     buffer[2] = data[1];
  512.     buffer[3] = data[0];
  513.     buffer[6] = data[3];
  514.     buffer[7] = data[2];
  515.     buffer[10] = data[5];
  516.     buffer[11] = data[4];
  517.     buffer[14] = data[7];
  518.     buffer[15] = data[6];
  519.     buffer[16] = data[8];
  520.     buffer[17] = data[9];
  521.     buffer[18] = GifScreen.ColorMap[data[10]].red;
  522.     buffer[19] = GifScreen.ColorMap[data[10]].green;
  523.     buffer[20] = GifScreen.ColorMap[data[10]].blue;
  524.     buffer[21] = GifScreen.ColorMap[data[11]].red;
  525.     buffer[22] = GifScreen.ColorMap[data[11]].green;
  526.     buffer[23] = GifScreen.ColorMap[data[11]].blue;
  527.     png_write_chunk_data(png_ptr, buffer, 24);
  528.     png_write_chunk_data(png_ptr, data+12, s->size-12);
  529.     png_write_chunk_end(png_ptr);
  530.     break;
  531. #endif
  533. case GIFgraphicctl:
  534.     data = access_data(s, 0, s->size);
  535.     buffer[0] = (data[0] >> 2) & 7;
  536.     buffer[1] = (data[0] >> 1) & 1;
  537.     buffer[2] = data[2];
  538.     buffer[3] = data[1];
  540.     png_write_chunk(png_ptr, "gIFg", buffer, 4);
  541.     break;
  543. default:
  544.     fprintf(stderr, "gif2png internal error: encountered unused element type %cn", s->GIFtype);
  545.     break;
  546. }
  547. s = s->next;
  548.     }
  549.     png_write_end(png_ptr, info_ptr);
  550.     png_write_destroy(png_ptr);
  552.     free(png_ptr);
  553.     free(info_ptr);
  555.     return errorcount;
  556. }
  558. int
  559. MatteGIF(GifColor matte)
  560. /* convert transparent pixels to a matte of given color */
  561. {
  562.     int icount = 0;
  564.     /* apply matte color to image-local transparency values */
  565.     for (current = &first; current ; current = current->next) {
  566. if (current->imagestruct) {
  567.     if (current->imagestruct->trans == -1)
  568. fprintf(stderr, 
  569. "gif2png: no transparency color in image %d, matte argument ignoredn",
  570. icount);
  571.     else if (verbose) {
  572. fprintf(stderr, 
  573. "gif2png: transparent value in image %d is %dn",  
  574. icount, current->imagestruct->trans);
  575.     }
  577.     current->imagestruct->colors[current->imagestruct->trans] = matte;
  578.     current->imagestruct->trans = -1;
  579. }
  580.     }
  581.     return icount;
  582. }
  584. int processfilter(void)
  585. {
  586.     int num_pics;
  587.     struct GIFelement *start;
  589.     current = &first;
  590.     num_pics = ReadGIF (stdin);
  591.     fclose(stdin);
  593.     if (num_pics != 1) {
  594. fprintf(stderr, "gif2png: %d images in -1 (oneonly) moden", num_pics);
  595. return 1;
  596.     }
  598.     /* eliminate use of transparency, if that is called for */
  599.     if (matte)
  600. MatteGIF(matte_color);
  602.     start = NULL;
  603.     for (current = first.next; current ; current = current->next) {
  604. if (start == NULL) start = current;
  605. if (current->GIFtype == GIFimage) {
  606.     (void)writefile(start, current, stdout, TRUE);
  607.     start = NULL;
  608.     ++numpngs;
  609. }
  610.     }
  611.     free_mem();
  612.     return 0;
  613. }
  615. int processfile(char *fname, FILE *fp)
  616. {
  617.     char outname[1025]; /* MAXPATHLEN comes under too many names */
  618.     int num_pics;
  619.     struct GIFelement *start;
  620.     int i, suppress_delete = FALSE;
  621.     char *file_ext;
  623.     if (fp == NULL) return 1;
  625. #ifdef TMPFILE
  626.     fseek(tempfile, 0, SEEK_SET);
  627. #endif
  629.     current = &first;
  631.     num_pics = ReadGIF (fp);
  633.     fclose(fp);
  635.     if (num_pics >= 0 && verbose > 1)
  636. fprintf(stderr, "gif2png: number of images %dn", num_pics);
  638.     if (num_pics <= 0)
  639. return 1;
  641.     if (webconvert)
  642. if (num_pics != 1)
  643. {
  644.     fprintf(stderr, "gif2png: %s is multi-imagen", fname);
  645.     return 0;
  646. }
  647. else if (current->imagestruct && current->imagestruct->trans != -1)
  648. {
  649.     fprintf(stderr, "gif2png: %s has a transparency colorn", fname);
  650.     return 0;
  651. }
  652. else
  653. {
  654.     printf("%sn", fname);
  655.     return 0;
  656. }
  658.     /* eliminate use of transparency, if that is called for */
  659.     if (matte)
  660. MatteGIF(matte_color);
  662.     /* create output filename */
  664.     strcpy(outname, fname);
  666.     file_ext = outname+strlen(outname)-4;
  667.     if (strcmp(file_ext, ".gif") != 0 && strcmp(file_ext, ".GIF") != 0 &&
  668. strcmp(file_ext, "_gif") != 0 && strcmp(file_ext, "_GIF") != 0) {
  669. /* try to derive basename */
  670. file_ext = outname+strlen(outname);
  671. while(file_ext >= outname) {
  672.     if (*file_ext == '.' || *file_ext == '/' || *file_ext == '\') break;
  673.     file_ext--;
  674. }
  675. if (file_ext<outname || *file_ext != '.') {
  676.     /* as a last resort, just add .png to the filename */
  677.     file_ext = outname+strlen(outname);
  678. }
  679.     }
  681.     strcpy(file_ext, ".png"); /* images are named .png, .p01, .p02, ... */
  683.     start = NULL;
  685.     i = 0;
  687.     for (current = first.next; current ; current = current->next) {
  688. if (start == NULL) start = current;
  689. if (current->GIFtype == GIFimage) {
  690.     i++;
  691.     if ((fp = fopen(outname, "wb")) == NULL) {
  692. perror(outname);
  693. return 1;
  694.     } else {
  695. suppress_delete |= writefile(start, current, fp, i == num_pics);
  696. fclose(fp);
  697. ++numpngs;
  698. start = NULL;
  699. sprintf(file_ext, ".p%02d", i);
  700.     }
  701. }
  702.     }
  704.     free_mem();
  706.     if (delete && !suppress_delete) {
  707. unlink(fname);
  708.     }
  710.     return 0;
  711. }
  713. /* check if stdin is a terminal, if your compiler is lacking isatty or fileno
  714.    (non-ANSI functions), just return 0
  715. */
  717. int input_is_terminal(void)
  718. {
  719.     return isatty(fileno(stdin));
  720. }
  722. int main(int argc, char *argv[])
  723. {
  724.     FILE *fp;
  725.     int i, background;
  726.     int errors = 0;
  727.     char name[1025];
  728.     int ac;
  729.     char *color;
  731.     software_chunk = 1;
  733.     ac = 1;
  735.     for (ac = 1; ac<argc && argv[ac][0] == '-'; ac++)
  736.     {
  737. for (i = 1;i<strlen(argv[ac]); i++)
  738.     switch(argv[ac][i]) {
  739.     case 'b':
  740. if (ac >= argc - 1)
  741. {
  742.     fputs("gif2png: missing background-matte argumentn",
  743.   stderr);
  744.     exit(1);
  745. }
  746. color = argv[++ac];
  747. if (*color == '#')
  748.     color++;
  749.         sscanf(color, "%x", &background);
  750. matte_color.red = (background >> 16) & 0xff;
  751. matte_color.green = (background >> 8) & 0xff; 
  752. matte_color.blue = background & 0xff;
  753. matte = TRUE;
  754. goto skiparg;
  756.     case 'd':
  757. delete = TRUE;
  758. break;
  760.     case 'f':
  761. filtermode = TRUE;
  762. break;
  764.     case 'g':
  765. gamma_srgb = TRUE;
  766. break;
  768.     case 'h':
  769. histogram = TRUE;
  770. break;
  772.     case 'i':
  773. interlaced = PNG_INTERLACE_ADAM7;
  774. break;
  776.     case 'n':
  777. interlaced = PNG_INTERLACE_NONE;
  778. break;
  780.     case 'p':
  781. progress = TRUE;
  782. break;
  784.     case 'r':
  785. recover = TRUE;
  786. break;
  788.     case 's':
  789. software_chunk = FALSE;
  790. break;
  792.     case 'v':
  793. ++verbose;
  794. break;
  796.     case 'w':
  797. webconvert = TRUE;
  798. break;
  800.     case 'O':
  801. optimize = TRUE;
  802. break;
  804.     default:
  805. fprintf(stderr, "gif2png: unknown option `-%c'n", argv[ac][i]);
  806.     usage:
  807. fprintf(stderr,
  808. "n"
  809. "usage: gif2png [ -bdfghinprsvwO ] [file[.gif]] ...n"
  810. "n"
  811. "   -b  replace background pels with given RRGGBB color (hex digits)n"
  812. "   -d  delete source GIF files after successful conversionn"
  813. "   -g  write gamma=(1.0/2.2) and sRGB chunksn"
  814. "   -h  generate PNG histogram chunks into color output filesn"
  815. "   -i  force conversion to interlaced PNG filesn"
  816. "   -n  force conversion to noninterlaced PNG filesn"
  817. "   -p  display progress of PNG writing in %%n"
  818. "   -r  try to recover corrupted GIF filesn"
  819. "   -s  do not write Software text chunkn"
  820. "   -v  verbose; display conversion statistics and debugging messagesn"
  821. "   -w  web probe, list images without animation or transparencyn"
  822. "   -O  optimize; remove unused color-table entries; use zlib level 9n"
  823. "   -1  one-only; allow use as filter, die on multi-image GIFn"
  824. "n"
  825. "   If no source files are listed, stdin is converted to noname.png.n"
  826. "n"
  827. "   This is %s, %sn", version, compile_info);
  828. return 1;
  829.     }
  830.     skiparg:;
  831.     }
  833.     if (verbose > 1)
  834. fprintf(stderr, "gif2png: %s, %sn", version, compile_info);
  836. #ifdef TMPFILE
  837.     if ((tempfile = tmpfile()) == NULL) {
  838. perror("tempfile");
  839. exit(1);
  840.     }
  841. #endif
  843.     /* loop over arguments or use stdin */
  844.     if (argc == ac) {
  845. if (input_is_terminal()) {
  846.     goto usage;
  847. }
  848. if (verbose > 1)
  849.     fprintf(stderr, "stdin:n");
  850. if (filtermode) {
  851.     if (processfilter() != 0) ++errors;
  852. } else {
  853.     processfile("noname.gif", stdin);
  854.     ++numgifs;
  855. }
  856.     } else {
  857. for (i = ac;i<argc; i++) {
  858.     strcpy(name, argv[i]);
  859.     if ((fp = fopen(name, "rb")) == NULL) {
  860. /* retry with .gif appended */
  861. strcat(name, ".gif");
  862. fp = fopen(name,"rb");
  863.     }
  864.     if (fp == NULL) {
  865. perror(argv[i]);
  866. errors = 1;
  867.     } else {
  868. if (verbose > 1)
  869.     fprintf(stderr, "%s:n", name);
  870. errors |= processfile(name, fp);
  871. /* fp is closed in processfile */
  872. ++numgifs;
  873.     }
  874. }
  875.     }
  877.     if (verbose)
  878. fprintf(stderr, "Done (%s).  Converted %ld GIF%s into %ld PNG%s.n",
  879. errors? "with one or more errors" : "no errors detected", 
  880. numgifs, (numgifs == 1) ? "" : "s", numpngs, (numpngs == 1)? "" : "s");
  882.     return errors;
  883. }