ReactOS 0.4.15-dev-8419-g7f0e8a3
pngget.c
Go to the documentation of this file.
1
2/* pngget.c - retrieval of values from info struct
3 *
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.
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
22{
23 if (png_ptr != NULL && info_ptr != NULL)
24 return(info_ptr->valid & flag);
25
26 return(0);
27}
28
29size_t PNGAPI
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
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 */
53{
54 if (png_ptr != NULL && info_ptr != NULL)
55 return info_ptr->width;
56
57 return (0);
58}
59
62{
63 if (png_ptr != NULL && info_ptr != NULL)
64 return info_ptr->height;
65
66 return (0);
67}
68
69png_byte PNGAPI
71{
72 if (png_ptr != NULL && info_ptr != NULL)
73 return info_ptr->bit_depth;
74
75 return (0);
76}
77
78png_byte PNGAPI
80{
81 if (png_ptr != NULL && info_ptr != NULL)
82 return info_ptr->color_type;
83
84 return (0);
85}
86
87png_byte PNGAPI
89{
90 if (png_ptr != NULL && info_ptr != NULL)
91 return info_ptr->filter_type;
92
93 return (0);
94}
95
96png_byte PNGAPI
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
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
131#endif
132
133 return (0);
134}
135
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
153#endif
154
155 return (0);
156}
157
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
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
197#endif
198
199 return ((float)0.0);
200}
201#endif
202
203#ifdef PNG_FIXED_POINT_SUPPORTED
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 {
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
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
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
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
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
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 */
339 if (ppm <= PNG_UINT_31_MAX && png_muldiv(&result, (png_int_32)ppm, 127,
340 5000) != 0)
341 return (png_uint_32)result;
342
343 /* Overflow. */
344 return 0;
345#endif
346}
347
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
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
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 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
373 * returned.
374 */
375 return png_muldiv_warn(png_ptr, microns, 500, 127);
376}
377
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
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
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
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
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
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
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
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
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
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
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
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
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
737 png_charpp name, int *compression_type,
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 && profile != NULL && proflen != NULL)
745 {
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.
751 */
752 if (compression_type != NULL)
753 *compression_type = PNG_COMPRESSION_TYPE_BASE;
754 return (PNG_INFO_iCCP);
755 }
756
757 return (0);
758
759}
760#endif
761
762#ifdef PNG_sPLT_SUPPORTED
763int PNGAPI
765 png_sPLT_tpp spalettes)
766{
767 if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL)
768 {
769 *spalettes = info_ptr->splt_palettes;
770 return info_ptr->splt_palettes_num;
771 }
772
773 return (0);
774}
775#endif
776
777#ifdef PNG_eXIf_SUPPORTED
781{
782 png_warning(png_ptr, "png_get_eXIf does not work; use png_get_eXIf_1");
785 return 0;
786}
787
790 png_uint_32 *num_exif, png_bytep *exif)
791{
792 png_debug1(1, "in %s retrieval function", "eXIf");
793
794 if (png_ptr != NULL && info_ptr != NULL &&
795 (info_ptr->valid & PNG_INFO_eXIf) != 0 && exif != NULL)
796 {
797 *num_exif = info_ptr->num_exif;
798 *exif = info_ptr->exif;
799 return (PNG_INFO_eXIf);
800 }
801
802 return (0);
803}
804#endif
805
806#ifdef PNG_hIST_SUPPORTED
809 png_uint_16p *hist)
810{
811 png_debug1(1, "in %s retrieval function", "hIST");
812
813 if (png_ptr != NULL && info_ptr != NULL &&
814 (info_ptr->valid & PNG_INFO_hIST) != 0 && hist != NULL)
815 {
816 *hist = info_ptr->hist;
817 return (PNG_INFO_hIST);
818 }
819
820 return (0);
821}
822#endif
823
826 png_uint_32 *width, png_uint_32 *height, int *bit_depth,
827 int *color_type, int *interlace_type, int *compression_type,
828 int *filter_type)
829{
830 png_debug1(1, "in %s retrieval function", "IHDR");
831
832 if (png_ptr == NULL || info_ptr == NULL)
833 return (0);
834
835 if (width != NULL)
836 *width = info_ptr->width;
837
838 if (height != NULL)
839 *height = info_ptr->height;
840
841 if (bit_depth != NULL)
842 *bit_depth = info_ptr->bit_depth;
843
844 if (color_type != NULL)
845 *color_type = info_ptr->color_type;
846
847 if (compression_type != NULL)
848 *compression_type = info_ptr->compression_type;
849
850 if (filter_type != NULL)
851 *filter_type = info_ptr->filter_type;
852
853 if (interlace_type != NULL)
854 *interlace_type = info_ptr->interlace_type;
855
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.
860 */
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);
864
865 return (1);
866}
867
868#ifdef PNG_oFFs_SUPPORTED
871 png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)
872{
873 png_debug1(1, "in %s retrieval function", "oFFs");
874
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)
878 {
879 *offset_x = info_ptr->x_offset;
880 *offset_y = info_ptr->y_offset;
881 *unit_type = (int)info_ptr->offset_unit_type;
883 }
884
885 return (0);
886}
887#endif
888
889#ifdef PNG_pCAL_SUPPORTED
892 png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,
894{
895 png_debug1(1, "in %s retrieval function", "pCAL");
896
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)
901 {
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);
910 }
911
912 return (0);
913}
914#endif
915
916#ifdef PNG_sCAL_SUPPORTED
917# ifdef PNG_FIXED_POINT_SUPPORTED
918# if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || \
919 defined(PNG_FLOATING_POINT_SUPPORTED)
923{
924 if (png_ptr != NULL && info_ptr != NULL &&
925 (info_ptr->valid & PNG_INFO_sCAL) != 0)
926 {
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
930 * are enabled.
931 */
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),
934 "sCAL height");
935 return (PNG_INFO_sCAL);
936 }
937
938 return(0);
939}
940# endif /* FLOATING_ARITHMETIC */
941# endif /* FIXED_POINT */
942# ifdef PNG_FLOATING_POINT_SUPPORTED
945 int *unit, double *width, double *height)
946{
947 if (png_ptr != NULL && info_ptr != NULL &&
948 (info_ptr->valid & PNG_INFO_sCAL) != 0)
949 {
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);
954 }
955
956 return(0);
957}
958# endif /* FLOATING POINT */
962{
963 if (png_ptr != NULL && info_ptr != NULL &&
964 (info_ptr->valid & PNG_INFO_sCAL) != 0)
965 {
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);
970 }
971
972 return(0);
973}
974#endif /* sCAL */
975
976#ifdef PNG_pHYs_SUPPORTED
979 png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
980{
981 png_uint_32 retval = 0;
982
983 png_debug1(1, "in %s retrieval function", "pHYs");
984
985 if (png_ptr != NULL && info_ptr != NULL &&
986 (info_ptr->valid & PNG_INFO_pHYs) != 0)
987 {
988 if (res_x != NULL)
989 {
990 *res_x = info_ptr->x_pixels_per_unit;
991 retval |= PNG_INFO_pHYs;
992 }
993
994 if (res_y != NULL)
995 {
996 *res_y = info_ptr->y_pixels_per_unit;
997 retval |= PNG_INFO_pHYs;
998 }
999
1000 if (unit_type != NULL)
1001 {
1002 *unit_type = (int)info_ptr->phys_unit_type;
1003 retval |= PNG_INFO_pHYs;
1004 }
1005 }
1006
1007 return (retval);
1008}
1009#endif /* pHYs */
1010
1013 png_colorp *palette, int *num_palette)
1014{
1015 png_debug1(1, "in %s retrieval function", "PLTE");
1016
1017 if (png_ptr != NULL && info_ptr != NULL &&
1018 (info_ptr->valid & PNG_INFO_PLTE) != 0 && palette != NULL)
1019 {
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);
1024 }
1025
1026 return (0);
1027}
1028
1029#ifdef PNG_sBIT_SUPPORTED
1032 png_color_8p *sig_bit)
1033{
1034 png_debug1(1, "in %s retrieval function", "sBIT");
1035
1036 if (png_ptr != NULL && info_ptr != NULL &&
1037 (info_ptr->valid & PNG_INFO_sBIT) != 0 && sig_bit != NULL)
1038 {
1039 *sig_bit = &(info_ptr->sig_bit);
1040 return (PNG_INFO_sBIT);
1041 }
1042
1043 return (0);
1044}
1045#endif
1046
1047#ifdef PNG_TEXT_SUPPORTED
1048int PNGAPI
1050 png_textp *text_ptr, int *num_text)
1051{
1052 if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)
1053 {
1054 png_debug1(1, "in 0x%lx retrieval function",
1055 (unsigned long)png_ptr->chunk_name);
1056
1057 if (text_ptr != NULL)
1058 *text_ptr = info_ptr->text;
1059
1060 if (num_text != NULL)
1061 *num_text = info_ptr->num_text;
1062
1063 return info_ptr->num_text;
1064 }
1065
1066 if (num_text != NULL)
1067 *num_text = 0;
1068
1069 return(0);
1070}
1071#endif
1072
1073#ifdef PNG_tIME_SUPPORTED
1076 png_timep *mod_time)
1077{
1078 png_debug1(1, "in %s retrieval function", "tIME");
1079
1080 if (png_ptr != NULL && info_ptr != NULL &&
1081 (info_ptr->valid & PNG_INFO_tIME) != 0 && mod_time != NULL)
1082 {
1083 *mod_time = &(info_ptr->mod_time);
1084 return (PNG_INFO_tIME);
1085 }
1086
1087 return (0);
1088}
1089#endif
1090
1091#ifdef PNG_tRNS_SUPPORTED
1094 png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color)
1095{
1096 png_uint_32 retval = 0;
1097 if (png_ptr != NULL && info_ptr != NULL &&
1098 (info_ptr->valid & PNG_INFO_tRNS) != 0)
1099 {
1100 png_debug1(1, "in %s retrieval function", "tRNS");
1101
1102 if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1103 {
1104 if (trans_alpha != NULL)
1105 {
1106 *trans_alpha = info_ptr->trans_alpha;
1107 retval |= PNG_INFO_tRNS;
1108 }
1109
1110 if (trans_color != NULL)
1111 *trans_color = &(info_ptr->trans_color);
1112 }
1113
1114 else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */
1115 {
1116 if (trans_color != NULL)
1117 {
1118 *trans_color = &(info_ptr->trans_color);
1119 retval |= PNG_INFO_tRNS;
1120 }
1121
1122 if (trans_alpha != NULL)
1123 *trans_alpha = NULL;
1124 }
1125
1126 if (num_trans != NULL)
1127 {
1128 *num_trans = info_ptr->num_trans;
1129 retval |= PNG_INFO_tRNS;
1130 }
1131 }
1132
1133 return (retval);
1134}
1135#endif
1136
1137#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
1138int PNGAPI
1139png_get_unknown_chunks(png_const_structrp png_ptr, png_inforp info_ptr,
1140 png_unknown_chunkpp unknowns)
1141{
1142 if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)
1143 {
1144 *unknowns = info_ptr->unknown_chunks;
1145 return info_ptr->unknown_chunks_num;
1146 }
1147
1148 return (0);
1149}
1150#endif
1151
1152#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
1153png_byte PNGAPI
1154png_get_rgb_to_gray_status(png_const_structrp png_ptr)
1155{
1156 return (png_byte)(png_ptr ? png_ptr->rgb_to_gray_status : 0);
1157}
1158#endif
1159
1160#ifdef PNG_USER_CHUNKS_SUPPORTED
1162png_get_user_chunk_ptr(png_const_structrp png_ptr)
1163{
1164 return (png_ptr ? png_ptr->user_chunk_ptr : NULL);
1165}
1166#endif
1167
1168size_t PNGAPI
1169png_get_compression_buffer_size(png_const_structrp png_ptr)
1170{
1171 if (png_ptr == NULL)
1172 return 0;
1173
1174#ifdef PNG_WRITE_SUPPORTED
1175 if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
1176#endif
1177 {
1178#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1179 return png_ptr->IDAT_read_size;
1180#else
1181 return PNG_IDAT_READ_SIZE;
1182#endif
1183 }
1184
1185#ifdef PNG_WRITE_SUPPORTED
1186 else
1187 return png_ptr->zbuffer_size;
1188#endif
1189}
1190
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 */
1195png_get_user_width_max(png_const_structrp png_ptr)
1196{
1197 return (png_ptr ? png_ptr->user_width_max : 0);
1198}
1199
1201png_get_user_height_max(png_const_structrp png_ptr)
1202{
1203 return (png_ptr ? png_ptr->user_height_max : 0);
1204}
1205
1206/* This function was added to libpng 1.4.0 */
1208png_get_chunk_cache_max(png_const_structrp png_ptr)
1209{
1210 return (png_ptr ? png_ptr->user_chunk_cache_max : 0);
1211}
1212
1213/* This function was added to libpng 1.4.1 */
1215png_get_chunk_malloc_max(png_const_structrp png_ptr)
1216{
1217 return (png_ptr ? png_ptr->user_chunk_malloc_max : 0);
1218}
1219#endif /* SET_USER_LIMITS */
1220
1221/* These functions were added to libpng 1.4.0 */
1222#ifdef PNG_IO_STATE_SUPPORTED
1224png_get_io_state(png_const_structrp png_ptr)
1225{
1226 return png_ptr->io_state;
1227}
1228
1231{
1232 return png_ptr->chunk_name;
1233}
1234#endif /* IO_STATE */
1235
1236#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
1237# ifdef PNG_GET_PALETTE_MAX_SUPPORTED
1238int PNGAPI
1240{
1241 if (png_ptr != NULL && info_ptr != NULL)
1242 return png_ptr->num_palette_max;
1243
1244 return (-1);
1245}
1246# endif
1247#endif
1248
1249#endif /* READ || WRITE */
return
Definition: dirsup.c:529
#define NULL
Definition: types.h:112
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
GLint GLint GLsizei width
Definition: gl.h:1546
GLuint res
Definition: glext.h:9613
GLenum const GLfloat * params
Definition: glext.h:5645
GLfloat units
Definition: glext.h:11727
GLuint64EXT * result
Definition: glext.h:11304
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean flag
Definition: glfuncs.h:52
#define profile
Definition: kernel32.h:12
if(dx< 0)
Definition: linetemp.h:194
static const WCHAR exif[]
#define PNG_COLOR_TYPE_PALETTE
Definition: image.c:5166
static HPALETTE palette
Definition: clipboard.c:1345
#define PNG_INFO_cHRM
Definition: png.h:731
#define PNG_UINT_31_MAX
Definition: png.h:646
png_const_structrp png_const_inforp double * red_X
Definition: png.h:1937
png_const_structrp png_const_inforp double double double double double double double double * blue_Y
Definition: png.h:1939
png_get_cHRM_XYZ
Definition: png.h:1936
png_get_x_offset_inches_fixed
Definition: png.h:2389
png_const_structrp png_const_inforp int * unit
Definition: png.h:2159
png_get_io_chunk_type
Definition: png.h:2415
png_const_structrp png_const_inforp double double double double double double double double double *blue_Z png_const_structrp png_const_inforp png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point * int_blue_X
Definition: png.h:1951
#define PNG_INFO_gAMA
Definition: png.h:729
png_const_structrp png_const_inforp double double double double double double double double double *blue_Z png_const_structrp png_const_inforp png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point * int_green_Y
Definition: png.h:1950
png_structrp png_ptr
Definition: png.h:1080
png_const_structrp png_const_inforp double double double double double double * green_Z
Definition: png.h:1938
png_uint_32
Definition: png.h:1936
png_const_structrp png_const_inforp double double double * red_Z
Definition: png.h:1937
#define PNG_FP_1
Definition: png.h:653
#define PNG_INFO_pHYs
Definition: png.h:736
#define PNG_OFFSET_MICROMETER
Definition: png.h:690
#define PNG_OFFSET_PIXEL
Definition: png.h:689
png_const_structrp png_const_inforp double double double double double double double double double *blue_Z png_const_structrp png_const_inforp png_fixed_point * int_red_X
Definition: png.h:1948
png_const_structrp png_const_inforp double double double double double double double double double *blue_Z png_const_structrp png_const_inforp png_fixed_point png_fixed_point * int_red_Y
Definition: png.h:1948
#define PNG_INFO_pCAL
Definition: png.h:739
png_const_structrp png_const_inforp double double double double double * green_Y
Definition: png.h:1938
png_const_structrp png_const_inforp double double double double * green_X
Definition: png.h:1938
png_const_structrp png_const_inforp double double double double double double double double double *blue_Z png_const_structrp png_const_inforp png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point * int_blue_Y
Definition: png.h:1951
png_const_structrp png_const_inforp double double double double double double double double double *blue_Z png_get_cHRM_XYZ_fixed
Definition: png.h:1946
png_const_structrp png_const_inforp double double * red_Y
Definition: png.h:1937
#define PNG_RESOLUTION_METER
Definition: png.h:708
png_get_gAMA_fixed
Definition: png.h:1993
#define PNG_INFO_eXIf
Definition: png.h:745
#define PNG_INFO_tIME
Definition: png.h:738
png_const_structrp png_const_inforp info_ptr png_get_y_offset_inches_fixed
Definition: png.h:2396
png_const_structrp png_const_inforp double double double double double double double double double *blue_Z png_const_structrp png_const_inforp png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point * int_green_Z
Definition: png.h:1950
#define PNG_INFO_sRGB
Definition: png.h:740
png_const_structrp png_const_inforp double double double double double double double * blue_X
Definition: png.h:1938
#define png_get_uint_32(buf)
Definition: png.h:2595
png_get_pixel_aspect_ratio_fixed
Definition: png.h:1900
png_const_structrp png_const_inforp double double double double double double double double double *blue_Z png_const_structrp png_const_inforp png_fixed_point png_fixed_point png_fixed_point png_fixed_point * int_green_X
Definition: png.h:1949
#define PNG_INFO_sBIT
Definition: png.h:730
png_get_sCAL_fixed
Definition: png.h:2158
#define PNG_INFO_tRNS
Definition: png.h:733
#define PNG_INFO_sCAL
Definition: png.h:743
png_const_structrp png_const_inforp double double double double double double double double double *blue_Z png_const_structrp png_const_inforp png_fixed_point png_fixed_point png_fixed_point * int_red_Z
Definition: png.h:1949
#define PNG_INFO_bKGD
Definition: png.h:734
#define PNG_INFO_hIST
Definition: png.h:735
const png_struct *PNG_RESTRICT png_const_structrp
Definition: png.h:467
const png_info *PNG_RESTRICT png_const_inforp
Definition: png.h:469
#define PNG_INFO_iCCP
Definition: png.h:741
#define PNG_INFO_PLTE
Definition: png.h:732
#define PNG_INFO_oFFs
Definition: png.h:737
png_info *PNG_RESTRICT png_inforp
Definition: png.h:468
#define PNG_COMPRESSION_TYPE_BASE
Definition: png.h:675
png_const_structrp png_const_inforp info_ptr
Definition: png.h:1937
char * png_charp
Definition: pngconf.h:589
png_int_32 png_fixed_point
Definition: pngconf.h:574
const png_byte * png_const_bytep
Definition: pngconf.h:580
char ** png_charpp
Definition: pngconf.h:612
size_t png_alloc_size_t
Definition: pngconf.h:557
#define PNGAPI
Definition: pngconf.h:261
png_byte * png_bytep
Definition: pngconf.h:579
png_byte ** png_bytepp
Definition: pngconf.h:606
png_uint_16 * png_uint_16p
Definition: pngconf.h:585
#define png_debug1(l, m, p1)
Definition: pngdebug.h:148
#define PNG_IDAT_READ_SIZE
Definition: pnglibconf.h:195
#define PNG_UNUSED(param)
Definition: pngpriv.h:444
#define PNG_IS_READ_STRUCT
Definition: pngpriv.h:630
Definition: name.c:39
double atof()