2 /* pngget.c - retrieval of values from info struct
4 * Copyright (c) 2018 Cosmin Truta
5 * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
6 * Copyright (c) 1996-1997 Andreas Dilger
7 * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
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
17 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
20 png_get_valid(png_const_structrp png_ptr
, png_const_inforp info_ptr
,
23 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
24 return(info_ptr
->valid
& flag
);
30 png_get_rowbytes(png_const_structrp png_ptr
, png_const_inforp info_ptr
)
32 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
33 return(info_ptr
->rowbytes
);
38 #ifdef PNG_INFO_IMAGE_SUPPORTED
40 png_get_rows(png_const_structrp png_ptr
, png_const_inforp info_ptr
)
42 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
43 return(info_ptr
->row_pointers
);
49 #ifdef PNG_EASY_ACCESS_SUPPORTED
50 /* Easy access to info, added in libpng-0.99 */
52 png_get_image_width(png_const_structrp png_ptr
, png_const_inforp info_ptr
)
54 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
55 return info_ptr
->width
;
61 png_get_image_height(png_const_structrp png_ptr
, png_const_inforp info_ptr
)
63 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
64 return info_ptr
->height
;
70 png_get_bit_depth(png_const_structrp png_ptr
, png_const_inforp info_ptr
)
72 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
73 return info_ptr
->bit_depth
;
79 png_get_color_type(png_const_structrp png_ptr
, png_const_inforp info_ptr
)
81 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
82 return info_ptr
->color_type
;
88 png_get_filter_type(png_const_structrp png_ptr
, png_const_inforp info_ptr
)
90 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
91 return info_ptr
->filter_type
;
97 png_get_interlace_type(png_const_structrp png_ptr
, png_const_inforp info_ptr
)
99 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
100 return info_ptr
->interlace_type
;
106 png_get_compression_type(png_const_structrp png_ptr
, png_const_inforp info_ptr
)
108 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
109 return info_ptr
->compression_type
;
115 png_get_x_pixels_per_meter(png_const_structrp png_ptr
, png_const_inforp
118 #ifdef PNG_pHYs_SUPPORTED
119 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
120 (info_ptr
->valid
& PNG_INFO_pHYs
) != 0)
122 png_debug1(1, "in %s retrieval function",
123 "png_get_x_pixels_per_meter");
125 if (info_ptr
->phys_unit_type
== PNG_RESOLUTION_METER
)
126 return (info_ptr
->x_pixels_per_unit
);
137 png_get_y_pixels_per_meter(png_const_structrp png_ptr
, png_const_inforp
140 #ifdef PNG_pHYs_SUPPORTED
141 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
142 (info_ptr
->valid
& PNG_INFO_pHYs
) != 0)
144 png_debug1(1, "in %s retrieval function",
145 "png_get_y_pixels_per_meter");
147 if (info_ptr
->phys_unit_type
== PNG_RESOLUTION_METER
)
148 return (info_ptr
->y_pixels_per_unit
);
159 png_get_pixels_per_meter(png_const_structrp png_ptr
, png_const_inforp info_ptr
)
161 #ifdef PNG_pHYs_SUPPORTED
162 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
163 (info_ptr
->valid
& PNG_INFO_pHYs
) != 0)
165 png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter");
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
);
179 #ifdef PNG_FLOATING_POINT_SUPPORTED
181 png_get_pixel_aspect_ratio(png_const_structrp png_ptr
, png_const_inforp
184 #ifdef PNG_READ_pHYs_SUPPORTED
185 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
186 (info_ptr
->valid
& PNG_INFO_pHYs
) != 0)
188 png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio");
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
));
203 #ifdef PNG_FIXED_POINT_SUPPORTED
204 png_fixed_point PNGAPI
205 png_get_pixel_aspect_ratio_fixed(png_const_structrp png_ptr
,
206 png_const_inforp info_ptr
)
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
)
217 png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio_fixed");
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.
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)
236 png_get_x_offset_microns(png_const_structrp png_ptr
, png_const_inforp info_ptr
)
238 #ifdef PNG_oFFs_SUPPORTED
239 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
240 (info_ptr
->valid
& PNG_INFO_oFFs
) != 0)
242 png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");
244 if (info_ptr
->offset_unit_type
== PNG_OFFSET_MICROMETER
)
245 return (info_ptr
->x_offset
);
256 png_get_y_offset_microns(png_const_structrp png_ptr
, png_const_inforp info_ptr
)
258 #ifdef PNG_oFFs_SUPPORTED
259 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
260 (info_ptr
->valid
& PNG_INFO_oFFs
) != 0)
262 png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");
264 if (info_ptr
->offset_unit_type
== PNG_OFFSET_MICROMETER
)
265 return (info_ptr
->y_offset
);
276 png_get_x_offset_pixels(png_const_structrp png_ptr
, png_const_inforp info_ptr
)
278 #ifdef PNG_oFFs_SUPPORTED
279 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
280 (info_ptr
->valid
& PNG_INFO_oFFs
) != 0)
282 png_debug1(1, "in %s retrieval function", "png_get_x_offset_pixels");
284 if (info_ptr
->offset_unit_type
== PNG_OFFSET_PIXEL
)
285 return (info_ptr
->x_offset
);
296 png_get_y_offset_pixels(png_const_structrp png_ptr
, png_const_inforp info_ptr
)
298 #ifdef PNG_oFFs_SUPPORTED
299 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
300 (info_ptr
->valid
& PNG_INFO_oFFs
) != 0)
302 png_debug1(1, "in %s retrieval function", "png_get_y_offset_pixels");
304 if (info_ptr
->offset_unit_type
== PNG_OFFSET_PIXEL
)
305 return (info_ptr
->y_offset
);
315 #ifdef PNG_INCH_CONVERSIONS_SUPPORTED
317 ppi_from_ppm(png_uint_32 ppm
)
320 /* The conversion is *(2.54/100), in binary (32 digits):
321 * .00000110100000001001110101001001
323 png_uint_32 t1001
, t1101
;
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 */
335 /* The argument is a PNG unsigned integer, so it is not permitted
336 * to be bigger than 2^31.
338 png_fixed_point result
;
339 if (ppm
<= PNG_UINT_31_MAX
&& png_muldiv(&result
, (png_int_32
)ppm
, 127,
341 return (png_uint_32
)result
;
349 png_get_pixels_per_inch(png_const_structrp png_ptr
, png_const_inforp info_ptr
)
351 return ppi_from_ppm(png_get_pixels_per_meter(png_ptr
, info_ptr
));
355 png_get_x_pixels_per_inch(png_const_structrp png_ptr
, png_const_inforp info_ptr
)
357 return ppi_from_ppm(png_get_x_pixels_per_meter(png_ptr
, info_ptr
));
361 png_get_y_pixels_per_inch(png_const_structrp png_ptr
, png_const_inforp info_ptr
)
363 return ppi_from_ppm(png_get_y_pixels_per_meter(png_ptr
, info_ptr
));
366 #ifdef PNG_FIXED_POINT_SUPPORTED
367 static png_fixed_point
368 png_fixed_inches_from_microns(png_const_structrp png_ptr
, png_int_32 microns
)
370 /* Convert from meters * 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
375 return png_muldiv_warn(png_ptr
, microns
, 500, 127);
378 png_fixed_point PNGAPI
379 png_get_x_offset_inches_fixed(png_const_structrp png_ptr
,
380 png_const_inforp info_ptr
)
382 return png_fixed_inches_from_microns(png_ptr
,
383 png_get_x_offset_microns(png_ptr
, info_ptr
));
387 #ifdef PNG_FIXED_POINT_SUPPORTED
388 png_fixed_point PNGAPI
389 png_get_y_offset_inches_fixed(png_const_structrp png_ptr
,
390 png_const_inforp info_ptr
)
392 return png_fixed_inches_from_microns(png_ptr
,
393 png_get_y_offset_microns(png_ptr
, info_ptr
));
397 #ifdef PNG_FLOATING_POINT_SUPPORTED
399 png_get_x_offset_inches(png_const_structrp png_ptr
, png_const_inforp info_ptr
)
401 /* To avoid the overflow do the conversion directly in floating
404 return (float)(png_get_x_offset_microns(png_ptr
, info_ptr
) * .00003937);
408 #ifdef PNG_FLOATING_POINT_SUPPORTED
410 png_get_y_offset_inches(png_const_structrp png_ptr
, png_const_inforp info_ptr
)
412 /* To avoid the overflow do the conversion directly in floating
415 return (float)(png_get_y_offset_microns(png_ptr
, info_ptr
) * .00003937);
419 #ifdef PNG_pHYs_SUPPORTED
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
)
424 png_uint_32 retval
= 0;
426 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
427 (info_ptr
->valid
& PNG_INFO_pHYs
) != 0)
429 png_debug1(1, "in %s retrieval function", "pHYs");
433 *res_x
= info_ptr
->x_pixels_per_unit
;
434 retval
|= PNG_INFO_pHYs
;
439 *res_y
= info_ptr
->y_pixels_per_unit
;
440 retval
|= PNG_INFO_pHYs
;
443 if (unit_type
!= NULL
)
445 *unit_type
= (int)info_ptr
->phys_unit_type
;
446 retval
|= PNG_INFO_pHYs
;
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);
459 #endif /* INCH_CONVERSIONS */
461 /* png_get_channels really belongs in here, too, but it's been around longer */
463 #endif /* EASY_ACCESS */
467 png_get_channels(png_const_structrp png_ptr
, png_const_inforp info_ptr
)
469 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
470 return(info_ptr
->channels
);
475 #ifdef PNG_READ_SUPPORTED
476 png_const_bytep PNGAPI
477 png_get_signature(png_const_structrp png_ptr
, png_const_inforp info_ptr
)
479 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
480 return(info_ptr
->signature
);
486 #ifdef PNG_bKGD_SUPPORTED
488 png_get_bKGD(png_const_structrp png_ptr
, png_inforp info_ptr
,
489 png_color_16p
*background
)
491 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
492 (info_ptr
->valid
& PNG_INFO_bKGD
) != 0 &&
495 png_debug1(1, "in %s retrieval function", "bKGD");
497 *background
= &(info_ptr
->background
);
498 return (PNG_INFO_bKGD
);
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
510 # ifdef PNG_FLOATING_POINT_SUPPORTED
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
)
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
522 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
523 (info_ptr
->colorspace
.flags
& PNG_COLORSPACE_HAVE_ENDPOINTS
) != 0)
525 png_debug1(1, "in %s retrieval function", "cHRM");
528 *white_x
= png_float(png_ptr
,
529 info_ptr
->colorspace
.end_points_xy
.whitex
, "cHRM white X");
531 *white_y
= png_float(png_ptr
,
532 info_ptr
->colorspace
.end_points_xy
.whitey
, "cHRM white Y");
534 *red_x
= png_float(png_ptr
, info_ptr
->colorspace
.end_points_xy
.redx
,
537 *red_y
= png_float(png_ptr
, info_ptr
->colorspace
.end_points_xy
.redy
,
540 *green_x
= png_float(png_ptr
,
541 info_ptr
->colorspace
.end_points_xy
.greenx
, "cHRM green X");
543 *green_y
= png_float(png_ptr
,
544 info_ptr
->colorspace
.end_points_xy
.greeny
, "cHRM green Y");
546 *blue_x
= png_float(png_ptr
, info_ptr
->colorspace
.end_points_xy
.bluex
,
549 *blue_y
= png_float(png_ptr
, info_ptr
->colorspace
.end_points_xy
.bluey
,
551 return (PNG_INFO_cHRM
);
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
,
563 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
564 (info_ptr
->colorspace
.flags
& PNG_COLORSPACE_HAVE_ENDPOINTS
) != 0)
566 png_debug1(1, "in %s retrieval function", "cHRM_XYZ(float)");
569 *red_X
= png_float(png_ptr
, info_ptr
->colorspace
.end_points_XYZ
.red_X
,
572 *red_Y
= png_float(png_ptr
, info_ptr
->colorspace
.end_points_XYZ
.red_Y
,
575 *red_Z
= png_float(png_ptr
, info_ptr
->colorspace
.end_points_XYZ
.red_Z
,
578 *green_X
= png_float(png_ptr
,
579 info_ptr
->colorspace
.end_points_XYZ
.green_X
, "cHRM green X");
581 *green_Y
= png_float(png_ptr
,
582 info_ptr
->colorspace
.end_points_XYZ
.green_Y
, "cHRM green Y");
584 *green_Z
= png_float(png_ptr
,
585 info_ptr
->colorspace
.end_points_XYZ
.green_Z
, "cHRM green Z");
587 *blue_X
= png_float(png_ptr
,
588 info_ptr
->colorspace
.end_points_XYZ
.blue_X
, "cHRM blue X");
590 *blue_Y
= png_float(png_ptr
,
591 info_ptr
->colorspace
.end_points_XYZ
.blue_Y
, "cHRM blue Y");
593 *blue_Z
= png_float(png_ptr
,
594 info_ptr
->colorspace
.end_points_XYZ
.blue_Z
, "cHRM blue Z");
595 return (PNG_INFO_cHRM
);
602 # ifdef PNG_FIXED_POINT_SUPPORTED
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
)
611 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
612 (info_ptr
->colorspace
.flags
& PNG_COLORSPACE_HAVE_ENDPOINTS
) != 0)
614 png_debug1(1, "in %s retrieval function", "cHRM_XYZ");
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
);
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
)
646 png_debug1(1, "in %s retrieval function", "cHRM");
648 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
649 (info_ptr
->colorspace
.flags
& PNG_COLORSPACE_HAVE_ENDPOINTS
) != 0)
652 *white_x
= info_ptr
->colorspace
.end_points_xy
.whitex
;
654 *white_y
= info_ptr
->colorspace
.end_points_xy
.whitey
;
656 *red_x
= info_ptr
->colorspace
.end_points_xy
.redx
;
658 *red_y
= info_ptr
->colorspace
.end_points_xy
.redy
;
660 *green_x
= info_ptr
->colorspace
.end_points_xy
.greenx
;
662 *green_y
= info_ptr
->colorspace
.end_points_xy
.greeny
;
664 *blue_x
= info_ptr
->colorspace
.end_points_xy
.bluex
;
666 *blue_y
= info_ptr
->colorspace
.end_points_xy
.bluey
;
667 return (PNG_INFO_cHRM
);
675 #ifdef PNG_gAMA_SUPPORTED
676 # ifdef PNG_FIXED_POINT_SUPPORTED
678 png_get_gAMA_fixed(png_const_structrp png_ptr
, png_const_inforp info_ptr
,
679 png_fixed_point
*file_gamma
)
681 png_debug1(1, "in %s retrieval function", "gAMA");
683 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
684 (info_ptr
->colorspace
.flags
& PNG_COLORSPACE_HAVE_GAMMA
) != 0 &&
687 *file_gamma
= info_ptr
->colorspace
.gamma
;
688 return (PNG_INFO_gAMA
);
695 # ifdef PNG_FLOATING_POINT_SUPPORTED
697 png_get_gAMA(png_const_structrp png_ptr
, png_const_inforp info_ptr
,
700 png_debug1(1, "in %s retrieval function", "gAMA(float)");
702 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
703 (info_ptr
->colorspace
.flags
& PNG_COLORSPACE_HAVE_GAMMA
) != 0 &&
706 *file_gamma
= png_float(png_ptr
, info_ptr
->colorspace
.gamma
,
708 return (PNG_INFO_gAMA
);
716 #ifdef PNG_sRGB_SUPPORTED
718 png_get_sRGB(png_const_structrp png_ptr
, png_const_inforp info_ptr
,
719 int *file_srgb_intent
)
721 png_debug1(1, "in %s retrieval function", "sRGB");
723 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
724 (info_ptr
->valid
& PNG_INFO_sRGB
) != 0 && file_srgb_intent
!= NULL
)
726 *file_srgb_intent
= info_ptr
->colorspace
.rendering_intent
;
727 return (PNG_INFO_sRGB
);
734 #ifdef PNG_iCCP_SUPPORTED
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
)
740 png_debug1(1, "in %s retrieval function", "iCCP");
742 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
743 (info_ptr
->valid
& PNG_INFO_iCCP
) != 0 &&
744 name
!= NULL
&& profile
!= NULL
&& proflen
!= NULL
)
746 *name
= info_ptr
->iccp_name
;
747 *profile
= info_ptr
->iccp_profile
;
748 *proflen
= png_get_uint_32(info_ptr
->iccp_profile
);
749 /* This is somewhat irrelevant since the profile data returned has
750 * actually been uncompressed.
752 if (compression_type
!= NULL
)
753 *compression_type
= PNG_COMPRESSION_TYPE_BASE
;
754 return (PNG_INFO_iCCP
);
762 #ifdef PNG_sPLT_SUPPORTED
764 png_get_sPLT(png_const_structrp png_ptr
, png_inforp info_ptr
,
765 png_sPLT_tpp spalettes
)
767 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&& spalettes
!= NULL
)
769 *spalettes
= info_ptr
->splt_palettes
;
770 return info_ptr
->splt_palettes_num
;
777 #ifdef PNG_eXIf_SUPPORTED
779 png_get_eXIf(png_const_structrp png_ptr
, png_inforp info_ptr
,
782 png_warning(png_ptr
, "png_get_eXIf does not work; use png_get_eXIf_1");
789 png_get_eXIf_1(png_const_structrp png_ptr
, png_const_inforp info_ptr
,
790 png_uint_32
*num_exif
, png_bytep
*exif
)
792 png_debug1(1, "in %s retrieval function", "eXIf");
794 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
795 (info_ptr
->valid
& PNG_INFO_eXIf
) != 0 && exif
!= NULL
)
797 *num_exif
= info_ptr
->num_exif
;
798 *exif
= info_ptr
->exif
;
799 return (PNG_INFO_eXIf
);
806 #ifdef PNG_hIST_SUPPORTED
808 png_get_hIST(png_const_structrp png_ptr
, png_inforp info_ptr
,
811 png_debug1(1, "in %s retrieval function", "hIST");
813 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
814 (info_ptr
->valid
& PNG_INFO_hIST
) != 0 && hist
!= NULL
)
816 *hist
= info_ptr
->hist
;
817 return (PNG_INFO_hIST
);
825 png_get_IHDR(png_const_structrp png_ptr
, png_const_inforp info_ptr
,
826 png_uint_32
*width
, png_uint_32
*height
, int *bit_depth
,
827 int *color_type
, int *interlace_type
, int *compression_type
,
830 png_debug1(1, "in %s retrieval function", "IHDR");
832 if (png_ptr
== NULL
|| info_ptr
== NULL
)
836 *width
= info_ptr
->width
;
839 *height
= info_ptr
->height
;
841 if (bit_depth
!= NULL
)
842 *bit_depth
= info_ptr
->bit_depth
;
844 if (color_type
!= NULL
)
845 *color_type
= info_ptr
->color_type
;
847 if (compression_type
!= NULL
)
848 *compression_type
= info_ptr
->compression_type
;
850 if (filter_type
!= NULL
)
851 *filter_type
= info_ptr
->filter_type
;
853 if (interlace_type
!= NULL
)
854 *interlace_type
= info_ptr
->interlace_type
;
856 /* This is redundant if we can be sure that the info_ptr values were all
857 * assigned in png_set_IHDR(). We do the check anyhow in case an
858 * application has ignored our advice not to mess with the members
859 * of info_ptr directly.
861 png_check_IHDR(png_ptr
, info_ptr
->width
, info_ptr
->height
,
862 info_ptr
->bit_depth
, info_ptr
->color_type
, info_ptr
->interlace_type
,
863 info_ptr
->compression_type
, info_ptr
->filter_type
);
868 #ifdef PNG_oFFs_SUPPORTED
870 png_get_oFFs(png_const_structrp png_ptr
, png_const_inforp info_ptr
,
871 png_int_32
*offset_x
, png_int_32
*offset_y
, int *unit_type
)
873 png_debug1(1, "in %s retrieval function", "oFFs");
875 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
876 (info_ptr
->valid
& PNG_INFO_oFFs
) != 0 &&
877 offset_x
!= NULL
&& offset_y
!= NULL
&& unit_type
!= NULL
)
879 *offset_x
= info_ptr
->x_offset
;
880 *offset_y
= info_ptr
->y_offset
;
881 *unit_type
= (int)info_ptr
->offset_unit_type
;
882 return (PNG_INFO_oFFs
);
889 #ifdef PNG_pCAL_SUPPORTED
891 png_get_pCAL(png_const_structrp png_ptr
, png_inforp info_ptr
,
892 png_charp
*purpose
, png_int_32
*X0
, png_int_32
*X1
, int *type
, int *nparams
,
893 png_charp
*units
, png_charpp
*params
)
895 png_debug1(1, "in %s retrieval function", "pCAL");
897 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
898 (info_ptr
->valid
& PNG_INFO_pCAL
) != 0 &&
899 purpose
!= NULL
&& X0
!= NULL
&& X1
!= NULL
&& type
!= NULL
&&
900 nparams
!= NULL
&& units
!= NULL
&& params
!= NULL
)
902 *purpose
= info_ptr
->pcal_purpose
;
903 *X0
= info_ptr
->pcal_X0
;
904 *X1
= info_ptr
->pcal_X1
;
905 *type
= (int)info_ptr
->pcal_type
;
906 *nparams
= (int)info_ptr
->pcal_nparams
;
907 *units
= info_ptr
->pcal_units
;
908 *params
= info_ptr
->pcal_params
;
909 return (PNG_INFO_pCAL
);
916 #ifdef PNG_sCAL_SUPPORTED
917 # ifdef PNG_FIXED_POINT_SUPPORTED
918 # if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || \
919 defined(PNG_FLOATING_POINT_SUPPORTED)
921 png_get_sCAL_fixed(png_const_structrp png_ptr
, png_const_inforp info_ptr
,
922 int *unit
, png_fixed_point
*width
, png_fixed_point
*height
)
924 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
925 (info_ptr
->valid
& PNG_INFO_sCAL
) != 0)
927 *unit
= info_ptr
->scal_unit
;
928 /*TODO: make this work without FP support; the API is currently eliminated
929 * if neither floating point APIs nor internal floating point arithmetic
932 *width
= png_fixed(png_ptr
, atof(info_ptr
->scal_s_width
), "sCAL width");
933 *height
= png_fixed(png_ptr
, atof(info_ptr
->scal_s_height
),
935 return (PNG_INFO_sCAL
);
940 # endif /* FLOATING_ARITHMETIC */
941 # endif /* FIXED_POINT */
942 # ifdef PNG_FLOATING_POINT_SUPPORTED
944 png_get_sCAL(png_const_structrp png_ptr
, png_const_inforp info_ptr
,
945 int *unit
, double *width
, double *height
)
947 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
948 (info_ptr
->valid
& PNG_INFO_sCAL
) != 0)
950 *unit
= info_ptr
->scal_unit
;
951 *width
= atof(info_ptr
->scal_s_width
);
952 *height
= atof(info_ptr
->scal_s_height
);
953 return (PNG_INFO_sCAL
);
958 # endif /* FLOATING POINT */
960 png_get_sCAL_s(png_const_structrp png_ptr
, png_const_inforp info_ptr
,
961 int *unit
, png_charpp width
, png_charpp height
)
963 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
964 (info_ptr
->valid
& PNG_INFO_sCAL
) != 0)
966 *unit
= info_ptr
->scal_unit
;
967 *width
= info_ptr
->scal_s_width
;
968 *height
= info_ptr
->scal_s_height
;
969 return (PNG_INFO_sCAL
);
976 #ifdef PNG_pHYs_SUPPORTED
978 png_get_pHYs(png_const_structrp png_ptr
, png_const_inforp info_ptr
,
979 png_uint_32
*res_x
, png_uint_32
*res_y
, int *unit_type
)
981 png_uint_32 retval
= 0;
983 png_debug1(1, "in %s retrieval function", "pHYs");
985 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
986 (info_ptr
->valid
& PNG_INFO_pHYs
) != 0)
990 *res_x
= info_ptr
->x_pixels_per_unit
;
991 retval
|= PNG_INFO_pHYs
;
996 *res_y
= info_ptr
->y_pixels_per_unit
;
997 retval
|= PNG_INFO_pHYs
;
1000 if (unit_type
!= NULL
)
1002 *unit_type
= (int)info_ptr
->phys_unit_type
;
1003 retval
|= PNG_INFO_pHYs
;
1012 png_get_PLTE(png_const_structrp png_ptr
, png_inforp info_ptr
,
1013 png_colorp
*palette
, int *num_palette
)
1015 png_debug1(1, "in %s retrieval function", "PLTE");
1017 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
1018 (info_ptr
->valid
& PNG_INFO_PLTE
) != 0 && palette
!= NULL
)
1020 *palette
= info_ptr
->palette
;
1021 *num_palette
= info_ptr
->num_palette
;
1022 png_debug1(3, "num_palette = %d", *num_palette
);
1023 return (PNG_INFO_PLTE
);
1029 #ifdef PNG_sBIT_SUPPORTED
1031 png_get_sBIT(png_const_structrp png_ptr
, png_inforp info_ptr
,
1032 png_color_8p
*sig_bit
)
1034 png_debug1(1, "in %s retrieval function", "sBIT");
1036 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
1037 (info_ptr
->valid
& PNG_INFO_sBIT
) != 0 && sig_bit
!= NULL
)
1039 *sig_bit
= &(info_ptr
->sig_bit
);
1040 return (PNG_INFO_sBIT
);
1047 #ifdef PNG_TEXT_SUPPORTED
1049 png_get_text(png_const_structrp png_ptr
, png_inforp info_ptr
,
1050 png_textp
*text_ptr
, int *num_text
)
1052 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&& info_ptr
->num_text
> 0)
1054 png_debug1(1, "in 0x%lx retrieval function",
1055 (unsigned long)png_ptr
->chunk_name
);
1057 if (text_ptr
!= NULL
)
1058 *text_ptr
= info_ptr
->text
;
1060 if (num_text
!= NULL
)
1061 *num_text
= info_ptr
->num_text
;
1063 return info_ptr
->num_text
;
1066 if (num_text
!= NULL
)
1073 #ifdef PNG_tIME_SUPPORTED
1075 png_get_tIME(png_const_structrp png_ptr
, png_inforp info_ptr
,
1076 png_timep
*mod_time
)
1078 png_debug1(1, "in %s retrieval function", "tIME");
1080 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
1081 (info_ptr
->valid
& PNG_INFO_tIME
) != 0 && mod_time
!= NULL
)
1083 *mod_time
= &(info_ptr
->mod_time
);
1084 return (PNG_INFO_tIME
);
1091 #ifdef PNG_tRNS_SUPPORTED
1093 png_get_tRNS(png_const_structrp png_ptr
, png_inforp info_ptr
,
1094 png_bytep
*trans_alpha
, int *num_trans
, png_color_16p
*trans_color
)
1096 png_uint_32 retval
= 0;
1097 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
1098 (info_ptr
->valid
& PNG_INFO_tRNS
) != 0)
1100 png_debug1(1, "in %s retrieval function", "tRNS");
1102 if (info_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
)
1104 if (trans_alpha
!= NULL
)
1106 *trans_alpha
= info_ptr
->trans_alpha
;
1107 retval
|= PNG_INFO_tRNS
;
1110 if (trans_color
!= NULL
)
1111 *trans_color
= &(info_ptr
->trans_color
);
1114 else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */
1116 if (trans_color
!= NULL
)
1118 *trans_color
= &(info_ptr
->trans_color
);
1119 retval
|= PNG_INFO_tRNS
;
1122 if (trans_alpha
!= NULL
)
1123 *trans_alpha
= NULL
;
1126 if (num_trans
!= NULL
)
1128 *num_trans
= info_ptr
->num_trans
;
1129 retval
|= PNG_INFO_tRNS
;
1137 #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
1139 png_get_unknown_chunks(png_const_structrp png_ptr
, png_inforp info_ptr
,
1140 png_unknown_chunkpp unknowns
)
1142 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&& unknowns
!= NULL
)
1144 *unknowns
= info_ptr
->unknown_chunks
;
1145 return info_ptr
->unknown_chunks_num
;
1152 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
1154 png_get_rgb_to_gray_status (png_const_structrp png_ptr
)
1156 return (png_byte
)(png_ptr
? png_ptr
->rgb_to_gray_status
: 0);
1160 #ifdef PNG_USER_CHUNKS_SUPPORTED
1162 png_get_user_chunk_ptr(png_const_structrp png_ptr
)
1164 return (png_ptr
? png_ptr
->user_chunk_ptr
: NULL
);
1169 png_get_compression_buffer_size(png_const_structrp png_ptr
)
1171 if (png_ptr
== NULL
)
1174 #ifdef PNG_WRITE_SUPPORTED
1175 if ((png_ptr
->mode
& PNG_IS_READ_STRUCT
) != 0)
1178 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1179 return png_ptr
->IDAT_read_size
;
1181 return PNG_IDAT_READ_SIZE
;
1185 #ifdef PNG_WRITE_SUPPORTED
1187 return png_ptr
->zbuffer_size
;
1191 #ifdef PNG_SET_USER_LIMITS_SUPPORTED
1192 /* These functions were added to libpng 1.2.6 and were enabled
1193 * by default in libpng-1.4.0 */
1195 png_get_user_width_max (png_const_structrp png_ptr
)
1197 return (png_ptr
? png_ptr
->user_width_max
: 0);
1201 png_get_user_height_max (png_const_structrp png_ptr
)
1203 return (png_ptr
? png_ptr
->user_height_max
: 0);
1206 /* This function was added to libpng 1.4.0 */
1208 png_get_chunk_cache_max (png_const_structrp png_ptr
)
1210 return (png_ptr
? png_ptr
->user_chunk_cache_max
: 0);
1213 /* This function was added to libpng 1.4.1 */
1214 png_alloc_size_t PNGAPI
1215 png_get_chunk_malloc_max (png_const_structrp png_ptr
)
1217 return (png_ptr
? png_ptr
->user_chunk_malloc_max
: 0);
1219 #endif /* SET_USER_LIMITS */
1221 /* These functions were added to libpng 1.4.0 */
1222 #ifdef PNG_IO_STATE_SUPPORTED
1224 png_get_io_state (png_const_structrp png_ptr
)
1226 return png_ptr
->io_state
;
1230 png_get_io_chunk_type (png_const_structrp png_ptr
)
1232 return png_ptr
->chunk_name
;
1234 #endif /* IO_STATE */
1236 #ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
1237 # ifdef PNG_GET_PALETTE_MAX_SUPPORTED
1239 png_get_palette_max(png_const_structp png_ptr
, png_const_infop info_ptr
)
1241 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
1242 return png_ptr
->num_palette_max
;
1249 #ifdef PNG_APNG_SUPPORTED
1251 png_get_acTL(png_structp png_ptr
, png_infop info_ptr
,
1252 png_uint_32
*num_frames
, png_uint_32
*num_plays
)
1254 png_debug1(1, "in %s retrieval function", "acTL");
1256 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
1257 (info_ptr
->valid
& PNG_INFO_acTL
) != 0 &&
1258 num_frames
!= NULL
&& num_plays
!= NULL
)
1260 *num_frames
= info_ptr
->num_frames
;
1261 *num_plays
= info_ptr
->num_plays
;
1269 png_get_num_frames(png_structp png_ptr
, png_infop info_ptr
)
1271 png_debug(1, "in png_get_num_frames()");
1273 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
1274 return (info_ptr
->num_frames
);
1279 png_get_num_plays(png_structp png_ptr
, png_infop info_ptr
)
1281 png_debug(1, "in png_get_num_plays()");
1283 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
1284 return (info_ptr
->num_plays
);
1289 png_get_next_frame_fcTL(png_structp png_ptr
, png_infop info_ptr
,
1290 png_uint_32
*width
, png_uint_32
*height
,
1291 png_uint_32
*x_offset
, png_uint_32
*y_offset
,
1292 png_uint_16
*delay_num
, png_uint_16
*delay_den
,
1293 png_byte
*dispose_op
, png_byte
*blend_op
)
1295 png_debug1(1, "in %s retrieval function", "fcTL");
1297 if (png_ptr
!= NULL
&& info_ptr
!= NULL
&&
1298 (info_ptr
->valid
& PNG_INFO_fcTL
) != 0 &&
1299 width
!= NULL
&& height
!= NULL
&&
1300 x_offset
!= NULL
&& y_offset
!= NULL
&&
1301 delay_num
!= NULL
&& delay_den
!= NULL
&&
1302 dispose_op
!= NULL
&& blend_op
!= NULL
)
1304 *width
= info_ptr
->next_frame_width
;
1305 *height
= info_ptr
->next_frame_height
;
1306 *x_offset
= info_ptr
->next_frame_x_offset
;
1307 *y_offset
= info_ptr
->next_frame_y_offset
;
1308 *delay_num
= info_ptr
->next_frame_delay_num
;
1309 *delay_den
= info_ptr
->next_frame_delay_den
;
1310 *dispose_op
= info_ptr
->next_frame_dispose_op
;
1311 *blend_op
= info_ptr
->next_frame_blend_op
;
1319 png_get_next_frame_width(png_structp png_ptr
, png_infop info_ptr
)
1321 png_debug(1, "in png_get_next_frame_width()");
1323 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
1324 return (info_ptr
->next_frame_width
);
1329 png_get_next_frame_height(png_structp png_ptr
, png_infop info_ptr
)
1331 png_debug(1, "in png_get_next_frame_height()");
1333 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
1334 return (info_ptr
->next_frame_height
);
1339 png_get_next_frame_x_offset(png_structp png_ptr
, png_infop info_ptr
)
1341 png_debug(1, "in png_get_next_frame_x_offset()");
1343 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
1344 return (info_ptr
->next_frame_x_offset
);
1349 png_get_next_frame_y_offset(png_structp png_ptr
, png_infop info_ptr
)
1351 png_debug(1, "in png_get_next_frame_y_offset()");
1353 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
1354 return (info_ptr
->next_frame_y_offset
);
1359 png_get_next_frame_delay_num(png_structp png_ptr
, png_infop info_ptr
)
1361 png_debug(1, "in png_get_next_frame_delay_num()");
1363 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
1364 return (info_ptr
->next_frame_delay_num
);
1369 png_get_next_frame_delay_den(png_structp png_ptr
, png_infop info_ptr
)
1371 png_debug(1, "in png_get_next_frame_delay_den()");
1373 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
1374 return (info_ptr
->next_frame_delay_den
);
1379 png_get_next_frame_dispose_op(png_structp png_ptr
, png_infop info_ptr
)
1381 png_debug(1, "in png_get_next_frame_dispose_op()");
1383 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
1384 return (info_ptr
->next_frame_dispose_op
);
1389 png_get_next_frame_blend_op(png_structp png_ptr
, png_infop info_ptr
)
1391 png_debug(1, "in png_get_next_frame_blend_op()");
1393 if (png_ptr
!= NULL
&& info_ptr
!= NULL
)
1394 return (info_ptr
->next_frame_blend_op
);
1399 png_get_first_frame_is_hidden(png_structp png_ptr
, png_infop info_ptr
)
1401 png_debug(1, "in png_first_frame_is_hidden()");
1403 if (png_ptr
!= NULL
)
1404 return (png_byte
)(png_ptr
->apng_flags
& PNG_FIRST_FRAME_HIDDEN
);
1406 PNG_UNUSED(info_ptr
)
1411 #endif /* READ || WRITE */