1 /*
2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3 *
4 * This code is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2 only, as
6 * published by the Free Software Foundation. Oracle designates this
7 * particular file as subject to the "Classpath" exception as provided
8 * by Oracle in the LICENSE file that accompanied this code.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 */
24
25 /* png.c - location for general purpose libpng functions
26 *
27 * This file is available under and governed by the GNU General Public
28 * License version 2 only, as published by the Free Software Foundation.
29 * However, the following notice accompanied the original version of this
30 * file and, per its terms, should not be removed:
31 *
32 * Last changed in libpng 1.6.19 [November 12, 2015]
33 * Copyright (c) 1998-2015 Glenn Randers-Pehrson
34 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
35 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
36 *
37 * This code is released under the libpng license.
38 * For conditions of distribution and use, see the disclaimer
39 * and license in png.h
40 */
41
42 #include "pngpriv.h"
43
44 /* Generate a compiler error if there is an old png.h in the search path. */
45 typedef png_libpng_version_1_6_20 Your_png_h_is_not_version_1_6_20;
46
47 /* Tells libpng that we have already handled the first "num_bytes" bytes
48 * of the PNG file signature. If the PNG data is embedded into another
49 * stream we can set num_bytes = 8 so that libpng will not attempt to read
50 * or write any of the magic bytes before it starts on the IHDR.
51 */
52
53 #ifdef PNG_READ_SUPPORTED
54 void PNGAPI
55 png_set_sig_bytes(png_structrp png_ptr, int num_bytes)
56 {
57 unsigned int nb = (unsigned int)num_bytes;
58
59 png_debug(1, "in png_set_sig_bytes");
60
61 if (png_ptr == NULL)
62 return;
63
64 if (num_bytes < 0)
65 nb = 0;
66
67 if (nb > 8)
68 png_error(png_ptr, "Too many bytes for PNG signature");
69
70 png_ptr->sig_bytes = (png_byte)nb;
71 }
72
73 /* Checks whether the supplied bytes match the PNG signature. We allow
74 * checking less than the full 8-byte signature so that those apps that
75 * already read the first few bytes of a file to determine the file type
76 * can simply check the remaining bytes for extra assurance. Returns
77 * an integer less than, equal to, or greater than zero if sig is found,
78 * respectively, to be less than, to match, or be greater than the correct
79 * PNG signature (this is the same behavior as strcmp, memcmp, etc).
80 */
81 int PNGAPI
82 png_sig_cmp(png_const_bytep sig, png_size_t start, png_size_t num_to_check)
83 {
84 png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
85
86 if (num_to_check > 8)
87 num_to_check = 8;
88
89 else if (num_to_check < 1)
90 return (-1);
91
92 if (start > 7)
93 return (-1);
94
95 if (start + num_to_check > 8)
96 num_to_check = 8 - start;
97
98 return ((int)(memcmp(&sig[start], &png_signature[start], num_to_check)));
99 }
100
101 #endif /* READ */
102
103 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
104 /* Function to allocate memory for zlib */
105 PNG_FUNCTION(voidpf /* PRIVATE */,
106 png_zalloc,(voidpf png_ptr, uInt items, uInt size),PNG_ALLOCATED)
107 {
108 png_alloc_size_t num_bytes = size;
109
110 if (png_ptr == NULL)
111 return NULL;
112
113 if (items >= (~(png_alloc_size_t)0)/size)
114 {
115 png_warning (png_voidcast(png_structrp, png_ptr),
116 "Potential overflow in png_zalloc()");
117 return NULL;
118 }
119
120 num_bytes *= items;
121 return png_malloc_warn(png_voidcast(png_structrp, png_ptr), num_bytes);
122 }
123
124 /* Function to free memory for zlib */
125 void /* PRIVATE */
126 png_zfree(voidpf png_ptr, voidpf ptr)
127 {
128 png_free(png_voidcast(png_const_structrp,png_ptr), ptr);
129 }
130
131 /* Reset the CRC variable to 32 bits of 1's. Care must be taken
132 * in case CRC is > 32 bits to leave the top bits 0.
133 */
134 void /* PRIVATE */
135 png_reset_crc(png_structrp png_ptr)
136 {
137 /* The cast is safe because the crc is a 32-bit value. */
138 png_ptr->crc = (png_uint_32)crc32(0, Z_NULL, 0);
139 }
140
141 /* Calculate the CRC over a section of data. We can only pass as
142 * much data to this routine as the largest single buffer size. We
143 * also check that this data will actually be used before going to the
144 * trouble of calculating it.
145 */
146 void /* PRIVATE */
147 png_calculate_crc(png_structrp png_ptr, png_const_bytep ptr, png_size_t length)
148 {
149 int need_crc = 1;
150
151 if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name) != 0)
152 {
153 if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
154 (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
155 need_crc = 0;
156 }
157
158 else /* critical */
159 {
160 if ((png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) != 0)
161 need_crc = 0;
162 }
163
164 /* 'uLong' is defined in zlib.h as unsigned long; this means that on some
165 * systems it is a 64-bit value. crc32, however, returns 32 bits so the
166 * following cast is safe. 'uInt' may be no more than 16 bits, so it is
167 * necessary to perform a loop here.
168 */
169 if (need_crc != 0 && length > 0)
170 {
171 uLong crc = png_ptr->crc; /* Should never issue a warning */
172
173 do
174 {
175 uInt safe_length = (uInt)length;
176 #ifndef __COVERITY__
177 if (safe_length == 0)
178 safe_length = (uInt)-1; /* evil, but safe */
179 #endif
180
181 crc = crc32(crc, ptr, safe_length);
182
183 /* The following should never issue compiler warnings; if they do the
184 * target system has characteristics that will probably violate other
185 * assumptions within the libpng code.
186 */
187 ptr += safe_length;
188 length -= safe_length;
189 }
190 while (length > 0);
191
192 /* And the following is always safe because the crc is only 32 bits. */
193 png_ptr->crc = (png_uint_32)crc;
194 }
195 }
196
197 /* Check a user supplied version number, called from both read and write
198 * functions that create a png_struct.
199 */
200 int
201 png_user_version_check(png_structrp png_ptr, png_const_charp user_png_ver)
202 {
203 /* Libpng versions 1.0.0 and later are binary compatible if the version
204 * string matches through the second '.'; we must recompile any
205 * applications that use any older library version.
206 */
207
208 if (user_png_ver != NULL)
209 {
210 int i = -1;
211 int found_dots = 0;
212
213 do
214 {
215 i++;
216 if (user_png_ver[i] != PNG_LIBPNG_VER_STRING[i])
217 png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
218 if (user_png_ver[i] == '.')
219 found_dots++;
220 } while (found_dots < 2 && user_png_ver[i] != 0 &&
221 PNG_LIBPNG_VER_STRING[i] != 0);
222 }
223
224 else
225 png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
226
227 if ((png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) != 0)
228 {
229 #ifdef PNG_WARNINGS_SUPPORTED
230 size_t pos = 0;
231 char m[128];
232
233 pos = png_safecat(m, (sizeof m), pos,
234 "Application built with libpng-");
235 pos = png_safecat(m, (sizeof m), pos, user_png_ver);
236 pos = png_safecat(m, (sizeof m), pos, " but running with ");
237 pos = png_safecat(m, (sizeof m), pos, PNG_LIBPNG_VER_STRING);
238 PNG_UNUSED(pos)
239
240 png_warning(png_ptr, m);
241 #endif
242
243 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
244 png_ptr->flags = 0;
245 #endif
246
247 return 0;
248 }
249
250 /* Success return. */
251 return 1;
252 }
253
254 /* Generic function to create a png_struct for either read or write - this
255 * contains the common initialization.
256 */
257 PNG_FUNCTION(png_structp /* PRIVATE */,
258 png_create_png_struct,(png_const_charp user_png_ver, png_voidp error_ptr,
259 png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
260 png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED)
261 {
262 png_struct create_struct;
263 # ifdef PNG_SETJMP_SUPPORTED
264 jmp_buf create_jmp_buf;
265 # endif
266
267 /* This temporary stack-allocated structure is used to provide a place to
268 * build enough context to allow the user provided memory allocator (if any)
269 * to be called.
270 */
271 memset(&create_struct, 0, (sizeof create_struct));
272
273 /* Added at libpng-1.2.6 */
274 # ifdef PNG_USER_LIMITS_SUPPORTED
275 create_struct.user_width_max = PNG_USER_WIDTH_MAX;
276 create_struct.user_height_max = PNG_USER_HEIGHT_MAX;
277
278 # ifdef PNG_USER_CHUNK_CACHE_MAX
279 /* Added at libpng-1.2.43 and 1.4.0 */
280 create_struct.user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX;
281 # endif
282
283 # ifdef PNG_USER_CHUNK_MALLOC_MAX
284 /* Added at libpng-1.2.43 and 1.4.1, required only for read but exists
285 * in png_struct regardless.
286 */
287 create_struct.user_chunk_malloc_max = PNG_USER_CHUNK_MALLOC_MAX;
288 # endif
289 # endif
290
291 /* The following two API calls simply set fields in png_struct, so it is safe
292 * to do them now even though error handling is not yet set up.
293 */
294 # ifdef PNG_USER_MEM_SUPPORTED
295 png_set_mem_fn(&create_struct, mem_ptr, malloc_fn, free_fn);
296 # else
297 PNG_UNUSED(mem_ptr)
298 PNG_UNUSED(malloc_fn)
299 PNG_UNUSED(free_fn)
300 # endif
301
302 /* (*error_fn) can return control to the caller after the error_ptr is set,
303 * this will result in a memory leak unless the error_fn does something
304 * extremely sophisticated. The design lacks merit but is implicit in the
305 * API.
306 */
307 png_set_error_fn(&create_struct, error_ptr, error_fn, warn_fn);
308
309 # ifdef PNG_SETJMP_SUPPORTED
310 if (!setjmp(create_jmp_buf))
311 # endif
312 {
313 # ifdef PNG_SETJMP_SUPPORTED
314 /* Temporarily fake out the longjmp information until we have
315 * successfully completed this function. This only works if we have
316 * setjmp() support compiled in, but it is safe - this stuff should
317 * never happen.
318 */
319 create_struct.jmp_buf_ptr = &create_jmp_buf;
320 create_struct.jmp_buf_size = 0; /*stack allocation*/
321 create_struct.longjmp_fn = longjmp;
322 # endif
323 /* Call the general version checker (shared with read and write code):
324 */
325 if (png_user_version_check(&create_struct, user_png_ver) != 0)
326 {
327 png_structrp png_ptr = png_voidcast(png_structrp,
328 png_malloc_warn(&create_struct, (sizeof *png_ptr)));
329
330 if (png_ptr != NULL)
331 {
332 /* png_ptr->zstream holds a back-pointer to the png_struct, so
333 * this can only be done now:
334 */
335 create_struct.zstream.zalloc = png_zalloc;
336 create_struct.zstream.zfree = png_zfree;
337 create_struct.zstream.opaque = png_ptr;
338
339 # ifdef PNG_SETJMP_SUPPORTED
340 /* Eliminate the local error handling: */
341 create_struct.jmp_buf_ptr = NULL;
342 create_struct.jmp_buf_size = 0;
343 create_struct.longjmp_fn = 0;
344 # endif
345
346 *png_ptr = create_struct;
347
348 /* This is the successful return point */
349 return png_ptr;
350 }
351 }
352 }
353
354 /* A longjmp because of a bug in the application storage allocator or a
355 * simple failure to allocate the png_struct.
356 */
357 return NULL;
358 }
359
360 /* Allocate the memory for an info_struct for the application. */
361 PNG_FUNCTION(png_infop,PNGAPI
362 png_create_info_struct,(png_const_structrp png_ptr),PNG_ALLOCATED)
363 {
364 png_inforp info_ptr;
365
366 png_debug(1, "in png_create_info_struct");
367
368 if (png_ptr == NULL)
369 return NULL;
370
371 /* Use the internal API that does not (or at least should not) error out, so
372 * that this call always returns ok. The application typically sets up the
373 * error handling *after* creating the info_struct because this is the way it
374 * has always been done in 'example.c'.
375 */
376 info_ptr = png_voidcast(png_inforp, png_malloc_base(png_ptr,
377 (sizeof *info_ptr)));
378
379 if (info_ptr != NULL)
380 memset(info_ptr, 0, (sizeof *info_ptr));
381
382 return info_ptr;
383 }
384
385 /* This function frees the memory associated with a single info struct.
386 * Normally, one would use either png_destroy_read_struct() or
387 * png_destroy_write_struct() to free an info struct, but this may be
388 * useful for some applications. From libpng 1.6.0 this function is also used
389 * internally to implement the png_info release part of the 'struct' destroy
390 * APIs. This ensures that all possible approaches free the same data (all of
391 * it).
392 */
393 void PNGAPI
394 png_destroy_info_struct(png_const_structrp png_ptr, png_infopp info_ptr_ptr)
395 {
396 png_inforp info_ptr = NULL;
397
398 png_debug(1, "in png_destroy_info_struct");
399
400 if (png_ptr == NULL)
401 return;
402
403 if (info_ptr_ptr != NULL)
404 info_ptr = *info_ptr_ptr;
405
406 if (info_ptr != NULL)
407 {
408 /* Do this first in case of an error below; if the app implements its own
409 * memory management this can lead to png_free calling png_error, which
410 * will abort this routine and return control to the app error handler.
411 * An infinite loop may result if it then tries to free the same info
412 * ptr.
413 */
414 *info_ptr_ptr = NULL;
415
416 png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
417 memset(info_ptr, 0, (sizeof *info_ptr));
418 png_free(png_ptr, info_ptr);
419 }
420 }
421
422 /* Initialize the info structure. This is now an internal function (0.89)
423 * and applications using it are urged to use png_create_info_struct()
424 * instead. Use deprecated in 1.6.0, internal use removed (used internally it
425 * is just a memset).
426 *
427 * NOTE: it is almost inconceivable that this API is used because it bypasses
428 * the user-memory mechanism and the user error handling/warning mechanisms in
429 * those cases where it does anything other than a memset.
430 */
431 PNG_FUNCTION(void,PNGAPI
432 png_info_init_3,(png_infopp ptr_ptr, png_size_t png_info_struct_size),
433 PNG_DEPRECATED)
434 {
435 png_inforp info_ptr = *ptr_ptr;
436
437 png_debug(1, "in png_info_init_3");
438
439 if (info_ptr == NULL)
440 return;
441
442 if ((sizeof (png_info)) > png_info_struct_size)
443 {
444 *ptr_ptr = NULL;
445 /* The following line is why this API should not be used: */
446 free(info_ptr);
447 info_ptr = png_voidcast(png_inforp, png_malloc_base(NULL,
448 (sizeof *info_ptr)));
449 if (info_ptr == NULL)
450 return;
451 *ptr_ptr = info_ptr;
452 }
453
454 /* Set everything to 0 */
455 memset(info_ptr, 0, (sizeof *info_ptr));
456 }
457
458 /* The following API is not called internally */
459 void PNGAPI
460 png_data_freer(png_const_structrp png_ptr, png_inforp info_ptr,
461 int freer, png_uint_32 mask)
462 {
463 png_debug(1, "in png_data_freer");
464
465 if (png_ptr == NULL || info_ptr == NULL)
466 return;
467
468 if (freer == PNG_DESTROY_WILL_FREE_DATA)
469 info_ptr->free_me |= mask;
470
471 else if (freer == PNG_USER_WILL_FREE_DATA)
472 info_ptr->free_me &= ~mask;
473
474 else
475 png_error(png_ptr, "Unknown freer parameter in png_data_freer");
476 }
477
478 void PNGAPI
479 png_free_data(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 mask,
480 int num)
481 {
482 png_debug(1, "in png_free_data");
483
484 if (png_ptr == NULL || info_ptr == NULL)
485 return;
486
487 #ifdef PNG_TEXT_SUPPORTED
488 /* Free text item num or (if num == -1) all text items */
489 if (info_ptr->text != 0 &&
490 ((mask & PNG_FREE_TEXT) & info_ptr->free_me) != 0)
491 {
492 if (num != -1)
493 {
494 png_free(png_ptr, info_ptr->text[num].key);
495 info_ptr->text[num].key = NULL;
496 }
497
498 else
499 {
500 int i;
501
502 for (i = 0; i < info_ptr->num_text; i++)
503 png_free(png_ptr, info_ptr->text[i].key);
504
505 png_free(png_ptr, info_ptr->text);
506 info_ptr->text = NULL;
507 info_ptr->num_text = 0;
508 }
509 }
510 #endif
511
512 #ifdef PNG_tRNS_SUPPORTED
513 /* Free any tRNS entry */
514 if (((mask & PNG_FREE_TRNS) & info_ptr->free_me) != 0)
515 {
516 info_ptr->valid &= ~PNG_INFO_tRNS;
517 png_free(png_ptr, info_ptr->trans_alpha);
518 info_ptr->trans_alpha = NULL;
519 info_ptr->num_trans = 0;
520 }
521 #endif
522
523 #ifdef PNG_sCAL_SUPPORTED
524 /* Free any sCAL entry */
525 if (((mask & PNG_FREE_SCAL) & info_ptr->free_me) != 0)
526 {
527 png_free(png_ptr, info_ptr->scal_s_width);
528 png_free(png_ptr, info_ptr->scal_s_height);
529 info_ptr->scal_s_width = NULL;
530 info_ptr->scal_s_height = NULL;
531 info_ptr->valid &= ~PNG_INFO_sCAL;
532 }
533 #endif
534
535 #ifdef PNG_pCAL_SUPPORTED
536 /* Free any pCAL entry */
537 if (((mask & PNG_FREE_PCAL) & info_ptr->free_me) != 0)
538 {
539 png_free(png_ptr, info_ptr->pcal_purpose);
540 png_free(png_ptr, info_ptr->pcal_units);
541 info_ptr->pcal_purpose = NULL;
542 info_ptr->pcal_units = NULL;
543
544 if (info_ptr->pcal_params != NULL)
545 {
546 int i;
547
548 for (i = 0; i < info_ptr->pcal_nparams; i++)
549 png_free(png_ptr, info_ptr->pcal_params[i]);
550
551 png_free(png_ptr, info_ptr->pcal_params);
552 info_ptr->pcal_params = NULL;
553 }
554 info_ptr->valid &= ~PNG_INFO_pCAL;
555 }
556 #endif
557
558 #ifdef PNG_iCCP_SUPPORTED
559 /* Free any profile entry */
560 if (((mask & PNG_FREE_ICCP) & info_ptr->free_me) != 0)
561 {
562 png_free(png_ptr, info_ptr->iccp_name);
563 png_free(png_ptr, info_ptr->iccp_profile);
564 info_ptr->iccp_name = NULL;
565 info_ptr->iccp_profile = NULL;
566 info_ptr->valid &= ~PNG_INFO_iCCP;
567 }
568 #endif
569
570 #ifdef PNG_sPLT_SUPPORTED
571 /* Free a given sPLT entry, or (if num == -1) all sPLT entries */
572 if (info_ptr->splt_palettes != 0 &&
573 ((mask & PNG_FREE_SPLT) & info_ptr->free_me) != 0)
574 {
575 if (num != -1)
576 {
577 png_free(png_ptr, info_ptr->splt_palettes[num].name);
578 png_free(png_ptr, info_ptr->splt_palettes[num].entries);
579 info_ptr->splt_palettes[num].name = NULL;
580 info_ptr->splt_palettes[num].entries = NULL;
581 }
582
583 else
584 {
585 int i;
586
587 for (i = 0; i < info_ptr->splt_palettes_num; i++)
588 {
589 png_free(png_ptr, info_ptr->splt_palettes[i].name);
590 png_free(png_ptr, info_ptr->splt_palettes[i].entries);
591 }
592
593 png_free(png_ptr, info_ptr->splt_palettes);
594 info_ptr->splt_palettes = NULL;
595 info_ptr->splt_palettes_num = 0;
596 info_ptr->valid &= ~PNG_INFO_sPLT;
597 }
598 }
599 #endif
600
601 #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
602 if (info_ptr->unknown_chunks != 0 &&
603 ((mask & PNG_FREE_UNKN) & info_ptr->free_me) != 0)
604 {
605 if (num != -1)
606 {
607 png_free(png_ptr, info_ptr->unknown_chunks[num].data);
608 info_ptr->unknown_chunks[num].data = NULL;
609 }
610
611 else
612 {
613 int i;
614
615 for (i = 0; i < info_ptr->unknown_chunks_num; i++)
616 png_free(png_ptr, info_ptr->unknown_chunks[i].data);
617
618 png_free(png_ptr, info_ptr->unknown_chunks);
619 info_ptr->unknown_chunks = NULL;
620 info_ptr->unknown_chunks_num = 0;
621 }
622 }
623 #endif
624
625 #ifdef PNG_hIST_SUPPORTED
626 /* Free any hIST entry */
627 if (((mask & PNG_FREE_HIST) & info_ptr->free_me) != 0)
628 {
629 png_free(png_ptr, info_ptr->hist);
630 info_ptr->hist = NULL;
631 info_ptr->valid &= ~PNG_INFO_hIST;
632 }
633 #endif
634
635 /* Free any PLTE entry that was internally allocated */
636 if (((mask & PNG_FREE_PLTE) & info_ptr->free_me) != 0)
637 {
638 png_free(png_ptr, info_ptr->palette);
639 info_ptr->palette = NULL;
640 info_ptr->valid &= ~PNG_INFO_PLTE;
641 info_ptr->num_palette = 0;
642 }
643
644 #ifdef PNG_INFO_IMAGE_SUPPORTED
645 /* Free any image bits attached to the info structure */
646 if (((mask & PNG_FREE_ROWS) & info_ptr->free_me) != 0)
647 {
648 if (info_ptr->row_pointers != 0)
649 {
650 png_uint_32 row;
651 for (row = 0; row < info_ptr->height; row++)
652 png_free(png_ptr, info_ptr->row_pointers[row]);
653
654 png_free(png_ptr, info_ptr->row_pointers);
655 info_ptr->row_pointers = NULL;
656 }
657 info_ptr->valid &= ~PNG_INFO_IDAT;
658 }
659 #endif
660
661 if (num != -1)
662 mask &= ~PNG_FREE_MUL;
663
664 info_ptr->free_me &= ~mask;
665 }
666 #endif /* READ || WRITE */
667
668 /* This function returns a pointer to the io_ptr associated with the user
669 * functions. The application should free any memory associated with this
670 * pointer before png_write_destroy() or png_read_destroy() are called.
671 */
672 png_voidp PNGAPI
673 png_get_io_ptr(png_const_structrp png_ptr)
674 {
675 if (png_ptr == NULL)
676 return (NULL);
677
678 return (png_ptr->io_ptr);
679 }
680
681 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
682 # ifdef PNG_STDIO_SUPPORTED
683 /* Initialize the default input/output functions for the PNG file. If you
684 * use your own read or write routines, you can call either png_set_read_fn()
685 * or png_set_write_fn() instead of png_init_io(). If you have defined
686 * PNG_NO_STDIO or otherwise disabled PNG_STDIO_SUPPORTED, you must use a
687 * function of your own because "FILE *" isn't necessarily available.
688 */
689 void PNGAPI
690 png_init_io(png_structrp png_ptr, png_FILE_p fp)
691 {
692 png_debug(1, "in png_init_io");
693
694 if (png_ptr == NULL)
695 return;
696
697 png_ptr->io_ptr = (png_voidp)fp;
698 }
699 # endif
700
701 # ifdef PNG_SAVE_INT_32_SUPPORTED
702 /* PNG signed integers are saved in 32-bit 2's complement format. ANSI C-90
703 * defines a cast of a signed integer to an unsigned integer either to preserve
704 * the value, if it is positive, or to calculate:
705 *
706 * (UNSIGNED_MAX+1) + integer
707 *
708 * Where UNSIGNED_MAX is the appropriate maximum unsigned value, so when the
709 * negative integral value is added the result will be an unsigned value
710 * correspnding to the 2's complement representation.
711 */
712 void PNGAPI
713 png_save_int_32(png_bytep buf, png_int_32 i)
714 {
715 png_save_uint_32(buf, i);
716 }
717 # endif
718
719 # ifdef PNG_TIME_RFC1123_SUPPORTED
720 /* Convert the supplied time into an RFC 1123 string suitable for use in
721 * a "Creation Time" or other text-based time string.
722 */
723 int PNGAPI
724 png_convert_to_rfc1123_buffer(char out[29], png_const_timep ptime)
725 {
726 static PNG_CONST char short_months[12][4] =
727 {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
728 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
729
730 if (out == NULL)
731 return 0;
732
733 if (ptime->year > 9999 /* RFC1123 limitation */ ||
734 ptime->month == 0 || ptime->month > 12 ||
735 ptime->day == 0 || ptime->day > 31 ||
736 ptime->hour > 23 || ptime->minute > 59 ||
737 ptime->second > 60)
738 return 0;
739
740 {
741 size_t pos = 0;
742 char number_buf[5]; /* enough for a four-digit year */
743
744 # define APPEND_STRING(string) pos = png_safecat(out, 29, pos, (string))
745 # define APPEND_NUMBER(format, value)\
746 APPEND_STRING(PNG_FORMAT_NUMBER(number_buf, format, (value)))
747 # define APPEND(ch) if (pos < 28) out[pos++] = (ch)
748
749 APPEND_NUMBER(PNG_NUMBER_FORMAT_u, (unsigned)ptime->day);
750 APPEND(' ');
751 APPEND_STRING(short_months[(ptime->month - 1)]);
752 APPEND(' ');
753 APPEND_NUMBER(PNG_NUMBER_FORMAT_u, ptime->year);
754 APPEND(' ');
755 APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->hour);
756 APPEND(':');
757 APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->minute);
758 APPEND(':');
759 APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->second);
760 APPEND_STRING(" +0000"); /* This reliably terminates the buffer */
761 PNG_UNUSED (pos)
762
763 # undef APPEND
764 # undef APPEND_NUMBER
765 # undef APPEND_STRING
766 }
767
768 return 1;
769 }
770
771 # if PNG_LIBPNG_VER < 10700
772 /* To do: remove the following from libpng-1.7 */
773 /* Original API that uses a private buffer in png_struct.
774 * Deprecated because it causes png_struct to carry a spurious temporary
775 * buffer (png_struct::time_buffer), better to have the caller pass this in.
776 */
777 png_const_charp PNGAPI
778 png_convert_to_rfc1123(png_structrp png_ptr, png_const_timep ptime)
779 {
780 if (png_ptr != NULL)
781 {
782 /* The only failure above if png_ptr != NULL is from an invalid ptime */
783 if (png_convert_to_rfc1123_buffer(png_ptr->time_buffer, ptime) == 0)
784 png_warning(png_ptr, "Ignoring invalid time value");
785
786 else
787 return png_ptr->time_buffer;
788 }
789
790 return NULL;
791 }
792 # endif /* LIBPNG_VER < 10700 */
793 # endif /* TIME_RFC1123 */
794
795 #endif /* READ || WRITE */
796
797 png_const_charp PNGAPI
798 png_get_copyright(png_const_structrp png_ptr)
799 {
800 PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */
801 #ifdef PNG_STRING_COPYRIGHT
802 return PNG_STRING_COPYRIGHT
803 #else
804 # ifdef __STDC__
805 return PNG_STRING_NEWLINE \
806 "libpng version 1.6.20 - December 3, 2015" PNG_STRING_NEWLINE \
807 "Copyright (c) 1998-2015 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \
808 "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
809 "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \
810 PNG_STRING_NEWLINE;
811 # else
812 return "libpng version 1.6.20 - December 3, 2015\
813 Copyright (c) 1998-2015 Glenn Randers-Pehrson\
814 Copyright (c) 1996-1997 Andreas Dilger\
815 Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.";
816 # endif
817 #endif
818 }
819
820 /* The following return the library version as a short string in the
821 * format 1.0.0 through 99.99.99zz. To get the version of *.h files
822 * used with your application, print out PNG_LIBPNG_VER_STRING, which
823 * is defined in png.h.
824 * Note: now there is no difference between png_get_libpng_ver() and
825 * png_get_header_ver(). Due to the version_nn_nn_nn typedef guard,
826 * it is guaranteed that png.c uses the correct version of png.h.
827 */
828 png_const_charp PNGAPI
829 png_get_libpng_ver(png_const_structrp png_ptr)
830 {
831 /* Version of *.c files used when building libpng */
832 return png_get_header_ver(png_ptr);
833 }
834
835 png_const_charp PNGAPI
836 png_get_header_ver(png_const_structrp png_ptr)
837 {
838 /* Version of *.h files used when building libpng */
839 PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */
840 return PNG_LIBPNG_VER_STRING;
841 }
842
843 png_const_charp PNGAPI
844 png_get_header_version(png_const_structrp png_ptr)
845 {
846 /* Returns longer string containing both version and date */
847 PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */
848 #ifdef __STDC__
849 return PNG_HEADER_VERSION_STRING
850 # ifndef PNG_READ_SUPPORTED
851 " (NO READ SUPPORT)"
852 # endif
853 PNG_STRING_NEWLINE;
854 #else
855 return PNG_HEADER_VERSION_STRING;
856 #endif
857 }
858
859 #ifdef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED
860 /* NOTE: this routine is not used internally! */
861 /* Build a grayscale palette. Palette is assumed to be 1 << bit_depth
862 * large of png_color. This lets grayscale images be treated as
863 * paletted. Most useful for gamma correction and simplification
864 * of code. This API is not used internally.
865 */
866 void PNGAPI
867 png_build_grayscale_palette(int bit_depth, png_colorp palette)
868 {
869 int num_palette;
870 int color_inc;
871 int i;
872 int v;
873
874 png_debug(1, "in png_do_build_grayscale_palette");
875
876 if (palette == NULL)
877 return;
878
879 switch (bit_depth)
880 {
881 case 1:
882 num_palette = 2;
883 color_inc = 0xff;
884 break;
885
886 case 2:
887 num_palette = 4;
888 color_inc = 0x55;
889 break;
890
891 case 4:
892 num_palette = 16;
893 color_inc = 0x11;
894 break;
895
896 case 8:
897 num_palette = 256;
898 color_inc = 1;
899 break;
900
901 default:
902 num_palette = 0;
903 color_inc = 0;
904 break;
905 }
906
907 for (i = 0, v = 0; i < num_palette; i++, v += color_inc)
908 {
909 palette[i].red = (png_byte)(v & 0xff);
910 palette[i].green = (png_byte)(v & 0xff);
911 palette[i].blue = (png_byte)(v & 0xff);
912 }
913 }
914 #endif
915
916 #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
917 int PNGAPI
918 png_handle_as_unknown(png_const_structrp png_ptr, png_const_bytep chunk_name)
919 {
920 /* Check chunk_name and return "keep" value if it's on the list, else 0 */
921 png_const_bytep p, p_end;
922
923 if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list == 0)
924 return PNG_HANDLE_CHUNK_AS_DEFAULT;
925
926 p_end = png_ptr->chunk_list;
927 p = p_end + png_ptr->num_chunk_list*5; /* beyond end */
928
929 /* The code is the fifth byte after each four byte string. Historically this
930 * code was always searched from the end of the list, this is no longer
931 * necessary because the 'set' routine handles duplicate entries correcty.
932 */
933 do /* num_chunk_list > 0, so at least one */
934 {
935 p -= 5;
936
937 if (memcmp(chunk_name, p, 4) == 0)
938 return p[4];
939 }
940 while (p > p_end);
941
942 /* This means that known chunks should be processed and unknown chunks should
943 * be handled according to the value of png_ptr->unknown_default; this can be
944 * confusing because, as a result, there are two levels of defaulting for
945 * unknown chunks.
946 */
947 return PNG_HANDLE_CHUNK_AS_DEFAULT;
948 }
949
950 #if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) ||\
951 defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED)
952 int /* PRIVATE */
953 png_chunk_unknown_handling(png_const_structrp png_ptr, png_uint_32 chunk_name)
954 {
955 png_byte chunk_string[5];
956
957 PNG_CSTRING_FROM_CHUNK(chunk_string, chunk_name);
958 return png_handle_as_unknown(png_ptr, chunk_string);
959 }
960 #endif /* READ_UNKNOWN_CHUNKS || HANDLE_AS_UNKNOWN */
961 #endif /* SET_UNKNOWN_CHUNKS */
962
963 #ifdef PNG_READ_SUPPORTED
964 /* This function, added to libpng-1.0.6g, is untested. */
965 int PNGAPI
966 png_reset_zstream(png_structrp png_ptr)
967 {
968 if (png_ptr == NULL)
969 return Z_STREAM_ERROR;
970
971 /* WARNING: this resets the window bits to the maximum! */
972 return (inflateReset(&png_ptr->zstream));
973 }
974 #endif /* READ */
975
976 /* This function was added to libpng-1.0.7 */
977 png_uint_32 PNGAPI
978 png_access_version_number(void)
979 {
980 /* Version of *.c files used when building libpng */
981 return((png_uint_32)PNG_LIBPNG_VER);
982 }
983
984 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
985 /* Ensure that png_ptr->zstream.msg holds some appropriate error message string.
986 * If it doesn't 'ret' is used to set it to something appropriate, even in cases
987 * like Z_OK or Z_STREAM_END where the error code is apparently a success code.
988 */
989 void /* PRIVATE */
990 png_zstream_error(png_structrp png_ptr, int ret)
991 {
992 /* Translate 'ret' into an appropriate error string, priority is given to the
993 * one in zstream if set. This always returns a string, even in cases like
994 * Z_OK or Z_STREAM_END where the error code is a success code.
995 */
996 if (png_ptr->zstream.msg == NULL) switch (ret)
997 {
998 default:
999 case Z_OK:
1000 png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected zlib return code");
1001 break;
1002
1003 case Z_STREAM_END:
1004 /* Normal exit */
1005 png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected end of LZ stream");
1006 break;
1007
1008 case Z_NEED_DICT:
1009 /* This means the deflate stream did not have a dictionary; this
1010 * indicates a bogus PNG.
1011 */
1012 png_ptr->zstream.msg = PNGZ_MSG_CAST("missing LZ dictionary");
1013 break;
1014
1015 case Z_ERRNO:
1016 /* gz APIs only: should not happen */
1017 png_ptr->zstream.msg = PNGZ_MSG_CAST("zlib IO error");
1018 break;
1019
1020 case Z_STREAM_ERROR:
1021 /* internal libpng error */
1022 png_ptr->zstream.msg = PNGZ_MSG_CAST("bad parameters to zlib");
1023 break;
1024
1025 case Z_DATA_ERROR:
1026 png_ptr->zstream.msg = PNGZ_MSG_CAST("damaged LZ stream");
1027 break;
1028
1029 case Z_MEM_ERROR:
1030 png_ptr->zstream.msg = PNGZ_MSG_CAST("insufficient memory");
1031 break;
1032
1033 case Z_BUF_ERROR:
1034 /* End of input or output; not a problem if the caller is doing
1035 * incremental read or write.
1036 */
1037 png_ptr->zstream.msg = PNGZ_MSG_CAST("truncated");
1038 break;
1039
1040 case Z_VERSION_ERROR:
1041 png_ptr->zstream.msg = PNGZ_MSG_CAST("unsupported zlib version");
1042 break;
1043
1044 case PNG_UNEXPECTED_ZLIB_RETURN:
1045 /* Compile errors here mean that zlib now uses the value co-opted in
1046 * pngpriv.h for PNG_UNEXPECTED_ZLIB_RETURN; update the switch above
1047 * and change pngpriv.h. Note that this message is "... return",
1048 * whereas the default/Z_OK one is "... return code".
1049 */
1050 png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected zlib return");
1051 break;
1052 }
1053 }
1054
1055 /* png_convert_size: a PNGAPI but no longer in png.h, so deleted
1056 * at libpng 1.5.5!
1057 */
1058
1059 /* Added at libpng version 1.2.34 and 1.4.0 (moved from pngset.c) */
1060 #ifdef PNG_GAMMA_SUPPORTED /* always set if COLORSPACE */
1061 static int
1062 png_colorspace_check_gamma(png_const_structrp png_ptr,
1063 png_colorspacerp colorspace, png_fixed_point gAMA, int from)
1064 /* This is called to check a new gamma value against an existing one. The
1065 * routine returns false if the new gamma value should not be written.
1066 *
1067 * 'from' says where the new gamma value comes from:
1068 *
1069 * 0: the new gamma value is the libpng estimate for an ICC profile
1070 * 1: the new gamma value comes from a gAMA chunk
1071 * 2: the new gamma value comes from an sRGB chunk
1072 */
1073 {
1074 png_fixed_point gtest;
1075
1076 if ((colorspace->flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 &&
1077 (png_muldiv(>est, colorspace->gamma, PNG_FP_1, gAMA) == 0 ||
1078 png_gamma_significant(gtest) != 0))
1079 {
1080 /* Either this is an sRGB image, in which case the calculated gamma
1081 * approximation should match, or this is an image with a profile and the
1082 * value libpng calculates for the gamma of the profile does not match the
1083 * value recorded in the file. The former, sRGB, case is an error, the
1084 * latter is just a warning.
1085 */
1086 if ((colorspace->flags & PNG_COLORSPACE_FROM_sRGB) != 0 || from == 2)
1087 {
1088 png_chunk_report(png_ptr, "gamma value does not match sRGB",
1089 PNG_CHUNK_ERROR);
1090 /* Do not overwrite an sRGB value */
1091 return from == 2;
1092 }
1093
1094 else /* sRGB tag not involved */
1095 {
1096 png_chunk_report(png_ptr, "gamma value does not match libpng estimate",
1097 PNG_CHUNK_WARNING);
1098 return from == 1;
1099 }
1100 }
1101
1102 return 1;
1103 }
1104
1105 void /* PRIVATE */
1106 png_colorspace_set_gamma(png_const_structrp png_ptr,
1107 png_colorspacerp colorspace, png_fixed_point gAMA)
1108 {
1109 /* Changed in libpng-1.5.4 to limit the values to ensure overflow can't
1110 * occur. Since the fixed point representation is asymetrical it is
1111 * possible for 1/gamma to overflow the limit of 21474 and this means the
1112 * gamma value must be at least 5/100000 and hence at most 20000.0. For
1113 * safety the limits here are a little narrower. The values are 0.00016 to
1114 * 6250.0, which are truly ridiculous gamma values (and will produce
1115 * displays that are all black or all white.)
1116 *
1117 * In 1.6.0 this test replaces the ones in pngrutil.c, in the gAMA chunk
1118 * handling code, which only required the value to be >0.
1119 */
1120 png_const_charp errmsg;
1121
1122 if (gAMA < 16 || gAMA > 625000000)
1123 errmsg = "gamma value out of range";
1124
1125 # ifdef PNG_READ_gAMA_SUPPORTED
1126 /* Allow the application to set the gamma value more than once */
1127 else if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
1128 (colorspace->flags & PNG_COLORSPACE_FROM_gAMA) != 0)
1129 errmsg = "duplicate";
1130 # endif
1131
1132 /* Do nothing if the colorspace is already invalid */
1133 else if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
1134 return;
1135
1136 else
1137 {
1138 if (png_colorspace_check_gamma(png_ptr, colorspace, gAMA,
1139 1/*from gAMA*/) != 0)
1140 {
1141 /* Store this gamma value. */
1142 colorspace->gamma = gAMA;
1143 colorspace->flags |=
1144 (PNG_COLORSPACE_HAVE_GAMMA | PNG_COLORSPACE_FROM_gAMA);
1145 }
1146
1147 /* At present if the check_gamma test fails the gamma of the colorspace is
1148 * not updated however the colorspace is not invalidated. This
1149 * corresponds to the case where the existing gamma comes from an sRGB
1150 * chunk or profile. An error message has already been output.
1151 */
1152 return;
1153 }
1154
1155 /* Error exit - errmsg has been set. */
1156 colorspace->flags |= PNG_COLORSPACE_INVALID;
1157 png_chunk_report(png_ptr, errmsg, PNG_CHUNK_WRITE_ERROR);
1158 }
1159
1160 void /* PRIVATE */
1161 png_colorspace_sync_info(png_const_structrp png_ptr, png_inforp info_ptr)
1162 {
1163 if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) != 0)
1164 {
1165 /* Everything is invalid */
1166 info_ptr->valid &= ~(PNG_INFO_gAMA|PNG_INFO_cHRM|PNG_INFO_sRGB|
1167 PNG_INFO_iCCP);
1168
1169 # ifdef PNG_COLORSPACE_SUPPORTED
1170 /* Clean up the iCCP profile now if it won't be used. */
1171 png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, -1/*not used*/);
1172 # else
1173 PNG_UNUSED(png_ptr)
1174 # endif
1175 }
1176
1177 else
1178 {
1179 # ifdef PNG_COLORSPACE_SUPPORTED
1180 /* Leave the INFO_iCCP flag set if the pngset.c code has already set
1181 * it; this allows a PNG to contain a profile which matches sRGB and
1182 * yet still have that profile retrievable by the application.
1183 */
1184 if ((info_ptr->colorspace.flags & PNG_COLORSPACE_MATCHES_sRGB) != 0)
1185 info_ptr->valid |= PNG_INFO_sRGB;
1186
1187 else
1188 info_ptr->valid &= ~PNG_INFO_sRGB;
1189
1190 if ((info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
1191 info_ptr->valid |= PNG_INFO_cHRM;
1192
1193 else
1194 info_ptr->valid &= ~PNG_INFO_cHRM;
1195 # endif
1196
1197 if ((info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0)
1198 info_ptr->valid |= PNG_INFO_gAMA;
1199
1200 else
1201 info_ptr->valid &= ~PNG_INFO_gAMA;
1202 }
1203 }
1204
1205 #ifdef PNG_READ_SUPPORTED
1206 void /* PRIVATE */
1207 png_colorspace_sync(png_const_structrp png_ptr, png_inforp info_ptr)
1208 {
1209 if (info_ptr == NULL) /* reduce code size; check here not in the caller */
1210 return;
1211
1212 info_ptr->colorspace = png_ptr->colorspace;
1213 png_colorspace_sync_info(png_ptr, info_ptr);
1214 }
1215 #endif
1216 #endif /* GAMMA */
1217
1218 #ifdef PNG_COLORSPACE_SUPPORTED
1219 /* Added at libpng-1.5.5 to support read and write of true CIEXYZ values for
1220 * cHRM, as opposed to using chromaticities. These internal APIs return
1221 * non-zero on a parameter error. The X, Y and Z values are required to be
1222 * positive and less than 1.0.
1223 */
1224 static int
1225 png_xy_from_XYZ(png_xy *xy, const png_XYZ *XYZ)
1226 {
1227 png_int_32 d, dwhite, whiteX, whiteY;
1228
1229 d = XYZ->red_X + XYZ->red_Y + XYZ->red_Z;
1230 if (png_muldiv(&xy->redx, XYZ->red_X, PNG_FP_1, d) == 0)
1231 return 1;
1232 if (png_muldiv(&xy->redy, XYZ->red_Y, PNG_FP_1, d) == 0)
1233 return 1;
1234 dwhite = d;
1235 whiteX = XYZ->red_X;
1236 whiteY = XYZ->red_Y;
1237
1238 d = XYZ->green_X + XYZ->green_Y + XYZ->green_Z;
1239 if (png_muldiv(&xy->greenx, XYZ->green_X, PNG_FP_1, d) == 0)
1240 return 1;
1241 if (png_muldiv(&xy->greeny, XYZ->green_Y, PNG_FP_1, d) == 0)
1242 return 1;
1243 dwhite += d;
1244 whiteX += XYZ->green_X;
1245 whiteY += XYZ->green_Y;
1246
1247 d = XYZ->blue_X + XYZ->blue_Y + XYZ->blue_Z;
1248 if (png_muldiv(&xy->bluex, XYZ->blue_X, PNG_FP_1, d) == 0)
1249 return 1;
1250 if (png_muldiv(&xy->bluey, XYZ->blue_Y, PNG_FP_1, d) == 0)
1251 return 1;
1252 dwhite += d;
1253 whiteX += XYZ->blue_X;
1254 whiteY += XYZ->blue_Y;
1255
1256 /* The reference white is simply the sum of the end-point (X,Y,Z) vectors,
1257 * thus:
1258 */
1259 if (png_muldiv(&xy->whitex, whiteX, PNG_FP_1, dwhite) == 0)
1260 return 1;
1261 if (png_muldiv(&xy->whitey, whiteY, PNG_FP_1, dwhite) == 0)
1262 return 1;
1263
1264 return 0;
1265 }
1266
1267 static int
1268 png_XYZ_from_xy(png_XYZ *XYZ, const png_xy *xy)
1269 {
1270 png_fixed_point red_inverse, green_inverse, blue_scale;
1271 png_fixed_point left, right, denominator;
1272
1273 /* Check xy and, implicitly, z. Note that wide gamut color spaces typically
1274 * have end points with 0 tristimulus values (these are impossible end
1275 * points, but they are used to cover the possible colors). We check
1276 * xy->whitey against 5, not 0, to avoid a possible integer overflow.
1277 */
1278 if (xy->redx < 0 || xy->redx > PNG_FP_1) return 1;
1279 if (xy->redy < 0 || xy->redy > PNG_FP_1-xy->redx) return 1;
1280 if (xy->greenx < 0 || xy->greenx > PNG_FP_1) return 1;
1281 if (xy->greeny < 0 || xy->greeny > PNG_FP_1-xy->greenx) return 1;
1282 if (xy->bluex < 0 || xy->bluex > PNG_FP_1) return 1;
1283 if (xy->bluey < 0 || xy->bluey > PNG_FP_1-xy->bluex) return 1;
1284 if (xy->whitex < 0 || xy->whitex > PNG_FP_1) return 1;
1285 if (xy->whitey < 5 || xy->whitey > PNG_FP_1-xy->whitex) return 1;
1286
1287 /* The reverse calculation is more difficult because the original tristimulus
1288 * value had 9 independent values (red,green,blue)x(X,Y,Z) however only 8
1289 * derived values were recorded in the cHRM chunk;
1290 * (red,green,blue,white)x(x,y). This loses one degree of freedom and
1291 * therefore an arbitrary ninth value has to be introduced to undo the
1292 * original transformations.
1293 *
1294 * Think of the original end-points as points in (X,Y,Z) space. The
1295 * chromaticity values (c) have the property:
1296 *
1297 * C
1298 * c = ---------
1299 * X + Y + Z
1300 *
1301 * For each c (x,y,z) from the corresponding original C (X,Y,Z). Thus the
1302 * three chromaticity values (x,y,z) for each end-point obey the
1303 * relationship:
1304 *
1305 * x + y + z = 1
1306 *
1307 * This describes the plane in (X,Y,Z) space that intersects each axis at the
1308 * value 1.0; call this the chromaticity plane. Thus the chromaticity
1309 * calculation has scaled each end-point so that it is on the x+y+z=1 plane
1310 * and chromaticity is the intersection of the vector from the origin to the
1311 * (X,Y,Z) value with the chromaticity plane.
1312 *
1313 * To fully invert the chromaticity calculation we would need the three
1314 * end-point scale factors, (red-scale, green-scale, blue-scale), but these
1315 * were not recorded. Instead we calculated the reference white (X,Y,Z) and
1316 * recorded the chromaticity of this. The reference white (X,Y,Z) would have
1317 * given all three of the scale factors since:
1318 *
1319 * color-C = color-c * color-scale
1320 * white-C = red-C + green-C + blue-C
1321 * = red-c*red-scale + green-c*green-scale + blue-c*blue-scale
1322 *
1323 * But cHRM records only white-x and white-y, so we have lost the white scale
1324 * factor:
1325 *
1326 * white-C = white-c*white-scale
1327 *
1328 * To handle this the inverse transformation makes an arbitrary assumption
1329 * about white-scale:
1330 *
1331 * Assume: white-Y = 1.0
1332 * Hence: white-scale = 1/white-y
1333 * Or: red-Y + green-Y + blue-Y = 1.0
1334 *
1335 * Notice the last statement of the assumption gives an equation in three of
1336 * the nine values we want to calculate. 8 more equations come from the
1337 * above routine as summarised at the top above (the chromaticity
1338 * calculation):
1339 *
1340 * Given: color-x = color-X / (color-X + color-Y + color-Z)
1341 * Hence: (color-x - 1)*color-X + color.x*color-Y + color.x*color-Z = 0
1342 *
1343 * This is 9 simultaneous equations in the 9 variables "color-C" and can be
1344 * solved by Cramer's rule. Cramer's rule requires calculating 10 9x9 matrix
1345 * determinants, however this is not as bad as it seems because only 28 of
1346 * the total of 90 terms in the various matrices are non-zero. Nevertheless
1347 * Cramer's rule is notoriously numerically unstable because the determinant
1348 * calculation involves the difference of large, but similar, numbers. It is
1349 * difficult to be sure that the calculation is stable for real world values
1350 * and it is certain that it becomes unstable where the end points are close
1351 * together.
1352 *
1353 * So this code uses the perhaps slightly less optimal but more
1354 * understandable and totally obvious approach of calculating color-scale.
1355 *
1356 * This algorithm depends on the precision in white-scale and that is
1357 * (1/white-y), so we can immediately see that as white-y approaches 0 the
1358 * accuracy inherent in the cHRM chunk drops off substantially.
1359 *
1360 * libpng arithmetic: a simple inversion of the above equations
1361 * ------------------------------------------------------------
1362 *
1363 * white_scale = 1/white-y
1364 * white-X = white-x * white-scale
1365 * white-Y = 1.0
1366 * white-Z = (1 - white-x - white-y) * white_scale
1367 *
1368 * white-C = red-C + green-C + blue-C
1369 * = red-c*red-scale + green-c*green-scale + blue-c*blue-scale
1370 *
1371 * This gives us three equations in (red-scale,green-scale,blue-scale) where
1372 * all the coefficients are now known:
1373 *
1374 * red-x*red-scale + green-x*green-scale + blue-x*blue-scale
1375 * = white-x/white-y
1376 * red-y*red-scale + green-y*green-scale + blue-y*blue-scale = 1
1377 * red-z*red-scale + green-z*green-scale + blue-z*blue-scale
1378 * = (1 - white-x - white-y)/white-y
1379 *
1380 * In the last equation color-z is (1 - color-x - color-y) so we can add all
1381 * three equations together to get an alternative third:
1382 *
1383 * red-scale + green-scale + blue-scale = 1/white-y = white-scale
1384 *
1385 * So now we have a Cramer's rule solution where the determinants are just
1386 * 3x3 - far more tractible. Unfortunately 3x3 determinants still involve
1387 * multiplication of three coefficients so we can't guarantee to avoid
1388 * overflow in the libpng fixed point representation. Using Cramer's rule in
1389 * floating point is probably a good choice here, but it's not an option for
1390 * fixed point. Instead proceed to simplify the first two equations by
1391 * eliminating what is likely to be the largest value, blue-scale:
1392 *
1393 * blue-scale = white-scale - red-scale - green-scale
1394 *
1395 * Hence:
1396 *
1397 * (red-x - blue-x)*red-scale + (green-x - blue-x)*green-scale =
1398 * (white-x - blue-x)*white-scale
1399 *
1400 * (red-y - blue-y)*red-scale + (green-y - blue-y)*green-scale =
1401 * 1 - blue-y*white-scale
1402 *
1403 * And now we can trivially solve for (red-scale,green-scale):
1404 *
1405 * green-scale =
1406 * (white-x - blue-x)*white-scale - (red-x - blue-x)*red-scale
1407 * -----------------------------------------------------------
1408 * green-x - blue-x
1409 *
1410 * red-scale =
1411 * 1 - blue-y*white-scale - (green-y - blue-y) * green-scale
1412 * ---------------------------------------------------------
1413 * red-y - blue-y
1414 *
1415 * Hence:
1416 *
1417 * red-scale =
1418 * ( (green-x - blue-x) * (white-y - blue-y) -
1419 * (green-y - blue-y) * (white-x - blue-x) ) / white-y
1420 * -------------------------------------------------------------------------
1421 * (green-x - blue-x)*(red-y - blue-y)-(green-y - blue-y)*(red-x - blue-x)
1422 *
1423 * green-scale =
1424 * ( (red-y - blue-y) * (white-x - blue-x) -
1425 * (red-x - blue-x) * (white-y - blue-y) ) / white-y
1426 * -------------------------------------------------------------------------
1427 * (green-x - blue-x)*(red-y - blue-y)-(green-y - blue-y)*(red-x - blue-x)
1428 *
1429 * Accuracy:
1430 * The input values have 5 decimal digits of accuracy. The values are all in
1431 * the range 0 < value < 1, so simple products are in the same range but may
1432 * need up to 10 decimal digits to preserve the original precision and avoid
1433 * underflow. Because we are using a 32-bit signed representation we cannot
1434 * match this; the best is a little over 9 decimal digits, less than 10.
1435 *
1436 * The approach used here is to preserve the maximum precision within the
1437 * signed representation. Because the red-scale calculation above uses the
1438 * difference between two products of values that must be in the range -1..+1
1439 * it is sufficient to divide the product by 7; ceil(100,000/32767*2). The
1440 * factor is irrelevant in the calculation because it is applied to both
1441 * numerator and denominator.
1442 *
1443 * Note that the values of the differences of the products of the
1444 * chromaticities in the above equations tend to be small, for example for
1445 * the sRGB chromaticities they are:
1446 *
1447 * red numerator: -0.04751
1448 * green numerator: -0.08788
1449 * denominator: -0.2241 (without white-y multiplication)
1450 *
1451 * The resultant Y coefficients from the chromaticities of some widely used
1452 * color space definitions are (to 15 decimal places):
1453 *
1454 * sRGB
1455 * 0.212639005871510 0.715168678767756 0.072192315360734
1456 * Kodak ProPhoto
1457 * 0.288071128229293 0.711843217810102 0.000085653960605
1458 * Adobe RGB
1459 * 0.297344975250536 0.627363566255466 0.075291458493998
1460 * Adobe Wide Gamut RGB
1461 * 0.258728243040113 0.724682314948566 0.016589442011321
1462 */
1463 /* By the argument, above overflow should be impossible here. The return
1464 * value of 2 indicates an internal error to the caller.
1465 */
1466 if (png_muldiv(&left, xy->greenx-xy->bluex, xy->redy - xy->bluey, 7) == 0)
1467 return 2;
1468 if (png_muldiv(&right, xy->greeny-xy->bluey, xy->redx - xy->bluex, 7) == 0)
1469 return 2;
1470 denominator = left - right;
1471
1472 /* Now find the red numerator. */
1473 if (png_muldiv(&left, xy->greenx-xy->bluex, xy->whitey-xy->bluey, 7) == 0)
1474 return 2;
1475 if (png_muldiv(&right, xy->greeny-xy->bluey, xy->whitex-xy->bluex, 7) == 0)
1476 return 2;
1477
1478 /* Overflow is possible here and it indicates an extreme set of PNG cHRM
1479 * chunk values. This calculation actually returns the reciprocal of the
1480 * scale value because this allows us to delay the multiplication of white-y
1481 * into the denominator, which tends to produce a small number.
1482 */
1483 if (png_muldiv(&red_inverse, xy->whitey, denominator, left-right) == 0 ||
1484 red_inverse <= xy->whitey /* r+g+b scales = white scale */)
1485 return 1;
1486
1487 /* Similarly for green_inverse: */
1488 if (png_muldiv(&left, xy->redy-xy->bluey, xy->whitex-xy->bluex, 7) == 0)
1489 return 2;
1490 if (png_muldiv(&right, xy->redx-xy->bluex, xy->whitey-xy->bluey, 7) == 0)
1491 return 2;
1492 if (png_muldiv(&green_inverse, xy->whitey, denominator, left-right) == 0 ||
1493 green_inverse <= xy->whitey)
1494 return 1;
1495
1496 /* And the blue scale, the checks above guarantee this can't overflow but it
1497 * can still produce 0 for extreme cHRM values.
1498 */
1499 blue_scale = png_reciprocal(xy->whitey) - png_reciprocal(red_inverse) -
1500 png_reciprocal(green_inverse);
1501 if (blue_scale <= 0)
1502 return 1;
1503
1504
1505 /* And fill in the png_XYZ: */
1506 if (png_muldiv(&XYZ->red_X, xy->redx, PNG_FP_1, red_inverse) == 0)
1507 return 1;
1508 if (png_muldiv(&XYZ->red_Y, xy->redy, PNG_FP_1, red_inverse) == 0)
1509 return 1;
1510 if (png_muldiv(&XYZ->red_Z, PNG_FP_1 - xy->redx - xy->redy, PNG_FP_1,
1511 red_inverse) == 0)
1512 return 1;
1513
1514 if (png_muldiv(&XYZ->green_X, xy->greenx, PNG_FP_1, green_inverse) == 0)
1515 return 1;
1516 if (png_muldiv(&XYZ->green_Y, xy->greeny, PNG_FP_1, green_inverse) == 0)
1517 return 1;
1518 if (png_muldiv(&XYZ->green_Z, PNG_FP_1 - xy->greenx - xy->greeny, PNG_FP_1,
1519 green_inverse) == 0)
1520 return 1;
1521
1522 if (png_muldiv(&XYZ->blue_X, xy->bluex, blue_scale, PNG_FP_1) == 0)
1523 return 1;
1524 if (png_muldiv(&XYZ->blue_Y, xy->bluey, blue_scale, PNG_FP_1) == 0)
1525 return 1;
1526 if (png_muldiv(&XYZ->blue_Z, PNG_FP_1 - xy->bluex - xy->bluey, blue_scale,
1527 PNG_FP_1) == 0)
1528 return 1;
1529
1530 return 0; /*success*/
1531 }
1532
1533 static int
1534 png_XYZ_normalize(png_XYZ *XYZ)
1535 {
1536 png_int_32 Y;
1537
1538 if (XYZ->red_Y < 0 || XYZ->green_Y < 0 || XYZ->blue_Y < 0 ||
1539 XYZ->red_X < 0 || XYZ->green_X < 0 || XYZ->blue_X < 0 ||
1540 XYZ->red_Z < 0 || XYZ->green_Z < 0 || XYZ->blue_Z < 0)
1541 return 1;
1542
1543 /* Normalize by scaling so the sum of the end-point Y values is PNG_FP_1.
1544 * IMPLEMENTATION NOTE: ANSI requires signed overflow not to occur, therefore
1545 * relying on addition of two positive values producing a negative one is not
1546 * safe.
1547 */
1548 Y = XYZ->red_Y;
1549 if (0x7fffffff - Y < XYZ->green_X)
1550 return 1;
1551 Y += XYZ->green_Y;
1552 if (0x7fffffff - Y < XYZ->blue_X)
1553 return 1;
1554 Y += XYZ->blue_Y;
1555
1556 if (Y != PNG_FP_1)
1557 {
1558 if (png_muldiv(&XYZ->red_X, XYZ->red_X, PNG_FP_1, Y) == 0)
1559 return 1;
1560 if (png_muldiv(&XYZ->red_Y, XYZ->red_Y, PNG_FP_1, Y) == 0)
1561 return 1;
1562 if (png_muldiv(&XYZ->red_Z, XYZ->red_Z, PNG_FP_1, Y) == 0)
1563 return 1;
1564
1565 if (png_muldiv(&XYZ->green_X, XYZ->green_X, PNG_FP_1, Y) == 0)
1566 return 1;
1567 if (png_muldiv(&XYZ->green_Y, XYZ->green_Y, PNG_FP_1, Y) == 0)
1568 return 1;
1569 if (png_muldiv(&XYZ->green_Z, XYZ->green_Z, PNG_FP_1, Y) == 0)
1570 return 1;
1571
1572 if (png_muldiv(&XYZ->blue_X, XYZ->blue_X, PNG_FP_1, Y) == 0)
1573 return 1;
1574 if (png_muldiv(&XYZ->blue_Y, XYZ->blue_Y, PNG_FP_1, Y) == 0)
1575 return 1;
1576 if (png_muldiv(&XYZ->blue_Z, XYZ->blue_Z, PNG_FP_1, Y) == 0)
1577 return 1;
1578 }
1579
1580 return 0;
1581 }
1582
1583 static int
1584 png_colorspace_endpoints_match(const png_xy *xy1, const png_xy *xy2, int delta)
1585 {
1586 /* Allow an error of +/-0.01 (absolute value) on each chromaticity */
1587 if (PNG_OUT_OF_RANGE(xy1->whitex, xy2->whitex,delta) ||
1588 PNG_OUT_OF_RANGE(xy1->whitey, xy2->whitey,delta) ||
1589 PNG_OUT_OF_RANGE(xy1->redx, xy2->redx, delta) ||
1590 PNG_OUT_OF_RANGE(xy1->redy, xy2->redy, delta) ||
1591 PNG_OUT_OF_RANGE(xy1->greenx, xy2->greenx,delta) ||
1592 PNG_OUT_OF_RANGE(xy1->greeny, xy2->greeny,delta) ||
1593 PNG_OUT_OF_RANGE(xy1->bluex, xy2->bluex, delta) ||
1594 PNG_OUT_OF_RANGE(xy1->bluey, xy2->bluey, delta))
1595 return 0;
1596 return 1;
1597 }
1598
1599 /* Added in libpng-1.6.0, a different check for the validity of a set of cHRM
1600 * chunk chromaticities. Earlier checks used to simply look for the overflow
1601 * condition (where the determinant of the matrix to solve for XYZ ends up zero
1602 * because the chromaticity values are not all distinct.) Despite this it is
1603 * theoretically possible to produce chromaticities that are apparently valid
1604 * but that rapidly degrade to invalid, potentially crashing, sets because of
1605 * arithmetic inaccuracies when calculations are performed on them. The new
1606 * check is to round-trip xy -> XYZ -> xy and then check that the result is
1607 * within a small percentage of the original.
1608 */
1609 static int
1610 png_colorspace_check_xy(png_XYZ *XYZ, const png_xy *xy)
1611 {
1612 int result;
1613 png_xy xy_test;
1614
1615 /* As a side-effect this routine also returns the XYZ endpoints. */
1616 result = png_XYZ_from_xy(XYZ, xy);
1617 if (result != 0)
1618 return result;
1619
1620 result = png_xy_from_XYZ(&xy_test, XYZ);
1621 if (result != 0)
1622 return result;
1623
1624 if (png_colorspace_endpoints_match(xy, &xy_test,
1625 5/*actually, the math is pretty accurate*/) != 0)
1626 return 0;
1627
1628 /* Too much slip */
1629 return 1;
1630 }
1631
1632 /* This is the check going the other way. The XYZ is modified to normalize it
1633 * (another side-effect) and the xy chromaticities are returned.
1634 */
1635 static int
1636 png_colorspace_check_XYZ(png_xy *xy, png_XYZ *XYZ)
1637 {
1638 int result;
1639 png_XYZ XYZtemp;
1640
1641 result = png_XYZ_normalize(XYZ);
1642 if (result != 0)
1643 return result;
1644
1645 result = png_xy_from_XYZ(xy, XYZ);
1646 if (result != 0)
1647 return result;
1648
1649 XYZtemp = *XYZ;
1650 return png_colorspace_check_xy(&XYZtemp, xy);
1651 }
1652
1653 /* Used to check for an endpoint match against sRGB */
1654 static const png_xy sRGB_xy = /* From ITU-R BT.709-3 */
1655 {
1656 /* color x y */
1657 /* red */ 64000, 33000,
1658 /* green */ 30000, 60000,
1659 /* blue */ 15000, 6000,
1660 /* white */ 31270, 32900
1661 };
1662
1663 static int
1664 png_colorspace_set_xy_and_XYZ(png_const_structrp png_ptr,
1665 png_colorspacerp colorspace, const png_xy *xy, const png_XYZ *XYZ,
1666 int preferred)
1667 {
1668 if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
1669 return 0;
1670
1671 /* The consistency check is performed on the chromaticities; this factors out
1672 * variations because of the normalization (or not) of the end point Y
1673 * values.
1674 */
1675 if (preferred < 2 &&
1676 (colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
1677 {
1678 /* The end points must be reasonably close to any we already have. The
1679 * following allows an error of up to +/-.001
1680 */
1681 if (png_colorspace_endpoints_match(xy, &colorspace->end_points_xy,
1682 100) == 0)
1683 {
1684 colorspace->flags |= PNG_COLORSPACE_INVALID;
1685 png_benign_error(png_ptr, "inconsistent chromaticities");
1686 return 0; /* failed */
1687 }
1688
1689 /* Only overwrite with preferred values */
1690 if (preferred == 0)
1691 return 1; /* ok, but no change */
1692 }
1693
1694 colorspace->end_points_xy = *xy;
1695 colorspace->end_points_XYZ = *XYZ;
1696 colorspace->flags |= PNG_COLORSPACE_HAVE_ENDPOINTS;
1697
1698 /* The end points are normally quoted to two decimal digits, so allow +/-0.01
1699 * on this test.
1700 */
1701 if (png_colorspace_endpoints_match(xy, &sRGB_xy, 1000) != 0)
1702 colorspace->flags |= PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB;
1703
1704 else
1705 colorspace->flags &= PNG_COLORSPACE_CANCEL(
1706 PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB);
1707
1708 return 2; /* ok and changed */
1709 }
1710
1711 int /* PRIVATE */
1712 png_colorspace_set_chromaticities(png_const_structrp png_ptr,
1713 png_colorspacerp colorspace, const png_xy *xy, int preferred)
1714 {
1715 /* We must check the end points to ensure they are reasonable - in the past
1716 * color management systems have crashed as a result of getting bogus
1717 * colorant values, while this isn't the fault of libpng it is the
1718 * responsibility of libpng because PNG carries the bomb and libpng is in a
1719 * position to protect against it.
1720 */
1721 png_XYZ XYZ;
1722
1723 switch (png_colorspace_check_xy(&XYZ, xy))
1724 {
1725 case 0: /* success */
1726 return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, xy, &XYZ,
1727 preferred);
1728
1729 case 1:
1730 /* We can't invert the chromaticities so we can't produce value XYZ
1731 * values. Likely as not a color management system will fail too.
1732 */
1733 colorspace->flags |= PNG_COLORSPACE_INVALID;
1734 png_benign_error(png_ptr, "invalid chromaticities");
1735 break;
1736
1737 default:
1738 /* libpng is broken; this should be a warning but if it happens we
1739 * want error reports so for the moment it is an error.
1740 */
1741 colorspace->flags |= PNG_COLORSPACE_INVALID;
1742 png_error(png_ptr, "internal error checking chromaticities");
1743 }
1744
1745 return 0; /* failed */
1746 }
1747
1748 int /* PRIVATE */
1749 png_colorspace_set_endpoints(png_const_structrp png_ptr,
1750 png_colorspacerp colorspace, const png_XYZ *XYZ_in, int preferred)
1751 {
1752 png_XYZ XYZ = *XYZ_in;
1753 png_xy xy;
1754
1755 switch (png_colorspace_check_XYZ(&xy, &XYZ))
1756 {
1757 case 0:
1758 return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, &xy, &XYZ,
1759 preferred);
1760
1761 case 1:
1762 /* End points are invalid. */
1763 colorspace->flags |= PNG_COLORSPACE_INVALID;
1764 png_benign_error(png_ptr, "invalid end points");
1765 break;
1766
1767 default:
1768 colorspace->flags |= PNG_COLORSPACE_INVALID;
1769 png_error(png_ptr, "internal error checking chromaticities");
1770 }
1771
1772 return 0; /* failed */
1773 }
1774
1775 #if defined(PNG_sRGB_SUPPORTED) || defined(PNG_iCCP_SUPPORTED)
1776 /* Error message generation */
1777 static char
1778 png_icc_tag_char(png_uint_32 byte)
1779 {
1780 byte &= 0xff;
1781 if (byte >= 32 && byte <= 126)
1782 return (char)byte;
1783 else
1784 return '?';
1785 }
1786
1787 static void
1788 png_icc_tag_name(char *name, png_uint_32 tag)
1789 {
1790 name[0] = '\'';
1791 name[1] = png_icc_tag_char(tag >> 24);
1792 name[2] = png_icc_tag_char(tag >> 16);
1793 name[3] = png_icc_tag_char(tag >> 8);
1794 name[4] = png_icc_tag_char(tag );
1795 name[5] = '\'';
1796 }
1797
1798 static int
1799 is_ICC_signature_char(png_alloc_size_t it)
1800 {
1801 return it == 32 || (it >= 48 && it <= 57) || (it >= 65 && it <= 90) ||
1802 (it >= 97 && it <= 122);
1803 }
1804
1805 static int
1806 is_ICC_signature(png_alloc_size_t it)
1807 {
1808 return is_ICC_signature_char(it >> 24) /* checks all the top bits */ &&
1809 is_ICC_signature_char((it >> 16) & 0xff) &&
1810 is_ICC_signature_char((it >> 8) & 0xff) &&
1811 is_ICC_signature_char(it & 0xff);
1812 }
1813
1814 static int
1815 png_icc_profile_error(png_const_structrp png_ptr, png_colorspacerp colorspace,
1816 png_const_charp name, png_alloc_size_t value, png_const_charp reason)
1817 {
1818 size_t pos;
1819 char message[196]; /* see below for calculation */
1820
1821 if (colorspace != NULL)
1822 colorspace->flags |= PNG_COLORSPACE_INVALID;
1823
1824 pos = png_safecat(message, (sizeof message), 0, "profile '"); /* 9 chars */
1825 pos = png_safecat(message, pos+79, pos, name); /* Truncate to 79 chars */
1826 pos = png_safecat(message, (sizeof message), pos, "': "); /* +2 = 90 */
1827 if (is_ICC_signature(value) != 0)
1828 {
1829 /* So 'value' is at most 4 bytes and the following cast is safe */
1830 png_icc_tag_name(message+pos, (png_uint_32)value);
1831 pos += 6; /* total +8; less than the else clause */
1832 message[pos++] = ':';
1833 message[pos++] = ' ';
1834 }
1835 # ifdef PNG_WARNINGS_SUPPORTED
1836 else
1837 {
1838 char number[PNG_NUMBER_BUFFER_SIZE]; /* +24 = 114*/
1839
1840 pos = png_safecat(message, (sizeof message), pos,
1841 png_format_number(number, number+(sizeof number),
1842 PNG_NUMBER_FORMAT_x, value));
1843 pos = png_safecat(message, (sizeof message), pos, "h: "); /*+2 = 116*/
1844 }
1845 # endif
1846 /* The 'reason' is an arbitrary message, allow +79 maximum 195 */
1847 pos = png_safecat(message, (sizeof message), pos, reason);
1848 PNG_UNUSED(pos)
1849
1850 /* This is recoverable, but make it unconditionally an app_error on write to
1851 * avoid writing invalid ICC profiles into PNG files (i.e., we handle them
1852 * on read, with a warning, but on write unless the app turns off
1853 * application errors the PNG won't be written.)
1854 */
1855 png_chunk_report(png_ptr, message,
1856 (colorspace != NULL) ? PNG_CHUNK_ERROR : PNG_CHUNK_WRITE_ERROR);
1857
1858 return 0;
1859 }
1860 #endif /* sRGB || iCCP */
1861
1862 #ifdef PNG_sRGB_SUPPORTED
1863 int /* PRIVATE */
1864 png_colorspace_set_sRGB(png_const_structrp png_ptr, png_colorspacerp colorspace,
1865 int intent)
1866 {
1867 /* sRGB sets known gamma, end points and (from the chunk) intent. */
1868 /* IMPORTANT: these are not necessarily the values found in an ICC profile
1869 * because ICC profiles store values adapted to a D50 environment; it is
1870 * expected that the ICC profile mediaWhitePointTag will be D50; see the
1871 * checks and code elsewhere to understand this better.
1872 *
1873 * These XYZ values, which are accurate to 5dp, produce rgb to gray
1874 * coefficients of (6968,23435,2366), which are reduced (because they add up
1875 * to 32769 not 32768) to (6968,23434,2366). These are the values that
1876 * libpng has traditionally used (and are the best values given the 15bit
1877 * algorithm used by the rgb to gray code.)
1878 */
1879 static const png_XYZ sRGB_XYZ = /* D65 XYZ (*not* the D50 adapted values!) */
1880 {
1881 /* color X Y Z */
1882 /* red */ 41239, 21264, 1933,
1883 /* green */ 35758, 71517, 11919,
1884 /* blue */ 18048, 7219, 95053
1885 };
1886
1887 /* Do nothing if the colorspace is already invalidated. */
1888 if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
1889 return 0;
1890
1891 /* Check the intent, then check for existing settings. It is valid for the
1892 * PNG file to have cHRM or gAMA chunks along with sRGB, but the values must
1893 * be consistent with the correct values. If, however, this function is
1894 * called below because an iCCP chunk matches sRGB then it is quite
1895 * conceivable that an older app recorded incorrect gAMA and cHRM because of
1896 * an incorrect calculation based on the values in the profile - this does
1897 * *not* invalidate the profile (though it still produces an error, which can
1898 * be ignored.)
1899 */
1900 if (intent < 0 || intent >= PNG_sRGB_INTENT_LAST)
1901 return png_icc_profile_error(png_ptr, colorspace, "sRGB",
1902 (unsigned)intent, "invalid sRGB rendering intent");
1903
1904 if ((colorspace->flags & PNG_COLORSPACE_HAVE_INTENT) != 0 &&
1905 colorspace->rendering_intent != intent)
1906 return png_icc_profile_error(png_ptr, colorspace, "sRGB",
1907 (unsigned)intent, "inconsistent rendering intents");
1908
1909 if ((colorspace->flags & PNG_COLORSPACE_FROM_sRGB) != 0)
1910 {
1911 png_benign_error(png_ptr, "duplicate sRGB information ignored");
1912 return 0;
1913 }
1914
1915 /* If the standard sRGB cHRM chunk does not match the one from the PNG file
1916 * warn but overwrite the value with the correct one.
1917 */
1918 if ((colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0 &&
1919 !png_colorspace_endpoints_match(&sRGB_xy, &colorspace->end_points_xy,
1920 100))
1921 png_chunk_report(png_ptr, "cHRM chunk does not match sRGB",
1922 PNG_CHUNK_ERROR);
1923
1924 /* This check is just done for the error reporting - the routine always
1925 * returns true when the 'from' argument corresponds to sRGB (2).
1926 */
1927 (void)png_colorspace_check_gamma(png_ptr, colorspace, PNG_GAMMA_sRGB_INVERSE,
1928 2/*from sRGB*/);
1929
1930 /* intent: bugs in GCC force 'int' to be used as the parameter type. */
1931 colorspace->rendering_intent = (png_uint_16)intent;
1932 colorspace->flags |= PNG_COLORSPACE_HAVE_INTENT;
1933
1934 /* endpoints */
1935 colorspace->end_points_xy = sRGB_xy;
1936 colorspace->end_points_XYZ = sRGB_XYZ;
1937 colorspace->flags |=
1938 (PNG_COLORSPACE_HAVE_ENDPOINTS|PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB);
1939
1940 /* gamma */
1941 colorspace->gamma = PNG_GAMMA_sRGB_INVERSE;
1942 colorspace->flags |= PNG_COLORSPACE_HAVE_GAMMA;
1943
1944 /* Finally record that we have an sRGB profile */
1945 colorspace->flags |=
1946 (PNG_COLORSPACE_MATCHES_sRGB|PNG_COLORSPACE_FROM_sRGB);
1947
1948 return 1; /* set */
1949 }
1950 #endif /* sRGB */
1951
1952 #ifdef PNG_iCCP_SUPPORTED
1953 /* Encoded value of D50 as an ICC XYZNumber. From the ICC 2010 spec the value
1954 * is XYZ(0.9642,1.0,0.8249), which scales to:
1955 *
1956 * (63189.8112, 65536, 54060.6464)
1957 */
1958 static const png_byte D50_nCIEXYZ[12] =
1959 { 0x00, 0x00, 0xf6, 0xd6, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d };
1960
1961 int /* PRIVATE */
1962 png_icc_check_length(png_const_structrp png_ptr, png_colorspacerp colorspace,
1963 png_const_charp name, png_uint_32 profile_length)
1964 {
1965 if (profile_length < 132)
1966 return png_icc_profile_error(png_ptr, colorspace, name, profile_length,
1967 "too short");
1968
1969 return 1;
1970 }
1971
1972 int /* PRIVATE */
1973 png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace,
1974 png_const_charp name, png_uint_32 profile_length,
1975 png_const_bytep profile/* first 132 bytes only */, int color_type)
1976 {
1977 png_uint_32 temp;
1978
1979 /* Length check; this cannot be ignored in this code because profile_length
1980 * is used later to check the tag table, so even if the profile seems over
1981 * long profile_length from the caller must be correct. The caller can fix
1982 * this up on read or write by just passing in the profile header length.
1983 */
1984 temp = png_get_uint_32(profile);
1985 if (temp != profile_length)
1986 return png_icc_profile_error(png_ptr, colorspace, name, temp,
1987 "length does not match profile");
1988
1989 temp = (png_uint_32) (*(profile+8));
1990 if (temp > 3 && (profile_length & 3))
1991 return png_icc_profile_error(png_ptr, colorspace, name, profile_length,
1992 "invalid length");
1993
1994 temp = png_get_uint_32(profile+128); /* tag count: 12 bytes/tag */
1995 if (temp > 357913930 || /* (2^32-4-132)/12: maximum possible tag count */
1996 profile_length < 132+12*temp) /* truncated tag table */
1997 return png_icc_profile_error(png_ptr, colorspace, name, temp,
1998 "tag count too large");
1999
2000 /* The 'intent' must be valid or we can't store it, ICC limits the intent to
2001 * 16 bits.
2002 */
2003 temp = png_get_uint_32(profile+64);
2004 if (temp >= 0xffff) /* The ICC limit */
2005 return png_icc_profile_error(png_ptr, colorspace, name, temp,
2006 "invalid rendering intent");
2007
2008 /* This is just a warning because the profile may be valid in future
2009 * versions.
2010 */
2011 if (temp >= PNG_sRGB_INTENT_LAST)
2012 (void)png_icc_profile_error(png_ptr, NULL, name, temp,
2013 "intent outside defined range");
2014
2015 /* At this point the tag table can't be checked because it hasn't necessarily
2016 * been loaded; however, various header fields can be checked. These checks
2017 * are for values permitted by the PNG spec in an ICC profile; the PNG spec
2018 * restricts the profiles that can be passed in an iCCP chunk (they must be
2019 * appropriate to processing PNG data!)
2020 */
2021
2022 /* Data checks (could be skipped). These checks must be independent of the
2023 * version number; however, the version number doesn't accomodate changes in
2024 * the header fields (just the known tags and the interpretation of the
2025 * data.)
2026 */
2027 temp = png_get_uint_32(profile+36); /* signature 'ascp' */
2028 if (temp != 0x61637370)
2029 return png_icc_profile_error(png_ptr, colorspace, name, temp,
2030 "invalid signature");
2031
2032 /* Currently the PCS illuminant/adopted white point (the computational
2033 * white point) are required to be D50,
2034 * however the profile contains a record of the illuminant so perhaps ICC
2035 * expects to be able to change this in the future (despite the rationale in
2036 * the introduction for using a fixed PCS adopted white.) Consequently the
2037 * following is just a warning.
2038 */
2039 if (memcmp(profile+68, D50_nCIEXYZ, 12) != 0)
2040 (void)png_icc_profile_error(png_ptr, NULL, name, 0/*no tag value*/,
2041 "PCS illuminant is not D50");
2042
2043 /* The PNG spec requires this:
2044 * "If the iCCP chunk is present, the image samples conform to the colour
2045 * space represented by the embedded ICC profile as defined by the
2046 * International Color Consortium [ICC]. The colour space of the ICC profile
2047 * shall be an RGB colour space for colour images (PNG colour types 2, 3, and
2048 * 6), or a greyscale colour space for greyscale images (PNG colour types 0
2049 * and 4)."
2050 *
2051 * This checking code ensures the embedded profile (on either read or write)
2052 * conforms to the specification requirements. Notice that an ICC 'gray'
2053 * color-space profile contains the information to transform the monochrome
2054 * data to XYZ or L*a*b (according to which PCS the profile uses) and this
2055 * should be used in preference to the standard libpng K channel replication
2056 * into R, G and B channels.
2057 *
2058 * Previously it was suggested that an RGB profile on grayscale data could be
2059 * handled. However it it is clear that using an RGB profile in this context
2060 * must be an error - there is no specification of what it means. Thus it is
2061 * almost certainly more correct to ignore the profile.
2062 */
2063 temp = png_get_uint_32(profile+16); /* data colour space field */
2064 switch (temp)
2065 {
2066 case 0x52474220: /* 'RGB ' */
2067 if ((color_type & PNG_COLOR_MASK_COLOR) == 0)
2068 return png_icc_profile_error(png_ptr, colorspace, name, temp,
2069 "RGB color space not permitted on grayscale PNG");
2070 break;
2071
2072 case 0x47524159: /* 'GRAY' */
2073 if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
2074 return png_icc_profile_error(png_ptr, colorspace, name, temp,
2075 "Gray color space not permitted on RGB PNG");
2076 break;
2077
2078 default:
2079 return png_icc_profile_error(png_ptr, colorspace, name, temp,
2080 "invalid ICC profile color space");
2081 }
2082
2083 /* It is up to the application to check that the profile class matches the
2084 * application requirements; the spec provides no guidance, but it's pretty
2085 * weird if the profile is not scanner ('scnr'), monitor ('mntr'), printer
2086 * ('prtr') or 'spac' (for generic color spaces). Issue a warning in these
2087 * cases. Issue an error for device link or abstract profiles - these don't
2088 * contain the records necessary to transform the color-space to anything
2089 * other than the target device (and not even that for an abstract profile).
2090 * Profiles of these classes may not be embedded in images.
2091 */
2092 temp = png_get_uint_32(profile+12); /* profile/device class */
2093 switch (temp)
2094 {
2095 case 0x73636e72: /* 'scnr' */
2096 case 0x6d6e7472: /* 'mntr' */
2097 case 0x70727472: /* 'prtr' */
2098 case 0x73706163: /* 'spac' */
2099 /* All supported */
2100 break;
2101
2102 case 0x61627374: /* 'abst' */
2103 /* May not be embedded in an image */
2104 return png_icc_profile_error(png_ptr, colorspace, name, temp,
2105 "invalid embedded Abstract ICC profile");
2106
2107 case 0x6c696e6b: /* 'link' */
2108 /* DeviceLink profiles cannot be interpreted in a non-device specific
2109 * fashion, if an app uses the AToB0Tag in the profile the results are
2110 * undefined unless the result is sent to the intended device,
2111 * therefore a DeviceLink profile should not be found embedded in a
2112 * PNG.
2113 */
2114 return png_icc_profile_error(png_ptr, colorspace, name, temp,
2115 "unexpected DeviceLink ICC profile class");
2116
2117 case 0x6e6d636c: /* 'nmcl' */
2118 /* A NamedColor profile is also device specific, however it doesn't
2119 * contain an AToB0 tag that is open to misinterpretation. Almost
2120 * certainly it will fail the tests below.
2121 */
2122 (void)png_icc_profile_error(png_ptr, NULL, name, temp,
2123 "unexpected NamedColor ICC profile class");
2124 break;
2125
2126 default:
2127 /* To allow for future enhancements to the profile accept unrecognized
2128 * profile classes with a warning, these then hit the test below on the
2129 * tag content to ensure they are backward compatible with one of the
2130 * understood profiles.
2131 */
2132 (void)png_icc_profile_error(png_ptr, NULL, name, temp,
2133 "unrecognized ICC profile class");
2134 break;
2135 }
2136
2137 /* For any profile other than a device link one the PCS must be encoded
2138 * either in XYZ or Lab.
2139 */
2140 temp = png_get_uint_32(profile+20);
2141 switch (temp)
2142 {
2143 case 0x58595a20: /* 'XYZ ' */
2144 case 0x4c616220: /* 'Lab ' */
2145 break;
2146
2147 default:
2148 return png_icc_profile_error(png_ptr, colorspace, name, temp,
2149 "unexpected ICC PCS encoding");
2150 }
2151
2152 return 1;
2153 }
2154
2155 int /* PRIVATE */
2156 png_icc_check_tag_table(png_const_structrp png_ptr, png_colorspacerp colorspace,
2157 png_const_charp name, png_uint_32 profile_length,
2158 png_const_bytep profile /* header plus whole tag table */)
2159 {
2160 png_uint_32 tag_count = png_get_uint_32(profile+128);
2161 png_uint_32 itag;
2162 png_const_bytep tag = profile+132; /* The first tag */
2163
2164 /* First scan all the tags in the table and add bits to the icc_info value
2165 * (temporarily in 'tags').
2166 */
2167 for (itag=0; itag < tag_count; ++itag, tag += 12)
2168 {
2169 png_uint_32 tag_id = png_get_uint_32(tag+0);
2170 png_uint_32 tag_start = png_get_uint_32(tag+4); /* must be aligned */
2171 png_uint_32 tag_length = png_get_uint_32(tag+8);/* not padded */
2172
2173 /* The ICC specification does not exclude zero length tags, therefore the
2174 * start might actually be anywhere if there is no data, but this would be
2175 * a clear abuse of the intent of the standard so the start is checked for
2176 * being in range. All defined tag types have an 8 byte header - a 4 byte
2177 * type signature then 0.
2178 */
2179 if ((tag_start & 3) != 0)
2180 {
2181 /* CNHP730S.icc shipped with Microsoft Windows 64 violates this, it is
2182 * only a warning here because libpng does not care about the
2183 * alignment.
2184 */
2185 (void)png_icc_profile_error(png_ptr, NULL, name, tag_id,
2186 "ICC profile tag start not a multiple of 4");
2187 }
2188
2189 /* This is a hard error; potentially it can cause read outside the
2190 * profile.
2191 */
2192 if (tag_start > profile_length || tag_length > profile_length - tag_start)
2193 return png_icc_profile_error(png_ptr, colorspace, name, tag_id,
2194 "ICC profile tag outside profile");
2195 }
2196
2197 return 1; /* success, maybe with warnings */
2198 }
2199
2200 #ifdef PNG_sRGB_SUPPORTED
2201 #if PNG_sRGB_PROFILE_CHECKS >= 0
2202 /* Information about the known ICC sRGB profiles */
2203 static const struct
2204 {
2205 png_uint_32 adler, crc, length;
2206 png_uint_32 md5[4];
2207 png_byte have_md5;
2208 png_byte is_broken;
2209 png_uint_16 intent;
2210
2211 # define PNG_MD5(a,b,c,d) { a, b, c, d }, (a!=0)||(b!=0)||(c!=0)||(d!=0)
2212 # define PNG_ICC_CHECKSUM(adler, crc, md5, intent, broke, date, length, fname)\
2213 { adler, crc, length, md5, broke, intent },
2214
2215 } png_sRGB_checks[] =
2216 {
2217 /* This data comes from contrib/tools/checksum-icc run on downloads of
2218 * all four ICC sRGB profiles from www.color.org.
2219 */
2220 /* adler32, crc32, MD5[4], intent, date, length, file-name */
2221 PNG_ICC_CHECKSUM(0x0a3fd9f6, 0x3b8772b9,
2222 PNG_MD5(0x29f83dde, 0xaff255ae, 0x7842fae4, 0xca83390d), 0, 0,
2223 "2009/03/27 21:36:31", 3048, "sRGB_IEC61966-2-1_black_scaled.icc")
2224
2225 /* ICC sRGB v2 perceptual no black-compensation: */
2226 PNG_ICC_CHECKSUM(0x4909e5e1, 0x427ebb21,
2227 PNG_MD5(0xc95bd637, 0xe95d8a3b, 0x0df38f99, 0xc1320389), 1, 0,
2228 "2009/03/27 21:37:45", 3052, "sRGB_IEC61966-2-1_no_black_scaling.icc")
2229
2230 PNG_ICC_CHECKSUM(0xfd2144a1, 0x306fd8ae,
2231 PNG_MD5(0xfc663378, 0x37e2886b, 0xfd72e983, 0x8228f1b8), 0, 0,
2232 "2009/08/10 17:28:01", 60988, "sRGB_v4_ICC_preference_displayclass.icc")
2233
2234 /* ICC sRGB v4 perceptual */
2235 PNG_ICC_CHECKSUM(0x209c35d2, 0xbbef7812,
2236 PNG_MD5(0x34562abf, 0x994ccd06, 0x6d2c5721, 0xd0d68c5d), 0, 0,
2237 "2007/07/25 00:05:37", 60960, "sRGB_v4_ICC_preference.icc")
2238
2239 /* The following profiles have no known MD5 checksum. If there is a match
2240 * on the (empty) MD5 the other fields are used to attempt a match and
2241 * a warning is produced. The first two of these profiles have a 'cprt' tag
2242 * which suggests that they were also made by Hewlett Packard.
2243 */
2244 PNG_ICC_CHECKSUM(0xa054d762, 0x5d5129ce,
2245 PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 1, 0,
2246 "2004/07/21 18:57:42", 3024, "sRGB_IEC61966-2-1_noBPC.icc")
2247
2248 /* This is a 'mntr' (display) profile with a mediaWhitePointTag that does not
2249 * match the D50 PCS illuminant in the header (it is in fact the D65 values,
2250 * so the white point is recorded as the un-adapted value.) The profiles
2251 * below only differ in one byte - the intent - and are basically the same as
2252 * the previous profile except for the mediaWhitePointTag error and a missing
2253 * chromaticAdaptationTag.
2254 */
2255 PNG_ICC_CHECKSUM(0xf784f3fb, 0x182ea552,
2256 PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 0, 1/*broken*/,
2257 "1998/02/09 06:49:00", 3144, "HP-Microsoft sRGB v2 perceptual")
2258
2259 PNG_ICC_CHECKSUM(0x0398f3fc, 0xf29e526d,
2260 PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 1, 1/*broken*/,
2261 "1998/02/09 06:49:00", 3144, "HP-Microsoft sRGB v2 media-relative")
2262 };
2263
2264 static int
2265 png_compare_ICC_profile_with_sRGB(png_const_structrp png_ptr,
2266 png_const_bytep profile, uLong adler)
2267 {
2268 /* The quick check is to verify just the MD5 signature and trust the
2269 * rest of the data. Because the profile has already been verified for
2270 * correctness this is safe. png_colorspace_set_sRGB will check the 'intent'
2271 * field too, so if the profile has been edited with an intent not defined
2272 * by sRGB (but maybe defined by a later ICC specification) the read of
2273 * the profile will fail at that point.
2274 */
2275
2276 png_uint_32 length = 0;
2277 png_uint_32 intent = 0x10000; /* invalid */
2278 #if PNG_sRGB_PROFILE_CHECKS > 1
2279 uLong crc = 0; /* the value for 0 length data */
2280 #endif
2281 unsigned int i;
2282
2283 #ifdef PNG_SET_OPTION_SUPPORTED
2284 /* First see if PNG_SKIP_sRGB_CHECK_PROFILE has been set to "on" */
2285 if (((png_ptr->options >> PNG_SKIP_sRGB_CHECK_PROFILE) & 3) ==
2286 PNG_OPTION_ON)
2287 return 0;
2288 #endif
2289
2290 for (i=0; i < (sizeof png_sRGB_checks) / (sizeof png_sRGB_checks[0]); ++i)
2291 {
2292 if (png_get_uint_32(profile+84) == png_sRGB_checks[i].md5[0] &&
2293 png_get_uint_32(profile+88) == png_sRGB_checks[i].md5[1] &&
2294 png_get_uint_32(profile+92) == png_sRGB_checks[i].md5[2] &&
2295 png_get_uint_32(profile+96) == png_sRGB_checks[i].md5[3])
2296 {
2297 /* This may be one of the old HP profiles without an MD5, in that
2298 * case we can only use the length and Adler32 (note that these
2299 * are not used by default if there is an MD5!)
2300 */
2301 # if PNG_sRGB_PROFILE_CHECKS == 0
2302 if (png_sRGB_checks[i].have_md5 != 0)
2303 return 1+png_sRGB_checks[i].is_broken;
2304 # endif
2305
2306 /* Profile is unsigned or more checks have been configured in. */
2307 if (length == 0)
2308 {
2309 length = png_get_uint_32(profile);
2310 intent = png_get_uint_32(profile+64);
2311 }
2312
2313 /* Length *and* intent must match */
2314 if (length == (png_uint_32) png_sRGB_checks[i].length &&
2315 intent == (png_uint_32) png_sRGB_checks[i].intent)
2316 {
2317 /* Now calculate the adler32 if not done already. */
2318 if (adler == 0)
2319 {
2320 adler = adler32(0, NULL, 0);
2321 adler = adler32(adler, profile, length);
2322 }
2323
2324 if (adler == png_sRGB_checks[i].adler)
2325 {
2326 /* These basic checks suggest that the data has not been
2327 * modified, but if the check level is more than 1 perform
2328 * our own crc32 checksum on the data.
2329 */
2330 # if PNG_sRGB_PROFILE_CHECKS > 1
2331 if (crc == 0)
2332 {
2333 crc = crc32(0, NULL, 0);
2334 crc = crc32(crc, profile, length);
2335 }
2336
2337 /* So this check must pass for the 'return' below to happen.
2338 */
2339 if (crc == png_sRGB_checks[i].crc)
2340 # endif
2341 {
2342 if (png_sRGB_checks[i].is_broken != 0)
2343 {
2344 /* These profiles are known to have bad data that may cause
2345 * problems if they are used, therefore attempt to
2346 * discourage their use, skip the 'have_md5' warning below,
2347 * which is made irrelevant by this error.
2348 */
2349 png_chunk_report(png_ptr, "known incorrect sRGB profile",
2350 PNG_CHUNK_ERROR);
2351 }
2352
2353 /* Warn that this being done; this isn't even an error since
2354 * the profile is perfectly valid, but it would be nice if
2355 * people used the up-to-date ones.
2356 */
2357 else if (png_sRGB_checks[i].have_md5 == 0)
2358 {
2359 png_chunk_report(png_ptr,
2360 "out-of-date sRGB profile with no signature",
2361 PNG_CHUNK_WARNING);
2362 }
2363
2364 return 1+png_sRGB_checks[i].is_broken;
2365 }
2366 }
2367
2368 # if PNG_sRGB_PROFILE_CHECKS > 0
2369 /* The signature matched, but the profile had been changed in some
2370 * way. This probably indicates a data error or uninformed hacking.
2371 * Fall through to "no match".
2372 */
2373 png_chunk_report(png_ptr,
2374 "Not recognizing known sRGB profile that has been edited",
2375 PNG_CHUNK_WARNING);
2376 break;
2377 # endif
2378 }
2379 }
2380 }
2381
2382 return 0; /* no match */
2383 }
2384 #endif /* PNG_sRGB_PROFILE_CHECKS >= 0 */
2385
2386 void /* PRIVATE */
2387 png_icc_set_sRGB(png_const_structrp png_ptr,
2388 png_colorspacerp colorspace, png_const_bytep profile, uLong adler)
2389 {
2390 /* Is this profile one of the known ICC sRGB profiles? If it is, just set
2391 * the sRGB information.
2392 */
2393 #if PNG_sRGB_PROFILE_CHECKS >= 0
2394 if (png_compare_ICC_profile_with_sRGB(png_ptr, profile, adler) != 0)
2395 #endif
2396 (void)png_colorspace_set_sRGB(png_ptr, colorspace,
2397 (int)/*already checked*/png_get_uint_32(profile+64));
2398 }
2399 #endif /* sRGB */
2400
2401 int /* PRIVATE */
2402 png_colorspace_set_ICC(png_const_structrp png_ptr, png_colorspacerp colorspace,
2403 png_const_charp name, png_uint_32 profile_length, png_const_bytep profile,
2404 int color_type)
2405 {
2406 if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
2407 return 0;
2408
2409 if (png_icc_check_length(png_ptr, colorspace, name, profile_length) != 0 &&
2410 png_icc_check_header(png_ptr, colorspace, name, profile_length, profile,
2411 color_type) != 0 &&
2412 png_icc_check_tag_table(png_ptr, colorspace, name, profile_length,
2413 profile) != 0)
2414 {
2415 # ifdef PNG_sRGB_SUPPORTED
2416 /* If no sRGB support, don't try storing sRGB information */
2417 png_icc_set_sRGB(png_ptr, colorspace, profile, 0);
2418 # endif
2419 return 1;
2420 }
2421
2422 /* Failure case */
2423 return 0;
2424 }
2425 #endif /* iCCP */
2426
2427 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
2428 void /* PRIVATE */
2429 png_colorspace_set_rgb_coefficients(png_structrp png_ptr)
2430 {
2431 /* Set the rgb_to_gray coefficients from the colorspace. */
2432 if (png_ptr->rgb_to_gray_coefficients_set == 0 &&
2433 (png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
2434 {
2435 /* png_set_background has not been called, get the coefficients from the Y
2436 * values of the colorspace colorants.
2437 */
2438 png_fixed_point r = png_ptr->colorspace.end_points_XYZ.red_Y;
2439 png_fixed_point g = png_ptr->colorspace.end_points_XYZ.green_Y;
2440 png_fixed_point b = png_ptr->colorspace.end_points_XYZ.blue_Y;
2441 png_fixed_point total = r+g+b;
2442
2443 if (total > 0 &&
2444 r >= 0 && png_muldiv(&r, r, 32768, total) && r >= 0 && r <= 32768 &&
2445 g >= 0 && png_muldiv(&g, g, 32768, total) && g >= 0 && g <= 32768 &&
2446 b >= 0 && png_muldiv(&b, b, 32768, total) && b >= 0 && b <= 32768 &&
2447 r+g+b <= 32769)
2448 {
2449 /* We allow 0 coefficients here. r+g+b may be 32769 if two or
2450 * all of the coefficients were rounded up. Handle this by
2451 * reducing the *largest* coefficient by 1; this matches the
2452 * approach used for the default coefficients in pngrtran.c
2453 */
2454 int add = 0;
2455
2456 if (r+g+b > 32768)
2457 add = -1;
2458 else if (r+g+b < 32768)
2459 add = 1;
2460
2461 if (add != 0)
2462 {
2463 if (g >= r && g >= b)
2464 g += add;
2465 else if (r >= g && r >= b)
2466 r += add;
2467 else
2468 b += add;
2469 }
2470
2471 /* Check for an internal error. */
2472 if (r+g+b != 32768)
2473 png_error(png_ptr,
2474 "internal error handling cHRM coefficients");
2475
2476 else
2477 {
2478 png_ptr->rgb_to_gray_red_coeff = (png_uint_16)r;
2479 png_ptr->rgb_to_gray_green_coeff = (png_uint_16)g;
2480 }
2481 }
2482
2483 /* This is a png_error at present even though it could be ignored -
2484 * it should never happen, but it is important that if it does, the
2485 * bug is fixed.
2486 */
2487 else
2488 png_error(png_ptr, "internal error handling cHRM->XYZ");
2489 }
2490 }
2491 #endif /* READ_RGB_TO_GRAY */
2492
2493 #endif /* COLORSPACE */
2494
2495 #ifdef __GNUC__
2496 /* This exists solely to work round a warning from GNU C. */
2497 static int /* PRIVATE */
2498 png_gt(size_t a, size_t b)
2499 {
2500 return a > b;
2501 }
2502 #else
2503 # define png_gt(a,b) ((a) > (b))
2504 #endif
2505
2506 void /* PRIVATE */
2507 png_check_IHDR(png_const_structrp png_ptr,
2508 png_uint_32 width, png_uint_32 height, int bit_depth,
2509 int color_type, int interlace_type, int compression_type,
2510 int filter_type)
2511 {
2512 int error = 0;
2513
2514 /* Check for width and height valid values */
2515 if (width == 0)
2516 {
2517 png_warning(png_ptr, "Image width is zero in IHDR");
2518 error = 1;
2519 }
2520
2521 if (width > PNG_UINT_31_MAX)
2522 {
2523 png_warning(png_ptr, "Invalid image width in IHDR");
2524 error = 1;
2525 }
2526
2527 if (png_gt(((width + 7) & (~7)),
2528 ((PNG_SIZE_MAX
2529 - 48 /* big_row_buf hack */
2530 - 1) /* filter byte */
2531 / 8) /* 8-byte RGBA pixels */
2532 - 1)) /* extra max_pixel_depth pad */
2533 {
2534 /* The size of the row must be within the limits of this architecture.
2535 * Because the read code can perform arbitrary transformations the
2536 * maximum size is checked here. Because the code in png_read_start_row
2537 * adds extra space "for safety's sake" in several places a conservative
2538 * limit is used here.
2539 *
2540 * NOTE: it would be far better to check the size that is actually used,
2541 * but the effect in the real world is minor and the changes are more
2542 * extensive, therefore much more dangerous and much more difficult to
2543 * write in a way that avoids compiler warnings.
2544 */
2545 png_warning(png_ptr, "Image width is too large for this architecture");
2546 error = 1;
2547 }
2548
2549 #ifdef PNG_SET_USER_LIMITS_SUPPORTED
2550 if (width > png_ptr->user_width_max)
2551 #else
2552 if (width > PNG_USER_WIDTH_MAX)
2553 #endif
2554 {
2555 png_warning(png_ptr, "Image width exceeds user limit in IHDR");
2556 error = 1;
2557 }
2558
2559 if (height == 0)
2560 {
2561 png_warning(png_ptr, "Image height is zero in IHDR");
2562 error = 1;
2563 }
2564
2565 if (height > PNG_UINT_31_MAX)
2566 {
2567 png_warning(png_ptr, "Invalid image height in IHDR");
2568 error = 1;
2569 }
2570
2571 #ifdef PNG_SET_USER_LIMITS_SUPPORTED
2572 if (height > png_ptr->user_height_max)
2573 #else
2574 if (height > PNG_USER_HEIGHT_MAX)
2575 #endif
2576 {
2577 png_warning(png_ptr, "Image height exceeds user limit in IHDR");
2578 error = 1;
2579 }
2580
2581 /* Check other values */
2582 if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 &&
2583 bit_depth != 8 && bit_depth != 16)
2584 {
2585 png_warning(png_ptr, "Invalid bit depth in IHDR");
2586 error = 1;
2587 }
2588
2589 if (color_type < 0 || color_type == 1 ||
2590 color_type == 5 || color_type > 6)
2591 {
2592 png_warning(png_ptr, "Invalid color type in IHDR");
2593 error = 1;
2594 }
2595
2596 if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) ||
2597 ((color_type == PNG_COLOR_TYPE_RGB ||
2598 color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
2599 color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8))
2600 {
2601 png_warning(png_ptr, "Invalid color type/bit depth combination in IHDR");
2602 error = 1;
2603 }
2604
2605 if (interlace_type >= PNG_INTERLACE_LAST)
2606 {
2607 png_warning(png_ptr, "Unknown interlace method in IHDR");
2608 error = 1;
2609 }
2610
2611 if (compression_type != PNG_COMPRESSION_TYPE_BASE)
2612 {
2613 png_warning(png_ptr, "Unknown compression method in IHDR");
2614 error = 1;
2615 }
2616
2617 #ifdef PNG_MNG_FEATURES_SUPPORTED
2618 /* Accept filter_method 64 (intrapixel differencing) only if
2619 * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
2620 * 2. Libpng did not read a PNG signature (this filter_method is only
2621 * used in PNG datastreams that are embedded in MNG datastreams) and
2622 * 3. The application called png_permit_mng_features with a mask that
2623 * included PNG_FLAG_MNG_FILTER_64 and
2624 * 4. The filter_method is 64 and
2625 * 5. The color_type is RGB or RGBA
2626 */
2627 if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0 &&
2628 png_ptr->mng_features_permitted != 0)
2629 png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");
2630
2631 if (filter_type != PNG_FILTER_TYPE_BASE)
2632 {
2633 if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
2634 (filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&
2635 ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&
2636 (color_type == PNG_COLOR_TYPE_RGB ||
2637 color_type == PNG_COLOR_TYPE_RGB_ALPHA)))
2638 {
2639 png_warning(png_ptr, "Unknown filter method in IHDR");
2640 error = 1;
2641 }
2642
2643 if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0)
2644 {
2645 png_warning(png_ptr, "Invalid filter method in IHDR");
2646 error = 1;
2647 }
2648 }
2649
2650 #else
2651 if (filter_type != PNG_FILTER_TYPE_BASE)
2652 {
2653 png_warning(png_ptr, "Unknown filter method in IHDR");
2654 error = 1;
2655 }
2656 #endif
2657
2658 if (error == 1)
2659 png_error(png_ptr, "Invalid IHDR data");
2660 }
2661
2662 #if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED)
2663 /* ASCII to fp functions */
2664 /* Check an ASCII formated floating point value, see the more detailed
2665 * comments in pngpriv.h
2666 */
2667 /* The following is used internally to preserve the sticky flags */
2668 #define png_fp_add(state, flags) ((state) |= (flags))
2669 #define png_fp_set(state, value) ((state) = (value) | ((state) & PNG_FP_STICKY))
2670
2671 int /* PRIVATE */
2672 png_check_fp_number(png_const_charp string, png_size_t size, int *statep,
2673 png_size_tp whereami)
2674 {
2675 int state = *statep;
2676 png_size_t i = *whereami;
2677
2678 while (i < size)
2679 {
2680 int type;
2681 /* First find the type of the next character */
2682 switch (string[i])
2683 {
2684 case 43: type = PNG_FP_SAW_SIGN; break;
2685 case 45: type = PNG_FP_SAW_SIGN + PNG_FP_NEGATIVE; break;
2686 case 46: type = PNG_FP_SAW_DOT; break;
2687 case 48: type = PNG_FP_SAW_DIGIT; break;
2688 case 49: case 50: case 51: case 52:
2689 case 53: case 54: case 55: case 56:
2690 case 57: type = PNG_FP_SAW_DIGIT + PNG_FP_NONZERO; break;
2691 case 69:
2692 case 101: type = PNG_FP_SAW_E; break;
2693 default: goto PNG_FP_End;
2694 }
2695
2696 /* Now deal with this type according to the current
2697 * state, the type is arranged to not overlap the
2698 * bits of the PNG_FP_STATE.
2699 */
2700 switch ((state & PNG_FP_STATE) + (type & PNG_FP_SAW_ANY))
2701 {
2702 case PNG_FP_INTEGER + PNG_FP_SAW_SIGN:
2703 if ((state & PNG_FP_SAW_ANY) != 0)
2704 goto PNG_FP_End; /* not a part of the number */
2705
2706 png_fp_add(state, type);
2707 break;
2708
2709 case PNG_FP_INTEGER + PNG_FP_SAW_DOT:
2710 /* Ok as trailer, ok as lead of fraction. */
2711 if ((state & PNG_FP_SAW_DOT) != 0) /* two dots */
2712 goto PNG_FP_End;
2713
2714 else if ((state & PNG_FP_SAW_DIGIT) != 0) /* trailing dot? */
2715 png_fp_add(state, type);
2716
2717 else
2718 png_fp_set(state, PNG_FP_FRACTION | type);
2719
2720 break;
2721
2722 case PNG_FP_INTEGER + PNG_FP_SAW_DIGIT:
2723 if ((state & PNG_FP_SAW_DOT) != 0) /* delayed fraction */
2724 png_fp_set(state, PNG_FP_FRACTION | PNG_FP_SAW_DOT);
2725
2726 png_fp_add(state, type | PNG_FP_WAS_VALID);
2727
2728 break;
2729
2730 case PNG_FP_INTEGER + PNG_FP_SAW_E:
2731 if ((state & PNG_FP_SAW_DIGIT) == 0)
2732 goto PNG_FP_End;
2733
2734 png_fp_set(state, PNG_FP_EXPONENT);
2735
2736 break;
2737
2738 /* case PNG_FP_FRACTION + PNG_FP_SAW_SIGN:
2739 goto PNG_FP_End; ** no sign in fraction */
2740
2741 /* case PNG_FP_FRACTION + PNG_FP_SAW_DOT:
2742 goto PNG_FP_End; ** Because SAW_DOT is always set */
2743
2744 case PNG_FP_FRACTION + PNG_FP_SAW_DIGIT:
2745 png_fp_add(state, type | PNG_FP_WAS_VALID);
2746 break;
2747
2748 case PNG_FP_FRACTION + PNG_FP_SAW_E:
2749 /* This is correct because the trailing '.' on an
2750 * integer is handled above - so we can only get here
2751 * with the sequence ".E" (with no preceding digits).
2752 */
2753 if ((state & PNG_FP_SAW_DIGIT) == 0)
2754 goto PNG_FP_End;
2755
2756 png_fp_set(state, PNG_FP_EXPONENT);
2757
2758 break;
2759
2760 case PNG_FP_EXPONENT + PNG_FP_SAW_SIGN:
2761 if ((state & PNG_FP_SAW_ANY) != 0)
2762 goto PNG_FP_End; /* not a part of the number */
2763
2764 png_fp_add(state, PNG_FP_SAW_SIGN);
2765
2766 break;
2767
2768 /* case PNG_FP_EXPONENT + PNG_FP_SAW_DOT:
2769 goto PNG_FP_End; */
2770
2771 case PNG_FP_EXPONENT + PNG_FP_SAW_DIGIT:
2772 png_fp_add(state, PNG_FP_SAW_DIGIT | PNG_FP_WAS_VALID);
2773
2774 break;
2775
2776 /* case PNG_FP_EXPONEXT + PNG_FP_SAW_E:
2777 goto PNG_FP_End; */
2778
2779 default: goto PNG_FP_End; /* I.e. break 2 */
2780 }
2781
2782 /* The character seems ok, continue. */
2783 ++i;
2784 }
2785
2786 PNG_FP_End:
2787 /* Here at the end, update the state and return the correct
2788 * return code.
2789 */
2790 *statep = state;
2791 *whereami = i;
2792
2793 return (state & PNG_FP_SAW_DIGIT) != 0;
2794 }
2795
2796
2797 /* The same but for a complete string. */
2798 int
2799 png_check_fp_string(png_const_charp string, png_size_t size)
2800 {
2801 int state=0;
2802 png_size_t char_index=0;
2803
2804 if (png_check_fp_number(string, size, &state, &char_index) != 0 &&
2805 (char_index == size || string[char_index] == 0))
2806 return state /* must be non-zero - see above */;
2807
2808 return 0; /* i.e. fail */
2809 }
2810 #endif /* pCAL || sCAL */
2811
2812 #ifdef PNG_sCAL_SUPPORTED
2813 # ifdef PNG_FLOATING_POINT_SUPPORTED
2814 /* Utility used below - a simple accurate power of ten from an integral
2815 * exponent.
2816 */
2817 static double
2818 png_pow10(int power)
2819 {
2820 int recip = 0;
2821 double d = 1;
2822
2823 /* Handle negative exponent with a reciprocal at the end because
2824 * 10 is exact whereas .1 is inexact in base 2
2825 */
2826 if (power < 0)
2827 {
2828 if (power < DBL_MIN_10_EXP) return 0;
2829 recip = 1, power = -power;
2830 }
2831
2832 if (power > 0)
2833 {
2834 /* Decompose power bitwise. */
2835 double mult = 10;
2836 do
2837 {
2838 if (power & 1) d *= mult;
2839 mult *= mult;
2840 power >>= 1;
2841 }
2842 while (power > 0);
2843
2844 if (recip != 0) d = 1/d;
2845 }
2846 /* else power is 0 and d is 1 */
2847
2848 return d;
2849 }
2850
2851 /* Function to format a floating point value in ASCII with a given
2852 * precision.
2853 */
2854 void /* PRIVATE */
2855 png_ascii_from_fp(png_const_structrp png_ptr, png_charp ascii, png_size_t size,
2856 double fp, unsigned int precision)
2857 {
2858 /* We use standard functions from math.h, but not printf because
2859 * that would require stdio. The caller must supply a buffer of
2860 * sufficient size or we will png_error. The tests on size and
2861 * the space in ascii[] consumed are indicated below.
2862 */
2863 if (precision < 1)
2864 precision = DBL_DIG;
2865
2866 /* Enforce the limit of the implementation precision too. */
2867 if (precision > DBL_DIG+1)
2868 precision = DBL_DIG+1;
2869
2870 /* Basic sanity checks */
2871 if (size >= precision+5) /* See the requirements below. */
2872 {
2873 if (fp < 0)
2874 {
2875 fp = -fp;
2876 *ascii++ = 45; /* '-' PLUS 1 TOTAL 1 */
2877 --size;
2878 }
2879
2880 if (fp >= DBL_MIN && fp <= DBL_MAX)
2881 {
2882 int exp_b10; /* A base 10 exponent */
2883 double base; /* 10^exp_b10 */
2884
2885 /* First extract a base 10 exponent of the number,
2886 * the calculation below rounds down when converting
2887 * from base 2 to base 10 (multiply by log10(2) -
2888 * 0.3010, but 77/256 is 0.3008, so exp_b10 needs to
2889 * be increased. Note that the arithmetic shift
2890 * performs a floor() unlike C arithmetic - using a
2891 * C multiply would break the following for negative
2892 * exponents.
2893 */
2894 (void)frexp(fp, &exp_b10); /* exponent to base 2 */
2895
2896 exp_b10 = (exp_b10 * 77) >> 8; /* <= exponent to base 10 */
2897
2898 /* Avoid underflow here. */
2899 base = png_pow10(exp_b10); /* May underflow */
2900
2901 while (base < DBL_MIN || base < fp)
2902 {
2903 /* And this may overflow. */
2904 double test = png_pow10(exp_b10+1);
2905
2906 if (test <= DBL_MAX)
2907 ++exp_b10, base = test;
2908
2909 else
2910 break;
2911 }
2912
2913 /* Normalize fp and correct exp_b10, after this fp is in the
2914 * range [.1,1) and exp_b10 is both the exponent and the digit
2915 * *before* which the decimal point should be inserted
2916 * (starting with 0 for the first digit). Note that this
2917 * works even if 10^exp_b10 is out of range because of the
2918 * test on DBL_MAX above.
2919 */
2920 fp /= base;
2921 while (fp >= 1) fp /= 10, ++exp_b10;
2922
2923 /* Because of the code above fp may, at this point, be
2924 * less than .1, this is ok because the code below can
2925 * handle the leading zeros this generates, so no attempt
2926 * is made to correct that here.
2927 */
2928
2929 {
2930 unsigned int czero, clead, cdigits;
2931 char exponent[10];
2932
2933 /* Allow up to two leading zeros - this will not lengthen
2934 * the number compared to using E-n.
2935 */
2936 if (exp_b10 < 0 && exp_b10 > -3) /* PLUS 3 TOTAL 4 */
2937 {
2938 czero = -exp_b10; /* PLUS 2 digits: TOTAL 3 */
2939 exp_b10 = 0; /* Dot added below before first output. */
2940 }
2941 else
2942 czero = 0; /* No zeros to add */
2943
2944 /* Generate the digit list, stripping trailing zeros and
2945 * inserting a '.' before a digit if the exponent is 0.
2946 */
2947 clead = czero; /* Count of leading zeros */
2948 cdigits = 0; /* Count of digits in list. */
2949
2950 do
2951 {
2952 double d;
2953
2954 fp *= 10;
2955 /* Use modf here, not floor and subtract, so that
2956 * the separation is done in one step. At the end
2957 * of the loop don't break the number into parts so
2958 * that the final digit is rounded.
2959 */
2960 if (cdigits+czero+1 < precision+clead)
2961 fp = modf(fp, &d);
2962
2963 else
2964 {
2965 d = floor(fp + .5);
2966
2967 if (d > 9)
2968 {
2969 /* Rounding up to 10, handle that here. */
2970 if (czero > 0)
2971 {
2972 --czero, d = 1;
2973 if (cdigits == 0) --clead;
2974 }
2975 else
2976 {
2977 while (cdigits > 0 && d > 9)
2978 {
2979 int ch = *--ascii;
2980
2981 if (exp_b10 != (-1))
2982 ++exp_b10;
2983
2984 else if (ch == 46)
2985 {
2986 ch = *--ascii, ++size;
2987 /* Advance exp_b10 to '1', so that the
2988 * decimal point happens after the
2989 * previous digit.
2990 */
2991 exp_b10 = 1;
2992 }
2993
2994 --cdigits;
2995 d = ch - 47; /* I.e. 1+(ch-48) */
2996 }
2997
2998 /* Did we reach the beginning? If so adjust the
2999 * exponent but take into account the leading
3000 * decimal point.
3001 */
3002 if (d > 9) /* cdigits == 0 */
3003 {
3004 if (exp_b10 == (-1))
3005 {
3006 /* Leading decimal point (plus zeros?), if
3007 * we lose the decimal point here it must
3008 * be reentered below.
3009 */
3010 int ch = *--ascii;
3011
3012 if (ch == 46)
3013 ++size, exp_b10 = 1;
3014
3015 /* Else lost a leading zero, so 'exp_b10' is
3016 * still ok at (-1)
3017 */
3018 }
3019 else
3020 ++exp_b10;
3021
3022 /* In all cases we output a '1' */
3023 d = 1;
3024 }
3025 }
3026 }
3027 fp = 0; /* Guarantees termination below. */
3028 }
3029
3030 if (d == 0)
3031 {
3032 ++czero;
3033 if (cdigits == 0) ++clead;
3034 }
3035 else
3036 {
3037 /* Included embedded zeros in the digit count. */
3038 cdigits += czero - clead;
3039 clead = 0;
3040
3041 while (czero > 0)
3042 {
3043 /* exp_b10 == (-1) means we just output the decimal
3044 * place - after the DP don't adjust 'exp_b10' any
3045 * more!
3046 */
3047 if (exp_b10 != (-1))
3048 {
3049 if (exp_b10 == 0) *ascii++ = 46, --size;
3050 /* PLUS 1: TOTAL 4 */
3051 --exp_b10;
3052 }
3053 *ascii++ = 48, --czero;
3054 }
3055
3056 if (exp_b10 != (-1))
3057 {
3058 if (exp_b10 == 0)
3059 *ascii++ = 46, --size; /* counted above */
3060
3061 --exp_b10;
3062 }
3063 *ascii++ = (char)(48 + (int)d), ++cdigits;
3064 }
3065 }
3066 while (cdigits+czero < precision+clead && fp > DBL_MIN);
3067
3068 /* The total output count (max) is now 4+precision */
3069
3070 /* Check for an exponent, if we don't need one we are
3071 * done and just need to terminate the string. At
3072 * this point exp_b10==(-1) is effectively if flag - it got
3073 * to '-1' because of the decrement after outputting
3074 * the decimal point above (the exponent required is
3075 * *not* -1!)
3076 */
3077 if (exp_b10 >= (-1) && exp_b10 <= 2)
3078 {
3079 /* The following only happens if we didn't output the
3080 * leading zeros above for negative exponent, so this
3081 * doesn't add to the digit requirement. Note that the
3082 * two zeros here can only be output if the two leading
3083 * zeros were *not* output, so this doesn't increase
3084 * the output count.
3085 */
3086 while (--exp_b10 >= 0) *ascii++ = 48;
3087
3088 *ascii = 0;
3089
3090 /* Total buffer requirement (including the '\0') is
3091 * 5+precision - see check at the start.
3092 */
3093 return;
3094 }
3095
3096 /* Here if an exponent is required, adjust size for
3097 * the digits we output but did not count. The total
3098 * digit output here so far is at most 1+precision - no
3099 * decimal point and no leading or trailing zeros have
3100 * been output.
3101 */
3102 size -= cdigits;
3103
3104 *ascii++ = 69, --size; /* 'E': PLUS 1 TOTAL 2+precision */
3105
3106 /* The following use of an unsigned temporary avoids ambiguities in
3107 * the signed arithmetic on exp_b10 and permits GCC at least to do
3108 * better optimization.
3109 */
3110 {
3111 unsigned int uexp_b10;
3112
3113 if (exp_b10 < 0)
3114 {
3115 *ascii++ = 45, --size; /* '-': PLUS 1 TOTAL 3+precision */
3116 uexp_b10 = -exp_b10;
3117 }
3118
3119 else
3120 uexp_b10 = exp_b10;
3121
3122 cdigits = 0;
3123
3124 while (uexp_b10 > 0)
3125 {
3126 exponent[cdigits++] = (char)(48 + uexp_b10 % 10);
3127 uexp_b10 /= 10;
3128 }
3129 }
3130
3131 /* Need another size check here for the exponent digits, so
3132 * this need not be considered above.
3133 */
3134 if (size > cdigits)
3135 {
3136 while (cdigits > 0) *ascii++ = exponent[--cdigits];
3137
3138 *ascii = 0;
3139
3140 return;
3141 }
3142 }
3143 }
3144 else if (!(fp >= DBL_MIN))
3145 {
3146 *ascii++ = 48; /* '0' */
3147 *ascii = 0;
3148 return;
3149 }
3150 else
3151 {
3152 *ascii++ = 105; /* 'i' */
3153 *ascii++ = 110; /* 'n' */
3154 *ascii++ = 102; /* 'f' */
3155 *ascii = 0;
3156 return;
3157 }
3158 }
3159
3160 /* Here on buffer too small. */
3161 png_error(png_ptr, "ASCII conversion buffer too small");
3162 }
3163
3164 # endif /* FLOATING_POINT */
3165
3166 # ifdef PNG_FIXED_POINT_SUPPORTED
3167 /* Function to format a fixed point value in ASCII.
3168 */
3169 void /* PRIVATE */
3170 png_ascii_from_fixed(png_const_structrp png_ptr, png_charp ascii,
3171 png_size_t size, png_fixed_point fp)
3172 {
3173 /* Require space for 10 decimal digits, a decimal point, a minus sign and a
3174 * trailing \0, 13 characters:
3175 */
3176 if (size > 12)
3177 {
3178 png_uint_32 num;
3179
3180 /* Avoid overflow here on the minimum integer. */
3181 if (fp < 0)
3182 *ascii++ = 45, num = -fp;
3183 else
3184 num = fp;
3185
3186 if (num <= 0x80000000) /* else overflowed */
3187 {
3188 unsigned int ndigits = 0, first = 16 /* flag value */;
3189 char digits[10];
3190
3191 while (num)
3192 {
3193 /* Split the low digit off num: */
3194 unsigned int tmp = num/10;
3195 num -= tmp*10;
3196 digits[ndigits++] = (char)(48 + num);
3197 /* Record the first non-zero digit, note that this is a number
3198 * starting at 1, it's not actually the array index.
3199 */
3200 if (first == 16 && num > 0)
3201 first = ndigits;
3202 num = tmp;
3203 }
3204
3205 if (ndigits > 0)
3206 {
3207 while (ndigits > 5) *ascii++ = digits[--ndigits];
3208 /* The remaining digits are fractional digits, ndigits is '5' or
3209 * smaller at this point. It is certainly not zero. Check for a
3210 * non-zero fractional digit:
3211 */
3212 if (first <= 5)
3213 {
3214 unsigned int i;
3215 *ascii++ = 46; /* decimal point */
3216 /* ndigits may be <5 for small numbers, output leading zeros
3217 * then ndigits digits to first:
3218 */
3219 i = 5;
3220 while (ndigits < i) *ascii++ = 48, --i;
3221 while (ndigits >= first) *ascii++ = digits[--ndigits];
3222 /* Don't output the trailing zeros! */
3223 }
3224 }
3225 else
3226 *ascii++ = 48;
3227
3228 /* And null terminate the string: */
3229 *ascii = 0;
3230 return;
3231 }
3232 }
3233
3234 /* Here on buffer too small. */
3235 png_error(png_ptr, "ASCII conversion buffer too small");
3236 }
3237 # endif /* FIXED_POINT */
3238 #endif /* SCAL */
3239
3240 #if defined(PNG_FLOATING_POINT_SUPPORTED) && \
3241 !defined(PNG_FIXED_POINT_MACRO_SUPPORTED) && \
3242 (defined(PNG_gAMA_SUPPORTED) || defined(PNG_cHRM_SUPPORTED) || \
3243 defined(PNG_sCAL_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) || \
3244 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)) || \
3245 (defined(PNG_sCAL_SUPPORTED) && \
3246 defined(PNG_FLOATING_ARITHMETIC_SUPPORTED))
3247 png_fixed_point
3248 png_fixed(png_const_structrp png_ptr, double fp, png_const_charp text)
3249 {
3250 double r = floor(100000 * fp + .5);
3251
3252 if (r > 2147483647. || r < -2147483648.)
3253 png_fixed_error(png_ptr, text);
3254
3255 # ifndef PNG_ERROR_TEXT_SUPPORTED
3256 PNG_UNUSED(text)
3257 # endif
3258
3259 return (png_fixed_point)r;
3260 }
3261 #endif
3262
3263 #if defined(PNG_GAMMA_SUPPORTED) || defined(PNG_COLORSPACE_SUPPORTED) ||\
3264 defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG_READ_pHYs_SUPPORTED)
3265 /* muldiv functions */
3266 /* This API takes signed arguments and rounds the result to the nearest
3267 * integer (or, for a fixed point number - the standard argument - to
3268 * the nearest .00001). Overflow and divide by zero are signalled in
3269 * the result, a boolean - true on success, false on overflow.
3270 */
3271 int
3272 png_muldiv(png_fixed_point_p res, png_fixed_point a, png_int_32 times,
3273 png_int_32 divisor)
3274 {
3275 /* Return a * times / divisor, rounded. */
3276 if (divisor != 0)
3277 {
3278 if (a == 0 || times == 0)
3279 {
3280 *res = 0;
3281 return 1;
3282 }
3283 else
3284 {
3285 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
3286 double r = a;
3287 r *= times;
3288 r /= divisor;
3289 r = floor(r+.5);
3290
3291 /* A png_fixed_point is a 32-bit integer. */
3292 if (r <= 2147483647. && r >= -2147483648.)
3293 {
3294 *res = (png_fixed_point)r;
3295 return 1;
3296 }
3297 #else
3298 int negative = 0;
3299 png_uint_32 A, T, D;
3300 png_uint_32 s16, s32, s00;
3301
3302 if (a < 0)
3303 negative = 1, A = -a;
3304 else
3305 A = a;
3306
3307 if (times < 0)
3308 negative = !negative, T = -times;
3309 else
3310 T = times;
3311
3312 if (divisor < 0)
3313 negative = !negative, D = -divisor;
3314 else
3315 D = divisor;
3316
3317 /* Following can't overflow because the arguments only
3318 * have 31 bits each, however the result may be 32 bits.
3319 */
3320 s16 = (A >> 16) * (T & 0xffff) +
3321 (A & 0xffff) * (T >> 16);
3322 /* Can't overflow because the a*times bit is only 30
3323 * bits at most.
3324 */
3325 s32 = (A >> 16) * (T >> 16) + (s16 >> 16);
3326 s00 = (A & 0xffff) * (T & 0xffff);
3327
3328 s16 = (s16 & 0xffff) << 16;
3329 s00 += s16;
3330
3331 if (s00 < s16)
3332 ++s32; /* carry */
3333
3334 if (s32 < D) /* else overflow */
3335 {
3336 /* s32.s00 is now the 64-bit product, do a standard
3337 * division, we know that s32 < D, so the maximum
3338 * required shift is 31.
3339 */
3340 int bitshift = 32;
3341 png_fixed_point result = 0; /* NOTE: signed */
3342
3343 while (--bitshift >= 0)
3344 {
3345 png_uint_32 d32, d00;
3346
3347 if (bitshift > 0)
3348 d32 = D >> (32-bitshift), d00 = D << bitshift;
3349
3350 else
3351 d32 = 0, d00 = D;
3352
3353 if (s32 > d32)
3354 {
3355 if (s00 < d00) --s32; /* carry */
3356 s32 -= d32, s00 -= d00, result += 1<<bitshift;
3357 }
3358
3359 else
3360 if (s32 == d32 && s00 >= d00)
3361 s32 = 0, s00 -= d00, result += 1<<bitshift;
3362 }
3363
3364 /* Handle the rounding. */
3365 if (s00 >= (D >> 1))
3366 ++result;
3367
3368 if (negative != 0)
3369 result = -result;
3370
3371 /* Check for overflow. */
3372 if ((negative != 0 && result <= 0) ||
3373 (negative == 0 && result >= 0))
3374 {
3375 *res = result;
3376 return 1;
3377 }
3378 }
3379 #endif
3380 }
3381 }
3382
3383 return 0;
3384 }
3385 #endif /* READ_GAMMA || INCH_CONVERSIONS */
3386
3387 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED)
3388 /* The following is for when the caller doesn't much care about the
3389 * result.
3390 */
3391 png_fixed_point
3392 png_muldiv_warn(png_const_structrp png_ptr, png_fixed_point a, png_int_32 times,
3393 png_int_32 divisor)
3394 {
3395 png_fixed_point result;
3396
3397 if (png_muldiv(&result, a, times, divisor) != 0)
3398 return result;
3399
3400 png_warning(png_ptr, "fixed point overflow ignored");
3401 return 0;
3402 }
3403 #endif
3404
3405 #ifdef PNG_GAMMA_SUPPORTED /* more fixed point functions for gamma */
3406 /* Calculate a reciprocal, return 0 on div-by-zero or overflow. */
3407 png_fixed_point
3408 png_reciprocal(png_fixed_point a)
3409 {
3410 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
3411 double r = floor(1E10/a+.5);
3412
3413 if (r <= 2147483647. && r >= -2147483648.)
3414 return (png_fixed_point)r;
3415 #else
3416 png_fixed_point res;
3417
3418 if (png_muldiv(&res, 100000, 100000, a) != 0)
3419 return res;
3420 #endif
3421
3422 return 0; /* error/overflow */
3423 }
3424
3425 /* This is the shared test on whether a gamma value is 'significant' - whether
3426 * it is worth doing gamma correction.
3427 */
3428 int /* PRIVATE */
3429 png_gamma_significant(png_fixed_point gamma_val)
3430 {
3431 return gamma_val < PNG_FP_1 - PNG_GAMMA_THRESHOLD_FIXED ||
3432 gamma_val > PNG_FP_1 + PNG_GAMMA_THRESHOLD_FIXED;
3433 }
3434 #endif
3435
3436 #ifdef PNG_READ_GAMMA_SUPPORTED
3437 #ifdef PNG_16BIT_SUPPORTED
3438 /* A local convenience routine. */
3439 static png_fixed_point
3440 png_product2(png_fixed_point a, png_fixed_point b)
3441 {
3442 /* The required result is 1/a * 1/b; the following preserves accuracy. */
3443 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
3444 double r = a * 1E-5;
3445 r *= b;
3446 r = floor(r+.5);
3447
3448 if (r <= 2147483647. && r >= -2147483648.)
3449 return (png_fixed_point)r;
3450 #else
3451 png_fixed_point res;
3452
3453 if (png_muldiv(&res, a, b, 100000) != 0)
3454 return res;
3455 #endif
3456
3457 return 0; /* overflow */
3458 }
3459 #endif /* 16BIT */
3460
3461 /* The inverse of the above. */
3462 png_fixed_point
3463 png_reciprocal2(png_fixed_point a, png_fixed_point b)
3464 {
3465 /* The required result is 1/a * 1/b; the following preserves accuracy. */
3466 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
3467 if (a != 0 && b != 0)
3468 {
3469 double r = 1E15/a;
3470 r /= b;
3471 r = floor(r+.5);
3472
3473 if (r <= 2147483647. && r >= -2147483648.)
3474 return (png_fixed_point)r;
3475 }
3476 #else
3477 /* This may overflow because the range of png_fixed_point isn't symmetric,
3478 * but this API is only used for the product of file and screen gamma so it
3479 * doesn't matter that the smallest number it can produce is 1/21474, not
3480 * 1/100000
3481 */
3482 png_fixed_point res = png_product2(a, b);
3483
3484 if (res != 0)
3485 return png_reciprocal(res);
3486 #endif
3487
3488 return 0; /* overflow */
3489 }
3490 #endif /* READ_GAMMA */
3491
3492 #ifdef PNG_READ_GAMMA_SUPPORTED /* gamma table code */
3493 #ifndef PNG_FLOATING_ARITHMETIC_SUPPORTED
3494 /* Fixed point gamma.
3495 *
3496 * The code to calculate the tables used below can be found in the shell script
3497 * contrib/tools/intgamma.sh
3498 *
3499 * To calculate gamma this code implements fast log() and exp() calls using only
3500 * fixed point arithmetic. This code has sufficient precision for either 8-bit
3501 * or 16-bit sample values.
3502 *
3503 * The tables used here were calculated using simple 'bc' programs, but C double
3504 * precision floating point arithmetic would work fine.
3505 *
3506 * 8-bit log table
3507 * This is a table of -log(value/255)/log(2) for 'value' in the range 128 to
3508 * 255, so it's the base 2 logarithm of a normalized 8-bit floating point
3509 * mantissa. The numbers are 32-bit fractions.
3510 */
3511 static const png_uint_32
3512 png_8bit_l2[128] =
3513 {
3514 4270715492U, 4222494797U, 4174646467U, 4127164793U, 4080044201U, 4033279239U,
3515 3986864580U, 3940795015U, 3895065449U, 3849670902U, 3804606499U, 3759867474U,
3516 3715449162U, 3671346997U, 3627556511U, 3584073329U, 3540893168U, 3498011834U,
3517 3455425220U, 3413129301U, 3371120137U, 3329393864U, 3287946700U, 3246774933U,
3518 3205874930U, 3165243125U, 3124876025U, 3084770202U, 3044922296U, 3005329011U,
3519 2965987113U, 2926893432U, 2888044853U, 2849438323U, 2811070844U, 2772939474U,
3520 2735041326U, 2697373562U, 2659933400U, 2622718104U, 2585724991U, 2548951424U,
3521 2512394810U, 2476052606U, 2439922311U, 2404001468U, 2368287663U, 2332778523U,
3522 2297471715U, 2262364947U, 2227455964U, 2192742551U, 2158222529U, 2123893754U,
3523 2089754119U, 2055801552U, 2022034013U, 1988449497U, 1955046031U, 1921821672U,
3524 1888774511U, 1855902668U, 1823204291U, 1790677560U, 1758320682U, 1726131893U,
3525 1694109454U, 1662251657U, 1630556815U, 1599023271U, 1567649391U, 1536433567U,
3526 1505374214U, 1474469770U, 1443718700U, 1413119487U, 1382670639U, 1352370686U,
3527 1322218179U, 1292211689U, 1262349810U, 1232631153U, 1203054352U, 1173618059U,
3528 1144320946U, 1115161701U, 1086139034U, 1057251672U, 1028498358U, 999877854U,
3529 971388940U, 943030410U, 914801076U, 886699767U, 858725327U, 830876614U,
3530 803152505U, 775551890U, 748073672U, 720716771U, 693480120U, 666362667U,
3531 639363374U, 612481215U, 585715177U, 559064263U, 532527486U, 506103872U,
3532 479792461U, 453592303U, 427502463U, 401522014U, 375650043U, 349885648U,
3533 324227938U, 298676034U, 273229066U, 247886176U, 222646516U, 197509248U,
3534 172473545U, 147538590U, 122703574U, 97967701U, 73330182U, 48790236U,
3535 24347096U, 0U
3536
3537 #if 0
3538 /* The following are the values for 16-bit tables - these work fine for the
3539 * 8-bit conversions but produce very slightly larger errors in the 16-bit
3540 * log (about 1.2 as opposed to 0.7 absolute error in the final value). To
3541 * use these all the shifts below must be adjusted appropriately.
3542 */
3543 65166, 64430, 63700, 62976, 62257, 61543, 60835, 60132, 59434, 58741, 58054,
3544 57371, 56693, 56020, 55352, 54689, 54030, 53375, 52726, 52080, 51439, 50803,
3545 50170, 49542, 48918, 48298, 47682, 47070, 46462, 45858, 45257, 44661, 44068,
3546 43479, 42894, 42312, 41733, 41159, 40587, 40020, 39455, 38894, 38336, 37782,
3547 37230, 36682, 36137, 35595, 35057, 34521, 33988, 33459, 32932, 32408, 31887,
3548 31369, 30854, 30341, 29832, 29325, 28820, 28319, 27820, 27324, 26830, 26339,
3549 25850, 25364, 24880, 24399, 23920, 23444, 22970, 22499, 22029, 21562, 21098,
3550 20636, 20175, 19718, 19262, 18808, 18357, 17908, 17461, 17016, 16573, 16132,
3551 15694, 15257, 14822, 14390, 13959, 13530, 13103, 12678, 12255, 11834, 11415,
3552 10997, 10582, 10168, 9756, 9346, 8937, 8531, 8126, 7723, 7321, 6921, 6523,
3553 6127, 5732, 5339, 4947, 4557, 4169, 3782, 3397, 3014, 2632, 2251, 1872, 1495,
3554 1119, 744, 372
3555 #endif
3556 };
3557
3558 static png_int_32
3559 png_log8bit(unsigned int x)
3560 {
3561 unsigned int lg2 = 0;
3562 /* Each time 'x' is multiplied by 2, 1 must be subtracted off the final log,
3563 * because the log is actually negate that means adding 1. The final
3564 * returned value thus has the range 0 (for 255 input) to 7.994 (for 1
3565 * input), return -1 for the overflow (log 0) case, - so the result is
3566 * always at most 19 bits.
3567 */
3568 if ((x &= 0xff) == 0)
3569 return -1;
3570
3571 if ((x & 0xf0) == 0)
3572 lg2 = 4, x <<= 4;
3573
3574 if ((x & 0xc0) == 0)
3575 lg2 += 2, x <<= 2;
3576
3577 if ((x & 0x80) == 0)
3578 lg2 += 1, x <<= 1;
3579
3580 /* result is at most 19 bits, so this cast is safe: */
3581 return (png_int_32)((lg2 << 16) + ((png_8bit_l2[x-128]+32768)>>16));
3582 }
3583
3584 /* The above gives exact (to 16 binary places) log2 values for 8-bit images,
3585 * for 16-bit images we use the most significant 8 bits of the 16-bit value to
3586 * get an approximation then multiply the approximation by a correction factor
3587 * determined by the remaining up to 8 bits. This requires an additional step
3588 * in the 16-bit case.
3589 *
3590 * We want log2(value/65535), we have log2(v'/255), where:
3591 *
3592 * value = v' * 256 + v''
3593 * = v' * f
3594 *
3595 * So f is value/v', which is equal to (256+v''/v') since v' is in the range 128
3596 * to 255 and v'' is in the range 0 to 255 f will be in the range 256 to less
3597 * than 258. The final factor also needs to correct for the fact that our 8-bit
3598 * value is scaled by 255, whereas the 16-bit values must be scaled by 65535.
3599 *
3600 * This gives a final formula using a calculated value 'x' which is value/v' and
3601 * scaling by 65536 to match the above table:
3602 *
3603 * log2(x/257) * 65536
3604 *
3605 * Since these numbers are so close to '1' we can use simple linear
3606 * interpolation between the two end values 256/257 (result -368.61) and 258/257
3607 * (result 367.179). The values used below are scaled by a further 64 to give
3608 * 16-bit precision in the interpolation:
3609 *
3610 * Start (256): -23591
3611 * Zero (257): 0
3612 * End (258): 23499
3613 */
3614 #ifdef PNG_16BIT_SUPPORTED
3615 static png_int_32
3616 png_log16bit(png_uint_32 x)
3617 {
3618 unsigned int lg2 = 0;
3619
3620 /* As above, but now the input has 16 bits. */
3621 if ((x &= 0xffff) == 0)
3622 return -1;
3623
3624 if ((x & 0xff00) == 0)
3625 lg2 = 8, x <<= 8;
3626
3627 if ((x & 0xf000) == 0)
3628 lg2 += 4, x <<= 4;
3629
3630 if ((x & 0xc000) == 0)
3631 lg2 += 2, x <<= 2;
3632
3633 if ((x & 0x8000) == 0)
3634 lg2 += 1, x <<= 1;
3635
3636 /* Calculate the base logarithm from the top 8 bits as a 28-bit fractional
3637 * value.
3638 */
3639 lg2 <<= 28;
3640 lg2 += (png_8bit_l2[(x>>8)-128]+8) >> 4;
3641
3642 /* Now we need to interpolate the factor, this requires a division by the top
3643 * 8 bits. Do this with maximum precision.
3644 */
3645 x = ((x << 16) + (x >> 9)) / (x >> 8);
3646
3647 /* Since we divided by the top 8 bits of 'x' there will be a '1' at 1<<24,
3648 * the value at 1<<16 (ignoring this) will be 0 or 1; this gives us exactly
3649 * 16 bits to interpolate to get the low bits of the result. Round the
3650 * answer. Note that the end point values are scaled by 64 to retain overall
3651 * precision and that 'lg2' is current scaled by an extra 12 bits, so adjust
3652 * the overall scaling by 6-12. Round at every step.
3653 */
3654 x -= 1U << 24;
3655
3656 if (x <= 65536U) /* <= '257' */
3657 lg2 += ((23591U * (65536U-x)) + (1U << (16+6-12-1))) >> (16+6-12);
3658
3659 else
3660 lg2 -= ((23499U * (x-65536U)) + (1U << (16+6-12-1))) >> (16+6-12);
3661
3662 /* Safe, because the result can't have more than 20 bits: */
3663 return (png_int_32)((lg2 + 2048) >> 12);
3664 }
3665 #endif /* 16BIT */
3666
3667 /* The 'exp()' case must invert the above, taking a 20-bit fixed point
3668 * logarithmic value and returning a 16 or 8-bit number as appropriate. In
3669 * each case only the low 16 bits are relevant - the fraction - since the
3670 * integer bits (the top 4) simply determine a shift.
3671 *
3672 * The worst case is the 16-bit distinction between 65535 and 65534. This
3673 * requires perhaps spurious accuracy in the decoding of the logarithm to
3674 * distinguish log2(65535/65534.5) - 10^-5 or 17 bits. There is little chance
3675 * of getting this accuracy in practice.
3676 *
3677 * To deal with this the following exp() function works out the exponent of the
3678 * frational part of the logarithm by using an accurate 32-bit value from the
3679 * top four fractional bits then multiplying in the remaining bits.
3680 */
3681 static const png_uint_32
3682 png_32bit_exp[16] =
3683 {
3684 /* NOTE: the first entry is deliberately set to the maximum 32-bit value. */
3685 4294967295U, 4112874773U, 3938502376U, 3771522796U, 3611622603U, 3458501653U,
3686 3311872529U, 3171459999U, 3037000500U, 2908241642U, 2784941738U, 2666869345U,
3687 2553802834U, 2445529972U, 2341847524U, 2242560872U
3688 };
3689
3690 /* Adjustment table; provided to explain the numbers in the code below. */
3691 #if 0
3692 for (i=11;i>=0;--i){ print i, " ", (1 - e(-(2^i)/65536*l(2))) * 2^(32-i), "\n"}
3693 11 44937.64284865548751208448
3694 10 45180.98734845585101160448
3695 9 45303.31936980687359311872
3696 8 45364.65110595323018870784
3697 7 45395.35850361789624614912
3698 6 45410.72259715102037508096
3699 5 45418.40724413220722311168
3700 4 45422.25021786898173001728
3701 3 45424.17186732298419044352
3702 2 45425.13273269940811464704
3703 1 45425.61317555035558641664
3704 0 45425.85339951654943850496
3705 #endif
3706
3707 static png_uint_32
3708 png_exp(png_fixed_point x)
3709 {
3710 if (x > 0 && x <= 0xfffff) /* Else overflow or zero (underflow) */
3711 {
3712 /* Obtain a 4-bit approximation */
3713 png_uint_32 e = png_32bit_exp[(x >> 12) & 0x0f];
3714
3715 /* Incorporate the low 12 bits - these decrease the returned value by
3716 * multiplying by a number less than 1 if the bit is set. The multiplier
3717 * is determined by the above table and the shift. Notice that the values
3718 * converge on 45426 and this is used to allow linear interpolation of the
3719 * low bits.
3720 */
3721 if (x & 0x800)
3722 e -= (((e >> 16) * 44938U) + 16U) >> 5;
3723
3724 if (x & 0x400)
3725 e -= (((e >> 16) * 45181U) + 32U) >> 6;
3726
3727 if (x & 0x200)
3728 e -= (((e >> 16) * 45303U) + 64U) >> 7;
3729
3730 if (x & 0x100)
3731 e -= (((e >> 16) * 45365U) + 128U) >> 8;
3732
3733 if (x & 0x080)
3734 e -= (((e >> 16) * 45395U) + 256U) >> 9;
3735
3736 if (x & 0x040)
3737 e -= (((e >> 16) * 45410U) + 512U) >> 10;
3738
3739 /* And handle the low 6 bits in a single block. */
3740 e -= (((e >> 16) * 355U * (x & 0x3fU)) + 256U) >> 9;
3741
3742 /* Handle the upper bits of x. */
3743 e >>= x >> 16;
3744 return e;
3745 }
3746
3747 /* Check for overflow */
3748 if (x <= 0)
3749 return png_32bit_exp[0];
3750
3751 /* Else underflow */
3752 return 0;
3753 }
3754
3755 static png_byte
3756 png_exp8bit(png_fixed_point lg2)
3757 {
3758 /* Get a 32-bit value: */
3759 png_uint_32 x = png_exp(lg2);
3760
3761 /* Convert the 32-bit value to 0..255 by multiplying by 256-1. Note that the
3762 * second, rounding, step can't overflow because of the first, subtraction,
3763 * step.
3764 */
3765 x -= x >> 8;
3766 return (png_byte)(((x + 0x7fffffU) >> 24) & 0xff);
3767 }
3768
3769 #ifdef PNG_16BIT_SUPPORTED
3770 static png_uint_16
3771 png_exp16bit(png_fixed_point lg2)
3772 {
3773 /* Get a 32-bit value: */
3774 png_uint_32 x = png_exp(lg2);
3775
3776 /* Convert the 32-bit value to 0..65535 by multiplying by 65536-1: */
3777 x -= x >> 16;
3778 return (png_uint_16)((x + 32767U) >> 16);
3779 }
3780 #endif /* 16BIT */
3781 #endif /* FLOATING_ARITHMETIC */
3782
3783 png_byte
3784 png_gamma_8bit_correct(unsigned int value, png_fixed_point gamma_val)
3785 {
3786 if (value > 0 && value < 255)
3787 {
3788 # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
3789 /* 'value' is unsigned, ANSI-C90 requires the compiler to correctly
3790 * convert this to a floating point value. This includes values that
3791 * would overflow if 'value' were to be converted to 'int'.
3792 *
3793 * Apparently GCC, however, does an intermediate conversion to (int)
3794 * on some (ARM) but not all (x86) platforms, possibly because of
3795 * hardware FP limitations. (E.g. if the hardware conversion always
3796 * assumes the integer register contains a signed value.) This results
3797 * in ANSI-C undefined behavior for large values.
3798 *
3799 * Other implementations on the same machine might actually be ANSI-C90
3800 * conformant and therefore compile spurious extra code for the large
3801 * values.
3802 *
3803 * We can be reasonably sure that an unsigned to float conversion
3804 * won't be faster than an int to float one. Therefore this code
3805 * assumes responsibility for the undefined behavior, which it knows
3806 * can't happen because of the check above.
3807 *
3808 * Note the argument to this routine is an (unsigned int) because, on
3809 * 16-bit platforms, it is assigned a value which might be out of
3810 * range for an (int); that would result in undefined behavior in the
3811 * caller if the *argument* ('value') were to be declared (int).
3812 */
3813 double r = floor(255*pow((int)/*SAFE*/value/255.,gamma_val*.00001)+.5);
3814 return (png_byte)r;
3815 # else
3816 png_int_32 lg2 = png_log8bit(value);
3817 png_fixed_point res;
3818
3819 if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1) != 0)
3820 return png_exp8bit(res);
3821
3822 /* Overflow. */
3823 value = 0;
3824 # endif
3825 }
3826
3827 return (png_byte)(value & 0xff);
3828 }
3829
3830 #ifdef PNG_16BIT_SUPPORTED
3831 png_uint_16
3832 png_gamma_16bit_correct(unsigned int value, png_fixed_point gamma_val)
3833 {
3834 if (value > 0 && value < 65535)
3835 {
3836 # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
3837 /* The same (unsigned int)->(double) constraints apply here as above,
3838 * however in this case the (unsigned int) to (int) conversion can
3839 * overflow on an ANSI-C90 compliant system so the cast needs to ensure
3840 * that this is not possible.
3841 */
3842 double r = floor(65535*pow((png_int_32)value/65535.,
3843 gamma_val*.00001)+.5);
3844 return (png_uint_16)r;
3845 # else
3846 png_int_32 lg2 = png_log16bit(value);
3847 png_fixed_point res;
3848
3849 if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1) != 0)
3850 return png_exp16bit(res);
3851
3852 /* Overflow. */
3853 value = 0;
3854 # endif
3855 }
3856
3857 return (png_uint_16)value;
3858 }
3859 #endif /* 16BIT */
3860
3861 /* This does the right thing based on the bit_depth field of the
3862 * png_struct, interpreting values as 8-bit or 16-bit. While the result
3863 * is nominally a 16-bit value if bit depth is 8 then the result is
3864 * 8-bit (as are the arguments.)
3865 */
3866 png_uint_16 /* PRIVATE */
3867 png_gamma_correct(png_structrp png_ptr, unsigned int value,
3868 png_fixed_point gamma_val)
3869 {
3870 if (png_ptr->bit_depth == 8)
3871 return png_gamma_8bit_correct(value, gamma_val);
3872
3873 #ifdef PNG_16BIT_SUPPORTED
3874 else
3875 return png_gamma_16bit_correct(value, gamma_val);
3876 #else
3877 /* should not reach this */
3878 return 0;
3879 #endif /* 16BIT */
3880 }
3881
3882 #ifdef PNG_16BIT_SUPPORTED
3883 /* Internal function to build a single 16-bit table - the table consists of
3884 * 'num' 256 entry subtables, where 'num' is determined by 'shift' - the amount
3885 * to shift the input values right (or 16-number_of_signifiant_bits).
3886 *
3887 * The caller is responsible for ensuring that the table gets cleaned up on
3888 * png_error (i.e. if one of the mallocs below fails) - i.e. the *table argument
3889 * should be somewhere that will be cleaned.
3890 */
3891 static void
3892 png_build_16bit_table(png_structrp png_ptr, png_uint_16pp *ptable,
3893 PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val)
3894 {
3895 /* Various values derived from 'shift': */
3896 PNG_CONST unsigned int num = 1U << (8U - shift);
3897 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
3898 /* CSE the division and work round wacky GCC warnings (see the comments
3899 * in png_gamma_8bit_correct for where these come from.)
3900 */
3901 PNG_CONST double fmax = 1./(((png_int_32)1 << (16U - shift))-1);
3902 #endif
3903 PNG_CONST unsigned int max = (1U << (16U - shift))-1U;
3904 PNG_CONST unsigned int max_by_2 = 1U << (15U-shift);
3905 unsigned int i;
3906
3907 png_uint_16pp table = *ptable =
3908 (png_uint_16pp)png_calloc(png_ptr, num * (sizeof (png_uint_16p)));
3909
3910 for (i = 0; i < num; i++)
3911 {
3912 png_uint_16p sub_table = table[i] =
3913 (png_uint_16p)png_malloc(png_ptr, 256 * (sizeof (png_uint_16)));
3914
3915 /* The 'threshold' test is repeated here because it can arise for one of
3916 * the 16-bit tables even if the others don't hit it.
3917 */
3918 if (png_gamma_significant(gamma_val) != 0)
3919 {
3920 /* The old code would overflow at the end and this would cause the
3921 * 'pow' function to return a result >1, resulting in an
3922 * arithmetic error. This code follows the spec exactly; ig is
3923 * the recovered input sample, it always has 8-16 bits.
3924 *
3925 * We want input * 65535/max, rounded, the arithmetic fits in 32
3926 * bits (unsigned) so long as max <= 32767.
3927 */
3928 unsigned int j;
3929 for (j = 0; j < 256; j++)
3930 {
3931 png_uint_32 ig = (j << (8-shift)) + i;
3932 # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
3933 /* Inline the 'max' scaling operation: */
3934 /* See png_gamma_8bit_correct for why the cast to (int) is
3935 * required here.
3936 */
3937 double d = floor(65535.*pow(ig*fmax, gamma_val*.00001)+.5);
3938 sub_table[j] = (png_uint_16)d;
3939 # else
3940 if (shift != 0)
3941 ig = (ig * 65535U + max_by_2)/max;
3942
3943 sub_table[j] = png_gamma_16bit_correct(ig, gamma_val);
3944 # endif
3945 }
3946 }
3947 else
3948 {
3949 /* We must still build a table, but do it the fast way. */
3950 unsigned int j;
3951
3952 for (j = 0; j < 256; j++)
3953 {
3954 png_uint_32 ig = (j << (8-shift)) + i;
3955
3956 if (shift != 0)
3957 ig = (ig * 65535U + max_by_2)/max;
3958
3959 sub_table[j] = (png_uint_16)ig;
3960 }
3961 }
3962 }
3963 }
3964
3965 /* NOTE: this function expects the *inverse* of the overall gamma transformation
3966 * required.
3967 */
3968 static void
3969 png_build_16to8_table(png_structrp png_ptr, png_uint_16pp *ptable,
3970 PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val)
3971 {
3972 PNG_CONST unsigned int num = 1U << (8U - shift);
3973 PNG_CONST unsigned int max = (1U << (16U - shift))-1U;
3974 unsigned int i;
3975 png_uint_32 last;
3976
3977 png_uint_16pp table = *ptable =
3978 (png_uint_16pp)png_calloc(png_ptr, num * (sizeof (png_uint_16p)));
3979
3980 /* 'num' is the number of tables and also the number of low bits of low
3981 * bits of the input 16-bit value used to select a table. Each table is
3982 * itself indexed by the high 8 bits of the value.
3983 */
3984 for (i = 0; i < num; i++)
3985 table[i] = (png_uint_16p)png_malloc(png_ptr,
3986 256 * (sizeof (png_uint_16)));
3987
3988 /* 'gamma_val' is set to the reciprocal of the value calculated above, so
3989 * pow(out,g) is an *input* value. 'last' is the last input value set.
3990 *
3991 * In the loop 'i' is used to find output values. Since the output is
3992 * 8-bit there are only 256 possible values. The tables are set up to
3993 * select the closest possible output value for each input by finding
3994 * the input value at the boundary between each pair of output values
3995 * and filling the table up to that boundary with the lower output
3996 * value.
3997 *
3998 * The boundary values are 0.5,1.5..253.5,254.5. Since these are 9-bit
3999 * values the code below uses a 16-bit value in i; the values start at
4000 * 128.5 (for 0.5) and step by 257, for a total of 254 values (the last
4001 * entries are filled with 255). Start i at 128 and fill all 'last'
4002 * table entries <= 'max'
4003 */
4004 last = 0;
4005 for (i = 0; i < 255; ++i) /* 8-bit output value */
4006 {
4007 /* Find the corresponding maximum input value */
4008 png_uint_16 out = (png_uint_16)(i * 257U); /* 16-bit output value */
4009
4010 /* Find the boundary value in 16 bits: */
4011 png_uint_32 bound = png_gamma_16bit_correct(out+128U, gamma_val);
4012
4013 /* Adjust (round) to (16-shift) bits: */
4014 bound = (bound * max + 32768U)/65535U + 1U;
4015
4016 while (last < bound)
4017 {
4018 table[last & (0xffU >> shift)][last >> (8U - shift)] = out;
4019 last++;
4020 }
4021 }
4022
4023 /* And fill in the final entries. */
4024 while (last < (num << 8))
4025 {
4026 table[last & (0xff >> shift)][last >> (8U - shift)] = 65535U;
4027 last++;
4028 }
4029 }
4030 #endif /* 16BIT */
4031
4032 /* Build a single 8-bit table: same as the 16-bit case but much simpler (and
4033 * typically much faster). Note that libpng currently does no sBIT processing
4034 * (apparently contrary to the spec) so a 256-entry table is always generated.
4035 */
4036 static void
4037 png_build_8bit_table(png_structrp png_ptr, png_bytepp ptable,
4038 PNG_CONST png_fixed_point gamma_val)
4039 {
4040 unsigned int i;
4041 png_bytep table = *ptable = (png_bytep)png_malloc(png_ptr, 256);
4042
4043 if (png_gamma_significant(gamma_val) != 0)
4044 for (i=0; i<256; i++)
4045 table[i] = png_gamma_8bit_correct(i, gamma_val);
4046
4047 else
4048 for (i=0; i<256; ++i)
4049 table[i] = (png_byte)(i & 0xff);
4050 }
4051
4052 /* Used from png_read_destroy and below to release the memory used by the gamma
4053 * tables.
4054 */
4055 void /* PRIVATE */
4056 png_destroy_gamma_table(png_structrp png_ptr)
4057 {
4058 png_free(png_ptr, png_ptr->gamma_table);
4059 png_ptr->gamma_table = NULL;
4060
4061 #ifdef PNG_16BIT_SUPPORTED
4062 if (png_ptr->gamma_16_table != NULL)
4063 {
4064 int i;
4065 int istop = (1 << (8 - png_ptr->gamma_shift));
4066 for (i = 0; i < istop; i++)
4067 {
4068 png_free(png_ptr, png_ptr->gamma_16_table[i]);
4069 }
4070 png_free(png_ptr, png_ptr->gamma_16_table);
4071 png_ptr->gamma_16_table = NULL;
4072 }
4073 #endif /* 16BIT */
4074
4075 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
4076 defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
4077 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
4078 png_free(png_ptr, png_ptr->gamma_from_1);
4079 png_ptr->gamma_from_1 = NULL;
4080 png_free(png_ptr, png_ptr->gamma_to_1);
4081 png_ptr->gamma_to_1 = NULL;
4082
4083 #ifdef PNG_16BIT_SUPPORTED
4084 if (png_ptr->gamma_16_from_1 != NULL)
4085 {
4086 int i;
4087 int istop = (1 << (8 - png_ptr->gamma_shift));
4088 for (i = 0; i < istop; i++)
4089 {
4090 png_free(png_ptr, png_ptr->gamma_16_from_1[i]);
4091 }
4092 png_free(png_ptr, png_ptr->gamma_16_from_1);
4093 png_ptr->gamma_16_from_1 = NULL;
4094 }
4095 if (png_ptr->gamma_16_to_1 != NULL)
4096 {
4097 int i;
4098 int istop = (1 << (8 - png_ptr->gamma_shift));
4099 for (i = 0; i < istop; i++)
4100 {
4101 png_free(png_ptr, png_ptr->gamma_16_to_1[i]);
4102 }
4103 png_free(png_ptr, png_ptr->gamma_16_to_1);
4104 png_ptr->gamma_16_to_1 = NULL;
4105 }
4106 #endif /* 16BIT */
4107 #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
4108 }
4109
4110 /* We build the 8- or 16-bit gamma tables here. Note that for 16-bit
4111 * tables, we don't make a full table if we are reducing to 8-bit in
4112 * the future. Note also how the gamma_16 tables are segmented so that
4113 * we don't need to allocate > 64K chunks for a full 16-bit table.
4114 */
4115 void /* PRIVATE */
4116 png_build_gamma_table(png_structrp png_ptr, int bit_depth)
4117 {
4118 png_debug(1, "in png_build_gamma_table");
4119
4120 /* Remove any existing table; this copes with multiple calls to
4121 * png_read_update_info. The warning is because building the gamma tables
4122 * multiple times is a performance hit - it's harmless but the ability to call
4123 * png_read_update_info() multiple times is new in 1.5.6 so it seems sensible
4124 * to warn if the app introduces such a hit.
4125 */
4126 if (png_ptr->gamma_table != NULL || png_ptr->gamma_16_table != NULL)
4127 {
4128 png_warning(png_ptr, "gamma table being rebuilt");
4129 png_destroy_gamma_table(png_ptr);
4130 }
4131
4132 if (bit_depth <= 8)
4133 {
4134 png_build_8bit_table(png_ptr, &png_ptr->gamma_table,
4135 png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->colorspace.gamma,
4136 png_ptr->screen_gamma) : PNG_FP_1);
4137
4138 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
4139 defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
4140 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
4141 if ((png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) != 0)
4142 {
4143 png_build_8bit_table(png_ptr, &png_ptr->gamma_to_1,
4144 png_reciprocal(png_ptr->colorspace.gamma));
4145
4146 png_build_8bit_table(png_ptr, &png_ptr->gamma_from_1,
4147 png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) :
4148 png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */);
4149 }
4150 #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
4151 }
4152 #ifdef PNG_16BIT_SUPPORTED
4153 else
4154 {
4155 png_byte shift, sig_bit;
4156
4157 if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
4158 {
4159 sig_bit = png_ptr->sig_bit.red;
4160
4161 if (png_ptr->sig_bit.green > sig_bit)
4162 sig_bit = png_ptr->sig_bit.green;
4163
4164 if (png_ptr->sig_bit.blue > sig_bit)
4165 sig_bit = png_ptr->sig_bit.blue;
4166 }
4167 else
4168 sig_bit = png_ptr->sig_bit.gray;
4169
4170 /* 16-bit gamma code uses this equation:
4171 *
4172 * ov = table[(iv & 0xff) >> gamma_shift][iv >> 8]
4173 *
4174 * Where 'iv' is the input color value and 'ov' is the output value -
4175 * pow(iv, gamma).
4176 *
4177 * Thus the gamma table consists of up to 256 256-entry tables. The table
4178 * is selected by the (8-gamma_shift) most significant of the low 8 bits of
4179 * the color value then indexed by the upper 8 bits:
4180 *
4181 * table[low bits][high 8 bits]
4182 *
4183 * So the table 'n' corresponds to all those 'iv' of:
4184 *
4185 * <all high 8-bit values><n << gamma_shift>..<(n+1 << gamma_shift)-1>
4186 *
4187 */
4188 if (sig_bit > 0 && sig_bit < 16U)
4189 /* shift == insignificant bits */
4190 shift = (png_byte)((16U - sig_bit) & 0xff);
4191
4192 else
4193 shift = 0; /* keep all 16 bits */
4194
4195 if ((png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8)) != 0)
4196 {
4197 /* PNG_MAX_GAMMA_8 is the number of bits to keep - effectively
4198 * the significant bits in the *input* when the output will
4199 * eventually be 8 bits. By default it is 11.
4200 */
4201 if (shift < (16U - PNG_MAX_GAMMA_8))
4202 shift = (16U - PNG_MAX_GAMMA_8);
4203 }
4204
4205 if (shift > 8U)
4206 shift = 8U; /* Guarantees at least one table! */
4207
4208 png_ptr->gamma_shift = shift;
4209
4210 /* NOTE: prior to 1.5.4 this test used to include PNG_BACKGROUND (now
4211 * PNG_COMPOSE). This effectively smashed the background calculation for
4212 * 16-bit output because the 8-bit table assumes the result will be reduced
4213 * to 8 bits.
4214 */
4215 if ((png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8)) != 0)
4216 png_build_16to8_table(png_ptr, &png_ptr->gamma_16_table, shift,
4217 png_ptr->screen_gamma > 0 ? png_product2(png_ptr->colorspace.gamma,
4218 png_ptr->screen_gamma) : PNG_FP_1);
4219
4220 else
4221 png_build_16bit_table(png_ptr, &png_ptr->gamma_16_table, shift,
4222 png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->colorspace.gamma,
4223 png_ptr->screen_gamma) : PNG_FP_1);
4224
4225 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
4226 defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
4227 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
4228 if ((png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) != 0)
4229 {
4230 png_build_16bit_table(png_ptr, &png_ptr->gamma_16_to_1, shift,
4231 png_reciprocal(png_ptr->colorspace.gamma));
4232
4233 /* Notice that the '16 from 1' table should be full precision, however
4234 * the lookup on this table still uses gamma_shift, so it can't be.
4235 * TODO: fix this.
4236 */
4237 png_build_16bit_table(png_ptr, &png_ptr->gamma_16_from_1, shift,
4238 png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) :
4239 png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */);
4240 }
4241 #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
4242 }
4243 #endif /* 16BIT */
4244 }
4245 #endif /* READ_GAMMA */
4246
4247 /* HARDWARE OR SOFTWARE OPTION SUPPORT */
4248 #ifdef PNG_SET_OPTION_SUPPORTED
4249 int PNGAPI
4250 png_set_option(png_structrp png_ptr, int option, int onoff)
4251 {
4252 if (png_ptr != NULL && option >= 0 && option < PNG_OPTION_NEXT &&
4253 (option & 1) == 0)
4254 {
4255 int mask = 3 << option;
4256 int setting = (2 + (onoff != 0)) << option;
4257 int current = png_ptr->options;
4258
4259 png_ptr->options = (png_byte)(((current & ~mask) | setting) & 0xff);
4260
4261 return (current & mask) >> option;
4262 }
4263
4264 return PNG_OPTION_INVALID;
4265 }
4266 #endif
4267
4268 /* sRGB support */
4269 #if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
4270 defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
4271 /* sRGB conversion tables; these are machine generated with the code in
4272 * contrib/tools/makesRGB.c. The actual sRGB transfer curve defined in the
4273 * specification (see the article at http://en.wikipedia.org/wiki/SRGB)
4274 * is used, not the gamma=1/2.2 approximation use elsewhere in libpng.
4275 * The sRGB to linear table is exact (to the nearest 16-bit linear fraction).
4276 * The inverse (linear to sRGB) table has accuracies as follows:
4277 *
4278 * For all possible (255*65535+1) input values:
4279 *
4280 * error: -0.515566 - 0.625971, 79441 (0.475369%) of readings inexact
4281 *
4282 * For the input values corresponding to the 65536 16-bit values:
4283 *
4284 * error: -0.513727 - 0.607759, 308 (0.469978%) of readings inexact
4285 *
4286 * In all cases the inexact readings are only off by one.
4287 */
4288
4289 #ifdef PNG_SIMPLIFIED_READ_SUPPORTED
4290 /* The convert-to-sRGB table is only currently required for read. */
4291 const png_uint_16 png_sRGB_table[256] =
4292 {
4293 0,20,40,60,80,99,119,139,
4294 159,179,199,219,241,264,288,313,
4295 340,367,396,427,458,491,526,562,
4296 599,637,677,718,761,805,851,898,
4297 947,997,1048,1101,1156,1212,1270,1330,
4298 1391,1453,1517,1583,1651,1720,1790,1863,
4299 1937,2013,2090,2170,2250,2333,2418,2504,
4300 2592,2681,2773,2866,2961,3058,3157,3258,
4301 3360,3464,3570,3678,3788,3900,4014,4129,
4302 4247,4366,4488,4611,4736,4864,4993,5124,
4303 5257,5392,5530,5669,5810,5953,6099,6246,
4304 6395,6547,6700,6856,7014,7174,7335,7500,
4305 7666,7834,8004,8177,8352,8528,8708,8889,
4306 9072,9258,9445,9635,9828,10022,10219,10417,
4307 10619,10822,11028,11235,11446,11658,11873,12090,
4308 12309,12530,12754,12980,13209,13440,13673,13909,
4309 14146,14387,14629,14874,15122,15371,15623,15878,
4310 16135,16394,16656,16920,17187,17456,17727,18001,
4311 18277,18556,18837,19121,19407,19696,19987,20281,
4312 20577,20876,21177,21481,21787,22096,22407,22721,
4313 23038,23357,23678,24002,24329,24658,24990,25325,
4314 25662,26001,26344,26688,27036,27386,27739,28094,
4315 28452,28813,29176,29542,29911,30282,30656,31033,
4316 31412,31794,32179,32567,32957,33350,33745,34143,
4317 34544,34948,35355,35764,36176,36591,37008,37429,
4318 37852,38278,38706,39138,39572,40009,40449,40891,
4319 41337,41785,42236,42690,43147,43606,44069,44534,
4320 45002,45473,45947,46423,46903,47385,47871,48359,
4321 48850,49344,49841,50341,50844,51349,51858,52369,
4322 52884,53401,53921,54445,54971,55500,56032,56567,
4323 57105,57646,58190,58737,59287,59840,60396,60955,
4324 61517,62082,62650,63221,63795,64372,64952,65535
4325 };
4326 #endif /* SIMPLIFIED_READ */
4327
4328 /* The base/delta tables are required for both read and write (but currently
4329 * only the simplified versions.)
4330 */
4331 const png_uint_16 png_sRGB_base[512] =
4332 {
4333 128,1782,3383,4644,5675,6564,7357,8074,
4334 8732,9346,9921,10463,10977,11466,11935,12384,
4335 12816,13233,13634,14024,14402,14769,15125,15473,
4336 15812,16142,16466,16781,17090,17393,17690,17981,
4337 18266,18546,18822,19093,19359,19621,19879,20133,
4338 20383,20630,20873,21113,21349,21583,21813,22041,
4339 22265,22487,22707,22923,23138,23350,23559,23767,
4340 23972,24175,24376,24575,24772,24967,25160,25352,
4341 25542,25730,25916,26101,26284,26465,26645,26823,
4342 27000,27176,27350,27523,27695,27865,28034,28201,
4343 28368,28533,28697,28860,29021,29182,29341,29500,
4344 29657,29813,29969,30123,30276,30429,30580,30730,
4345 30880,31028,31176,31323,31469,31614,31758,31902,
4346 32045,32186,32327,32468,32607,32746,32884,33021,
4347 33158,33294,33429,33564,33697,33831,33963,34095,
4348 34226,34357,34486,34616,34744,34873,35000,35127,
4349 35253,35379,35504,35629,35753,35876,35999,36122,
4350 36244,36365,36486,36606,36726,36845,36964,37083,
4351 37201,37318,37435,37551,37668,37783,37898,38013,
4352 38127,38241,38354,38467,38580,38692,38803,38915,
4353 39026,39136,39246,39356,39465,39574,39682,39790,
4354 39898,40005,40112,40219,40325,40431,40537,40642,
4355 40747,40851,40955,41059,41163,41266,41369,41471,
4356 41573,41675,41777,41878,41979,42079,42179,42279,
4357 42379,42478,42577,42676,42775,42873,42971,43068,
4358 43165,43262,43359,43456,43552,43648,43743,43839,
4359 43934,44028,44123,44217,44311,44405,44499,44592,
4360 44685,44778,44870,44962,45054,45146,45238,45329,
4361 45420,45511,45601,45692,45782,45872,45961,46051,
4362 46140,46229,46318,46406,46494,46583,46670,46758,
4363 46846,46933,47020,47107,47193,47280,47366,47452,
4364 47538,47623,47709,47794,47879,47964,48048,48133,
4365 48217,48301,48385,48468,48552,48635,48718,48801,
4366 48884,48966,49048,49131,49213,49294,49376,49458,
4367 49539,49620,49701,49782,49862,49943,50023,50103,
4368 50183,50263,50342,50422,50501,50580,50659,50738,
4369 50816,50895,50973,51051,51129,51207,51285,51362,
4370 51439,51517,51594,51671,51747,51824,51900,51977,
4371 52053,52129,52205,52280,52356,52432,52507,52582,
4372 52657,52732,52807,52881,52956,53030,53104,53178,
4373 53252,53326,53400,53473,53546,53620,53693,53766,
4374 53839,53911,53984,54056,54129,54201,54273,54345,
4375 54417,54489,54560,54632,54703,54774,54845,54916,
4376 54987,55058,55129,55199,55269,55340,55410,55480,
4377 55550,55620,55689,55759,55828,55898,55967,56036,
4378 56105,56174,56243,56311,56380,56448,56517,56585,
4379 56653,56721,56789,56857,56924,56992,57059,57127,
4380 57194,57261,57328,57395,57462,57529,57595,57662,
4381 57728,57795,57861,57927,57993,58059,58125,58191,
4382 58256,58322,58387,58453,58518,58583,58648,58713,
4383 58778,58843,58908,58972,59037,59101,59165,59230,
4384 59294,59358,59422,59486,59549,59613,59677,59740,
4385 59804,59867,59930,59993,60056,60119,60182,60245,
4386 60308,60370,60433,60495,60558,60620,60682,60744,
4387 60806,60868,60930,60992,61054,61115,61177,61238,
4388 61300,61361,61422,61483,61544,61605,61666,61727,
4389 61788,61848,61909,61969,62030,62090,62150,62211,
4390 62271,62331,62391,62450,62510,62570,62630,62689,
4391 62749,62808,62867,62927,62986,63045,63104,63163,
4392 63222,63281,63340,63398,63457,63515,63574,63632,
4393 63691,63749,63807,63865,63923,63981,64039,64097,
4394 64155,64212,64270,64328,64385,64443,64500,64557,
4395 64614,64672,64729,64786,64843,64900,64956,65013,
4396 65070,65126,65183,65239,65296,65352,65409,65465
4397 };
4398
4399 const png_byte png_sRGB_delta[512] =
4400 {
4401 207,201,158,129,113,100,90,82,77,72,68,64,61,59,56,54,
4402 52,50,49,47,46,45,43,42,41,40,39,39,38,37,36,36,
4403 35,34,34,33,33,32,32,31,31,30,30,30,29,29,28,28,
4404 28,27,27,27,27,26,26,26,25,25,25,25,24,24,24,24,
4405 23,23,23,23,23,22,22,22,22,22,22,21,21,21,21,21,
4406 21,20,20,20,20,20,20,20,20,19,19,19,19,19,19,19,
4407 19,18,18,18,18,18,18,18,18,18,18,17,17,17,17,17,
4408 17,17,17,17,17,17,16,16,16,16,16,16,16,16,16,16,
4409 16,16,16,16,15,15,15,15,15,15,15,15,15,15,15,15,
4410 15,15,15,15,14,14,14,14,14,14,14,14,14,14,14,14,
4411 14,14,14,14,14,14,14,13,13,13,13,13,13,13,13,13,
4412 13,13,13,13,13,13,13,13,13,13,13,13,13,13,12,12,
4413 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
4414 12,12,12,12,12,12,12,12,12,12,12,12,11,11,11,11,
4415 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
4416 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
4417 11,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
4418 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
4419 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
4420 10,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
4421 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
4422 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
4423 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
4424 9,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
4425 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
4426 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
4427 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
4428 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
4429 8,8,8,8,8,8,8,8,8,7,7,7,7,7,7,7,
4430 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
4431 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
4432 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
4433 };
4434 #endif /* SIMPLIFIED READ/WRITE sRGB support */
4435
4436 /* SIMPLIFIED READ/WRITE SUPPORT */
4437 #if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
4438 defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
4439 static int
4440 png_image_free_function(png_voidp argument)
4441 {
4442 png_imagep image = png_voidcast(png_imagep, argument);
4443 png_controlp cp = image->opaque;
4444 png_control c;
4445
4446 /* Double check that we have a png_ptr - it should be impossible to get here
4447 * without one.
4448 */
4449 if (cp->png_ptr == NULL)
4450 return 0;
4451
4452 /* First free any data held in the control structure. */
4453 # ifdef PNG_STDIO_SUPPORTED
4454 if (cp->owned_file != 0)
4455 {
4456 FILE *fp = png_voidcast(FILE*, cp->png_ptr->io_ptr);
4457 cp->owned_file = 0;
4458
4459 /* Ignore errors here. */
4460 if (fp != NULL)
4461 {
4462 cp->png_ptr->io_ptr = NULL;
4463 (void)fclose(fp);
4464 }
4465 }
4466 # endif
4467
4468 /* Copy the control structure so that the original, allocated, version can be
4469 * safely freed. Notice that a png_error here stops the remainder of the
4470 * cleanup, but this is probably fine because that would indicate bad memory
4471 * problems anyway.
4472 */
4473 c = *cp;
4474 image->opaque = &c;
4475 png_free(c.png_ptr, cp);
4476
4477 /* Then the structures, calling the correct API. */
4478 if (c.for_write != 0)
4479 {
4480 # ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
4481 png_destroy_write_struct(&c.png_ptr, &c.info_ptr);
4482 # else
4483 png_error(c.png_ptr, "simplified write not supported");
4484 # endif
4485 }
4486 else
4487 {
4488 # ifdef PNG_SIMPLIFIED_READ_SUPPORTED
4489 png_destroy_read_struct(&c.png_ptr, &c.info_ptr, NULL);
4490 # else
4491 png_error(c.png_ptr, "simplified read not supported");
4492 # endif
4493 }
4494
4495 /* Success. */
4496 return 1;
4497 }
4498
4499 void PNGAPI
4500 png_image_free(png_imagep image)
4501 {
4502 /* Safely call the real function, but only if doing so is safe at this point
4503 * (if not inside an error handling context). Otherwise assume
4504 * png_safe_execute will call this API after the return.
4505 */
4506 if (image != NULL && image->opaque != NULL &&
4507 image->opaque->error_buf == NULL)
4508 {
4509 /* Ignore errors here: */
4510 (void)png_safe_execute(image, png_image_free_function, image);
4511 image->opaque = NULL;
4512 }
4513 }
4514
4515 int /* PRIVATE */
4516 png_image_error(png_imagep image, png_const_charp error_message)
4517 {
4518 /* Utility to log an error. */
4519 png_safecat(image->message, (sizeof image->message), 0, error_message);
4520 image->warning_or_error |= PNG_IMAGE_ERROR;
4521 png_image_free(image);
4522 return 0;
4523 }
4524
4525 #endif /* SIMPLIFIED READ/WRITE */
4526 #endif /* READ || WRITE */