OLD | NEW |
| (Empty) |
1 | |
2 /* pngget.c - retrieval of values from info struct | |
3 * | |
4 * Last changed in libpng 1.6.17 [March 26, 2015] | |
5 * Copyright (c) 1998-2015 Glenn Randers-Pehrson | |
6 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) | |
7 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) | |
8 * | |
9 * This code is released under the libpng license. | |
10 * For conditions of distribution and use, see the disclaimer | |
11 * and license in png.h | |
12 * | |
13 */ | |
14 | |
15 #include "pngpriv.h" | |
16 | |
17 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) | |
18 | |
19 png_uint_32 PNGAPI | |
20 png_get_valid(png_const_structrp png_ptr, png_const_inforp info_ptr, | |
21 png_uint_32 flag) | |
22 { | |
23 if (png_ptr != NULL && info_ptr != NULL) | |
24 return(info_ptr->valid & flag); | |
25 | |
26 return(0); | |
27 } | |
28 | |
29 png_size_t PNGAPI | |
30 png_get_rowbytes(png_const_structrp png_ptr, png_const_inforp info_ptr) | |
31 { | |
32 if (png_ptr != NULL && info_ptr != NULL) | |
33 return(info_ptr->rowbytes); | |
34 | |
35 return(0); | |
36 } | |
37 | |
38 #ifdef PNG_INFO_IMAGE_SUPPORTED | |
39 png_bytepp PNGAPI | |
40 png_get_rows(png_const_structrp png_ptr, png_const_inforp info_ptr) | |
41 { | |
42 if (png_ptr != NULL && info_ptr != NULL) | |
43 return(info_ptr->row_pointers); | |
44 | |
45 return(0); | |
46 } | |
47 #endif | |
48 | |
49 #ifdef PNG_EASY_ACCESS_SUPPORTED | |
50 /* Easy access to info, added in libpng-0.99 */ | |
51 png_uint_32 PNGAPI | |
52 png_get_image_width(png_const_structrp png_ptr, png_const_inforp info_ptr) | |
53 { | |
54 if (png_ptr != NULL && info_ptr != NULL) | |
55 return info_ptr->width; | |
56 | |
57 return (0); | |
58 } | |
59 | |
60 png_uint_32 PNGAPI | |
61 png_get_image_height(png_const_structrp png_ptr, png_const_inforp info_ptr) | |
62 { | |
63 if (png_ptr != NULL && info_ptr != NULL) | |
64 return info_ptr->height; | |
65 | |
66 return (0); | |
67 } | |
68 | |
69 png_byte PNGAPI | |
70 png_get_bit_depth(png_const_structrp png_ptr, png_const_inforp info_ptr) | |
71 { | |
72 if (png_ptr != NULL && info_ptr != NULL) | |
73 return info_ptr->bit_depth; | |
74 | |
75 return (0); | |
76 } | |
77 | |
78 png_byte PNGAPI | |
79 png_get_color_type(png_const_structrp png_ptr, png_const_inforp info_ptr) | |
80 { | |
81 if (png_ptr != NULL && info_ptr != NULL) | |
82 return info_ptr->color_type; | |
83 | |
84 return (0); | |
85 } | |
86 | |
87 png_byte PNGAPI | |
88 png_get_filter_type(png_const_structrp png_ptr, png_const_inforp info_ptr) | |
89 { | |
90 if (png_ptr != NULL && info_ptr != NULL) | |
91 return info_ptr->filter_type; | |
92 | |
93 return (0); | |
94 } | |
95 | |
96 png_byte PNGAPI | |
97 png_get_interlace_type(png_const_structrp png_ptr, png_const_inforp info_ptr) | |
98 { | |
99 if (png_ptr != NULL && info_ptr != NULL) | |
100 return info_ptr->interlace_type; | |
101 | |
102 return (0); | |
103 } | |
104 | |
105 png_byte PNGAPI | |
106 png_get_compression_type(png_const_structrp png_ptr, png_const_inforp info_ptr) | |
107 { | |
108 if (png_ptr != NULL && info_ptr != NULL) | |
109 return info_ptr->compression_type; | |
110 | |
111 return (0); | |
112 } | |
113 | |
114 png_uint_32 PNGAPI | |
115 png_get_x_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp | |
116 info_ptr) | |
117 { | |
118 #ifdef PNG_pHYs_SUPPORTED | |
119 if (png_ptr != NULL && info_ptr != NULL && | |
120 (info_ptr->valid & PNG_INFO_pHYs) != 0) | |
121 { | |
122 png_debug1(1, "in %s retrieval function", | |
123 "png_get_x_pixels_per_meter"); | |
124 | |
125 if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER) | |
126 return (info_ptr->x_pixels_per_unit); | |
127 } | |
128 #else | |
129 PNG_UNUSED(png_ptr) | |
130 PNG_UNUSED(info_ptr) | |
131 #endif | |
132 | |
133 return (0); | |
134 } | |
135 | |
136 png_uint_32 PNGAPI | |
137 png_get_y_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp | |
138 info_ptr) | |
139 { | |
140 #ifdef PNG_pHYs_SUPPORTED | |
141 if (png_ptr != NULL && info_ptr != NULL && | |
142 (info_ptr->valid & PNG_INFO_pHYs) != 0) | |
143 { | |
144 png_debug1(1, "in %s retrieval function", | |
145 "png_get_y_pixels_per_meter"); | |
146 | |
147 if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER) | |
148 return (info_ptr->y_pixels_per_unit); | |
149 } | |
150 #else | |
151 PNG_UNUSED(png_ptr) | |
152 PNG_UNUSED(info_ptr) | |
153 #endif | |
154 | |
155 return (0); | |
156 } | |
157 | |
158 png_uint_32 PNGAPI | |
159 png_get_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp info_ptr) | |
160 { | |
161 #ifdef PNG_pHYs_SUPPORTED | |
162 if (png_ptr != NULL && info_ptr != NULL && | |
163 (info_ptr->valid & PNG_INFO_pHYs) != 0) | |
164 { | |
165 png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter"); | |
166 | |
167 if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER && | |
168 info_ptr->x_pixels_per_unit == info_ptr->y_pixels_per_unit) | |
169 return (info_ptr->x_pixels_per_unit); | |
170 } | |
171 #else | |
172 PNG_UNUSED(png_ptr) | |
173 PNG_UNUSED(info_ptr) | |
174 #endif | |
175 | |
176 return (0); | |
177 } | |
178 | |
179 #ifdef PNG_FLOATING_POINT_SUPPORTED | |
180 float PNGAPI | |
181 png_get_pixel_aspect_ratio(png_const_structrp png_ptr, png_const_inforp | |
182 info_ptr) | |
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 | |
419 #ifdef PNG_pHYs_SUPPORTED | |
420 png_uint_32 PNGAPI | |
421 png_get_pHYs_dpi(png_const_structrp png_ptr, png_const_inforp info_ptr, | |
422 png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) | |
423 { | |
424 png_uint_32 retval = 0; | |
425 | |
426 if (png_ptr != NULL && info_ptr != NULL && | |
427 (info_ptr->valid & PNG_INFO_pHYs) != 0) | |
428 { | |
429 png_debug1(1, "in %s retrieval function", "pHYs"); | |
430 | |
431 if (res_x != NULL) | |
432 { | |
433 *res_x = info_ptr->x_pixels_per_unit; | |
434 retval |= PNG_INFO_pHYs; | |
435 } | |
436 | |
437 if (res_y != NULL) | |
438 { | |
439 *res_y = info_ptr->y_pixels_per_unit; | |
440 retval |= PNG_INFO_pHYs; | |
441 } | |
442 | |
443 if (unit_type != NULL) | |
444 { | |
445 *unit_type = (int)info_ptr->phys_unit_type; | |
446 retval |= PNG_INFO_pHYs; | |
447 | |
448 if (*unit_type == 1) | |
449 { | |
450 if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50); | |
451 if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50); | |
452 } | |
453 } | |
454 } | |
455 | |
456 return (retval); | |
457 } | |
458 #endif /* pHYs */ | |
459 #endif /* INCH_CONVERSIONS */ | |
460 | |
461 /* png_get_channels really belongs in here, too, but it's been around longer */ | |
462 | |
463 #endif /* EASY_ACCESS */ | |
464 | |
465 | |
466 png_byte PNGAPI | |
467 png_get_channels(png_const_structrp png_ptr, png_const_inforp info_ptr) | |
468 { | |
469 if (png_ptr != NULL && info_ptr != NULL) | |
470 return(info_ptr->channels); | |
471 | |
472 return (0); | |
473 } | |
474 | |
475 #ifdef PNG_READ_SUPPORTED | |
476 png_const_bytep PNGAPI | |
477 png_get_signature(png_const_structrp png_ptr, png_const_inforp info_ptr) | |
478 { | |
479 if (png_ptr != NULL && info_ptr != NULL) | |
480 return(info_ptr->signature); | |
481 | |
482 return (NULL); | |
483 } | |
484 #endif | |
485 | |
486 #ifdef PNG_bKGD_SUPPORTED | |
487 png_uint_32 PNGAPI | |
488 png_get_bKGD(png_const_structrp png_ptr, png_inforp info_ptr, | |
489 png_color_16p *background) | |
490 { | |
491 if (png_ptr != NULL && info_ptr != NULL && | |
492 (info_ptr->valid & PNG_INFO_bKGD) != 0 && | |
493 background != NULL) | |
494 { | |
495 png_debug1(1, "in %s retrieval function", "bKGD"); | |
496 | |
497 *background = &(info_ptr->background); | |
498 return (PNG_INFO_bKGD); | |
499 } | |
500 | |
501 return (0); | |
502 } | |
503 #endif | |
504 | |
505 #ifdef PNG_cHRM_SUPPORTED | |
506 /* The XYZ APIs were added in 1.5.5 to take advantage of the code added at the | |
507 * same time to correct the rgb grayscale coefficient defaults obtained from the | |
508 * cHRM chunk in 1.5.4 | |
509 */ | |
510 # ifdef PNG_FLOATING_POINT_SUPPORTED | |
511 png_uint_32 PNGAPI | |
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) | |
524 { | |
525 png_debug1(1, "in %s retrieval function", "cHRM"); | |
526 | |
527 if (white_x != NULL) | |
528 *white_x = png_float(png_ptr, | |
529 info_ptr->colorspace.end_points_xy.whitex, "cHRM white X"); | |
530 if (white_y != NULL) | |
531 *white_y = png_float(png_ptr, | |
532 info_ptr->colorspace.end_points_xy.whitey, "cHRM white Y"); | |
533 if (red_x != NULL) | |
534 *red_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redx, | |
535 "cHRM red X"); | |
536 if (red_y != NULL) | |
537 *red_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redy, | |
538 "cHRM red Y"); | |
539 if (green_x != NULL) | |
540 *green_x = png_float(png_ptr, | |
541 info_ptr->colorspace.end_points_xy.greenx, "cHRM green X"); | |
542 if (green_y != NULL) | |
543 *green_y = png_float(png_ptr, | |
544 info_ptr->colorspace.end_points_xy.greeny, "cHRM green Y"); | |
545 if (blue_x != NULL) | |
546 *blue_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluex, | |
547 "cHRM blue X"); | |
548 if (blue_y != NULL) | |
549 *blue_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluey, | |
550 "cHRM blue Y"); | |
551 return (PNG_INFO_cHRM); | |
552 } | |
553 | |
554 return (0); | |
555 } | |
556 | |
557 png_uint_32 PNGAPI | |
558 png_get_cHRM_XYZ(png_const_structrp png_ptr, png_const_inforp info_ptr, | |
559 double *red_X, double *red_Y, double *red_Z, double *green_X, | |
560 double *green_Y, double *green_Z, double *blue_X, double *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) | |
645 { | |
646 png_debug1(1, "in %s retrieval function", "cHRM"); | |
647 | |
648 if (png_ptr != NULL && info_ptr != NULL && | |
649 (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0) | |
650 { | |
651 if (white_x != NULL) | |
652 *white_x = info_ptr->colorspace.end_points_xy.whitex; | |
653 if (white_y != NULL) | |
654 *white_y = info_ptr->colorspace.end_points_xy.whitey; | |
655 if (red_x != NULL) | |
656 *red_x = info_ptr->colorspace.end_points_xy.redx; | |
657 if (red_y != NULL) | |
658 *red_y = info_ptr->colorspace.end_points_xy.redy; | |
659 if (green_x != NULL) | |
660 *green_x = info_ptr->colorspace.end_points_xy.greenx; | |
661 if (green_y != NULL) | |
662 *green_y = info_ptr->colorspace.end_points_xy.greeny; | |
663 if (blue_x != NULL) | |
664 *blue_x = info_ptr->colorspace.end_points_xy.bluex; | |
665 if (blue_y != NULL) | |
666 *blue_y = info_ptr->colorspace.end_points_xy.bluey; | |
667 return (PNG_INFO_cHRM); | |
668 } | |
669 | |
670 return (0); | |
671 } | |
672 # endif | |
673 #endif | |
674 | |
675 #ifdef PNG_gAMA_SUPPORTED | |
676 # ifdef PNG_FIXED_POINT_SUPPORTED | |
677 png_uint_32 PNGAPI | |
678 png_get_gAMA_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr, | |
679 png_fixed_point *file_gamma) | |
680 { | |
681 png_debug1(1, "in %s retrieval function", "gAMA"); | |
682 | |
683 if (png_ptr != NULL && info_ptr != NULL && | |
684 (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 && | |
685 file_gamma != NULL) | |
686 { | |
687 *file_gamma = info_ptr->colorspace.gamma; | |
688 return (PNG_INFO_gAMA); | |
689 } | |
690 | |
691 return (0); | |
692 } | |
693 # endif | |
694 | |
695 # ifdef PNG_FLOATING_POINT_SUPPORTED | |
696 png_uint_32 PNGAPI | |
697 png_get_gAMA(png_const_structrp png_ptr, png_const_inforp info_ptr, | |
698 double *file_gamma) | |
699 { | |
700 png_debug1(1, "in %s retrieval function", "gAMA(float)"); | |
701 | |
702 if (png_ptr != NULL && info_ptr != NULL && | |
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"); | |
708 return (PNG_INFO_gAMA); | |
709 } | |
710 | |
711 return (0); | |
712 } | |
713 # endif | |
714 #endif | |
715 | |
716 #ifdef PNG_sRGB_SUPPORTED | |
717 png_uint_32 PNGAPI | |
718 png_get_sRGB(png_const_structrp png_ptr, png_const_inforp info_ptr, | |
719 int *file_srgb_intent) | |
720 { | |
721 png_debug1(1, "in %s retrieval function", "sRGB"); | |
722 | |
723 if (png_ptr != NULL && info_ptr != NULL && | |
724 (info_ptr->valid & PNG_INFO_sRGB) != 0 && file_srgb_intent != NULL) | |
725 { | |
726 *file_srgb_intent = info_ptr->colorspace.rendering_intent; | |
727 return (PNG_INFO_sRGB); | |
728 } | |
729 | |
730 return (0); | |
731 } | |
732 #endif | |
733 | |
734 #ifdef PNG_iCCP_SUPPORTED | |
735 png_uint_32 PNGAPI | |
736 png_get_iCCP(png_const_structrp png_ptr, png_inforp info_ptr, | |
737 png_charpp name, int *compression_type, | |
738 png_bytepp profile, png_uint_32 *proflen) | |
739 { | |
740 png_debug1(1, "in %s retrieval function", "iCCP"); | |
741 | |
742 if (png_ptr != NULL && info_ptr != NULL && | |
743 (info_ptr->valid & PNG_INFO_iCCP) != 0 && | |
744 name != NULL && compression_type != NULL && profile != NULL && | |
745 proflen != NULL) | |
746 { | |
747 *name = info_ptr->iccp_name; | |
748 *profile = info_ptr->iccp_profile; | |
749 *proflen = png_get_uint_32(info_ptr->iccp_profile); | |
750 /* This is somewhat irrelevant since the profile data returned has | |
751 * actually been uncompressed. | |
752 */ | |
753 *compression_type = PNG_COMPRESSION_TYPE_BASE; | |
754 return (PNG_INFO_iCCP); | |
755 } | |
756 | |
757 return (0); | |
758 } | |
759 #endif | |
760 | |
761 #ifdef PNG_sPLT_SUPPORTED | |
762 int PNGAPI | |
763 png_get_sPLT(png_const_structrp png_ptr, png_inforp info_ptr, | |
764 png_sPLT_tpp spalettes) | |
765 { | |
766 if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL) | |
767 { | |
768 *spalettes = info_ptr->splt_palettes; | |
769 return info_ptr->splt_palettes_num; | |
770 } | |
771 | |
772 return (0); | |
773 } | |
774 #endif | |
775 | |
776 #ifdef PNG_hIST_SUPPORTED | |
777 png_uint_32 PNGAPI | |
778 png_get_hIST(png_const_structrp png_ptr, png_inforp info_ptr, | |
779 png_uint_16p *hist) | |
780 { | |
781 png_debug1(1, "in %s retrieval function", "hIST"); | |
782 | |
783 if (png_ptr != NULL && info_ptr != NULL && | |
784 (info_ptr->valid & PNG_INFO_hIST) != 0 && hist != NULL) | |
785 { | |
786 *hist = info_ptr->hist; | |
787 return (PNG_INFO_hIST); | |
788 } | |
789 | |
790 return (0); | |
791 } | |
792 #endif | |
793 | |
794 png_uint_32 PNGAPI | |
795 png_get_IHDR(png_const_structrp png_ptr, png_const_inforp info_ptr, | |
796 png_uint_32 *width, png_uint_32 *height, int *bit_depth, | |
797 int *color_type, int *interlace_type, int *compression_type, | |
798 int *filter_type) | |
799 { | |
800 png_debug1(1, "in %s retrieval function", "IHDR"); | |
801 | |
802 if (png_ptr == NULL || info_ptr == NULL) | |
803 return (0); | |
804 | |
805 if (width != NULL) | |
806 *width = info_ptr->width; | |
807 | |
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; | |
816 | |
817 if (compression_type != NULL) | |
818 *compression_type = info_ptr->compression_type; | |
819 | |
820 if (filter_type != NULL) | |
821 *filter_type = info_ptr->filter_type; | |
822 | |
823 if (interlace_type != NULL) | |
824 *interlace_type = info_ptr->interlace_type; | |
825 | |
826 /* This is redundant if we can be sure that the info_ptr values were all | |
827 * assigned in png_set_IHDR(). We do the check anyhow in case an | |
828 * application has ignored our advice not to mess with the members | |
829 * of info_ptr directly. | |
830 */ | |
831 png_check_IHDR(png_ptr, info_ptr->width, info_ptr->height, | |
832 info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type, | |
833 info_ptr->compression_type, info_ptr->filter_type); | |
834 | |
835 return (1); | |
836 } | |
837 | |
838 #ifdef PNG_oFFs_SUPPORTED | |
839 png_uint_32 PNGAPI | |
840 png_get_oFFs(png_const_structrp png_ptr, png_const_inforp info_ptr, | |
841 png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type) | |
842 { | |
843 png_debug1(1, "in %s retrieval function", "oFFs"); | |
844 | |
845 if (png_ptr != NULL && info_ptr != NULL && | |
846 (info_ptr->valid & PNG_INFO_oFFs) != 0 && | |
847 offset_x != NULL && offset_y != NULL && unit_type != NULL) | |
848 { | |
849 *offset_x = info_ptr->x_offset; | |
850 *offset_y = info_ptr->y_offset; | |
851 *unit_type = (int)info_ptr->offset_unit_type; | |
852 return (PNG_INFO_oFFs); | |
853 } | |
854 | |
855 return (0); | |
856 } | |
857 #endif | |
858 | |
859 #ifdef PNG_pCAL_SUPPORTED | |
860 png_uint_32 PNGAPI | |
861 png_get_pCAL(png_const_structrp png_ptr, png_inforp info_ptr, | |
862 png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams, | |
863 png_charp *units, png_charpp *params) | |
864 { | |
865 png_debug1(1, "in %s retrieval function", "pCAL"); | |
866 | |
867 if (png_ptr != NULL && info_ptr != NULL && | |
868 (info_ptr->valid & PNG_INFO_pCAL) != 0 && | |
869 purpose != NULL && X0 != NULL && X1 != NULL && type != NULL && | |
870 nparams != NULL && units != NULL && params != NULL) | |
871 { | |
872 *purpose = info_ptr->pcal_purpose; | |
873 *X0 = info_ptr->pcal_X0; | |
874 *X1 = info_ptr->pcal_X1; | |
875 *type = (int)info_ptr->pcal_type; | |
876 *nparams = (int)info_ptr->pcal_nparams; | |
877 *units = info_ptr->pcal_units; | |
878 *params = info_ptr->pcal_params; | |
879 return (PNG_INFO_pCAL); | |
880 } | |
881 | |
882 return (0); | |
883 } | |
884 #endif | |
885 | |
886 #ifdef PNG_sCAL_SUPPORTED | |
887 # ifdef PNG_FIXED_POINT_SUPPORTED | |
888 # if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || \ | |
889 defined(PNG_FLOATING_POINT_SUPPORTED) | |
890 png_uint_32 PNGAPI | |
891 png_get_sCAL_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr, | |
892 int *unit, png_fixed_point *width, png_fixed_point *height) | |
893 { | |
894 if (png_ptr != NULL && info_ptr != NULL && | |
895 (info_ptr->valid & PNG_INFO_sCAL) != 0) | |
896 { | |
897 *unit = info_ptr->scal_unit; | |
898 /*TODO: make this work without FP support; the API is currently eliminated | |
899 * if neither floating point APIs nor internal floating point arithmetic | |
900 * are enabled. | |
901 */ | |
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); | |
909 } | |
910 # endif /* FLOATING_ARITHMETIC */ | |
911 # endif /* FIXED_POINT */ | |
912 # ifdef PNG_FLOATING_POINT_SUPPORTED | |
913 png_uint_32 PNGAPI | |
914 png_get_sCAL(png_const_structrp png_ptr, png_const_inforp info_ptr, | |
915 int *unit, double *width, double *height) | |
916 { | |
917 if (png_ptr != NULL && info_ptr != NULL && | |
918 (info_ptr->valid & PNG_INFO_sCAL) != 0) | |
919 { | |
920 *unit = info_ptr->scal_unit; | |
921 *width = atof(info_ptr->scal_s_width); | |
922 *height = atof(info_ptr->scal_s_height); | |
923 return (PNG_INFO_sCAL); | |
924 } | |
925 | |
926 return(0); | |
927 } | |
928 # endif /* FLOATING POINT */ | |
929 png_uint_32 PNGAPI | |
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 */ | |
945 | |
946 #ifdef PNG_pHYs_SUPPORTED | |
947 png_uint_32 PNGAPI | |
948 png_get_pHYs(png_const_structrp png_ptr, png_const_inforp info_ptr, | |
949 png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) | |
950 { | |
951 png_uint_32 retval = 0; | |
952 | |
953 png_debug1(1, "in %s retrieval function", "pHYs"); | |
954 | |
955 if (png_ptr != NULL && info_ptr != NULL && | |
956 (info_ptr->valid & PNG_INFO_pHYs) != 0) | |
957 { | |
958 if (res_x != NULL) | |
959 { | |
960 *res_x = info_ptr->x_pixels_per_unit; | |
961 retval |= PNG_INFO_pHYs; | |
962 } | |
963 | |
964 if (res_y != NULL) | |
965 { | |
966 *res_y = info_ptr->y_pixels_per_unit; | |
967 retval |= PNG_INFO_pHYs; | |
968 } | |
969 | |
970 if (unit_type != NULL) | |
971 { | |
972 *unit_type = (int)info_ptr->phys_unit_type; | |
973 retval |= PNG_INFO_pHYs; | |
974 } | |
975 } | |
976 | |
977 return (retval); | |
978 } | |
979 #endif /* pHYs */ | |
980 | |
981 png_uint_32 PNGAPI | |
982 png_get_PLTE(png_const_structrp png_ptr, png_inforp info_ptr, | |
983 png_colorp *palette, int *num_palette) | |
984 { | |
985 png_debug1(1, "in %s retrieval function", "PLTE"); | |
986 | |
987 if (png_ptr != NULL && info_ptr != NULL && | |
988 (info_ptr->valid & PNG_INFO_PLTE) != 0 && palette != NULL) | |
989 { | |
990 *palette = info_ptr->palette; | |
991 *num_palette = info_ptr->num_palette; | |
992 png_debug1(3, "num_palette = %d", *num_palette); | |
993 return (PNG_INFO_PLTE); | |
994 } | |
995 | |
996 return (0); | |
997 } | |
998 | |
999 #ifdef PNG_sBIT_SUPPORTED | |
1000 png_uint_32 PNGAPI | |
1001 png_get_sBIT(png_const_structrp png_ptr, png_inforp info_ptr, | |
1002 png_color_8p *sig_bit) | |
1003 { | |
1004 png_debug1(1, "in %s retrieval function", "sBIT"); | |
1005 | |
1006 if (png_ptr != NULL && info_ptr != NULL && | |
1007 (info_ptr->valid & PNG_INFO_sBIT) != 0 && sig_bit != NULL) | |
1008 { | |
1009 *sig_bit = &(info_ptr->sig_bit); | |
1010 return (PNG_INFO_sBIT); | |
1011 } | |
1012 | |
1013 return (0); | |
1014 } | |
1015 #endif | |
1016 | |
1017 #ifdef PNG_TEXT_SUPPORTED | |
1018 int PNGAPI | |
1019 png_get_text(png_const_structrp png_ptr, png_inforp info_ptr, | |
1020 png_textp *text_ptr, int *num_text) | |
1021 { | |
1022 if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0) | |
1023 { | |
1024 png_debug1(1, "in 0x%lx retrieval function", | |
1025 (unsigned long)png_ptr->chunk_name); | |
1026 | |
1027 if (text_ptr != NULL) | |
1028 *text_ptr = info_ptr->text; | |
1029 | |
1030 if (num_text != NULL) | |
1031 *num_text = info_ptr->num_text; | |
1032 | |
1033 return info_ptr->num_text; | |
1034 } | |
1035 | |
1036 if (num_text != NULL) | |
1037 *num_text = 0; | |
1038 | |
1039 return(0); | |
1040 } | |
1041 #endif | |
1042 | |
1043 #ifdef PNG_tIME_SUPPORTED | |
1044 png_uint_32 PNGAPI | |
1045 png_get_tIME(png_const_structrp png_ptr, png_inforp info_ptr, | |
1046 png_timep *mod_time) | |
1047 { | |
1048 png_debug1(1, "in %s retrieval function", "tIME"); | |
1049 | |
1050 if (png_ptr != NULL && info_ptr != NULL && | |
1051 (info_ptr->valid & PNG_INFO_tIME) != 0 && mod_time != NULL) | |
1052 { | |
1053 *mod_time = &(info_ptr->mod_time); | |
1054 return (PNG_INFO_tIME); | |
1055 } | |
1056 | |
1057 return (0); | |
1058 } | |
1059 #endif | |
1060 | |
1061 #ifdef PNG_tRNS_SUPPORTED | |
1062 png_uint_32 PNGAPI | |
1063 png_get_tRNS(png_const_structrp png_ptr, png_inforp info_ptr, | |
1064 png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color) | |
1065 { | |
1066 png_uint_32 retval = 0; | |
1067 if (png_ptr != NULL && info_ptr != NULL && | |
1068 (info_ptr->valid & PNG_INFO_tRNS) != 0) | |
1069 { | |
1070 png_debug1(1, "in %s retrieval function", "tRNS"); | |
1071 | |
1072 if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) | |
1073 { | |
1074 if (trans_alpha != NULL) | |
1075 { | |
1076 *trans_alpha = info_ptr->trans_alpha; | |
1077 retval |= PNG_INFO_tRNS; | |
1078 } | |
1079 | |
1080 if (trans_color != NULL) | |
1081 *trans_color = &(info_ptr->trans_color); | |
1082 } | |
1083 | |
1084 else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */ | |
1085 { | |
1086 if (trans_color != NULL) | |
1087 { | |
1088 *trans_color = &(info_ptr->trans_color); | |
1089 retval |= PNG_INFO_tRNS; | |
1090 } | |
1091 | |
1092 if (trans_alpha != NULL) | |
1093 *trans_alpha = NULL; | |
1094 } | |
1095 | |
1096 if (num_trans != NULL) | |
1097 { | |
1098 *num_trans = info_ptr->num_trans; | |
1099 retval |= PNG_INFO_tRNS; | |
1100 } | |
1101 } | |
1102 | |
1103 return (retval); | |
1104 } | |
1105 #endif | |
1106 | |
1107 #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED | |
1108 int PNGAPI | |
1109 png_get_unknown_chunks(png_const_structrp png_ptr, png_inforp info_ptr, | |
1110 png_unknown_chunkpp unknowns) | |
1111 { | |
1112 if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL) | |
1113 { | |
1114 *unknowns = info_ptr->unknown_chunks; | |
1115 return info_ptr->unknown_chunks_num; | |
1116 } | |
1117 | |
1118 return (0); | |
1119 } | |
1120 #endif | |
1121 | |
1122 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED | |
1123 png_byte PNGAPI | |
1124 png_get_rgb_to_gray_status (png_const_structrp png_ptr) | |
1125 { | |
1126 return (png_byte)(png_ptr ? png_ptr->rgb_to_gray_status : 0); | |
1127 } | |
1128 #endif | |
1129 | |
1130 #ifdef PNG_USER_CHUNKS_SUPPORTED | |
1131 png_voidp PNGAPI | |
1132 png_get_user_chunk_ptr(png_const_structrp png_ptr) | |
1133 { | |
1134 return (png_ptr ? png_ptr->user_chunk_ptr : NULL); | |
1135 } | |
1136 #endif | |
1137 | |
1138 png_size_t PNGAPI | |
1139 png_get_compression_buffer_size(png_const_structrp png_ptr) | |
1140 { | |
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 | |
1159 } | |
1160 | |
1161 #ifdef PNG_SET_USER_LIMITS_SUPPORTED | |
1162 /* These functions were added to libpng 1.2.6 and were enabled | |
1163 * by default in libpng-1.4.0 */ | |
1164 png_uint_32 PNGAPI | |
1165 png_get_user_width_max (png_const_structrp png_ptr) | |
1166 { | |
1167 return (png_ptr ? png_ptr->user_width_max : 0); | |
1168 } | |
1169 | |
1170 png_uint_32 PNGAPI | |
1171 png_get_user_height_max (png_const_structrp png_ptr) | |
1172 { | |
1173 return (png_ptr ? png_ptr->user_height_max : 0); | |
1174 } | |
1175 | |
1176 /* This function was added to libpng 1.4.0 */ | |
1177 png_uint_32 PNGAPI | |
1178 png_get_chunk_cache_max (png_const_structrp png_ptr) | |
1179 { | |
1180 return (png_ptr ? png_ptr->user_chunk_cache_max : 0); | |
1181 } | |
1182 | |
1183 /* This function was added to libpng 1.4.1 */ | |
1184 png_alloc_size_t PNGAPI | |
1185 png_get_chunk_malloc_max (png_const_structrp png_ptr) | |
1186 { | |
1187 return (png_ptr ? png_ptr->user_chunk_malloc_max : 0); | |
1188 } | |
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; | |
1197 } | |
1198 | |
1199 png_uint_32 PNGAPI | |
1200 png_get_io_chunk_type (png_const_structrp png_ptr) | |
1201 { | |
1202 return png_ptr->chunk_name; | |
1203 } | |
1204 #endif /* IO_STATE */ | |
1205 | |
1206 #ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED | |
1207 # ifdef PNG_GET_PALETTE_MAX_SUPPORTED | |
1208 int PNGAPI | |
1209 png_get_palette_max(png_const_structp png_ptr, png_const_infop info_ptr) | |
1210 { | |
1211 if (png_ptr != NULL && info_ptr != NULL) | |
1212 return png_ptr->num_palette_max; | |
1213 | |
1214 return (-1); | |
1215 } | |
1216 # endif | |
1217 #endif | |
1218 | |
1219 #endif /* READ || WRITE */ | |
OLD | NEW |