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
19png_uint_32 PNGAPI
20png_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
29png_size_t PNGAPI
30png_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
39png_bytepp PNGAPI
40png_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 */
51png_uint_32 PNGAPI
52png_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
60png_uint_32 PNGAPI
61png_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
69png_byte PNGAPI
70png_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
78png_byte PNGAPI
79png_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
87png_byte PNGAPI
88png_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
96png_byte PNGAPI
97png_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
105png_byte PNGAPI
106png_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
114png_uint_32 PNGAPI
115png_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
136png_uint_32 PNGAPI
137png_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
158png_uint_32 PNGAPI
159png_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
180float PNGAPI
181png_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
204png_fixed_point PNGAPI
205png_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
235png_int_32 PNGAPI
236png_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
255png_int_32 PNGAPI
256png_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
275png_int_32 PNGAPI
276png_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
295png_int_32 PNGAPI
296png_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
316static png_uint_32
317ppi_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
348png_uint_32 PNGAPI
349png_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
354png_uint_32 PNGAPI
355png_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
360png_uint_32 PNGAPI
361png_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
367static png_fixed_point
368png_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
378png_fixed_point PNGAPI
379png_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
388png_fixed_point PNGAPI
389png_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
398float PNGAPI
399png_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
409float PNGAPI
410png_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
420png_uint_32 PNGAPI
421png_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
466png_byte PNGAPI
467png_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
476png_const_bytep PNGAPI
477png_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
487png_uint_32 PNGAPI
488png_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
511png_uint_32 PNGAPI
512png_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
557png_uint_32 PNGAPI
558png_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
603png_uint_32 PNGAPI
604png_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
640png_uint_32 PNGAPI
641png_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
677png_uint_32 PNGAPI
678png_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
696png_uint_32 PNGAPI
697png_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
717png_uint_32 PNGAPI
718png_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
735png_uint_32 PNGAPI
736png_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
762int PNGAPI
763png_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
777png_uint_32 PNGAPI
778png_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
794png_uint_32 PNGAPI
795png_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
839png_uint_32 PNGAPI
840png_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
860png_uint_32 PNGAPI
861png_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)
890png_uint_32 PNGAPI
891png_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
913png_uint_32 PNGAPI
914png_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 */
929png_uint_32 PNGAPI
930png_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
947png_uint_32 PNGAPI
948png_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
981png_uint_32 PNGAPI
982png_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
1000png_uint_32 PNGAPI
1001png_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
1018int PNGAPI
1019png_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
1044png_uint_32 PNGAPI
1045png_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
1062png_uint_32 PNGAPI
1063png_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
1108int PNGAPI
1109png_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
1123png_byte PNGAPI
1124png_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
1131png_voidp PNGAPI
1132png_get_user_chunk_ptr(png_const_structrp png_ptr)
1133{
1134   return (png_ptr ? png_ptr->user_chunk_ptr : NULL);
1135}
1136#endif
1137
1138png_size_t PNGAPI
1139png_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 */
1164png_uint_32 PNGAPI
1165png_get_user_width_max (png_const_structrp png_ptr)
1166{
1167   return (png_ptr ? png_ptr->user_width_max : 0);
1168}
1169
1170png_uint_32 PNGAPI
1171png_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 */
1177png_uint_32 PNGAPI
1178png_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 */
1184png_alloc_size_t PNGAPI
1185png_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
1193png_uint_32 PNGAPI
1194png_get_io_state (png_const_structrp png_ptr)
1195{
1196   return png_ptr->io_state;
1197}
1198
1199png_uint_32 PNGAPI
1200png_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
1208int PNGAPI
1209png_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