source: trunk/third/libpng/pngget.c @ 17001

Revision 17001, 24.7 KB checked in by ghudson, 22 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r17000, which included commits to RCS files with non-trunk default branches.
Line 
1
2/* pngget.c - retrieval of values from info struct
3 *
4 * libpng 1.2.1 - December 12, 2001
5 * For conditions of distribution and use, see copyright notice in png.h
6 * Copyright (c) 1998-2001 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      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      *color_type = info_ptr->color_type;
551      if (compression_type != NULL)
552         *compression_type = info_ptr->compression_type;
553      if (filter_type != NULL)
554         *filter_type = info_ptr->filter_type;
555      if (interlace_type != NULL)
556         *interlace_type = info_ptr->interlace_type;
557
558      /* check for potential overflow of rowbytes */
559      if (*color_type == PNG_COLOR_TYPE_PALETTE)
560         channels = 1;
561      else if (*color_type & PNG_COLOR_MASK_COLOR)
562         channels = 3;
563      else
564         channels = 1;
565      if (*color_type & PNG_COLOR_MASK_ALPHA)
566         channels++;
567      pixel_depth = *bit_depth * channels;
568      rowbytes_per_pixel = (pixel_depth + 7) >> 3;
569      if ((*width > PNG_MAX_UINT/rowbytes_per_pixel))
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
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
829
830#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
831/* this function was added to libpng 1.2.0 and should exist by default*/
832png_uint_32 PNGAPI
833png_get_asm_flags (png_structp png_ptr)
834{
835    return (png_uint_32)(png_ptr? png_ptr->asm_flags : 0L);
836}
837
838/* this function was added to libpng 1.2.0 and should exist by default */
839png_uint_32 PNGAPI
840png_get_asm_flagmask (int flag_select)
841{
842    png_uint_32 settable_asm_flags = 0;
843
844    if (flag_select & PNG_SELECT_READ)
845        settable_asm_flags |=
846          PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  |
847          PNG_ASM_FLAG_MMX_READ_INTERLACE    |
848          PNG_ASM_FLAG_MMX_READ_FILTER_SUB   |
849          PNG_ASM_FLAG_MMX_READ_FILTER_UP    |
850          PNG_ASM_FLAG_MMX_READ_FILTER_AVG   |
851          PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ;
852          /* no non-MMX flags yet */
853
854#if 0
855    /* GRR:  no write-flags yet, either, but someday... */
856    if (flag_select & PNG_SELECT_WRITE)
857        settable_asm_flags |=
858          PNG_ASM_FLAG_MMX_WRITE_ [whatever] ;
859#endif /* 0 */
860
861    return settable_asm_flags;  /* _theoretically_ settable capabilities only */
862}
863#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */
864
865
866#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
867    /* GRR:  could add this:   && defined(PNG_MMX_CODE_SUPPORTED) */
868/* this function was added to libpng 1.2.0 */
869png_uint_32 PNGAPI
870png_get_mmx_flagmask (int flag_select, int *compilerID)
871{
872    png_uint_32 settable_mmx_flags = 0;
873
874    if (flag_select & PNG_SELECT_READ)
875        settable_mmx_flags |=
876          PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  |
877          PNG_ASM_FLAG_MMX_READ_INTERLACE    |
878          PNG_ASM_FLAG_MMX_READ_FILTER_SUB   |
879          PNG_ASM_FLAG_MMX_READ_FILTER_UP    |
880          PNG_ASM_FLAG_MMX_READ_FILTER_AVG   |
881          PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ;
882#if 0
883    /* GRR:  no MMX write support yet, but someday... */
884    if (flag_select & PNG_SELECT_WRITE)
885        settable_mmx_flags |=
886          PNG_ASM_FLAG_MMX_WRITE_ [whatever] ;
887#endif /* 0 */
888
889    if (compilerID != NULL) {
890#ifdef PNG_USE_PNGVCRD
891        *compilerID = 1;    /* MSVC */
892#else
893#ifdef PNG_USE_PNGGCCRD
894        *compilerID = 2;    /* gcc/gas */
895#else
896        *compilerID = -1;   /* unknown (i.e., no asm/MMX code compiled) */
897#endif
898#endif
899    }
900
901    return settable_mmx_flags;  /* _theoretically_ settable capabilities only */
902}
903
904/* this function was added to libpng 1.2.0 */
905png_byte PNGAPI
906png_get_mmx_bitdepth_threshold (png_structp png_ptr)
907{
908    return (png_byte)(png_ptr? png_ptr->mmx_bitdepth_threshold : 0);
909}
910
911/* this function was added to libpng 1.2.0 */
912png_uint_32 PNGAPI
913png_get_mmx_rowbytes_threshold (png_structp png_ptr)
914{
915    return (png_uint_32)(png_ptr? png_ptr->mmx_rowbytes_threshold : 0L);
916}
917#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */
Note: See TracBrowser for help on using the repository browser.