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