| Bsoft 1.9 Bernard's software package

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

png.c
Go to the documentation of this file.
1
2 /* png.c - location for general purpose libpng functions
3 *
4 * Last changed in libpng 1.5.1 [February 3, 2011]
5 * Copyright (c) 1998-2011 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 * This code is released under the libpng license.
10 * For conditions of distribution and use, see the disclaimer
11 * and license in png.h
12 */
13
14 #include "pngpriv.h"
15
16 /* Generate a compiler error if there is an old png.h in the search path. */
17 typedef png_libpng_version_1_5_1 Your_png_h_is_not_version_1_5_1;
18
19 /* Tells libpng that we have already handled the first "num_bytes" bytes
20 * of the PNG file signature. If the PNG data is embedded into another
21 * stream we can set num_bytes = 8 so that libpng will not attempt to read
22 * or write any of the magic bytes before it starts on the IHDR.
23 */
24
25 #ifdef PNG_READ_SUPPORTED
26 void PNGAPI
27 png_set_sig_bytes(png_structp png_ptr, int num_bytes)
28 {
29 png_debug(1, "in png_set_sig_bytes");
30
31 if (png_ptr == NULL)
32 return;
33
34 if (num_bytes > 8)
35 png_error(png_ptr, "Too many bytes for PNG signature");
36
37 png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);
38 }
39
40 /* Checks whether the supplied bytes match the PNG signature. We allow
41 * checking less than the full 8-byte signature so that those apps that
42 * already read the first few bytes of a file to determine the file type
43 * can simply check the remaining bytes for extra assurance. Returns
44 * an integer less than, equal to, or greater than zero if sig is found,
45 * respectively, to be less than, to match, or be greater than the correct
46 * PNG signature (this is the same behaviour as strcmp, memcmp, etc).
47 */
48 int PNGAPI
49 png_sig_cmp(png_const_bytep sig, png_size_t start, png_size_t num_to_check)
50 {
51 png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
52
53 if (num_to_check > 8)
54 num_to_check = 8;
55
56 else if (num_to_check < 1)
57 return (-1);
58
59 if (start > 7)
60 return (-1);
61
62 if (start + num_to_check > 8)
63 num_to_check = 8 - start;
64
65 return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check)));
66 }
67
68 #endif /* PNG_READ_SUPPORTED */
69
70 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
71 /* Function to allocate memory for zlib */
72 PNG_FUNCTION(voidpf /* PRIVATE */,
73 png_zalloc,(voidpf png_ptr, uInt items, uInt size),PNG_ALLOCATED)
74 {
75 png_voidp ptr;
76 png_structp p=(png_structp)png_ptr;
77 png_uint_32 save_flags=p->flags;
78 png_alloc_size_t num_bytes;
79
80 if (png_ptr == NULL)
81 return (NULL);
82
83 if (items > PNG_UINT_32_MAX/size)
84 {
85 png_warning (p, "Potential overflow in png_zalloc()");
86 return (NULL);
87 }
88 num_bytes = (png_alloc_size_t)items * size;
89
90 p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
91 ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);
92 p->flags=save_flags;
93
94 return ((voidpf)ptr);
95 }
96
97 /* Function to free memory for zlib */
98 void /* PRIVATE */
99 png_zfree(voidpf png_ptr, voidpf ptr)
100 {
101 png_free((png_structp)png_ptr, (png_voidp)ptr);
102 }
103
104 /* Reset the CRC variable to 32 bits of 1's. Care must be taken
105 * in case CRC is > 32 bits to leave the top bits 0.
106 */
107 void /* PRIVATE */
108 png_reset_crc(png_structp png_ptr)
109 {
110 png_ptr->crc = crc32(0, Z_NULL, 0);
111 }
112
113 /* Calculate the CRC over a section of data. We can only pass as
114 * much data to this routine as the largest single buffer size. We
115 * also check that this data will actually be used before going to the
116 * trouble of calculating it.
117 */
118 void /* PRIVATE */
119 png_calculate_crc(png_structp png_ptr, png_const_bytep ptr, png_size_t length)
120 {
121 int need_crc = 1;
122
123 if (png_ptr->chunk_name[0] & 0x20) /* ancillary */
124 {
125 if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
126 (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
127 need_crc = 0;
128 }
129
130 else /* critical */
131 {
132 if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
133 need_crc = 0;
134 }
135
136 if (need_crc)
137 png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);
138 }
139
140 /* Allocate the memory for an info_struct for the application. We don't
141 * really need the png_ptr, but it could potentially be useful in the
142 * future. This should be used in favour of malloc(png_sizeof(png_info))
143 * and png_info_init() so that applications that want to use a shared
144 * libpng don't have to be recompiled if png_info changes size.
145 */
146 PNG_FUNCTION(png_infop,PNGAPI
147 png_create_info_struct,(png_structp png_ptr),PNG_ALLOCATED)
148 {
149 png_infop info_ptr;
150
151 png_debug(1, "in png_create_info_struct");
152
153 if (png_ptr == NULL)
154 return (NULL);
155
156 #ifdef PNG_USER_MEM_SUPPORTED
157 info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,
158 png_ptr->malloc_fn, png_ptr->mem_ptr);
159 #else
160 info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
161 #endif
162 if (info_ptr != NULL)
163 png_info_init_3(&info_ptr, png_sizeof(png_info));
164
165 return (info_ptr);
166 }
167
168 /* This function frees the memory associated with a single info struct.
169 * Normally, one would use either png_destroy_read_struct() or
170 * png_destroy_write_struct() to free an info struct, but this may be
171 * useful for some applications.
172 */
173 void PNGAPI
174 png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
175 {
176 png_infop info_ptr = NULL;
177
178 png_debug(1, "in png_destroy_info_struct");
179
180 if (png_ptr == NULL)
181 return;
182
183 if (info_ptr_ptr != NULL)
184 info_ptr = *info_ptr_ptr;
185
186 if (info_ptr != NULL)
187 {
188 png_info_destroy(png_ptr, info_ptr);
189
190 #ifdef PNG_USER_MEM_SUPPORTED
191 png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn,
192 png_ptr->mem_ptr);
193 #else
194 png_destroy_struct((png_voidp)info_ptr);
195 #endif
196 *info_ptr_ptr = NULL;
197 }
198 }
199
200 /* Initialize the info structure. This is now an internal function (0.89)
201 * and applications using it are urged to use png_create_info_struct()
202 * instead.
203 */
204
205 void PNGAPI
206 png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size)
207 {
208 png_infop info_ptr = *ptr_ptr;
209
210 png_debug(1, "in png_info_init_3");
211
212 if (info_ptr == NULL)
213 return;
214
215 if (png_sizeof(png_info) > png_info_struct_size)
216 {
217 png_destroy_struct(info_ptr);
218 info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
219 *ptr_ptr = info_ptr;
220 }
221
222 /* Set everything to 0 */
223 png_memset(info_ptr, 0, png_sizeof(png_info));
224 }
225
226 void PNGAPI
227 png_data_freer(png_structp png_ptr, png_infop info_ptr,
228 int freer, png_uint_32 mask)
229 {
230 png_debug(1, "in png_data_freer");
231
232 if (png_ptr == NULL || info_ptr == NULL)
233 return;
234
235 if (freer == PNG_DESTROY_WILL_FREE_DATA)
236 info_ptr->free_me |= mask;
237
238 else if (freer == PNG_USER_WILL_FREE_DATA)
239 info_ptr->free_me &= ~mask;
240
241 else
242 png_warning(png_ptr,
243 "Unknown freer parameter in png_data_freer");
244 }
245
246 void PNGAPI
247 png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask,
248 int num)
249 {
250 png_debug(1, "in png_free_data");
251
252 if (png_ptr == NULL || info_ptr == NULL)
253 return;
254
255 #ifdef PNG_TEXT_SUPPORTED
256 /* Free text item num or (if num == -1) all text items */
257 if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)
258 {
259 if (num != -1)
260 {
261 if (info_ptr->text && info_ptr->text[num].key)
262 {
263 png_free(png_ptr, info_ptr->text[num].key);
264 info_ptr->text[num].key = NULL;
265 }
266 }
267
268 else
269 {
270 int i;
271 for (i = 0; i < info_ptr->num_text; i++)
272 png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);
273 png_free(png_ptr, info_ptr->text);
274 info_ptr->text = NULL;
275 info_ptr->num_text=0;
276 }
277 }
278 #endif
279
280 #ifdef PNG_tRNS_SUPPORTED
281 /* Free any tRNS entry */
282 if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)
283 {
284 png_free(png_ptr, info_ptr->trans_alpha);
285 info_ptr->trans_alpha = NULL;
286 info_ptr->valid &= ~PNG_INFO_tRNS;
287 }
288 #endif
289
290 #ifdef PNG_sCAL_SUPPORTED
291 /* Free any sCAL entry */
292 if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)
293 {
294 #if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)
295 png_free(png_ptr, info_ptr->scal_s_width);
296 png_free(png_ptr, info_ptr->scal_s_height);
297 info_ptr->scal_s_width = NULL;
298 info_ptr->scal_s_height = NULL;
299 #endif
300 info_ptr->valid &= ~PNG_INFO_sCAL;
301 }
302 #endif
303
304 #ifdef PNG_pCAL_SUPPORTED
305 /* Free any pCAL entry */
306 if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)
307 {
308 png_free(png_ptr, info_ptr->pcal_purpose);
309 png_free(png_ptr, info_ptr->pcal_units);
310 info_ptr->pcal_purpose = NULL;
311 info_ptr->pcal_units = NULL;
312 if (info_ptr->pcal_params != NULL)
313 {
314 int i;
315 for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
316 {
317 png_free(png_ptr, info_ptr->pcal_params[i]);
318 info_ptr->pcal_params[i] = NULL;
319 }
320 png_free(png_ptr, info_ptr->pcal_params);
321 info_ptr->pcal_params = NULL;
322 }
323 info_ptr->valid &= ~PNG_INFO_pCAL;
324 }
325 #endif
326
327 #ifdef PNG_iCCP_SUPPORTED
328 /* Free any iCCP entry */
329 if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)
330 {
331 png_free(png_ptr, info_ptr->iccp_name);
332 png_free(png_ptr, info_ptr->iccp_profile);
333 info_ptr->iccp_name = NULL;
334 info_ptr->iccp_profile = NULL;
335 info_ptr->valid &= ~PNG_INFO_iCCP;
336 }
337 #endif
338
339 #ifdef PNG_sPLT_SUPPORTED
340 /* Free a given sPLT entry, or (if num == -1) all sPLT entries */
341 if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)
342 {
343 if (num != -1)
344 {
345 if (info_ptr->splt_palettes)
346 {
347 png_free(png_ptr, info_ptr->splt_palettes[num].name);
348 png_free(png_ptr, info_ptr->splt_palettes[num].entries);
349 info_ptr->splt_palettes[num].name = NULL;
350 info_ptr->splt_palettes[num].entries = NULL;
351 }
352 }
353
354 else
355 {
356 if (info_ptr->splt_palettes_num)
357 {
358 int i;
359 for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
360 png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);
361
362 png_free(png_ptr, info_ptr->splt_palettes);
363 info_ptr->splt_palettes = NULL;
364 info_ptr->splt_palettes_num = 0;
365 }
366 info_ptr->valid &= ~PNG_INFO_sPLT;
367 }
368 }
369 #endif
370
371 #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
372 if (png_ptr->unknown_chunk.data)
373 {
374 png_free(png_ptr, png_ptr->unknown_chunk.data);
375 png_ptr->unknown_chunk.data = NULL;
376 }
377
378 if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)
379 {
380 if (num != -1)
381 {
382 if (info_ptr->unknown_chunks)
383 {
384 png_free(png_ptr, info_ptr->unknown_chunks[num].data);
385 info_ptr->unknown_chunks[num].data = NULL;
386 }
387 }
388
389 else
390 {
391 int i;
392
393 if (info_ptr->unknown_chunks_num)
394 {
395 for (i = 0; i < info_ptr->unknown_chunks_num; i++)
396 png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i);
397
398 png_free(png_ptr, info_ptr->unknown_chunks);
399 info_ptr->unknown_chunks = NULL;
400 info_ptr->unknown_chunks_num = 0;
401 }
402 }
403 }
404 #endif
405
406 #ifdef PNG_hIST_SUPPORTED
407 /* Free any hIST entry */
408 if ((mask & PNG_FREE_HIST) & info_ptr->free_me)
409 {
410 png_free(png_ptr, info_ptr->hist);
411 info_ptr->hist = NULL;
412 info_ptr->valid &= ~PNG_INFO_hIST;
413 }
414 #endif
415
416 /* Free any PLTE entry that was internally allocated */
417 if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)
418 {
419 png_zfree(png_ptr, info_ptr->palette);
420 info_ptr->palette = NULL;
421 info_ptr->valid &= ~PNG_INFO_PLTE;
422 info_ptr->num_palette = 0;
423 }
424
425 #ifdef PNG_INFO_IMAGE_SUPPORTED
426 /* Free any image bits attached to the info structure */
427 if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)
428 {
429 if (info_ptr->row_pointers)
430 {
431 int row;
432 for (row = 0; row < (int)info_ptr->height; row++)
433 {
434 png_free(png_ptr, info_ptr->row_pointers[row]);
435 info_ptr->row_pointers[row] = NULL;
436 }
437 png_free(png_ptr, info_ptr->row_pointers);
438 info_ptr->row_pointers = NULL;
439 }
440 info_ptr->valid &= ~PNG_INFO_IDAT;
441 }
442 #endif
443
444 if (num != -1)
445 mask &= ~PNG_FREE_MUL;
446
447 info_ptr->free_me &= ~mask;
448 }
449
450 /* This is an internal routine to free any memory that the info struct is
451 * pointing to before re-using it or freeing the struct itself. Recall
452 * that png_free() checks for NULL pointers for us.
453 */
454 void /* PRIVATE */
455 png_info_destroy(png_structp png_ptr, png_infop info_ptr)
456 {
457 png_debug(1, "in png_info_destroy");
458
459 png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
460
461 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
462 if (png_ptr->num_chunk_list)
463 {
464 png_free(png_ptr, png_ptr->chunk_list);
465 png_ptr->chunk_list = NULL;
466 png_ptr->num_chunk_list = 0;
467 }
468 #endif
469
470 png_info_init_3(&info_ptr, png_sizeof(png_info));
471 }
472 #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
473
474 /* This function returns a pointer to the io_ptr associated with the user
475 * functions. The application should free any memory associated with this
476 * pointer before png_write_destroy() or png_read_destroy() are called.
477 */
478 png_voidp PNGAPI
479 png_get_io_ptr(png_structp png_ptr)
480 {
481 if (png_ptr == NULL)
482 return (NULL);
483
484 return (png_ptr->io_ptr);
485 }
486
487 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
488 # ifdef PNG_STDIO_SUPPORTED
489 /* Initialize the default input/output functions for the PNG file. If you
490 * use your own read or write routines, you can call either png_set_read_fn()
491 * or png_set_write_fn() instead of png_init_io(). If you have defined
492 * PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't
493 * necessarily available.
494 */
495 void PNGAPI
496 png_init_io(png_structp png_ptr, png_FILE_p fp)
497 {
498 png_debug(1, "in png_init_io");
499
500 if (png_ptr == NULL)
501 return;
502
503 png_ptr->io_ptr = (png_voidp)fp;
504 }
505 # endif
506
507 # ifdef PNG_TIME_RFC1123_SUPPORTED
508 /* Convert the supplied time into an RFC 1123 string suitable for use in
509 * a "Creation Time" or other text-based time string.
510 */
511 png_const_charp PNGAPI
512 png_convert_to_rfc1123(png_structp png_ptr, png_const_timep ptime)
513 {
514 static PNG_CONST char short_months[12][4] =
515 {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
516 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
517
518 if (png_ptr == NULL)
519 return (NULL);
520
521 if (png_ptr->time_buffer == NULL)
522 {
523 png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*
524 png_sizeof(char)));
525 }
526
527 # ifdef USE_FAR_KEYWORD
528 {
529 char near_time_buf[29];
530 png_snprintf6(near_time_buf, 29, "%d %s %d %02d:%02d:%02d +0000",
531 ptime->day % 32, short_months[(ptime->month - 1) % 12],
532 ptime->year, ptime->hour % 24, ptime->minute % 60,
533 ptime->second % 61);
534 png_memcpy(png_ptr->time_buffer, near_time_buf,
535 29*png_sizeof(char));
536 }
537 # else
538 png_snprintf6(png_ptr->time_buffer, 29, "%d %s %d %02d:%02d:%02d +0000",
539 ptime->day % 32, short_months[(ptime->month - 1) % 12],
540 ptime->year, ptime->hour % 24, ptime->minute % 60,
541 ptime->second % 61);
542 # endif
543 return png_ptr->time_buffer;
544 }
545 # endif /* PNG_TIME_RFC1123_SUPPORTED */
546
547 #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
548
549 png_const_charp PNGAPI
550 png_get_copyright(png_const_structp png_ptr)
551 {
552 PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */
553 #ifdef PNG_STRING_COPYRIGHT
554 return PNG_STRING_COPYRIGHT
555 #else
556 # ifdef __STDC__
557 return PNG_STRING_NEWLINE \
558 "libpng version 1.5.1 - February 3, 2011" PNG_STRING_NEWLINE \
559 "Copyright (c) 1998-2011 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \
560 "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
561 "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \
562 PNG_STRING_NEWLINE;
563 # else
564 return "libpng version 1.5.1 - February 3, 2011\
565 Copyright (c) 1998-2011 Glenn Randers-Pehrson\
566 Copyright (c) 1996-1997 Andreas Dilger\
567 Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.";
568 # endif
569 #endif
570 }
571
572 /* The following return the library version as a short string in the
573 * format 1.0.0 through 99.99.99zz. To get the version of *.h files
574 * used with your application, print out PNG_LIBPNG_VER_STRING, which
575 * is defined in png.h.
576 * Note: now there is no difference between png_get_libpng_ver() and
577 * png_get_header_ver(). Due to the version_nn_nn_nn typedef guard,
578 * it is guaranteed that png.c uses the correct version of png.h.
579 */
580 png_const_charp PNGAPI
581 png_get_libpng_ver(png_const_structp png_ptr)
582 {
583 /* Version of *.c files used when building libpng */
584 return png_get_header_ver(png_ptr);
585 }
586
587 png_const_charp PNGAPI
588 png_get_header_ver(png_const_structp png_ptr)
589 {
590 /* Version of *.h files used when building libpng */
591 PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */
592 return PNG_LIBPNG_VER_STRING;
593 }
594
595 png_const_charp PNGAPI
596 png_get_header_version(png_const_structp png_ptr)
597 {
598 /* Returns longer string containing both version and date */
599 PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */
600 #ifdef __STDC__
601 return PNG_HEADER_VERSION_STRING
602 # ifndef PNG_READ_SUPPORTED
603 " (NO READ SUPPORT)"
604 # endif
605 PNG_STRING_NEWLINE;
606 #else
607 return PNG_HEADER_VERSION_STRING;
608 #endif
609 }
610
611 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
612 # ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
613 int PNGAPI
614 png_handle_as_unknown(png_structp png_ptr, png_const_bytep chunk_name)
615 {
616 /* Check chunk_name and return "keep" value if it's on the list, else 0 */
617 int i;
618 png_bytep p;
619 if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list<=0)
620 return 0;
621
622 p = png_ptr->chunk_list + png_ptr->num_chunk_list*5 - 5;
623 for (i = png_ptr->num_chunk_list; i; i--, p -= 5)
624 if (!png_memcmp(chunk_name, p, 4))
625 return ((int)*(p + 4));
626 return 0;
627 }
628 # endif
629 #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
630
631 #ifdef PNG_READ_SUPPORTED
632 /* This function, added to libpng-1.0.6g, is untested. */
633 int PNGAPI
634 png_reset_zstream(png_structp png_ptr)
635 {
636 if (png_ptr == NULL)
637 return Z_STREAM_ERROR;
638
639 return (inflateReset(&png_ptr->zstream));
640 }
641 #endif /* PNG_READ_SUPPORTED */
642
643 /* This function was added to libpng-1.0.7 */
644 png_uint_32 PNGAPI
645 png_access_version_number(void)
646 {
647 /* Version of *.c files used when building libpng */
648 return((png_uint_32)PNG_LIBPNG_VER);
649 }
650
651
652
653 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
654 # ifdef PNG_SIZE_T
655 /* Added at libpng version 1.2.6 */
656 PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size));
657 png_size_t PNGAPI
658 png_convert_size(size_t size)
659 {
660 if (size > (png_size_t)-1)
661 PNG_ABORT(); /* We haven't got access to png_ptr, so no png_error() */
662
663 return ((png_size_t)size);
664 }
665 # endif /* PNG_SIZE_T */
666
667 /* Added at libpng version 1.2.34 and 1.4.0 (moved from pngset.c) */
668 # ifdef PNG_CHECK_cHRM_SUPPORTED
669
670 int /* PRIVATE */
671 png_check_cHRM_fixed(png_structp png_ptr,
672 png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,
673 png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,
674 png_fixed_point blue_x, png_fixed_point blue_y)
675 {
676 int ret = 1;
677 unsigned long xy_hi,xy_lo,yx_hi,yx_lo;
678
679 png_debug(1, "in function png_check_cHRM_fixed");
680
681 if (png_ptr == NULL)
682 return 0;
683
684 if (white_x < 0 || white_y <= 0 ||
685 red_x < 0 || red_y < 0 ||
686 green_x < 0 || green_y < 0 ||
687 blue_x < 0 || blue_y < 0)
688 {
689 png_warning(png_ptr,
690 "Ignoring attempt to set negative chromaticity value");
691 ret = 0;
692 }
693 if (white_x > (png_fixed_point)PNG_UINT_31_MAX ||
694 white_y > (png_fixed_point)PNG_UINT_31_MAX ||
695 red_x > (png_fixed_point)PNG_UINT_31_MAX ||
696 red_y > (png_fixed_point)PNG_UINT_31_MAX ||
697 green_x > (png_fixed_point)PNG_UINT_31_MAX ||
698 green_y > (png_fixed_point)PNG_UINT_31_MAX ||
699 blue_x > (png_fixed_point)PNG_UINT_31_MAX ||
700 blue_y > (png_fixed_point)PNG_UINT_31_MAX )
701 {
702 png_warning(png_ptr,
703 "Ignoring attempt to set chromaticity value exceeding 21474.83");
704 ret = 0;
705 }
706 if (white_x > 100000L - white_y)
707 {
708 png_warning(png_ptr, "Invalid cHRM white point");
709 ret = 0;
710 }
711
712 if (red_x > 100000L - red_y)
713 {
714 png_warning(png_ptr, "Invalid cHRM red point");
715 ret = 0;
716 }
717
718 if (green_x > 100000L - green_y)
719 {
720 png_warning(png_ptr, "Invalid cHRM green point");
721 ret = 0;
722 }
723
724 if (blue_x > 100000L - blue_y)
725 {
726 png_warning(png_ptr, "Invalid cHRM blue point");
727 ret = 0;
728 }
729
730 png_64bit_product(green_x - red_x, blue_y - red_y, &xy_hi, &xy_lo);
731 png_64bit_product(green_y - red_y, blue_x - red_x, &yx_hi, &yx_lo);
732
733 if (xy_hi == yx_hi && xy_lo == yx_lo)
734 {
735 png_warning(png_ptr,
736 "Ignoring attempt to set cHRM RGB triangle with zero area");
737 ret = 0;
738 }
739
740 return ret;
741 }
742 # endif /* PNG_CHECK_cHRM_SUPPORTED */
743
744 void /* PRIVATE */
745 png_check_IHDR(png_structp png_ptr,
746 png_uint_32 width, png_uint_32 height, int bit_depth,
747 int color_type, int interlace_type, int compression_type,
748 int filter_type)
749 {
750 int error = 0;
751
752 /* Check for width and height valid values */
753 if (width == 0)
754 {
755 png_warning(png_ptr, "Image width is zero in IHDR");
756 error = 1;
757 }
758
759 if (height == 0)
760 {
761 png_warning(png_ptr, "Image height is zero in IHDR");
762 error = 1;
763 }
764
765 # ifdef PNG_SET_USER_LIMITS_SUPPORTED
766 if (width > png_ptr->user_width_max || width > PNG_USER_WIDTH_MAX)
767
768 # else
769 if (width > PNG_USER_WIDTH_MAX)
770 # endif
771 {
772 png_warning(png_ptr, "Image width exceeds user limit in IHDR");
773 error = 1;
774 }
775
776 # ifdef PNG_SET_USER_LIMITS_SUPPORTED
777 if (height > png_ptr->user_height_max || height > PNG_USER_HEIGHT_MAX)
778 # else
779 if (height > PNG_USER_HEIGHT_MAX)
780 # endif
781 {
782 png_warning(png_ptr, "Image height exceeds user limit in IHDR");
783 error = 1;
784 }
785
786 if (width > PNG_UINT_31_MAX)
787 {
788 png_warning(png_ptr, "Invalid image width in IHDR");
789 error = 1;
790 }
791
792 if (height > PNG_UINT_31_MAX)
793 {
794 png_warning(png_ptr, "Invalid image height in IHDR");
795 error = 1;
796 }
797
798 if (width > (PNG_UINT_32_MAX
799 >> 3) /* 8-byte RGBA pixels */
800 - 48 /* bigrowbuf hack */
801 - 1 /* filter byte */
802 - 7*8 /* rounding of width to multiple of 8 pixels */
803 - 8) /* extra max_pixel_depth pad */
804 png_warning(png_ptr, "Width is too large for libpng to process pixels");
805
806 /* Check other values */
807 if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 &&
808 bit_depth != 8 && bit_depth != 16)
809 {
810 png_warning(png_ptr, "Invalid bit depth in IHDR");
811 error = 1;
812 }
813
814 if (color_type < 0 || color_type == 1 ||
815 color_type == 5 || color_type > 6)
816 {
817 png_warning(png_ptr, "Invalid color type in IHDR");
818 error = 1;
819 }
820
821 if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) ||
822 ((color_type == PNG_COLOR_TYPE_RGB ||
823 color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
824 color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8))
825 {
826 png_warning(png_ptr, "Invalid color type/bit depth combination in IHDR");
827 error = 1;
828 }
829
830 if (interlace_type >= PNG_INTERLACE_LAST)
831 {
832 png_warning(png_ptr, "Unknown interlace method in IHDR");
833 error = 1;
834 }
835
836 if (compression_type != PNG_COMPRESSION_TYPE_BASE)
837 {
838 png_warning(png_ptr, "Unknown compression method in IHDR");
839 error = 1;
840 }
841
842 # ifdef PNG_MNG_FEATURES_SUPPORTED
843 /* Accept filter_method 64 (intrapixel differencing) only if
844 * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
845 * 2. Libpng did not read a PNG signature (this filter_method is only
846 * used in PNG datastreams that are embedded in MNG datastreams) and
847 * 3. The application called png_permit_mng_features with a mask that
848 * included PNG_FLAG_MNG_FILTER_64 and
849 * 4. The filter_method is 64 and
850 * 5. The color_type is RGB or RGBA
851 */
852 if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) &&
853 png_ptr->mng_features_permitted)
854 png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");
855
856 if (filter_type != PNG_FILTER_TYPE_BASE)
857 {
858 if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
859 (filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&
860 ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&
861 (color_type == PNG_COLOR_TYPE_RGB ||
862 color_type == PNG_COLOR_TYPE_RGB_ALPHA)))
863 {
864 png_warning(png_ptr, "Unknown filter method in IHDR");
865 error = 1;
866 }
867
868 if (png_ptr->mode & PNG_HAVE_PNG_SIGNATURE)
869 {
870 png_warning(png_ptr, "Invalid filter method in IHDR");
871 error = 1;
872 }
873 }
874
875 # else
876 if (filter_type != PNG_FILTER_TYPE_BASE)
877 {
878 png_warning(png_ptr, "Unknown filter method in IHDR");
879 error = 1;
880 }
881 # endif
882
883 if (error == 1)
884 png_error(png_ptr, "Invalid IHDR data");
885 }
886
887 #if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED)
888 /* ASCII to fp functions */
889 /* Check an ASCII formated floating point value, see the more detailed
890 * comments in pngpriv.h
891 */
892 /* The following is used internally to preserve the 'valid' flag */
893 #define png_fp_add(state, flags) ((state) |= (flags))
894 #define png_fp_set(state, value)\
895 ((state) = (value) | ((state) & PNG_FP_WAS_VALID))
896
897 /* Internal type codes: bits above the base state! */
898 #define PNG_FP_SIGN 0 /* [+-] */
899 #define PNG_FP_DOT 4 /* . */
900 #define PNG_FP_DIGIT 8 /* [0123456789] */
901 #define PNG_FP_E 12 /* [Ee] */
902
903 int /* PRIVATE */
904 png_check_fp_number(png_const_charp string, png_size_t size, int *statep,
905 png_size_tp whereami)
906 {
907 int state = *statep;
908 png_size_t i = *whereami;
909
910 while (i < size)
911 {
912 int type;
913 /* First find the type of the next character */
914 {
915 char ch = string[i];
916
917 if (ch >= 48 && ch <= 57)
918 type = PNG_FP_DIGIT;
919
920 else switch (ch)
921 {
922 case 43: case 45: type = PNG_FP_SIGN; break;
923 case 46: type = PNG_FP_DOT; break;
924 case 69: case 101: type = PNG_FP_E; break;
925 default: goto PNG_FP_End;
926 }
927 }
928
929 /* Now deal with this type according to the current
930 * state, the type is arranged to not overlap the
931 * bits of the PNG_FP_STATE.
932 */
933 switch ((state & PNG_FP_STATE) + type)
934 {
935 case PNG_FP_INTEGER + PNG_FP_SIGN:
936 if (state & PNG_FP_SAW_ANY)
937 goto PNG_FP_End; /* not a part of the number */
938
939 png_fp_add(state, PNG_FP_SAW_SIGN);
940 break;
941
942 case PNG_FP_INTEGER + PNG_FP_DOT:
943 /* Ok as trailer, ok as lead of fraction. */
944 if (state & PNG_FP_SAW_DOT) /* two dots */
945 goto PNG_FP_End;
946
947 else if (state & PNG_FP_SAW_DIGIT) /* trailing dot? */
948 png_fp_add(state, PNG_FP_SAW_DOT);
949
950 else
951 png_fp_set(state, PNG_FP_FRACTION | PNG_FP_SAW_DOT);
952
953 break;
954
955 case PNG_FP_INTEGER + PNG_FP_DIGIT:
956 if (state & PNG_FP_SAW_DOT) /* delayed fraction */
957 png_fp_set(state, PNG_FP_FRACTION | PNG_FP_SAW_DOT);
958
959 png_fp_add(state, PNG_FP_SAW_DIGIT + PNG_FP_WAS_VALID);
960
961 break;
962 case PNG_FP_INTEGER + PNG_FP_E:
963 if ((state & PNG_FP_SAW_DIGIT) == 0)
964 goto PNG_FP_End;
965
966 png_fp_set(state, PNG_FP_EXPONENT);
967
968 break;
969
970 /* case PNG_FP_FRACTION + PNG_FP_SIGN:
971 goto PNG_FP_End; ** no sign in exponent */
972
973 /* case PNG_FP_FRACTION + PNG_FP_DOT:
974 goto PNG_FP_End; ** Because SAW_DOT is always set */
975
976 case PNG_FP_FRACTION + PNG_FP_DIGIT:
977 png_fp_add(state, PNG_FP_SAW_DIGIT + PNG_FP_WAS_VALID);
978 break;
979
980 case PNG_FP_FRACTION + PNG_FP_E:
981 /* This is correct because the trailing '.' on an
982 * integer is handled above - so we can only get here
983 * with the sequence ".E" (with no preceding digits).
984 */
985 if ((state & PNG_FP_SAW_DIGIT) == 0)
986 goto PNG_FP_End;
987
988 png_fp_set(state, PNG_FP_EXPONENT);
989
990 break;
991
992 case PNG_FP_EXPONENT + PNG_FP_SIGN:
993 if (state & PNG_FP_SAW_ANY)
994 goto PNG_FP_End; /* not a part of the number */
995
996 png_fp_add(state, PNG_FP_SAW_SIGN);
997
998 break;
999
1000 /* case PNG_FP_EXPONENT + PNG_FP_DOT:
1001 goto PNG_FP_End; */
1002
1003 case PNG_FP_EXPONENT + PNG_FP_DIGIT:
1004 png_fp_add(state, PNG_FP_SAW_DIGIT + PNG_FP_WAS_VALID);
1005
1006 break;
1007
1008 /* case PNG_FP_EXPONEXT + PNG_FP_E:
1009 goto PNG_FP_End; */
1010
1011 default: goto PNG_FP_End; /* I.e. break 2 */
1012 }
1013
1014 /* The character seems ok, continue. */
1015 ++i;
1016 }
1017
1018 PNG_FP_End:
1019 /* Here at the end, update the state and return the correct
1020 * return code.
1021 */
1022 *statep = state;
1023 *whereami = i;
1024
1025 return (state & PNG_FP_SAW_DIGIT) != 0;
1026 }
1027
1028
1029 /* The same but for a complete string. */
1030 int
1031 png_check_fp_string(png_const_charp string, png_size_t size)
1032 {
1033 int state=0;
1034 png_size_t char_index=0;
1035
1036 return png_check_fp_number(string, size, &state, &char_index) &&
1037 (char_index == size || string[char_index] == 0);
1038 }
1039 #endif /* pCAL or sCAL */
1040
1041 #ifdef PNG_READ_sCAL_SUPPORTED
1042 # ifdef PNG_FLOATING_POINT_SUPPORTED
1043 /* Utility used below - a simple accurate power of ten from an integral
1044 * exponent.
1045 */
1046 static double
1047 png_pow10(int power)
1048 {
1049 int recip = 0;
1050 double d = 1;
1051
1052 /* Handle negative exponent with a reciprocal at the end because
1053 * 10 is exact whereas .1 is inexact in base 2
1054 */
1055 if (power < 0)
1056 {
1057 if (power < DBL_MIN_10_EXP) return 0;
1058 recip = 1, power = -power;
1059 }
1060
1061 if (power > 0)
1062 {
1063 /* Decompose power bitwise. */
1064 double mult = 10;
1065 do
1066 {
1067 if (power & 1) d *= mult;
1068 mult *= mult;
1069 power >>= 1;
1070 }
1071 while (power > 0);
1072
1073 if (recip) d = 1/d;
1074 }
1075 /* else power is 0 and d is 1 */
1076
1077 return d;
1078 }
1079
1080 /* Function to format a floating point value in ASCII with a given
1081 * precision.
1082 */
1083 void /* PRIVATE */
1084 png_ascii_from_fp(png_structp png_ptr, png_charp ascii, png_size_t size,
1085 double fp, unsigned int precision)
1086 {
1087 /* We use standard functions from math.h, but not printf because
1088 * that would require stdio. The caller must supply a buffer of
1089 * sufficient size or we will png_error. The tests on size and
1090 * the space in ascii[] consumed are indicated below.
1091 */
1092 if (precision < 1)
1093 precision = DBL_DIG;
1094
1095 /* Enforce the limit of the implementation precision too. */
1096 if (precision > DBL_DIG+1)
1097 precision = DBL_DIG+1;
1098
1099 /* Basic sanity checks */
1100 if (size >= precision+5) /* See the requirements below. */
1101 {
1102 if (fp < 0)
1103 {
1104 fp = -fp;
1105 *ascii++ = 45; /* '-' PLUS 1 TOTAL 1*/
1106 --size;
1107 }
1108
1109 if (fp >= DBL_MIN && fp <= DBL_MAX)
1110 {
1111 int exp_b10; /* A base 10 exponent */
1112 double base; /* 10^exp_b10 */
1113
1114 /* First extract a base 10 exponent of the number,
1115 * the calculation below rounds down when converting
1116 * from base 2 to base 10 (multiply by log10(2) -
1117 * 0.3010, but 77/256 is 0.3008, so exp_b10 needs to
1118 * be increased. Note that the arithmetic shift
1119 * performs a floor() unlike C arithmetic - using a
1120 * C multiply would break the following for negative
1121 * exponents.
1122 */
1123 (void)frexp(fp, &exp_b10); /* exponent to base 2 */
1124
1125 exp_b10 = (exp_b10 * 77) >> 8; /* <= exponent to base 10 */
1126
1127 /* Avoid underflow here. */
1128 base = png_pow10(exp_b10); /* May underflow */
1129
1130 while (base < DBL_MIN || base < fp)
1131 {
1132 /* And this may overflow. */
1133 double test = png_pow10(exp_b10+1);
1134
1135 if (test <= DBL_MAX)
1136 ++exp_b10, base = test;
1137
1138 else
1139 break;
1140 }
1141
1142 /* Normalize fp and correct exp_b10, after this fp is in the
1143 * range [.1,1) and exp_b10 is both the exponent and the digit
1144 * *before* which the decimal point should be inserted
1145 * (starting with 0 for the first digit). Note that this
1146 * works even if 10^exp_b10 is out of range because of the
1147 * test on DBL_MAX above.
1148 */
1149 fp /= base;
1150 while (fp >= 1) fp /= 10, ++exp_b10;
1151
1152 /* Because of the code above fp may, at this point, be
1153 * less than .1, this is ok because the code below can
1154 * handle the leading zeros this generates, so no attempt
1155 * is made to correct that here.
1156 */
1157
1158 {
1159 int czero, clead, cdigits;
1160 char exponent[10];
1161
1162 /* Allow up to two leading zeros - this will not lengthen
1163 * the number compared to using E-n.
1164 */
1165 if (exp_b10 < 0 && exp_b10 > -3) /* PLUS 3 TOTAL 4 */
1166 {
1167 czero = -exp_b10; /* PLUS 2 digits: TOTAL 3 */
1168 exp_b10 = 0; /* Dot added below before first output. */
1169 }
1170 else
1171 czero = 0; /* No zeros to add */
1172
1173 /* Generate the digit list, stripping trailing zeros and
1174 * inserting a '.' before a digit if the exponent is 0.
1175 */
1176 clead = czero; /* Count of leading zeros */
1177 cdigits = 0; /* Count of digits in list. */
1178
1179 do
1180 {
1181 double d;
1182
1183 fp *= 10;
1184 /* Use modf here, not floor and subtract, so that
1185 * the separation is done in one step. At the end
1186 * of the loop don't break the number into parts so
1187 * that the final digit is rounded.
1188 */
1189 if (cdigits+czero-clead+1 < (int)precision)
1190 fp = modf(fp, &d);
1191
1192 else
1193 {
1194 d = floor(fp + .5);
1195
1196 if (d > 9)
1197 {
1198 /* Rounding up to 10, handle that here. */
1199 if (czero > 0)
1200 {
1201 --czero, d = 1;
1202 if (cdigits == 0) --clead;
1203 }
1204 else
1205 {
1206 while (cdigits > 0 && d > 9)
1207 {
1208 int ch = *--ascii;
1209
1210 if (exp_b10 != (-1))
1211 ++exp_b10;
1212
1213 else if (ch == 46)
1214 {
1215 ch = *--ascii, ++size;
1216 /* Advance exp_b10 to '1', so that the
1217 * decimal point happens after the
1218 * previous digit.
1219 */
1220 exp_b10 = 1;
1221 }
1222
1223 --cdigits;
1224 d = ch - 47; /* I.e. 1+(ch-48) */
1225 }
1226
1227 /* Did we reach the beginning? If so adjust the
1228 * exponent but take into account the leading
1229 * decimal point.
1230 */
1231 if (d > 9) /* cdigits == 0 */
1232 {
1233 if (exp_b10 == (-1))
1234 {
1235 /* Leading decimal point (plus zeros?), if
1236 * we lose the decimal point here it must
1237 * be reentered below.
1238 */
1239 int ch = *--ascii;
1240
1241 if (ch == 46)
1242 ++size, exp_b10 = 1;
1243
1244 /* Else lost a leading zero, so 'exp_b10' is
1245 * still ok at (-1)
1246 */
1247 }
1248 else
1249 ++exp_b10;
1250
1251 /* In all cases we output a '1' */
1252 d = 1;
1253 }
1254 }
1255 }
1256 fp = 0; /* Guarantees termination below. */
1257 }
1258
1259 if (d == 0)
1260 {
1261 ++czero;
1262 if (cdigits == 0) ++clead;
1263 }
1264 else
1265 {
1266 /* Included embedded zeros in the digit count. */
1267 cdigits += czero - clead;
1268 clead = 0;
1269
1270 while (czero > 0)
1271 {
1272 /* exp_b10 == (-1) means we just output the decimal
1273 * place - after the DP don't adjust 'exp_b10' any
1274 * more!
1275 */
1276 if (exp_b10 != (-1))
1277 {
1278 if (exp_b10 == 0) *ascii++ = 46, --size;
1279 /* PLUS 1: TOTAL 4 */
1280 --exp_b10;
1281 }
1282 *ascii++ = 48, --czero;
1283 }
1284
1285 if (exp_b10 != (-1))
1286 {
1287 if (exp_b10 == 0) *ascii++ = 46, --size; /* counted
1288 above */
1289 --exp_b10;
1290 }
1291 *ascii++ = (char)(48 + (int)d), ++cdigits;
1292 }
1293 }
1294 while (cdigits+czero-clead < (int)precision && fp > DBL_MIN);
1295
1296 /* The total output count (max) is now 4+precision */
1297
1298 /* Check for an exponent, if we don't need one we are
1299 * done and just need to terminate the string. At
1300 * this point exp_b10==(-1) is effectively if flag - it got
1301 * to '-1' because of the decrement after outputing
1302 * the decimal point above (the exponent required is
1303 * *not* -1!)
1304 */
1305 if (exp_b10 >= (-1) && exp_b10 <= 2)
1306 {
1307 /* The following only happens if we didn't output the
1308 * leading zeros above for negative exponent, so this
1309 * doest add to the digit requirement. Note that the
1310 * two zeros here can only be output if the two leading
1311 * zeros were *not* output, so this doesn't increase
1312 * the output count.
1313 */
1314 while (--exp_b10 >= 0) *ascii++ = 48;
1315
1316 *ascii = 0;
1317
1318 /* Total buffer requirement (including the '\0') is
1319 * 5+precision - see check at the start.
1320 */
1321 return;
1322 }
1323
1324 /* Here if an exponent is required, adjust size for
1325 * the digits we output but did not count. The total
1326 * digit output here so far is at most 1+precision - no
1327 * decimal point and no leading or trailing zeros have
1328 * been output.
1329 */
1330 size -= cdigits;
1331
1332 *ascii++ = 69, --size; /* 'E': PLUS 1 TOTAL 2+precision*/
1333 if (exp_b10 < 0)
1334 {
1335 *ascii++ = 45, --size; /* '-': PLUS 1 TOTAL 3+precision */
1336 exp_b10 = -exp_b10;
1337 }
1338
1339 cdigits = 0;
1340
1341 while (exp_b10 > 0)
1342 {
1343 exponent[cdigits++] = (char)(48 + exp_b10 % 10);
1344 exp_b10 /= 10;
1345 }
1346
1347 /* Need another size check here for the exponent digits, so
1348 * this need not be considered above.
1349 */
1350 if ((int)size > cdigits)
1351 {
1352 while (cdigits > 0) *ascii++ = exponent[--cdigits];
1353
1354 *ascii = 0;
1355
1356 return;
1357 }
1358 }
1359 }
1360 else if (!(fp >= DBL_MIN))
1361 {
1362 *ascii++ = 48; /* '0' */
1363 *ascii = 0;
1364 return;
1365 }
1366 else
1367 {
1368 *ascii++ = 105; /* 'i' */
1369 *ascii++ = 110; /* 'n' */
1370 *ascii++ = 102; /* 'f' */
1371 *ascii = 0;
1372 return;
1373 }
1374 }
1375
1376 /* Here on buffer too small. */
1377 png_error(png_ptr, "ASCII conversion buffer too small");
1378 }
1379
1380 # endif /* FLOATING_POINT */
1381
1382 # ifdef PNG_FIXED_POINT_SUPPORTED
1383 /* Function to format a fixed point value in ASCII.
1384 */
1385 void /* PRIVATE */
1386 png_ascii_from_fixed(png_structp png_ptr, png_charp ascii, png_size_t size,
1387 png_fixed_point fp)
1388 {
1389 /* Require space for 10 decimal digits, a decimal point, a minus sign and a
1390 * trailing \0, 13 characters:
1391 */
1392 if (size > 12)
1393 {
1394 png_uint_32 num;
1395
1396 /* Avoid overflow here on the minimum integer. */
1397 if (fp < 0)
1398 *ascii++ = 45, --size, num = -fp;
1399 else
1400 num = fp;
1401
1402 if (num <= 0x80000000U) /* else overflowed */
1403 {
1404 unsigned int ndigits = 0, first = 16/*flag value*/;
1405 char digits[10];
1406
1407 while (num)
1408 {
1409 /* Split the low digit off num: */
1410 unsigned int tmp = num/10;
1411 num -= tmp*10;
1412 digits[ndigits++] = (char)(48 + num);
1413 /* Record the first non-zero digit, note that this is a number
1414 * starting at 1, it's not actually the array index.
1415 */
1416 if (first == 16 && num > 0)
1417 first = ndigits;
1418 num = tmp;
1419 }
1420
1421 if (ndigits > 0)
1422 {
1423 while (ndigits > 5) *ascii++ = digits[--ndigits];
1424 /* The remaining digits are fractional digits, ndigits is '5' or
1425 * smaller at this point. It is certainly not zero. Check for a
1426 * non-zero fractional digit:
1427 */
1428 if (first <= 5)
1429 {
1430 unsigned int i;
1431 *ascii++ = 46; /* decimal point */
1432 /* ndigits may be <5 for small numbers, output leading zeros
1433 * then ndigits digits to first:
1434 */
1435 i = 5;
1436 while (ndigits < i) *ascii++ = 48, --i;
1437 while (ndigits >= first) *ascii++ = digits[--ndigits];
1438 /* Don't output the trailing zeros! */
1439 }
1440 }
1441 else
1442 *ascii++ = 48;
1443
1444 /* And null terminate the string: */
1445 *ascii = 0;
1446 return;
1447 }
1448 }
1449
1450 /* Here on buffer too small. */
1451 png_error(png_ptr, "ASCII conversion buffer too small");
1452 }
1453 # endif /* FIXED_POINT */
1454 #endif /* READ_SCAL */
1455
1456 #if defined(PNG_FLOATING_POINT_SUPPORTED) && \
1457 !defined(PNG_FIXED_POINT_MACRO_SUPPORTED)
1458 png_fixed_point
1459 png_fixed(png_structp png_ptr, double fp, png_const_charp text)
1460 {
1461 double r = floor(100000 * fp + .5);
1462
1463 if (r > 2147483647. || r < -2147483648.)
1464 png_fixed_error(png_ptr, text);
1465
1466 return (png_fixed_point)r;
1467 }
1468 #endif
1469
1470 #if defined(PNG_READ_GAMMA_SUPPORTED) || \
1471 defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG__READ_pHYs_SUPPORTED)
1472 /* muldiv functions */
1473 /* This API takes signed arguments and rounds the result to the nearest
1474 * integer (or, for a fixed point number - the standard argument - to
1475 * the nearest .00001). Overflow and divide by zero are signalled in
1476 * the result, a boolean - true on success, false on overflow.
1477 */
1478 int
1479 png_muldiv(png_fixed_point_p res, png_fixed_point a, png_int_32 times,
1480 png_int_32 divisor)
1481 {
1482 /* Return a * times / divisor, rounded. */
1483 if (divisor != 0)
1484 {
1485 if (a == 0 || times == 0)
1486 {
1487 *res = 0;
1488 return 1;
1489 }
1490 else
1491 {
1492 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
1493 double r = a;
1494 r *= times;
1495 r /= divisor;
1496 r = floor(r+.5);
1497
1498 /* A png_fixed_point is a 32 bit integer. */
1499 if (r <= 2147483647. && r >= -2147483648.)
1500 {
1501 *res = (png_fixed_point)r;
1502 return 1;
1503 }
1504 #else
1505 int negative = 0;
1506 png_uint_32 A, T, D;
1507 png_uint_32 s16, s32, s00;
1508
1509 if (a < 0)
1510 negative = 1, A = -a;
1511 else
1512 A = a;
1513
1514 if (times < 0)
1515 negative = !negative, T = -times;
1516 else
1517 T = times;
1518
1519 if (divisor < 0)
1520 negative = !negative, D = -divisor;
1521 else
1522 D = divisor;
1523
1524 /* Following can't overflow because the arguments only
1525 * have 31 bits each, however the result may be 32 bits.
1526 */
1527 s16 = (A >> 16) * (T & 0xffff) +
1528 (A & 0xffff) * (T >> 16);
1529 /* Can't overflow because the a*times bit is only 30
1530 * bits at most.
1531 */
1532 s32 = (A >> 16) * (T >> 16) + (s16 >> 16);
1533 s00 = (A & 0xffff) * (T & 0xffff);
1534
1535 s16 = (s16 & 0xffff) << 16;
1536 s00 += s16;
1537
1538 if (s00 < s16)
1539 ++s32; /* carry */
1540
1541 if (s32 < D) /* else overflow */
1542 {
1543 /* s32.s00 is now the 64 bit product, do a standard
1544 * division, we know that s32 < D, so the maximum
1545 * required shift is 31.
1546 */
1547 int bitshift = 32;
1548 png_fixed_point result = 0; /* NOTE: signed */
1549
1550 while (--bitshift >= 0)
1551 {
1552 png_uint_32 d32, d00;
1553
1554 if (bitshift > 0)
1555 d32 = D >> (32-bitshift), d00 = D << bitshift;
1556
1557 else
1558 d32 = 0, d00 = D;
1559
1560 if (s32 > d32)
1561 {
1562 if (s00 < d00) --s32; /* carry */
1563 s32 -= d32, s00 -= d00, result += 1<<bitshift;
1564 }
1565
1566 else
1567 if (s32 == d32 && s00 >= d00)
1568 s32 = 0, s00 -= d00, result += 1<<bitshift;
1569 }
1570
1571 /* Handle the rounding. */
1572 if (s00 >= (D >> 1))
1573 ++result;
1574
1575 if (negative)
1576 result = -result;
1577
1578 /* Check for overflow. */
1579 if ((negative && result <= 0) || (!negative && result >= 0))
1580 {
1581 *res = result;
1582 return 1;
1583 }
1584 }
1585 #endif
1586 }
1587 }
1588
1589 return 0;
1590 }
1591 #endif /* READ_GAMMA || INCH_CONVERSIONS */
1592
1593 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED)
1594 /* The following is for when the caller doesn't much care about the
1595 * result.
1596 */
1597 png_fixed_point
1598 png_muldiv_warn(png_structp png_ptr, png_fixed_point a, png_int_32 times,
1599 png_int_32 divisor)
1600 {
1601 png_fixed_point result;
1602
1603 if (png_muldiv(&result, a, times, divisor))
1604 return result;
1605
1606 png_warning(png_ptr, "fixed point overflow ignored");
1607 return 0;
1608 }
1609 #endif
1610
1611 #ifdef PNG_READ_GAMMA_SUPPORTED /* more fixed point functions for gammma */
1612 /* Calculate a reciprocal, return 0 on div-by-zero or overflow. */
1613 png_fixed_point
1614 png_reciprocal(png_fixed_point a)
1615 {
1616 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
1617 double r = floor(1E10/a+.5);
1618
1619 if (r <= 2147483647. && r >= -2147483648.)
1620 return (png_fixed_point)r;
1621 #else
1622 png_fixed_point res;
1623
1624 if (png_muldiv(&res, 100000, 100000, a))
1625 return res;
1626 #endif
1627
1628 return 0; /* error/overflow */
1629 }
1630
1631 /* A local convenience routine. */
1632 static png_fixed_point
1633 png_product2(png_fixed_point a, png_fixed_point b)
1634 {
1635 /* The required result is 1/a * 1/b; the following preserves accuracy. */
1636 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
1637 double r = a * 1E-5;
1638 r *= b;
1639 r = floor(r+.5);
1640
1641 if (r <= 2147483647. && r >= -2147483648.)
1642 return (png_fixed_point)r;
1643 #else
1644 png_fixed_point res;
1645
1646 if (png_muldiv(&res, a, b, 100000))
1647 return res;
1648 #endif
1649
1650 return 0; /* overflow */
1651 }
1652
1653 /* The inverse of the above. */
1654 png_fixed_point
1655 png_reciprocal2(png_fixed_point a, png_fixed_point b)
1656 {
1657 /* The required result is 1/a * 1/b; the following preserves accuracy. */
1658 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
1659 double r = 1E15/a;
1660 r /= b;
1661 r = floor(r+.5);
1662
1663 if (r <= 2147483647. && r >= -2147483648.)
1664 return (png_fixed_point)r;
1665 #else
1666 /* This may overflow because the range of png_fixed_point isn't symmetric,
1667 * but this API is only used for the product of file and screen gamma so it
1668 * doesn't matter that the smallest number it can produce is 1/21474, not
1669 * 1/100000
1670 */
1671 png_fixed_point res = png_product2(a, b);
1672
1673 if (res != 0)
1674 return png_reciprocal(res);
1675 #endif
1676
1677 return 0; /* overflow */
1678 }
1679 #endif /* READ_GAMMA */
1680
1681 #ifdef PNG_CHECK_cHRM_SUPPORTED
1682 /* Added at libpng version 1.2.34 (Dec 8, 2008) and 1.4.0 (Jan 2,
1683 * 2010: moved from pngset.c) */
1684 /*
1685 * Multiply two 32-bit numbers, V1 and V2, using 32-bit
1686 * arithmetic, to produce a 64 bit result in the HI/LO words.
1687 *
1688 * A B
1689 * x C D
1690 * ------
1691 * AD || BD
1692 * AC || CB || 0
1693 *
1694 * where A and B are the high and low 16-bit words of V1,
1695 * C and D are the 16-bit words of V2, AD is the product of
1696 * A and D, and X || Y is (X << 16) + Y.
1697 */
1698
1699 void /* PRIVATE */
1700 png_64bit_product (long v1, long v2, unsigned long *hi_product,
1701 unsigned long *lo_product)
1702 {
1703 int a, b, c, d;
1704 long lo, hi, x, y;
1705
1706 a = (v1 >> 16) & 0xffff;
1707 b = v1 & 0xffff;
1708 c = (v2 >> 16) & 0xffff;
1709 d = v2 & 0xffff;
1710
1711 lo = b * d; /* BD */
1712 x = a * d + c * b; /* AD + CB */
1713 y = ((lo >> 16) & 0xffff) + x;
1714
1715 lo = (lo & 0xffff) | ((y & 0xffff) << 16);
1716 hi = (y >> 16) & 0xffff;
1717
1718 hi += a * c; /* AC */
1719
1720 *hi_product = (unsigned long)hi;
1721 *lo_product = (unsigned long)lo;
1722 }
1723 #endif /* CHECK_cHRM */
1724
1725 #ifdef PNG_READ_GAMMA_SUPPORTED /* gamma table code */
1726 #ifndef PNG_FLOATING_ARITHMETIC_SUPPORTED
1727 /* Fixed point gamma.
1728 *
1729 * To calculate gamma this code implements fast log() and exp() calls using only
1730 * fixed point arithmetic. This code has sufficient precision for either 8 or
1731 * 16 bit sample values.
1732 *
1733 * The tables used here were calculated using simple 'bc' programs, but C double
1734 * precision floating point arithmetic would work fine. The programs are given
1735 * at the head of each table.
1736 *
1737 * 8 bit log table
1738 * This is a table of -log(value/255)/log(2) for 'value' in the range 128 to
1739 * 255, so it's the base 2 logarithm of a normalized 8 bit floating point
1740 * mantissa. The numbers are 32 bit fractions.
1741 */
1742 static png_uint_32
1743 png_8bit_l2[128] =
1744 {
1745 # if PNG_DO_BC
1746 for (i=128;i<256;++i) { .5 - l(i/255)/l(2)*65536*65536; }
1747 # endif
1748 4270715492U, 4222494797U, 4174646467U, 4127164793U, 4080044201U, 4033279239U,
1749 3986864580U, 3940795015U, 3895065449U, 3849670902U, 3804606499U, 3759867474U,
1750 3715449162U, 3671346997U, 3627556511U, 3584073329U, 3540893168U, 3498011834U,
1751 3455425220U, 3413129301U, 3371120137U, 3329393864U, 3287946700U, 3246774933U,
1752 3205874930U, 3165243125U, 3124876025U, 3084770202U, 3044922296U, 3005329011U,
1753 2965987113U, 2926893432U, 2888044853U, 2849438323U, 2811070844U, 2772939474U,
1754 2735041326U, 2697373562U, 2659933400U, 2622718104U, 2585724991U, 2548951424U,
1755 2512394810U, 2476052606U, 2439922311U, 2404001468U, 2368287663U, 2332778523U,
1756 2297471715U, 2262364947U, 2227455964U, 2192742551U, 2158222529U, 2123893754U,
1757 2089754119U, 2055801552U, 2022034013U, 1988449497U, 1955046031U, 1921821672U,
1758 1888774511U, 1855902668U, 1823204291U, 1790677560U, 1758320682U, 1726131893U,
1759 1694109454U, 1662251657U, 1630556815U, 1599023271U, 1567649391U, 1536433567U,
1760 1505374214U, 1474469770U, 1443718700U, 1413119487U, 1382670639U, 1352370686U,
1761 1322218179U, 1292211689U, 1262349810U, 1232631153U, 1203054352U, 1173618059U,
1762 1144320946U, 1115161701U, 1086139034U, 1057251672U, 1028498358U, 999877854U,
1763 971388940U, 943030410U, 914801076U, 886699767U, 858725327U, 830876614U,
1764 803152505U, 775551890U, 748073672U, 720716771U, 693480120U, 666362667U,
1765 639363374U, 612481215U, 585715177U, 559064263U, 532527486U, 506103872U,
1766 479792461U, 453592303U, 427502463U, 401522014U, 375650043U, 349885648U,
1767 324227938U, 298676034U, 273229066U, 247886176U, 222646516U, 197509248U,
1768 172473545U, 147538590U, 122703574U, 97967701U, 73330182U, 48790236U,
1769 24347096U, 0U
1770 #if 0
1771 /* The following are the values for 16 bit tables - these work fine for the 8
1772 * bit conversions but produce very slightly larger errors in the 16 bit log
1773 * (about 1.2 as opposed to 0.7 absolute error in the final value). To use
1774 * these all the shifts below must be adjusted appropriately.
1775 */
1776 65166, 64430, 63700, 62976, 62257, 61543, 60835, 60132, 59434, 58741, 58054,
1777 57371, 56693, 56020, 55352, 54689, 54030, 53375, 52726, 52080, 51439, 50803,
1778 50170, 49542, 48918, 48298, 47682, 47070, 46462, 45858, 45257, 44661, 44068,
1779 43479, 42894, 42312, 41733, 41159, 40587, 40020, 39455, 38894, 38336, 37782,
1780 37230, 36682, 36137, 35595, 35057, 34521, 33988, 33459, 32932, 32408, 31887,
1781 31369, 30854, 30341, 29832, 29325, 28820, 28319, 27820, 27324, 26830, 26339,
1782 25850, 25364, 24880, 24399, 23920, 23444, 22970, 22499, 22029, 21562, 21098,
1783 20636, 20175, 19718, 19262, 18808, 18357, 17908, 17461, 17016, 16573, 16132,
1784 15694, 15257, 14822, 14390, 13959, 13530, 13103, 12678, 12255, 11834, 11415,
1785 10997, 10582, 10168, 9756, 9346, 8937, 8531, 8126, 7723, 7321, 6921, 6523,
1786 6127, 5732, 5339, 4947, 4557, 4169, 3782, 3397, 3014, 2632, 2251, 1872, 1495,
1787 1119, 744, 372
1788 #endif
1789 };
1790
1791 static png_int_32
1792 png_log8bit(unsigned int x)
1793 {
1794 unsigned int lg2 = 0;
1795 /* Each time 'x' is multiplied by 2, 1 must be subtracted off the final log,
1796 * because the log is actually negate that means adding 1. The final
1797 * returned value thus has the range 0 (for 255 input) to 7.994 (for 1
1798 * input), return 7.99998 for the overflow (log 0) case - so the result is
1799 * always at most 19 bits.
1800 */
1801 if ((x &= 0xff) == 0)
1802 return 0xffffffff;
1803
1804 if ((x & 0xf0) == 0)
1805 lg2 = 4, x <<= 4;
1806
1807 if ((x & 0xc0) == 0)
1808 lg2 += 2, x <<= 2;
1809
1810 if ((x & 0x80) == 0)
1811 lg2 += 1, x <<= 1;
1812
1813 /* result is at most 19 bits, so this cast is safe: */
1814 return (png_int_32)((lg2 << 16) + ((png_8bit_l2[x-128]+32768)>>16));
1815 }
1816
1817 /* The above gives exact (to 16 binary places) log2 values for 8 bit images,
1818 * for 16 bit images we use the most significant 8 bits of the 16 bit value to
1819 * get an approximation then multiply the approximation by a correction factor
1820 * determined by the remaining up to 8 bits. This requires an additional step
1821 * in the 16 bit case.
1822 *
1823 * We want log2(value/65535), we have log2(v'/255), where:
1824 *
1825 * value = v' * 256 + v''
1826 * = v' * f
1827 *
1828 * So f is value/v', which is equal to (256+v''/v') since v' is in the range 128
1829 * to 255 and v'' is in the range 0 to 255 f will be in the range 256 to less
1830 * than 258. The final factor also needs to correct for the fact that our 8 bit
1831 * value is scaled by 255, whereas the 16 bit values must be scaled by 65535.
1832 *
1833 * This gives a final formula using a calculated value 'x' which is value/v' and
1834 * scaling by 65536 to match the above table:
1835 *
1836 * log2(x/257) * 65536
1837 *
1838 * Since these numbers are so close to '1' we can use simple linear
1839 * interpolation between the two end values 256/257 (result -368.61) and 258/257
1840 * (result 367.179). The values used below are scaled by a further 64 to give
1841 * 16 bit precision in the interpolation:
1842 *
1843 * Start (256): -23591
1844 * Zero (257): 0
1845 * End (258): 23499
1846 */
1847 static png_int_32
1848 png_log16bit(png_uint_32 x)
1849 {
1850 unsigned int lg2 = 0;
1851
1852 /* As above, but now the input has 16 bits. */
1853 if ((x &= 0xffff) == 0)
1854 return 0xffffffff;
1855
1856 if ((x & 0xff00) == 0)
1857 lg2 = 8, x <<= 8;
1858
1859 if ((x & 0xf000) == 0)
1860 lg2 += 4, x <<= 4;
1861
1862 if ((x & 0xc000) == 0)
1863 lg2 += 2, x <<= 2;
1864
1865 if ((x & 0x8000) == 0)
1866 lg2 += 1, x <<= 1;
1867
1868 /* Calculate the base logarithm from the top 8 bits as a 28 bit fractional
1869 * value.
1870 */
1871 lg2 <<= 28;
1872 lg2 += (png_8bit_l2[(x>>8)-128]+8) >> 4;
1873
1874 /* Now we need to interpolate the factor, this requires a division by the top
1875 * 8 bits. Do this with maximum precision.
1876 */
1877 x = ((x << 16) + (x >> 9)) / (x >> 8);
1878
1879 /* Since we divided by the top 8 bits of 'x' there will be a '1' at 1<<24,
1880 * the value at 1<<16 (ignoring this) will be 0 or 1; this gives us exactly
1881 * 16 bits to interpolate to get the low bits of the result. Round the
1882 * answer. Note that the end point values are scaled by 64 to retain overall
1883 * precision and that 'lg2' is current scaled by an extra 12 bits, so adjust
1884 * the overall scaling by 6-12. Round at every step.
1885 */
1886 x -= 1U << 24;
1887
1888 if (x <= 65536U) /* <= '257' */
1889 lg2 += ((23591U * (65536U-x)) + (1U << (16+6-12-1))) >> (16+6-12);
1890
1891 else
1892 lg2 -= ((23499U * (x-65536U)) + (1U << (16+6-12-1))) >> (16+6-12);
1893
1894 /* Safe, because the result can't have more than 20 bits: */
1895 return (png_int_32)((lg2 + 2048) >> 12);
1896 }
1897
1898 /* The 'exp()' case must invert the above, taking a 20 bit fixed point
1899 * logarithmic value and returning a 16 or 8 bit number as appropriate. In
1900 * each case only the low 16 bits are relevant - the fraction - since the
1901 * integer bits (the top 4) simply determine a shift.
1902 *
1903 * The worst case is the 16 bit distinction between 65535 and 65534, this
1904 * requires perhaps spurious accuracty in the decoding of the logarithm to
1905 * distinguish log2(65535/65534.5) - 10^-5 or 17 bits. There is little chance
1906 * of getting this accuracy in practice.
1907 *
1908 * To deal with this the following exp() function works out the exponent of the
1909 * frational part of the logarithm by using an accurate 32 bit value from the
1910 * top four fractional bits then multiplying in the remaining bits.
1911 */
1912 static png_uint_32
1913 png_32bit_exp[16] =
1914 {
1915 # if PNG_DO_BC
1916 for (i=0;i<16;++i) { .5 + e(-i/16*l(2))*2^32; }
1917 # endif
1918 /* NOTE: the first entry is deliberately set to the maximum 32 bit value. */
1919 4294967295U, 4112874773U, 3938502376U, 3771522796U, 3611622603U, 3458501653U,
1920 3311872529U, 3171459999U, 3037000500U, 2908241642U, 2784941738U, 2666869345U,
1921 2553802834U, 2445529972U, 2341847524U, 2242560872U
1922 };
1923
1924 /* Adjustment table; provided to explain the numbers in the code below. */
1925 #if PNG_DO_BC
1926 for (i=11;i>=0;--i){ print i, " ", (1 - e(-(2^i)/65536*l(2))) * 2^(32-i), "\n"}
1927 11 44937.64284865548751208448
1928 10 45180.98734845585101160448
1929 9 45303.31936980687359311872
1930 8 45364.65110595323018870784
1931 7 45395.35850361789624614912
1932 6 45410.72259715102037508096
1933 5 45418.40724413220722311168
1934 4 45422.25021786898173001728
1935 3 45424.17186732298419044352
1936 2 45425.13273269940811464704
1937 1 45425.61317555035558641664
1938 0 45425.85339951654943850496
1939 #endif
1940
1941 static png_uint_32
1942 png_exp(png_fixed_point x)
1943 {
1944 if (x > 0 && x <= 0xfffff) /* Else overflow or zero (underflow) */
1945 {
1946 /* Obtain a 4 bit approximation */
1947 png_uint_32 e = png_32bit_exp[(x >> 12) & 0xf];
1948
1949 /* Incorporate the low 12 bits - these decrease the returned value by
1950 * multiplying by a number less than 1 if the bit is set. The multiplier
1951 * is determined by the above table and the shift. Notice that the values
1952 * converge on 45426 and this is used to allow linear interpolation of the
1953 * low bits.
1954 */
1955 if (x & 0x800)
1956 e -= (((e >> 16) * 44938U) + 16U) >> 5;
1957
1958 if (x & 0x400)
1959 e -= (((e >> 16) * 45181U) + 32U) >> 6;
1960
1961 if (x & 0x200)
1962 e -= (((e >> 16) * 45303U) + 64U) >> 7;
1963
1964 if (x & 0x100)
1965 e -= (((e >> 16) * 45365U) + 128U) >> 8;
1966
1967 if (x & 0x080)
1968 e -= (((e >> 16) * 45395U) + 256U) >> 9;
1969
1970 if (x & 0x040)
1971 e -= (((e >> 16) * 45410U) + 512U) >> 10;
1972
1973 /* And handle the low 6 bits in a single block. */
1974 e -= (((e >> 16) * 355U * (x & 0x3fU)) + 256U) >> 9;
1975
1976 /* Handle the upper bits of x. */
1977 e >>= x >> 16;
1978 return e;
1979 }
1980
1981 /* Check for overflow */
1982 if (x <= 0)
1983 return png_32bit_exp[0];
1984
1985 /* Else underflow */
1986 return 0;
1987 }
1988
1989 static png_byte
1990 png_exp8bit(png_fixed_point lg2)
1991 {
1992 /* Get a 32 bit value: */
1993 png_uint_32 x = png_exp(lg2);
1994
1995 /* Convert the 32 bit value to 0..255 by multiplying by 256-1, note that the
1996 * second, rounding, step can't overflow because of the first, subtraction,
1997 * step.
1998 */
1999 x -= x >> 8;
2000 return (png_byte)((x + 0x7fffffU) >> 24);
2001 }
2002
2003 static png_uint_16
2004 png_exp16bit(png_fixed_point lg2)
2005 {
2006 /* Get a 32 bit value: */
2007 png_uint_32 x = png_exp(lg2);
2008
2009 /* Convert the 32 bit value to 0..65535 by multiplying by 65536-1: */
2010 x -= x >> 16;
2011 return (png_uint_16)((x + 32767U) >> 16);
2012 }
2013 #endif /* FLOATING_ARITHMETIC */
2014
2015 png_byte
2016 png_gamma_8bit_correct(unsigned int value, png_fixed_point gamma_val)
2017 {
2018 if (value > 0 && value < 255)
2019 {
2020 # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
2021 double r = floor(255*pow(value/255.,gamma_val*.00001)+.5);
2022 return (png_byte)r;
2023 # else
2024 png_int_32 lg2 = png_log8bit(value);
2025 png_fixed_point res;
2026
2027 if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1))
2028 return png_exp8bit(res);
2029
2030 /* Overflow. */
2031 value = 0;
2032 # endif
2033 }
2034
2035 return (png_byte)value;
2036 }
2037
2038 png_uint_16
2039 png_gamma_16bit_correct(unsigned int value, png_fixed_point gamma_val)
2040 {
2041 if (value > 0 && value < 65535)
2042 {
2043 # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
2044 double r = floor(65535*pow(value/65535.,gamma_val*.00001)+.5);
2045 return (png_uint_16)r;
2046 # else
2047 png_int_32 lg2 = png_log16bit(value);
2048 png_fixed_point res;
2049
2050 if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1))
2051 return png_exp16bit(res);
2052
2053 /* Overflow. */
2054 value = 0;
2055 # endif
2056 }
2057
2058 return (png_uint_16)value;
2059 }
2060
2061 /* This does the right thing based on the bit_depth field of the
2062 * png_struct, interpreting values as 8 or 16 bit. While the result
2063 * is nominally a 16 bit value if bit depth is 8 then the result is
2064 * 8 bit (as are the arguments.)
2065 */
2066 png_uint_16 /* PRIVATE */
2067 png_gamma_correct(png_structp png_ptr, unsigned int value,
2068 png_fixed_point gamma_val)
2069 {
2070 if (png_ptr->bit_depth == 8)
2071 return png_gamma_8bit_correct(value, gamma_val);
2072
2073 else
2074 return png_gamma_16bit_correct(value, gamma_val);
2075 }
2076
2077 /* This is the shared test on whether a gamma value is 'significant' - whether
2078 * it is worth doing gamma correction.
2079 */
2080 int /* PRIVATE */
2081 png_gamma_significant(png_fixed_point gamma_val)
2082 {
2083 return gamma_val < PNG_FP_1 - PNG_GAMMA_THRESHOLD_FIXED ||
2084 gamma_val > PNG_FP_1 + PNG_GAMMA_THRESHOLD_FIXED;
2085 }
2086
2087 /* Internal function to build a single 16 bit table - the table consists of
2088 * 'num' 256 entry subtables, where 'num' is determined by 'shift' - the amount
2089 * to shift the input values right (or 16-number_of_signifiant_bits).
2090 *
2091 * The caller is responsible for ensuring that the table gets cleaned up on
2092 * png_error (i.e. if one of the mallocs below fails) - i.e. the *table argument
2093 * should be somewhere that will be cleaned.
2094 */
2095 static void
2096 png_build_16bit_table(png_structp png_ptr, png_uint_16pp *ptable,
2097 PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val)
2098 {
2099 /* Various values derived from 'shift': */
2100 PNG_CONST unsigned int num = 1U << (8U - shift);
2101 PNG_CONST unsigned int max = (1U << (16U - shift))-1U;
2102 PNG_CONST unsigned int max_by_2 = 1U << (15U-shift);
2103 unsigned int i;
2104
2105 png_uint_16pp table = *ptable =
2106 (png_uint_16pp)png_calloc(png_ptr, num * png_sizeof(png_uint_16p));
2107
2108 for (i = 0; i < num; i++)
2109 {
2110 png_uint_16p sub_table = table[i] =
2111 (png_uint_16p)png_malloc(png_ptr, 256 * png_sizeof(png_uint_16));
2112
2113 /* The 'threshold' test is repeated here because it can arise for one of
2114 * the 16 bit tables even if the others don't hit it.
2115 */
2116 if (png_gamma_significant(gamma_val))
2117 {
2118 /* The old code would overflow at the end and this would cause the
2119 * 'pow' function to return a result >1, resulting in an
2120 * arithmetic error. This code follows the spec exactly; ig is
2121 * the recovered input sample, it always has 8-16 bits.
2122 *
2123 * We want input * 65535/max, rounded, the arithmetic fits in 32
2124 * bits (unsigned) so long as max <= 32767.
2125 */
2126 unsigned int j;
2127 for (j = 0; j < 256; j++)
2128 {
2129 png_uint_32 ig = (j << (8-shift)) + i;
2130 # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
2131 /* Inline the 'max' scaling operation: */
2132 double d = floor(65535*pow(ig/(double)max, gamma_val*.00001)+.5);
2133 sub_table[j] = (png_uint_16)d;
2134 # else
2135 if (shift)
2136 ig = (ig * 65535U + max_by_2)/max;
2137
2138 sub_table[j] = png_gamma_16bit_correct(ig, gamma_val);
2139 # endif
2140 }
2141 }
2142 else
2143 {
2144 /* We must still build a table, but do it the fast way. */
2145 unsigned int j;
2146
2147 for (j = 0; j < 256; j++)
2148 {
2149 png_uint_32 ig = (j << (8-shift)) + i;
2150
2151 if (shift)
2152 ig = (ig * 65535U + max_by_2)/max;
2153
2154 sub_table[j] = (png_uint_16)ig;
2155 }
2156 }
2157 }
2158 }
2159
2160 /* NOTE: this function expects the *inverse* of the overall gamma transformation
2161 * required.
2162 */
2163 static void
2164 png_build_16to8_table(png_structp png_ptr, png_uint_16pp *ptable,
2165 PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val)
2166 {
2167 PNG_CONST unsigned int num = 1U << (8U - shift);
2168 PNG_CONST unsigned int max = (1U << (16U - shift))-1U;
2169 unsigned int i;
2170 png_uint_32 last;
2171
2172 png_uint_16pp table = *ptable =
2173 (png_uint_16pp)png_calloc(png_ptr, num * png_sizeof(png_uint_16p));
2174
2175 /* 'num' is the number of tables and also the number of low bits of low
2176 * bits of the input 16 bit value used to select a table. Each table is
2177 * itself index by the high 8 bits of the value.
2178 */
2179 for (i = 0; i < num; i++)
2180 table[i] = (png_uint_16p)png_malloc(png_ptr,
2181 256 * png_sizeof(png_uint_16));
2182
2183 /* 'gamma_val' is set to the reciprocal of the value calculated above, so
2184 * pow(out,g) is an *input* value. 'last' is the last input value set.
2185 *
2186 * In the loop 'i' is used to find output values. Since the output is 8
2187 * bit there are only 256 possible values. The tables are set up to
2188 * select the closest possible output value for each input by finding
2189 * the input value at the boundary between each pair of output values
2190 * and filling the table up to that boundary with the lower output
2191 * value.
2192 *
2193 * The boundary values are 0.5,1.5..253.5,254.5. Since these are 9 bit
2194 * values the code below uses a 16 bit value in i; the values start at
2195 * 128.5 (for 0.5) and step by 257, for a total of 254 values (the last
2196 * entries are filled with 255). Start i at 128 and fill all 'last'
2197 * table entries <= 'max'
2198 */
2199 last = 0;
2200 for (i = 0; i < 255; ++i) /* 8 bit output value */
2201 {
2202 /* Find the corresponding maximum input value */
2203 png_uint_16 out = (png_uint_16)(i * 257U); /* 16 bit output value */
2204
2205 /* Find the boundary value in 16 bits: */
2206 png_uint_32 bound = png_gamma_16bit_correct(out+128U, gamma_val);
2207
2208 /* Adjust (round) to (16-shift) bits: */
2209 bound = (bound * max + 32768U)/65535U + 1U;
2210
2211 while (last < bound)
2212 {
2213 table[last & (0xffU >> shift)][last >> (8U - shift)] = out;
2214 last++;
2215 }
2216 }
2217
2218 /* And fill in the final entries. */
2219 while (last < (num << 8))
2220 {
2221 table[last & (0xff >> shift)][last >> (8U - shift)] = 65535U;
2222 last++;
2223 }
2224 }
2225
2226 /* Build a single 8 bit table: same as the 16 bit case but much simpler (and
2227 * typically much faster). Note that libpng currently does no sBIT processing
2228 * (apparently contrary to the spec) so a 256 entry table is always generated.
2229 */
2230 static void
2231 png_build_8bit_table(png_structp png_ptr, png_bytepp ptable,
2232 PNG_CONST png_fixed_point gamma_val)
2233 {
2234 unsigned int i;
2235 png_bytep table = *ptable = (png_bytep)png_malloc(png_ptr, 256);
2236
2237 if (png_gamma_significant(gamma_val)) for (i=0; i<256; i++)
2238 table[i] = png_gamma_8bit_correct(i, gamma_val);
2239
2240 else for (i=0; i<256; ++i)
2241 table[i] = (png_byte)i;
2242 }
2243
2244 /* We build the 8- or 16-bit gamma tables here. Note that for 16-bit
2245 * tables, we don't make a full table if we are reducing to 8-bit in
2246 * the future. Note also how the gamma_16 tables are segmented so that
2247 * we don't need to allocate > 64K chunks for a full 16-bit table.
2248 */
2249 void /* PRIVATE */
2250 png_build_gamma_table(png_structp png_ptr, int bit_depth)
2251 {
2252 png_debug(1, "in png_build_gamma_table");
2253
2254 if (bit_depth <= 8)
2255 {
2256 png_build_8bit_table(png_ptr, &png_ptr->gamma_table,
2257 png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->gamma,
2258 png_ptr->screen_gamma) : PNG_FP_1);
2259
2260 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
2261 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
2262 if (png_ptr->transformations & ((PNG_BACKGROUND) | PNG_RGB_TO_GRAY))
2263 {
2264 png_build_8bit_table(png_ptr, &png_ptr->gamma_to_1,
2265 png_reciprocal(png_ptr->gamma));
2266
2267 png_build_8bit_table(png_ptr, &png_ptr->gamma_from_1,
2268 png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) :
2269 png_ptr->gamma/* Probably doing rgb_to_gray */);
2270 }
2271 #endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */
2272 }
2273 else
2274 {
2275 png_byte shift, sig_bit;
2276
2277 if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
2278 {
2279 sig_bit = png_ptr->sig_bit.red;
2280
2281 if (png_ptr->sig_bit.green > sig_bit)
2282 sig_bit = png_ptr->sig_bit.green;
2283
2284 if (png_ptr->sig_bit.blue > sig_bit)
2285 sig_bit = png_ptr->sig_bit.blue;
2286 }
2287 else
2288 sig_bit = png_ptr->sig_bit.gray;
2289
2290 /* 16 bit gamma code uses this equation:
2291 *
2292 * ov = table[(iv & 0xff) >> gamma_shift][iv >> 8]
2293 *
2294 * Where 'iv' is the input color value and 'ov' is the output value -
2295 * pow(iv, gamma).
2296 *
2297 * Thus the gamma table consists of up to 256 256 entry tables. The table
2298 * is selected by the (8-gamma_shift) most significant of the low 8 bits of
2299 * the color value then indexed by the upper 8 bits:
2300 *
2301 * table[low bits][high 8 bits]
2302 *
2303 * So the table 'n' corresponds to all those 'iv' of:
2304 *
2305 * <all high 8 bit values><n << gamma_shift>..<(n+1 << gamma_shift)-1>
2306 *
2307 */
2308 if (sig_bit > 0 && sig_bit < 16U)
2309 shift = (png_byte)(16U - sig_bit); /* shift == insignificant bits */
2310
2311 else
2312 shift = 0; /* keep all 16 bits */
2313
2314 if (png_ptr->transformations & PNG_16_TO_8)
2315 {
2316 /* PNG_MAX_GAMMA_8 is the number of bits to keep - effectively
2317 * the significant bits in the *input* when the output will
2318 * eventually be 8 bits. By default it is 11.
2319 */
2320 if (shift < (16U - PNG_MAX_GAMMA_8))
2321 shift = (16U - PNG_MAX_GAMMA_8);
2322 }
2323
2324 if (shift > 8U)
2325 shift = 8U; /* Guarantees at least one table! */
2326
2327 png_ptr->gamma_shift = shift;
2328
2329 #ifdef PNG_16BIT_SUPPORTED
2330 if (png_ptr->transformations & (PNG_16_TO_8 | PNG_BACKGROUND))
2331 #endif
2332 png_build_16to8_table(png_ptr, &png_ptr->gamma_16_table, shift,
2333 png_ptr->screen_gamma > 0 ? png_product2(png_ptr->gamma,
2334 png_ptr->screen_gamma) : PNG_FP_1);
2335
2336 #ifdef PNG_16BIT_SUPPORTED
2337 else
2338 png_build_16bit_table(png_ptr, &png_ptr->gamma_16_table, shift,
2339 png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->gamma,
2340 png_ptr->screen_gamma) : PNG_FP_1);
2341 #endif
2342
2343 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
2344 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
2345 if (png_ptr->transformations & (PNG_BACKGROUND | PNG_RGB_TO_GRAY))
2346 {
2347 png_build_16bit_table(png_ptr, &png_ptr->gamma_16_to_1, shift,
2348 png_reciprocal(png_ptr->gamma));
2349
2350 /* Notice that the '16 from 1' table should be full precision, however
2351 * the lookup on this table still uses gamma_shift, so it can't be.
2352 * TODO: fix this.
2353 */
2354 png_build_16bit_table(png_ptr, &png_ptr->gamma_16_from_1, shift,
2355 png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) :
2356 png_ptr->gamma/* Probably doing rgb_to_gray */);
2357 }
2358 #endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */
2359 }
2360 }
2361 #endif /* READ_GAMMA */
2362 #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
PNG_INTERLACE_LAST
#define PNG_INTERLACE_LAST
Definition: png.h:710
PNG_FREE_TEXT
#define PNG_FREE_TEXT
Definition: png.h:1573
png_zfree
void png_zfree(voidpf png_ptr, voidpf ptr)
Definition: png.c:99
png_memcpy
#define png_memcpy
Definition: pngpriv.h:226
png_free_data
void PNGAPI png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask, int num)
Definition: png.c:247
voidpf
Byte FAR * voidpf
Definition: zconf.h:355
PNG_FREE_HIST
#define PNG_FREE_HIST
Definition: png.h:1563
inflateReset
int ZEXPORT inflateReset(z_streamp strm)
Definition: inflate.c:103
PNG_UNUSED
#define PNG_UNUSED(param)
Definition: pngpriv.h:92
png_const_timep
PNG_CONST png_time FAR * png_const_timep
Definition: png.h:641
png_ascii_from_fp
void png_ascii_from_fp(png_structp png_ptr, png_charp ascii, png_size_t size, double fp, unsigned int precision)
Definition: png.c:1084
png_size_tp
png_size_t FAR * png_size_tp
Definition: pngconf.h:576
PNG_INFO_hIST
#define PNG_INFO_hIST
Definition: png.h:759
PNG_UINT_31_MAX
#define PNG_UINT_31_MAX
Definition: png.h:672
PNG_STRUCT_INFO
#define PNG_STRUCT_INFO
Definition: pngpriv.h:315
png_const_structp
PNG_CONST png_struct FAR * png_const_structp
Definition: png.h:796
PNG_FLAG_MALLOC_NULL_MEM_OK
#define PNG_FLAG_MALLOC_NULL_MEM_OK
Definition: pngpriv.h:342
PNG_COLOR_TYPE_RGB
#define PNG_COLOR_TYPE_RGB
Definition: png.h:691
png_libpng_version_1_5_1
char * png_libpng_version_1_5_1
Definition: png.h:512
PNG_COLOR_TYPE_GRAY_ALPHA
#define PNG_COLOR_TYPE_GRAY_ALPHA
Definition: png.h:693
png_charp
char FAR * png_charp
Definition: pngconf.h:572
PNG_COLOR_TYPE_PALETTE
#define PNG_COLOR_TYPE_PALETTE
Definition: png.h:690
png_get_libpng_ver
png_const_charp PNGAPI png_get_libpng_ver(png_const_structp png_ptr)
Definition: png.c:581
png_fixed
png_fixed_point png_fixed(png_structp png_ptr, double fp, png_const_charp text)
Definition: png.c:1459
png_fixed_point_p
png_fixed_point FAR * png_fixed_point_p
Definition: pngconf.h:574
PNG_LIBPNG_VER_STRING
#define PNG_LIBPNG_VER_STRING
Definition: png.h:355
PNG_FP_SAW_SIGN
#define PNG_FP_SAW_SIGN
Definition: pngpriv.h:1139
PNG_ABORT
#define PNG_ABORT()
Definition: pngpriv.h:191
PNG_FUNCTION
PNG_FUNCTION(voidpf, png_zalloc,(voidpf png_ptr, uInt items, uInt size), PNG_ALLOCATED)
Definition: png.c:72
png_set_sig_bytes
void PNGAPI png_set_sig_bytes(png_structp png_ptr, int num_bytes)
Definition: png.c:27
png_reciprocal
png_fixed_point png_reciprocal(png_fixed_point a)
Definition: png.c:1614
PNG_FREE_PLTE
#define PNG_FREE_PLTE
Definition: png.h:1571
png_debug
#define png_debug(l, m)
Definition: pngdebug.h:149
PNG_COLOR_TYPE_RGB_ALPHA
#define PNG_COLOR_TYPE_RGB_ALPHA
Definition: png.h:692
PNG_FREE_ICCP
#define PNG_FREE_ICCP
Definition: png.h:1564
png_int_32
long png_int_32
Definition: pngconf.h:481
png_memset
#define png_memset
Definition: pngpriv.h:227
png_const_charp
PNG_CONST char FAR * png_const_charp
Definition: pngconf.h:573
PNG_FP_FRACTION
#define PNG_FP_FRACTION
Definition: pngpriv.h:1136
Z_STREAM_ERROR
#define Z_STREAM_ERROR
Definition: zlib.h:177
PNG_FP_SAW_ANY
#define PNG_FP_SAW_ANY
Definition: pngpriv.h:1143
PNG_ALLOCATED
#define PNG_ALLOCATED
Definition: pngconf.h:428
b
long b
Definition: jpegint.h:371
png_info_init_3
void PNGAPI png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size)
Definition: png.c:206
png_info_def
Definition: pnginfo.h:56
png_destroy_info_struct
void PNGAPI png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
Definition: png.c:174
png_alloc_size_t
png_size_t png_alloc_size_t
Definition: pngconf.h:627
PNGARG
#define PNGARG(arglist)
Definition: pngconf.h:89
png_snprintf6
#define png_snprintf6
Definition: pngpriv.h:241
png_bytepp
png_byte FAR *FAR * png_bytepp
Definition: pngconf.h:589
PNG_FLAG_CRC_ANCILLARY_USE
#define PNG_FLAG_CRC_ANCILLARY_USE
Definition: pngpriv.h:330
PNG_USER_WILL_FREE_DATA
#define PNG_USER_WILL_FREE_DATA
Definition: png.h:1561
png_convert_to_rfc1123
png_const_charp PNGAPI png_convert_to_rfc1123(png_structp png_ptr, png_const_timep ptime)
Definition: png.c:512
png_uint_32
unsigned long png_uint_32
Definition: pngconf.h:480
PNG_MAX_GAMMA_8
#define PNG_MAX_GAMMA_8
Definition: pnglibconf.h:31
PNG_FP_EXPONENT
#define PNG_FP_EXPONENT
Definition: pngpriv.h:1137
PNGAPI
#define PNGAPI
Definition: pngconf.h:256
png_check_IHDR
void png_check_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, int color_type, int interlace_type, int compression_type, int filter_type)
Definition: png.c:745
png_structp
png_struct FAR * png_structp
Definition: png.h:797
PNG_FREE_ROWS
#define PNG_FREE_ROWS
Definition: png.h:1566
PNG_FREE_ALL
#define PNG_FREE_ALL
Definition: png.h:1574
png_info_destroy
void png_info_destroy(png_structp png_ptr, png_infop info_ptr)
Definition: png.c:455
PNG_COLOR_MASK_COLOR
#define PNG_COLOR_MASK_COLOR
Definition: png.h:685
PNG_GAMMA_THRESHOLD_FIXED
#define PNG_GAMMA_THRESHOLD_FIXED
Definition: pnglibconf.h:20
png_get_header_version
png_const_charp PNGAPI png_get_header_version(png_const_structp png_ptr)
Definition: png.c:596
PNG_CONST
#define PNG_CONST
Definition: pngconf.h:462
PNG_USER_HEIGHT_MAX
#define PNG_USER_HEIGHT_MAX
Definition: pnglibconf.h:17
png_infop
png_info FAR * png_infop
Definition: png.h:667
png_check_fp_number
int png_check_fp_number(png_const_charp string, png_size_t size, int *statep, png_size_tp whereami)
Definition: png.c:904
png_muldiv_warn
png_fixed_point png_muldiv_warn(png_structp png_ptr, png_fixed_point a, png_int_32 times, png_int_32 divisor)
Definition: png.c:1598
png_destroy_struct
void png_destroy_struct(png_voidp struct_ptr)
Definition: pngmem.c:429
PNG_FLAG_CRC_CRITICAL_IGNORE
#define PNG_FLAG_CRC_CRITICAL_IGNORE
Definition: pngpriv.h:333
PNG_FREE_SPLT
#define PNG_FREE_SPLT
Definition: png.h:1565
png_build_gamma_table
void png_build_gamma_table(png_structp png_ptr, int bit_depth)
Definition: png.c:2250
png_byte
unsigned char png_byte
Definition: pngconf.h:485
png_uint_16
unsigned short png_uint_16
Definition: pngconf.h:483
png_warning
void PNGAPI png_warning(png_structp png_ptr, png_const_charp warning_message)
Definition: pngerror.c:108
png_check_cHRM_fixed
int png_check_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x, png_fixed_point blue_y)
Definition: png.c:671
png_get_io_ptr
png_voidp PNGAPI png_get_io_ptr(png_structp png_ptr)
Definition: png.c:479
png_ascii_from_fixed
void png_ascii_from_fixed(png_structp png_ptr, png_charp ascii, png_size_t size, png_fixed_point fp)
Definition: png.c:1386
png_handle_as_unknown
int PNGAPI png_handle_as_unknown(png_structp png_ptr, png_const_bytep chunk_name)
Definition: png.c:614
png_memcmp
#define png_memcmp
Definition: pngpriv.h:225
png_uint_16p
png_uint_16 FAR * png_uint_16p
Definition: pngconf.h:568
PNG_UINT_32_MAX
#define PNG_UINT_32_MAX
Definition: png.h:673
crc32
unsigned long ZEXPORT crc32(unsigned long crc, const unsigned char FAR *buf, uInt len)
Definition: crc32.c:221
png_const_bytep
PNG_CONST png_byte FAR * png_const_bytep
Definition: pngconf.h:563
PNG_STRING_NEWLINE
#define PNG_STRING_NEWLINE
Definition: pngdebug.h:49
PNG_FREE_UNKN
#define PNG_FREE_UNKN
Definition: png.h:1569
png_muldiv
int png_muldiv(png_fixed_point_p res, png_fixed_point a, png_int_32 times, png_int_32 divisor)
Definition: png.c:1479
PNG_FLAG_CRC_ANCILLARY_NOWARN
#define PNG_FLAG_CRC_ANCILLARY_NOWARN
Definition: pngpriv.h:331
png_reciprocal2
png_fixed_point png_reciprocal2(png_fixed_point a, png_fixed_point b)
Definition: png.c:1655
PNG_DESTROY_WILL_FREE_DATA
#define PNG_DESTROY_WILL_FREE_DATA
Definition: png.h:1559
PNG_FLAG_MNG_FILTER_64
#define PNG_FLAG_MNG_FILTER_64
Definition: png.h:874
PNG_INFO_PLTE
#define PNG_INFO_PLTE
Definition: png.h:756
png_bytep
png_byte FAR * png_bytep
Definition: pngconf.h:562
PNG_FP_1
#define PNG_FP_1
Definition: png.h:679
pngpriv.h
PNG_FILTER_TYPE_BASE
#define PNG_FILTER_TYPE_BASE
Definition: png.h:703
PNG_LIBPNG_VER
#define PNG_LIBPNG_VER
Definition: png.h:395
png_uint_16pp
png_uint_16 FAR *FAR * png_uint_16pp
Definition: pngconf.h:592
png_data_freer
void PNGAPI png_data_freer(png_structp png_ptr, png_infop info_ptr, int freer, png_uint_32 mask)
Definition: png.c:227
PNG_INFO_IDAT
#define PNG_INFO_IDAT
Definition: png.h:768
PNG_FP_SAW_DIGIT
#define PNG_FP_SAW_DIGIT
Definition: pngpriv.h:1140
png_get_copyright
png_const_charp PNGAPI png_get_copyright(png_const_structp png_ptr)
Definition: png.c:550
png_64bit_product
void png_64bit_product(long v1, long v2, unsigned long *hi_product, unsigned long *lo_product)
Definition: png.c:1700
PNG_COMPRESSION_TYPE_BASE
#define PNG_COMPRESSION_TYPE_BASE
Definition: png.h:699
PNG_INFO_tRNS
#define PNG_INFO_tRNS
Definition: png.h:757
PNG_HEADER_VERSION_STRING
#define PNG_HEADER_VERSION_STRING
Definition: png.h:356
PNG_FP_STATE
#define PNG_FP_STATE
Definition: pngpriv.h:1138
png_gamma_8bit_correct
png_byte png_gamma_8bit_correct(unsigned int value, png_fixed_point gamma_val)
Definition: png.c:2016
PNG_FP_INTEGER
#define PNG_FP_INTEGER
Definition: pngpriv.h:1135
PNG_BACKGROUND
#define PNG_BACKGROUND
Definition: pngpriv.h:287
png_voidp
void FAR * png_voidp
Definition: pngconf.h:560
png_fixed_point
png_int_32 png_fixed_point
Definition: pngconf.h:557
PNG_FP_DOT
#define PNG_FP_DOT
Definition: png.c:899
PNG_FREE_PCAL
#define PNG_FREE_PCAL
Definition: png.h:1567
png_destroy_struct_2
void png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn, png_voidp mem_ptr)
Definition: pngmem.c:437
PNG_FREE_MUL
#define PNG_FREE_MUL
Definition: png.h:1575
png_calculate_crc
void png_calculate_crc(png_structp png_ptr, png_const_bytep ptr, png_size_t length)
Definition: png.c:119
png_size_t
size_t png_size_t
Definition: pngconf.h:490
PNG_FP_SAW_DOT
#define PNG_FP_SAW_DOT
Definition: pngpriv.h:1141
PNG_RGB_TO_GRAY
#define PNG_RGB_TO_GRAY
Definition: pngpriv.h:303
PNG_INTRAPIXEL_DIFFERENCING
#define PNG_INTRAPIXEL_DIFFERENCING
Definition: png.h:704
PNG_USER_WIDTH_MAX
#define PNG_USER_WIDTH_MAX
Definition: pnglibconf.h:28
PNG_INFO_sPLT
#define PNG_INFO_sPLT
Definition: png.h:766
Z_NULL
#define Z_NULL
Definition: zlib.h:208
png_get_header_ver
png_const_charp PNGAPI png_get_header_ver(png_const_structp png_ptr)
Definition: png.c:588
png_check_fp_string
int png_check_fp_string(png_const_charp string, png_size_t size)
Definition: png.c:1031
PNG_FP_E
#define PNG_FP_E
Definition: png.c:901
PNG_FLAG_CRC_ANCILLARY_MASK
#define PNG_FLAG_CRC_ANCILLARY_MASK
Definition: pngpriv.h:354
png_fp_add
#define png_fp_add(state, flags)
Definition: png.c:893
PNG_16_TO_8
#define PNG_16_TO_8
Definition: pngpriv.h:290
png_infopp
png_info FAR *FAR * png_infopp
Definition: png.h:669
png_reset_zstream
int PNGAPI png_reset_zstream(png_structp png_ptr)
Definition: png.c:634
png_free
void PNGAPI png_free(png_structp png_ptr, png_voidp ptr)
Definition: pngmem.c:569
Your_png_h_is_not_version_1_5_1
png_libpng_version_1_5_1 Your_png_h_is_not_version_1_5_1
Definition: png.c:17
PNG_INFO_pCAL
#define PNG_INFO_pCAL
Definition: png.h:763
PNG_FREE_SCAL
#define PNG_FREE_SCAL
Definition: png.h:1568
PNG_HAVE_PNG_SIGNATURE
#define PNG_HAVE_PNG_SIGNATURE
Definition: pngpriv.h:276
png_gamma_correct
png_uint_16 png_gamma_correct(png_structp png_ptr, unsigned int value, png_fixed_point gamma_val)
Definition: png.c:2067
PNG_FP_DIGIT
#define PNG_FP_DIGIT
Definition: png.c:900
png_gamma_16bit_correct
png_uint_16 png_gamma_16bit_correct(unsigned int value, png_fixed_point gamma_val)
Definition: png.c:2039
PNG_FP_SIGN
#define PNG_FP_SIGN
Definition: png.c:898
png_init_io
void PNGAPI png_init_io(png_structp png_ptr, png_FILE_p fp)
Definition: png.c:496
png_sig_cmp
int PNGAPI png_sig_cmp(png_const_bytep sig, png_size_t start, png_size_t num_to_check)
Definition: png.c:49
PNG_FP_WAS_VALID
#define PNG_FP_WAS_VALID
Definition: pngpriv.h:1144
png_reset_crc
void png_reset_crc(png_structp png_ptr)
Definition: png.c:108
png_gamma_significant
int png_gamma_significant(png_fixed_point gamma_val)
Definition: png.c:2081
png_fp_set
#define png_fp_set(state, value)
Definition: png.c:894
PNG_INFO_iCCP
#define PNG_INFO_iCCP
Definition: png.h:765
uInt
unsigned int uInt
Definition: zconf.h:335
PNG_EXTERN
#define PNG_EXTERN
Definition: pngpriv.h:123
png_sizeof
#define png_sizeof(x)
Definition: pngconf.h:492
PNG_FREE_TRNS
#define PNG_FREE_TRNS
Definition: png.h:1572
PNG_INFO_sCAL
#define PNG_INFO_sCAL
Definition: png.h:767
png_access_version_number
png_uint_32 PNGAPI png_access_version_number(void)
Definition: png.c:645