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