PageRenderTime 93ms CodeModel.GetById 13ms app.highlight 74ms RepoModel.GetById 1ms app.codeStats 1ms

/thirdparty/libpng/pngget.c

http://crashrpt.googlecode.com/
C | 934 lines | 842 code | 69 blank | 23 comment | 361 complexity | 1fd7b1178a895edb84e1a3d4016428e4 MD5 | raw file
  1
  2/* pngget.c - retrieval of values from info struct
  3 *
  4 * libpng 1.2.7 - September 12, 2004
  5 * For conditions of distribution and use, see copyright notice in png.h
  6 * Copyright (c) 1998-2004 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
 14png_uint_32 PNGAPI
 15png_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
 23png_uint_32 PNGAPI
 24png_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)
 33png_bytepp PNGAPI
 34png_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 */
 45png_uint_32 PNGAPI
 46png_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
 55png_uint_32 PNGAPI
 56png_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
 65png_byte PNGAPI
 66png_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
 75png_byte PNGAPI
 76png_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
 85png_byte PNGAPI
 86png_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
 95png_byte PNGAPI
 96png_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
105png_byte PNGAPI
106png_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
115png_uint_32 PNGAPI
116png_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
133png_uint_32 PNGAPI
134png_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
151png_uint_32 PNGAPI
152png_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
171float PNGAPI
172png_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
192png_int_32 PNGAPI
193png_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
210png_int_32 PNGAPI
211png_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
228png_int_32 PNGAPI
229png_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
246png_int_32 PNGAPI
247png_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)
265png_uint_32 PNGAPI
266png_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
272png_uint_32 PNGAPI
273png_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
279png_uint_32 PNGAPI
280png_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
286float PNGAPI
287png_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
293float PNGAPI
294png_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)
301png_uint_32 PNGAPI
302png_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
340png_byte PNGAPI
341png_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
349png_bytep PNGAPI
350png_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)
359png_uint_32 PNGAPI
360png_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
376png_uint_32 PNGAPI
377png_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
406png_uint_32 PNGAPI
407png_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
440png_uint_32 PNGAPI
441png_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
454png_uint_32 PNGAPI
455png_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)
471png_uint_32 PNGAPI
472png_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)
486png_uint_32 PNGAPI
487png_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)
508png_uint_32 PNGAPI
509png_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)
519png_uint_32 PNGAPI
520png_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
533png_uint_32 PNGAPI
534png_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      png_debug1(1, "in %s retrieval function\n", "IHDR");
544      *width = info_ptr->width;
545      *height = info_ptr->height;
546      *bit_depth = info_ptr->bit_depth;
547      if (info_ptr->bit_depth < 1 || info_ptr->bit_depth > 16)
548        png_error(png_ptr, "Invalid bit depth");
549      *color_type = info_ptr->color_type;
550      if (info_ptr->color_type > 6)
551        png_error(png_ptr, "Invalid color type");
552      if (compression_type != NULL)
553         *compression_type = info_ptr->compression_type;
554      if (filter_type != NULL)
555         *filter_type = info_ptr->filter_type;
556      if (interlace_type != NULL)
557         *interlace_type = info_ptr->interlace_type;
558
559      /* check for potential overflow of rowbytes */
560      if (width == 0 || *width > PNG_UINT_31_MAX)
561        png_error(png_ptr, "Invalid image width");
562      if (height == 0 || *height > PNG_UINT_31_MAX)
563        png_error(png_ptr, "Invalid image height");
564      if (info_ptr->width > (PNG_UINT_32_MAX
565                 >> 3)      /* 8-byte RGBA pixels */
566                 - 64       /* bigrowbuf hack */
567                 - 1        /* filter byte */
568                 - 7*8      /* rounding of width to multiple of 8 pixels */
569                 - 8)       /* extra max_pixel_depth pad */
570      {
571         png_warning(png_ptr,
572            "Width too large for libpng to process image data.");
573      }
574      return (1);
575   }
576   return (0);
577}
578
579#if defined(PNG_oFFs_SUPPORTED)
580png_uint_32 PNGAPI
581png_get_oFFs(png_structp png_ptr, png_infop info_ptr,
582   png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)
583{
584   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)
585      && offset_x != NULL && offset_y != NULL && unit_type != NULL)
586   {
587      png_debug1(1, "in %s retrieval function\n", "oFFs");
588      *offset_x = info_ptr->x_offset;
589      *offset_y = info_ptr->y_offset;
590      *unit_type = (int)info_ptr->offset_unit_type;
591      return (PNG_INFO_oFFs);
592   }
593   return (0);
594}
595#endif
596
597#if defined(PNG_pCAL_SUPPORTED)
598png_uint_32 PNGAPI
599png_get_pCAL(png_structp png_ptr, png_infop info_ptr,
600   png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,
601   png_charp *units, png_charpp *params)
602{
603   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)
604      && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
605      nparams != NULL && units != NULL && params != NULL)
606   {
607      png_debug1(1, "in %s retrieval function\n", "pCAL");
608      *purpose = info_ptr->pcal_purpose;
609      *X0 = info_ptr->pcal_X0;
610      *X1 = info_ptr->pcal_X1;
611      *type = (int)info_ptr->pcal_type;
612      *nparams = (int)info_ptr->pcal_nparams;
613      *units = info_ptr->pcal_units;
614      *params = info_ptr->pcal_params;
615      return (PNG_INFO_pCAL);
616   }
617   return (0);
618}
619#endif
620
621#if defined(PNG_sCAL_SUPPORTED)
622#ifdef PNG_FLOATING_POINT_SUPPORTED
623png_uint_32 PNGAPI
624png_get_sCAL(png_structp png_ptr, png_infop info_ptr,
625             int *unit, double *width, double *height)
626{
627    if (png_ptr != NULL && info_ptr != NULL &&
628       (info_ptr->valid & PNG_INFO_sCAL))
629    {
630        *unit = info_ptr->scal_unit;
631        *width = info_ptr->scal_pixel_width;
632        *height = info_ptr->scal_pixel_height;
633        return (PNG_INFO_sCAL);
634    }
635    return(0);
636}
637#else
638#ifdef PNG_FIXED_POINT_SUPPORTED
639png_uint_32 PNGAPI
640png_get_sCAL_s(png_structp png_ptr, png_infop info_ptr,
641             int *unit, png_charpp width, png_charpp height)
642{
643    if (png_ptr != NULL && info_ptr != NULL &&
644       (info_ptr->valid & PNG_INFO_sCAL))
645    {
646        *unit = info_ptr->scal_unit;
647        *width = info_ptr->scal_s_width;
648        *height = info_ptr->scal_s_height;
649        return (PNG_INFO_sCAL);
650    }
651    return(0);
652}
653#endif
654#endif
655#endif
656
657#if defined(PNG_pHYs_SUPPORTED)
658png_uint_32 PNGAPI
659png_get_pHYs(png_structp png_ptr, png_infop info_ptr,
660   png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
661{
662   png_uint_32 retval = 0;
663
664   if (png_ptr != NULL && info_ptr != NULL &&
665      (info_ptr->valid & PNG_INFO_pHYs))
666   {
667      png_debug1(1, "in %s retrieval function\n", "pHYs");
668      if (res_x != NULL)
669      {
670         *res_x = info_ptr->x_pixels_per_unit;
671         retval |= PNG_INFO_pHYs;
672      }
673      if (res_y != NULL)
674      {
675         *res_y = info_ptr->y_pixels_per_unit;
676         retval |= PNG_INFO_pHYs;
677      }
678      if (unit_type != NULL)
679      {
680         *unit_type = (int)info_ptr->phys_unit_type;
681         retval |= PNG_INFO_pHYs;
682      }
683   }
684   return (retval);
685}
686#endif
687
688png_uint_32 PNGAPI
689png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette,
690   int *num_palette)
691{
692   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE)
693       && palette != NULL)
694   {
695      png_debug1(1, "in %s retrieval function\n", "PLTE");
696      *palette = info_ptr->palette;
697      *num_palette = info_ptr->num_palette;
698      png_debug1(3, "num_palette = %d\n", *num_palette);
699      return (PNG_INFO_PLTE);
700   }
701   return (0);
702}
703
704#if defined(PNG_sBIT_SUPPORTED)
705png_uint_32 PNGAPI
706png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit)
707{
708   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)
709      && sig_bit != NULL)
710   {
711      png_debug1(1, "in %s retrieval function\n", "sBIT");
712      *sig_bit = &(info_ptr->sig_bit);
713      return (PNG_INFO_sBIT);
714   }
715   return (0);
716}
717#endif
718
719#if defined(PNG_TEXT_SUPPORTED)
720png_uint_32 PNGAPI
721png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,
722   int *num_text)
723{
724   if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)
725   {
726      png_debug1(1, "in %s retrieval function\n",
727         (png_ptr->chunk_name[0] == '\0' ? "text"
728             : (png_const_charp)png_ptr->chunk_name));
729      if (text_ptr != NULL)
730         *text_ptr = info_ptr->text;
731      if (num_text != NULL)
732         *num_text = info_ptr->num_text;
733      return ((png_uint_32)info_ptr->num_text);
734   }
735   if (num_text != NULL)
736     *num_text = 0;
737   return(0);
738}
739#endif
740
741#if defined(PNG_tIME_SUPPORTED)
742png_uint_32 PNGAPI
743png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time)
744{
745   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)
746       && mod_time != NULL)
747   {
748      png_debug1(1, "in %s retrieval function\n", "tIME");
749      *mod_time = &(info_ptr->mod_time);
750      return (PNG_INFO_tIME);
751   }
752   return (0);
753}
754#endif
755
756#if defined(PNG_tRNS_SUPPORTED)
757png_uint_32 PNGAPI
758png_get_tRNS(png_structp png_ptr, png_infop info_ptr,
759   png_bytep *trans, int *num_trans, png_color_16p *trans_values)
760{
761   png_uint_32 retval = 0;
762   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))
763   {
764      png_debug1(1, "in %s retrieval function\n", "tRNS");
765      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
766      {
767          if (trans != NULL)
768          {
769             *trans = info_ptr->trans;
770             retval |= PNG_INFO_tRNS;
771          }
772          if (trans_values != NULL)
773             *trans_values = &(info_ptr->trans_values);
774      }
775      else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */
776      {
777          if (trans_values != NULL)
778          {
779             *trans_values = &(info_ptr->trans_values);
780             retval |= PNG_INFO_tRNS;
781          }
782          if(trans != NULL)
783             *trans = NULL;
784      }
785      if(num_trans != NULL)
786      {
787         *num_trans = info_ptr->num_trans;
788         retval |= PNG_INFO_tRNS;
789      }
790   }
791   return (retval);
792}
793#endif
794
795#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
796png_uint_32 PNGAPI
797png_get_unknown_chunks(png_structp png_ptr, png_infop info_ptr,
798             png_unknown_chunkpp unknowns)
799{
800   if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)
801     *unknowns = info_ptr->unknown_chunks;
802   return ((png_uint_32)info_ptr->unknown_chunks_num);
803}
804#endif
805
806#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
807png_byte PNGAPI
808png_get_rgb_to_gray_status (png_structp png_ptr)
809{
810   return (png_byte)(png_ptr? png_ptr->rgb_to_gray_status : 0);
811}
812#endif
813
814#if defined(PNG_USER_CHUNKS_SUPPORTED)
815png_voidp PNGAPI
816png_get_user_chunk_ptr(png_structp png_ptr)
817{
818   return (png_ptr? png_ptr->user_chunk_ptr : NULL);
819}
820#endif
821
822#ifdef PNG_WRITE_SUPPORTED
823png_uint_32 PNGAPI
824png_get_compression_buffer_size(png_structp png_ptr)
825{
826   return (png_uint_32)(png_ptr? png_ptr->zbuf_size : 0L);
827}
828#endif
829
830#ifndef PNG_1_0_X
831#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
832/* this function was added to libpng 1.2.0 and should exist by default */
833png_uint_32 PNGAPI
834png_get_asm_flags (png_structp png_ptr)
835{
836    return (png_uint_32)(png_ptr? png_ptr->asm_flags : 0L);
837}
838
839/* this function was added to libpng 1.2.0 and should exist by default */
840png_uint_32 PNGAPI
841png_get_asm_flagmask (int flag_select)
842{
843    png_uint_32 settable_asm_flags = 0;
844
845    if (flag_select & PNG_SELECT_READ)
846        settable_asm_flags |=
847          PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  |
848          PNG_ASM_FLAG_MMX_READ_INTERLACE    |
849          PNG_ASM_FLAG_MMX_READ_FILTER_SUB   |
850          PNG_ASM_FLAG_MMX_READ_FILTER_UP    |
851          PNG_ASM_FLAG_MMX_READ_FILTER_AVG   |
852          PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ;
853          /* no non-MMX flags yet */
854
855#if 0
856    /* GRR:  no write-flags yet, either, but someday... */
857    if (flag_select & PNG_SELECT_WRITE)
858        settable_asm_flags |=
859          PNG_ASM_FLAG_MMX_WRITE_ [whatever] ;
860#endif /* 0 */
861
862    return settable_asm_flags;  /* _theoretically_ settable capabilities only */
863}
864#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */
865
866
867#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
868    /* GRR:  could add this:   && defined(PNG_MMX_CODE_SUPPORTED) */
869/* this function was added to libpng 1.2.0 */
870png_uint_32 PNGAPI
871png_get_mmx_flagmask (int flag_select, int *compilerID)
872{
873    png_uint_32 settable_mmx_flags = 0;
874
875    if (flag_select & PNG_SELECT_READ)
876        settable_mmx_flags |=
877          PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  |
878          PNG_ASM_FLAG_MMX_READ_INTERLACE    |
879          PNG_ASM_FLAG_MMX_READ_FILTER_SUB   |
880          PNG_ASM_FLAG_MMX_READ_FILTER_UP    |
881          PNG_ASM_FLAG_MMX_READ_FILTER_AVG   |
882          PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ;
883#if 0
884    /* GRR:  no MMX write support yet, but someday... */
885    if (flag_select & PNG_SELECT_WRITE)
886        settable_mmx_flags |=
887          PNG_ASM_FLAG_MMX_WRITE_ [whatever] ;
888#endif /* 0 */
889
890    if (compilerID != NULL) {
891#ifdef PNG_USE_PNGVCRD
892        *compilerID = 1;    /* MSVC */
893#else
894#ifdef PNG_USE_PNGGCCRD
895        *compilerID = 2;    /* gcc/gas */
896#else
897        *compilerID = -1;   /* unknown (i.e., no asm/MMX code compiled) */
898#endif
899#endif
900    }
901
902    return settable_mmx_flags;  /* _theoretically_ settable capabilities only */
903}
904
905/* this function was added to libpng 1.2.0 */
906png_byte PNGAPI
907png_get_mmx_bitdepth_threshold (png_structp png_ptr)
908{
909    return (png_byte)(png_ptr? png_ptr->mmx_bitdepth_threshold : 0);
910}
911
912/* this function was added to libpng 1.2.0 */
913png_uint_32 PNGAPI
914png_get_mmx_rowbytes_threshold (png_structp png_ptr)
915{
916    return (png_uint_32)(png_ptr? png_ptr->mmx_rowbytes_threshold : 0L);
917}
918#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */
919
920#ifdef PNG_SET_USER_LIMITS_SUPPORTED
921/* these functions were added to libpng 1.2.6 */
922png_uint_32 PNGAPI
923png_get_user_width_max (png_structp png_ptr)
924{
925    return (png_ptr? png_ptr->user_width_max : 0);
926}
927png_uint_32 PNGAPI
928png_get_user_height_max (png_structp png_ptr)
929{
930    return (png_ptr? png_ptr->user_height_max : 0);
931}
932#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */
933
934#endif /* ?PNG_1_0_X */