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