1 /*
2 * pnm2png.c --- conversion from PBM/PGM/PPM-file to PNG-file
3 * copyright (C) 1999,2015,2017 by Willem van Schaik <willem at schaik.com>
4 *
5 * version 1.0 - 1999.10.15 - First version.
6 * version 1.1 - 2015.07.29 - Fixed leaks (Glenn Randers-Pehrson)
7 * version 1.2 - 2017.04.22 - Add buffer-size check
8 * 1.3 - 2017.08.24 - Fix potential overflow in buffer-size check
9 * (Glenn Randers-Pehrson)
10 * 1.4 - 2017.08.28 - Add PNGMINUS_UNUSED (Christian Hesse)
11 *
12 * Permission to use, copy, modify, and distribute this software and
13 * its documentation for any purpose and without fee is hereby granted,
14 * provided that the above copyright notice appear in all copies and
15 * that both that copyright notice and this permission notice appear in
16 * supporting documentation. This software is provided "as is" without
17 * express or implied warranty.
18 */
19
20 #include <stdio.h>
21 #include <stdlib.h>
22 #ifdef __TURBOC__
23 #include <mem.h>
24 #include <fcntl.h>
25 #endif
26 #include <zlib.h>
27
28 #ifndef BOOL
29 #define BOOL unsigned char
30 #endif
31 #ifndef TRUE
32 #define TRUE (BOOL) 1
33 #endif
34 #ifndef FALSE
35 #define FALSE (BOOL) 0
36 #endif
37
38 #define STDIN 0
39 #define STDOUT 1
40 #define STDERR 2
41
42 /* to make pnm2png verbose so we can find problems (needs to be before png.h) */
43 #ifndef PNG_DEBUG
44 #define PNG_DEBUG 0
45 #endif
46
47 #include "png.h"
48
49 /* Define png_jmpbuf() in case we are using a pre-1.0.6 version of libpng */
50 #ifndef png_jmpbuf
51 # define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
52 #endif
53
54 #ifndef PNGMINUS_UNUSED
55 /* Unused formal parameter warnings are silenced using the following macro
56 * which is expected to have no bad effects on performance (optimizing
57 * compilers will probably remove it entirely).
58 */
59 # define PNGMINUS_UNUSED(param) (void)param
60 #endif
61
62
63 /* function prototypes */
64
65 int main (int argc, char *argv[]);
66 void usage ();
67 BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
68 BOOL alpha);
69 void get_token(FILE *pnm_file, char *token);
70 png_uint_32 get_data (FILE *pnm_file, int depth);
71 png_uint_32 get_value (FILE *pnm_file, int depth);
72
73 /*
74 * main
75 */
76
main(int argc,char * argv[])77 int main(int argc, char *argv[])
78 {
79 FILE *fp_rd = stdin;
80 FILE *fp_al = NULL;
81 FILE *fp_wr = stdout;
82 BOOL interlace = FALSE;
83 BOOL alpha = FALSE;
84 int argi;
85
86 for (argi = 1; argi < argc; argi++)
87 {
88 if (argv[argi][0] == '-')
89 {
90 switch (argv[argi][1])
91 {
92 case 'i':
93 interlace = TRUE;
94 break;
95 case 'a':
96 alpha = TRUE;
97 argi++;
98 if ((fp_al = fopen (argv[argi], "rb")) == NULL)
99 {
100 fprintf (stderr, "PNM2PNG\n");
101 fprintf (stderr, "Error: alpha-channel file %s does not exist\n",
102 argv[argi]);
103 exit (1);
104 }
105 break;
106 case 'h':
107 case '?':
108 usage();
109 exit(0);
110 break;
111 default:
112 fprintf (stderr, "PNM2PNG\n");
113 fprintf (stderr, "Error: unknown option %s\n", argv[argi]);
114 usage();
115 exit(1);
116 break;
117 } /* end switch */
118 }
119 else if (fp_rd == stdin)
120 {
121 if ((fp_rd = fopen (argv[argi], "rb")) == NULL)
122 {
123 fprintf (stderr, "PNM2PNG\n");
124 fprintf (stderr, "Error: file %s does not exist\n", argv[argi]);
125 exit (1);
126 }
127 }
128 else if (fp_wr == stdout)
129 {
130 if ((fp_wr = fopen (argv[argi], "wb")) == NULL)
131 {
132 fprintf (stderr, "PNM2PNG\n");
133 fprintf (stderr, "Error: can not create PNG-file %s\n", argv[argi]);
134 exit (1);
135 }
136 }
137 else
138 {
139 fprintf (stderr, "PNM2PNG\n");
140 fprintf (stderr, "Error: too many parameters\n");
141 usage();
142 exit (1);
143 }
144 } /* end for */
145
146 #ifdef __TURBOC__
147 /* set stdin/stdout to binary, we're reading the PNM always! in binary format */
148 if (fp_rd == stdin)
149 {
150 setmode (STDIN, O_BINARY);
151 }
152 if (fp_wr == stdout)
153 {
154 setmode (STDOUT, O_BINARY);
155 }
156 #endif
157
158 /* call the conversion program itself */
159 if (pnm2png (fp_rd, fp_wr, fp_al, interlace, alpha) == FALSE)
160 {
161 fprintf (stderr, "PNM2PNG\n");
162 fprintf (stderr, "Error: unsuccessful converting to PNG-image\n");
163 exit (1);
164 }
165
166 /* close input file */
167 fclose (fp_rd);
168 /* close output file */
169 fclose (fp_wr);
170 /* close alpha file */
171 if (alpha)
172 fclose (fp_al);
173
174 return 0;
175 }
176
177 /*
178 * usage
179 */
180
usage()181 void usage()
182 {
183 fprintf (stderr, "PNM2PNG\n");
184 fprintf (stderr, " by Willem van Schaik, 1999\n");
185 #ifdef __TURBOC__
186 fprintf (stderr, " for Turbo-C and Borland-C compilers\n");
187 #else
188 fprintf (stderr, " for Linux (and Unix) compilers\n");
189 #endif
190 fprintf (stderr, "Usage: pnm2png [options] <file>.<pnm> [<file>.png]\n");
191 fprintf (stderr, " or: ... | pnm2png [options]\n");
192 fprintf (stderr, "Options:\n");
193 fprintf (stderr, " -i[nterlace] write png-file with interlacing on\n");
194 fprintf (stderr,
195 " -a[lpha] <file>.pgm read PNG alpha channel as pgm-file\n");
196 fprintf (stderr, " -h | -? print this help-information\n");
197 }
198
199 /*
200 * pnm2png
201 */
202
pnm2png(FILE * pnm_file,FILE * png_file,FILE * alpha_file,BOOL interlace,BOOL alpha)203 BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
204 BOOL alpha)
205 {
206 png_struct *png_ptr = NULL;
207 png_info *info_ptr = NULL;
208 png_byte *png_pixels = NULL;
209 png_byte **row_pointers = NULL;
210 png_byte *pix_ptr = NULL;
211 volatile png_uint_32 row_bytes;
212
213 char type_token[16];
214 char width_token[16];
215 char height_token[16];
216 char maxval_token[16];
217 volatile int color_type=1;
218 unsigned long ul_width=0, ul_alpha_width=0;
219 unsigned long ul_height=0, ul_alpha_height=0;
220 unsigned long ul_maxval=0;
221 volatile png_uint_32 width=0, height=0;
222 volatile png_uint_32 alpha_width=0, alpha_height=0;
223 png_uint_32 maxval;
224 volatile int bit_depth = 0;
225 int channels=0;
226 int alpha_depth = 0;
227 int alpha_present=0;
228 int row, col;
229 BOOL raw, alpha_raw = FALSE;
230 #if defined(PNG_WRITE_INVERT_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
231 BOOL packed_bitmap = FALSE;
232 #endif
233 png_uint_32 tmp16;
234 int i;
235
236 /* read header of PNM file */
237
238 get_token(pnm_file, type_token);
239 if (type_token[0] != 'P')
240 {
241 return FALSE;
242 }
243 else if ((type_token[1] == '1') || (type_token[1] == '4'))
244 {
245 #if defined(PNG_WRITE_INVERT_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
246 raw = (type_token[1] == '4');
247 color_type = PNG_COLOR_TYPE_GRAY;
248 get_token(pnm_file, width_token);
249 sscanf (width_token, "%lu", &ul_width);
250 width = (png_uint_32) ul_width;
251 get_token(pnm_file, height_token);
252 sscanf (height_token, "%lu", &ul_height);
253 height = (png_uint_32) ul_height;
254 bit_depth = 1;
255 packed_bitmap = TRUE;
256 #else
257 fprintf (stderr, "PNM2PNG built without PNG_WRITE_INVERT_SUPPORTED and \n");
258 fprintf (stderr, "PNG_WRITE_PACK_SUPPORTED can't read PBM (P1,P4) files\n");
259 #endif
260 }
261 else if ((type_token[1] == '2') || (type_token[1] == '5'))
262 {
263 raw = (type_token[1] == '5');
264 color_type = PNG_COLOR_TYPE_GRAY;
265 get_token(pnm_file, width_token);
266 sscanf (width_token, "%lu", &ul_width);
267 width = (png_uint_32) ul_width;
268 get_token(pnm_file, height_token);
269 sscanf (height_token, "%lu", &ul_height);
270 height = (png_uint_32) ul_height;
271 get_token(pnm_file, maxval_token);
272 sscanf (maxval_token, "%lu", &ul_maxval);
273 maxval = (png_uint_32) ul_maxval;
274
275 if (maxval <= 1)
276 bit_depth = 1;
277 else if (maxval <= 3)
278 bit_depth = 2;
279 else if (maxval <= 15)
280 bit_depth = 4;
281 else if (maxval <= 255)
282 bit_depth = 8;
283 else /* if (maxval <= 65535) */
284 bit_depth = 16;
285 }
286 else if ((type_token[1] == '3') || (type_token[1] == '6'))
287 {
288 raw = (type_token[1] == '6');
289 color_type = PNG_COLOR_TYPE_RGB;
290 get_token(pnm_file, width_token);
291 sscanf (width_token, "%lu", &ul_width);
292 width = (png_uint_32) ul_width;
293 get_token(pnm_file, height_token);
294 sscanf (height_token, "%lu", &ul_height);
295 height = (png_uint_32) ul_height;
296 get_token(pnm_file, maxval_token);
297 sscanf (maxval_token, "%lu", &ul_maxval);
298 maxval = (png_uint_32) ul_maxval;
299 if (maxval <= 1)
300 bit_depth = 1;
301 else if (maxval <= 3)
302 bit_depth = 2;
303 else if (maxval <= 15)
304 bit_depth = 4;
305 else if (maxval <= 255)
306 bit_depth = 8;
307 else /* if (maxval <= 65535) */
308 bit_depth = 16;
309 }
310 else
311 {
312 return FALSE;
313 }
314
315 /* read header of PGM file with alpha channel */
316
317 if (alpha)
318 {
319 if (color_type == PNG_COLOR_TYPE_GRAY)
320 color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
321 if (color_type == PNG_COLOR_TYPE_RGB)
322 color_type = PNG_COLOR_TYPE_RGB_ALPHA;
323
324 get_token(alpha_file, type_token);
325 if (type_token[0] != 'P')
326 {
327 return FALSE;
328 }
329 else if ((type_token[1] == '2') || (type_token[1] == '5'))
330 {
331 alpha_raw = (type_token[1] == '5');
332 get_token(alpha_file, width_token);
333 sscanf (width_token, "%lu", &ul_alpha_width);
334 alpha_width=(png_uint_32) ul_alpha_width;
335 if (alpha_width != width)
336 return FALSE;
337 get_token(alpha_file, height_token);
338 sscanf (height_token, "%lu", &ul_alpha_height);
339 alpha_height = (png_uint_32) ul_alpha_height;
340 if (alpha_height != height)
341 return FALSE;
342 get_token(alpha_file, maxval_token);
343 sscanf (maxval_token, "%lu", &ul_maxval);
344 maxval = (png_uint_32) ul_maxval;
345 if (maxval <= 1)
346 alpha_depth = 1;
347 else if (maxval <= 3)
348 alpha_depth = 2;
349 else if (maxval <= 15)
350 alpha_depth = 4;
351 else if (maxval <= 255)
352 alpha_depth = 8;
353 else /* if (maxval <= 65535) */
354 alpha_depth = 16;
355 if (alpha_depth != bit_depth)
356 return FALSE;
357 }
358 else
359 {
360 return FALSE;
361 }
362 } /* end if alpha */
363
364 /* calculate the number of channels and store alpha-presence */
365 if (color_type == PNG_COLOR_TYPE_GRAY)
366 channels = 1;
367 else if (color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
368 channels = 2;
369 else if (color_type == PNG_COLOR_TYPE_RGB)
370 channels = 3;
371 else if (color_type == PNG_COLOR_TYPE_RGB_ALPHA)
372 channels = 4;
373 #if 0
374 else
375 channels = 0; /* cannot happen */
376 #endif
377
378 alpha_present = (channels - 1) % 2;
379
380 #if defined(PNG_WRITE_INVERT_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
381 if (packed_bitmap)
382 /* row data is as many bytes as can fit width x channels x bit_depth */
383 row_bytes = (width * channels * bit_depth + 7) / 8;
384 else
385 #endif
386 /* row_bytes is the width x number of channels x (bit-depth / 8) */
387 row_bytes = width * channels * ((bit_depth <= 8) ? 1 : 2);
388
389 if ((row_bytes == 0 || (size_t)height > ((size_t)(-1))/(size_t)row_bytes))
390 {
391 /* too big */
392 return FALSE;
393 }
394 if ((png_pixels = (png_byte *)
395 malloc ((size_t)row_bytes * (size_t)height * sizeof (png_byte))) == NULL)
396 return FALSE;
397
398 /* read data from PNM file */
399 pix_ptr = png_pixels;
400
401 for (row = 0; row < (int) height; row++)
402 {
403 #if defined(PNG_WRITE_INVERT_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
404 if (packed_bitmap)
405 {
406 for (i = 0; i < (int) row_bytes; i++)
407 /* png supports this format natively so no conversion is needed */
408 *pix_ptr++ = get_data (pnm_file, 8);
409 } else
410 #endif
411 {
412 for (col = 0; col < (int) width; col++)
413 {
414 for (i = 0; i < (channels - alpha_present); i++)
415 {
416 if (raw)
417 *pix_ptr++ = get_data (pnm_file, bit_depth);
418 else
419 if (bit_depth <= 8)
420 *pix_ptr++ = get_value (pnm_file, bit_depth);
421 else
422 {
423 tmp16 = get_value (pnm_file, bit_depth);
424 *pix_ptr = (png_byte) ((tmp16 >> 8) & 0xFF);
425 pix_ptr++;
426 *pix_ptr = (png_byte) (tmp16 & 0xFF);
427 pix_ptr++;
428 }
429 }
430
431 if (alpha) /* read alpha-channel from pgm file */
432 {
433 if (alpha_raw)
434 *pix_ptr++ = get_data (alpha_file, alpha_depth);
435 else
436 if (alpha_depth <= 8)
437 *pix_ptr++ = get_value (alpha_file, bit_depth);
438 else
439 {
440 tmp16 = get_value (alpha_file, bit_depth);
441 *pix_ptr++ = (png_byte) ((tmp16 >> 8) & 0xFF);
442 *pix_ptr++ = (png_byte) (tmp16 & 0xFF);
443 }
444 } /* if alpha */
445 } /* if packed_bitmap */
446 } /* end for col */
447 } /* end for row */
448
449 /* prepare the standard PNG structures */
450 png_ptr = png_create_write_struct (png_get_libpng_ver(NULL), NULL, NULL,
451 NULL);
452 if (!png_ptr)
453 {
454 free (png_pixels);
455 png_pixels = NULL;
456 return FALSE;
457 }
458 info_ptr = png_create_info_struct (png_ptr);
459 if (!info_ptr)
460 {
461 png_destroy_write_struct (&png_ptr, (png_infopp) NULL);
462 free (png_pixels);
463 png_pixels = NULL;
464 return FALSE;
465 }
466
467 #if defined(PNG_WRITE_INVERT_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
468 if (packed_bitmap == TRUE)
469 {
470 png_set_packing (png_ptr);
471 png_set_invert_mono (png_ptr);
472 }
473 #endif
474
475 /* setjmp() must be called in every function that calls a PNG-reading libpng function */
476 if (setjmp (png_jmpbuf(png_ptr)))
477 {
478 png_destroy_write_struct (&png_ptr, &info_ptr);
479 free (png_pixels);
480 png_pixels = NULL;
481 return FALSE;
482 }
483
484 /* initialize the png structure */
485 png_init_io (png_ptr, png_file);
486
487 /* we're going to write more or less the same PNG as the input file */
488 png_set_IHDR (png_ptr, info_ptr, width, height, bit_depth, color_type,
489 (!interlace) ? PNG_INTERLACE_NONE : PNG_INTERLACE_ADAM7,
490 PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
491
492 /* write the file header information */
493 png_write_info (png_ptr, info_ptr);
494
495 /* if needed we will allocate memory for an new array of row-pointers */
496 if (row_pointers == (unsigned char**) NULL)
497 {
498 if ((row_pointers = (png_byte **)
499 malloc (height * sizeof (png_bytep))) == NULL)
500 {
501 png_destroy_write_struct (&png_ptr, &info_ptr);
502 free (png_pixels);
503 png_pixels = NULL;
504 return FALSE;
505 }
506 }
507
508 /* set the individual row_pointers to point at the correct offsets */
509 for (i = 0; i < (int) height; i++)
510 row_pointers[i] = png_pixels + i * row_bytes;
511
512 /* write out the entire image data in one call */
513 png_write_image (png_ptr, row_pointers);
514
515 /* write the additional chunks to the PNG file (not really needed) */
516 png_write_end (png_ptr, info_ptr);
517
518 /* clean up after the write, and free any memory allocated */
519 png_destroy_write_struct (&png_ptr, &info_ptr);
520
521 if (row_pointers != (unsigned char**) NULL)
522 free (row_pointers);
523 if (png_pixels != (unsigned char*) NULL)
524 free (png_pixels);
525
526 PNGMINUS_UNUSED(raw); /* Quiet a Coverity defect */
527
528 return TRUE;
529 } /* end of pnm2png */
530
531 /*
532 * get_token() - gets the first string after whitespace
533 */
534
get_token(FILE * pnm_file,char * token)535 void get_token(FILE *pnm_file, char *token)
536 {
537 int i = 0;
538 int ret;
539
540 /* remove white-space and comment lines */
541 do
542 {
543 ret = fgetc(pnm_file);
544 if (ret == '#')
545 {
546 /* the rest of this line is a comment */
547 do
548 {
549 ret = fgetc(pnm_file);
550 }
551 while ((ret != '\n') && (ret != '\r') && (ret != EOF));
552 }
553 if (ret == EOF) break;
554 token[i] = (unsigned char) ret;
555 }
556 while ((token[i] == '\n') || (token[i] == '\r') || (token[i] == ' '));
557
558 /* read string */
559 do
560 {
561 ret = fgetc(pnm_file);
562 if (ret == EOF) break;
563 i++;
564 token[i] = (unsigned char) ret;
565 }
566 while ((token[i] != '\n') && (token[i] != '\r') && (token[i] != ' '));
567
568 token[i] = '\0';
569
570 return;
571 }
572
573 /*
574 * get_data() - takes first byte and converts into next pixel value,
575 * taking as much bits as defined by bit-depth and
576 * using the bit-depth to fill up a byte (0Ah -> AAh)
577 */
578
get_data(FILE * pnm_file,int depth)579 png_uint_32 get_data (FILE *pnm_file, int depth)
580 {
581 static int bits_left = 0;
582 static int old_value = 0;
583 static int mask = 0;
584 int i;
585 png_uint_32 ret_value;
586
587 if (mask == 0)
588 for (i = 0; i < depth; i++)
589 mask = (mask >> 1) | 0x80;
590
591 if (bits_left <= 0)
592 {
593 old_value = fgetc (pnm_file);
594 bits_left = 8;
595 }
596
597 ret_value = old_value & mask;
598 for (i = 1; i < (8 / depth); i++)
599 ret_value = ret_value || (ret_value >> depth);
600
601 old_value = (old_value << depth) & 0xFF;
602 bits_left -= depth;
603
604 return ret_value;
605 }
606
607 /*
608 * get_value() - takes first (numeric) string and converts into number,
609 * using the bit-depth to fill up a byte (0Ah -> AAh)
610 */
611
get_value(FILE * pnm_file,int depth)612 png_uint_32 get_value (FILE *pnm_file, int depth)
613 {
614 static png_uint_32 mask = 0;
615 png_byte token[16];
616 unsigned long ul_ret_value;
617 png_uint_32 ret_value;
618 int i = 0;
619
620 if (mask == 0)
621 for (i = 0; i < depth; i++)
622 mask = (mask << 1) | 0x01;
623
624 get_token (pnm_file, (char *) token);
625 sscanf ((const char *) token, "%lu", &ul_ret_value);
626 ret_value = (png_uint_32) ul_ret_value;
627
628 ret_value &= mask;
629
630 if (depth < 8)
631 for (i = 0; i < (8 / depth); i++)
632 ret_value = (ret_value << depth) || ret_value;
633
634 return ret_value;
635 }
636
637 /* end of source */
638
639