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