1 /*---------------------------------------------------------------------------
2
3 wpng - simple PNG-writing program wpng.c
4
5 This program converts certain NetPBM binary files (grayscale and RGB,
6 maxval = 255) to PNG. Non-interlaced PNGs are written progressively;
7 interlaced PNGs are read and written in one memory-intensive blast.
8
9 Thanks to Jean-loup Gailly for providing the necessary trick to read
10 interactive text from the keyboard while stdin is redirected. Thanks
11 to Cosmin Truta for Cygwin fixes.
12
13 NOTE: includes provisional support for PNM type "8" (portable alphamap)
14 images, presumed to be a 32-bit interleaved RGBA format; no pro-
15 vision for possible interleaved grayscale+alpha (16-bit) format.
16 THIS IS UNLIKELY TO BECOME AN OFFICIAL NETPBM ALPHA FORMAT!
17
18 to do:
19 - delete output file if quit before calling any writepng routines
20 - process backspace with -text option under DOS/Win? (currently get ^H)
21
22 ---------------------------------------------------------------------------
23
24 Changelog:
25 - 1.01: initial public release
26 - 1.02: modified to allow abbreviated options
27 - 1.03: removed extraneous character from usage screen; fixed bug in
28 command-line parsing
29 - 1.04: fixed DOS/OS2/Win32 detection, including partial Cygwin fix
30 (see http://home.att.net/~perlspinr/diffs/GregBook_cygwin.diff)
31 - 2.00: dual-licensed (added GNU GPL)
32 - 2.01: check for integer overflow (Glenn R-P)
33
34 [REPORTED BUG (win32 only): "contrib/gregbook/wpng.c - cmd line
35 dose not work! In order to do something useful I needed to redirect
36 both input and output, with cygwin and with bcc32 as well. Under
37 Linux, the same wpng appears to work fine. I don't know what is
38 the problem."]
39
40 ---------------------------------------------------------------------------
41
42 Copyright (c) 1998-2007, 2017 Greg Roelofs. All rights reserved.
43
44 This software is provided "as is," without warranty of any kind,
45 express or implied. In no event shall the author or contributors
46 be held liable for any damages arising in any way from the use of
47 this software.
48
49 The contents of this file are DUAL-LICENSED. You may modify and/or
50 redistribute this software according to the terms of one of the
51 following two licenses (at your option):
52
53
54 LICENSE 1 ("BSD-like with advertising clause"):
55
56 Permission is granted to anyone to use this software for any purpose,
57 including commercial applications, and to alter it and redistribute
58 it freely, subject to the following restrictions:
59
60 1. Redistributions of source code must retain the above copyright
61 notice, disclaimer, and this list of conditions.
62 2. Redistributions in binary form must reproduce the above copyright
63 notice, disclaimer, and this list of conditions in the documenta-
64 tion and/or other materials provided with the distribution.
65 3. All advertising materials mentioning features or use of this
66 software must display the following acknowledgment:
67
68 This product includes software developed by Greg Roelofs
69 and contributors for the book, "PNG: The Definitive Guide,"
70 published by O'Reilly and Associates.
71
72
73 LICENSE 2 (GNU GPL v2 or later):
74
75 This program is free software; you can redistribute it and/or modify
76 it under the terms of the GNU General Public License as published by
77 the Free Software Foundation; either version 2 of the License, or
78 (at your option) any later version.
79
80 This program is distributed in the hope that it will be useful,
81 but WITHOUT ANY WARRANTY; without even the implied warranty of
82 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
83 GNU General Public License for more details.
84
85 You should have received a copy of the GNU General Public License
86 along with this program; if not, write to the Free Software Foundation,
87 Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
88
89 ---------------------------------------------------------------------------*/
90
91 #define PROGNAME "wpng"
92 #define VERSION "2.00 of 2 June 2007"
93 #define APPNAME "Simple PGM/PPM/PAM to PNG Converter"
94
95 #if defined(__MSDOS__) || defined(__OS2__)
96 # define DOS_OS2_W32
97 #elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
98 # ifndef __GNUC__ /* treat Win32 native ports of gcc as Unix environments */
99 # define DOS_OS2_W32
100 # endif
101 #endif
102
103 #include <stdio.h>
104 #include <stdlib.h>
105 #include <string.h>
106 #include <setjmp.h> /* for jmpbuf declaration in writepng.h */
107 #include <time.h>
108
109 #ifdef DOS_OS2_W32
110 # include <io.h> /* for isatty(), setmode() prototypes */
111 # include <fcntl.h> /* O_BINARY for fdopen() without text translation */
112 # ifdef __EMX__
113 # ifndef getch
114 # define getch() _read_kbd(0, 1, 0) /* need getche() */
115 # endif
116 # else /* !__EMX__ */
117 # ifdef __GO32__
118 # include <pc.h>
119 # define getch() getkey() /* GRR: need getche() */
120 # else
121 # include <conio.h> /* for getche() console input */
122 # endif
123 # endif /* ?__EMX__ */
124 # define FGETS(buf,len,stream) dos_kbd_gets(buf,len)
125 #else
126 # include <unistd.h> /* for isatty() prototype */
127 # define FGETS fgets
128 #endif
129
130 /* #define DEBUG : this enables the Trace() macros */
131
132 /* #define FORBID_LATIN1_CTRL : this requires the user to re-enter any
133 text that includes control characters discouraged by the PNG spec; text
134 that includes an escape character (27) must be re-entered regardless */
135
136 #include "writepng.h" /* typedefs, common macros, writepng prototypes */
137
138
139
140 /* local prototypes */
141
142 static int wpng_isvalid_latin1(uch *p, int len);
143 static void wpng_cleanup(void);
144
145 #ifdef DOS_OS2_W32
146 static char *dos_kbd_gets(char *buf, int len);
147 #endif
148
149
150
151 static mainprog_info wpng_info; /* lone global */
152
153
154
155 int main(int argc, char **argv)
156 {
157 #ifndef DOS_OS2_W32
158 FILE *keybd;
159 #endif
160 #ifdef sgi
161 FILE *tmpfile; /* or we could just use keybd, since no overlap */
162 char tmpline[80];
163 #endif
164 char *inname = NULL, outname[256];
165 char *p, pnmchar, pnmline[256];
166 char *bgstr, *textbuf = NULL;
167 ulg rowbytes;
168 int rc, len = 0;
169 int error = 0;
170 int text = FALSE;
171 int maxval;
172 double LUT_exponent; /* just the lookup table */
173 double CRT_exponent = 2.2; /* just the monitor */
174 double default_display_exponent; /* whole display system */
175 double default_gamma = 0.0;
176
177
178 wpng_info.infile = NULL;
179 wpng_info.outfile = NULL;
180 wpng_info.image_data = NULL;
181 wpng_info.row_pointers = NULL;
182 wpng_info.filter = FALSE;
183 wpng_info.interlaced = FALSE;
184 wpng_info.have_bg = FALSE;
185 wpng_info.have_time = FALSE;
186 wpng_info.have_text = 0;
187 wpng_info.gamma = 0.0;
188
189
190 /* First get the default value for our display-system exponent, i.e.,
191 * the product of the CRT exponent and the exponent corresponding to
192 * the frame-buffer's lookup table (LUT), if any. If the PNM image
193 * looks correct on the user's display system, its file gamma is the
194 * inverse of this value. (Note that this is not an exhaustive list
195 * of LUT values--e.g., OpenStep has a lot of weird ones--but it should
196 * cover 99% of the current possibilities. This section must ensure
197 * that default_display_exponent is positive.) */
198
199 #if defined(NeXT)
200 /* third-party utilities can modify the default LUT exponent */
201 LUT_exponent = 1.0 / 2.2;
202 /*
203 if (some_next_function_that_returns_gamma(&next_gamma))
204 LUT_exponent = 1.0 / next_gamma;
205 */
206 #elif defined(sgi)
207 LUT_exponent = 1.0 / 1.7;
208 /* there doesn't seem to be any documented function to
209 * get the "gamma" value, so we do it the hard way */
210 tmpfile = fopen("/etc/config/system.glGammaVal", "r");
211 if (tmpfile) {
212 double sgi_gamma;
213
214 fgets(tmpline, 80, tmpfile);
215 fclose(tmpfile);
216 sgi_gamma = atof(tmpline);
217 if (sgi_gamma > 0.0)
218 LUT_exponent = 1.0 / sgi_gamma;
219 }
220 #elif defined(Macintosh)
221 LUT_exponent = 1.8 / 2.61;
222 /*
223 if (some_mac_function_that_returns_gamma(&mac_gamma))
224 LUT_exponent = mac_gamma / 2.61;
225 */
226 #else
227 LUT_exponent = 1.0; /* assume no LUT: most PCs */
228 #endif
229
230 /* the defaults above give 1.0, 1.3, 1.5 and 2.2, respectively: */
231 default_display_exponent = LUT_exponent * CRT_exponent;
232
233
234 /* If the user has set the SCREEN_GAMMA environment variable as suggested
235 * (somewhat imprecisely) in the libpng documentation, use that; otherwise
236 * use the default value we just calculated. Either way, the user may
237 * override this via a command-line option. */
238
239 if ((p = getenv("SCREEN_GAMMA")) != NULL) {
240 double exponent = atof(p);
241
242 if (exponent > 0.0)
243 default_gamma = 1.0 / exponent;
244 }
245
246 if (default_gamma == 0.0)
247 default_gamma = 1.0 / default_display_exponent;
248
249
250 /* Now parse the command line for options and the PNM filename. */
251
252 while (*++argv && !error) {
253 if (!strncmp(*argv, "-i", 2)) {
254 wpng_info.interlaced = TRUE;
255 } else if (!strncmp(*argv, "-time", 3)) {
256 wpng_info.modtime = time(NULL);
257 wpng_info.have_time = TRUE;
258 } else if (!strncmp(*argv, "-text", 3)) {
259 text = TRUE;
260 } else if (!strncmp(*argv, "-gamma", 2)) {
261 if (!*++argv)
262 ++error;
263 else {
264 wpng_info.gamma = atof(*argv);
265 if (wpng_info.gamma <= 0.0)
266 ++error;
267 else if (wpng_info.gamma > 1.01)
268 fprintf(stderr, PROGNAME
269 " warning: file gammas are usually less than 1.0\n");
270 }
271 } else if (!strncmp(*argv, "-bgcolor", 4)) {
272 if (!*++argv)
273 ++error;
274 else {
275 bgstr = *argv;
276 if (strlen(bgstr) != 7 || bgstr[0] != '#')
277 ++error;
278 else {
279 unsigned r, g, b; /* this way quiets compiler warnings */
280
281 sscanf(bgstr+1, "%2x%2x%2x", &r, &g, &b);
282 wpng_info.bg_red = (uch)r;
283 wpng_info.bg_green = (uch)g;
284 wpng_info.bg_blue = (uch)b;
285 wpng_info.have_bg = TRUE;
286 }
287 }
288 } else {
289 if (**argv != '-') {
290 inname = *argv;
291 if (argv[1]) /* shouldn't be any more args after filename */
292 ++error;
293 } else
294 ++error; /* not expecting any other options */
295 }
296 }
297
298
299 /* open the input and output files, or register an error and abort */
300
301 if (!inname) {
302 if (isatty(0)) {
303 fprintf(stderr, PROGNAME
304 ": must give input filename or provide image data via stdin\n");
305 ++error;
306 } else {
307 #ifdef DOS_OS2_W32
308 /* some buggy C libraries require BOTH setmode() and fdopen(bin) */
309 setmode(fileno(stdin), O_BINARY);
310 setmode(fileno(stdout), O_BINARY);
311 #endif
312 if ((wpng_info.infile = fdopen(fileno(stdin), "rb")) == NULL) {
313 fprintf(stderr, PROGNAME
314 ": unable to reopen stdin in binary mode\n");
315 ++error;
316 } else
317 if ((wpng_info.outfile = fdopen(fileno(stdout), "wb")) == NULL) {
318 fprintf(stderr, PROGNAME
319 ": unable to reopen stdout in binary mode\n");
320 fclose(wpng_info.infile);
321 ++error;
322 } else
323 wpng_info.filter = TRUE;
324 }
325 } else if ((len = strlen(inname)) > 250) {
326 fprintf(stderr, PROGNAME ": input filename is too long [%d chars]\n",
327 len);
328 ++error;
329 } else if (!(wpng_info.infile = fopen(inname, "rb"))) {
330 fprintf(stderr, PROGNAME ": can't open input file [%s]\n", inname);
331 ++error;
332 }
333
334 if (!error) {
335 fgets(pnmline, 256, wpng_info.infile);
336 if (pnmline[0] != 'P' || ((pnmchar = pnmline[1]) != '5' &&
337 pnmchar != '6' && pnmchar != '8'))
338 {
339 fprintf(stderr, PROGNAME
340 ": input file [%s] is not a binary PGM, PPM or PAM file\n",
341 inname);
342 ++error;
343 } else {
344 wpng_info.pnmtype = (int)(pnmchar - '0');
345 if (wpng_info.pnmtype != 8)
346 wpng_info.have_bg = FALSE; /* no need for bg if opaque */
347 do {
348 fgets(pnmline, 256, wpng_info.infile); /* lose any comments */
349 } while (pnmline[0] == '#');
350 sscanf(pnmline, "%ld %ld", &wpng_info.width, &wpng_info.height);
351 do {
352 fgets(pnmline, 256, wpng_info.infile); /* more comment lines */
353 } while (pnmline[0] == '#');
354 sscanf(pnmline, "%d", &maxval);
355 if (wpng_info.width <= 0L || wpng_info.height <= 0L ||
356 maxval != 255)
357 {
358 fprintf(stderr, PROGNAME
359 ": only positive width/height, maxval == 255 allowed \n");
360 ++error;
361 }
362 wpng_info.sample_depth = 8; /* <==> maxval 255 */
363
364 if (!wpng_info.filter) {
365 /* make outname from inname */
366 if ((p = strrchr(inname, '.')) == NULL ||
367 (p - inname) != (len - 4))
368 {
369 strcpy(outname, inname);
370 strcpy(outname+len, ".png");
371 } else {
372 len -= 4;
373 strncpy(outname, inname, len);
374 strcpy(outname+len, ".png");
375 }
376 /* check if outname already exists; if not, open */
377 if ((wpng_info.outfile = fopen(outname, "rb")) != NULL) {
378 fprintf(stderr, PROGNAME ": output file exists [%s]\n",
379 outname);
380 fclose(wpng_info.outfile);
381 ++error;
382 } else if (!(wpng_info.outfile = fopen(outname, "wb"))) {
383 fprintf(stderr, PROGNAME ": can't open output file [%s]\n",
384 outname);
385 ++error;
386 }
387 }
388 }
389 if (error) {
390 fclose(wpng_info.infile);
391 wpng_info.infile = NULL;
392 if (wpng_info.filter) {
393 fclose(wpng_info.outfile);
394 wpng_info.outfile = NULL;
395 }
396 }
397 }
398
399
400 /* if we had any errors, print usage and die horrible death...arrr! */
401
402 if (error) {
403 fprintf(stderr, "\n%s %s: %s\n", PROGNAME, VERSION, APPNAME);
404 writepng_version_info();
405 fprintf(stderr, "\n"
406 "Usage: %s [-gamma exp] [-bgcolor bg] [-text] [-time] [-interlace] pnmfile\n"
407 "or: ... | %s [-gamma exp] [-bgcolor bg] [-text] [-time] [-interlace] | ...\n"
408 " exp \ttransfer-function exponent (``gamma'') of the image in\n"
409 "\t\t floating-point format (e.g., ``%.5f''); if image looks\n"
410 "\t\t correct on given display system, image gamma is equal to\n"
411 "\t\t inverse of display-system exponent, i.e., 1 / (LUT * CRT)\n"
412 "\t\t (where LUT = lookup-table exponent and CRT = CRT exponent;\n"
413 "\t\t first varies, second is usually 2.2, all are positive)\n"
414 " bg \tdesired background color for alpha-channel images, in\n"
415 "\t\t 7-character hex RGB format (e.g., ``#ff7700'' for orange:\n"
416 "\t\t same as HTML colors)\n"
417 " -text\tprompt interactively for text info (tEXt chunks)\n"
418 " -time\tinclude a tIME chunk (last modification time)\n"
419 " -interlace\twrite interlaced PNG image\n"
420 "\n"
421 "pnmfile or stdin must be a binary PGM (`P5'), PPM (`P6') or (extremely\n"
422 "unofficial and unsupported!) PAM (`P8') file. Currently it is required\n"
423 "to have maxval == 255 (i.e., no scaling). If pnmfile is specified, it\n"
424 "is converted to the corresponding PNG file with the same base name but a\n"
425 "``.png'' extension; files read from stdin are converted and sent to stdout.\n"
426 "The conversion is progressive (low memory usage) unless interlacing is\n"
427 "requested; in that case the whole image will be buffered in memory and\n"
428 "written in one call.\n"
429 "\n", PROGNAME, PROGNAME, default_gamma);
430 exit(1);
431 }
432
433
434 /* prepare the text buffers for libpng's use; note that even though
435 * PNG's png_text struct includes a length field, we don't have to fill
436 * it out */
437
438 if (text &&
439 #ifndef DOS_OS2_W32
440 (keybd = fdopen(fileno(stderr), "r")) != NULL &&
441 #endif
442 (textbuf = (char *)malloc((5 + 9)*75)) != NULL)
443 {
444 int i, valid, result;
445
446 fprintf(stderr,
447 "Enter text info (no more than 72 characters per line);\n");
448 fprintf(stderr, "to skip a field, hit the <Enter> key.\n");
449 /* note: just <Enter> leaves len == 1 */
450
451 do {
452 valid = TRUE;
453 p = textbuf + TEXT_TITLE_OFFSET;
454 fprintf(stderr, " Title: ");
455 fflush(stderr);
456 if (FGETS(p, 74, keybd) && (len = strlen(p)) > 1) {
457 if (p[len-1] == '\n')
458 p[--len] = '\0';
459 wpng_info.title = p;
460 wpng_info.have_text |= TEXT_TITLE;
461 if ((result = wpng_isvalid_latin1((uch *)p, len)) >= 0) {
462 fprintf(stderr, " " PROGNAME " warning: character code"
463 " %u is %sdiscouraged by the PNG\n specification "
464 "[first occurrence was at character position #%d]\n",
465 (unsigned)p[result], (p[result] == 27)? "strongly " : "",
466 result+1);
467 fflush(stderr);
468 #ifdef FORBID_LATIN1_CTRL
469 wpng_info.have_text &= ~TEXT_TITLE;
470 valid = FALSE;
471 #else
472 if (p[result] == 27) { /* escape character */
473 wpng_info.have_text &= ~TEXT_TITLE;
474 valid = FALSE;
475 }
476 #endif
477 }
478 }
479 } while (!valid);
480
481 do {
482 valid = TRUE;
483 p = textbuf + TEXT_AUTHOR_OFFSET;
484 fprintf(stderr, " Author: ");
485 fflush(stderr);
486 if (FGETS(p, 74, keybd) && (len = strlen(p)) > 1) {
487 if (p[len-1] == '\n')
488 p[--len] = '\0';
489 wpng_info.author = p;
490 wpng_info.have_text |= TEXT_AUTHOR;
491 if ((result = wpng_isvalid_latin1((uch *)p, len)) >= 0) {
492 fprintf(stderr, " " PROGNAME " warning: character code"
493 " %u is %sdiscouraged by the PNG\n specification "
494 "[first occurrence was at character position #%d]\n",
495 (unsigned)p[result], (p[result] == 27)? "strongly " : "",
496 result+1);
497 fflush(stderr);
498 #ifdef FORBID_LATIN1_CTRL
499 wpng_info.have_text &= ~TEXT_AUTHOR;
500 valid = FALSE;
501 #else
502 if (p[result] == 27) { /* escape character */
503 wpng_info.have_text &= ~TEXT_AUTHOR;
504 valid = FALSE;
505 }
506 #endif
507 }
508 }
509 } while (!valid);
510
511 do {
512 valid = TRUE;
513 p = textbuf + TEXT_DESC_OFFSET;
514 fprintf(stderr, " Description (up to 9 lines):\n");
515 for (i = 1; i < 10; ++i) {
516 fprintf(stderr, " [%d] ", i);
517 fflush(stderr);
518 if (FGETS(p, 74, keybd) && (len = strlen(p)) > 1)
519 p += len; /* now points at NULL; char before is newline */
520 else
521 break;
522 }
523 if ((len = p - (textbuf + TEXT_DESC_OFFSET)) > 1) {
524 if (p[-1] == '\n') {
525 p[-1] = '\0';
526 --len;
527 }
528 wpng_info.desc = textbuf + TEXT_DESC_OFFSET;
529 wpng_info.have_text |= TEXT_DESC;
530 p = textbuf + TEXT_DESC_OFFSET;
531 if ((result = wpng_isvalid_latin1((uch *)p, len)) >= 0) {
532 fprintf(stderr, " " PROGNAME " warning: character code"
533 " %u is %sdiscouraged by the PNG\n specification "
534 "[first occurrence was at character position #%d]\n",
535 (unsigned)p[result], (p[result] == 27)? "strongly " : "",
536 result+1);
537 fflush(stderr);
538 #ifdef FORBID_LATIN1_CTRL
539 wpng_info.have_text &= ~TEXT_DESC;
540 valid = FALSE;
541 #else
542 if (p[result] == 27) { /* escape character */
543 wpng_info.have_text &= ~TEXT_DESC;
544 valid = FALSE;
545 }
546 #endif
547 }
548 }
549 } while (!valid);
550
551 do {
552 valid = TRUE;
553 p = textbuf + TEXT_COPY_OFFSET;
554 fprintf(stderr, " Copyright: ");
555 fflush(stderr);
556 if (FGETS(p, 74, keybd) && (len = strlen(p)) > 1) {
557 if (p[len-1] == '\n')
558 p[--len] = '\0';
559 wpng_info.copyright = p;
560 wpng_info.have_text |= TEXT_COPY;
561 if ((result = wpng_isvalid_latin1((uch *)p, len)) >= 0) {
562 fprintf(stderr, " " PROGNAME " warning: character code"
563 " %u is %sdiscouraged by the PNG\n specification "
564 "[first occurrence was at character position #%d]\n",
565 (unsigned)p[result], (p[result] == 27)? "strongly " : "",
566 result+1);
567 fflush(stderr);
568 #ifdef FORBID_LATIN1_CTRL
569 wpng_info.have_text &= ~TEXT_COPY;
570 valid = FALSE;
571 #else
572 if (p[result] == 27) { /* escape character */
573 wpng_info.have_text &= ~TEXT_COPY;
574 valid = FALSE;
575 }
576 #endif
577 }
578 }
579 } while (!valid);
580
581 do {
582 valid = TRUE;
583 p = textbuf + TEXT_EMAIL_OFFSET;
584 fprintf(stderr, " E-mail: ");
585 fflush(stderr);
586 if (FGETS(p, 74, keybd) && (len = strlen(p)) > 1) {
587 if (p[len-1] == '\n')
588 p[--len] = '\0';
589 wpng_info.email = p;
590 wpng_info.have_text |= TEXT_EMAIL;
591 if ((result = wpng_isvalid_latin1((uch *)p, len)) >= 0) {
592 fprintf(stderr, " " PROGNAME " warning: character code"
593 " %u is %sdiscouraged by the PNG\n specification "
594 "[first occurrence was at character position #%d]\n",
595 (unsigned)p[result], (p[result] == 27)? "strongly " : "",
596 result+1);
597 fflush(stderr);
598 #ifdef FORBID_LATIN1_CTRL
599 wpng_info.have_text &= ~TEXT_EMAIL;
600 valid = FALSE;
601 #else
602 if (p[result] == 27) { /* escape character */
603 wpng_info.have_text &= ~TEXT_EMAIL;
604 valid = FALSE;
605 }
606 #endif
607 }
608 }
609 } while (!valid);
610
611 do {
612 valid = TRUE;
613 p = textbuf + TEXT_URL_OFFSET;
614 fprintf(stderr, " URL: ");
615 fflush(stderr);
616 if (FGETS(p, 74, keybd) && (len = strlen(p)) > 1) {
617 if (p[len-1] == '\n')
618 p[--len] = '\0';
619 wpng_info.url = p;
620 wpng_info.have_text |= TEXT_URL;
621 if ((result = wpng_isvalid_latin1((uch *)p, len)) >= 0) {
622 fprintf(stderr, " " PROGNAME " warning: character code"
623 " %u is %sdiscouraged by the PNG\n specification "
624 "[first occurrence was at character position #%d]\n",
625 (unsigned)p[result], (p[result] == 27)? "strongly " : "",
626 result+1);
627 fflush(stderr);
628 #ifdef FORBID_LATIN1_CTRL
629 wpng_info.have_text &= ~TEXT_URL;
630 valid = FALSE;
631 #else
632 if (p[result] == 27) { /* escape character */
633 wpng_info.have_text &= ~TEXT_URL;
634 valid = FALSE;
635 }
636 #endif
637 }
638 }
639 } while (!valid);
640
641 #ifndef DOS_OS2_W32
642 fclose(keybd);
643 #endif
644
645 } else if (text) {
646 fprintf(stderr, PROGNAME ": unable to allocate memory for text\n");
647 text = FALSE;
648 wpng_info.have_text = 0;
649 }
650
651
652 /* allocate libpng stuff, initialize transformations, write pre-IDAT data */
653
654 if ((rc = writepng_init(&wpng_info)) != 0) {
655 switch (rc) {
656 case 2:
657 fprintf(stderr, PROGNAME
658 ": libpng initialization problem (longjmp)\n");
659 break;
660 case 4:
661 fprintf(stderr, PROGNAME ": insufficient memory\n");
662 break;
663 case 11:
664 fprintf(stderr, PROGNAME
665 ": internal logic error (unexpected PNM type)\n");
666 break;
667 default:
668 fprintf(stderr, PROGNAME
669 ": unknown writepng_init() error\n");
670 break;
671 }
672 exit(rc);
673 }
674
675
676 /* free textbuf, since it's a completely local variable and all text info
677 * has just been written to the PNG file */
678
679 if (text && textbuf) {
680 free(textbuf);
681 textbuf = NULL;
682 }
683
684
685 /* calculate rowbytes on basis of image type; note that this becomes much
686 * more complicated if we choose to support PBM type, ASCII PNM types, or
687 * 16-bit-per-sample binary data [currently not an official NetPBM type] */
688
689 if (wpng_info.pnmtype == 5)
690 rowbytes = wpng_info.width;
691 else if (wpng_info.pnmtype == 6)
692 rowbytes = wpng_info.width * 3;
693 else /* if (wpng_info.pnmtype == 8) */
694 rowbytes = wpng_info.width * 4;
695
696
697 /* read and write the image, either in its entirety (if writing interlaced
698 * PNG) or row by row (if non-interlaced) */
699
700 fprintf(stderr, "Encoding image data...\n");
701 fflush(stderr);
702
703 if (wpng_info.interlaced) {
704 long i;
705 ulg bytes;
706 ulg image_bytes;
707
708 /* Guard against integer overflow */
709 if (wpng_info_height > ((size_t)(-1)/rowbytes ||
710 wpng_info_height > ((ulg)(-1)/rowbytes) {
711 fprintf(stderr, PROGNAME ": image_data buffer too large\n");
712 writepng_cleanup(&wpng_info);
713 wpng_cleanup();
714 exit(5);
715 }
716
717 image_bytes = rowbytes * wpng_info.height;
718
719 wpng_info.image_data = (uch *)malloc(image_bytes);
720 wpng_info.row_pointers = (uch **)malloc(wpng_info.height*sizeof(uch *));
721 if (wpng_info.image_data == NULL || wpng_info.row_pointers == NULL) {
722 fprintf(stderr, PROGNAME ": insufficient memory for image data\n");
723 writepng_cleanup(&wpng_info);
724 wpng_cleanup();
725 exit(5);
726 }
727 for (i = 0; i < wpng_info.height; ++i)
728 wpng_info.row_pointers[i] = wpng_info.image_data + i*rowbytes;
729 bytes = fread(wpng_info.image_data, 1, image_bytes, wpng_info.infile);
730 if (bytes != image_bytes) {
731 fprintf(stderr, PROGNAME ": expected %lu bytes, got %lu bytes\n",
732 image_bytes, bytes);
733 fprintf(stderr, " (continuing anyway)\n");
734 }
735 if (writepng_encode_image(&wpng_info) != 0) {
736 fprintf(stderr, PROGNAME
737 ": libpng problem (longjmp) while writing image data\n");
738 writepng_cleanup(&wpng_info);
739 wpng_cleanup();
740 exit(2);
741 }
742
743 } else /* not interlaced: write progressively (row by row) */ {
744 long j;
745 ulg bytes;
746
747 wpng_info.image_data = (uch *)malloc(rowbytes);
748 if (wpng_info.image_data == NULL) {
749 fprintf(stderr, PROGNAME ": insufficient memory for row data\n");
750 writepng_cleanup(&wpng_info);
751 wpng_cleanup();
752 exit(5);
753 }
754 error = 0;
755 for (j = wpng_info.height; j > 0L; --j) {
756 bytes = fread(wpng_info.image_data, 1, rowbytes, wpng_info.infile);
757 if (bytes != rowbytes) {
758 fprintf(stderr, PROGNAME
759 ": expected %lu bytes, got %lu bytes (row %ld)\n", rowbytes,
760 bytes, wpng_info.height-j);
761 ++error;
762 break;
763 }
764 if (writepng_encode_row(&wpng_info) != 0) {
765 fprintf(stderr, PROGNAME
766 ": libpng problem (longjmp) while writing row %ld\n",
767 wpng_info.height-j);
768 ++error;
769 break;
770 }
771 }
772 if (error) {
773 writepng_cleanup(&wpng_info);
774 wpng_cleanup();
775 exit(2);
776 }
777 if (writepng_encode_finish(&wpng_info) != 0) {
778 fprintf(stderr, PROGNAME ": error on final libpng call\n");
779 writepng_cleanup(&wpng_info);
780 wpng_cleanup();
781 exit(2);
782 }
783 }
784
785
786 /* OK, we're done (successfully): clean up all resources and quit */
787
788 fprintf(stderr, "Done.\n");
789 fflush(stderr);
790
791 writepng_cleanup(&wpng_info);
792 wpng_cleanup();
793
794 return 0;
795 }
796
797
798
799
800
801 static int wpng_isvalid_latin1(uch *p, int len)
802 {
803 int i, result = -1;
804
805 for (i = 0; i < len; ++i) {
806 if (p[i] == 10 || (p[i] > 31 && p[i] < 127) || p[i] > 160)
807 continue; /* character is completely OK */
808 if (result < 0 || (p[result] != 27 && p[i] == 27))
809 result = i; /* mark location of first questionable one */
810 } /* or of first escape character (bad) */
811
812 return result;
813 }
814
815
816
817
818
819 static void wpng_cleanup(void)
820 {
821 if (wpng_info.outfile) {
822 fclose(wpng_info.outfile);
823 wpng_info.outfile = NULL;
824 }
825
826 if (wpng_info.infile) {
827 fclose(wpng_info.infile);
828 wpng_info.infile = NULL;
829 }
830
831 if (wpng_info.image_data) {
832 free(wpng_info.image_data);
833 wpng_info.image_data = NULL;
834 }
835
836 if (wpng_info.row_pointers) {
837 free(wpng_info.row_pointers);
838 wpng_info.row_pointers = NULL;
839 }
840 }
841
842
843
844
845 #ifdef DOS_OS2_W32
846
847 static char *dos_kbd_gets(char *buf, int len)
848 {
849 int ch, count=0;
850
851 do {
852 buf[count++] = ch = getche();
853 } while (ch != '\r' && count < len-1);
854
855 buf[count--] = '\0'; /* terminate string */
856 if (buf[count] == '\r') /* Enter key makes CR, so change to newline */
857 buf[count] = '\n';
858
859 fprintf(stderr, "\n"); /* Enter key does *not* cause a newline */
860 fflush(stderr);
861
862 return buf;
863 }
864
865 #endif /* DOS_OS2_W32 */