OLD | NEW |
1 | 1 |
2 /* pngget.c - retrieval of values from info struct | 2 /* pngget.c - retrieval of values from info struct |
3 * | 3 * |
4 * Last changed in libpng 1.2.53 [February 26, 2015] | 4 * Last changed in libpng 1.6.17 [March 26, 2015] |
5 * Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson | 5 * Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson |
6 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) | 6 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
7 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) | 7 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
8 * | 8 * |
9 * This code is released under the libpng license. | 9 * This code is released under the libpng license. |
10 * For conditions of distribution and use, see the disclaimer | 10 * For conditions of distribution and use, see the disclaimer |
11 * and license in png.h | 11 * and license in png.h |
12 * | 12 * |
13 */ | 13 */ |
14 | 14 |
15 #define PNG_INTERNAL | 15 #include "pngpriv.h" |
16 #define PNG_NO_PEDANTIC_WARNINGS | 16 |
17 #include "png.h" | |
18 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) | 17 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) |
19 | 18 |
20 png_uint_32 PNGAPI | 19 png_uint_32 PNGAPI |
21 png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag) | 20 png_get_valid(png_const_structrp png_ptr, png_const_inforp info_ptr, |
| 21 png_uint_32 flag) |
22 { | 22 { |
23 if (png_ptr != NULL && info_ptr != NULL) | 23 if (png_ptr != NULL && info_ptr != NULL) |
24 return(info_ptr->valid & flag); | 24 return(info_ptr->valid & flag); |
25 | 25 |
26 else | 26 return(0); |
27 return(0); | |
28 } | 27 } |
29 | 28 |
30 png_uint_32 PNGAPI | 29 png_size_t PNGAPI |
31 png_get_rowbytes(png_structp png_ptr, png_infop info_ptr) | 30 png_get_rowbytes(png_const_structrp png_ptr, png_const_inforp info_ptr) |
32 { | 31 { |
33 if (png_ptr != NULL && info_ptr != NULL) | 32 if (png_ptr != NULL && info_ptr != NULL) |
34 return(info_ptr->rowbytes); | 33 return(info_ptr->rowbytes); |
35 | 34 |
36 else | 35 return(0); |
37 return(0); | |
38 } | 36 } |
39 | 37 |
40 #ifdef PNG_INFO_IMAGE_SUPPORTED | 38 #ifdef PNG_INFO_IMAGE_SUPPORTED |
41 png_bytepp PNGAPI | 39 png_bytepp PNGAPI |
42 png_get_rows(png_structp png_ptr, png_infop info_ptr) | 40 png_get_rows(png_const_structrp png_ptr, png_const_inforp info_ptr) |
43 { | 41 { |
44 if (png_ptr != NULL && info_ptr != NULL) | 42 if (png_ptr != NULL && info_ptr != NULL) |
45 return(info_ptr->row_pointers); | 43 return(info_ptr->row_pointers); |
46 | 44 |
47 else | 45 return(0); |
48 return(0); | |
49 } | 46 } |
50 #endif | 47 #endif |
51 | 48 |
52 #ifdef PNG_EASY_ACCESS_SUPPORTED | 49 #ifdef PNG_EASY_ACCESS_SUPPORTED |
53 /* Easy access to info, added in libpng-0.99 */ | 50 /* Easy access to info, added in libpng-0.99 */ |
54 png_uint_32 PNGAPI | 51 png_uint_32 PNGAPI |
55 png_get_image_width(png_structp png_ptr, png_infop info_ptr) | 52 png_get_image_width(png_const_structrp png_ptr, png_const_inforp info_ptr) |
56 { | 53 { |
57 if (png_ptr != NULL && info_ptr != NULL) | 54 if (png_ptr != NULL && info_ptr != NULL) |
58 return info_ptr->width; | 55 return info_ptr->width; |
59 | 56 |
60 return (0); | 57 return (0); |
61 } | 58 } |
62 | 59 |
63 png_uint_32 PNGAPI | 60 png_uint_32 PNGAPI |
64 png_get_image_height(png_structp png_ptr, png_infop info_ptr) | 61 png_get_image_height(png_const_structrp png_ptr, png_const_inforp info_ptr) |
65 { | 62 { |
66 if (png_ptr != NULL && info_ptr != NULL) | 63 if (png_ptr != NULL && info_ptr != NULL) |
67 return info_ptr->height; | 64 return info_ptr->height; |
68 | 65 |
69 return (0); | 66 return (0); |
70 } | 67 } |
71 | 68 |
72 png_byte PNGAPI | 69 png_byte PNGAPI |
73 png_get_bit_depth(png_structp png_ptr, png_infop info_ptr) | 70 png_get_bit_depth(png_const_structrp png_ptr, png_const_inforp info_ptr) |
74 { | 71 { |
75 if (png_ptr != NULL && info_ptr != NULL) | 72 if (png_ptr != NULL && info_ptr != NULL) |
76 return info_ptr->bit_depth; | 73 return info_ptr->bit_depth; |
77 | 74 |
78 return (0); | 75 return (0); |
79 } | 76 } |
80 | 77 |
81 png_byte PNGAPI | 78 png_byte PNGAPI |
82 png_get_color_type(png_structp png_ptr, png_infop info_ptr) | 79 png_get_color_type(png_const_structrp png_ptr, png_const_inforp info_ptr) |
83 { | 80 { |
84 if (png_ptr != NULL && info_ptr != NULL) | 81 if (png_ptr != NULL && info_ptr != NULL) |
85 return info_ptr->color_type; | 82 return info_ptr->color_type; |
86 | 83 |
87 return (0); | 84 return (0); |
88 } | 85 } |
89 | 86 |
90 png_byte PNGAPI | 87 png_byte PNGAPI |
91 png_get_filter_type(png_structp png_ptr, png_infop info_ptr) | 88 png_get_filter_type(png_const_structrp png_ptr, png_const_inforp info_ptr) |
92 { | 89 { |
93 if (png_ptr != NULL && info_ptr != NULL) | 90 if (png_ptr != NULL && info_ptr != NULL) |
94 return info_ptr->filter_type; | 91 return info_ptr->filter_type; |
95 | 92 |
96 return (0); | 93 return (0); |
97 } | 94 } |
98 | 95 |
99 png_byte PNGAPI | 96 png_byte PNGAPI |
100 png_get_interlace_type(png_structp png_ptr, png_infop info_ptr) | 97 png_get_interlace_type(png_const_structrp png_ptr, png_const_inforp info_ptr) |
101 { | 98 { |
102 if (png_ptr != NULL && info_ptr != NULL) | 99 if (png_ptr != NULL && info_ptr != NULL) |
103 return info_ptr->interlace_type; | 100 return info_ptr->interlace_type; |
104 | 101 |
105 return (0); | 102 return (0); |
106 } | 103 } |
107 | 104 |
108 png_byte PNGAPI | 105 png_byte PNGAPI |
109 png_get_compression_type(png_structp png_ptr, png_infop info_ptr) | 106 png_get_compression_type(png_const_structrp png_ptr, png_const_inforp info_ptr) |
110 { | 107 { |
111 if (png_ptr != NULL && info_ptr != NULL) | 108 if (png_ptr != NULL && info_ptr != NULL) |
112 return info_ptr->compression_type; | 109 return info_ptr->compression_type; |
113 | 110 |
114 return (0); | 111 return (0); |
115 } | 112 } |
116 | 113 |
117 png_uint_32 PNGAPI | 114 png_uint_32 PNGAPI |
118 png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr) | 115 png_get_x_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp |
119 { | 116 info_ptr) |
120 if (png_ptr != NULL && info_ptr != NULL) | 117 { |
121 #ifdef PNG_pHYs_SUPPORTED | 118 #ifdef PNG_pHYs_SUPPORTED |
122 if (info_ptr->valid & PNG_INFO_pHYs) | 119 if (png_ptr != NULL && info_ptr != NULL && |
123 { | 120 (info_ptr->valid & PNG_INFO_pHYs) != 0) |
124 png_debug1(1, "in %s retrieval function", "png_get_x_pixels_per_meter"); | 121 { |
125 | 122 png_debug1(1, "in %s retrieval function", |
126 if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER) | 123 "png_get_x_pixels_per_meter"); |
127 return (0); | 124 |
128 | 125 if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER) |
129 else | 126 return (info_ptr->x_pixels_per_unit); |
130 return (info_ptr->x_pixels_per_unit); | 127 } |
131 } | 128 #else |
132 #else | 129 PNG_UNUSED(png_ptr) |
133 return (0); | 130 PNG_UNUSED(info_ptr) |
134 #endif | 131 #endif |
135 return (0); | 132 |
136 } | 133 return (0); |
137 | 134 } |
138 png_uint_32 PNGAPI | 135 |
139 png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr) | 136 png_uint_32 PNGAPI |
140 { | 137 png_get_y_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp |
141 if (png_ptr != NULL && info_ptr != NULL) | 138 info_ptr) |
| 139 { |
142 #ifdef PNG_pHYs_SUPPORTED | 140 #ifdef PNG_pHYs_SUPPORTED |
143 if (info_ptr->valid & PNG_INFO_pHYs) | 141 if (png_ptr != NULL && info_ptr != NULL && |
144 { | 142 (info_ptr->valid & PNG_INFO_pHYs) != 0) |
145 png_debug1(1, "in %s retrieval function", "png_get_y_pixels_per_meter"); | 143 { |
146 | 144 png_debug1(1, "in %s retrieval function", |
147 if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER) | 145 "png_get_y_pixels_per_meter"); |
148 return (0); | 146 |
149 | 147 if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER) |
150 else | 148 return (info_ptr->y_pixels_per_unit); |
151 return (info_ptr->y_pixels_per_unit); | 149 } |
152 } | 150 #else |
153 #else | 151 PNG_UNUSED(png_ptr) |
154 return (0); | 152 PNG_UNUSED(info_ptr) |
155 #endif | 153 #endif |
156 return (0); | 154 |
157 } | 155 return (0); |
158 | 156 } |
159 png_uint_32 PNGAPI | 157 |
160 png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr) | 158 png_uint_32 PNGAPI |
161 { | 159 png_get_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp info_ptr) |
162 if (png_ptr != NULL && info_ptr != NULL) | 160 { |
163 #ifdef PNG_pHYs_SUPPORTED | 161 #ifdef PNG_pHYs_SUPPORTED |
164 if (info_ptr->valid & PNG_INFO_pHYs) | 162 if (png_ptr != NULL && info_ptr != NULL && |
| 163 (info_ptr->valid & PNG_INFO_pHYs) != 0) |
165 { | 164 { |
166 png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter"); | 165 png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter"); |
167 | 166 |
168 if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER || | 167 if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER && |
169 info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit) | 168 info_ptr->x_pixels_per_unit == info_ptr->y_pixels_per_unit) |
170 return (0); | 169 return (info_ptr->x_pixels_per_unit); |
171 | 170 } |
172 else | 171 #else |
173 return (info_ptr->x_pixels_per_unit); | 172 PNG_UNUSED(png_ptr) |
174 } | 173 PNG_UNUSED(info_ptr) |
175 #else | 174 #endif |
176 return (0); | 175 |
177 #endif | |
178 return (0); | 176 return (0); |
179 } | 177 } |
180 | 178 |
181 #ifdef PNG_FLOATING_POINT_SUPPORTED | 179 #ifdef PNG_FLOATING_POINT_SUPPORTED |
182 float PNGAPI | 180 float PNGAPI |
183 png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr) | 181 png_get_pixel_aspect_ratio(png_const_structrp png_ptr, png_const_inforp |
184 { | 182 info_ptr) |
185 if (png_ptr != NULL && info_ptr != NULL) | 183 { |
| 184 #ifdef PNG_READ_pHYs_SUPPORTED |
| 185 if (png_ptr != NULL && info_ptr != NULL && |
| 186 (info_ptr->valid & PNG_INFO_pHYs) != 0) |
| 187 { |
| 188 png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio"); |
| 189 |
| 190 if (info_ptr->x_pixels_per_unit != 0) |
| 191 return ((float)((float)info_ptr->y_pixels_per_unit |
| 192 /(float)info_ptr->x_pixels_per_unit)); |
| 193 } |
| 194 #else |
| 195 PNG_UNUSED(png_ptr) |
| 196 PNG_UNUSED(info_ptr) |
| 197 #endif |
| 198 |
| 199 return ((float)0.0); |
| 200 } |
| 201 #endif |
| 202 |
| 203 #ifdef PNG_FIXED_POINT_SUPPORTED |
| 204 png_fixed_point PNGAPI |
| 205 png_get_pixel_aspect_ratio_fixed(png_const_structrp png_ptr, |
| 206 png_const_inforp info_ptr) |
| 207 { |
| 208 #ifdef PNG_READ_pHYs_SUPPORTED |
| 209 if (png_ptr != NULL && info_ptr != NULL && |
| 210 (info_ptr->valid & PNG_INFO_pHYs) != 0 && |
| 211 info_ptr->x_pixels_per_unit > 0 && info_ptr->y_pixels_per_unit > 0 && |
| 212 info_ptr->x_pixels_per_unit <= PNG_UINT_31_MAX && |
| 213 info_ptr->y_pixels_per_unit <= PNG_UINT_31_MAX) |
| 214 { |
| 215 png_fixed_point res; |
| 216 |
| 217 png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio_fixed"); |
| 218 |
| 219 /* The following casts work because a PNG 4 byte integer only has a valid |
| 220 * range of 0..2^31-1; otherwise the cast might overflow. |
| 221 */ |
| 222 if (png_muldiv(&res, (png_int_32)info_ptr->y_pixels_per_unit, PNG_FP_1, |
| 223 (png_int_32)info_ptr->x_pixels_per_unit) != 0) |
| 224 return res; |
| 225 } |
| 226 #else |
| 227 PNG_UNUSED(png_ptr) |
| 228 PNG_UNUSED(info_ptr) |
| 229 #endif |
| 230 |
| 231 return 0; |
| 232 } |
| 233 #endif |
| 234 |
| 235 png_int_32 PNGAPI |
| 236 png_get_x_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr) |
| 237 { |
| 238 #ifdef PNG_oFFs_SUPPORTED |
| 239 if (png_ptr != NULL && info_ptr != NULL && |
| 240 (info_ptr->valid & PNG_INFO_oFFs) != 0) |
| 241 { |
| 242 png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns"); |
| 243 |
| 244 if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER) |
| 245 return (info_ptr->x_offset); |
| 246 } |
| 247 #else |
| 248 PNG_UNUSED(png_ptr) |
| 249 PNG_UNUSED(info_ptr) |
| 250 #endif |
| 251 |
| 252 return (0); |
| 253 } |
| 254 |
| 255 png_int_32 PNGAPI |
| 256 png_get_y_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr) |
| 257 { |
| 258 #ifdef PNG_oFFs_SUPPORTED |
| 259 if (png_ptr != NULL && info_ptr != NULL && |
| 260 (info_ptr->valid & PNG_INFO_oFFs) != 0) |
| 261 { |
| 262 png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns"); |
| 263 |
| 264 if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER) |
| 265 return (info_ptr->y_offset); |
| 266 } |
| 267 #else |
| 268 PNG_UNUSED(png_ptr) |
| 269 PNG_UNUSED(info_ptr) |
| 270 #endif |
| 271 |
| 272 return (0); |
| 273 } |
| 274 |
| 275 png_int_32 PNGAPI |
| 276 png_get_x_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr) |
| 277 { |
| 278 #ifdef PNG_oFFs_SUPPORTED |
| 279 if (png_ptr != NULL && info_ptr != NULL && |
| 280 (info_ptr->valid & PNG_INFO_oFFs) != 0) |
| 281 { |
| 282 png_debug1(1, "in %s retrieval function", "png_get_x_offset_pixels"); |
| 283 |
| 284 if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL) |
| 285 return (info_ptr->x_offset); |
| 286 } |
| 287 #else |
| 288 PNG_UNUSED(png_ptr) |
| 289 PNG_UNUSED(info_ptr) |
| 290 #endif |
| 291 |
| 292 return (0); |
| 293 } |
| 294 |
| 295 png_int_32 PNGAPI |
| 296 png_get_y_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr) |
| 297 { |
| 298 #ifdef PNG_oFFs_SUPPORTED |
| 299 if (png_ptr != NULL && info_ptr != NULL && |
| 300 (info_ptr->valid & PNG_INFO_oFFs) != 0) |
| 301 { |
| 302 png_debug1(1, "in %s retrieval function", "png_get_y_offset_pixels"); |
| 303 |
| 304 if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL) |
| 305 return (info_ptr->y_offset); |
| 306 } |
| 307 #else |
| 308 PNG_UNUSED(png_ptr) |
| 309 PNG_UNUSED(info_ptr) |
| 310 #endif |
| 311 |
| 312 return (0); |
| 313 } |
| 314 |
| 315 #ifdef PNG_INCH_CONVERSIONS_SUPPORTED |
| 316 static png_uint_32 |
| 317 ppi_from_ppm(png_uint_32 ppm) |
| 318 { |
| 319 #if 0 |
| 320 /* The conversion is *(2.54/100), in binary (32 digits): |
| 321 * .00000110100000001001110101001001 |
| 322 */ |
| 323 png_uint_32 t1001, t1101; |
| 324 ppm >>= 1; /* .1 */ |
| 325 t1001 = ppm + (ppm >> 3); /* .1001 */ |
| 326 t1101 = t1001 + (ppm >> 1); /* .1101 */ |
| 327 ppm >>= 20; /* .000000000000000000001 */ |
| 328 t1101 += t1101 >> 15; /* .1101000000000001101 */ |
| 329 t1001 >>= 11; /* .000000000001001 */ |
| 330 t1001 += t1001 >> 12; /* .000000000001001000000001001 */ |
| 331 ppm += t1001; /* .000000000001001000001001001 */ |
| 332 ppm += t1101; /* .110100000001001110101001001 */ |
| 333 return (ppm + 16) >> 5;/* .00000110100000001001110101001001 */ |
| 334 #else |
| 335 /* The argument is a PNG unsigned integer, so it is not permitted |
| 336 * to be bigger than 2^31. |
| 337 */ |
| 338 png_fixed_point result; |
| 339 if (ppm <= PNG_UINT_31_MAX && png_muldiv(&result, (png_int_32)ppm, 127, |
| 340 5000) != 0) |
| 341 return result; |
| 342 |
| 343 /* Overflow. */ |
| 344 return 0; |
| 345 #endif |
| 346 } |
| 347 |
| 348 png_uint_32 PNGAPI |
| 349 png_get_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr) |
| 350 { |
| 351 return ppi_from_ppm(png_get_pixels_per_meter(png_ptr, info_ptr)); |
| 352 } |
| 353 |
| 354 png_uint_32 PNGAPI |
| 355 png_get_x_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr) |
| 356 { |
| 357 return ppi_from_ppm(png_get_x_pixels_per_meter(png_ptr, info_ptr)); |
| 358 } |
| 359 |
| 360 png_uint_32 PNGAPI |
| 361 png_get_y_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr) |
| 362 { |
| 363 return ppi_from_ppm(png_get_y_pixels_per_meter(png_ptr, info_ptr)); |
| 364 } |
| 365 |
| 366 #ifdef PNG_FIXED_POINT_SUPPORTED |
| 367 static png_fixed_point |
| 368 png_fixed_inches_from_microns(png_const_structrp png_ptr, png_int_32 microns) |
| 369 { |
| 370 /* Convert from metres * 1,000,000 to inches * 100,000, meters to |
| 371 * inches is simply *(100/2.54), so we want *(10/2.54) == 500/127. |
| 372 * Notice that this can overflow - a warning is output and 0 is |
| 373 * returned. |
| 374 */ |
| 375 return png_muldiv_warn(png_ptr, microns, 500, 127); |
| 376 } |
| 377 |
| 378 png_fixed_point PNGAPI |
| 379 png_get_x_offset_inches_fixed(png_const_structrp png_ptr, |
| 380 png_const_inforp info_ptr) |
| 381 { |
| 382 return png_fixed_inches_from_microns(png_ptr, |
| 383 png_get_x_offset_microns(png_ptr, info_ptr)); |
| 384 } |
| 385 #endif |
| 386 |
| 387 #ifdef PNG_FIXED_POINT_SUPPORTED |
| 388 png_fixed_point PNGAPI |
| 389 png_get_y_offset_inches_fixed(png_const_structrp png_ptr, |
| 390 png_const_inforp info_ptr) |
| 391 { |
| 392 return png_fixed_inches_from_microns(png_ptr, |
| 393 png_get_y_offset_microns(png_ptr, info_ptr)); |
| 394 } |
| 395 #endif |
| 396 |
| 397 #ifdef PNG_FLOATING_POINT_SUPPORTED |
| 398 float PNGAPI |
| 399 png_get_x_offset_inches(png_const_structrp png_ptr, png_const_inforp info_ptr) |
| 400 { |
| 401 /* To avoid the overflow do the conversion directly in floating |
| 402 * point. |
| 403 */ |
| 404 return (float)(png_get_x_offset_microns(png_ptr, info_ptr) * .00003937); |
| 405 } |
| 406 #endif |
| 407 |
| 408 #ifdef PNG_FLOATING_POINT_SUPPORTED |
| 409 float PNGAPI |
| 410 png_get_y_offset_inches(png_const_structrp png_ptr, png_const_inforp info_ptr) |
| 411 { |
| 412 /* To avoid the overflow do the conversion directly in floating |
| 413 * point. |
| 414 */ |
| 415 return (float)(png_get_y_offset_microns(png_ptr, info_ptr) * .00003937); |
| 416 } |
| 417 #endif |
| 418 |
186 #ifdef PNG_pHYs_SUPPORTED | 419 #ifdef PNG_pHYs_SUPPORTED |
187 | 420 png_uint_32 PNGAPI |
188 if (info_ptr->valid & PNG_INFO_pHYs) | 421 png_get_pHYs_dpi(png_const_structrp png_ptr, png_const_inforp info_ptr, |
189 { | 422 png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) |
190 png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio"); | |
191 | |
192 if (info_ptr->x_pixels_per_unit == 0) | |
193 return ((float)0.0); | |
194 | |
195 else | |
196 return ((float)((float)info_ptr->y_pixels_per_unit | |
197 /(float)info_ptr->x_pixels_per_unit)); | |
198 } | |
199 #else | |
200 return (0.0); | |
201 #endif | |
202 return ((float)0.0); | |
203 } | |
204 #endif | |
205 | |
206 png_int_32 PNGAPI | |
207 png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr) | |
208 { | |
209 if (png_ptr != NULL && info_ptr != NULL) | |
210 #ifdef PNG_oFFs_SUPPORTED | |
211 | |
212 if (info_ptr->valid & PNG_INFO_oFFs) | |
213 { | |
214 png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns"); | |
215 | |
216 if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER) | |
217 return (0); | |
218 | |
219 else | |
220 return (info_ptr->x_offset); | |
221 } | |
222 #else | |
223 return (0); | |
224 #endif | |
225 return (0); | |
226 } | |
227 | |
228 png_int_32 PNGAPI | |
229 png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr) | |
230 { | |
231 if (png_ptr != NULL && info_ptr != NULL) | |
232 | |
233 #ifdef PNG_oFFs_SUPPORTED | |
234 if (info_ptr->valid & PNG_INFO_oFFs) | |
235 { | |
236 png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns"); | |
237 | |
238 if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER) | |
239 return (0); | |
240 | |
241 else | |
242 return (info_ptr->y_offset); | |
243 } | |
244 #else | |
245 return (0); | |
246 #endif | |
247 return (0); | |
248 } | |
249 | |
250 png_int_32 PNGAPI | |
251 png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr) | |
252 { | |
253 if (png_ptr != NULL && info_ptr != NULL) | |
254 | |
255 #ifdef PNG_oFFs_SUPPORTED | |
256 if (info_ptr->valid & PNG_INFO_oFFs) | |
257 { | |
258 png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns"); | |
259 | |
260 if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL) | |
261 return (0); | |
262 | |
263 else | |
264 return (info_ptr->x_offset); | |
265 } | |
266 #else | |
267 return (0); | |
268 #endif | |
269 return (0); | |
270 } | |
271 | |
272 png_int_32 PNGAPI | |
273 png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr) | |
274 { | |
275 if (png_ptr != NULL && info_ptr != NULL) | |
276 | |
277 #ifdef PNG_oFFs_SUPPORTED | |
278 if (info_ptr->valid & PNG_INFO_oFFs) | |
279 { | |
280 png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns"); | |
281 | |
282 if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL) | |
283 return (0); | |
284 | |
285 else | |
286 return (info_ptr->y_offset); | |
287 } | |
288 #else | |
289 return (0); | |
290 #endif | |
291 return (0); | |
292 } | |
293 | |
294 #if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED) | |
295 png_uint_32 PNGAPI | |
296 png_get_pixels_per_inch(png_structp png_ptr, png_infop info_ptr) | |
297 { | |
298 return ((png_uint_32)((float)png_get_pixels_per_meter(png_ptr, info_ptr) | |
299 *.0254 +.5)); | |
300 } | |
301 | |
302 png_uint_32 PNGAPI | |
303 png_get_x_pixels_per_inch(png_structp png_ptr, png_infop info_ptr) | |
304 { | |
305 return ((png_uint_32)((float)png_get_x_pixels_per_meter(png_ptr, info_ptr) | |
306 *.0254 +.5)); | |
307 } | |
308 | |
309 png_uint_32 PNGAPI | |
310 png_get_y_pixels_per_inch(png_structp png_ptr, png_infop info_ptr) | |
311 { | |
312 return ((png_uint_32)((float)png_get_y_pixels_per_meter(png_ptr, info_ptr) | |
313 *.0254 +.5)); | |
314 } | |
315 | |
316 float PNGAPI | |
317 png_get_x_offset_inches(png_structp png_ptr, png_infop info_ptr) | |
318 { | |
319 return ((float)png_get_x_offset_microns(png_ptr, info_ptr) | |
320 *.00003937); | |
321 } | |
322 | |
323 float PNGAPI | |
324 png_get_y_offset_inches(png_structp png_ptr, png_infop info_ptr) | |
325 { | |
326 return ((float)png_get_y_offset_microns(png_ptr, info_ptr) | |
327 *.00003937); | |
328 } | |
329 | |
330 #ifdef PNG_pHYs_SUPPORTED | |
331 png_uint_32 PNGAPI | |
332 png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr, | |
333 png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) | |
334 { | 423 { |
335 png_uint_32 retval = 0; | 424 png_uint_32 retval = 0; |
336 | 425 |
337 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) | 426 if (png_ptr != NULL && info_ptr != NULL && |
| 427 (info_ptr->valid & PNG_INFO_pHYs) != 0) |
338 { | 428 { |
339 png_debug1(1, "in %s retrieval function", "pHYs"); | 429 png_debug1(1, "in %s retrieval function", "pHYs"); |
340 | 430 |
341 if (res_x != NULL) | 431 if (res_x != NULL) |
342 { | 432 { |
343 *res_x = info_ptr->x_pixels_per_unit; | 433 *res_x = info_ptr->x_pixels_per_unit; |
344 retval |= PNG_INFO_pHYs; | 434 retval |= PNG_INFO_pHYs; |
345 } | 435 } |
| 436 |
346 if (res_y != NULL) | 437 if (res_y != NULL) |
347 { | 438 { |
348 *res_y = info_ptr->y_pixels_per_unit; | 439 *res_y = info_ptr->y_pixels_per_unit; |
349 retval |= PNG_INFO_pHYs; | 440 retval |= PNG_INFO_pHYs; |
350 } | 441 } |
| 442 |
351 if (unit_type != NULL) | 443 if (unit_type != NULL) |
352 { | 444 { |
353 *unit_type = (int)info_ptr->phys_unit_type; | 445 *unit_type = (int)info_ptr->phys_unit_type; |
354 retval |= PNG_INFO_pHYs; | 446 retval |= PNG_INFO_pHYs; |
| 447 |
355 if (*unit_type == 1) | 448 if (*unit_type == 1) |
356 { | 449 { |
357 if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50); | 450 if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50); |
358 if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50); | 451 if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50); |
359 } | 452 } |
360 } | 453 } |
361 } | 454 } |
| 455 |
362 return (retval); | 456 return (retval); |
363 } | 457 } |
364 #endif /* PNG_pHYs_SUPPORTED */ | 458 #endif /* pHYs */ |
365 #endif /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */ | 459 #endif /* INCH_CONVERSIONS */ |
366 | 460 |
367 /* png_get_channels really belongs in here, too, but it's been around longer */ | 461 /* png_get_channels really belongs in here, too, but it's been around longer */ |
368 | 462 |
369 #endif /* PNG_EASY_ACCESS_SUPPORTED */ | 463 #endif /* EASY_ACCESS */ |
| 464 |
370 | 465 |
371 png_byte PNGAPI | 466 png_byte PNGAPI |
372 png_get_channels(png_structp png_ptr, png_infop info_ptr) | 467 png_get_channels(png_const_structrp png_ptr, png_const_inforp info_ptr) |
373 { | 468 { |
374 if (png_ptr != NULL && info_ptr != NULL) | 469 if (png_ptr != NULL && info_ptr != NULL) |
375 return(info_ptr->channels); | 470 return(info_ptr->channels); |
376 else | 471 |
377 return (0); | 472 return (0); |
378 } | 473 } |
379 | 474 |
380 png_bytep PNGAPI | 475 #ifdef PNG_READ_SUPPORTED |
381 png_get_signature(png_structp png_ptr, png_infop info_ptr) | 476 png_const_bytep PNGAPI |
| 477 png_get_signature(png_const_structrp png_ptr, png_const_inforp info_ptr) |
382 { | 478 { |
383 if (png_ptr != NULL && info_ptr != NULL) | 479 if (png_ptr != NULL && info_ptr != NULL) |
384 return(info_ptr->signature); | 480 return(info_ptr->signature); |
385 else | 481 |
386 return (NULL); | 482 return (NULL); |
387 } | 483 } |
| 484 #endif |
388 | 485 |
389 #ifdef PNG_bKGD_SUPPORTED | 486 #ifdef PNG_bKGD_SUPPORTED |
390 png_uint_32 PNGAPI | 487 png_uint_32 PNGAPI |
391 png_get_bKGD(png_structp png_ptr, png_infop info_ptr, | 488 png_get_bKGD(png_const_structrp png_ptr, png_inforp info_ptr, |
392 png_color_16p *background) | 489 png_color_16p *background) |
393 { | 490 { |
394 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD) | 491 if (png_ptr != NULL && info_ptr != NULL && |
395 && background != NULL) | 492 (info_ptr->valid & PNG_INFO_bKGD) != 0 && |
| 493 background != NULL) |
396 { | 494 { |
397 png_debug1(1, "in %s retrieval function", "bKGD"); | 495 png_debug1(1, "in %s retrieval function", "bKGD"); |
398 | 496 |
399 *background = &(info_ptr->background); | 497 *background = &(info_ptr->background); |
400 return (PNG_INFO_bKGD); | 498 return (PNG_INFO_bKGD); |
401 } | 499 } |
| 500 |
402 return (0); | 501 return (0); |
403 } | 502 } |
404 #endif | 503 #endif |
405 | 504 |
406 #ifdef PNG_cHRM_SUPPORTED | 505 #ifdef PNG_cHRM_SUPPORTED |
407 #ifdef PNG_FLOATING_POINT_SUPPORTED | 506 /* The XYZ APIs were added in 1.5.5 to take advantage of the code added at the |
408 png_uint_32 PNGAPI | 507 * same time to correct the rgb grayscale coefficient defaults obtained from the |
409 png_get_cHRM(png_structp png_ptr, png_infop info_ptr, | 508 * cHRM chunk in 1.5.4 |
410 double *white_x, double *white_y, double *red_x, double *red_y, | 509 */ |
411 double *green_x, double *green_y, double *blue_x, double *blue_y) | 510 # ifdef PNG_FLOATING_POINT_SUPPORTED |
412 { | 511 png_uint_32 PNGAPI |
413 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)) | 512 png_get_cHRM(png_const_structrp png_ptr, png_const_inforp info_ptr, |
| 513 double *white_x, double *white_y, double *red_x, double *red_y, |
| 514 double *green_x, double *green_y, double *blue_x, double *blue_y) |
| 515 { |
| 516 /* Quiet API change: this code used to only return the end points if a cHRM |
| 517 * chunk was present, but the end points can also come from iCCP or sRGB |
| 518 * chunks, so in 1.6.0 the png_get_ APIs return the end points regardless and |
| 519 * the png_set_ APIs merely check that set end points are mutually |
| 520 * consistent. |
| 521 */ |
| 522 if (png_ptr != NULL && info_ptr != NULL && |
| 523 (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0) |
414 { | 524 { |
415 png_debug1(1, "in %s retrieval function", "cHRM"); | 525 png_debug1(1, "in %s retrieval function", "cHRM"); |
416 | 526 |
417 if (white_x != NULL) | 527 if (white_x != NULL) |
418 *white_x = (double)info_ptr->x_white; | 528 *white_x = png_float(png_ptr, |
| 529 info_ptr->colorspace.end_points_xy.whitex, "cHRM white X"); |
419 if (white_y != NULL) | 530 if (white_y != NULL) |
420 *white_y = (double)info_ptr->y_white; | 531 *white_y = png_float(png_ptr, |
| 532 info_ptr->colorspace.end_points_xy.whitey, "cHRM white Y"); |
421 if (red_x != NULL) | 533 if (red_x != NULL) |
422 *red_x = (double)info_ptr->x_red; | 534 *red_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redx, |
| 535 "cHRM red X"); |
423 if (red_y != NULL) | 536 if (red_y != NULL) |
424 *red_y = (double)info_ptr->y_red; | 537 *red_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redy, |
| 538 "cHRM red Y"); |
425 if (green_x != NULL) | 539 if (green_x != NULL) |
426 *green_x = (double)info_ptr->x_green; | 540 *green_x = png_float(png_ptr, |
| 541 info_ptr->colorspace.end_points_xy.greenx, "cHRM green X"); |
427 if (green_y != NULL) | 542 if (green_y != NULL) |
428 *green_y = (double)info_ptr->y_green; | 543 *green_y = png_float(png_ptr, |
| 544 info_ptr->colorspace.end_points_xy.greeny, "cHRM green Y"); |
429 if (blue_x != NULL) | 545 if (blue_x != NULL) |
430 *blue_x = (double)info_ptr->x_blue; | 546 *blue_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluex, |
| 547 "cHRM blue X"); |
431 if (blue_y != NULL) | 548 if (blue_y != NULL) |
432 *blue_y = (double)info_ptr->y_blue; | 549 *blue_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluey, |
| 550 "cHRM blue Y"); |
433 return (PNG_INFO_cHRM); | 551 return (PNG_INFO_cHRM); |
434 } | 552 } |
435 return (0); | 553 |
436 } | 554 return (0); |
437 #endif | 555 } |
438 #ifdef PNG_FIXED_POINT_SUPPORTED | 556 |
439 png_uint_32 PNGAPI | 557 png_uint_32 PNGAPI |
440 png_get_cHRM_fixed(png_structp png_ptr, png_infop info_ptr, | 558 png_get_cHRM_XYZ(png_const_structrp png_ptr, png_const_inforp info_ptr, |
441 png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x, | 559 double *red_X, double *red_Y, double *red_Z, double *green_X, |
442 png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y, | 560 double *green_Y, double *green_Z, double *blue_X, double *blue_Y, |
443 png_fixed_point *blue_x, png_fixed_point *blue_y) | 561 double *blue_Z) |
| 562 { |
| 563 if (png_ptr != NULL && info_ptr != NULL && |
| 564 (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0) |
| 565 { |
| 566 png_debug1(1, "in %s retrieval function", "cHRM_XYZ(float)"); |
| 567 |
| 568 if (red_X != NULL) |
| 569 *red_X = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_X, |
| 570 "cHRM red X"); |
| 571 if (red_Y != NULL) |
| 572 *red_Y = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_Y, |
| 573 "cHRM red Y"); |
| 574 if (red_Z != NULL) |
| 575 *red_Z = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_Z, |
| 576 "cHRM red Z"); |
| 577 if (green_X != NULL) |
| 578 *green_X = png_float(png_ptr, |
| 579 info_ptr->colorspace.end_points_XYZ.green_X, "cHRM green X"); |
| 580 if (green_Y != NULL) |
| 581 *green_Y = png_float(png_ptr, |
| 582 info_ptr->colorspace.end_points_XYZ.green_Y, "cHRM green Y"); |
| 583 if (green_Z != NULL) |
| 584 *green_Z = png_float(png_ptr, |
| 585 info_ptr->colorspace.end_points_XYZ.green_Z, "cHRM green Z"); |
| 586 if (blue_X != NULL) |
| 587 *blue_X = png_float(png_ptr, |
| 588 info_ptr->colorspace.end_points_XYZ.blue_X, "cHRM blue X"); |
| 589 if (blue_Y != NULL) |
| 590 *blue_Y = png_float(png_ptr, |
| 591 info_ptr->colorspace.end_points_XYZ.blue_Y, "cHRM blue Y"); |
| 592 if (blue_Z != NULL) |
| 593 *blue_Z = png_float(png_ptr, |
| 594 info_ptr->colorspace.end_points_XYZ.blue_Z, "cHRM blue Z"); |
| 595 return (PNG_INFO_cHRM); |
| 596 } |
| 597 |
| 598 return (0); |
| 599 } |
| 600 # endif |
| 601 |
| 602 # ifdef PNG_FIXED_POINT_SUPPORTED |
| 603 png_uint_32 PNGAPI |
| 604 png_get_cHRM_XYZ_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr, |
| 605 png_fixed_point *int_red_X, png_fixed_point *int_red_Y, |
| 606 png_fixed_point *int_red_Z, png_fixed_point *int_green_X, |
| 607 png_fixed_point *int_green_Y, png_fixed_point *int_green_Z, |
| 608 png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y, |
| 609 png_fixed_point *int_blue_Z) |
| 610 { |
| 611 if (png_ptr != NULL && info_ptr != NULL && |
| 612 (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0) |
| 613 { |
| 614 png_debug1(1, "in %s retrieval function", "cHRM_XYZ"); |
| 615 |
| 616 if (int_red_X != NULL) |
| 617 *int_red_X = info_ptr->colorspace.end_points_XYZ.red_X; |
| 618 if (int_red_Y != NULL) |
| 619 *int_red_Y = info_ptr->colorspace.end_points_XYZ.red_Y; |
| 620 if (int_red_Z != NULL) |
| 621 *int_red_Z = info_ptr->colorspace.end_points_XYZ.red_Z; |
| 622 if (int_green_X != NULL) |
| 623 *int_green_X = info_ptr->colorspace.end_points_XYZ.green_X; |
| 624 if (int_green_Y != NULL) |
| 625 *int_green_Y = info_ptr->colorspace.end_points_XYZ.green_Y; |
| 626 if (int_green_Z != NULL) |
| 627 *int_green_Z = info_ptr->colorspace.end_points_XYZ.green_Z; |
| 628 if (int_blue_X != NULL) |
| 629 *int_blue_X = info_ptr->colorspace.end_points_XYZ.blue_X; |
| 630 if (int_blue_Y != NULL) |
| 631 *int_blue_Y = info_ptr->colorspace.end_points_XYZ.blue_Y; |
| 632 if (int_blue_Z != NULL) |
| 633 *int_blue_Z = info_ptr->colorspace.end_points_XYZ.blue_Z; |
| 634 return (PNG_INFO_cHRM); |
| 635 } |
| 636 |
| 637 return (0); |
| 638 } |
| 639 |
| 640 png_uint_32 PNGAPI |
| 641 png_get_cHRM_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr, |
| 642 png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x, |
| 643 png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y, |
| 644 png_fixed_point *blue_x, png_fixed_point *blue_y) |
444 { | 645 { |
445 png_debug1(1, "in %s retrieval function", "cHRM"); | 646 png_debug1(1, "in %s retrieval function", "cHRM"); |
446 | 647 |
447 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)) | 648 if (png_ptr != NULL && info_ptr != NULL && |
| 649 (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0) |
448 { | 650 { |
449 if (white_x != NULL) | 651 if (white_x != NULL) |
450 *white_x = info_ptr->int_x_white; | 652 *white_x = info_ptr->colorspace.end_points_xy.whitex; |
451 if (white_y != NULL) | 653 if (white_y != NULL) |
452 *white_y = info_ptr->int_y_white; | 654 *white_y = info_ptr->colorspace.end_points_xy.whitey; |
453 if (red_x != NULL) | 655 if (red_x != NULL) |
454 *red_x = info_ptr->int_x_red; | 656 *red_x = info_ptr->colorspace.end_points_xy.redx; |
455 if (red_y != NULL) | 657 if (red_y != NULL) |
456 *red_y = info_ptr->int_y_red; | 658 *red_y = info_ptr->colorspace.end_points_xy.redy; |
457 if (green_x != NULL) | 659 if (green_x != NULL) |
458 *green_x = info_ptr->int_x_green; | 660 *green_x = info_ptr->colorspace.end_points_xy.greenx; |
459 if (green_y != NULL) | 661 if (green_y != NULL) |
460 *green_y = info_ptr->int_y_green; | 662 *green_y = info_ptr->colorspace.end_points_xy.greeny; |
461 if (blue_x != NULL) | 663 if (blue_x != NULL) |
462 *blue_x = info_ptr->int_x_blue; | 664 *blue_x = info_ptr->colorspace.end_points_xy.bluex; |
463 if (blue_y != NULL) | 665 if (blue_y != NULL) |
464 *blue_y = info_ptr->int_y_blue; | 666 *blue_y = info_ptr->colorspace.end_points_xy.bluey; |
465 return (PNG_INFO_cHRM); | 667 return (PNG_INFO_cHRM); |
466 } | 668 } |
467 return (0); | 669 |
468 } | 670 return (0); |
469 #endif | 671 } |
| 672 # endif |
470 #endif | 673 #endif |
471 | 674 |
472 #ifdef PNG_gAMA_SUPPORTED | 675 #ifdef PNG_gAMA_SUPPORTED |
473 #ifdef PNG_FLOATING_POINT_SUPPORTED | 676 # ifdef PNG_FIXED_POINT_SUPPORTED |
474 png_uint_32 PNGAPI | 677 png_uint_32 PNGAPI |
475 png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma) | 678 png_get_gAMA_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr, |
| 679 png_fixed_point *file_gamma) |
476 { | 680 { |
477 png_debug1(1, "in %s retrieval function", "gAMA"); | 681 png_debug1(1, "in %s retrieval function", "gAMA"); |
478 | 682 |
479 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) | 683 if (png_ptr != NULL && info_ptr != NULL && |
480 && file_gamma != NULL) | 684 (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 && |
481 { | 685 file_gamma != NULL) |
482 *file_gamma = (double)info_ptr->gamma; | 686 { |
| 687 *file_gamma = info_ptr->colorspace.gamma; |
483 return (PNG_INFO_gAMA); | 688 return (PNG_INFO_gAMA); |
484 } | 689 } |
485 return (0); | 690 |
486 } | 691 return (0); |
487 #endif | 692 } |
488 #ifdef PNG_FIXED_POINT_SUPPORTED | 693 # endif |
489 png_uint_32 PNGAPI | 694 |
490 png_get_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, | 695 # ifdef PNG_FLOATING_POINT_SUPPORTED |
491 png_fixed_point *int_file_gamma) | 696 png_uint_32 PNGAPI |
492 { | 697 png_get_gAMA(png_const_structrp png_ptr, png_const_inforp info_ptr, |
493 png_debug1(1, "in %s retrieval function", "gAMA"); | 698 double *file_gamma) |
494 | 699 { |
495 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) | 700 png_debug1(1, "in %s retrieval function", "gAMA(float)"); |
496 && int_file_gamma != NULL) | 701 |
497 { | 702 if (png_ptr != NULL && info_ptr != NULL && |
498 *int_file_gamma = info_ptr->int_gamma; | 703 (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 && |
| 704 file_gamma != NULL) |
| 705 { |
| 706 *file_gamma = png_float(png_ptr, info_ptr->colorspace.gamma, |
| 707 "png_get_gAMA"); |
499 return (PNG_INFO_gAMA); | 708 return (PNG_INFO_gAMA); |
500 } | 709 } |
501 return (0); | 710 |
502 } | 711 return (0); |
503 #endif | 712 } |
| 713 # endif |
504 #endif | 714 #endif |
505 | 715 |
506 #ifdef PNG_sRGB_SUPPORTED | 716 #ifdef PNG_sRGB_SUPPORTED |
507 png_uint_32 PNGAPI | 717 png_uint_32 PNGAPI |
508 png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent) | 718 png_get_sRGB(png_const_structrp png_ptr, png_const_inforp info_ptr, |
| 719 int *file_srgb_intent) |
509 { | 720 { |
510 png_debug1(1, "in %s retrieval function", "sRGB"); | 721 png_debug1(1, "in %s retrieval function", "sRGB"); |
511 | 722 |
512 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB) | 723 if (png_ptr != NULL && info_ptr != NULL && |
513 && file_srgb_intent != NULL) | 724 (info_ptr->valid & PNG_INFO_sRGB) != 0 && file_srgb_intent != NULL) |
514 { | 725 { |
515 *file_srgb_intent = (int)info_ptr->srgb_intent; | 726 *file_srgb_intent = info_ptr->colorspace.rendering_intent; |
516 return (PNG_INFO_sRGB); | 727 return (PNG_INFO_sRGB); |
517 } | 728 } |
| 729 |
518 return (0); | 730 return (0); |
519 } | 731 } |
520 #endif | 732 #endif |
521 | 733 |
522 #ifdef PNG_iCCP_SUPPORTED | 734 #ifdef PNG_iCCP_SUPPORTED |
523 png_uint_32 PNGAPI | 735 png_uint_32 PNGAPI |
524 png_get_iCCP(png_structp png_ptr, png_infop info_ptr, | 736 png_get_iCCP(png_const_structrp png_ptr, png_inforp info_ptr, |
525 png_charpp name, int *compression_type, | 737 png_charpp name, int *compression_type, |
526 png_charpp profile, png_uint_32 *proflen) | 738 png_bytepp profile, png_uint_32 *proflen) |
527 { | 739 { |
528 png_debug1(1, "in %s retrieval function", "iCCP"); | 740 png_debug1(1, "in %s retrieval function", "iCCP"); |
529 | 741 |
530 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP) | 742 if (png_ptr != NULL && info_ptr != NULL && |
531 && name != NULL && profile != NULL && proflen != NULL) | 743 (info_ptr->valid & PNG_INFO_iCCP) != 0 && |
| 744 name != NULL && compression_type != NULL && profile != NULL && |
| 745 proflen != NULL) |
532 { | 746 { |
533 *name = info_ptr->iccp_name; | 747 *name = info_ptr->iccp_name; |
534 *profile = info_ptr->iccp_profile; | 748 *profile = info_ptr->iccp_profile; |
535 /* Compression_type is a dummy so the API won't have to change | 749 *proflen = png_get_uint_32(info_ptr->iccp_profile); |
536 * if we introduce multiple compression types later. | 750 /* This is somewhat irrelevant since the profile data returned has |
| 751 * actually been uncompressed. |
537 */ | 752 */ |
538 *proflen = (int)info_ptr->iccp_proflen; | 753 *compression_type = PNG_COMPRESSION_TYPE_BASE; |
539 *compression_type = (int)info_ptr->iccp_compression; | |
540 return (PNG_INFO_iCCP); | 754 return (PNG_INFO_iCCP); |
541 } | 755 } |
| 756 |
542 return (0); | 757 return (0); |
543 } | 758 } |
544 #endif | 759 #endif |
545 | 760 |
546 #ifdef PNG_sPLT_SUPPORTED | 761 #ifdef PNG_sPLT_SUPPORTED |
547 png_uint_32 PNGAPI | 762 int PNGAPI |
548 png_get_sPLT(png_structp png_ptr, png_infop info_ptr, | 763 png_get_sPLT(png_const_structrp png_ptr, png_inforp info_ptr, |
549 png_sPLT_tpp spalettes) | 764 png_sPLT_tpp spalettes) |
550 { | 765 { |
551 if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL) | 766 if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL) |
552 { | 767 { |
553 *spalettes = info_ptr->splt_palettes; | 768 *spalettes = info_ptr->splt_palettes; |
554 return ((png_uint_32)info_ptr->splt_palettes_num); | 769 return info_ptr->splt_palettes_num; |
555 } | 770 } |
| 771 |
556 return (0); | 772 return (0); |
557 } | 773 } |
558 #endif | 774 #endif |
559 | 775 |
560 #ifdef PNG_hIST_SUPPORTED | 776 #ifdef PNG_hIST_SUPPORTED |
561 png_uint_32 PNGAPI | 777 png_uint_32 PNGAPI |
562 png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist) | 778 png_get_hIST(png_const_structrp png_ptr, png_inforp info_ptr, |
| 779 png_uint_16p *hist) |
563 { | 780 { |
564 png_debug1(1, "in %s retrieval function", "hIST"); | 781 png_debug1(1, "in %s retrieval function", "hIST"); |
565 | 782 |
566 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST) | 783 if (png_ptr != NULL && info_ptr != NULL && |
567 && hist != NULL) | 784 (info_ptr->valid & PNG_INFO_hIST) != 0 && hist != NULL) |
568 { | 785 { |
569 *hist = info_ptr->hist; | 786 *hist = info_ptr->hist; |
570 return (PNG_INFO_hIST); | 787 return (PNG_INFO_hIST); |
571 } | 788 } |
572 return (0); | 789 |
573 } | 790 return (0); |
574 #endif | 791 } |
575 | 792 #endif |
576 png_uint_32 PNGAPI | 793 |
577 png_get_IHDR(png_structp png_ptr, png_infop info_ptr, | 794 png_uint_32 PNGAPI |
578 png_uint_32 *width, png_uint_32 *height, int *bit_depth, | 795 png_get_IHDR(png_const_structrp png_ptr, png_const_inforp info_ptr, |
579 int *color_type, int *interlace_type, int *compression_type, | 796 png_uint_32 *width, png_uint_32 *height, int *bit_depth, |
580 int *filter_type) | 797 int *color_type, int *interlace_type, int *compression_type, |
581 | 798 int *filter_type) |
582 { | 799 { |
583 png_debug1(1, "in %s retrieval function", "IHDR"); | 800 png_debug1(1, "in %s retrieval function", "IHDR"); |
584 | 801 |
585 if (png_ptr == NULL || info_ptr == NULL || width == NULL || | 802 if (png_ptr == NULL || info_ptr == NULL) |
586 height == NULL || bit_depth == NULL || color_type == NULL) | |
587 return (0); | 803 return (0); |
588 | 804 |
589 *width = info_ptr->width; | 805 if (width != NULL) |
590 *height = info_ptr->height; | 806 *width = info_ptr->width; |
591 *bit_depth = info_ptr->bit_depth; | 807 |
592 *color_type = info_ptr->color_type; | 808 if (height != NULL) |
| 809 *height = info_ptr->height; |
| 810 |
| 811 if (bit_depth != NULL) |
| 812 *bit_depth = info_ptr->bit_depth; |
| 813 |
| 814 if (color_type != NULL) |
| 815 *color_type = info_ptr->color_type; |
593 | 816 |
594 if (compression_type != NULL) | 817 if (compression_type != NULL) |
595 *compression_type = info_ptr->compression_type; | 818 *compression_type = info_ptr->compression_type; |
596 | 819 |
597 if (filter_type != NULL) | 820 if (filter_type != NULL) |
598 *filter_type = info_ptr->filter_type; | 821 *filter_type = info_ptr->filter_type; |
599 | 822 |
600 if (interlace_type != NULL) | 823 if (interlace_type != NULL) |
601 *interlace_type = info_ptr->interlace_type; | 824 *interlace_type = info_ptr->interlace_type; |
602 | 825 |
603 /* This is redundant if we can be sure that the info_ptr values were all | 826 /* This is redundant if we can be sure that the info_ptr values were all |
604 * assigned in png_set_IHDR(). We do the check anyhow in case an | 827 * assigned in png_set_IHDR(). We do the check anyhow in case an |
605 * application has ignored our advice not to mess with the members | 828 * application has ignored our advice not to mess with the members |
606 * of info_ptr directly. | 829 * of info_ptr directly. |
607 */ | 830 */ |
608 png_check_IHDR (png_ptr, info_ptr->width, info_ptr->height, | 831 png_check_IHDR(png_ptr, info_ptr->width, info_ptr->height, |
609 info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type, | 832 info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type, |
610 info_ptr->compression_type, info_ptr->filter_type); | 833 info_ptr->compression_type, info_ptr->filter_type); |
611 | 834 |
612 return (1); | 835 return (1); |
613 } | 836 } |
614 | 837 |
615 #ifdef PNG_oFFs_SUPPORTED | 838 #ifdef PNG_oFFs_SUPPORTED |
616 png_uint_32 PNGAPI | 839 png_uint_32 PNGAPI |
617 png_get_oFFs(png_structp png_ptr, png_infop info_ptr, | 840 png_get_oFFs(png_const_structrp png_ptr, png_const_inforp info_ptr, |
618 png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type) | 841 png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type) |
619 { | 842 { |
620 png_debug1(1, "in %s retrieval function", "oFFs"); | 843 png_debug1(1, "in %s retrieval function", "oFFs"); |
621 | 844 |
622 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs) | 845 if (png_ptr != NULL && info_ptr != NULL && |
623 && offset_x != NULL && offset_y != NULL && unit_type != NULL) | 846 (info_ptr->valid & PNG_INFO_oFFs) != 0 && |
| 847 offset_x != NULL && offset_y != NULL && unit_type != NULL) |
624 { | 848 { |
625 *offset_x = info_ptr->x_offset; | 849 *offset_x = info_ptr->x_offset; |
626 *offset_y = info_ptr->y_offset; | 850 *offset_y = info_ptr->y_offset; |
627 *unit_type = (int)info_ptr->offset_unit_type; | 851 *unit_type = (int)info_ptr->offset_unit_type; |
628 return (PNG_INFO_oFFs); | 852 return (PNG_INFO_oFFs); |
629 } | 853 } |
| 854 |
630 return (0); | 855 return (0); |
631 } | 856 } |
632 #endif | 857 #endif |
633 | 858 |
634 #ifdef PNG_pCAL_SUPPORTED | 859 #ifdef PNG_pCAL_SUPPORTED |
635 png_uint_32 PNGAPI | 860 png_uint_32 PNGAPI |
636 png_get_pCAL(png_structp png_ptr, png_infop info_ptr, | 861 png_get_pCAL(png_const_structrp png_ptr, png_inforp info_ptr, |
637 png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams, | 862 png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams, |
638 png_charp *units, png_charpp *params) | 863 png_charp *units, png_charpp *params) |
639 { | 864 { |
640 png_debug1(1, "in %s retrieval function", "pCAL"); | 865 png_debug1(1, "in %s retrieval function", "pCAL"); |
641 | 866 |
642 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL) | 867 if (png_ptr != NULL && info_ptr != NULL && |
643 && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL && | 868 (info_ptr->valid & PNG_INFO_pCAL) != 0 && |
| 869 purpose != NULL && X0 != NULL && X1 != NULL && type != NULL && |
644 nparams != NULL && units != NULL && params != NULL) | 870 nparams != NULL && units != NULL && params != NULL) |
645 { | 871 { |
646 *purpose = info_ptr->pcal_purpose; | 872 *purpose = info_ptr->pcal_purpose; |
647 *X0 = info_ptr->pcal_X0; | 873 *X0 = info_ptr->pcal_X0; |
648 *X1 = info_ptr->pcal_X1; | 874 *X1 = info_ptr->pcal_X1; |
649 *type = (int)info_ptr->pcal_type; | 875 *type = (int)info_ptr->pcal_type; |
650 *nparams = (int)info_ptr->pcal_nparams; | 876 *nparams = (int)info_ptr->pcal_nparams; |
651 *units = info_ptr->pcal_units; | 877 *units = info_ptr->pcal_units; |
652 *params = info_ptr->pcal_params; | 878 *params = info_ptr->pcal_params; |
653 return (PNG_INFO_pCAL); | 879 return (PNG_INFO_pCAL); |
654 } | 880 } |
| 881 |
655 return (0); | 882 return (0); |
656 } | 883 } |
657 #endif | 884 #endif |
658 | 885 |
659 #ifdef PNG_sCAL_SUPPORTED | 886 #ifdef PNG_sCAL_SUPPORTED |
660 #ifdef PNG_FLOATING_POINT_SUPPORTED | 887 # ifdef PNG_FIXED_POINT_SUPPORTED |
| 888 # if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || \ |
| 889 defined(PNG_FLOATING_POINT_SUPPORTED) |
661 png_uint_32 PNGAPI | 890 png_uint_32 PNGAPI |
662 png_get_sCAL(png_structp png_ptr, png_infop info_ptr, | 891 png_get_sCAL_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr, |
663 int *unit, double *width, double *height) | 892 int *unit, png_fixed_point *width, png_fixed_point *height) |
664 { | 893 { |
665 if (png_ptr != NULL && info_ptr != NULL && | 894 if (png_ptr != NULL && info_ptr != NULL && |
666 (info_ptr->valid & PNG_INFO_sCAL)) | 895 (info_ptr->valid & PNG_INFO_sCAL) != 0) |
667 { | 896 { |
668 *unit = info_ptr->scal_unit; | 897 *unit = info_ptr->scal_unit; |
669 *width = info_ptr->scal_pixel_width; | 898 /*TODO: make this work without FP support; the API is currently eliminated |
670 *height = info_ptr->scal_pixel_height; | 899 * if neither floating point APIs nor internal floating point arithmetic |
671 return (PNG_INFO_sCAL); | 900 * are enabled. |
672 } | 901 */ |
673 return(0); | 902 *width = png_fixed(png_ptr, atof(info_ptr->scal_s_width), "sCAL width"); |
| 903 *height = png_fixed(png_ptr, atof(info_ptr->scal_s_height), |
| 904 "sCAL height"); |
| 905 return (PNG_INFO_sCAL); |
| 906 } |
| 907 |
| 908 return(0); |
674 } | 909 } |
675 #else | 910 # endif /* FLOATING_ARITHMETIC */ |
676 #ifdef PNG_FIXED_POINT_SUPPORTED | 911 # endif /* FIXED_POINT */ |
| 912 # ifdef PNG_FLOATING_POINT_SUPPORTED |
677 png_uint_32 PNGAPI | 913 png_uint_32 PNGAPI |
678 png_get_sCAL_s(png_structp png_ptr, png_infop info_ptr, | 914 png_get_sCAL(png_const_structrp png_ptr, png_const_inforp info_ptr, |
679 int *unit, png_charpp width, png_charpp height) | 915 int *unit, double *width, double *height) |
680 { | 916 { |
681 if (png_ptr != NULL && info_ptr != NULL && | 917 if (png_ptr != NULL && info_ptr != NULL && |
682 (info_ptr->valid & PNG_INFO_sCAL)) | 918 (info_ptr->valid & PNG_INFO_sCAL) != 0) |
683 { | 919 { |
684 *unit = info_ptr->scal_unit; | 920 *unit = info_ptr->scal_unit; |
685 *width = info_ptr->scal_s_width; | 921 *width = atof(info_ptr->scal_s_width); |
686 *height = info_ptr->scal_s_height; | 922 *height = atof(info_ptr->scal_s_height); |
687 return (PNG_INFO_sCAL); | 923 return (PNG_INFO_sCAL); |
688 } | 924 } |
689 return(0); | 925 |
| 926 return(0); |
690 } | 927 } |
691 #endif | 928 # endif /* FLOATING POINT */ |
692 #endif | 929 png_uint_32 PNGAPI |
693 #endif | 930 png_get_sCAL_s(png_const_structrp png_ptr, png_const_inforp info_ptr, |
| 931 int *unit, png_charpp width, png_charpp height) |
| 932 { |
| 933 if (png_ptr != NULL && info_ptr != NULL && |
| 934 (info_ptr->valid & PNG_INFO_sCAL) != 0) |
| 935 { |
| 936 *unit = info_ptr->scal_unit; |
| 937 *width = info_ptr->scal_s_width; |
| 938 *height = info_ptr->scal_s_height; |
| 939 return (PNG_INFO_sCAL); |
| 940 } |
| 941 |
| 942 return(0); |
| 943 } |
| 944 #endif /* sCAL */ |
694 | 945 |
695 #ifdef PNG_pHYs_SUPPORTED | 946 #ifdef PNG_pHYs_SUPPORTED |
696 png_uint_32 PNGAPI | 947 png_uint_32 PNGAPI |
697 png_get_pHYs(png_structp png_ptr, png_infop info_ptr, | 948 png_get_pHYs(png_const_structrp png_ptr, png_const_inforp info_ptr, |
698 png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) | 949 png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) |
699 { | 950 { |
700 png_uint_32 retval = 0; | 951 png_uint_32 retval = 0; |
701 | 952 |
702 png_debug1(1, "in %s retrieval function", "pHYs"); | 953 png_debug1(1, "in %s retrieval function", "pHYs"); |
703 | 954 |
704 if (png_ptr != NULL && info_ptr != NULL && | 955 if (png_ptr != NULL && info_ptr != NULL && |
705 (info_ptr->valid & PNG_INFO_pHYs)) | 956 (info_ptr->valid & PNG_INFO_pHYs) != 0) |
706 { | 957 { |
707 if (res_x != NULL) | 958 if (res_x != NULL) |
708 { | 959 { |
709 *res_x = info_ptr->x_pixels_per_unit; | 960 *res_x = info_ptr->x_pixels_per_unit; |
710 retval |= PNG_INFO_pHYs; | 961 retval |= PNG_INFO_pHYs; |
711 } | 962 } |
712 | 963 |
713 if (res_y != NULL) | 964 if (res_y != NULL) |
714 { | 965 { |
715 *res_y = info_ptr->y_pixels_per_unit; | 966 *res_y = info_ptr->y_pixels_per_unit; |
716 retval |= PNG_INFO_pHYs; | 967 retval |= PNG_INFO_pHYs; |
717 } | 968 } |
718 | 969 |
719 if (unit_type != NULL) | 970 if (unit_type != NULL) |
720 { | 971 { |
721 *unit_type = (int)info_ptr->phys_unit_type; | 972 *unit_type = (int)info_ptr->phys_unit_type; |
722 retval |= PNG_INFO_pHYs; | 973 retval |= PNG_INFO_pHYs; |
723 } | 974 } |
724 } | 975 } |
| 976 |
725 return (retval); | 977 return (retval); |
726 } | 978 } |
727 #endif | 979 #endif /* pHYs */ |
728 | 980 |
729 png_uint_32 PNGAPI | 981 png_uint_32 PNGAPI |
730 png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette, | 982 png_get_PLTE(png_const_structrp png_ptr, png_inforp info_ptr, |
731 int *num_palette) | 983 png_colorp *palette, int *num_palette) |
732 { | 984 { |
733 png_debug1(1, "in %s retrieval function", "PLTE"); | 985 png_debug1(1, "in %s retrieval function", "PLTE"); |
734 | 986 |
735 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE) | 987 if (png_ptr != NULL && info_ptr != NULL && |
736 && palette != NULL) | 988 (info_ptr->valid & PNG_INFO_PLTE) != 0 && palette != NULL) |
737 { | 989 { |
738 *palette = info_ptr->palette; | 990 *palette = info_ptr->palette; |
739 *num_palette = info_ptr->num_palette; | 991 *num_palette = info_ptr->num_palette; |
740 png_debug1(3, "num_palette = %d", *num_palette); | 992 png_debug1(3, "num_palette = %d", *num_palette); |
741 return (PNG_INFO_PLTE); | 993 return (PNG_INFO_PLTE); |
742 } | 994 } |
| 995 |
743 return (0); | 996 return (0); |
744 } | 997 } |
745 | 998 |
746 #ifdef PNG_sBIT_SUPPORTED | 999 #ifdef PNG_sBIT_SUPPORTED |
747 png_uint_32 PNGAPI | 1000 png_uint_32 PNGAPI |
748 png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit) | 1001 png_get_sBIT(png_const_structrp png_ptr, png_inforp info_ptr, |
| 1002 png_color_8p *sig_bit) |
749 { | 1003 { |
750 png_debug1(1, "in %s retrieval function", "sBIT"); | 1004 png_debug1(1, "in %s retrieval function", "sBIT"); |
751 | 1005 |
752 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT) | 1006 if (png_ptr != NULL && info_ptr != NULL && |
753 && sig_bit != NULL) | 1007 (info_ptr->valid & PNG_INFO_sBIT) != 0 && sig_bit != NULL) |
754 { | 1008 { |
755 *sig_bit = &(info_ptr->sig_bit); | 1009 *sig_bit = &(info_ptr->sig_bit); |
756 return (PNG_INFO_sBIT); | 1010 return (PNG_INFO_sBIT); |
757 } | 1011 } |
| 1012 |
758 return (0); | 1013 return (0); |
759 } | 1014 } |
760 #endif | 1015 #endif |
761 | 1016 |
762 #ifdef PNG_TEXT_SUPPORTED | 1017 #ifdef PNG_TEXT_SUPPORTED |
763 png_uint_32 PNGAPI | 1018 int PNGAPI |
764 png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr, | 1019 png_get_text(png_const_structrp png_ptr, png_inforp info_ptr, |
765 int *num_text) | 1020 png_textp *text_ptr, int *num_text) |
766 { | 1021 { |
767 if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0) | 1022 if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0) |
768 { | 1023 { |
769 png_debug1(1, "in %s retrieval function", | 1024 png_debug1(1, "in 0x%lx retrieval function", |
770 (png_ptr->chunk_name[0] == '\0' ? "text" | 1025 (unsigned long)png_ptr->chunk_name); |
771 : (png_const_charp)png_ptr->chunk_name)); | |
772 | 1026 |
773 if (text_ptr != NULL) | 1027 if (text_ptr != NULL) |
774 *text_ptr = info_ptr->text; | 1028 *text_ptr = info_ptr->text; |
775 | 1029 |
776 if (num_text != NULL) | 1030 if (num_text != NULL) |
777 *num_text = info_ptr->num_text; | 1031 *num_text = info_ptr->num_text; |
778 | 1032 |
779 return ((png_uint_32)info_ptr->num_text); | 1033 return info_ptr->num_text; |
780 } | 1034 } |
| 1035 |
781 if (num_text != NULL) | 1036 if (num_text != NULL) |
782 *num_text = 0; | 1037 *num_text = 0; |
| 1038 |
783 return(0); | 1039 return(0); |
784 } | 1040 } |
785 #endif | 1041 #endif |
786 | 1042 |
787 #ifdef PNG_tIME_SUPPORTED | 1043 #ifdef PNG_tIME_SUPPORTED |
788 png_uint_32 PNGAPI | 1044 png_uint_32 PNGAPI |
789 png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time) | 1045 png_get_tIME(png_const_structrp png_ptr, png_inforp info_ptr, |
| 1046 png_timep *mod_time) |
790 { | 1047 { |
791 png_debug1(1, "in %s retrieval function", "tIME"); | 1048 png_debug1(1, "in %s retrieval function", "tIME"); |
792 | 1049 |
793 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME) | 1050 if (png_ptr != NULL && info_ptr != NULL && |
794 && mod_time != NULL) | 1051 (info_ptr->valid & PNG_INFO_tIME) != 0 && mod_time != NULL) |
795 { | 1052 { |
796 *mod_time = &(info_ptr->mod_time); | 1053 *mod_time = &(info_ptr->mod_time); |
797 return (PNG_INFO_tIME); | 1054 return (PNG_INFO_tIME); |
798 } | 1055 } |
| 1056 |
799 return (0); | 1057 return (0); |
800 } | 1058 } |
801 #endif | 1059 #endif |
802 | 1060 |
803 #ifdef PNG_tRNS_SUPPORTED | 1061 #ifdef PNG_tRNS_SUPPORTED |
804 png_uint_32 PNGAPI | 1062 png_uint_32 PNGAPI |
805 png_get_tRNS(png_structp png_ptr, png_infop info_ptr, | 1063 png_get_tRNS(png_const_structrp png_ptr, png_inforp info_ptr, |
806 png_bytep *trans, int *num_trans, png_color_16p *trans_values) | 1064 png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color) |
807 { | 1065 { |
808 png_uint_32 retval = 0; | 1066 png_uint_32 retval = 0; |
809 if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS)) | 1067 if (png_ptr != NULL && info_ptr != NULL && |
| 1068 (info_ptr->valid & PNG_INFO_tRNS) != 0) |
810 { | 1069 { |
811 png_debug1(1, "in %s retrieval function", "tRNS"); | 1070 png_debug1(1, "in %s retrieval function", "tRNS"); |
812 | 1071 |
813 if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) | 1072 if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
814 { | 1073 { |
815 if (trans != NULL) | 1074 if (trans_alpha != NULL) |
816 { | 1075 { |
817 *trans = info_ptr->trans; | 1076 *trans_alpha = info_ptr->trans_alpha; |
818 retval |= PNG_INFO_tRNS; | 1077 retval |= PNG_INFO_tRNS; |
819 } | 1078 } |
820 | 1079 |
821 if (trans_values != NULL) | 1080 if (trans_color != NULL) |
822 *trans_values = &(info_ptr->trans_values); | 1081 *trans_color = &(info_ptr->trans_color); |
823 } | 1082 } |
| 1083 |
824 else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */ | 1084 else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */ |
825 { | 1085 { |
826 if (trans_values != NULL) | 1086 if (trans_color != NULL) |
827 { | 1087 { |
828 *trans_values = &(info_ptr->trans_values); | 1088 *trans_color = &(info_ptr->trans_color); |
829 retval |= PNG_INFO_tRNS; | 1089 retval |= PNG_INFO_tRNS; |
830 } | 1090 } |
831 | 1091 |
832 if (trans != NULL) | 1092 if (trans_alpha != NULL) |
833 *trans = NULL; | 1093 *trans_alpha = NULL; |
834 } | 1094 } |
| 1095 |
835 if (num_trans != NULL) | 1096 if (num_trans != NULL) |
836 { | 1097 { |
837 *num_trans = info_ptr->num_trans; | 1098 *num_trans = info_ptr->num_trans; |
838 retval |= PNG_INFO_tRNS; | 1099 retval |= PNG_INFO_tRNS; |
839 } | 1100 } |
840 } | 1101 } |
| 1102 |
841 return (retval); | 1103 return (retval); |
842 } | 1104 } |
843 #endif | 1105 #endif |
844 | 1106 |
845 #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED | 1107 #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED |
846 png_uint_32 PNGAPI | 1108 int PNGAPI |
847 png_get_unknown_chunks(png_structp png_ptr, png_infop info_ptr, | 1109 png_get_unknown_chunks(png_const_structrp png_ptr, png_inforp info_ptr, |
848 png_unknown_chunkpp unknowns) | 1110 png_unknown_chunkpp unknowns) |
849 { | 1111 { |
850 if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL) | 1112 if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL) |
851 { | 1113 { |
852 *unknowns = info_ptr->unknown_chunks; | 1114 *unknowns = info_ptr->unknown_chunks; |
853 return ((png_uint_32)info_ptr->unknown_chunks_num); | 1115 return info_ptr->unknown_chunks_num; |
854 } | 1116 } |
| 1117 |
855 return (0); | 1118 return (0); |
856 } | 1119 } |
857 #endif | 1120 #endif |
858 | 1121 |
859 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED | 1122 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED |
860 png_byte PNGAPI | 1123 png_byte PNGAPI |
861 png_get_rgb_to_gray_status (png_structp png_ptr) | 1124 png_get_rgb_to_gray_status (png_const_structrp png_ptr) |
862 { | 1125 { |
863 return (png_byte)(png_ptr? png_ptr->rgb_to_gray_status : 0); | 1126 return (png_byte)(png_ptr ? png_ptr->rgb_to_gray_status : 0); |
864 } | 1127 } |
865 #endif | 1128 #endif |
866 | 1129 |
867 #ifdef PNG_USER_CHUNKS_SUPPORTED | 1130 #ifdef PNG_USER_CHUNKS_SUPPORTED |
868 png_voidp PNGAPI | 1131 png_voidp PNGAPI |
869 png_get_user_chunk_ptr(png_structp png_ptr) | 1132 png_get_user_chunk_ptr(png_const_structrp png_ptr) |
870 { | 1133 { |
871 return (png_ptr? png_ptr->user_chunk_ptr : NULL); | 1134 return (png_ptr ? png_ptr->user_chunk_ptr : NULL); |
872 } | 1135 } |
873 #endif | 1136 #endif |
874 | 1137 |
875 png_uint_32 PNGAPI | 1138 png_size_t PNGAPI |
876 png_get_compression_buffer_size(png_structp png_ptr) | 1139 png_get_compression_buffer_size(png_const_structrp png_ptr) |
877 { | 1140 { |
878 return (png_uint_32)(png_ptr? png_ptr->zbuf_size : 0L); | 1141 if (png_ptr == NULL) |
| 1142 return 0; |
| 1143 |
| 1144 #ifdef PNG_WRITE_SUPPORTED |
| 1145 if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0) |
| 1146 #endif |
| 1147 { |
| 1148 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
| 1149 return png_ptr->IDAT_read_size; |
| 1150 #else |
| 1151 return PNG_IDAT_READ_SIZE; |
| 1152 #endif |
| 1153 } |
| 1154 |
| 1155 #ifdef PNG_WRITE_SUPPORTED |
| 1156 else |
| 1157 return png_ptr->zbuffer_size; |
| 1158 #endif |
879 } | 1159 } |
880 | 1160 |
881 #ifdef PNG_ASSEMBLER_CODE_SUPPORTED | 1161 #ifdef PNG_SET_USER_LIMITS_SUPPORTED |
882 #ifndef PNG_1_0_X | 1162 /* These functions were added to libpng 1.2.6 and were enabled |
883 /* This function was added to libpng 1.2.0 and should exist by default */ | 1163 * by default in libpng-1.4.0 */ |
884 png_uint_32 PNGAPI | 1164 png_uint_32 PNGAPI |
885 png_get_asm_flags (png_structp png_ptr) | 1165 png_get_user_width_max (png_const_structrp png_ptr) |
886 { | 1166 { |
887 /* Obsolete, to be removed from libpng-1.4.0 */ | 1167 return (png_ptr ? png_ptr->user_width_max : 0); |
888 PNG_UNUSED(png_ptr) | |
889 return 0L; | |
890 } | 1168 } |
891 | 1169 |
892 /* This function was added to libpng 1.2.0 and should exist by default */ | |
893 png_uint_32 PNGAPI | 1170 png_uint_32 PNGAPI |
894 png_get_asm_flagmask (int flag_select) | 1171 png_get_user_height_max (png_const_structrp png_ptr) |
895 { | 1172 { |
896 /* Obsolete, to be removed from libpng-1.4.0 */ | 1173 return (png_ptr ? png_ptr->user_height_max : 0); |
897 PNG_UNUSED(flag_select) | |
898 return 0L; | |
899 } | 1174 } |
900 | 1175 |
901 /* GRR: could add this: && defined(PNG_MMX_CODE_SUPPORTED) */ | 1176 /* This function was added to libpng 1.4.0 */ |
902 /* This function was added to libpng 1.2.0 */ | |
903 png_uint_32 PNGAPI | 1177 png_uint_32 PNGAPI |
904 png_get_mmx_flagmask (int flag_select, int *compilerID) | 1178 png_get_chunk_cache_max (png_const_structrp png_ptr) |
905 { | 1179 { |
906 /* Obsolete, to be removed from libpng-1.4.0 */ | 1180 return (png_ptr ? png_ptr->user_chunk_cache_max : 0); |
907 PNG_UNUSED(flag_select) | |
908 *compilerID = -1; /* unknown (i.e., no asm/MMX code compiled) */ | |
909 return 0L; | |
910 } | 1181 } |
911 | 1182 |
912 /* This function was added to libpng 1.2.0 */ | 1183 /* This function was added to libpng 1.4.1 */ |
913 png_byte PNGAPI | 1184 png_alloc_size_t PNGAPI |
914 png_get_mmx_bitdepth_threshold (png_structp png_ptr) | 1185 png_get_chunk_malloc_max (png_const_structrp png_ptr) |
915 { | 1186 { |
916 /* Obsolete, to be removed from libpng-1.4.0 */ | 1187 return (png_ptr ? png_ptr->user_chunk_malloc_max : 0); |
917 PNG_UNUSED(png_ptr) | 1188 } |
918 return 0L; | 1189 #endif /* SET_USER_LIMITS */ |
| 1190 |
| 1191 /* These functions were added to libpng 1.4.0 */ |
| 1192 #ifdef PNG_IO_STATE_SUPPORTED |
| 1193 png_uint_32 PNGAPI |
| 1194 png_get_io_state (png_const_structrp png_ptr) |
| 1195 { |
| 1196 return png_ptr->io_state; |
919 } | 1197 } |
920 | 1198 |
921 /* This function was added to libpng 1.2.0 */ | |
922 png_uint_32 PNGAPI | 1199 png_uint_32 PNGAPI |
923 png_get_mmx_rowbytes_threshold (png_structp png_ptr) | 1200 png_get_io_chunk_type (png_const_structrp png_ptr) |
924 { | 1201 { |
925 /* Obsolete, to be removed from libpng-1.4.0 */ | 1202 return png_ptr->chunk_name; |
926 PNG_UNUSED(png_ptr) | |
927 return 0L; | |
928 } | 1203 } |
929 #endif /* ?PNG_1_0_X */ | 1204 #endif /* IO_STATE */ |
930 #endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */ | |
931 | 1205 |
932 #ifdef PNG_SET_USER_LIMITS_SUPPORTED | 1206 #ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED |
933 /* These functions were added to libpng 1.2.6 but not enabled | 1207 # ifdef PNG_GET_PALETTE_MAX_SUPPORTED |
934 * by default. They will be enabled in libpng-1.4.0 */ | 1208 int PNGAPI |
935 png_uint_32 PNGAPI | 1209 png_get_palette_max(png_const_structp png_ptr, png_const_infop info_ptr) |
936 png_get_user_width_max (png_structp png_ptr) | |
937 { | 1210 { |
938 return (png_ptr? png_ptr->user_width_max : 0); | 1211 if (png_ptr != NULL && info_ptr != NULL) |
| 1212 return png_ptr->num_palette_max; |
| 1213 |
| 1214 return (-1); |
939 } | 1215 } |
940 png_uint_32 PNGAPI | 1216 # endif |
941 png_get_user_height_max (png_structp png_ptr) | 1217 #endif |
942 { | |
943 return (png_ptr? png_ptr->user_height_max : 0); | |
944 } | |
945 #endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */ | |
946 | 1218 |
947 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ | 1219 #endif /* READ || WRITE */ |
OLD | NEW |