开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 查看源码
pngget.c
资源名称：profuis288_freeware.zip　[点击查看]
上传用户：sesekoo
上传日期：2020-07-18
资源大小：21543k
文件大小：25k
源码类别：

界面编程

开发平台：

Visual C++

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