743a6a9bbccdaebcb73a1a69f80342d97bc8aa42
[reactos.git] / reactos / dll / 3rdparty / libpng / pngget.c
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-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
19 png_uint_32 PNGAPI
20 png_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
29 png_size_t PNGAPI
30 png_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
39 png_bytepp PNGAPI
40 png_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 */
51 png_uint_32 PNGAPI
52 png_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
60 png_uint_32 PNGAPI
61 png_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
69 png_byte PNGAPI
70 png_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
78 png_byte PNGAPI
79 png_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
87 png_byte PNGAPI
88 png_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
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
114 png_uint_32 PNGAPI
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
129 PNG_UNUSED(png_ptr)
130 PNG_UNUSED(info_ptr)
131 #endif
132
133 return (0);
134 }
135
136 png_uint_32 PNGAPI
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
151 PNG_UNUSED(png_ptr)
152 PNG_UNUSED(info_ptr)
153 #endif
154
155 return (0);
156 }
157
158 png_uint_32 PNGAPI
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
172 PNG_UNUSED(png_ptr)
173 PNG_UNUSED(info_ptr)
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
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
204 png_fixed_point PNGAPI
205 png_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
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
248 PNG_UNUSED(png_ptr)
249 PNG_UNUSED(info_ptr)
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
268 PNG_UNUSED(png_ptr)
269 PNG_UNUSED(info_ptr)
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
288 PNG_UNUSED(png_ptr)
289 PNG_UNUSED(info_ptr)
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
308 PNG_UNUSED(png_ptr)
309 PNG_UNUSED(info_ptr)
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 */
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
348 png_uint_32 PNGAPI
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
354 png_uint_32 PNGAPI
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
360 png_uint_32 PNGAPI
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 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
378 png_fixed_point PNGAPI
379 png_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
388 png_fixed_point PNGAPI
389 png_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
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
420 png_uint_32 PNGAPI
421 png_get_pHYs_dpi(png_const_structrp png_ptr, png_const_inforp info_ptr,
422 png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
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
467 png_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
476 png_const_bytep PNGAPI
477 png_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
487 png_uint_32 PNGAPI
488 png_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
511 png_uint_32 PNGAPI
512 png_get_cHRM(png_const_structrp png_ptr, png_const_inforp info_ptr,
513 double *white_x, double *white_y, double *red_x, double *red_y,
514 double *green_x, double *green_y, double *blue_x, double *blue_y)
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
557 png_uint_32 PNGAPI
558 png_get_cHRM_XYZ(png_const_structrp png_ptr, png_const_inforp info_ptr,
559 double *red_X, double *red_Y, double *red_Z, double *green_X,
560 double *green_Y, double *green_Z, double *blue_X, double *blue_Y,
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
603 png_uint_32 PNGAPI
604 png_get_cHRM_XYZ_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
605 png_fixed_point *int_red_X, png_fixed_point *int_red_Y,
606 png_fixed_point *int_red_Z, png_fixed_point *int_green_X,
607 png_fixed_point *int_green_Y, png_fixed_point *int_green_Z,
608 png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y,
609 png_fixed_point *int_blue_Z)
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
640 png_uint_32 PNGAPI
641 png_get_cHRM_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
642 png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x,
643 png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y,
644 png_fixed_point *blue_x, png_fixed_point *blue_y)
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
677 png_uint_32 PNGAPI
678 png_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
696 png_uint_32 PNGAPI
697 png_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
717 png_uint_32 PNGAPI
718 png_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
735 png_uint_32 PNGAPI
736 png_get_iCCP(png_const_structrp png_ptr, png_inforp info_ptr,
737 png_charpp name, int *compression_type,
738 png_bytepp profile, png_uint_32 *proflen)
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
762 int PNGAPI
763 png_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
777 png_uint_32 PNGAPI
778 png_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
794 png_uint_32 PNGAPI
795 png_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
839 png_uint_32 PNGAPI
840 png_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
860 png_uint_32 PNGAPI
861 png_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)
890 png_uint_32 PNGAPI
891 png_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
913 png_uint_32 PNGAPI
914 png_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 */
929 png_uint_32 PNGAPI
930 png_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
947 png_uint_32 PNGAPI
948 png_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
981 png_uint_32 PNGAPI
982 png_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
1000 png_uint_32 PNGAPI
1001 png_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
1018 int PNGAPI
1019 png_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
1044 png_uint_32 PNGAPI
1045 png_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
1062 png_uint_32 PNGAPI
1063 png_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
1108 int PNGAPI
1109 png_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
1123 png_byte PNGAPI
1124 png_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
1131 png_voidp PNGAPI
1132 png_get_user_chunk_ptr(png_const_structrp png_ptr)
1133 {
1134 return (png_ptr ? png_ptr->user_chunk_ptr : NULL);
1135 }
1136 #endif
1137
1138 png_size_t PNGAPI
1139 png_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 */
1164 png_uint_32 PNGAPI
1165 png_get_user_width_max (png_const_structrp png_ptr)
1166 {
1167 return (png_ptr ? png_ptr->user_width_max : 0);
1168 }
1169
1170 png_uint_32 PNGAPI
1171 png_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 */
1177 png_uint_32 PNGAPI
1178 png_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 */
1184 png_alloc_size_t PNGAPI
1185 png_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
1193 png_uint_32 PNGAPI
1194 png_get_io_state (png_const_structrp png_ptr)
1195 {
1196 return png_ptr->io_state;
1197 }
1198
1199 png_uint_32 PNGAPI
1200 png_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
1208 int PNGAPI
1209 png_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 */