The Tor Browser / file comparison

comparison: media/libpng/pngget.c

media/libpng/pngget.c

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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial