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