sdk-world v2026.11.05
PS2 SDK - world tier (copyleft-allowed, non-essential packages)
Loading...
Searching...
No Matches
pngget.c
1/* pngget.c - retrieval of values from info struct
2 *
3 * Copyright (c) 2018-2025 Cosmin Truta
4 * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
5 * Copyright (c) 1996-1997 Andreas Dilger
6 * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
7 *
8 * This code is released under the libpng license.
9 * For conditions of distribution and use, see the disclaimer
10 * and license in png.h
11 *
12 */
13
14#include "pngpriv.h"
15
16#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
17
18png_uint_32 PNGAPI
19png_get_valid(png_const_structrp png_ptr, png_const_inforp info_ptr,
20 png_uint_32 flag)
21{
22 if (png_ptr != NULL && info_ptr != NULL)
23 {
24#ifdef PNG_READ_tRNS_SUPPORTED
25 /* png_handle_PLTE() may have canceled a valid tRNS chunk but left the
26 * 'valid' flag for the detection of duplicate chunks. Do not report a
27 * valid tRNS chunk in this case.
28 */
29 if (flag == PNG_INFO_tRNS && png_ptr->num_trans == 0)
30 return 0;
31#endif
32
33 return info_ptr->valid & flag;
34 }
35
36 return 0;
37}
38
39size_t PNGAPI
40png_get_rowbytes(png_const_structrp png_ptr, png_const_inforp info_ptr)
41{
42 if (png_ptr != NULL && info_ptr != NULL)
43 return info_ptr->rowbytes;
44
45 return 0;
46}
47
48#ifdef PNG_INFO_IMAGE_SUPPORTED
49png_bytepp PNGAPI
50png_get_rows(png_const_structrp png_ptr, png_const_inforp info_ptr)
51{
52 if (png_ptr != NULL && info_ptr != NULL)
53 return info_ptr->row_pointers;
54
55 return 0;
56}
57#endif
58
59#ifdef PNG_EASY_ACCESS_SUPPORTED
60/* Easy access to info, added in libpng-0.99 */
61png_uint_32 PNGAPI
62png_get_image_width(png_const_structrp png_ptr, png_const_inforp info_ptr)
63{
64 if (png_ptr != NULL && info_ptr != NULL)
65 return info_ptr->width;
66
67 return 0;
68}
69
70png_uint_32 PNGAPI
71png_get_image_height(png_const_structrp png_ptr, png_const_inforp info_ptr)
72{
73 if (png_ptr != NULL && info_ptr != NULL)
74 return info_ptr->height;
75
76 return 0;
77}
78
79png_byte PNGAPI
80png_get_bit_depth(png_const_structrp png_ptr, png_const_inforp info_ptr)
81{
82 if (png_ptr != NULL && info_ptr != NULL)
83 return info_ptr->bit_depth;
84
85 return 0;
86}
87
88png_byte PNGAPI
89png_get_color_type(png_const_structrp png_ptr, png_const_inforp info_ptr)
90{
91 if (png_ptr != NULL && info_ptr != NULL)
92 return info_ptr->color_type;
93
94 return 0;
95}
96
97png_byte PNGAPI
98png_get_filter_type(png_const_structrp png_ptr, png_const_inforp info_ptr)
99{
100 if (png_ptr != NULL && info_ptr != NULL)
101 return info_ptr->filter_type;
102
103 return 0;
104}
105
106png_byte PNGAPI
107png_get_interlace_type(png_const_structrp png_ptr, png_const_inforp info_ptr)
108{
109 if (png_ptr != NULL && info_ptr != NULL)
110 return info_ptr->interlace_type;
111
112 return 0;
113}
114
115png_byte PNGAPI
116png_get_compression_type(png_const_structrp png_ptr, png_const_inforp info_ptr)
117{
118 if (png_ptr != NULL && info_ptr != NULL)
119 return info_ptr->compression_type;
120
121 return 0;
122}
123
124png_uint_32 PNGAPI
125png_get_x_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp
126 info_ptr)
127{
128#ifdef PNG_pHYs_SUPPORTED
129 png_debug(1, "in png_get_x_pixels_per_meter");
130
131 if (png_ptr != NULL && info_ptr != NULL &&
132 (info_ptr->valid & PNG_INFO_pHYs) != 0)
133 {
134 if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER)
135 return info_ptr->x_pixels_per_unit;
136 }
137#else
138 PNG_UNUSED(png_ptr)
139 PNG_UNUSED(info_ptr)
140#endif
141
142 return 0;
143}
144
145png_uint_32 PNGAPI
146png_get_y_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp
147 info_ptr)
148{
149#ifdef PNG_pHYs_SUPPORTED
150 png_debug(1, "in png_get_y_pixels_per_meter");
151
152 if (png_ptr != NULL && info_ptr != NULL &&
153 (info_ptr->valid & PNG_INFO_pHYs) != 0)
154 {
155 if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER)
156 return info_ptr->y_pixels_per_unit;
157 }
158#else
159 PNG_UNUSED(png_ptr)
160 PNG_UNUSED(info_ptr)
161#endif
162
163 return 0;
164}
165
166png_uint_32 PNGAPI
167png_get_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp info_ptr)
168{
169#ifdef PNG_pHYs_SUPPORTED
170 png_debug(1, "in png_get_pixels_per_meter");
171
172 if (png_ptr != NULL && info_ptr != NULL &&
173 (info_ptr->valid & PNG_INFO_pHYs) != 0)
174 {
175 if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER &&
176 info_ptr->x_pixels_per_unit == info_ptr->y_pixels_per_unit)
177 return info_ptr->x_pixels_per_unit;
178 }
179#else
180 PNG_UNUSED(png_ptr)
181 PNG_UNUSED(info_ptr)
182#endif
183
184 return 0;
185}
186
187#ifdef PNG_FLOATING_POINT_SUPPORTED
188float PNGAPI
189png_get_pixel_aspect_ratio(png_const_structrp png_ptr, png_const_inforp
190 info_ptr)
191{
192#ifdef PNG_READ_pHYs_SUPPORTED
193 png_debug(1, "in png_get_pixel_aspect_ratio");
194
195 if (png_ptr != NULL && info_ptr != NULL &&
196 (info_ptr->valid & PNG_INFO_pHYs) != 0)
197 {
198 if (info_ptr->x_pixels_per_unit != 0)
199 return (float)info_ptr->y_pixels_per_unit
200 / (float)info_ptr->x_pixels_per_unit;
201 }
202#else
203 PNG_UNUSED(png_ptr)
204 PNG_UNUSED(info_ptr)
205#endif
206
207 return (float)0.0;
208}
209#endif
210
211#ifdef PNG_FIXED_POINT_SUPPORTED
212png_fixed_point PNGAPI
213png_get_pixel_aspect_ratio_fixed(png_const_structrp png_ptr,
214 png_const_inforp info_ptr)
215{
216#ifdef PNG_READ_pHYs_SUPPORTED
217 png_debug(1, "in png_get_pixel_aspect_ratio_fixed");
218
219 if (png_ptr != NULL && info_ptr != NULL &&
220 (info_ptr->valid & PNG_INFO_pHYs) != 0 &&
221 info_ptr->x_pixels_per_unit > 0 && info_ptr->y_pixels_per_unit > 0 &&
222 info_ptr->x_pixels_per_unit <= PNG_UINT_31_MAX &&
223 info_ptr->y_pixels_per_unit <= PNG_UINT_31_MAX)
224 {
225 png_fixed_point res;
226
227 /* The following casts work because a PNG 4 byte integer only has a valid
228 * range of 0..2^31-1; otherwise the cast might overflow.
229 */
230 if (png_muldiv(&res, (png_int_32)info_ptr->y_pixels_per_unit, PNG_FP_1,
231 (png_int_32)info_ptr->x_pixels_per_unit) != 0)
232 return res;
233 }
234#else
235 PNG_UNUSED(png_ptr)
236 PNG_UNUSED(info_ptr)
237#endif
238
239 return 0;
240}
241#endif
242
243png_int_32 PNGAPI
244png_get_x_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr)
245{
246#ifdef PNG_oFFs_SUPPORTED
247 png_debug(1, "in png_get_x_offset_microns");
248
249 if (png_ptr != NULL && info_ptr != NULL &&
250 (info_ptr->valid & PNG_INFO_oFFs) != 0)
251 {
252 if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER)
253 return info_ptr->x_offset;
254 }
255#else
256 PNG_UNUSED(png_ptr)
257 PNG_UNUSED(info_ptr)
258#endif
259
260 return 0;
261}
262
263png_int_32 PNGAPI
264png_get_y_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr)
265{
266#ifdef PNG_oFFs_SUPPORTED
267 png_debug(1, "in png_get_y_offset_microns");
268
269 if (png_ptr != NULL && info_ptr != NULL &&
270 (info_ptr->valid & PNG_INFO_oFFs) != 0)
271 {
272 if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER)
273 return info_ptr->y_offset;
274 }
275#else
276 PNG_UNUSED(png_ptr)
277 PNG_UNUSED(info_ptr)
278#endif
279
280 return 0;
281}
282
283png_int_32 PNGAPI
284png_get_x_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr)
285{
286#ifdef PNG_oFFs_SUPPORTED
287 png_debug(1, "in png_get_x_offset_pixels");
288
289 if (png_ptr != NULL && info_ptr != NULL &&
290 (info_ptr->valid & PNG_INFO_oFFs) != 0)
291 {
292 if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL)
293 return info_ptr->x_offset;
294 }
295#else
296 PNG_UNUSED(png_ptr)
297 PNG_UNUSED(info_ptr)
298#endif
299
300 return 0;
301}
302
303png_int_32 PNGAPI
304png_get_y_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr)
305{
306#ifdef PNG_oFFs_SUPPORTED
307 png_debug(1, "in png_get_y_offset_pixels");
308
309 if (png_ptr != NULL && info_ptr != NULL &&
310 (info_ptr->valid & PNG_INFO_oFFs) != 0)
311 {
312 if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL)
313 return info_ptr->y_offset;
314 }
315#else
316 PNG_UNUSED(png_ptr)
317 PNG_UNUSED(info_ptr)
318#endif
319
320 return 0;
321}
322
323#ifdef PNG_INCH_CONVERSIONS_SUPPORTED
324static png_uint_32
325ppi_from_ppm(png_uint_32 ppm)
326{
327#if 0
328 /* The conversion is *(2.54/100), in binary (32 digits):
329 * .00000110100000001001110101001001
330 */
331 png_uint_32 t1001, t1101;
332 ppm >>= 1; /* .1 */
333 t1001 = ppm + (ppm >> 3); /* .1001 */
334 t1101 = t1001 + (ppm >> 1); /* .1101 */
335 ppm >>= 20; /* .000000000000000000001 */
336 t1101 += t1101 >> 15; /* .1101000000000001101 */
337 t1001 >>= 11; /* .000000000001001 */
338 t1001 += t1001 >> 12; /* .000000000001001000000001001 */
339 ppm += t1001; /* .000000000001001000001001001 */
340 ppm += t1101; /* .110100000001001110101001001 */
341 return (ppm + 16) >> 5;/* .00000110100000001001110101001001 */
342#else
343 /* The argument is a PNG unsigned integer, so it is not permitted
344 * to be bigger than 2^31.
345 */
346 png_fixed_point result;
347 if (ppm <= PNG_UINT_31_MAX && png_muldiv(&result, (png_int_32)ppm, 127,
348 5000) != 0)
349 return (png_uint_32)result;
350
351 /* Overflow. */
352 return 0;
353#endif
354}
355
356png_uint_32 PNGAPI
357png_get_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)
358{
359 return ppi_from_ppm(png_get_pixels_per_meter(png_ptr, info_ptr));
360}
361
362png_uint_32 PNGAPI
363png_get_x_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)
364{
365 return ppi_from_ppm(png_get_x_pixels_per_meter(png_ptr, info_ptr));
366}
367
368png_uint_32 PNGAPI
369png_get_y_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)
370{
371 return ppi_from_ppm(png_get_y_pixels_per_meter(png_ptr, info_ptr));
372}
373
374#ifdef PNG_FIXED_POINT_SUPPORTED
375static png_fixed_point
376png_fixed_inches_from_microns(png_const_structrp png_ptr, png_int_32 microns)
377{
378 /* Convert from meters * 1,000,000 to inches * 100,000, meters to
379 * inches is simply *(100/2.54), so we want *(10/2.54) == 500/127.
380 * Notice that this can overflow - a warning is output and 0 is
381 * returned.
382 */
383 png_fixed_point result;
384
385 if (png_muldiv(&result, microns, 500, 127) != 0)
386 return result;
387
388 png_warning(png_ptr, "fixed point overflow ignored");
389 return 0;
390}
391
392png_fixed_point PNGAPI
393png_get_x_offset_inches_fixed(png_const_structrp png_ptr,
394 png_const_inforp info_ptr)
395{
396 return png_fixed_inches_from_microns(png_ptr,
397 png_get_x_offset_microns(png_ptr, info_ptr));
398}
399#endif /* FIXED_POINT */
400
401#ifdef PNG_FIXED_POINT_SUPPORTED
402png_fixed_point PNGAPI
403png_get_y_offset_inches_fixed(png_const_structrp png_ptr,
404 png_const_inforp info_ptr)
405{
406 return png_fixed_inches_from_microns(png_ptr,
407 png_get_y_offset_microns(png_ptr, info_ptr));
408}
409#endif
410
411#ifdef PNG_FLOATING_POINT_SUPPORTED
412float PNGAPI
413png_get_x_offset_inches(png_const_structrp png_ptr, png_const_inforp info_ptr)
414{
415 /* To avoid the overflow do the conversion directly in floating
416 * point.
417 */
418 return (float)(png_get_x_offset_microns(png_ptr, info_ptr) * .00003937);
419}
420#endif
421
422#ifdef PNG_FLOATING_POINT_SUPPORTED
423float PNGAPI
424png_get_y_offset_inches(png_const_structrp png_ptr, png_const_inforp info_ptr)
425{
426 /* To avoid the overflow do the conversion directly in floating
427 * point.
428 */
429 return (float)(png_get_y_offset_microns(png_ptr, info_ptr) * .00003937);
430}
431#endif
432
433#ifdef PNG_pHYs_SUPPORTED
434png_uint_32 PNGAPI
435png_get_pHYs_dpi(png_const_structrp png_ptr, png_const_inforp info_ptr,
436 png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
437{
438 png_uint_32 retval = 0;
439
440 png_debug1(1, "in %s retrieval function", "pHYs");
441
442 if (png_ptr != NULL && info_ptr != NULL &&
443 (info_ptr->valid & PNG_INFO_pHYs) != 0)
444 {
445 if (res_x != NULL)
446 {
447 *res_x = info_ptr->x_pixels_per_unit;
448 retval |= PNG_INFO_pHYs;
449 }
450
451 if (res_y != NULL)
452 {
453 *res_y = info_ptr->y_pixels_per_unit;
454 retval |= PNG_INFO_pHYs;
455 }
456
457 if (unit_type != NULL)
458 {
459 *unit_type = (int)info_ptr->phys_unit_type;
460 retval |= PNG_INFO_pHYs;
461
462 if (*unit_type == 1)
463 {
464 if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50);
465 if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50);
466 }
467 }
468 }
469
470 return retval;
471}
472#endif /* pHYs */
473#endif /* INCH_CONVERSIONS */
474
475/* png_get_channels really belongs in here, too, but it's been around longer */
476
477#endif /* EASY_ACCESS */
478
479
480png_byte PNGAPI
481png_get_channels(png_const_structrp png_ptr, png_const_inforp info_ptr)
482{
483 if (png_ptr != NULL && info_ptr != NULL)
484 return info_ptr->channels;
485
486 return 0;
487}
488
489#ifdef PNG_READ_SUPPORTED
490png_const_bytep PNGAPI
491png_get_signature(png_const_structrp png_ptr, png_const_inforp info_ptr)
492{
493 if (png_ptr != NULL && info_ptr != NULL)
494 return info_ptr->signature;
495
496 return NULL;
497}
498#endif
499
500#ifdef PNG_bKGD_SUPPORTED
501png_uint_32 PNGAPI
502png_get_bKGD(png_const_structrp png_ptr, png_inforp info_ptr,
503 png_color_16p *background)
504{
505 png_debug1(1, "in %s retrieval function", "bKGD");
506
507 if (png_ptr != NULL && info_ptr != NULL &&
508 (info_ptr->valid & PNG_INFO_bKGD) != 0 &&
509 background != NULL)
510 {
511 *background = &(info_ptr->background);
512 return PNG_INFO_bKGD;
513 }
514
515 return 0;
516}
517#endif
518
519#ifdef PNG_cHRM_SUPPORTED
520/* The XYZ APIs were added in 1.5.5 to take advantage of the code added at the
521 * same time to correct the rgb grayscale coefficient defaults obtained from the
522 * cHRM chunk in 1.5.4
523 */
524# ifdef PNG_FLOATING_POINT_SUPPORTED
525png_uint_32 PNGAPI
526png_get_cHRM(png_const_structrp png_ptr, png_const_inforp info_ptr,
527 double *whitex, double *whitey, double *redx, double *redy,
528 double *greenx, double *greeny, double *bluex, double *bluey)
529{
530 png_debug1(1, "in %s retrieval function", "cHRM");
531
532 /* PNGv3: this just returns the values store from the cHRM, if any. */
533 if (png_ptr != NULL && info_ptr != NULL &&
534 (info_ptr->valid & PNG_INFO_cHRM) != 0)
535 {
536 if (whitex != NULL)
537 *whitex = png_float(png_ptr, info_ptr->cHRM.whitex, "cHRM wx");
538 if (whitey != NULL)
539 *whitey = png_float(png_ptr, info_ptr->cHRM.whitey, "cHRM wy");
540 if (redx != NULL)
541 *redx = png_float(png_ptr, info_ptr->cHRM.redx, "cHRM rx");
542 if (redy != NULL)
543 *redy = png_float(png_ptr, info_ptr->cHRM.redy, "cHRM ry");
544 if (greenx != NULL)
545 *greenx = png_float(png_ptr, info_ptr->cHRM.greenx, "cHRM gx");
546 if (greeny != NULL)
547 *greeny = png_float(png_ptr, info_ptr->cHRM.greeny, "cHRM gy");
548 if (bluex != NULL)
549 *bluex = png_float(png_ptr, info_ptr->cHRM.bluex, "cHRM bx");
550 if (bluey != NULL)
551 *bluey = png_float(png_ptr, info_ptr->cHRM.bluey, "cHRM by");
552 return PNG_INFO_cHRM;
553 }
554
555 return 0;
556}
557
558png_uint_32 PNGAPI
559png_get_cHRM_XYZ(png_const_structrp png_ptr, png_const_inforp info_ptr,
560 double *red_X, double *red_Y, double *red_Z, double *green_X,
561 double *green_Y, double *green_Z, double *blue_X, double *blue_Y,
562 double *blue_Z)
563{
564 png_XYZ XYZ;
565 png_debug1(1, "in %s retrieval function", "cHRM_XYZ(float)");
566
567 if (png_ptr != NULL && info_ptr != NULL &&
568 (info_ptr->valid & PNG_INFO_cHRM) != 0 &&
569 png_XYZ_from_xy(&XYZ, &info_ptr->cHRM) == 0)
570 {
571 if (red_X != NULL)
572 *red_X = png_float(png_ptr, XYZ.red_X, "cHRM red X");
573 if (red_Y != NULL)
574 *red_Y = png_float(png_ptr, XYZ.red_Y, "cHRM red Y");
575 if (red_Z != NULL)
576 *red_Z = png_float(png_ptr, XYZ.red_Z, "cHRM red Z");
577 if (green_X != NULL)
578 *green_X = png_float(png_ptr, XYZ.green_X, "cHRM green X");
579 if (green_Y != NULL)
580 *green_Y = png_float(png_ptr, XYZ.green_Y, "cHRM green Y");
581 if (green_Z != NULL)
582 *green_Z = png_float(png_ptr, XYZ.green_Z, "cHRM green Z");
583 if (blue_X != NULL)
584 *blue_X = png_float(png_ptr, XYZ.blue_X, "cHRM blue X");
585 if (blue_Y != NULL)
586 *blue_Y = png_float(png_ptr, XYZ.blue_Y, "cHRM blue Y");
587 if (blue_Z != NULL)
588 *blue_Z = png_float(png_ptr, XYZ.blue_Z, "cHRM blue Z");
589 return PNG_INFO_cHRM;
590 }
591
592 return 0;
593}
594# endif
595
596# ifdef PNG_FIXED_POINT_SUPPORTED
597png_uint_32 PNGAPI
598png_get_cHRM_XYZ_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
599 png_fixed_point *int_red_X, png_fixed_point *int_red_Y,
600 png_fixed_point *int_red_Z, png_fixed_point *int_green_X,
601 png_fixed_point *int_green_Y, png_fixed_point *int_green_Z,
602 png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y,
603 png_fixed_point *int_blue_Z)
604{
605 png_XYZ XYZ;
606 png_debug1(1, "in %s retrieval function", "cHRM_XYZ");
607
608 if (png_ptr != NULL && info_ptr != NULL &&
609 (info_ptr->valid & PNG_INFO_cHRM) != 0U &&
610 png_XYZ_from_xy(&XYZ, &info_ptr->cHRM) == 0)
611 {
612 if (int_red_X != NULL) *int_red_X = XYZ.red_X;
613 if (int_red_Y != NULL) *int_red_Y = XYZ.red_Y;
614 if (int_red_Z != NULL) *int_red_Z = XYZ.red_Z;
615 if (int_green_X != NULL) *int_green_X = XYZ.green_X;
616 if (int_green_Y != NULL) *int_green_Y = XYZ.green_Y;
617 if (int_green_Z != NULL) *int_green_Z = XYZ.green_Z;
618 if (int_blue_X != NULL) *int_blue_X = XYZ.blue_X;
619 if (int_blue_Y != NULL) *int_blue_Y = XYZ.blue_Y;
620 if (int_blue_Z != NULL) *int_blue_Z = XYZ.blue_Z;
621 return PNG_INFO_cHRM;
622 }
623
624 return 0;
625}
626
627png_uint_32 PNGAPI
628png_get_cHRM_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
629 png_fixed_point *whitex, png_fixed_point *whitey, png_fixed_point *redx,
630 png_fixed_point *redy, png_fixed_point *greenx, png_fixed_point *greeny,
631 png_fixed_point *bluex, png_fixed_point *bluey)
632{
633 png_debug1(1, "in %s retrieval function", "cHRM");
634
635 /* PNGv3: this just returns the values store from the cHRM, if any. */
636 if (png_ptr != NULL && info_ptr != NULL &&
637 (info_ptr->valid & PNG_INFO_cHRM) != 0)
638 {
639 if (whitex != NULL) *whitex = info_ptr->cHRM.whitex;
640 if (whitey != NULL) *whitey = info_ptr->cHRM.whitey;
641 if (redx != NULL) *redx = info_ptr->cHRM.redx;
642 if (redy != NULL) *redy = info_ptr->cHRM.redy;
643 if (greenx != NULL) *greenx = info_ptr->cHRM.greenx;
644 if (greeny != NULL) *greeny = info_ptr->cHRM.greeny;
645 if (bluex != NULL) *bluex = info_ptr->cHRM.bluex;
646 if (bluey != NULL) *bluey = info_ptr->cHRM.bluey;
647 return PNG_INFO_cHRM;
648 }
649
650 return 0;
651}
652# endif
653#endif
654
655#ifdef PNG_gAMA_SUPPORTED
656# ifdef PNG_FIXED_POINT_SUPPORTED
657png_uint_32 PNGAPI
658png_get_gAMA_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
659 png_fixed_point *file_gamma)
660{
661 png_debug1(1, "in %s retrieval function", "gAMA");
662
663 /* PNGv3 compatibility: only report gAMA if it is really present. */
664 if (png_ptr != NULL && info_ptr != NULL &&
665 (info_ptr->valid & PNG_INFO_gAMA) != 0)
666 {
667 if (file_gamma != NULL) *file_gamma = info_ptr->gamma;
668 return PNG_INFO_gAMA;
669 }
670
671 return 0;
672}
673# endif
674
675# ifdef PNG_FLOATING_POINT_SUPPORTED
676png_uint_32 PNGAPI
677png_get_gAMA(png_const_structrp png_ptr, png_const_inforp info_ptr,
678 double *file_gamma)
679{
680 png_debug1(1, "in %s retrieval function", "gAMA(float)");
681
682 /* PNGv3 compatibility: only report gAMA if it is really present. */
683 if (png_ptr != NULL && info_ptr != NULL &&
684 (info_ptr->valid & PNG_INFO_gAMA) != 0)
685 {
686 if (file_gamma != NULL)
687 *file_gamma = png_float(png_ptr, info_ptr->gamma, "gAMA");
688
689 return PNG_INFO_gAMA;
690 }
691
692 return 0;
693}
694# endif
695#endif
696
697#ifdef PNG_sRGB_SUPPORTED
698png_uint_32 PNGAPI
699png_get_sRGB(png_const_structrp png_ptr, png_const_inforp info_ptr,
700 int *file_srgb_intent)
701{
702 png_debug1(1, "in %s retrieval function", "sRGB");
703
704 if (png_ptr != NULL && info_ptr != NULL &&
705 (info_ptr->valid & PNG_INFO_sRGB) != 0)
706 {
707 if (file_srgb_intent != NULL)
708 *file_srgb_intent = info_ptr->rendering_intent;
709 return PNG_INFO_sRGB;
710 }
711
712 return 0;
713}
714#endif
715
716#ifdef PNG_iCCP_SUPPORTED
717png_uint_32 PNGAPI
718png_get_iCCP(png_const_structrp png_ptr, png_inforp info_ptr,
719 png_charpp name, int *compression_type,
720 png_bytepp profile, png_uint_32 *proflen)
721{
722 png_debug1(1, "in %s retrieval function", "iCCP");
723
724 if (png_ptr != NULL && info_ptr != NULL &&
725 (info_ptr->valid & PNG_INFO_iCCP) != 0 &&
726 name != NULL && profile != NULL && proflen != NULL)
727 {
728 *name = info_ptr->iccp_name;
729 *profile = info_ptr->iccp_profile;
730 *proflen = png_get_uint_32(info_ptr->iccp_profile);
731 /* This is somewhat irrelevant since the profile data returned has
732 * actually been uncompressed.
733 */
734 if (compression_type != NULL)
735 *compression_type = PNG_COMPRESSION_TYPE_BASE;
736 return PNG_INFO_iCCP;
737 }
738
739 return 0;
740
741}
742#endif
743
744#ifdef PNG_sPLT_SUPPORTED
745int PNGAPI
746png_get_sPLT(png_const_structrp png_ptr, png_inforp info_ptr,
747 png_sPLT_tpp spalettes)
748{
749 png_debug1(1, "in %s retrieval function", "sPLT");
750
751 if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL)
752 {
753 *spalettes = info_ptr->splt_palettes;
754 return info_ptr->splt_palettes_num;
755 }
756
757 return 0;
758}
759#endif
760
761#ifdef PNG_cICP_SUPPORTED
762png_uint_32 PNGAPI
763png_get_cICP(png_const_structrp png_ptr,
764 png_const_inforp info_ptr, png_bytep colour_primaries,
765 png_bytep transfer_function, png_bytep matrix_coefficients,
766 png_bytep video_full_range_flag)
767{
768 png_debug1(1, "in %s retrieval function", "cICP");
769
770 if (png_ptr != NULL && info_ptr != NULL &&
771 (info_ptr->valid & PNG_INFO_cICP) != 0 &&
772 colour_primaries != NULL && transfer_function != NULL &&
773 matrix_coefficients != NULL && video_full_range_flag != NULL)
774 {
775 *colour_primaries = info_ptr->cicp_colour_primaries;
776 *transfer_function = info_ptr->cicp_transfer_function;
777 *matrix_coefficients = info_ptr->cicp_matrix_coefficients;
778 *video_full_range_flag = info_ptr->cicp_video_full_range_flag;
779 return (PNG_INFO_cICP);
780 }
781
782 return 0;
783}
784#endif
785
786#ifdef PNG_cLLI_SUPPORTED
787# ifdef PNG_FIXED_POINT_SUPPORTED
788png_uint_32 PNGAPI
789png_get_cLLI_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
790 png_uint_32p maxCLL,
791 png_uint_32p maxFALL)
792{
793 png_debug1(1, "in %s retrieval function", "cLLI");
794
795 if (png_ptr != NULL && info_ptr != NULL &&
796 (info_ptr->valid & PNG_INFO_cLLI) != 0)
797 {
798 if (maxCLL != NULL) *maxCLL = info_ptr->maxCLL;
799 if (maxFALL != NULL) *maxFALL = info_ptr->maxFALL;
800 return PNG_INFO_cLLI;
801 }
802
803 return 0;
804}
805# endif
806
807# ifdef PNG_FLOATING_POINT_SUPPORTED
808png_uint_32 PNGAPI
809png_get_cLLI(png_const_structrp png_ptr, png_const_inforp info_ptr,
810 double *maxCLL, double *maxFALL)
811{
812 png_debug1(1, "in %s retrieval function", "cLLI(float)");
813
814 if (png_ptr != NULL && info_ptr != NULL &&
815 (info_ptr->valid & PNG_INFO_cLLI) != 0)
816 {
817 if (maxCLL != NULL) *maxCLL = info_ptr->maxCLL * .0001;
818 if (maxFALL != NULL) *maxFALL = info_ptr->maxFALL * .0001;
819 return PNG_INFO_cLLI;
820 }
821
822 return 0;
823}
824# endif
825#endif /* cLLI */
826
827#ifdef PNG_mDCV_SUPPORTED
828# ifdef PNG_FIXED_POINT_SUPPORTED
829png_uint_32 PNGAPI
830png_get_mDCV_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
831 png_fixed_point *white_x, png_fixed_point *white_y,
832 png_fixed_point *red_x, png_fixed_point *red_y,
833 png_fixed_point *green_x, png_fixed_point *green_y,
834 png_fixed_point *blue_x, png_fixed_point *blue_y,
835 png_uint_32p mastering_maxDL, png_uint_32p mastering_minDL)
836{
837 png_debug1(1, "in %s retrieval function", "mDCV");
838
839 if (png_ptr != NULL && info_ptr != NULL &&
840 (info_ptr->valid & PNG_INFO_mDCV) != 0)
841 {
842 if (white_x != NULL) *white_x = info_ptr->mastering_white_x * 2;
843 if (white_y != NULL) *white_y = info_ptr->mastering_white_y * 2;
844 if (red_x != NULL) *red_x = info_ptr->mastering_red_x * 2;
845 if (red_y != NULL) *red_y = info_ptr->mastering_red_y * 2;
846 if (green_x != NULL) *green_x = info_ptr->mastering_green_x * 2;
847 if (green_y != NULL) *green_y = info_ptr->mastering_green_y * 2;
848 if (blue_x != NULL) *blue_x = info_ptr->mastering_blue_x * 2;
849 if (blue_y != NULL) *blue_y = info_ptr->mastering_blue_y * 2;
850 if (mastering_maxDL != NULL) *mastering_maxDL = info_ptr->mastering_maxDL;
851 if (mastering_minDL != NULL) *mastering_minDL = info_ptr->mastering_minDL;
852 return PNG_INFO_mDCV;
853 }
854
855 return 0;
856}
857# endif
858
859# ifdef PNG_FLOATING_POINT_SUPPORTED
860png_uint_32 PNGAPI
861png_get_mDCV(png_const_structrp png_ptr, png_const_inforp info_ptr,
862 double *white_x, double *white_y, double *red_x, double *red_y,
863 double *green_x, double *green_y, double *blue_x, double *blue_y,
864 double *mastering_maxDL, double *mastering_minDL)
865{
866 png_debug1(1, "in %s retrieval function", "mDCV(float)");
867
868 if (png_ptr != NULL && info_ptr != NULL &&
869 (info_ptr->valid & PNG_INFO_mDCV) != 0)
870 {
871 if (white_x != NULL) *white_x = info_ptr->mastering_white_x * .00002;
872 if (white_y != NULL) *white_y = info_ptr->mastering_white_y * .00002;
873 if (red_x != NULL) *red_x = info_ptr->mastering_red_x * .00002;
874 if (red_y != NULL) *red_y = info_ptr->mastering_red_y * .00002;
875 if (green_x != NULL) *green_x = info_ptr->mastering_green_x * .00002;
876 if (green_y != NULL) *green_y = info_ptr->mastering_green_y * .00002;
877 if (blue_x != NULL) *blue_x = info_ptr->mastering_blue_x * .00002;
878 if (blue_y != NULL) *blue_y = info_ptr->mastering_blue_y * .00002;
879 if (mastering_maxDL != NULL)
880 *mastering_maxDL = info_ptr->mastering_maxDL * .0001;
881 if (mastering_minDL != NULL)
882 *mastering_minDL = info_ptr->mastering_minDL * .0001;
883 return PNG_INFO_mDCV;
884 }
885
886 return 0;
887}
888# endif /* FLOATING_POINT */
889#endif /* mDCV */
890
891#ifdef PNG_eXIf_SUPPORTED
892png_uint_32 PNGAPI
893png_get_eXIf(png_const_structrp png_ptr, png_inforp info_ptr,
894 png_bytep *exif)
895{
896 png_warning(png_ptr, "png_get_eXIf does not work; use png_get_eXIf_1");
897 PNG_UNUSED(info_ptr)
898 PNG_UNUSED(exif)
899 return 0;
900}
901
902png_uint_32 PNGAPI
903png_get_eXIf_1(png_const_structrp png_ptr, png_const_inforp info_ptr,
904 png_uint_32 *num_exif, png_bytep *exif)
905{
906 png_debug1(1, "in %s retrieval function", "eXIf");
907
908 if (png_ptr != NULL && info_ptr != NULL &&
909 (info_ptr->valid & PNG_INFO_eXIf) != 0 && exif != NULL)
910 {
911 *num_exif = info_ptr->num_exif;
912 *exif = info_ptr->exif;
913 return PNG_INFO_eXIf;
914 }
915
916 return 0;
917}
918#endif
919
920#ifdef PNG_hIST_SUPPORTED
921png_uint_32 PNGAPI
922png_get_hIST(png_const_structrp png_ptr, png_inforp info_ptr,
923 png_uint_16p *hist)
924{
925 png_debug1(1, "in %s retrieval function", "hIST");
926
927 if (png_ptr != NULL && info_ptr != NULL &&
928 (info_ptr->valid & PNG_INFO_hIST) != 0 && hist != NULL)
929 {
930 *hist = info_ptr->hist;
931 return PNG_INFO_hIST;
932 }
933
934 return 0;
935}
936#endif
937
938png_uint_32 PNGAPI
939png_get_IHDR(png_const_structrp png_ptr, png_const_inforp info_ptr,
940 png_uint_32 *width, png_uint_32 *height, int *bit_depth,
941 int *color_type, int *interlace_type, int *compression_type,
942 int *filter_type)
943{
944 png_debug1(1, "in %s retrieval function", "IHDR");
945
946 if (png_ptr == NULL || info_ptr == NULL)
947 return 0;
948
949 if (width != NULL)
950 *width = info_ptr->width;
951
952 if (height != NULL)
953 *height = info_ptr->height;
954
955 if (bit_depth != NULL)
956 *bit_depth = info_ptr->bit_depth;
957
958 if (color_type != NULL)
959 *color_type = info_ptr->color_type;
960
961 if (compression_type != NULL)
962 *compression_type = info_ptr->compression_type;
963
964 if (filter_type != NULL)
965 *filter_type = info_ptr->filter_type;
966
967 if (interlace_type != NULL)
968 *interlace_type = info_ptr->interlace_type;
969
970 /* This is redundant if we can be sure that the info_ptr values were all
971 * assigned in png_set_IHDR(). We do the check anyhow in case an
972 * application has ignored our advice not to mess with the members
973 * of info_ptr directly.
974 */
975 png_check_IHDR(png_ptr, info_ptr->width, info_ptr->height,
976 info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,
977 info_ptr->compression_type, info_ptr->filter_type);
978
979 return 1;
980}
981
982#ifdef PNG_oFFs_SUPPORTED
983png_uint_32 PNGAPI
984png_get_oFFs(png_const_structrp png_ptr, png_const_inforp info_ptr,
985 png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)
986{
987 png_debug1(1, "in %s retrieval function", "oFFs");
988
989 if (png_ptr != NULL && info_ptr != NULL &&
990 (info_ptr->valid & PNG_INFO_oFFs) != 0 &&
991 offset_x != NULL && offset_y != NULL && unit_type != NULL)
992 {
993 *offset_x = info_ptr->x_offset;
994 *offset_y = info_ptr->y_offset;
995 *unit_type = (int)info_ptr->offset_unit_type;
996 return PNG_INFO_oFFs;
997 }
998
999 return 0;
1000}
1001#endif
1002
1003#ifdef PNG_pCAL_SUPPORTED
1004png_uint_32 PNGAPI
1005png_get_pCAL(png_const_structrp png_ptr, png_inforp info_ptr,
1006 png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,
1007 png_charp *units, png_charpp *params)
1008{
1009 png_debug1(1, "in %s retrieval function", "pCAL");
1010
1011 if (png_ptr != NULL && info_ptr != NULL &&
1012 (info_ptr->valid & PNG_INFO_pCAL) != 0 &&
1013 purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
1014 nparams != NULL && units != NULL && params != NULL)
1015 {
1016 *purpose = info_ptr->pcal_purpose;
1017 *X0 = info_ptr->pcal_X0;
1018 *X1 = info_ptr->pcal_X1;
1019 *type = (int)info_ptr->pcal_type;
1020 *nparams = (int)info_ptr->pcal_nparams;
1021 *units = info_ptr->pcal_units;
1022 *params = info_ptr->pcal_params;
1023 return PNG_INFO_pCAL;
1024 }
1025
1026 return 0;
1027}
1028#endif
1029
1030#ifdef PNG_sCAL_SUPPORTED
1031# ifdef PNG_FIXED_POINT_SUPPORTED
1032# if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || \
1033 defined(PNG_FLOATING_POINT_SUPPORTED)
1034png_uint_32 PNGAPI
1035png_get_sCAL_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
1036 int *unit, png_fixed_point *width, png_fixed_point *height)
1037{
1038 png_debug1(1, "in %s retrieval function", "sCAL");
1039
1040 if (png_ptr != NULL && info_ptr != NULL &&
1041 (info_ptr->valid & PNG_INFO_sCAL) != 0)
1042 {
1043 *unit = info_ptr->scal_unit;
1044 /*TODO: make this work without FP support; the API is currently eliminated
1045 * if neither floating point APIs nor internal floating point arithmetic
1046 * are enabled.
1047 */
1048 *width = png_fixed(png_ptr, atof(info_ptr->scal_s_width), "sCAL width");
1049 *height = png_fixed(png_ptr, atof(info_ptr->scal_s_height),
1050 "sCAL height");
1051 return PNG_INFO_sCAL;
1052 }
1053
1054 return 0;
1055}
1056# endif /* FLOATING_ARITHMETIC */
1057# endif /* FIXED_POINT */
1058# ifdef PNG_FLOATING_POINT_SUPPORTED
1059png_uint_32 PNGAPI
1060png_get_sCAL(png_const_structrp png_ptr, png_const_inforp info_ptr,
1061 int *unit, double *width, double *height)
1062{
1063 png_debug1(1, "in %s retrieval function", "sCAL(float)");
1064
1065 if (png_ptr != NULL && info_ptr != NULL &&
1066 (info_ptr->valid & PNG_INFO_sCAL) != 0)
1067 {
1068 *unit = info_ptr->scal_unit;
1069 *width = atof(info_ptr->scal_s_width);
1070 *height = atof(info_ptr->scal_s_height);
1071 return PNG_INFO_sCAL;
1072 }
1073
1074 return 0;
1075}
1076# endif /* FLOATING POINT */
1077png_uint_32 PNGAPI
1078png_get_sCAL_s(png_const_structrp png_ptr, png_const_inforp info_ptr,
1079 int *unit, png_charpp width, png_charpp height)
1080{
1081 png_debug1(1, "in %s retrieval function", "sCAL(str)");
1082
1083 if (png_ptr != NULL && info_ptr != NULL &&
1084 (info_ptr->valid & PNG_INFO_sCAL) != 0)
1085 {
1086 *unit = info_ptr->scal_unit;
1087 *width = info_ptr->scal_s_width;
1088 *height = info_ptr->scal_s_height;
1089 return PNG_INFO_sCAL;
1090 }
1091
1092 return 0;
1093}
1094#endif /* sCAL */
1095
1096#ifdef PNG_pHYs_SUPPORTED
1097png_uint_32 PNGAPI
1098png_get_pHYs(png_const_structrp png_ptr, png_const_inforp info_ptr,
1099 png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
1100{
1101 png_uint_32 retval = 0;
1102
1103 png_debug1(1, "in %s retrieval function", "pHYs");
1104
1105 if (png_ptr != NULL && info_ptr != NULL &&
1106 (info_ptr->valid & PNG_INFO_pHYs) != 0)
1107 {
1108 if (res_x != NULL)
1109 {
1110 *res_x = info_ptr->x_pixels_per_unit;
1111 retval |= PNG_INFO_pHYs;
1112 }
1113
1114 if (res_y != NULL)
1115 {
1116 *res_y = info_ptr->y_pixels_per_unit;
1117 retval |= PNG_INFO_pHYs;
1118 }
1119
1120 if (unit_type != NULL)
1121 {
1122 *unit_type = (int)info_ptr->phys_unit_type;
1123 retval |= PNG_INFO_pHYs;
1124 }
1125 }
1126
1127 return retval;
1128}
1129#endif /* pHYs */
1130
1131png_uint_32 PNGAPI
1132png_get_PLTE(png_const_structrp png_ptr, png_inforp info_ptr,
1133 png_colorp *palette, int *num_palette)
1134{
1135 png_debug1(1, "in %s retrieval function", "PLTE");
1136
1137 if (png_ptr != NULL && info_ptr != NULL &&
1138 (info_ptr->valid & PNG_INFO_PLTE) != 0 && palette != NULL)
1139 {
1140 *palette = info_ptr->palette;
1141 *num_palette = info_ptr->num_palette;
1142 png_debug1(3, "num_palette = %d", *num_palette);
1143 return PNG_INFO_PLTE;
1144 }
1145
1146 return 0;
1147}
1148
1149#ifdef PNG_sBIT_SUPPORTED
1150png_uint_32 PNGAPI
1151png_get_sBIT(png_const_structrp png_ptr, png_inforp info_ptr,
1152 png_color_8p *sig_bit)
1153{
1154 png_debug1(1, "in %s retrieval function", "sBIT");
1155
1156 if (png_ptr != NULL && info_ptr != NULL &&
1157 (info_ptr->valid & PNG_INFO_sBIT) != 0 && sig_bit != NULL)
1158 {
1159 *sig_bit = &(info_ptr->sig_bit);
1160 return PNG_INFO_sBIT;
1161 }
1162
1163 return 0;
1164}
1165#endif
1166
1167#ifdef PNG_TEXT_SUPPORTED
1168int PNGAPI
1169png_get_text(png_const_structrp png_ptr, png_inforp info_ptr,
1170 png_textp *text_ptr, int *num_text)
1171{
1172 if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)
1173 {
1174 png_debug1(1, "in text retrieval function, chunk typeid = 0x%lx",
1175 (unsigned long)png_ptr->chunk_name);
1176
1177 if (text_ptr != NULL)
1178 *text_ptr = info_ptr->text;
1179
1180 if (num_text != NULL)
1181 *num_text = info_ptr->num_text;
1182
1183 return info_ptr->num_text;
1184 }
1185
1186 if (num_text != NULL)
1187 *num_text = 0;
1188
1189 return 0;
1190}
1191#endif
1192
1193#ifdef PNG_tIME_SUPPORTED
1194png_uint_32 PNGAPI
1195png_get_tIME(png_const_structrp png_ptr, png_inforp info_ptr,
1196 png_timep *mod_time)
1197{
1198 png_debug1(1, "in %s retrieval function", "tIME");
1199
1200 if (png_ptr != NULL && info_ptr != NULL &&
1201 (info_ptr->valid & PNG_INFO_tIME) != 0 && mod_time != NULL)
1202 {
1203 *mod_time = &(info_ptr->mod_time);
1204 return PNG_INFO_tIME;
1205 }
1206
1207 return 0;
1208}
1209#endif
1210
1211#ifdef PNG_tRNS_SUPPORTED
1212png_uint_32 PNGAPI
1213png_get_tRNS(png_const_structrp png_ptr, png_inforp info_ptr,
1214 png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color)
1215{
1216 png_uint_32 retval = 0;
1217
1218 png_debug1(1, "in %s retrieval function", "tRNS");
1219
1220 if (png_ptr != NULL && info_ptr != NULL &&
1221 (info_ptr->valid & PNG_INFO_tRNS) != 0)
1222 {
1223 if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1224 {
1225 if (trans_alpha != NULL)
1226 {
1227 *trans_alpha = info_ptr->trans_alpha;
1228 retval |= PNG_INFO_tRNS;
1229 }
1230
1231 if (trans_color != NULL)
1232 *trans_color = &(info_ptr->trans_color);
1233 }
1234
1235 else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */
1236 {
1237 if (trans_color != NULL)
1238 {
1239 *trans_color = &(info_ptr->trans_color);
1240 retval |= PNG_INFO_tRNS;
1241 }
1242
1243 if (trans_alpha != NULL)
1244 *trans_alpha = NULL;
1245 }
1246
1247 if (num_trans != NULL)
1248 {
1249 *num_trans = info_ptr->num_trans;
1250 retval |= PNG_INFO_tRNS;
1251 }
1252 }
1253
1254 return retval;
1255}
1256#endif
1257
1258#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
1259int PNGAPI
1260png_get_unknown_chunks(png_const_structrp png_ptr, png_inforp info_ptr,
1261 png_unknown_chunkpp unknowns)
1262{
1263 if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)
1264 {
1265 *unknowns = info_ptr->unknown_chunks;
1266 return info_ptr->unknown_chunks_num;
1267 }
1268
1269 return 0;
1270}
1271#endif
1272
1273#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
1274png_byte PNGAPI
1275png_get_rgb_to_gray_status(png_const_structrp png_ptr)
1276{
1277 return (png_byte)(png_ptr ? png_ptr->rgb_to_gray_status : 0);
1278}
1279#endif
1280
1281#ifdef PNG_USER_CHUNKS_SUPPORTED
1282png_voidp PNGAPI
1283png_get_user_chunk_ptr(png_const_structrp png_ptr)
1284{
1285 return (png_ptr ? png_ptr->user_chunk_ptr : NULL);
1286}
1287#endif
1288
1289size_t PNGAPI
1290png_get_compression_buffer_size(png_const_structrp png_ptr)
1291{
1292 if (png_ptr == NULL)
1293 return 0;
1294
1295#ifdef PNG_WRITE_SUPPORTED
1296 if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
1297#endif
1298 {
1299#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1300 return png_ptr->IDAT_read_size;
1301#else
1302 return PNG_IDAT_READ_SIZE;
1303#endif
1304 }
1305
1306#ifdef PNG_WRITE_SUPPORTED
1307 else
1308 return png_ptr->zbuffer_size;
1309#endif
1310}
1311
1312#ifdef PNG_SET_USER_LIMITS_SUPPORTED
1313/* These functions were added to libpng 1.2.6 and were enabled
1314 * by default in libpng-1.4.0 */
1315png_uint_32 PNGAPI
1316png_get_user_width_max(png_const_structrp png_ptr)
1317{
1318 return (png_ptr ? png_ptr->user_width_max : 0);
1319}
1320
1321png_uint_32 PNGAPI
1322png_get_user_height_max(png_const_structrp png_ptr)
1323{
1324 return (png_ptr ? png_ptr->user_height_max : 0);
1325}
1326
1327/* This function was added to libpng 1.4.0 */
1328png_uint_32 PNGAPI
1329png_get_chunk_cache_max(png_const_structrp png_ptr)
1330{
1331 return (png_ptr ? png_ptr->user_chunk_cache_max : 0);
1332}
1333
1334/* This function was added to libpng 1.4.1 */
1335png_alloc_size_t PNGAPI
1336png_get_chunk_malloc_max(png_const_structrp png_ptr)
1337{
1338 return (png_ptr ? png_ptr->user_chunk_malloc_max : 0);
1339}
1340#endif /* SET_USER_LIMITS */
1341
1342/* These functions were added to libpng 1.4.0 */
1343#ifdef PNG_IO_STATE_SUPPORTED
1344png_uint_32 PNGAPI
1345png_get_io_state(png_const_structrp png_ptr)
1346{
1347 return png_ptr->io_state;
1348}
1349
1350png_uint_32 PNGAPI
1351png_get_io_chunk_type(png_const_structrp png_ptr)
1352{
1353 return png_ptr->chunk_name;
1354}
1355#endif /* IO_STATE */
1356
1357#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
1358# ifdef PNG_GET_PALETTE_MAX_SUPPORTED
1359int PNGAPI
1360png_get_palette_max(png_const_structp png_ptr, png_const_infop info_ptr)
1361{
1362 if (png_ptr != NULL && info_ptr != NULL)
1363 return png_ptr->num_palette_max;
1364
1365 return -1;
1366}
1367# endif
1368#endif
1369
1370#endif /* READ || WRITE */
png_XYZ
Definition pngstruct.h:90