1 /*---------------------------------------------------------------------------
2
3 rpng - simple PNG display program readpng.c
4
5 ---------------------------------------------------------------------------
6
7 Copyright (c) 1998-2007,2017 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 #include <stdio.h>
57 #include <stdlib.h>
58 #include <zlib.h>
59
60 #include "png.h" /* libpng header */
61 #include "readpng.h" /* typedefs, common macros, public prototypes */
62
63 /* future versions of libpng will provide this macro: */
64 #ifndef png_jmpbuf
65 # define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
66 #endif
67
68
69 static png_structp png_ptr = NULL;
70 static png_infop info_ptr = NULL;
71
72 png_uint_32 width, height;
73 int bit_depth, color_type;
74 uch *image_data = NULL;
75
76
77 void readpng_version_info(void)
78 {
79 fprintf(stderr, " Compiled with libpng %s; using libpng %s.\n",
80 PNG_LIBPNG_VER_STRING, png_libpng_ver);
81 fprintf(stderr, " Compiled with zlib %s; using zlib %s.\n",
82 ZLIB_VERSION, zlib_version);
83 }
84
85
86 /* return value = 0 for success, 1 for bad sig, 2 for bad IHDR, 4 for no mem */
87
88 int readpng_init(FILE *infile, ulg *pWidth, ulg *pHeight)
89 {
90 uch sig[8];
91
92
93 /* first do a quick check that the file really is a PNG image; could
94 * have used slightly more general png_sig_cmp() function instead */
95
96 fread(sig, 1, 8, infile);
97 if (png_sig_cmp(sig, 0, 8))
98 return 1; /* bad signature */
99
100
101 /* could pass pointers to user-defined error handlers instead of NULLs: */
102
103 png_ptr = png_create_read_struct(png_get_libpng_ver(NULL), NULL, NULL,
104 NULL);
105 if (!png_ptr)
106 return 4; /* out of memory */
107
108 info_ptr = png_create_info_struct(png_ptr);
109 if (!info_ptr) {
110 png_destroy_read_struct(&png_ptr, NULL, NULL);
111 return 4; /* out of memory */
112 }
113
114
115 /* we could create a second info struct here (end_info), but it's only
116 * useful if we want to keep pre- and post-IDAT chunk info separated
117 * (mainly for PNG-aware image editors and converters) */
118
119
120 /* setjmp() must be called in every function that calls a PNG-reading
121 * libpng function */
122
123 if (setjmp(png_jmpbuf(png_ptr))) {
124 png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
125 return 2;
126 }
127
128
129 png_init_io(png_ptr, infile);
130 png_set_sig_bytes(png_ptr, 8); /* we already read the 8 signature bytes */
131
132 png_read_info(png_ptr, info_ptr); /* read all PNG info up to image data */
133
134
135 /* alternatively, could make separate calls to png_get_image_width(),
136 * etc., but want bit_depth and color_type for later [don't care about
137 * compression_type and filter_type => NULLs] */
138
139 png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
140 NULL, NULL, NULL);
141 *pWidth = width;
142 *pHeight = height;
143
144
145 /* OK, that's all we need for now; return happy */
146
147 return 0;
148 }
149
150
151
152
153 /* returns 0 if succeeds, 1 if fails due to no bKGD chunk, 2 if libpng error;
154 * scales values to 8-bit if necessary */
155
156 int readpng_get_bgcolor(uch *red, uch *green, uch *blue)
157 {
158 png_color_16p pBackground;
159
160
161 /* setjmp() must be called in every function that calls a PNG-reading
162 * libpng function */
163
164 if (setjmp(png_jmpbuf(png_ptr))) {
165 png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
166 return 2;
167 }
168
169
170 if (!png_get_valid(png_ptr, info_ptr, PNG_INFO_bKGD))
171 return 1;
172
173 /* it is not obvious from the libpng documentation, but this function
174 * takes a pointer to a pointer, and it always returns valid red, green
175 * and blue values, regardless of color_type: */
176
177 png_get_bKGD(png_ptr, info_ptr, &pBackground);
178
179
180 /* however, it always returns the raw bKGD data, regardless of any
181 * bit-depth transformations, so check depth and adjust if necessary */
182
183 if (bit_depth == 16) {
184 *red = pBackground->red >> 8;
185 *green = pBackground->green >> 8;
186 *blue = pBackground->blue >> 8;
187 } else if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) {
188 if (bit_depth == 1)
189 *red = *green = *blue = pBackground->gray? 255 : 0;
190 else if (bit_depth == 2)
191 *red = *green = *blue = (255/3) * pBackground->gray;
192 else /* bit_depth == 4 */
193 *red = *green = *blue = (255/15) * pBackground->gray;
194 } else {
195 *red = (uch)pBackground->red;
196 *green = (uch)pBackground->green;
197 *blue = (uch)pBackground->blue;
198 }
199
200 return 0;
201 }
202
203
204
205
206 /* display_exponent == LUT_exponent * CRT_exponent */
207
208 uch *readpng_get_image(double display_exponent, int *pChannels, ulg *pRowbytes)
209 {
210 double gamma;
211 png_uint_32 i, rowbytes;
212 png_bytepp row_pointers = NULL;
213
214
215 /* setjmp() must be called in every function that calls a PNG-reading
216 * libpng function */
217
218 if (setjmp(png_jmpbuf(png_ptr))) {
219 free(image_data);
220 image_data = NULL;
221 free(row_pointers);
222 row_pointers = NULL;
223 png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
224 return NULL;
225 }
226
227
228 /* expand palette images to RGB, low-bit-depth grayscale images to 8 bits,
229 * transparency chunks to full alpha channel; strip 16-bit-per-sample
230 * images to 8 bits per sample; and convert grayscale to RGB[A] */
231
232 if (color_type == PNG_COLOR_TYPE_PALETTE)
233 png_set_expand(png_ptr);
234 if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
235 png_set_expand(png_ptr);
236 if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
237 png_set_expand(png_ptr);
238 #ifdef PNG_READ_16_TO_8_SUPPORTED
239 if (bit_depth == 16)
240 # ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
241 png_set_scale_16(png_ptr);
242 # else
243 png_set_strip_16(png_ptr);
244 # endif
245 #endif
246 if (color_type == PNG_COLOR_TYPE_GRAY ||
247 color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
248 png_set_gray_to_rgb(png_ptr);
249
250
251 /* unlike the example in the libpng documentation, we have *no* idea where
252 * this file may have come from--so if it doesn't have a file gamma, don't
253 * do any correction ("do no harm") */
254
255 if (png_get_gAMA(png_ptr, info_ptr, &gamma))
256 png_set_gamma(png_ptr, display_exponent, gamma);
257
258
259 /* all transformations have been registered; now update info_ptr data,
260 * get rowbytes and channels, and allocate image memory */
261
262 png_read_update_info(png_ptr, info_ptr);
263
264 *pRowbytes = rowbytes = png_get_rowbytes(png_ptr, info_ptr);
265 *pChannels = (int)png_get_channels(png_ptr, info_ptr);
266
267 /* Guard against integer overflow */
268 if (height > ((size_t)(-1))/rowbytes) {
269 fprintf(stderr, "readpng: image_data buffer would be too large\n",
270 return NULL;
271 }
272
273 if ((image_data = (uch *)malloc(rowbytes*height)) == NULL) {
274 png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
275 return NULL;
276 }
277 if ((row_pointers = (png_bytepp)malloc(height*sizeof(png_bytep))) == NULL) {
278 png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
279 free(image_data);
280 image_data = NULL;
281 return NULL;
282 }
283
284 Trace((stderr, "readpng_get_image: channels = %d, rowbytes = %ld, height = %ld\n",
285 *pChannels, rowbytes, height));
286
287
288 /* set the individual row_pointers to point at the correct offsets */
289
290 for (i = 0; i < height; ++i)
291 row_pointers[i] = image_data + i*rowbytes;
292
293
294 /* now we can go ahead and just read the whole image */
295
296 png_read_image(png_ptr, row_pointers);
297
298
299 /* and we're done! (png_read_end() can be omitted if no processing of
300 * post-IDAT text/time/etc. is desired) */
301
302 free(row_pointers);
303 row_pointers = NULL;
304
305 png_read_end(png_ptr, NULL);
306
307 return image_data;
308 }
309
310
311 void readpng_cleanup(int free_image_data)
312 {
313 if (free_image_data && image_data) {
314 free(image_data);
315 image_data = NULL;
316 }
317
318 if (png_ptr && info_ptr) {
319 png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
320 png_ptr = NULL;
321 info_ptr = NULL;
322 }
323 }