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