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-2002,2004,2006-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
png_get_valid(png_const_structrp png_ptr,png_const_inforp info_ptr,png_uint_32 flag)20 png_get_valid(png_const_structrp png_ptr, png_const_inforp info_ptr,
21     png_uint_32 flag)
22 {
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
png_get_rowbytes(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_rows(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_image_width(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_image_height(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_bit_depth(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_color_type(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_filter_type(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_interlace_type(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_compression_type(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_x_pixels_per_meter(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_y_pixels_per_meter(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_pixels_per_meter(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_pixel_aspect_ratio(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_pixel_aspect_ratio_fixed(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_x_offset_microns(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_y_offset_microns(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_x_offset_pixels(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_y_offset_pixels(png_const_structrp png_ptr,png_const_inforp info_ptr)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
ppi_from_ppm(png_uint_32 ppm)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
png_get_pixels_per_inch(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_x_pixels_per_inch(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_y_pixels_per_inch(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_fixed_inches_from_microns(png_const_structrp png_ptr,png_int_32 microns)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
png_get_x_offset_inches_fixed(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_y_offset_inches_fixed(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_x_offset_inches(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_y_offset_inches(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_pHYs_dpi(png_const_structrp png_ptr,png_const_inforp info_ptr,png_uint_32 * res_x,png_uint_32 * res_y,int * unit_type)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
png_get_channels(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_signature(png_const_structrp png_ptr,png_const_inforp info_ptr)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
png_get_bKGD(png_const_structrp png_ptr,png_inforp info_ptr,png_color_16p * background)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
png_get_cHRM(png_const_structrp png_ptr,png_const_inforp info_ptr,double * white_x,double * white_y,double * red_x,double * red_y,double * green_x,double * green_y,double * blue_x,double * blue_y)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
png_get_cHRM_XYZ(png_const_structrp png_ptr,png_const_inforp info_ptr,double * red_X,double * red_Y,double * red_Z,double * green_X,double * green_Y,double * green_Z,double * blue_X,double * blue_Y,double * blue_Z)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
png_get_cHRM_XYZ_fixed(png_const_structrp png_ptr,png_const_inforp info_ptr,png_fixed_point * int_red_X,png_fixed_point * int_red_Y,png_fixed_point * int_red_Z,png_fixed_point * int_green_X,png_fixed_point * int_green_Y,png_fixed_point * int_green_Z,png_fixed_point * int_blue_X,png_fixed_point * int_blue_Y,png_fixed_point * int_blue_Z)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
png_get_cHRM_fixed(png_const_structrp png_ptr,png_const_inforp info_ptr,png_fixed_point * white_x,png_fixed_point * white_y,png_fixed_point * red_x,png_fixed_point * red_y,png_fixed_point * green_x,png_fixed_point * green_y,png_fixed_point * blue_x,png_fixed_point * blue_y)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
png_get_gAMA_fixed(png_const_structrp png_ptr,png_const_inforp info_ptr,png_fixed_point * file_gamma)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
png_get_gAMA(png_const_structrp png_ptr,png_const_inforp info_ptr,double * file_gamma)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
png_get_sRGB(png_const_structrp png_ptr,png_const_inforp info_ptr,int * file_srgb_intent)718 png_get_sRGB(png_const_structrp png_ptr, png_const_inforp info_ptr,
719     int *file_srgb_intent)
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
png_get_iCCP(png_const_structrp png_ptr,png_inforp info_ptr,png_charpp name,int * compression_type,png_bytepp profile,png_uint_32 * proflen)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
png_get_sPLT(png_const_structrp png_ptr,png_inforp info_ptr,png_sPLT_tpp spalettes)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
png_get_hIST(png_const_structrp png_ptr,png_inforp info_ptr,png_uint_16p * hist)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
png_get_IHDR(png_const_structrp png_ptr,png_const_inforp info_ptr,png_uint_32 * width,png_uint_32 * height,int * bit_depth,int * color_type,int * interlace_type,int * compression_type,int * filter_type)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
png_get_oFFs(png_const_structrp png_ptr,png_const_inforp info_ptr,png_int_32 * offset_x,png_int_32 * offset_y,int * unit_type)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
png_get_pCAL(png_const_structrp png_ptr,png_inforp info_ptr,png_charp * purpose,png_int_32 * X0,png_int_32 * X1,int * type,int * nparams,png_charp * units,png_charpp * params)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
png_get_sCAL_fixed(png_const_structrp png_ptr,png_const_inforp info_ptr,int * unit,png_fixed_point * width,png_fixed_point * height)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
png_get_sCAL(png_const_structrp png_ptr,png_const_inforp info_ptr,int * unit,double * width,double * height)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
png_get_sCAL_s(png_const_structrp png_ptr,png_const_inforp info_ptr,int * unit,png_charpp width,png_charpp height)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
png_get_pHYs(png_const_structrp png_ptr,png_const_inforp info_ptr,png_uint_32 * res_x,png_uint_32 * res_y,int * unit_type)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
png_get_PLTE(png_const_structrp png_ptr,png_inforp info_ptr,png_colorp * palette,int * num_palette)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
png_get_sBIT(png_const_structrp png_ptr,png_inforp info_ptr,png_color_8p * sig_bit)1001 png_get_sBIT(png_const_structrp png_ptr, png_inforp info_ptr,
1002     png_color_8p *sig_bit)
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
png_get_text(png_const_structrp png_ptr,png_inforp info_ptr,png_textp * text_ptr,int * num_text)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
png_get_tIME(png_const_structrp png_ptr,png_inforp info_ptr,png_timep * mod_time)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
png_get_tRNS(png_const_structrp png_ptr,png_inforp info_ptr,png_bytep * trans_alpha,int * num_trans,png_color_16p * trans_color)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
png_get_unknown_chunks(png_const_structrp png_ptr,png_inforp info_ptr,png_unknown_chunkpp unknowns)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
png_get_rgb_to_gray_status(png_const_structrp png_ptr)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
png_get_user_chunk_ptr(png_const_structrp png_ptr)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
png_get_compression_buffer_size(png_const_structrp png_ptr)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
png_get_user_width_max(png_const_structrp png_ptr)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
png_get_user_height_max(png_const_structrp png_ptr)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
png_get_chunk_cache_max(png_const_structrp png_ptr)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
png_get_chunk_malloc_max(png_const_structrp png_ptr)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
png_get_io_state(png_const_structrp png_ptr)1194 png_get_io_state (png_const_structrp png_ptr)
1195 {
1196    return png_ptr->io_state;
1197 }
1198 
1199 png_uint_32 PNGAPI
png_get_io_chunk_type(png_const_structrp png_ptr)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
png_get_palette_max(png_const_structp png_ptr,png_const_infop info_ptr)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 */
1220