1/*---------------------------------------------------------------------------
2
3   rpng2 - progressive-model PNG display program                 readpng2.c
4
5  ---------------------------------------------------------------------------
6
7      Copyright (c) 1998-2015 Greg Roelofs.  All rights reserved.
8
9      This software is provided "as is," without warranty of any kind,
10      express or implied.  In no event shall the author or contributors
11      be held liable for any damages arising in any way from the use of
12      this software.
13
14      The contents of this file are DUAL-LICENSED.  You may modify and/or
15      redistribute this software according to the terms of one of the
16      following two licenses (at your option):
17
18
19      LICENSE 1 ("BSD-like with advertising clause"):
20
21      Permission is granted to anyone to use this software for any purpose,
22      including commercial applications, and to alter it and redistribute
23      it freely, subject to the following restrictions:
24
25      1. Redistributions of source code must retain the above copyright
26         notice, disclaimer, and this list of conditions.
27      2. Redistributions in binary form must reproduce the above copyright
28         notice, disclaimer, and this list of conditions in the documenta-
29         tion and/or other materials provided with the distribution.
30      3. All advertising materials mentioning features or use of this
31         software must display the following acknowledgment:
32
33            This product includes software developed by Greg Roelofs
34            and contributors for the book, "PNG: The Definitive Guide,"
35            published by O'Reilly and Associates.
36
37
38      LICENSE 2 (GNU GPL v2 or later):
39
40      This program is free software; you can redistribute it and/or modify
41      it under the terms of the GNU General Public License as published by
42      the Free Software Foundation; either version 2 of the License, or
43      (at your option) any later version.
44
45      This program is distributed in the hope that it will be useful,
46      but WITHOUT ANY WARRANTY; without even the implied warranty of
47      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
48      GNU General Public License for more details.
49
50      You should have received a copy of the GNU General Public License
51      along with this program; if not, write to the Free Software Foundation,
52      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
53
54  ---------------------------------------------------------------------------
55
56   Changelog:
57     %RDATE% - Check return value of png_get_bKGD() (Glenn R-P)
58
59  ---------------------------------------------------------------------------*/
60
61
62#include <stdlib.h>     /* for exit() prototype */
63#include <setjmp.h>
64
65#include <zlib.h>
66#include "png.h"        /* libpng header from the local directory */
67#include "readpng2.h"   /* typedefs, common macros, public prototypes */
68
69
70/* local prototypes */
71
72static void readpng2_info_callback(png_structp png_ptr, png_infop info_ptr);
73static void readpng2_row_callback(png_structp png_ptr, png_bytep new_row,
74                                 png_uint_32 row_num, int pass);
75static void readpng2_end_callback(png_structp png_ptr, png_infop info_ptr);
76static void readpng2_error_handler(png_structp png_ptr, png_const_charp msg);
77static void readpng2_warning_handler(png_structp png_ptr, png_const_charp msg);
78
79
80
81
82void readpng2_version_info(void)
83{
84    fprintf(stderr, "   Compiled with libpng %s; using libpng %s\n",
85      PNG_LIBPNG_VER_STRING, png_libpng_ver);
86
87    fprintf(stderr, "   and with zlib %s; using zlib %s.\n",
88      ZLIB_VERSION, zlib_version);
89}
90
91
92
93
94int readpng2_check_sig(uch *sig, int num)
95{
96    return !png_sig_cmp(sig, 0, num);
97}
98
99
100
101
102/* returns 0 for success, 2 for libpng problem, 4 for out of memory */
103
104int readpng2_init(mainprog_info *mainprog_ptr)
105{
106    png_structp  png_ptr;       /* note:  temporary variables! */
107    png_infop  info_ptr;
108
109
110    /* could also replace libpng warning-handler (final NULL), but no need: */
111
112    png_ptr = png_create_read_struct(png_get_libpng_ver(NULL), mainprog_ptr,
113      readpng2_error_handler, readpng2_warning_handler);
114    if (!png_ptr)
115        return 4;   /* out of memory */
116
117    info_ptr = png_create_info_struct(png_ptr);
118    if (!info_ptr) {
119        png_destroy_read_struct(&png_ptr, NULL, NULL);
120        return 4;   /* out of memory */
121    }
122
123
124    /* we could create a second info struct here (end_info), but it's only
125     * useful if we want to keep pre- and post-IDAT chunk info separated
126     * (mainly for PNG-aware image editors and converters) */
127
128
129    /* setjmp() must be called in every function that calls a PNG-reading
130     * libpng function, unless an alternate error handler was installed--
131     * but compatible error handlers must either use longjmp() themselves
132     * (as in this program) or exit immediately, so here we are: */
133
134    if (setjmp(mainprog_ptr->jmpbuf)) {
135        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
136        return 2;
137    }
138
139
140#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
141    /* prepare the reader to ignore all recognized chunks whose data won't be
142     * used, i.e., all chunks recognized by libpng except for IHDR, PLTE, IDAT,
143     * IEND, tRNS, bKGD, gAMA, and sRGB (small performance improvement) */
144    {
145        /* These byte strings were copied from png.h.  If a future version
146         * of readpng2.c recognizes more chunks, add them to this list.
147         */
148        static PNG_CONST png_byte chunks_to_process[] = {
149            98,  75,  71,  68, '\0',  /* bKGD */
150           103,  65,  77,  65, '\0',  /* gAMA */
151           115,  82,  71,  66, '\0',  /* sRGB */
152           };
153
154       /* Ignore all chunks except for IHDR, PLTE, tRNS, IDAT, and IEND */
155       png_set_keep_unknown_chunks(png_ptr, -1 /* PNG_HANDLE_CHUNK_NEVER */,
156          NULL, -1);
157
158       /* But do not ignore chunks in the "chunks_to_process" list */
159       png_set_keep_unknown_chunks(png_ptr,
160          0 /* PNG_HANDLE_CHUNK_AS_DEFAULT */, chunks_to_process,
161          sizeof(chunks_to_process)/5);
162    }
163#endif /* PNG_HANDLE_AS_UNKNOWN_SUPPORTED */
164
165
166    /* instead of doing png_init_io() here, now we set up our callback
167     * functions for progressive decoding */
168
169    png_set_progressive_read_fn(png_ptr, mainprog_ptr,
170      readpng2_info_callback, readpng2_row_callback, readpng2_end_callback);
171
172
173    /* make sure we save our pointers for use in readpng2_decode_data() */
174
175    mainprog_ptr->png_ptr = png_ptr;
176    mainprog_ptr->info_ptr = info_ptr;
177
178
179    /* and that's all there is to initialization */
180
181    return 0;
182}
183
184
185
186
187/* returns 0 for success, 2 for libpng (longjmp) problem */
188
189int readpng2_decode_data(mainprog_info *mainprog_ptr, uch *rawbuf, ulg length)
190{
191    png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
192    png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
193
194
195    /* setjmp() must be called in every function that calls a PNG-reading
196     * libpng function */
197
198    if (setjmp(mainprog_ptr->jmpbuf)) {
199        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
200        mainprog_ptr->png_ptr = NULL;
201        mainprog_ptr->info_ptr = NULL;
202        return 2;
203    }
204
205
206    /* hand off the next chunk of input data to libpng for decoding */
207
208    png_process_data(png_ptr, info_ptr, rawbuf, length);
209
210    return 0;
211}
212
213
214
215
216static void readpng2_info_callback(png_structp png_ptr, png_infop info_ptr)
217{
218    mainprog_info  *mainprog_ptr;
219    int  color_type, bit_depth;
220    png_uint_32 width, height;
221#ifdef PNG_FLOATING_POINT_SUPPORTED
222    double  gamma;
223#else
224    png_fixed_point gamma;
225#endif
226
227
228    /* setjmp() doesn't make sense here, because we'd either have to exit(),
229     * longjmp() ourselves, or return control to libpng, which doesn't want
230     * to see us again.  By not doing anything here, libpng will instead jump
231     * to readpng2_decode_data(), which can return an error value to the main
232     * program. */
233
234
235    /* retrieve the pointer to our special-purpose struct, using the png_ptr
236     * that libpng passed back to us (i.e., not a global this time--there's
237     * no real difference for a single image, but for a multithreaded browser
238     * decoding several PNG images at the same time, one needs to avoid mixing
239     * up different images' structs) */
240
241    mainprog_ptr = png_get_progressive_ptr(png_ptr);
242
243    if (mainprog_ptr == NULL) {         /* we be hosed */
244        fprintf(stderr,
245          "readpng2 error:  main struct not recoverable in info_callback.\n");
246        fflush(stderr);
247        return;
248        /*
249         * Alternatively, we could call our error-handler just like libpng
250         * does, which would effectively terminate the program.  Since this
251         * can only happen if png_ptr gets redirected somewhere odd or the
252         * main PNG struct gets wiped, we're probably toast anyway.  (If
253         * png_ptr itself is NULL, we would not have been called.)
254         */
255    }
256
257
258    /* this is just like in the non-progressive case */
259
260    png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
261       NULL, NULL, NULL);
262    mainprog_ptr->width = (ulg)width;
263    mainprog_ptr->height = (ulg)height;
264
265
266    /* since we know we've read all of the PNG file's "header" (i.e., up
267     * to IDAT), we can check for a background color here */
268
269    if (mainprog_ptr->need_bgcolor)
270    {
271        png_color_16p pBackground;
272
273        /* it is not obvious from the libpng documentation, but this function
274         * takes a pointer to a pointer, and it always returns valid red,
275         * green and blue values, regardless of color_type: */
276        if (png_get_bKGD(png_ptr, info_ptr, &pBackground))
277        {
278
279           /* however, it always returns the raw bKGD data, regardless of any
280            * bit-depth transformations, so check depth and adjust if necessary
281            */
282           if (bit_depth == 16) {
283               mainprog_ptr->bg_red   = pBackground->red   >> 8;
284               mainprog_ptr->bg_green = pBackground->green >> 8;
285               mainprog_ptr->bg_blue  = pBackground->blue  >> 8;
286           } else if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) {
287               if (bit_depth == 1)
288                   mainprog_ptr->bg_red = mainprog_ptr->bg_green =
289                     mainprog_ptr->bg_blue = pBackground->gray? 255 : 0;
290               else if (bit_depth == 2)
291                   mainprog_ptr->bg_red = mainprog_ptr->bg_green =
292                     mainprog_ptr->bg_blue = (255/3) * pBackground->gray;
293               else /* bit_depth == 4 */
294                   mainprog_ptr->bg_red = mainprog_ptr->bg_green =
295                     mainprog_ptr->bg_blue = (255/15) * pBackground->gray;
296           } else {
297               mainprog_ptr->bg_red   = (uch)pBackground->red;
298               mainprog_ptr->bg_green = (uch)pBackground->green;
299               mainprog_ptr->bg_blue  = (uch)pBackground->blue;
300           }
301        }
302    }
303
304
305    /* as before, let libpng expand palette images to RGB, low-bit-depth
306     * grayscale images to 8 bits, transparency chunks to full alpha channel;
307     * strip 16-bit-per-sample images to 8 bits per sample; and convert
308     * grayscale to RGB[A] */
309
310    if (color_type == PNG_COLOR_TYPE_PALETTE)
311        png_set_expand(png_ptr);
312    if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
313        png_set_expand(png_ptr);
314    if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
315        png_set_expand(png_ptr);
316#ifdef PNG_READ_16_TO_8_SUPPORTED
317    if (bit_depth == 16)
318#  ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
319        png_set_scale_16(png_ptr);
320#  else
321        png_set_strip_16(png_ptr);
322#  endif
323#endif
324    if (color_type == PNG_COLOR_TYPE_GRAY ||
325        color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
326        png_set_gray_to_rgb(png_ptr);
327
328
329    /* Unlike the basic viewer, which was designed to operate on local files,
330     * this program is intended to simulate a web browser--even though we
331     * actually read from a local file, too.  But because we are pretending
332     * that most of the images originate on the Internet, we follow the recom-
333     * mendation of the sRGB proposal and treat unlabelled images (no gAMA
334     * chunk) as existing in the sRGB color space.  That is, we assume that
335     * such images have a file gamma of 0.45455, which corresponds to a PC-like
336     * display system.  This change in assumptions will have no effect on a
337     * PC-like system, but on a Mac, SGI, NeXT or other system with a non-
338     * identity lookup table, it will darken unlabelled images, which effec-
339     * tively favors images from PC-like systems over those originating on
340     * the local platform.  Note that mainprog_ptr->display_exponent is the
341     * "gamma" value for the entire display system, i.e., the product of
342     * LUT_exponent and CRT_exponent. */
343
344#ifdef PNG_FLOATING_POINT_SUPPORTED
345    if (png_get_gAMA(png_ptr, info_ptr, &gamma))
346        png_set_gamma(png_ptr, mainprog_ptr->display_exponent, gamma);
347    else
348        png_set_gamma(png_ptr, mainprog_ptr->display_exponent, 0.45455);
349#else
350    if (png_get_gAMA_fixed(png_ptr, info_ptr, &gamma))
351        png_set_gamma_fixed(png_ptr,
352            (png_fixed_point)(100000*mainprog_ptr->display_exponent+.5), gamma);
353    else
354        png_set_gamma_fixed(png_ptr,
355            (png_fixed_point)(100000*mainprog_ptr->display_exponent+.5), 45455);
356#endif
357
358    /* we'll let libpng expand interlaced images, too */
359
360    mainprog_ptr->passes = png_set_interlace_handling(png_ptr);
361
362
363    /* all transformations have been registered; now update info_ptr data and
364     * then get rowbytes and channels */
365
366    png_read_update_info(png_ptr, info_ptr);
367
368    mainprog_ptr->rowbytes = (int)png_get_rowbytes(png_ptr, info_ptr);
369    mainprog_ptr->channels = png_get_channels(png_ptr, info_ptr);
370
371
372    /* Call the main program to allocate memory for the image buffer and
373     * initialize windows and whatnot.  (The old-style function-pointer
374     * invocation is used for compatibility with a few supposedly ANSI
375     * compilers that nevertheless barf on "fn_ptr()"-style syntax.) */
376
377    (*mainprog_ptr->mainprog_init)();
378
379
380    /* and that takes care of initialization */
381
382    return;
383}
384
385
386
387
388
389static void readpng2_row_callback(png_structp png_ptr, png_bytep new_row,
390                                  png_uint_32 row_num, int pass)
391{
392    mainprog_info  *mainprog_ptr;
393
394
395    /* first check whether the row differs from the previous pass; if not,
396     * nothing to combine or display */
397
398    if (!new_row)
399        return;
400
401
402    /* retrieve the pointer to our special-purpose struct so we can access
403     * the old rows and image-display callback function */
404
405    mainprog_ptr = png_get_progressive_ptr(png_ptr);
406
407
408    /* save the pass number for optional use by the front end */
409
410    mainprog_ptr->pass = pass;
411
412
413    /* have libpng either combine the new row data with the existing row data
414     * from previous passes (if interlaced) or else just copy the new row
415     * into the main program's image buffer */
416
417    png_progressive_combine_row(png_ptr, mainprog_ptr->row_pointers[row_num],
418      new_row);
419
420
421    /* finally, call the display routine in the main program with the number
422     * of the row we just updated */
423
424    (*mainprog_ptr->mainprog_display_row)(row_num);
425
426
427    /* and we're ready for more */
428
429    return;
430}
431
432
433
434
435
436static void readpng2_end_callback(png_structp png_ptr, png_infop info_ptr)
437{
438    mainprog_info  *mainprog_ptr;
439
440
441    /* retrieve the pointer to our special-purpose struct */
442
443    mainprog_ptr = png_get_progressive_ptr(png_ptr);
444
445
446    /* let the main program know that it should flush any buffered image
447     * data to the display now and set a "done" flag or whatever, but note
448     * that it SHOULD NOT DESTROY THE PNG STRUCTS YET--in other words, do
449     * NOT call readpng2_cleanup() either here or in the finish_display()
450     * routine; wait until control returns to the main program via
451     * readpng2_decode_data() */
452
453    (*mainprog_ptr->mainprog_finish_display)();
454
455
456    /* all done */
457
458    (void)info_ptr; /* Unused */
459
460    return;
461}
462
463
464
465
466
467void readpng2_cleanup(mainprog_info *mainprog_ptr)
468{
469    png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
470    png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
471
472    if (png_ptr && info_ptr)
473        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
474
475    mainprog_ptr->png_ptr = NULL;
476    mainprog_ptr->info_ptr = NULL;
477}
478
479
480static void readpng2_warning_handler(png_structp png_ptr, png_const_charp msg)
481{
482    fprintf(stderr, "readpng2 libpng warning: %s\n", msg);
483    fflush(stderr);
484    (void)png_ptr; /* Unused */
485}
486
487
488static void readpng2_error_handler(png_structp png_ptr, png_const_charp msg)
489{
490    mainprog_info  *mainprog_ptr;
491
492    /* This function, aside from the extra step of retrieving the "error
493     * pointer" (below) and the fact that it exists within the application
494     * rather than within libpng, is essentially identical to libpng's
495     * default error handler.  The second point is critical:  since both
496     * setjmp() and longjmp() are called from the same code, they are
497     * guaranteed to have compatible notions of how big a jmp_buf is,
498     * regardless of whether _BSD_SOURCE or anything else has (or has not)
499     * been defined. */
500
501    fprintf(stderr, "readpng2 libpng error: %s\n", msg);
502    fflush(stderr);
503
504    mainprog_ptr = png_get_error_ptr(png_ptr);
505    if (mainprog_ptr == NULL) {         /* we are completely hosed now */
506        fprintf(stderr,
507          "readpng2 severe error:  jmpbuf not recoverable; terminating.\n");
508        fflush(stderr);
509        exit(99);
510    }
511
512    /* Now we have our data structure we can use the information in it
513     * to return control to our own higher level code (all the points
514     * where 'setjmp' is called in this file.)  This will work with other
515     * error handling mechanisms as well - libpng always calls png_error
516     * when it can proceed no further, thus, so long as the error handler
517     * is intercepted, application code can do its own error recovery.
518     */
519    longjmp(mainprog_ptr->jmpbuf, 1);
520}
521