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