Improve single-threaded operation. It's now safe(r?) to close a canvas while it...
[synfig.git] / gtkmm-osx / trunk / libpng-1.2.5 / contrib / gregbook / readpng.c
1 /*---------------------------------------------------------------------------
2
3    rpng - simple PNG display program                              readpng.c
4
5   ---------------------------------------------------------------------------
6
7       Copyright (c) 1998-2000 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       Permission is granted to anyone to use this software for any purpose,
15       including commercial applications, and to alter it and redistribute
16       it freely, subject to the following restrictions:
17
18       1. Redistributions of source code must retain the above copyright
19          notice, disclaimer, and this list of conditions.
20       2. Redistributions in binary form must reproduce the above copyright
21          notice, disclaimer, and this list of conditions in the documenta-
22          tion and/or other materials provided with the distribution.
23       3. All advertising materials mentioning features or use of this
24          software must display the following acknowledgment:
25
26             This product includes software developed by Greg Roelofs
27             and contributors for the book, "PNG: The Definitive Guide,"
28             published by O'Reilly and Associates.
29
30   ---------------------------------------------------------------------------*/
31
32 #include <stdio.h>
33 #include <stdlib.h>
34
35 #include "png.h"        /* libpng header; includes zlib.h */
36 #include "readpng.h"    /* typedefs, common macros, public prototypes */
37
38 /* future versions of libpng will provide this macro: */
39 #ifndef png_jmpbuf
40 #  define png_jmpbuf(png_ptr)   ((png_ptr)->jmpbuf)
41 #endif
42
43
44 static png_structp png_ptr = NULL;
45 static png_infop info_ptr = NULL;
46
47 png_uint_32  width, height;
48 int  bit_depth, color_type;
49 uch  *image_data = NULL;
50
51
52 void readpng_version_info(void)
53 {
54     fprintf(stderr, "   Compiled with libpng %s; using libpng %s.\n",
55       PNG_LIBPNG_VER_STRING, png_libpng_ver);
56     fprintf(stderr, "   Compiled with zlib %s; using zlib %s.\n",
57       ZLIB_VERSION, zlib_version);
58 }
59
60
61 /* return value = 0 for success, 1 for bad sig, 2 for bad IHDR, 4 for no mem */
62
63 int readpng_init(FILE *infile, ulg *pWidth, ulg *pHeight)
64 {
65     uch sig[8];
66
67
68     /* first do a quick check that the file really is a PNG image; could
69      * have used slightly more general png_sig_cmp() function instead */
70
71     fread(sig, 1, 8, infile);
72     if (!png_check_sig(sig, 8))
73         return 1;   /* bad signature */
74
75
76     /* could pass pointers to user-defined error handlers instead of NULLs: */
77
78     png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
79     if (!png_ptr)
80         return 4;   /* out of memory */
81
82     info_ptr = png_create_info_struct(png_ptr);
83     if (!info_ptr) {
84         png_destroy_read_struct(&png_ptr, NULL, NULL);
85         return 4;   /* out of memory */
86     }
87
88
89     /* we could create a second info struct here (end_info), but it's only
90      * useful if we want to keep pre- and post-IDAT chunk info separated
91      * (mainly for PNG-aware image editors and converters) */
92
93
94     /* setjmp() must be called in every function that calls a PNG-reading
95      * libpng function */
96
97     if (setjmp(png_jmpbuf(png_ptr))) {
98         png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
99         return 2;
100     }
101
102
103     png_init_io(png_ptr, infile);
104     png_set_sig_bytes(png_ptr, 8);  /* we already read the 8 signature bytes */
105
106     png_read_info(png_ptr, info_ptr);  /* read all PNG info up to image data */
107
108
109     /* alternatively, could make separate calls to png_get_image_width(),
110      * etc., but want bit_depth and color_type for later [don't care about
111      * compression_type and filter_type => NULLs] */
112
113     png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
114       NULL, NULL, NULL);
115     *pWidth = width;
116     *pHeight = height;
117
118
119     /* OK, that's all we need for now; return happy */
120
121     return 0;
122 }
123
124
125
126
127 /* returns 0 if succeeds, 1 if fails due to no bKGD chunk, 2 if libpng error;
128  * scales values to 8-bit if necessary */
129
130 int readpng_get_bgcolor(uch *red, uch *green, uch *blue)
131 {
132     png_color_16p pBackground;
133
134
135     /* setjmp() must be called in every function that calls a PNG-reading
136      * libpng function */
137
138     if (setjmp(png_jmpbuf(png_ptr))) {
139         png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
140         return 2;
141     }
142
143
144     if (!png_get_valid(png_ptr, info_ptr, PNG_INFO_bKGD))
145         return 1;
146
147     /* it is not obvious from the libpng documentation, but this function
148      * takes a pointer to a pointer, and it always returns valid red, green
149      * and blue values, regardless of color_type: */
150
151     png_get_bKGD(png_ptr, info_ptr, &pBackground);
152
153
154     /* however, it always returns the raw bKGD data, regardless of any
155      * bit-depth transformations, so check depth and adjust if necessary */
156
157     if (bit_depth == 16) {
158         *red   = pBackground->red   >> 8;
159         *green = pBackground->green >> 8;
160         *blue  = pBackground->blue  >> 8;
161     } else if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) {
162         if (bit_depth == 1)
163             *red = *green = *blue = pBackground->gray? 255 : 0;
164         else if (bit_depth == 2)
165             *red = *green = *blue = (255/3) * pBackground->gray;
166         else /* bit_depth == 4 */
167             *red = *green = *blue = (255/15) * pBackground->gray;
168     } else {
169         *red   = (uch)pBackground->red;
170         *green = (uch)pBackground->green;
171         *blue  = (uch)pBackground->blue;
172     }
173
174     return 0;
175 }
176
177
178
179
180 /* display_exponent == LUT_exponent * CRT_exponent */
181
182 uch *readpng_get_image(double display_exponent, int *pChannels, ulg *pRowbytes)
183 {
184     double  gamma;
185     png_uint_32  i, rowbytes;
186     png_bytepp  row_pointers = NULL;
187
188
189     /* setjmp() must be called in every function that calls a PNG-reading
190      * libpng function */
191
192     if (setjmp(png_jmpbuf(png_ptr))) {
193         png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
194         return NULL;
195     }
196
197
198     /* expand palette images to RGB, low-bit-depth grayscale images to 8 bits,
199      * transparency chunks to full alpha channel; strip 16-bit-per-sample
200      * images to 8 bits per sample; and convert grayscale to RGB[A] */
201
202     if (color_type == PNG_COLOR_TYPE_PALETTE)
203         png_set_expand(png_ptr);
204     if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
205         png_set_expand(png_ptr);
206     if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
207         png_set_expand(png_ptr);
208     if (bit_depth == 16)
209         png_set_strip_16(png_ptr);
210     if (color_type == PNG_COLOR_TYPE_GRAY ||
211         color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
212         png_set_gray_to_rgb(png_ptr);
213
214
215     /* unlike the example in the libpng documentation, we have *no* idea where
216      * this file may have come from--so if it doesn't have a file gamma, don't
217      * do any correction ("do no harm") */
218
219     if (png_get_gAMA(png_ptr, info_ptr, &gamma))
220         png_set_gamma(png_ptr, display_exponent, gamma);
221
222
223     /* all transformations have been registered; now update info_ptr data,
224      * get rowbytes and channels, and allocate image memory */
225
226     png_read_update_info(png_ptr, info_ptr);
227
228     *pRowbytes = rowbytes = png_get_rowbytes(png_ptr, info_ptr);
229     *pChannels = (int)png_get_channels(png_ptr, info_ptr);
230
231     if ((image_data = (uch *)malloc(rowbytes*height)) == NULL) {
232         png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
233         return NULL;
234     }
235     if ((row_pointers = (png_bytepp)malloc(height*sizeof(png_bytep))) == NULL) {
236         png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
237         free(image_data);
238         image_data = NULL;
239         return NULL;
240     }
241
242     Trace((stderr, "readpng_get_image:  channels = %d, rowbytes = %ld, height = %ld\n", *pChannels, rowbytes, height));
243
244
245     /* set the individual row_pointers to point at the correct offsets */
246
247     for (i = 0;  i < height;  ++i)
248         row_pointers[i] = image_data + i*rowbytes;
249
250
251     /* now we can go ahead and just read the whole image */
252
253     png_read_image(png_ptr, row_pointers);
254
255
256     /* and we're done!  (png_read_end() can be omitted if no processing of
257      * post-IDAT text/time/etc. is desired) */
258
259     free(row_pointers);
260     row_pointers = NULL;
261
262     png_read_end(png_ptr, NULL);
263
264     return image_data;
265 }
266
267
268 void readpng_cleanup(int free_image_data)
269 {
270     if (free_image_data && image_data) {
271         free(image_data);
272         image_data = NULL;
273     }
274
275     if (png_ptr && info_ptr) {
276         png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
277         png_ptr = NULL;
278         info_ptr = NULL;
279     }
280 }