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