PageRenderTime 37ms CodeModel.GetById 2ms app.highlight 29ms RepoModel.GetById 2ms app.codeStats 0ms

/src/compiler/android/jni/ftk/pngget.c

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