1 :
2 : /* pngget.c - retrieval of values from info struct
3 : *
4 : * Last changed in libpng 1.5.7 [December 15, 2011]
5 : * Copyright (c) 1998-2011 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 29 : png_get_valid(png_const_structp png_ptr, png_const_infop info_ptr,
21 : png_uint_32 flag)
22 : {
23 29 : if (png_ptr != NULL && info_ptr != NULL)
24 29 : return(info_ptr->valid & flag);
25 :
26 0 : return(0);
27 : }
28 :
29 : png_size_t PNGAPI
30 0 : png_get_rowbytes(png_const_structp png_ptr, png_const_infop info_ptr)
31 : {
32 0 : if (png_ptr != NULL && info_ptr != NULL)
33 0 : return(info_ptr->rowbytes);
34 :
35 0 : return(0);
36 : }
37 :
38 : #ifdef PNG_INFO_IMAGE_SUPPORTED
39 : png_bytepp PNGAPI
40 : png_get_rows(png_const_structp png_ptr, png_const_infop 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_structp png_ptr, png_const_infop 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_structp png_ptr, png_const_infop 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_structp png_ptr, png_const_infop 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_structp png_ptr, png_const_infop 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_structp png_ptr, png_const_infop 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_structp png_ptr, png_const_infop 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_structp png_ptr, png_const_infop 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_structp png_ptr, png_const_infop info_ptr)
116 : {
117 : #ifdef PNG_pHYs_SUPPORTED
118 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
119 : {
120 : png_debug1(1, "in %s retrieval function",
121 : "png_get_x_pixels_per_meter");
122 :
123 : if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER)
124 : return (info_ptr->x_pixels_per_unit);
125 : }
126 : #endif
127 :
128 : return (0);
129 : }
130 :
131 : png_uint_32 PNGAPI
132 : png_get_y_pixels_per_meter(png_const_structp png_ptr, png_const_infop info_ptr)
133 : {
134 : #ifdef PNG_pHYs_SUPPORTED
135 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
136 : {
137 : png_debug1(1, "in %s retrieval function",
138 : "png_get_y_pixels_per_meter");
139 :
140 : if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER)
141 : return (info_ptr->y_pixels_per_unit);
142 : }
143 : #endif
144 :
145 : return (0);
146 : }
147 :
148 : png_uint_32 PNGAPI
149 : png_get_pixels_per_meter(png_const_structp png_ptr, png_const_infop info_ptr)
150 : {
151 : #ifdef PNG_pHYs_SUPPORTED
152 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
153 : {
154 : png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter");
155 :
156 : if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER &&
157 : info_ptr->x_pixels_per_unit == info_ptr->y_pixels_per_unit)
158 : return (info_ptr->x_pixels_per_unit);
159 : }
160 : #endif
161 :
162 : return (0);
163 : }
164 :
165 : #ifdef PNG_FLOATING_POINT_SUPPORTED
166 : float PNGAPI
167 : png_get_pixel_aspect_ratio(png_const_structp png_ptr, png_const_infop info_ptr)
168 : {
169 : #ifdef PNG_READ_pHYs_SUPPORTED
170 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
171 : {
172 : png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio");
173 :
174 : if (info_ptr->x_pixels_per_unit != 0)
175 : return ((float)((float)info_ptr->y_pixels_per_unit
176 : /(float)info_ptr->x_pixels_per_unit));
177 : }
178 : #endif
179 :
180 : return ((float)0.0);
181 : }
182 : #endif
183 :
184 : #ifdef PNG_FIXED_POINT_SUPPORTED
185 : png_fixed_point PNGAPI
186 : png_get_pixel_aspect_ratio_fixed(png_const_structp png_ptr,
187 : png_const_infop info_ptr)
188 : {
189 : #ifdef PNG_READ_pHYs_SUPPORTED
190 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)
191 : && info_ptr->x_pixels_per_unit > 0 && info_ptr->y_pixels_per_unit > 0
192 : && info_ptr->x_pixels_per_unit <= PNG_UINT_31_MAX
193 : && info_ptr->y_pixels_per_unit <= PNG_UINT_31_MAX)
194 : {
195 : png_fixed_point res;
196 :
197 : png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio_fixed");
198 :
199 : /* The following casts work because a PNG 4 byte integer only has a valid
200 : * range of 0..2^31-1; otherwise the cast might overflow.
201 : */
202 : if (png_muldiv(&res, (png_int_32)info_ptr->y_pixels_per_unit, PNG_FP_1,
203 : (png_int_32)info_ptr->x_pixels_per_unit))
204 : return res;
205 : }
206 : #endif
207 :
208 : return 0;
209 : }
210 : #endif
211 :
212 : png_int_32 PNGAPI
213 : png_get_x_offset_microns(png_const_structp png_ptr, png_const_infop info_ptr)
214 : {
215 : #ifdef PNG_oFFs_SUPPORTED
216 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
217 : {
218 : png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");
219 :
220 : if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER)
221 : return (info_ptr->x_offset);
222 : }
223 : #endif
224 :
225 : return (0);
226 : }
227 :
228 : png_int_32 PNGAPI
229 : png_get_y_offset_microns(png_const_structp png_ptr, png_const_infop info_ptr)
230 : {
231 : #ifdef PNG_oFFs_SUPPORTED
232 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
233 : {
234 : png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");
235 :
236 : if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER)
237 : return (info_ptr->y_offset);
238 : }
239 : #endif
240 :
241 : return (0);
242 : }
243 :
244 : png_int_32 PNGAPI
245 : png_get_x_offset_pixels(png_const_structp png_ptr, png_const_infop info_ptr)
246 : {
247 : #ifdef PNG_oFFs_SUPPORTED
248 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
249 : {
250 : png_debug1(1, "in %s retrieval function", "png_get_x_offset_pixels");
251 :
252 : if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL)
253 : return (info_ptr->x_offset);
254 : }
255 : #endif
256 :
257 : return (0);
258 : }
259 :
260 : png_int_32 PNGAPI
261 : png_get_y_offset_pixels(png_const_structp png_ptr, png_const_infop info_ptr)
262 : {
263 : #ifdef PNG_oFFs_SUPPORTED
264 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
265 : {
266 : png_debug1(1, "in %s retrieval function", "png_get_y_offset_pixels");
267 :
268 : if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL)
269 : return (info_ptr->y_offset);
270 : }
271 : #endif
272 :
273 : return (0);
274 : }
275 :
276 : #ifdef PNG_INCH_CONVERSIONS_SUPPORTED
277 : static png_uint_32
278 : ppi_from_ppm(png_uint_32 ppm)
279 : {
280 : #if 0
281 : /* The conversion is *(2.54/100), in binary (32 digits):
282 : * .00000110100000001001110101001001
283 : */
284 : png_uint_32 t1001, t1101;
285 : ppm >>= 1; /* .1 */
286 : t1001 = ppm + (ppm >> 3); /* .1001 */
287 : t1101 = t1001 + (ppm >> 1); /* .1101 */
288 : ppm >>= 20; /* .000000000000000000001 */
289 : t1101 += t1101 >> 15; /* .1101000000000001101 */
290 : t1001 >>= 11; /* .000000000001001 */
291 : t1001 += t1001 >> 12; /* .000000000001001000000001001 */
292 : ppm += t1001; /* .000000000001001000001001001 */
293 : ppm += t1101; /* .110100000001001110101001001 */
294 : return (ppm + 16) >> 5;/* .00000110100000001001110101001001 */
295 : #else
296 : /* The argument is a PNG unsigned integer, so it is not permitted
297 : * to be bigger than 2^31.
298 : */
299 : png_fixed_point result;
300 : if (ppm <= PNG_UINT_31_MAX && png_muldiv(&result, (png_int_32)ppm, 127,
301 : 5000))
302 : return result;
303 :
304 : /* Overflow. */
305 : return 0;
306 : #endif
307 : }
308 :
309 : png_uint_32 PNGAPI
310 : png_get_pixels_per_inch(png_const_structp png_ptr, png_const_infop info_ptr)
311 : {
312 : return ppi_from_ppm(png_get_pixels_per_meter(png_ptr, info_ptr));
313 : }
314 :
315 : png_uint_32 PNGAPI
316 : png_get_x_pixels_per_inch(png_const_structp png_ptr, png_const_infop info_ptr)
317 : {
318 : return ppi_from_ppm(png_get_x_pixels_per_meter(png_ptr, info_ptr));
319 : }
320 :
321 : png_uint_32 PNGAPI
322 : png_get_y_pixels_per_inch(png_const_structp png_ptr, png_const_infop info_ptr)
323 : {
324 : return ppi_from_ppm(png_get_y_pixels_per_meter(png_ptr, info_ptr));
325 : }
326 :
327 : #ifdef PNG_FIXED_POINT_SUPPORTED
328 : static png_fixed_point
329 : png_fixed_inches_from_microns(png_structp png_ptr, png_int_32 microns)
330 : {
331 : /* Convert from metres * 1,000,000 to inches * 100,000, meters to
332 : * inches is simply *(100/2.54), so we want *(10/2.54) == 500/127.
333 : * Notice that this can overflow - a warning is output and 0 is
334 : * returned.
335 : */
336 : return png_muldiv_warn(png_ptr, microns, 500, 127);
337 : }
338 :
339 : png_fixed_point PNGAPI
340 : png_get_x_offset_inches_fixed(png_structp png_ptr,
341 : png_const_infop info_ptr)
342 : {
343 : return png_fixed_inches_from_microns(png_ptr,
344 : png_get_x_offset_microns(png_ptr, info_ptr));
345 : }
346 : #endif
347 :
348 : #ifdef PNG_FIXED_POINT_SUPPORTED
349 : png_fixed_point PNGAPI
350 : png_get_y_offset_inches_fixed(png_structp png_ptr,
351 : png_const_infop info_ptr)
352 : {
353 : return png_fixed_inches_from_microns(png_ptr,
354 : png_get_y_offset_microns(png_ptr, info_ptr));
355 : }
356 : #endif
357 :
358 : #ifdef PNG_FLOATING_POINT_SUPPORTED
359 : float PNGAPI
360 : png_get_x_offset_inches(png_const_structp png_ptr, png_const_infop info_ptr)
361 : {
362 : /* To avoid the overflow do the conversion directly in floating
363 : * point.
364 : */
365 : return (float)(png_get_x_offset_microns(png_ptr, info_ptr) * .00003937);
366 : }
367 : #endif
368 :
369 : #ifdef PNG_FLOATING_POINT_SUPPORTED
370 : float PNGAPI
371 : png_get_y_offset_inches(png_const_structp png_ptr, png_const_infop info_ptr)
372 : {
373 : /* To avoid the overflow do the conversion directly in floating
374 : * point.
375 : */
376 : return (float)(png_get_y_offset_microns(png_ptr, info_ptr) * .00003937);
377 : }
378 : #endif
379 :
380 : #ifdef PNG_pHYs_SUPPORTED
381 : png_uint_32 PNGAPI
382 : png_get_pHYs_dpi(png_const_structp png_ptr, png_const_infop info_ptr,
383 : png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
384 : {
385 : png_uint_32 retval = 0;
386 :
387 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
388 : {
389 : png_debug1(1, "in %s retrieval function", "pHYs");
390 :
391 : if (res_x != NULL)
392 : {
393 : *res_x = info_ptr->x_pixels_per_unit;
394 : retval |= PNG_INFO_pHYs;
395 : }
396 :
397 : if (res_y != NULL)
398 : {
399 : *res_y = info_ptr->y_pixels_per_unit;
400 : retval |= PNG_INFO_pHYs;
401 : }
402 :
403 : if (unit_type != NULL)
404 : {
405 : *unit_type = (int)info_ptr->phys_unit_type;
406 : retval |= PNG_INFO_pHYs;
407 :
408 : if (*unit_type == 1)
409 : {
410 : if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50);
411 : if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50);
412 : }
413 : }
414 : }
415 :
416 : return (retval);
417 : }
418 : #endif /* PNG_pHYs_SUPPORTED */
419 : #endif /* PNG_INCH_CONVERSIONS_SUPPORTED */
420 :
421 : /* png_get_channels really belongs in here, too, but it's been around longer */
422 :
423 : #endif /* PNG_EASY_ACCESS_SUPPORTED */
424 :
425 : png_byte PNGAPI
426 4 : png_get_channels(png_const_structp png_ptr, png_const_infop info_ptr)
427 : {
428 4 : if (png_ptr != NULL && info_ptr != NULL)
429 4 : return(info_ptr->channels);
430 :
431 0 : return (0);
432 : }
433 :
434 : png_const_bytep PNGAPI
435 0 : png_get_signature(png_const_structp png_ptr, png_infop info_ptr)
436 : {
437 0 : if (png_ptr != NULL && info_ptr != NULL)
438 0 : return(info_ptr->signature);
439 :
440 0 : return (NULL);
441 : }
442 :
443 : #ifdef PNG_bKGD_SUPPORTED
444 : png_uint_32 PNGAPI
445 : png_get_bKGD(png_const_structp png_ptr, png_infop info_ptr,
446 : png_color_16p *background)
447 : {
448 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)
449 : && background != NULL)
450 : {
451 : png_debug1(1, "in %s retrieval function", "bKGD");
452 :
453 : *background = &(info_ptr->background);
454 : return (PNG_INFO_bKGD);
455 : }
456 :
457 : return (0);
458 : }
459 : #endif
460 :
461 : #ifdef PNG_cHRM_SUPPORTED
462 : /* The XYZ APIs were added in 1.5.5 to take advantage of the code added at the
463 : * same time to correct the rgb grayscale coefficient defaults obtained from the
464 : * cHRM chunk in 1.5.4
465 : */
466 : png_uint_32 PNGFAPI
467 0 : png_get_cHRM_XYZ_fixed(png_structp png_ptr, png_const_infop info_ptr,
468 : png_fixed_point *int_red_X, png_fixed_point *int_red_Y,
469 : png_fixed_point *int_red_Z, png_fixed_point *int_green_X,
470 : png_fixed_point *int_green_Y, png_fixed_point *int_green_Z,
471 : png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y,
472 : png_fixed_point *int_blue_Z)
473 : {
474 0 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
475 : {
476 : png_xy xy;
477 : png_XYZ XYZ;
478 :
479 : png_debug1(1, "in %s retrieval function", "cHRM_XYZ");
480 :
481 0 : xy.whitex = info_ptr->x_white;
482 0 : xy.whitey = info_ptr->y_white;
483 0 : xy.redx = info_ptr->x_red;
484 0 : xy.redy = info_ptr->y_red;
485 0 : xy.greenx = info_ptr->x_green;
486 0 : xy.greeny = info_ptr->y_green;
487 0 : xy.bluex = info_ptr->x_blue;
488 0 : xy.bluey = info_ptr->y_blue;
489 :
490 : /* The *_checked function handles error reporting, so just return 0 if
491 : * there is a failure here.
492 : */
493 0 : if (png_XYZ_from_xy_checked(png_ptr, &XYZ, xy))
494 : {
495 0 : if (int_red_X != NULL)
496 0 : *int_red_X = XYZ.redX;
497 0 : if (int_red_Y != NULL)
498 0 : *int_red_Y = XYZ.redY;
499 0 : if (int_red_Z != NULL)
500 0 : *int_red_Z = XYZ.redZ;
501 0 : if (int_green_X != NULL)
502 0 : *int_green_X = XYZ.greenX;
503 0 : if (int_green_Y != NULL)
504 0 : *int_green_Y = XYZ.greenY;
505 0 : if (int_green_Z != NULL)
506 0 : *int_green_Z = XYZ.greenZ;
507 0 : if (int_blue_X != NULL)
508 0 : *int_blue_X = XYZ.blueX;
509 0 : if (int_blue_Y != NULL)
510 0 : *int_blue_Y = XYZ.blueY;
511 0 : if (int_blue_Z != NULL)
512 0 : *int_blue_Z = XYZ.blueZ;
513 :
514 0 : return (PNG_INFO_cHRM);
515 : }
516 : }
517 :
518 0 : return (0);
519 : }
520 :
521 : # ifdef PNG_FLOATING_POINT_SUPPORTED
522 : png_uint_32 PNGAPI
523 0 : png_get_cHRM(png_const_structp png_ptr, png_const_infop info_ptr,
524 : double *white_x, double *white_y, double *red_x, double *red_y,
525 : double *green_x, double *green_y, double *blue_x, double *blue_y)
526 : {
527 0 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
528 : {
529 : png_debug1(1, "in %s retrieval function", "cHRM");
530 :
531 0 : if (white_x != NULL)
532 0 : *white_x = png_float(png_ptr, info_ptr->x_white, "cHRM white X");
533 0 : if (white_y != NULL)
534 0 : *white_y = png_float(png_ptr, info_ptr->y_white, "cHRM white Y");
535 0 : if (red_x != NULL)
536 0 : *red_x = png_float(png_ptr, info_ptr->x_red, "cHRM red X");
537 0 : if (red_y != NULL)
538 0 : *red_y = png_float(png_ptr, info_ptr->y_red, "cHRM red Y");
539 0 : if (green_x != NULL)
540 0 : *green_x = png_float(png_ptr, info_ptr->x_green, "cHRM green X");
541 0 : if (green_y != NULL)
542 0 : *green_y = png_float(png_ptr, info_ptr->y_green, "cHRM green Y");
543 0 : if (blue_x != NULL)
544 0 : *blue_x = png_float(png_ptr, info_ptr->x_blue, "cHRM blue X");
545 0 : if (blue_y != NULL)
546 0 : *blue_y = png_float(png_ptr, info_ptr->y_blue, "cHRM blue Y");
547 0 : return (PNG_INFO_cHRM);
548 : }
549 :
550 0 : return (0);
551 : }
552 :
553 : png_uint_32 PNGAPI
554 0 : png_get_cHRM_XYZ(png_structp png_ptr, png_const_infop info_ptr,
555 : double *red_X, double *red_Y, double *red_Z, double *green_X,
556 : double *green_Y, double *green_Z, double *blue_X, double *blue_Y,
557 : double *blue_Z)
558 : {
559 : png_XYZ XYZ;
560 :
561 0 : if (png_get_cHRM_XYZ_fixed(png_ptr, info_ptr,
562 : &XYZ.redX, &XYZ.redY, &XYZ.redZ, &XYZ.greenX, &XYZ.greenY, &XYZ.greenZ,
563 0 : &XYZ.blueX, &XYZ.blueY, &XYZ.blueZ) & PNG_INFO_cHRM)
564 : {
565 0 : if (red_X != NULL)
566 0 : *red_X = png_float(png_ptr, XYZ.redX, "cHRM red X");
567 0 : if (red_Y != NULL)
568 0 : *red_Y = png_float(png_ptr, XYZ.redY, "cHRM red Y");
569 0 : if (red_Z != NULL)
570 0 : *red_Z = png_float(png_ptr, XYZ.redZ, "cHRM red Z");
571 0 : if (green_X != NULL)
572 0 : *green_X = png_float(png_ptr, XYZ.greenX, "cHRM green X");
573 0 : if (green_Y != NULL)
574 0 : *green_Y = png_float(png_ptr, XYZ.greenY, "cHRM green Y");
575 0 : if (green_Z != NULL)
576 0 : *green_Z = png_float(png_ptr, XYZ.greenZ, "cHRM green Z");
577 0 : if (blue_X != NULL)
578 0 : *blue_X = png_float(png_ptr, XYZ.blueX, "cHRM blue X");
579 0 : if (blue_Y != NULL)
580 0 : *blue_Y = png_float(png_ptr, XYZ.blueY, "cHRM blue Y");
581 0 : if (blue_Z != NULL)
582 0 : *blue_Z = png_float(png_ptr, XYZ.blueZ, "cHRM blue Z");
583 0 : return (PNG_INFO_cHRM);
584 : }
585 :
586 0 : return (0);
587 : }
588 : # endif
589 :
590 : # ifdef PNG_FIXED_POINT_SUPPORTED
591 : png_uint_32 PNGAPI
592 0 : png_get_cHRM_fixed(png_const_structp png_ptr, png_const_infop info_ptr,
593 : png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x,
594 : png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y,
595 : png_fixed_point *blue_x, png_fixed_point *blue_y)
596 : {
597 : png_debug1(1, "in %s retrieval function", "cHRM");
598 :
599 0 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
600 : {
601 0 : if (white_x != NULL)
602 0 : *white_x = info_ptr->x_white;
603 0 : if (white_y != NULL)
604 0 : *white_y = info_ptr->y_white;
605 0 : if (red_x != NULL)
606 0 : *red_x = info_ptr->x_red;
607 0 : if (red_y != NULL)
608 0 : *red_y = info_ptr->y_red;
609 0 : if (green_x != NULL)
610 0 : *green_x = info_ptr->x_green;
611 0 : if (green_y != NULL)
612 0 : *green_y = info_ptr->y_green;
613 0 : if (blue_x != NULL)
614 0 : *blue_x = info_ptr->x_blue;
615 0 : if (blue_y != NULL)
616 0 : *blue_y = info_ptr->y_blue;
617 0 : return (PNG_INFO_cHRM);
618 : }
619 :
620 0 : return (0);
621 : }
622 : # endif
623 : #endif
624 :
625 : #ifdef PNG_gAMA_SUPPORTED
626 : png_uint_32 PNGFAPI
627 4 : png_get_gAMA_fixed(png_const_structp png_ptr, png_const_infop info_ptr,
628 : png_fixed_point *file_gamma)
629 : {
630 : png_debug1(1, "in %s retrieval function", "gAMA");
631 :
632 4 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)
633 1 : && file_gamma != NULL)
634 : {
635 1 : *file_gamma = info_ptr->gamma;
636 1 : return (PNG_INFO_gAMA);
637 : }
638 :
639 3 : return (0);
640 : }
641 : # ifdef PNG_FLOATING_POINT_SUPPORTED
642 : png_uint_32 PNGAPI
643 4 : png_get_gAMA(png_const_structp png_ptr, png_const_infop info_ptr,
644 : double *file_gamma)
645 : {
646 : png_fixed_point igamma;
647 4 : png_uint_32 ok = png_get_gAMA_fixed(png_ptr, info_ptr, &igamma);
648 :
649 4 : if (ok)
650 1 : *file_gamma = png_float(png_ptr, igamma, "png_get_gAMA");
651 :
652 4 : return ok;
653 : }
654 :
655 : # endif
656 : #endif
657 :
658 : #ifdef PNG_sRGB_SUPPORTED
659 : png_uint_32 PNGAPI
660 0 : png_get_sRGB(png_const_structp png_ptr, png_const_infop info_ptr,
661 : int *file_srgb_intent)
662 : {
663 : png_debug1(1, "in %s retrieval function", "sRGB");
664 :
665 0 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)
666 0 : && file_srgb_intent != NULL)
667 : {
668 0 : *file_srgb_intent = (int)info_ptr->srgb_intent;
669 0 : return (PNG_INFO_sRGB);
670 : }
671 :
672 0 : return (0);
673 : }
674 : #endif
675 :
676 : #ifdef PNG_iCCP_SUPPORTED
677 : png_uint_32 PNGAPI
678 0 : png_get_iCCP(png_const_structp png_ptr, png_const_infop info_ptr,
679 : png_charpp name, int *compression_type,
680 : png_bytepp profile, png_uint_32 *proflen)
681 : {
682 : png_debug1(1, "in %s retrieval function", "iCCP");
683 :
684 0 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)
685 0 : && name != NULL && compression_type != NULL && profile != NULL &&
686 : proflen != NULL)
687 : {
688 0 : *name = info_ptr->iccp_name;
689 0 : *profile = info_ptr->iccp_profile;
690 : /* Compression_type is a dummy so the API won't have to change
691 : * if we introduce multiple compression types later.
692 : */
693 0 : *proflen = info_ptr->iccp_proflen;
694 0 : *compression_type = info_ptr->iccp_compression;
695 0 : return (PNG_INFO_iCCP);
696 : }
697 :
698 0 : return (0);
699 : }
700 : #endif
701 :
702 : #ifdef PNG_sPLT_SUPPORTED
703 : png_uint_32 PNGAPI
704 : png_get_sPLT(png_const_structp png_ptr, png_const_infop info_ptr,
705 : png_sPLT_tpp spalettes)
706 : {
707 : if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL)
708 : {
709 : *spalettes = info_ptr->splt_palettes;
710 : return ((png_uint_32)info_ptr->splt_palettes_num);
711 : }
712 :
713 : return (0);
714 : }
715 : #endif
716 :
717 : #ifdef PNG_hIST_SUPPORTED
718 : png_uint_32 PNGAPI
719 : png_get_hIST(png_const_structp png_ptr, png_const_infop info_ptr,
720 : png_uint_16p *hist)
721 : {
722 : png_debug1(1, "in %s retrieval function", "hIST");
723 :
724 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)
725 : && hist != NULL)
726 : {
727 : *hist = info_ptr->hist;
728 : return (PNG_INFO_hIST);
729 : }
730 :
731 : return (0);
732 : }
733 : #endif
734 :
735 : png_uint_32 PNGAPI
736 4 : png_get_IHDR(png_structp png_ptr, png_infop info_ptr,
737 : png_uint_32 *width, png_uint_32 *height, int *bit_depth,
738 : int *color_type, int *interlace_type, int *compression_type,
739 : int *filter_type)
740 :
741 : {
742 : png_debug1(1, "in %s retrieval function", "IHDR");
743 :
744 4 : if (png_ptr == NULL || info_ptr == NULL || width == NULL ||
745 4 : height == NULL || bit_depth == NULL || color_type == NULL)
746 0 : return (0);
747 :
748 4 : *width = info_ptr->width;
749 4 : *height = info_ptr->height;
750 4 : *bit_depth = info_ptr->bit_depth;
751 4 : *color_type = info_ptr->color_type;
752 :
753 4 : if (compression_type != NULL)
754 4 : *compression_type = info_ptr->compression_type;
755 :
756 4 : if (filter_type != NULL)
757 4 : *filter_type = info_ptr->filter_type;
758 :
759 4 : if (interlace_type != NULL)
760 4 : *interlace_type = info_ptr->interlace_type;
761 :
762 : /* This is redundant if we can be sure that the info_ptr values were all
763 : * assigned in png_set_IHDR(). We do the check anyhow in case an
764 : * application has ignored our advice not to mess with the members
765 : * of info_ptr directly.
766 : */
767 20 : png_check_IHDR (png_ptr, info_ptr->width, info_ptr->height,
768 12 : info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,
769 8 : info_ptr->compression_type, info_ptr->filter_type);
770 :
771 4 : return (1);
772 : }
773 :
774 : #ifdef PNG_oFFs_SUPPORTED
775 : png_uint_32 PNGAPI
776 : png_get_oFFs(png_const_structp png_ptr, png_const_infop info_ptr,
777 : png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)
778 : {
779 : png_debug1(1, "in %s retrieval function", "oFFs");
780 :
781 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)
782 : && offset_x != NULL && offset_y != NULL && unit_type != NULL)
783 : {
784 : *offset_x = info_ptr->x_offset;
785 : *offset_y = info_ptr->y_offset;
786 : *unit_type = (int)info_ptr->offset_unit_type;
787 : return (PNG_INFO_oFFs);
788 : }
789 :
790 : return (0);
791 : }
792 : #endif
793 :
794 : #ifdef PNG_pCAL_SUPPORTED
795 : png_uint_32 PNGAPI
796 : png_get_pCAL(png_const_structp png_ptr, png_const_infop info_ptr,
797 : png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,
798 : png_charp *units, png_charpp *params)
799 : {
800 : png_debug1(1, "in %s retrieval function", "pCAL");
801 :
802 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)
803 : && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
804 : nparams != NULL && units != NULL && params != NULL)
805 : {
806 : *purpose = info_ptr->pcal_purpose;
807 : *X0 = info_ptr->pcal_X0;
808 : *X1 = info_ptr->pcal_X1;
809 : *type = (int)info_ptr->pcal_type;
810 : *nparams = (int)info_ptr->pcal_nparams;
811 : *units = info_ptr->pcal_units;
812 : *params = info_ptr->pcal_params;
813 : return (PNG_INFO_pCAL);
814 : }
815 :
816 : return (0);
817 : }
818 : #endif
819 :
820 : #ifdef PNG_sCAL_SUPPORTED
821 : # ifdef PNG_FIXED_POINT_SUPPORTED
822 : # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
823 : png_uint_32 PNGAPI
824 : png_get_sCAL_fixed(png_structp png_ptr, png_const_infop info_ptr,
825 : int *unit, png_fixed_point *width, png_fixed_point *height)
826 : {
827 : if (png_ptr != NULL && info_ptr != NULL &&
828 : (info_ptr->valid & PNG_INFO_sCAL))
829 : {
830 : *unit = info_ptr->scal_unit;
831 : /*TODO: make this work without FP support */
832 : *width = png_fixed(png_ptr, atof(info_ptr->scal_s_width), "sCAL width");
833 : *height = png_fixed(png_ptr, atof(info_ptr->scal_s_height),
834 : "sCAL height");
835 : return (PNG_INFO_sCAL);
836 : }
837 :
838 : return(0);
839 : }
840 : # endif /* FLOATING_ARITHMETIC */
841 : # endif /* FIXED_POINT */
842 : # ifdef PNG_FLOATING_POINT_SUPPORTED
843 : png_uint_32 PNGAPI
844 : png_get_sCAL(png_const_structp png_ptr, png_const_infop info_ptr,
845 : int *unit, double *width, double *height)
846 : {
847 : if (png_ptr != NULL && info_ptr != NULL &&
848 : (info_ptr->valid & PNG_INFO_sCAL))
849 : {
850 : *unit = info_ptr->scal_unit;
851 : *width = atof(info_ptr->scal_s_width);
852 : *height = atof(info_ptr->scal_s_height);
853 : return (PNG_INFO_sCAL);
854 : }
855 :
856 : return(0);
857 : }
858 : # endif /* FLOATING POINT */
859 : png_uint_32 PNGAPI
860 : png_get_sCAL_s(png_const_structp png_ptr, png_const_infop info_ptr,
861 : int *unit, png_charpp width, png_charpp height)
862 : {
863 : if (png_ptr != NULL && info_ptr != NULL &&
864 : (info_ptr->valid & PNG_INFO_sCAL))
865 : {
866 : *unit = info_ptr->scal_unit;
867 : *width = info_ptr->scal_s_width;
868 : *height = info_ptr->scal_s_height;
869 : return (PNG_INFO_sCAL);
870 : }
871 :
872 : return(0);
873 : }
874 : #endif /* sCAL */
875 :
876 : #ifdef PNG_pHYs_SUPPORTED
877 : png_uint_32 PNGAPI
878 : png_get_pHYs(png_const_structp png_ptr, png_const_infop info_ptr,
879 : png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
880 : {
881 : png_uint_32 retval = 0;
882 :
883 : png_debug1(1, "in %s retrieval function", "pHYs");
884 :
885 : if (png_ptr != NULL && info_ptr != NULL &&
886 : (info_ptr->valid & PNG_INFO_pHYs))
887 : {
888 : if (res_x != NULL)
889 : {
890 : *res_x = info_ptr->x_pixels_per_unit;
891 : retval |= PNG_INFO_pHYs;
892 : }
893 :
894 : if (res_y != NULL)
895 : {
896 : *res_y = info_ptr->y_pixels_per_unit;
897 : retval |= PNG_INFO_pHYs;
898 : }
899 :
900 : if (unit_type != NULL)
901 : {
902 : *unit_type = (int)info_ptr->phys_unit_type;
903 : retval |= PNG_INFO_pHYs;
904 : }
905 : }
906 :
907 : return (retval);
908 : }
909 : #endif /* pHYs */
910 :
911 : png_uint_32 PNGAPI
912 0 : png_get_PLTE(png_const_structp png_ptr, png_const_infop info_ptr,
913 : png_colorp *palette, int *num_palette)
914 : {
915 : png_debug1(1, "in %s retrieval function", "PLTE");
916 :
917 0 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE)
918 0 : && palette != NULL)
919 : {
920 0 : *palette = info_ptr->palette;
921 0 : *num_palette = info_ptr->num_palette;
922 : png_debug1(3, "num_palette = %d", *num_palette);
923 0 : return (PNG_INFO_PLTE);
924 : }
925 :
926 0 : return (0);
927 : }
928 :
929 : #ifdef PNG_sBIT_SUPPORTED
930 : png_uint_32 PNGAPI
931 : png_get_sBIT(png_const_structp png_ptr, png_infop info_ptr,
932 : png_color_8p *sig_bit)
933 : {
934 : png_debug1(1, "in %s retrieval function", "sBIT");
935 :
936 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)
937 : && sig_bit != NULL)
938 : {
939 : *sig_bit = &(info_ptr->sig_bit);
940 : return (PNG_INFO_sBIT);
941 : }
942 :
943 : return (0);
944 : }
945 : #endif
946 :
947 : #ifdef PNG_TEXT_SUPPORTED
948 : png_uint_32 PNGAPI
949 0 : png_get_text(png_const_structp png_ptr, png_const_infop info_ptr,
950 : png_textp *text_ptr, int *num_text)
951 : {
952 0 : if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)
953 : {
954 : png_debug1(1, "in 0x%lx retrieval function",
955 : (unsigned long)png_ptr->chunk_name);
956 :
957 0 : if (text_ptr != NULL)
958 0 : *text_ptr = info_ptr->text;
959 :
960 0 : if (num_text != NULL)
961 0 : *num_text = info_ptr->num_text;
962 :
963 0 : return ((png_uint_32)info_ptr->num_text);
964 : }
965 :
966 0 : if (num_text != NULL)
967 0 : *num_text = 0;
968 :
969 0 : return(0);
970 : }
971 : #endif
972 :
973 : #ifdef PNG_tIME_SUPPORTED
974 : png_uint_32 PNGAPI
975 : png_get_tIME(png_const_structp png_ptr, png_infop info_ptr, png_timep *mod_time)
976 : {
977 : png_debug1(1, "in %s retrieval function", "tIME");
978 :
979 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)
980 : && mod_time != NULL)
981 : {
982 : *mod_time = &(info_ptr->mod_time);
983 : return (PNG_INFO_tIME);
984 : }
985 :
986 : return (0);
987 : }
988 : #endif
989 :
990 : #ifdef PNG_tRNS_SUPPORTED
991 : png_uint_32 PNGAPI
992 0 : png_get_tRNS(png_const_structp png_ptr, png_infop info_ptr,
993 : png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color)
994 : {
995 0 : png_uint_32 retval = 0;
996 0 : if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))
997 : {
998 : png_debug1(1, "in %s retrieval function", "tRNS");
999 :
1000 0 : if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1001 : {
1002 0 : if (trans_alpha != NULL)
1003 : {
1004 0 : *trans_alpha = info_ptr->trans_alpha;
1005 0 : retval |= PNG_INFO_tRNS;
1006 : }
1007 :
1008 0 : if (trans_color != NULL)
1009 0 : *trans_color = &(info_ptr->trans_color);
1010 : }
1011 :
1012 : else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */
1013 : {
1014 0 : if (trans_color != NULL)
1015 : {
1016 0 : *trans_color = &(info_ptr->trans_color);
1017 0 : retval |= PNG_INFO_tRNS;
1018 : }
1019 :
1020 0 : if (trans_alpha != NULL)
1021 0 : *trans_alpha = NULL;
1022 : }
1023 :
1024 0 : if (num_trans != NULL)
1025 : {
1026 0 : *num_trans = info_ptr->num_trans;
1027 0 : retval |= PNG_INFO_tRNS;
1028 : }
1029 : }
1030 :
1031 0 : return (retval);
1032 : }
1033 : #endif
1034 :
1035 : #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
1036 : int PNGAPI
1037 : png_get_unknown_chunks(png_const_structp png_ptr, png_const_infop info_ptr,
1038 : png_unknown_chunkpp unknowns)
1039 : {
1040 : if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)
1041 : {
1042 : *unknowns = info_ptr->unknown_chunks;
1043 : return info_ptr->unknown_chunks_num;
1044 : }
1045 :
1046 : return (0);
1047 : }
1048 : #endif
1049 :
1050 : #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
1051 : png_byte PNGAPI
1052 : png_get_rgb_to_gray_status (png_const_structp png_ptr)
1053 : {
1054 : return (png_byte)(png_ptr ? png_ptr->rgb_to_gray_status : 0);
1055 : }
1056 : #endif
1057 :
1058 : #ifdef PNG_USER_CHUNKS_SUPPORTED
1059 : png_voidp PNGAPI
1060 : png_get_user_chunk_ptr(png_const_structp png_ptr)
1061 : {
1062 : return (png_ptr ? png_ptr->user_chunk_ptr : NULL);
1063 : }
1064 : #endif
1065 :
1066 : png_size_t PNGAPI
1067 0 : png_get_compression_buffer_size(png_const_structp png_ptr)
1068 : {
1069 0 : return (png_ptr ? png_ptr->zbuf_size : 0);
1070 : }
1071 :
1072 : #ifdef PNG_SET_USER_LIMITS_SUPPORTED
1073 : /* These functions were added to libpng 1.2.6 and were enabled
1074 : * by default in libpng-1.4.0 */
1075 : png_uint_32 PNGAPI
1076 : png_get_user_width_max (png_const_structp png_ptr)
1077 : {
1078 : return (png_ptr ? png_ptr->user_width_max : 0);
1079 : }
1080 :
1081 : png_uint_32 PNGAPI
1082 : png_get_user_height_max (png_const_structp png_ptr)
1083 : {
1084 : return (png_ptr ? png_ptr->user_height_max : 0);
1085 : }
1086 :
1087 : /* This function was added to libpng 1.4.0 */
1088 : png_uint_32 PNGAPI
1089 : png_get_chunk_cache_max (png_const_structp png_ptr)
1090 : {
1091 : return (png_ptr ? png_ptr->user_chunk_cache_max : 0);
1092 : }
1093 :
1094 : /* This function was added to libpng 1.4.1 */
1095 : png_alloc_size_t PNGAPI
1096 : png_get_chunk_malloc_max (png_const_structp png_ptr)
1097 : {
1098 : return (png_ptr ? png_ptr->user_chunk_malloc_max : 0);
1099 : }
1100 : #endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */
1101 :
1102 : /* These functions were added to libpng 1.4.0 */
1103 : #ifdef PNG_IO_STATE_SUPPORTED
1104 : png_uint_32 PNGAPI
1105 : png_get_io_state (png_structp png_ptr)
1106 : {
1107 : return png_ptr->io_state;
1108 : }
1109 :
1110 : png_uint_32 PNGAPI
1111 : png_get_io_chunk_type (png_const_structp png_ptr)
1112 : {
1113 : return png_ptr->chunk_name;
1114 : }
1115 :
1116 : png_const_bytep PNGAPI
1117 : png_get_io_chunk_name (png_structp png_ptr)
1118 : {
1119 : PNG_CSTRING_FROM_CHUNK(png_ptr->io_chunk_string, png_ptr->chunk_name);
1120 : return png_ptr->io_chunk_string;
1121 : }
1122 : #endif /* ?PNG_IO_STATE_SUPPORTED */
1123 :
1124 : #ifdef PNG_APNG_SUPPORTED
1125 : png_uint_32 PNGAPI
1126 0 : png_get_acTL(png_structp png_ptr, png_infop info_ptr,
1127 : png_uint_32 *num_frames, png_uint_32 *num_plays)
1128 : {
1129 : png_debug1(1, "in %s retrieval function", "acTL");
1130 :
1131 0 : if (png_ptr != NULL && info_ptr != NULL &&
1132 0 : (info_ptr->valid & PNG_INFO_acTL) &&
1133 0 : num_frames != NULL && num_plays != NULL)
1134 : {
1135 0 : *num_frames = info_ptr->num_frames;
1136 0 : *num_plays = info_ptr->num_plays;
1137 0 : return (1);
1138 : }
1139 :
1140 0 : return (0);
1141 : }
1142 :
1143 : png_uint_32 PNGAPI
1144 0 : png_get_num_frames(png_structp png_ptr, png_infop info_ptr)
1145 : {
1146 : png_debug(1, "in png_get_num_frames()");
1147 :
1148 0 : if (png_ptr != NULL && info_ptr != NULL)
1149 0 : return (info_ptr->num_frames);
1150 0 : return (0);
1151 : }
1152 :
1153 : png_uint_32 PNGAPI
1154 0 : png_get_num_plays(png_structp png_ptr, png_infop info_ptr)
1155 : {
1156 : png_debug(1, "in png_get_num_plays()");
1157 :
1158 0 : if (png_ptr != NULL && info_ptr != NULL)
1159 0 : return (info_ptr->num_plays);
1160 0 : return (0);
1161 : }
1162 :
1163 : png_uint_32 PNGAPI
1164 0 : png_get_next_frame_fcTL(png_structp png_ptr, png_infop info_ptr,
1165 : png_uint_32 *width, png_uint_32 *height,
1166 : png_uint_32 *x_offset, png_uint_32 *y_offset,
1167 : png_uint_16 *delay_num, png_uint_16 *delay_den,
1168 : png_byte *dispose_op, png_byte *blend_op)
1169 : {
1170 : png_debug1(1, "in %s retrieval function", "fcTL");
1171 :
1172 0 : if (png_ptr != NULL && info_ptr != NULL &&
1173 0 : (info_ptr->valid & PNG_INFO_fcTL) &&
1174 0 : width != NULL && height != NULL &&
1175 0 : x_offset != NULL && x_offset != NULL &&
1176 0 : delay_num != NULL && delay_den != NULL &&
1177 0 : dispose_op != NULL && blend_op != NULL)
1178 : {
1179 0 : *width = info_ptr->next_frame_width;
1180 0 : *height = info_ptr->next_frame_height;
1181 0 : *x_offset = info_ptr->next_frame_x_offset;
1182 0 : *y_offset = info_ptr->next_frame_y_offset;
1183 0 : *delay_num = info_ptr->next_frame_delay_num;
1184 0 : *delay_den = info_ptr->next_frame_delay_den;
1185 0 : *dispose_op = info_ptr->next_frame_dispose_op;
1186 0 : *blend_op = info_ptr->next_frame_blend_op;
1187 0 : return (1);
1188 : }
1189 :
1190 0 : return (0);
1191 : }
1192 :
1193 : png_uint_32 PNGAPI
1194 0 : png_get_next_frame_width(png_structp png_ptr, png_infop info_ptr)
1195 : {
1196 : png_debug(1, "in png_get_next_frame_width()");
1197 :
1198 0 : if (png_ptr != NULL && info_ptr != NULL)
1199 0 : return (info_ptr->next_frame_width);
1200 0 : return (0);
1201 : }
1202 :
1203 : png_uint_32 PNGAPI
1204 0 : png_get_next_frame_height(png_structp png_ptr, png_infop info_ptr)
1205 : {
1206 : png_debug(1, "in png_get_next_frame_height()");
1207 :
1208 0 : if (png_ptr != NULL && info_ptr != NULL)
1209 0 : return (info_ptr->next_frame_height);
1210 0 : return (0);
1211 : }
1212 :
1213 : png_uint_32 PNGAPI
1214 0 : png_get_next_frame_x_offset(png_structp png_ptr, png_infop info_ptr)
1215 : {
1216 : png_debug(1, "in png_get_next_frame_x_offset()");
1217 :
1218 0 : if (png_ptr != NULL && info_ptr != NULL)
1219 0 : return (info_ptr->next_frame_x_offset);
1220 0 : return (0);
1221 : }
1222 :
1223 : png_uint_32 PNGAPI
1224 0 : png_get_next_frame_y_offset(png_structp png_ptr, png_infop info_ptr)
1225 : {
1226 : png_debug(1, "in png_get_next_frame_y_offset()");
1227 :
1228 0 : if (png_ptr != NULL && info_ptr != NULL)
1229 0 : return (info_ptr->next_frame_y_offset);
1230 0 : return (0);
1231 : }
1232 :
1233 : png_uint_16 PNGAPI
1234 0 : png_get_next_frame_delay_num(png_structp png_ptr, png_infop info_ptr)
1235 : {
1236 : png_debug(1, "in png_get_next_frame_delay_num()");
1237 :
1238 0 : if (png_ptr != NULL && info_ptr != NULL)
1239 0 : return (info_ptr->next_frame_delay_num);
1240 0 : return (0);
1241 : }
1242 :
1243 : png_uint_16 PNGAPI
1244 0 : png_get_next_frame_delay_den(png_structp png_ptr, png_infop info_ptr)
1245 : {
1246 : png_debug(1, "in png_get_next_frame_delay_den()");
1247 :
1248 0 : if (png_ptr != NULL && info_ptr != NULL)
1249 0 : return (info_ptr->next_frame_delay_den);
1250 0 : return (0);
1251 : }
1252 :
1253 : png_byte PNGAPI
1254 0 : png_get_next_frame_dispose_op(png_structp png_ptr, png_infop info_ptr)
1255 : {
1256 : png_debug(1, "in png_get_next_frame_dispose_op()");
1257 :
1258 0 : if (png_ptr != NULL && info_ptr != NULL)
1259 0 : return (info_ptr->next_frame_dispose_op);
1260 0 : return (0);
1261 : }
1262 :
1263 : png_byte PNGAPI
1264 0 : png_get_next_frame_blend_op(png_structp png_ptr, png_infop info_ptr)
1265 : {
1266 : png_debug(1, "in png_get_next_frame_blend_op()");
1267 :
1268 0 : if (png_ptr != NULL && info_ptr != NULL)
1269 0 : return (info_ptr->next_frame_blend_op);
1270 0 : return (0);
1271 : }
1272 :
1273 : png_byte PNGAPI
1274 4 : png_get_first_frame_is_hidden(png_structp png_ptr, png_infop info_ptr)
1275 : {
1276 : png_debug(1, "in png_first_frame_is_hidden()");
1277 :
1278 4 : if (png_ptr != NULL)
1279 4 : return (png_byte)(png_ptr->apng_flags & PNG_FIRST_FRAME_HIDDEN);
1280 :
1281 : PNG_UNUSED(info_ptr)
1282 :
1283 0 : return 0;
1284 : }
1285 : #endif /* PNG_APNG_SUPPORTED */
1286 : #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
|