Set back development snapshot splash screen type
[synfig.git] / gtkmm-osx / libpng-1.2.5 / contrib / pngminus / png2pnm.c
1 /*
2  *  png2pnm.c --- conversion from PNG-file to PGM/PPM-file
3  *  copyright (C) 1999 by Willem van Schaik <willem@schaik.com>
4  *
5  *  version 1.0 - 1999.10.15 - First version.
6  *
7  *  Permission to use, copy, modify, and distribute this software and
8  *  its documentation for any purpose and without fee is hereby granted,
9  *  provided that the above copyright notice appear in all copies and
10  *  that both that copyright notice and this permission notice appear in
11  *  supporting documentation. This software is provided "as is" without
12  *  express or implied warranty.
13  */
14
15 #include <stdio.h>
16 #include <stdlib.h>
17 #ifdef __TURBOC__
18 #include <mem.h>
19 #include <fcntl.h>
20 #endif
21
22 #ifndef BOOL
23 #define BOOL unsigned char
24 #endif
25 #ifndef TRUE
26 #define TRUE (BOOL) 1
27 #endif
28 #ifndef FALSE
29 #define FALSE (BOOL) 0
30 #endif
31
32 #ifdef __TURBOC__
33 #define STDIN  0
34 #define STDOUT 1
35 #define STDERR 2
36 #endif
37
38 /* to make png2pnm verbose so we can find problems (needs to be before png.h) */
39 #ifndef PNG_DEBUG
40 #define PNG_DEBUG 0
41 #endif
42
43 #include "png.h"
44
45 /* Define png_jmpbuf() in case we are using a pre-1.0.6 version of libpng */
46 #ifndef png_jmpbuf
47 #  define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
48 #endif
49
50 /* function prototypes */
51
52 int  main (int argc, char *argv[]);
53 void usage ();
54 BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file, BOOL raw, BOOL alpha);
55
56 /*
57  *  main
58  */
59
60 int main(int argc, char *argv[])
61 {
62   FILE *fp_rd = stdin;
63   FILE *fp_wr = stdout;
64   FILE *fp_al = NULL;
65   BOOL raw = TRUE;
66   BOOL alpha = FALSE;
67   int argi;
68
69   for (argi = 1; argi < argc; argi++)
70   {
71     if (argv[argi][0] == '-')
72     {
73       switch (argv[argi][1])
74       {
75         case 'n':
76           raw = FALSE;
77           break;
78         case 'r':
79           raw = TRUE;
80           break;
81         case 'a':
82           alpha = TRUE;
83           argi++;
84           if ((fp_al = fopen (argv[argi], "wb")) == NULL)
85           {
86             fprintf (stderr, "PNM2PNG\n");
87             fprintf (stderr, "Error:  can not create alpha-channel file %s\n", argv[argi]);
88             exit (1);
89           }
90           break;
91         case 'h':
92         case '?':
93           usage();
94           exit(0);
95           break;
96         default:
97           fprintf (stderr, "PNG2PNM\n");
98           fprintf (stderr, "Error:  unknown option %s\n", argv[argi]);
99           usage();
100           exit(1);
101           break;
102       } /* end switch */
103     }
104     else if (fp_rd == stdin)
105     {
106       if ((fp_rd = fopen (argv[argi], "rb")) == NULL)
107       {
108              fprintf (stderr, "PNG2PNM\n");
109             fprintf (stderr, "Error:  file %s does not exist\n", argv[argi]);
110             exit (1);
111       }
112     }
113     else if (fp_wr == stdout)
114     {
115       if ((fp_wr = fopen (argv[argi], "wb")) == NULL)
116       {
117         fprintf (stderr, "PNG2PNM\n");
118         fprintf (stderr, "Error:  can not create file %s\n", argv[argi]);
119         exit (1);
120       }
121     }
122     else
123     {
124       fprintf (stderr, "PNG2PNM\n");
125       fprintf (stderr, "Error:  too many parameters\n");
126       usage();
127       exit(1);
128     }
129   } /* end for */
130
131 #ifdef __TURBOC__
132   /* set stdin/stdout if required to binary */
133   if (fp_rd == stdin)
134   {
135     setmode (STDIN, O_BINARY);
136   }
137   if ((raw) && (fp_wr == stdout))
138   {
139     setmode (STDOUT, O_BINARY);
140   }
141 #endif
142
143   /* call the conversion program itself */
144   if (png2pnm (fp_rd, fp_wr, fp_al, raw, alpha) == FALSE)
145   {
146     fprintf (stderr, "PNG2PNM\n");
147     fprintf (stderr, "Error:  unsuccessful convertion of PNG-image\n");
148     exit(1);
149   }
150
151   /* close input file */
152   fclose (fp_rd);
153   /* close output file */
154   fclose (fp_wr);
155   /* close alpha file */
156   if (alpha)
157     fclose (fp_al);
158
159   return 0;
160 }
161
162 /*
163  *  usage
164  */
165
166 void usage()
167 {
168   fprintf (stderr, "PNG2PNM\n");
169   fprintf (stderr, "   by Willem van Schaik, 1999\n");
170 #ifdef __TURBOC__
171   fprintf (stderr, "   for Turbo-C and Borland-C compilers\n");
172 #else
173   fprintf (stderr, "   for Linux (and Unix) compilers\n");
174 #endif
175   fprintf (stderr, "Usage:  png2pnm [options] <file>.png [<file>.pnm]\n");
176   fprintf (stderr, "   or:  ... | png2pnm [options]\n");
177   fprintf (stderr, "Options:\n");
178   fprintf (stderr, "   -r[aw]   write pnm-file in binary format (P4/P5/P6) (default)\n");
179   fprintf (stderr, "   -n[oraw] write pnm-file in ascii format (P1/P2/P3)\n");
180   fprintf (stderr, "   -a[lpha] <file>.pgm write PNG alpha channel as pgm-file\n");
181   fprintf (stderr, "   -h | -?  print this help-information\n");
182 }
183
184 /*
185  *  png2pnm
186  */
187
188 BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file, BOOL raw, BOOL alpha)
189 {
190   png_struct    *png_ptr = NULL;
191   png_info      *info_ptr = NULL;
192   png_byte      buf[8];
193   png_byte      *png_pixels = NULL;
194   png_byte      **row_pointers = NULL;
195   png_byte      *pix_ptr = NULL;
196   png_uint_32   row_bytes;
197
198   png_uint_32   width;
199   png_uint_32   height;
200   int           bit_depth;
201   int           channels;
202   int           color_type;
203   int           alpha_present;
204   int           row, col;
205   int           ret;
206   int           i;
207   long          dep_16;
208
209   /* read and check signature in PNG file */
210   ret = fread (buf, 1, 8, png_file);
211   if (ret != 8)
212     return FALSE;
213
214   ret = png_check_sig (buf, 8);
215   if (!ret)
216     return FALSE;
217
218   /* create png and info structures */
219
220   png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING,
221     NULL, NULL, NULL);
222   if (!png_ptr)
223     return FALSE;   /* out of memory */
224
225   info_ptr = png_create_info_struct (png_ptr);
226   if (!info_ptr)
227   {
228     png_destroy_read_struct (&png_ptr, NULL, NULL);
229     return FALSE;   /* out of memory */
230   }
231
232   if (setjmp (png_jmpbuf(png_ptr)))
233   {
234     png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
235     return FALSE;
236   }
237
238   /* set up the input control for C streams */
239   png_init_io (png_ptr, png_file);
240   png_set_sig_bytes (png_ptr, 8);  /* we already read the 8 signature bytes */
241
242   /* read the file information */
243   png_read_info (png_ptr, info_ptr);
244
245   /* get size and bit-depth of the PNG-image */
246   png_get_IHDR (png_ptr, info_ptr,
247     &width, &height, &bit_depth, &color_type,
248     NULL, NULL, NULL);
249
250   /* set-up the transformations */
251
252   /* transform paletted images into full-color rgb */
253   if (color_type == PNG_COLOR_TYPE_PALETTE)
254     png_set_expand (png_ptr);
255   /* expand images to bit-depth 8 (only applicable for grayscale images) */
256   if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
257     png_set_expand (png_ptr);
258   /* transform transparency maps into full alpha-channel */
259   if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
260     png_set_expand (png_ptr);
261
262 #ifdef NJET
263   /* downgrade 16-bit images to 8 bit */
264   if (bit_depth == 16)
265     png_set_strip_16 (png_ptr);
266   /* transform grayscale images into full-color */
267   if (color_type == PNG_COLOR_TYPE_GRAY ||
268     color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
269     png_set_gray_to_rgb (png_ptr);
270   /* only if file has a file gamma, we do a correction */
271   if (png_get_gAMA (png_ptr, info_ptr, &file_gamma))
272     png_set_gamma (png_ptr, (double) 2.2, file_gamma);
273 #endif
274
275   /* all transformations have been registered; now update info_ptr data,
276    * get rowbytes and channels, and allocate image memory */
277
278   png_read_update_info (png_ptr, info_ptr);
279
280   /* get the new color-type and bit-depth (after expansion/stripping) */
281   png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
282     NULL, NULL, NULL);
283
284   /* check for 16-bit files */
285   if (bit_depth == 16)
286   {
287     raw = FALSE;
288 #ifdef __TURBOC__
289     pnm_file->flags &= ~((unsigned) _F_BIN);
290 #endif
291   }
292
293   /* calculate new number of channels and store alpha-presence */
294   if (color_type == PNG_COLOR_TYPE_GRAY)
295     channels = 1;
296   else if (color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
297     channels = 2;
298   else if (color_type == PNG_COLOR_TYPE_RGB)
299     channels = 3;
300   else if (color_type == PNG_COLOR_TYPE_RGB_ALPHA)
301     channels = 4;
302   else
303     channels = 0; /* should never happen */
304   alpha_present = (channels - 1) % 2;
305
306   /* check if alpha is expected to be present in file */
307   if (alpha && !alpha_present)
308   {
309     fprintf (stderr, "PNG2PNM\n");
310     fprintf (stderr, "Error:  PNG-file doesn't contain alpha channel\n");
311     exit (1);
312   }
313
314   /* row_bytes is the width x number of channels x (bit-depth / 8) */
315   row_bytes = png_get_rowbytes (png_ptr, info_ptr);
316
317   if ((png_pixels = (png_byte *) malloc (row_bytes * height * sizeof (png_byte))) == NULL) {
318     png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
319     return FALSE;
320   }
321
322   if ((row_pointers = (png_byte **) malloc (height * sizeof (png_bytep))) == NULL)
323   {
324     png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
325     free (png_pixels);
326     png_pixels = NULL;
327     return FALSE;
328   }
329
330   /* set the individual row_pointers to point at the correct offsets */
331   for (i = 0; i < (height); i++)
332     row_pointers[i] = png_pixels + i * row_bytes;
333
334   /* now we can go ahead and just read the whole image */
335   png_read_image (png_ptr, row_pointers);
336
337   /* read rest of file, and get additional chunks in info_ptr - REQUIRED */
338   png_read_end (png_ptr, info_ptr);
339
340   /* clean up after the read, and free any memory allocated - REQUIRED */
341   png_destroy_read_struct (&png_ptr, &info_ptr, (png_infopp) NULL);
342
343   /* write header of PNM file */
344
345   if ((color_type == PNG_COLOR_TYPE_GRAY) ||
346       (color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
347   {
348     fprintf (pnm_file, "%s\n", (raw) ? "P5" : "P2");
349     fprintf (pnm_file, "%d %d\n", (int) width, (int) height);
350     fprintf (pnm_file, "%ld\n", ((1L << (int) bit_depth) - 1L));
351   }
352   else if ((color_type == PNG_COLOR_TYPE_RGB) ||
353            (color_type == PNG_COLOR_TYPE_RGB_ALPHA))
354   {
355     fprintf (pnm_file, "%s\n", (raw) ? "P6" : "P3");
356     fprintf (pnm_file, "%d %d\n", (int) width, (int) height);
357     fprintf (pnm_file, "%ld\n", ((1L << (int) bit_depth) - 1L));
358   }
359
360   /* write header of PGM file with alpha channel */
361
362   if ((alpha) &&
363       ((color_type == PNG_COLOR_TYPE_GRAY_ALPHA) ||
364        (color_type == PNG_COLOR_TYPE_RGB_ALPHA)))
365   {
366     fprintf (alpha_file, "%s\n", (raw) ? "P5" : "P2");
367     fprintf (alpha_file, "%d %d\n", (int) width, (int) height);
368     fprintf (alpha_file, "%ld\n", ((1L << (int) bit_depth) - 1L));
369   }
370
371   /* write data to PNM file */
372   pix_ptr = png_pixels;
373
374   for (row = 0; row < height; row++)
375   {
376     for (col = 0; col < width; col++)
377     {
378       for (i = 0; i < (channels - alpha_present); i++)
379       {
380         if (raw)
381           fputc ((int) *pix_ptr++ , pnm_file);
382         else
383           if (bit_depth == 16){
384             dep_16 = (long) *pix_ptr++;
385             fprintf (pnm_file, "%ld ", (dep_16 << 8) + ((long) *pix_ptr++));
386           }
387           else
388             fprintf (pnm_file, "%ld ", (long) *pix_ptr++);
389       }
390       if (alpha_present)
391       {
392         if (!alpha)
393         {
394           pix_ptr++; /* alpha */
395           if (bit_depth == 16)
396             pix_ptr++;
397         }
398         else /* output alpha-channel as pgm file */
399         {
400           if (raw)
401             fputc ((int) *pix_ptr++ , alpha_file);
402           else
403             if (bit_depth == 16){
404               dep_16 = (long) *pix_ptr++;
405               fprintf (alpha_file, "%ld ", (dep_16 << 8) + (long) *pix_ptr++);
406             }  
407             else
408               fprintf (alpha_file, "%ld ", (long) *pix_ptr++);
409         }
410       } /* if alpha_present */
411
412       if (!raw)
413         if (col % 4 == 3)
414           fprintf (pnm_file, "\n");
415     } /* end for col */
416
417     if (!raw)
418       if (col % 4 != 0)
419         fprintf (pnm_file, "\n");
420   } /* end for row */
421
422   if (row_pointers != (unsigned char**) NULL)
423     free (row_pointers);
424   if (png_pixels != (unsigned char*) NULL)
425     free (png_pixels);
426
427   return TRUE;
428
429 } /* end of source */
430