Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
96 | giacomo | 1 | |
2 | /* png.c - location for general purpose libpng functions |
||
3 | * |
||
4 | * libpng version 1.2.5 - October 3, 2002 |
||
5 | * Copyright (c) 1998-2002 Glenn Randers-Pehrson |
||
6 | * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
||
7 | * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
||
8 | * |
||
9 | */ |
||
10 | |||
11 | #define PNG_INTERNAL |
||
12 | #define PNG_NO_EXTERN |
||
13 | #include "png.h" |
||
14 | |||
15 | /* Generate a compiler error if there is an old png.h in the search path. */ |
||
16 | typedef version_1_2_5 Your_png_h_is_not_version_1_2_5; |
||
17 | |||
18 | /* Version information for C files. This had better match the version |
||
19 | * string defined in png.h. */ |
||
20 | |||
21 | #ifdef PNG_USE_GLOBAL_ARRAYS |
||
22 | /* png_libpng_ver was changed to a function in version 1.0.5c */ |
||
23 | const char png_libpng_ver[18] = "1.2.5"; |
||
24 | |||
25 | /* png_sig was changed to a function in version 1.0.5c */ |
||
26 | /* Place to hold the signature string for a PNG file. */ |
||
27 | const png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10}; |
||
28 | |||
29 | /* Invoke global declarations for constant strings for known chunk types */ |
||
30 | PNG_IHDR; |
||
31 | PNG_IDAT; |
||
32 | PNG_IEND; |
||
33 | PNG_PLTE; |
||
34 | PNG_bKGD; |
||
35 | PNG_cHRM; |
||
36 | PNG_gAMA; |
||
37 | PNG_hIST; |
||
38 | PNG_iCCP; |
||
39 | PNG_iTXt; |
||
40 | PNG_oFFs; |
||
41 | PNG_pCAL; |
||
42 | PNG_sCAL; |
||
43 | PNG_pHYs; |
||
44 | PNG_sBIT; |
||
45 | PNG_sPLT; |
||
46 | PNG_sRGB; |
||
47 | PNG_tEXt; |
||
48 | PNG_tIME; |
||
49 | PNG_tRNS; |
||
50 | PNG_zTXt; |
||
51 | |||
52 | /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
||
53 | |||
54 | /* start of interlace block */ |
||
55 | const int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; |
||
56 | |||
57 | /* offset to next interlace block */ |
||
58 | const int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; |
||
59 | |||
60 | /* start of interlace block in the y direction */ |
||
61 | const int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1}; |
||
62 | |||
63 | /* offset to next interlace block in the y direction */ |
||
64 | const int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2}; |
||
65 | |||
66 | /* width of interlace block (used in assembler routines only) */ |
||
67 | #ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW |
||
68 | const int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; |
||
69 | #endif |
||
70 | |||
71 | /* Height of interlace block. This is not currently used - if you need |
||
72 | * it, uncomment it here and in png.h |
||
73 | const int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1}; |
||
74 | */ |
||
75 | |||
76 | /* Mask to determine which pixels are valid in a pass */ |
||
77 | const int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff}; |
||
78 | |||
79 | /* Mask to determine which pixels to overwrite while displaying */ |
||
80 | const int FARDATA png_pass_dsp_mask[] |
||
81 | = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}; |
||
82 | |||
83 | #endif |
||
84 | |||
85 | /* Tells libpng that we have already handled the first "num_bytes" bytes |
||
86 | * of the PNG file signature. If the PNG data is embedded into another |
||
87 | * stream we can set num_bytes = 8 so that libpng will not attempt to read |
||
88 | * or write any of the magic bytes before it starts on the IHDR. |
||
89 | */ |
||
90 | |||
91 | void PNGAPI |
||
92 | png_set_sig_bytes(png_structp png_ptr, int num_bytes) |
||
93 | { |
||
94 | png_debug(1, "in png_set_sig_bytes\n"); |
||
95 | if (num_bytes > 8) |
||
96 | png_error(png_ptr, "Too many bytes for PNG signature."); |
||
97 | |||
98 | png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes); |
||
99 | } |
||
100 | |||
101 | /* Checks whether the supplied bytes match the PNG signature. We allow |
||
102 | * checking less than the full 8-byte signature so that those apps that |
||
103 | * already read the first few bytes of a file to determine the file type |
||
104 | * can simply check the remaining bytes for extra assurance. Returns |
||
105 | * an integer less than, equal to, or greater than zero if sig is found, |
||
106 | * respectively, to be less than, to match, or be greater than the correct |
||
107 | * PNG signature (this is the same behaviour as strcmp, memcmp, etc). |
||
108 | */ |
||
109 | int PNGAPI |
||
110 | png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check) |
||
111 | { |
||
112 | png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10}; |
||
113 | if (num_to_check > 8) |
||
114 | num_to_check = 8; |
||
115 | else if (num_to_check < 1) |
||
116 | return (0); |
||
117 | |||
118 | if (start > 7) |
||
119 | return (0); |
||
120 | |||
121 | if (start + num_to_check > 8) |
||
122 | num_to_check = 8 - start; |
||
123 | |||
124 | return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check))); |
||
125 | } |
||
126 | |||
127 | /* (Obsolete) function to check signature bytes. It does not allow one |
||
128 | * to check a partial signature. This function might be removed in the |
||
129 | * future - use png_sig_cmp(). Returns true (nonzero) if the file is a PNG. |
||
130 | */ |
||
131 | int PNGAPI |
||
132 | png_check_sig(png_bytep sig, int num) |
||
133 | { |
||
134 | return ((int)!png_sig_cmp(sig, (png_size_t)0, (png_size_t)num)); |
||
135 | } |
||
136 | |||
137 | /* Function to allocate memory for zlib and clear it to 0. */ |
||
138 | #ifdef PNG_1_0_X |
||
139 | voidpf PNGAPI |
||
140 | #else |
||
141 | voidpf /* private */ |
||
142 | #endif |
||
143 | png_zalloc(voidpf png_ptr, uInt items, uInt size) |
||
144 | { |
||
145 | png_uint_32 num_bytes = (png_uint_32)items * size; |
||
146 | png_voidp ptr; |
||
147 | png_structp p=png_ptr; |
||
148 | png_uint_32 save_flags=p->flags; |
||
149 | |||
150 | p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK; |
||
151 | ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes); |
||
152 | p->flags=save_flags; |
||
153 | |||
154 | #ifndef PNG_NO_ZALLOC_ZERO |
||
155 | if (ptr == NULL) |
||
156 | return ((voidpf)ptr); |
||
157 | |||
158 | if (num_bytes > (png_uint_32)0x8000L) |
||
159 | { |
||
160 | png_memset(ptr, 0, (png_size_t)0x8000L); |
||
161 | png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0, |
||
162 | (png_size_t)(num_bytes - (png_uint_32)0x8000L)); |
||
163 | } |
||
164 | else |
||
165 | { |
||
166 | png_memset(ptr, 0, (png_size_t)num_bytes); |
||
167 | } |
||
168 | #endif |
||
169 | return ((voidpf)ptr); |
||
170 | } |
||
171 | |||
172 | /* function to free memory for zlib */ |
||
173 | #ifdef PNG_1_0_X |
||
174 | void PNGAPI |
||
175 | #else |
||
176 | void /* private */ |
||
177 | #endif |
||
178 | png_zfree(voidpf png_ptr, voidpf ptr) |
||
179 | { |
||
180 | png_free((png_structp)png_ptr, (png_voidp)ptr); |
||
181 | } |
||
182 | |||
183 | /* Reset the CRC variable to 32 bits of 1's. Care must be taken |
||
184 | * in case CRC is > 32 bits to leave the top bits 0. |
||
185 | */ |
||
186 | void /* PRIVATE */ |
||
187 | png_reset_crc(png_structp png_ptr) |
||
188 | { |
||
189 | png_ptr->crc = crc32(0, Z_NULL, 0); |
||
190 | } |
||
191 | |||
192 | /* Calculate the CRC over a section of data. We can only pass as |
||
193 | * much data to this routine as the largest single buffer size. We |
||
194 | * also check that this data will actually be used before going to the |
||
195 | * trouble of calculating it. |
||
196 | */ |
||
197 | void /* PRIVATE */ |
||
198 | png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length) |
||
199 | { |
||
200 | int need_crc = 1; |
||
201 | |||
202 | if (png_ptr->chunk_name[0] & 0x20) /* ancillary */ |
||
203 | { |
||
204 | if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) == |
||
205 | (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN)) |
||
206 | need_crc = 0; |
||
207 | } |
||
208 | else /* critical */ |
||
209 | { |
||
210 | if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) |
||
211 | need_crc = 0; |
||
212 | } |
||
213 | |||
214 | if (need_crc) |
||
215 | png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length); |
||
216 | } |
||
217 | |||
218 | /* Allocate the memory for an info_struct for the application. We don't |
||
219 | * really need the png_ptr, but it could potentially be useful in the |
||
220 | * future. This should be used in favour of malloc(sizeof(png_info)) |
||
221 | * and png_info_init() so that applications that want to use a shared |
||
222 | * libpng don't have to be recompiled if png_info changes size. |
||
223 | */ |
||
224 | png_infop PNGAPI |
||
225 | png_create_info_struct(png_structp png_ptr) |
||
226 | { |
||
227 | png_infop info_ptr; |
||
228 | |||
229 | png_debug(1, "in png_create_info_struct\n"); |
||
230 | if(png_ptr == NULL) return (NULL); |
||
231 | #ifdef PNG_USER_MEM_SUPPORTED |
||
232 | info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO, |
||
233 | png_ptr->malloc_fn, png_ptr->mem_ptr); |
||
234 | #else |
||
235 | info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO); |
||
236 | #endif |
||
237 | if (info_ptr != NULL) |
||
238 | png_info_init_3(&info_ptr, sizeof(png_info)); |
||
239 | |||
240 | return (info_ptr); |
||
241 | } |
||
242 | |||
243 | /* This function frees the memory associated with a single info struct. |
||
244 | * Normally, one would use either png_destroy_read_struct() or |
||
245 | * png_destroy_write_struct() to free an info struct, but this may be |
||
246 | * useful for some applications. |
||
247 | */ |
||
248 | void PNGAPI |
||
249 | png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr) |
||
250 | { |
||
251 | png_infop info_ptr = NULL; |
||
252 | |||
253 | png_debug(1, "in png_destroy_info_struct\n"); |
||
254 | if (info_ptr_ptr != NULL) |
||
255 | info_ptr = *info_ptr_ptr; |
||
256 | |||
257 | if (info_ptr != NULL) |
||
258 | { |
||
259 | png_info_destroy(png_ptr, info_ptr); |
||
260 | |||
261 | #ifdef PNG_USER_MEM_SUPPORTED |
||
262 | png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn, |
||
263 | png_ptr->mem_ptr); |
||
264 | #else |
||
265 | png_destroy_struct((png_voidp)info_ptr); |
||
266 | #endif |
||
267 | *info_ptr_ptr = NULL; |
||
268 | } |
||
269 | } |
||
270 | |||
271 | /* Initialize the info structure. This is now an internal function (0.89) |
||
272 | * and applications using it are urged to use png_create_info_struct() |
||
273 | * instead. |
||
274 | */ |
||
275 | #undef png_info_init |
||
276 | void PNGAPI |
||
277 | png_info_init(png_infop info_ptr) |
||
278 | { |
||
279 | /* We only come here via pre-1.0.12-compiled applications */ |
||
280 | png_info_init_3(&info_ptr, 0); |
||
281 | } |
||
282 | |||
283 | void PNGAPI |
||
284 | png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size) |
||
285 | { |
||
286 | png_infop info_ptr = *ptr_ptr; |
||
287 | |||
288 | png_debug(1, "in png_info_init_3\n"); |
||
289 | |||
290 | if(sizeof(png_info) > png_info_struct_size) |
||
291 | { |
||
292 | png_destroy_struct(info_ptr); |
||
293 | info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO); |
||
294 | *ptr_ptr = info_ptr; |
||
295 | } |
||
296 | |||
297 | /* set everything to 0 */ |
||
298 | png_memset(info_ptr, 0, sizeof (png_info)); |
||
299 | } |
||
300 | |||
301 | #ifdef PNG_FREE_ME_SUPPORTED |
||
302 | void PNGAPI |
||
303 | png_data_freer(png_structp png_ptr, png_infop info_ptr, |
||
304 | int freer, png_uint_32 mask) |
||
305 | { |
||
306 | png_debug(1, "in png_data_freer\n"); |
||
307 | if (png_ptr == NULL || info_ptr == NULL) |
||
308 | return; |
||
309 | if(freer == PNG_DESTROY_WILL_FREE_DATA) |
||
310 | info_ptr->free_me |= mask; |
||
311 | else if(freer == PNG_USER_WILL_FREE_DATA) |
||
312 | info_ptr->free_me &= ~mask; |
||
313 | else |
||
314 | png_warning(png_ptr, |
||
315 | "Unknown freer parameter in png_data_freer."); |
||
316 | } |
||
317 | #endif |
||
318 | |||
319 | void PNGAPI |
||
320 | png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask, |
||
321 | int num) |
||
322 | { |
||
323 | png_debug(1, "in png_free_data\n"); |
||
324 | if (png_ptr == NULL || info_ptr == NULL) |
||
325 | return; |
||
326 | |||
327 | #if defined(PNG_TEXT_SUPPORTED) |
||
328 | /* free text item num or (if num == -1) all text items */ |
||
329 | #ifdef PNG_FREE_ME_SUPPORTED |
||
330 | if ((mask & PNG_FREE_TEXT) & info_ptr->free_me) |
||
331 | #else |
||
332 | if (mask & PNG_FREE_TEXT) |
||
333 | #endif |
||
334 | { |
||
335 | if (num != -1) |
||
336 | { |
||
337 | if (info_ptr->text && info_ptr->text[num].key) |
||
338 | { |
||
339 | png_free(png_ptr, info_ptr->text[num].key); |
||
340 | info_ptr->text[num].key = NULL; |
||
341 | } |
||
342 | } |
||
343 | else |
||
344 | { |
||
345 | int i; |
||
346 | for (i = 0; i < info_ptr->num_text; i++) |
||
347 | png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i); |
||
348 | png_free(png_ptr, info_ptr->text); |
||
349 | info_ptr->text = NULL; |
||
350 | info_ptr->num_text=0; |
||
351 | } |
||
352 | } |
||
353 | #endif |
||
354 | |||
355 | #if defined(PNG_tRNS_SUPPORTED) |
||
356 | /* free any tRNS entry */ |
||
357 | #ifdef PNG_FREE_ME_SUPPORTED |
||
358 | if ((mask & PNG_FREE_TRNS) & info_ptr->free_me) |
||
359 | #else |
||
360 | if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS)) |
||
361 | #endif |
||
362 | { |
||
363 | png_free(png_ptr, info_ptr->trans); |
||
364 | info_ptr->valid &= ~PNG_INFO_tRNS; |
||
365 | #ifndef PNG_FREE_ME_SUPPORTED |
||
366 | png_ptr->flags &= ~PNG_FLAG_FREE_TRNS; |
||
367 | #endif |
||
368 | info_ptr->trans = NULL; |
||
369 | } |
||
370 | #endif |
||
371 | |||
372 | #if defined(PNG_sCAL_SUPPORTED) |
||
373 | /* free any sCAL entry */ |
||
374 | #ifdef PNG_FREE_ME_SUPPORTED |
||
375 | if ((mask & PNG_FREE_SCAL) & info_ptr->free_me) |
||
376 | #else |
||
377 | if (mask & PNG_FREE_SCAL) |
||
378 | #endif |
||
379 | { |
||
380 | #if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) |
||
381 | png_free(png_ptr, info_ptr->scal_s_width); |
||
382 | png_free(png_ptr, info_ptr->scal_s_height); |
||
383 | info_ptr->scal_s_width = NULL; |
||
384 | info_ptr->scal_s_height = NULL; |
||
385 | #endif |
||
386 | info_ptr->valid &= ~PNG_INFO_sCAL; |
||
387 | } |
||
388 | #endif |
||
389 | |||
390 | #if defined(PNG_pCAL_SUPPORTED) |
||
391 | /* free any pCAL entry */ |
||
392 | #ifdef PNG_FREE_ME_SUPPORTED |
||
393 | if ((mask & PNG_FREE_PCAL) & info_ptr->free_me) |
||
394 | #else |
||
395 | if (mask & PNG_FREE_PCAL) |
||
396 | #endif |
||
397 | { |
||
398 | png_free(png_ptr, info_ptr->pcal_purpose); |
||
399 | png_free(png_ptr, info_ptr->pcal_units); |
||
400 | info_ptr->pcal_purpose = NULL; |
||
401 | info_ptr->pcal_units = NULL; |
||
402 | if (info_ptr->pcal_params != NULL) |
||
403 | { |
||
404 | int i; |
||
405 | for (i = 0; i < (int)info_ptr->pcal_nparams; i++) |
||
406 | { |
||
407 | png_free(png_ptr, info_ptr->pcal_params[i]); |
||
408 | info_ptr->pcal_params[i]=NULL; |
||
409 | } |
||
410 | png_free(png_ptr, info_ptr->pcal_params); |
||
411 | info_ptr->pcal_params = NULL; |
||
412 | } |
||
413 | info_ptr->valid &= ~PNG_INFO_pCAL; |
||
414 | } |
||
415 | #endif |
||
416 | |||
417 | #if defined(PNG_iCCP_SUPPORTED) |
||
418 | /* free any iCCP entry */ |
||
419 | #ifdef PNG_FREE_ME_SUPPORTED |
||
420 | if ((mask & PNG_FREE_ICCP) & info_ptr->free_me) |
||
421 | #else |
||
422 | if (mask & PNG_FREE_ICCP) |
||
423 | #endif |
||
424 | { |
||
425 | png_free(png_ptr, info_ptr->iccp_name); |
||
426 | png_free(png_ptr, info_ptr->iccp_profile); |
||
427 | info_ptr->iccp_name = NULL; |
||
428 | info_ptr->iccp_profile = NULL; |
||
429 | info_ptr->valid &= ~PNG_INFO_iCCP; |
||
430 | } |
||
431 | #endif |
||
432 | |||
433 | #if defined(PNG_sPLT_SUPPORTED) |
||
434 | /* free a given sPLT entry, or (if num == -1) all sPLT entries */ |
||
435 | #ifdef PNG_FREE_ME_SUPPORTED |
||
436 | if ((mask & PNG_FREE_SPLT) & info_ptr->free_me) |
||
437 | #else |
||
438 | if (mask & PNG_FREE_SPLT) |
||
439 | #endif |
||
440 | { |
||
441 | if (num != -1) |
||
442 | { |
||
443 | if(info_ptr->splt_palettes) |
||
444 | { |
||
445 | png_free(png_ptr, info_ptr->splt_palettes[num].name); |
||
446 | png_free(png_ptr, info_ptr->splt_palettes[num].entries); |
||
447 | info_ptr->splt_palettes[num].name = NULL; |
||
448 | info_ptr->splt_palettes[num].entries = NULL; |
||
449 | } |
||
450 | } |
||
451 | else |
||
452 | { |
||
453 | if(info_ptr->splt_palettes_num) |
||
454 | { |
||
455 | int i; |
||
456 | for (i = 0; i < (int)info_ptr->splt_palettes_num; i++) |
||
457 | png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i); |
||
458 | |||
459 | png_free(png_ptr, info_ptr->splt_palettes); |
||
460 | info_ptr->splt_palettes = NULL; |
||
461 | info_ptr->splt_palettes_num = 0; |
||
462 | } |
||
463 | info_ptr->valid &= ~PNG_INFO_sPLT; |
||
464 | } |
||
465 | } |
||
466 | #endif |
||
467 | |||
468 | #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
||
469 | #ifdef PNG_FREE_ME_SUPPORTED |
||
470 | if ((mask & PNG_FREE_UNKN) & info_ptr->free_me) |
||
471 | #else |
||
472 | if (mask & PNG_FREE_UNKN) |
||
473 | #endif |
||
474 | { |
||
475 | if (num != -1) |
||
476 | { |
||
477 | if(info_ptr->unknown_chunks) |
||
478 | { |
||
479 | png_free(png_ptr, info_ptr->unknown_chunks[num].data); |
||
480 | info_ptr->unknown_chunks[num].data = NULL; |
||
481 | } |
||
482 | } |
||
483 | else |
||
484 | { |
||
485 | int i; |
||
486 | |||
487 | if(info_ptr->unknown_chunks_num) |
||
488 | { |
||
489 | for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++) |
||
490 | png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i); |
||
491 | |||
492 | png_free(png_ptr, info_ptr->unknown_chunks); |
||
493 | info_ptr->unknown_chunks = NULL; |
||
494 | info_ptr->unknown_chunks_num = 0; |
||
495 | } |
||
496 | } |
||
497 | } |
||
498 | #endif |
||
499 | |||
500 | #if defined(PNG_hIST_SUPPORTED) |
||
501 | /* free any hIST entry */ |
||
502 | #ifdef PNG_FREE_ME_SUPPORTED |
||
503 | if ((mask & PNG_FREE_HIST) & info_ptr->free_me) |
||
504 | #else |
||
505 | if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST)) |
||
506 | #endif |
||
507 | { |
||
508 | png_free(png_ptr, info_ptr->hist); |
||
509 | info_ptr->hist = NULL; |
||
510 | info_ptr->valid &= ~PNG_INFO_hIST; |
||
511 | #ifndef PNG_FREE_ME_SUPPORTED |
||
512 | png_ptr->flags &= ~PNG_FLAG_FREE_HIST; |
||
513 | #endif |
||
514 | } |
||
515 | #endif |
||
516 | |||
517 | /* free any PLTE entry that was internally allocated */ |
||
518 | #ifdef PNG_FREE_ME_SUPPORTED |
||
519 | if ((mask & PNG_FREE_PLTE) & info_ptr->free_me) |
||
520 | #else |
||
521 | if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE)) |
||
522 | #endif |
||
523 | { |
||
524 | png_zfree(png_ptr, info_ptr->palette); |
||
525 | info_ptr->palette = NULL; |
||
526 | info_ptr->valid &= ~PNG_INFO_PLTE; |
||
527 | #ifndef PNG_FREE_ME_SUPPORTED |
||
528 | png_ptr->flags &= ~PNG_FLAG_FREE_PLTE; |
||
529 | #endif |
||
530 | info_ptr->num_palette = 0; |
||
531 | } |
||
532 | |||
533 | #if defined(PNG_INFO_IMAGE_SUPPORTED) |
||
534 | /* free any image bits attached to the info structure */ |
||
535 | #ifdef PNG_FREE_ME_SUPPORTED |
||
536 | if ((mask & PNG_FREE_ROWS) & info_ptr->free_me) |
||
537 | #else |
||
538 | if (mask & PNG_FREE_ROWS) |
||
539 | #endif |
||
540 | { |
||
541 | if(info_ptr->row_pointers) |
||
542 | { |
||
543 | int row; |
||
544 | for (row = 0; row < (int)info_ptr->height; row++) |
||
545 | { |
||
546 | png_free(png_ptr, info_ptr->row_pointers[row]); |
||
547 | info_ptr->row_pointers[row]=NULL; |
||
548 | } |
||
549 | png_free(png_ptr, info_ptr->row_pointers); |
||
550 | info_ptr->row_pointers=NULL; |
||
551 | } |
||
552 | info_ptr->valid &= ~PNG_INFO_IDAT; |
||
553 | } |
||
554 | #endif |
||
555 | |||
556 | #ifdef PNG_FREE_ME_SUPPORTED |
||
557 | if(num == -1) |
||
558 | info_ptr->free_me &= ~mask; |
||
559 | else |
||
560 | info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL); |
||
561 | #endif |
||
562 | } |
||
563 | |||
564 | /* This is an internal routine to free any memory that the info struct is |
||
565 | * pointing to before re-using it or freeing the struct itself. Recall |
||
566 | * that png_free() checks for NULL pointers for us. |
||
567 | */ |
||
568 | void /* PRIVATE */ |
||
569 | png_info_destroy(png_structp png_ptr, png_infop info_ptr) |
||
570 | { |
||
571 | png_debug(1, "in png_info_destroy\n"); |
||
572 | |||
573 | png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1); |
||
574 | |||
575 | #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
||
576 | if (png_ptr->num_chunk_list) |
||
577 | { |
||
578 | png_free(png_ptr, png_ptr->chunk_list); |
||
579 | png_ptr->chunk_list=NULL; |
||
580 | png_ptr->num_chunk_list=0; |
||
581 | } |
||
582 | #endif |
||
583 | |||
584 | png_info_init_3(&info_ptr, sizeof(png_info)); |
||
585 | } |
||
586 | |||
587 | /* This function returns a pointer to the io_ptr associated with the user |
||
588 | * functions. The application should free any memory associated with this |
||
589 | * pointer before png_write_destroy() or png_read_destroy() are called. |
||
590 | */ |
||
591 | png_voidp PNGAPI |
||
592 | png_get_io_ptr(png_structp png_ptr) |
||
593 | { |
||
594 | return (png_ptr->io_ptr); |
||
595 | } |
||
596 | |||
597 | #if !defined(PNG_NO_STDIO) |
||
598 | /* Initialize the default input/output functions for the PNG file. If you |
||
599 | * use your own read or write routines, you can call either png_set_read_fn() |
||
600 | * or png_set_write_fn() instead of png_init_io(). If you have defined |
||
601 | * PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't |
||
602 | * necessarily available. |
||
603 | */ |
||
604 | void PNGAPI |
||
605 | png_init_io(png_structp png_ptr, png_FILE_p fp) |
||
606 | { |
||
607 | png_debug(1, "in png_init_io\n"); |
||
608 | png_ptr->io_ptr = (png_voidp)fp; |
||
609 | } |
||
610 | #endif |
||
611 | |||
612 | #if defined(PNG_TIME_RFC1123_SUPPORTED) |
||
613 | /* Convert the supplied time into an RFC 1123 string suitable for use in |
||
614 | * a "Creation Time" or other text-based time string. |
||
615 | */ |
||
616 | png_charp PNGAPI |
||
617 | png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime) |
||
618 | { |
||
619 | static PNG_CONST char short_months[12][4] = |
||
620 | {"Jan", "Feb", "Mar", "Apr", "May", "Jun", |
||
621 | "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; |
||
622 | |||
623 | if (png_ptr->time_buffer == NULL) |
||
624 | { |
||
625 | png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29* |
||
626 | sizeof(char))); |
||
627 | } |
||
628 | |||
629 | #if defined(_WIN32_WCE) |
||
630 | { |
||
631 | wchar_t time_buf[29]; |
||
632 | wsprintf(time_buf, TEXT("%d %S %d %02d:%02d:%02d +0000"), |
||
633 | ptime->day % 32, short_months[(ptime->month - 1) % 12], |
||
634 | ptime->year, ptime->hour % 24, ptime->minute % 60, |
||
635 | ptime->second % 61); |
||
636 | WideCharToMultiByte(CP_ACP, 0, time_buf, -1, png_ptr->time_buffer, 29, |
||
637 | NULL, NULL); |
||
638 | } |
||
639 | #else |
||
640 | #ifdef USE_FAR_KEYWORD |
||
641 | { |
||
642 | char near_time_buf[29]; |
||
643 | sprintf(near_time_buf, "%d %s %d %02d:%02d:%02d +0000", |
||
644 | ptime->day % 32, short_months[(ptime->month - 1) % 12], |
||
645 | ptime->year, ptime->hour % 24, ptime->minute % 60, |
||
646 | ptime->second % 61); |
||
647 | png_memcpy(png_ptr->time_buffer, near_time_buf, |
||
648 | 29*sizeof(char)); |
||
649 | } |
||
650 | #else |
||
651 | sprintf(png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000", |
||
652 | ptime->day % 32, short_months[(ptime->month - 1) % 12], |
||
653 | ptime->year, ptime->hour % 24, ptime->minute % 60, |
||
654 | ptime->second % 61); |
||
655 | #endif |
||
656 | #endif /* _WIN32_WCE */ |
||
657 | return ((png_charp)png_ptr->time_buffer); |
||
658 | } |
||
659 | #endif /* PNG_TIME_RFC1123_SUPPORTED */ |
||
660 | |||
661 | #if 0 |
||
662 | /* Signature string for a PNG file. */ |
||
663 | png_bytep PNGAPI |
||
664 | png_sig_bytes(void) |
||
665 | { |
||
666 | return ((png_bytep)"\211\120\116\107\015\012\032\012"); |
||
667 | } |
||
668 | #endif |
||
669 | |||
670 | png_charp PNGAPI |
||
671 | png_get_copyright(png_structp png_ptr) |
||
672 | { |
||
673 | if (png_ptr != NULL || png_ptr == NULL) /* silence compiler warning */ |
||
674 | return ((png_charp) "\n libpng version 1.2.5 - October 3, 2002\n\ |
||
675 | Copyright (c) 1998-2002 Glenn Randers-Pehrson\n\ |
||
676 | Copyright (c) 1996-1997 Andreas Dilger\n\ |
||
677 | Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.\n"); |
||
678 | return ((png_charp) ""); |
||
679 | } |
||
680 | |||
681 | /* The following return the library version as a short string in the |
||
682 | * format 1.0.0 through 99.99.99zz. To get the version of *.h files used |
||
683 | * with your application, print out PNG_LIBPNG_VER_STRING, which is defined |
||
684 | * in png.h. |
||
685 | */ |
||
686 | |||
687 | png_charp PNGAPI |
||
688 | png_get_libpng_ver(png_structp png_ptr) |
||
689 | { |
||
690 | /* Version of *.c files used when building libpng */ |
||
691 | if(png_ptr != NULL) /* silence compiler warning about unused png_ptr */ |
||
692 | return((png_charp) "1.2.5"); |
||
693 | return((png_charp) "1.2.5"); |
||
694 | } |
||
695 | |||
696 | png_charp PNGAPI |
||
697 | png_get_header_ver(png_structp png_ptr) |
||
698 | { |
||
699 | /* Version of *.h files used when building libpng */ |
||
700 | if(png_ptr != NULL) /* silence compiler warning about unused png_ptr */ |
||
701 | return((png_charp) PNG_LIBPNG_VER_STRING); |
||
702 | return((png_charp) PNG_LIBPNG_VER_STRING); |
||
703 | } |
||
704 | |||
705 | png_charp PNGAPI |
||
706 | png_get_header_version(png_structp png_ptr) |
||
707 | { |
||
708 | /* Returns longer string containing both version and date */ |
||
709 | if(png_ptr != NULL) /* silence compiler warning about unused png_ptr */ |
||
710 | return((png_charp) PNG_HEADER_VERSION_STRING); |
||
711 | return((png_charp) PNG_HEADER_VERSION_STRING); |
||
712 | } |
||
713 | |||
714 | #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
||
715 | int PNGAPI |
||
716 | png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name) |
||
717 | { |
||
718 | /* check chunk_name and return "keep" value if it's on the list, else 0 */ |
||
719 | int i; |
||
720 | png_bytep p; |
||
721 | if((png_ptr == NULL && chunk_name == NULL) || png_ptr->num_chunk_list<=0) |
||
722 | return 0; |
||
723 | p=png_ptr->chunk_list+png_ptr->num_chunk_list*5-5; |
||
724 | for (i = png_ptr->num_chunk_list; i; i--, p-=5) |
||
725 | if (!png_memcmp(chunk_name, p, 4)) |
||
726 | return ((int)*(p+4)); |
||
727 | return 0; |
||
728 | } |
||
729 | #endif |
||
730 | |||
731 | /* This function, added to libpng-1.0.6g, is untested. */ |
||
732 | int PNGAPI |
||
733 | png_reset_zstream(png_structp png_ptr) |
||
734 | { |
||
735 | return (inflateReset(&png_ptr->zstream)); |
||
736 | } |
||
737 | |||
738 | /* This function was added to libpng-1.0.7 */ |
||
739 | png_uint_32 PNGAPI |
||
740 | png_access_version_number(void) |
||
741 | { |
||
742 | /* Version of *.c files used when building libpng */ |
||
743 | return((png_uint_32) 10205L); |
||
744 | } |
||
745 | |||
746 | |||
747 | #if !defined(PNG_1_0_X) |
||
748 | #if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
||
749 | /* GRR: could add this: && defined(PNG_MMX_CODE_SUPPORTED) */ |
||
750 | /* this INTERNAL function was added to libpng 1.2.0 */ |
||
751 | void /* PRIVATE */ |
||
752 | png_init_mmx_flags (png_structp png_ptr) |
||
753 | { |
||
754 | png_ptr->mmx_rowbytes_threshold = 0; |
||
755 | png_ptr->mmx_bitdepth_threshold = 0; |
||
756 | |||
757 | # if (defined(PNG_USE_PNGVCRD) || defined(PNG_USE_PNGGCCRD)) |
||
758 | |||
759 | png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_COMPILED; |
||
760 | |||
761 | if (png_mmx_support() > 0) { |
||
762 | png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU |
||
763 | # ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW |
||
764 | | PNG_ASM_FLAG_MMX_READ_COMBINE_ROW |
||
765 | # endif |
||
766 | # ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE |
||
767 | | PNG_ASM_FLAG_MMX_READ_INTERLACE |
||
768 | # endif |
||
769 | # ifndef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW |
||
770 | ; |
||
771 | # else |
||
772 | | PNG_ASM_FLAG_MMX_READ_FILTER_SUB |
||
773 | | PNG_ASM_FLAG_MMX_READ_FILTER_UP |
||
774 | | PNG_ASM_FLAG_MMX_READ_FILTER_AVG |
||
775 | | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ; |
||
776 | |||
777 | png_ptr->mmx_rowbytes_threshold = PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT; |
||
778 | png_ptr->mmx_bitdepth_threshold = PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT; |
||
779 | # endif |
||
780 | } else { |
||
781 | png_ptr->asm_flags &= ~( PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU |
||
782 | | PNG_MMX_READ_FLAGS |
||
783 | | PNG_MMX_WRITE_FLAGS ); |
||
784 | } |
||
785 | |||
786 | # else /* !((PNGVCRD || PNGGCCRD) && PNG_ASSEMBLER_CODE_SUPPORTED)) */ |
||
787 | |||
788 | /* clear all MMX flags; no support is compiled in */ |
||
789 | png_ptr->asm_flags &= ~( PNG_MMX_FLAGS ); |
||
790 | |||
791 | # endif /* ?(PNGVCRD || PNGGCCRD) */ |
||
792 | } |
||
793 | |||
794 | #endif /* !(PNG_ASSEMBLER_CODE_SUPPORTED) */ |
||
795 | |||
796 | /* this function was added to libpng 1.2.0 */ |
||
797 | #if !defined(PNG_USE_PNGGCCRD) && \ |
||
798 | !(defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_USE_PNGVCRD)) |
||
799 | int PNGAPI |
||
800 | png_mmx_support(void) |
||
801 | { |
||
802 | return -1; |
||
803 | } |
||
804 | #endif |
||
805 | #endif /* PNG_1_0_X */ |