ReactOS  0.4.15-dev-494-g1d8c567
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 
29 size_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 
69 png_byte PNGAPI
71 {
72  if (png_ptr != NULL && info_ptr != NULL)
73  return info_ptr->bit_depth;
74 
75  return (0);
76 }
77 
78 png_byte PNGAPI
80 {
81  if (png_ptr != NULL && info_ptr != NULL)
82  return info_ptr->color_type;
83 
84  return (0);
85 }
86 
87 png_byte PNGAPI
89 {
90  if (png_ptr != NULL && info_ptr != NULL)
91  return info_ptr->filter_type;
92 
93  return (0);
94 }
95 
96 png_byte PNGAPI
97 png_get_interlace_type(png_const_structrp png_ptr, png_const_inforp info_ptr)
98 {
99  if (png_ptr != NULL && info_ptr != NULL)
100  return info_ptr->interlace_type;
101 
102  return (0);
103 }
104 
105 png_byte PNGAPI
106 png_get_compression_type(png_const_structrp png_ptr, png_const_inforp info_ptr)
107 {
108  if (png_ptr != NULL && info_ptr != NULL)
109  return info_ptr->compression_type;
110 
111  return (0);
112 }
113 
115 png_get_x_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp
116  info_ptr)
117 {
118 #ifdef PNG_pHYs_SUPPORTED
119  if (png_ptr != NULL && info_ptr != NULL &&
120  (info_ptr->valid & PNG_INFO_pHYs) != 0)
121  {
122  png_debug1(1, "in %s retrieval function",
123  "png_get_x_pixels_per_meter");
124 
125  if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER)
126  return (info_ptr->x_pixels_per_unit);
127  }
128 #else
131 #endif
132 
133  return (0);
134 }
135 
137 png_get_y_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp
138  info_ptr)
139 {
140 #ifdef PNG_pHYs_SUPPORTED
141  if (png_ptr != NULL && info_ptr != NULL &&
142  (info_ptr->valid & PNG_INFO_pHYs) != 0)
143  {
144  png_debug1(1, "in %s retrieval function",
145  "png_get_y_pixels_per_meter");
146 
147  if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER)
148  return (info_ptr->y_pixels_per_unit);
149  }
150 #else
153 #endif
154 
155  return (0);
156 }
157 
159 png_get_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp info_ptr)
160 {
161 #ifdef PNG_pHYs_SUPPORTED
162  if (png_ptr != NULL && info_ptr != NULL &&
163  (info_ptr->valid & PNG_INFO_pHYs) != 0)
164  {
165  png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter");
166 
167  if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER &&
168  info_ptr->x_pixels_per_unit == info_ptr->y_pixels_per_unit)
169  return (info_ptr->x_pixels_per_unit);
170  }
171 #else
174 #endif
175 
176  return (0);
177 }
178 
179 #ifdef PNG_FLOATING_POINT_SUPPORTED
180 float PNGAPI
181 png_get_pixel_aspect_ratio(png_const_structrp png_ptr, png_const_inforp
182  info_ptr)
183 {
184 #ifdef PNG_READ_pHYs_SUPPORTED
185  if (png_ptr != NULL && info_ptr != NULL &&
186  (info_ptr->valid & PNG_INFO_pHYs) != 0)
187  {
188  png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio");
189 
190  if (info_ptr->x_pixels_per_unit != 0)
191  return ((float)((float)info_ptr->y_pixels_per_unit
192  /(float)info_ptr->x_pixels_per_unit));
193  }
194 #else
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 
235 png_int_32 PNGAPI
236 png_get_x_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr)
237 {
238 #ifdef PNG_oFFs_SUPPORTED
239  if (png_ptr != NULL && info_ptr != NULL &&
240  (info_ptr->valid & PNG_INFO_oFFs) != 0)
241  {
242  png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");
243 
244  if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER)
245  return (info_ptr->x_offset);
246  }
247 #else
250 #endif
251 
252  return (0);
253 }
254 
255 png_int_32 PNGAPI
256 png_get_y_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr)
257 {
258 #ifdef PNG_oFFs_SUPPORTED
259  if (png_ptr != NULL && info_ptr != NULL &&
260  (info_ptr->valid & PNG_INFO_oFFs) != 0)
261  {
262  png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");
263 
264  if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER)
265  return (info_ptr->y_offset);
266  }
267 #else
270 #endif
271 
272  return (0);
273 }
274 
275 png_int_32 PNGAPI
276 png_get_x_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr)
277 {
278 #ifdef PNG_oFFs_SUPPORTED
279  if (png_ptr != NULL && info_ptr != NULL &&
280  (info_ptr->valid & PNG_INFO_oFFs) != 0)
281  {
282  png_debug1(1, "in %s retrieval function", "png_get_x_offset_pixels");
283 
284  if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL)
285  return (info_ptr->x_offset);
286  }
287 #else
290 #endif
291 
292  return (0);
293 }
294 
295 png_int_32 PNGAPI
296 png_get_y_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr)
297 {
298 #ifdef PNG_oFFs_SUPPORTED
299  if (png_ptr != NULL && info_ptr != NULL &&
300  (info_ptr->valid & PNG_INFO_oFFs) != 0)
301  {
302  png_debug1(1, "in %s retrieval function", "png_get_y_offset_pixels");
303 
304  if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL)
305  return (info_ptr->y_offset);
306  }
307 #else
310 #endif
311 
312  return (0);
313 }
314 
315 #ifdef PNG_INCH_CONVERSIONS_SUPPORTED
316 static png_uint_32
317 ppi_from_ppm(png_uint_32 ppm)
318 {
319 #if 0
320  /* The conversion is *(2.54/100), in binary (32 digits):
321  * .00000110100000001001110101001001
322  */
323  png_uint_32 t1001, t1101;
324  ppm >>= 1; /* .1 */
325  t1001 = ppm + (ppm >> 3); /* .1001 */
326  t1101 = t1001 + (ppm >> 1); /* .1101 */
327  ppm >>= 20; /* .000000000000000000001 */
328  t1101 += t1101 >> 15; /* .1101000000000001101 */
329  t1001 >>= 11; /* .000000000001001 */
330  t1001 += t1001 >> 12; /* .000000000001001000000001001 */
331  ppm += t1001; /* .000000000001001000001001001 */
332  ppm += t1101; /* .110100000001001110101001001 */
333  return (ppm + 16) >> 5;/* .00000110100000001001110101001001 */
334 #else
335  /* The argument is a PNG unsigned integer, so it is not permitted
336  * to be bigger than 2^31.
337  */
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 
349 png_get_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)
350 {
351  return ppi_from_ppm(png_get_pixels_per_meter(png_ptr, info_ptr));
352 }
353 
355 png_get_x_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)
356 {
357  return ppi_from_ppm(png_get_x_pixels_per_meter(png_ptr, info_ptr));
358 }
359 
361 png_get_y_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)
362 {
363  return ppi_from_ppm(png_get_y_pixels_per_meter(png_ptr, info_ptr));
364 }
365 
366 #ifdef PNG_FIXED_POINT_SUPPORTED
367 static png_fixed_point
368 png_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
398 float PNGAPI
399 png_get_x_offset_inches(png_const_structrp png_ptr, png_const_inforp info_ptr)
400 {
401  /* To avoid the overflow do the conversion directly in floating
402  * point.
403  */
404  return (float)(png_get_x_offset_microns(png_ptr, info_ptr) * .00003937);
405 }
406 #endif
407 
408 #ifdef PNG_FLOATING_POINT_SUPPORTED
409 float PNGAPI
410 png_get_y_offset_inches(png_const_structrp png_ptr, png_const_inforp info_ptr)
411 {
412  /* To avoid the overflow do the conversion directly in floating
413  * point.
414  */
415  return (float)(png_get_y_offset_microns(png_ptr, info_ptr) * .00003937);
416 }
417 #endif
418 
419 #ifdef PNG_pHYs_SUPPORTED
422  png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
423 {
424  png_uint_32 retval = 0;
425 
426  if (png_ptr != NULL && info_ptr != NULL &&
427  (info_ptr->valid & PNG_INFO_pHYs) != 0)
428  {
429  png_debug1(1, "in %s retrieval function", "pHYs");
430 
431  if (res_x != NULL)
432  {
433  *res_x = info_ptr->x_pixels_per_unit;
434  retval |= PNG_INFO_pHYs;
435  }
436 
437  if (res_y != NULL)
438  {
439  *res_y = info_ptr->y_pixels_per_unit;
440  retval |= PNG_INFO_pHYs;
441  }
442 
443  if (unit_type != NULL)
444  {
445  *unit_type = (int)info_ptr->phys_unit_type;
446  retval |= PNG_INFO_pHYs;
447 
448  if (*unit_type == 1)
449  {
450  if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50);
451  if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50);
452  }
453  }
454  }
455 
456  return (retval);
457 }
458 #endif /* pHYs */
459 #endif /* INCH_CONVERSIONS */
460 
461 /* png_get_channels really belongs in here, too, but it's been around longer */
462 
463 #endif /* EASY_ACCESS */
464 
465 
466 png_byte PNGAPI
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,
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 && 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
763 int 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
780  png_bytep *exif)
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
1048 int 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
1138 int PNGAPI
1139 png_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
1153 png_byte PNGAPI
1154 png_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
1162 png_get_user_chunk_ptr(png_const_structrp png_ptr)
1163 {
1164  return (png_ptr ? png_ptr->user_chunk_ptr : NULL);
1165 }
1166 #endif
1167 
1168 size_t PNGAPI
1169 png_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 */
1195 png_get_user_width_max (png_const_structrp png_ptr)
1196 {
1197  return (png_ptr ? png_ptr->user_width_max : 0);
1198 }
1199 
1201 png_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 */
1208 png_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 */
1215 png_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
1224 png_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
1238 int PNGAPI
1239 png_get_palette_max(png_const_structp png_ptr, png_const_infop info_ptr)
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 */
#define PNG_IDAT_READ_SIZE
Definition: pnglibconf.h:195
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
png_const_structrp png_const_inforp double double * red_Y
Definition: png.h:1939
GLint GLint GLsizei width
Definition: gl.h:1546
return
Definition: dirsup.c:529
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:1949
#define PNG_INFO_gAMA
Definition: png.h:732
#define PNG_INFO_tIME
Definition: png.h:741
#define PNG_INFO_sRGB
Definition: png.h:743
#define png_get_uint_32(buf)
Definition: png.h:2598
png_get_io_chunk_type
Definition: png.h:2418
#define PNG_UNUSED(param)
Definition: pngpriv.h:438
#define PNG_INFO_hIST
Definition: png.h:738
#define PNG_UINT_31_MAX
Definition: png.h:649
png_const_structrp png_const_inforp double double double double * green_X
Definition: png.h:1939
static const WCHAR exif[]
png_byte * png_bytep
Definition: pngconf.h:579
png_get_cHRM_XYZ
Definition: png.h:1939
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
char * png_charp
Definition: pngconf.h:589
png_byte ** png_bytepp
Definition: pngconf.h:606
png_const_structrp png_const_inforp double double double double double double * green_Z
Definition: png.h:1939
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:1949
#define PNG_IS_READ_STRUCT
Definition: pngpriv.h:639
#define PNG_INFO_oFFs
Definition: png.h:740
_Check_return_ _CRTIMP double __cdecl atof(_In_z_ const char *str)
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
GLenum const GLfloat * params
Definition: glext.h:5645
png_const_structrp png_const_inforp int * unit
Definition: png.h:2161
smooth NULL
Definition: ftsmooth.c:416
const png_struct *PNG_RESTRICT png_const_structrp
Definition: png.h:470
png_const_structrp png_const_inforp double double double * red_Z
Definition: png.h:1939
png_const_structrp png_const_inforp double double double double double double double double * blue_Y
Definition: png.h:1939
const png_info *PNG_RESTRICT png_const_inforp
Definition: png.h:472
#define PNGAPI
Definition: pngconf.h:261
png_uint_32
Definition: png.h:1939
png_int_32 png_fixed_point
Definition: pngconf.h:574
#define PNG_OFFSET_PIXEL
Definition: png.h:692
const png_byte * png_const_bytep
Definition: pngconf.h:580
if(!(yy_init))
Definition: macro.lex.yy.c:714
png_const_structrp png_const_inforp info_ptr
Definition: png.h:1939
#define png_debug1(l, m, p1)
Definition: pngdebug.h:148
char ** png_charpp
Definition: pngconf.h:612
png_get_sCAL_fixed
Definition: png.h:2161
#define PNG_RESOLUTION_METER
Definition: png.h:711
png_get_pixel_aspect_ratio_fixed
Definition: png.h:1903
#define PNG_INFO_sBIT
Definition: png.h:733
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
png_get_gAMA_fixed
Definition: png.h:1996
#define PNG_INFO_PLTE
Definition: png.h:735
static HPALETTE palette
Definition: clipboard.c:1345
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
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:1949
#define PNG_FP_1
Definition: png.h:656
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:1949
png_structrp png_ptr
Definition: png.h:1083
png_uint_16 * png_uint_16p
Definition: pngconf.h:585
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:1949
#define PNG_COMPRESSION_TYPE_BASE
Definition: png.h:678
#define PNG_INFO_tRNS
Definition: png.h:736
png_const_structrp png_const_inforp double double double double double double double * blue_X
Definition: png.h:1939
#define PNG_OFFSET_MICROMETER
Definition: png.h:693
size_t png_alloc_size_t
Definition: pngconf.h:557
Definition: name.c:38
GLuint res
Definition: glext.h:9613
png_const_structrp png_const_inforp double double double double double * green_Y
Definition: png.h:1939
png_info *PNG_RESTRICT png_inforp
Definition: png.h:471
#define profile
Definition: kernel32.h:12
#define PNG_INFO_eXIf
Definition: png.h:748
#define PNG_INFO_pHYs
Definition: png.h:739
#define PNG_INFO_pCAL
Definition: png.h:742
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:1949
GLfloat units
Definition: glext.h:11727
#define PNG_INFO_cHRM
Definition: png.h:734
GLuint64EXT * result
Definition: glext.h:11304
#define PNG_INFO_bKGD
Definition: png.h:737
png_const_structrp png_const_inforp double * red_X
Definition: png.h:1939
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:1949
png_get_x_offset_inches_fixed
Definition: png.h:2392
#define PNG_INFO_iCCP
Definition: png.h:744
#define PNG_COLOR_TYPE_PALETTE
Definition: image.c:5166
#define PNG_INFO_sCAL
Definition: png.h:746
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
png_const_structrp png_const_inforp info_ptr png_get_y_offset_inches_fixed
Definition: png.h:2399