It seems that it was a mistake to OR the LFB flag to the video mode
[dosdemo] / libs / imago / libpng / pngget.c
1 \r
2 /* pngget.c - retrieval of values from info struct\r
3  *\r
4  * Last changed in libpng 1.2.30 [August 15, 2008]\r
5  * For conditions of distribution and use, see copyright notice in png.h\r
6  * Copyright (c) 1998-2008 Glenn Randers-Pehrson\r
7  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
8  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
9  */\r
10 \r
11 #define PNG_INTERNAL\r
12 #include "png.h"\r
13 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)\r
14 \r
15 png_uint_32 PNGAPI\r
16 png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag)\r
17 {\r
18    if (png_ptr != NULL && info_ptr != NULL)\r
19       return(info_ptr->valid & flag);\r
20    else\r
21       return(0);\r
22 }\r
23 \r
24 png_uint_32 PNGAPI\r
25 png_get_rowbytes(png_structp png_ptr, png_infop info_ptr)\r
26 {\r
27    if (png_ptr != NULL && info_ptr != NULL)\r
28       return(info_ptr->rowbytes);\r
29    else\r
30       return(0);\r
31 }\r
32 \r
33 #if defined(PNG_INFO_IMAGE_SUPPORTED)\r
34 png_bytepp PNGAPI\r
35 png_get_rows(png_structp png_ptr, png_infop info_ptr)\r
36 {\r
37    if (png_ptr != NULL && info_ptr != NULL)\r
38       return(info_ptr->row_pointers);\r
39    else\r
40       return(0);\r
41 }\r
42 #endif\r
43 \r
44 #ifdef PNG_EASY_ACCESS_SUPPORTED\r
45 /* easy access to info, added in libpng-0.99 */\r
46 png_uint_32 PNGAPI\r
47 png_get_image_width(png_structp png_ptr, png_infop info_ptr)\r
48 {\r
49    if (png_ptr != NULL && info_ptr != NULL)\r
50    {\r
51       return info_ptr->width;\r
52    }\r
53    return (0);\r
54 }\r
55 \r
56 png_uint_32 PNGAPI\r
57 png_get_image_height(png_structp png_ptr, png_infop info_ptr)\r
58 {\r
59    if (png_ptr != NULL && info_ptr != NULL)\r
60    {\r
61       return info_ptr->height;\r
62    }\r
63    return (0);\r
64 }\r
65 \r
66 png_byte PNGAPI\r
67 png_get_bit_depth(png_structp png_ptr, png_infop info_ptr)\r
68 {\r
69    if (png_ptr != NULL && info_ptr != NULL)\r
70    {\r
71       return info_ptr->bit_depth;\r
72    }\r
73    return (0);\r
74 }\r
75 \r
76 png_byte PNGAPI\r
77 png_get_color_type(png_structp png_ptr, png_infop info_ptr)\r
78 {\r
79    if (png_ptr != NULL && info_ptr != NULL)\r
80    {\r
81       return info_ptr->color_type;\r
82    }\r
83    return (0);\r
84 }\r
85 \r
86 png_byte PNGAPI\r
87 png_get_filter_type(png_structp png_ptr, png_infop info_ptr)\r
88 {\r
89    if (png_ptr != NULL && info_ptr != NULL)\r
90    {\r
91       return info_ptr->filter_type;\r
92    }\r
93    return (0);\r
94 }\r
95 \r
96 png_byte PNGAPI\r
97 png_get_interlace_type(png_structp png_ptr, png_infop info_ptr)\r
98 {\r
99    if (png_ptr != NULL && info_ptr != NULL)\r
100    {\r
101       return info_ptr->interlace_type;\r
102    }\r
103    return (0);\r
104 }\r
105 \r
106 png_byte PNGAPI\r
107 png_get_compression_type(png_structp png_ptr, png_infop info_ptr)\r
108 {\r
109    if (png_ptr != NULL && info_ptr != NULL)\r
110    {\r
111       return info_ptr->compression_type;\r
112    }\r
113    return (0);\r
114 }\r
115 \r
116 png_uint_32 PNGAPI\r
117 png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)\r
118 {\r
119    if (png_ptr != NULL && info_ptr != NULL)\r
120 #if defined(PNG_pHYs_SUPPORTED)\r
121    if (info_ptr->valid & PNG_INFO_pHYs)\r
122    {\r
123       png_debug1(1, "in %s retrieval function\n", "png_get_x_pixels_per_meter");\r
124       if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER)\r
125           return (0);\r
126       else return (info_ptr->x_pixels_per_unit);\r
127    }\r
128 #else\r
129    return (0);\r
130 #endif\r
131    return (0);\r
132 }\r
133 \r
134 png_uint_32 PNGAPI\r
135 png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)\r
136 {\r
137    if (png_ptr != NULL && info_ptr != NULL)\r
138 #if defined(PNG_pHYs_SUPPORTED)\r
139    if (info_ptr->valid & PNG_INFO_pHYs)\r
140    {\r
141       png_debug1(1, "in %s retrieval function\n", "png_get_y_pixels_per_meter");\r
142       if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER)\r
143           return (0);\r
144       else return (info_ptr->y_pixels_per_unit);\r
145    }\r
146 #else\r
147    return (0);\r
148 #endif\r
149    return (0);\r
150 }\r
151 \r
152 png_uint_32 PNGAPI\r
153 png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)\r
154 {\r
155    if (png_ptr != NULL && info_ptr != NULL)\r
156 #if defined(PNG_pHYs_SUPPORTED)\r
157    if (info_ptr->valid & PNG_INFO_pHYs)\r
158    {\r
159       png_debug1(1, "in %s retrieval function\n", "png_get_pixels_per_meter");\r
160       if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER ||\r
161          info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit)\r
162           return (0);\r
163       else return (info_ptr->x_pixels_per_unit);\r
164    }\r
165 #else\r
166    return (0);\r
167 #endif\r
168    return (0);\r
169 }\r
170 \r
171 #ifdef PNG_FLOATING_POINT_SUPPORTED\r
172 float PNGAPI\r
173 png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr)\r
174    {\r
175    if (png_ptr != NULL && info_ptr != NULL)\r
176 #if defined(PNG_pHYs_SUPPORTED)\r
177    if (info_ptr->valid & PNG_INFO_pHYs)\r
178    {\r
179       png_debug1(1, "in %s retrieval function\n", "png_get_aspect_ratio");\r
180       if (info_ptr->x_pixels_per_unit == 0)\r
181          return ((float)0.0);\r
182       else\r
183          return ((float)((float)info_ptr->y_pixels_per_unit\r
184             /(float)info_ptr->x_pixels_per_unit));\r
185    }\r
186 #else\r
187    return (0.0);\r
188 #endif\r
189    return ((float)0.0);\r
190 }\r
191 #endif\r
192 \r
193 png_int_32 PNGAPI\r
194 png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr)\r
195 {\r
196    if (png_ptr != NULL && info_ptr != NULL)\r
197 #if defined(PNG_oFFs_SUPPORTED)\r
198    if (info_ptr->valid & PNG_INFO_oFFs)\r
199    {\r
200       png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns");\r
201       if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)\r
202           return (0);\r
203       else return (info_ptr->x_offset);\r
204    }\r
205 #else\r
206    return (0);\r
207 #endif\r
208    return (0);\r
209 }\r
210 \r
211 png_int_32 PNGAPI\r
212 png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr)\r
213 {\r
214    if (png_ptr != NULL && info_ptr != NULL)\r
215 #if defined(PNG_oFFs_SUPPORTED)\r
216    if (info_ptr->valid & PNG_INFO_oFFs)\r
217    {\r
218       png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns");\r
219       if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)\r
220           return (0);\r
221       else return (info_ptr->y_offset);\r
222    }\r
223 #else\r
224    return (0);\r
225 #endif\r
226    return (0);\r
227 }\r
228 \r
229 png_int_32 PNGAPI\r
230 png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr)\r
231 {\r
232    if (png_ptr != NULL && info_ptr != NULL)\r
233 #if defined(PNG_oFFs_SUPPORTED)\r
234    if (info_ptr->valid & PNG_INFO_oFFs)\r
235    {\r
236       png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns");\r
237       if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)\r
238           return (0);\r
239       else return (info_ptr->x_offset);\r
240    }\r
241 #else\r
242    return (0);\r
243 #endif\r
244    return (0);\r
245 }\r
246 \r
247 png_int_32 PNGAPI\r
248 png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr)\r
249 {\r
250    if (png_ptr != NULL && info_ptr != NULL)\r
251 #if defined(PNG_oFFs_SUPPORTED)\r
252    if (info_ptr->valid & PNG_INFO_oFFs)\r
253    {\r
254       png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns");\r
255       if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)\r
256           return (0);\r
257       else return (info_ptr->y_offset);\r
258    }\r
259 #else\r
260    return (0);\r
261 #endif\r
262    return (0);\r
263 }\r
264 \r
265 #if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED)\r
266 png_uint_32 PNGAPI\r
267 png_get_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)\r
268 {\r
269    return ((png_uint_32)((float)png_get_pixels_per_meter(png_ptr, info_ptr)\r
270      *.0254 +.5));\r
271 }\r
272 \r
273 png_uint_32 PNGAPI\r
274 png_get_x_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)\r
275 {\r
276    return ((png_uint_32)((float)png_get_x_pixels_per_meter(png_ptr, info_ptr)\r
277      *.0254 +.5));\r
278 }\r
279 \r
280 png_uint_32 PNGAPI\r
281 png_get_y_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)\r
282 {\r
283    return ((png_uint_32)((float)png_get_y_pixels_per_meter(png_ptr, info_ptr)\r
284      *.0254 +.5));\r
285 }\r
286 \r
287 float PNGAPI\r
288 png_get_x_offset_inches(png_structp png_ptr, png_infop info_ptr)\r
289 {\r
290    return ((float)png_get_x_offset_microns(png_ptr, info_ptr)\r
291      *.00003937);\r
292 }\r
293 \r
294 float PNGAPI\r
295 png_get_y_offset_inches(png_structp png_ptr, png_infop info_ptr)\r
296 {\r
297    return ((float)png_get_y_offset_microns(png_ptr, info_ptr)\r
298      *.00003937);\r
299 }\r
300 \r
301 #if defined(PNG_pHYs_SUPPORTED)\r
302 png_uint_32 PNGAPI\r
303 png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr,\r
304    png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)\r
305 {\r
306    png_uint_32 retval = 0;\r
307 \r
308    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))\r
309    {\r
310       png_debug1(1, "in %s retrieval function\n", "pHYs");\r
311       if (res_x != NULL)\r
312       {\r
313          *res_x = info_ptr->x_pixels_per_unit;\r
314          retval |= PNG_INFO_pHYs;\r
315       }\r
316       if (res_y != NULL)\r
317       {\r
318          *res_y = info_ptr->y_pixels_per_unit;\r
319          retval |= PNG_INFO_pHYs;\r
320       }\r
321       if (unit_type != NULL)\r
322       {\r
323          *unit_type = (int)info_ptr->phys_unit_type;\r
324          retval |= PNG_INFO_pHYs;\r
325          if (*unit_type == 1)\r
326          {\r
327             if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50);\r
328             if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50);\r
329          }\r
330       }\r
331    }\r
332    return (retval);\r
333 }\r
334 #endif /* PNG_pHYs_SUPPORTED */\r
335 #endif  /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */\r
336 \r
337 /* png_get_channels really belongs in here, too, but it's been around longer */\r
338 \r
339 #endif  /* PNG_EASY_ACCESS_SUPPORTED */\r
340 \r
341 png_byte PNGAPI\r
342 png_get_channels(png_structp png_ptr, png_infop info_ptr)\r
343 {\r
344    if (png_ptr != NULL && info_ptr != NULL)\r
345       return(info_ptr->channels);\r
346    else\r
347       return (0);\r
348 }\r
349 \r
350 png_bytep PNGAPI\r
351 png_get_signature(png_structp png_ptr, png_infop info_ptr)\r
352 {\r
353    if (png_ptr != NULL && info_ptr != NULL)\r
354       return(info_ptr->signature);\r
355    else\r
356       return (NULL);\r
357 }\r
358 \r
359 #if defined(PNG_bKGD_SUPPORTED)\r
360 png_uint_32 PNGAPI\r
361 png_get_bKGD(png_structp png_ptr, png_infop info_ptr,\r
362    png_color_16p *background)\r
363 {\r
364    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)\r
365       && background != NULL)\r
366    {\r
367       png_debug1(1, "in %s retrieval function\n", "bKGD");\r
368       *background = &(info_ptr->background);\r
369       return (PNG_INFO_bKGD);\r
370    }\r
371    return (0);\r
372 }\r
373 #endif\r
374 \r
375 #if defined(PNG_cHRM_SUPPORTED)\r
376 #ifdef PNG_FLOATING_POINT_SUPPORTED\r
377 png_uint_32 PNGAPI\r
378 png_get_cHRM(png_structp png_ptr, png_infop info_ptr,\r
379    double *white_x, double *white_y, double *red_x, double *red_y,\r
380    double *green_x, double *green_y, double *blue_x, double *blue_y)\r
381 {\r
382    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))\r
383    {\r
384       png_debug1(1, "in %s retrieval function\n", "cHRM");\r
385       if (white_x != NULL)\r
386          *white_x = (double)info_ptr->x_white;\r
387       if (white_y != NULL)\r
388          *white_y = (double)info_ptr->y_white;\r
389       if (red_x != NULL)\r
390          *red_x = (double)info_ptr->x_red;\r
391       if (red_y != NULL)\r
392          *red_y = (double)info_ptr->y_red;\r
393       if (green_x != NULL)\r
394          *green_x = (double)info_ptr->x_green;\r
395       if (green_y != NULL)\r
396          *green_y = (double)info_ptr->y_green;\r
397       if (blue_x != NULL)\r
398          *blue_x = (double)info_ptr->x_blue;\r
399       if (blue_y != NULL)\r
400          *blue_y = (double)info_ptr->y_blue;\r
401       return (PNG_INFO_cHRM);\r
402    }\r
403    return (0);\r
404 }\r
405 #endif\r
406 #ifdef PNG_FIXED_POINT_SUPPORTED\r
407 png_uint_32 PNGAPI\r
408 png_get_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,\r
409    png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x,\r
410    png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y,\r
411    png_fixed_point *blue_x, png_fixed_point *blue_y)\r
412 {\r
413    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))\r
414    {\r
415       png_debug1(1, "in %s retrieval function\n", "cHRM");\r
416       if (white_x != NULL)\r
417          *white_x = info_ptr->int_x_white;\r
418       if (white_y != NULL)\r
419          *white_y = info_ptr->int_y_white;\r
420       if (red_x != NULL)\r
421          *red_x = info_ptr->int_x_red;\r
422       if (red_y != NULL)\r
423          *red_y = info_ptr->int_y_red;\r
424       if (green_x != NULL)\r
425          *green_x = info_ptr->int_x_green;\r
426       if (green_y != NULL)\r
427          *green_y = info_ptr->int_y_green;\r
428       if (blue_x != NULL)\r
429          *blue_x = info_ptr->int_x_blue;\r
430       if (blue_y != NULL)\r
431          *blue_y = info_ptr->int_y_blue;\r
432       return (PNG_INFO_cHRM);\r
433    }\r
434    return (0);\r
435 }\r
436 #endif\r
437 #endif\r
438 \r
439 #if defined(PNG_gAMA_SUPPORTED)\r
440 #ifdef PNG_FLOATING_POINT_SUPPORTED\r
441 png_uint_32 PNGAPI\r
442 png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma)\r
443 {\r
444    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)\r
445       && file_gamma != NULL)\r
446    {\r
447       png_debug1(1, "in %s retrieval function\n", "gAMA");\r
448       *file_gamma = (double)info_ptr->gamma;\r
449       return (PNG_INFO_gAMA);\r
450    }\r
451    return (0);\r
452 }\r
453 #endif\r
454 #ifdef PNG_FIXED_POINT_SUPPORTED\r
455 png_uint_32 PNGAPI\r
456 png_get_gAMA_fixed(png_structp png_ptr, png_infop info_ptr,\r
457     png_fixed_point *int_file_gamma)\r
458 {\r
459    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)\r
460       && int_file_gamma != NULL)\r
461    {\r
462       png_debug1(1, "in %s retrieval function\n", "gAMA");\r
463       *int_file_gamma = info_ptr->int_gamma;\r
464       return (PNG_INFO_gAMA);\r
465    }\r
466    return (0);\r
467 }\r
468 #endif\r
469 #endif\r
470 \r
471 #if defined(PNG_sRGB_SUPPORTED)\r
472 png_uint_32 PNGAPI\r
473 png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent)\r
474 {\r
475    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)\r
476       && file_srgb_intent != NULL)\r
477    {\r
478       png_debug1(1, "in %s retrieval function\n", "sRGB");\r
479       *file_srgb_intent = (int)info_ptr->srgb_intent;\r
480       return (PNG_INFO_sRGB);\r
481    }\r
482    return (0);\r
483 }\r
484 #endif\r
485 \r
486 #if defined(PNG_iCCP_SUPPORTED)\r
487 png_uint_32 PNGAPI\r
488 png_get_iCCP(png_structp png_ptr, png_infop info_ptr,\r
489              png_charpp name, int *compression_type,\r
490              png_charpp profile, png_uint_32 *proflen)\r
491 {\r
492    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)\r
493       && name != NULL && profile != NULL && proflen != NULL)\r
494    {\r
495       png_debug1(1, "in %s retrieval function\n", "iCCP");\r
496       *name = info_ptr->iccp_name;\r
497       *profile = info_ptr->iccp_profile;\r
498       /* compression_type is a dummy so the API won't have to change\r
499          if we introduce multiple compression types later. */\r
500       *proflen = (int)info_ptr->iccp_proflen;\r
501       *compression_type = (int)info_ptr->iccp_compression;\r
502       return (PNG_INFO_iCCP);\r
503    }\r
504    return (0);\r
505 }\r
506 #endif\r
507 \r
508 #if defined(PNG_sPLT_SUPPORTED)\r
509 png_uint_32 PNGAPI\r
510 png_get_sPLT(png_structp png_ptr, png_infop info_ptr,\r
511              png_sPLT_tpp spalettes)\r
512 {\r
513    if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL)\r
514    {\r
515      *spalettes = info_ptr->splt_palettes;\r
516      return ((png_uint_32)info_ptr->splt_palettes_num);\r
517    }\r
518    return (0);\r
519 }\r
520 #endif\r
521 \r
522 #if defined(PNG_hIST_SUPPORTED)\r
523 png_uint_32 PNGAPI\r
524 png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist)\r
525 {\r
526    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)\r
527       && hist != NULL)\r
528    {\r
529       png_debug1(1, "in %s retrieval function\n", "hIST");\r
530       *hist = info_ptr->hist;\r
531       return (PNG_INFO_hIST);\r
532    }\r
533    return (0);\r
534 }\r
535 #endif\r
536 \r
537 png_uint_32 PNGAPI\r
538 png_get_IHDR(png_structp png_ptr, png_infop info_ptr,\r
539    png_uint_32 *width, png_uint_32 *height, int *bit_depth,\r
540    int *color_type, int *interlace_type, int *compression_type,\r
541    int *filter_type)\r
542 \r
543 {\r
544    if (png_ptr != NULL && info_ptr != NULL && width != NULL && height != NULL &&\r
545       bit_depth != NULL && color_type != NULL)\r
546    {\r
547       png_debug1(1, "in %s retrieval function\n", "IHDR");\r
548       *width = info_ptr->width;\r
549       *height = info_ptr->height;\r
550       *bit_depth = info_ptr->bit_depth;\r
551       if (info_ptr->bit_depth < 1 || info_ptr->bit_depth > 16)\r
552         png_error(png_ptr, "Invalid bit depth");\r
553       *color_type = info_ptr->color_type;\r
554       if (info_ptr->color_type > 6)\r
555         png_error(png_ptr, "Invalid color type");\r
556       if (compression_type != NULL)\r
557          *compression_type = info_ptr->compression_type;\r
558       if (filter_type != NULL)\r
559          *filter_type = info_ptr->filter_type;\r
560       if (interlace_type != NULL)\r
561          *interlace_type = info_ptr->interlace_type;\r
562 \r
563       /* check for potential overflow of rowbytes */\r
564       if (*width == 0 || *width > PNG_UINT_31_MAX)\r
565         png_error(png_ptr, "Invalid image width");\r
566       if (*height == 0 || *height > PNG_UINT_31_MAX)\r
567         png_error(png_ptr, "Invalid image height");\r
568       if (info_ptr->width > (PNG_UINT_32_MAX\r
569                  >> 3)      /* 8-byte RGBA pixels */\r
570                  - 64       /* bigrowbuf hack */\r
571                  - 1        /* filter byte */\r
572                  - 7*8      /* rounding of width to multiple of 8 pixels */\r
573                  - 8)       /* extra max_pixel_depth pad */\r
574       {\r
575          png_warning(png_ptr,\r
576             "Width too large for libpng to process image data.");\r
577       }\r
578       return (1);\r
579    }\r
580    return (0);\r
581 }\r
582 \r
583 #if defined(PNG_oFFs_SUPPORTED)\r
584 png_uint_32 PNGAPI\r
585 png_get_oFFs(png_structp png_ptr, png_infop info_ptr,\r
586    png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)\r
587 {\r
588    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)\r
589       && offset_x != NULL && offset_y != NULL && unit_type != NULL)\r
590    {\r
591       png_debug1(1, "in %s retrieval function\n", "oFFs");\r
592       *offset_x = info_ptr->x_offset;\r
593       *offset_y = info_ptr->y_offset;\r
594       *unit_type = (int)info_ptr->offset_unit_type;\r
595       return (PNG_INFO_oFFs);\r
596    }\r
597    return (0);\r
598 }\r
599 #endif\r
600 \r
601 #if defined(PNG_pCAL_SUPPORTED)\r
602 png_uint_32 PNGAPI\r
603 png_get_pCAL(png_structp png_ptr, png_infop info_ptr,\r
604    png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,\r
605    png_charp *units, png_charpp *params)\r
606 {\r
607    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)\r
608       && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&\r
609       nparams != NULL && units != NULL && params != NULL)\r
610    {\r
611       png_debug1(1, "in %s retrieval function\n", "pCAL");\r
612       *purpose = info_ptr->pcal_purpose;\r
613       *X0 = info_ptr->pcal_X0;\r
614       *X1 = info_ptr->pcal_X1;\r
615       *type = (int)info_ptr->pcal_type;\r
616       *nparams = (int)info_ptr->pcal_nparams;\r
617       *units = info_ptr->pcal_units;\r
618       *params = info_ptr->pcal_params;\r
619       return (PNG_INFO_pCAL);\r
620    }\r
621    return (0);\r
622 }\r
623 #endif\r
624 \r
625 #if defined(PNG_sCAL_SUPPORTED)\r
626 #ifdef PNG_FLOATING_POINT_SUPPORTED\r
627 png_uint_32 PNGAPI\r
628 png_get_sCAL(png_structp png_ptr, png_infop info_ptr,\r
629              int *unit, double *width, double *height)\r
630 {\r
631     if (png_ptr != NULL && info_ptr != NULL &&\r
632        (info_ptr->valid & PNG_INFO_sCAL))\r
633     {\r
634         *unit = info_ptr->scal_unit;\r
635         *width = info_ptr->scal_pixel_width;\r
636         *height = info_ptr->scal_pixel_height;\r
637         return (PNG_INFO_sCAL);\r
638     }\r
639     return(0);\r
640 }\r
641 #else\r
642 #ifdef PNG_FIXED_POINT_SUPPORTED\r
643 png_uint_32 PNGAPI\r
644 png_get_sCAL_s(png_structp png_ptr, png_infop info_ptr,\r
645              int *unit, png_charpp width, png_charpp height)\r
646 {\r
647     if (png_ptr != NULL && info_ptr != NULL &&\r
648        (info_ptr->valid & PNG_INFO_sCAL))\r
649     {\r
650         *unit = info_ptr->scal_unit;\r
651         *width = info_ptr->scal_s_width;\r
652         *height = info_ptr->scal_s_height;\r
653         return (PNG_INFO_sCAL);\r
654     }\r
655     return(0);\r
656 }\r
657 #endif\r
658 #endif\r
659 #endif\r
660 \r
661 #if defined(PNG_pHYs_SUPPORTED)\r
662 png_uint_32 PNGAPI\r
663 png_get_pHYs(png_structp png_ptr, png_infop info_ptr,\r
664    png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)\r
665 {\r
666    png_uint_32 retval = 0;\r
667 \r
668    if (png_ptr != NULL && info_ptr != NULL &&\r
669       (info_ptr->valid & PNG_INFO_pHYs))\r
670    {\r
671       png_debug1(1, "in %s retrieval function\n", "pHYs");\r
672       if (res_x != NULL)\r
673       {\r
674          *res_x = info_ptr->x_pixels_per_unit;\r
675          retval |= PNG_INFO_pHYs;\r
676       }\r
677       if (res_y != NULL)\r
678       {\r
679          *res_y = info_ptr->y_pixels_per_unit;\r
680          retval |= PNG_INFO_pHYs;\r
681       }\r
682       if (unit_type != NULL)\r
683       {\r
684          *unit_type = (int)info_ptr->phys_unit_type;\r
685          retval |= PNG_INFO_pHYs;\r
686       }\r
687    }\r
688    return (retval);\r
689 }\r
690 #endif\r
691 \r
692 png_uint_32 PNGAPI\r
693 png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette,\r
694    int *num_palette)\r
695 {\r
696    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE)\r
697        && palette != NULL)\r
698    {\r
699       png_debug1(1, "in %s retrieval function\n", "PLTE");\r
700       *palette = info_ptr->palette;\r
701       *num_palette = info_ptr->num_palette;\r
702       png_debug1(3, "num_palette = %d\n", *num_palette);\r
703       return (PNG_INFO_PLTE);\r
704    }\r
705    return (0);\r
706 }\r
707 \r
708 #if defined(PNG_sBIT_SUPPORTED)\r
709 png_uint_32 PNGAPI\r
710 png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit)\r
711 {\r
712    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)\r
713       && sig_bit != NULL)\r
714    {\r
715       png_debug1(1, "in %s retrieval function\n", "sBIT");\r
716       *sig_bit = &(info_ptr->sig_bit);\r
717       return (PNG_INFO_sBIT);\r
718    }\r
719    return (0);\r
720 }\r
721 #endif\r
722 \r
723 #if defined(PNG_TEXT_SUPPORTED)\r
724 png_uint_32 PNGAPI\r
725 png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,\r
726    int *num_text)\r
727 {\r
728    if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)\r
729    {\r
730       png_debug1(1, "in %s retrieval function\n",\r
731          (png_ptr->chunk_name[0] == '\0' ? "text"\r
732              : (png_const_charp)png_ptr->chunk_name));\r
733       if (text_ptr != NULL)\r
734          *text_ptr = info_ptr->text;\r
735       if (num_text != NULL)\r
736          *num_text = info_ptr->num_text;\r
737       return ((png_uint_32)info_ptr->num_text);\r
738    }\r
739    if (num_text != NULL)\r
740      *num_text = 0;\r
741    return(0);\r
742 }\r
743 #endif\r
744 \r
745 #if defined(PNG_tIME_SUPPORTED)\r
746 png_uint_32 PNGAPI\r
747 png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time)\r
748 {\r
749    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)\r
750        && mod_time != NULL)\r
751    {\r
752       png_debug1(1, "in %s retrieval function\n", "tIME");\r
753       *mod_time = &(info_ptr->mod_time);\r
754       return (PNG_INFO_tIME);\r
755    }\r
756    return (0);\r
757 }\r
758 #endif\r
759 \r
760 #if defined(PNG_tRNS_SUPPORTED)\r
761 png_uint_32 PNGAPI\r
762 png_get_tRNS(png_structp png_ptr, png_infop info_ptr,\r
763    png_bytep *trans, int *num_trans, png_color_16p *trans_values)\r
764 {\r
765    png_uint_32 retval = 0;\r
766    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))\r
767    {\r
768       png_debug1(1, "in %s retrieval function\n", "tRNS");\r
769       if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)\r
770       {\r
771           if (trans != NULL)\r
772           {\r
773              *trans = info_ptr->trans;\r
774              retval |= PNG_INFO_tRNS;\r
775           }\r
776           if (trans_values != NULL)\r
777              *trans_values = &(info_ptr->trans_values);\r
778       }\r
779       else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */\r
780       {\r
781           if (trans_values != NULL)\r
782           {\r
783              *trans_values = &(info_ptr->trans_values);\r
784              retval |= PNG_INFO_tRNS;\r
785           }\r
786           if (trans != NULL)\r
787              *trans = NULL;\r
788       }\r
789       if (num_trans != NULL)\r
790       {\r
791          *num_trans = info_ptr->num_trans;\r
792          retval |= PNG_INFO_tRNS;\r
793       }\r
794    }\r
795    return (retval);\r
796 }\r
797 #endif\r
798 \r
799 #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)\r
800 png_uint_32 PNGAPI\r
801 png_get_unknown_chunks(png_structp png_ptr, png_infop info_ptr,\r
802              png_unknown_chunkpp unknowns)\r
803 {\r
804    if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)\r
805    {\r
806      *unknowns = info_ptr->unknown_chunks;\r
807      return ((png_uint_32)info_ptr->unknown_chunks_num);\r
808    }\r
809    return (0);\r
810 }\r
811 #endif\r
812 \r
813 #if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)\r
814 png_byte PNGAPI\r
815 png_get_rgb_to_gray_status (png_structp png_ptr)\r
816 {\r
817    return (png_byte)(png_ptr? png_ptr->rgb_to_gray_status : 0);\r
818 }\r
819 #endif\r
820 \r
821 #if defined(PNG_USER_CHUNKS_SUPPORTED)\r
822 png_voidp PNGAPI\r
823 png_get_user_chunk_ptr(png_structp png_ptr)\r
824 {\r
825    return (png_ptr? png_ptr->user_chunk_ptr : NULL);\r
826 }\r
827 #endif\r
828 \r
829 #ifdef PNG_WRITE_SUPPORTED\r
830 png_uint_32 PNGAPI\r
831 png_get_compression_buffer_size(png_structp png_ptr)\r
832 {\r
833    return (png_uint_32)(png_ptr? png_ptr->zbuf_size : 0L);\r
834 }\r
835 #endif\r
836 \r
837 #ifdef PNG_ASSEMBLER_CODE_SUPPORTED\r
838 #ifndef PNG_1_0_X\r
839 /* this function was added to libpng 1.2.0 and should exist by default */\r
840 png_uint_32 PNGAPI\r
841 png_get_asm_flags (png_structp png_ptr)\r
842 {\r
843     /* obsolete, to be removed from libpng-1.4.0 */\r
844     return (png_ptr? 0L: 0L);\r
845 }\r
846 \r
847 /* this function was added to libpng 1.2.0 and should exist by default */\r
848 png_uint_32 PNGAPI\r
849 png_get_asm_flagmask (int flag_select)\r
850 {\r
851     /* obsolete, to be removed from libpng-1.4.0 */\r
852     flag_select=flag_select;\r
853     return 0L;\r
854 }\r
855 \r
856     /* GRR:  could add this:   && defined(PNG_MMX_CODE_SUPPORTED) */\r
857 /* this function was added to libpng 1.2.0 */\r
858 png_uint_32 PNGAPI\r
859 png_get_mmx_flagmask (int flag_select, int *compilerID)\r
860 {\r
861     /* obsolete, to be removed from libpng-1.4.0 */\r
862     flag_select=flag_select;\r
863     *compilerID = -1;   /* unknown (i.e., no asm/MMX code compiled) */\r
864     return 0L;\r
865 }\r
866 \r
867 /* this function was added to libpng 1.2.0 */\r
868 png_byte PNGAPI\r
869 png_get_mmx_bitdepth_threshold (png_structp png_ptr)\r
870 {\r
871     /* obsolete, to be removed from libpng-1.4.0 */\r
872     return (png_ptr? 0: 0);\r
873 }\r
874 \r
875 /* this function was added to libpng 1.2.0 */\r
876 png_uint_32 PNGAPI\r
877 png_get_mmx_rowbytes_threshold (png_structp png_ptr)\r
878 {\r
879     /* obsolete, to be removed from libpng-1.4.0 */\r
880     return (png_ptr? 0L: 0L);\r
881 }\r
882 #endif /* ?PNG_1_0_X */\r
883 #endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */\r
884 \r
885 #ifdef PNG_SET_USER_LIMITS_SUPPORTED\r
886 /* these functions were added to libpng 1.2.6 */\r
887 png_uint_32 PNGAPI\r
888 png_get_user_width_max (png_structp png_ptr)\r
889 {\r
890     return (png_ptr? png_ptr->user_width_max : 0);\r
891 }\r
892 png_uint_32 PNGAPI\r
893 png_get_user_height_max (png_structp png_ptr)\r
894 {\r
895     return (png_ptr? png_ptr->user_height_max : 0);\r
896 }\r
897 #endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */\r
898  \r
899 \r
900 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */\r