Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1.  
  2. /* pngget.c - retrieval of values from info struct
  3.  *
  4.  * Last changed in libpng 1.6.1 [March 28, 2013]
  5.  * Copyright (c) 1998-2013 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. #include "pngpriv.h"
  16.  
  17. #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  18.  
  19. png_uint_32 PNGAPI
  20. png_get_valid(png_const_structrp png_ptr, png_const_inforp info_ptr,
  21.     png_uint_32 flag)
  22. {
  23.    if (png_ptr != NULL && info_ptr != NULL)
  24.       return(info_ptr->valid & flag);
  25.  
  26.    return(0);
  27. }
  28.  
  29. png_size_t PNGAPI
  30. png_get_rowbytes(png_const_structrp png_ptr, png_const_inforp info_ptr)
  31. {
  32.    if (png_ptr != NULL && info_ptr != NULL)
  33.       return(info_ptr->rowbytes);
  34.  
  35.    return(0);
  36. }
  37.  
  38. #ifdef PNG_INFO_IMAGE_SUPPORTED
  39. png_bytepp PNGAPI
  40. png_get_rows(png_const_structrp png_ptr, png_const_inforp info_ptr)
  41. {
  42.    if (png_ptr != NULL && info_ptr != NULL)
  43.       return(info_ptr->row_pointers);
  44.  
  45.    return(0);
  46. }
  47. #endif
  48.  
  49. #ifdef PNG_EASY_ACCESS_SUPPORTED
  50. /* Easy access to info, added in libpng-0.99 */
  51. png_uint_32 PNGAPI
  52. png_get_image_width(png_const_structrp png_ptr, png_const_inforp info_ptr)
  53. {
  54.    if (png_ptr != NULL && info_ptr != NULL)
  55.       return info_ptr->width;
  56.  
  57.    return (0);
  58. }
  59.  
  60. png_uint_32 PNGAPI
  61. png_get_image_height(png_const_structrp png_ptr, png_const_inforp info_ptr)
  62. {
  63.    if (png_ptr != NULL && info_ptr != NULL)
  64.       return info_ptr->height;
  65.  
  66.    return (0);
  67. }
  68.  
  69. png_byte PNGAPI
  70. png_get_bit_depth(png_const_structrp png_ptr, png_const_inforp info_ptr)
  71. {
  72.    if (png_ptr != NULL && info_ptr != NULL)
  73.       return info_ptr->bit_depth;
  74.  
  75.    return (0);
  76. }
  77.  
  78. png_byte PNGAPI
  79. png_get_color_type(png_const_structrp png_ptr, png_const_inforp info_ptr)
  80. {
  81.    if (png_ptr != NULL && info_ptr != NULL)
  82.       return info_ptr->color_type;
  83.  
  84.    return (0);
  85. }
  86.  
  87. png_byte PNGAPI
  88. png_get_filter_type(png_const_structrp png_ptr, png_const_inforp info_ptr)
  89. {
  90.    if (png_ptr != NULL && info_ptr != NULL)
  91.       return info_ptr->filter_type;
  92.  
  93.    return (0);
  94. }
  95.  
  96. png_byte PNGAPI
  97. png_get_interlace_type(png_const_structrp png_ptr, png_const_inforp info_ptr)
  98. {
  99.    if (png_ptr != NULL && info_ptr != NULL)
  100.       return info_ptr->interlace_type;
  101.  
  102.    return (0);
  103. }
  104.  
  105. png_byte PNGAPI
  106. png_get_compression_type(png_const_structrp png_ptr, png_const_inforp info_ptr)
  107. {
  108.    if (png_ptr != NULL && info_ptr != NULL)
  109.       return info_ptr->compression_type;
  110.  
  111.    return (0);
  112. }
  113.  
  114. png_uint_32 PNGAPI
  115. png_get_x_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp
  116.    info_ptr)
  117. {
  118. #ifdef PNG_pHYs_SUPPORTED
  119.    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
  120.       {
  121.          png_debug1(1, "in %s retrieval function",
  122.              "png_get_x_pixels_per_meter");
  123.  
  124.          if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER)
  125.             return (info_ptr->x_pixels_per_unit);
  126.       }
  127. #endif
  128.  
  129.    return (0);
  130. }
  131.  
  132. png_uint_32 PNGAPI
  133. png_get_y_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp
  134.     info_ptr)
  135. {
  136. #ifdef PNG_pHYs_SUPPORTED
  137.    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
  138.    {
  139.       png_debug1(1, "in %s retrieval function",
  140.           "png_get_y_pixels_per_meter");
  141.  
  142.       if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER)
  143.          return (info_ptr->y_pixels_per_unit);
  144.    }
  145. #endif
  146.  
  147.    return (0);
  148. }
  149.  
  150. png_uint_32 PNGAPI
  151. png_get_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp info_ptr)
  152. {
  153. #ifdef PNG_pHYs_SUPPORTED
  154.    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
  155.    {
  156.       png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter");
  157.  
  158.       if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER &&
  159.           info_ptr->x_pixels_per_unit == info_ptr->y_pixels_per_unit)
  160.          return (info_ptr->x_pixels_per_unit);
  161.    }
  162. #endif
  163.  
  164.    return (0);
  165. }
  166.  
  167. #ifdef PNG_FLOATING_POINT_SUPPORTED
  168. float PNGAPI
  169. png_get_pixel_aspect_ratio(png_const_structrp png_ptr, png_const_inforp
  170.    info_ptr)
  171. {
  172. #ifdef PNG_READ_pHYs_SUPPORTED
  173.    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
  174.    {
  175.       png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio");
  176.  
  177.       if (info_ptr->x_pixels_per_unit != 0)
  178.          return ((float)((float)info_ptr->y_pixels_per_unit
  179.              /(float)info_ptr->x_pixels_per_unit));
  180.    }
  181. #else
  182.    PNG_UNUSED(png_ptr)
  183.    PNG_UNUSED(info_ptr)
  184. #endif
  185.  
  186.    return ((float)0.0);
  187. }
  188. #endif
  189.  
  190. #ifdef PNG_FIXED_POINT_SUPPORTED
  191. png_fixed_point PNGAPI
  192. png_get_pixel_aspect_ratio_fixed(png_const_structrp png_ptr,
  193.     png_const_inforp info_ptr)
  194. {
  195. #ifdef PNG_READ_pHYs_SUPPORTED
  196.    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)
  197.        && info_ptr->x_pixels_per_unit > 0 && info_ptr->y_pixels_per_unit > 0
  198.        && info_ptr->x_pixels_per_unit <= PNG_UINT_31_MAX
  199.        && info_ptr->y_pixels_per_unit <= PNG_UINT_31_MAX)
  200.    {
  201.       png_fixed_point res;
  202.  
  203.       png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio_fixed");
  204.  
  205.       /* The following casts work because a PNG 4 byte integer only has a valid
  206.        * range of 0..2^31-1; otherwise the cast might overflow.
  207.        */
  208.       if (png_muldiv(&res, (png_int_32)info_ptr->y_pixels_per_unit, PNG_FP_1,
  209.           (png_int_32)info_ptr->x_pixels_per_unit))
  210.          return res;
  211.    }
  212. #else
  213.    PNG_UNUSED(png_ptr)
  214.    PNG_UNUSED(info_ptr)
  215. #endif
  216.  
  217.    return 0;
  218. }
  219. #endif
  220.  
  221. png_int_32 PNGAPI
  222. png_get_x_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr)
  223. {
  224. #ifdef PNG_oFFs_SUPPORTED
  225.    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
  226.    {
  227.       png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");
  228.  
  229.       if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER)
  230.          return (info_ptr->x_offset);
  231.    }
  232. #endif
  233.  
  234.    return (0);
  235. }
  236.  
  237. png_int_32 PNGAPI
  238. png_get_y_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr)
  239. {
  240. #ifdef PNG_oFFs_SUPPORTED
  241.    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
  242.    {
  243.       png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");
  244.  
  245.       if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER)
  246.          return (info_ptr->y_offset);
  247.    }
  248. #endif
  249.  
  250.    return (0);
  251. }
  252.  
  253. png_int_32 PNGAPI
  254. png_get_x_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr)
  255. {
  256. #ifdef PNG_oFFs_SUPPORTED
  257.    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
  258.    {
  259.       png_debug1(1, "in %s retrieval function", "png_get_x_offset_pixels");
  260.  
  261.       if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL)
  262.          return (info_ptr->x_offset);
  263.    }
  264. #endif
  265.  
  266.    return (0);
  267. }
  268.  
  269. png_int_32 PNGAPI
  270. png_get_y_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr)
  271. {
  272. #ifdef PNG_oFFs_SUPPORTED
  273.    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
  274.    {
  275.       png_debug1(1, "in %s retrieval function", "png_get_y_offset_pixels");
  276.  
  277.       if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL)
  278.          return (info_ptr->y_offset);
  279.    }
  280. #endif
  281.  
  282.    return (0);
  283. }
  284.  
  285. #ifdef PNG_INCH_CONVERSIONS_SUPPORTED
  286. static png_uint_32
  287. ppi_from_ppm(png_uint_32 ppm)
  288. {
  289. #if 0
  290.    /* The conversion is *(2.54/100), in binary (32 digits):
  291.     * .00000110100000001001110101001001
  292.     */
  293.    png_uint_32 t1001, t1101;
  294.    ppm >>= 1;                  /* .1 */
  295.    t1001 = ppm + (ppm >> 3);   /* .1001 */
  296.    t1101 = t1001 + (ppm >> 1); /* .1101 */
  297.    ppm >>= 20;                 /* .000000000000000000001 */
  298.    t1101 += t1101 >> 15;       /* .1101000000000001101 */
  299.    t1001 >>= 11;               /* .000000000001001 */
  300.    t1001 += t1001 >> 12;       /* .000000000001001000000001001 */
  301.    ppm += t1001;               /* .000000000001001000001001001 */
  302.    ppm += t1101;               /* .110100000001001110101001001 */
  303.    return (ppm + 16) >> 5;/* .00000110100000001001110101001001 */
  304. #else
  305.    /* The argument is a PNG unsigned integer, so it is not permitted
  306.     * to be bigger than 2^31.
  307.     */
  308.    png_fixed_point result;
  309.    if (ppm <= PNG_UINT_31_MAX && png_muldiv(&result, (png_int_32)ppm, 127,
  310.        5000))
  311.       return result;
  312.  
  313.    /* Overflow. */
  314.    return 0;
  315. #endif
  316. }
  317.  
  318. png_uint_32 PNGAPI
  319. png_get_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)
  320. {
  321.    return ppi_from_ppm(png_get_pixels_per_meter(png_ptr, info_ptr));
  322. }
  323.  
  324. png_uint_32 PNGAPI
  325. png_get_x_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)
  326. {
  327.    return ppi_from_ppm(png_get_x_pixels_per_meter(png_ptr, info_ptr));
  328. }
  329.  
  330. png_uint_32 PNGAPI
  331. png_get_y_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)
  332. {
  333.    return ppi_from_ppm(png_get_y_pixels_per_meter(png_ptr, info_ptr));
  334. }
  335.  
  336. #ifdef PNG_FIXED_POINT_SUPPORTED
  337. static png_fixed_point
  338. png_fixed_inches_from_microns(png_const_structrp png_ptr, png_int_32 microns)
  339. {
  340.    /* Convert from metres * 1,000,000 to inches * 100,000, meters to
  341.     * inches is simply *(100/2.54), so we want *(10/2.54) == 500/127.
  342.     * Notice that this can overflow - a warning is output and 0 is
  343.     * returned.
  344.     */
  345.    return png_muldiv_warn(png_ptr, microns, 500, 127);
  346. }
  347.  
  348. png_fixed_point PNGAPI
  349. png_get_x_offset_inches_fixed(png_const_structrp png_ptr,
  350.     png_const_inforp info_ptr)
  351. {
  352.    return png_fixed_inches_from_microns(png_ptr,
  353.        png_get_x_offset_microns(png_ptr, info_ptr));
  354. }
  355. #endif
  356.  
  357. #ifdef PNG_FIXED_POINT_SUPPORTED
  358. png_fixed_point PNGAPI
  359. png_get_y_offset_inches_fixed(png_const_structrp png_ptr,
  360.     png_const_inforp info_ptr)
  361. {
  362.    return png_fixed_inches_from_microns(png_ptr,
  363.        png_get_y_offset_microns(png_ptr, info_ptr));
  364. }
  365. #endif
  366.  
  367. #ifdef PNG_FLOATING_POINT_SUPPORTED
  368. float PNGAPI
  369. png_get_x_offset_inches(png_const_structrp png_ptr, png_const_inforp info_ptr)
  370. {
  371.    /* To avoid the overflow do the conversion directly in floating
  372.     * point.
  373.     */
  374.    return (float)(png_get_x_offset_microns(png_ptr, info_ptr) * .00003937);
  375. }
  376. #endif
  377.  
  378. #ifdef PNG_FLOATING_POINT_SUPPORTED
  379. float PNGAPI
  380. png_get_y_offset_inches(png_const_structrp png_ptr, png_const_inforp info_ptr)
  381. {
  382.    /* To avoid the overflow do the conversion directly in floating
  383.     * point.
  384.     */
  385.    return (float)(png_get_y_offset_microns(png_ptr, info_ptr) * .00003937);
  386. }
  387. #endif
  388.  
  389. #ifdef PNG_pHYs_SUPPORTED
  390. png_uint_32 PNGAPI
  391. png_get_pHYs_dpi(png_const_structrp png_ptr, png_const_inforp info_ptr,
  392.     png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
  393. {
  394.    png_uint_32 retval = 0;
  395.  
  396.    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
  397.    {
  398.       png_debug1(1, "in %s retrieval function", "pHYs");
  399.  
  400.       if (res_x != NULL)
  401.       {
  402.          *res_x = info_ptr->x_pixels_per_unit;
  403.          retval |= PNG_INFO_pHYs;
  404.       }
  405.  
  406.       if (res_y != NULL)
  407.       {
  408.          *res_y = info_ptr->y_pixels_per_unit;
  409.          retval |= PNG_INFO_pHYs;
  410.       }
  411.  
  412.       if (unit_type != NULL)
  413.       {
  414.          *unit_type = (int)info_ptr->phys_unit_type;
  415.          retval |= PNG_INFO_pHYs;
  416.  
  417.          if (*unit_type == 1)
  418.          {
  419.             if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50);
  420.             if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50);
  421.          }
  422.       }
  423.    }
  424.  
  425.    return (retval);
  426. }
  427. #endif /* PNG_pHYs_SUPPORTED */
  428. #endif  /* PNG_INCH_CONVERSIONS_SUPPORTED */
  429.  
  430. /* png_get_channels really belongs in here, too, but it's been around longer */
  431.  
  432. #endif  /* PNG_EASY_ACCESS_SUPPORTED */
  433.  
  434.  
  435. png_byte PNGAPI
  436. png_get_channels(png_const_structrp png_ptr, png_const_inforp info_ptr)
  437. {
  438.    if (png_ptr != NULL && info_ptr != NULL)
  439.       return(info_ptr->channels);
  440.  
  441.    return (0);
  442. }
  443.  
  444. #ifdef PNG_READ_SUPPORTED
  445. png_const_bytep PNGAPI
  446. png_get_signature(png_const_structrp png_ptr, png_const_inforp info_ptr)
  447. {
  448.    if (png_ptr != NULL && info_ptr != NULL)
  449.       return(info_ptr->signature);
  450.  
  451.    return (NULL);
  452. }
  453. #endif
  454.  
  455. #ifdef PNG_bKGD_SUPPORTED
  456. png_uint_32 PNGAPI
  457. png_get_bKGD(png_const_structrp png_ptr, png_inforp info_ptr,
  458.    png_color_16p *background)
  459. {
  460.    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)
  461.        && background != NULL)
  462.    {
  463.       png_debug1(1, "in %s retrieval function", "bKGD");
  464.  
  465.       *background = &(info_ptr->background);
  466.       return (PNG_INFO_bKGD);
  467.    }
  468.  
  469.    return (0);
  470. }
  471. #endif
  472.  
  473. #ifdef PNG_cHRM_SUPPORTED
  474. /* The XYZ APIs were added in 1.5.5 to take advantage of the code added at the
  475.  * same time to correct the rgb grayscale coefficient defaults obtained from the
  476.  * cHRM chunk in 1.5.4
  477.  */
  478. #  ifdef PNG_FLOATING_POINT_SUPPORTED
  479. png_uint_32 PNGAPI
  480. png_get_cHRM(png_const_structrp png_ptr, png_const_inforp info_ptr,
  481.     double *white_x, double *white_y, double *red_x, double *red_y,
  482.     double *green_x, double *green_y, double *blue_x, double *blue_y)
  483. {
  484.    /* Quiet API change: this code used to only return the end points if a cHRM
  485.     * chunk was present, but the end points can also come from iCCP or sRGB
  486.     * chunks, so in 1.6.0 the png_get_ APIs return the end points regardless and
  487.     * the png_set_ APIs merely check that set end points are mutually
  488.     * consistent.
  489.     */
  490.    if (png_ptr != NULL && info_ptr != NULL &&
  491.       (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS))
  492.    {
  493.       png_debug1(1, "in %s retrieval function", "cHRM");
  494.  
  495.       if (white_x != NULL)
  496.          *white_x = png_float(png_ptr,
  497.             info_ptr->colorspace.end_points_xy.whitex, "cHRM white X");
  498.       if (white_y != NULL)
  499.          *white_y = png_float(png_ptr,
  500.             info_ptr->colorspace.end_points_xy.whitey, "cHRM white Y");
  501.       if (red_x != NULL)
  502.          *red_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redx,
  503.             "cHRM red X");
  504.       if (red_y != NULL)
  505.          *red_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redy,
  506.             "cHRM red Y");
  507.       if (green_x != NULL)
  508.          *green_x = png_float(png_ptr,
  509.             info_ptr->colorspace.end_points_xy.greenx, "cHRM green X");
  510.       if (green_y != NULL)
  511.          *green_y = png_float(png_ptr,
  512.             info_ptr->colorspace.end_points_xy.greeny, "cHRM green Y");
  513.       if (blue_x != NULL)
  514.          *blue_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluex,
  515.             "cHRM blue X");
  516.       if (blue_y != NULL)
  517.          *blue_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluey,
  518.             "cHRM blue Y");
  519.       return (PNG_INFO_cHRM);
  520.    }
  521.  
  522.    return (0);
  523. }
  524.  
  525. png_uint_32 PNGAPI
  526. png_get_cHRM_XYZ(png_const_structrp png_ptr, png_const_inforp info_ptr,
  527.    double *red_X, double *red_Y, double *red_Z, double *green_X,
  528.    double *green_Y, double *green_Z, double *blue_X, double *blue_Y,
  529.    double *blue_Z)
  530. {
  531.    if (png_ptr != NULL && info_ptr != NULL &&
  532.       (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS))
  533.    {
  534.       png_debug1(1, "in %s retrieval function", "cHRM_XYZ(float)");
  535.  
  536.       if (red_X != NULL)
  537.          *red_X = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_X,
  538.             "cHRM red X");
  539.       if (red_Y != NULL)
  540.          *red_Y = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_Y,
  541.             "cHRM red Y");
  542.       if (red_Z != NULL)
  543.          *red_Z = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_Z,
  544.             "cHRM red Z");
  545.       if (green_X != NULL)
  546.          *green_X = png_float(png_ptr,
  547.             info_ptr->colorspace.end_points_XYZ.green_X, "cHRM green X");
  548.       if (green_Y != NULL)
  549.          *green_Y = png_float(png_ptr,
  550.             info_ptr->colorspace.end_points_XYZ.green_Y, "cHRM green Y");
  551.       if (green_Z != NULL)
  552.          *green_Z = png_float(png_ptr,
  553.             info_ptr->colorspace.end_points_XYZ.green_Z, "cHRM green Z");
  554.       if (blue_X != NULL)
  555.          *blue_X = png_float(png_ptr,
  556.             info_ptr->colorspace.end_points_XYZ.blue_X, "cHRM blue X");
  557.       if (blue_Y != NULL)
  558.          *blue_Y = png_float(png_ptr,
  559.             info_ptr->colorspace.end_points_XYZ.blue_Y, "cHRM blue Y");
  560.       if (blue_Z != NULL)
  561.          *blue_Z = png_float(png_ptr,
  562.             info_ptr->colorspace.end_points_XYZ.blue_Z, "cHRM blue Z");
  563.       return (PNG_INFO_cHRM);
  564.    }
  565.  
  566.    return (0);
  567. }
  568. #  endif
  569.  
  570. #  ifdef PNG_FIXED_POINT_SUPPORTED
  571. png_uint_32 PNGAPI
  572. png_get_cHRM_XYZ_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
  573.     png_fixed_point *int_red_X, png_fixed_point *int_red_Y,
  574.     png_fixed_point *int_red_Z, png_fixed_point *int_green_X,
  575.     png_fixed_point *int_green_Y, png_fixed_point *int_green_Z,
  576.     png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y,
  577.     png_fixed_point *int_blue_Z)
  578. {
  579.    if (png_ptr != NULL && info_ptr != NULL &&
  580.       (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS))
  581.    {
  582.       png_debug1(1, "in %s retrieval function", "cHRM_XYZ");
  583.  
  584.       if (int_red_X != NULL)
  585.          *int_red_X = info_ptr->colorspace.end_points_XYZ.red_X;
  586.       if (int_red_Y != NULL)
  587.          *int_red_Y = info_ptr->colorspace.end_points_XYZ.red_Y;
  588.       if (int_red_Z != NULL)
  589.          *int_red_Z = info_ptr->colorspace.end_points_XYZ.red_Z;
  590.       if (int_green_X != NULL)
  591.          *int_green_X = info_ptr->colorspace.end_points_XYZ.green_X;
  592.       if (int_green_Y != NULL)
  593.          *int_green_Y = info_ptr->colorspace.end_points_XYZ.green_Y;
  594.       if (int_green_Z != NULL)
  595.          *int_green_Z = info_ptr->colorspace.end_points_XYZ.green_Z;
  596.       if (int_blue_X != NULL)
  597.          *int_blue_X = info_ptr->colorspace.end_points_XYZ.blue_X;
  598.       if (int_blue_Y != NULL)
  599.          *int_blue_Y = info_ptr->colorspace.end_points_XYZ.blue_Y;
  600.       if (int_blue_Z != NULL)
  601.          *int_blue_Z = info_ptr->colorspace.end_points_XYZ.blue_Z;
  602.       return (PNG_INFO_cHRM);
  603.    }
  604.  
  605.    return (0);
  606. }
  607.  
  608. png_uint_32 PNGAPI
  609. png_get_cHRM_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
  610.     png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x,
  611.     png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y,
  612.     png_fixed_point *blue_x, png_fixed_point *blue_y)
  613. {
  614.    png_debug1(1, "in %s retrieval function", "cHRM");
  615.  
  616.    if (png_ptr != NULL && info_ptr != NULL &&
  617.       (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS))
  618.    {
  619.       if (white_x != NULL)
  620.          *white_x = info_ptr->colorspace.end_points_xy.whitex;
  621.       if (white_y != NULL)
  622.          *white_y = info_ptr->colorspace.end_points_xy.whitey;
  623.       if (red_x != NULL)
  624.          *red_x = info_ptr->colorspace.end_points_xy.redx;
  625.       if (red_y != NULL)
  626.          *red_y = info_ptr->colorspace.end_points_xy.redy;
  627.       if (green_x != NULL)
  628.          *green_x = info_ptr->colorspace.end_points_xy.greenx;
  629.       if (green_y != NULL)
  630.          *green_y = info_ptr->colorspace.end_points_xy.greeny;
  631.       if (blue_x != NULL)
  632.          *blue_x = info_ptr->colorspace.end_points_xy.bluex;
  633.       if (blue_y != NULL)
  634.          *blue_y = info_ptr->colorspace.end_points_xy.bluey;
  635.       return (PNG_INFO_cHRM);
  636.    }
  637.  
  638.    return (0);
  639. }
  640. #  endif
  641. #endif
  642.  
  643. #ifdef PNG_gAMA_SUPPORTED
  644. #  ifdef PNG_FIXED_POINT_SUPPORTED
  645. png_uint_32 PNGAPI
  646. png_get_gAMA_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
  647.     png_fixed_point *file_gamma)
  648. {
  649.    png_debug1(1, "in %s retrieval function", "gAMA");
  650.  
  651.    if (png_ptr != NULL && info_ptr != NULL &&
  652.       (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) &&
  653.       file_gamma != NULL)
  654.    {
  655.       *file_gamma = info_ptr->colorspace.gamma;
  656.       return (PNG_INFO_gAMA);
  657.    }
  658.  
  659.    return (0);
  660. }
  661. #  endif
  662.  
  663. #  ifdef PNG_FLOATING_POINT_SUPPORTED
  664. png_uint_32 PNGAPI
  665. png_get_gAMA(png_const_structrp png_ptr, png_const_inforp info_ptr,
  666.     double *file_gamma)
  667. {
  668.    png_debug1(1, "in %s retrieval function", "gAMA(float)");
  669.  
  670.    if (png_ptr != NULL && info_ptr != NULL &&
  671.       (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) &&
  672.       file_gamma != NULL)
  673.    {
  674.       *file_gamma = png_float(png_ptr, info_ptr->colorspace.gamma,
  675.          "png_get_gAMA");
  676.       return (PNG_INFO_gAMA);
  677.    }
  678.  
  679.    return (0);
  680. }
  681. #  endif
  682. #endif
  683.  
  684. #ifdef PNG_sRGB_SUPPORTED
  685. png_uint_32 PNGAPI
  686. png_get_sRGB(png_const_structrp png_ptr, png_const_inforp info_ptr,
  687.     int *file_srgb_intent)
  688. {
  689.    png_debug1(1, "in %s retrieval function", "sRGB");
  690.  
  691.    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)
  692.        && file_srgb_intent != NULL)
  693.    {
  694.       *file_srgb_intent = info_ptr->colorspace.rendering_intent;
  695.       return (PNG_INFO_sRGB);
  696.    }
  697.  
  698.    return (0);
  699. }
  700. #endif
  701.  
  702. #ifdef PNG_iCCP_SUPPORTED
  703. png_uint_32 PNGAPI
  704. png_get_iCCP(png_const_structrp png_ptr, png_inforp info_ptr,
  705.     png_charpp name, int *compression_type,
  706.     png_bytepp profile, png_uint_32 *proflen)
  707. {
  708.    png_debug1(1, "in %s retrieval function", "iCCP");
  709.  
  710.    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)
  711.        && name != NULL && compression_type != NULL && profile != NULL &&
  712.                  proflen != NULL)
  713.    {
  714.       *name = info_ptr->iccp_name;
  715.       *profile = info_ptr->iccp_profile;
  716.       *proflen = png_get_uint_32(info_ptr->iccp_profile);
  717.       /* This is somewhat irrelevant since the profile data returned has
  718.        * actually been uncompressed.
  719.        */
  720.       *compression_type = PNG_COMPRESSION_TYPE_BASE;
  721.       return (PNG_INFO_iCCP);
  722.    }
  723.  
  724.    return (0);
  725. }
  726. #endif
  727.  
  728. #ifdef PNG_sPLT_SUPPORTED
  729. int PNGAPI
  730. png_get_sPLT(png_const_structrp png_ptr, png_inforp info_ptr,
  731.     png_sPLT_tpp spalettes)
  732. {
  733.    if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL)
  734.    {
  735.       *spalettes = info_ptr->splt_palettes;
  736.       return info_ptr->splt_palettes_num;
  737.    }
  738.  
  739.    return (0);
  740. }
  741. #endif
  742.  
  743. #ifdef PNG_hIST_SUPPORTED
  744. png_uint_32 PNGAPI
  745. png_get_hIST(png_const_structrp png_ptr, png_inforp info_ptr,
  746.     png_uint_16p *hist)
  747. {
  748.    png_debug1(1, "in %s retrieval function", "hIST");
  749.  
  750.    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)
  751.        && hist != NULL)
  752.    {
  753.       *hist = info_ptr->hist;
  754.       return (PNG_INFO_hIST);
  755.    }
  756.  
  757.    return (0);
  758. }
  759. #endif
  760.  
  761. png_uint_32 PNGAPI
  762. png_get_IHDR(png_const_structrp png_ptr, png_const_inforp info_ptr,
  763.     png_uint_32 *width, png_uint_32 *height, int *bit_depth,
  764.     int *color_type, int *interlace_type, int *compression_type,
  765.     int *filter_type)
  766. {
  767.    png_debug1(1, "in %s retrieval function", "IHDR");
  768.  
  769.    if (png_ptr == NULL || info_ptr == NULL || width == NULL ||
  770.        height == NULL || bit_depth == NULL || color_type == NULL)
  771.       return (0);
  772.  
  773.    *width = info_ptr->width;
  774.    *height = info_ptr->height;
  775.    *bit_depth = info_ptr->bit_depth;
  776.    *color_type = info_ptr->color_type;
  777.  
  778.    if (compression_type != NULL)
  779.       *compression_type = info_ptr->compression_type;
  780.  
  781.    if (filter_type != NULL)
  782.       *filter_type = info_ptr->filter_type;
  783.  
  784.    if (interlace_type != NULL)
  785.       *interlace_type = info_ptr->interlace_type;
  786.  
  787.    /* This is redundant if we can be sure that the info_ptr values were all
  788.     * assigned in png_set_IHDR().  We do the check anyhow in case an
  789.     * application has ignored our advice not to mess with the members
  790.     * of info_ptr directly.
  791.     */
  792.    png_check_IHDR(png_ptr, info_ptr->width, info_ptr->height,
  793.        info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,
  794.        info_ptr->compression_type, info_ptr->filter_type);
  795.  
  796.    return (1);
  797. }
  798.  
  799. #ifdef PNG_oFFs_SUPPORTED
  800. png_uint_32 PNGAPI
  801. png_get_oFFs(png_const_structrp png_ptr, png_const_inforp info_ptr,
  802.     png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)
  803. {
  804.    png_debug1(1, "in %s retrieval function", "oFFs");
  805.  
  806.    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)
  807.        && offset_x != NULL && offset_y != NULL && unit_type != NULL)
  808.    {
  809.       *offset_x = info_ptr->x_offset;
  810.       *offset_y = info_ptr->y_offset;
  811.       *unit_type = (int)info_ptr->offset_unit_type;
  812.       return (PNG_INFO_oFFs);
  813.    }
  814.  
  815.    return (0);
  816. }
  817. #endif
  818.  
  819. #ifdef PNG_pCAL_SUPPORTED
  820. png_uint_32 PNGAPI
  821. png_get_pCAL(png_const_structrp png_ptr, png_inforp info_ptr,
  822.     png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,
  823.     png_charp *units, png_charpp *params)
  824. {
  825.    png_debug1(1, "in %s retrieval function", "pCAL");
  826.  
  827.    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)
  828.        && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
  829.        nparams != NULL && units != NULL && params != NULL)
  830.    {
  831.       *purpose = info_ptr->pcal_purpose;
  832.       *X0 = info_ptr->pcal_X0;
  833.       *X1 = info_ptr->pcal_X1;
  834.       *type = (int)info_ptr->pcal_type;
  835.       *nparams = (int)info_ptr->pcal_nparams;
  836.       *units = info_ptr->pcal_units;
  837.       *params = info_ptr->pcal_params;
  838.       return (PNG_INFO_pCAL);
  839.    }
  840.  
  841.    return (0);
  842. }
  843. #endif
  844.  
  845. #ifdef PNG_sCAL_SUPPORTED
  846. #  ifdef PNG_FIXED_POINT_SUPPORTED
  847. #    if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || \
  848.          defined(PNG_FLOATING_POINT_SUPPORTED)
  849. png_uint_32 PNGAPI
  850. png_get_sCAL_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
  851.     int *unit, png_fixed_point *width, png_fixed_point *height)
  852. {
  853.    if (png_ptr != NULL && info_ptr != NULL &&
  854.        (info_ptr->valid & PNG_INFO_sCAL))
  855.    {
  856.       *unit = info_ptr->scal_unit;
  857.       /*TODO: make this work without FP support; the API is currently eliminated
  858.        * if neither floating point APIs nor internal floating point arithmetic
  859.        * are enabled.
  860.        */
  861.       *width = png_fixed(png_ptr, atof(info_ptr->scal_s_width), "sCAL width");
  862.       *height = png_fixed(png_ptr, atof(info_ptr->scal_s_height),
  863.          "sCAL height");
  864.       return (PNG_INFO_sCAL);
  865.    }
  866.  
  867.    return(0);
  868. }
  869. #    endif /* FLOATING_ARITHMETIC */
  870. #  endif /* FIXED_POINT */
  871. #  ifdef PNG_FLOATING_POINT_SUPPORTED
  872. png_uint_32 PNGAPI
  873. png_get_sCAL(png_const_structrp png_ptr, png_const_inforp info_ptr,
  874.     int *unit, double *width, double *height)
  875. {
  876.    if (png_ptr != NULL && info_ptr != NULL &&
  877.        (info_ptr->valid & PNG_INFO_sCAL))
  878.    {
  879.       *unit = info_ptr->scal_unit;
  880.       *width = atof(info_ptr->scal_s_width);
  881.       *height = atof(info_ptr->scal_s_height);
  882.       return (PNG_INFO_sCAL);
  883.    }
  884.  
  885.    return(0);
  886. }
  887. #  endif /* FLOATING POINT */
  888. png_uint_32 PNGAPI
  889. png_get_sCAL_s(png_const_structrp png_ptr, png_const_inforp info_ptr,
  890.     int *unit, png_charpp width, png_charpp height)
  891. {
  892.    if (png_ptr != NULL && info_ptr != NULL &&
  893.        (info_ptr->valid & PNG_INFO_sCAL))
  894.    {
  895.       *unit = info_ptr->scal_unit;
  896.       *width = info_ptr->scal_s_width;
  897.       *height = info_ptr->scal_s_height;
  898.       return (PNG_INFO_sCAL);
  899.    }
  900.  
  901.    return(0);
  902. }
  903. #endif /* sCAL */
  904.  
  905. #ifdef PNG_pHYs_SUPPORTED
  906. png_uint_32 PNGAPI
  907. png_get_pHYs(png_const_structrp png_ptr, png_const_inforp info_ptr,
  908.     png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
  909. {
  910.    png_uint_32 retval = 0;
  911.  
  912.    png_debug1(1, "in %s retrieval function", "pHYs");
  913.  
  914.    if (png_ptr != NULL && info_ptr != NULL &&
  915.        (info_ptr->valid & PNG_INFO_pHYs))
  916.    {
  917.       if (res_x != NULL)
  918.       {
  919.          *res_x = info_ptr->x_pixels_per_unit;
  920.          retval |= PNG_INFO_pHYs;
  921.       }
  922.  
  923.       if (res_y != NULL)
  924.       {
  925.          *res_y = info_ptr->y_pixels_per_unit;
  926.          retval |= PNG_INFO_pHYs;
  927.       }
  928.  
  929.       if (unit_type != NULL)
  930.       {
  931.          *unit_type = (int)info_ptr->phys_unit_type;
  932.          retval |= PNG_INFO_pHYs;
  933.       }
  934.    }
  935.  
  936.    return (retval);
  937. }
  938. #endif /* pHYs */
  939.  
  940. png_uint_32 PNGAPI
  941. png_get_PLTE(png_const_structrp png_ptr, png_inforp info_ptr,
  942.     png_colorp *palette, int *num_palette)
  943. {
  944.    png_debug1(1, "in %s retrieval function", "PLTE");
  945.  
  946.    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE)
  947.        && palette != NULL)
  948.    {
  949.       *palette = info_ptr->palette;
  950.       *num_palette = info_ptr->num_palette;
  951.       png_debug1(3, "num_palette = %d", *num_palette);
  952.       return (PNG_INFO_PLTE);
  953.    }
  954.  
  955.    return (0);
  956. }
  957.  
  958. #ifdef PNG_sBIT_SUPPORTED
  959. png_uint_32 PNGAPI
  960. png_get_sBIT(png_const_structrp png_ptr, png_inforp info_ptr,
  961.     png_color_8p *sig_bit)
  962. {
  963.    png_debug1(1, "in %s retrieval function", "sBIT");
  964.  
  965.    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)
  966.        && sig_bit != NULL)
  967.    {
  968.       *sig_bit = &(info_ptr->sig_bit);
  969.       return (PNG_INFO_sBIT);
  970.    }
  971.  
  972.    return (0);
  973. }
  974. #endif
  975.  
  976. #ifdef PNG_TEXT_SUPPORTED
  977. int PNGAPI
  978. png_get_text(png_const_structrp png_ptr, png_inforp info_ptr,
  979.     png_textp *text_ptr, int *num_text)
  980. {
  981.    if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)
  982.    {
  983.       png_debug1(1, "in 0x%lx retrieval function",
  984.          (unsigned long)png_ptr->chunk_name);
  985.  
  986.       if (text_ptr != NULL)
  987.          *text_ptr = info_ptr->text;
  988.  
  989.       if (num_text != NULL)
  990.          *num_text = info_ptr->num_text;
  991.  
  992.       return info_ptr->num_text;
  993.    }
  994.  
  995.    if (num_text != NULL)
  996.       *num_text = 0;
  997.  
  998.    return(0);
  999. }
  1000. #endif
  1001.  
  1002. #ifdef PNG_tIME_SUPPORTED
  1003. png_uint_32 PNGAPI
  1004. png_get_tIME(png_const_structrp png_ptr, png_inforp info_ptr,
  1005.     png_timep *mod_time)
  1006. {
  1007.    png_debug1(1, "in %s retrieval function", "tIME");
  1008.  
  1009.    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)
  1010.        && mod_time != NULL)
  1011.    {
  1012.       *mod_time = &(info_ptr->mod_time);
  1013.       return (PNG_INFO_tIME);
  1014.    }
  1015.  
  1016.    return (0);
  1017. }
  1018. #endif
  1019.  
  1020. #ifdef PNG_tRNS_SUPPORTED
  1021. png_uint_32 PNGAPI
  1022. png_get_tRNS(png_const_structrp png_ptr, png_inforp info_ptr,
  1023.     png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color)
  1024. {
  1025.    png_uint_32 retval = 0;
  1026.    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))
  1027.    {
  1028.       png_debug1(1, "in %s retrieval function", "tRNS");
  1029.  
  1030.       if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
  1031.       {
  1032.          if (trans_alpha != NULL)
  1033.          {
  1034.             *trans_alpha = info_ptr->trans_alpha;
  1035.             retval |= PNG_INFO_tRNS;
  1036.          }
  1037.  
  1038.          if (trans_color != NULL)
  1039.             *trans_color = &(info_ptr->trans_color);
  1040.       }
  1041.  
  1042.       else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */
  1043.       {
  1044.          if (trans_color != NULL)
  1045.          {
  1046.             *trans_color = &(info_ptr->trans_color);
  1047.             retval |= PNG_INFO_tRNS;
  1048.          }
  1049.  
  1050.          if (trans_alpha != NULL)
  1051.             *trans_alpha = NULL;
  1052.       }
  1053.  
  1054.       if (num_trans != NULL)
  1055.       {
  1056.          *num_trans = info_ptr->num_trans;
  1057.          retval |= PNG_INFO_tRNS;
  1058.       }
  1059.    }
  1060.  
  1061.    return (retval);
  1062. }
  1063. #endif
  1064.  
  1065. #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
  1066. int PNGAPI
  1067. png_get_unknown_chunks(png_const_structrp png_ptr, png_inforp info_ptr,
  1068.     png_unknown_chunkpp unknowns)
  1069. {
  1070.    if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)
  1071.    {
  1072.       *unknowns = info_ptr->unknown_chunks;
  1073.       return info_ptr->unknown_chunks_num;
  1074.    }
  1075.  
  1076.    return (0);
  1077. }
  1078. #endif
  1079.  
  1080. #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
  1081. png_byte PNGAPI
  1082. png_get_rgb_to_gray_status (png_const_structrp png_ptr)
  1083. {
  1084.    return (png_byte)(png_ptr ? png_ptr->rgb_to_gray_status : 0);
  1085. }
  1086. #endif
  1087.  
  1088. #ifdef PNG_USER_CHUNKS_SUPPORTED
  1089. png_voidp PNGAPI
  1090. png_get_user_chunk_ptr(png_const_structrp png_ptr)
  1091. {
  1092.    return (png_ptr ? png_ptr->user_chunk_ptr : NULL);
  1093. }
  1094. #endif
  1095.  
  1096. png_size_t PNGAPI
  1097. png_get_compression_buffer_size(png_const_structrp png_ptr)
  1098. {
  1099.    if (png_ptr == NULL)
  1100.       return 0;
  1101.  
  1102. #  ifdef PNG_WRITE_SUPPORTED
  1103.       if (png_ptr->mode & PNG_IS_READ_STRUCT)
  1104. #  endif
  1105.    {
  1106. #     ifdef PNG_SEQUENTIAL_READ_SUPPORTED
  1107.          return png_ptr->IDAT_read_size;
  1108. #     else
  1109.          return PNG_IDAT_READ_SIZE;
  1110. #     endif
  1111.    }
  1112.  
  1113. #  ifdef PNG_WRITE_SUPPORTED
  1114.       else
  1115.          return png_ptr->zbuffer_size;
  1116. #  endif
  1117. }
  1118.  
  1119. #ifdef PNG_SET_USER_LIMITS_SUPPORTED
  1120. /* These functions were added to libpng 1.2.6 and were enabled
  1121.  * by default in libpng-1.4.0 */
  1122. png_uint_32 PNGAPI
  1123. png_get_user_width_max (png_const_structrp png_ptr)
  1124. {
  1125.    return (png_ptr ? png_ptr->user_width_max : 0);
  1126. }
  1127.  
  1128. png_uint_32 PNGAPI
  1129. png_get_user_height_max (png_const_structrp png_ptr)
  1130. {
  1131.    return (png_ptr ? png_ptr->user_height_max : 0);
  1132. }
  1133.  
  1134. /* This function was added to libpng 1.4.0 */
  1135. png_uint_32 PNGAPI
  1136. png_get_chunk_cache_max (png_const_structrp png_ptr)
  1137. {
  1138.    return (png_ptr ? png_ptr->user_chunk_cache_max : 0);
  1139. }
  1140.  
  1141. /* This function was added to libpng 1.4.1 */
  1142. png_alloc_size_t PNGAPI
  1143. png_get_chunk_malloc_max (png_const_structrp png_ptr)
  1144. {
  1145.    return (png_ptr ? png_ptr->user_chunk_malloc_max : 0);
  1146. }
  1147. #endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */
  1148.  
  1149. /* These functions were added to libpng 1.4.0 */
  1150. #ifdef PNG_IO_STATE_SUPPORTED
  1151. png_uint_32 PNGAPI
  1152. png_get_io_state (png_const_structrp png_ptr)
  1153. {
  1154.    return png_ptr->io_state;
  1155. }
  1156.  
  1157. png_uint_32 PNGAPI
  1158. png_get_io_chunk_type (png_const_structrp png_ptr)
  1159. {
  1160.    return png_ptr->chunk_name;
  1161. }
  1162. #endif /* ?PNG_IO_STATE_SUPPORTED */
  1163.  
  1164. #ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
  1165. #  ifdef PNG_GET_PALETTE_MAX_SUPPORTED
  1166. int PNGAPI
  1167. png_get_palette_max(png_const_structp png_ptr, png_const_infop info_ptr)
  1168. {
  1169.    if (png_ptr != NULL && info_ptr != NULL)
  1170.       return png_ptr->num_palette_max;
  1171.  
  1172.    return (-1);
  1173. }
  1174. #  endif
  1175. #endif
  1176.  
  1177. #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
  1178.